@ttsc/lint 0.14.0-dev.20260529.2 → 0.14.1

package/linthost/rules_unicorn_prefer_class_fields.go

@@ -22,72 +22,72 @@ type unicornPreferClassFields struct{}
 
 func (unicornPreferClassFields) Name() string { return "unicorn/prefer-class-fields" }
 func (unicornPreferClassFields) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindConstructor}
+  return []shimast.Kind{shimast.KindConstructor}
 }
 func (unicornPreferClassFields) Check(ctx *Context, node *shimast.Node) {
-	ctor := node.AsConstructorDeclaration()
-	if ctor == nil || ctor.Body == nil {
-		return
-	}
-	body := ctor.Body.AsBlock()
-	if body == nil || body.Statements == nil {
-		return
-	}
-	for _, stmt := range body.Statements.Nodes {
-		if stmt == nil || stmt.Kind != shimast.KindExpressionStatement {
-			continue
-		}
-		exprStmt := stmt.AsExpressionStatement()
-		if exprStmt == nil || exprStmt.Expression == nil {
-			continue
-		}
-		expr := stripParens(exprStmt.Expression)
-		if expr == nil || expr.Kind != shimast.KindBinaryExpression {
-			continue
-		}
-		bin := expr.AsBinaryExpression()
-		if bin == nil || bin.OperatorToken == nil || bin.OperatorToken.Kind != shimast.KindEqualsToken {
-			continue
-		}
-		lhs := stripParens(bin.Left)
-		if lhs == nil || lhs.Kind != shimast.KindPropertyAccessExpression {
-			continue
-		}
-		access := lhs.AsPropertyAccessExpression()
-		if access == nil {
-			continue
-		}
-		receiver := stripParens(access.Expression)
-		if receiver == nil || receiver.Kind != shimast.KindThisKeyword {
-			continue
-		}
-		rhs := stripParens(bin.Right)
-		if !isPrimitiveLiteralForClassField(rhs) {
-			continue
-		}
-		ctx.Report(expr, "Prefer class field declarations over constructor assignments to `this.field`.")
-	}
+  ctor := node.AsConstructorDeclaration()
+  if ctor == nil || ctor.Body == nil {
+    return
+  }
+  body := ctor.Body.AsBlock()
+  if body == nil || body.Statements == nil {
+    return
+  }
+  for _, stmt := range body.Statements.Nodes {
+    if stmt == nil || stmt.Kind != shimast.KindExpressionStatement {
+      continue
+    }
+    exprStmt := stmt.AsExpressionStatement()
+    if exprStmt == nil || exprStmt.Expression == nil {
+      continue
+    }
+    expr := stripParens(exprStmt.Expression)
+    if expr == nil || expr.Kind != shimast.KindBinaryExpression {
+      continue
+    }
+    bin := expr.AsBinaryExpression()
+    if bin == nil || bin.OperatorToken == nil || bin.OperatorToken.Kind != shimast.KindEqualsToken {
+      continue
+    }
+    lhs := stripParens(bin.Left)
+    if lhs == nil || lhs.Kind != shimast.KindPropertyAccessExpression {
+      continue
+    }
+    access := lhs.AsPropertyAccessExpression()
+    if access == nil {
+      continue
+    }
+    receiver := stripParens(access.Expression)
+    if receiver == nil || receiver.Kind != shimast.KindThisKeyword {
+      continue
+    }
+    rhs := stripParens(bin.Right)
+    if !isPrimitiveLiteralForClassField(rhs) {
+      continue
+    }
+    ctx.Report(expr, "Prefer class field declarations over constructor assignments to `this.field`.")
+  }
 }
 
 // isPrimitiveLiteralForClassField reports whether `node` is one of the
 // primitive-literal kinds that the prefer-class-fields rule treats as
 // "trivially hoistable" to a class field initializer.
 func isPrimitiveLiteralForClassField(node *shimast.Node) bool {
-	if node == nil {
-		return false
-	}
-	switch node.Kind {
-	case shimast.KindStringLiteral,
-		shimast.KindNumericLiteral,
-		shimast.KindTrueKeyword,
-		shimast.KindFalseKeyword,
-		shimast.KindNullKeyword,
-		shimast.KindNoSubstitutionTemplateLiteral:
-		return true
-	}
-	return false
+  if node == nil {
+    return false
+  }
+  switch node.Kind {
+  case shimast.KindStringLiteral,
+    shimast.KindNumericLiteral,
+    shimast.KindTrueKeyword,
+    shimast.KindFalseKeyword,
+    shimast.KindNullKeyword,
+    shimast.KindNoSubstitutionTemplateLiteral:
+    return true
+  }
+  return false
 }
 
 func init() {
-	Register(unicornPreferClassFields{})
+  Register(unicornPreferClassFields{})
 }

package/linthost/rules_unicorn_prefer_classlist_toggle.go

@@ -21,36 +21,36 @@ type unicornPreferClasslistToggle struct{}
 
 func (unicornPreferClasslistToggle) Name() string { return "unicorn/prefer-classlist-toggle" }
 func (unicornPreferClasslistToggle) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindIfStatement}
+  return []shimast.Kind{shimast.KindIfStatement}
 }
 func (unicornPreferClasslistToggle) Check(ctx *Context, node *shimast.Node) {
-	stmt := node.AsIfStatement()
-	if stmt == nil || stmt.ThenStatement == nil || stmt.ElseStatement == nil {
-		return
-	}
-	thenCall := classlistToggleSingleCall(stmt.ThenStatement)
-	elseCall := classlistToggleSingleCall(stmt.ElseStatement)
-	if thenCall == nil || elseCall == nil {
-		return
-	}
-	thenMethod, thenReceiver, thenArg := classlistAddRemoveParts(thenCall)
-	elseMethod, elseReceiver, elseArg := classlistAddRemoveParts(elseCall)
-	if thenMethod == "" || elseMethod == "" {
-		return
-	}
-	// One branch must be `add`, the other `remove` — order does not
-	// matter; the toggle rewrite is symmetric.
-	if !((thenMethod == "add" && elseMethod == "remove") ||
-		(thenMethod == "remove" && elseMethod == "add")) {
-		return
-	}
-	if nodeText(ctx.File, thenReceiver) != nodeText(ctx.File, elseReceiver) {
-		return
-	}
-	if nodeText(ctx.File, thenArg) != nodeText(ctx.File, elseArg) {
-		return
-	}
-	ctx.Report(node, "Prefer `classList.toggle(name, condition)` over manual `add`/`remove` branches.")
+  stmt := node.AsIfStatement()
+  if stmt == nil || stmt.ThenStatement == nil || stmt.ElseStatement == nil {
+    return
+  }
+  thenCall := classlistToggleSingleCall(stmt.ThenStatement)
+  elseCall := classlistToggleSingleCall(stmt.ElseStatement)
+  if thenCall == nil || elseCall == nil {
+    return
+  }
+  thenMethod, thenReceiver, thenArg := classlistAddRemoveParts(thenCall)
+  elseMethod, elseReceiver, elseArg := classlistAddRemoveParts(elseCall)
+  if thenMethod == "" || elseMethod == "" {
+    return
+  }
+  // One branch must be `add`, the other `remove` — order does not
+  // matter; the toggle rewrite is symmetric.
+  if !((thenMethod == "add" && elseMethod == "remove") ||
+    (thenMethod == "remove" && elseMethod == "add")) {
+    return
+  }
+  if nodeText(ctx.File, thenReceiver) != nodeText(ctx.File, elseReceiver) {
+    return
+  }
+  if nodeText(ctx.File, thenArg) != nodeText(ctx.File, elseArg) {
+    return
+  }
+  ctx.Report(node, "Prefer `classList.toggle(name, condition)` over manual `add`/`remove` branches.")
 }
 
 // classlistToggleSingleCall returns the single CallExpression inside a
@@ -58,29 +58,29 @@ func (unicornPreferClasslistToggle) Check(ctx *Context, node *shimast.Node) {
 // Block wrapping exactly one ExpressionStatement. Returns nil for any
 // other shape.
 func classlistToggleSingleCall(branch *shimast.Node) *shimast.Node {
-	if branch == nil {
-		return nil
-	}
-	stmt := branch
-	if branch.Kind == shimast.KindBlock {
-		block := branch.AsBlock()
-		if block == nil || block.Statements == nil || len(block.Statements.Nodes) != 1 {
-			return nil
-		}
-		stmt = block.Statements.Nodes[0]
-	}
-	if stmt == nil || stmt.Kind != shimast.KindExpressionStatement {
-		return nil
-	}
-	expr := stmt.AsExpressionStatement()
-	if expr == nil || expr.Expression == nil {
-		return nil
-	}
-	call := stripParens(expr.Expression)
-	if call == nil || call.Kind != shimast.KindCallExpression {
-		return nil
-	}
-	return call
+  if branch == nil {
+    return nil
+  }
+  stmt := branch
+  if branch.Kind == shimast.KindBlock {
+    block := branch.AsBlock()
+    if block == nil || block.Statements == nil || len(block.Statements.Nodes) != 1 {
+      return nil
+    }
+    stmt = block.Statements.Nodes[0]
+  }
+  if stmt == nil || stmt.Kind != shimast.KindExpressionStatement {
+    return nil
+  }
+  expr := stmt.AsExpressionStatement()
+  if expr == nil || expr.Expression == nil {
+    return nil
+  }
+  call := stripParens(expr.Expression)
+  if call == nil || call.Kind != shimast.KindCallExpression {
+    return nil
+  }
+  return call
 }
 
 // classlistAddRemoveParts pulls (method, receiver, arg) out of a
@@ -89,32 +89,32 @@ func classlistToggleSingleCall(branch *shimast.Node) *shimast.Node {
 // node) and `arg` is the single argument. Returns ("", nil, nil) for
 // any other shape.
 func classlistAddRemoveParts(call *shimast.Node) (string, *shimast.Node, *shimast.Node) {
-	ce := call.AsCallExpression()
-	if ce == nil || ce.Expression == nil || ce.Arguments == nil || len(ce.Arguments.Nodes) != 1 {
-		return "", nil, nil
-	}
-	if ce.Expression.Kind != shimast.KindPropertyAccessExpression {
-		return "", nil, nil
-	}
-	access := ce.Expression.AsPropertyAccessExpression()
-	if access == nil {
-		return "", nil, nil
-	}
-	method := identifierText(access.Name())
-	if method != "add" && method != "remove" {
-		return "", nil, nil
-	}
-	receiver := access.Expression
-	if receiver == nil || receiver.Kind != shimast.KindPropertyAccessExpression {
-		return "", nil, nil
-	}
-	receiverAccess := receiver.AsPropertyAccessExpression()
-	if receiverAccess == nil || identifierText(receiverAccess.Name()) != "classList" {
-		return "", nil, nil
-	}
-	return method, receiver, ce.Arguments.Nodes[0]
+  ce := call.AsCallExpression()
+  if ce == nil || ce.Expression == nil || ce.Arguments == nil || len(ce.Arguments.Nodes) != 1 {
+    return "", nil, nil
+  }
+  if ce.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return "", nil, nil
+  }
+  access := ce.Expression.AsPropertyAccessExpression()
+  if access == nil {
+    return "", nil, nil
+  }
+  method := identifierText(access.Name())
+  if method != "add" && method != "remove" {
+    return "", nil, nil
+  }
+  receiver := access.Expression
+  if receiver == nil || receiver.Kind != shimast.KindPropertyAccessExpression {
+    return "", nil, nil
+  }
+  receiverAccess := receiver.AsPropertyAccessExpression()
+  if receiverAccess == nil || identifierText(receiverAccess.Name()) != "classList" {
+    return "", nil, nil
+  }
+  return method, receiver, ce.Arguments.Nodes[0]
 }
 
 func init() {
-	Register(unicornPreferClasslistToggle{})
+  Register(unicornPreferClasslistToggle{})
 }

package/linthost/rules_unicorn_prefer_code_point.go

@@ -20,30 +20,30 @@ type unicornPreferCodePoint struct{}
 
 func (unicornPreferCodePoint) Name() string { return "unicorn/prefer-code-point" }
 func (unicornPreferCodePoint) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression}
+  return []shimast.Kind{shimast.KindCallExpression}
 }
 func (unicornPreferCodePoint) 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 {
-		return
-	}
-	switch identifierText(access.Name()) {
-	case "charCodeAt":
-		// Instance call — receiver type is irrelevant.
-		ctx.Report(node, "Prefer `String#codePointAt()` / `String.fromCodePoint()` over `charCodeAt` / `fromCharCode`.")
-	case "fromCharCode":
-		// Static call — only the `String.fromCharCode(...)` shape.
-		if identifierText(access.Expression) != "String" {
-			return
-		}
-		ctx.Report(node, "Prefer `String#codePointAt()` / `String.fromCodePoint()` over `charCodeAt` / `fromCharCode`.")
-	}
+  call := node.AsCallExpression()
+  if call == nil || call.Expression == nil || call.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return
+  }
+  access := call.Expression.AsPropertyAccessExpression()
+  if access == nil {
+    return
+  }
+  switch identifierText(access.Name()) {
+  case "charCodeAt":
+    // Instance call — receiver type is irrelevant.
+    ctx.Report(node, "Prefer `String#codePointAt()` / `String.fromCodePoint()` over `charCodeAt` / `fromCharCode`.")
+  case "fromCharCode":
+    // Static call — only the `String.fromCharCode(...)` shape.
+    if identifierText(access.Expression) != "String" {
+      return
+    }
+    ctx.Report(node, "Prefer `String#codePointAt()` / `String.fromCodePoint()` over `charCodeAt` / `fromCharCode`.")
+  }
 }
 
 func init() {
-	Register(unicornPreferCodePoint{})
+  Register(unicornPreferCodePoint{})
 }

package/linthost/rules_unicorn_prefer_date_now.go

@@ -23,56 +23,56 @@ type unicornPreferDateNow struct{}
 
 func (unicornPreferDateNow) Name() string { return "unicorn/prefer-date-now" }
 func (unicornPreferDateNow) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression, shimast.KindPrefixUnaryExpression}
+  return []shimast.Kind{shimast.KindCallExpression, shimast.KindPrefixUnaryExpression}
 }
 func (unicornPreferDateNow) Check(ctx *Context, node *shimast.Node) {
-	switch node.Kind {
-	case shimast.KindCallExpression:
-		call := node.AsCallExpression()
-		if call == nil || call.Expression == nil {
-			return
-		}
-		if call.Arguments != nil && len(call.Arguments.Nodes) > 0 {
-			return
-		}
-		access := stripParens(call.Expression)
-		if access == nil || access.Kind != shimast.KindPropertyAccessExpression {
-			return
-		}
-		propAccess := access.AsPropertyAccessExpression()
-		if propAccess == nil {
-			return
-		}
-		method := identifierText(propAccess.Name())
-		if method != "getTime" && method != "valueOf" {
-			return
-		}
-		receiver := stripParens(propAccess.Expression)
-		if receiver == nil || receiver.Kind != shimast.KindNewExpression {
-			return
-		}
-		ne := receiver.AsNewExpression()
-		if ne == nil || identifierText(ne.Expression) != "Date" {
-			return
-		}
-		ctx.Report(node, "Prefer `Date.now()` over `new Date().getTime()` / `+new Date()`.")
-	case shimast.KindPrefixUnaryExpression:
-		prefix := node.AsPrefixUnaryExpression()
-		if prefix == nil || prefix.Operator != shimast.KindPlusToken || prefix.Operand == nil {
-			return
-		}
-		operand := stripParens(prefix.Operand)
-		if operand == nil || operand.Kind != shimast.KindNewExpression {
-			return
-		}
-		ne := operand.AsNewExpression()
-		if ne == nil || identifierText(ne.Expression) != "Date" {
-			return
-		}
-		ctx.Report(node, "Prefer `Date.now()` over `new Date().getTime()` / `+new Date()`.")
-	}
+  switch node.Kind {
+  case shimast.KindCallExpression:
+    call := node.AsCallExpression()
+    if call == nil || call.Expression == nil {
+      return
+    }
+    if call.Arguments != nil && len(call.Arguments.Nodes) > 0 {
+      return
+    }
+    access := stripParens(call.Expression)
+    if access == nil || access.Kind != shimast.KindPropertyAccessExpression {
+      return
+    }
+    propAccess := access.AsPropertyAccessExpression()
+    if propAccess == nil {
+      return
+    }
+    method := identifierText(propAccess.Name())
+    if method != "getTime" && method != "valueOf" {
+      return
+    }
+    receiver := stripParens(propAccess.Expression)
+    if receiver == nil || receiver.Kind != shimast.KindNewExpression {
+      return
+    }
+    ne := receiver.AsNewExpression()
+    if ne == nil || identifierText(ne.Expression) != "Date" {
+      return
+    }
+    ctx.Report(node, "Prefer `Date.now()` over `new Date().getTime()` / `+new Date()`.")
+  case shimast.KindPrefixUnaryExpression:
+    prefix := node.AsPrefixUnaryExpression()
+    if prefix == nil || prefix.Operator != shimast.KindPlusToken || prefix.Operand == nil {
+      return
+    }
+    operand := stripParens(prefix.Operand)
+    if operand == nil || operand.Kind != shimast.KindNewExpression {
+      return
+    }
+    ne := operand.AsNewExpression()
+    if ne == nil || identifierText(ne.Expression) != "Date" {
+      return
+    }
+    ctx.Report(node, "Prefer `Date.now()` over `new Date().getTime()` / `+new Date()`.")
+  }
 }
 
 func init() {
-	Register(unicornPreferDateNow{})
+  Register(unicornPreferDateNow{})
 }