@ttsc/lint 0.7.2 → 0.7.3

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.2",
+  "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.2"
+    "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
 }