@ttsc/lint 0.14.0-dev.20260529.2 → 0.14.1

package/linthost/rules_no_useless_constructor.go

@@ -28,48 +28,48 @@ type noUselessConstructor struct{}
 func (noUselessConstructor) Name() string           { return "no-useless-constructor" }
 func (noUselessConstructor) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindConstructor} }
 func (noUselessConstructor) Check(ctx *Context, node *shimast.Node) {
-	ctor := node.AsConstructorDeclaration()
-	if ctor == nil || ctor.Body == nil {
-		return
-	}
-	// Accessibility modifiers (`private`/`protected`) on the constructor
-	// itself are load-bearing: they restrict who can `new` the class.
-	// Removing the constructor would silently widen visibility.
-	if node.ModifierFlags()&(shimast.ModifierFlagsPrivate|shimast.ModifierFlagsProtected) != 0 {
-		return
-	}
-	if hasParameterProperty(node) {
-		return
-	}
-	body := ctor.Body.AsBlock()
-	if body == nil || body.Statements == nil {
-		return
-	}
-	params := node.Parameters()
+  ctor := node.AsConstructorDeclaration()
+  if ctor == nil || ctor.Body == nil {
+    return
+  }
+  // Accessibility modifiers (`private`/`protected`) on the constructor
+  // itself are load-bearing: they restrict who can `new` the class.
+  // Removing the constructor would silently widen visibility.
+  if node.ModifierFlags()&(shimast.ModifierFlagsPrivate|shimast.ModifierFlagsProtected) != 0 {
+    return
+  }
+  if hasParameterProperty(node) {
+    return
+  }
+  body := ctor.Body.AsBlock()
+  if body == nil || body.Statements == nil {
+    return
+  }
+  params := node.Parameters()
 
-	// Shape 1: empty body, no parameters. The implicit constructor that
-	// the engine generates when no constructor is written is identical,
-	// so the explicit declaration is noise.
-	if len(params) == 0 && len(body.Statements.Nodes) == 0 {
-		ctx.Report(node, "Useless empty constructor.")
-		return
-	}
+  // Shape 1: empty body, no parameters. The implicit constructor that
+  // the engine generates when no constructor is written is identical,
+  // so the explicit declaration is noise.
+  if len(params) == 0 && len(body.Statements.Nodes) == 0 {
+    ctx.Report(node, "Useless empty constructor.")
+    return
+  }
 
-	// Shape 2: derived class constructor that only forwards arguments to
-	// `super(...args)` without modification. The synthetic default
-	// constructor of a subclass behaves identically, so the explicit
-	// declaration is noise. Only fires when the class extends another.
-	parent := node.Parent
-	if parent == nil || !classExtendsAnother(parent) {
-		return
-	}
-	if len(body.Statements.Nodes) != 1 {
-		return
-	}
-	if !isPlainSuperForwarder(params, body.Statements.Nodes[0]) {
-		return
-	}
-	ctx.Report(node, "Useless constructor: forwards arguments to `super` unchanged.")
+  // Shape 2: derived class constructor that only forwards arguments to
+  // `super(...args)` without modification. The synthetic default
+  // constructor of a subclass behaves identically, so the explicit
+  // declaration is noise. Only fires when the class extends another.
+  parent := node.Parent
+  if parent == nil || !classExtendsAnother(parent) {
+    return
+  }
+  if len(body.Statements.Nodes) != 1 {
+    return
+  }
+  if !isPlainSuperForwarder(params, body.Statements.Nodes[0]) {
+    return
+  }
+  ctx.Report(node, "Useless constructor: forwards arguments to `super` unchanged.")
 }
 
 // hasParameterProperty reports whether any constructor parameter carries
@@ -78,25 +78,25 @@ func (noUselessConstructor) Check(ctx *Context, node *shimast.Node) {
 // field, so the constructor is doing real work even if its body is
 // empty — removing it would drop the field.
 func hasParameterProperty(node *shimast.Node) bool {
-	for _, p := range node.Parameters() {
-		if p == nil {
-			continue
-		}
-		if p.ModifierFlags()&(shimast.ModifierFlagsPrivate|shimast.ModifierFlagsProtected|shimast.ModifierFlagsReadonly) != 0 {
-			return true
-		}
-		// `public` is not represented by any of the above flags but does
-		// still create a parameter property. Inspect the raw modifier
-		// list for a PublicKeyword.
-		decl := p.AsParameterDeclaration()
-		if decl == nil {
-			continue
-		}
-		if hasPublicModifier(decl.Modifiers()) {
-			return true
-		}
-	}
-	return false
+  for _, p := range node.Parameters() {
+    if p == nil {
+      continue
+    }
+    if p.ModifierFlags()&(shimast.ModifierFlagsPrivate|shimast.ModifierFlagsProtected|shimast.ModifierFlagsReadonly) != 0 {
+      return true
+    }
+    // `public` is not represented by any of the above flags but does
+    // still create a parameter property. Inspect the raw modifier
+    // list for a PublicKeyword.
+    decl := p.AsParameterDeclaration()
+    if decl == nil {
+      continue
+    }
+    if hasPublicModifier(decl.Modifiers()) {
+      return true
+    }
+  }
+  return false
 }
 
 // hasPublicModifier reports whether `mods` includes a `public` keyword.
@@ -104,15 +104,15 @@ func hasParameterProperty(node *shimast.Node) bool {
 // the Private/Protected/Readonly modifier flags, so we walk the raw
 // modifier list to detect it.
 func hasPublicModifier(mods *shimast.ModifierList) bool {
-	if mods == nil {
-		return false
-	}
-	for _, m := range mods.Nodes {
-		if m != nil && m.Kind == shimast.KindPublicKeyword {
-			return true
-		}
-	}
-	return false
+  if mods == nil {
+    return false
+  }
+  for _, m := range mods.Nodes {
+    if m != nil && m.Kind == shimast.KindPublicKeyword {
+      return true
+    }
+  }
+  return false
 }
 
 // isPlainSuperForwarder reports whether `stmt` is exactly
@@ -123,57 +123,57 @@ func hasPublicModifier(mods *shimast.ModifierList) bool {
 // the rest parameter are allowed — `(...args: unknown[])` still
 // forwards unchanged.
 func isPlainSuperForwarder(params []*shimast.Node, stmt *shimast.Node) bool {
-	if stmt == nil || stmt.Kind != shimast.KindExpressionStatement {
-		return false
-	}
-	exprStmt := stmt.AsExpressionStatement()
-	if exprStmt == nil || exprStmt.Expression == nil {
-		return false
-	}
-	expr := stripParens(exprStmt.Expression)
-	if expr == nil || expr.Kind != shimast.KindCallExpression {
-		return false
-	}
-	call := expr.AsCallExpression()
-	if call == nil || call.Expression == nil || call.Expression.Kind != shimast.KindSuperKeyword {
-		return false
-	}
-	if call.Arguments == nil {
-		return false
-	}
-	args := call.Arguments.Nodes
-	// `super()` — zero arguments — only matches when the constructor
-	// also declares zero parameters. ESLint flags this shape too: the
-	// synthetic default constructor of a derived class would call
-	// `super(...args)`, which for a zero-arg case is the same thing.
-	if len(args) == 0 {
-		return len(params) == 0
-	}
-	if len(args) != len(params) {
-		return false
-	}
-	// All arguments must be `...name` spreading the identically named
-	// rest parameter. ESLint also accepts the positional `super(a, b)`
-	// over `(a, b)` shape — match that too: every parameter must be a
-	// plain identifier (or rest), and the argument must spread/use the
-	// same identifier in the same position.
-	for i, arg := range args {
-		paramName, paramRest, ok := plainParamIdentifier(params[i])
-		if !ok {
-			return false
-		}
-		argName, argSpread, ok := plainArgIdentifier(arg)
-		if !ok {
-			return false
-		}
-		if paramName != argName {
-			return false
-		}
-		if paramRest != argSpread {
-			return false
-		}
-	}
-	return true
+  if stmt == nil || stmt.Kind != shimast.KindExpressionStatement {
+    return false
+  }
+  exprStmt := stmt.AsExpressionStatement()
+  if exprStmt == nil || exprStmt.Expression == nil {
+    return false
+  }
+  expr := stripParens(exprStmt.Expression)
+  if expr == nil || expr.Kind != shimast.KindCallExpression {
+    return false
+  }
+  call := expr.AsCallExpression()
+  if call == nil || call.Expression == nil || call.Expression.Kind != shimast.KindSuperKeyword {
+    return false
+  }
+  if call.Arguments == nil {
+    return false
+  }
+  args := call.Arguments.Nodes
+  // `super()` — zero arguments — only matches when the constructor
+  // also declares zero parameters. ESLint flags this shape too: the
+  // synthetic default constructor of a derived class would call
+  // `super(...args)`, which for a zero-arg case is the same thing.
+  if len(args) == 0 {
+    return len(params) == 0
+  }
+  if len(args) != len(params) {
+    return false
+  }
+  // All arguments must be `...name` spreading the identically named
+  // rest parameter. ESLint also accepts the positional `super(a, b)`
+  // over `(a, b)` shape — match that too: every parameter must be a
+  // plain identifier (or rest), and the argument must spread/use the
+  // same identifier in the same position.
+  for i, arg := range args {
+    paramName, paramRest, ok := plainParamIdentifier(params[i])
+    if !ok {
+      return false
+    }
+    argName, argSpread, ok := plainArgIdentifier(arg)
+    if !ok {
+      return false
+    }
+    if paramName != argName {
+      return false
+    }
+    if paramRest != argSpread {
+      return false
+    }
+  }
+  return true
 }
 
 // plainParamIdentifier extracts the identifier name of a parameter that
@@ -184,29 +184,29 @@ func isPlainSuperForwarder(params []*shimast.Node, stmt *shimast.Node) bool {
 // Type annotations are intentionally ignored — they do not change the
 // runtime forwarding behavior.
 func plainParamIdentifier(param *shimast.Node) (string, bool, bool) {
-	if param == nil {
-		return "", false, false
-	}
-	decl := param.AsParameterDeclaration()
-	if decl == nil {
-		return "", false, false
-	}
-	if decl.Initializer != nil || decl.QuestionToken != nil {
-		return "", false, false
-	}
-	// Accessibility modifier on the parameter would already have been
-	// caught by hasParameterProperty above, but guard locally too.
-	if param.ModifierFlags()&(shimast.ModifierFlagsPrivate|shimast.ModifierFlagsProtected|shimast.ModifierFlagsReadonly) != 0 {
-		return "", false, false
-	}
-	if hasPublicModifier(decl.Modifiers()) {
-		return "", false, false
-	}
-	name := identifierText(decl.Name())
-	if name == "" {
-		return "", false, false
-	}
-	return name, decl.DotDotDotToken != nil, true
+  if param == nil {
+    return "", false, false
+  }
+  decl := param.AsParameterDeclaration()
+  if decl == nil {
+    return "", false, false
+  }
+  if decl.Initializer != nil || decl.QuestionToken != nil {
+    return "", false, false
+  }
+  // Accessibility modifier on the parameter would already have been
+  // caught by hasParameterProperty above, but guard locally too.
+  if param.ModifierFlags()&(shimast.ModifierFlagsPrivate|shimast.ModifierFlagsProtected|shimast.ModifierFlagsReadonly) != 0 {
+    return "", false, false
+  }
+  if hasPublicModifier(decl.Modifiers()) {
+    return "", false, false
+  }
+  name := identifierText(decl.Name())
+  if name == "" {
+    return "", false, false
+  }
+  return name, decl.DotDotDotToken != nil, true
 }
 
 // plainArgIdentifier extracts the identifier name of a call argument
@@ -214,32 +214,32 @@ func plainParamIdentifier(param *shimast.Node) (string, bool, bool) {
 // on match. Anything else — a literal, property access, expression —
 // is treated as observable work and disqualifies the forwarder.
 func plainArgIdentifier(arg *shimast.Node) (string, bool, bool) {
-	if arg == nil {
-		return "", false, false
-	}
-	stripped := stripParens(arg)
-	if stripped == nil {
-		return "", false, false
-	}
-	if stripped.Kind == shimast.KindSpreadElement {
-		spread := stripped.AsSpreadElement()
-		if spread == nil {
-			return "", false, false
-		}
-		inner := stripParens(spread.Expression)
-		name := identifierText(inner)
-		if name == "" {
-			return "", false, false
-		}
-		return name, true, true
-	}
-	name := identifierText(stripped)
-	if name == "" {
-		return "", false, false
-	}
-	return name, false, true
+  if arg == nil {
+    return "", false, false
+  }
+  stripped := stripParens(arg)
+  if stripped == nil {
+    return "", false, false
+  }
+  if stripped.Kind == shimast.KindSpreadElement {
+    spread := stripped.AsSpreadElement()
+    if spread == nil {
+      return "", false, false
+    }
+    inner := stripParens(spread.Expression)
+    name := identifierText(inner)
+    if name == "" {
+      return "", false, false
+    }
+    return name, true, true
+  }
+  name := identifierText(stripped)
+  if name == "" {
+    return "", false, false
+  }
+  return name, false, true
 }
 
 func init() {
-	Register(noUselessConstructor{})
+  Register(noUselessConstructor{})
 }

package/linthost/rules_no_useless_return.go

@@ -9,43 +9,43 @@
 package linthost
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 type noUselessReturn struct{}
 
 func (noUselessReturn) Name() string { return "no-useless-return" }
 func (noUselessReturn) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindReturnStatement}
+  return []shimast.Kind{shimast.KindReturnStatement}
 }
 func (noUselessReturn) Check(ctx *Context, node *shimast.Node) {
-	ret := node.AsReturnStatement()
-	if ret == nil || ret.Expression != nil {
-		// `return X;` is never useless: it carries a value.
-		return
-	}
-	parent := node.Parent
-	if parent == nil || parent.Kind != shimast.KindBlock {
-		return
-	}
-	block := parent.AsBlock()
-	if block == nil || block.Statements == nil {
-		return
-	}
-	stmts := block.Statements.Nodes
-	if len(stmts) == 0 || stmts[len(stmts)-1] != node {
-		// Only the last statement of the block is provably useless;
-		// any earlier `return;` may guard the statements that follow.
-		return
-	}
-	if !isFunctionLikeKind(parent.Parent) {
-		// The block must be the immediate body of a function-like so
-		// the function's natural completion is what would run next.
-		return
-	}
-	ctx.Report(node, "Unnecessary return statement.")
+  ret := node.AsReturnStatement()
+  if ret == nil || ret.Expression != nil {
+    // `return X;` is never useless: it carries a value.
+    return
+  }
+  parent := node.Parent
+  if parent == nil || parent.Kind != shimast.KindBlock {
+    return
+  }
+  block := parent.AsBlock()
+  if block == nil || block.Statements == nil {
+    return
+  }
+  stmts := block.Statements.Nodes
+  if len(stmts) == 0 || stmts[len(stmts)-1] != node {
+    // Only the last statement of the block is provably useless;
+    // any earlier `return;` may guard the statements that follow.
+    return
+  }
+  if !isFunctionLikeKind(parent.Parent) {
+    // The block must be the immediate body of a function-like so
+    // the function's natural completion is what would run next.
+    return
+  }
+  ctx.Report(node, "Unnecessary return statement.")
 }
 
 func init() {
-	Register(noUselessReturn{})
+  Register(noUselessReturn{})
 }

package/linthost/rules_prefer_arrow_callback.go

@@ -27,44 +27,44 @@ type preferArrowCallback struct{}
 
 func (preferArrowCallback) Name() string { return "prefer-arrow-callback" }
 func (preferArrowCallback) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindCallExpression, shimast.KindNewExpression}
+  return []shimast.Kind{shimast.KindCallExpression, shimast.KindNewExpression}
 }
 func (preferArrowCallback) Check(ctx *Context, node *shimast.Node) {
-	args := callArgumentsList(node)
-	if args == nil {
-		return
-	}
-	for _, arg := range args.Nodes {
-		fn := stripParens(arg)
-		if fn == nil || fn.Kind != shimast.KindFunctionExpression {
-			continue
-		}
-		if !preferArrowCallbackEligible(fn) {
-			continue
-		}
-		ctx.Report(fn, "Unexpected function expression. Use an arrow function instead.")
-	}
+  args := callArgumentsList(node)
+  if args == nil {
+    return
+  }
+  for _, arg := range args.Nodes {
+    fn := stripParens(arg)
+    if fn == nil || fn.Kind != shimast.KindFunctionExpression {
+      continue
+    }
+    if !preferArrowCallbackEligible(fn) {
+      continue
+    }
+    ctx.Report(fn, "Unexpected function expression. Use an arrow function instead.")
+  }
 }
 
 // callArgumentsList returns the argument NodeList of a CallExpression or
 // NewExpression, or nil when the node either lacks arguments or is not a
 // call/new shape.
 func callArgumentsList(node *shimast.Node) *shimast.NodeList {
-	switch node.Kind {
-	case shimast.KindCallExpression:
-		call := node.AsCallExpression()
-		if call == nil {
-			return nil
-		}
-		return call.Arguments
-	case shimast.KindNewExpression:
-		newExpr := node.AsNewExpression()
-		if newExpr == nil {
-			return nil
-		}
-		return newExpr.Arguments
-	}
-	return nil
+  switch node.Kind {
+  case shimast.KindCallExpression:
+    call := node.AsCallExpression()
+    if call == nil {
+      return nil
+    }
+    return call.Arguments
+  case shimast.KindNewExpression:
+    newExpr := node.AsNewExpression()
+    if newExpr == nil {
+      return nil
+    }
+    return newExpr.Arguments
+  }
+  return nil
 }
 
 // preferArrowCallbackEligible reports whether `fn` (a FunctionExpression)
@@ -74,51 +74,51 @@ func callArgumentsList(node *shimast.Node) *shimast.NodeList {
 // its own inner name (a self-recursion handle that an arrow cannot
 // reproduce).
 func preferArrowCallbackEligible(fn *shimast.Node) bool {
-	expr := fn.AsFunctionExpression()
-	if expr == nil {
-		return false
-	}
-	if expr.AsteriskToken != nil {
-		return false
-	}
-	innerName := identifierText(expr.Name())
-	body := expr.Body
-	if body == nil {
-		return true
-	}
-	usesForbidden := false
-	walkFunctionBody(body, func(child *shimast.Node) {
-		if usesForbidden || child == nil {
-			return
-		}
-		switch child.Kind {
-		case shimast.KindThisKeyword:
-			usesForbidden = true
-		case shimast.KindIdentifier:
-			text := identifierText(child)
-			if text == "arguments" {
-				// Skip `obj.arguments` — that's an unrelated member access.
-				if parent := child.Parent; parent != nil && parent.Kind == shimast.KindPropertyAccessExpression {
-					if access := parent.AsPropertyAccessExpression(); access != nil && access.Name() == child {
-						return
-					}
-				}
-				usesForbidden = true
-				return
-			}
-			if innerName != "" && text == innerName {
-				if parent := child.Parent; parent != nil && parent.Kind == shimast.KindPropertyAccessExpression {
-					if access := parent.AsPropertyAccessExpression(); access != nil && access.Name() == child {
-						return
-					}
-				}
-				usesForbidden = true
-			}
-		}
-	})
-	return !usesForbidden
+  expr := fn.AsFunctionExpression()
+  if expr == nil {
+    return false
+  }
+  if expr.AsteriskToken != nil {
+    return false
+  }
+  innerName := identifierText(expr.Name())
+  body := expr.Body
+  if body == nil {
+    return true
+  }
+  usesForbidden := false
+  walkFunctionBody(body, func(child *shimast.Node) {
+    if usesForbidden || child == nil {
+      return
+    }
+    switch child.Kind {
+    case shimast.KindThisKeyword:
+      usesForbidden = true
+    case shimast.KindIdentifier:
+      text := identifierText(child)
+      if text == "arguments" {
+        // Skip `obj.arguments` — that's an unrelated member access.
+        if parent := child.Parent; parent != nil && parent.Kind == shimast.KindPropertyAccessExpression {
+          if access := parent.AsPropertyAccessExpression(); access != nil && access.Name() == child {
+            return
+          }
+        }
+        usesForbidden = true
+        return
+      }
+      if innerName != "" && text == innerName {
+        if parent := child.Parent; parent != nil && parent.Kind == shimast.KindPropertyAccessExpression {
+          if access := parent.AsPropertyAccessExpression(); access != nil && access.Name() == child {
+            return
+          }
+        }
+        usesForbidden = true
+      }
+    }
+  })
+  return !usesForbidden
 }
 
 func init() {
-	Register(preferArrowCallback{})
+  Register(preferArrowCallback{})
 }