ucn 5.5.1 → 5.5.2

package/languages/csharp.js

@@ -14,6 +14,7 @@ const {
     containsOwnNode,
     parseErrorRegions,
     genericArityOf,
+    hasParameterizedQualifier,
 } = require('./utils');
 
 // An iterator method (`yield return` in its OWN body) returns an enumerable /
@@ -203,7 +204,12 @@ function csBuildViews(parser, code) {
     });
     if (resolved.length === 0) return null;
     for (const group of resolved) group.primary = csPrimaryBranch(group, lines);
-    return csViewsFromGroups(parser, code, lines, resolved, damaged.errors);
+    const views = csViewsFromGroups(parser, code, lines, resolved, damaged.errors);
+    // The raw parse the views read from: its type-parameter names are the
+    // file's (fix #421).
+    if (views) Object.defineProperty(views, 'typeParameterNames', {
+        value: require('./utils').declaredTypeParameterNames(literal), enumerable: false });
+    return views;
 }
 
 // Rows of branch b of a group (between its directive and the next).
@@ -237,7 +243,7 @@ function csPrimaryBranch(group, lines) {
  * index recorded for this content from `groups` (persisted per file as
  * [branch rows..., end row, primary branch]) without the literal parse.
  */
-function csViewsFromGroups(parser, code, lines, resolved, literalErrors = null) {
+function csViewsFromGroups(parser, code, lines, resolved, literalErrors = null, transform = null) {
     // One view per alternative position: view 0 keeps each group's primary
     // branch, view k its k-th other branch (the primary one when it has no
     // more). A lone `#if` branch is kept in every view.
@@ -265,7 +271,8 @@ function csViewsFromGroups(parser, code, lines, resolved, literalErrors = null)
         };
     };
     const reparse = source => safeParse(parser, source, undefined, PARSE_OPTIONS);
-    const primaryTree = reparse(viewSource(0).source);
+    const primarySource = viewSource(0).source;
+    const primaryTree = reparse(transform ? transform(primarySource, null) : primarySource);
     if (literalErrors != null && primaryTree.rootNode.hasError &&
         csCountErrors(primaryTree.rootNode) >= literalErrors) return null;
     const secondary = [];
@@ -274,7 +281,7 @@ function csViewsFromGroups(parser, code, lines, resolved, literalErrors = null)
         // Only rows that hold code are worth a parse.
         const owns = new Set([...view.owns].filter(row => /\w/.test(lines[row])));
         if (owns.size === 0) continue;
-        secondary.push({ tree: reparse(view.source), owns, reaches: csRowReach(owns) });
+        secondary.push({ tree: reparse(transform ? transform(view.source, owns) : view.source), owns, reaches: csRowReach(owns) });
     }
     return {
         primary: { tree: primaryTree },
@@ -361,6 +368,26 @@ function queryTreeIsPlain(code, entry = null) {
         crypto.createHash('md5').update(code).digest('hex') === entry.hash;
 }
 
+function queryBodyViews(tree) {
+    const views = tree && csViewsByTree.get(tree)?.views;
+    return views ? [views.primary, ...views.secondary] : [{ tree }];
+}
+
+/** Rebuild every recorded configuration, with a source-local body transform. */
+function queryBodyTree(code, parser, entry, transform) {
+    if (!Array.isArray(entry.conditionalViews)) {
+        const tree = safeParse(parser, transform(code, null), undefined, PARSE_OPTIONS);
+        if (tree) csViewsByTree.set(tree, { code, views: null });
+        return tree;
+    }
+    const lines = code.match(/.*(?:\r\n|\n|\r|$)/g)?.filter(Boolean) || [];
+    const resolved = entry.conditionalViews.map(group => ({ branches: group.slice(0, -2),
+        end: group[group.length - 2], primary: group[group.length - 1] }));
+    const views = csViewsFromGroups(parser, code, lines, resolved, null, transform);
+    for (const view of [views.primary, ...views.secondary]) csViewsByTree.set(view.tree, { code, views });
+    return views.primary.tree;
+}
+
 function namespaceDeclarationName(declaration) {
     const nameNode = declaration.childForFieldName('name') ||
         declaration.namedChildren.find(child =>
@@ -414,16 +441,7 @@ function namespaceOf(node, tree) {
 // The file-scoped namespace declaration of a compilation unit, also when a
 // conditional wraps the whole file (`#if X` ... `namespace N;` ... `#endif`,
 // fix #391).
-function fileScopedNamespace(root) {
-    for (const child of root?.namedChildren || []) {
-        if (child.type === 'file_scoped_namespace_declaration') return child;
-        if (child.type.startsWith('preproc_')) {
-            const nested = fileScopedNamespace(child);
-            if (nested) return nested;
-        }
-    }
-    return null;
-}
+const { fileScopedNamespace } = require('./csharp-scope');
 
 function modifiersOf(node) {
     return (node.namedChildren || [])
@@ -551,7 +569,7 @@ function memberFromNode(node, className, lines) {
     if (!name) return null;
     const paramsNode = node.childForFieldName('parameters');
     const returnNode = node.childForFieldName('returns') || node.childForFieldName('type');
-    const { startLine, endLine, indent } = nodeToLocation(node, lines);
+    const { startLine, endLine, indent, sourceSpan } = nodeToLocation(node, lines);
     const attrs = attributeData(node);
     const modifiers = modifiersOf(node);
     const isConstructor = node.type === 'constructor_declaration';
@@ -562,27 +580,33 @@ function memberFromNode(node, className, lines) {
     const explicitInterface = explicitInterfaceOf(node);
     const paramsStructured = structuredParams(paramsNode);
     const generics = typeParameterNames(node);
+    const typeParameterConstraints = generics ? typeParameterConstraintMap(node) : null;
     // fix #380: an extension receiver typed by a METHOD type parameter
     // (`static T Ext<T>(this T e) where T : Exception`) accepts any type
     // satisfying the parameter's constraints.
-    const receiverParam = paramsStructured[0];
-    if (receiverParam?.extensionReceiver && receiverParam.type) {
-        const typeParams = node.childForFieldName('type_parameters');
-        const isTypeParam = (typeParams?.namedChildren || []).some(child =>
-            child.type === 'type_parameter' && child.childForFieldName('name')?.text === receiverParam.type);
-        if (isTypeParam) {
+    // fix #434: every parameter typed by a method type parameter carries
+    // that parameter's type constraints (`Send<TRequest>(TRequest r) where
+    // TRequest : IRequest`): an argument of a type that satisfies none of
+    // them makes the method inapplicable (C# 7.3 candidate pruning).
+    const typeParams = node.childForFieldName('type_parameters');
+    const ownTypeParams = new Set((typeParams?.namedChildren || []).filter(child => child.type === 'type_parameter')
+        .map(child => child.childForFieldName('name')?.text).filter(Boolean));
+    if (ownTypeParams.size > 0) {
+        paramsStructured.forEach((param, position) => {
+            const type = String(param?.type || '').replace(/\?$/, '');
+            if (!ownTypeParams.has(type)) return;
             const constraints = [];
             for (const clause of node.namedChildren) {
                 if (clause.type !== 'type_parameter_constraints_clause') continue;
-                if (clause.namedChild(0)?.text !== receiverParam.type) continue;
+                if (clause.namedChild(0)?.text !== type) continue;
                 for (const constraint of clause.namedChildren.slice(1)) {
                     const typeNode = constraint.childForFieldName('type');
                     if (typeNode) constraints.push(nodeTextWithoutComments(typeNode));
                 }
             }
-            paramsStructured[0] = { ...receiverParam, typeParameter: true,
+            paramsStructured[position] = { ...param, typeParameter: true,
                 ...(constraints.length > 0 && { constraints }) };
-        }
+        });
     }
     return {
         name,
@@ -591,10 +615,12 @@ function memberFromNode(node, className, lines) {
         returnType: isConstructor ? null : nodeTextWithoutComments(returnNode).trim() || null,
         startLine,
         endLine,
+        sourceSpan,
         ...nameLineOf(nameNode, startLine),
         indent,
         modifiers,
         ...(generics && { generics }),
+        ...(typeParameterConstraints && { typeParameterConstraints }),
         memberType: isConstructor ? 'constructor' : 'method',
         isMethod: true,
         isConstructor,
@@ -623,11 +649,12 @@ function fieldMembers(node, lines) {
         if (declarator.type !== 'variable_declarator') continue;
         const nameNode = declarator.childForFieldName('name');
         if (!nameNode?.text) continue;
-        const { startLine, endLine, indent } = nodeToLocation(declarator, lines);
+        const { startLine, endLine, indent, sourceSpan } = nodeToLocation(declarator, lines);
         members.push({
             name: nameNode.text,
             startLine,
             endLine,
+            sourceSpan,
             indent,
             modifiers: modifiersOf(node),
             memberType: 'field',
@@ -651,7 +678,7 @@ function indexerMember(node, className, lines) {
     if (node.type !== 'indexer_declaration') return null;
     const paramsNode = node.childForFieldName('parameters');
     const typeNode = node.childForFieldName('type');
-    const { startLine, endLine, indent } = nodeToLocation(node, lines);
+    const { startLine, endLine, indent, sourceSpan } = nodeToLocation(node, lines);
     const explicitInterface = explicitInterfaceOf(node);
     return {
         name: 'this[]',
@@ -660,6 +687,7 @@ function indexerMember(node, className, lines) {
         returnType: nodeTextWithoutComments(typeNode).trim() || null,
         startLine,
         endLine,
+        sourceSpan,
         ...nameLineOf((node.children || []).find(child => child.type === 'this') || null, startLine),
         indent,
         modifiers: modifiersOf(node),
@@ -680,12 +708,13 @@ function propertyMember(node, lines) {
     // The real declaration is already indexed; reject the missing-node
     // artifact instead of letting one invalid symbol discard the whole file.
     if (!nameNode?.text) return null;
-    const { startLine, endLine, indent } = nodeToLocation(node, lines);
+    const { startLine, endLine, indent, sourceSpan } = nodeToLocation(node, lines);
     const explicitInterface = explicitInterfaceOf(node);
     return {
         name: nameNode.text,
         startLine,
         endLine,
+        sourceSpan,
         ...nameLineOf(nameNode, startLine),
         indent,
         modifiers: modifiersOf(node),
@@ -703,6 +732,26 @@ function typeParameterCount(node) {
     return list.namedChildren.filter(child => child.type === 'type_parameter').length;
 }
 
+// The constructed type is the terminal AST name. A generic containing
+// type keeps its written arguments in the qualifier for identity lookup.
+function constructionType(node) {
+    let name = node, qualifier = null;
+    if (name?.type === 'qualified_name') {
+        qualifier = name.childForFieldName('qualifier');
+        name = name.childForFieldName('name');
+    } else if (name?.type === 'alias_qualified_name') {
+        qualifier = name.childForFieldName('alias');
+        name = name.childForFieldName('name');
+    }
+    const typeArgs = name?.type === 'generic_name'
+        ? name.namedChildren.find(child => child.type === 'type_argument_list')?.namedChildCount || 0 : 0;
+    if (name?.type === 'generic_name') name = name.namedChild(0);
+    // Predefined keywords (`new object()`) cannot name project types.
+    // Escaped names (`new @object()`) are identifiers and keep their records.
+    if (name?.type !== 'identifier') return null;
+    return { name: name.text, node: name, qualifier: qualifier?.text, typeArgs };
+}
+
 // fix #390: the declared type parameter NAMES, in order (`<TState, TResult>`;
 // variance and attributes dropped), so a base clause `: Visitor<TextWriter,
 // bool>` can be read as a substitution of those names.
@@ -720,6 +769,28 @@ function typeParameterNames(node) {
     return names.length > 0 ? `<${names.join(', ')}>` : null;
 }
 
+/**
+ * The type constraints a declaration's `where` clauses give its type
+ * parameters (fix #434): { T: ['IParsable<T>'] }, types only (`class`,
+ * `struct`, `new()` and `notnull` constrain no member lookup), or null.
+ */
+function typeParameterConstraintMap(node) {
+    const out = {};
+    let any = false;
+    for (const clause of node?.namedChildren || []) {
+        if (clause.type !== 'type_parameter_constraints_clause') continue;
+        const target = clause.namedChild(0)?.text;
+        if (!target) continue;
+        for (const constraint of clause.namedChildren.slice(1)) {
+            const typeNode = constraint.childForFieldName('type');
+            if (!typeNode) continue;
+            (out[target] ||= []).push(nodeTextWithoutComments(typeNode));
+            any = true;
+        }
+    }
+    return any ? out : null;
+}
+
 // fix #390: the line of the declared name when attributes on their own lines
 // start the declaration (`[Obsolete]` above `void M()`): definition edits and
 // definition-line classification use it.
@@ -815,7 +886,7 @@ function findClassesInTree(code, tree) {
             // function-pointer typedef.
             const delegateName = node.childForFieldName('name');
             if (delegateName) {
-                const { startLine, endLine, indent } = nodeToLocation(node, lines);
+                const { startLine, endLine, indent, sourceSpan } = nodeToLocation(node, lines);
                 const delegateArity = typeParameterCount(node);
                 const delegateGenerics = typeParameterNames(node);
                 // fix #393: the delegate's parameter count, the count a
@@ -833,6 +904,7 @@ function findClassesInTree(code, tree) {
                     ...(Number.isInteger(delegateParams) && { delegateParams }),
                     startLine,
                     endLine,
+                    sourceSpan,
                     ...nameLineOf(delegateName, startLine),
                     indent,
                     modifiers: modifiersOf(node),
@@ -868,11 +940,12 @@ function findClassesInTree(code, tree) {
                 const enumName = child.childForFieldName('name') ||
                     child.namedChildren.find(item => item.type === 'identifier');
                 if (enumName) {
-                    const { startLine, endLine, indent } = nodeToLocation(child, lines);
+                    const { startLine, endLine, indent, sourceSpan } = nodeToLocation(child, lines);
                     members.push({
                         name: enumName.text,
                         startLine,
                         endLine,
+                        sourceSpan,
                         ...nameLineOf(enumName, startLine),
                         indent,
                         modifiers: ['public', 'static'],
@@ -893,7 +966,7 @@ function findClassesInTree(code, tree) {
         }
         const baseList = node.namedChildren.find(child => child.type === 'base_list');
         const bases = baseList?.namedChildren.map(child => child.text) || [];
-        const { startLine, endLine, indent } = nodeToLocation(node, lines);
+        const { startLine, endLine, indent, sourceSpan } = nodeToLocation(node, lines);
         const attrs = attributeData(node);
         let enclosingType;
         for (let parent = node.parent; parent; parent = parent.parent) {
@@ -906,6 +979,7 @@ function findClassesInTree(code, tree) {
             for (const member of members) member.ownerTypeArity = typeArity;
         }
         const generics = typeParameterNames(node);
+        const typeParameterConstraints = generics ? typeParameterConstraintMap(node) : null;
         // A primary constructor's parameters (`class C(int a)`, positional
         // records): the constructor the type declares in its header (fix #400).
         const primaryList = node.namedChildren.find(child => child.type === 'parameter_list');
@@ -915,10 +989,12 @@ function findClassesInTree(code, tree) {
             ...(primaryList && { primaryParams: structuredParams(primaryList) }),
             startLine,
             endLine,
+            sourceSpan,
             ...nameLineOf(nameNode, startLine),
             indent,
             modifiers: modifiersOf(node),
             ...(typeArity > 0 && { typeArity }),
+            ...(typeParameterConstraints && { typeParameterConstraints }),
             ...(generics && { generics }),
             ...(enclosingType && { enclosingType }),
             ...(namespaceOf(node, tree) && { namespace: namespaceOf(node, tree) }),
@@ -991,7 +1067,7 @@ function findFunctionsInTree(code, tree, reaches = null) {
         }
         const paramsNode = node.childForFieldName('parameters');
         const returnNode = node.childForFieldName('returns') || node.childForFieldName('type');
-        const { startLine, endLine, indent } = nodeToLocation(node, lines);
+        const { startLine, endLine, indent, sourceSpan } = nodeToLocation(node, lines);
         const modifiers = modifiersOf(node);
         const localGenerics = typeParameterNames(node);
         functions.push({
@@ -1001,6 +1077,7 @@ function findFunctionsInTree(code, tree, reaches = null) {
             returnType: nodeTextWithoutComments(returnNode).trim() || null,
             startLine,
             endLine,
+            sourceSpan,
             ...nameLineOf(nameNode, startLine),
             indent,
             modifiers,
@@ -1051,11 +1128,12 @@ function findStateObjectsInTree(code, tree, reaches = null) {
             if (declarator.type !== 'variable_declarator') continue;
             const nameNode = declarator.childForFieldName('name');
             if (!nameNode) continue;
-            const { startLine, endLine, indent } = nodeToLocation(node, lines);
+            const { startLine, endLine, indent, sourceSpan } = nodeToLocation(node, lines);
             states.push({
                 name: nameNode.text,
                 startLine,
                 endLine,
+                sourceSpan,
                 indent,
                 modifiers: [],
             });
@@ -1433,18 +1511,57 @@ const CALLABLE_SCOPE_NODES = new Set([
     'local_function_statement', 'accessor_declaration',
 ]);
 
-function variableScopeKey(node) {
+// Names a local function declares itself (parameters, locals, pattern
+// and foreach variables, catch and query variables): they hide the
+// enclosing callable's (fix #434).
+const CS_DECLARING_NODES = new Set(['parameter', 'variable_declarator', 'single_variable_designation',
+    'foreach_statement', 'catch_declaration', 'from_clause', 'let_clause', 'join_clause']);
+function csDeclaredNames(scopeNode) {
+    const names = new Set();
+    traverseTree(scopeNode, node => {
+        if (!CS_DECLARING_NODES.has(node.type)) return true;
+        const name = node.type === 'single_variable_designation'
+            ? node.namedChild(0) || node
+            : node.childForFieldName('name') || node.childForFieldName('left') ||
+                node.namedChildren.find(child => child.type === 'identifier');
+        if (name?.type === 'identifier') names.add(name.text);
+        return true;
+    });
+    return names;
+}
+
+/**
+ * The variable types in scope at a node (fix #434): a local function
+ * also reads the typed locals of the callables around it (C# closures
+ * capture them), except the names it declares itself.
+ */
+function scopedVariableTypes(byScope, node, memo) {
+    let scopeNode = null;
     for (let parent = node?.parent; parent; parent = parent.parent) {
-        if (CALLABLE_SCOPE_NODES.has(parent.type)) {
-            if (isControlFlowLocalArtifact(parent)) continue;
-            return parent.startPosition.row + 1;
-        }
-        if (parent.type === 'global_statement') return 'global';
-    }
-    return 'global';
+        if (CALLABLE_SCOPE_NODES.has(parent.type) && !isControlFlowLocalArtifact(parent)) { scopeNode = parent; break; }
+        if (parent.type === 'global_statement') break;
+    }
+    const own = (scopeNode && byScope.get(scopeNode.startPosition.row + 1)) || byScope.get('global');
+    if (scopeNode?.type !== 'local_function_statement') return own;
+    const key = scopeNode.startPosition.row + 1;
+    if (memo.has(key)) return memo.get(key);
+    const outer = scopedVariableTypes(byScope, scopeNode, memo);
+    let merged = own;
+    if (outer && outer !== own && outer.size > 0) {
+        const declared = csDeclaredNames(scopeNode);
+        merged = new ReceiverTypeMap();
+        for (const [name, type] of outer) {
+            if (!declared.has(name) && !own?.has(name)) merged.set(name, type, outer.origins.get(name) || 'unknown');
+        }
+        for (const [name, type] of own || []) merged.set(name, type, own.origins.get(name) || 'unknown');
+    }
+    memo.set(key, merged);
+    return merged;
 }
 
 const localBindingFactsByTree = new WeakMap();
+// Nodes whose identifier children can be deconstruction designations.
+const DECONSTRUCTION_PARENTS = new Set(['tuple_pattern', 'parenthesized_variable_designation', 'argument']);
 
 /**
  * Local binding facts of one callable (fix #381): how many times each name
@@ -1475,6 +1592,10 @@ function csharpLocalBindingFacts(fnNode) {
                 }
             } else if (child.type === 'declaration_pattern' || child.type === 'declaration_expression') {
                 declare(child.childForFieldName('name')?.text || child.namedChildren.at(-1)?.text);
+            } else if (child.type === 'identifier' && DECONSTRUCTION_PARENTS.has(node.type) &&
+                require('./csharp-scope').deconstructionRoot(child)) {
+                // `var (a, b) = t;`, `case var (a, b):` (fix #419).
+                declare(child.text);
             } else if (child.type === 'assignment_expression') {
                 const left = child.childForFieldName('left');
                 if (left?.type === 'identifier') facts.assigned.add(left.text);
@@ -1573,7 +1694,10 @@ function buildVariableTypes(tree, parser) {
     const conflictsByScope = new Map([['global', new Set()]]);
     const scopeStack = [];
     const setType = (scope, name, type, source = 'unknown', node = null) => {
-        if (!name || !type) return;
+        // An implicitly typed declaration (`out var f`, `is var x` in a
+        // recovered condition) writes no type: the name is a local of
+        // unknown type, never a value of a type named `var` (fix #426).
+        if (!name || !type || type === 'var') return;
         if (!conflictsByScope.has(scope)) conflictsByScope.set(scope, new Set());
         const conflicts = conflictsByScope.get(scope);
         if (conflicts.has(name)) return;
@@ -1738,6 +1862,21 @@ function buildVariableTypes(tree, parser) {
     return byScope;
 }
 
+// Type spellings held in local bindings have no retained AST node. Parse
+// them on demand and keep bounded data, never nodes, across worker files.
+const constructedTypeSyntax = new Map();
+function constructionTypeText(text) {
+    if (constructedTypeSyntax.has(text)) return constructedTypeSyntax.get(text);
+    const tree = safeParse(require('./index').getParser('csharp'), `class TypeSlot { ${text} field; }`);
+    const type = tree && !tree.rootNode.hasError
+        ? tree.rootNode.descendantsOfType('variable_declaration')[0]?.childForFieldName('type') : null;
+    const shape = constructionType(type);
+    const result = shape ? { name: shape.name, qualifier: shape.qualifier, typeArgs: shape.typeArgs } : null;
+    if (constructedTypeSyntax.size >= 256) constructedTypeSyntax.delete(constructedTypeSyntax.keys().next().value);
+    constructedTypeSyntax.set(text, result);
+    return result;
+}
+
 function normalizeReceiverType(raw) {
     if (!raw) return null;
     let value = String(raw).trim().replace(/\?$/, '');
@@ -1746,6 +1885,10 @@ function normalizeReceiverType(raw) {
     // this index cannot attribute (fix #401): no receiver type.
     if (/^(?!global::)[A-Za-z_]\w*::/.test(value)) return null;
     value = value.replace(/^global::/, '').replace(/::/g, '.');
+    if (hasParameterizedQualifier(value)) {
+        const shape = constructionTypeText(value);
+        return shape ? { name: shape.name, namespace: shape.qualifier, typeArgs: shape.typeArgs } : null;
+    }
     const match = value.match(/^([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*)\s*(?:<.*>)?$/s);
     if (!match) return null;
     const parts = match[1].split('.');
@@ -1911,6 +2054,31 @@ function receiverFieldPath(node, variableTypes, enclosingClass) {
     return null;
 }
 
+/**
+ * A receiver expression's text with the null-forgiving operator removed
+ * (fix #430): `TraceWriter!.Trace(..)` calls `Trace` on `TraceWriter`, the
+ * operator changes no type or lookup.
+ */
+function nullForgivingFreeText(node) {
+    if (!node) return node?.text;
+    const cuts = [];
+    const visit = current => {
+        if (current.type === 'postfix_unary_expression' && current.childCount === 2 &&
+            current.child(1).type === '!') cuts.push(current.child(1));
+        if (current.type === 'argument_list' || current.type === 'lambda_expression') return;
+        for (let i = 0; i < current.namedChildCount; i++) visit(current.namedChild(i));
+    };
+    visit(node);
+    if (cuts.length === 0) return node.text;
+    let text = '', at = node.startIndex;
+    const source = node.text;
+    for (const cut of cuts.sort((a, b) => a.startIndex - b.startIndex)) {
+        text += source.slice(at - node.startIndex, cut.startIndex - node.startIndex);
+        at = cut.endIndex;
+    }
+    return text + source.slice(at - node.startIndex);
+}
+
 function invocationIdentity(node) {
     if (!node) return {};
     if (node.type === 'identifier' || node.type === 'generic_name') {
@@ -1924,7 +2092,7 @@ function invocationIdentity(node) {
         return {
             name: nameNode?.type === 'generic_name' ? nameNode.namedChild(0)?.text : nameNode?.text,
             nameNode,
-            receiver: expression?.text,
+            receiver: nullForgivingFreeText(expression),
             isMethod: true,
         };
     }
@@ -1939,7 +2107,7 @@ function invocationIdentity(node) {
             name: nameNode?.type === 'generic_name'
                 ? nameNode.namedChild(0)?.text : nameNode?.text,
             nameNode,
-            receiver: expression?.text,
+            receiver: nullForgivingFreeText(expression),
             isMethod: true,
         };
     }
@@ -1987,6 +2155,15 @@ function staticMemberPath(node, variableTypes) {
 function staticArgKind(node, variableTypes) {
     if (!node) return 'expr';
     switch (node.type) {
+        case 'this': {
+            // `this` is an instance of the enclosing type (fix #430); a
+            // generic type's own instance stays unknown.
+            let owner = node.parent;
+            while (owner && !TYPE_DECLARATIONS.has(owner.type)) owner = owner.parent;
+            const name = owner?.childForFieldName('name')?.text;
+            return name && !owner.childForFieldName('type_parameters') &&
+                !owner.namedChildren.some(child => child.type === 'type_parameter_list') ? `type:${name}` : 'expr';
+        }
         case 'string_literal':
         case 'verbatim_string_literal':
         case 'interpolated_string_expression':
@@ -2036,6 +2213,11 @@ function staticArgKind(node, variableTypes) {
         }
         case 'invocation_expression': {
             const identity = invocationIdentity(node.childForFieldName('function'));
+            // An untyped local or member remains a value binding. Its
+            // spelling cannot identify a same-named producer class.
+            if (identity.receiver && !variableTypes?.has(identity.receiver) &&
+                (csharpBareNameShadowedByLocal(node, identity.receiver) ||
+                 enclosingTypeDeclaresMember(node, identity.receiver))) return 'expr';
             if (identity.name === 'GetValueOrDefault' && identity.receiver) {
                 const rawType = variableTypes?.get(identity.receiver);
                 if (rawType?.trim().endsWith('?')) {
@@ -2109,11 +2291,16 @@ function staticArgKind(node, variableTypes) {
         case 'anonymous_method_expression': {
             // Its parameter count selects among delegate overloads (fix
             // #391); `delegate { }` without a list converts to any count.
+            // An implicitly typed lambda (`x => ..`, `(a, b) => ..`) is
+            // marked `:i`: its parameter types come from the target
+            // delegate, never the other way (fix #428).
             const params = node.childForFieldName('parameters');
             if (!params) return 'lambda';
-            return params.type === 'parameter_list'
-                ? `lambda:${params.namedChildren.filter(child => child.type === 'parameter').length}`
-                : 'lambda:1';
+            if (params.type !== 'parameter_list') return 'lambda:1:i';
+            const list = params.namedChildren.filter(child => child.type === 'parameter');
+            const implicit = node.type === 'lambda_expression' && list.length > 0 &&
+                list.every(child => !child.childForFieldName('type'));
+            return `lambda:${list.length}${implicit ? ':i' : ''}`;
         }
         case 'binary_expression': {
             // String concatenation: `+` with a string operand is a string
@@ -2134,7 +2321,8 @@ function callArgs(node, variableTypes) {
         node.namedChildren.find(child => child.type === 'argument_list');
     const args = (argsNode?.namedChildren || []).filter(child => child.type === 'argument');
     const argKinds = args.map(argument =>
-        staticArgKind(argument.namedChild(0), variableTypes));
+        staticArgKind(argument.namedChild(0) ||
+            (argument.childCount === 1 && argument.child(0)?.type === 'this' ? argument.child(0) : null), variableTypes));
     return {
         argCount: args.length,
         ...(argKinds.some(kind => kind !== 'expr') && { argKinds }),
@@ -2272,13 +2460,22 @@ function findCallsInCode(code, parser) {
             (a.callSite?.column ?? 0) - (b.callSite?.column ?? 0));
 }
 
+/** Omitted base initializer calls of one class, read as findCallsInCode reads them (fix #421). */
+function implicitBaseCallsOf(code, parser, ownerLine, ownerEndLine) {
+    const extract = (tree, reaches) => require('./constructor-bases').implicitBaseCallsOfOwner(tree.rootNode, 'csharp',
+        reaches, ownerLine, ownerEndLine);
+    const views = csharpViews(parser, code);
+    if (!views) return extract(safeParse(parser, code, undefined, PARSE_OPTIONS), null);
+    return csMergeViewItems(views, extract, call => call.line);
+}
+
 function findCallsInTree(code, parser, tree, reaches = null) {
     const variableTypesByScope = buildVariableTypes(tree, parser);
     const calls = [];
     // The variable types in scope at a call (only call nodes ask: the scope
     // walk climbs parents).
-    const typesAt = node => variableTypesByScope.get(variableScopeKey(node)) ||
-        variableTypesByScope.get('global');
+    const scopeMemo = new Map();
+    const typesAt = node => scopedVariableTypes(variableTypesByScope, node, scopeMemo);
     traverseTree(tree.rootNode, node => {
         if (reaches && !reaches(node)) return false;
         if (isControlFlowLocalArtifact(node)) {
@@ -2300,6 +2497,26 @@ function findCallsInTree(code, parser, tree, reaches = null) {
             // contains valid invocation AST nodes.
             return true;
         }
+        if (node.type === 'constructor_initializer') {
+            let owner = node.parent;
+            while (owner && !TYPE_DECLARATIONS.has(owner.type)) owner = owner.parent;
+            const isBase = node.children.some(child => child.type === 'base');
+            const baseList = owner?.namedChildren.find(child => child.type === 'base_list');
+            const type = isBase ? baseList?.namedChild(0) : owner?.childForFieldName('name');
+            if (!type) return true;
+            const constructed = constructionType(type);
+            if (!constructed) return true;
+            const typeArgs = isBase ? constructed.typeArgs : typeParameterCount(owner);
+            const args = callArgs(node, typesAt(node));
+            calls.push({ callSite: typeOrigin('call', node), name: constructed.name,
+                line: node.startPosition.row + 1, isMethod: false, isConstructor: true,
+                constructorSyntax: 'delegation', ctorDelegation: isBase ? 'super' : 'this',
+                ...(constructed.qualifier && { constructorQualifier: constructed.qualifier }),
+                ...(typeArgs > 0 && { typeArgs }),
+                argCount: args.argCount, ...(args.argKinds && { argKinds: args.argKinds }),
+                enclosingFunction: enclosingFunctionOf(node) });
+            return true;
+        }
         if (node.type === 'invocation_expression') {
             const identity = invocationIdentity(node.childForFieldName('function'));
             if (!identity.name) return true;
@@ -2515,13 +2732,13 @@ function findCallsInTree(code, parser, tree, reaches = null) {
             }
             if (!typeNode) return true;
             const args = callArgs(node, typesAt(node));
-            const raw = typeNode.text.replace(/<.*>$/, '');
-            const name = raw.split('.').pop();
-            const typeArgs = genericArityOf(typeNode.text);
+            const constructed = typeNode.type ? constructionType(typeNode) : constructionTypeText(typeNode.text);
+            if (!constructed) return true;
+            const { name, typeArgs } = constructed;
             // A target-typed site is the `new` token; its type is written
             // elsewhere.
             const targetTyped = !node.childForFieldName('type');
-            const siteNode = targetTyped ? (node.child(0) || node) : typeNode;
+            const siteNode = targetTyped ? (node.child(0) || node) : constructed.node;
             calls.push({
                 callSite: typeOrigin('call', siteNode),
                 name,
@@ -2529,6 +2746,7 @@ function findCallsInTree(code, parser, tree, reaches = null) {
                 ...(targetTyped && { targetTyped: true }),
                 isMethod: false,
                 isConstructor: true,
+                ...(constructed.qualifier && { constructorQualifier: constructed.qualifier }),
                 ...(typeArgs > 0 && { typeArgs }),
                 argCount: args.argCount,
                 ...(args.argKinds && { argKinds: args.argKinds }),
@@ -2537,6 +2755,7 @@ function findCallsInTree(code, parser, tree, reaches = null) {
         }
         return true;
     });
+    calls.push(...require('./constructor-bases').implicitBaseCalls(tree.rootNode, 'csharp', reaches));
     return calls;
 }
 
@@ -2547,9 +2766,9 @@ function findImportsInCode(code, parser) {
         .sort((a, b) => a.line - b.line);
 }
 
-function findImportsInTree(tree) {
+function findImportsInTree(tree, queryOnly = false) {
     const imports = [];
-    traverseTreeCached(tree.rootNode, node => {
+    const collect = node => {
         if (node.type !== 'using_directive') return true;
         const nameNode = node.childForFieldName('name');
         const named = node.namedChildren || [];
@@ -2572,9 +2791,17 @@ function findImportsInTree(tree) {
             ...(isGlobal && { global: true }),
             ...(isStatic && { static: true }),
             ...(enclosing && !rooted && { namespace: enclosing }),
+            // csMergeViewItems passes a reach predicate as its second arg.
+            // Only this explicit query mode adds facts; build records keep
+            // their existing persisted shape.
+            ...(queryOnly === true && { rooted,
+                usingScopes: require('./csharp-scope').usingScopesOf(node) }),
         });
         return false;
-    });
+    };
+    if (queryOnly === true) {
+        for (const node of tree.rootNode.descendantsOfType('using_directive')) collect(node);
+    } else traverseTreeCached(tree.rootNode, collect);
     return imports;
 }
 
@@ -2591,15 +2818,98 @@ function findUsagesInCode(code, name, parser, existingTree) {
     return usagesInTree(code, name, parser, existingTree || safeParse(parser, code, undefined, PARSE_OPTIONS));
 }
 
+// Lift only the terminal name, never a receiver or type argument, through
+// the grammar's generic/member wrappers (fix #411).
+function usageNameExpression(node) {
+    let current = node;
+    let parent = current.parent;
+    if (parent?.type === 'generic_name' && sameNode(parent.namedChild(0), current)) {
+        current = parent;
+        parent = current.parent;
+    }
+    if ((parent?.type === 'member_access_expression' || parent?.type === 'member_binding_expression') &&
+        sameNode(parent.childForFieldName('name') || parent.namedChild(0), current)) {
+        current = parent;
+        parent = current.parent;
+        if (current.type === 'member_binding_expression' && parent?.type === 'conditional_access_expression') {
+            current = parent;
+        }
+    }
+    return current;
+}
+
+function methodGroupReceiver(node) {
+    const expression = usageNameExpression(node);
+    const receiver = expression.childForFieldName('expression') || expression.childForFieldName('condition');
+    const type = require('./csharp-scope').namedType(receiver, node);
+    if (!type) return null;
+    const argumentsNode = type.node.parent?.type === 'generic_name'
+        ? type.node.parent.namedChildren.find(child => child.type === 'type_argument_list') : null;
+    return { name: type.name, qualifier: type.qualifierText,
+        arity: argumentsNode?.namedChildCount || 0 };
+}
+
+function invokesNameExpression(expression) {
+    return expression.parent?.type === 'invocation_expression' &&
+        sameNode(expression.parent.childForFieldName('function'), expression);
+}
+
+function isInvokedName(node, options = {}) {
+    const expression = usageNameExpression(node);
+    if (options.unqualified && expression.type !== 'identifier' && expression.type !== 'generic_name') return false;
+    return invokesNameExpression(expression);
+}
+
+/** Only declarations can give the local-type map a receiver's name. */
+function possibleReceiverBinding(node, name, memo) {
+    const member = csharpEnclosingCallable(node);
+    if (!member || member.hasError) return true;
+    const key = `${member.id}\0${name}`;
+    if (memo.has(key)) return memo.get(key);
+    const text = member.text;
+    let possible = false;
+    for (let at = text.indexOf(name); at >= 0; at = text.indexOf(name, at + name.length)) {
+        const token = member.descendantForIndex(member.startIndex + at, member.startIndex + at + name.length);
+        if (!token || token.text !== name) continue;
+        const parent = token.parent;
+        if (token.type !== 'identifier' || parent?.type !== 'member_access_expression' ||
+            !sameNode(parent.childForFieldName('expression'), token)) {
+            possible = true;
+            break;
+        }
+    }
+    if (!possible) {
+        let rows = memo.get('scope-rows');
+        if (!rows) {
+            rows = new Map();
+            for (const scope of node.tree.rootNode.descendantsOfType([...CALLABLE_SCOPE_NODES])) {
+                if (isControlFlowLocalArtifact(scope)) continue;
+                const row = scope.startPosition.row;
+                rows.set(row, (rows.get(row) || 0) + 1);
+            }
+            memo.set('scope-rows', rows);
+        }
+        // Scopes sharing a declaration row contribute to the same local-type
+        // map, so another callable on that row can carry the binding.
+        if (rows.get(member.startPosition.row) !== 1) possible = true;
+    }
+    memo.set(key, possible);
+    return possible;
+}
+
 function usagesInTree(code, name, parser, tree) {
     const usages = [];
-    const variableTypesByScope = buildVariableTypes(tree, parser);
+    const receiverBindings = new Map();
+    let variableTypesByScope;
+    const scopeMemo = new Map();
     visitNameNodes(tree, code, name, node => {
         if (!IDENTIFIER_NODES.has(node.type) || node.text !== name) return;
         let usageType = 'reference';
         const parent = node.parent;
+        const expression = usageNameExpression(node);
         if (parent) {
             if ((parent.type === 'method_declaration' ||
+                parent.type === 'local_function_statement' ||
                 parent.type === 'constructor_declaration' ||
                 TYPE_DECLARATIONS.has(parent.type) ||
                 parent.type === 'property_declaration' ||
@@ -2608,21 +2918,23 @@ function usagesInTree(code, name, parser, tree) {
                 parent.type === 'variable_declarator') &&
                 (sameNode(parent.childForFieldName('name'), node))) {
                 usageType = 'definition';
-            } else if (parent.type === 'invocation_expression' ||
-                parent.parent?.type === 'invocation_expression') {
+            } else if (invokesNameExpression(expression)) {
                 usageType = 'call';
             } else if (parent.type === 'using_directive') {
                 usageType = 'import';
             }
-            if (parent.type === 'member_access_expression' &&
-                sameNode(parent.childForFieldName('name'), node)) {
-                const receiverNode = parent.childForFieldName('expression') ||
-                    parent.namedChild(0);
-                const receiver = receiverNode?.text;
-                const scopeTypes = variableTypesByScope.get(variableScopeKey(node)) ||
-                    variableTypesByScope.get('global');
-                const declared = receiverNode?.type === 'identifier'
-                    ? normalizeReceiverType(scopeTypes?.get(receiver)) : null;
+            const identity = invocationIdentity(expression);
+            if (identity.receiver) {
+                const receiverNode = expression.childForFieldName('expression') ||
+                    expression.childForFieldName('condition') || expression.namedChild(0);
+                const receiver = identity.receiver;
+                let declared = null;
+                if (receiverNode?.type === 'identifier' &&
+                    (variableTypesByScope || possibleReceiverBinding(node, receiver, receiverBindings))) {
+                    variableTypesByScope ||= buildVariableTypes(tree, parser);
+                    const scopeTypes = scopedVariableTypes(variableTypesByScope, node, scopeMemo);
+                    declared = normalizeReceiverType(scopeTypes?.get(receiver));
+                }
                 const sameClass = ['this', 'base'].includes(receiver)
                     ? enclosingClassName(node) : null;
                 usages.push({
@@ -2632,6 +2944,8 @@ function usagesInTree(code, name, parser, tree) {
                     ...(receiver && { receiver }),
                     ...((declared?.name || sameClass) && {
                         receiverType: declared?.name || sameClass,
+                        ...(declared?.namespace && { receiverTypeQualifier: declared.namespace }),
+                        ...(Number.isInteger(declared?.typeArgs) && { receiverTypeArgs: declared.typeArgs }),
                     }),
                 });
                 return true;
@@ -2771,6 +3085,10 @@ function parse(code, parser) {
         }),
         ...(features.length > 0 && { languageFeatures: features }),
         ...(views && { conditionalViews: views.groups.map(group => [...group]) }),
+        // The raw parse's names: configuration views parse rewritten sources.
+        ...((!views || views.typeParameterNames) && {
+            typeParameterNames: views ? views.typeParameterNames : require('./utils').declaredTypeParameterNames(tree),
+        }),
     };
 }
 
@@ -2790,7 +3108,49 @@ function exportsOfClasses(classes) {
     return exports;
 }
 
+const scopedUsingsByTree = new WeakMap();
+function queryUsingDirectives(tree) {
+    if (scopedUsingsByTree.has(tree)) return scopedUsingsByTree.get(tree);
+    const views = csViewsByTree.get(tree)?.views;
+    const read = view => findImportsInTree(view, true);
+    const result = views ? csMergeViewItems(views, read, item => item.line) : read(tree);
+    scopedUsingsByTree.set(tree, result);
+    return result;
+}
+
+function accessorReferenceShape(tree, usage) {
+    const views = tree && csViewsByTree.get(tree)?.views;
+    const owner = views?.secondary.find(view => view.owns.has(usage.line - 1));
+    return require('./csharp-scope').accessorReferenceShape(owner?.tree || tree, usage, implicitCreationTarget);
+}
+
+function accessorTypeSyntax(text) {
+    const parser = require('./index').getParser('csharp');
+    const tree = safeParse(parser, `class TypeSlot { ${text} field; }`);
+    if (!tree || tree.rootNode.hasError) return null;
+    const declaration = tree.rootNode.descendantsOfType('variable_declaration')[0];
+    const type = declaration?.childForFieldName('type');
+    return type ? require('./csharp-scope').namedType(type, type) : null;
+}
+
 module.exports = {
+    implicitBaseCallsOf,
+    implicitOwnerScope(node) {
+        let enclosingType = null;
+        for (let parent = node.parent; parent; parent = parent.parent) {
+            if (!TYPE_DECLARATIONS.has(parent.type)) continue;
+            enclosingType = parent.childForFieldName('name')?.text || null;
+            break;
+        }
+        return { namespace: namespaceOf(node, node.tree), enclosingType };
+    },
+    queryBodyViews,
+    queryBodyTree,
+    methodGroupReceiver,
+    isInvokedName,
+    queryUsingDirectives,
+    accessorReferenceShape,
+    accessorTypeSyntax,
     queryTree,
     queryTreeIsPlain,
     analysisTree: queryTree,