gitnexus 1.6.3-rc.9 → 1.6.3

package/dist/core/ingestion/languages/csharp/query.js

@@ -0,0 +1,515 @@
+/**
+ * Tree-sitter query for C# scope captures (RFC §5.1).
+ *
+ * Captures the structural skeleton the generic scope-resolution
+ * pipeline consumes: scopes (module/namespace/class/function),
+ * declarations (class-likes, method-likes, properties, variables,
+ * local functions), imports (using directives), type bindings
+ * (parameter annotations, variable annotations, constructor
+ * inference), and references (call sites, member writes).
+ *
+ * C# specifics that shape this query:
+ *
+ *   - Both block-scoped (`namespace X { }`) and file-scoped
+ *     (`namespace X;`) namespaces. tree-sitter-c-sharp emits them
+ *     under distinct node types (`namespace_declaration` vs
+ *     `file_scoped_namespace_declaration`); both map to
+ *     `@scope.namespace` since the scope semantics are identical.
+ *   - `partial class X` splits a Class def across files. Each file
+ *     emits its own `@declaration.class`; cross-file resolution is
+ *     handled at the graph-bridge layer via the qualified-name key.
+ *   - `using X = Y;` aliases and `using static X;` are interpreted in
+ *     `interpret.ts` via the `@import.*` captures. All three using
+ *     flavors share the same anchor (`@import.statement`).
+ *   - Explicit interface implementations (`void IFoo.Bar() { }`)
+ *     expose the qualified name via the existing `@declaration.name`
+ *     — the extractor's `csharpMethodConfig.extractQualifiedName`
+ *     picks up the explicit qualifier from the method declaration
+ *     node.
+ *
+ * Exposes lazy `Parser` and `Query` singletons so callers don't pay
+ * tree-sitter init cost per file.
+ */
+import Parser from 'tree-sitter';
+import CSharp from 'tree-sitter-c-sharp';
+const CSHARP_SCOPE_QUERY = `
+;; Scopes
+(compilation_unit) @scope.module
+
+(namespace_declaration) @scope.namespace
+(file_scoped_namespace_declaration) @scope.namespace
+
+(class_declaration) @scope.class
+(interface_declaration) @scope.class
+(struct_declaration) @scope.class
+(record_declaration) @scope.class
+(enum_declaration) @scope.class
+
+(method_declaration) @scope.function
+(constructor_declaration) @scope.function
+(destructor_declaration) @scope.function
+(local_function_statement) @scope.function
+(operator_declaration) @scope.function
+(conversion_operator_declaration) @scope.function
+;; Property accessors are blocks within a property; not scoped here.
+;; Anonymous methods / lambdas are not scoped — out of scope per plan.
+
+;; Declarations — types
+(class_declaration
+  name: (identifier) @declaration.name) @declaration.class
+
+(interface_declaration
+  name: (identifier) @declaration.name) @declaration.interface
+
+(struct_declaration
+  name: (identifier) @declaration.name) @declaration.struct
+
+(record_declaration
+  name: (identifier) @declaration.name) @declaration.record
+
+(enum_declaration
+  name: (identifier) @declaration.name) @declaration.enum
+
+;; Declarations — methods / constructors / properties
+(method_declaration
+  name: (identifier) @declaration.name) @declaration.method
+
+(constructor_declaration
+  name: (identifier) @declaration.name) @declaration.constructor
+
+(destructor_declaration
+  name: (identifier) @declaration.name) @declaration.method
+
+(local_function_statement
+  name: (identifier) @declaration.name) @declaration.function
+
+;; Operator declarations — \`public static T operator +(T a, T b)\`.
+;; tree-sitter-c-sharp exposes the operator token under the \`operator:\`
+;; field (an anonymous node like \`+\`, \`-\`, \`==\`). Capture the whole
+;; node under @declaration.name so the extractor reads the operator
+;; symbol as the declared name; downstream csharpMethodConfig can
+;; normalize it (e.g. to \`op_Addition\`) when it runs.
+(operator_declaration
+  operator: _ @declaration.name) @declaration.method
+
+;; Conversion operators — \`public static explicit operator int(T x)\`.
+;; No operator token; the target type (\`int\`) identifies the conversion
+;; and serves as the name anchor.
+(conversion_operator_declaration
+  type: _ @declaration.name) @declaration.method
+
+(property_declaration
+  name: (identifier) @declaration.name) @declaration.property
+
+(indexer_declaration) @declaration.property
+
+;; Fields — \`int x;\` at class scope. variable_declarator inside
+;; field_declaration carries the name.
+(field_declaration
+  (variable_declaration
+    (variable_declarator
+      name: (identifier) @declaration.name))) @declaration.variable
+
+;; Local variables — \`int x = 1;\` inside a method body
+(local_declaration_statement
+  (variable_declaration
+    (variable_declarator
+      name: (identifier) @declaration.name))) @declaration.variable
+
+;; Imports — single anchor per directive; interpretCsharpImport classifies
+(using_directive) @import.statement
+
+;; Type bindings — parameter annotations: \`void F(User u)\`
+(parameter
+  type: (identifier) @type-binding.type
+  name: (identifier) @type-binding.name) @type-binding.parameter
+
+(parameter
+  type: (generic_name) @type-binding.type
+  name: (identifier) @type-binding.name) @type-binding.parameter
+
+(parameter
+  type: (qualified_name) @type-binding.type
+  name: (identifier) @type-binding.name) @type-binding.parameter
+
+(parameter
+  type: (nullable_type) @type-binding.type
+  name: (identifier) @type-binding.name) @type-binding.parameter
+
+;; Type bindings — local variable annotations: \`User u = new User();\`
+;; Typed local with identifier type + \`new X()\` initializer — shape
+;; matters so \`u\` binds to \`X\` (the constructor call's type), not the
+;; declared type alias (which is usually the same, but \`new DerivedUser()\`
+;; would be distinct).
+(local_declaration_statement
+  (variable_declaration
+    type: (identifier) @type-binding.type
+    (variable_declarator
+      name: (identifier) @type-binding.name))) @type-binding.annotation
+
+(local_declaration_statement
+  (variable_declaration
+    type: (generic_name) @type-binding.type
+    (variable_declarator
+      name: (identifier) @type-binding.name))) @type-binding.annotation
+
+(local_declaration_statement
+  (variable_declaration
+    type: (qualified_name) @type-binding.type
+    (variable_declarator
+      name: (identifier) @type-binding.name))) @type-binding.annotation
+
+;; Type bindings — \`var u = new User();\` — constructor-inferred.
+;; Captures object_creation_expression's type as the binding type.
+;; variable_declarator wraps the \`= <expr>\` directly; tree-sitter-c-sharp
+;; does not surface an equals_value_clause wrapper here.
+(local_declaration_statement
+  (variable_declaration
+    (variable_declarator
+      name: (identifier) @type-binding.name
+      (object_creation_expression
+        type: (identifier) @type-binding.type)))) @type-binding.constructor
+
+(local_declaration_statement
+  (variable_declaration
+    (variable_declarator
+      name: (identifier) @type-binding.name
+      (object_creation_expression
+        type: (generic_name) @type-binding.type)))) @type-binding.constructor
+
+(local_declaration_statement
+  (variable_declaration
+    (variable_declarator
+      name: (identifier) @type-binding.name
+      (object_creation_expression
+        type: (qualified_name) @type-binding.type)))) @type-binding.constructor
+
+;; Type bindings — \`var u = factory();\` alias (chain-follow picks up
+;; factory's return type via propagateImportedReturnTypes)
+(local_declaration_statement
+  (variable_declaration
+    (variable_declarator
+      name: (identifier) @type-binding.name
+      (invocation_expression
+        function: (identifier) @type-binding.type)))) @type-binding.alias
+
+;; Type bindings — identifier-to-identifier alias: \`var alias = u;\`.
+;; The resolver's chain-follow walks from \`alias\` → \`u\` → u's
+;; declared type, so we only need to tag the rename here.
+(local_declaration_statement
+  (variable_declaration
+    type: (implicit_type)
+    (variable_declarator
+      name: (identifier) @type-binding.name
+      (identifier) @type-binding.type))) @type-binding.alias
+
+;; Type bindings — chained method-call alias: \`var u = svc.GetUser();\`.
+;; The chain-follow then walks GetUser's return-type binding.
+(local_declaration_statement
+  (variable_declaration
+    type: (implicit_type)
+    (variable_declarator
+      name: (identifier) @type-binding.name
+      (invocation_expression
+        function: (member_access_expression
+          name: (identifier) @type-binding.type))))) @type-binding.alias
+
+;; Type bindings — \`await\` propagation: \`var u = await Factory();\`.
+;; Strip the await wrapper to get the underlying invocation; interpret
+;; layer's stripGeneric handles Task<T> / ValueTask<T>.
+(local_declaration_statement
+  (variable_declaration
+    type: (implicit_type)
+    (variable_declarator
+      name: (identifier) @type-binding.name
+      (await_expression
+        (invocation_expression
+          function: (identifier) @type-binding.type))))) @type-binding.alias
+
+(local_declaration_statement
+  (variable_declaration
+    type: (implicit_type)
+    (variable_declarator
+      name: (identifier) @type-binding.name
+      (await_expression
+        (invocation_expression
+          function: (member_access_expression
+            name: (identifier) @type-binding.type)))))) @type-binding.alias
+
+;; Type bindings — identifier-to-identifier assignment rebind:
+;; \`alias = u;\` — aliases the rhs identifier's current type.
+(assignment_expression
+  left: (identifier) @type-binding.name
+  right: (identifier) @type-binding.type) @type-binding.alias
+
+;; Type bindings — method return type: \`public User GetUser() { ... }\`.
+;; Anchor on the method_declaration so bindingScopeFor can hoist the
+;; binding from function scope to the enclosing class/module scope
+;; (callers, not the function body, look up the return type by the
+;; function's name). Required for cross-file return-type propagation
+;; via propagateImportedReturnTypes.
+(method_declaration
+  returns: (identifier) @type-binding.type
+  name: (identifier) @type-binding.name) @type-binding.return
+
+(method_declaration
+  returns: (generic_name) @type-binding.type
+  name: (identifier) @type-binding.name) @type-binding.return
+
+(method_declaration
+  returns: (qualified_name) @type-binding.type
+  name: (identifier) @type-binding.name) @type-binding.return
+
+(method_declaration
+  returns: (nullable_type) @type-binding.type
+  name: (identifier) @type-binding.name) @type-binding.return
+
+;; Type bindings — field declaration: \`private City _city;\`. Attaches
+;; to the enclosing class scope via positionIndex, so \`this._city.X\`
+;; can look up _city's type on the class.
+(field_declaration
+  (variable_declaration
+    type: (identifier) @type-binding.type
+    (variable_declarator
+      name: (identifier) @type-binding.name))) @type-binding.annotation
+
+(field_declaration
+  (variable_declaration
+    type: (generic_name) @type-binding.type
+    (variable_declarator
+      name: (identifier) @type-binding.name))) @type-binding.annotation
+
+(field_declaration
+  (variable_declaration
+    type: (qualified_name) @type-binding.type
+    (variable_declarator
+      name: (identifier) @type-binding.name))) @type-binding.annotation
+
+;; Type bindings — property declaration: \`public User Owner { get; set; }\`.
+(property_declaration
+  type: (identifier) @type-binding.type
+  name: (identifier) @type-binding.name) @type-binding.annotation
+
+(property_declaration
+  type: (generic_name) @type-binding.type
+  name: (identifier) @type-binding.name) @type-binding.annotation
+
+(property_declaration
+  type: (qualified_name) @type-binding.type
+  name: (identifier) @type-binding.name) @type-binding.annotation
+
+(property_declaration
+  type: (nullable_type) @type-binding.type
+  name: (identifier) @type-binding.name) @type-binding.annotation
+
+;; Type bindings — assignment rebind: \`alias = Factory();\` where
+;; \`alias\` was previously declared. Same alias shape as \`var x = F();\`.
+(assignment_expression
+  left: (identifier) @type-binding.name
+  right: (invocation_expression
+    function: (identifier) @type-binding.type)) @type-binding.alias
+
+;; Type bindings — assignment with constructor: \`alias = new User();\`.
+(assignment_expression
+  left: (identifier) @type-binding.name
+  right: (object_creation_expression
+    type: (identifier) @type-binding.type)) @type-binding.constructor
+
+(assignment_expression
+  left: (identifier) @type-binding.name
+  right: (object_creation_expression
+    type: (generic_name) @type-binding.type)) @type-binding.constructor
+
+;; Type bindings — \`is\` pattern: \`if (obj is User u) { u.Save(); }\`.
+;; The declaration_pattern carries both the matched type and the
+;; binding name; scope narrowing to the guarded branch is simplified
+;; to function-scope (matches Python's match-case treatment) since we
+;; don't emit @scope.block.
+(is_pattern_expression
+  pattern: (declaration_pattern
+    type: (identifier) @type-binding.type
+    name: (identifier) @type-binding.name)) @type-binding.annotation
+
+(is_pattern_expression
+  pattern: (declaration_pattern
+    type: (generic_name) @type-binding.type
+    name: (identifier) @type-binding.name)) @type-binding.annotation
+
+(is_pattern_expression
+  pattern: (declaration_pattern
+    type: (qualified_name) @type-binding.type
+    name: (identifier) @type-binding.name)) @type-binding.annotation
+
+;; Type bindings — \`case User u:\` inside a switch section.
+;; tree-sitter-c-sharp's switch_section directly contains the
+;; declaration_pattern / recursive_pattern (no case_pattern_switch_label
+;; wrapper as in other C# grammars).
+(switch_section
+  (declaration_pattern
+    type: (identifier) @type-binding.type
+    name: (identifier) @type-binding.name)) @type-binding.annotation
+
+(switch_section
+  (declaration_pattern
+    type: (generic_name) @type-binding.type
+    name: (identifier) @type-binding.name)) @type-binding.annotation
+
+;; Type bindings — recursive_pattern with named binding:
+;; \`x is User { Age: 1 } u\` / \`case User { Age: 1 } u:\`. type + name
+;; are named fields on recursive_pattern; inner property/positional
+;; clauses don't affect the binding.
+(is_pattern_expression
+  pattern: (recursive_pattern
+    type: (identifier) @type-binding.type
+    name: (identifier) @type-binding.name)) @type-binding.annotation
+
+(switch_section
+  (recursive_pattern
+    type: (identifier) @type-binding.type
+    name: (identifier) @type-binding.name)) @type-binding.annotation
+
+;; Type bindings — switch-expression arms: \`obj switch { User u => …, Repo { Name: "x" } r => … }\`.
+;; Distinct from the \`switch_statement\` shape above — expression-switch
+;; uses \`switch_expression_arm\` nodes.
+(switch_expression_arm
+  (declaration_pattern
+    type: (identifier) @type-binding.type
+    name: (identifier) @type-binding.name)) @type-binding.annotation
+
+(switch_expression_arm
+  (declaration_pattern
+    type: (generic_name) @type-binding.type
+    name: (identifier) @type-binding.name)) @type-binding.annotation
+
+(switch_expression_arm
+  (recursive_pattern
+    type: (identifier) @type-binding.type
+    name: (identifier) @type-binding.name)) @type-binding.annotation
+
+;; Type bindings — typed foreach: \`foreach (User u in xs)\`.
+;; Shape parity with \`User u = …;\` — left binds to the declared type.
+(foreach_statement
+  type: (identifier) @type-binding.type
+  left: (identifier) @type-binding.name) @type-binding.annotation
+
+(foreach_statement
+  type: (generic_name) @type-binding.type
+  left: (identifier) @type-binding.name) @type-binding.annotation
+
+(foreach_statement
+  type: (qualified_name) @type-binding.type
+  left: (identifier) @type-binding.name) @type-binding.annotation
+
+(foreach_statement
+  type: (nullable_type) @type-binding.type
+  left: (identifier) @type-binding.name) @type-binding.annotation
+
+;; Type bindings — \`var\` foreach: \`foreach (var u in xs)\`. Alias to
+;; the iterable's identifier / chain so chain-follow unwraps
+;; \`List<User>\` / \`Dictionary<K,V>.Values\` to the element type via
+;; the generic-stripper in interpret.ts. Mirrors Python's for-loop
+;; alias patterns.
+(foreach_statement
+  type: (implicit_type)
+  left: (identifier) @type-binding.name
+  right: (identifier) @type-binding.type) @type-binding.alias
+
+(foreach_statement
+  type: (implicit_type)
+  left: (identifier) @type-binding.name
+  right: (member_access_expression) @type-binding.type) @type-binding.alias
+
+(foreach_statement
+  type: (implicit_type)
+  left: (identifier) @type-binding.name
+  right: (invocation_expression
+    function: (identifier) @type-binding.type)) @type-binding.alias
+
+;; Return-type captures on method_declaration / property_declaration /
+;; field_declaration are deferred — tree-sitter-c-sharp does not expose
+;; the return/field type under a simple named field that pattern-matches
+;; cleanly. When Unit 7's parity gate surfaces a gap requiring these
+;; bindings, revisit with a positional pattern or a post-hoc lookup via
+;; csharpMethodConfig.extractReturnType / csharpFieldConfig.extractType.
+
+;; References — free calls: \`Foo()\`
+(invocation_expression
+  function: (identifier) @reference.name) @reference.call.free
+
+;; References — member calls: \`obj.Method()\`
+;; \`(_)\` matches only named nodes in tree-sitter queries. \`this\` and
+;; \`base\` are anonymous tokens in tree-sitter-c-sharp (unlike Python's
+;; \`self\` which is a regular identifier), so they need explicit
+;; patterns to emit a receiver capture.
+(invocation_expression
+  function: (member_access_expression
+    expression: (_) @reference.receiver
+    name: (identifier) @reference.name)) @reference.call.member
+
+(invocation_expression
+  function: (member_access_expression
+    expression: "this" @reference.receiver
+    name: (identifier) @reference.name)) @reference.call.member
+
+(invocation_expression
+  function: (member_access_expression
+    expression: "base" @reference.receiver
+    name: (identifier) @reference.name)) @reference.call.member
+
+;; References — null-conditional member calls: \`obj?.Method()\`
+;; conditional_access_expression wraps a receiver followed by a
+;; member_binding_expression. Capture the receiver explicitly so
+;; receiver-bound resolution doesn't silently downgrade the call to
+;; a free-call (which would misresolve to an imported \`Save\`).
+;; tree-sitter-c-sharp doesn't expose named fields here, so use
+;; positional wildcards.
+(invocation_expression
+  function: (conditional_access_expression
+    (_) @reference.receiver
+    (member_binding_expression
+      (identifier) @reference.name))) @reference.call.member
+
+;; References — constructor calls: \`new User(...)\`
+(object_creation_expression
+  type: (identifier) @reference.name) @reference.call.constructor
+
+(object_creation_expression
+  type: (generic_name
+    (identifier) @reference.name)) @reference.call.constructor
+
+(object_creation_expression
+  type: (qualified_name) @reference.call.constructor.qualified) @reference.call.constructor
+
+;; References — field/property writes: \`obj.Name = "x"\` emits a write
+;; ACCESSES edge from the enclosing method to the field/property on
+;; obj's class.
+(assignment_expression
+  left: (member_access_expression
+    expression: (_) @reference.receiver
+    name: (identifier) @reference.name)) @reference.write.member
+
+(assignment_expression
+  left: (member_access_expression
+    expression: "this" @reference.receiver
+    name: (identifier) @reference.name)) @reference.write.member
+
+(assignment_expression
+  left: (member_access_expression
+    expression: "base" @reference.receiver
+    name: (identifier) @reference.name)) @reference.write.member
+`;
+let _parser = null;
+let _query = null;
+export function getCsharpParser() {
+    if (_parser === null) {
+        _parser = new Parser();
+        _parser.setLanguage(CSharp);
+    }
+    return _parser;
+}
+export function getCsharpScopeQuery() {
+    if (_query === null) {
+        _query = new Parser.Query(CSharp, CSHARP_SCOPE_QUERY);
+    }
+    return _query;
+}

package/dist/core/ingestion/languages/csharp/receiver-binding.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Synthesize `@type-binding.self` captures for C# instance methods —
+ * one for `this` (always on non-static methods inside a type
+ * declaration) and optionally one for `base` (only on class methods
+ * when the enclosing class has an explicit base in its `base_list`).
+ *
+ * Mirrors `languages/python/receiver-binding.ts` in structure. The
+ * tree-sitter-c-sharp grammar doesn't give us a clean `.scm` pattern
+ * for "this-receiver on every instance method inside an enclosing
+ * type" because the binding isn't a parameter — it's an implicit
+ * receiver. Synthesis in code is the same approach Python uses for
+ * `self` / `cls`.
+ */
+import type { CaptureMatch } from '../../../../_shared/index.js';
+import { type SyntaxNode } from '../../utils/ast-helpers.js';
+/**
+ * Build zero, one, or two `@type-binding.self` matches for `fnNode`:
+ *
+ *  - Returns `null` if the function is free (no enclosing type),
+ *    static, or the enclosing type has no resolvable name.
+ *  - Returns one match (`this`) for non-static methods inside a
+ *    class/struct/record/interface.
+ *  - Returns two matches (`this` + `base`) only when the function
+ *    lives in a `class_declaration` (or `record_declaration`) that has
+ *    at least one base entry. Structs cannot inherit classes;
+ *    interfaces cannot call `base.X`.
+ *
+ *  The caller is responsible for guaranteeing
+ *  `FUNCTION_NODE_TYPES.has(fnNode.type)`.
+ */
+export declare function synthesizeCsharpReceiverBinding(fnNode: SyntaxNode): CaptureMatch[];

package/dist/core/ingestion/languages/csharp/receiver-binding.js

@@ -0,0 +1,135 @@
+/**
+ * Synthesize `@type-binding.self` captures for C# instance methods —
+ * one for `this` (always on non-static methods inside a type
+ * declaration) and optionally one for `base` (only on class methods
+ * when the enclosing class has an explicit base in its `base_list`).
+ *
+ * Mirrors `languages/python/receiver-binding.ts` in structure. The
+ * tree-sitter-c-sharp grammar doesn't give us a clean `.scm` pattern
+ * for "this-receiver on every instance method inside an enclosing
+ * type" because the binding isn't a parameter — it's an implicit
+ * receiver. Synthesis in code is the same approach Python uses for
+ * `self` / `cls`.
+ */
+import { nodeToCapture, syntheticCapture } from '../../utils/ast-helpers.js';
+const TYPE_DECL_NODE_TYPES = new Set([
+    'class_declaration',
+    'struct_declaration',
+    'record_declaration',
+    'interface_declaration',
+]);
+const FUNCTION_NODE_TYPES = new Set([
+    'method_declaration',
+    'constructor_declaration',
+    'destructor_declaration',
+    'operator_declaration',
+    'conversion_operator_declaration',
+    'local_function_statement',
+]);
+/** Walk up to the enclosing type declaration, stopping at any other
+ *  function-like node (nested local functions shouldn't leak `this`
+ *  from an outer class to an inner closure). */
+function findEnclosingTypeDeclaration(node) {
+    let cur = node.parent;
+    while (cur !== null) {
+        if (TYPE_DECL_NODE_TYPES.has(cur.type))
+            return cur;
+        // A local function nested inside another method still sees `this`
+        // from the enclosing class — don't break on function-like nodes.
+        cur = cur.parent;
+    }
+    return null;
+}
+function typeName(typeNode) {
+    return typeNode.childForFieldName('name')?.text ?? null;
+}
+/** First entry in the type's `base_list`, read as raw text. C# allows
+ *  generic and qualified bases (`Foo<T>`, `N.M.Base`); we keep the raw
+ *  form so downstream interpret layer can strip generics/qualifiers
+ *  the same way as other type-binding captures. Returns null when the
+ *  type has no base (or an empty base_list). */
+function firstBaseText(typeNode) {
+    for (let i = 0; i < typeNode.namedChildCount; i++) {
+        const child = typeNode.namedChild(i);
+        if (child === null || child.type !== 'base_list')
+            continue;
+        const firstBase = child.namedChild(0);
+        if (firstBase === null)
+            return null;
+        return firstBase.text;
+    }
+    return null;
+}
+function isStaticMethod(fnNode) {
+    // A `static` modifier appears as a named `modifier` child whose text
+    // is exactly "static". collectModifierTexts in field-extractors
+    // handles this, but duplicating the tiny scan here keeps the
+    // receiver-binding module dependency-free.
+    for (let i = 0; i < fnNode.namedChildCount; i++) {
+        const child = fnNode.namedChild(i);
+        if (child !== null && child.type === 'modifier' && child.text.trim() === 'static')
+            return true;
+    }
+    return false;
+}
+/**
+ * Build zero, one, or two `@type-binding.self` matches for `fnNode`:
+ *
+ *  - Returns `null` if the function is free (no enclosing type),
+ *    static, or the enclosing type has no resolvable name.
+ *  - Returns one match (`this`) for non-static methods inside a
+ *    class/struct/record/interface.
+ *  - Returns two matches (`this` + `base`) only when the function
+ *    lives in a `class_declaration` (or `record_declaration`) that has
+ *    at least one base entry. Structs cannot inherit classes;
+ *    interfaces cannot call `base.X`.
+ *
+ *  The caller is responsible for guaranteeing
+ *  `FUNCTION_NODE_TYPES.has(fnNode.type)`.
+ */
+export function synthesizeCsharpReceiverBinding(fnNode) {
+    if (!FUNCTION_NODE_TYPES.has(fnNode.type))
+        return [];
+    if (isStaticMethod(fnNode))
+        return [];
+    const enclosingType = findEnclosingTypeDeclaration(fnNode);
+    if (enclosingType === null)
+        return [];
+    const enclosingName = typeName(enclosingType);
+    if (enclosingName === null)
+        return [];
+    // Anchor the synthesized captures to a node clearly *inside* the
+    // function's scope (not at the method's start position, which maps
+    // to the enclosing class scope via positionIndex). The method's
+    // `body` field is the block statement — its range is guaranteed to
+    // be inside the function scope. If the method has no body (interface
+    // declaration, `abstract`), skip — there's no function scope to
+    // attach the binding to.
+    const anchorNode = fnNode.childForFieldName('body');
+    if (anchorNode === null)
+        return [];
+    const out = [];
+    out.push(buildReceiverMatch(anchorNode, 'this', enclosingName));
+    // `base` applies only to class / record methods with an explicit
+    // base class. `struct` can't inherit a class; `interface` can't
+    // call `base.X`. The first entry of `base_list` is the base class
+    // (interfaces follow); we can't statically distinguish the two here,
+    // but `base.X` only compiles when the first entry IS a class, so we
+    // trust the source — if the user wrote `base.X` in a class with
+    // interface-only bases, their code wouldn't compile anyway.
+    if (enclosingType.type === 'class_declaration' || enclosingType.type === 'record_declaration') {
+        const baseText = firstBaseText(enclosingType);
+        if (baseText !== null) {
+            out.push(buildReceiverMatch(anchorNode, 'base', baseText));
+        }
+    }
+    return out;
+}
+function buildReceiverMatch(anchorNode, name, typeText) {
+    const m = {
+        '@type-binding.self': nodeToCapture('@type-binding.self', anchorNode),
+        '@type-binding.name': syntheticCapture('@type-binding.name', anchorNode, name),
+        '@type-binding.type': syntheticCapture('@type-binding.type', anchorNode, typeText),
+    };
+    return m;
+}

package/dist/core/ingestion/languages/csharp/scope-resolver.d.ts

@@ -0,0 +1,10 @@
+/**
+ * C# `ScopeResolver` registered in `SCOPE_RESOLVERS` and consumed by
+ * the generic `runScopeResolution` orchestrator (RFC #909 Ring 3).
+ *
+ * Second migration after Python — see `pythonScopeResolver` for the
+ * canonical shape.
+ */
+import type { ScopeResolver } from '../../scope-resolution/contract/scope-resolver.js';
+declare const csharpScopeResolver: ScopeResolver;
+export { csharpScopeResolver };