gopls/internal/goasm: support Definition in Go *.s assembly

This CL provides a minimal implementation of the
Definition query within Go assembly files, plus a test.
For now it only works for references to package-level
symbols in the same package or a dependency.

Details:
- add file.Kind Asm and protocol.LanguageKind "go.s".
- include .s files in metadata.Graph.IDs mapping.
- set LanguageKind correctly in gopls CLI.

Also:
- add String() method to file.Handle.
- add convenient forward deps iterator to Graph.
- internal/extract: extract notes from .s files too.

Updates golang/go#71754

Change-Id: I0c518c3279f825411221ebe23dc04654e129fc56
Reviewed-on: https://go-review.googlesource.com/c/tools/+/649461
Auto-Submit: Alan Donovan <[email protected]>
LUCI-TryBot-Result: Go LUCI <[email protected]>
Reviewed-by: Alan Donovan <[email protected]>
Reviewed-by: Robert Findley <[email protected]>
Commit-Queue: Alan Donovan <[email protected]>

Author: adonovan

gopls/internal/cache/fs_memoized.go

@@ -41,6 +41,8 @@ type diskFile struct {
 	err     error
 }
 
+func (h *diskFile) String() string { return h.uri.Path() }
+
 func (h *diskFile) URI() protocol.DocumentURI { return h.uri }
 
 func (h *diskFile) Identity() file.Identity {

gopls/internal/cache/fs_overlay.go

@@ -64,6 +64,8 @@ type overlay struct {
 	saved bool
 }
 
+func (o *overlay) String() string { return o.uri.Path() }
+
 func (o *overlay) URI() protocol.DocumentURI { return o.uri }
 
 func (o *overlay) Identity() file.Identity {

gopls/internal/cache/metadata/graph.go

@@ -5,7 +5,9 @@
 package metadata
 
 import (
+	"iter"
 	"sort"
+	"strings"
 
 	"golang.org/x/tools/go/packages"
 	"golang.org/x/tools/gopls/internal/protocol"
@@ -99,6 +101,11 @@ func newGraph(pkgs map[PackageID]*Package) *Graph {
 		for _, uri := range mp.GoFiles {
 			uris[uri] = struct{}{}
 		}
+		for _, uri := range mp.OtherFiles {
+			if strings.HasSuffix(string(uri), ".s") { // assembly
+				uris[uri] = struct{}{}
+			}
+		}
 		for uri := range uris {
 			uriIDs[uri] = append(uriIDs[uri], id)
 		}
@@ -160,6 +167,35 @@ func (g *Graph) ReverseReflexiveTransitiveClosure(ids ...PackageID) map[PackageI
 	return seen
 }
 
+// ForwardReflexiveTransitiveClosure returns an iterator over the
+// specified nodes and all their forward dependencies, in an arbitrary
+// topological (dependencies-first) order. The order may vary.
+func (g *Graph) ForwardReflexiveTransitiveClosure(ids ...PackageID) iter.Seq[*Package] {
+	return func(yield func(*Package) bool) {
+		seen := make(map[PackageID]bool)
+		var visit func(PackageID) bool
+		visit = func(id PackageID) bool {
+			if !seen[id] {
+				seen[id] = true
+				if mp := g.Packages[id]; mp != nil {
+					for _, depID := range mp.DepsByPkgPath {
+						if !visit(depID) {
+							return false
+						}
+					}
+					if !yield(mp) {
+						return false
+					}
+				}
+			}
+			return true
+		}
+		for _, id := range ids {
+			visit(id)
+		}
+	}
+}
+
 // breakImportCycles breaks import cycles in the metadata by deleting
 // Deps* edges. It modifies only metadata present in the 'updates'
 // subset. This function has an internal test.

gopls/internal/cache/parse_cache_test.go

@@ -218,6 +218,10 @@ type fakeFileHandle struct {
 	hash file.Hash
 }
 
+func (h fakeFileHandle) String() string {
+	return h.uri.Path()
+}
+
 func (h fakeFileHandle) URI() protocol.DocumentURI {
 	return h.uri
 }

gopls/internal/cache/session.go

@@ -1084,6 +1084,7 @@ type brokenFile struct {
 	err error
 }
 
+func (b brokenFile) String() string            { return b.uri.Path() }
 func (b brokenFile) URI() protocol.DocumentURI { return b.uri }
 func (b brokenFile) Identity() file.Identity   { return file.Identity{URI: b.uri} }
 func (b brokenFile) SameContentsOnDisk() bool  { return false }

gopls/internal/cache/snapshot.go

@@ -323,6 +323,8 @@ func fileKind(fh file.Handle) file.Kind {
 		return file.Sum
 	case ".work":
 		return file.Work
+	case ".s":
+		return file.Asm
 	}
 	return file.UnknownKind
 }
@@ -645,13 +647,32 @@ func (s *Snapshot) Tests(ctx context.Context, ids ...PackageID) ([]*testfuncs.In
 	return indexes, s.forEachPackage(ctx, ids, pre, post)
 }
 
+// NarrowestMetadataForFile returns metadata for the narrowest package
+// (the one with the fewest files) that encloses the specified file.
+// The result may be a test variant, but never an intermediate test variant.
+func (snapshot *Snapshot) NarrowestMetadataForFile(ctx context.Context, uri protocol.DocumentURI) (*metadata.Package, error) {
+	mps, err := snapshot.MetadataForFile(ctx, uri)
+	if err != nil {
+		return nil, err
+	}
+	metadata.RemoveIntermediateTestVariants(&mps)
+	if len(mps) == 0 {
+		return nil, fmt.Errorf("no package metadata for file %s", uri)
+	}
+	return mps[0], nil
+}
+
 // MetadataForFile returns a new slice containing metadata for each
 // package containing the Go file identified by uri, ordered by the
 // number of CompiledGoFiles (i.e. "narrowest" to "widest" package),
 // and secondarily by IsIntermediateTestVariant (false < true).
 // The result may include tests and intermediate test variants of
 // importable packages.
 // It returns an error if the context was cancelled.
+//
+// TODO(adonovan): in nearly all cases the caller must use
+// [metadata.RemoveIntermediateTestVariants]. Make this a parameter to
+// force the caller to consider it (and reduce code).
 func (s *Snapshot) MetadataForFile(ctx context.Context, uri protocol.DocumentURI) ([]*metadata.Package, error) {
 	if s.view.typ == AdHocView {
 		// As described in golang/go#57209, in ad-hoc workspaces (where we load ./

gopls/internal/cmd/cmd.go

@@ -773,10 +773,25 @@ func (c *connection) openFile(ctx context.Context, uri protocol.DocumentURI) (*c
 		return nil, file.err
 	}
 
+	// Choose language ID from file extension.
+	var langID protocol.LanguageKind // "" eventually maps to file.UnknownKind
+	switch filepath.Ext(uri.Path()) {
+	case ".go":
+		langID = "go"
+	case ".mod":
+		langID = "go.mod"
+	case ".sum":
+		langID = "go.sum"
+	case ".work":
+		langID = "go.work"
+	case ".s":
+		langID = "go.s"
+	}
+
 	p := &protocol.DidOpenTextDocumentParams{
 		TextDocument: protocol.TextDocumentItem{
 			URI:        uri,
-			LanguageID: "go",
+			LanguageID: langID,
 			Version:    1,
 			Text:       string(file.mapper.Content),
 		},

gopls/internal/cmd/definition.go

@@ -96,7 +96,7 @@ func (d *definition) Run(ctx context.Context, args ...string) error {
 	}
 
 	if len(locs) == 0 {
-		return fmt.Errorf("%v: not an identifier", from)
+		return fmt.Errorf("%v: no definition location (not an identifier?)", from)
 	}
 	file, err = conn.openFile(ctx, locs[0].URI)
 	if err != nil {

gopls/internal/file/file.go

@@ -49,6 +49,8 @@ type Handle interface {
 	// Content returns the contents of a file.
 	// If the file is not available, returns a nil slice and an error.
 	Content() ([]byte, error)
+	// String returns the file's path.
+	String() string
 }
 
 // A Source maps URIs to Handles.

gopls/internal/file/kind.go

@@ -28,6 +28,8 @@ const (
 	Tmpl
 	// Work is a go.work file.
 	Work
+	// Asm is a Go assembly (.s) file.
+	Asm
 )
 
 func (k Kind) String() string {
@@ -42,13 +44,15 @@ func (k Kind) String() string {
 		return "tmpl"
 	case Work:
 		return "go.work"
+	case Asm:
+		return "Go assembly"
 	default:
 		return fmt.Sprintf("internal error: unknown file kind %d", k)
 	}
 }
 
 // KindForLang returns the gopls file [Kind] associated with the given LSP
-// LanguageKind string from protocol.TextDocumentItem.LanguageID,
+// LanguageKind string from the LanguageID field of [protocol.TextDocumentItem],
 // or UnknownKind if the language is not one recognized by gopls.
 func KindForLang(langID protocol.LanguageKind) Kind {
 	switch langID {
@@ -62,6 +66,8 @@ func KindForLang(langID protocol.LanguageKind) Kind {
 		return Tmpl
 	case "go.work":
 		return Work
+	case "go.s":
+		return Asm
 	default:
 		return UnknownKind
 	}