@ttsc/lint 0.7.2 → 0.8.0-dev.20260505

package/plugin/rules_dupes.go

@@ -9,33 +9,33 @@ type noDuplicateCase struct{}
 func (noDuplicateCase) Name() string           { return "no-duplicate-case" }
 func (noDuplicateCase) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindSwitchStatement} }
 func (noDuplicateCase) Check(ctx *Context, node *shimast.Node) {
-	sw := node.AsSwitchStatement()
-	if sw == nil || sw.CaseBlock == nil {
-		return
-	}
-	block := sw.CaseBlock.AsCaseBlock()
-	if block == nil || block.Clauses == nil {
-		return
-	}
-	seen := make(map[string]bool, len(block.Clauses.Nodes))
-	for _, clause := range block.Clauses.Nodes {
-		if clause == nil || clause.Kind != shimast.KindCaseClause {
-			continue
-		}
-		caseClause := clause.AsCaseOrDefaultClause()
-		if caseClause == nil || caseClause.Expression == nil {
-			continue
-		}
-		key := nodeText(ctx.File, caseClause.Expression)
-		if key == "" {
-			continue
-		}
-		if seen[key] {
-			ctx.Report(clause, "Duplicate case label.")
-			continue
-		}
-		seen[key] = true
-	}
+  sw := node.AsSwitchStatement()
+  if sw == nil || sw.CaseBlock == nil {
+    return
+  }
+  block := sw.CaseBlock.AsCaseBlock()
+  if block == nil || block.Clauses == nil {
+    return
+  }
+  seen := make(map[string]bool, len(block.Clauses.Nodes))
+  for _, clause := range block.Clauses.Nodes {
+    if clause == nil || clause.Kind != shimast.KindCaseClause {
+      continue
+    }
+    caseClause := clause.AsCaseOrDefaultClause()
+    if caseClause == nil || caseClause.Expression == nil {
+      continue
+    }
+    key := nodeText(ctx.File, caseClause.Expression)
+    if key == "" {
+      continue
+    }
+    if seen[key] {
+      ctx.Report(clause, "Duplicate case label.")
+      continue
+    }
+    seen[key] = true
+  }
 }
 
 // no-dupe-keys: duplicated property names in a single object literal.
@@ -45,23 +45,23 @@ type noDupeKeys struct{}
 func (noDupeKeys) Name() string           { return "no-dupe-keys" }
 func (noDupeKeys) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindObjectLiteralExpression} }
 func (noDupeKeys) Check(ctx *Context, node *shimast.Node) {
-	obj := node.AsObjectLiteralExpression()
-	if obj == nil || obj.Properties == nil {
-		return
-	}
-	seen := make(map[string]*shimast.Node, len(obj.Properties.Nodes))
-	for _, prop := range obj.Properties.Nodes {
-		key := propertyKey(ctx.File, prop)
-		if key == "" {
-			continue
-		}
-		if first, ok := seen[key]; ok {
-			ctx.Report(prop, "Duplicate key '"+key+"'.")
-			_ = first
-			continue
-		}
-		seen[key] = prop
-	}
+  obj := node.AsObjectLiteralExpression()
+  if obj == nil || obj.Properties == nil {
+    return
+  }
+  seen := make(map[string]*shimast.Node, len(obj.Properties.Nodes))
+  for _, prop := range obj.Properties.Nodes {
+    key := propertyKey(ctx.File, prop)
+    if key == "" {
+      continue
+    }
+    if first, ok := seen[key]; ok {
+      ctx.Report(prop, "Duplicate key '"+key+"'.")
+      _ = first
+      continue
+    }
+    seen[key] = prop
+  }
 }
 
 // no-dupe-args: duplicated parameter names in a single function head.
@@ -70,34 +70,34 @@ type noDupeArgs struct{}
 
 func (noDupeArgs) Name() string { return "no-dupe-args" }
 func (noDupeArgs) Visits() []shimast.Kind {
-	return []shimast.Kind{
-		shimast.KindFunctionDeclaration,
-		shimast.KindFunctionExpression,
-		shimast.KindArrowFunction,
-		shimast.KindMethodDeclaration,
-		shimast.KindConstructor,
-		shimast.KindGetAccessor,
-		shimast.KindSetAccessor,
-	}
+  return []shimast.Kind{
+    shimast.KindFunctionDeclaration,
+    shimast.KindFunctionExpression,
+    shimast.KindArrowFunction,
+    shimast.KindMethodDeclaration,
+    shimast.KindConstructor,
+    shimast.KindGetAccessor,
+    shimast.KindSetAccessor,
+  }
 }
 func (noDupeArgs) Check(ctx *Context, node *shimast.Node) {
-	params := node.Parameters()
-	seen := make(map[string]bool, len(params))
-	for _, param := range params {
-		paramDecl := param.AsParameterDeclaration()
-		if paramDecl == nil {
-			continue
-		}
-		name := identifierText(paramDecl.Name())
-		if name == "" {
-			continue
-		}
-		if seen[name] {
-			ctx.Report(param, "Duplicate parameter name '"+name+"'.")
-			continue
-		}
-		seen[name] = true
-	}
+  params := node.Parameters()
+  seen := make(map[string]bool, len(params))
+  for _, param := range params {
+    paramDecl := param.AsParameterDeclaration()
+    if paramDecl == nil {
+      continue
+    }
+    name := identifierText(paramDecl.Name())
+    if name == "" {
+      continue
+    }
+    if seen[name] {
+      ctx.Report(param, "Duplicate parameter name '"+name+"'.")
+      continue
+    }
+    seen[name] = true
+  }
 }
 
 // propertyKey returns a stable key for a property in an object literal.
@@ -106,74 +106,74 @@ func (noDupeArgs) Check(ctx *Context, node *shimast.Node) {
 // expressions still won't cause false positives because the same expr
 // produces the same source text).
 func propertyKey(file *shimast.SourceFile, prop *shimast.Node) string {
-	if prop == nil {
-		return ""
-	}
-	switch prop.Kind {
-	case shimast.KindPropertyAssignment:
-		assignment := prop.AsPropertyAssignment()
-		if assignment == nil {
-			return ""
-		}
-		return staticPropertyKey(file, assignment.Name())
-	case shimast.KindShorthandPropertyAssignment:
-		short := prop.AsShorthandPropertyAssignment()
-		if short == nil {
-			return ""
-		}
-		return staticPropertyKey(file, short.Name())
-	case shimast.KindMethodDeclaration:
-		method := prop.AsMethodDeclaration()
-		if method == nil {
-			return ""
-		}
-		return staticPropertyKey(file, method.Name())
-	case shimast.KindGetAccessor, shimast.KindSetAccessor:
-		// Getter and setter pairs share a name but are not duplicates.
-		// Add a kind suffix so the dedupe key separates them.
-		switch prop.Kind {
-		case shimast.KindGetAccessor:
-			get := prop.AsGetAccessorDeclaration()
-			if get == nil {
-				return ""
-			}
-			if k := staticPropertyKey(file, get.Name()); k != "" {
-				return "get:" + k
-			}
-		case shimast.KindSetAccessor:
-			set := prop.AsSetAccessorDeclaration()
-			if set == nil {
-				return ""
-			}
-			if k := staticPropertyKey(file, set.Name()); k != "" {
-				return "set:" + k
-			}
-		}
-	}
-	return ""
+  if prop == nil {
+    return ""
+  }
+  switch prop.Kind {
+  case shimast.KindPropertyAssignment:
+    assignment := prop.AsPropertyAssignment()
+    if assignment == nil {
+      return ""
+    }
+    return staticPropertyKey(file, assignment.Name())
+  case shimast.KindShorthandPropertyAssignment:
+    short := prop.AsShorthandPropertyAssignment()
+    if short == nil {
+      return ""
+    }
+    return staticPropertyKey(file, short.Name())
+  case shimast.KindMethodDeclaration:
+    method := prop.AsMethodDeclaration()
+    if method == nil {
+      return ""
+    }
+    return staticPropertyKey(file, method.Name())
+  case shimast.KindGetAccessor, shimast.KindSetAccessor:
+    // Getter and setter pairs share a name but are not duplicates.
+    // Add a kind suffix so the dedupe key separates them.
+    switch prop.Kind {
+    case shimast.KindGetAccessor:
+      get := prop.AsGetAccessorDeclaration()
+      if get == nil {
+        return ""
+      }
+      if k := staticPropertyKey(file, get.Name()); k != "" {
+        return "get:" + k
+      }
+    case shimast.KindSetAccessor:
+      set := prop.AsSetAccessorDeclaration()
+      if set == nil {
+        return ""
+      }
+      if k := staticPropertyKey(file, set.Name()); k != "" {
+        return "set:" + k
+      }
+    }
+  }
+  return ""
 }
 
 func staticPropertyKey(file *shimast.SourceFile, name *shimast.Node) string {
-	if name == nil {
-		return ""
-	}
-	switch name.Kind {
-	case shimast.KindIdentifier:
-		return identifierText(name)
-	case shimast.KindStringLiteral, shimast.KindNoSubstitutionTemplateLiteral:
-		return stringLiteralText(name)
-	case shimast.KindNumericLiteral, shimast.KindBigIntLiteral:
-		return numericLiteralText(name)
-	case shimast.KindComputedPropertyName:
-		// fall back to source text so a computed `[`foo`]` still compares
-		// against the literal `foo` form when both appear together.
-		return nodeText(file, name)
-	}
-	return ""
+  if name == nil {
+    return ""
+  }
+  switch name.Kind {
+  case shimast.KindIdentifier:
+    return identifierText(name)
+  case shimast.KindStringLiteral, shimast.KindNoSubstitutionTemplateLiteral:
+    return stringLiteralText(name)
+  case shimast.KindNumericLiteral, shimast.KindBigIntLiteral:
+    return numericLiteralText(name)
+  case shimast.KindComputedPropertyName:
+    // fall back to source text so a computed `[`foo`]` still compares
+    // against the literal `foo` form when both appear together.
+    return nodeText(file, name)
+  }
+  return ""
 }
 
 func init() {
-	Register(noDuplicateCase{})
-	Register(noDupeKeys{})
-	Register(noDupeArgs{})
+  Register(noDuplicateCase{})
+  Register(noDupeKeys{})
+  Register(noDupeArgs{})
 }

package/plugin/rules_empty.go

@@ -10,21 +10,21 @@ type noEmpty struct{}
 func (noEmpty) Name() string           { return "no-empty" }
 func (noEmpty) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindBlock} }
 func (noEmpty) Check(ctx *Context, node *shimast.Node) {
-	block := node.AsBlock()
-	if block == nil || block.Statements == nil {
-		return
-	}
-	if len(block.Statements.Nodes) > 0 {
-		return
-	}
-	parent := node.Parent
-	if parent != nil && parent.Kind == shimast.KindCatchClause {
-		return // tolerated — see ESLint default options
-	}
-	if isFunctionLikeKind(parent) {
-		return // empty function body is `no-empty-function`'s job
-	}
-	ctx.Report(node, "Empty block statement.")
+  block := node.AsBlock()
+  if block == nil || block.Statements == nil {
+    return
+  }
+  if len(block.Statements.Nodes) > 0 {
+    return
+  }
+  parent := node.Parent
+  if parent != nil && parent.Kind == shimast.KindCatchClause {
+    return // tolerated — see ESLint default options
+  }
+  if isFunctionLikeKind(parent) {
+    return // empty function body is `no-empty-function`'s job
+  }
+  ctx.Report(node, "Empty block statement.")
 }
 
 // no-empty-function: empty function / method / arrow / accessor bodies.
@@ -33,31 +33,31 @@ type noEmptyFunction struct{}
 
 func (noEmptyFunction) Name() string { return "no-empty-function" }
 func (noEmptyFunction) Visits() []shimast.Kind {
-	return []shimast.Kind{
-		shimast.KindFunctionDeclaration,
-		shimast.KindFunctionExpression,
-		shimast.KindArrowFunction,
-		shimast.KindMethodDeclaration,
-		shimast.KindGetAccessor,
-		shimast.KindSetAccessor,
-		shimast.KindConstructor,
-	}
+  return []shimast.Kind{
+    shimast.KindFunctionDeclaration,
+    shimast.KindFunctionExpression,
+    shimast.KindArrowFunction,
+    shimast.KindMethodDeclaration,
+    shimast.KindGetAccessor,
+    shimast.KindSetAccessor,
+    shimast.KindConstructor,
+  }
 }
 func (noEmptyFunction) Check(ctx *Context, node *shimast.Node) {
-	body := node.Body()
-	if body == nil {
-		return
-	}
-	if body.Kind != shimast.KindBlock {
-		return
-	}
-	block := body.AsBlock()
-	if block == nil || block.Statements == nil {
-		return
-	}
-	if len(block.Statements.Nodes) == 0 {
-		ctx.Report(node, "Unexpected empty function.")
-	}
+  body := node.Body()
+  if body == nil {
+    return
+  }
+  if body.Kind != shimast.KindBlock {
+    return
+  }
+  block := body.AsBlock()
+  if block == nil || block.Statements == nil {
+    return
+  }
+  if len(block.Statements.Nodes) == 0 {
+    ctx.Report(node, "Unexpected empty function.")
+  }
 }
 
 // no-empty-pattern: `({}) => x` or `function ({}) {}` — destructuring
@@ -67,44 +67,44 @@ type noEmptyPattern struct{}
 
 func (noEmptyPattern) Name() string { return "no-empty-pattern" }
 func (noEmptyPattern) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindObjectBindingPattern, shimast.KindArrayBindingPattern}
+  return []shimast.Kind{shimast.KindObjectBindingPattern, shimast.KindArrayBindingPattern}
 }
 func (noEmptyPattern) Check(ctx *Context, node *shimast.Node) {
-	pattern := node.AsBindingPattern()
-	if pattern == nil || pattern.Elements == nil {
-		return
-	}
-	if len(pattern.Elements.Nodes) == 0 {
-		shape := "object"
-		if node.Kind == shimast.KindArrayBindingPattern {
-			shape = "array"
-		}
-		ctx.Report(node, "Unexpected empty "+shape+" pattern.")
-	}
+  pattern := node.AsBindingPattern()
+  if pattern == nil || pattern.Elements == nil {
+    return
+  }
+  if len(pattern.Elements.Nodes) == 0 {
+    shape := "object"
+    if node.Kind == shimast.KindArrayBindingPattern {
+      shape = "array"
+    }
+    ctx.Report(node, "Unexpected empty "+shape+" pattern.")
+  }
 }
 
 // isFunctionLikeKind reports whether the node represents a function-like
 // host whose body is the relevant scope for the empty check.
 func isFunctionLikeKind(n *shimast.Node) bool {
-	if n == nil {
-		return false
-	}
-	switch n.Kind {
-	case
-		shimast.KindFunctionDeclaration,
-		shimast.KindFunctionExpression,
-		shimast.KindArrowFunction,
-		shimast.KindMethodDeclaration,
-		shimast.KindGetAccessor,
-		shimast.KindSetAccessor,
-		shimast.KindConstructor:
-		return true
-	}
-	return false
+  if n == nil {
+    return false
+  }
+  switch n.Kind {
+  case
+    shimast.KindFunctionDeclaration,
+    shimast.KindFunctionExpression,
+    shimast.KindArrowFunction,
+    shimast.KindMethodDeclaration,
+    shimast.KindGetAccessor,
+    shimast.KindSetAccessor,
+    shimast.KindConstructor:
+    return true
+  }
+  return false
 }
 
 func init() {
-	Register(noEmpty{})
-	Register(noEmptyFunction{})
-	Register(noEmptyPattern{})
+  Register(noEmpty{})
+  Register(noEmptyFunction{})
+  Register(noEmptyPattern{})
 }

package/plugin/rules_eval.go

@@ -11,13 +11,13 @@ type noEval struct{}
 func (noEval) Name() string           { return "no-eval" }
 func (noEval) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindCallExpression} }
 func (noEval) Check(ctx *Context, node *shimast.Node) {
-	call := node.AsCallExpression()
-	if call == nil {
-		return
-	}
-	if callCalleeName(call) == "eval" {
-		ctx.Report(node, "eval can be harmful.")
-	}
+  call := node.AsCallExpression()
+  if call == nil {
+    return
+  }
+  if callCalleeName(call) == "eval" {
+    ctx.Report(node, "eval can be harmful.")
+  }
 }
 
 // no-script-url: forbid `"javascript:..."` literals. Often used to inject
@@ -27,33 +27,33 @@ type noScriptURL struct{}
 
 func (noScriptURL) Name() string { return "no-script-url" }
 func (noScriptURL) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindStringLiteral, shimast.KindNoSubstitutionTemplateLiteral}
+  return []shimast.Kind{shimast.KindStringLiteral, shimast.KindNoSubstitutionTemplateLiteral}
 }
 func (noScriptURL) Check(ctx *Context, node *shimast.Node) {
-	text := stringLiteralText(node)
-	if isJavaScriptURL(text) {
-		ctx.Report(node, "Script URL is a form of eval.")
-	}
+  text := stringLiteralText(node)
+  if isJavaScriptURL(text) {
+    ctx.Report(node, "Script URL is a form of eval.")
+  }
 }
 
 func isJavaScriptURL(text string) bool {
-	const prefix = "javascript:"
-	if len(text) < len(prefix) {
-		return false
-	}
-	for i := 0; i < len(prefix); i++ {
-		c := text[i]
-		if c >= 'A' && c <= 'Z' {
-			c += 'a' - 'A'
-		}
-		if c != prefix[i] {
-			return false
-		}
-	}
-	return true
+  const prefix = "javascript:"
+  if len(text) < len(prefix) {
+    return false
+  }
+  for i := 0; i < len(prefix); i++ {
+    c := text[i]
+    if c >= 'A' && c <= 'Z' {
+      c += 'a' - 'A'
+    }
+    if c != prefix[i] {
+      return false
+    }
+  }
+  return true
 }
 
 func init() {
-	Register(noEval{})
-	Register(noScriptURL{})
+  Register(noEval{})
+  Register(noScriptURL{})
 }