@ttsc/lint 0.18.4 → 0.19.1

package/linthost/rules_no_duplicate_imports.go

@@ -0,0 +1,266 @@
+// noDuplicateImports reports an import (and, with `includeExports`, a
+// re-export) declaration whose module specifier already appeared above,
+// but only when the two declarations could be consolidated into one
+// legal declaration. Same-module declarations TypeScript cannot merge —
+// named next to namespace bindings, or (since ESLint 9.30.1) a
+// type-only default next to type-only named bindings — are not
+// duplicates, and `allowSeparateTypeImports` additionally keeps one
+// clause-level `import type` declaration apart from value-bearing
+// declarations.
+// https://eslint.org/docs/latest/rules/no-duplicate-imports
+package linthost
+
+import (
+  "strings"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+// noDuplicateImportsOptions mirrors the official rule's options object.
+// Both keys default to false, matching ESLint's `defaultOptions`.
+type noDuplicateImportsOptions struct {
+  // AllowSeparateTypeImports keeps clause-level `import type` / `export
+  // type` declarations out of the duplicate comparison with
+  // value-bearing declarations of the same module. Inline type
+  // specifiers (`import { type Foo }`) stay on the value side because
+  // their import clause is not type-only.
+  AllowSeparateTypeImports bool `json:"allowSeparateTypeImports"`
+
+  // IncludeExports folds `export … from` declarations into the same
+  // duplicate/mergeability analysis, adding the official
+  // duplicated-as-export / duplicated-as-import pairings.
+  IncludeExports bool `json:"includeExports"`
+}
+
+// importExportCategory mirrors the specifier categories the official
+// implementation derives from ESTree specifier types
+// (`getImportExportType`).
+type importExportCategory int
+
+const (
+  // `import def from "m"` — ImportDefaultSpecifier.
+  importExportDefault importExportCategory = iota
+  // `import { a } from "m"` / `export { a } from "m"` —
+  // ImportSpecifier / ExportSpecifier.
+  importExportNamed
+  // `import * as ns from "m"` / `export * as ns from "m"` —
+  // ImportNamespaceSpecifier / ExportNamespaceSpecifier.
+  importExportNamespace
+  // `export * from "m"` — ExportAllDeclaration without an alias.
+  importExportAll
+  // `import "m"` and specifier-less clauses such as `import {} from
+  // "m"` / `export {} from "m"` — SideEffectImport.
+  importExportSideEffect
+)
+
+// importExportEntry retains the shape of one earlier import/re-export
+// declaration so later declarations of the same module can answer the
+// mergeability question against it.
+type importExportEntry struct {
+  node     *shimast.Node
+  category importExportCategory
+  typeOnly bool
+  isExport bool
+}
+
+type noDuplicateImports struct{ optionsRule }
+
+func (noDuplicateImports) Name() string { return "no-duplicate-imports" }
+func (noDuplicateImports) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindSourceFile}
+}
+func (noDuplicateImports) Check(ctx *Context, node *shimast.Node) {
+  var opts noDuplicateImportsOptions
+  _ = ctx.DecodeOptions(&opts)
+  modules := map[string][]importExportEntry{}
+  node.ForEachChild(func(child *shimast.Node) bool {
+    if child == nil {
+      return false
+    }
+    switch child.Kind {
+    case shimast.KindImportDeclaration:
+      decl := child.AsImportDeclaration()
+      if decl == nil {
+        return false
+      }
+      module := duplicateImportsModule(decl.ModuleSpecifier)
+      if module == "" {
+        return false
+      }
+      entry := duplicateImportsImportEntry(child, decl)
+      reportDuplicateImports(ctx, opts, modules[module], entry, module)
+      modules[module] = append(modules[module], entry)
+    case shimast.KindExportDeclaration:
+      // Without `includeExports` the official rule does not even
+      // record re-exports, so they can neither be reported nor make
+      // a later import count as duplicated-as-export.
+      if !opts.IncludeExports {
+        return false
+      }
+      decl := child.AsExportDeclaration()
+      if decl == nil {
+        return false
+      }
+      module := duplicateImportsModule(decl.ModuleSpecifier)
+      if module == "" {
+        return false
+      }
+      entry := duplicateImportsExportEntry(child, decl)
+      reportDuplicateImports(ctx, opts, modules[module], entry, module)
+      modules[module] = append(modules[module], entry)
+    }
+    return false
+  })
+}
+
+// duplicateImportsModule returns the trimmed module specifier text, or
+// "" when the declaration has no usable string specifier (`export { x
+// }` without `from`, an empty string module). Trimming mirrors the
+// official implementation, which compares `source.value.trim()`.
+func duplicateImportsModule(spec *shimast.Node) string {
+  return strings.TrimSpace(stringLiteralText(spec))
+}
+
+// duplicateImportsImportEntry categorizes one `import` declaration the
+// way the official rule reads ESTree specifiers: the first named or
+// namespace specifier decides the category, a lone default binding is
+// the default category, and a clause-less or specifier-less import is a
+// side-effect import.
+func duplicateImportsImportEntry(node *shimast.Node, decl *shimast.ImportDeclaration) importExportEntry {
+  entry := importExportEntry{node: node, category: importExportSideEffect}
+  clause := decl.ImportClause
+  if clause == nil {
+    return entry
+  }
+  entry.typeOnly = clause.IsTypeOnly()
+  clauseData := clause.AsImportClause()
+  if clauseData == nil {
+    return entry
+  }
+  if bindings := clauseData.NamedBindings; bindings != nil {
+    switch bindings.Kind {
+    case shimast.KindNamespaceImport:
+      entry.category = importExportNamespace
+      return entry
+    case shimast.KindNamedImports:
+      // `import def, {} from "m"` has no named specifier in ESTree;
+      // the empty block falls through to the default binding below.
+      if named := bindings.AsNamedImports(); named != nil && named.Elements != nil && len(named.Elements.Nodes) > 0 {
+        entry.category = importExportNamed
+        return entry
+      }
+    }
+  }
+  if clauseData.Name() != nil {
+    entry.category = importExportDefault
+  }
+  return entry
+}
+
+// duplicateImportsExportEntry categorizes one `export … from`
+// declaration. `export * from` is the export-all category, `export * as
+// ns from` is a namespace specifier, non-empty `export { … } from` is
+// named, and the degenerate `export {} from "m"` matches the official
+// specifier-less SideEffectImport category.
+func duplicateImportsExportEntry(node *shimast.Node, decl *shimast.ExportDeclaration) importExportEntry {
+  entry := importExportEntry{
+    node:     node,
+    category: importExportSideEffect,
+    typeOnly: decl.IsTypeOnly,
+    isExport: true,
+  }
+  clause := decl.ExportClause
+  if clause == nil {
+    entry.category = importExportAll
+    return entry
+  }
+  switch clause.Kind {
+  case shimast.KindNamespaceExport:
+    entry.category = importExportNamespace
+  case shimast.KindNamedExports:
+    if named := clause.AsNamedExports(); named != nil && named.Elements != nil && len(named.Elements.Nodes) > 0 {
+      entry.category = importExportNamed
+    }
+  }
+  return entry
+}
+
+// reportDuplicateImports mirrors the official checkAndReport: an import
+// is reported once against earlier imports and once more against
+// earlier re-exports, a re-export against earlier re-exports and
+// earlier imports, each pairing with its own message. Earlier
+// re-exports only exist when `includeExports` recorded them.
+func reportDuplicateImports(ctx *Context, opts noDuplicateImportsOptions, previous []importExportEntry, entry importExportEntry, module string) {
+  if len(previous) == 0 {
+    return
+  }
+  if entry.isExport {
+    if duplicateImportsShouldReport(entry, previous, true, opts.AllowSeparateTypeImports) {
+      ctx.Report(entry.node, "`"+module+"` export is duplicated.")
+    }
+    if duplicateImportsShouldReport(entry, previous, false, opts.AllowSeparateTypeImports) {
+      ctx.Report(entry.node, "`"+module+"` export is duplicated as import.")
+    }
+    return
+  }
+  if duplicateImportsShouldReport(entry, previous, false, opts.AllowSeparateTypeImports) {
+    ctx.Report(entry.node, "`"+module+"` import is duplicated.")
+  }
+  if duplicateImportsShouldReport(entry, previous, true, opts.AllowSeparateTypeImports) {
+    ctx.Report(entry.node, "`"+module+"` import is duplicated as export.")
+  }
+}
+
+// duplicateImportsShouldReport mirrors the official
+// shouldReportImportExport: the new declaration is a duplicate when at
+// least one earlier declaration of the requested kind could legally
+// absorb it. With `allowSeparateTypeImports`, earlier declarations
+// whose clause-level type-ness differs from the new declaration's are
+// exempt from the comparison.
+func duplicateImportsShouldReport(entry importExportEntry, previous []importExportEntry, wantExport bool, allowSeparateTypeImports bool) bool {
+  for _, prev := range previous {
+    if prev.isExport != wantExport {
+      continue
+    }
+    if allowSeparateTypeImports && entry.typeOnly != prev.typeOnly {
+      continue
+    }
+    if duplicateImportsCanMerge(entry, prev) {
+      return true
+    }
+  }
+  return false
+}
+
+// duplicateImportsCanMerge mirrors the official
+// isImportExportCanBeMerged: two same-module declarations are duplicates
+// only when one legal declaration could carry both clauses.
+func duplicateImportsCanMerge(a, b importExportEntry) bool {
+  // ESLint 9.30.1 correction: a type-only default and type-only named
+  // bindings cannot be merged, because `import type Def, { Named }` is
+  // not legal TypeScript.
+  if a.typeOnly && b.typeOnly {
+    if (a.category == importExportDefault && b.category == importExportNamed) ||
+      (b.category == importExportDefault && a.category == importExportNamed) {
+      return false
+    }
+  }
+  // `export * from` merges only with another export-all or with a bare
+  // side-effect import; default, named, and namespace forms all need a
+  // different declaration shape.
+  if (a.category == importExportAll && b.category != importExportAll && b.category != importExportSideEffect) ||
+    (b.category == importExportAll && a.category != importExportAll && a.category != importExportSideEffect) {
+    return false
+  }
+  // A namespace binding and named bindings cannot share one
+  // declaration.
+  if (a.category == importExportNamespace && b.category == importExportNamed) ||
+    (b.category == importExportNamespace && a.category == importExportNamed) {
+    return false
+  }
+  return true
+}
+
+func init() {
+  Register(noDuplicateImports{})
+}

package/linthost/rules_no_else_return.go

@@ -1,71 +1,189 @@
-// noElseReturn: when an `if` block ends in a `return` / `throw` /
-// `break` / `continue` statement, the matching `else` block is
-// redundant — control already left the function (or loop), so flatten
-// the `else` body into the surrounding scope to keep one less level of
-// nesting and one less branch to read.
+// noElseReturn: an `else` block whose preceding `if` branch ends in a
+// `return` is redundant — control already left the function on that
+// branch, so the `else` body can be flattened into the surrounding
+// scope for one less level of nesting and one less branch to read.
 // https://eslint.org/docs/latest/rules/no-else-return
 //
-// AST-only: each visited `IfStatement` whose `ThenStatement` provably
-// terminates control flow on every branch reports on the `else`
-// keyword. A `then` branch terminates when:
+// This is an AST-only port of the ESLint rule, faithful to its
+// analysis:
 //
-//   - it is itself a terminating statement (`return`, `throw`, etc.), or
-//   - it is a `Block` whose final statement terminates AND every
-//     `if/else if/else` chain inside it terminates on every leaf, or
-//   - it is an `IfStatement` whose `then` AND `else` both terminate
-//     (chained early returns).
-//
-// The analysis is conservative; ambiguous shapes (e.g. an `if` with no
-// `else`, or a loop with `break` only) are left alone.
+//   - Only `return` terminates a branch (`checkForReturn`). `throw`,
+//     `break`, and `continue` do NOT count — matching upstream, which
+//     leaves those shapes alone.
+//   - `allowElseIf` (default `true`) walks the `if / else if` chain and
+//     bails when it ends without a plain `else`, so the very common
+//     `return` + `else if` early-return chain stays valid. Set it to
+//     `false` to also flag an `else if`.
+//   - Analysis starts only at an `if` that sits directly in a statement
+//     list (source file, block, class static block, or switch clause),
+//     mirroring upstream's `STATEMENT_LIST_PARENTS` gate. A nested
+//     `else if` is reached through its chain head's walk, so the rule
+//     reports exactly ONCE — on the chain's terminal `else`.
 package linthost
 
 import (
   shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
-type noElseReturn struct{}
+const noElseReturnMessage = "Remove the `else` — the preceding `if` branch already returns."
+
+type noElseReturn struct{ optionsRule }
+
+// noElseReturnOptions mirrors ESLint's single object option. `AllowElseIf`
+// is a pointer so a missing option decodes to the upstream default (`true`)
+// rather than Go's zero value (`false`).
+type noElseReturnOptions struct {
+  AllowElseIf *bool `json:"allowElseIf"`
+}
 
 func (noElseReturn) Name() string { return "no-else-return" }
 func (noElseReturn) Visits() []shimast.Kind {
   return []shimast.Kind{shimast.KindIfStatement}
 }
+
 func (noElseReturn) Check(ctx *Context, node *shimast.Node) {
+  if node == nil || node.AsIfStatement() == nil {
+    return
+  }
+  // Only analyze a chain head: an `if` whose parent is a statement list.
+  // A nested `else if` (parent is the outer `if`) is folded into its head's
+  // walk, and a bare loop/label body `if` is left alone — both match
+  // upstream's STATEMENT_LIST_PARENTS gate.
+  if !noElseReturnStatementListParent(node.Parent) {
+    return
+  }
+
+  allowElseIf := true
+  var opts noElseReturnOptions
+  _ = ctx.DecodeOptions(&opts)
+  if opts.AllowElseIf != nil {
+    allowElseIf = *opts.AllowElseIf
+  }
+
+  if allowElseIf {
+    noElseReturnCheckWithoutElse(ctx, node)
+  } else {
+    noElseReturnCheckWithElse(ctx, node)
+  }
+}
+
+// noElseReturnCheckWithoutElse ports upstream `checkIfWithoutElse`
+// (`allowElseIf: true`). Starting at the chain head `node`, it walks the
+// `if / else if` chain; if the chain ends without a plain `else` it bails,
+// otherwise it reports once on the terminal `else` when every consequent
+// always returns.
+func noElseReturnCheckWithoutElse(ctx *Context, node *shimast.Node) {
+  consequents := make([]*shimast.Node, 0)
+  var alternate *shimast.Node
+  for current := node; current != nil && current.Kind == shimast.KindIfStatement; {
+    ifStmt := current.AsIfStatement()
+    if ifStmt == nil || ifStmt.ElseStatement == nil {
+      return
+    }
+    consequents = append(consequents, ifStmt.ThenStatement)
+    alternate = ifStmt.ElseStatement
+    current = ifStmt.ElseStatement
+  }
+  for _, consequent := range consequents {
+    if !noElseReturnAlwaysReturns(consequent) {
+      return
+    }
+  }
+  ctx.Report(alternate, noElseReturnMessage)
+}
+
+// noElseReturnCheckWithElse ports upstream `checkIfWithElse`
+// (`allowElseIf: false`): a single `if` with an `else` (which may itself be
+// an `else if`) reports when its consequent always returns.
+func noElseReturnCheckWithElse(ctx *Context, node *shimast.Node) {
   ifStmt := node.AsIfStatement()
   if ifStmt == nil || ifStmt.ElseStatement == nil {
     return
   }
-  if !noElseReturnTerminates(ifStmt.ThenStatement) {
-    return
+  if noElseReturnAlwaysReturns(ifStmt.ThenStatement) {
+    ctx.Report(ifStmt.ElseStatement, noElseReturnMessage)
   }
-  ctx.Report(ifStmt.ElseStatement, "Remove the `else` — the preceding branch already terminates.")
 }
 
-func noElseReturnTerminates(stmt *shimast.Node) bool {
-  if stmt == nil {
+// noElseReturnAlwaysReturns ports upstream `alwaysReturns`: a block returns
+// when ANY of its statements returns (or is an `if/else` that returns on both
+// paths); a non-block returns when it is itself such a statement.
+func noElseReturnAlwaysReturns(node *shimast.Node) bool {
+  if node == nil {
     return false
   }
-  switch stmt.Kind {
-  case shimast.KindReturnStatement,
-    shimast.KindThrowStatement,
-    shimast.KindBreakStatement,
-    shimast.KindContinueStatement:
-    return true
-  case shimast.KindBlock:
-    block := stmt.AsBlock()
+  if node.Kind == shimast.KindBlock {
+    block := node.AsBlock()
     if block == nil || block.Statements == nil {
       return false
     }
-    stmts := block.Statements.Nodes
-    if len(stmts) == 0 {
-      return false
+    for _, stmt := range block.Statements.Nodes {
+      if noElseReturnCheckForReturnOrIf(stmt) {
+        return true
+      }
     }
-    return noElseReturnTerminates(stmts[len(stmts)-1])
-  case shimast.KindIfStatement:
-    inner := stmt.AsIfStatement()
-    if inner == nil || inner.ElseStatement == nil {
+    return false
+  }
+  return noElseReturnCheckForReturnOrIf(node)
+}
+
+// noElseReturnCheckForReturnOrIf ports upstream `checkForReturnOrIf`.
+func noElseReturnCheckForReturnOrIf(node *shimast.Node) bool {
+  return noElseReturnCheckForReturn(node) || noElseReturnCheckForIf(node)
+}
+
+// noElseReturnCheckForReturn ports upstream `checkForReturn`: the terminator
+// is a `return`, and only a `return`.
+func noElseReturnCheckForReturn(node *shimast.Node) bool {
+  return node != nil && node.Kind == shimast.KindReturnStatement
+}
+
+// noElseReturnCheckForIf ports upstream `checkForIf`: an `if` with an `else`
+// whose then AND else branches each naively return (chained early returns).
+func noElseReturnCheckForIf(node *shimast.Node) bool {
+  if node == nil || node.Kind != shimast.KindIfStatement {
+    return false
+  }
+  ifStmt := node.AsIfStatement()
+  if ifStmt == nil || ifStmt.ThenStatement == nil || ifStmt.ElseStatement == nil {
+    return false
+  }
+  return noElseReturnNaiveHasReturn(ifStmt.ElseStatement) &&
+    noElseReturnNaiveHasReturn(ifStmt.ThenStatement)
+}
+
+// noElseReturnNaiveHasReturn ports upstream `naiveHasReturn`: a block returns
+// when its LAST statement is a `return`; a non-block returns when it is itself
+// a `return`.
+func noElseReturnNaiveHasReturn(node *shimast.Node) bool {
+  if node == nil {
+    return false
+  }
+  if node.Kind == shimast.KindBlock {
+    block := node.AsBlock()
+    if block == nil || block.Statements == nil || len(block.Statements.Nodes) == 0 {
       return false
     }
-    return noElseReturnTerminates(inner.ThenStatement) && noElseReturnTerminates(inner.ElseStatement)
+    stmts := block.Statements.Nodes
+    return noElseReturnCheckForReturn(stmts[len(stmts)-1])
+  }
+  return noElseReturnCheckForReturn(node)
+}
+
+// noElseReturnStatementListParent reports whether `parent` is a node whose
+// body is a statement list, the TypeScript-AST equivalents of upstream's
+// STATEMENT_LIST_PARENTS (Program, BlockStatement, StaticBlock, SwitchCase).
+func noElseReturnStatementListParent(parent *shimast.Node) bool {
+  if parent == nil {
+    return false
+  }
+  switch parent.Kind {
+  case shimast.KindSourceFile,
+    shimast.KindBlock,
+    shimast.KindClassStaticBlockDeclaration,
+    shimast.KindCaseClause,
+    shimast.KindDefaultClause:
+    return true
   }
   return false
 }

package/linthost/rules_no_extend_native.go

@@ -2,38 +2,134 @@ package linthost
 
 import shimast "github.com/microsoft/typescript-go/shim/ast"
 
-// noExtendNative: forbid assignments to `<Builtin>.prototype.<key>`,
-// which mutate a shared global and leak across the entire realm.
+// noExtendNative forbids extending a native builtin's prototype, which mutates a
+// shared global and leaks across the entire realm. Mirroring ESLint's
+// no-extend-native, it flags every shape that adds to `<Builtin>.prototype`:
+// direct member assignment (`X.prototype.y = …` and `X.prototype["y"] = …`) and
+// `Object.defineProperty` / `Object.defineProperties` calls whose target is a
+// native prototype. The `exceptions` option removes builtins from the set.
 // https://eslint.org/docs/latest/rules/no-extend-native
-type noExtendNative struct{}
+type noExtendNative struct{ optionsRule }
 
-func (noExtendNative) Name() string           { return "no-extend-native" }
-func (noExtendNative) Visits() []shimast.Kind { return []shimast.Kind{shimast.KindBinaryExpression} }
+type noExtendNativeOptions struct {
+  Exceptions []string `json:"exceptions"`
+}
+
+func (noExtendNative) Name() string { return "no-extend-native" }
+func (noExtendNative) Visits() []shimast.Kind {
+  return []shimast.Kind{shimast.KindBinaryExpression, shimast.KindCallExpression}
+}
 func (noExtendNative) Check(ctx *Context, node *shimast.Node) {
+  switch node.Kind {
+  case shimast.KindBinaryExpression:
+    checkExtendNativeAssignment(ctx, node)
+  case shimast.KindCallExpression:
+    checkExtendNativeDefineProperty(ctx, node)
+  }
+}
+
+// checkExtendNativeAssignment reports `<Builtin>.prototype.<key> = …` and
+// `<Builtin>.prototype["<key>"] = …`. Mirroring upstream's isAssigningToPropertyOf,
+// the assigned member key itself is not inspected: any write to a member of the
+// prototype extends it.
+func checkExtendNativeAssignment(ctx *Context, node *shimast.Node) {
   expr := node.AsBinaryExpression()
-  if expr == nil || expr.OperatorToken == nil {
+  if expr == nil || expr.OperatorToken == nil || expr.OperatorToken.Kind != shimast.KindEqualsToken {
     return
   }
-  if expr.OperatorToken.Kind != shimast.KindEqualsToken {
+  target := stripParens(expr.Left)
+  if target == nil {
     return
   }
-  outer := stripParens(expr.Left)
-  if outer == nil || outer.Kind != shimast.KindPropertyAccessExpression {
+  var object *shimast.Node
+  switch target.Kind {
+  case shimast.KindPropertyAccessExpression:
+    if access := target.AsPropertyAccessExpression(); access != nil {
+      object = access.Expression
+    }
+  case shimast.KindElementAccessExpression:
+    if access := target.AsElementAccessExpression(); access != nil {
+      object = access.Expression
+    }
+  default:
     return
   }
-  receiver := stripParens(outer.AsPropertyAccessExpression().Expression)
-  if receiver == nil || receiver.Kind != shimast.KindPropertyAccessExpression {
-    return
+  if builtin := extendNativePrototypeBuiltin(ctx, object); builtin != "" {
+    ctx.Report(node, builtin+" prototype is read only, properties should not be added.")
   }
-  inner := receiver.AsPropertyAccessExpression()
-  if identifierText(inner.Name()) != "prototype" {
+}
+
+// checkExtendNativeDefineProperty reports
+// `Object.defineProperty(<Builtin>.prototype, …)` and the `defineProperties`
+// variant, mirroring upstream's isInDefinePropertyCall: the extended prototype
+// is the call's first argument.
+func checkExtendNativeDefineProperty(ctx *Context, node *shimast.Node) {
+  call := node.AsCallExpression()
+  if call == nil || call.Arguments == nil || len(call.Arguments.Nodes) == 0 {
     return
   }
-  builtin := identifierText(stripParens(inner.Expression))
-  if !isExtendNativeBuiltin(builtin) {
+  callee := stripParens(call.Expression)
+  if !isMatchingPropertyAccess(callee, "Object", "defineProperty") &&
+    !isMatchingPropertyAccess(callee, "Object", "defineProperties") {
     return
   }
-  ctx.Report(node, builtin+" prototype is read only, properties should not be added.")
+  if builtin := extendNativePrototypeBuiltin(ctx, call.Arguments.Nodes[0]); builtin != "" {
+    ctx.Report(node, builtin+" prototype is read only, properties should not be added.")
+  }
+}
+
+// extendNativePrototypeBuiltin returns the native builtin name when `node` reads
+// `<Builtin>.prototype` — through `.prototype` property access or a static
+// `["prototype"]` element access — and the builtin is protected (a known native
+// not listed in the rule's `exceptions` option). Otherwise it returns "".
+// Mirrors upstream's isPrototypePropertyAccessed, which resolves the accessed
+// key with getStaticPropertyName, combined with the exceptions filter.
+func extendNativePrototypeBuiltin(ctx *Context, node *shimast.Node) string {
+  node = stripParens(node)
+  if node == nil {
+    return ""
+  }
+  var object *shimast.Node
+  var key string
+  switch node.Kind {
+  case shimast.KindPropertyAccessExpression:
+    access := node.AsPropertyAccessExpression()
+    if access == nil {
+      return ""
+    }
+    object = access.Expression
+    key = identifierText(access.Name())
+  case shimast.KindElementAccessExpression:
+    access := node.AsElementAccessExpression()
+    if access == nil {
+      return ""
+    }
+    object = access.Expression
+    key = stringLiteralText(access.ArgumentExpression)
+  default:
+    return ""
+  }
+  if key != "prototype" {
+    return ""
+  }
+  builtin := identifierText(stripParens(object))
+  if !isExtendNativeBuiltin(builtin) || extendNativeExcepted(ctx, builtin) {
+    return ""
+  }
+  return builtin
+}
+
+// extendNativeExcepted reports whether the rule's `exceptions` option opts the
+// given builtin out of the protected set.
+func extendNativeExcepted(ctx *Context, builtin string) bool {
+  var options noExtendNativeOptions
+  _ = ctx.DecodeOptions(&options)
+  for _, name := range options.Exceptions {
+    if name == builtin {
+      return true
+    }
+  }
+  return false
 }
 
 func isExtendNativeBuiltin(name string) bool {