gitnexus 1.5.3 → 1.6.1

package/dist/core/ingestion/method-extractors/configs/swift.js

@@ -0,0 +1,277 @@
+// gitnexus/src/core/ingestion/method-extractors/configs/swift.ts
+// Verified against tree-sitter-swift 0.6.0
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { findVisibility, hasKeyword, hasModifier } from '../../field-extractors/configs/helpers.js';
+import { extractSimpleTypeName } from '../../type-extractors/shared.js';
+// ---------------------------------------------------------------------------
+// Swift helpers
+// ---------------------------------------------------------------------------
+const SWIFT_VIS = new Set([
+    'public',
+    'private',
+    'fileprivate',
+    'internal',
+    'open',
+]);
+/**
+ * Extract the method name from a function_declaration or protocol_function_declaration.
+ *
+ * In tree-sitter-swift, the name is stored in a `simple_identifier` child
+ * (not a 'name' field) on both function_declaration and protocol_function_declaration.
+ */
+function extractSwiftName(node) {
+    // Try field-based name first
+    const nameField = node.childForFieldName('name');
+    if (nameField)
+        return nameField.text;
+    // Walk named children for simple_identifier (the function name)
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type === 'simple_identifier')
+            return child.text;
+    }
+    return undefined;
+}
+/**
+ * Extract the return type from a Swift function declaration.
+ *
+ * In tree-sitter-swift, the return type appears in a `type_annotation` child
+ * that follows the parameter list (after `->` in source). It may also appear
+ * as a direct type child (user_type, optional_type, tuple_type, array_type).
+ */
+function extractSwiftReturnType(node) {
+    // Look for the return type — typically the last type_annotation or a type node
+    // that appears after the parameter list.
+    // tree-sitter-swift places the return type inside a type child after '->'
+    let seenParams = false;
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (!child)
+            continue;
+        if (child.type === 'parameter') {
+            seenParams = true;
+            continue;
+        }
+        // The parameter list may be unnamed children; track when we pass ')'
+        if (seenParams || child.type === 'type_annotation') {
+            if (child.type === 'type_annotation') {
+                const inner = child.firstNamedChild;
+                if (inner)
+                    return inner.text?.trim();
+            }
+            if (child.type === 'user_type' ||
+                child.type === 'optional_type' ||
+                child.type === 'tuple_type' ||
+                child.type === 'array_type' ||
+                child.type === 'dictionary_type' ||
+                child.type === 'function_type') {
+                return child.text?.trim();
+            }
+        }
+    }
+    // Fallback: scan all children (named + unnamed) for '->' then grab the next named child
+    let seenArrow = false;
+    for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (!child)
+            continue;
+        if (!child.isNamed && child.text.trim() === '->') {
+            seenArrow = true;
+            continue;
+        }
+        if (seenArrow && child.isNamed) {
+            return child.text?.trim();
+        }
+    }
+    return undefined;
+}
+/**
+ * Extract parameters from a Swift function declaration.
+ *
+ * In tree-sitter-swift, parameters are `parameter` named children directly on
+ * the function_declaration node. Each parameter has:
+ *   - An external name (label) and/or internal name as simple_identifier children
+ *   - A type_annotation child containing the type
+ *   - An optional default value after '='
+ *   - A possible `...` for variadic parameters
+ */
+function extractSwiftParameters(node) {
+    const params = [];
+    // In tree-sitter-swift 0.6.0, parameters are direct children of function_declaration.
+    // Default value tokens ('=', literal) are siblings of the parameter node at the
+    // function_declaration level, not children of the parameter node.
+    for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (!child?.isNamed || child.type !== 'parameter')
+            continue;
+        // Extract parameter name — the last simple_identifier is the internal name
+        let paramName;
+        for (let j = 0; j < child.namedChildCount; j++) {
+            const part = child.namedChild(j);
+            if (part?.type === 'simple_identifier') {
+                paramName = part.text;
+            }
+        }
+        if (!paramName)
+            continue;
+        // Extract type — tree-sitter-swift uses user_type (not type_annotation)
+        let typeName = null;
+        let rawTypeName = null;
+        for (let j = 0; j < child.namedChildCount; j++) {
+            const part = child.namedChild(j);
+            if (part?.type === 'user_type' || part?.type === 'type_annotation') {
+                rawTypeName = part.text?.trim() ?? null;
+                const inner = part.firstNamedChild;
+                if (inner) {
+                    typeName = extractSimpleTypeName(inner) ?? inner.text?.trim() ?? null;
+                }
+                else {
+                    typeName = rawTypeName;
+                }
+                break;
+            }
+            // Handle built-in types (array_type, dictionary_type, optional_type, tuple_type)
+            if (part?.type.endsWith('_type') && part.type !== 'simple_identifier') {
+                rawTypeName = part.text?.trim() ?? null;
+                typeName = extractSimpleTypeName(part) ?? rawTypeName;
+                break;
+            }
+        }
+        // Check for default value: '=' token appears as a sibling after the parameter node
+        let isOptional = false;
+        const nextSibling = node.child(i + 1);
+        if (nextSibling && !nextSibling.isNamed && nextSibling.text.trim() === '=') {
+            isOptional = true;
+        }
+        // Check for variadic: '...' token among parameter children
+        let isVariadic = false;
+        for (let j = 0; j < child.childCount; j++) {
+            const c = child.child(j);
+            if (c && c.text.trim() === '...') {
+                isVariadic = true;
+                break;
+            }
+        }
+        params.push({
+            name: paramName,
+            type: typeName,
+            rawType: rawTypeName,
+            isOptional,
+            isVariadic,
+        });
+    }
+    return params;
+}
+/**
+ * Check if a method is inside a protocol.
+ *
+ * A protocol_function_declaration is always abstract. For function_declaration
+ * inside a protocol_body (if it appears there), it's also abstract when it has
+ * no body.
+ */
+function isSwiftAbstract(node, ownerNode) {
+    // protocol_function_declaration nodes are inherently abstract
+    if (node.type === 'protocol_function_declaration')
+        return true;
+    // function_declaration inside a protocol is abstract if it has no body
+    if (ownerNode.type === 'protocol_declaration') {
+        const body = node.childForFieldName('body');
+        if (!body) {
+            // Also check for function_body named child
+            for (let i = 0; i < node.namedChildCount; i++) {
+                const child = node.namedChild(i);
+                if (child?.type === 'function_body')
+                    return false;
+            }
+            return true;
+        }
+        return false;
+    }
+    return false;
+}
+/**
+ * Collect attribute nodes from a Swift function declaration.
+ *
+ * In tree-sitter-swift, attributes appear as `attribute` named children
+ * directly on the function_declaration node, or inside a `modifiers` wrapper.
+ * Each attribute node text starts with '@'.
+ */
+function extractSwiftAnnotations(node) {
+    const annotations = [];
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (!child)
+            continue;
+        if (child.type === 'attribute') {
+            const text = child.text?.trim();
+            if (text) {
+                // Normalize: strip arguments, keep just the name
+                // e.g. "@objc(myMethod)" -> "@objc", "@available(iOS 13, *)" -> "@available"
+                const match = text.match(/^@(\w+)/);
+                if (match) {
+                    annotations.push('@' + match[1]);
+                }
+                else {
+                    annotations.push(text);
+                }
+            }
+        }
+        // Also check inside modifiers wrapper
+        if (child.type === 'modifiers') {
+            for (let j = 0; j < child.namedChildCount; j++) {
+                const mod = child.namedChild(j);
+                if (mod?.type === 'attribute') {
+                    const text = mod.text?.trim();
+                    if (text) {
+                        const match = text.match(/^@(\w+)/);
+                        if (match) {
+                            annotations.push('@' + match[1]);
+                        }
+                        else {
+                            annotations.push(text);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return annotations;
+}
+// ---------------------------------------------------------------------------
+// Swift config
+// ---------------------------------------------------------------------------
+export const swiftMethodConfig = {
+    language: SupportedLanguages.Swift,
+    // tree-sitter-swift 0.6.0 may use class_declaration for classes, structs, enums, extensions,
+    // and actors — but this cannot be verified until the grammar installs on Node 22+.
+    // TODO: Verify struct_declaration, enum_declaration, extension_declaration, actor_declaration
+    // node types once tree-sitter-swift loads on Node 22, and add them here if they are distinct.
+    // protocol_declaration is a separate, confirmed node type.
+    typeDeclarationNodes: ['class_declaration', 'protocol_declaration'],
+    // function_declaration for class/struct methods, protocol_function_declaration for protocol methods
+    methodNodeTypes: ['function_declaration', 'protocol_function_declaration'],
+    bodyNodeTypes: ['class_body', 'protocol_body'],
+    extractName: extractSwiftName,
+    extractReturnType: extractSwiftReturnType,
+    extractParameters: extractSwiftParameters,
+    extractVisibility(node) {
+        return findVisibility(node, SWIFT_VIS, 'internal', 'modifiers');
+    },
+    isStatic(node) {
+        return (hasKeyword(node, 'static') ||
+            hasKeyword(node, 'class') ||
+            hasModifier(node, 'modifiers', 'static') ||
+            hasModifier(node, 'modifiers', 'class'));
+    },
+    isAbstract: isSwiftAbstract,
+    isFinal(node) {
+        return hasKeyword(node, 'final') || hasModifier(node, 'modifiers', 'final');
+    },
+    isAsync(node) {
+        return hasKeyword(node, 'async') || hasModifier(node, 'modifiers', 'async');
+    },
+    isOverride(node) {
+        return hasKeyword(node, 'override') || hasModifier(node, 'modifiers', 'override');
+    },
+    extractAnnotations: extractSwiftAnnotations,
+};

package/dist/core/ingestion/method-extractors/configs/typescript-javascript.js

@@ -46,6 +46,7 @@ function extractTsJsParameters(node) {
                     type: typeNode
                         ? (extractSimpleTypeName(typeNode) ?? typeNode.text?.trim() ?? null)
                         : null,
+                    rawType: typeNode?.text?.trim() ?? null,
                     isOptional: hasDefault,
                     isVariadic: isRest,
                 });
@@ -62,6 +63,7 @@ function extractTsJsParameters(node) {
                     type: typeNode
                         ? (extractSimpleTypeName(typeNode) ?? typeNode.text?.trim() ?? null)
                         : null,
+                    rawType: typeNode?.text?.trim() ?? null,
                     isOptional: true,
                     isVariadic: false,
                 });
@@ -78,6 +80,7 @@ function extractTsJsParameters(node) {
                     type: typeNode
                         ? (extractSimpleTypeName(typeNode) ?? typeNode.text?.trim() ?? null)
                         : null,
+                    rawType: typeNode?.text?.trim() ?? null,
                     isOptional: false,
                     isVariadic: true,
                 });
@@ -85,14 +88,26 @@ function extractTsJsParameters(node) {
             }
             case 'identifier': {
                 // JS: bare parameter name, no type info
-                params.push({ name: param.text, type: null, isOptional: false, isVariadic: false });
+                params.push({
+                    name: param.text,
+                    type: null,
+                    rawType: null,
+                    isOptional: false,
+                    isVariadic: false,
+                });
                 break;
             }
             case 'assignment_pattern': {
                 // JS: param = defaultValue — the left side is the name, isOptional = true
                 const left = param.childForFieldName('left');
                 if (left) {
-                    params.push({ name: left.text, type: null, isOptional: true, isVariadic: false });
+                    params.push({
+                        name: left.text,
+                        type: null,
+                        rawType: null,
+                        isOptional: true,
+                        isVariadic: false,
+                    });
                 }
                 break;
             }
@@ -100,22 +115,76 @@ function extractTsJsParameters(node) {
                 // JS: ...args
                 const inner = param.firstNamedChild;
                 if (inner) {
-                    params.push({ name: inner.text, type: null, isOptional: false, isVariadic: true });
+                    params.push({
+                        name: inner.text,
+                        type: null,
+                        rawType: null,
+                        isOptional: false,
+                        isVariadic: true,
+                    });
                 }
                 break;
             }
             case 'object_pattern':
             case 'array_pattern': {
                 // Destructured parameter — use full text as name
-                params.push({ name: param.text, type: null, isOptional: false, isVariadic: false });
+                params.push({
+                    name: param.text,
+                    type: null,
+                    rawType: null,
+                    isOptional: false,
+                    isVariadic: false,
+                });
                 break;
             }
         }
     }
     return params;
 }
+/** Regex to extract @returns or @return from JSDoc comments: `@returns {Type}` */
+const JSDOC_RETURN_RE = /@returns?\s*\{([^}]+)\}/;
+/**
+ * Minimal sanitization for JSDoc return types — preserves generic wrappers
+ * (e.g. `Promise<User>`) so that extractReturnTypeName in call-processor
+ * can apply WRAPPER_GENERICS unwrapping. Only strips JSDoc-specific syntax markers.
+ */
+function sanitizeJsDocReturnType(raw) {
+    let type = raw.trim();
+    // Strip JSDoc nullable/non-nullable prefixes: ?User → User, !User → User
+    if (type.startsWith('?') || type.startsWith('!'))
+        type = type.slice(1);
+    // Strip module: prefix — module:models.User → models.User
+    if (type.startsWith('module:'))
+        type = type.slice(7);
+    // Reject unions (ambiguous)
+    if (type.includes('|'))
+        return undefined;
+    if (!type)
+        return undefined;
+    return type;
+}
+/**
+ * Walk backwards through preceding siblings looking for a JSDoc comment containing
+ * `@returns {Type}` or `@return {Type}`. Stops at the first non-comment named node
+ * (excluding decorators, which precede methods in TS/JS).
+ */
+function extractJsDocReturnType(node) {
+    let sibling = node.previousSibling;
+    while (sibling) {
+        if (sibling.type === 'comment') {
+            const match = JSDOC_RETURN_RE.exec(sibling.text);
+            if (match)
+                return sanitizeJsDocReturnType(match[1]);
+        }
+        else if (sibling.isNamed && sibling.type !== 'decorator')
+            break;
+        sibling = sibling.previousSibling;
+    }
+    return undefined;
+}
 /**
  * Extract return type from return_type field, unwrapping type_annotation.
+ * Falls back to JSDoc `@returns {Type}` when the AST has no return type annotation.
  *
  * tree-sitter-typescript uses `return_type` as the field name (not `type` like JVM).
  * The return_type field points to a type_annotation node that must be unwrapped.
@@ -126,11 +195,12 @@ function extractTsJsReturnType(node) {
         if (returnType.type === 'type_annotation') {
             const inner = returnType.firstNamedChild;
             if (inner)
-                return extractSimpleTypeName(inner) ?? inner.text?.trim();
+                return inner.text?.trim();
         }
-        return extractSimpleTypeName(returnType) ?? returnType.text?.trim();
+        return returnType.text?.trim();
     }
-    return undefined;
+    // AST has no return type annotation — try JSDoc fallback
+    return extractJsDocReturnType(node);
 }
 /**
  * Extract visibility from accessibility_modifier or #private name.
@@ -218,7 +288,14 @@ const shared = {
     //     are not discovered because class_expression is not in typeDeclarationNodes.
     //   - declare module / declare global augmentations — methods inside ambient_module_declaration
     //     wrappers are not surfaced because the top-level walker doesn't descend into them.
-    methodNodeTypes: ['method_definition', 'method_signature', 'abstract_method_signature'],
+    methodNodeTypes: [
+        'method_definition',
+        'method_signature',
+        'abstract_method_signature',
+        'function_declaration',
+        'generator_function_declaration',
+        'function_signature',
+    ],
     bodyNodeTypes: ['class_body', 'interface_body'],
     extractName(node) {
         const nameNode = node.childForFieldName('name');

package/dist/core/ingestion/method-extractors/generic.d.ts

@@ -1,5 +1,11 @@
 import type { MethodExtractor, MethodExtractionConfig } from '../method-types.js';
 /**
  * Create a MethodExtractor from a declarative config.
+ *
+ * @throws {Error} if `typeDeclarationNodes` contains a static-implying owner
+ *   type (companion_object / object_declaration / singleton_class) that is
+ *   not covered by `staticOwnerTypes`. The guard fires once per language at
+ *   provider construction to prevent silent `isStatic=false` regressions. See
+ *   `STATIC_IMPLYING_OWNER_TYPES` for the exact opt-out convention.
  */
 export declare function createMethodExtractor(config: MethodExtractionConfig): MethodExtractor;

package/dist/core/ingestion/method-extractors/generic.js

@@ -1,10 +1,53 @@
 // gitnexus/src/core/ingestion/method-extractors/generic.ts
-/** Owner node types where member functions are effectively static (JVM semantics). */
-const STATIC_OWNER_TYPES = new Set(['companion_object', 'object_declaration']);
+/**
+ * Node types that imply static member semantics when they appear as the owner
+ * of a method (Kotlin companion objects, Kotlin top-level `object` declarations,
+ * Ruby `class << self` singleton classes). A config that lists any of these in
+ * `typeDeclarationNodes` MUST also include the same node type in
+ * `staticOwnerTypes` — otherwise methods inside these containers silently get
+ * `isStatic=false`, which is a correctness bug that previously only surfaced
+ * at analysis time on large repos.
+ *
+ * Opt-out: a config that sets `staticOwnerTypes: new Set()` (explicit empty
+ * set) signals "I handle static-ness entirely via isStatic()" and is exempt
+ * from the guard.
+ */
+const STATIC_IMPLYING_OWNER_TYPES = new Set([
+    'companion_object',
+    'object_declaration',
+    'singleton_class',
+]);
 /**
  * Create a MethodExtractor from a declarative config.
+ *
+ * @throws {Error} if `typeDeclarationNodes` contains a static-implying owner
+ *   type (companion_object / object_declaration / singleton_class) that is
+ *   not covered by `staticOwnerTypes`. The guard fires once per language at
+ *   provider construction to prevent silent `isStatic=false` regressions. See
+ *   `STATIC_IMPLYING_OWNER_TYPES` for the exact opt-out convention.
  */
 export function createMethodExtractor(config) {
+    // Runtime invariant: each static-implying container type declared in
+    // typeDeclarationNodes must be covered by staticOwnerTypes. An explicit
+    // empty Set is treated as intentional opt-out.
+    if (config.staticOwnerTypes === undefined) {
+        const missing = config.typeDeclarationNodes.filter((t) => STATIC_IMPLYING_OWNER_TYPES.has(t));
+        if (missing.length > 0) {
+            throw new Error(`[MethodExtractionConfig:${config.language}] typeDeclarationNodes includes static-implying owner type(s) ` +
+                `${JSON.stringify(missing)} but staticOwnerTypes is not set. Add ` +
+                `'staticOwnerTypes: new Set([${missing.map((t) => `'${t}'`).join(', ')}])' ` +
+                `to the config, or set 'staticOwnerTypes: new Set()' to opt out explicitly.`);
+        }
+    }
+    else {
+        const missing = config.typeDeclarationNodes.filter((t) => STATIC_IMPLYING_OWNER_TYPES.has(t) && !config.staticOwnerTypes.has(t));
+        // Explicit empty Set is the opt-out signal; don't second-guess it.
+        if (missing.length > 0 && config.staticOwnerTypes.size > 0) {
+            throw new Error(`[MethodExtractionConfig:${config.language}] typeDeclarationNodes includes static-implying owner type(s) ` +
+                `${JSON.stringify(missing)} that are missing from staticOwnerTypes. ` +
+                `Either add them to staticOwnerTypes, or set 'staticOwnerTypes: new Set()' to opt out explicitly.`);
+        }
+    }
     const typeDeclarationSet = new Set(config.typeDeclarationNodes);
     const methodNodeSet = new Set(config.methodNodeTypes);
     const bodyNodeSet = new Set(config.bodyNodeTypes);
@@ -16,18 +59,26 @@ export function createMethodExtractor(config) {
         extract(node, context) {
             if (!typeDeclarationSet.has(node.type))
                 return null;
-            // Resolve owner name: field-based → type_identifier → simple_identifier → "Companion"
+            // Resolve owner name: config hook → field-based → type_identifier → simple_identifier → "Companion"
             let ownerName;
-            const nameField = node.childForFieldName('name');
-            if (nameField) {
-                ownerName = nameField.text;
+            if (config.extractOwnerName) {
+                ownerName = config.extractOwnerName(node);
             }
-            else {
-                for (let i = 0; i < node.namedChildCount; i++) {
-                    const child = node.namedChild(i);
-                    if (child && (child.type === 'type_identifier' || child.type === 'simple_identifier')) {
-                        ownerName = child.text;
-                        break;
+            if (!ownerName) {
+                const nameField = node.childForFieldName('name');
+                if (nameField) {
+                    ownerName = nameField.text;
+                }
+                else {
+                    for (let i = 0; i < node.namedChildCount; i++) {
+                        const child = node.namedChild(i);
+                        if (child &&
+                            (child.type === 'type_identifier' ||
+                                child.type === 'simple_identifier' ||
+                                child.type === 'identifier')) {
+                            ownerName = child.text;
+                            break;
+                        }
                     }
                 }
             }
@@ -50,6 +101,12 @@ export function createMethodExtractor(config) {
             }
             return { ownerName, methods };
         },
+        extractFromNode(node, context) {
+            if (!methodNodeSet.has(node.type))
+                return null;
+            return buildMethod(node, node, context, config);
+        },
+        ...(config.extractFunctionName ? { extractFunctionName: config.extractFunctionName } : {}),
     };
 }
 function findBodies(node, bodyNodeSet) {
@@ -77,19 +134,27 @@ function findBodies(node, bodyNodeSet) {
     }
     return result;
 }
-function addNestedBodies(parent, bodyNodeSet, out) {
+function addNestedBodies(parent, bodyNodeSet, out, seen) {
+    const visited = seen ?? new Set(out);
     for (let i = 0; i < parent.namedChildCount; i++) {
         const child = parent.namedChild(i);
-        if (child && bodyNodeSet.has(child.type) && !out.includes(child)) {
+        if (child && bodyNodeSet.has(child.type) && !visited.has(child)) {
+            visited.add(child);
             out.push(child);
         }
     }
 }
 function extractMethodsFromBody(body, ownerNode, context, config, methodNodeSet, out) {
     for (let i = 0; i < body.namedChildCount; i++) {
-        const child = body.namedChild(i);
+        let child = body.namedChild(i);
         if (!child)
             continue;
+        // C++ template methods are wrapped in template_declaration — unwrap to the inner node
+        if (child.type === 'template_declaration') {
+            const inner = child.namedChildren.find((c) => methodNodeSet.has(c.type));
+            if (inner)
+                child = inner;
+        }
         if (methodNodeSet.has(child.type)) {
             const method = buildMethod(child, ownerNode, context, config);
             if (method)
@@ -115,8 +180,9 @@ function buildMethod(node, ownerNode, context, config) {
     // Domain invariant: abstract methods cannot be final
     if (isAbstract)
         isFinal = false;
-    // companion_object / object_declaration members are effectively static on JVM
-    const isStatic = STATIC_OWNER_TYPES.has(ownerNode.type) || config.isStatic(node);
+    // Static-owner detection is config-driven: each language declares which
+    // container node types imply static (e.g. Ruby singleton_class, Kotlin companion_object).
+    const isStatic = (config.staticOwnerTypes?.has(ownerNode.type) ?? false) || config.isStatic(node);
     return {
         name,
         receiverType: config.extractReceiverType?.(node) ?? null,
@@ -130,6 +196,7 @@ function buildMethod(node, ownerNode, context, config) {
         ...(config.isOverride?.(node) ? { isOverride: true } : {}),
         ...(config.isAsync?.(node) ? { isAsync: true } : {}),
         ...(config.isPartial?.(node) ? { isPartial: true } : {}),
+        ...(config.isConst?.(node) ? { isConst: true } : {}),
         annotations: config.extractAnnotations?.(node) ?? [],
         sourceFile: context.filePath,
         line: node.startPosition.row + 1,

package/dist/core/ingestion/method-types.d.ts

@@ -5,6 +5,10 @@ export type MethodVisibility = FieldVisibility;
 export interface ParameterInfo {
     name: string;
     type: string | null;
+    /** Full type text including generic/template args (e.g. 'vector<int>', 'List<String>').
+     *  Used by typeTagForId for overload disambiguation where generic args matter.
+     *  Falls back to `type` when not set. */
+    rawType?: string | null;
     isOptional: boolean;
     isVariadic: boolean;
 }
@@ -21,6 +25,7 @@ export interface MethodInfo {
     isOverride?: boolean;
     isAsync?: boolean;
     isPartial?: boolean;
+    isConst?: boolean;
     annotations: string[];
     sourceFile: string;
     line: number;
@@ -37,6 +42,17 @@ export interface MethodExtractor {
     language: SupportedLanguages;
     extract(node: SyntaxNode, context: MethodExtractorContext): ExtractedMethods | null;
     isTypeDeclaration(node: SyntaxNode): boolean;
+    /** Extract method info from a standalone method node (e.g. Go top-level method_declaration). */
+    extractFromNode?(node: SyntaxNode, context: MethodExtractorContext): MethodInfo | null;
+    /** Extract function name + label from an AST node during parent-walk.
+     *  Languages with non-standard AST structures (e.g. C/C++ declarator
+     *  unwrapping, Swift init/deinit, Rust impl_item) provide this hook
+     *  to replace the generic name-field lookup.
+     *  Return null to fall through to the generic extractor. */
+    extractFunctionName?(node: SyntaxNode): {
+        funcName: string | null;
+        label: import('../../_shared/index.js').NodeLabel;
+    } | null;
 }
 export interface MethodExtractionConfig {
     language: SupportedLanguages;
@@ -56,6 +72,19 @@ export interface MethodExtractionConfig {
     isOverride?: (node: SyntaxNode) => boolean;
     isAsync?: (node: SyntaxNode) => boolean;
     isPartial?: (node: SyntaxNode) => boolean;
+    isConst?: (node: SyntaxNode) => boolean;
+    /** Owner node types where member functions are effectively static (e.g.
+     *  Ruby singleton_class, Kotlin companion_object / object_declaration).
+     *  When the ownerNode matches one of these types, isStatic is forced true. */
+    staticOwnerTypes?: ReadonlySet<string>;
+    /** Resolve the owner name from a standalone method node (e.g. Go receiver type). */
+    extractOwnerName?: (node: SyntaxNode) => string | undefined;
     /** Extract a primary constructor from the owner node itself (e.g. C# 12 class Point(int x, int y)). */
     extractPrimaryConstructor?: (ownerNode: SyntaxNode, context: MethodExtractorContext) => MethodInfo | null;
+    /** Extract function name + label from an AST node during parent-walk.
+     *  Passed through to the MethodExtractor by createMethodExtractor. */
+    extractFunctionName?: (node: SyntaxNode) => {
+        funcName: string | null;
+        label: import('../../_shared/index.js').NodeLabel;
+    } | null;
 }