chore: enable staticcheck rule (#150)

hardfist · Amour1688 · commit f9ae2cd8ee2c · 2025-08-04T13:58:25.000+08:00
diff --git a/.golangci.yml b/.golangci.yml
@@ -56,10 +56,10 @@ linters:
     # - gocritic
     # - gosec
     # - revive
-    # - staticcheck
+    - staticcheck
     # - testifylint
     # - unparam
-    # - unused
+    - unused
 
   settings:
     depguard:
diff --git a/cmd/rslint/cmd.go b/cmd/rslint/cmd.go
@@ -141,8 +141,8 @@ func printDiagnosticJsonLine(d rule.RuleDiagnostic, w *bufio.Writer, comparePath
 			Error string `json:"error"`
 		}
 		errorObject := ErrorObject{Error: fmt.Sprintf("Failed to marshal diagnostic: %s", err)}
-		
-		errorBytes,_ := json.Marshal(errorObject) //nolint:errchkjson
+
+		errorBytes, _ := json.Marshal(errorObject) //nolint:errchkjson
 		w.Write(errorBytes)
 		w.WriteByte('\n')
 		return
diff --git a/cmd/rslint/lsp.go b/cmd/rslint/lsp.go
@@ -97,7 +97,7 @@ func (s *LSPServer) handleInitialize(ctx context.Context, req *jsonrpc2.Request)
 			Message: "Failed to parse initialize params",
 		}
 	}
-
+	//nolint:staticcheck
 	if params.RootUri.DocumentUri != nil {
 		s.rootURI = uriToPath(string(*params.RootUri.DocumentUri))
 	}
@@ -274,7 +274,6 @@ func (s *LSPServer) runDiagnostics(ctx context.Context, uri lsproto.DocumentUri,
 
 	// Create multiple programs for all tsconfig files
 	var programs []*compiler.Program
-	var allSourceFiles []*ast.SourceFile
 	var targetFile *ast.SourceFile
 
 	for _, tsConfigPath := range tsConfigs {
@@ -287,7 +286,6 @@ func (s *LSPServer) runDiagnostics(ctx context.Context, uri lsproto.DocumentUri,
 
 		// Check if the current file is in this program
 		sourceFiles := program.GetSourceFiles()
-		allSourceFiles = append(allSourceFiles, sourceFiles...)
 
 		if targetFile == nil {
 			for _, sf := range sourceFiles {
@@ -451,10 +449,13 @@ func runLintWithPrograms(uri lsproto.DocumentUri, programs []*compiler.Program,
 
 // Helper function to check if two ranges overlap
 func rangesOverlap(a, b lsproto.Range) bool {
-	return !(a.End.Line < b.Start.Line ||
-		(a.End.Line == b.Start.Line && a.End.Character < b.Start.Character) ||
-		b.End.Line < a.Start.Line ||
-		(b.End.Line == a.Start.Line && b.End.Character < a.Start.Character))
+	// Ranges overlap if a starts before or at b's end AND b starts before or at a's end
+	aStartsBefore := a.Start.Line < b.End.Line ||
+		(a.Start.Line == b.End.Line && a.Start.Character <= b.End.Character)
+	bStartsBefore := b.Start.Line < a.End.Line ||
+		(b.Start.Line == a.End.Line && b.Start.Character <= a.End.Character)
+
+	return aStartsBefore && bStartsBefore
 }
 
 // Helper function to create a code action from a rule diagnostic
diff --git a/internal/rules/no_base_to_string/no_base_to_string.go b/internal/rules/no_base_to_string/no_base_to_string.go
@@ -305,11 +305,12 @@ var NoBaseToStringRule = rule.Rule{
 				if ast.IsPropertyAccessExpression(callExpr.Expression) {
 					memberExpr := callExpr.Expression.AsPropertyAccessExpression()
 					propertyName := memberExpr.Name().Text()
-					if propertyName == "join" {
+					switch propertyName {
+					case "join":
 						t := utils.GetConstrainedTypeAtLocation(ctx.TypeChecker, memberExpr.Expression)
 						checkExpressionForArrayJoin(memberExpr.Expression, t)
 						return
-					} else if propertyName == "toLocaleString" || propertyName == "toString" {
+					case "toLocaleString", "toString":
 						checkExpression(memberExpr.Expression, nil)
 						return
 					}
diff --git a/internal/rules/no_duplicate_type_constituents/no_duplicate_type_constituents.go b/internal/rules/no_duplicate_type_constituents/no_duplicate_type_constituents.go
@@ -91,10 +91,8 @@ var NoDuplicateTypeConstituentsRule = rule.Rule{
 			prevStart := 0
 			bracketBeforeTokens := []core.TextRange{}
 
-			for {
-				if s.TokenStart() >= constituentNode.Pos() {
-					break
-				}
+			for s.TokenStart() < constituentNode.Pos() {
+
 				if s.Token() == ast.KindAmpersandToken || s.Token() == ast.KindBarToken {
 					foundBefore = true
 					prevStart = s.TokenStart()
@@ -238,13 +236,14 @@ var NoDuplicateTypeConstituentsRule = rule.Rule{
 
 			var unionOrIntersection unionOrIntersection
 			var types []*ast.Node
-			if node.Kind == ast.KindIntersectionType {
+			switch node.Kind {
+			case ast.KindIntersectionType:
 				unionOrIntersection = unionOrIntersection_Intersection
 				types = node.AsIntersectionTypeNode().Types.Nodes
-			} else if node.Kind == ast.KindUnionType {
+			case ast.KindUnionType:
 				unionOrIntersection = unionOrIntersection_Union
 				types = node.AsUnionTypeNode().Types.Nodes
-			} else {
+			default:
 				panic(fmt.Sprintf("expected union or intersection, got %v", node.Kind))
 			}
 
@@ -288,7 +287,6 @@ var NoDuplicateTypeConstituentsRule = rule.Rule{
 						report(true, unionOrIntersection_Union, buildUnnecessaryMessage(), constituentNode)
 					}
 				})
-				return
 			}
 		}
 
diff --git a/internal/rules/no_misused_promises/no_misused_promises.go b/internal/rules/no_misused_promises/no_misused_promises.go
@@ -508,7 +508,7 @@ var NoMisusedPromisesRule = rule.Rule{
 					// signature here against its compatible index signatures in `heritageTypes`
 					continue
 				}
-				if !(ast.IsIdentifier(nodeMember.Name()) || ast.IsPrivateIdentifier(nodeMember.Name()) || ast.IsStringLiteral(nodeMember.Name()) || ast.IsNumericLiteral(nodeMember.Name()) || ast.IsBigIntLiteral(nodeMember.Name())) {
+				if !ast.IsIdentifier(nodeMember.Name()) && !ast.IsPrivateIdentifier(nodeMember.Name()) && !ast.IsStringLiteral(nodeMember.Name()) && !ast.IsNumericLiteral(nodeMember.Name()) && !ast.IsBigIntLiteral(nodeMember.Name()) {
 					continue
 				}
 				memberName := nodeMember.Name().Text()
@@ -593,7 +593,9 @@ var NoMisusedPromisesRule = rule.Rule{
 				)
 
 				if isVoidReturningFunctionType(node.Name(), contextualType) {
+					//nolint:staticcheck // FIXME: todo
 					if ast.IsMethodDeclaration(node) {
+
 					}
 
 					if node.Type() != nil {
diff --git a/internal/rules/no_unnecessary_type_arguments/no_unnecessary_type_arguments.go b/internal/rules/no_unnecessary_type_arguments/no_unnecessary_type_arguments.go
@@ -124,7 +124,7 @@ var NoUnnecessaryTypeArgumentsRule = rule.Rule{
 			if utils.IsIntrinsicErrorType(argType) {
 				return
 			}
-			if argType != paramType && (utils.IsTypeAnyType(argType) || utils.IsTypeAnyType(paramType) || !(checker.Checker_isTypeStrictSubtypeOf(ctx.TypeChecker, argType, paramType) && checker.Checker_isTypeStrictSubtypeOf(ctx.TypeChecker, paramType, argType))) {
+			if argType != paramType && (utils.IsTypeAnyType(argType) || utils.IsTypeAnyType(paramType) || (!checker.Checker_isTypeStrictSubtypeOf(ctx.TypeChecker, argType, paramType) || !checker.Checker_isTypeStrictSubtypeOf(ctx.TypeChecker, paramType, argType))) {
 				return
 			}
 
diff --git a/internal/rules/no_unnecessary_type_assertion/no_unnecessary_type_assertion.go b/internal/rules/no_unnecessary_type_assertion/no_unnecessary_type_assertion.go
@@ -107,9 +107,7 @@ var NoUnnecessaryTypeAssertionRule = rule.Rule{
 				t := utils.GetConstrainedTypeAtLocation(ctx.TypeChecker, node)
 				if declarationType == t &&
 					// `declare`s are never narrowed, so never skip them
-					!(ast.IsVariableDeclarationList(declaration.Parent) &&
-						ast.IsVariableStatement(declaration.Parent.Parent) &&
-						utils.IncludesModifier(declaration.Parent.Parent.AsVariableStatement(), ast.KindDeclareKeyword)) {
+					(!ast.IsVariableDeclarationList(declaration.Parent) || !ast.IsVariableStatement(declaration.Parent.Parent) || !utils.IncludesModifier(declaration.Parent.Parent.AsVariableStatement(), ast.KindDeclareKeyword)) {
 					// possibly used before assigned, so just skip it
 					// better to false negative and skip it, than false positive and fix to compile erroring code
 					//
diff --git a/internal/rules/no_unsafe_argument/no_unsafe_argument.go b/internal/rules/no_unsafe_argument/no_unsafe_argument.go
@@ -66,7 +66,7 @@ func newFunctionSignature(
 	for i, param := range parameters {
 		t := typeChecker.GetTypeOfSymbolAtLocation(param, node)
 
-		if param.Declarations != nil && len(param.Declarations) != 0 {
+		if len(param.Declarations) != 0 {
 			decl := param.Declarations[0]
 			if utils.IsRestParameterDeclaration(decl) {
 				// is a rest param
@@ -240,7 +240,10 @@ var NoUnsafeArgumentRule = rule.Rule{
 							// all remaining arguments should be compared against the rest type (if one exists)
 							signature.consumeRemainingArguments()
 						}
-					} else {
+
+					} else
+					//nolint:staticcheck // FIXME: todo
+					{
 						// something that's iterable
 						// handling this will be pretty complex - so we ignore it for now
 						// TODO - handle generic iterable case
diff --git a/internal/rules/no_unsafe_enum_comparison/no_unsafe_enum_comparison.go b/internal/rules/no_unsafe_enum_comparison/no_unsafe_enum_comparison.go
@@ -134,7 +134,7 @@ var NoUnsafeEnumComparisonRule = rule.Rule{
 			ast.KindBinaryExpression: func(node *ast.Node) {
 				expr := node.AsBinaryExpression()
 				opKind := expr.OperatorToken.Kind
-				if !(opKind == ast.KindLessThanToken || opKind == ast.KindLessThanEqualsToken || opKind == ast.KindGreaterThanToken || opKind == ast.KindGreaterThanEqualsToken || opKind == ast.KindEqualsEqualsToken || opKind == ast.KindEqualsEqualsEqualsToken || opKind == ast.KindExclamationEqualsToken || opKind == ast.KindExclamationEqualsEqualsToken) {
+				if opKind != ast.KindLessThanToken && opKind != ast.KindLessThanEqualsToken && opKind != ast.KindGreaterThanToken && opKind != ast.KindGreaterThanEqualsToken && opKind != ast.KindEqualsEqualsToken && opKind != ast.KindEqualsEqualsEqualsToken && opKind != ast.KindExclamationEqualsToken && opKind != ast.KindExclamationEqualsEqualsToken {
 					return
 				}
 
diff --git a/internal/rules/require_await/require_await.go b/internal/rules/require_await/require_await.go
@@ -49,7 +49,7 @@ var RequireAwaitRule = rule.Rule{
 		}
 
 		exitFunction := func(node *ast.Node) {
-			if currentScope.functionFlags&checker.FunctionFlagsAsync != 0 && !currentScope.hasAwait && !(currentScope.functionFlags&checker.FunctionFlagsGenerator != 0 && currentScope.isAsyncYield) {
+			if currentScope.functionFlags&checker.FunctionFlagsAsync != 0 && !currentScope.hasAwait && (currentScope.functionFlags&checker.FunctionFlagsGenerator == 0 || !currentScope.isAsyncYield) {
 				// TODO(port): implement suggestions
 				// // If the function belongs to a method definition or
 				// // property, then the function's range may not include the
diff --git a/internal/rules/return_await/return_await.go b/internal/rules/return_await/return_await.go
@@ -125,17 +125,16 @@ var ReturnAwaitRule = rule.Rule{
 
 			for declarationScope := ast.GetEnclosingBlockScopeContainer(node); declarationScope != nil; declarationScope = ast.GetEnclosingBlockScopeContainer(declarationScope) {
 				locals := declarationScope.Locals()
-				if locals != nil {
-					for _, local := range locals {
-						decl := local.ValueDeclaration
-						// if it's a using/await using declaration, and it comes _before_ the
-						// node we're checking, it affects control flow for that node.
-
-						if decl != nil && ast.IsVariableDeclaration(decl) && decl.Parent.Flags&ast.NodeFlagsUsing != 0 && decl.Pos() < node.Pos() {
-							return true
-						}
+				for _, local := range locals {
+					decl := local.ValueDeclaration
+					// if it's a using/await using declaration, and it comes _before_ the
+					// node we're checking, it affects control flow for that node.
+
+					if decl != nil && ast.IsVariableDeclaration(decl) && decl.Parent.Flags&ast.NodeFlagsUsing != 0 && decl.Pos() < node.Pos() {
+						return true
 					}
 				}
+
 				if scope.owningFunc == declarationScope {
 					break
 				}
@@ -164,12 +163,12 @@ var ReturnAwaitRule = rule.Rule{
 				statement := ancestor.AsTryStatement()
 
 				var block containingTryStatementBlock
-				switch {
-				case child == statement.TryBlock:
+				switch child {
+				case statement.TryBlock:
 					block = containingTryStatementBlockTry
-				case child == statement.CatchClause:
+				case statement.CatchClause:
 					block = containingTryStatementBlockCatch
-				case child == statement.FinallyBlock:
+				case statement.FinallyBlock:
 					block = containingTryStatementBlockFinally
 				}
 
diff --git a/internal/rules/use_unknown_in_catch_callback_variable/use_unknown_in_catch_callback_variable.go b/internal/rules/use_unknown_in_catch_callback_variable/use_unknown_in_catch_callback_variable.go
@@ -129,13 +129,14 @@ var UseUnknownInCatchCallbackVariableRule = rule.Rule{
 				var method string
 				var argIndexToCheck int
 
-				if propertyName == "catch" {
+				switch propertyName {
+				case "catch":
 					method = "`catch`"
 					argIndexToCheck = 0
-				} else if propertyName == "then" {
+				case "then":
 					method = "`then` rejection"
 					argIndexToCheck = 1
-				} else {
+				default:
 					return
 				}
 
diff --git a/internal/utils/builtin_symbol_likes.go b/internal/utils/builtin_symbol_likes.go
@@ -248,9 +248,10 @@ func IsBuiltinSymbolLikeRecurser(
 	}
 
 	predicateResult := predicate(t)
-	if predicateResult == builtinPredicateMatches_True {
+	switch predicateResult {
+	case builtinPredicateMatches_True:
 		return true
-	} else if predicateResult == builtinPredicateMatches_False {
+	case builtinPredicateMatches_False:
 		return false
 	}
 
diff --git a/internal/utils/create_program.go b/internal/utils/create_program.go
@@ -43,7 +43,7 @@ func CreateProgram(singleThreaded bool, fs vfs.FS, cwd string, tsconfigPath stri
 
 	diagnostics := program.GetSyntacticDiagnostics(context.Background(), nil)
 	if len(diagnostics) != 0 {
-		return nil, fmt.Errorf("found %v syntactic errors. Try running \"tsgo --noEmit\" first\n", len(diagnostics))
+		return nil, fmt.Errorf("found %v syntactic errors. Try running \"tsgo --noEmit\" first", len(diagnostics))
 	}
 
 	program.BindSourceFiles()
diff --git a/internal/utils/ts_eslint.go b/internal/utils/ts_eslint.go
@@ -113,7 +113,7 @@ func GetTypeName(
 		// via AST.
 		symbol := checker.Type_symbol(t)
 		decls := symbol.Declarations
-		if decls != nil && len(decls) > 0 {
+		if len(decls) > 0 {
 			if ast.IsTypeParameterDeclaration(decls[0]) {
 				typeParamDecl := decls[0].AsTypeParameter()
 				if typeParamDecl.Constraint != nil {
diff --git a/internal/utils/utils.go b/internal/utils/utils.go
@@ -159,7 +159,7 @@ func IncludesModifier(node interface{ Modifiers() *ast.ModifierList }, modifier
 	if modifiers == nil {
 		return false
 	}
-	return Some(modifiers.NodeList.Nodes, func(m *ast.Node) bool {
+	return Some(modifiers.Nodes, func(m *ast.Node) bool {
 		return m.Kind == modifier
 	})
 }

Original file line number	Diff line number	Diff line change
`@@ -508,7 +508,7 @@ var NoMisusedPromisesRule = rule.Rule{`
`508`	`508`	// signature here against its compatible index signatures in `heritageTypes`
`509`	`509`	`continue`
`510`	`510`	`}`
`511`		`- if !(ast.IsIdentifier(nodeMember.Name()) \|\| ast.IsPrivateIdentifier(nodeMember.Name()) \|\| ast.IsStringLiteral(nodeMember.Name()) \|\| ast.IsNumericLiteral(nodeMember.Name()) \|\| ast.IsBigIntLiteral(nodeMember.Name())) {`
	`511`	`+ if !ast.IsIdentifier(nodeMember.Name()) && !ast.IsPrivateIdentifier(nodeMember.Name()) && !ast.IsStringLiteral(nodeMember.Name()) && !ast.IsNumericLiteral(nodeMember.Name()) && !ast.IsBigIntLiteral(nodeMember.Name()) {`
`512`	`512`	`continue`
`513`	`513`	`}`
`514`	`514`	`memberName := nodeMember.Name().Text()`
`@@ -593,7 +593,9 @@ var NoMisusedPromisesRule = rule.Rule{`
`593`	`593`	`)`
`594`	`594`
`595`	`595`	`if isVoidReturningFunctionType(node.Name(), contextualType) {`
	`596`	`+ //nolint:staticcheck // FIXME: todo`
`596`	`597`	`if ast.IsMethodDeclaration(node) {`
	`598`	`+`
`597`	`599`	`}`
`598`	`600`
`599`	`601`	`if node.Type() != nil {`
Original file line number	Diff line number	Diff line change
`@@ -124,7 +124,7 @@ var NoUnnecessaryTypeArgumentsRule = rule.Rule{`
`124`	`124`	`if utils.IsIntrinsicErrorType(argType) {`
`125`	`125`	`return`
`126`	`126`	`}`
`127`		`- if argType != paramType && (utils.IsTypeAnyType(argType) \|\| utils.IsTypeAnyType(paramType) \|\| !(checker.Checker_isTypeStrictSubtypeOf(ctx.TypeChecker, argType, paramType) && checker.Checker_isTypeStrictSubtypeOf(ctx.TypeChecker, paramType, argType))) {`
	`127`	`+ if argType != paramType && (utils.IsTypeAnyType(argType) \|\| utils.IsTypeAnyType(paramType) \|\| (!checker.Checker_isTypeStrictSubtypeOf(ctx.TypeChecker, argType, paramType) \|\| !checker.Checker_isTypeStrictSubtypeOf(ctx.TypeChecker, paramType, argType))) {`
`128`	`128`	`return`
`129`	`129`	`}`
`130`	`130`
Original file line number	Diff line number	Diff line change
`@@ -134,7 +134,7 @@ var NoUnsafeEnumComparisonRule = rule.Rule{`
`134`	`134`	`ast.KindBinaryExpression: func(node *ast.Node) {`
`135`	`135`	`expr := node.AsBinaryExpression()`
`136`	`136`	`opKind := expr.OperatorToken.Kind`
`137`		`- if !(opKind == ast.KindLessThanToken \|\| opKind == ast.KindLessThanEqualsToken \|\| opKind == ast.KindGreaterThanToken \|\| opKind == ast.KindGreaterThanEqualsToken \|\| opKind == ast.KindEqualsEqualsToken \|\| opKind == ast.KindEqualsEqualsEqualsToken \|\| opKind == ast.KindExclamationEqualsToken \|\| opKind == ast.KindExclamationEqualsEqualsToken) {`
	`137`	`+ if opKind != ast.KindLessThanToken && opKind != ast.KindLessThanEqualsToken && opKind != ast.KindGreaterThanToken && opKind != ast.KindGreaterThanEqualsToken && opKind != ast.KindEqualsEqualsToken && opKind != ast.KindEqualsEqualsEqualsToken && opKind != ast.KindExclamationEqualsToken && opKind != ast.KindExclamationEqualsEqualsToken {`
`138`	`138`	`return`
`139`	`139`	`}`
`140`	`140`