@ttsc/lint 0.14.0-dev.20260529.2 → 0.14.0

package/linthost/rules_ts_class_literal_property_style.go

@@ -6,7 +6,7 @@
 package linthost
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 // classLiteralPropertyStyle reports `get foo() { return <literal>; }`
@@ -28,44 +28,44 @@ import (
 type classLiteralPropertyStyle struct{}
 
 func (classLiteralPropertyStyle) Name() string {
-	return "typescript/class-literal-property-style"
+  return "typescript/class-literal-property-style"
 }
 func (classLiteralPropertyStyle) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindGetAccessor}
+  return []shimast.Kind{shimast.KindGetAccessor}
 }
 func (classLiteralPropertyStyle) Check(ctx *Context, node *shimast.Node) {
-	parent := node.Parent
-	if parent == nil ||
-		(parent.Kind != shimast.KindClassDeclaration && parent.Kind != shimast.KindClassExpression) {
-		return
-	}
-	accessor := node.AsGetAccessorDeclaration()
-	if accessor == nil || accessor.Body == nil || accessor.Body.Kind != shimast.KindBlock {
-		return
-	}
-	statements := accessor.Body.Statements()
-	if len(statements) != 1 {
-		return
-	}
-	ret := statements[0]
-	if ret == nil || ret.Kind != shimast.KindReturnStatement {
-		return
-	}
-	retStmt := ret.AsReturnStatement()
-	if retStmt == nil || retStmt.Expression == nil {
-		return
-	}
-	if !isClassLiteralPropertyValue(retStmt.Expression) {
-		return
-	}
-	name := classMemberName(node)
-	if name == "" {
-		return
-	}
-	if classHasSetterFor(parent, name) {
-		return
-	}
-	ctx.Report(node, "Literal-returning getter `"+name+"` should be a `readonly` field instead.")
+  parent := node.Parent
+  if parent == nil ||
+    (parent.Kind != shimast.KindClassDeclaration && parent.Kind != shimast.KindClassExpression) {
+    return
+  }
+  accessor := node.AsGetAccessorDeclaration()
+  if accessor == nil || accessor.Body == nil || accessor.Body.Kind != shimast.KindBlock {
+    return
+  }
+  statements := accessor.Body.Statements()
+  if len(statements) != 1 {
+    return
+  }
+  ret := statements[0]
+  if ret == nil || ret.Kind != shimast.KindReturnStatement {
+    return
+  }
+  retStmt := ret.AsReturnStatement()
+  if retStmt == nil || retStmt.Expression == nil {
+    return
+  }
+  if !isClassLiteralPropertyValue(retStmt.Expression) {
+    return
+  }
+  name := classMemberName(node)
+  if name == "" {
+    return
+  }
+  if classHasSetterFor(parent, name) {
+    return
+  }
+  ctx.Report(node, "Literal-returning getter `"+name+"` should be a `readonly` field instead.")
 }
 
 // isClassLiteralPropertyValue reports whether the expression is one of
@@ -73,25 +73,25 @@ func (classLiteralPropertyStyle) Check(ctx *Context, node *shimast.Node) {
 // literal without substitutions, or a unary-minus prefix on a numeric
 // literal.
 func isClassLiteralPropertyValue(expr *shimast.Node) bool {
-	if expr == nil {
-		return false
-	}
-	switch expr.Kind {
-	case shimast.KindStringLiteral,
-		shimast.KindNumericLiteral,
-		shimast.KindTrueKeyword,
-		shimast.KindFalseKeyword,
-		shimast.KindNullKeyword,
-		shimast.KindNoSubstitutionTemplateLiteral:
-		return true
-	case shimast.KindPrefixUnaryExpression:
-		prefix := expr.AsPrefixUnaryExpression()
-		if prefix == nil || prefix.Operator != shimast.KindMinusToken || prefix.Operand == nil {
-			return false
-		}
-		return prefix.Operand.Kind == shimast.KindNumericLiteral
-	}
-	return false
+  if expr == nil {
+    return false
+  }
+  switch expr.Kind {
+  case shimast.KindStringLiteral,
+    shimast.KindNumericLiteral,
+    shimast.KindTrueKeyword,
+    shimast.KindFalseKeyword,
+    shimast.KindNullKeyword,
+    shimast.KindNoSubstitutionTemplateLiteral:
+    return true
+  case shimast.KindPrefixUnaryExpression:
+    prefix := expr.AsPrefixUnaryExpression()
+    if prefix == nil || prefix.Operator != shimast.KindMinusToken || prefix.Operand == nil {
+      return false
+    }
+    return prefix.Operand.Kind == shimast.KindNumericLiteral
+  }
+  return false
 }
 
 // classHasSetterFor reports whether the class contains a `set`
@@ -99,17 +99,17 @@ func isClassLiteralPropertyValue(expr *shimast.Node) bool {
 // is left alone because the field form cannot reproduce the setter's
 // side effects.
 func classHasSetterFor(class *shimast.Node, name string) bool {
-	for _, member := range classMembers(class) {
-		if member == nil || member.Kind != shimast.KindSetAccessor {
-			continue
-		}
-		if classMemberName(member) == name {
-			return true
-		}
-	}
-	return false
+  for _, member := range classMembers(class) {
+    if member == nil || member.Kind != shimast.KindSetAccessor {
+      continue
+    }
+    if classMemberName(member) == name {
+      return true
+    }
+  }
+  return false
 }
 
 func init() {
-	Register(classLiteralPropertyStyle{})
+  Register(classLiteralPropertyStyle{})
 }

package/linthost/rules_ts_consistent_type_exports.go

@@ -16,68 +16,68 @@
 package linthost
 
 import (
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 type consistentTypeExports struct{}
 
 func (consistentTypeExports) Name() string { return "typescript/consistent-type-exports" }
 func (consistentTypeExports) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindExportDeclaration}
+  return []shimast.Kind{shimast.KindExportDeclaration}
 }
 func (consistentTypeExports) Check(ctx *Context, node *shimast.Node) {
-	decl := node.AsExportDeclaration()
-	if decl == nil || decl.ExportClause == nil {
-		return
-	}
-	// Already `export type { ... }` — nothing to suggest.
-	if decl.IsTypeOnly {
-		return
-	}
-	// Re-export from another module (`export { Foo } from "bar"`)
-	// cannot be classified by the AST alone — the source's nature
-	// lives in a different file. Skip to stay conservative.
-	if decl.ModuleSpecifier != nil {
-		return
-	}
-	if decl.ExportClause.Kind != shimast.KindNamedExports {
-		return
-	}
-	named := decl.ExportClause.AsNamedExports()
-	if named == nil || named.Elements == nil || len(named.Elements.Nodes) == 0 {
-		return
-	}
-	// Collect the local names being exported. `export { Foo as Bar }`
-	// — the `propertyName` (Foo) is the local identifier; the `name`
-	// (Bar) is the externally visible alias.
-	localNames := []string{}
-	for _, el := range named.Elements.Nodes {
-		spec := el.AsExportSpecifier()
-		if spec == nil {
-			return
-		}
-		// An inline `export { type Foo }` already opts out at the
-		// specifier level — bail rather than try to merge mixed shapes.
-		if spec.IsTypeOnly {
-			return
-		}
-		local := spec.PropertyName
-		if local == nil {
-			local = spec.Name()
-		}
-		name := identifierText(local)
-		if name == "" {
-			return
-		}
-		localNames = append(localNames, name)
-	}
-	if len(localNames) == 0 {
-		return
-	}
-	if !allNamesAreTypeOnlyDeclarations(ctx.File, localNames) {
-		return
-	}
-	ctx.Report(node, "All exported names are type-only declarations — prefer `export type { ... }` so consumers and bundlers can elide the import.")
+  decl := node.AsExportDeclaration()
+  if decl == nil || decl.ExportClause == nil {
+    return
+  }
+  // Already `export type { ... }` — nothing to suggest.
+  if decl.IsTypeOnly {
+    return
+  }
+  // Re-export from another module (`export { Foo } from "bar"`)
+  // cannot be classified by the AST alone — the source's nature
+  // lives in a different file. Skip to stay conservative.
+  if decl.ModuleSpecifier != nil {
+    return
+  }
+  if decl.ExportClause.Kind != shimast.KindNamedExports {
+    return
+  }
+  named := decl.ExportClause.AsNamedExports()
+  if named == nil || named.Elements == nil || len(named.Elements.Nodes) == 0 {
+    return
+  }
+  // Collect the local names being exported. `export { Foo as Bar }`
+  // — the `propertyName` (Foo) is the local identifier; the `name`
+  // (Bar) is the externally visible alias.
+  localNames := []string{}
+  for _, el := range named.Elements.Nodes {
+    spec := el.AsExportSpecifier()
+    if spec == nil {
+      return
+    }
+    // An inline `export { type Foo }` already opts out at the
+    // specifier level — bail rather than try to merge mixed shapes.
+    if spec.IsTypeOnly {
+      return
+    }
+    local := spec.PropertyName
+    if local == nil {
+      local = spec.Name()
+    }
+    name := identifierText(local)
+    if name == "" {
+      return
+    }
+    localNames = append(localNames, name)
+  }
+  if len(localNames) == 0 {
+    return
+  }
+  if !allNamesAreTypeOnlyDeclarations(ctx.File, localNames) {
+    return
+  }
+  ctx.Report(node, "All exported names are type-only declarations — prefer `export type { ... }` so consumers and bundlers can elide the import.")
 }
 
 // allNamesAreTypeOnlyDeclarations reports whether every name in
@@ -88,113 +88,113 @@ func (consistentTypeExports) Check(ctx *Context, node *shimast.Node) {
 // Checker the rule cannot prove the binding is type-only when its
 // source is elsewhere.
 func allNamesAreTypeOnlyDeclarations(file *shimast.SourceFile, names []string) bool {
-	if file == nil || file.Statements == nil || len(names) == 0 {
-		return false
-	}
-	want := map[string]bool{}
-	for _, n := range names {
-		want[n] = true
-	}
-	found := map[string]bool{}
-	valueShadow := map[string]bool{}
-	for _, stmt := range file.Statements.Nodes {
-		if stmt == nil {
-			continue
-		}
-		switch stmt.Kind {
-		case shimast.KindInterfaceDeclaration:
-			decl := stmt.AsInterfaceDeclaration()
-			if decl == nil {
-				continue
-			}
-			name := identifierText(decl.Name())
-			if want[name] {
-				found[name] = true
-			}
-		case shimast.KindTypeAliasDeclaration:
-			decl := stmt.AsTypeAliasDeclaration()
-			if decl == nil {
-				continue
-			}
-			name := identifierText(decl.Name())
-			if want[name] {
-				found[name] = true
-			}
-		case shimast.KindVariableStatement:
-			vs := stmt.AsVariableStatement()
-			if vs == nil || vs.DeclarationList == nil {
-				continue
-			}
-			list := vs.DeclarationList.AsVariableDeclarationList()
-			if list == nil || list.Declarations == nil {
-				continue
-			}
-			for _, d := range list.Declarations.Nodes {
-				if d == nil {
-					continue
-				}
-				vd := d.AsVariableDeclaration()
-				if vd == nil {
-					continue
-				}
-				if name := identifierText(vd.Name()); want[name] {
-					valueShadow[name] = true
-				}
-			}
-		case shimast.KindFunctionDeclaration:
-			fn := stmt.AsFunctionDeclaration()
-			if fn == nil {
-				continue
-			}
-			if name := identifierText(fn.Name()); want[name] {
-				valueShadow[name] = true
-			}
-		case shimast.KindClassDeclaration:
-			cd := stmt.AsClassDeclaration()
-			if cd == nil {
-				continue
-			}
-			if name := identifierText(cd.Name()); want[name] {
-				valueShadow[name] = true
-			}
-		case shimast.KindEnumDeclaration:
-			ed := stmt.AsEnumDeclaration()
-			if ed == nil {
-				continue
-			}
-			if name := identifierText(ed.Name()); want[name] {
-				valueShadow[name] = true
-			}
-		case shimast.KindModuleDeclaration:
-			// `namespace Foo { ... }` and `module "foo" { ... }` both
-			// produce a value binding for the namespace object.
-			md := stmt.AsModuleDeclaration()
-			if md == nil {
-				continue
-			}
-			if name := identifierText(md.Name()); want[name] {
-				valueShadow[name] = true
-			}
-		case shimast.KindImportDeclaration:
-			// Any name that comes in through a value import is a value
-			// here, so the export rewrite would be wrong.
-			collectImportBindings(stmt, want, valueShadow)
-		case shimast.KindImportEqualsDeclaration:
-			ied := stmt.AsImportEqualsDeclaration()
-			if ied == nil {
-				continue
-			}
-			if name := identifierText(ied.Name()); want[name] {
-				valueShadow[name] = true
-			}
-		}
-	}
-	for _, n := range names {
-		if valueShadow[n] || !found[n] {
-			return false
-		}
-	}
-	return true
+  if file == nil || file.Statements == nil || len(names) == 0 {
+    return false
+  }
+  want := map[string]bool{}
+  for _, n := range names {
+    want[n] = true
+  }
+  found := map[string]bool{}
+  valueShadow := map[string]bool{}
+  for _, stmt := range file.Statements.Nodes {
+    if stmt == nil {
+      continue
+    }
+    switch stmt.Kind {
+    case shimast.KindInterfaceDeclaration:
+      decl := stmt.AsInterfaceDeclaration()
+      if decl == nil {
+        continue
+      }
+      name := identifierText(decl.Name())
+      if want[name] {
+        found[name] = true
+      }
+    case shimast.KindTypeAliasDeclaration:
+      decl := stmt.AsTypeAliasDeclaration()
+      if decl == nil {
+        continue
+      }
+      name := identifierText(decl.Name())
+      if want[name] {
+        found[name] = true
+      }
+    case shimast.KindVariableStatement:
+      vs := stmt.AsVariableStatement()
+      if vs == nil || vs.DeclarationList == nil {
+        continue
+      }
+      list := vs.DeclarationList.AsVariableDeclarationList()
+      if list == nil || list.Declarations == nil {
+        continue
+      }
+      for _, d := range list.Declarations.Nodes {
+        if d == nil {
+          continue
+        }
+        vd := d.AsVariableDeclaration()
+        if vd == nil {
+          continue
+        }
+        if name := identifierText(vd.Name()); want[name] {
+          valueShadow[name] = true
+        }
+      }
+    case shimast.KindFunctionDeclaration:
+      fn := stmt.AsFunctionDeclaration()
+      if fn == nil {
+        continue
+      }
+      if name := identifierText(fn.Name()); want[name] {
+        valueShadow[name] = true
+      }
+    case shimast.KindClassDeclaration:
+      cd := stmt.AsClassDeclaration()
+      if cd == nil {
+        continue
+      }
+      if name := identifierText(cd.Name()); want[name] {
+        valueShadow[name] = true
+      }
+    case shimast.KindEnumDeclaration:
+      ed := stmt.AsEnumDeclaration()
+      if ed == nil {
+        continue
+      }
+      if name := identifierText(ed.Name()); want[name] {
+        valueShadow[name] = true
+      }
+    case shimast.KindModuleDeclaration:
+      // `namespace Foo { ... }` and `module "foo" { ... }` both
+      // produce a value binding for the namespace object.
+      md := stmt.AsModuleDeclaration()
+      if md == nil {
+        continue
+      }
+      if name := identifierText(md.Name()); want[name] {
+        valueShadow[name] = true
+      }
+    case shimast.KindImportDeclaration:
+      // Any name that comes in through a value import is a value
+      // here, so the export rewrite would be wrong.
+      collectImportBindings(stmt, want, valueShadow)
+    case shimast.KindImportEqualsDeclaration:
+      ied := stmt.AsImportEqualsDeclaration()
+      if ied == nil {
+        continue
+      }
+      if name := identifierText(ied.Name()); want[name] {
+        valueShadow[name] = true
+      }
+    }
+  }
+  for _, n := range names {
+    if valueShadow[n] || !found[n] {
+      return false
+    }
+  }
+  return true
 }
 
 // collectImportBindings records every value-import name from `stmt`
@@ -202,55 +202,55 @@ func allNamesAreTypeOnlyDeclarations(file *shimast.SourceFile, names []string) b
 // (`import type { Foo }` or inline `import { type Foo }`) do not
 // produce a value binding and are skipped.
 func collectImportBindings(stmt *shimast.Node, want, valueShadow map[string]bool) {
-	if stmt == nil {
-		return
-	}
-	decl := stmt.AsImportDeclaration()
-	if decl == nil || decl.ImportClause == nil {
-		return
-	}
-	clause := decl.ImportClause.AsImportClause()
-	if clause == nil {
-		return
-	}
-	// `import type { Foo }` — entire clause is type-only.
-	if clause.PhaseModifier == shimast.KindTypeKeyword {
-		return
-	}
-	if def := clause.Name(); def != nil {
-		if name := identifierText(def); want[name] {
-			valueShadow[name] = true
-		}
-	}
-	if clause.NamedBindings == nil {
-		return
-	}
-	switch clause.NamedBindings.Kind {
-	case shimast.KindNamespaceImport:
-		ns := clause.NamedBindings.AsNamespaceImport()
-		if ns == nil {
-			return
-		}
-		if name := identifierText(ns.Name()); want[name] {
-			valueShadow[name] = true
-		}
-	case shimast.KindNamedImports:
-		named := clause.NamedBindings.AsNamedImports()
-		if named == nil || named.Elements == nil {
-			return
-		}
-		for _, spec := range named.Elements.Nodes {
-			s := spec.AsImportSpecifier()
-			if s == nil || s.IsTypeOnly {
-				continue
-			}
-			if name := identifierText(s.Name()); want[name] {
-				valueShadow[name] = true
-			}
-		}
-	}
+  if stmt == nil {
+    return
+  }
+  decl := stmt.AsImportDeclaration()
+  if decl == nil || decl.ImportClause == nil {
+    return
+  }
+  clause := decl.ImportClause.AsImportClause()
+  if clause == nil {
+    return
+  }
+  // `import type { Foo }` — entire clause is type-only.
+  if clause.PhaseModifier == shimast.KindTypeKeyword {
+    return
+  }
+  if def := clause.Name(); def != nil {
+    if name := identifierText(def); want[name] {
+      valueShadow[name] = true
+    }
+  }
+  if clause.NamedBindings == nil {
+    return
+  }
+  switch clause.NamedBindings.Kind {
+  case shimast.KindNamespaceImport:
+    ns := clause.NamedBindings.AsNamespaceImport()
+    if ns == nil {
+      return
+    }
+    if name := identifierText(ns.Name()); want[name] {
+      valueShadow[name] = true
+    }
+  case shimast.KindNamedImports:
+    named := clause.NamedBindings.AsNamedImports()
+    if named == nil || named.Elements == nil {
+      return
+    }
+    for _, spec := range named.Elements.Nodes {
+      s := spec.AsImportSpecifier()
+      if s == nil || s.IsTypeOnly {
+        continue
+      }
+      if name := identifierText(s.Name()); want[name] {
+        valueShadow[name] = true
+      }
+    }
+  }
 }
 
 func init() {
-	Register(consistentTypeExports{})
+  Register(consistentTypeExports{})
 }