cgraphx 2.0.1 → 2.0.3

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

@@ -0,0 +1,350 @@
+"use strict";
+// cgraph/src/core/ingestion/method-extractors/configs/jvm.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kotlinMethodConfig = exports.javaMethodConfig = 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");
+// ---------------------------------------------------------------------------
+// Shared JVM helpers
+// ---------------------------------------------------------------------------
+const INTERFACE_OWNER_TYPES = new Set(['interface_declaration', 'annotation_type_declaration']);
+function extractReturnTypeFromField(node) {
+    const typeNode = node.childForFieldName('type');
+    if (!typeNode)
+        return undefined;
+    // Use .text to preserve full generic types (e.g. List<User>, Stream<T>)
+    // needed by the call resolver for return-type inference.
+    return typeNode.text?.trim();
+}
+// `extractAnnotations` moved to `field-extractors/configs/helpers.js` (PR
+// #2200 U2) so the field extractor shares the identical walk.
+// ---------------------------------------------------------------------------
+// Java
+// ---------------------------------------------------------------------------
+const JAVA_VIS = new Set(['public', 'private', 'protected']);
+function extractJavaParameters(node) {
+    const params = [];
+    let paramList = node.childForFieldName('parameters');
+    // Compact constructors have no parameter list — inherit from parent record_declaration
+    if (!paramList && node.type === 'compact_constructor_declaration') {
+        const recordNode = node.parent?.parent; // compact_ctor → class_body → record_declaration
+        if (recordNode?.type === 'record_declaration') {
+            paramList = recordNode.childForFieldName('parameters');
+        }
+    }
+    if (!paramList)
+        return params;
+    for (let i = 0; i < paramList.namedChildCount; i++) {
+        const param = paramList.namedChild(i);
+        if (!param)
+            continue;
+        if (param.type === 'formal_parameter') {
+            const nameNode = param.childForFieldName('name');
+            const typeNode = param.childForFieldName('type');
+            if (nameNode) {
+                params.push({
+                    name: nameNode.text,
+                    type: typeNode ? ((0, shared_js_1.extractSimpleTypeName)(typeNode) ?? typeNode.text?.trim()) : null,
+                    rawType: typeNode?.text?.trim() ?? null,
+                    isOptional: false,
+                    isVariadic: false,
+                });
+            }
+        }
+        else if (param.type === 'spread_parameter') {
+            // Varargs: type_identifier + "..." + variable_declarator
+            let paramName;
+            let paramType = null;
+            let paramRawType = null;
+            for (let j = 0; j < param.namedChildCount; j++) {
+                const c = param.namedChild(j);
+                if (!c)
+                    continue;
+                if (c.type === 'variable_declarator') {
+                    const nameChild = c.childForFieldName('name');
+                    paramName = nameChild?.text ?? c.text;
+                }
+                else if (c.type === 'type_identifier' ||
+                    c.type === 'generic_type' ||
+                    c.type === 'scoped_type_identifier' ||
+                    c.type === 'integral_type' ||
+                    c.type === 'floating_point_type' ||
+                    c.type === 'boolean_type') {
+                    paramRawType = c.text?.trim() ?? null;
+                    paramType = (0, shared_js_1.extractSimpleTypeName)(c) ?? paramRawType;
+                }
+            }
+            if (paramName) {
+                params.push({
+                    name: paramName,
+                    type: paramType,
+                    rawType: paramRawType,
+                    isOptional: false,
+                    isVariadic: true,
+                });
+            }
+        }
+    }
+    return params;
+}
+exports.javaMethodConfig = {
+    language: index_js_1.SupportedLanguages.Java,
+    typeDeclarationNodes: [
+        'class_declaration',
+        'interface_declaration',
+        'enum_declaration',
+        'record_declaration',
+        'annotation_type_declaration',
+    ],
+    methodNodeTypes: [
+        'method_declaration',
+        'constructor_declaration',
+        'compact_constructor_declaration',
+        'annotation_type_element_declaration',
+    ],
+    bodyNodeTypes: [
+        'class_body',
+        'interface_body',
+        'enum_body',
+        'enum_body_declarations',
+        'annotation_type_body',
+    ],
+    extractName(node) {
+        const nameNode = node.childForFieldName('name');
+        return nameNode?.text;
+    },
+    extractReturnType: extractReturnTypeFromField,
+    extractParameters: extractJavaParameters,
+    extractVisibility(node) {
+        return (0, helpers_js_1.findVisibility)(node, JAVA_VIS, 'package', 'modifiers');
+    },
+    isStatic(node) {
+        return (0, helpers_js_1.hasModifier)(node, 'modifiers', 'static');
+    },
+    isAbstract(node, ownerNode) {
+        if ((0, helpers_js_1.hasModifier)(node, 'modifiers', 'abstract'))
+            return true;
+        // Interface methods are implicitly abstract unless they have a body (default methods)
+        if (INTERFACE_OWNER_TYPES.has(ownerNode.type)) {
+            const body = node.childForFieldName('body');
+            return !body;
+        }
+        return false;
+    },
+    isFinal(node) {
+        return (0, helpers_js_1.hasModifier)(node, 'modifiers', 'final');
+    },
+    extractAnnotations(node) {
+        return (0, helpers_js_1.extractAnnotations)(node, 'modifiers');
+    },
+};
+// ---------------------------------------------------------------------------
+// Kotlin
+// ---------------------------------------------------------------------------
+const KOTLIN_VIS = new Set(['public', 'private', 'protected', 'internal']);
+function kotlinParameterHasDefaultValue(param) {
+    // tree-sitter-kotlin inlines `_function_value_parameter`, so `=` and its
+    // expression are siblings of `parameter`, not children of the parameter.
+    for (let sibling = param.nextSibling; sibling !== null; sibling = sibling.nextSibling) {
+        if (sibling.type === ',' || sibling.type === ')')
+            return false;
+        if (sibling.type === '=')
+            return true;
+    }
+    return false;
+}
+/**
+ * Member name for a Kotlin method node. A `secondary_constructor`
+ * (`constructor(...) { }`) has no name child — its only identity token is
+ * the anonymous `constructor` keyword — so it is named "constructor" (F48,
+ * issue #1919), matching the @name the KOTLIN_QUERIES structure rule captures
+ * off that keyword so method-extractor enrichment keys (`name:line`) align.
+ * Multiple secondary constructors collide on this name but are disambiguated
+ * downstream by the `#<arity>` ID suffix the worker appends to Constructors.
+ */
+function extractKotlinMethodName(node) {
+    if (node.type === 'secondary_constructor')
+        return 'constructor';
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type === 'simple_identifier')
+            return child.text;
+    }
+    return undefined;
+}
+function extractKotlinParameters(node) {
+    const params = [];
+    // Kotlin: function_declaration / secondary_constructor >
+    // function_value_parameters > parameter. Both node types nest the
+    // parameter list the same way, so the same walk extracts a secondary
+    // constructor's parameters (F48).
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child && child.type === 'function_value_parameters') {
+            let nextIsVariadic = false;
+            for (let j = 0; j < child.namedChildCount; j++) {
+                const param = child.namedChild(j);
+                if (!param)
+                    continue;
+                // parameter_modifiers containing vararg precedes the parameter node
+                if (param.type === 'parameter_modifiers') {
+                    for (let m = 0; m < param.namedChildCount; m++) {
+                        const mod = param.namedChild(m);
+                        if (mod && mod.text === 'vararg')
+                            nextIsVariadic = true;
+                    }
+                    continue;
+                }
+                if (param.type !== 'parameter')
+                    continue;
+                let paramName;
+                let paramType = null;
+                let paramRawType = null;
+                const isVariadic = nextIsVariadic;
+                nextIsVariadic = false;
+                for (let k = 0; k < param.namedChildCount; k++) {
+                    const part = param.namedChild(k);
+                    if (!part)
+                        continue;
+                    if (part.type === 'simple_identifier') {
+                        paramName = part.text;
+                    }
+                    else if (part.type === 'user_type' ||
+                        part.type === 'nullable_type' ||
+                        part.type === 'function_type') {
+                        paramRawType = part.text?.trim() ?? null;
+                        paramType = (0, shared_js_1.extractSimpleTypeName)(part) ?? paramRawType;
+                    }
+                }
+                if (paramName) {
+                    params.push({
+                        name: paramName,
+                        type: paramType,
+                        rawType: paramRawType,
+                        isOptional: kotlinParameterHasDefaultValue(param),
+                        isVariadic: isVariadic,
+                    });
+                }
+            }
+            break;
+        }
+    }
+    return params;
+}
+function extractKotlinReturnType(node) {
+    // Kotlin: return type appears after `:` following the parameter list
+    // In tree-sitter-kotlin, it's a user_type/nullable_type child after function_value_parameters
+    let seenParams = false;
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (!child)
+            continue;
+        if (child.type === 'function_value_parameters') {
+            seenParams = true;
+            continue;
+        }
+        if (seenParams &&
+            (child.type === 'user_type' ||
+                child.type === 'nullable_type' ||
+                child.type === 'function_type')) {
+            return child.text?.trim();
+        }
+        if (child.type === 'function_body')
+            break;
+    }
+    return undefined;
+}
+exports.kotlinMethodConfig = {
+    language: index_js_1.SupportedLanguages.Kotlin,
+    typeDeclarationNodes: ['class_declaration', 'object_declaration', 'companion_object'],
+    methodNodeTypes: ['function_declaration', 'secondary_constructor'],
+    bodyNodeTypes: ['class_body'],
+    staticOwnerTypes: new Set(['companion_object', 'object_declaration']),
+    extractName: extractKotlinMethodName,
+    extractReturnType: extractKotlinReturnType,
+    extractParameters: extractKotlinParameters,
+    extractVisibility(node) {
+        return (0, helpers_js_1.findVisibility)(node, KOTLIN_VIS, 'public', 'modifiers');
+    },
+    isStatic(_node) {
+        // Kotlin has no static — companion object members are separate
+        return false;
+    },
+    isAbstract(node, ownerNode) {
+        if ((0, helpers_js_1.hasModifier)(node, 'modifiers', 'abstract'))
+            return true;
+        // Interface methods without a body are abstract
+        // Kotlin interfaces: class_declaration with "interface" keyword child
+        for (let i = 0; i < ownerNode.childCount; i++) {
+            const child = ownerNode.child(i);
+            if (child && child.text === 'interface') {
+                const body = node.childForFieldName('body');
+                // function_declaration > function_body
+                let hasBody = !!body;
+                if (!hasBody) {
+                    for (let j = 0; j < node.namedChildCount; j++) {
+                        const c = node.namedChild(j);
+                        if (c && c.type === 'function_body') {
+                            hasBody = true;
+                            break;
+                        }
+                    }
+                }
+                return !hasBody;
+            }
+        }
+        return false;
+    },
+    isFinal(node) {
+        // Kotlin functions are closed (final) by default — only open/abstract/override makes them overridable
+        if ((0, helpers_js_1.hasModifier)(node, 'modifiers', 'open'))
+            return false;
+        if ((0, helpers_js_1.hasModifier)(node, 'modifiers', 'abstract'))
+            return false;
+        if ((0, helpers_js_1.hasModifier)(node, 'modifiers', 'override'))
+            return false;
+        return true;
+    },
+    extractAnnotations(node) {
+        const annotations = [];
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child && child.type === 'modifiers') {
+                for (let j = 0; j < child.namedChildCount; j++) {
+                    const mod = child.namedChild(j);
+                    if (mod && mod.type === 'annotation') {
+                        // Kotlin annotation text includes the @ prefix
+                        const text = mod.text.trim();
+                        annotations.push(text.startsWith('@') ? text : '@' + text);
+                    }
+                }
+            }
+        }
+        return annotations;
+    },
+    extractReceiverType(node) {
+        // Extension function receiver. Newer tree-sitter-kotlin exposes it as a
+        // `receiver` field wrapping a `receiver_type` (which wraps the user_type);
+        // older grammars emitted a bare user_type/nullable_type child before the
+        // name (e.g. fun String.format(...) → receiver is "String").
+        const receiverField = node.childForFieldName('receiver');
+        if (receiverField) {
+            const inner = receiverField.namedChild(0) ?? receiverField;
+            return (0, shared_js_1.extractSimpleTypeName)(inner) ?? inner.text?.trim();
+        }
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (!child)
+                continue;
+            if (child.type === 'simple_identifier')
+                break; // past the name — no receiver
+            if (child.type === 'receiver_type' ||
+                child.type === 'user_type' ||
+                child.type === 'nullable_type') {
+                return (0, shared_js_1.extractSimpleTypeName)(child) ?? child.text?.trim();
+            }
+        }
+        return undefined;
+    },
+};

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

@@ -0,0 +1,306 @@
+"use strict";
+// cgraph/src/core/ingestion/method-extractors/configs/php.ts
+// Verified against tree-sitter-php 0.23.12
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.phpMethodConfig = void 0;
+const index_js_1 = require("../../../../../shared/index.js");
+const shared_js_1 = require("../../type-extractors/shared.js");
+// ---------------------------------------------------------------------------
+// PHP helpers
+// ---------------------------------------------------------------------------
+/** Regex to extract PHPDoc @return annotations: `@return User` */
+const PHPDOC_RETURN_RE = /@return\s+(\S+)/;
+/** Node types to skip when walking backwards through siblings for PHPDoc. */
+const PHPDOC_SKIP_NODE_TYPES = new Set(['attribute_list', 'attribute']);
+/**
+ * Normalize a PHPDoc return type for the MethodExtractor.
+ * Strips nullable prefix, null/false/void unions, namespace prefixes, and
+ * rejects uninformative types (mixed, void, self, static, object, array).
+ */
+function normalizePhpReturnType(raw) {
+    let type = raw.startsWith('?') ? raw.slice(1) : raw;
+    const parts = type
+        .split('|')
+        .filter((p) => p !== 'null' && p !== 'false' && p !== 'void' && p !== 'mixed');
+    if (parts.length !== 1)
+        return undefined;
+    type = parts[0];
+    const segments = type.split('\\');
+    type = segments[segments.length - 1];
+    if (type === 'mixed' ||
+        type === 'void' ||
+        type === 'self' ||
+        type === 'static' ||
+        type === 'object' ||
+        type === 'array')
+        return undefined;
+    if (/^\w+(\[\])?$/.test(type) || /^\w+\s*</.test(type))
+        return type;
+    return undefined;
+}
+/**
+ * Walk backwards through preceding siblings of `node` to find a PHPDoc
+ * `@return Type` annotation. Skips `attribute_list` nodes (PHP 8 attributes).
+ */
+function extractPhpDocReturnType(node) {
+    let sibling = node.previousSibling;
+    while (sibling) {
+        if (sibling.type === 'comment') {
+            const match = PHPDOC_RETURN_RE.exec(sibling.text);
+            if (match)
+                return normalizePhpReturnType(match[1]);
+        }
+        else if (sibling.isNamed && !PHPDOC_SKIP_NODE_TYPES.has(sibling.type)) {
+            break;
+        }
+        sibling = sibling.previousSibling;
+    }
+    return undefined;
+}
+const PHP_VIS = new Set(['public', 'private', 'protected']);
+/**
+ * Find the visibility keyword from a visibility_modifier named child.
+ * PHP tree-sitter emits `visibility_modifier` as a named node with text
+ * "public", "private", or "protected".
+ */
+function findPhpVisibility(node) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type === 'visibility_modifier') {
+            const text = child.text.trim();
+            if (PHP_VIS.has(text))
+                return text;
+        }
+    }
+    return 'public'; // PHP methods are public by default
+}
+/**
+ * Check for a named modifier child of a specific type.
+ * PHP tree-sitter uses distinct node types: abstract_modifier, final_modifier,
+ * static_modifier — rather than a wrapper `modifiers` node with keyword children.
+ */
+function hasModifierNode(node, modifierType) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type === modifierType)
+            return true;
+    }
+    return false;
+}
+/**
+ * Extract the return type from a PHP method_declaration node.
+ *
+ * In tree-sitter-php, the return type is not exposed via a named field.
+ * It appears as a type node (primitive_type, named_type, union_type,
+ * optional_type, nullable_type, intersection_type) after the formal_parameters
+ * and a `:` token separator.
+ *
+ * When the AST return type is missing or uninformative (`array` / `iterable`),
+ * falls back to parsing PHPDoc `@return Type` from preceding doc comments.
+ */
+function extractPhpReturnType(node) {
+    const TYPE_NODE_TYPES = new Set([
+        'primitive_type',
+        'named_type',
+        'union_type',
+        'optional_type',
+        'intersection_type',
+    ]);
+    let astType;
+    let seenParams = false;
+    for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (!child)
+            continue;
+        if (child.type === 'formal_parameters') {
+            seenParams = true;
+            continue;
+        }
+        // After the parameters node, look for the colon and then the type
+        if (seenParams && child.isNamed && TYPE_NODE_TYPES.has(child.type)) {
+            astType = child.text?.trim();
+            break;
+        }
+        // Stop at body or semicolon
+        if (child.type === 'compound_statement' || (!child.isNamed && child.text === ';')) {
+            break;
+        }
+    }
+    // If AST type is missing or uninformative, try PHPDoc @return fallback
+    if (!astType || astType === 'array' || astType === 'iterable') {
+        const docType = extractPhpDocReturnType(node);
+        if (docType)
+            return docType;
+    }
+    return astType;
+}
+/**
+ * Extract parameters from a PHP method_declaration node.
+ *
+ * PHP parameter types in tree-sitter-php:
+ * - `simple_parameter`: regular parameter with optional type and default
+ * - `variadic_parameter`: `...$param` with optional type
+ * - `property_promotion_parameter`: constructor promotion `private string $name`
+ *   (may also be variadic via an ERROR node containing `...`)
+ */
+function extractPhpParameters(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;
+        if (param.type === 'simple_parameter') {
+            const nameNode = param.childForFieldName('name');
+            if (!nameNode)
+                continue;
+            const typeNode = param.childForFieldName('type');
+            const typeName = typeNode ? ((0, shared_js_1.extractSimpleTypeName)(typeNode) ?? typeNode.text?.trim()) : null;
+            // Detect optional: '=' token among children indicates a default value
+            let isOptional = false;
+            for (let j = 0; j < param.childCount; j++) {
+                const c = param.child(j);
+                if (c && !c.isNamed && c.text === '=') {
+                    isOptional = true;
+                    break;
+                }
+            }
+            params.push({
+                name: stripDollar(nameNode.text),
+                type: typeName ?? null,
+                rawType: typeNode?.text?.trim() ?? null,
+                isOptional,
+                isVariadic: false,
+            });
+        }
+        else if (param.type === 'variadic_parameter') {
+            const nameNode = param.childForFieldName('name');
+            if (!nameNode)
+                continue;
+            const typeNode = param.childForFieldName('type');
+            const typeName = typeNode ? ((0, shared_js_1.extractSimpleTypeName)(typeNode) ?? typeNode.text?.trim()) : null;
+            params.push({
+                name: stripDollar(nameNode.text),
+                type: typeName ?? null,
+                rawType: typeNode?.text?.trim() ?? null,
+                isOptional: false,
+                isVariadic: true,
+            });
+        }
+        else if (param.type === 'property_promotion_parameter') {
+            const nameNode = param.childForFieldName('name');
+            if (!nameNode)
+                continue;
+            const typeNode = param.childForFieldName('type');
+            const typeName = typeNode ? ((0, shared_js_1.extractSimpleTypeName)(typeNode) ?? typeNode.text?.trim()) : null;
+            // Detect variadic: an ERROR child containing "..." indicates variadic promotion
+            let isVariadic = false;
+            for (let j = 0; j < param.childCount; j++) {
+                const c = param.child(j);
+                if (c && (c.text === '...' || (c.type === 'ERROR' && c.text === '...'))) {
+                    isVariadic = true;
+                    break;
+                }
+            }
+            params.push({
+                name: stripDollar(nameNode.text),
+                type: typeName ?? null,
+                rawType: typeNode?.text?.trim() ?? null,
+                isOptional: false,
+                isVariadic,
+            });
+        }
+    }
+    return params;
+}
+/** Strip leading $ from PHP variable names. */
+function stripDollar(name) {
+    return name.startsWith('$') ? name.slice(1) : name;
+}
+/**
+ * Extract PHP 8 attributes (#[...]) from a method_declaration node.
+ *
+ * AST structure: attribute_list → attribute_group → attribute → name child.
+ * Names are prefixed with '#' to distinguish from Java/Kotlin @ annotations.
+ */
+function extractPhpAnnotations(node) {
+    const annotations = [];
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (!child || child.type !== 'attribute_list')
+            continue;
+        for (let j = 0; j < child.namedChildCount; j++) {
+            const group = child.namedChild(j);
+            if (!group || group.type !== 'attribute_group')
+                continue;
+            for (let k = 0; k < group.namedChildCount; k++) {
+                const attr = group.namedChild(k);
+                if (!attr || attr.type !== 'attribute')
+                    continue;
+                const nameNode = attr.firstNamedChild;
+                if (nameNode && nameNode.type === 'name') {
+                    annotations.push('#' + nameNode.text);
+                }
+            }
+        }
+    }
+    return annotations;
+}
+// ---------------------------------------------------------------------------
+// PHP config
+// ---------------------------------------------------------------------------
+exports.phpMethodConfig = {
+    language: index_js_1.SupportedLanguages.PHP,
+    typeDeclarationNodes: [
+        'class_declaration',
+        'interface_declaration',
+        'trait_declaration',
+        'enum_declaration',
+    ],
+    methodNodeTypes: ['method_declaration', 'function_definition'],
+    bodyNodeTypes: ['declaration_list'],
+    extractName(node) {
+        return node.childForFieldName('name')?.text;
+    },
+    extractReturnType: extractPhpReturnType,
+    extractParameters: extractPhpParameters,
+    extractVisibility: findPhpVisibility,
+    isStatic(node) {
+        return hasModifierNode(node, 'static_modifier');
+    },
+    isAbstract(node, ownerNode) {
+        if (hasModifierNode(node, 'abstract_modifier'))
+            return true;
+        // Interface methods are implicitly abstract when they have no body.
+        // Check ownerNode first, then fall back to walking the parent chain
+        // (needed when called from extractFromNode where ownerNode === node).
+        let isInterface = ownerNode.type === 'interface_declaration';
+        if (!isInterface) {
+            let p = node.parent;
+            while (p) {
+                if (p.type === 'interface_declaration') {
+                    isInterface = true;
+                    break;
+                }
+                p = p.parent;
+            }
+        }
+        if (isInterface) {
+            const body = node.childForFieldName('body');
+            if (body)
+                return false;
+            for (let i = 0; i < node.namedChildCount; i++) {
+                if (node.namedChild(i)?.type === 'compound_statement')
+                    return false;
+            }
+            return true;
+        }
+        return false;
+    },
+    isFinal(node) {
+        return hasModifierNode(node, 'final_modifier');
+    },
+    extractAnnotations: extractPhpAnnotations,
+};