@ttsc/lint 0.14.0-dev.20260529.2 → 0.14.0

package/linthost/rules_ts_unbound_method.go

@@ -23,37 +23,37 @@
 package linthost
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 type unboundMethod struct{}
 
 func (unboundMethod) Name() string { return "typescript/unbound-method" }
 func (unboundMethod) NeedsTypeChecker() bool {
-	return true
+  return true
 }
 func (unboundMethod) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindPropertyAccessExpression}
+  return []shimast.Kind{shimast.KindPropertyAccessExpression}
 }
 func (unboundMethod) Check(ctx *Context, node *shimast.Node) {
-	if ctx.Checker == nil {
-		return
-	}
-	access := node.AsPropertyAccessExpression()
-	if access == nil || access.Name() == nil {
-		return
-	}
-	if unboundMethodSafePosition(node) {
-		return
-	}
-	symbol := ctx.Checker.GetSymbolAtLocation(access.Name())
-	if symbol == nil {
-		return
-	}
-	if !unboundMethodSymbolIsClassMethod(symbol) {
-		return
-	}
-	ctx.Report(node, "Avoid referencing an unbound method which may cause unintentional scoping of `this`.")
+  if ctx.Checker == nil {
+    return
+  }
+  access := node.AsPropertyAccessExpression()
+  if access == nil || access.Name() == nil {
+    return
+  }
+  if unboundMethodSafePosition(node) {
+    return
+  }
+  symbol := ctx.Checker.GetSymbolAtLocation(access.Name())
+  if symbol == nil {
+    return
+  }
+  if !unboundMethodSymbolIsClassMethod(symbol) {
+    return
+  }
+  ctx.Report(node, "Avoid referencing an unbound method which may cause unintentional scoping of `this`.")
 }
 
 // unboundMethodSafePosition reports whether the property access sits in
@@ -64,33 +64,33 @@ func (unboundMethod) Check(ctx *Context, node *shimast.Node) {
 // all positions where the method reference is consumed in place rather
 // than carried away as a free function value.
 func unboundMethodSafePosition(node *shimast.Node) bool {
-	parent := node.Parent
-	if parent == nil {
-		return false
-	}
-	switch parent.Kind {
-	case shimast.KindCallExpression:
-		call := parent.AsCallExpression()
-		if call != nil && call.Expression == node {
-			return true
-		}
-	case shimast.KindTaggedTemplateExpression:
-		return true
-	case shimast.KindBinaryExpression:
-		bin := parent.AsBinaryExpression()
-		if bin == nil || bin.OperatorToken == nil {
-			return false
-		}
-		switch bin.OperatorToken.Kind {
-		case shimast.KindEqualsToken,
-			shimast.KindInstanceOfKeyword,
-			shimast.KindInKeyword:
-			return true
-		}
-	case shimast.KindTypeOfExpression, shimast.KindDeleteExpression:
-		return true
-	}
-	return false
+  parent := node.Parent
+  if parent == nil {
+    return false
+  }
+  switch parent.Kind {
+  case shimast.KindCallExpression:
+    call := parent.AsCallExpression()
+    if call != nil && call.Expression == node {
+      return true
+    }
+  case shimast.KindTaggedTemplateExpression:
+    return true
+  case shimast.KindBinaryExpression:
+    bin := parent.AsBinaryExpression()
+    if bin == nil || bin.OperatorToken == nil {
+      return false
+    }
+    switch bin.OperatorToken.Kind {
+    case shimast.KindEqualsToken,
+      shimast.KindInstanceOfKeyword,
+      shimast.KindInKeyword:
+      return true
+    }
+  case shimast.KindTypeOfExpression, shimast.KindDeleteExpression:
+    return true
+  }
+  return false
 }
 
 // unboundMethodSymbolIsClassMethod reports whether symbol denotes a
@@ -103,24 +103,24 @@ func unboundMethodSafePosition(node *shimast.Node) bool {
 // constructor itself, which is bound for the lifetime of the
 // program.
 func unboundMethodSymbolIsClassMethod(symbol *shimast.Symbol) bool {
-	if symbol == nil {
-		return false
-	}
-	for _, decl := range symbol.Declarations {
-		if decl == nil {
-			continue
-		}
-		if decl.Kind != shimast.KindMethodDeclaration {
-			continue
-		}
-		if hasModifier(decl, shimast.KindStaticKeyword) {
-			continue
-		}
-		return true
-	}
-	return false
+  if symbol == nil {
+    return false
+  }
+  for _, decl := range symbol.Declarations {
+    if decl == nil {
+      continue
+    }
+    if decl.Kind != shimast.KindMethodDeclaration {
+      continue
+    }
+    if hasModifier(decl, shimast.KindStaticKeyword) {
+      continue
+    }
+    return true
+  }
+  return false
 }
 
 func init() {
-	Register(unboundMethod{})
+  Register(unboundMethod{})
 }

package/linthost/rules_tsdoc.go

@@ -12,125 +12,125 @@ func (tsdocSyntax) Name() string           { return "jsdoc/tsdoc-syntax" }
 func (tsdocSyntax) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindSourceFile} }
 
 func (tsdocSyntax) Check(ctx *Context, node *shimast.Node) {
-	if ctx == nil || ctx.File == nil {
-		return
-	}
-	src := ctx.File.Text()
-	for _, block := range findJSDocBlocks(src) {
-		checkTSDocBlockTags(ctx, src, block)
-		checkTSDocInlineTags(ctx, src, block)
-	}
+  if ctx == nil || ctx.File == nil {
+    return
+  }
+  src := ctx.File.Text()
+  for _, block := range findJSDocBlocks(src) {
+    checkTSDocBlockTags(ctx, src, block)
+    checkTSDocInlineTags(ctx, src, block)
+  }
 }
 
 func checkTSDocBlockTags(ctx *Context, src string, block jsdocBlock) {
-	walkJSDocLines(src, block, func(contentStart, lineEnd int, inFence bool) {
-		if inFence || contentStart >= lineEnd || src[contentStart] != '@' {
-			return
-		}
-		tagStart := contentStart + 1
-		if tagStart >= lineEnd || !isTSDocTagStart(src[tagStart]) {
-			ctx.ReportRange(contentStart, minInt(lineEnd, contentStart+2), "Malformed TSDoc block tag.")
-		}
-	})
+  walkJSDocLines(src, block, func(contentStart, lineEnd int, inFence bool) {
+    if inFence || contentStart >= lineEnd || src[contentStart] != '@' {
+      return
+    }
+    tagStart := contentStart + 1
+    if tagStart >= lineEnd || !isTSDocTagStart(src[tagStart]) {
+      ctx.ReportRange(contentStart, minInt(lineEnd, contentStart+2), "Malformed TSDoc block tag.")
+    }
+  })
 }
 
 func checkTSDocInlineTags(ctx *Context, src string, block jsdocBlock) {
-	walkJSDocLines(src, block, func(contentStart, lineEnd int, inFence bool) {
-		if inFence {
-			return
-		}
-		for i := contentStart; i+1 < lineEnd; i++ {
-			if src[i] != '{' || src[i+1] != '@' {
-				continue
-			}
-			tagStart := i + 2
-			if tagStart >= lineEnd || !isTSDocTagStart(src[tagStart]) {
-				ctx.ReportRange(i, minInt(lineEnd, i+2), "Malformed TSDoc inline tag.")
-				continue
-			}
-			tagEnd := tagStart + 1
-			for tagEnd < lineEnd && isTSDocTagContinue(src[tagEnd]) {
-				tagEnd++
-			}
-			close := findByteInRange(src, '}', tagEnd, block.bodyEnd)
-			if close < 0 {
-				ctx.ReportRange(i, tagEnd, "Unclosed TSDoc inline tag.")
-				i = tagEnd - 1
-				continue
-			}
-			i = close
-		}
-	})
+  walkJSDocLines(src, block, func(contentStart, lineEnd int, inFence bool) {
+    if inFence {
+      return
+    }
+    for i := contentStart; i+1 < lineEnd; i++ {
+      if src[i] != '{' || src[i+1] != '@' {
+        continue
+      }
+      tagStart := i + 2
+      if tagStart >= lineEnd || !isTSDocTagStart(src[tagStart]) {
+        ctx.ReportRange(i, minInt(lineEnd, i+2), "Malformed TSDoc inline tag.")
+        continue
+      }
+      tagEnd := tagStart + 1
+      for tagEnd < lineEnd && isTSDocTagContinue(src[tagEnd]) {
+        tagEnd++
+      }
+      close := findByteInRange(src, '}', tagEnd, block.bodyEnd)
+      if close < 0 {
+        ctx.ReportRange(i, tagEnd, "Unclosed TSDoc inline tag.")
+        i = tagEnd - 1
+        continue
+      }
+      i = close
+    }
+  })
 }
 
 func walkJSDocLines(src string, block jsdocBlock, visit func(contentStart, lineEnd int, inFence bool)) {
-	inFence := false
-	for lineStart := block.bodyStart; lineStart < block.bodyEnd; {
-		lineEnd := lineStart
-		for lineEnd < block.bodyEnd && src[lineEnd] != '\n' {
-			lineEnd++
-		}
-		contentStart := tsdocLineContentStart(src, lineStart, lineEnd)
-		visit(contentStart, trimLineEnd(src, lineEnd), inFence)
-		if startsWithFenceMarker(src, contentStart, trimLineEnd(src, lineEnd)) {
-			inFence = !inFence
-		}
-		if lineEnd >= block.bodyEnd {
-			break
-		}
-		lineStart = lineEnd + 1
-	}
+  inFence := false
+  for lineStart := block.bodyStart; lineStart < block.bodyEnd; {
+    lineEnd := lineStart
+    for lineEnd < block.bodyEnd && src[lineEnd] != '\n' {
+      lineEnd++
+    }
+    contentStart := tsdocLineContentStart(src, lineStart, lineEnd)
+    visit(contentStart, trimLineEnd(src, lineEnd), inFence)
+    if startsWithFenceMarker(src, contentStart, trimLineEnd(src, lineEnd)) {
+      inFence = !inFence
+    }
+    if lineEnd >= block.bodyEnd {
+      break
+    }
+    lineStart = lineEnd + 1
+  }
 }
 
 func tsdocLineContentStart(src string, lineStart, lineEnd int) int {
-	i := lineStart
-	for i < lineEnd && (src[i] == ' ' || src[i] == '\t' || src[i] == '\r') {
-		i++
-	}
-	if i < lineEnd && src[i] == '*' {
-		i++
-		if i < lineEnd && src[i] == ' ' {
-			i++
-		}
-	}
-	return i
+  i := lineStart
+  for i < lineEnd && (src[i] == ' ' || src[i] == '\t' || src[i] == '\r') {
+    i++
+  }
+  if i < lineEnd && src[i] == '*' {
+    i++
+    if i < lineEnd && src[i] == ' ' {
+      i++
+    }
+  }
+  return i
 }
 
 func trimLineEnd(src string, lineEnd int) int {
-	for lineEnd > 0 && src[lineEnd-1] == '\r' {
-		lineEnd--
-	}
-	return lineEnd
+  for lineEnd > 0 && src[lineEnd-1] == '\r' {
+    lineEnd--
+  }
+  return lineEnd
 }
 
 func startsWithFenceMarker(src string, start, end int) bool {
-	return end-start >= 3 && src[start] == '`' && src[start+1] == '`' && src[start+2] == '`'
+  return end-start >= 3 && src[start] == '`' && src[start+1] == '`' && src[start+2] == '`'
 }
 
 func findByteInRange(src string, target byte, start, end int) int {
-	for i := start; i < end; i++ {
-		if src[i] == target {
-			return i
-		}
-	}
-	return -1
+  for i := start; i < end; i++ {
+    if src[i] == target {
+      return i
+    }
+  }
+  return -1
 }
 
 func isTSDocTagStart(b byte) bool {
-	return (b >= 'a' && b <= 'z') || (b >= 'A' && b <= 'Z')
+  return (b >= 'a' && b <= 'z') || (b >= 'A' && b <= 'Z')
 }
 
 func isTSDocTagContinue(b byte) bool {
-	return isTSDocTagStart(b) || (b >= '0' && b <= '9') || b == '-'
+  return isTSDocTagStart(b) || (b >= '0' && b <= '9') || b == '-'
 }
 
 func minInt(a, b int) int {
-	if a < b {
-		return a
-	}
-	return b
+  if a < b {
+    return a
+  }
+  return b
 }
 
 func init() {
-	Register(tsdocSyntax{})
+  Register(tsdocSyntax{})
 }

package/linthost/rules_unicorn_better_regex.go

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

package/linthost/rules_unicorn_catch_error_name.go

@@ -19,28 +19,28 @@ type unicornCatchErrorName struct{}
 
 func (unicornCatchErrorName) Name() string { return "unicorn/catch-error-name" }
 func (unicornCatchErrorName) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCatchClause}
+  return []shimast.Kind{shimast.KindCatchClause}
 }
 func (unicornCatchErrorName) Check(ctx *Context, node *shimast.Node) {
-	catch := node.AsCatchClause()
-	if catch == nil || catch.VariableDeclaration == nil {
-		return
-	}
-	binding := catch.VariableDeclaration.Name()
-	if binding == nil {
-		return
-	}
-	// Destructuring (object/array binding pattern) is out of scope.
-	if binding.Kind != shimast.KindIdentifier {
-		return
-	}
-	name := identifierText(binding)
-	if name == "" || name == "error" {
-		return
-	}
-	ctx.Report(binding, "The catch parameter should be named `error`.")
+  catch := node.AsCatchClause()
+  if catch == nil || catch.VariableDeclaration == nil {
+    return
+  }
+  binding := catch.VariableDeclaration.Name()
+  if binding == nil {
+    return
+  }
+  // Destructuring (object/array binding pattern) is out of scope.
+  if binding.Kind != shimast.KindIdentifier {
+    return
+  }
+  name := identifierText(binding)
+  if name == "" || name == "error" {
+    return
+  }
+  ctx.Report(binding, "The catch parameter should be named `error`.")
 }
 
 func init() {
-	Register(unicornCatchErrorName{})
+  Register(unicornCatchErrorName{})
 }

package/linthost/rules_unicorn_consistent_assert.go

@@ -19,29 +19,29 @@ type unicornConsistentAssert struct{}
 
 func (unicornConsistentAssert) Name() string { return "unicorn/consistent-assert" }
 func (unicornConsistentAssert) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindCallExpression}
 }
 func (unicornConsistentAssert) Check(ctx *Context, node *shimast.Node) {
-	call := node.AsCallExpression()
-	if call == nil || call.Expression == nil ||
-		call.Expression.Kind != shimast.KindPropertyAccessExpression {
-		return
-	}
-	access := call.Expression.AsPropertyAccessExpression()
-	if access == nil || access.Expression == nil {
-		return
-	}
-	if identifierText(access.Expression) != "assert" {
-		return
-	}
-	switch identifierText(access.Name()) {
-	case "equal", "notEqual":
-	default:
-		return
-	}
-	ctx.Report(node, "Use the strict variant — `assert.strictEqual` / `assert.notStrictEqual`.")
+  call := node.AsCallExpression()
+  if call == nil || call.Expression == nil ||
+    call.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  access := call.Expression.AsPropertyAccessExpression()
+  if access == nil || access.Expression == nil {
+    return
+  }
+  if identifierText(access.Expression) != "assert" {
+    return
+  }
+  switch identifierText(access.Name()) {
+  case "equal", "notEqual":
+  default:
+    return
+  }
+  ctx.Report(node, "Use the strict variant — `assert.strictEqual` / `assert.notStrictEqual`.")
 }
 
 func init() {
-	Register(unicornConsistentAssert{})
+  Register(unicornConsistentAssert{})
 }

package/linthost/rules_unicorn_consistent_date_clone.go

@@ -17,38 +17,38 @@ import shimast "github.com/microsoft/typescript-go/shim/ast"
 type unicornConsistentDateClone struct{}
 
 func (unicornConsistentDateClone) Name() string {
-	return "unicorn/consistent-date-clone"
+  return "unicorn/consistent-date-clone"
 }
 func (unicornConsistentDateClone) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindNewExpression}
+  return []shimast.Kind{shimast.KindNewExpression}
 }
 func (unicornConsistentDateClone) Check(ctx *Context, node *shimast.Node) {
-	ne := node.AsNewExpression()
-	if ne == nil || identifierText(ne.Expression) != "Date" {
-		return
-	}
-	if ne.Arguments == nil || len(ne.Arguments.Nodes) != 1 {
-		return
-	}
-	arg := stripParens(ne.Arguments.Nodes[0])
-	if arg == nil || arg.Kind != shimast.KindCallExpression {
-		return
-	}
-	call := arg.AsCallExpression()
-	if call == nil || call.Expression == nil ||
-		call.Expression.Kind != shimast.KindPropertyAccessExpression {
-		return
-	}
-	access := call.Expression.AsPropertyAccessExpression()
-	if access == nil || identifierText(access.Name()) != "getTime" {
-		return
-	}
-	if call.Arguments != nil && len(call.Arguments.Nodes) != 0 {
-		return
-	}
-	ctx.Report(node, "Pass the `Date` directly to `new Date(...)` — `getTime()` is redundant.")
+  ne := node.AsNewExpression()
+  if ne == nil || identifierText(ne.Expression) != "Date" {
+    return
+  }
+  if ne.Arguments == nil || len(ne.Arguments.Nodes) != 1 {
+    return
+  }
+  arg := stripParens(ne.Arguments.Nodes[0])
+  if arg == nil || arg.Kind != shimast.KindCallExpression {
+    return
+  }
+  call := arg.AsCallExpression()
+  if call == nil || call.Expression == nil ||
+    call.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  access := call.Expression.AsPropertyAccessExpression()
+  if access == nil || identifierText(access.Name()) != "getTime" {
+    return
+  }
+  if call.Arguments != nil && len(call.Arguments.Nodes) != 0 {
+    return
+  }
+  ctx.Report(node, "Pass the `Date` directly to `new Date(...)` — `getTime()` is redundant.")
 }
 
 func init() {
-	Register(unicornConsistentDateClone{})
+  Register(unicornConsistentDateClone{})
 }

package/linthost/rules_unicorn_consistent_destructuring.go

@@ -12,14 +12,14 @@ import shimast "github.com/microsoft/typescript-go/shim/ast"
 type unicornConsistentDestructuring struct{}
 
 func (unicornConsistentDestructuring) Name() string {
-	return "unicorn/consistent-destructuring"
+  return "unicorn/consistent-destructuring"
 }
 func (unicornConsistentDestructuring) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindSourceFile}
+  return []shimast.Kind{shimast.KindSourceFile}
 }
 func (unicornConsistentDestructuring) Check(ctx *Context, node *shimast.Node) {
 }
 
 func init() {
-	Register(unicornConsistentDestructuring{})
+  Register(unicornConsistentDestructuring{})
 }

package/linthost/rules_unicorn_consistent_empty_array_spread.go

@@ -18,45 +18,45 @@ import shimast "github.com/microsoft/typescript-go/shim/ast"
 type unicornConsistentEmptyArraySpread struct{}
 
 func (unicornConsistentEmptyArraySpread) Name() string {
-	return "unicorn/consistent-empty-array-spread"
+  return "unicorn/consistent-empty-array-spread"
 }
 func (unicornConsistentEmptyArraySpread) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindArrayLiteralExpression}
+  return []shimast.Kind{shimast.KindArrayLiteralExpression}
 }
 func (unicornConsistentEmptyArraySpread) Check(ctx *Context, node *shimast.Node) {
-	arr := node.AsArrayLiteralExpression()
-	if arr == nil || arr.Elements == nil {
-		return
-	}
-	for _, el := range arr.Elements.Nodes {
-		if el == nil || el.Kind != shimast.KindSpreadElement {
-			continue
-		}
-		spread := el.AsSpreadElement()
-		if spread == nil {
-			continue
-		}
-		inner := stripParens(spread.Expression)
-		if inner == nil || inner.Kind != shimast.KindConditionalExpression {
-			continue
-		}
-		cond := inner.AsConditionalExpression()
-		if cond == nil {
-			continue
-		}
-		whenTrue := stripParens(cond.WhenTrue)
-		whenFalse := stripParens(cond.WhenFalse)
-		if whenTrue == nil || whenFalse == nil {
-			continue
-		}
-		trueIsArr := whenTrue.Kind == shimast.KindArrayLiteralExpression
-		falseIsArr := whenFalse.Kind == shimast.KindArrayLiteralExpression
-		if trueIsArr != falseIsArr {
-			ctx.Report(el, "When spreading a ternary in an array literal, both branches should be arrays.")
-		}
-	}
+  arr := node.AsArrayLiteralExpression()
+  if arr == nil || arr.Elements == nil {
+    return
+  }
+  for _, el := range arr.Elements.Nodes {
+    if el == nil || el.Kind != shimast.KindSpreadElement {
+      continue
+    }
+    spread := el.AsSpreadElement()
+    if spread == nil {
+      continue
+    }
+    inner := stripParens(spread.Expression)
+    if inner == nil || inner.Kind != shimast.KindConditionalExpression {
+      continue
+    }
+    cond := inner.AsConditionalExpression()
+    if cond == nil {
+      continue
+    }
+    whenTrue := stripParens(cond.WhenTrue)
+    whenFalse := stripParens(cond.WhenFalse)
+    if whenTrue == nil || whenFalse == nil {
+      continue
+    }
+    trueIsArr := whenTrue.Kind == shimast.KindArrayLiteralExpression
+    falseIsArr := whenFalse.Kind == shimast.KindArrayLiteralExpression
+    if trueIsArr != falseIsArr {
+      ctx.Report(el, "When spreading a ternary in an array literal, both branches should be arrays.")
+    }
+  }
 }
 
 func init() {
-	Register(unicornConsistentEmptyArraySpread{})
+  Register(unicornConsistentEmptyArraySpread{})
 }