Enable staticcheck

.golangci.yml

@@ -41,6 +41,7 @@ linters:
     - perfsprint
     - predeclared
     - reassign
+    - staticcheck
     - testableexamples
     - tparallel
     - unconvert
@@ -55,7 +56,6 @@ linters:
     # - gocritic
     # - gosec
     # - revive
-    # - staticcheck
     # - testifylint
     # - unparam
     # - unused
@@ -85,6 +85,22 @@ linters:
           msg: a host implementation should likely be used instead
           pkg: ^runtime$
 
+    staticcheck:
+      checks:
+        - all
+        - -QF1001
+        - -QF1003
+        - -SA1019
+        - -SA6005
+        - -SA9003
+        - -ST1000
+        - -ST1003
+        - -ST1006 # TODO: enable
+        - -ST1016
+        - -ST1020
+        - -ST1021
+        - -ST1022
+
   exclusions:
     rules:
       - path: internal/fourslash/tests/gen/

internal/astnav/tokens_test.go

@@ -331,23 +331,23 @@ func writeRangeDiff(output *strings.Builder, file *ast.SourceFile, diff tokenDif
 		output.WriteString("\n\n")
 	}
 
-	output.WriteString(fmt.Sprintf("〚Positions: [%d, %d]〛\n", rng.Pos(), rng.End()))
+	fmt.Fprintf(output, "〚Positions: [%d, %d]〛\n", rng.Pos(), rng.End())
 	if diff.tsToken != nil {
-		output.WriteString(fmt.Sprintf("【TS: %s [%d, %d)】\n", diff.tsToken.Kind, tsTokenPos, tsTokenEnd))
+		fmt.Fprintf(output, "【TS: %s [%d, %d)】\n", diff.tsToken.Kind, tsTokenPos, tsTokenEnd)
 	} else {
 		output.WriteString("【TS: nil】\n")
 	}
 	if diff.goToken != nil {
-		output.WriteString(fmt.Sprintf("《Go: %s [%d, %d)》\n", diff.goToken.Kind, goTokenPos, goTokenEnd))
+		fmt.Fprintf(output, "《Go: %s [%d, %d)》\n", diff.goToken.Kind, goTokenPos, goTokenEnd)
 	} else {
 		output.WriteString("《Go: nil》\n")
 	}
 	for line := contextStart; line <= contextEnd; line++ {
 		if truncate, skipTo := shouldTruncate(line); truncate {
-			output.WriteString(fmt.Sprintf("%s │........ %d lines omitted ........\n", strings.Repeat(" ", digits), skipTo-line+1))
+			fmt.Fprintf(output, "%s │........ %d lines omitted ........\n", strings.Repeat(" ", digits), skipTo-line+1)
 			line = skipTo
 		}
-		output.WriteString(fmt.Sprintf("%*d │", digits, line+1))
+		fmt.Fprintf(output, "%*d │", digits, line+1)
 		end := len(file.Text()) + 1
 		if line < len(lines)-1 {
 			end = int(lines[line+1])

internal/binder/binder.go

@@ -243,7 +243,7 @@ func (b *Binder) declareSymbolEx(symbolTable ast.SymbolTable, parent *ast.Symbol
 						}
 					}
 				}
-				var declarationName *ast.Node = ast.GetNameOfDeclaration(node)
+				declarationName := ast.GetNameOfDeclaration(node)
 				if declarationName == nil {
 					declarationName = node
 				}
@@ -258,7 +258,7 @@ func (b *Binder) declareSymbolEx(symbolTable ast.SymbolTable, parent *ast.Symbol
 					diag.AddRelatedInfo(b.createDiagnosticForNode(node, diagnostics.Did_you_mean_0, "export type { "+node.AsTypeAliasDeclaration().Name().Text()+" }"))
 				}
 				for index, declaration := range symbol.Declarations {
-					var decl *ast.Node = ast.GetNameOfDeclaration(declaration)
+					decl := ast.GetNameOfDeclaration(declaration)
 					if decl == nil {
 						decl = declaration
 					}
@@ -1992,7 +1992,7 @@ func (b *Binder) bindCaseBlock(node *ast.Node) {
 	switchStatement := node.Parent
 	clauses := node.AsCaseBlock().Clauses.Nodes
 	isNarrowingSwitch := switchStatement.Expression().Kind == ast.KindTrueKeyword || isNarrowingExpression(switchStatement.Expression())
-	var fallthroughFlow *ast.FlowNode = b.unreachableFlow
+	fallthroughFlow := b.unreachableFlow
 	for i := 0; i < len(clauses); i++ {
 		clauseStart := i
 		for len(clauses[i].Statements()) == 0 && i+1 < len(clauses) {

internal/checker/checker.go

@@ -1655,13 +1655,6 @@ func (c *Checker) getSuggestedLibForNonExistentName(name string) string {
 	return ""
 }
 
-func (c *Checker) getPrimitiveAliasSymbols() {
-	var symbols []*ast.Symbol
-	for _, name := range []string{"string", "number", "boolean", "object", "bigint", "symbol"} {
-		symbols = append(symbols, c.newSymbol(ast.SymbolFlagsTypeAlias, name))
-	}
-}
-
 func (c *Checker) getSuggestedSymbolForNonexistentSymbol(location *ast.Node, outerName string, meaning ast.SymbolFlags) *ast.Symbol {
 	return c.resolveNameForSymbolSuggestion(location, outerName, meaning, nil /*nameNotFoundMessage*/, false /*isUse*/, false /*excludeGlobals*/)
 }
@@ -10558,10 +10551,10 @@ func (c *Checker) checkPrefixUnaryExpression(node *ast.Node) *Type {
 	case ast.KindExclamationToken:
 		c.checkTruthinessOfType(operandType, expr.Operand)
 		facts := c.getTypeFacts(operandType, TypeFactsTruthy|TypeFactsFalsy)
-		switch {
-		case facts == TypeFactsTruthy:
+		switch facts {
+		case TypeFactsTruthy:
 			return c.falseType
-		case facts == TypeFactsFalsy:
+		case TypeFactsFalsy:
 			return c.trueType
 		default:
 			return c.booleanType
@@ -14954,10 +14947,10 @@ func (c *Checker) getSuggestedImportSource(moduleReference string, tsExtension s
 	if c.moduleKind.IsNonNodeESM() || mode == core.ModuleKindESNext {
 		preferTs := tspath.IsDeclarationFileName(moduleReference) && c.compilerOptions.GetAllowImportingTsExtensions()
 		var ext string
-		switch {
-		case tsExtension == tspath.ExtensionMts || tsExtension == tspath.ExtensionDmts:
+		switch tsExtension {
+		case tspath.ExtensionMts, tspath.ExtensionDmts:
 			ext = core.IfElse(preferTs, ".mts", ".mjs")
-		case tsExtension == tspath.ExtensionCts || tsExtension == tspath.ExtensionDcts:
+		case tspath.ExtensionCts, tspath.ExtensionDcts:
 			ext = core.IfElse(preferTs, ".cts", ".cjs")
 		default:
 			ext = core.IfElse(preferTs, ".ts", ".js")
@@ -15710,10 +15703,8 @@ func (c *Checker) getExportsOfModuleWorker(moduleSymbol *ast.Symbol) (exports as
 		return symbols
 	}
 	var originalModule *ast.Symbol
-	if moduleSymbol != nil {
-		if c.resolveSymbolEx(moduleSymbol.Exports[ast.InternalSymbolNameExportEquals], false /*dontResolveAlias*/) != nil {
-			originalModule = moduleSymbol
-		}
+	if c.resolveSymbolEx(moduleSymbol.Exports[ast.InternalSymbolNameExportEquals], false /*dontResolveAlias*/) != nil {
+		originalModule = moduleSymbol
 	}
 	// A module defined by an 'export=' consists of one export that needs to be resolved
 	moduleSymbol = c.resolveExternalModuleSymbol(moduleSymbol, false /*dontResolveAlias*/)
@@ -16482,7 +16473,7 @@ func (c *Checker) getBaseConstructorTypeOfClass(t *Type) *Type {
 		err := c.error(baseTypeNode.Expression(), diagnostics.Type_0_is_not_a_constructor_function_type, c.TypeToString(baseConstructorType))
 		if baseConstructorType.flags&TypeFlagsTypeParameter != 0 {
 			constraint := c.getConstraintFromTypeParameter(baseConstructorType)
-			var ctorReturn *Type = c.unknownType
+			ctorReturn := c.unknownType
 			if constraint != nil {
 				ctorSigs := c.getSignaturesOfType(constraint, SignatureKindConstruct)
 				if len(ctorSigs) != 0 {
@@ -18050,12 +18041,12 @@ func (c *Checker) getOptionalType(t *Type, isProperty bool) *Type {
 // Add undefined or null or both to a type if they are missing.
 func (c *Checker) getNullableType(t *Type, flags TypeFlags) *Type {
 	missing := (flags & ^t.flags) & (TypeFlagsUndefined | TypeFlagsNull)
-	switch {
-	case missing == 0:
+	switch missing {
+	case 0:
 		return t
-	case missing == TypeFlagsUndefined:
+	case TypeFlagsUndefined:
 		return c.getUnionType([]*Type{t, c.undefinedType})
-	case missing == TypeFlagsNull:
+	case TypeFlagsNull:
 		return c.getUnionType([]*Type{t, c.nullType})
 	}
 	return c.getUnionType([]*Type{t, c.undefinedType, c.nullType})
@@ -19531,7 +19522,7 @@ func (c *Checker) getReturnTypeFromBody(fn *ast.Node, checkMode CheckMode) *Type
 	var returnType *Type
 	var yieldType *Type
 	var nextType *Type
-	var fallbackReturnType *Type = c.voidType
+	fallbackReturnType := c.voidType
 	switch {
 	case !ast.IsBlock(body):
 		returnType = c.checkExpressionCachedEx(body, checkMode & ^CheckModeSkipGenericFunctions)
@@ -20543,7 +20534,7 @@ func (c *Checker) getUnionSignatures(signatureLists [][]*Signature) []*Signature
 		// nature and having overloads in multiple constituents would necessitate making a power set of signatures from the type, whose
 		// ordering would be non-obvious)
 		masterList := signatureLists[indexWithLengthOverOne]
-		var results []*Signature = slices.Clone(masterList)
+		results := slices.Clone(masterList)
 		for _, signatures := range signatureLists {
 			if !core.Same(signatures, masterList) {
 				signature := signatures[0]
@@ -28757,10 +28748,10 @@ func (c *Checker) getContextualTypeForArgument(callTarget *ast.Node, arg *ast.No
 
 func (c *Checker) getContextualTypeForArgumentAtIndex(callTarget *ast.Node, argIndex int) *Type {
 	if ast.IsImportCall(callTarget) {
-		switch {
-		case argIndex == 0:
+		switch argIndex {
+		case 0:
 			return c.stringType
-		case argIndex == 1:
+		case 1:
 			return c.getGlobalImportCallOptionsType()
 		default:
 			return c.anyType
@@ -30183,10 +30174,10 @@ func (c *Checker) getGlobalNonNullableTypeInstantiation(t *Type) *Type {
 }
 
 func (c *Checker) convertAutoToAny(t *Type) *Type {
-	switch {
-	case t == c.autoType:
+	switch t {
+	case c.autoType:
 		return c.anyType
-	case t == c.autoArrayType:
+	case c.autoArrayType:
 		return c.anyArrayType
 	}
 	return t

internal/checker/flow.go

@@ -1979,7 +1979,7 @@ func (c *Checker) getSwitchClauseTypeOfWitnesses(node *ast.Node) []string {
 
 // Return the combined not-equal type facts for all cases except those between the start and end indices.
 func (c *Checker) getNotEqualFactsFromTypeofSwitch(start int, end int, witnesses []string) TypeFacts {
-	var facts TypeFacts = TypeFactsNone
+	facts := TypeFactsNone
 	for i, witness := range witnesses {
 		if (i < start || i >= end) && witness != "" {
 			f, ok := typeofNEFacts[witness]

internal/checker/grammarchecks.go

@@ -1494,7 +1494,7 @@ func (c *Checker) checkGrammarMethod(node *ast.Node /*Union[MethodDeclaration, M
 
 func (c *Checker) checkGrammarBreakOrContinueStatement(node *ast.Node) bool {
 	targetLabel := node.Label()
-	var current *ast.Node = node
+	current := node
 	for current != nil {
 		if ast.IsFunctionLikeOrClassStaticBlockDeclaration(current) {
 			return c.grammarErrorOnNode(node, diagnostics.Jump_target_cannot_cross_function_boundary)
@@ -1804,14 +1804,14 @@ func (c *Checker) checkGrammarForDisallowedBlockScopedVariableStatement(node *as
 		blockScopeKind := c.getCombinedNodeFlagsCached(node.DeclarationList) & ast.NodeFlagsBlockScoped
 		if blockScopeKind != 0 {
 			var keyword string
-			switch {
-			case blockScopeKind == ast.NodeFlagsLet:
+			switch blockScopeKind {
+			case ast.NodeFlagsLet:
 				keyword = "let"
-			case blockScopeKind == ast.NodeFlagsConst:
+			case ast.NodeFlagsConst:
 				keyword = "const"
-			case blockScopeKind == ast.NodeFlagsUsing:
+			case ast.NodeFlagsUsing:
 				keyword = "using"
-			case blockScopeKind == ast.NodeFlagsAwaitUsing:
+			case ast.NodeFlagsAwaitUsing:
 				keyword = "await using"
 			default:
 				panic("Unknown BlockScope flag")

internal/checker/inference.go

@@ -580,10 +580,10 @@ func (c *Checker) inferToTemplateLiteralType(n *InferenceState, source *Type, ta
 								case left.flags&TypeFlagsBoolean != 0:
 									return left
 								case right.flags&TypeFlagsBoolean != 0:
-									switch {
-									case str == "true":
+									switch str {
+									case "true":
 										return c.trueType
-									case str == "false":
+									case "false":
 										return c.falseType
 									default:
 										return c.booleanType

internal/checker/jsx.go

@@ -818,7 +818,7 @@ func (c *Checker) createJsxAttributesTypeFromAttributesProperty(openingLikeEleme
 		return len(ast.GetSemanticJsxChildren(children)) != 0
 	}
 	if parentHasSemanticJsxChildren(openingLikeElement) {
-		var childTypes []*Type = c.checkJsxChildren(openingLikeElement.Parent, checkMode)
+		childTypes := c.checkJsxChildren(openingLikeElement.Parent, checkMode)
 		if !hasSpreadAnyType && jsxChildrenPropertyName != ast.InternalSymbolNameMissing && jsxChildrenPropertyName != "" {
 			// Error if there is a attribute named "children" explicitly specified and children element.
 			// This is because children element will overwrite the value from attributes.

internal/checker/nodebuilderimpl.go

@@ -181,7 +181,7 @@ func (b *NodeBuilderImpl) appendReferenceToType(root *ast.TypeNode, ref *ast.Typ
 		// !!! Without the above, nested type args are silently elided
 		// then move qualifiers
 		ids := getAccessStack(ref)
-		var typeName *ast.Node = root.AsTypeReferenceNode().TypeName
+		typeName := root.AsTypeReferenceNode().TypeName
 		for _, id := range ids {
 			typeName = b.f.NewQualifiedName(typeName, id)
 		}
@@ -190,7 +190,7 @@ func (b *NodeBuilderImpl) appendReferenceToType(root *ast.TypeNode, ref *ast.Typ
 }
 
 func getAccessStack(ref *ast.Node) []*ast.Node {
-	var state *ast.Node = ref.AsTypeReferenceNode().TypeName
+	state := ref.AsTypeReferenceNode().TypeName
 	ids := []*ast.Node{}
 	for !ast.IsIdentifier(state) {
 		entity := state.AsQualifiedName()
@@ -1315,7 +1315,7 @@ func (b *NodeBuilderImpl) typeParameterToName(typeParameter *Type) *ast.Identifi
 		}
 		text := rawText
 
-		for true {
+		for {
 			_, present := b.ctx.typeParameterNamesByText[text]
 			if !present && !b.typeParameterShadowsOtherTypeParameterInScope(text, typeParameter) {
 				break
@@ -1751,47 +1751,47 @@ func (b *NodeBuilderImpl) signatureToSignatureDeclarationHelper(signature *Signa
 	}
 
 	var node *ast.Node
-	switch {
-	case kind == ast.KindCallSignature:
+	switch kind {
+	case ast.KindCallSignature:
 		node = b.f.NewCallSignatureDeclaration(typeParamList, paramList, returnTypeNode)
-	case kind == ast.KindConstructSignature:
+	case ast.KindConstructSignature:
 		node = b.f.NewConstructSignatureDeclaration(typeParamList, paramList, returnTypeNode)
-	case kind == ast.KindMethodSignature:
+	case ast.KindMethodSignature:
 		var questionToken *ast.Node
 		if options != nil {
 			questionToken = options.questionToken
 		}
 		node = b.f.NewMethodSignatureDeclaration(modifierList, name, questionToken, typeParamList, paramList, returnTypeNode)
-	case kind == ast.KindMethodDeclaration:
+	case ast.KindMethodDeclaration:
 		node = b.f.NewMethodDeclaration(modifierList, nil /*asteriskToken*/, name, nil /*questionToken*/, typeParamList, paramList, returnTypeNode, nil /*fullSignature*/, nil /*body*/)
-	case kind == ast.KindConstructor:
+	case ast.KindConstructor:
 		node = b.f.NewConstructorDeclaration(modifierList, nil /*typeParamList*/, paramList, nil /*returnTypeNode*/, nil /*fullSignature*/, nil /*body*/)
-	case kind == ast.KindGetAccessor:
+	case ast.KindGetAccessor:
 		node = b.f.NewGetAccessorDeclaration(modifierList, name, nil /*typeParamList*/, paramList, returnTypeNode, nil /*fullSignature*/, nil /*body*/)
-	case kind == ast.KindSetAccessor:
+	case ast.KindSetAccessor:
 		node = b.f.NewSetAccessorDeclaration(modifierList, name, nil /*typeParamList*/, paramList, nil /*returnTypeNode*/, nil /*fullSignature*/, nil /*body*/)
-	case kind == ast.KindIndexSignature:
+	case ast.KindIndexSignature:
 		node = b.f.NewIndexSignatureDeclaration(modifierList, paramList, returnTypeNode)
 	// !!! JSDoc Support
-	// case kind == ast.KindJSDocFunctionType:
+	// case ast.KindJSDocFunctionType:
 	// 	node = b.f.NewJSDocFunctionType(parameters, returnTypeNode)
-	case kind == ast.KindFunctionType:
+	case ast.KindFunctionType:
 		if returnTypeNode == nil {
 			returnTypeNode = b.f.NewTypeReferenceNode(b.f.NewIdentifier(""), nil)
 		}
 		node = b.f.NewFunctionTypeNode(typeParamList, paramList, returnTypeNode)
-	case kind == ast.KindConstructorType:
+	case ast.KindConstructorType:
 		if returnTypeNode == nil {
 			returnTypeNode = b.f.NewTypeReferenceNode(b.f.NewIdentifier(""), nil)
 		}
 		node = b.f.NewConstructorTypeNode(modifierList, typeParamList, paramList, returnTypeNode)
-	case kind == ast.KindFunctionDeclaration:
+	case ast.KindFunctionDeclaration:
 		// TODO: assert name is Identifier
 		node = b.f.NewFunctionDeclaration(modifierList, nil /*asteriskToken*/, name, typeParamList, paramList, returnTypeNode, nil /*fullSignature*/, nil /*body*/)
-	case kind == ast.KindFunctionExpression:
+	case ast.KindFunctionExpression:
 		// TODO: assert name is Identifier
 		node = b.f.NewFunctionExpression(modifierList, nil /*asteriskToken*/, name, typeParamList, paramList, returnTypeNode, nil /*fullSignature*/, b.f.NewBlock(b.f.NewNodeList([]*ast.Node{}), false))
-	case kind == ast.KindArrowFunction:
+	case ast.KindArrowFunction:
 		node = b.f.NewArrowFunction(modifierList, typeParamList, paramList, returnTypeNode, nil /*fullSignature*/, nil /*equalsGreaterThanToken*/, b.f.NewBlock(b.f.NewNodeList([]*ast.Node{}), false))
 	default:
 		panic("Unhandled kind in signatureToSignatureDeclarationHelper")
@@ -1833,7 +1833,7 @@ func (c *Checker) getExpandedParameters(sig *Signature, skipUnionExpanding bool)
 						counter = 1
 					}
 					var name string
-					for true {
+					for {
 						name = fmt.Sprintf("%s_%d", names[i], counter)
 						_, ok := uniqueNames[name]
 						if ok {
@@ -2578,7 +2578,7 @@ func (b *NodeBuilderImpl) conditionalTypeToTypeNode(_t *Type) *ast.TypeNode {
 
 func (b *NodeBuilderImpl) getParentSymbolOfTypeParameter(typeParameter *TypeParameter) *ast.Symbol {
 	tp := ast.GetDeclarationOfKind(typeParameter.symbol, ast.KindTypeParameter)
-	var host *ast.Node
+	var host *ast.Node //nolint:staticcheck
 	// !!! JSDoc support
 	// if ast.IsJSDocTemplateTag(tp.Parent) {
 	// 	host = getEffectiveContainerForJSDocTemplateTag(tp.Parent)
@@ -2592,7 +2592,7 @@ func (b *NodeBuilderImpl) getParentSymbolOfTypeParameter(typeParameter *TypePara
 }
 
 func (b *NodeBuilderImpl) typeReferenceToTypeNode(t *Type) *ast.TypeNode {
-	var typeArguments []*Type = b.ch.getTypeArguments(t)
+	typeArguments := b.ch.getTypeArguments(t)
 	if t.Target() == b.ch.globalArrayType || t.Target() == b.ch.globalReadonlyArrayType {
 		if b.ctx.flags&nodebuilder.FlagsWriteArrayAsGenericType != 0 {
 			typeArgumentNode := b.typeToTypeNode(typeArguments[0])