@ttsc/lint 0.18.4 → 0.19.1

package/linthost/rules_ts_no_restricted_types.go

@@ -1,60 +1,346 @@
-// AST-only baseline of typescript-eslint's `no-restricted-types`.
-//
-// The upstream rule is fully configurable — users supply a map from
-// banned type name to a custom message and (optionally) a rewrite hint.
-// Without the rule-options plumbing, this baseline ships a fixed
-// default set that covers the five built-in wrapper / global types
-// that almost every team forbids: `Object`, `Function`, `Number`,
-// `String`, and `Boolean`. The dedicated `typescript/no-unsafe-function-type`
-// and `typescript/no-wrapper-object-types` rules also cover some of
-// these, but `no-restricted-types` is the documented umbrella users
-// reach for when they want a single "ban these names" knob.
+// typescript/no-restricted-types implements typescript-eslint's configurable
+// spelling policy for type syntax. The rule has no implicit restrictions: a
+// type is rejected only when its whitespace-normalized source spelling is an
+// enabled key in the configured `types` map.
 //
 // https://typescript-eslint.io/rules/no-restricted-types/
 package linthost
 
 import (
+  "bytes"
+  "encoding/json"
+  "errors"
+  "fmt"
+  "io"
+  "strings"
+  "unicode"
+
   shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
-type noRestrictedTypes struct{}
+type noRestrictedTypes struct{ optionsRule }
+
+type noRestrictedTypeConfig struct {
+  enabled     bool
+  message     string
+  fixWith     string
+  suggestions []string
+}
 
-// noRestrictedTypesDefault is the default set surfaced by the rule
-// when no config is supplied. Each entry pairs the banned identifier
-// with a short, actionable replacement hint.
-var noRestrictedTypesDefault = map[string]string{
-  "Object":   "Use `object` (any non-primitive) or a specific shape like `Record<string, unknown>` instead of `Object`.",
-  "Function": "Declare the specific call signature instead of the unsafe `Function` type.",
-  "Number":   "Use the lowercase primitive `number` instead of the wrapper type `Number`.",
-  "String":   "Use the lowercase primitive `string` instead of the wrapper type `String`.",
-  "Boolean":  "Use the lowercase primitive `boolean` instead of the wrapper type `Boolean`.",
+type noRestrictedTypeObjectConfig struct {
+  Message json.RawMessage `json:"message"`
+  FixWith json.RawMessage `json:"fixWith"`
+  Suggest json.RawMessage `json:"suggest"`
 }
 
 func (noRestrictedTypes) Name() string { return "typescript/no-restricted-types" }
 func (noRestrictedTypes) Visits() []shimast.Kind {
-  return []shimast.Kind{shimast.KindTypeReference}
+  // Decode the options once per file, then inspect only the upstream rule's
+  // supported type-syntax surfaces during one AST walk.
+  return []shimast.Kind{shimast.KindSourceFile}
 }
+
+func (noRestrictedTypes) ValidateOptions(raw json.RawMessage) error {
+  _, err := decodeNoRestrictedTypesOptions(raw)
+  return err
+}
+
 func (noRestrictedTypes) Check(ctx *Context, node *shimast.Node) {
-  ref := node.AsTypeReferenceNode()
-  if ref == nil || ref.TypeName == nil {
+  configured, err := decodeNoRestrictedTypesOptions(ctx.Options)
+  if err != nil || len(configured) == 0 {
+    // Real config-loading paths reject malformed settings through
+    // ValidateOptions. A directly constructed resolver still fails safely.
     return
   }
-  name := identifierText(ref.TypeName)
-  if name == "" {
+  walkDescendants(node, func(candidate *shimast.Node) {
+    checkNoRestrictedTypeNode(ctx, candidate, configured)
+  })
+}
+
+func checkNoRestrictedTypeNode(
+  ctx *Context,
+  node *shimast.Node,
+  configured map[string]noRestrictedTypeConfig,
+) {
+  if node == nil {
     return
   }
-  message, banned := noRestrictedTypesDefault[name]
-  if !banned {
+  switch node.Kind {
+  case shimast.KindTypeReference:
+    ref := node.AsTypeReferenceNode()
+    if ref == nil || ref.TypeName == nil {
+      return
+    }
+    reportRestrictedType(ctx, ref.TypeName, configured)
+    if ref.TypeArguments != nil && len(ref.TypeArguments.Nodes) != 0 {
+      reportRestrictedType(ctx, node, configured)
+    }
+  case shimast.KindExpressionWithTypeArguments:
+    if !isRestrictedTypeHeritage(node) {
+      return
+    }
+    heritage := node.AsExpressionWithTypeArguments()
+    if heritage == nil || heritage.Expression == nil {
+      return
+    }
+    reportRestrictedType(ctx, heritage.Expression, configured)
+    if heritage.TypeArguments != nil && len(heritage.TypeArguments.Nodes) != 0 {
+      reportRestrictedType(ctx, node, configured)
+    }
+  case shimast.KindTupleType:
+    tuple := node.AsTupleTypeNode()
+    if tuple != nil && tuple.Elements != nil && len(tuple.Elements.Nodes) == 0 {
+      reportRestrictedType(ctx, node, configured)
+    }
+  case shimast.KindTypeLiteral:
+    literal := node.AsTypeLiteralNode()
+    if literal != nil && literal.Members != nil && len(literal.Members.Nodes) == 0 {
+      reportRestrictedType(ctx, node, configured)
+    }
+  case shimast.KindNullKeyword:
+    // TypeScript-Go shares NullKeyword between the runtime literal and the
+    // token wrapped by a null LiteralType. typescript-estree exposes only the
+    // latter as TSNullKeyword to this rule.
+    if node.Parent != nil && node.Parent.Kind == shimast.KindLiteralType {
+      reportRestrictedType(ctx, node, configured)
+    }
+  case shimast.KindVoidKeyword:
+    // Exclude the runtime `void expression` operator; only the type keyword is
+    // a typescript-eslint TSVoidKeyword listener target.
+    if node.Parent == nil || node.Parent.Kind != shimast.KindVoidExpression {
+      reportRestrictedType(ctx, node, configured)
+    }
+  case shimast.KindBigIntKeyword,
+    shimast.KindBooleanKeyword,
+    shimast.KindNeverKeyword,
+    shimast.KindNumberKeyword,
+    shimast.KindObjectKeyword,
+    shimast.KindStringKeyword,
+    shimast.KindSymbolKeyword,
+    shimast.KindUndefinedKeyword,
+    shimast.KindUnknownKeyword:
+    reportRestrictedType(ctx, node, configured)
+  }
+}
+
+// isRestrictedTypeHeritage mirrors the two upstream listener surfaces:
+// TSClassImplements and TSInterfaceHeritage. A class `extends` expression is a
+// runtime value expression and is deliberately excluded, although type
+// references nested in its type arguments are still visited independently.
+func isRestrictedTypeHeritage(node *shimast.Node) bool {
+  clauseNode := node.Parent
+  if clauseNode == nil || clauseNode.Kind != shimast.KindHeritageClause {
+    return false
+  }
+  clause := clauseNode.AsHeritageClause()
+  if clause == nil {
+    return false
+  }
+  if clause.Token == shimast.KindImplementsKeyword {
+    return true
+  }
+  return clause.Token == shimast.KindExtendsKeyword &&
+    clauseNode.Parent != nil && clauseNode.Parent.Kind == shimast.KindInterfaceDeclaration
+}
+
+func reportRestrictedType(
+  ctx *Context,
+  node *shimast.Node,
+  configured map[string]noRestrictedTypeConfig,
+) {
+  name := normalizeRestrictedTypeName(nodeText(ctx.File, node))
+  restriction, ok := configured[name]
+  if name == "" || !ok || !restriction.enabled {
     return
   }
-  // Shadow guard: if the user has declared a same-named `type` /
-  // `interface` / `class` at file scope, their identifier is NOT the
-  // global wrapper. Re-use the wrapper-types helper so the two rules
-  // stay consistent about what counts as a shadow.
-  if fileShadowsWrapperName(ctx.File, name) {
+
+  message := fmt.Sprintf("Don't use `%s` as a type.", name)
+  if restriction.message != "" {
+    message += " " + restriction.message
+  }
+  pos, end := tokenRange(ctx.File, node)
+  if pos < 0 {
+    ctx.Report(node, message)
     return
   }
-  ctx.Report(node, message)
+
+  var fix []TextEdit
+  if restriction.fixWith != "" {
+    fix = []TextEdit{{Pos: pos, End: end, Text: restriction.fixWith}}
+  }
+  suggestions := make([]Suggestion, 0, len(restriction.suggestions))
+  for _, replacement := range restriction.suggestions {
+    suggestions = append(suggestions, Suggestion{
+      Title: fmt.Sprintf("Replace `%s` with `%s`.", name, replacement),
+      Edits: []TextEdit{{Pos: pos, End: end, Text: replacement}},
+    })
+  }
+  ctx.ReportFixSuggestions(node, message, fix, suggestions...)
+}
+
+// decodeNoRestrictedTypesOptions validates the complete public option shape
+// and preserves object declaration order. Whitespace-equivalent keys collapse
+// exactly as they do in the upstream Map constructor, with the later entry
+// winning deterministically.
+func decodeNoRestrictedTypesOptions(raw json.RawMessage) (map[string]noRestrictedTypeConfig, error) {
+  configured := map[string]noRestrictedTypeConfig{}
+  if len(bytes.TrimSpace(raw)) == 0 {
+    return configured, nil
+  }
+
+  decoder := json.NewDecoder(bytes.NewReader(raw))
+  token, err := decoder.Token()
+  if err != nil {
+    return nil, fmt.Errorf("options must be an object: %w", err)
+  }
+  if token != json.Delim('{') {
+    return nil, errors.New("options must be an object")
+  }
+
+  var types json.RawMessage
+  for decoder.More() {
+    token, err = decoder.Token()
+    if err != nil {
+      return nil, err
+    }
+    key, ok := token.(string)
+    if !ok {
+      return nil, errors.New("option keys must be strings")
+    }
+    if key != "types" {
+      return nil, fmt.Errorf("unknown option %q", key)
+    }
+    if err := decoder.Decode(&types); err != nil {
+      return nil, fmt.Errorf("decode options.types: %w", err)
+    }
+  }
+  if err := closeRestrictedTypesObject(decoder, "options"); err != nil {
+    return nil, err
+  }
+  if len(types) == 0 {
+    return configured, nil
+  }
+  return decodeRestrictedTypesMap(types)
+}
+
+func decodeRestrictedTypesMap(raw json.RawMessage) (map[string]noRestrictedTypeConfig, error) {
+  configured := map[string]noRestrictedTypeConfig{}
+  decoder := json.NewDecoder(bytes.NewReader(raw))
+  token, err := decoder.Token()
+  if err != nil {
+    return nil, fmt.Errorf("options.types must be an object: %w", err)
+  }
+  if token != json.Delim('{') {
+    return nil, errors.New("options.types must be an object")
+  }
+  for decoder.More() {
+    token, err = decoder.Token()
+    if err != nil {
+      return nil, err
+    }
+    key, ok := token.(string)
+    if !ok {
+      return nil, errors.New("options.types keys must be strings")
+    }
+    var value json.RawMessage
+    if err := decoder.Decode(&value); err != nil {
+      return nil, fmt.Errorf("decode options.types[%q]: %w", key, err)
+    }
+    restriction, err := decodeRestrictedTypeConfig(value)
+    if err != nil {
+      return nil, fmt.Errorf("options.types[%q]: %w", key, err)
+    }
+    configured[normalizeRestrictedTypeName(key)] = restriction
+  }
+  if err := closeRestrictedTypesObject(decoder, "options.types"); err != nil {
+    return nil, err
+  }
+  return configured, nil
+}
+
+func decodeRestrictedTypeConfig(raw json.RawMessage) (noRestrictedTypeConfig, error) {
+  trimmed := bytes.TrimSpace(raw)
+  if len(trimmed) == 0 {
+    return noRestrictedTypeConfig{}, errors.New("restriction must not be empty")
+  }
+  if bytes.Equal(trimmed, []byte("null")) {
+    return noRestrictedTypeConfig{}, nil
+  }
+  if bytes.Equal(trimmed, []byte("true")) || bytes.Equal(trimmed, []byte("false")) {
+    return noRestrictedTypeConfig{enabled: bytes.Equal(trimmed, []byte("true"))}, nil
+  }
+  if trimmed[0] == '"' {
+    var message string
+    if err := json.Unmarshal(trimmed, &message); err != nil {
+      return noRestrictedTypeConfig{}, errors.New("restriction must be a boolean, string, object, or null")
+    }
+    return noRestrictedTypeConfig{enabled: true, message: message}, nil
+  }
+  if trimmed[0] != '{' {
+    return noRestrictedTypeConfig{}, errors.New("restriction must be a boolean, string, object, or null")
+  }
+
+  decoder := json.NewDecoder(bytes.NewReader(trimmed))
+  decoder.DisallowUnknownFields()
+  var object noRestrictedTypeObjectConfig
+  if err := decoder.Decode(&object); err != nil {
+    return noRestrictedTypeConfig{}, fmt.Errorf("invalid restriction object: %w", err)
+  }
+  // The official runtime schema keeps message optional even though its
+  // exported TypeScript object type requires one. Empty, fix-only, and
+  // suggest-only objects therefore ban with the standard diagnostic.
+  var restriction noRestrictedTypeConfig
+  if len(object.Message) != 0 {
+    if !isRestrictedTypeJSONString(object.Message) ||
+      json.Unmarshal(object.Message, &restriction.message) != nil {
+      return noRestrictedTypeConfig{}, errors.New("restriction object message must be a string")
+    }
+  }
+  if len(object.FixWith) != 0 {
+    if !isRestrictedTypeJSONString(object.FixWith) ||
+      json.Unmarshal(object.FixWith, &restriction.fixWith) != nil {
+      return noRestrictedTypeConfig{}, errors.New("restriction object fixWith must be a string")
+    }
+  }
+  if len(object.Suggest) != 0 {
+    if bytes.Equal(bytes.TrimSpace(object.Suggest), []byte("null")) ||
+      json.Unmarshal(object.Suggest, &restriction.suggestions) != nil {
+      return noRestrictedTypeConfig{}, errors.New("restriction object suggest must be a string array")
+    }
+  }
+  restriction.enabled = true
+  return restriction, nil
+}
+
+func isRestrictedTypeJSONString(raw json.RawMessage) bool {
+  trimmed := bytes.TrimSpace(raw)
+  return len(trimmed) >= 2 && trimmed[0] == '"'
+}
+
+func closeRestrictedTypesObject(decoder *json.Decoder, label string) error {
+  token, err := decoder.Token()
+  if err != nil {
+    return err
+  }
+  if token != json.Delim('}') {
+    return fmt.Errorf("%s object is not closed", label)
+  }
+  if err := decoder.Decode(&struct{}{}); !errors.Is(err, io.EOF) {
+    if err != nil {
+      return err
+    }
+    return fmt.Errorf("%s contains trailing JSON", label)
+  }
+  return nil
+}
+
+func normalizeRestrictedTypeName(name string) string {
+  return strings.Map(func(r rune) rune {
+    if unicode.IsSpace(r) || r == '\ufeff' {
+      return -1
+    }
+    return r
+  }, name)
 }
 
 func init() {

package/linthost/rules_ts_no_unnecessary_qualifier.go

@@ -1,8 +1,8 @@
 // typescript/no-unnecessary-qualifier: a qualified reference like
 // `Foo.Bar` written inside `namespace Foo { ... }` (or `enum Foo { ...,
-// X = Foo.Y, ... }`) names the same scope the reference is already in.
-// The qualifier adds no information; dropping `Foo.` leaves the
-// identical binding lookup. typescript-eslint:
+// X = Foo.Y, ... }`) is redundant only when the unqualified name `Bar`
+// resolves, from the same location, to the exact same binding the
+// qualifier reaches. typescript-eslint:
 // https://typescript-eslint.io/rules/no-unnecessary-qualifier/
 package linthost
 
@@ -13,17 +13,36 @@ import (
 // noUnnecessaryQualifier inspects every two-segment qualified reference
 // whose head is a plain identifier — `QualifiedName` shows up in type
 // position (`Foo.Bar` inside a type annotation) and
-// `PropertyAccessExpression` shows up in value position. The check is
-// AST-only: it walks the ancestor chain for an enclosing `namespace
-// <head> { ... }` or `enum <head> { ... }` declaration and reports when
-// one is found. The rule deliberately does not consult the Checker
-// because the upstream rule operates on lexical scope identity, which
-// the AST already encodes via declaration ancestry.
+// `PropertyAccessExpression` shows up in value position.
+//
+// The check is type-aware, mirroring the upstream rule's
+// `qualifierIsUnnecessary`: text identity alone is not enough because a
+// qualifier can be load-bearing. `Foo.` is redundant only when
+//
+//  1. the head identifier resolves to a namespace/enum symbol that is
+//     declared by one of the declarations enclosing the access
+//     (`symbolIsNamespaceInScope`), and
+//  2. the member name, looked up unqualified from the head's location,
+//     resolves to the same symbol the qualified access reaches
+//     (`getSymbolsInScope` + export-symbol equality).
+//
+// The second clause is what keeps a shadowed member (`const bar` hiding
+// `Foo.bar`) or a shadowed namespace name (`const Foo = { bar }`) from
+// being reported — dropping such a qualifier would silently change which
+// binding the code reads.
 type noUnnecessaryQualifier struct{}
 
 func (noUnnecessaryQualifier) Name() string {
   return "typescript/no-unnecessary-qualifier"
 }
+
+// NeedsTypeChecker marks the rule type-aware: it resolves the head and
+// member symbols and enumerates the in-scope bindings through
+// Context.Checker, so the engine must acquire a checker for it.
+func (noUnnecessaryQualifier) NeedsTypeChecker() bool {
+  return true
+}
+
 func (noUnnecessaryQualifier) Visits() []shimast.Kind {
   return []shimast.Kind{
     shimast.KindQualifiedName,
@@ -31,88 +50,146 @@ func (noUnnecessaryQualifier) Visits() []shimast.Kind {
   }
 }
 func (noUnnecessaryQualifier) Check(ctx *Context, node *shimast.Node) {
-  head := noUnnecessaryQualifierHead(node)
-  if head == "" {
+  head, name := noUnnecessaryQualifierParts(node)
+  if head == nil || name == nil {
     return
   }
-  if !noUnnecessaryQualifierHasEnclosingScope(node, head) {
+  if !noUnnecessaryQualifierIsUnnecessary(ctx, node, head, name) {
     return
   }
-  ctx.Report(node, "Qualifier `"+head+"` is the enclosing namespace or enum — drop the qualifier.")
+  ctx.Report(node, "Qualifier `"+identifierText(head)+"` is the enclosing namespace or enum — drop the qualifier.")
 }
 
-// noUnnecessaryQualifierHead returns the LHS identifier text when the
-// node is a two-segment qualified reference (`A.B`) whose head is a
-// plain identifier. Returns "" for nested chains (`A.B.C`), computed
-// accesses, or non-identifier heads — those shapes don't match the
-// "qualifier names the enclosing scope" pattern.
-func noUnnecessaryQualifierHead(node *shimast.Node) string {
+// noUnnecessaryQualifierParts returns the head (qualifier) and member
+// name nodes of a two-segment qualified reference (`A.B`) whose head is a
+// plain identifier. Returns (nil, nil) for nested chains (`A.B.C`),
+// computed accesses, or non-identifier heads — those shapes don't match
+// the "qualifier names the enclosing scope" pattern.
+func noUnnecessaryQualifierParts(node *shimast.Node) (head *shimast.Node, name *shimast.Node) {
   if node == nil {
-    return ""
+    return nil, nil
   }
   switch node.Kind {
   case shimast.KindQualifiedName:
     qn := node.AsQualifiedName()
-    if qn == nil || qn.Left == nil {
-      return ""
+    if qn == nil || qn.Left == nil || qn.Right == nil {
+      return nil, nil
     }
     if qn.Left.Kind != shimast.KindIdentifier {
-      return ""
+      return nil, nil
     }
-    return identifierText(qn.Left)
+    return qn.Left, qn.Right
   case shimast.KindPropertyAccessExpression:
     pa := node.AsPropertyAccessExpression()
     if pa == nil || pa.Expression == nil || pa.Name() == nil {
-      return ""
+      return nil, nil
     }
     // Optional chains (`Foo?.Bar`) aren't redundant in the same
     // sense — the `?.` changes runtime behavior, so leave them be.
     if pa.QuestionDotToken != nil {
-      return ""
+      return nil, nil
     }
     if pa.Expression.Kind != shimast.KindIdentifier {
-      return ""
+      return nil, nil
     }
-    return identifierText(pa.Expression)
+    return pa.Expression, pa.Name()
+  }
+  return nil, nil
+}
+
+// noUnnecessaryQualifierIsUnnecessary is the Go port of upstream
+// `qualifierIsUnnecessary`. It reports whether dropping the `head.`
+// qualifier leaves the identical binding lookup.
+func noUnnecessaryQualifierIsUnnecessary(ctx *Context, node *shimast.Node, head *shimast.Node, name *shimast.Node) bool {
+  if ctx == nil || ctx.Checker == nil {
+    return false
+  }
+  // The cheap AST walk short-circuits before any checker call: the vast
+  // majority of qualified references in a program sit outside every
+  // namespace/enum, so an empty enclosing set rules them out without
+  // resolving a symbol.
+  enclosing := noUnnecessaryQualifierEnclosingNamespaces(node)
+  if len(enclosing) == 0 {
+    return false
   }
-  return ""
+  namespaceSymbol := ctx.Checker.GetSymbolAtLocation(head)
+  if namespaceSymbol == nil {
+    return false
+  }
+  if !noUnnecessaryQualifierSymbolIsNamespaceInScope(ctx, enclosing, namespaceSymbol, 0) {
+    return false
+  }
+  accessedSymbol := ctx.Checker.GetSymbolAtLocation(name)
+  if accessedSymbol == nil {
+    return false
+  }
+  fromScope := noUnnecessaryQualifierSymbolInScope(ctx, head, accessedSymbol.Flags, identifierText(name))
+  if fromScope == nil {
+    return false
+  }
+  // Upstream `symbolsAreEqual`: the unqualified lookup must reach the
+  // same symbol as the qualified access. Normalizing the in-scope
+  // symbol to its export symbol collapses the local/export duality that
+  // a namespace or enum member carries.
+  return accessedSymbol == ctx.Checker.GetExportSymbolOfSymbol(fromScope)
 }
 
-// noUnnecessaryQualifierHasEnclosingScope reports whether `node`
-// appears inside a `namespace <head> { ... }` or `enum <head> { ... }`
-// declaration body. The walk climbs `Parent` links until it finds a
-// matching block or hits the SourceFile root.
-func noUnnecessaryQualifierHasEnclosingScope(node *shimast.Node, head string) bool {
+// noUnnecessaryQualifierEnclosingNamespaces collects the `namespace`
+// (`ModuleDeclaration`) and `enum` (`EnumDeclaration`) declaration nodes
+// that enclose `node`, mirroring the upstream `namespacesInScope` stack.
+// The walk climbs `Parent` links until it hits the SourceFile root.
+func noUnnecessaryQualifierEnclosingNamespaces(node *shimast.Node) []*shimast.Node {
+  var enclosing []*shimast.Node
   for cur := node.Parent; cur != nil; cur = cur.Parent {
     switch cur.Kind {
-    case shimast.KindModuleDeclaration:
-      decl := cur.AsModuleDeclaration()
-      if decl == nil || decl.Name() == nil {
-        continue
-      }
-      // `declare module "fs"` carries a string-literal name and
-      // does not bind an identifier in the surrounding scope —
-      // skip those entirely. The rule only fires when the head
-      // matches the enclosing namespace's identifier name.
-      if decl.Name().Kind != shimast.KindIdentifier {
-        continue
-      }
-      if identifierText(decl.Name()) == head {
-        return true
-      }
-    case shimast.KindEnumDeclaration:
-      decl := cur.AsEnumDeclaration()
-      if decl == nil || decl.Name() == nil {
-        continue
-      }
-      if identifierText(decl.Name()) == head {
+    case shimast.KindModuleDeclaration, shimast.KindEnumDeclaration:
+      enclosing = append(enclosing, cur)
+    }
+  }
+  return enclosing
+}
+
+// noUnnecessaryQualifierSymbolIsNamespaceInScope is the Go port of
+// upstream `symbolIsNamespaceInScope`: it reports whether `symbol` is one
+// of the namespaces/enums currently in scope by checking its declarations
+// against `enclosing`, following aliases when the direct declarations
+// don't match. The depth guard bounds pathological alias cycles.
+func noUnnecessaryQualifierSymbolIsNamespaceInScope(ctx *Context, enclosing []*shimast.Node, symbol *shimast.Symbol, depth int) bool {
+  if symbol == nil || depth > 16 {
+    return false
+  }
+  for _, decl := range symbol.Declarations {
+    for _, ns := range enclosing {
+      if decl == ns {
         return true
       }
     }
   }
+  if symbol.Flags&shimast.SymbolFlagsAlias != 0 {
+    alias := ctx.Checker.GetAliasedSymbol(symbol)
+    if alias != nil && alias != symbol {
+      return noUnnecessaryQualifierSymbolIsNamespaceInScope(ctx, enclosing, alias, depth+1)
+    }
+  }
   return false
 }
 
+// noUnnecessaryQualifierSymbolInScope is the Go port of upstream
+// `getSymbolInScope`: it returns the first symbol named `name` that the
+// checker reports as visible (with the given meaning `flags`) from the
+// `head` location, or nil when the name is not in scope.
+func noUnnecessaryQualifierSymbolInScope(ctx *Context, head *shimast.Node, flags shimast.SymbolFlags, name string) *shimast.Symbol {
+  if name == "" {
+    return nil
+  }
+  for _, symbol := range ctx.Checker.GetSymbolsInScope(head, flags) {
+    if symbol != nil && symbol.Name == name {
+      return symbol
+    }
+  }
+  return nil
+}
+
 func init() {
   Register(noUnnecessaryQualifier{})
 }