@ttsc/lint 0.14.0-dev.20260529.2 → 0.14.1

package/linthost/rules_unicorn_expiring_todo_comments.go

@@ -18,11 +18,11 @@
 package linthost
 
 import (
-	"regexp"
-	"strings"
+  "regexp"
+  "strings"
 
-	shimast "github.com/microsoft/typescript-go/shim/ast"
-	shimscanner "github.com/microsoft/typescript-go/shim/scanner"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimscanner "github.com/microsoft/typescript-go/shim/scanner"
 )
 
 // unicornExpiringTodoCommentsKeywordPattern matches a TODO-family
@@ -38,41 +38,41 @@ type unicornExpiringTodoComments struct{}
 
 func (unicornExpiringTodoComments) Name() string { return "unicorn/expiring-todo-comments" }
 func (unicornExpiringTodoComments) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindSourceFile}
+  return []shimast.Kind{shimast.KindSourceFile}
 }
 func (unicornExpiringTodoComments) Check(ctx *Context, node *shimast.Node) {
-	if ctx.File == nil {
-		return
-	}
-	src := ctx.File.Text()
-	scanner := shimscanner.NewScanner()
-	scanner.SetText(src)
-	scanner.SetSkipTrivia(false)
-	for {
-		kind := scanner.Scan()
-		if kind == shimast.KindEndOfFile {
-			break
-		}
-		if kind != shimast.KindSingleLineCommentTrivia && kind != shimast.KindMultiLineCommentTrivia {
-			continue
-		}
-		start := scanner.TokenStart()
-		end := scanner.TokenEnd()
-		if start < 0 || end > len(src) || end <= start {
-			continue
-		}
-		body := stripCommentDelimiters(src[start:end])
-		match := unicornExpiringTodoCommentsKeywordPattern.FindStringIndex(body)
-		if match == nil {
-			continue
-		}
-		if strings.Contains(body[match[1]:], "[") {
-			continue
-		}
-		ctx.ReportRange(start, end, "Add an expiration condition to this TODO (e.g., `[2027-01-01]` or `[npm:foo@>=2]`).")
-	}
+  if ctx.File == nil {
+    return
+  }
+  src := ctx.File.Text()
+  scanner := shimscanner.NewScanner()
+  scanner.SetText(src)
+  scanner.SetSkipTrivia(false)
+  for {
+    kind := scanner.Scan()
+    if kind == shimast.KindEndOfFile {
+      break
+    }
+    if kind != shimast.KindSingleLineCommentTrivia && kind != shimast.KindMultiLineCommentTrivia {
+      continue
+    }
+    start := scanner.TokenStart()
+    end := scanner.TokenEnd()
+    if start < 0 || end > len(src) || end <= start {
+      continue
+    }
+    body := stripCommentDelimiters(src[start:end])
+    match := unicornExpiringTodoCommentsKeywordPattern.FindStringIndex(body)
+    if match == nil {
+      continue
+    }
+    if strings.Contains(body[match[1]:], "[") {
+      continue
+    }
+    ctx.ReportRange(start, end, "Add an expiration condition to this TODO (e.g., `[2027-01-01]` or `[npm:foo@>=2]`).")
+  }
 }
 
 func init() {
-	Register(unicornExpiringTodoComments{})
+  Register(unicornExpiringTodoComments{})
 }

package/linthost/rules_unicorn_explicit_length_check.go

@@ -22,21 +22,21 @@ type unicornExplicitLengthCheck struct{}
 
 func (unicornExplicitLengthCheck) Name() string { return "unicorn/explicit-length-check" }
 func (unicornExplicitLengthCheck) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindPropertyAccessExpression}
+  return []shimast.Kind{shimast.KindPropertyAccessExpression}
 }
 func (unicornExplicitLengthCheck) Check(ctx *Context, node *shimast.Node) {
-	access := node.AsPropertyAccessExpression()
-	if access == nil {
-		return
-	}
-	name := identifierText(access.Name())
-	if name != "length" && name != "size" {
-		return
-	}
-	if !unicornExplicitLengthCheckIsBooleanContext(node) {
-		return
-	}
-	ctx.Report(node, "Use an explicit comparison (`.length > 0` or `.length === 0`) instead of truthy coercion.")
+  access := node.AsPropertyAccessExpression()
+  if access == nil {
+    return
+  }
+  name := identifierText(access.Name())
+  if name != "length" && name != "size" {
+    return
+  }
+  if !unicornExplicitLengthCheckIsBooleanContext(node) {
+    return
+  }
+  ctx.Report(node, "Use an explicit comparison (`.length > 0` or `.length === 0`) instead of truthy coercion.")
 }
 
 // unicornExplicitLengthCheckIsBooleanContext walks the parent chain to
@@ -44,45 +44,45 @@ func (unicornExplicitLengthCheck) Check(ctx *Context, node *shimast.Node) {
 // position of a control-flow statement / ternary, the operand of `!`,
 // or one side of a logical (`&&` / `||` / `??`) chain.
 func unicornExplicitLengthCheckIsBooleanContext(node *shimast.Node) bool {
-	cur := node
-	for cur != nil && cur.Parent != nil && cur.Parent.Kind == shimast.KindParenthesizedExpression {
-		cur = cur.Parent
-	}
-	if cur == nil {
-		return false
-	}
-	parent := cur.Parent
-	if parent == nil {
-		return false
-	}
-	switch parent.Kind {
-	case shimast.KindIfStatement:
-		return parent.AsIfStatement().Expression == cur
-	case shimast.KindWhileStatement:
-		return parent.AsWhileStatement().Expression == cur
-	case shimast.KindDoStatement:
-		return parent.AsDoStatement().Expression == cur
-	case shimast.KindForStatement:
-		return parent.AsForStatement().Condition == cur
-	case shimast.KindConditionalExpression:
-		return parent.AsConditionalExpression().Condition == cur
-	case shimast.KindPrefixUnaryExpression:
-		return parent.AsPrefixUnaryExpression().Operator == shimast.KindExclamationToken
-	case shimast.KindBinaryExpression:
-		bin := parent.AsBinaryExpression()
-		if bin == nil || bin.OperatorToken == nil {
-			return false
-		}
-		switch bin.OperatorToken.Kind {
-		case shimast.KindAmpersandAmpersandToken,
-			shimast.KindBarBarToken,
-			shimast.KindQuestionQuestionToken:
-			return true
-		}
-	}
-	return false
+  cur := node
+  for cur != nil && cur.Parent != nil && cur.Parent.Kind == shimast.KindParenthesizedExpression {
+    cur = cur.Parent
+  }
+  if cur == nil {
+    return false
+  }
+  parent := cur.Parent
+  if parent == nil {
+    return false
+  }
+  switch parent.Kind {
+  case shimast.KindIfStatement:
+    return parent.AsIfStatement().Expression == cur
+  case shimast.KindWhileStatement:
+    return parent.AsWhileStatement().Expression == cur
+  case shimast.KindDoStatement:
+    return parent.AsDoStatement().Expression == cur
+  case shimast.KindForStatement:
+    return parent.AsForStatement().Condition == cur
+  case shimast.KindConditionalExpression:
+    return parent.AsConditionalExpression().Condition == cur
+  case shimast.KindPrefixUnaryExpression:
+    return parent.AsPrefixUnaryExpression().Operator == shimast.KindExclamationToken
+  case shimast.KindBinaryExpression:
+    bin := parent.AsBinaryExpression()
+    if bin == nil || bin.OperatorToken == nil {
+      return false
+    }
+    switch bin.OperatorToken.Kind {
+    case shimast.KindAmpersandAmpersandToken,
+      shimast.KindBarBarToken,
+      shimast.KindQuestionQuestionToken:
+      return true
+    }
+  }
+  return false
 }
 
 func init() {
-	Register(unicornExplicitLengthCheck{})
+  Register(unicornExplicitLengthCheck{})
 }

package/linthost/rules_unicorn_filename_case.go

@@ -25,5 +25,5 @@ func (unicornFilenameCase) Check(_ *Context, _ *shimast.Node) {
 }
 
 func init() {
-	Register(unicornFilenameCase{})
+  Register(unicornFilenameCase{})
 }

package/linthost/rules_unicorn_import_style.go

@@ -24,5 +24,5 @@ func (unicornImportStyle) Check(_ *Context, _ *shimast.Node) {
 }
 
 func init() {
-	Register(unicornImportStyle{})
+  Register(unicornImportStyle{})
 }

package/linthost/rules_unicorn_isolated_functions.go

@@ -19,11 +19,11 @@ type unicornIsolatedFunctions struct{}
 
 func (unicornIsolatedFunctions) Name() string { return "unicorn/isolated-functions" }
 func (unicornIsolatedFunctions) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindSourceFile}
+  return []shimast.Kind{shimast.KindSourceFile}
 }
 func (unicornIsolatedFunctions) Check(_ *Context, _ *shimast.Node) {
 }
 
 func init() {
-	Register(unicornIsolatedFunctions{})
+  Register(unicornIsolatedFunctions{})
 }

package/linthost/rules_unicorn_new_for_builtins.go

@@ -18,70 +18,70 @@ import shimast "github.com/microsoft/typescript-go/shim/ast"
 
 // Primitive wrappers — `new` is wrong, call form is required.
 var unicornNewForBuiltinsPrimitiveWrappers = map[string]struct{}{
-	"String":  {},
-	"Number":  {},
-	"Boolean": {},
-	"Symbol":  {},
-	"BigInt":  {},
+  "String":  {},
+  "Number":  {},
+  "Boolean": {},
+  "Symbol":  {},
+  "BigInt":  {},
 }
 
 // Container constructors — `new` is required, call form is wrong. Note
 // that `Symbol` is intentionally NOT in this list: `Symbol(...)` is the
 // correct primitive-wrapper call and must not be flagged.
 var unicornNewForBuiltinsContainers = map[string]struct{}{
-	"Array":          {},
-	"Error":          {},
-	"EvalError":      {},
-	"RangeError":     {},
-	"ReferenceError": {},
-	"SyntaxError":    {},
-	"TypeError":      {},
-	"URIError":       {},
-	"AggregateError": {},
-	"Object":         {},
-	"Map":            {},
-	"Set":            {},
-	"WeakMap":        {},
-	"WeakSet":        {},
-	"Date":           {},
-	"RegExp":         {},
+  "Array":          {},
+  "Error":          {},
+  "EvalError":      {},
+  "RangeError":     {},
+  "ReferenceError": {},
+  "SyntaxError":    {},
+  "TypeError":      {},
+  "URIError":       {},
+  "AggregateError": {},
+  "Object":         {},
+  "Map":            {},
+  "Set":            {},
+  "WeakMap":        {},
+  "WeakSet":        {},
+  "Date":           {},
+  "RegExp":         {},
 }
 
 type unicornNewForBuiltins struct{}
 
 func (unicornNewForBuiltins) Name() string { return "unicorn/new-for-builtins" }
 func (unicornNewForBuiltins) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindNewExpression, shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindNewExpression, shimast.KindCallExpression}
 }
 func (unicornNewForBuiltins) Check(ctx *Context, node *shimast.Node) {
-	switch node.Kind {
-	case shimast.KindNewExpression:
-		ne := node.AsNewExpression()
-		if ne == nil {
-			return
-		}
-		name := identifierText(ne.Expression)
-		if name == "" {
-			return
-		}
-		if _, ok := unicornNewForBuiltinsPrimitiveWrappers[name]; ok {
-			ctx.Report(node, "Don't use `new "+name+"(...)` with a primitive wrapper like `"+name+"`.")
-		}
-	case shimast.KindCallExpression:
-		call := node.AsCallExpression()
-		if call == nil {
-			return
-		}
-		name := identifierText(call.Expression)
-		if name == "" {
-			return
-		}
-		if _, ok := unicornNewForBuiltinsContainers[name]; ok {
-			ctx.Report(node, "Use `new "+name+"(...)` instead of `"+name+"(...)`.")
-		}
-	}
+  switch node.Kind {
+  case shimast.KindNewExpression:
+    ne := node.AsNewExpression()
+    if ne == nil {
+      return
+    }
+    name := identifierText(ne.Expression)
+    if name == "" {
+      return
+    }
+    if _, ok := unicornNewForBuiltinsPrimitiveWrappers[name]; ok {
+      ctx.Report(node, "Don't use `new "+name+"(...)` with a primitive wrapper like `"+name+"`.")
+    }
+  case shimast.KindCallExpression:
+    call := node.AsCallExpression()
+    if call == nil {
+      return
+    }
+    name := identifierText(call.Expression)
+    if name == "" {
+      return
+    }
+    if _, ok := unicornNewForBuiltinsContainers[name]; ok {
+      ctx.Report(node, "Use `new "+name+"(...)` instead of `"+name+"(...)`.")
+    }
+  }
 }
 
 func init() {
-	Register(unicornNewForBuiltins{})
+  Register(unicornNewForBuiltins{})
 }

package/linthost/rules_unicorn_no_abusive_eslint_disable.go

@@ -15,10 +15,10 @@
 package linthost
 
 import (
-	"regexp"
+  "regexp"
 
-	shimast "github.com/microsoft/typescript-go/shim/ast"
-	shimscanner "github.com/microsoft/typescript-go/shim/scanner"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimscanner "github.com/microsoft/typescript-go/shim/scanner"
 )
 
 var unicornNoAbusiveEslintDisablePattern = regexp.MustCompile(`^eslint-disable(?:-next-line|-line)?$`)
@@ -27,37 +27,37 @@ type unicornNoAbusiveEslintDisable struct{}
 
 func (unicornNoAbusiveEslintDisable) Name() string { return "unicorn/no-abusive-eslint-disable" }
 func (unicornNoAbusiveEslintDisable) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindSourceFile}
+  return []shimast.Kind{shimast.KindSourceFile}
 }
 func (unicornNoAbusiveEslintDisable) Check(ctx *Context, node *shimast.Node) {
-	if ctx.File == nil {
-		return
-	}
-	src := ctx.File.Text()
-	scanner := shimscanner.NewScanner()
-	scanner.SetText(src)
-	scanner.SetSkipTrivia(false)
-	for {
-		kind := scanner.Scan()
-		if kind == shimast.KindEndOfFile {
-			break
-		}
-		if kind != shimast.KindSingleLineCommentTrivia && kind != shimast.KindMultiLineCommentTrivia {
-			continue
-		}
-		start := scanner.TokenStart()
-		end := scanner.TokenEnd()
-		if start < 0 || end > len(src) || end <= start {
-			continue
-		}
-		body := stripCommentDelimiters(src[start:end])
-		if !unicornNoAbusiveEslintDisablePattern.MatchString(body) {
-			continue
-		}
-		ctx.ReportRange(start, end, "Specify the rules to disable in each `eslint-disable*` directive.")
-	}
+  if ctx.File == nil {
+    return
+  }
+  src := ctx.File.Text()
+  scanner := shimscanner.NewScanner()
+  scanner.SetText(src)
+  scanner.SetSkipTrivia(false)
+  for {
+    kind := scanner.Scan()
+    if kind == shimast.KindEndOfFile {
+      break
+    }
+    if kind != shimast.KindSingleLineCommentTrivia && kind != shimast.KindMultiLineCommentTrivia {
+      continue
+    }
+    start := scanner.TokenStart()
+    end := scanner.TokenEnd()
+    if start < 0 || end > len(src) || end <= start {
+      continue
+    }
+    body := stripCommentDelimiters(src[start:end])
+    if !unicornNoAbusiveEslintDisablePattern.MatchString(body) {
+      continue
+    }
+    ctx.ReportRange(start, end, "Specify the rules to disable in each `eslint-disable*` directive.")
+  }
 }
 
 func init() {
-	Register(unicornNoAbusiveEslintDisable{})
+  Register(unicornNoAbusiveEslintDisable{})
 }

package/linthost/rules_unicorn_no_accessor_recursion.go

@@ -17,42 +17,42 @@
 package linthost
 
 import (
-	"fmt"
+  "fmt"
 
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 type unicornNoAccessorRecursion struct{}
 
 func (unicornNoAccessorRecursion) Name() string { return "unicorn/no-accessor-recursion" }
 func (unicornNoAccessorRecursion) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindGetAccessor, shimast.KindSetAccessor}
+  return []shimast.Kind{shimast.KindGetAccessor, shimast.KindSetAccessor}
 }
 func (unicornNoAccessorRecursion) Check(ctx *Context, node *shimast.Node) {
-	name := unicornAccessorRecursionName(node)
-	if name == "" {
-		return
-	}
-	body := node.Body()
-	if body == nil {
-		return
-	}
-	unicornAccessorRecursionWalkRespectingThisBoundary(body, func(child *shimast.Node) {
-		if child == nil || child.Kind != shimast.KindPropertyAccessExpression {
-			return
-		}
-		access := child.AsPropertyAccessExpression()
-		if access == nil || access.Expression == nil {
-			return
-		}
-		if access.Expression.Kind != shimast.KindThisKeyword {
-			return
-		}
-		if identifierText(access.Name()) != name {
-			return
-		}
-		ctx.Report(child, fmt.Sprintf("Reading `this.%s` inside the `%s` accessor recurses forever.", name, name))
-	})
+  name := unicornAccessorRecursionName(node)
+  if name == "" {
+    return
+  }
+  body := node.Body()
+  if body == nil {
+    return
+  }
+  unicornAccessorRecursionWalkRespectingThisBoundary(body, func(child *shimast.Node) {
+    if child == nil || child.Kind != shimast.KindPropertyAccessExpression {
+      return
+    }
+    access := child.AsPropertyAccessExpression()
+    if access == nil || access.Expression == nil {
+      return
+    }
+    if access.Expression.Kind != shimast.KindThisKeyword {
+      return
+    }
+    if identifierText(access.Name()) != name {
+      return
+    }
+    ctx.Report(child, fmt.Sprintf("Reading `this.%s` inside the `%s` accessor recurses forever.", name, name))
+  })
 }
 
 // unicornAccessorRecursionWalkRespectingThisBoundary walks `node` and
@@ -60,26 +60,26 @@ func (unicornNoAccessorRecursion) Check(ctx *Context, node *shimast.Node) {
 // rebind `this`. Arrow functions are walked through because they
 // capture the outer `this`.
 func unicornAccessorRecursionWalkRespectingThisBoundary(node *shimast.Node, visit func(*shimast.Node)) {
-	if node == nil {
-		return
-	}
-	visit(node)
-	node.ForEachChild(func(child *shimast.Node) bool {
-		if child == nil {
-			return false
-		}
-		switch child.Kind {
-		case shimast.KindFunctionDeclaration,
-			shimast.KindFunctionExpression,
-			shimast.KindMethodDeclaration,
-			shimast.KindGetAccessor,
-			shimast.KindSetAccessor,
-			shimast.KindConstructor:
-			return false
-		}
-		unicornAccessorRecursionWalkRespectingThisBoundary(child, visit)
-		return false
-	})
+  if node == nil {
+    return
+  }
+  visit(node)
+  node.ForEachChild(func(child *shimast.Node) bool {
+    if child == nil {
+      return false
+    }
+    switch child.Kind {
+    case shimast.KindFunctionDeclaration,
+      shimast.KindFunctionExpression,
+      shimast.KindMethodDeclaration,
+      shimast.KindGetAccessor,
+      shimast.KindSetAccessor,
+      shimast.KindConstructor:
+      return false
+    }
+    unicornAccessorRecursionWalkRespectingThisBoundary(child, visit)
+    return false
+  })
 }
 
 // unicornAccessorRecursionName returns the property name of a
@@ -87,29 +87,29 @@ func unicornAccessorRecursionWalkRespectingThisBoundary(node *shimast.Node, visi
 // names are supported because computed names cannot be matched against
 // the `this.<X>` shape statically.
 func unicornAccessorRecursionName(node *shimast.Node) string {
-	var name *shimast.Node
-	switch node.Kind {
-	case shimast.KindGetAccessor:
-		if g := node.AsGetAccessorDeclaration(); g != nil {
-			name = g.Name()
-		}
-	case shimast.KindSetAccessor:
-		if s := node.AsSetAccessorDeclaration(); s != nil {
-			name = s.Name()
-		}
-	}
-	if name == nil {
-		return ""
-	}
-	switch name.Kind {
-	case shimast.KindIdentifier:
-		return identifierText(name)
-	case shimast.KindStringLiteral:
-		return stringLiteralText(name)
-	}
-	return ""
+  var name *shimast.Node
+  switch node.Kind {
+  case shimast.KindGetAccessor:
+    if g := node.AsGetAccessorDeclaration(); g != nil {
+      name = g.Name()
+    }
+  case shimast.KindSetAccessor:
+    if s := node.AsSetAccessorDeclaration(); s != nil {
+      name = s.Name()
+    }
+  }
+  if name == nil {
+    return ""
+  }
+  switch name.Kind {
+  case shimast.KindIdentifier:
+    return identifierText(name)
+  case shimast.KindStringLiteral:
+    return stringLiteralText(name)
+  }
+  return ""
 }
 
 func init() {
-	Register(unicornNoAccessorRecursion{})
+  Register(unicornNoAccessorRecursion{})
 }