@ttsc/lint 0.7.1 → 0.7.3

package/README.md

@@ -9,7 +9,48 @@
 [![Guide Documents](https://img.shields.io/badge/Guide-Documents-forestgreen)](https://github.com/samchon/ttsc/tree/master/docs)
 [![Discord Badge](https://img.shields.io/badge/discord-samchon-d91965?style=flat&labelColor=5866f2&logo=discord&logoColor=white&link=https://discord.gg/E94XhzrUCZ)](https://discord.gg/E94XhzrUCZ)
 
-`@ttsc/lint` reports ESLint-style diagnostics from the same TypeScript-Go type-check pass that `ttsc` already runs.
+Lint as compile errors.
+
+Rules run inside `ttsc`'s `typescript-go` type-check pass — one compile, both checks.
+
+## Demonstration
+
+Given this file:
+
+```typescript
+// src/lint.ts
+var x: number = 3;
+let y: number = 4;
+const z: string = 5;
+
+console.log(x + y + z);
+```
+
+Run `ttsc` with `@ttsc/lint` enabled (see [Setup](#setup)):
+
+```bash
+$ pnpm ttsc
+src/lint.ts:3:7 - error TS2322: Type 'number' is not assignable to type 'string'.
+
+3 const z: string = 5;
+        ~
+
+src/lint.ts:2:5 - error TS17397: [prefer-const] Use const instead of let.
+
+2 let y: number = 4;
+      ~~~~~~~~~~~~~
+
+src/lint.ts:1:1 - error TS11966: [no-var] Unexpected var, use let or const instead.
+
+1 var x: number = 3;
+  ~~~~~~~~~~~~~~~~~~
+
+Found 3 errors in the same file, starting at: src/lint.ts:3
+```
+
+Type errors (`TS2322`) and lint violations (`TS17397`, `TS11966`) come out together, in the same `error TSxxxxx` shape.
+
+CI that already runs `ttsc` blocks on lint with no extra wiring.
 
 ## Setup
 
@@ -19,7 +60,9 @@ Install `ttsc`, TypeScript-Go, and the lint plugin:
 npm install -D ttsc @typescript/native-preview @ttsc/lint
 ```
 
-Open your project's `tsconfig.json`, then add this entry under `compilerOptions.plugins`. If the file already has `compilerOptions`, merge this into the existing object and keep `@ttsc/lint` as the first active plugin:
+Add the plugin under `compilerOptions.plugins` in your `tsconfig.json`.
+
+Keep `@ttsc/lint` as the first plugin entry — see [Plugin order](#plugin-order).
 
 ```jsonc
 {
@@ -39,16 +82,20 @@ Open your project's `tsconfig.json`, then add this entry under `compilerOptions.
 }
 ```
 
-Run your normal `ttsc` or `ttsx` command:
+Then run your normal `ttsc` or `ttsx`:
 
 ```bash
 npx ttsc
 npx ttsx src/index.ts
 ```
 
-Lint errors fail the command. With `ttsx`, lint errors stop the program before your entrypoint runs. Lint warnings are printed without changing the exit code.
+- Lint errors fail the command.
+- Under `ttsx`, lint errors stop the program before your entrypoint runs.
+- Lint warnings are printed without changing the exit code.
+
+### External config file
 
-You can also keep the lint rules in a standalone config file and leave only the file reference in `tsconfig.json`:
+You can also keep the rules in a standalone file and reference it from `tsconfig.json`:
 
 ```jsonc
 {
@@ -73,28 +120,17 @@ export default {
 };
 ```
 
-`config` accepts either a config object or a path to `.json`, `.js`, `.cjs`, `.mjs`, `.ts`, `.cts`, or `.mts`. JavaScript and TypeScript config files may export the object directly, as `default`, as `config`, or as a function that returns the object. Relative paths are resolved from the owning tsconfig directory.
+The `config` field accepts:
 
-Inline `config` is also accepted:
+- An inline object (shown earlier), **or** a path to a file ending in `.json`, `.js`, `.cjs`, `.mjs`, `.ts`, `.cts`, or `.mts`.
+- For JS/TS configs: a `default` export, a named `config` export, a direct module export, or a function that returns the object.
+- Relative paths resolve from the directory of the owning `tsconfig.json`.
 
-```jsonc
-{
-  "compilerOptions": {
-    "plugins": [
-      {
-        "transform": "@ttsc/lint",
-        "config": {
-          "no-var": "error"
-        }
-      }
-    ]
-  }
-}
-```
+## Plugin order
 
-## Notes
+`@ttsc/lint` must be the first plugin in `compilerOptions.plugins`.
 
-`@ttsc/lint` must be the first active plugin entry because it reports on the source code you wrote. Output plugins such as `@ttsc/banner`, `@ttsc/paths`, and `@ttsc/strip` can come after it.
+It inspects the source you wrote, so output plugins (`@ttsc/banner`, `@ttsc/paths`, `@ttsc/strip`) have to come after it.
 
 ```jsonc
 {
@@ -112,7 +148,9 @@ Inline `config` is also accepted:
 }
 ```
 
-This package is diagnostic-only today: no autofix, no recommended preset, no custom rule loading, and no cross-file lint rules.
+## Scope
+
+Diagnostic-only today: no autofix, no recommended preset, no custom rule loading, and no cross-file lint rules.
 
 ## Rules
 

package/lib/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA,0DAA6B;AAQ7B,qDAAmC;AAEnC,0BACE,QAA0D;IAE1D,OAAO;QACL,IAAI,EAAE,YAAY;QAClB,MAAM,EAAE,mBAAI,CAAC,OAAO,CAAC,SAAS,EAAE,IAAI,EAAE,QAAQ,CAAC;QAC/C,KAAK,EAAE,OAAO;KACf,CAAC;AACJ,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA,0DAA6B;AAK7B,qDAAmC;AAEnC,0BACE,QAA0D;IAE1D,OAAO;QACL,IAAI,EAAE,YAAY;QAClB,MAAM,EAAE,mBAAI,CAAC,OAAO,CAAC,SAAS,EAAE,IAAI,EAAE,QAAQ,CAAC;QAC/C,KAAK,EAAE,OAAO;KACf,CAAC;AACJ,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ttsc/lint",
-  "version": "0.7.1",
+  "version": "0.7.3",
   "description": "Reference ttsc plugin: ESLint-style lint rules hosted in the same Program/Checker as the type-check pass.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -27,10 +27,10 @@
     "plugin"
   ],
   "devDependencies": {
-    "@typescript/native-preview": "7.0.0-dev.20260430.1",
+    "@typescript/native-preview": "7.0.0-dev.20260501.1",
     "@types/node": "^25.3.0",
     "rimraf": "^6.1.2",
-    "ttsc": "0.7.1"
+    "ttsc": "0.7.3"
   },
   "repository": {
     "type": "git",

package/plugin/ast_helpers.go

@@ -1,10 +1,10 @@
 package main
 
 import (
-	"strings"
+  "strings"
 
-	shimast "github.com/microsoft/typescript-go/shim/ast"
-	shimscanner "github.com/microsoft/typescript-go/shim/scanner"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimscanner "github.com/microsoft/typescript-go/shim/scanner"
 )
 
 // nodeText returns the source text under a node with all leading
@@ -14,213 +14,213 @@ import (
 // would include any preceding comment because tsgo's Pos points at
 // the start of leading trivia, not the actual token.
 func nodeText(file *shimast.SourceFile, node *shimast.Node) string {
-	if file == nil || node == nil {
-		return ""
-	}
-	src := file.Text()
-	end := node.End()
-	pos := shimscanner.SkipTrivia(src, node.Pos())
-	if pos < 0 || end > len(src) || pos >= end {
-		return ""
-	}
-	return strings.TrimRight(src[pos:end], " \t\r\n")
+  if file == nil || node == nil {
+    return ""
+  }
+  src := file.Text()
+  end := node.End()
+  pos := shimscanner.SkipTrivia(src, node.Pos())
+  if pos < 0 || end > len(src) || pos >= end {
+    return ""
+  }
+  return strings.TrimRight(src[pos:end], " \t\r\n")
 }
 
 // identifierText returns the lexical name of an Identifier node, or "" if
 // the node isn't an Identifier.
 func identifierText(node *shimast.Node) string {
-	if node == nil || node.Kind != shimast.KindIdentifier {
-		return ""
-	}
-	id := node.AsIdentifier()
-	if id == nil {
-		return ""
-	}
-	return id.Text
+  if node == nil || node.Kind != shimast.KindIdentifier {
+    return ""
+  }
+  id := node.AsIdentifier()
+  if id == nil {
+    return ""
+  }
+  return id.Text
 }
 
 // stripParens descends through ParenthesizedExpression nodes and returns
 // the first non-parenthesized child. ESLint rules typically operate on
 // the canonical form.
 func stripParens(node *shimast.Node) *shimast.Node {
-	for node != nil && node.Kind == shimast.KindParenthesizedExpression {
-		next := node.AsParenthesizedExpression()
-		if next == nil || next.Expression == nil {
-			return node
-		}
-		node = next.Expression
-	}
-	return node
+  for node != nil && node.Kind == shimast.KindParenthesizedExpression {
+    next := node.AsParenthesizedExpression()
+    if next == nil || next.Expression == nil {
+      return node
+    }
+    node = next.Expression
+  }
+  return node
 }
 
 // isMatchingPropertyAccess reports whether `node` reads the chain
 // `head.tail[0].tail[1]…`. Useful for detecting `obj.__proto__` or
 // `console.log` shapes regardless of nesting.
 func isMatchingPropertyAccess(node *shimast.Node, head string, tail ...string) bool {
-	if node == nil || node.Kind != shimast.KindPropertyAccessExpression {
-		return false
-	}
-	chain := []*shimast.Node{}
-	cur := node
-	for cur != nil && cur.Kind == shimast.KindPropertyAccessExpression {
-		access := cur.AsPropertyAccessExpression()
-		if access == nil {
-			return false
-		}
-		chain = append([]*shimast.Node{access.Name()}, chain...)
-		cur = access.Expression
-	}
-	if cur == nil || identifierText(cur) != head {
-		return false
-	}
-	if len(chain) != len(tail) {
-		return false
-	}
-	for i, want := range tail {
-		if identifierText(chain[i]) != want {
-			return false
-		}
-	}
-	return true
+  if node == nil || node.Kind != shimast.KindPropertyAccessExpression {
+    return false
+  }
+  chain := []*shimast.Node{}
+  cur := node
+  for cur != nil && cur.Kind == shimast.KindPropertyAccessExpression {
+    access := cur.AsPropertyAccessExpression()
+    if access == nil {
+      return false
+    }
+    chain = append([]*shimast.Node{access.Name()}, chain...)
+    cur = access.Expression
+  }
+  if cur == nil || identifierText(cur) != head {
+    return false
+  }
+  if len(chain) != len(tail) {
+    return false
+  }
+  for i, want := range tail {
+    if identifierText(chain[i]) != want {
+      return false
+    }
+  }
+  return true
 }
 
 // isLiteralBoolean returns the boolean value (and ok=true) for a
 // `KindTrueKeyword` / `KindFalseKeyword` literal. Other nodes return
 // (false, false).
 func isLiteralBoolean(node *shimast.Node) (bool, bool) {
-	if node == nil {
-		return false, false
-	}
-	switch node.Kind {
-	case shimast.KindTrueKeyword:
-		return true, true
-	case shimast.KindFalseKeyword:
-		return false, true
-	}
-	return false, false
+  if node == nil {
+    return false, false
+  }
+  switch node.Kind {
+  case shimast.KindTrueKeyword:
+    return true, true
+  case shimast.KindFalseKeyword:
+    return false, true
+  }
+  return false, false
 }
 
 // isLiteralExpression returns true for nodes whose value is intrinsically
 // truthy / falsy at parse time — these flag `no-constant-condition` etc.
 func isLiteralExpression(node *shimast.Node) bool {
-	if node == nil {
-		return false
-	}
-	switch node.Kind {
-	case
-		shimast.KindStringLiteral,
-		shimast.KindNumericLiteral,
-		shimast.KindBigIntLiteral,
-		shimast.KindNoSubstitutionTemplateLiteral,
-		shimast.KindRegularExpressionLiteral,
-		shimast.KindTrueKeyword,
-		shimast.KindFalseKeyword,
-		shimast.KindNullKeyword:
-		return true
-	}
-	return false
+  if node == nil {
+    return false
+  }
+  switch node.Kind {
+  case
+    shimast.KindStringLiteral,
+    shimast.KindNumericLiteral,
+    shimast.KindBigIntLiteral,
+    shimast.KindNoSubstitutionTemplateLiteral,
+    shimast.KindRegularExpressionLiteral,
+    shimast.KindTrueKeyword,
+    shimast.KindFalseKeyword,
+    shimast.KindNullKeyword:
+    return true
+  }
+  return false
 }
 
 // callCalleeName returns the simple-identifier callee of a CallExpression
 // (e.g. `eval` from `eval("...")`). Returns "" when the callee is more
 // complex than a bare identifier.
 func callCalleeName(call *shimast.CallExpression) string {
-	if call == nil || call.Expression == nil {
-		return ""
-	}
-	return identifierText(call.Expression)
+  if call == nil || call.Expression == nil {
+    return ""
+  }
+  return identifierText(call.Expression)
 }
 
 // numericLiteralText returns the literal text of a numeric / bigint
 // literal, normalized for the comparisons rules need (`-0`, `0xFF`).
 func numericLiteralText(node *shimast.Node) string {
-	if node == nil {
-		return ""
-	}
-	switch node.Kind {
-	case shimast.KindNumericLiteral:
-		if lit := node.AsNumericLiteral(); lit != nil {
-			return lit.Text
-		}
-	case shimast.KindBigIntLiteral:
-		if lit := node.AsBigIntLiteral(); lit != nil {
-			return lit.Text
-		}
-	}
-	return ""
+  if node == nil {
+    return ""
+  }
+  switch node.Kind {
+  case shimast.KindNumericLiteral:
+    if lit := node.AsNumericLiteral(); lit != nil {
+      return lit.Text
+    }
+  case shimast.KindBigIntLiteral:
+    if lit := node.AsBigIntLiteral(); lit != nil {
+      return lit.Text
+    }
+  }
+  return ""
 }
 
 // stringLiteralText returns the value of a string-shaped literal:
 // StringLiteral or NoSubstitutionTemplateLiteral.
 func stringLiteralText(node *shimast.Node) string {
-	if node == nil {
-		return ""
-	}
-	switch node.Kind {
-	case shimast.KindStringLiteral:
-		if lit := node.AsStringLiteral(); lit != nil {
-			return lit.Text
-		}
-	case shimast.KindNoSubstitutionTemplateLiteral:
-		if lit := node.AsNoSubstitutionTemplateLiteral(); lit != nil {
-			return lit.Text
-		}
-	}
-	return ""
+  if node == nil {
+    return ""
+  }
+  switch node.Kind {
+  case shimast.KindStringLiteral:
+    if lit := node.AsStringLiteral(); lit != nil {
+      return lit.Text
+    }
+  case shimast.KindNoSubstitutionTemplateLiteral:
+    if lit := node.AsNoSubstitutionTemplateLiteral(); lit != nil {
+      return lit.Text
+    }
+  }
+  return ""
 }
 
 // walkDescendants visits node and every child below it, depth-first.
 func walkDescendants(node *shimast.Node, visit func(*shimast.Node)) {
-	if node == nil {
-		return
-	}
-	visit(node)
-	node.ForEachChild(func(child *shimast.Node) bool {
-		walkDescendants(child, visit)
-		return false
-	})
+  if node == nil {
+    return
+  }
+  visit(node)
+  node.ForEachChild(func(child *shimast.Node) bool {
+    walkDescendants(child, visit)
+    return false
+  })
 }
 
 func bindingIdentifierNames(node *shimast.Node) []string {
-	if node == nil {
-		return nil
-	}
-	if name := identifierText(node); name != "" {
-		return []string{name}
-	}
-	if node.Kind != shimast.KindObjectBindingPattern && node.Kind != shimast.KindArrayBindingPattern {
-		return nil
-	}
-	var names []string
-	walkDescendants(node, func(child *shimast.Node) {
-		if child == node {
-			return
-		}
-		if name := identifierText(child); name != "" {
-			names = append(names, name)
-		}
-	})
-	return names
+  if node == nil {
+    return nil
+  }
+  if name := identifierText(node); name != "" {
+    return []string{name}
+  }
+  if node.Kind != shimast.KindObjectBindingPattern && node.Kind != shimast.KindArrayBindingPattern {
+    return nil
+  }
+  var names []string
+  walkDescendants(node, func(child *shimast.Node) {
+    if child == node {
+      return
+    }
+    if name := identifierText(child); name != "" {
+      names = append(names, name)
+    }
+  })
+  return names
 }
 
 func isLiteralLike(node *shimast.Node) bool {
-	node = stripParens(node)
-	if node == nil {
-		return false
-	}
-	if isLiteralExpression(node) {
-		return true
-	}
-	if node.Kind == shimast.KindPrefixUnaryExpression {
-		prefix := node.AsPrefixUnaryExpression()
-		if prefix == nil {
-			return false
-		}
-		switch prefix.Operator {
-		case shimast.KindPlusToken, shimast.KindMinusToken:
-			return prefix.Operand != nil &&
-				(prefix.Operand.Kind == shimast.KindNumericLiteral || prefix.Operand.Kind == shimast.KindBigIntLiteral)
-		}
-	}
-	return false
+  node = stripParens(node)
+  if node == nil {
+    return false
+  }
+  if isLiteralExpression(node) {
+    return true
+  }
+  if node.Kind == shimast.KindPrefixUnaryExpression {
+    prefix := node.AsPrefixUnaryExpression()
+    if prefix == nil {
+      return false
+    }
+    switch prefix.Operator {
+    case shimast.KindPlusToken, shimast.KindMinusToken:
+      return prefix.Operand != nil &&
+        (prefix.Operand.Kind == shimast.KindNumericLiteral || prefix.Operand.Kind == shimast.KindBigIntLiteral)
+    }
+  }
+  return false
 }