ucn 5.5.1 → 5.5.3

package/languages/lexical-scope.js

@@ -291,13 +291,26 @@ function pyScopeBindings(scopeNode, body, name, isFunction, includeClasses = fal
     }
 }
 
-function pyVerdict(info) {
+function pyVerdict(info, scopeNode) {
     if (info.import || info.starImport) return 'unknown';
-    if (info.other) return { local: true, defRows: null };
-    return { local: true, defRows: info.defRows.slice() };
+    if (info.other) return withScopeNode({ local: true, defRows: null }, scopeNode);
+    return withScopeNode({ local: true, defRows: info.defRows.slice() }, scopeNode);
 }
 
-function pythonReferenceScope(node, name, memo, includeClasses) {
+/** A local verdict names its binding scope node only when asked for. */
+function withScopeNode(verdict, scopeNode) {
+    if (scopeNode) Object.defineProperty(verdict, 'scopeNode', { value: scopeNode, enumerable: false });
+    return verdict;
+}
+
+/**
+ * `globalBindsModule` (fix #420): a name a function declares `global` is the
+ * module variable there, assigned or not. Callable resolution keeps 'unknown'
+ * for an assigned global (the binding the call reaches changes at run time);
+ * a value reference names the variable itself.
+ */
+function pythonReferenceScope(node, name, memo, includeClasses, globalBindsModule = false) {
+    const local = scope => (globalBindsModule ? scope : null);
     const parent = node.parent;
     if (!parent) return 'unknown';
     if (parent.type === 'keyword_argument' && sameNode(parent.childForFieldName('name'), node)) return 'none';
@@ -316,6 +329,7 @@ function pythonReferenceScope(node, name, memo, includeClasses) {
                 if (info.global) {
                     // A function that assigns a `global` name rebinds the module
                     // binding at run time.
+                    if (globalBindsModule) return 'module';
                     return info.other || info.defRows.length > 0 || info.import ? 'unknown' : 'module';
                 }
                 if (info.nonlocal) {
@@ -323,7 +337,7 @@ function pythonReferenceScope(node, name, memo, includeClasses) {
                     crossedFunction = true;
                     continue;
                 }
-                if (info.bound) return pyVerdict(info);
+                if (info.bound) return pyVerdict(info, local(scope));
                 crossedFunction = true;
                 continue;
             }
@@ -331,7 +345,7 @@ function pythonReferenceScope(node, name, memo, includeClasses) {
                 if (!sameNode(scope.childForFieldName('body'), child)) continue;
                 const names = [];
                 pyParameterNames(scope.childForFieldName('parameters'), names);
-                if (names.some(n => n.text === name)) return { local: true, defRows: null };
+                if (names.some(n => n.text === name)) return withScopeNode({ local: true, defRows: null }, local(scope));
                 crossedFunction = true;
                 continue;
             }
@@ -354,7 +368,7 @@ function pythonReferenceScope(node, name, memo, includeClasses) {
                 for (const clause of clauses) {
                     const names = [];
                     pyTargetNames(clause.childForFieldName('left'), names);
-                    if (names.some(n => n.text === name)) return { local: true, defRows: null };
+                    if (names.some(n => n.text === name)) return withScopeNode({ local: true, defRows: null }, local(scope));
                 }
                 crossedFunction = true;
                 continue;
@@ -372,7 +386,9 @@ function pythonReferenceScope(node, name, memo, includeClasses) {
 
 const JS_FUNCTIONS = new Set(['function_declaration', 'function_expression', 'function',
     'arrow_function', 'method_definition', 'generator_function',
-    'generator_function_declaration']);
+    'generator_function_declaration', 'function_signature', 'function_type',
+    'constructor_type', 'call_signature', 'construct_signature', 'method_signature',
+    'abstract_method_signature']);
 const JS_BLOCKS = new Set(['statement_block', 'switch_body', 'class_static_block', 'program']);
 
 function jsPatternNames(pattern, out) {
@@ -537,12 +553,50 @@ function jsVerdict(info) {
     return { local: true, defRows: info.defRows.slice() };
 }
 
+/**
+ * What a destructuring pattern's target name does (fix #431): 'declaration'
+ * (a declarator, parameter, catch or `for (const [a] of ..)` pattern binds
+ * it), 'assignment' (`[a, b] = f()`, `({ a } = o)`, `for ([a] of ..)` write
+ * the binding in scope) or null (a default value or key, not a target).
+ */
+function jsPatternTarget(node) {
+    let current = node;
+    for (let parent = node.parent; parent; current = parent, parent = parent.parent) {
+        switch (parent.type) {
+            case 'array_pattern': case 'object_pattern': case 'rest_pattern':
+                continue;
+            case 'pair_pattern':
+                if (fieldIs(current, 'value')) continue;
+                return null;
+            case 'assignment_pattern': case 'object_assignment_pattern':
+                if (fieldIs(current, 'left')) continue;
+                return null;
+            case 'assignment_expression':
+                return current !== node && fieldIs(current, 'left') ? 'assignment' : null;
+            case 'for_in_statement':
+                if (current === node || !fieldIs(current, 'left')) return null;
+                return parent.childForFieldName('kind') ? 'declaration' : 'assignment';
+            case 'parenthesized_expression':
+                return null;
+            default:
+                return current === node ? null : 'declaration';
+        }
+    }
+    return null;
+}
+
+function fieldIs(node, field) {
+    const child = node.parent?.childForFieldName(field);
+    return !!child && sameNode(child, node);
+}
+
 function jsReferenceScope(node, name, memo, includeClasses) {
-    if (node.type !== 'identifier' && node.type !== 'shorthand_property_identifier') {
+    if (node.type !== 'identifier' && node.type !== 'shorthand_property_identifier' &&
+        !(node.type === 'shorthand_property_identifier_pattern' && jsPatternTarget(node) === 'assignment')) {
         // Keys, member properties and type names are not variable
         // references. Object shorthand `{ name }` is both key and value:
         // its value resolves like an identifier (fix #397; the rename keeps
-        // the key).
+        // the key), as `({ name } = o)` writes it (fix #431).
         return 'none';
     }
     const parent = node.parent;
@@ -668,8 +722,27 @@ function goParamNames(list, out) {
     }
 }
 
+/** A Go qualified type that is a type argument of an instantiation written
+ * in an expression: `x[a.b]` parses as one, though `a` may be a value whose
+ * field `b` indexes `x` (fix #431). */
+function goExpressionTypeArgument(qualifiedType) {
+    let current = qualifiedType?.parent;
+    // `h.funcs[i](n)` reads as a conversion to the generic type `h.funcs[i]`
+    // (fix #434): its base is a selector when `h` is a value.
+    if (current?.type === 'generic_type' && sameNode(current.childForFieldName('type'), qualifiedType) &&
+        current.parent?.type === 'type_conversion_expression' &&
+        sameNode(current.parent.childForFieldName('type'), current)) return true;
+    if (current?.type === 'type_elem') current = current.parent;
+    if (current?.type !== 'type_arguments') return false;
+    current = current.parent;
+    if (current?.type === 'generic_type') current = current.parent;
+    return current?.type === 'type_instantiation_expression';
+}
+
 function goReferenceScope(node, name) {
-    if (node.type !== 'identifier') return 'none';
+    // The package of an expression type argument may be a value (fix #431).
+    if (node.type !== 'identifier' && !(node.type === 'package_identifier' &&
+        node.parent?.type === 'qualified_type' && goExpressionTypeArgument(node.parent))) return 'none';
     const parent = node.parent;
     if (!parent) return 'unknown';
     // `T{field: v}`: a struct field name or a map key, undecidable here.
@@ -854,14 +927,44 @@ function cDeclarationBinds(statement, name) {
     return verdict;
 }
 
-function cReferenceScope(node, name) {
+function cBlockBinding(scope, name, start, memo) {
+    let trees = memo.get('c-block-bindings');
+    if (!trees) { trees = new WeakMap(); memo.set('c-block-bindings', trees); }
+    let blocks = trees.get(scope.tree);
+    if (!blocks) { blocks = new Map(); trees.set(scope.tree, blocks); }
+    let block = blocks.get(scope.id);
+    if (!block) {
+        block = { statements: namedChildrenOf(scope), names: new Map() };
+        blocks.set(scope.id, block);
+    }
+    let state = block.names.get(name);
+    if (!state) { state = { next: 0, bindings: [] }; block.names.set(name, state); }
+    // Extend only through the requested position. Earlier queries can use
+    // this prefix too, without seeing any later declaration.
+    while (state.next < block.statements.length) {
+        const statement = block.statements[state.next];
+        if (statement.startIndex >= start) break;
+        const verdict = cDeclarationBinds(statement, name);
+        if (verdict) state.bindings.push([statement.startIndex, verdict]);
+        state.next++;
+    }
+    let lo = 0, hi = state.bindings.length;
+    while (lo < hi) {
+        const mid = (lo + hi) >> 1;
+        if (state.bindings[mid][0] < start) lo = mid + 1;
+        else hi = mid;
+    }
+    return lo ? state.bindings[lo - 1][1] : null;
+}
+
+function cReferenceScope(node, name, memo) {
     if (node.type !== 'identifier') return 'none';
     const parent = node.parent;
     if (!parent) return 'unknown';
     // The declared name of a variable or parameter is a binding, never a
     // reference to a function of the same spelling.
-    for (let up = parent, child = node; up && C_DECLARATOR_WRAPPERS.has(up.type); child = up, up = up.parent) {
-        if (up.type === 'init_declarator' && !sameNode(up.childForFieldName('declarator'), child)) break;
+    for (let up = parent; up && C_DECLARATOR_WRAPPERS.has(up.type); up = up.parent) {
+        if (!sameNode(cDeclaratorName(up)?.node, node)) break;
         const owner = up.parent;
         if (owner && (owner.type === 'declaration' || owner.type === 'parameter_declaration' ||
             owner.type === 'field_declaration')) return 'none';
@@ -876,12 +979,7 @@ function cReferenceScope(node, name) {
             case 'ERROR':
                 return 'unknown';
             case 'compound_statement': {
-                let bound = null;
-                for (const statement of namedChildrenOf(scope)) {
-                    if (statement.startIndex >= start) break;
-                    const verdict = cDeclarationBinds(statement, name);
-                    if (verdict) bound = verdict;
-                }
+                const bound = cBlockBinding(scope, name, start, memo);
                 if (bound === 'function') return 'unknown';
                 if (bound) return { local: true, defRows: null };
                 continue;
@@ -1182,11 +1280,12 @@ function referenceScope(node, language, memo = new Map(), name = node?.text, opt
             memo = classMemo;
         }
         switch (family) {
-            case 'python': return pythonReferenceScope(node, name, memo, includeClasses);
+            case 'python': return pythonReferenceScope(node, name, memo, includeClasses,
+                options.globalBindsModule === true);
             case 'js': return jsReferenceScope(node, name, memo, includeClasses);
             case 'go': return goReferenceScope(node, name, memo);
             case 'rust': return rustReferenceScope(node, name, memo);
-            case 'c': return cReferenceScope(node, name);
+            case 'c': return cReferenceScope(node, name, memo);
             default: return null;
         }
     } catch {
@@ -1269,6 +1368,23 @@ function referenceScopeNode(node, name, memo = new Map()) {
     return null;
 }
 
+/**
+ * Every binding of `name` in the Python scope (module or function) that
+ * holds `node` (fix #424), with its kind: 'def' (def and class
+ * statements), 'binding' (assignment targets, parameters, captures) or
+ * 'import'.
+ */
+function pythonScopeBindingKinds(node, name) {
+    let scope = node;
+    while (scope && !['module', 'function_definition', 'class_definition'].includes(scope.type)) scope = scope.parent;
+    if (!scope || scope.type === 'class_definition') return [];
+    const sites = [];
+    const isFunction = scope.type === 'function_definition';
+    pyScopeBindings(scope, isFunction ? scope.childForFieldName('body') : scope, name, isFunction, true,
+        (site, kind) => sites.push({ node: site, kind }));
+    return sites;
+}
+
 /** Declaration tokens binding one name in a Python function's own scope. */
 function pythonBindingSites(scope, name) {
     const sites = [];
@@ -1277,4 +1393,55 @@ function pythonBindingSites(scope, name) {
     return sites;
 }
 
-module.exports = { referenceScope, referenceScopeNode, scopeFields, familyOf, rustLetBindingOf, rustSelfFieldBinding, pythonBindingSites };
+/**
+ * Statement-order lookup of a name read directly in a Python class body
+ * whose body also binds it (fix #420): a class body reads its namespace,
+ * then the scope around the class, as it executes. 'outer' when every
+ * binding of the name in the body runs after the read (`limit = limit`
+ * reads the outer binding), 'class' when an unconditional earlier
+ * statement of the body binds it, null when the order cannot settle it
+ * (loops, conditional bindings, `global` in the body).
+ */
+function pythonClassBodyOrder(classNode, node, name) {
+    const body = classNode?.childForFieldName('body');
+    if (!body) return null;
+    const sites = [];
+    const info = pyScopeBindings(classNode, body, name, false, false, site => sites.push(site));
+    if (info.global || info.nonlocal || info.starImport || sites.length === 0) return null;
+    const statementOf = site => {
+        let current = site;
+        while (current.parent && !sameNode(current.parent, body)) current = current.parent;
+        return sameNode(current.parent, body) ? current : null;
+    };
+    const readStatement = statementOf(node);
+    if (!readStatement) return null;
+    for (let current = node.parent; current && !sameNode(current, body); current = current.parent) {
+        if (['for_statement', 'while_statement'].includes(current.type)) return null;
+    }
+    let before = 0;
+    for (const site of sites) {
+        const statement = statementOf(site);
+        if (!statement) return null;
+        if (statement.startIndex > readStatement.startIndex) continue;
+        if (sameNode(statement, readStatement)) {
+            // `x = <reads x>`: the value is evaluated before the target binds.
+            const assignment = statement.type === 'expression_statement' ? statement.namedChild(0) : statement;
+            const left = assignment?.type === 'assignment' ? assignment.childForFieldName('left') : null;
+            const right = assignment?.type === 'assignment' ? assignment.childForFieldName('right') : null;
+            if (left && right && within(site, left) && within(node, right)) continue;
+            // A decorator runs before the definition it decorates binds the
+            // name (fix #431: `@plain.setter` reads the earlier `plain`).
+            if (statement.type === 'decorated_definition' && statement.namedChildren.some(child =>
+                child.type === 'decorator' && within(node, child)) && !statement.namedChildren.some(child =>
+                child.type === 'decorator' && within(site, child))) continue;
+            return null;
+        }
+        if (statement.type !== 'expression_statement' && statement.type !== 'function_definition' &&
+            statement.type !== 'class_definition' && statement.type !== 'decorated_definition') return null;
+        before++;
+    }
+    return before === 0 ? 'outer' : 'class';
+}
+
+module.exports = { referenceScope, referenceScopeNode, scopeFields, familyOf, rustLetBindingOf, rustSelfFieldBinding,
+    pythonBindingSites, pythonClassBodyOrder, pythonScopeBindingKinds, goExpressionTypeArgument, jsPatternTarget };