@ttsc/lint 0.14.0-dev.20260529.1 → 0.14.0

package/linthost/rules_unicorn_prefer_global_this.go

@@ -19,19 +19,19 @@ type unicornPreferGlobalThis struct{}
 
 func (unicornPreferGlobalThis) Name() string { return "unicorn/prefer-global-this" }
 func (unicornPreferGlobalThis) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindIdentifier}
+  return []shimast.Kind{shimast.KindIdentifier}
 }
 func (unicornPreferGlobalThis) Check(ctx *Context, node *shimast.Node) {
-	name := identifierText(node)
-	switch name {
-	case "window", "self", "global":
-	default:
-		return
-	}
-	if !isUnicornValuePositionIdentifier(node) {
-		return
-	}
-	ctx.Report(node, "Prefer `globalThis` over `window` / `self` / `global`.")
+  name := identifierText(node)
+  switch name {
+  case "window", "self", "global":
+  default:
+    return
+  }
+  if !isUnicornValuePositionIdentifier(node) {
+    return
+  }
+  ctx.Report(node, "Prefer `globalThis` over `window` / `self` / `global`.")
 }
 
 // isUnicornValuePositionIdentifier reports whether `node` (a bare
@@ -41,87 +41,87 @@ func (unicornPreferGlobalThis) Check(ctx *Context, node *shimast.Node) {
 // for the *name* itself, so they must not contribute to rules that
 // flag *uses* of a global.
 func isUnicornValuePositionIdentifier(node *shimast.Node) bool {
-	if node == nil || node.Kind != shimast.KindIdentifier || node.Parent == nil {
-		return false
-	}
-	parent := node.Parent
-	switch parent.Kind {
-	case shimast.KindVariableDeclaration:
-		decl := parent.AsVariableDeclaration()
-		if decl != nil && decl.Name() == node {
-			return false
-		}
-	case shimast.KindBindingElement:
-		elem := parent.AsBindingElement()
-		if elem != nil && elem.Name() == node {
-			return false
-		}
-	case shimast.KindParameter:
-		param := parent.AsParameterDeclaration()
-		if param != nil && param.Name() == node {
-			return false
-		}
-	case shimast.KindFunctionDeclaration:
-		fn := parent.AsFunctionDeclaration()
-		if fn != nil && fn.Name() == node {
-			return false
-		}
-	case shimast.KindFunctionExpression:
-		fn := parent.AsFunctionExpression()
-		if fn != nil && fn.Name() == node {
-			return false
-		}
-	case shimast.KindClassDeclaration:
-		cls := parent.AsClassDeclaration()
-		if cls != nil && cls.Name() == node {
-			return false
-		}
-	case shimast.KindClassExpression:
-		cls := parent.AsClassExpression()
-		if cls != nil && cls.Name() == node {
-			return false
-		}
-	case shimast.KindPropertyAccessExpression:
-		access := parent.AsPropertyAccessExpression()
-		if access != nil && access.Name() == node {
-			return false
-		}
-	case shimast.KindPropertyAssignment:
-		prop := parent.AsPropertyAssignment()
-		if prop != nil && prop.Name() == node {
-			return false
-		}
-	case shimast.KindShorthandPropertyAssignment:
-		// `{window}` shorthand — the identifier is both name and read,
-		// but the read here is the value position, so allow.
-	case shimast.KindMethodDeclaration,
-		shimast.KindGetAccessor,
-		shimast.KindSetAccessor,
-		shimast.KindPropertyDeclaration:
-		// These have a Name() slot that is not a value expression.
-		return false
-	case shimast.KindTypeReference,
-		shimast.KindQualifiedName,
-		shimast.KindImportSpecifier,
-		shimast.KindExportSpecifier,
-		shimast.KindNamespaceImport,
-		shimast.KindImportClause,
-		shimast.KindNamespaceExport,
-		shimast.KindLabeledStatement,
-		shimast.KindBreakStatement,
-		shimast.KindContinueStatement,
-		shimast.KindJsxAttribute,
-		shimast.KindEnumDeclaration,
-		shimast.KindEnumMember,
-		shimast.KindModuleDeclaration,
-		shimast.KindTypeParameter,
-		shimast.KindInterfaceDeclaration,
-		shimast.KindTypeAliasDeclaration:
-		return false
-	}
-	return true
+  if node == nil || node.Kind != shimast.KindIdentifier || node.Parent == nil {
+    return false
+  }
+  parent := node.Parent
+  switch parent.Kind {
+  case shimast.KindVariableDeclaration:
+    decl := parent.AsVariableDeclaration()
+    if decl != nil && decl.Name() == node {
+      return false
+    }
+  case shimast.KindBindingElement:
+    elem := parent.AsBindingElement()
+    if elem != nil && elem.Name() == node {
+      return false
+    }
+  case shimast.KindParameter:
+    param := parent.AsParameterDeclaration()
+    if param != nil && param.Name() == node {
+      return false
+    }
+  case shimast.KindFunctionDeclaration:
+    fn := parent.AsFunctionDeclaration()
+    if fn != nil && fn.Name() == node {
+      return false
+    }
+  case shimast.KindFunctionExpression:
+    fn := parent.AsFunctionExpression()
+    if fn != nil && fn.Name() == node {
+      return false
+    }
+  case shimast.KindClassDeclaration:
+    cls := parent.AsClassDeclaration()
+    if cls != nil && cls.Name() == node {
+      return false
+    }
+  case shimast.KindClassExpression:
+    cls := parent.AsClassExpression()
+    if cls != nil && cls.Name() == node {
+      return false
+    }
+  case shimast.KindPropertyAccessExpression:
+    access := parent.AsPropertyAccessExpression()
+    if access != nil && access.Name() == node {
+      return false
+    }
+  case shimast.KindPropertyAssignment:
+    prop := parent.AsPropertyAssignment()
+    if prop != nil && prop.Name() == node {
+      return false
+    }
+  case shimast.KindShorthandPropertyAssignment:
+    // `{window}` shorthand — the identifier is both name and read,
+    // but the read here is the value position, so allow.
+  case shimast.KindMethodDeclaration,
+    shimast.KindGetAccessor,
+    shimast.KindSetAccessor,
+    shimast.KindPropertyDeclaration:
+    // These have a Name() slot that is not a value expression.
+    return false
+  case shimast.KindTypeReference,
+    shimast.KindQualifiedName,
+    shimast.KindImportSpecifier,
+    shimast.KindExportSpecifier,
+    shimast.KindNamespaceImport,
+    shimast.KindImportClause,
+    shimast.KindNamespaceExport,
+    shimast.KindLabeledStatement,
+    shimast.KindBreakStatement,
+    shimast.KindContinueStatement,
+    shimast.KindJsxAttribute,
+    shimast.KindEnumDeclaration,
+    shimast.KindEnumMember,
+    shimast.KindModuleDeclaration,
+    shimast.KindTypeParameter,
+    shimast.KindInterfaceDeclaration,
+    shimast.KindTypeAliasDeclaration:
+    return false
+  }
+  return true
 }
 
 func init() {
-	Register(unicornPreferGlobalThis{})
+  Register(unicornPreferGlobalThis{})
 }

package/linthost/rules_unicorn_prefer_import_meta_properties.go

@@ -18,49 +18,49 @@ import shimast "github.com/microsoft/typescript-go/shim/ast"
 type unicornPreferImportMetaProperties struct{}
 
 func (unicornPreferImportMetaProperties) Name() string {
-	return "unicorn/prefer-import-meta-properties"
+  return "unicorn/prefer-import-meta-properties"
 }
 func (unicornPreferImportMetaProperties) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindCallExpression}
 }
 func (unicornPreferImportMetaProperties) Check(ctx *Context, node *shimast.Node) {
-	call := node.AsCallExpression()
-	if call == nil || call.Expression == nil {
-		return
-	}
-	if identifierText(call.Expression) != "fileURLToPath" {
-		return
-	}
-	if call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
-		return
-	}
-	arg := stripParens(call.Arguments.Nodes[0])
-	if arg == nil || arg.Kind != shimast.KindPropertyAccessExpression {
-		return
-	}
-	access := arg.AsPropertyAccessExpression()
-	if access == nil {
-		return
-	}
-	if identifierText(access.Name()) != "url" {
-		return
-	}
-	receiver := stripParens(access.Expression)
-	if receiver == nil {
-		return
-	}
-	// `import.meta` parses as either a MetaProperty token or a
-	// PropertyAccess(import, meta) chain depending on the path; both
-	// resolve textually to the same source span.
-	if receiver.Kind == shimast.KindMetaProperty {
-		ctx.Report(node, "Prefer `import.meta.dirname` / `import.meta.filename` over `fileURLToPath(import.meta.url)`.")
-		return
-	}
-	if isMatchingPropertyAccess(receiver, "import", "meta") {
-		ctx.Report(node, "Prefer `import.meta.dirname` / `import.meta.filename` over `fileURLToPath(import.meta.url)`.")
-	}
+  call := node.AsCallExpression()
+  if call == nil || call.Expression == nil {
+    return
+  }
+  if identifierText(call.Expression) != "fileURLToPath" {
+    return
+  }
+  if call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
+    return
+  }
+  arg := stripParens(call.Arguments.Nodes[0])
+  if arg == nil || arg.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  access := arg.AsPropertyAccessExpression()
+  if access == nil {
+    return
+  }
+  if identifierText(access.Name()) != "url" {
+    return
+  }
+  receiver := stripParens(access.Expression)
+  if receiver == nil {
+    return
+  }
+  // `import.meta` parses as either a MetaProperty token or a
+  // PropertyAccess(import, meta) chain depending on the path; both
+  // resolve textually to the same source span.
+  if receiver.Kind == shimast.KindMetaProperty {
+    ctx.Report(node, "Prefer `import.meta.dirname` / `import.meta.filename` over `fileURLToPath(import.meta.url)`.")
+    return
+  }
+  if isMatchingPropertyAccess(receiver, "import", "meta") {
+    ctx.Report(node, "Prefer `import.meta.dirname` / `import.meta.filename` over `fileURLToPath(import.meta.url)`.")
+  }
 }
 
 func init() {
-	Register(unicornPreferImportMetaProperties{})
+  Register(unicornPreferImportMetaProperties{})
 }

package/linthost/rules_unicorn_prefer_includes.go

@@ -23,127 +23,127 @@ type unicornPreferIncludes struct{}
 
 func (unicornPreferIncludes) Name() string { return "unicorn/prefer-includes" }
 func (unicornPreferIncludes) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindBinaryExpression}
+  return []shimast.Kind{shimast.KindBinaryExpression}
 }
 func (unicornPreferIncludes) Check(ctx *Context, node *shimast.Node) {
-	bin := node.AsBinaryExpression()
-	if bin == nil || bin.OperatorToken == nil || bin.Left == nil || bin.Right == nil {
-		return
-	}
-	op := bin.OperatorToken.Kind
-	wantNegOne := false
-	wantZero := false
-	switch op {
-	case shimast.KindEqualsEqualsEqualsToken,
-		shimast.KindExclamationEqualsEqualsToken,
-		shimast.KindEqualsEqualsToken,
-		shimast.KindExclamationEqualsToken:
-		wantNegOne = true
-	case shimast.KindLessThanToken:
-		// `indexOf(x) < 0`
-		wantZero = true
-	case shimast.KindGreaterThanEqualsToken:
-		// `indexOf(x) >= 0`
-		wantZero = true
-	case shimast.KindGreaterThanToken:
-		// Not in the canonical set for this orientation; handled below
-		// via `> -1` matching against the negative-one form.
-		wantNegOne = true
-	default:
-		return
-	}
-	left := stripParens(bin.Left)
-	right := stripParens(bin.Right)
-	matched := unicornPreferIncludesMatches(left, right, op, wantNegOne, wantZero)
-	// Equality is symmetric — also try the swapped orientation.
-	// Asymmetric operators (`<`, `>=`, `>`) only match the canonical
-	// orientation; swapping `indexOf(x) < 0` to `0 < indexOf(x)` changes
-	// the meaning ("found at index >= 1") and must not be rewritten.
-	if !matched {
-		switch op {
-		case shimast.KindEqualsEqualsEqualsToken,
-			shimast.KindExclamationEqualsEqualsToken,
-			shimast.KindEqualsEqualsToken,
-			shimast.KindExclamationEqualsToken:
-			matched = unicornPreferIncludesMatches(right, left, op, wantNegOne, wantZero)
-		}
-	}
-	if matched {
-		ctx.Report(node, "Prefer `Array#includes()` / `String#includes()` over `indexOf` comparisons.")
-	}
+  bin := node.AsBinaryExpression()
+  if bin == nil || bin.OperatorToken == nil || bin.Left == nil || bin.Right == nil {
+    return
+  }
+  op := bin.OperatorToken.Kind
+  wantNegOne := false
+  wantZero := false
+  switch op {
+  case shimast.KindEqualsEqualsEqualsToken,
+    shimast.KindExclamationEqualsEqualsToken,
+    shimast.KindEqualsEqualsToken,
+    shimast.KindExclamationEqualsToken:
+    wantNegOne = true
+  case shimast.KindLessThanToken:
+    // `indexOf(x) < 0`
+    wantZero = true
+  case shimast.KindGreaterThanEqualsToken:
+    // `indexOf(x) >= 0`
+    wantZero = true
+  case shimast.KindGreaterThanToken:
+    // Not in the canonical set for this orientation; handled below
+    // via `> -1` matching against the negative-one form.
+    wantNegOne = true
+  default:
+    return
+  }
+  left := stripParens(bin.Left)
+  right := stripParens(bin.Right)
+  matched := unicornPreferIncludesMatches(left, right, op, wantNegOne, wantZero)
+  // Equality is symmetric — also try the swapped orientation.
+  // Asymmetric operators (`<`, `>=`, `>`) only match the canonical
+  // orientation; swapping `indexOf(x) < 0` to `0 < indexOf(x)` changes
+  // the meaning ("found at index >= 1") and must not be rewritten.
+  if !matched {
+    switch op {
+    case shimast.KindEqualsEqualsEqualsToken,
+      shimast.KindExclamationEqualsEqualsToken,
+      shimast.KindEqualsEqualsToken,
+      shimast.KindExclamationEqualsToken:
+      matched = unicornPreferIncludesMatches(right, left, op, wantNegOne, wantZero)
+    }
+  }
+  if matched {
+    ctx.Report(node, "Prefer `Array#includes()` / `String#includes()` over `indexOf` comparisons.")
+  }
 }
 
 func unicornPreferIncludesMatches(
-	callSide, literalSide *shimast.Node,
-	op shimast.Kind,
-	wantNegOne, wantZero bool,
+  callSide, literalSide *shimast.Node,
+  op shimast.Kind,
+  wantNegOne, wantZero bool,
 ) bool {
-	if callSide == nil || literalSide == nil {
-		return false
-	}
-	if callSide.Kind != shimast.KindCallExpression {
-		return false
-	}
-	call := callSide.AsCallExpression()
-	if call == nil || call.Expression == nil ||
-		call.Expression.Kind != shimast.KindPropertyAccessExpression {
-		return false
-	}
-	access := call.Expression.AsPropertyAccessExpression()
-	if access == nil || identifierText(access.Name()) != "indexOf" {
-		return false
-	}
-	// `> -1`, `>= 0`, `< 0`, `=== -1`, `!== -1`, `== -1`, `!= -1`.
-	switch op {
-	case shimast.KindGreaterThanToken:
-		// Only `indexOf(x) > -1` matches.
-		return unicornPreferIncludesIsNegativeOne(literalSide)
-	case shimast.KindLessThanToken:
-		// Only `indexOf(x) < 0` matches.
-		return unicornPreferIncludesIsZero(literalSide)
-	case shimast.KindGreaterThanEqualsToken:
-		// Only `indexOf(x) >= 0` matches.
-		return unicornPreferIncludesIsZero(literalSide)
-	}
-	if wantNegOne && unicornPreferIncludesIsNegativeOne(literalSide) {
-		return true
-	}
-	if wantZero && unicornPreferIncludesIsZero(literalSide) {
-		return true
-	}
-	return false
+  if callSide == nil || literalSide == nil {
+    return false
+  }
+  if callSide.Kind != shimast.KindCallExpression {
+    return false
+  }
+  call := callSide.AsCallExpression()
+  if call == nil || call.Expression == nil ||
+    call.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return false
+  }
+  access := call.Expression.AsPropertyAccessExpression()
+  if access == nil || identifierText(access.Name()) != "indexOf" {
+    return false
+  }
+  // `> -1`, `>= 0`, `< 0`, `=== -1`, `!== -1`, `== -1`, `!= -1`.
+  switch op {
+  case shimast.KindGreaterThanToken:
+    // Only `indexOf(x) > -1` matches.
+    return unicornPreferIncludesIsNegativeOne(literalSide)
+  case shimast.KindLessThanToken:
+    // Only `indexOf(x) < 0` matches.
+    return unicornPreferIncludesIsZero(literalSide)
+  case shimast.KindGreaterThanEqualsToken:
+    // Only `indexOf(x) >= 0` matches.
+    return unicornPreferIncludesIsZero(literalSide)
+  }
+  if wantNegOne && unicornPreferIncludesIsNegativeOne(literalSide) {
+    return true
+  }
+  if wantZero && unicornPreferIncludesIsZero(literalSide) {
+    return true
+  }
+  return false
 }
 
 func unicornPreferIncludesIsNegativeOne(node *shimast.Node) bool {
-	node = stripParens(node)
-	if node == nil {
-		return false
-	}
-	if node.Kind == shimast.KindPrefixUnaryExpression {
-		prefix := node.AsPrefixUnaryExpression()
-		if prefix == nil || prefix.Operator != shimast.KindMinusToken || prefix.Operand == nil {
-			return false
-		}
-		if prefix.Operand.Kind != shimast.KindNumericLiteral {
-			return false
-		}
-		return numericLiteralText(prefix.Operand) == "1"
-	}
-	if node.Kind == shimast.KindNumericLiteral {
-		// Some tokenizers preserve the leading `-` in the literal text.
-		return numericLiteralText(node) == "-1"
-	}
-	return false
+  node = stripParens(node)
+  if node == nil {
+    return false
+  }
+  if node.Kind == shimast.KindPrefixUnaryExpression {
+    prefix := node.AsPrefixUnaryExpression()
+    if prefix == nil || prefix.Operator != shimast.KindMinusToken || prefix.Operand == nil {
+      return false
+    }
+    if prefix.Operand.Kind != shimast.KindNumericLiteral {
+      return false
+    }
+    return numericLiteralText(prefix.Operand) == "1"
+  }
+  if node.Kind == shimast.KindNumericLiteral {
+    // Some tokenizers preserve the leading `-` in the literal text.
+    return numericLiteralText(node) == "-1"
+  }
+  return false
 }
 
 func unicornPreferIncludesIsZero(node *shimast.Node) bool {
-	node = stripParens(node)
-	if node == nil || node.Kind != shimast.KindNumericLiteral {
-		return false
-	}
-	return numericLiteralText(node) == "0"
+  node = stripParens(node)
+  if node == nil || node.Kind != shimast.KindNumericLiteral {
+    return false
+  }
+  return numericLiteralText(node) == "0"
 }
 
 func init() {
-	Register(unicornPreferIncludes{})
+  Register(unicornPreferIncludes{})
 }

package/linthost/rules_unicorn_prefer_json_parse_buffer.go

@@ -20,46 +20,46 @@ type unicornPreferJsonParseBuffer struct{}
 
 func (unicornPreferJsonParseBuffer) Name() string { return "unicorn/prefer-json-parse-buffer" }
 func (unicornPreferJsonParseBuffer) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindCallExpression}
 }
 func (unicornPreferJsonParseBuffer) Check(ctx *Context, node *shimast.Node) {
-	call := node.AsCallExpression()
-	if call == nil || call.Expression == nil || call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
-		return
-	}
-	// Callee must be `JSON.parse`.
-	if call.Expression.Kind != shimast.KindPropertyAccessExpression {
-		return
-	}
-	access := call.Expression.AsPropertyAccessExpression()
-	if access == nil {
-		return
-	}
-	if identifierText(access.Expression) != "JSON" || identifierText(access.Name()) != "parse" {
-		return
-	}
-	// Argument must be `_.toString()` with no arguments.
-	arg := stripParens(call.Arguments.Nodes[0])
-	if arg == nil || arg.Kind != shimast.KindCallExpression {
-		return
-	}
-	innerCall := arg.AsCallExpression()
-	if innerCall == nil || innerCall.Expression == nil {
-		return
-	}
-	if innerCall.Arguments != nil && len(innerCall.Arguments.Nodes) != 0 {
-		return
-	}
-	if innerCall.Expression.Kind != shimast.KindPropertyAccessExpression {
-		return
-	}
-	innerAccess := innerCall.Expression.AsPropertyAccessExpression()
-	if innerAccess == nil || identifierText(innerAccess.Name()) != "toString" {
-		return
-	}
-	ctx.Report(node, "Prefer passing a `Buffer` directly to `JSON.parse` (Node 21+) over decoding to a string first.")
+  call := node.AsCallExpression()
+  if call == nil || call.Expression == nil || call.Arguments == nil || len(call.Arguments.Nodes) != 1 {
+    return
+  }
+  // Callee must be `JSON.parse`.
+  if call.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  access := call.Expression.AsPropertyAccessExpression()
+  if access == nil {
+    return
+  }
+  if identifierText(access.Expression) != "JSON" || identifierText(access.Name()) != "parse" {
+    return
+  }
+  // Argument must be `_.toString()` with no arguments.
+  arg := stripParens(call.Arguments.Nodes[0])
+  if arg == nil || arg.Kind != shimast.KindCallExpression {
+    return
+  }
+  innerCall := arg.AsCallExpression()
+  if innerCall == nil || innerCall.Expression == nil {
+    return
+  }
+  if innerCall.Arguments != nil && len(innerCall.Arguments.Nodes) != 0 {
+    return
+  }
+  if innerCall.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  innerAccess := innerCall.Expression.AsPropertyAccessExpression()
+  if innerAccess == nil || identifierText(innerAccess.Name()) != "toString" {
+    return
+  }
+  ctx.Report(node, "Prefer passing a `Buffer` directly to `JSON.parse` (Node 21+) over decoding to a string first.")
 }
 
 func init() {
-	Register(unicornPreferJsonParseBuffer{})
+  Register(unicornPreferJsonParseBuffer{})
 }

package/linthost/rules_unicorn_prefer_keyboard_event_key.go

@@ -20,19 +20,19 @@ type unicornPreferKeyboardEventKey struct{}
 
 func (unicornPreferKeyboardEventKey) Name() string { return "unicorn/prefer-keyboard-event-key" }
 func (unicornPreferKeyboardEventKey) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindPropertyAccessExpression}
+  return []shimast.Kind{shimast.KindPropertyAccessExpression}
 }
 func (unicornPreferKeyboardEventKey) Check(ctx *Context, node *shimast.Node) {
-	access := node.AsPropertyAccessExpression()
-	if access == nil {
-		return
-	}
-	switch identifierText(access.Name()) {
-	case "keyCode", "charCode", "which":
-		ctx.Report(node, "Prefer `KeyboardEvent#key` over the deprecated `keyCode` / `charCode` / `which`.")
-	}
+  access := node.AsPropertyAccessExpression()
+  if access == nil {
+    return
+  }
+  switch identifierText(access.Name()) {
+  case "keyCode", "charCode", "which":
+    ctx.Report(node, "Prefer `KeyboardEvent#key` over the deprecated `keyCode` / `charCode` / `which`.")
+  }
 }
 
 func init() {
-	Register(unicornPreferKeyboardEventKey{})
+  Register(unicornPreferKeyboardEventKey{})
 }