posmap

Author: xzbdmw

gopls/doc/release/v0.18.0.md

@@ -100,8 +100,8 @@ When invoked on a return statement, hover reports the types of
 
 ## Improvements to "DocumentHighlight"
 
-When your cursor is inside a printf-like function, gopls now provide
-DocumentHighlight as visual cues to differentiate how operands are used in the format string.
+When your cursor is inside a printf-like function, gopls now highlights the relationship between
+formatting verbs and arguments as visual cues to differentiate how operands are used in the format string.
 
 ```go
 fmt.Printf("Hello %s, you scored %d", name, score)

gopls/internal/golang/highlight.go

@@ -10,7 +10,9 @@ import (
 	"go/ast"
 	"go/token"
 	"go/types"
+	"strconv"
 	"strings"
+	"unicode/utf8"
 
 	"golang.org/x/tools/go/ast/astutil"
 	"golang.org/x/tools/gopls/internal/cache"
@@ -74,15 +76,16 @@ func Highlight(ctx context.Context, snapshot *cache.Snapshot, fh file.Handle, po
 func highlightPath(info *types.Info, path []ast.Node, pos token.Pos) (map[posRange]protocol.DocumentHighlightKind, error) {
 	result := make(map[posRange]protocol.DocumentHighlightKind)
 
-	// Inside a printf-style call, printf("...%v...", arg)?
+	// Inside a call to a printf-like function (as identified
+	// by a simple heuristic).
 	// Treat each corresponding ("%v", arg) pair as a highlight class.
 	for _, node := range path {
 		if call, ok := node.(*ast.CallExpr); ok {
 			idx := formatStringIndex(info, call)
 			if idx >= 0 && idx < len(call.Args) {
-				// We only care string literal, so fmt.Sprint("a"+"b%s", "bar") won't highlight.
-				if lit, ok := call.Args[idx].(*ast.BasicLit); ok && strings.Contains(lit.Value, "%") {
-					highlightPrintf(call, idx, pos, lit.Value, result)
+				// We only care about literal format strings, so fmt.Sprint("a"+"b%s", "bar") won't be highlighted.
+				if lit, ok := call.Args[idx].(*ast.BasicLit); ok && lit.Kind == token.STRING {
+					highlightPrintf(call, idx, pos, lit, result)
 				}
 			}
 		}
@@ -175,14 +178,21 @@ func formatStringIndex(info *types.Info, call *ast.CallExpr) int {
 }
 
 // highlightPrintf highlights operations in a format string and their corresponding
-// variadic arguments in a printf-style function call.
+// variadic arguments in a (possible) printf-style function call.
 // For example:
 //
 // fmt.Printf("Hello %s, you scored %d", name, score)
 //
 // If the cursor is on %s or name, it will highlight %s as a write operation,
 // and name as a read operation.
-func highlightPrintf(call *ast.CallExpr, idx int, cursorPos token.Pos, format string, result map[posRange]protocol.DocumentHighlightKind) {
+func highlightPrintf(call *ast.CallExpr, idx int, cursorPos token.Pos, lit *ast.BasicLit, result map[posRange]protocol.DocumentHighlightKind) {
+	format, err := strconv.Unquote(lit.Value)
+	if err != nil {
+		return
+	}
+	if !strings.Contains(format, "%") {
+		return
+	}
 	operations, err := fmtstr.Parse(format, idx)
 	if err != nil {
 		return
@@ -199,18 +209,19 @@ func highlightPrintf(call *ast.CallExpr, idx int, cursorPos token.Pos, format st
 
 	formatPos := call.Args[idx].Pos()
 	// highlightPair highlights the operation and its potential argument pair if the cursor is within either range.
-	highlightPair := func(start, end token.Pos, argIndex int) {
+	highlightPair := func(rang fmtstr.Range, argIndex int) {
 		var (
-			rangeStart = formatPos + token.Pos(start)
-			rangeEnd   = formatPos + token.Pos(end)
+			rangeStart = formatPos + posInStringLiteral(lit.Value, format, rang.Start)
+			rangeEnd   = formatPos + posInStringLiteral(lit.Value, format, rang.End-1) + 1
 			arg        ast.Expr // may not exist
 		)
-		visited[posRange{start: rangeStart, end: rangeEnd}] = argIndex
-		if len(call.Args) > argIndex {
+		visited[posRange{rangeStart, rangeEnd}] = argIndex
+		if argIndex < len(call.Args) {
 			arg = call.Args[argIndex]
 		}
 
-		if (cursorPos >= rangeStart && cursorPos < rangeEnd) || (arg != nil && cursorPos >= arg.Pos() && cursorPos < arg.End()) {
+		if rangeStart <= cursorPos && cursorPos < rangeEnd ||
+			arg != nil && arg.Pos() <= cursorPos && cursorPos < arg.End() {
 			highlightRange(result, rangeStart, rangeEnd, protocol.Write)
 			if arg != nil {
 				succeededArg = argIndex
@@ -219,35 +230,34 @@ func highlightPrintf(call *ast.CallExpr, idx int, cursorPos token.Pos, format st
 		}
 	}
 
-	for _, operation := range operations {
+	for _, op := range operations {
 		// If width or prec has any *, we can not highlight the full range from % to verb,
 		// because it will overlap with the sub-range of *, for example:
 		//
 		// fmt.Printf("%*[3]d", 4, 5, 6)
 		//               ^  ^ we can only highlight this range when cursor in 6. '*' as a one-rune range will
 		//               highlight for 4.
-		anyAsterisk := false
+		hasAsterisk := false
 
-		width, prec, verb := operation.Width, operation.Prec, operation.Verb
 		// Try highlight Width if there is a *.
-		if width.Dynamic != -1 {
-			anyAsterisk = true
-			highlightPair(token.Pos(width.Range.Start), token.Pos(width.Range.End), width.Dynamic)
+		if op.Width.Dynamic != -1 {
+			hasAsterisk = true
+			highlightPair(op.Width.Range, op.Width.Dynamic)
 		}
 
 		// Try highlight Precision if there is a *.
-		if prec.Dynamic != -1 {
-			anyAsterisk = true
-			highlightPair(token.Pos(prec.Range.Start), token.Pos(prec.Range.End), prec.Dynamic)
+		if op.Prec.Dynamic != -1 {
+			hasAsterisk = true
+			highlightPair(op.Prec.Range, op.Prec.Dynamic)
 		}
 
 		// Try highlight Verb.
-		if verb.Verb != '%' {
+		if op.Verb.Verb != '%' {
 			// If any * is found inside operation, narrow the highlight range.
-			if anyAsterisk {
-				highlightPair(token.Pos(verb.Range.Start), token.Pos(verb.Range.End), verb.ArgIndex)
+			if hasAsterisk {
+				highlightPair(op.Verb.Range, op.Verb.ArgIndex)
 			} else {
-				highlightPair(token.Pos(operation.Range.Start), token.Pos(operation.Range.End), verb.ArgIndex)
+				highlightPair(op.Range, op.Verb.ArgIndex)
 			}
 		}
 	}
@@ -260,6 +270,69 @@ func highlightPrintf(call *ast.CallExpr, idx int, cursorPos token.Pos, format st
 	}
 }
 
+// posInStringLiteral maps an offset in the unquoted string to
+// a token.Pos in the source file. The ast.BasicLit.Value is the quoted literal
+// as it appears in code, e.g. \x25d. We compare it to the unquoted string
+// from strconv.Unquote, e.g. "%d".
+func posInStringLiteral(literal string, unquoted string, logicalOffset int) token.Pos {
+	literalIdx := 1 // Skip the initial quote char.
+	logIdx := 0
+
+	// Advance by one unquoted rune and the corresponding literal string.
+	advanceRune := func() {
+		r, size := utf8.DecodeRuneInString(unquoted[logIdx:])
+		if r == utf8.RuneError && size <= 1 {
+			// Malformed UTF-8 or end of string,
+			// move one byte in both strings to avoid infinite loops.
+			logIdx++
+			literalIdx++
+			return
+		}
+		logIdx += size
+
+		if literalIdx >= len(literal)-1 {
+			return
+		}
+
+		if literal[literalIdx] == '\\' {
+			remain := literal[literalIdx:]
+			escLen := 0
+			if len(remain) < 2 {
+				escLen = 1 // just the '\'
+			}
+			switch remain[1] {
+			case 'x':
+				escLen = 4
+			case 'u':
+				escLen = 6
+			case 'U':
+				escLen = 10
+			case 'a', 'b', 'f', 'n', 'r', 't', 'v', '\\', '"':
+				escLen = 2
+			case '0', '1', '2', '3', '4', '5', '6', '7':
+				escLen = 4
+			default:
+				return
+			}
+			literalIdx += escLen
+		} else {
+			// non-escaped character
+			literalIdx++
+		}
+	}
+
+	for logIdx < len(unquoted) && (logIdx < logicalOffset) && literalIdx < len(literal)-1 {
+		advanceRune()
+	}
+
+	// Clamp it to ensure we don't exceed array bounds.
+	if literalIdx >= len(literal)-1 {
+		literalIdx = len(literal) - 1
+	}
+
+	return token.Pos(literalIdx)
+}
+
 type posRange struct {
 	start, end token.Pos
 }

gopls/internal/test/marker/testdata/highlight/highlight_printf.txt

@@ -1,45 +1,55 @@
+
 This test checks functionality of the printf-like directives and operands highlight.
 -- flags --
 -ignore_extra_diags
 -- highlights.go --
 package highlightprintf
 import (
-		"fmt"
-	   )
+	"fmt"
+)
+
 func BasicPrintfHighlights() {
 	fmt.Printf("Hello %s, you have %d new messages!", "Alice", 5) //@hiloc(normals, "%s", write),hiloc(normalarg0, "\"Alice\"", read),highlightall(normals, normalarg0)
-		fmt.Printf("Hello %s, you have %d new messages!", "Alice", 5) //@hiloc(normald, "%d", write),hiloc(normalargs1, "5", read),highlightall(normald, normalargs1)
+	fmt.Printf("Hello %s, you have %d new messages!", "Alice", 5) //@hiloc(normald, "%d", write),hiloc(normalargs1, "5", read),highlightall(normald, normalargs1)
 }
+
 func ComplexPrintfHighlights() {
 	fmt.Printf("Hello %#3.4s, you have %-2.3d new messages!", "Alice", 5) //@hiloc(complexs, "%#3.4s", write),hiloc(complexarg0, "\"Alice\"", read),highlightall(complexs, complexarg0)
-		fmt.Printf("Hello %#3.4s, you have %-2.3d new messages!", "Alice", 5) //@hiloc(complexd, "%-2.3d", write),hiloc(complexarg1, "5", read),highlightall(complexd, complexarg1)
+	fmt.Printf("Hello %#3.4s, you have %-2.3d new messages!", "Alice", 5) //@hiloc(complexd, "%-2.3d", write),hiloc(complexarg1, "5", read),highlightall(complexd, complexarg1)
 }
+
 func MissingDirectives() {
 	fmt.Printf("Hello %s, you have 5 new messages!", "Alice", 5) //@hiloc(missings, "%s", write),hiloc(missingargs0, "\"Alice\"", read),highlightall(missings, missingargs0)
 }
+
 func TooManyDirectives() {
 	fmt.Printf("Hello %s, you have %d new %s %q messages!", "Alice", 5) //@hiloc(toomanys, "%s", write),hiloc(toomanyargs0, "\"Alice\"", read),highlightall(toomanys, toomanyargs0)
-		fmt.Printf("Hello %s, you have %d new %s %q messages!", "Alice", 5) //@hiloc(toomanyd, "%d", write),hiloc(toomanyargs1, "5", read),highlightall(toomanyd, toomanyargs1)
+	fmt.Printf("Hello %s, you have %d new %s %q messages!", "Alice", 5) //@hiloc(toomanyd, "%d", write),hiloc(toomanyargs1, "5", read),highlightall(toomanyd, toomanyargs1)
 }
+
 func VerbIsPercentage() {
 	fmt.Printf("%4.2% %d", 6) //@hiloc(z1, "%d", write),hiloc(z2, "6", read),highlightall(z1, z2)
 }
+
 func SpecialChars() {
 	fmt.Printf("Hello \n %s, you \t \n have %d new messages!", "Alice", 5) //@hiloc(specials, "%s", write),hiloc(specialargs0, "\"Alice\"", read),highlightall(specials, specialargs0)
-		fmt.Printf("Hello \n %s, you \t \n have %d new messages!", "Alice", 5) //@hiloc(speciald, "%d", write),hiloc(specialargs1, "5", read),highlightall(speciald, specialargs1)
+	fmt.Printf("Hello \n %s, you \t \n have %d new messages!", "Alice", 5) //@hiloc(speciald, "%d", write),hiloc(specialargs1, "5", read),highlightall(speciald, specialargs1)
 }
+
 func Escaped() {
 	fmt.Printf("Hello %% \n %s, you \t%% \n have %d new m%%essages!", "Alice", 5) //@hiloc(escapeds, "%s", write),hiloc(escapedargs0, "\"Alice\"", read),highlightall(escapeds, escapedargs0)
-		fmt.Printf("Hello %% \n %s, you \t%% \n have %d new m%%essages!", "Alice", 5) //@hiloc(escapedd, "%s", write),hiloc(escapedargs1, "\"Alice\"", read),highlightall(escapedd, escapedargs1)
+	fmt.Printf("Hello %% \n %s, you \t%% \n have %d new m%%essages!", "Alice", 5) //@hiloc(escapedd, "%s", write),hiloc(escapedargs1, "\"Alice\"", read),highlightall(escapedd, escapedargs1)
+	fmt.Printf("%d \nss \x25[2]d", 234, 123) //@hiloc(zz1, "%d", write),hiloc(zz2, "234", read),highlightall(zz1,zz2)
+	fmt.Printf("%d \nss \x25[2]d", 234, 123) //@hiloc(zz3, "\\x25[2]d", write),hiloc(zz4, "123", read),highlightall(zz3,zz4)
 }
 
-func IndexedAsterisk() {
+func Indexed() {
 	fmt.Printf("%[1]d", 3) //@hiloc(i1, "%[1]d", write),hiloc(i2, "3", read),highlightall(i1, i2)
-		fmt.Printf("%[1]*d", 3, 6) //@hiloc(i3, "[1]*", write),hiloc(i4, "3", read),hiloc(i5, "d", write),hiloc(i6, "6", read),highlightall(i3, i4),highlightall(i5, i6)
-		fmt.Printf("%[2]*[1]d", 3, 4) //@hiloc(i7, "[2]*", write),hiloc(i8, "4", read),hiloc(i9, "[1]d", write),hiloc(i10, "3", read),highlightall(i7, i8),highlightall(i9, i10)
-		fmt.Printf("%[2]*.[1]*[3]d", 4, 5, 6) //@hiloc(i11, "[2]*", write),hiloc(i12, "5", read),hiloc(i13, ".[1]*", write),hiloc(i14, "4", read),hiloc(i15, "[3]d", write),hiloc(i16, "6", read),highlightall(i11, i12),highlightall(i13, i14),highlightall(i15, i16)
+	fmt.Printf("%[1]*d", 3, 6) //@hiloc(i3, "[1]*", write),hiloc(i4, "3", read),hiloc(i5, "d", write),hiloc(i6, "6", read),highlightall(i3, i4),highlightall(i5, i6)
+	fmt.Printf("%[2]*[1]d", 3, 4) //@hiloc(i7, "[2]*", write),hiloc(i8, "4", read),hiloc(i9, "[1]d", write),hiloc(i10, "3", read),highlightall(i7, i8),highlightall(i9, i10)
+	fmt.Printf("%[2]*.[1]*[3]d", 4, 5, 6) //@hiloc(i11, "[2]*", write),hiloc(i12, "5", read),hiloc(i13, ".[1]*", write),hiloc(i14, "4", read),hiloc(i15, "[3]d", write),hiloc(i16, "6", read),highlightall(i11, i12),highlightall(i13, i14),highlightall(i15, i16)
 }
 
-func MultipleSameIndexed() {
+func MultipleIndexed() {
 	fmt.Printf("%[1]d %[1].2d", 3) //@hiloc(m1, "%[1]d", write),hiloc(m2, "3", read),hiloc(m3, "%[1].2d", write),highlightall(m1, m2, m3)
 }