@openrewrite/rewrite 8.92.17 → 8.92.18

package/dist/javascript/scope.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValueReference = void 0;
 exports.scopeOf = scopeOf;
 exports.namesDeclaredIn = namesDeclaredIn;
 exports.namesUsedIn = namesUsedIn;
@@ -12,7 +13,10 @@ exports.cursorOf = cursorOf;
 exports.compilationUnitOf = compilationUnitOf;
 exports.deconflict = deconflict;
 exports.declarationsOf = declarationsOf;
-exports.isValueReference = isValueReference;
+exports.isReference = isReference;
+exports.resolve = resolve;
+exports.isWrite = isWrite;
+exports.referencesOf = referencesOf;
 /*
  * Copyright 2025 the original author or authors.
  * <p>
@@ -32,6 +36,28 @@ const tree_1 = require("../tree");
 const java_1 = require("../java");
 const tree_2 = require("./tree");
 const noNames = new Set();
+const noBindings = new Map();
+/** Whether `bindings` holds `name` with `meaning`, or with any meaning where none is asked for. */
+function binds(bindings, name, meaning) {
+    const binding = bindings.get(name);
+    return binding !== undefined && (meaning === undefined || binding.meanings.has(meaning));
+}
+function bound(identifiers, ...meanings) {
+    return identifiers.map(identifier => ({ identifier, meanings }));
+}
+function toBindings(bound) {
+    const bindings = new Map();
+    for (const declaration of bound) {
+        const name = declaration.identifier.simpleName;
+        let held = bindings.get(name);
+        if (!held) {
+            bindings.set(name, held = { meanings: new Set(), declarations: [] });
+        }
+        declaration.meanings.forEach(meaning => held.meanings.add(meaning));
+        held.declarations.push(declaration);
+    }
+    return bindings;
+}
 /**
  * The innermost scope holding `cursor`, which a visitor's own cursor rarely is: it stands on
  * whatever node it is visiting. Where a declaration's shape leaves its reach unreadable the answer
@@ -43,7 +69,7 @@ function scopeOf(cursor) {
 }
 function scopeAt(cursor) {
     return {
-        names: () => { var _a; return frameBindings(cursor.value, (_a = cursor.parent) === null || _a === void 0 ? void 0 : _a.value); },
+        names: () => new Set(bindingsAt(cursor).keys()),
         walk: visit => {
             for (let c = cursor; c; c = enclosingScopeCursor(c.parent)) {
                 if (!visit(scopeAt(c))) {
@@ -51,8 +77,8 @@ function scopeAt(cursor) {
                 }
             }
         },
-        declares: name => declaringScopeOf(cursor, name) !== undefined,
-        declaringScope: name => declaringScopeOf(cursor, name)
+        declares: (name, meaning) => declaringScopeOf(cursor, name, meaning) !== undefined,
+        declaringScope: (name, meaning) => declaringScopeOf(cursor, name, meaning)
     };
 }
 function enclosingScopeCursor(from) {
@@ -66,8 +92,10 @@ function enclosingScopeCursor(from) {
 }
 /** The nodes {@link readBindings} answers for; everything else binds nothing and is not a scope. */
 const scopeKinds = new Set([
-    tree_2.JS.Kind.CompilationUnit, java_1.J.Kind.Block, java_1.J.Kind.MethodDeclaration, java_1.J.Kind.Lambda,
-    java_1.J.Kind.ClassDeclaration, java_1.J.Kind.TryCatch, java_1.J.Kind.ForLoop, java_1.J.Kind.ForEachLoop, tree_2.JS.Kind.ForInLoop
+    tree_2.JS.Kind.CompilationUnit, java_1.J.Kind.Block, java_1.J.Kind.MethodDeclaration, tree_2.JS.Kind.ComputedPropertyMethodDeclaration,
+    java_1.J.Kind.Lambda, tree_2.JS.Kind.ArrowFunction, java_1.J.Kind.ClassDeclaration, java_1.J.Kind.TryCatch, java_1.J.Kind.ForLoop,
+    java_1.J.Kind.ForEachLoop, tree_2.JS.Kind.ForInLoop, tree_2.JS.Kind.NamespaceDeclaration, tree_2.JS.Kind.TypeDeclaration,
+    tree_2.JS.Kind.FunctionType, tree_2.JS.Kind.MappedType, tree_2.JS.Kind.ConditionalType
 ]);
 /**
  * Every name the file declares, wherever it sits. A binding the whole file shares is referenced from
@@ -114,15 +142,20 @@ function namesDeclaredWithin(node, cacheKey = node) {
     }
     const names = new Set();
     const collect = (node) => {
-        var _a, _b;
-        declarationNames(node).forEach(name => names.add(name));
-        if (node.kind !== java_1.J.Kind.ClassDeclaration) {
+        declarationNames(node).forEach(({ identifier }) => names.add(identifier.simpleName));
+        const members = membersOf(node);
+        if (!members) {
             return true;
         }
-        // The walk ends at this branch, so the class's own type parameters are read here.
-        typeParameterNames(node).forEach(name => names.add(name));
+        // The walk ends at this branch, so what else the node holds is read here.
+        if (node.kind === java_1.J.Kind.ClassDeclaration) {
+            typeParameterNames(node).forEach(({ identifier }) => names.add(identifier.simpleName));
+        }
+        else if (node.kind === java_1.J.Kind.NewClass) {
+            walk(node.arguments, collect);
+        }
         // A member's name is not one the file binds, though the code inside one still declares names.
-        for (const member of (_b = (_a = node.body) === null || _a === void 0 ? void 0 : _a.statements) !== null && _b !== void 0 ? _b : []) {
+        for (const member of members.statements) {
             const element = unwrap(member);
             walk(element, node => node === element || collect(node));
         }
@@ -135,7 +168,8 @@ function namesDeclaredWithin(node, cacheKey = node) {
 /**
  * The names `node` reads and nothing within it binds, so each one reaches a binding further out.
  * A name its parent introduces rather than reads is not one, nor is a name an inner scope rebinds:
- * that reference reads the rebinding.
+ * that reference reads the rebinding. A value position is hidden only by a value binding, a type
+ * position only by a type.
  */
 function namesReferencedWithin(node, cacheKey = node) {
     if (cacheKey === null || typeof cacheKey !== 'object') {
@@ -146,122 +180,309 @@ function namesReferencedWithin(node, cacheKey = node) {
         return cached;
     }
     const names = new Set();
-    collectReferences(node, undefined, undefined, names);
+    treesIn(node).forEach(tree => readReferences(tree, undefined, undefined, 'value', (identifier, reading, scopes) => {
+        if (reading !== undefined && !bindingFrame(scopes, identifier.simpleName, reading)) {
+            names.add(identifier.simpleName);
+        }
+    }));
     referenced.set(cacheKey, names);
     return names;
 }
-/** Whether a scope between the name and where the walk began binds it. */
-function shadowed(scopes, name) {
+/** The innermost of `scopes` binding `name` as `reading` asks, or undefined where none does. */
+function bindingFrame(scopes, name, reading) {
     for (let scope = scopes; scope; scope = scope.outer) {
-        if (frameBindings(scope.node, scope.parent).has(name)) {
-            return true;
+        if (binds(frameBindings(scope.node, scope.parent), name, meaningRead(reading))) {
+            return scope;
         }
     }
-    return false;
+    return undefined;
 }
-function collectReferences(node, parent, scopes, names) {
-    if (Array.isArray(node)) {
-        node.forEach(child => collectReferences(child, parent, scopes, names));
-        return;
+/** The meaning a reading resolves against, or undefined for any. */
+function meaningRead(reading) {
+    return reading === 'any' ? undefined : reading === 'write' ? 'value' : reading;
+}
+/**
+ * Walks `node` top-down, telling `onIdentifier` of every identifier. `reading` is what `node`
+ * itself reads with, or undefined under a slot that names rather than reads.
+ */
+function readReferences(node, parent, scopes, reading, onIdentifier, trail = []) {
+    trail.push(node);
+    if (node.kind === java_1.J.Kind.Identifier) {
+        onIdentifier(node, reading, scopes, trail);
+    }
+    const within = framesAt(node, parent, scopes);
+    for (const [key, value] of Object.entries(node)) {
+        if (key !== 'markers') {
+            const [below, reads] = descend(node, parent, key, within, reading);
+            // A naming position reads against the tree parent, so the padding between is stepped over.
+            treesIn(value).forEach(child => readReferences(child, node, below, reads, onIdentifier, trail));
+        }
     }
-    const kind = node === null || node === void 0 ? void 0 : node.kind;
-    if (kind === java_1.J.Kind.RightPadded || kind === java_1.J.Kind.LeftPadded) {
-        // A naming position reads against the tree parent, so padding forwards the one it was handed.
-        collectReferences(node.element, parent, scopes, names);
-        return;
+    trail.pop();
+}
+/** The scopes a node sits in, with its own in front where it is one. */
+function framesAt(node, parent, scopes) {
+    return scopeKinds.has(node.kind) ? { node, parent, outer: scopes } : scopes;
+}
+/** The scopes the slot `key` of `node` resolves against, and what a read in it reads with. */
+function descend(node, parent, key, within, reading) {
+    return [reachOf(node, parent, key, within), meaningOf(node, key, reading)];
+}
+/**
+ * The scopes the slot `key` of `node` resolves against, `within` being those `node` sits in. A
+ * conditional type's `infer` names reach its extends clause and true branch alone, so its check
+ * type and false branch read past them.
+ */
+function reachOf(node, parent, key, within) {
+    const pastInferred = node.kind === tree_2.JS.Kind.ConditionalType && key === 'checkType' ||
+        node.kind === java_1.J.Kind.Ternary && (parent === null || parent === void 0 ? void 0 : parent.kind) === tree_2.JS.Kind.ConditionalType && key === 'falsePart';
+    return pastInferred ? within === null || within === void 0 ? void 0 : within.outer : within;
+}
+/**
+ * What a read in slot `key` of `node` reads with, given what `node` itself reads with. Undefined
+ * is a slot that names rather than reads, and so is everything under it. A whole import declares
+ * what it spells, and a re-export's clause names another module's members.
+ */
+function meaningOf(node, key, reading) {
+    // A computed key and a binding's default value read from within a naming slot.
+    if (node.kind === tree_2.JS.Kind.ComputedPropertyName || node.kind === tree_2.JS.Kind.BindingElement && key === 'initializer') {
+        return 'value';
     }
-    if (kind === java_1.J.Kind.Container) {
-        collectReferences(node.elements, parent, scopes, names);
-        return;
+    if (reading === undefined) {
+        return undefined;
     }
-    if (!(0, tree_1.isTree)(node)) {
-        return;
+    if (reading === 'write') {
+        return carriesWrite(node, key) ? 'write' : meaningOf(node, key, 'value');
+    }
+    if (key === 'typeParameters' || key === 'typeArguments') {
+        return 'type';
+    }
+    if (key === 'label' || key === namingSlots[node.kind] || key === 'name' && !readsItsName(node)) {
+        return undefined;
     }
-    const name = kind === java_1.J.Kind.Identifier ? node.simpleName : undefined;
-    if (name && reads(node, parent) && !shadowed(scopes, name)) {
-        names.add(name);
+    if (writes(node, key)) {
+        return 'write';
+    }
+    switch (node.kind) {
+        case tree_2.JS.Kind.Import:
+            // `import a = NS.b` reads `NS` as whatever it is. The rest of an import declares.
+            return key === 'initializer' ? 'any' : undefined;
+        case tree_2.JS.Kind.ExportDeclaration:
+            if (key !== 'exportClause') {
+                return reading;
+            }
+            return node.moduleSpecifier === undefined ? 'any' : undefined;
+        case java_1.J.Kind.FieldAccess:
+            // In a type, `NS.Foo` reads the namespace `NS`, as `A.B.C` reads `A`.
+            return key === 'target' && reading === 'type' ? 'namespace' : reading;
+        case tree_2.JS.Kind.TypeInfo:
+        case tree_2.JS.Kind.TypeDeclaration:
+        case java_1.J.Kind.TypeParameter:
+            return 'type';
+        case tree_2.JS.Kind.TypeQuery:
+            // `typeof x` reads the value `x` from within a type.
+            return key === 'typeExpression' ? 'value' : reading;
+        case tree_2.JS.Kind.TypePredicate:
+            // `x is Foo` names the parameter `x`, a value, from within a return type.
+            return key === 'parameterName' ? 'value' : reading;
+        case tree_2.JS.Kind.IndexSignatureDeclaration:
+            return key === 'typeExpression' ? 'type' : reading;
+        case tree_2.JS.Kind.As:
+            return key === 'right' ? 'type' : reading;
+        case tree_2.JS.Kind.SatisfiesExpression:
+            return key === 'satisfiesType' ? 'type' : reading;
+        case java_1.J.Kind.TypeCast:
+            return key === 'class' ? 'type' : reading;
+        case java_1.J.Kind.ClassDeclaration:
+            if (node.classKind.type === java_1.J.ClassDeclaration.Kind.Type.Interface) {
+                return 'type';
+            }
+            return key === 'implements' ? 'type' : reading;
+        default:
+            return reading;
     }
-    const within = scopeKinds.has(kind) ? { node, parent, outer: scopes } : scopes;
-    Object.entries(node).forEach(([key, value]) => key !== 'markers' && collectReferences(value, node, within, names));
 }
+/** Whether slot `key` of `node` is one {@link isWrite} counts as assigned to. A declaring loop head names instead. */
+function writes(node, key) {
+    switch (node.kind) {
+        case java_1.J.Kind.Assignment:
+        case java_1.J.Kind.AssignmentOperation:
+        case tree_2.JS.Kind.AssignmentOperation:
+            return key === 'variable';
+        case java_1.J.Kind.Unary:
+            return key === 'expression' && incrementing.has(node.operator.element);
+        case java_1.J.Kind.ForEachLoopControl:
+            return key === 'variable';
+        default:
+            return false;
+    }
+}
+const incrementing = new Set([
+    java_1.J.Unary.Type.PreIncrement, java_1.J.Unary.Type.PreDecrement, java_1.J.Unary.Type.PostIncrement, java_1.J.Unary.Type.PostDecrement
+]);
+/**
+ * Whether slot `key` of `node` passes a write on to what it holds, which parentheses, a type
+ * assertion and the shapes of a destructuring target do. Anything else under a target reads, as
+ * `x` does in `x.y = 1`.
+ */
+function carriesWrite(node, key) {
+    switch (node.kind) {
+        case java_1.J.Kind.Parentheses:
+            return key === 'tree';
+        case tree_2.JS.Kind.As:
+            return key === 'left';
+        case tree_2.JS.Kind.ExpressionStatement:
+        case tree_2.JS.Kind.Spread:
+        case tree_2.JS.Kind.SatisfiesExpression:
+        case java_1.J.Kind.TypeCast:
+            return key === 'expression';
+        case java_1.J.Kind.NewArray:
+            return key === 'initializer';
+        case java_1.J.Kind.NewClass:
+            return key === 'body';
+        case java_1.J.Kind.Block:
+            return key === 'statements';
+        case tree_2.JS.Kind.PropertyAssignment:
+            return key === (isShorthand(node) ? 'name' : 'initializer');
+        case tree_2.JS.Kind.ArrayBindingPattern:
+            return key === 'elements';
+        case tree_2.JS.Kind.ObjectBindingPattern:
+            return key === 'bindings';
+        case tree_2.JS.Kind.BindingElement:
+            return key === 'name';
+        default:
+            return false;
+    }
+}
+/**
+ * Whether a node's `name` slot reads rather than names. A call names a member of whatever it
+ * selects from, so with nothing selected its name is the function called, and a shorthand `{x}`
+ * reads the `x` it also names.
+ */
+function readsItsName(node) {
+    return node.kind === java_1.J.Kind.MethodInvocation && !node.select || isShorthand(node);
+}
+/** A shorthand property `{x}` or `{x = 1}`, which reads the `x` it names. */
+function isShorthand(node) {
+    return (node === null || node === void 0 ? void 0 : node.kind) === tree_2.JS.Kind.PropertyAssignment &&
+        node.assigmentToken === tree_2.JS.PropertyAssignment.Token.Equals;
+}
+/** The slot, beside `name` and `label`, in which a node names rather than reads. */
+const namingSlots = {
+    [tree_2.JS.Kind.Alias]: 'alias',
+    [tree_2.JS.Kind.BindingElement]: 'propertyName',
+    [tree_2.JS.Kind.ImportType]: 'qualifier',
+    [tree_2.JS.Kind.JsxAttribute]: 'key'
+};
 /**
  * Every name a binding pattern introduces. `member` is the property a name takes its value from,
  * which only a name an object pattern binds directly has: anything deeper reads a property of a
  * property, an array element is chosen by position, and a rest name gathers what nothing claimed.
  */
 function bindingNames(pattern) {
+    return patternBindings(pattern).map(({ identifier, member }) => member === undefined ? { name: identifier.simpleName } : { name: identifier.simpleName, member });
+}
+/** As {@link bindingNames}, with the identifier each name is read from. */
+function patternBindings(pattern) {
     var _a;
     switch (pattern === null || pattern === void 0 ? void 0 : pattern.kind) {
         case java_1.J.Kind.Identifier: {
-            const simpleName = pattern.simpleName;
-            return simpleName ? [{ name: simpleName }] : [];
+            const identifier = pattern;
+            return identifier.simpleName ? [{ identifier }] : [];
         }
         case tree_2.JS.Kind.Spread:
-            return bindingNames(pattern.expression);
+            return patternBindings(pattern.expression);
         case tree_2.JS.Kind.ArrayBindingPattern:
             return unnamedMembers(pattern.elements.elements
-                .flatMap(element => bindingNames(unwrap(element))));
+                .flatMap(element => patternBindings(unwrap(element))));
         case tree_2.JS.Kind.ObjectBindingPattern:
             return pattern.bindings.elements
-                .flatMap(element => bindingNames(unwrap(element)));
+                .flatMap(element => patternBindings(unwrap(element)));
         case tree_2.JS.Kind.BindingElement: {
             const element = pattern;
             if (((_a = element.name) === null || _a === void 0 ? void 0 : _a.kind) !== java_1.J.Kind.Identifier) {
-                return unnamedMembers(bindingNames(element.name));
+                return unnamedMembers(patternBindings(element.name));
             }
-            const name = element.name.simpleName;
+            const identifier = element.name;
             const propertyName = unwrap(element.propertyName);
             return [{
-                    name,
-                    member: (propertyName === null || propertyName === void 0 ? void 0 : propertyName.kind) === java_1.J.Kind.Identifier ? propertyName.simpleName : name
+                    identifier,
+                    member: (propertyName === null || propertyName === void 0 ? void 0 : propertyName.kind) === java_1.J.Kind.Identifier
+                        ? propertyName.simpleName
+                        : identifier.simpleName
                 }];
         }
         default:
             return [];
     }
 }
+function boundIdentifiers(pattern) {
+    return patternBindings(pattern).map(bound => bound.identifier);
+}
 function unnamedMembers(bound) {
-    return bound.map(({ name }) => ({ name }));
+    return bound.map(({ identifier }) => ({ identifier }));
 }
-function declaringScopeOf(cursor, name) {
-    var _a;
+/**
+ * The block of members a class, object literal or type literal holds. A member is reached through
+ * the value or type holding it, so its name binds nowhere.
+ */
+function membersOf(node) {
+    switch (node === null || node === void 0 ? void 0 : node.kind) {
+        case java_1.J.Kind.ClassDeclaration:
+            return node.body;
+        case java_1.J.Kind.NewClass:
+            return node.body;
+        case tree_2.JS.Kind.TypeLiteral:
+            return node.members;
+        default:
+            return undefined;
+    }
+}
+function declaringScopeOf(cursor, name, meaning) {
     for (let c = cursor; c; c = c.parent) {
-        if (frameBindings(c.value, (_a = c.parent) === null || _a === void 0 ? void 0 : _a.value).has(name)) {
+        if (binds(bindingsAt(c), name, meaning)) {
             return c.value;
         }
     }
     return undefined;
 }
+/** What the node a cursor stands on binds, which is nothing where it stands on padding or the root. */
+function bindingsAt(cursor) {
+    var _a;
+    const parent = (_a = cursor.parent) === null || _a === void 0 ? void 0 : _a.value;
+    return (0, tree_1.isTree)(cursor.value) ? frameBindings(cursor.value, (0, tree_1.isTree)(parent) ? parent : undefined) : noBindings;
+}
 /**
  * What one node on the cursor path binds, `parent` being the node it hangs from. Only these two
  * answers turn on the parent; a node alone settles the rest, which is what makes them cacheable.
  */
 function frameBindings(node, parent) {
-    // A class body holds members, which are reached through an instance rather than by name.
-    if ((node === null || node === void 0 ? void 0 : node.kind) === java_1.J.Kind.Block && (parent === null || parent === void 0 ? void 0 : parent.kind) === java_1.J.Kind.ClassDeclaration) {
-        return noNames;
+    if (node.kind === java_1.J.Kind.Block && membersOf(parent) === node) {
+        // An enum's members are in scope in its body, where an initializer may name an earlier one.
+        return isEnum(parent) ? toBindings(enumMemberNames(node)) : noBindings;
+    }
+    // An arrow binds its lambda's parameters itself, since its return type reads them.
+    if (node.kind === java_1.J.Kind.Lambda && (parent === null || parent === void 0 ? void 0 : parent.kind) === tree_2.JS.Kind.ArrowFunction) {
+        return noBindings;
     }
     // A function expression is the only function whose own name its body reaches: a declaration's
     // name belongs to the enclosing block, a method's to an instance.
-    if ((node === null || node === void 0 ? void 0 : node.kind) === java_1.J.Kind.MethodDeclaration && (parent === null || parent === void 0 ? void 0 : parent.kind) === tree_2.JS.Kind.StatementExpression) {
-        let names = selfNamed.get(node);
-        if (!names) {
-            const self = bindingNames(node.name).map(bound => bound.name);
-            selfNamed.set(node, names = new Set([...self, ...ownBindings(node)]));
+    if (node.kind === java_1.J.Kind.MethodDeclaration && (parent === null || parent === void 0 ? void 0 : parent.kind) === tree_2.JS.Kind.StatementExpression) {
+        let bindings = selfNamed.get(node);
+        if (!bindings) {
+            const self = bound(boundIdentifiers(node.name), 'value');
+            selfNamed.set(node, bindings = toBindings([...self, ...readBindings(node)]));
         }
-        return names;
+        return bindings;
     }
     return ownBindings(node);
 }
 function ownBindings(node) {
-    if (typeof node !== 'object' || node === null) {
-        return noNames;
+    let bindings = frames.get(node);
+    if (!bindings) {
+        frames.set(node, bindings = toBindings(readBindings(node)));
     }
-    let names = frames.get(node);
-    if (!names) {
-        frames.set(node, names = new Set(readBindings(node)));
-    }
-    return names;
+    return bindings;
 }
 function readBindings(node) {
     switch (node.kind) {
@@ -269,26 +490,52 @@ function readBindings(node) {
             const statements = node.statements;
             return [...declaredNames(statements), ...hoistedNames(statements)];
         }
-        case java_1.J.Kind.Block:
-            return blockScopedNames(node.statements);
-        case java_1.J.Kind.MethodDeclaration: {
+        case java_1.J.Kind.Block: {
+            const block = node;
+            // A class static block is a var scope, as a function body is.
+            return block.static.element
+                ? [...blockScopedNames(block.statements), ...hoistedNames(block.statements)]
+                : blockScopedNames(block.statements);
+        }
+        case java_1.J.Kind.MethodDeclaration:
+        case tree_2.JS.Kind.ComputedPropertyMethodDeclaration: {
             const method = node;
-            return [...declaredNames(method.parameters.elements), ...hoistedNames(method.body)];
+            return [
+                ...typeParameterNames(method),
+                ...declaredNames(method.parameters.elements),
+                ...hoistedNames(method.body)
+            ];
         }
         case java_1.J.Kind.Lambda: {
             const lambda = node;
             return [...declaredNames(lambda.parameters.parameters), ...hoistedNames(lambda.body)];
         }
         case java_1.J.Kind.ClassDeclaration:
-            return bindingNames(node.name).map(bound => bound.name);
+            return [...declarationNames(node), ...typeParameterNames(node)];
+        // A namespace is where the functions and `var`s in its body hoist to, its block binding the rest.
+        case tree_2.JS.Kind.NamespaceDeclaration:
+            return isGlobalAugmentation(node)
+                ? []
+                : hoistedNames(node.body);
+        case tree_2.JS.Kind.ArrowFunction:
+            return [...typeParameterNames(node), ...readBindings(node.lambda)];
+        case tree_2.JS.Kind.TypeDeclaration:
+            return typeParameterNames(node);
+        case tree_2.JS.Kind.FunctionType:
+            return [...typeParameterNames(node), ...declaredNames(node.parameters.elements)];
+        case tree_2.JS.Kind.MappedType:
+            return declarationNames(unwrap(node.keysRemapping.typeParameter));
+        case tree_2.JS.Kind.ConditionalType:
+            return inferredNames(node.condition.element.condition);
         case java_1.J.Kind.TryCatch:
             return declaredNames([node.parameter.tree]);
+        // A loop head's `var` hoists past the loop, as one anywhere in a function body does.
         case java_1.J.Kind.ForLoop:
-            return declaredNames(node.control.init);
+            return blockScopedNames(node.control.init);
         case java_1.J.Kind.ForEachLoop:
-            return declaredNames([node.control.variable]);
+            return blockScopedNames([node.control.variable]);
         case tree_2.JS.Kind.ForInLoop:
-            return declaredNames([node.control.variable]);
+            return blockScopedNames([node.control.variable]);
         default:
             return [];
     }
@@ -321,28 +568,48 @@ function isBlockScoped(declaration) {
 function declaredNames(statements) {
     return statements.flatMap(statement => declarationNames(unwrap(statement)));
 }
+/** The names a declaration binds, each with the meanings it has there. */
 function declarationNames(statement) {
     switch (statement === null || statement === void 0 ? void 0 : statement.kind) {
         case tree_2.JS.Kind.Import:
             return importNames(statement);
         case java_1.J.Kind.VariableDeclarations:
-            return statement.variables
-                .flatMap(variable => { var _a; return bindingNames((_a = unwrap(variable)) === null || _a === void 0 ? void 0 : _a.name); })
-                .map(bound => bound.name);
+            return bound(statement.variables.flatMap(variable => {
+                const named = unwrap(variable);
+                return boundIdentifiers(named === null || named === void 0 ? void 0 : named.name);
+            }), 'value');
         case tree_2.JS.Kind.ScopedVariableDeclarations:
             return declaredNames(statement.variables);
         case java_1.J.Kind.MethodDeclaration:
-            return bindingNames(statement.name).map(bound => bound.name);
-        case java_1.J.Kind.ClassDeclaration:
-            return bindingNames(statement.name).map(bound => bound.name);
-        case tree_2.JS.Kind.NamespaceDeclaration:
-            return bindingNames(unwrap(statement.name)).map(bound => bound.name);
+            return bound(boundIdentifiers(statement.name), 'value');
+        case java_1.J.Kind.ClassDeclaration: {
+            const declaration = statement;
+            switch (declaration.classKind.type) {
+                case java_1.J.ClassDeclaration.Kind.Type.Interface:
+                    return bound(boundIdentifiers(declaration.name), 'type');
+                case java_1.J.ClassDeclaration.Kind.Type.Enum:
+                    // An enum's members are read as `E.A` in a type, so it is a namespace too.
+                    return bound(boundIdentifiers(declaration.name), 'value', 'type', 'namespace');
+                default:
+                    return bound(boundIdentifiers(declaration.name), 'value', 'type');
+            }
+        }
+        case tree_2.JS.Kind.NamespaceDeclaration: {
+            const declaration = statement;
+            if (isGlobalAugmentation(declaration)) {
+                return [];
+            }
+            const names = boundIdentifiers(rootName(unwrap(declaration.name)));
+            return isInstantiated(declaration) ? bound(names, 'namespace', 'value') : bound(names, 'namespace');
+        }
         case tree_2.JS.Kind.TypeDeclaration:
-            return bindingNames(unwrap(statement.name)).map(bound => bound.name);
+            return bound(boundIdentifiers(unwrap(statement.name)), 'type');
         case java_1.J.Kind.TypeParameter:
-            // Reached by namesDeclaredWithin's walk, never through a statement list: a type
-            // parameter binds across the declaration carrying it, not in the scope that one sits in.
-            return bindingNames(statement.name).map(bound => bound.name);
+            // A type parameter binds across the declaration carrying it, not in the scope that one
+            // sits in, so no statement list leads here.
+            return bound(boundIdentifiers(statement.name), 'type');
+        case tree_2.JS.Kind.MappedTypeParameter:
+            return bound(boundIdentifiers(statement.name), 'type');
         case java_1.J.Kind.Case:
             // The cases of a switch share the block it opens, so each one's declarations bind in all.
             return declaredNames(statement.statements.elements);
@@ -350,24 +617,87 @@ function declarationNames(statement) {
             return [];
     }
 }
+/**
+ * Whether a namespace binds a value, which it does once its body holds something other than
+ * interfaces, type aliases, unexported imports and namespaces that do not. That is the binder's
+ * rule, under which a `const enum` counts, whatever the emitter later drops.
+ */
+function isInstantiated(declaration) {
+    var _a, _b;
+    return ((_b = (_a = declaration.body) === null || _a === void 0 ? void 0 : _a.statements) !== null && _b !== void 0 ? _b : []).some(statement => {
+        const element = unwrap(statement);
+        switch (element === null || element === void 0 ? void 0 : element.kind) {
+            case tree_2.JS.Kind.TypeDeclaration:
+                return false;
+            case java_1.J.Kind.ClassDeclaration:
+                return element.classKind.type !== java_1.J.ClassDeclaration.Kind.Type.Interface;
+            case tree_2.JS.Kind.Import:
+                return element.modifiers.some(modifier => modifier.keyword === 'export');
+            case tree_2.JS.Kind.NamespaceDeclaration:
+                return isInstantiated(element);
+            default:
+                return true;
+        }
+    });
+}
+/** `declare global { … }`, whose declarations the whole file sees, as if written at its top. */
+function isGlobalAugmentation(declaration) {
+    const name = unwrap(declaration.name);
+    return declaration.keywordType.element === tree_2.JS.NamespaceDeclaration.KeywordType.Empty &&
+        (name === null || name === void 0 ? void 0 : name.kind) === java_1.J.Kind.Identifier && name.simpleName === 'global';
+}
+function isEnum(node) {
+    return (node === null || node === void 0 ? void 0 : node.kind) === java_1.J.Kind.ClassDeclaration &&
+        node.classKind.type === java_1.J.ClassDeclaration.Kind.Type.Enum;
+}
+function enumMemberNames(body) {
+    return body.statements.flatMap(statement => {
+        const element = unwrap(statement);
+        return (element === null || element === void 0 ? void 0 : element.kind) === java_1.J.Kind.EnumValueSet
+            ? bound(element.enums.map(value => value.element.name), 'value')
+            : [];
+    });
+}
+/** The identifier a dotted name `A.B.C` declares, which is `A`: the rest are members of it. */
+function rootName(name) {
+    return (name === null || name === void 0 ? void 0 : name.kind) === java_1.J.Kind.FieldAccess ? rootName(name.target) : name;
+}
 /**
  * The names a declaration's type parameters bind. A class keeps them in a container and everything
  * else in a `J.TypeParameters`, and both hold the same right-padded list.
  */
 function typeParameterNames(node) {
-    const held = node === null || node === void 0 ? void 0 : node.typeParameters;
+    const held = node.typeParameters;
     const parameters = (held === null || held === void 0 ? void 0 : held.kind) === java_1.J.Kind.TypeParameters
         ? held.typeParameters
         : held === null || held === void 0 ? void 0 : held.elements;
     return (parameters !== null && parameters !== void 0 ? parameters : []).flatMap(parameter => declarationNames(unwrap(parameter)));
 }
-/** The names an import binds, which for an aliased or namespace specifier is the alias. */
+/**
+ * The names the `infer` declarations in a conditional type's extends clause bind. A conditional
+ * type nested in the clause keeps its own `infer` names to itself.
+ */
+function inferredNames(extendsType) {
+    const names = [];
+    walk(extendsType, node => {
+        if (node.kind === tree_2.JS.Kind.InferType) {
+            names.push(...declarationNames(unwrap(node.typeParameter)));
+        }
+        return node.kind !== tree_2.JS.Kind.ConditionalType;
+    });
+    return names;
+}
+/**
+ * The names an import binds, which for an aliased or namespace specifier is the alias, each with
+ * every meaning. A `type` import is no exception: `typeof X` reads it as a value from within a
+ * type, and a value use outside one is the checker's error rather than a read of a free name.
+ */
 function importNames(jsImport) {
     const importClause = jsImport.importClause;
     if (!importClause) {
         return [];
     }
-    const names = bindingNames(unwrap(importClause.name)).map(bound => bound.name);
+    const names = boundIdentifiers(unwrap(importClause.name));
     const namedBindings = importClause.namedBindings;
     if ((namedBindings === null || namedBindings === void 0 ? void 0 : namedBindings.kind) === tree_2.JS.Kind.NamedImports) {
         for (const element of namedBindings.elements.elements) {
@@ -380,11 +710,11 @@ function importNames(jsImport) {
     else {
         names.push(...aliasedName(namedBindings));
     }
-    return names;
+    return bound(names, 'value', 'type', 'namespace');
 }
 function aliasedName(specifier) {
     const name = (specifier === null || specifier === void 0 ? void 0 : specifier.kind) === tree_2.JS.Kind.Alias ? specifier.alias : specifier;
-    return bindingNames(name).map(bound => bound.name);
+    return boundIdentifiers(name);
 }
 const blockScoped = new Set(['let', 'const', 'using']);
 // A walk of an immutable subtree has one answer, so it runs once. Keyed on the subtree itself, a
@@ -395,6 +725,7 @@ const hoisted = new WeakMap();
 const declared = new WeakMap();
 const used = new WeakMap();
 const referenced = new WeakMap();
+const slots = new WeakMap();
 const frames = new WeakMap();
 const selfNamed = new WeakMap();
 /**
@@ -416,6 +747,8 @@ function hoistedNames(scope) {
             case java_1.J.Kind.MethodDeclaration:
                 names.push(...declarationNames(node));
                 return false;
+            case tree_2.JS.Kind.ComputedPropertyMethodDeclaration:
+                return false;
             case java_1.J.Kind.VariableDeclarations:
             case tree_2.JS.Kind.ScopedVariableDeclarations:
                 if (!isBlockScoped(node)) {
@@ -429,8 +762,14 @@ function hoistedNames(scope) {
             case tree_2.JS.Kind.StatementExpression:
                 // A function or class used as an expression names itself for its own body alone.
                 return false;
+            case tree_2.JS.Kind.NamespaceDeclaration:
+                // A namespace keeps its hoisting to itself, a global augmentation gives it to the file.
+                return isGlobalAugmentation(node);
             case java_1.J.Kind.Lambda:
             case java_1.J.Kind.ClassDeclaration:
+            case java_1.J.Kind.NewClass:
+            case tree_2.JS.Kind.TypeLiteral:
+                // Nothing in an expression or a type hoists past it.
                 return false;
             default:
                 return true;
@@ -463,9 +802,13 @@ function walk(node, visit) {
         Object.entries(node).forEach(([key, value]) => key !== 'markers' && walk(value, visit));
     }
 }
-/** The element a padding wrapper holds, or the node itself. */
+/** The tree a padding wrapper holds, or the node itself where it is a tree. */
 function unwrap(node) {
-    return (node === null || node === void 0 ? void 0 : node.kind) === java_1.J.Kind.RightPadded || (node === null || node === void 0 ? void 0 : node.kind) === java_1.J.Kind.LeftPadded ? unwrap(node.element) : node;
+    const kind = node === null || node === void 0 ? void 0 : node.kind;
+    if (kind === java_1.J.Kind.RightPadded || kind === java_1.J.Kind.LeftPadded) {
+        return unwrap(node.element);
+    }
+    return (0, tree_1.isTree)(node) ? node : undefined;
 }
 /** `cursor` is protected on `TreeVisitor` and these APIs are free functions, so reaching it takes a cast. */
 function cursorOf(visitor) {
@@ -505,52 +848,174 @@ function declarationsOf(statement) {
     return [];
 }
 /**
- * Whether the identifier references a binding rather than naming one, which is what tells a rename
- * which occurrences to follow. A name its parent introduces does not — a property, a method, a
- * variable, a type parameter — nor one drawn from a namespace of its own: a statement label,
- * declaring (`x:`) or referencing (`break x`), and a JSX attribute's prop. Position is all this
- * reads: an import specifier's own name answers true, and a type position reads alike to a value.
+ * Whether the identifier may be renamed in place, which is so where its slot reads rather than
+ * names. A shorthand property `{x}` answers false though it reads `x`, since a rename has to
+ * expand it to `{x: y}`. Position is all this reads, so a type position reads alike to a value,
+ * and what `x` reads is {@link resolve}'s question.
  */
-function isValueReference(cursor, identifier) {
-    let c = cursor.parent;
-    while (c && isPadding(c.value)) {
-        c = c.parent;
+function isReference(cursor, identifier) {
+    const path = pathTo(cursor, identifier);
+    return !isShorthand(path[path.length - 1]) && position(path, identifier)[1] !== undefined;
+}
+/**
+ * The tree nodes from the nearest compilation unit on `cursor`, or its outermost tree, down to the
+ * one holding `identifier`, which is the cursor's own node or that node's parent.
+ */
+function pathTo(cursor, identifier) {
+    const path = treePath(cursor);
+    if (path[path.length - 1] === identifier) {
+        path.pop();
     }
-    return references(identifier, c === null || c === void 0 ? void 0 : c.value);
+    return path;
 }
-/** The position half of {@link isValueReference}, against a parent already found. */
-function references(identifier, parent) {
+/** The cursors on `cursor`'s chain holding tree nodes, down from the nearest compilation unit or outermost tree. */
+function treeCursors(cursor) {
     var _a;
-    const owner = parent;
-    // A call names a member of whatever it selects from. With nothing selected there is no member,
-    // and its `name` is a reference to the function being called.
-    if ((owner === null || owner === void 0 ? void 0 : owner.kind) === java_1.J.Kind.MethodInvocation && !owner.select) {
-        return true;
+    const cursors = [];
+    for (let c = cursor; c; c = c.parent) {
+        if ((0, tree_1.isTree)(c.value)) {
+            cursors.unshift(c);
+        }
+        if (((_a = c.value) === null || _a === void 0 ? void 0 : _a.kind) === tree_2.JS.Kind.CompilationUnit) {
+            break;
+        }
     }
-    // A binding element names the property it destructures and binds under `name`, so both slots
-    // name rather than reference.
-    if ((owner === null || owner === void 0 ? void 0 : owner.kind) === tree_2.JS.Kind.BindingElement && holds(owner.propertyName, identifier)) {
-        return false;
+    return cursors;
+}
+function treePath(cursor) {
+    return treeCursors(cursor).map(c => c.value);
+}
+/**
+ * The scopes around `leaf` and what it reads with, folded down `path`, which ends at the node
+ * holding `leaf`, and what each node of `path` reads with. The fold runs to the end since a naming
+ * slot can hold a read deeper down.
+ */
+function position(path, leaf) {
+    var _a, _b;
+    let scopes;
+    let reading = 'value';
+    const readings = [];
+    for (let i = 0; i < path.length; i++) {
+        readings.push(reading);
+        const child = (_a = path[i + 1]) !== null && _a !== void 0 ? _a : leaf;
+        const key = slotOf(path[i], child);
+        if (key === undefined) {
+            const spelled = (_b = child.simpleName) !== null && _b !== void 0 ? _b : child.kind;
+            throw new Error(`\`${spelled}\` is not under the cursor it is resolved from`);
+        }
+        [scopes, reading] = descend(path[i], path[i - 1], key, framesAt(path[i], path[i - 1], scopes), reading);
+    }
+    return [scopes, reading, readings];
+}
+/**
+ * The slot of `node` holding `child`, by id, so a copy or a rebuilt node is found as the original.
+ * A node's slots are indexed once, through padding, containers and lists.
+ */
+function slotOf(node, child) {
+    let index = slots.get(node);
+    if (!index) {
+        index = new Map();
+        for (const [key, value] of Object.entries(node)) {
+            if (key !== 'markers') {
+                for (const held of treesIn(value)) {
+                    index.set(held.id, key);
+                }
+            }
+        }
+        slots.set(node, index);
+    }
+    return index.get(child.id);
+}
+/** The tree nodes a slot holds directly, through padding, containers and lists. */
+function treesIn(slot) {
+    if (Array.isArray(slot)) {
+        return slot.flatMap(treesIn);
+    }
+    const kind = slot === null || slot === void 0 ? void 0 : slot.kind;
+    if (kind === java_1.J.Kind.RightPadded || kind === java_1.J.Kind.LeftPadded) {
+        return treesIn(slot.element);
+    }
+    if (kind === java_1.J.Kind.Container) {
+        return treesIn(slot.elements);
     }
-    // A JSX attribute keeps its prop name on `key`; the three label-bearing nodes keep theirs on
-    // `label`. Every other kind that names rather than references keeps it on `name`.
-    return !holds((owner === null || owner === void 0 ? void 0 : owner.kind) === tree_2.JS.Kind.JsxAttribute ? owner.key : ((_a = owner === null || owner === void 0 ? void 0 : owner.name) !== null && _a !== void 0 ? _a : owner === null || owner === void 0 ? void 0 : owner.label), identifier);
+    return (0, tree_1.isTree)(slot) ? [slot] : [];
+}
+/**
+ * @deprecated Use {@link isReference}. Unlike this function once did, it answers false for an
+ * import's own name, an alias and a re-export's specifier, which name rather than read.
+ */
+exports.isValueReference = isReference;
+/**
+ * The node owning the scope that binds what `identifier` reads, or undefined where it reads a
+ * global or reads nothing. Position is what resolves it, so the cursor stands on the identifier
+ * or on the node holding it, and a node the cursor does not hold is refused.
+ */
+function resolve(cursor, identifier) {
+    var _a;
+    const [scopes, reading] = position(pathTo(cursor, identifier), identifier);
+    return reading && ((_a = bindingFrame(scopes, identifier.simpleName, reading)) === null || _a === void 0 ? void 0 : _a.node);
 }
-/** Whether a node slot, padded or not, is the identifier itself. */
-function holds(slot, identifier) {
-    return slot === identifier || (slot === null || slot === void 0 ? void 0 : slot.element) === identifier;
+/**
+ * Whether the identifier is assigned to where it stands. An assignment's target, plain or compound,
+ * is, and so are the operand of `++` or `--`, the head of a for-in or for-of declaring nothing, and
+ * a name in such a target's destructuring pattern. A write resolves as a value read, since
+ * `x = 2` assigns to the `x` it reads. The cursor is as {@link resolve} takes it.
+ */
+function isWrite(cursor, identifier) {
+    return position(pathTo(cursor, identifier), identifier)[1] === 'write';
 }
 /**
- * As {@link references}, for a collector rather than a renamer: a shorthand property's name slot is
- * also the value it reads, which a rename has to expand rather than follow.
+ * Every identifier referring to the binding `name` has at `cursor`, the ones declaring it and the
+ * ones resolving to it, in the order the tree holds them, which a type annotation can depart from.
+ * The binding is the innermost one of the name with `meaning`, or with any meaning where none is
+ * asked for. A read with any meaning, as an export clause reads, refers to every meaning it finds.
+ * A name bound nowhere has no references. Each reference's cursor continues the caller's chain.
  */
-function reads(identifier, parent) {
-    const owner = parent;
-    return ((owner === null || owner === void 0 ? void 0 : owner.kind) === tree_2.JS.Kind.PropertyAssignment && owner.initializer === undefined) ||
-        references(identifier, parent);
-}
-function isPadding(value) {
-    const kind = value === null || value === void 0 ? void 0 : value.kind;
-    return kind === java_1.J.Kind.RightPadded || kind === java_1.J.Kind.LeftPadded || kind === java_1.J.Kind.Container;
+function referencesOf(cursor, name, meaning) {
+    const cursors = treeCursors(cursor);
+    const path = cursors.map(c => c.value);
+    if (path.length === 0) {
+        return [];
+    }
+    const [scopes, reading, readings] = position(path.slice(0, -1), path[path.length - 1]);
+    readings.push(reading);
+    const here = framesAt(path[path.length - 1], path[path.length - 2], scopes);
+    const frame = bindingFrame(here, name, meaning !== null && meaning !== void 0 ? meaning : 'any');
+    if (!frame) {
+        return [];
+    }
+    const declarations = new Set(frameBindings(frame.node, frame.parent).get(name).declarations
+        .filter(declaration => meaning === undefined || declaration.meanings.includes(meaning))
+        .map(declaration => declaration.identifier.id));
+    // A class binds its own name in its body too, so a frame further out declaring the same
+    // identifier holds the same binding, and its references sit under that frame.
+    const sharesBinding = (scope) => {
+        var _a, _b;
+        return scope !== undefined &&
+            ((_b = (_a = frameBindings(scope.node, scope.parent).get(name)) === null || _a === void 0 ? void 0 : _a.declarations) !== null && _b !== void 0 ? _b : [])
+                .some(declaration => declarations.has(declaration.identifier.id));
+    };
+    let root = frame;
+    for (let outer = frame.outer; outer; outer = outer.outer) {
+        if (sharesBinding(outer)) {
+            root = outer;
+        }
+    }
+    const at = path.indexOf(root.node);
+    const references = [];
+    readReferences(root.node, root.parent, root.outer, readings[at], (identifier, reads, scopes, trail) => {
+        if (identifier.simpleName !== name) {
+            return;
+        }
+        const declares = declarations.has(identifier.id);
+        const refers = !declares && reads !== undefined &&
+            (meaning === undefined || reads === 'any' || meaningRead(reads) === meaning) &&
+            sharesBinding(bindingFrame(scopes, name, reads));
+        if (declares || refers) {
+            const standing = trail.reduce((above, node) => new tree_1.Cursor(node, above), cursors[at].parent);
+            references.push({ cursor: standing, identifier, declares, writes: reads === 'write' });
+        }
+    });
+    return references;
 }
 //# sourceMappingURL=scope.js.map