gopls/internal/golang/completion: modernize

This CL applies the modernizers to the completion code,
and removes some ununsed functions.

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

Author: pjweinbgo

gopls/internal/golang/completion/completion.go

@@ -489,12 +489,7 @@ type candidate struct {
 }
 
 func (c candidate) hasMod(mod typeModKind) bool {
-	for _, m := range c.mods {
-		if m == mod {
-			return true
-		}
-	}
-	return false
+	return slices.Contains(c.mods, mod)
 }
 
 // Completion returns a list of possible candidates for completion, given a
@@ -1487,7 +1482,6 @@ func (c *completer) selector(ctx context.Context, sel *ast.SelectorExpr) error {
 		}
 
 		for _, uri := range mp.CompiledGoFiles {
-			uri := uri
 			g.Go(func() error {
 				return quickParse(uri, mp, tooNew)
 			})

gopls/internal/golang/completion/deep_completion_test.go

@@ -20,7 +20,7 @@ func TestDeepCompletionIsHighScore(t *testing.T) {
 	}
 
 	// Fill up with higher scores.
-	for i := 0; i < MaxDeepCompletions; i++ {
+	for range MaxDeepCompletions {
 		if !s.isHighScore(10) {
 			t.Error("10 should be high score")
 		}

gopls/internal/golang/completion/labels.go

@@ -8,6 +8,7 @@ import (
 	"go/ast"
 	"go/token"
 	"math"
+	"slices"
 )
 
 type labelType int
@@ -96,12 +97,7 @@ func (c *completer) labels(lt labelType) {
 			// Only search into block-like nodes enclosing our "goto".
 			// This prevents us from finding labels in nested blocks.
 			case *ast.BlockStmt, *ast.CommClause, *ast.CaseClause:
-				for _, p := range c.path {
-					if n == p {
-						return true
-					}
-				}
-				return false
+				return slices.Contains(c.path, n)
 			case *ast.LabeledStmt:
 				addLabel(highScore, n)
 			}

gopls/internal/golang/completion/unify.go

@@ -189,29 +189,6 @@ func (u *unifier) set(x *types.TypeParam, t types.Type) {
 	*u.handles[x] = t
 }
 
-// unknowns returns the number of type parameters for which no type has been set yet.
-func (u *unifier) unknowns() int {
-	n := 0
-	for _, h := range u.handles {
-		if *h == nil {
-			n++
-		}
-	}
-	return n
-}
-
-// inferred returns the list of inferred types for the given type parameter list.
-// The result is never nil and has the same length as tparams; result types that
-// could not be inferred are nil. Corresponding type parameters and result types
-// have identical indices.
-func (u *unifier) inferred(tparams []*types.TypeParam) []types.Type {
-	list := make([]types.Type, len(tparams))
-	for i, x := range tparams {
-		list[i] = u.at(x)
-	}
-	return list
-}
-
 // asInterface returns the underlying type of x as an interface if
 // it is a non-type parameter interface. Otherwise it returns nil.
 func asInterface(x types.Type) (i *types.Interface) {
@@ -245,30 +222,6 @@ func identicalOrigin(x, y *types.Named) bool {
 	return x.Origin().Obj() == y.Origin().Obj()
 }
 
-func match(x, y types.Type) types.Type {
-	// Common case: we don't have channels.
-	if types.Identical(x, y) {
-		return x
-	}
-
-	// We may have channels that differ in direction only.
-	if x, _ := x.(*types.Chan); x != nil {
-		if y, _ := y.(*types.Chan); y != nil && types.Identical(x.Elem(), y.Elem()) {
-			// We have channels that differ in direction only.
-			// If there's an unrestricted channel, select the restricted one.
-			switch {
-			case x.Dir() == types.SendRecv:
-				return y
-			case y.Dir() == types.SendRecv:
-				return x
-			}
-		}
-	}
-
-	// types are different
-	return nil
-}
-
 func coreType(t types.Type) types.Type {
 	t = types.Unalias(t)
 	tpar, _ := t.(*types.TypeParam)