gopls/internal/golang: fix hover panic in raw strings with CRLF

Because raw string literals discard '\r', using the physical file
offset to index the parsed string caused out-of-bounds panics on
files with Windows line endings.

Fixes golang/go#77675

Change-Id: Iaf348c37eceb3a8da70df26c6aa6998d0696d57e
Reviewed-on: https://go-review.googlesource.com/c/tools/+/748322
Reviewed-by: Alan Donovan <adonovan@google.com>
Auto-Submit: Hongxiang Jiang <hxjiang@golang.org>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>

Author: h9jiang

gopls/internal/golang/hover.go

@@ -1056,42 +1056,32 @@ func hoverConstantExpr(pgf *parsego.File, expr ast.Expr, tv types.TypeAndValue,
 				}
 			}
 		case constant.String:
-			// Locate the unicode escape sequence under the current cursor
-			// position.
-			litOffset, err := safetoken.Offset(pgf.Tok, lit.Pos())
+			index, err := astutil.OffsetInStringLiteral(lit, posRange.Pos())
 			if err != nil {
 				return protocol.Range{}, nil, err
 			}
-			startOffset, err := safetoken.Offset(pgf.Tok, posRange.Pos())
+			// pos is the point in the literal where the current rune starts.
+			pos, err := astutil.PosInStringLiteral(lit, index)
 			if err != nil {
 				return protocol.Range{}, nil, err
 			}
-			for i := startOffset - litOffset; i > 0; i-- {
-				// Start at the cursor position and search backward for the beginning of a rune escape sequence.
-				rr, _ := utf8.DecodeRuneInString(lit.Value[i:])
-				if rr == utf8.RuneError {
-					return protocol.Range{}, nil, fmt.Errorf("rune error")
-				}
-				if rr == '\\' {
-					// Got the beginning, decode it.
-					rr, _, tail, err := strconv.UnquoteChar(lit.Value[i:], '"')
-					if err != nil {
-						// If the conversion fails, it's because of an invalid
-						// syntax, therefore is no rune to be found.
-						return protocol.Range{}, nil, nil
-					}
-					// Only the rune escape sequence part of the string has to
-					// be highlighted, recompute the range.
-					runeLen := len(lit.Value) - (i + len(tail))
-					pStart := token.Pos(int(lit.Pos()) + i)
-					pEnd := token.Pos(int(pStart) + runeLen)
-
-					if pEnd >= posRange.End() {
-						start, end = pStart, pEnd
-						r = rr
-					}
-					break
+
+			rest, err := pgf.PosText(pos, lit.End())
+			if err != nil {
+				return protocol.Range{}, nil, err
+			}
+
+			// Is the selected character denoted by an escape sequence?
+			if bytes.HasPrefix(rest, []byte(`\`)) {
+				rr, _, tail, err := strconv.UnquoteChar(string(rest), lit.Value[0])
+				if err != nil {
+					return protocol.Range{}, nil, err
 				}
+
+				rawSize := len(rest) - len(tail)
+
+				start, end = pos, pos+token.Pos(rawSize)
+				r = rr
 			}
 		default:
 			panic("unexpected constant.Kind")

gopls/internal/test/integration/hover/hover_test.go

@@ -0,0 +1,53 @@
+// Copyright 2026 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package hover
+
+import (
+	"os"
+	"testing"
+
+	. "golang.org/x/tools/gopls/internal/test/integration"
+	"golang.org/x/tools/gopls/internal/util/bug"
+)
+
+func TestMain(m *testing.M) {
+	bug.PanicOnBugs = true
+	os.Exit(Main(m))
+}
+
+// TestIssue77675 verifies that hovering over a raw string literal containing
+// Windows line endings (\r\n) does not cause an out-of-bounds panic.
+func TestIssue77675(t *testing.T) {
+	const src = `
+-- go.mod --
+module mod.com
+
+go 1.20
+
+-- main.go --
+package main
+
+func _() {
+    _ = ` + "`" + `foo
+
+bar
+baz` + "`" + `
+}
+`
+	WithOptions(
+		WindowsLineEndings(),
+	).Run(t, src, func(t *testing.T, env *Env) {
+		env.OpenFile("main.go")
+		env.Await(env.DoneWithOpen())
+		loc := env.RegexpSearch("main.go", "baz()")
+		content, l := env.Hover(loc)
+		if !l.Empty() {
+			t.Errorf("hover expect empty range got: %v", l)
+		}
+		if content != nil {
+			t.Errorf("hover expect empty result got: %v", content)
+		}
+	})
+}

gopls/internal/test/marker/testdata/hover/basiclit.txt

@@ -13,6 +13,7 @@ func _() {
 	_ = 0x61 //@hover("0x61", "0x61", latinAHex)
 
 	_ = '\u2211' //@hover("'\\u2211'", "'\\u2211'", summation)
+	_ = '\u2211' //@hover(re"u22()11", "'\\u2211'", summation)
 	_ = 0x2211 //@hover("0x2211", "0x2211", summationHex)
 	_ = "foo \u2211 bar" //@hover("\\u2211", "\\u2211", summation)
 

internal/astutil/stringlit.go

@@ -40,30 +40,64 @@ func PosInStringLiteral(lit *ast.BasicLit, offset int) (token.Pos, error) {
 		return 0, fmt.Errorf("invalid offset")
 	}
 
-	// Did the scanner normalize one or more carriage
-	// returns (\r) in a raw string literal?
+	pos, _ := walkStringLiteral(lit, lit.End(), offset)
+	return pos, nil
+}
+
+// OffsetInStringLiteral returns the byte offset within the logical (unquoted)
+// string corresponding to the specified source position.
+func OffsetInStringLiteral(lit *ast.BasicLit, pos token.Pos) (int, error) {
+	if !NodeContainsPos(lit, pos) {
+		return 0, fmt.Errorf("invalid position")
+	}
+
+	raw := lit.Value
+
+	value, err := strconv.Unquote(raw)
+	if err != nil {
+		return 0, err
+	}
+
+	_, offset := walkStringLiteral(lit, pos, len(value))
+	return offset, nil
+}
+
+// walkStringLiteral iterates through the raw string literal to map between
+// a file position and a logical byte offset. It stops when it reaches
+// either the targetPos or the targetOffset.
+//
+// TODO(hxjiang): consider making an iterator.
+func walkStringLiteral(lit *ast.BasicLit, targetPos token.Pos, targetOffset int) (token.Pos, int) {
+	raw := lit.Value
 	norm := int(lit.End()-lit.Pos()) > len(lit.Value)
 
 	// remove quotes
 	quote := raw[0] // '"' or '`'
 	raw = raw[1 : len(raw)-1]
 
 	var (
-		i   = 0                // byte index within logical value
-		pos = lit.ValuePos + 1 // position within literal
+		i   = 0             // byte index within logical value
+		pos = lit.Pos() + 1 // position within literal
 	)
-	for raw != "" && i < offset {
+
+	for raw != "" {
 		r, _, rest, _ := strconv.UnquoteChar(raw, quote) // can't fail
 		sz := len(raw) - len(rest)                       // length of literal char in raw bytes
-		pos += token.Pos(sz)
-		// If any \r normalization occurred,
-		// assume each \n was preceded by \r.
-		// (This is just a heuristic.)
+
+		nextPos := pos + token.Pos(sz)
 		if norm && r == '\n' {
-			pos++
+			nextPos++
 		}
+		nextI := i + utf8.RuneLen(r) // length of logical char in "cooked" bytes
+
+		if nextPos > targetPos || nextI > targetOffset {
+			break
+		}
+
 		raw = raw[sz:]
-		i += utf8.RuneLen(r)
+		i = nextI
+		pos = nextPos
 	}
-	return pos, nil
+
+	return pos, i
 }

internal/astutil/stringlit_test.go

@@ -98,3 +98,98 @@ func TestPosInStringLiteral(t *testing.T) {
 		}
 	}
 }
+
+func TestOffsetInStringLiteral(t *testing.T) {
+	// Each string is Go source for a string literal with | marker at expected
+	// physical pos, and $ marker at the expected logical unquoted index.
+	tests := []string{
+		`"$|abc"`,
+		`"a$|bc"`,
+		`"ab$|c"`,
+		`"abc$|"`,
+		`"a\n$|b"`,
+		`"\n$|"`,
+		`"a\000$|"`,
+		`"\x61$|"`,
+		`"\u0061$|"`,
+		`"\U00000061$|"`,
+		`"$\U00|000061"`,
+		`"€$|"`,
+		`"a€$|b"`,
+		"`abc$|`",
+		"`a\n$|b`",
+		// normalization of \r carriage returns:
+		"`a\r\n$|b`",
+		"`a\r\nb\r\nc\r\n$|d`",
+	}
+	for _, test := range tests {
+		// The workaround for \r requires the go1.26 fix for https://go.dev/issue/76031.
+		if strings.Contains(test, "\r") && testenv.Go1Point() < 26 {
+			continue
+		}
+
+		t.Logf("input: %#q", test)
+
+		const prefix = "package p; const _ = "
+		src := prefix + test
+
+		// Remove the physical marker to produce valid Go source.
+		offset := strings.Index(src, "|")
+		if offset < 0 {
+			t.Errorf("Source %q contains no marker", src)
+			continue
+		}
+		src = src[:offset] + src[offset+1:]
+
+		// Parse.
+		fset := token.NewFileSet()
+		f, err := parser.ParseFile(fset, "p.go", src, 0)
+		if err != nil {
+			t.Errorf("Parse: %v", err)
+			continue
+		}
+
+		// Find literal.
+		var lit *ast.BasicLit
+		ast.Inspect(f, func(n ast.Node) bool {
+			if b, ok := n.(*ast.BasicLit); ok {
+				lit = b
+				return false
+			}
+			return true
+		})
+		if lit == nil {
+			t.Errorf("No literal")
+			continue
+		}
+
+		tfile := fset.File(f.Pos())
+		pos := tfile.Pos(offset)
+
+		// Convert file position to logical index.
+		index, err := astutil.OffsetInStringLiteral(lit, pos)
+		if err != nil {
+			t.Errorf("OffsetInStringLiteral(%d): %v", pos, err)
+			continue
+		}
+
+		value, err := strconv.Unquote(lit.Value)
+		if err != nil {
+			t.Errorf("Unquote: %v", err)
+			continue
+		}
+
+		if index < 0 || index > len(value) {
+			t.Errorf("Returned index %d is out of bounds for logical string of length %d", index, len(value))
+			continue
+		}
+
+		// Check that cut offset in value is before marker.
+		before, after := value[:index], value[index:]
+		t.Logf("\t%q :: %q", before, after)
+		if !strings.HasSuffix(before, "$") {
+			t.Errorf("no marker at logical cut point, got before=%q", before)
+			continue
+		}
+	}
+}