@ttsc/lint 0.14.0-dev.20260529.1 → 0.14.0

package/linthost/rules_camelcase.go

@@ -14,56 +14,56 @@
 package linthost
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 type camelcase struct{}
 
 func (camelcase) Name() string { return "camelcase" }
 func (camelcase) Visits() []shimast.Kind {
-	return []shimast.Kind{
-		shimast.KindVariableDeclaration,
-		shimast.KindParameter,
-		shimast.KindFunctionDeclaration,
-		shimast.KindClassDeclaration,
-	}
+  return []shimast.Kind{
+    shimast.KindVariableDeclaration,
+    shimast.KindParameter,
+    shimast.KindFunctionDeclaration,
+    shimast.KindClassDeclaration,
+  }
 }
 func (camelcase) Check(ctx *Context, node *shimast.Node) {
-	var nameNode *shimast.Node
-	switch node.Kind {
-	case shimast.KindVariableDeclaration:
-		decl := node.AsVariableDeclaration()
-		if decl == nil {
-			return
-		}
-		nameNode = decl.Name()
-	case shimast.KindParameter:
-		decl := node.AsParameterDeclaration()
-		if decl == nil {
-			return
-		}
-		nameNode = decl.Name()
-	case shimast.KindFunctionDeclaration:
-		decl := node.AsFunctionDeclaration()
-		if decl == nil {
-			return
-		}
-		nameNode = decl.Name()
-	case shimast.KindClassDeclaration:
-		decl := node.AsClassDeclaration()
-		if decl == nil {
-			return
-		}
-		nameNode = decl.Name()
-	}
-	name := identifierText(nameNode)
-	if name == "" {
-		return
-	}
-	if isCamelOrPascalCaseName(name) {
-		return
-	}
-	ctx.Report(nameNode, "Identifier '"+name+"' is not in camelCase.")
+  var nameNode *shimast.Node
+  switch node.Kind {
+  case shimast.KindVariableDeclaration:
+    decl := node.AsVariableDeclaration()
+    if decl == nil {
+      return
+    }
+    nameNode = decl.Name()
+  case shimast.KindParameter:
+    decl := node.AsParameterDeclaration()
+    if decl == nil {
+      return
+    }
+    nameNode = decl.Name()
+  case shimast.KindFunctionDeclaration:
+    decl := node.AsFunctionDeclaration()
+    if decl == nil {
+      return
+    }
+    nameNode = decl.Name()
+  case shimast.KindClassDeclaration:
+    decl := node.AsClassDeclaration()
+    if decl == nil {
+      return
+    }
+    nameNode = decl.Name()
+  }
+  name := identifierText(nameNode)
+  if name == "" {
+    return
+  }
+  if isCamelOrPascalCaseName(name) {
+    return
+  }
+  ctx.Report(nameNode, "Identifier '"+name+"' is not in camelCase.")
 }
 
 // isCamelOrPascalCaseName reports whether `name` matches the convention
@@ -76,58 +76,58 @@ func (camelcase) Check(ctx *Context, node *shimast.Node) {
 // SCREAMING_SNAKE constant and accepted; everything else with an
 // interior underscore is reported.
 func isCamelOrPascalCaseName(name string) bool {
-	if name == "" {
-		return true
-	}
-	trimmed := trimUnderscores(name)
-	if trimmed == "" {
-		return true
-	}
-	if !containsUnderscore(trimmed) {
-		return true
-	}
-	return isAllUpperOrUnderscore(trimmed)
+  if name == "" {
+    return true
+  }
+  trimmed := trimUnderscores(name)
+  if trimmed == "" {
+    return true
+  }
+  if !containsUnderscore(trimmed) {
+    return true
+  }
+  return isAllUpperOrUnderscore(trimmed)
 }
 
 func trimUnderscores(s string) string {
-	start, end := 0, len(s)
-	for start < end && s[start] == '_' {
-		start++
-	}
-	for end > start && s[end-1] == '_' {
-		end--
-	}
-	return s[start:end]
+  start, end := 0, len(s)
+  for start < end && s[start] == '_' {
+    start++
+  }
+  for end > start && s[end-1] == '_' {
+    end--
+  }
+  return s[start:end]
 }
 
 func containsUnderscore(s string) bool {
-	for i := 0; i < len(s); i++ {
-		if s[i] == '_' {
-			return true
-		}
-	}
-	return false
+  for i := 0; i < len(s); i++ {
+    if s[i] == '_' {
+      return true
+    }
+  }
+  return false
 }
 
 // isAllUpperOrUnderscore returns true when every character is either an
 // uppercase ASCII letter, a digit, or an underscore. Lowercase letters
 // disqualify the string and force the rule to report.
 func isAllUpperOrUnderscore(s string) bool {
-	hasUpper := false
-	for i := 0; i < len(s); i++ {
-		ch := s[i]
-		switch {
-		case ch >= 'A' && ch <= 'Z':
-			hasUpper = true
-		case ch >= '0' && ch <= '9':
-		case ch == '_':
-		default:
-			return false
-		}
-	}
-	return hasUpper
+  hasUpper := false
+  for i := 0; i < len(s); i++ {
+    ch := s[i]
+    switch {
+    case ch >= 'A' && ch <= 'Z':
+      hasUpper = true
+    case ch >= '0' && ch <= '9':
+    case ch == '_':
+    default:
+      return false
+    }
+  }
+  return hasUpper
 }
 
 func init() {
-	Register(camelcase{})
+  Register(camelcase{})
 }

package/linthost/rules_complexity.go

@@ -11,6 +11,7 @@
 //   - `catch` clauses on `try`,
 //   - ternary (`?:`) expressions,
 //   - short-circuit operators `&&`, `||`, `??`.
+//
 // Nested function-likes start their own complexity counter and are
 // visited independently, so an inner closure's branches do not
 // inflate the outer function's score.
@@ -18,9 +19,9 @@
 package linthost
 
 import (
-	"fmt"
+  "fmt"
 
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 // complexityLimit is the cyclomatic-complexity ceiling. Above this
@@ -31,64 +32,64 @@ type complexity struct{}
 
 func (complexity) Name() string { return "complexity" }
 func (complexity) Visits() []shimast.Kind {
-	return []shimast.Kind{
-		shimast.KindFunctionDeclaration,
-		shimast.KindFunctionExpression,
-		shimast.KindArrowFunction,
-		shimast.KindMethodDeclaration,
-		shimast.KindGetAccessor,
-		shimast.KindSetAccessor,
-		shimast.KindConstructor,
-	}
+  return []shimast.Kind{
+    shimast.KindFunctionDeclaration,
+    shimast.KindFunctionExpression,
+    shimast.KindArrowFunction,
+    shimast.KindMethodDeclaration,
+    shimast.KindGetAccessor,
+    shimast.KindSetAccessor,
+    shimast.KindConstructor,
+  }
 }
 func (complexity) Check(ctx *Context, node *shimast.Node) {
-	if node == nil {
-		return
-	}
-	body := node.Body()
-	if body == nil || body.Kind != shimast.KindBlock {
-		return
-	}
-	score := 1
-	walkComplexityBody(body, node, &score)
-	if score > complexityLimit {
-		ctx.Report(node, fmt.Sprintf("Function has a complexity of %d. Maximum allowed is %d.", score, complexityLimit))
-	}
+  if node == nil {
+    return
+  }
+  body := node.Body()
+  if body == nil || body.Kind != shimast.KindBlock {
+    return
+  }
+  score := 1
+  walkComplexityBody(body, node, &score)
+  if score > complexityLimit {
+    ctx.Report(node, fmt.Sprintf("Function has a complexity of %d. Maximum allowed is %d.", score, complexityLimit))
+  }
 }
 
 // walkComplexityBody descends through `root` adding 1 to `score` at
 // every branching construct without crossing nested function-like
 // scopes. Each nested function is left for its own visit.
 func walkComplexityBody(node *shimast.Node, fn *shimast.Node, score *int) {
-	if node == nil {
-		return
-	}
-	if node != fn && isFunctionLikeKind(node) {
-		return
-	}
-	switch node.Kind {
-	case shimast.KindIfStatement,
-		shimast.KindCaseClause,
-		shimast.KindCatchClause,
-		shimast.KindConditionalExpression:
-		*score++
-	case shimast.KindBinaryExpression:
-		bin := node.AsBinaryExpression()
-		if bin != nil && bin.OperatorToken != nil {
-			switch bin.OperatorToken.Kind {
-			case shimast.KindAmpersandAmpersandToken,
-				shimast.KindBarBarToken,
-				shimast.KindQuestionQuestionToken:
-				*score++
-			}
-		}
-	}
-	node.ForEachChild(func(child *shimast.Node) bool {
-		walkComplexityBody(child, fn, score)
-		return false
-	})
+  if node == nil {
+    return
+  }
+  if node != fn && isFunctionLikeKind(node) {
+    return
+  }
+  switch node.Kind {
+  case shimast.KindIfStatement,
+    shimast.KindCaseClause,
+    shimast.KindCatchClause,
+    shimast.KindConditionalExpression:
+    *score++
+  case shimast.KindBinaryExpression:
+    bin := node.AsBinaryExpression()
+    if bin != nil && bin.OperatorToken != nil {
+      switch bin.OperatorToken.Kind {
+      case shimast.KindAmpersandAmpersandToken,
+        shimast.KindBarBarToken,
+        shimast.KindQuestionQuestionToken:
+        *score++
+      }
+    }
+  }
+  node.ForEachChild(func(child *shimast.Node) bool {
+    walkComplexityBody(child, fn, score)
+    return false
+  })
 }
 
 func init() {
-	Register(complexity{})
+  Register(complexity{})
 }

package/linthost/rules_consistent_return.go

@@ -22,70 +22,70 @@ type consistentReturn struct{}
 
 func (consistentReturn) Name() string { return "consistent-return" }
 func (consistentReturn) Visits() []shimast.Kind {
-	return []shimast.Kind{
-		shimast.KindFunctionDeclaration,
-		shimast.KindFunctionExpression,
-		shimast.KindArrowFunction,
-		shimast.KindMethodDeclaration,
-		shimast.KindGetAccessor,
-		shimast.KindSetAccessor,
-	}
+  return []shimast.Kind{
+    shimast.KindFunctionDeclaration,
+    shimast.KindFunctionExpression,
+    shimast.KindArrowFunction,
+    shimast.KindMethodDeclaration,
+    shimast.KindGetAccessor,
+    shimast.KindSetAccessor,
+  }
 }
 func (consistentReturn) Check(ctx *Context, node *shimast.Node) {
-	body := node.Body()
-	if body == nil || body.Kind != shimast.KindBlock {
-		return
-	}
-	withValue := false
-	withoutValue := false
-	walkConsistentReturnBody(body, func(ret *shimast.Node) {
-		stmt := ret.AsReturnStatement()
-		if stmt == nil {
-			return
-		}
-		if stmt.Expression != nil {
-			withValue = true
-		} else {
-			withoutValue = true
-		}
-	})
-	if withValue && withoutValue {
-		ctx.Report(node, "Function expected to either always or never specify a return value.")
-		return
-	}
-	// A function that returns a value on at least one path but can
-	// also fall through the end of its block leaks an implicit
-	// `undefined`. Flag it the same as the explicit mix above.
-	if withValue && !blockAlwaysExits(body) {
-		ctx.Report(node, "Function expected to either always or never specify a return value.")
-	}
+  body := node.Body()
+  if body == nil || body.Kind != shimast.KindBlock {
+    return
+  }
+  withValue := false
+  withoutValue := false
+  walkConsistentReturnBody(body, func(ret *shimast.Node) {
+    stmt := ret.AsReturnStatement()
+    if stmt == nil {
+      return
+    }
+    if stmt.Expression != nil {
+      withValue = true
+    } else {
+      withoutValue = true
+    }
+  })
+  if withValue && withoutValue {
+    ctx.Report(node, "Function expected to either always or never specify a return value.")
+    return
+  }
+  // A function that returns a value on at least one path but can
+  // also fall through the end of its block leaks an implicit
+  // `undefined`. Flag it the same as the explicit mix above.
+  if withValue && !blockAlwaysExits(body) {
+    ctx.Report(node, "Function expected to either always or never specify a return value.")
+  }
 }
 
 // walkConsistentReturnBody visits every `return` statement inside
 // `root` without crossing nested function-like scopes. Nested
 // function-likes report their own returns through their own visit.
 func walkConsistentReturnBody(root *shimast.Node, visit func(*shimast.Node)) {
-	if root == nil {
-		return
-	}
-	var walk func(*shimast.Node)
-	walk = func(n *shimast.Node) {
-		if n == nil {
-			return
-		}
-		if n != root && isFunctionLikeKind(n) {
-			return
-		}
-		if n.Kind == shimast.KindReturnStatement {
-			visit(n)
-			return
-		}
-		n.ForEachChild(func(child *shimast.Node) bool {
-			walk(child)
-			return false
-		})
-	}
-	walk(root)
+  if root == nil {
+    return
+  }
+  var walk func(*shimast.Node)
+  walk = func(n *shimast.Node) {
+    if n == nil {
+      return
+    }
+    if n != root && isFunctionLikeKind(n) {
+      return
+    }
+    if n.Kind == shimast.KindReturnStatement {
+      visit(n)
+      return
+    }
+    n.ForEachChild(func(child *shimast.Node) bool {
+      walk(child)
+      return false
+    })
+  }
+  walk(root)
 }
 
 // blockAlwaysExits reports whether a function-body block can never
@@ -93,38 +93,38 @@ func walkConsistentReturnBody(root *shimast.Node, visit func(*shimast.Node)) {
 // `throw`, or a nested block / `if` whose branches all terminate.
 // Mirrors the shallow approximation `getter-return` uses.
 func blockAlwaysExits(body *shimast.Node) bool {
-	if body == nil || body.Kind != shimast.KindBlock {
-		return false
-	}
-	stmts := body.Statements()
-	if len(stmts) == 0 {
-		return false
-	}
-	return statementAlwaysExits(stmts[len(stmts)-1])
+  if body == nil || body.Kind != shimast.KindBlock {
+    return false
+  }
+  stmts := body.Statements()
+  if len(stmts) == 0 {
+    return false
+  }
+  return statementAlwaysExits(stmts[len(stmts)-1])
 }
 
 // statementAlwaysExits reports whether `stmt` cannot fall through to
 // the next statement: a `return`, a `throw`, a block ending in either
 // of those, or an `if` whose branches both terminate.
 func statementAlwaysExits(stmt *shimast.Node) bool {
-	if stmt == nil {
-		return false
-	}
-	switch stmt.Kind {
-	case shimast.KindReturnStatement, shimast.KindThrowStatement:
-		return true
-	case shimast.KindBlock:
-		return blockAlwaysExits(stmt)
-	case shimast.KindIfStatement:
-		ifStmt := stmt.AsIfStatement()
-		if ifStmt == nil || ifStmt.ThenStatement == nil || ifStmt.ElseStatement == nil {
-			return false
-		}
-		return statementAlwaysExits(ifStmt.ThenStatement) && statementAlwaysExits(ifStmt.ElseStatement)
-	}
-	return false
+  if stmt == nil {
+    return false
+  }
+  switch stmt.Kind {
+  case shimast.KindReturnStatement, shimast.KindThrowStatement:
+    return true
+  case shimast.KindBlock:
+    return blockAlwaysExits(stmt)
+  case shimast.KindIfStatement:
+    ifStmt := stmt.AsIfStatement()
+    if ifStmt == nil || ifStmt.ThenStatement == nil || ifStmt.ElseStatement == nil {
+      return false
+    }
+    return statementAlwaysExits(ifStmt.ThenStatement) && statementAlwaysExits(ifStmt.ElseStatement)
+  }
+  return false
 }
 
 func init() {
-	Register(consistentReturn{})
+  Register(consistentReturn{})
 }