cgraphx 2.0.2 → 2.0.3

package/dist/core/code/engine/core/ingestion/method-extractors/configs/rust.js

@@ -0,0 +1,198 @@
+"use strict";
+// cgraph/src/core/ingestion/method-extractors/configs/rust.ts
+// Verified against tree-sitter-rust 0.23.1
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rustMethodConfig = void 0;
+const index_js_1 = require("../../../../../shared/index.js");
+const shared_js_1 = require("../../type-extractors/shared.js");
+// ---------------------------------------------------------------------------
+// Rust helpers
+// ---------------------------------------------------------------------------
+/**
+ * Extract method name from function_item or function_signature_item.
+ * Both use a `name` field containing an identifier.
+ */
+function extractRustMethodName(node) {
+    const nameNode = node.childForFieldName('name');
+    return nameNode?.text;
+}
+/**
+ * Extract return type from the `return_type` field.
+ * tree-sitter-rust puts the return type (after `->`) as the `return_type` field.
+ */
+function extractRustReturnType(node) {
+    const typeNode = node.childForFieldName('return_type');
+    if (!typeNode)
+        return undefined;
+    return typeNode.text?.trim();
+}
+/**
+ * Extract parameters, skipping the self_parameter (handled by extractReceiverType).
+ *
+ * Rust parameters use `pattern` and `type` fields:
+ *   parameter { pattern: identifier, type: primitive_type }
+ */
+function extractRustParameters(node) {
+    const paramList = node.childForFieldName('parameters');
+    if (!paramList)
+        return [];
+    const params = [];
+    for (let i = 0; i < paramList.namedChildCount; i++) {
+        const param = paramList.namedChild(i);
+        if (!param)
+            continue;
+        // Skip self_parameter — it is the receiver, not a regular parameter
+        if (param.type === 'self_parameter')
+            continue;
+        if (param.type === 'parameter') {
+            const patternNode = param.childForFieldName('pattern');
+            const typeNode = param.childForFieldName('type');
+            params.push({
+                name: patternNode?.text ?? '?',
+                type: typeNode ? ((0, shared_js_1.extractSimpleTypeName)(typeNode) ?? typeNode.text?.trim() ?? null) : null,
+                rawType: typeNode?.text?.trim() ?? null,
+                isOptional: false,
+                isVariadic: false,
+            });
+        }
+    }
+    return params;
+}
+/**
+ * Detect visibility from visibility_modifier named child.
+ * `pub`, `pub(crate)`, `pub(super)`, `pub(in path)` → public.
+ * Absence → private (Rust default).
+ */
+function extractRustVisibility(node) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type === 'visibility_modifier')
+            return 'public';
+    }
+    return 'private';
+}
+/**
+ * Detect receiver type from the first parameter if it is a self_parameter.
+ *
+ * Variants:
+ *   - `self`       → "self"
+ *   - `&self`      → "&self"
+ *   - `&mut self`  → "&mut self"
+ *   - `mut self`   → "mut self"
+ *   - `self: Box<Self>` → "Box<Self>" (explicit self type)
+ */
+function extractRustReceiverType(node) {
+    const paramList = node.childForFieldName('parameters');
+    if (!paramList)
+        return undefined;
+    const first = paramList.namedChild(0);
+    if (!first || first.type !== 'self_parameter')
+        return undefined;
+    return first.text;
+}
+/**
+ * Check whether a function_item has the `async` keyword.
+ * tree-sitter-rust wraps it in a `function_modifiers` named child.
+ */
+function isRustAsync(node) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type === 'function_modifiers' && child.text.includes('async'))
+            return true;
+    }
+    return false;
+}
+/**
+ * Extract attributes from preceding sibling attribute_item nodes.
+ *
+ * In tree-sitter-rust, `#[inline]` is an `attribute_item` sibling that precedes
+ * the function_item in the declaration_list, not a child of the function_item.
+ */
+function extractRustAnnotations(node) {
+    const annotations = [];
+    let sibling = node.previousNamedSibling;
+    while (sibling) {
+        if (sibling.type === 'attribute_item') {
+            annotations.unshift(sibling.text);
+        }
+        else {
+            // Stop at the first non-attribute sibling — attributes are contiguous
+            break;
+        }
+        sibling = sibling.previousNamedSibling;
+    }
+    return annotations;
+}
+// ---------------------------------------------------------------------------
+// Rust config
+// ---------------------------------------------------------------------------
+// Rust methods live inside `impl` blocks (concrete implementations) or
+// `trait` blocks (trait definitions with required/default methods).
+//
+// `impl_item` body contains `function_item` nodes for concrete methods.
+// `trait_item` body contains `function_item` (default methods) and
+// `function_signature_item` (required/abstract methods without a body).
+//
+// ownerName resolution: `impl_item` has no `name` field — the generic
+// extractor falls back to the first `type_identifier` child, which is the
+// implementing type (e.g. `impl MyStruct { ... }` → "MyStruct").
+// `trait_item` uses the standard `name` field.
+//
+// Known gaps:
+//   - Macro-generated methods (e.g. derive) are not visible in the AST.
+//   - Unsafe methods are not distinguished (no isUnsafe field in schema).
+exports.rustMethodConfig = {
+    language: index_js_1.SupportedLanguages.Rust,
+    typeDeclarationNodes: ['impl_item', 'trait_item'],
+    methodNodeTypes: ['function_item', 'function_signature_item'],
+    bodyNodeTypes: ['declaration_list'],
+    // For `impl Trait for Struct`, resolve owner to the concrete Struct (after `for`).
+    // For plain `impl Struct`, resolve to Struct (first type_identifier).
+    // For `trait Foo`, let the default name-field resolution handle it.
+    extractOwnerName(node) {
+        if (node.type !== 'impl_item')
+            return undefined;
+        const children = node.children ?? [];
+        const forIdx = children.findIndex((c) => c.text === 'for');
+        if (forIdx !== -1) {
+            // impl Trait for Struct — pick the type after `for`
+            const typeNode = children
+                .slice(forIdx + 1)
+                .find((c) => c.type === 'type_identifier' || c.type === 'scoped_type_identifier');
+            if (typeNode)
+                return typeNode.text;
+        }
+        // Plain `impl Struct` — pick the first type_identifier
+        const first = children.find((c) => c.type === 'type_identifier');
+        return first?.text;
+    },
+    extractName: extractRustMethodName,
+    extractReturnType: extractRustReturnType,
+    extractParameters: extractRustParameters,
+    extractVisibility: extractRustVisibility,
+    isStatic(node) {
+        // A Rust method is an "associated function" (static) if it lacks a
+        // self_parameter as first parameter.
+        const paramList = node.childForFieldName('parameters');
+        if (!paramList)
+            return true;
+        const first = paramList.namedChild(0);
+        return !first || first.type !== 'self_parameter';
+    },
+    isAbstract(node, ownerNode) {
+        // Only trait methods without a body (function_signature_item) are abstract.
+        // function_signature_item never has a body field.
+        if (ownerNode.type === 'trait_item' && node.type === 'function_signature_item') {
+            return true;
+        }
+        return false;
+    },
+    isFinal() {
+        // Rust has no `final` concept — all methods are effectively sealed
+        // (traits cannot be "overridden" the way Java methods can).
+        return false;
+    },
+    extractAnnotations: extractRustAnnotations,
+    extractReceiverType: extractRustReceiverType,
+    isAsync: isRustAsync,
+};

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

@@ -0,0 +1,286 @@
+"use strict";
+// cgraph/src/core/ingestion/method-extractors/configs/swift.ts
+// Verified against tree-sitter-swift 0.7.x
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.swiftMethodConfig = void 0;
+const index_js_1 = require("../../../../../shared/index.js");
+const helpers_js_1 = require("../../field-extractors/configs/helpers.js");
+const shared_js_1 = require("../../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, 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 = (0, shared_js_1.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 = (0, shared_js_1.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
+// ---------------------------------------------------------------------------
+exports.swiftMethodConfig = {
+    language: index_js_1.SupportedLanguages.Swift,
+    // tree-sitter-swift collapses class / struct / enum / extension / actor into a
+    // single `class_declaration` node (distinguished by the `declaration_kind`
+    // field) — verified by real parse. There is NO separate `enum_declaration`
+    // node type, so it must NOT be listed here (it would fail the grammar-drift
+    // gate). The enum's owner node is therefore already covered by
+    // `class_declaration`; F79 only needed the enum BODY node added below.
+    // 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'],
+    // class_body for class/struct/extension/actor, protocol_body for protocols,
+    // enum_class_body for enums (F79). Without enum_class_body the factory only
+    // reached enum methods via the generic findBodies fallback, which logs a
+    // dev-mode "body field type not in bodyNodeTypes" warning.
+    bodyNodeTypes: ['class_body', 'protocol_body', 'enum_class_body'],
+    extractName: extractSwiftName,
+    extractReturnType: extractSwiftReturnType,
+    extractParameters: extractSwiftParameters,
+    extractVisibility(node) {
+        return (0, helpers_js_1.findVisibility)(node, SWIFT_VIS, 'internal', 'modifiers');
+    },
+    isStatic(node) {
+        return ((0, helpers_js_1.hasKeyword)(node, 'static') ||
+            (0, helpers_js_1.hasKeyword)(node, 'class') ||
+            (0, helpers_js_1.hasModifier)(node, 'modifiers', 'static') ||
+            (0, helpers_js_1.hasModifier)(node, 'modifiers', 'class'));
+    },
+    isAbstract: isSwiftAbstract,
+    isFinal(node) {
+        return (0, helpers_js_1.hasKeyword)(node, 'final') || (0, helpers_js_1.hasModifier)(node, 'modifiers', 'final');
+    },
+    isAsync(node) {
+        return (0, helpers_js_1.hasKeyword)(node, 'async') || (0, helpers_js_1.hasModifier)(node, 'modifiers', 'async');
+    },
+    isOverride(node) {
+        return (0, helpers_js_1.hasKeyword)(node, 'override') || (0, helpers_js_1.hasModifier)(node, 'modifiers', 'override');
+    },
+    extractAnnotations: extractSwiftAnnotations,
+};