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
@@ -87,6 +87,21 @@ linters:
           msg: a host implementation should likely be used instead
           pkg: ^runtime$
 
+    staticcheck:
+      checks:
+        - all
+        - -QF1001 # Apply De Morgan’s law
+        - -QF1003 # Convert if/else-if chain to tagged switch
+        - -SA1019 # Using a deprecated function, variable, constant or field
+        - -SA9003 # Empty body in an if or else branch
+        - -ST1000 # Incorrect or missing package comment
+        - -ST1003 # Poorly chosen identifier
+        - -ST1006 # Poorly chosen receiver name
+        - -ST1016 # Use consistent method receiver names
+        - -ST1020 # The documentation of an exported function should start with the function’s name
+        - -ST1021 # The documentation of an exported type should start with type’s name
+        - -ST1022 # The documentation of an exported variable or constant should start with variable’s name
+
   exclusions:
     rules:
       - path: internal/fourslash/tests/gen/

internal/api/encoder/encoder_test.go

@@ -104,7 +104,7 @@ func formatEncodedSourceFile(encoded []byte) string {
 			strStart := readUint32(encoded, int(offsetStringOffsets+stringIndex*4))
 			strEnd := readUint32(encoded, int(offsetStringOffsets+stringIndex*4)+4)
 			str := string(encoded[offsetStrings+strStart : offsetStrings+strEnd])
-			result.WriteString(fmt.Sprintf(" \"%s\"", str))
+			fmt.Fprintf(&result, " \"%s\"", str)
 		}
 		fmt.Fprintf(&result, " [%d, %d), i=%d, next=%d", pos, end, j, encoded[i+encoder.NodeOffsetNext])
 		result.WriteString("\n")

internal/astnav/tokens_test.go

@@ -408,23 +408,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

@@ -249,7 +249,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
 				}
@@ -264,7 +264,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
 					}
@@ -2061,7 +2061,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

@@ -10510,10 +10510,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
@@ -13382,7 +13382,7 @@ func (c *Checker) isReadonlyAssignmentDeclaration(node *ast.Node) bool {
 			} else {
 				writableType = c.getTypeOfSymbol(writableProp)
 			}
-			return writableType.flags&TypeFlagsBooleanLiteral != 0 && getBooleanLiteralValue(writableType) == false
+			return writableType.flags&TypeFlagsBooleanLiteral != 0 && !getBooleanLiteralValue(writableType)
 		}
 		return true
 	}
@@ -14959,10 +14959,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")
@@ -15694,10 +15694,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*/)
@@ -16471,7 +16469,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 {
@@ -18097,12 +18095,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})
@@ -19581,7 +19579,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)
@@ -20606,7 +20604,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]
@@ -28809,10 +28807,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
@@ -30249,10 +30247,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

@@ -1987,7 +1987,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

@@ -1485,7 +1485,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)
@@ -1798,14 +1798,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

@@ -575,10 +575,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.