gopls: Refactor goasm.References function.

Modify the file index logic for asmfile in xrefs.go.
Adjust the overall code logic flow in references.
When parsing asm files, add the original symbol name length, return the original position, and update the test files.

Updates golang/go#71754

Author: groot-guo

gopls/internal/cache/xrefs/xrefs.go

@@ -11,7 +11,6 @@ package xrefs
 import (
 	"go/ast"
 	"go/types"
-	"slices"
 	"sort"
 
 	"golang.org/x/tools/go/types/objectpath"
@@ -118,6 +117,9 @@ func Index(files []*parsego.File, pkg *types.Package, info *types.Info, asmFiles
 	// For each asm file, record references to identifiers.
 	for fileIndex, af := range asmFiles {
 		for _, id := range af.Idents {
+			if id.Kind != asm.Data && id.Kind != asm.Text {
+				continue
+			}
 			_, name, ok := morestrings.CutLast(id.Name, ".")
 			if !ok {
 				continue
@@ -131,6 +133,7 @@ func Index(files []*parsego.File, pkg *types.Package, info *types.Info, asmFiles
 			objects := getObjects(pkg)
 			gobObj, ok := objects[obj]
 			if !ok {
+				// obj is a package-level symbol, so its objectpath is just its name.
 				gobObj = &gobObject{Path: objectpath.Path(obj.Name())}
 				objects[obj] = gobObj
 			}
@@ -171,14 +174,25 @@ func Index(files []*parsego.File, pkg *types.Package, info *types.Info, asmFiles
 // to any object in the target set. Each object is denoted by a pair
 // of (package path, object path).
 func Lookup(mp *metadata.Package, data []byte, targets map[metadata.PackagePath]map[objectpath.Path]struct{}) (locs []protocol.Location) {
-	var packages []*gobPackage
+	var (
+		packages      []*gobPackage
+		goFilesLen    = len(mp.CompiledGoFiles)
+		goAsmFilesLen = len(mp.AsmFiles)
+	)
 	packageCodec.Decode(data, &packages)
 	for _, gp := range packages {
 		if objectSet, ok := targets[gp.PkgPath]; ok {
 			for _, gobObj := range gp.Objects {
 				if _, ok := objectSet[gobObj.Path]; ok {
 					for _, ref := range gobObj.Refs {
-						uri := slices.Concat(mp.CompiledGoFiles, mp.AsmFiles)[ref.FileIndex]
+						var uri protocol.DocumentURI
+						if ref.FileIndex < goFilesLen {
+							uri = mp.CompiledGoFiles[ref.FileIndex]
+						} else if ref.FileIndex < goFilesLen+goAsmFilesLen {
+							uri = mp.AsmFiles[ref.FileIndex]
+						} else {
+							continue // out of bounds
+						}
 						locs = append(locs, protocol.Location{
 							URI:   uri,
 							Range: ref.Range,

gopls/internal/goasm/references.go

@@ -64,9 +64,8 @@ func References(ctx context.Context, snapshot *cache.Snapshot, fh file.Handle, p
 		return nil, fmt.Errorf("not an identifier")
 	}
 
-	sym := found.Name
 	var locations []protocol.Location
-	_, name, ok := morestrings.CutLast(sym, ".")
+	_, name, ok := morestrings.CutLast(found.Name, ".")
 	if !ok {
 		return nil, fmt.Errorf("not found")
 	}
@@ -76,25 +75,12 @@ func References(ctx context.Context, snapshot *cache.Snapshot, fh file.Handle, p
 	// Refer to the global search logic in golang.References, and add corresponding test cases for verification.
 	obj := pkg.Types().Scope().Lookup(name)
 	matches := func(curObj types.Object) bool {
-		if curObj == nil {
-			return false
-		}
-		if curObj.Name() != obj.Name() {
-			return false
-		}
-		return true
+		return curObj != nil && curObj.Name() == obj.Name()
 	}
 	for _, pgf := range pkg.CompiledGoFiles() {
 		for curId := range pgf.Cursor.Preorder((*ast.Ident)(nil)) {
 			id := curId.Node().(*ast.Ident)
-			curObj, ok := pkg.TypesInfo().Defs[id]
-			if !ok {
-				curObj, ok = pkg.TypesInfo().Uses[id]
-				if !ok {
-					continue
-				}
-			}
-			if !matches(curObj) {
+			if !matches(pkg.TypesInfo().ObjectOf(id)) {
 				continue
 			}
 			loc, err := pgf.NodeLocation(id)
@@ -105,21 +91,17 @@ func References(ctx context.Context, snapshot *cache.Snapshot, fh file.Handle, p
 		}
 	}
 
-	// If includeDeclaration is false, return only reference locations (exclude declarations).
-	if !includeDeclaration {
-		return locations, nil
-	}
-
-	for _, asmFile := range pkg.AsmFiles() {
-		for _, id := range asmFile.Idents {
-			if id.Name != sym {
-				continue
-			}
-			if loc, err := asmFile.NodeLocation(id); err == nil {
-				locations = append(locations, loc)
+	if includeDeclaration {
+		for _, asmFile := range pkg.AsmFiles() {
+			for _, id := range asmFile.Idents {
+				if id.Name == found.Name &&
+					(id.Kind == asm.Text || id.Kind == asm.Global || id.Kind == asm.Label) {
+					if loc, err := asmFile.NodeLocation(id); err == nil {
+						locations = append(locations, loc)
+					}
+				}
 			}
 		}
 	}
-
 	return locations, nil
 }

gopls/internal/golang/references.go

@@ -32,6 +32,7 @@ import (
 	"golang.org/x/tools/gopls/internal/cache/parsego"
 	"golang.org/x/tools/gopls/internal/file"
 	"golang.org/x/tools/gopls/internal/protocol"
+	"golang.org/x/tools/gopls/internal/util/asm"
 	"golang.org/x/tools/gopls/internal/util/morestrings"
 	"golang.org/x/tools/gopls/internal/util/safetoken"
 	"golang.org/x/tools/internal/event"
@@ -615,6 +616,9 @@ func localReferences(pkg *cache.Package, targets map[types.Object]bool, correspo
 	// Iterate over all assembly files and find all references to the target object.
 	for _, pgf := range pkg.AsmFiles() {
 		for _, id := range pgf.Idents {
+			if id.Kind != asm.Data && id.Kind != asm.Text {
+				continue
+			}
 			_, name, ok := morestrings.CutLast(id.Name, ".")
 			if !ok {
 				continue

gopls/internal/test/marker/testdata/references/asm.txt

@@ -25,12 +25,12 @@ var _ = sub //@loc(refSub, "sub"), refs("sub", useSub, defSub, refSub)
 // portable assembly
 #include "textflag.h"
 
-TEXT ·Add(SB), NOSPLIT, $0-24 //@ loc(def, "Add"), refs("Add", def, use)
+TEXT ·Add(SB), NOSPLIT, $0-24 //@ loc(def, "·Add"), refs("Add", def, use)
     MOVQ a+0(FP), AX
     ADDQ b+8(FP), AX
     RET
 
-TEXT ·sub(SB), NOSPLIT, $0-24 //@ loc(defSub, "sub"), refs("sub", defSub, useSub, refSub)
+TEXT ·sub(SB), NOSPLIT, $0-24 //@ loc(defSub, "·sub"), refs("sub", defSub, useSub, refSub)
     MOVQ a+0(FP), AX
     SUBQ b+8(FP), AX
     RET

gopls/internal/util/asm/parse.go

@@ -55,19 +55,20 @@ type File struct {
 }
 
 func (f *File) NodeRange(ident Ident) (protocol.Range, error) {
-	return f.Mapper.OffsetRange(ident.Offset+2, ident.End()+1)
+	return f.Mapper.OffsetRange(ident.Offset, ident.Offset+ident.OrigLen)
 }
 
 // NodeLocation returns a protocol Location for the ast.Node interval in this file.
 func (f *File) NodeLocation(ident Ident) (protocol.Location, error) {
-	return f.Mapper.OffsetLocation(ident.Offset+2, ident.End()+1)
+	return f.Mapper.OffsetLocation(ident.Offset, ident.Offset+ident.OrigLen)
 }
 
 // Ident represents an identifier in an assembly file.
 type Ident struct {
-	Name   string // symbol name (after correcting [·∕]); Name[0]='.' => current package
-	Offset int    // zero-based byte offset
-	Kind   Kind
+	Name    string // symbol name (after correcting [·∕]); Name[0]='.' => current package
+	Offset  int    // zero-based byte offset
+	OrigLen int    // original length of the symbol name (before cleanup)
+	Kind    Kind
 }
 
 // End returns the identifier's end offset.
@@ -136,9 +137,10 @@ func Parse(uri protocol.DocumentURI, content []byte) *File {
 				if isIdent(sym) {
 					// (The Index call assumes sym is not itself "TEXT" etc.)
 					idents = append(idents, Ident{
-						Name:   cleanup(sym),
-						Kind:   kind,
-						Offset: offset + strings.Index(line, sym),
+						Name:    cleanup(sym),
+						Kind:    kind,
+						Offset:  offset + strings.Index(line, sym),
+						OrigLen: len(sym),
 					})
 				}
 				continue
@@ -196,9 +198,10 @@ func Parse(uri protocol.DocumentURI, content []byte) *File {
 			sym = cutBefore(sym, "<")   // "sym<ABIInternal>" =>> "sym"
 			if isIdent(sym) {
 				idents = append(idents, Ident{
-					Name:   cleanup(sym),
-					Kind:   Ref,
-					Offset: offset + tokenPos,
+					Name:    cleanup(sym),
+					Kind:    Ref,
+					Offset:  offset + tokenPos,
+					OrigLen: len(sym),
 				})
 			}
 		}