@ttsc/lint 0.14.0-dev.20260529.1 → 0.14.0

package/linthost/rules_id_length.go

@@ -13,9 +13,9 @@
 package linthost
 
 import (
-	"strconv"
+  "strconv"
 
-	shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
 // idLengthMinimum is the default minimum identifier length. ESLint
@@ -27,51 +27,51 @@ type idLength struct{}
 
 func (idLength) Name() string { return "id-length" }
 func (idLength) Visits() []shimast.Kind {
-	return []shimast.Kind{
-		shimast.KindVariableDeclaration,
-		shimast.KindParameter,
-		shimast.KindFunctionDeclaration,
-		shimast.KindClassDeclaration,
-	}
+  return []shimast.Kind{
+    shimast.KindVariableDeclaration,
+    shimast.KindParameter,
+    shimast.KindFunctionDeclaration,
+    shimast.KindClassDeclaration,
+  }
 }
 func (idLength) Check(ctx *Context, node *shimast.Node) {
-	var nameNode *shimast.Node
-	switch node.Kind {
-	case shimast.KindVariableDeclaration:
-		decl := node.AsVariableDeclaration()
-		if decl == nil {
-			return
-		}
-		nameNode = decl.Name()
-	case shimast.KindParameter:
-		decl := node.AsParameterDeclaration()
-		if decl == nil {
-			return
-		}
-		nameNode = decl.Name()
-	case shimast.KindFunctionDeclaration:
-		decl := node.AsFunctionDeclaration()
-		if decl == nil {
-			return
-		}
-		nameNode = decl.Name()
-	case shimast.KindClassDeclaration:
-		decl := node.AsClassDeclaration()
-		if decl == nil {
-			return
-		}
-		nameNode = decl.Name()
-	}
-	name := identifierText(nameNode)
-	if name == "" {
-		return
-	}
-	if len([]rune(name)) >= idLengthMinimum {
-		return
-	}
-	ctx.Report(nameNode, "Identifier name '"+name+"' is too short (< "+strconv.Itoa(idLengthMinimum)+").")
+  var nameNode *shimast.Node
+  switch node.Kind {
+  case shimast.KindVariableDeclaration:
+    decl := node.AsVariableDeclaration()
+    if decl == nil {
+      return
+    }
+    nameNode = decl.Name()
+  case shimast.KindParameter:
+    decl := node.AsParameterDeclaration()
+    if decl == nil {
+      return
+    }
+    nameNode = decl.Name()
+  case shimast.KindFunctionDeclaration:
+    decl := node.AsFunctionDeclaration()
+    if decl == nil {
+      return
+    }
+    nameNode = decl.Name()
+  case shimast.KindClassDeclaration:
+    decl := node.AsClassDeclaration()
+    if decl == nil {
+      return
+    }
+    nameNode = decl.Name()
+  }
+  name := identifierText(nameNode)
+  if name == "" {
+    return
+  }
+  if len([]rune(name)) >= idLengthMinimum {
+    return
+  }
+  ctx.Report(nameNode, "Identifier name '"+name+"' is too short (< "+strconv.Itoa(idLengthMinimum)+").")
 }
 
 func init() {
-	Register(idLength{})
+  Register(idLength{})
 }

package/linthost/rules_imports.go

@@ -56,12 +56,20 @@ func (noImportTypeSideEffects) Check(ctx *Context, node *shimast.Node) {
   // non-overlapping; the keyword insertion is at offset 6 (after
   // `import`), and each specifier-level delete is strictly inside the
   // braces, so they never overlap.
-  importKwEnd := findKeyword(ctx.File, node.Pos(), node.End(), "import")
-  if importKwEnd < 0 {
+  // Anchor the `import` keyword at the first real token, not at
+  // node.Pos() which points into leading trivia. A raw findKeyword scan
+  // from node.Pos() would match the word `import` inside a leading
+  // comment (`// re-import below`) and insert ` type` into the comment,
+  // while the specifier loop still strips each `type ` — silently
+  // turning the type-only imports back into value imports. keywordStart
+  // mirrors the prefer-namespace-keyword pattern: SkipTrivia past
+  // comments/whitespace, then match the keyword at the token boundary.
+  importKwStart := keywordStart(ctx.File, node, "import")
+  if importKwStart < 0 {
     ctx.Report(node, message)
     return
   }
-  importKwEnd += len("import")
+  importKwEnd := importKwStart + len("import")
   edits := []TextEdit{
     {Pos: importKwEnd, End: importKwEnd, Text: " type"},
   }

package/linthost/rules_init_declarations.go

@@ -20,34 +20,34 @@ type initDeclarations struct{}
 
 func (initDeclarations) Name() string { return "init-declarations" }
 func (initDeclarations) Visits() []shimast.Kind {
-	return []shimast.Kind{shimast.KindVariableStatement}
+  return []shimast.Kind{shimast.KindVariableStatement}
 }
 func (initDeclarations) Check(ctx *Context, node *shimast.Node) {
-	stmt := node.AsVariableStatement()
-	if stmt == nil || stmt.DeclarationList == nil {
-		return
-	}
-	list := stmt.DeclarationList.AsVariableDeclarationList()
-	if list == nil || list.Declarations == nil {
-		return
-	}
-	// `const` declarations are syntactically required to carry an
-	// initializer, so skip the whole list when the modifier is `const`.
-	if list.Flags&shimast.NodeFlagsConst != 0 {
-		return
-	}
-	for _, decl := range list.Declarations.Nodes {
-		if decl == nil {
-			continue
-		}
-		v := decl.AsVariableDeclaration()
-		if v == nil || v.Initializer != nil {
-			continue
-		}
-		ctx.Report(decl, "Expected variable declaration to be initialized.")
-	}
+  stmt := node.AsVariableStatement()
+  if stmt == nil || stmt.DeclarationList == nil {
+    return
+  }
+  list := stmt.DeclarationList.AsVariableDeclarationList()
+  if list == nil || list.Declarations == nil {
+    return
+  }
+  // `const` declarations are syntactically required to carry an
+  // initializer, so skip the whole list when the modifier is `const`.
+  if list.Flags&shimast.NodeFlagsConst != 0 {
+    return
+  }
+  for _, decl := range list.Declarations.Nodes {
+    if decl == nil {
+      continue
+    }
+    v := decl.AsVariableDeclaration()
+    if v == nil || v.Initializer != nil {
+      continue
+    }
+    ctx.Report(decl, "Expected variable declaration to be initialized.")
+  }
 }
 
 func init() {
-	Register(initDeclarations{})
+  Register(initDeclarations{})
 }