@ttsc/lint 0.14.0-dev.20260529.2 → 0.14.1

package/linthost/rules_prefer_destructuring.go

@@ -20,79 +20,79 @@
 package linthost
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 type preferDestructuring struct{}
 
 func (preferDestructuring) Name() string { return "prefer-destructuring" }
 func (preferDestructuring) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindVariableDeclaration}
+  return []shimast.Kind{shimast.KindVariableDeclaration}
 }
 func (preferDestructuring) Check(ctx *Context, node *shimast.Node) {
-	decl := node.AsVariableDeclaration()
-	if decl == nil || decl.Initializer == nil {
-		return
-	}
-	// Only fire on plain identifier bindings — destructuring already
-	// happens on `const { a } = obj;`.
-	name := decl.Name()
-	if name == nil || name.Kind != shimast.KindIdentifier {
-		return
-	}
-	varName := identifierText(name)
-	if varName == "" {
-		return
-	}
-	init := stripParens(decl.Initializer)
-	if init == nil {
-		return
-	}
-	switch init.Kind {
-	case shimast.KindPropertyAccessExpression:
-		access := init.AsPropertyAccessExpression()
-		if access == nil || access.Expression == nil || !preferDestructuringSimpleReceiver(access.Expression) {
-			return
-		}
-		propName := access.Name()
-		if propName == nil || propName.Kind != shimast.KindIdentifier {
-			return
-		}
-		if identifierText(propName) != varName {
-			return
-		}
-		ctx.Report(node, "Use object destructuring (`const { "+varName+" } = obj`).")
-	case shimast.KindElementAccessExpression:
-		access := init.AsElementAccessExpression()
-		if access == nil || access.Expression == nil || access.ArgumentExpression == nil {
-			return
-		}
-		if !preferDestructuringSimpleReceiver(access.Expression) {
-			return
-		}
-		// Only numeric-literal index — array destructuring.
-		idx := stripParens(access.ArgumentExpression)
-		if idx == nil || idx.Kind != shimast.KindNumericLiteral {
-			return
-		}
-		ctx.Report(node, "Use array destructuring (`const ["+varName+"] = arr`).")
-	}
+  decl := node.AsVariableDeclaration()
+  if decl == nil || decl.Initializer == nil {
+    return
+  }
+  // Only fire on plain identifier bindings — destructuring already
+  // happens on `const { a } = obj;`.
+  name := decl.Name()
+  if name == nil || name.Kind != shimast.KindIdentifier {
+    return
+  }
+  varName := identifierText(name)
+  if varName == "" {
+    return
+  }
+  init := stripParens(decl.Initializer)
+  if init == nil {
+    return
+  }
+  switch init.Kind {
+  case shimast.KindPropertyAccessExpression:
+    access := init.AsPropertyAccessExpression()
+    if access == nil || access.Expression == nil || !preferDestructuringSimpleReceiver(access.Expression) {
+      return
+    }
+    propName := access.Name()
+    if propName == nil || propName.Kind != shimast.KindIdentifier {
+      return
+    }
+    if identifierText(propName) != varName {
+      return
+    }
+    ctx.Report(node, "Use object destructuring (`const { "+varName+" } = obj`).")
+  case shimast.KindElementAccessExpression:
+    access := init.AsElementAccessExpression()
+    if access == nil || access.Expression == nil || access.ArgumentExpression == nil {
+      return
+    }
+    if !preferDestructuringSimpleReceiver(access.Expression) {
+      return
+    }
+    // Only numeric-literal index — array destructuring.
+    idx := stripParens(access.ArgumentExpression)
+    if idx == nil || idx.Kind != shimast.KindNumericLiteral {
+      return
+    }
+    ctx.Report(node, "Use array destructuring (`const ["+varName+"] = arr`).")
+  }
 }
 
 func preferDestructuringSimpleReceiver(node *shimast.Node) bool {
-	n := stripParens(node)
-	if n == nil {
-		return false
-	}
-	switch n.Kind {
-	case shimast.KindIdentifier,
-		shimast.KindThisKeyword,
-		shimast.KindPropertyAccessExpression:
-		return true
-	}
-	return false
+  n := stripParens(node)
+  if n == nil {
+    return false
+  }
+  switch n.Kind {
+  case shimast.KindIdentifier,
+    shimast.KindThisKeyword,
+    shimast.KindPropertyAccessExpression:
+    return true
+  }
+  return false
 }
 
 func init() {
-	Register(preferDestructuring{})
+  Register(preferDestructuring{})
 }

package/linthost/rules_prefer_named_capture_group.go

@@ -19,21 +19,21 @@ type preferNamedCaptureGroup struct{}
 
 func (preferNamedCaptureGroup) Name() string { return "prefer-named-capture-group" }
 func (preferNamedCaptureGroup) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindRegularExpressionLiteral}
+  return []shimast.Kind{shimast.KindRegularExpressionLiteral}
 }
 func (preferNamedCaptureGroup) Check(ctx *Context, node *shimast.Node) {
-	raw := nodeText(ctx.File, node)
-	if len(raw) < 2 || raw[0] != '/' {
-		return
-	}
-	closing := lastSlashOutsideClass(raw)
-	if closing <= 0 {
-		return
-	}
-	pattern := raw[1:closing]
-	if regexpHasUnnamedCapture(pattern) {
-		ctx.Report(node, "Capture group should be named.")
-	}
+  raw := nodeText(ctx.File, node)
+  if len(raw) < 2 || raw[0] != '/' {
+    return
+  }
+  closing := lastSlashOutsideClass(raw)
+  if closing <= 0 {
+    return
+  }
+  pattern := raw[1:closing]
+  if regexpHasUnnamedCapture(pattern) {
+    ctx.Report(node, "Capture group should be named.")
+  }
 }
 
 // regexpHasUnnamedCapture reports whether `pattern` contains at least
@@ -43,87 +43,87 @@ func (preferNamedCaptureGroup) Check(ctx *Context, node *shimast.Node) {
 // character-class contents because `(` is a literal byte in those
 // positions and never opens a group.
 func regexpHasUnnamedCapture(pattern string) bool {
-	inClass := false
-	for i := 0; i < len(pattern); i++ {
-		ch := pattern[i]
-		if ch == '\\' {
-			i++
-			continue
-		}
-		if inClass {
-			if ch == ']' {
-				inClass = false
-			}
-			continue
-		}
-		if ch == '[' {
-			inClass = true
-			continue
-		}
-		if ch != '(' {
-			continue
-		}
-		// `(` is a group opener; classify what follows.
-		if i+1 >= len(pattern) || pattern[i+1] != '?' {
-			return true
-		}
-		if i+2 >= len(pattern) {
-			// `(?` with nothing after — treat as malformed but not flagged;
-			// the parser would have rejected this regex if it was truly
-			// invalid, so leave it alone.
-			continue
-		}
-		switch pattern[i+2] {
-		case ':', '=', '!':
-			// non-capturing or lookahead
-			continue
-		case '<':
-			if i+3 < len(pattern) && (pattern[i+3] == '=' || pattern[i+3] == '!') {
-				// lookbehind `(?<=` / `(?<!`
-				continue
-			}
-			// named capture `(?<name>…)`
-			continue
-		}
-		// `(?` followed by something else (e.g. an inline flag group).
-		// Treat as unnamed; ESLint flags these too because they still
-		// capture under the standard regex semantics they target.
-		return true
-	}
-	return false
+  inClass := false
+  for i := 0; i < len(pattern); i++ {
+    ch := pattern[i]
+    if ch == '\\' {
+      i++
+      continue
+    }
+    if inClass {
+      if ch == ']' {
+        inClass = false
+      }
+      continue
+    }
+    if ch == '[' {
+      inClass = true
+      continue
+    }
+    if ch != '(' {
+      continue
+    }
+    // `(` is a group opener; classify what follows.
+    if i+1 >= len(pattern) || pattern[i+1] != '?' {
+      return true
+    }
+    if i+2 >= len(pattern) {
+      // `(?` with nothing after — treat as malformed but not flagged;
+      // the parser would have rejected this regex if it was truly
+      // invalid, so leave it alone.
+      continue
+    }
+    switch pattern[i+2] {
+    case ':', '=', '!':
+      // non-capturing or lookahead
+      continue
+    case '<':
+      if i+3 < len(pattern) && (pattern[i+3] == '=' || pattern[i+3] == '!') {
+        // lookbehind `(?<=` / `(?<!`
+        continue
+      }
+      // named capture `(?<name>…)`
+      continue
+    }
+    // `(?` followed by something else (e.g. an inline flag group).
+    // Treat as unnamed; ESLint flags these too because they still
+    // capture under the standard regex semantics they target.
+    return true
+  }
+  return false
 }
 
 // lastSlashOutsideClass returns the index of the closing `/` of a regex
 // literal, accounting for `/` characters that appear inside escapes or
 // character classes. Returns -1 when no closing slash is found.
 func lastSlashOutsideClass(raw string) int {
-	if len(raw) < 2 || raw[0] != '/' {
-		return -1
-	}
-	inClass := false
-	for i := 1; i < len(raw); i++ {
-		ch := raw[i]
-		if ch == '\\' {
-			i++
-			continue
-		}
-		if inClass {
-			if ch == ']' {
-				inClass = false
-			}
-			continue
-		}
-		if ch == '[' {
-			inClass = true
-			continue
-		}
-		if ch == '/' {
-			return i
-		}
-	}
-	return -1
+  if len(raw) < 2 || raw[0] != '/' {
+    return -1
+  }
+  inClass := false
+  for i := 1; i < len(raw); i++ {
+    ch := raw[i]
+    if ch == '\\' {
+      i++
+      continue
+    }
+    if inClass {
+      if ch == ']' {
+        inClass = false
+      }
+      continue
+    }
+    if ch == '[' {
+      inClass = true
+      continue
+    }
+    if ch == '/' {
+      return i
+    }
+  }
+  return -1
 }
 
 func init() {
-	Register(preferNamedCaptureGroup{})
+  Register(preferNamedCaptureGroup{})
 }

package/linthost/rules_prefer_rest_params.go

@@ -16,79 +16,79 @@
 package linthost
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 type preferRestParams struct{}
 
 func (preferRestParams) Name() string { return "prefer-rest-params" }
 func (preferRestParams) Visits() []shimast.Kind {
-	return []shimast.Kind{
-		shimast.KindFunctionDeclaration,
-		shimast.KindFunctionExpression,
-		shimast.KindMethodDeclaration,
-		shimast.KindGetAccessor,
-		shimast.KindSetAccessor,
-		shimast.KindConstructor,
-	}
+  return []shimast.Kind{
+    shimast.KindFunctionDeclaration,
+    shimast.KindFunctionExpression,
+    shimast.KindMethodDeclaration,
+    shimast.KindGetAccessor,
+    shimast.KindSetAccessor,
+    shimast.KindConstructor,
+  }
 }
 func (preferRestParams) Check(ctx *Context, node *shimast.Node) {
-	body := preferRestParamsBody(node)
-	if body == nil {
-		return
-	}
-	reported := false
-	walkFunctionBody(body, func(child *shimast.Node) {
-		if reported || child == nil {
-			return
-		}
-		if child.Kind != shimast.KindIdentifier {
-			return
-		}
-		if identifierText(child) != "arguments" {
-			return
-		}
-		// 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
-			}
-		}
-		reported = true
-		ctx.Report(child, "Use rest parameters (`...args`) instead of `arguments`.")
-	})
+  body := preferRestParamsBody(node)
+  if body == nil {
+    return
+  }
+  reported := false
+  walkFunctionBody(body, func(child *shimast.Node) {
+    if reported || child == nil {
+      return
+    }
+    if child.Kind != shimast.KindIdentifier {
+      return
+    }
+    if identifierText(child) != "arguments" {
+      return
+    }
+    // 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
+      }
+    }
+    reported = true
+    ctx.Report(child, "Use rest parameters (`...args`) instead of `arguments`.")
+  })
 }
 
 func preferRestParamsBody(node *shimast.Node) *shimast.Node {
-	switch node.Kind {
-	case shimast.KindFunctionDeclaration:
-		if fn := node.AsFunctionDeclaration(); fn != nil {
-			return fn.Body
-		}
-	case shimast.KindFunctionExpression:
-		if fn := node.AsFunctionExpression(); fn != nil {
-			return fn.Body
-		}
-	case shimast.KindMethodDeclaration:
-		if m := node.AsMethodDeclaration(); m != nil {
-			return m.Body
-		}
-	case shimast.KindGetAccessor:
-		if a := node.AsGetAccessorDeclaration(); a != nil {
-			return a.Body
-		}
-	case shimast.KindSetAccessor:
-		if a := node.AsSetAccessorDeclaration(); a != nil {
-			return a.Body
-		}
-	case shimast.KindConstructor:
-		if c := node.AsConstructorDeclaration(); c != nil {
-			return c.Body
-		}
-	}
-	return nil
+  switch node.Kind {
+  case shimast.KindFunctionDeclaration:
+    if fn := node.AsFunctionDeclaration(); fn != nil {
+      return fn.Body
+    }
+  case shimast.KindFunctionExpression:
+    if fn := node.AsFunctionExpression(); fn != nil {
+      return fn.Body
+    }
+  case shimast.KindMethodDeclaration:
+    if m := node.AsMethodDeclaration(); m != nil {
+      return m.Body
+    }
+  case shimast.KindGetAccessor:
+    if a := node.AsGetAccessorDeclaration(); a != nil {
+      return a.Body
+    }
+  case shimast.KindSetAccessor:
+    if a := node.AsSetAccessorDeclaration(); a != nil {
+      return a.Body
+    }
+  case shimast.KindConstructor:
+    if c := node.AsConstructorDeclaration(); c != nil {
+      return c.Body
+    }
+  }
+  return nil
 }
 
 func init() {
-	Register(preferRestParams{})
+  Register(preferRestParams{})
 }