@ttsc/lint 0.18.4 → 0.19.1

package/linthost/rules_jsx_a11y.go

@@ -5,6 +5,7 @@ import (
   "strings"
 
   shimast "github.com/microsoft/typescript-go/shim/ast"
+  "golang.org/x/text/language"
 )
 
 type jsxAttr struct {
@@ -456,7 +457,7 @@ func jsxIsFocusable(info jsxElementInfo) bool {
 
 func jsxIsNonInteractiveElement(tag string) bool {
   switch tag {
-  case "article", "aside", "div", "footer", "header", "li", "main", "nav", "ol", "p", "section", "ul",
+  case "article", "aside", "footer", "header", "li", "main", "nav", "ol", "p", "section", "ul",
     "h1", "h2", "h3", "h4", "h5", "h6":
     return true
   }
@@ -573,7 +574,26 @@ var jsxAutocompleteTokens = map[string]bool{
   "transaction-currency": true, "transaction-amount": true, "language": true, "bday": true,
   "bday-day": true, "bday-month": true, "bday-year": true, "sex": true, "tel": true,
   "tel-country-code": true, "tel-national": true, "tel-area-code": true, "tel-local": true,
-  "tel-extension": true, "impp": true, "url": true, "photo": true,
+  "tel-local-prefix": true, "tel-local-suffix": true, "tel-extension": true,
+  "impp": true, "url": true, "photo": true,
+}
+
+var jsxAutocompleteContactQualifiers = map[string]bool{
+  "home": true, "work": true, "mobile": true, "fax": true, "pager": true,
+}
+
+var jsxAutocompleteContactPurposes = map[string]bool{
+  "email": true, "impp": true, "tel": true, "tel-country-code": true,
+  "tel-national": true, "tel-area-code": true, "tel-local": true,
+  "tel-local-prefix": true, "tel-local-suffix": true, "tel-extension": true,
+}
+
+var jsxHTMLInputTypes = map[string]bool{
+  "button": true, "checkbox": true, "color": true, "date": true, "datetime-local": true,
+  "email": true, "file": true, "hidden": true, "image": true, "month": true,
+  "number": true, "password": true, "radio": true, "range": true, "reset": true,
+  "search": true, "submit": true, "tel": true, "text": true, "time": true,
+  "url": true, "week": true,
 }
 
 type jsxA11yAltText struct{}
@@ -608,8 +628,10 @@ func (jsxA11yAltText) Check(ctx *Context, node *shimast.Node) {
 
 type jsxA11yAnchorHasContent struct{}
 
-func (jsxA11yAnchorHasContent) Name() string           { return "jsx-a11y/anchor-has-content" }
-func (jsxA11yAnchorHasContent) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindJsxElement} }
+func (jsxA11yAnchorHasContent) Name() string { return "jsx-a11y/anchor-has-content" }
+func (jsxA11yAnchorHasContent) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindJsxElement, shimast.KindJsxSelfClosingElement}
+}
 func (jsxA11yAnchorHasContent) Check(ctx *Context, node *shimast.Node) {
   info := jsxElementFromNode(node)
   if info.tag == "a" && !info.spread && !jsxHasAccessibleLabel(info) {
@@ -756,21 +778,123 @@ func (jsxA11yAutocompleteValid) Visits() []shimast.Kind {
 }
 func (jsxA11yAutocompleteValid) Check(ctx *Context, node *shimast.Node) {
   info := jsxElementFromNode(node)
-  attr, ok := jsxKnownAttr(info.attrs, "autoComplete")
+  if info.tag != "input" {
+    return
+  }
+  attr, ok := info.attrs["autoComplete"]
   if !ok {
-    attr, ok = jsxKnownAttr(info.attrs, "autocomplete")
+    attr, ok = info.attrs["autocomplete"]
   }
-  if !ok || strings.TrimSpace(attr.value) == "" {
+  if !ok {
     return
   }
-  for _, token := range strings.Fields(strings.ToLower(attr.value)) {
-    if strings.HasPrefix(token, "section-") || token == "shipping" || token == "billing" || token == "home" || token == "work" || token == "mobile" || token == "fax" || token == "pager" {
-      continue
+  value, ok := jsxStringLiteralAttrValue(attr)
+  if !ok || strings.TrimSpace(value) == "" {
+    return
+  }
+  purpose, valid := jsxAutocompletePurpose(value)
+  if !valid {
+    ctx.Report(attr.node, "autocomplete contains an invalid token sequence.")
+    return
+  }
+  if !jsxAutocompletePurposeAllowsInputType(purpose, jsxAutocompleteInputType(info)) {
+    ctx.Report(attr.node, "autocomplete token is not valid for this input type.")
+  }
+}
+
+func jsxStringLiteralAttrValue(attr jsxAttr) (string, bool) {
+  if attr.node == nil || attr.boolean {
+    return "", false
+  }
+  jsx := attr.node.AsJsxAttribute()
+  if jsx == nil || jsx.Initializer == nil {
+    return "", false
+  }
+  switch jsx.Initializer.Kind {
+  case shimast.KindStringLiteral, shimast.KindNoSubstitutionTemplateLiteral:
+    return stringLiteralText(jsx.Initializer), true
+  case shimast.KindJsxExpression:
+    expression := jsx.Initializer.AsJsxExpression()
+    if expression != nil && expression.Expression != nil && (expression.Expression.Kind == shimast.KindStringLiteral || expression.Expression.Kind == shimast.KindNoSubstitutionTemplateLiteral) {
+      return stringLiteralText(expression.Expression), true
     }
-    if !jsxAutocompleteTokens[token] {
-      ctx.Report(attr.node, "autocomplete contains an invalid token.")
-      return
+  }
+  return "", false
+}
+
+func jsxAutocompletePurpose(value string) (string, bool) {
+  tokens := strings.Fields(strings.ToLower(value))
+  if len(tokens) == 1 && (tokens[0] == "on" || tokens[0] == "off") {
+    return tokens[0], true
+  }
+  index := 0
+  if index < len(tokens) && strings.HasPrefix(tokens[index], "section-") {
+    if len(tokens[index]) == len("section-") {
+      return "", false
+    }
+    index++
+  }
+  if index < len(tokens) && (tokens[index] == "shipping" || tokens[index] == "billing") {
+    index++
+  }
+  qualifier := ""
+  if index < len(tokens) && jsxAutocompleteContactQualifiers[tokens[index]] {
+    qualifier = tokens[index]
+    index++
+  }
+  if index >= len(tokens) {
+    return "", false
+  }
+  purpose := tokens[index]
+  index++
+  if index < len(tokens) {
+    if index != len(tokens)-1 || tokens[index] != "webauthn" {
+      return "", false
     }
+    index++
+  }
+  if purpose == "on" || purpose == "off" || !jsxAutocompleteTokens[purpose] {
+    return "", false
+  }
+  if qualifier != "" && !jsxAutocompleteContactPurposes[purpose] {
+    return "", false
+  }
+  return purpose, index == len(tokens)
+}
+
+func jsxAutocompleteInputType(info jsxElementInfo) string {
+  attr, ok := jsxKnownAttr(info.attrs, "type")
+  if !ok {
+    return "text"
+  }
+  inputType := strings.ToLower(strings.TrimSpace(attr.value))
+  if !jsxHTMLInputTypes[inputType] {
+    return "text"
+  }
+  return inputType
+}
+
+func jsxAutocompletePurposeAllowsInputType(purpose string, inputType string) bool {
+  if purpose == "" || purpose == "on" || purpose == "off" || inputType == "text" {
+    return true
+  }
+  switch purpose {
+  case "email", "username":
+    return inputType == "email" || inputType == "search"
+  case "url", "photo", "impp":
+    return inputType == "url" || inputType == "search"
+  case "tel", "tel-country-code", "tel-national", "tel-area-code", "tel-local", "tel-local-prefix", "tel-local-suffix", "tel-extension":
+    return inputType == "tel" || inputType == "search"
+  case "new-password", "current-password":
+    return inputType == "password" || inputType == "search"
+  case "bday":
+    return inputType == "date" || inputType == "search"
+  case "cc-exp":
+    return inputType == "month" || inputType == "tel" || inputType == "search"
+  case "cc-number", "cc-exp-month", "cc-exp-year", "cc-csc", "transaction-amount", "bday-day", "bday-month", "bday-year":
+    return inputType == "number" || inputType == "tel" || inputType == "search"
+  default:
+    return false
   }
 }
 
@@ -806,7 +930,7 @@ type jsxA11yHeadingHasContent struct{}
 
 func (jsxA11yHeadingHasContent) Name() string { return "jsx-a11y/heading-has-content" }
 func (jsxA11yHeadingHasContent) Visits() []shimast.Kind {
-  return []shimast.Kind{shimast.KindJsxElement}
+  return []shimast.Kind{shimast.KindJsxElement, shimast.KindJsxSelfClosingElement}
 }
 func (jsxA11yHeadingHasContent) Check(ctx *Context, node *shimast.Node) {
   info := jsxElementFromNode(node)
@@ -826,8 +950,55 @@ func (jsxA11yHtmlHasLang) Visits() []shimast.Kind {
 }
 func (jsxA11yHtmlHasLang) Check(ctx *Context, node *shimast.Node) {
   info := jsxElementFromNode(node)
-  if info.tag == "html" && !info.spread && !jsxHasAttr(info.attrs, "lang") {
-    ctx.Report(info.opening, "The html element must have a lang attribute.")
+  if info.tag != "html" {
+    return
+  }
+  if !jsxHasAttr(info.attrs, "lang") {
+    if !info.spread {
+      ctx.Report(info.opening, "The html element must have a lang attribute.")
+    }
+    return
+  }
+  if attr := info.attrs["lang"]; jsxA11yHtmlLangIsStaticallyFalsy(attr) {
+    ctx.Report(attr.node, "The html element must have a non-empty lang attribute.")
+  }
+}
+
+func jsxA11yHtmlLangIsStaticallyFalsy(attr jsxAttr) bool {
+  if attr.node == nil || attr.boolean {
+    return false
+  }
+  jsx := attr.node.AsJsxAttribute()
+  if jsx == nil || jsx.Initializer == nil {
+    return false
+  }
+  if jsx.Initializer.Kind == shimast.KindStringLiteral || jsx.Initializer.Kind == shimast.KindNoSubstitutionTemplateLiteral {
+    return strings.TrimSpace(stringLiteralText(jsx.Initializer)) == ""
+  }
+  if jsx.Initializer.Kind != shimast.KindJsxExpression {
+    return false
+  }
+  expression := jsx.Initializer.AsJsxExpression()
+  if expression == nil || expression.Expression == nil {
+    return true
+  }
+  switch expression.Expression.Kind {
+  case shimast.KindStringLiteral, shimast.KindNoSubstitutionTemplateLiteral:
+    return strings.TrimSpace(stringLiteralText(expression.Expression)) == ""
+  case shimast.KindFalseKeyword, shimast.KindNullKeyword:
+    return true
+  case shimast.KindNumericLiteral:
+    value := strings.ReplaceAll(numericLiteralText(expression.Expression), "_", "")
+    if integer, err := strconv.ParseInt(value, 0, 64); err == nil {
+      return integer == 0
+    }
+    if unsigned, err := strconv.ParseUint(value, 0, 64); err == nil {
+      return unsigned == 0
+    }
+    number, err := strconv.ParseFloat(value, 64)
+    return err == nil && number == 0
+  default:
+    return identifierText(expression.Expression) == "undefined"
   }
 }
 
@@ -910,21 +1081,60 @@ func (jsxA11yLang) Visits() []shimast.Kind {
 }
 func (jsxA11yLang) Check(ctx *Context, node *shimast.Node) {
   info := jsxElementFromNode(node)
-  attr, ok := jsxKnownAttr(info.attrs, "lang")
+  if info.tag != "html" {
+    return
+  }
+  attr, ok := info.attrs["lang"]
   if !ok {
     return
   }
-  value := strings.TrimSpace(attr.value)
-  parts := strings.Split(value, "-")
-  if value == "" || len(parts[0]) < 2 || len(parts[0]) > 3 {
+  if jsxA11yLangIsInvalid(attr) {
     ctx.Report(attr.node, "lang must be a valid BCP 47 language tag.")
   }
 }
 
+func jsxA11yLangIsInvalid(attr jsxAttr) bool {
+  if attr.node == nil || attr.boolean {
+    return true
+  }
+  jsx := attr.node.AsJsxAttribute()
+  if jsx == nil || jsx.Initializer == nil {
+    return true
+  }
+  validate := func(value string) bool {
+    if value != strings.TrimSpace(value) {
+      return true
+    }
+    _, err := language.Parse(value)
+    return err != nil
+  }
+  switch jsx.Initializer.Kind {
+  case shimast.KindStringLiteral, shimast.KindNoSubstitutionTemplateLiteral:
+    return validate(stringLiteralText(jsx.Initializer))
+  case shimast.KindJsxExpression:
+    expression := jsx.Initializer.AsJsxExpression()
+    if expression == nil || expression.Expression == nil {
+      return true
+    }
+    switch expression.Expression.Kind {
+    case shimast.KindStringLiteral, shimast.KindNoSubstitutionTemplateLiteral:
+      return validate(stringLiteralText(expression.Expression))
+    case shimast.KindTrueKeyword, shimast.KindFalseKeyword, shimast.KindNumericLiteral:
+      return true
+    default:
+      return identifierText(expression.Expression) == "undefined"
+    }
+  default:
+    return false
+  }
+}
+
 type jsxA11yMediaHasCaption struct{}
 
-func (jsxA11yMediaHasCaption) Name() string           { return "jsx-a11y/media-has-caption" }
-func (jsxA11yMediaHasCaption) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindJsxElement} }
+func (jsxA11yMediaHasCaption) Name() string { return "jsx-a11y/media-has-caption" }
+func (jsxA11yMediaHasCaption) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindJsxElement, shimast.KindJsxSelfClosingElement}
+}
 func (jsxA11yMediaHasCaption) Check(ctx *Context, node *shimast.Node) {
   info := jsxElementFromNode(node)
   if (info.tag == "audio" || info.tag == "video") && !info.spread && !jsxHasTrackCaption(info.children) {

package/linthost/rules_logic.go

@@ -49,23 +49,7 @@ func (noExtraBooleanCast) Check(ctx *Context, node *shimast.Node) {
       ctx.Report(node, message)
       return
     }
-    src := ctx.File.Text()
-    argStart := shimscanner.SkipTrivia(src, arg.Pos())
-    argEnd := arg.End()
-    if argStart < 0 || argStart >= argEnd || argEnd > len(src) {
-      ctx.Report(node, message)
-      return
-    }
-    editPos := shimscanner.SkipTrivia(src, node.Pos())
-    if editPos < 0 || editPos >= node.End() {
-      ctx.Report(node, message)
-      return
-    }
-    ctx.ReportFix(
-      node,
-      message,
-      TextEdit{Pos: editPos, End: node.End(), Text: src[argStart:argEnd]},
-    )
+    reportBooleanCastFix(ctx, node, arg, message)
   case shimast.KindPrefixUnaryExpression:
     outer := node.AsPrefixUnaryExpression()
     if outer == nil || outer.Operator != shimast.KindExclamationToken {
@@ -83,28 +67,88 @@ func (noExtraBooleanCast) Check(ctx *Context, node *shimast.Node) {
       return
     }
     message := "Redundant double negation."
-    if inner.Operand == nil {
-      ctx.Report(node, message)
-      return
-    }
-    src := ctx.File.Text()
-    inStart := shimscanner.SkipTrivia(src, inner.Operand.Pos())
-    inEnd := inner.Operand.End()
-    if inStart < 0 || inStart >= inEnd || inEnd > len(src) {
-      ctx.Report(node, message)
-      return
+    reportBooleanCastFix(ctx, node, inner.Operand, message)
+  }
+}
+
+// reportBooleanCastFix reports a redundant boolean cast covering `node` and,
+// when safe, attaches the autofix that splices the inner expression's source
+// text over the whole cast. Two hazards can make the raw splice unsafe, and
+// both mirror upstream ESLint's fixer (#362):
+//
+//   - Precedence. In the two expression-level boolean contexts the rule
+//     accepts — `!` operand and ternary condition — a replacement that binds
+//     no tighter than the context re-associates: `!Boolean(a && b)` spliced
+//     bare becomes `!a && b`, which is `(!a) && b`. The replacement is
+//     wrapped in parentheses when the inner expression's precedence is at or
+//     below the context's floor. Statement conditions (`if`/`while`/`do`/
+//     `for`) need no wrap: the statement's own parentheses contain the
+//     result, as do explicit parentheses around the cast itself.
+//   - Comments. The splice keeps only the inner expression's text, so a
+//     comment anywhere else in the replaced span (`!Boolean(/* why */ ok)`)
+//     would be silently deleted. The fix is declined — report only — when
+//     the replaced span contains a comment outside the kept text.
+func reportBooleanCastFix(ctx *Context, node, inner *shimast.Node, message string) {
+  if inner == nil {
+    ctx.Report(node, message)
+    return
+  }
+  src := ctx.File.Text()
+  keepStart := shimscanner.SkipTrivia(src, inner.Pos())
+  keepEnd := inner.End()
+  if keepStart < 0 || keepStart >= keepEnd || keepEnd > len(src) {
+    ctx.Report(node, message)
+    return
+  }
+  editPos := shimscanner.SkipTrivia(src, node.Pos())
+  if editPos < 0 || editPos >= node.End() || node.End() > len(src) {
+    ctx.Report(node, message)
+    return
+  }
+  if hasCommentBetween(src, editPos, keepStart) ||
+    hasCommentBetween(src, keepEnd, node.End()) {
+    ctx.Report(node, message)
+    return
+  }
+  text := src[keepStart:keepEnd]
+  if floor, bounded := booleanContextPrecedenceFloor(node); bounded &&
+    shimast.GetExpressionPrecedence(inner) <= floor {
+    text = "(" + text + ")"
+  }
+  ctx.ReportFix(node, message, TextEdit{Pos: editPos, End: node.End(), Text: text})
+}
+
+// booleanContextPrecedenceFloor returns the precedence at or below which a
+// replacement spliced over `node` re-associates with its surroundings, and
+// whether such a floor applies at all.
+//
+// Only the two expression-level boolean contexts are bounded: an `!` operand
+// must bind tighter than a unary expression (`!(a && b)`, and the grammar
+// even rejects `!x ** 2` outright), and a ternary condition must bind
+// tighter than the conditional itself (`(x = f()) ? a : b`,
+// `(a ? b : c) ? x : y`). The statement conditions `isInBooleanContext`
+// accepts are unbounded — their mandatory parentheses already contain the
+// replacement — and so is a cast explicitly wrapped in parentheses, because
+// the direct parent is then the ParenthesizedExpression, not the `!` or
+// ternary beyond it.
+func booleanContextPrecedenceFloor(node *shimast.Node) (shimast.OperatorPrecedence, bool) {
+  parent := node.Parent
+  if parent == nil {
+    return shimast.OperatorPrecedenceInvalid, false
+  }
+  switch parent.Kind {
+  case shimast.KindPrefixUnaryExpression:
+    prefix := parent.AsPrefixUnaryExpression()
+    if prefix != nil && prefix.Operator == shimast.KindExclamationToken {
+      return shimast.OperatorPrecedenceUnary, true
     }
-    editPos := shimscanner.SkipTrivia(src, node.Pos())
-    if editPos < 0 || editPos >= node.End() {
-      ctx.Report(node, message)
-      return
+  case shimast.KindConditionalExpression:
+    cond := parent.AsConditionalExpression()
+    if cond != nil && cond.Condition == node {
+      return shimast.OperatorPrecedenceConditional, true
     }
-    ctx.ReportFix(
-      node,
-      message,
-      TextEdit{Pos: editPos, End: node.End(), Text: src[inStart:inEnd]},
-    )
   }
+  return shimast.OperatorPrecedenceInvalid, false
 }
 
 // isInBooleanContext walks up the parent chain to determine whether the
@@ -267,7 +311,9 @@ func (useIsNaN) Check(ctx *Context, node *shimast.Node) {
 }
 
 // validTypeof: typeof expressions can only be compared to known type
-// strings. Catches `typeof x === "stirng"`.
+// strings. Catches `typeof x === "stirng"`. Scoped to the four equality
+// operators, like ESLint's own OPERATORS set — a relational comparison such as
+// `typeof x < "m"` orders two strings rather than naming a type.
 // https://eslint.org/docs/latest/rules/valid-typeof
 type validTypeof struct{}
 
@@ -278,7 +324,7 @@ func (validTypeof) Check(ctx *Context, node *shimast.Node) {
   if expr == nil || expr.OperatorToken == nil {
     return
   }
-  if !isComparisonOperator(expr.OperatorToken.Kind) {
+  if !isEqualityOperator(expr.OperatorToken.Kind) {
     return
   }
   left := stripParens(expr.Left)

package/linthost/rules_nextjs.go

@@ -79,32 +79,121 @@ func nextjsInlineScriptID(ctx *Context, file *shimast.Node) {
 }
 
 func nextjsNextScriptForGA(ctx *Context, file *shimast.Node) {
-  imports := nextjsCollectImports(file)
-  if len(imports.scriptFromNextScript) == 0 {
-    return
-  }
-  walkDescendants(file, func(node *shimast.Node) {
-    if node.Kind != shimast.KindJsxElement && node.Kind != shimast.KindJsxSelfClosingElement {
-      return
-    }
-    opening := nextjsOpeningLike(node)
-    if !imports.scriptFromNextScript[nextjsJSXName(opening)] {
+  nextjsWalkOpeningLike(file, func(opening *shimast.Node) {
+    if nextjsJSXName(opening) != "script" {
       return
     }
     src := nextjsJSXAttrString(opening, "src")
-    if strings.Contains(src, "googletagmanager.com/gtag/js") || strings.Contains(src, "googletagmanager.com/gtm.js") {
+    if strings.Contains(src, "www.google-analytics.com/analytics.js") ||
+      strings.Contains(src, "www.googletagmanager.com/gtag/js") {
       ctx.Report(opening, "Use Next.js Google Analytics helpers instead of hand-written gtag scripts.")
       return
     }
-    if node.Kind == shimast.KindJsxElement {
-      text := nodeText(ctx.File, node)
-      if strings.Contains(text, "gtag(") || strings.Contains(text, "GTM-") {
-        ctx.Report(opening, "Use Next.js Google Analytics helpers instead of hand-written gtag scripts.")
-      }
+    inline := nextjsDangerouslySetInnerHTMLSource(opening)
+    if strings.Contains(inline, "www.google-analytics.com/analytics.js") ||
+      strings.Contains(inline, "www.googletagmanager.com/gtm.js") {
+      ctx.Report(opening, "Use Next.js Google Analytics helpers instead of hand-written gtag scripts.")
     }
   })
 }
 
+// nextjsDangerouslySetInnerHTMLSource returns the final static `__html`
+// payload from `dangerouslySetInnerHTML={{ __html: "..." }}`. Object-literal
+// properties are inspected from last to first so an earlier spread or dynamic
+// property cannot obscure a later static assignment, while any later write
+// that might replace `__html` keeps the payload unknown.
+func nextjsDangerouslySetInnerHTMLSource(opening *shimast.Node) string {
+  attrNode := nextjsJSXAttr(opening, "dangerouslySetInnerHTML")
+  if attrNode == nil {
+    return ""
+  }
+  attr := attrNode.AsJsxAttribute()
+  if attr == nil || attr.Initializer == nil || attr.Initializer.Kind != shimast.KindJsxExpression {
+    return ""
+  }
+  container := attr.Initializer.AsJsxExpression()
+  if container == nil {
+    return ""
+  }
+  expression := stripParens(container.Expression)
+  if expression == nil || expression.Kind != shimast.KindObjectLiteralExpression {
+    return ""
+  }
+  object := expression.AsObjectLiteralExpression()
+  if object == nil || object.Properties == nil {
+    return ""
+  }
+  properties := object.Properties.Nodes
+  for i := len(properties) - 1; i >= 0; i-- {
+    propertyNode := properties[i]
+    if propertyNode == nil {
+      return ""
+    }
+    if propertyNode.Kind == shimast.KindSpreadAssignment {
+      return ""
+    }
+
+    switch propertyNode.Kind {
+    case shimast.KindPropertyAssignment:
+      property := propertyNode.AsPropertyAssignment()
+      if property == nil {
+        return ""
+      }
+      name, known := nextjsStaticPropertyName(property.Name())
+      if !known {
+        return ""
+      }
+      if name == "__html" {
+        return stringLiteralText(stripParens(property.Initializer))
+      }
+    case shimast.KindShorthandPropertyAssignment,
+      shimast.KindMethodDeclaration,
+      shimast.KindGetAccessor,
+      shimast.KindSetAccessor:
+      name, known := nextjsStaticPropertyName(propertyNode.Name())
+      if !known {
+        return ""
+      }
+      if name == "__html" {
+        return ""
+      }
+    default:
+      return ""
+    }
+  }
+  return ""
+}
+
+func nextjsStaticPropertyName(node *shimast.Node) (string, bool) {
+  if node == nil {
+    return "", false
+  }
+  switch node.Kind {
+  case shimast.KindIdentifier:
+    return identifierText(node), true
+  case shimast.KindStringLiteral, shimast.KindNoSubstitutionTemplateLiteral:
+    return stringLiteralText(node), true
+  case shimast.KindNumericLiteral, shimast.KindBigIntLiteral:
+    return numericLiteralText(node), true
+  case shimast.KindComputedPropertyName:
+    computed := node.AsComputedPropertyName()
+    if computed == nil {
+      return "", false
+    }
+    expression := stripParens(computed.Expression)
+    if expression == nil {
+      return "", false
+    }
+    switch expression.Kind {
+    case shimast.KindStringLiteral, shimast.KindNoSubstitutionTemplateLiteral:
+      return stringLiteralText(expression), true
+    case shimast.KindNumericLiteral, shimast.KindBigIntLiteral:
+      return numericLiteralText(expression), true
+    }
+  }
+  return "", false
+}
+
 func nextjsNoAssignModuleVariable(ctx *Context, file *shimast.Node) {
   walkDescendants(file, func(node *shimast.Node) {
     if node.Kind != shimast.KindVariableDeclaration {

package/linthost/rules_no_class_assign.go

@@ -0,0 +1,70 @@
+// noClassAssign rejects writes to bindings introduced by class declarations
+// and named class expressions. It follows checker symbols instead of names,
+// so references inside the class and in its surrounding scope resolve while
+// parameter, catch, block, and sibling-scope shadows remain independent.
+// https://eslint.org/docs/latest/rules/no-class-assign
+package linthost
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type noClassAssign struct{}
+
+func (noClassAssign) Name() string           { return "no-class-assign" }
+func (noClassAssign) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindSourceFile} }
+func (noClassAssign) NeedsTypeChecker() bool { return true }
+func (noClassAssign) Check(ctx *Context, node *shimast.Node) {
+  if ctx == nil || ctx.Checker == nil || node == nil {
+    return
+  }
+
+  classSymbols := make(map[*shimast.Symbol]struct{})
+  walkDescendants(node, func(child *shimast.Node) {
+    name := noClassAssignDeclarationName(child)
+    symbol := canonicalValueSymbol(ctx, name)
+    if symbol != nil {
+      classSymbols[symbol] = struct{}{}
+    }
+  })
+  if len(classSymbols) == 0 {
+    return
+  }
+
+  reported := make(map[*shimast.Node]struct{})
+  walkDescendants(node, func(child *shimast.Node) {
+    for _, target := range writeTargetIdentifiers(child) {
+      if _, duplicate := reported[target]; duplicate {
+        continue
+      }
+      symbol := canonicalValueSymbol(ctx, target)
+      if _, isClass := classSymbols[symbol]; !isClass {
+        continue
+      }
+      reported[target] = struct{}{}
+      ctx.Report(target, "'"+identifierText(target)+"' is a class.")
+    }
+  })
+}
+
+// noClassAssignDeclarationName returns the value-binding name introduced by a
+// class declaration or named class expression. Anonymous expressions and
+// anonymous default-export declarations introduce no writable local name.
+func noClassAssignDeclarationName(node *shimast.Node) *shimast.Node {
+  if node == nil {
+    return nil
+  }
+  switch node.Kind {
+  case shimast.KindClassDeclaration:
+    if declaration := node.AsClassDeclaration(); declaration != nil {
+      return declaration.Name()
+    }
+  case shimast.KindClassExpression:
+    if expression := node.AsClassExpression(); expression != nil {
+      return expression.Name()
+    }
+  }
+  return nil
+}
+
+func init() {
+  Register(noClassAssign{})
+}