gopls: address various staticcheck findings

Fix several real findings uncovered by running staticcheck ./... from
the gopls module.

Change-Id: Ieffd38bfd98cac24052c3b408907eb197c9e1cda
Reviewed-on: https://go-review.googlesource.com/c/tools/+/650643
Reviewed-by: Alan Donovan <[email protected]>
LUCI-TryBot-Result: Go LUCI <[email protected]>

Author: findleyr

gopls/internal/analysis/modernize/sortslice.go

@@ -5,7 +5,6 @@
 package modernize
 
 import (
-	"fmt"
 	"go/ast"
 	"go/token"
 	"go/types"
@@ -78,9 +77,9 @@ func sortslice(pass *analysis.Pass) {
 							Pos:      call.Fun.Pos(),
 							End:      call.Fun.End(),
 							Category: "sortslice",
-							Message:  fmt.Sprintf("sort.Slice can be modernized using slices.Sort"),
+							Message:  "sort.Slice can be modernized using slices.Sort",
 							SuggestedFixes: []analysis.SuggestedFix{{
-								Message: fmt.Sprintf("Replace sort.Slice call by slices.Sort"),
+								Message: "Replace sort.Slice call by slices.Sort",
 								TextEdits: append(importEdits, []analysis.TextEdit{
 									{
 										// Replace sort.Slice with slices.Sort.

gopls/internal/analysis/unusedvariable/unusedvariable.go

@@ -47,7 +47,7 @@ func run(pass *analysis.Pass) (any, error) {
 			if len(match) > 0 {
 				varName := match[1]
 				// Beginning in Go 1.23, go/types began quoting vars as `v'.
-				varName = strings.Trim(varName, "'`'")
+				varName = strings.Trim(varName, "`'")
 
 				err := runForError(pass, typeErr, varName)
 				if err != nil {

gopls/internal/cache/analysis.go

@@ -822,8 +822,7 @@ func typesLookup(pkg *types.Package) func(string) *types.Package {
 	)
 
 	// search scans children the next package in pending, looking for pkgPath.
-	var search func(pkgPath string) (*types.Package, int)
-	search = func(pkgPath string) (sought *types.Package, numPending int) {
+	search := func(pkgPath string) (sought *types.Package, numPending int) {
 		mu.Lock()
 		defer mu.Unlock()
 

gopls/internal/cache/check.go

@@ -44,11 +44,6 @@ import (
 	"golang.org/x/tools/internal/versions"
 )
 
-// Various optimizations that should not affect correctness.
-const (
-	preserveImportGraph = true // hold on to the import graph for open packages
-)
-
 type unit = struct{}
 
 // A typeCheckBatch holds data for a logical type-checking operation, which may
@@ -97,21 +92,6 @@ func (b *typeCheckBatch) getHandle(id PackageID) *packageHandle {
 	return b._handles[id]
 }
 
-// A futurePackage is a future result of type checking or importing a package,
-// to be cached in a map.
-//
-// The goroutine that creates the futurePackage is responsible for evaluating
-// its value, and closing the done channel.
-type futurePackage struct {
-	done chan unit
-	v    pkgOrErr
-}
-
-type pkgOrErr struct {
-	pkg *types.Package
-	err error
-}
-
 // TypeCheck parses and type-checks the specified packages,
 // and returns them in the same order as the ids.
 // The resulting packages' types may belong to different importers,
@@ -701,8 +681,7 @@ func importLookup(mp *metadata.Package, source metadata.Source) func(PackagePath
 
 	// search scans children the next package in pending, looking for pkgPath.
 	// Invariant: whenever search is called, pkgPath is not yet mapped.
-	var search func(pkgPath PackagePath) (PackageID, bool)
-	search = func(pkgPath PackagePath) (id PackageID, found bool) {
+	search := func(pkgPath PackagePath) (id PackageID, found bool) {
 		pkg := pending[0]
 		pending = pending[1:]
 		for depPath, depID := range pkg.DepsByPkgPath {

gopls/internal/cache/methodsets/fingerprint_test.go

@@ -39,11 +39,6 @@ func Test_fingerprint(t *testing.T) {
 	// (Non-tricky types only.)
 	var fingerprints typeutil.Map
 
-	type eqclass struct {
-		class map[types.Type]bool
-		fp    string
-	}
-
 	for _, pkg := range pkgs {
 		switch pkg.Types.Path() {
 		case "unsafe", "builtin":

gopls/internal/cache/snapshot.go

@@ -1301,7 +1301,7 @@ searchOverlays:
 			// where the file is inside a workspace module, but perhaps no packages
 			// were loaded for that module.
 			_, loadedMod := loadedModFiles[goMod]
-			_, workspaceMod := s.view.viewDefinition.workspaceModFiles[goMod]
+			_, workspaceMod := s.view.workspaceModFiles[goMod]
 			// If we have a relevant go.mod file, check whether the file is orphaned
 			// due to its go.mod file being inactive. We could also offer a
 			// prescriptive diagnostic in the case that there is no go.mod file, but

gopls/internal/cache/source.go

@@ -61,9 +61,7 @@ func (s *goplsSource) ResolveReferences(ctx context.Context, filename string, mi
 	// collect the ones that are still
 	needed := maps.Clone(missing)
 	for _, a := range fromWS {
-		if _, ok := needed[a.Package.Name]; ok {
-			delete(needed, a.Package.Name)
-		}
+		delete(needed, a.Package.Name)
 	}
 	// when debug (below) is gone, change this to: if len(needed) == 0 {return fromWS, nil}
 	var fromCache []*result
@@ -184,10 +182,13 @@ type found struct {
 func (s *goplsSource) resolveWorkspaceReferences(filename string, missing imports.References) ([]*imports.Result, error) {
 	uri := protocol.URIFromPath(filename)
 	mypkgs, err := s.S.MetadataForFile(s.ctx, uri)
-	if len(mypkgs) != 1 {
-		// what does this mean? can it happen?
+	if err != nil {
+		return nil, err
+	}
+	if len(mypkgs) == 0 {
+		return nil, nil
 	}
-	mypkg := mypkgs[0]
+	mypkg := mypkgs[0] // narrowest package
 	// search the metadata graph for package ids correstponding to missing
 	g := s.S.MetadataGraph()
 	var ids []metadata.PackageID

gopls/internal/cache/view.go

@@ -20,7 +20,6 @@ import (
 	"os/exec"
 	"path"
 	"path/filepath"
-	"regexp"
 	"slices"
 	"sort"
 	"strings"
@@ -1253,8 +1252,6 @@ func globsMatchPath(globs, target string) bool {
 	return false
 }
 
-var modFlagRegexp = regexp.MustCompile(`-mod[ =](\w+)`)
-
 // TODO(rfindley): clean up the redundancy of allFilesExcluded,
 // pathExcludedByFilterFunc, pathExcludedByFilter, view.filterFunc...
 func allFilesExcluded(files []string, filterFunc func(protocol.DocumentURI) bool) bool {

gopls/internal/cmd/cmd.go

@@ -310,11 +310,6 @@ func (app *Application) featureCommands() []tool.Application {
 	}
 }
 
-var (
-	internalMu          sync.Mutex
-	internalConnections = make(map[string]*connection)
-)
-
 // connect creates and initializes a new in-process gopls session.
 func (app *Application) connect(ctx context.Context) (*connection, error) {
 	client := newClient(app)
@@ -377,10 +372,10 @@ func (c *connection) initialize(ctx context.Context, options func(*settings.Opti
 	params.InitializationOptions = map[string]interface{}{
 		"symbolMatcher": string(opts.SymbolMatcher),
 	}
-	if c.initializeResult, err = c.Server.Initialize(ctx, params); err != nil {
+	if c.initializeResult, err = c.Initialize(ctx, params); err != nil {
 		return err
 	}
-	if err := c.Server.Initialized(ctx, &protocol.InitializedParams{}); err != nil {
+	if err := c.Initialized(ctx, &protocol.InitializedParams{}); err != nil {
 		return err
 	}
 	return nil

gopls/internal/golang/extract.go

@@ -375,7 +375,7 @@ func stmtToInsertVarBefore(path []ast.Node, variables []*variable) (ast.Stmt, er
 		}
 		return parent, nil
 	}
-	return enclosingStmt.(ast.Stmt), nil
+	return enclosingStmt, nil
 }
 
 // canExtractVariable reports whether the code in the given range can be