cgraphx 2.0.2 → 2.0.3

package/dist/core/code/engine/core/ingestion/languages/kotlin/spring-conditionals.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attachKotlinSpringConditionalMetadata = void 0;
+exports.captureKotlinSpringConditionalFacts = captureKotlinSpringConditionalFacts;
+const index_js_1 = require("../../../../../shared/index.js");
+const conditionals_js_1 = require("../../frameworks/spring/conditionals.js");
+const ast_helpers_js_1 = require("../../utils/ast-helpers.js");
+const capture_side_channel_js_1 = require("./capture-side-channel.js");
+const package_siblings_js_1 = require("./package-siblings.js");
+const spring_di_js_1 = require("./spring-di.js");
+function scopeId(filePath, node, kind) {
+    return (0, index_js_1.makeScopeId)({
+        filePath,
+        range: (0, ast_helpers_js_1.nodeToCapture)('@spring-condition.owner', node).range,
+        kind,
+    });
+}
+/**
+ * Capture Kotlin condition syntax from the class node already surfaced by the
+ * scope query. Kotlin syntax stays local; shared Spring semantics are attached
+ * after resolution.
+ */
+function captureKotlinSpringConditionalFacts(classNode, filePath) {
+    const facts = [];
+    const classAnnotations = (0, spring_di_js_1.kotlinSpringAnnotationFacts)(classNode);
+    if ((0, conditionals_js_1.hasSpringConditionalRelevantAnnotation)(classAnnotations)) {
+        facts.push({
+            ownerScopeId: scopeId(filePath, classNode, 'Class'),
+            ownerKind: 'class',
+            annotations: classAnnotations,
+        });
+    }
+    const body = classNode.namedChildren.find((child) => child.type === 'class_body');
+    if (body === undefined)
+        return facts;
+    for (const member of body.namedChildren) {
+        if (member.type !== 'function_declaration')
+            continue;
+        const annotations = (0, spring_di_js_1.kotlinSpringAnnotationFacts)(member);
+        if (!(0, conditionals_js_1.hasSpringConditionalRelevantAnnotation)(annotations))
+            continue;
+        facts.push({
+            ownerScopeId: scopeId(filePath, member, 'Function'),
+            ownerKind: 'callable',
+            annotations,
+        });
+    }
+    return facts;
+}
+exports.attachKotlinSpringConditionalMetadata = (0, conditionals_js_1.createSpringConditionalMetadataAttacher)({
+    getFacts: capture_side_channel_js_1.getKotlinSpringConditionalFacts,
+    isPackageVisibilityIncomplete: package_siblings_js_1.isKotlinPackageSiblingVisibilityIncomplete,
+});

package/dist/core/code/engine/core/ingestion/languages/kotlin/spring-di.js

@@ -0,0 +1,304 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attachKotlinSpringDiMetadata = void 0;
+exports.kotlinSpringAnnotationFacts = kotlinSpringAnnotationFacts;
+exports.captureKotlinSpringDiClassFact = captureKotlinSpringDiClassFact;
+const index_js_1 = require("../../../../../shared/index.js");
+const spring_js_1 = require("../../di-extractors/spring.js");
+const di_metadata_js_1 = require("../../frameworks/spring/di-metadata.js");
+const bean_factories_js_1 = require("../../frameworks/spring/bean-factories.js");
+const ast_helpers_js_1 = require("../../utils/ast-helpers.js");
+const capture_side_channel_js_1 = require("./capture-side-channel.js");
+const package_siblings_js_1 = require("./package-siblings.js");
+const KOTLIN_TYPE_NODES = new Set(['user_type', 'nullable_type', 'function_type']);
+function firstDescendantOfType(node, type) {
+    const stack = [...node.namedChildren].reverse();
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (current === undefined)
+            continue;
+        if (current.type === type)
+            return current;
+        for (let index = current.namedChildren.length - 1; index >= 0; index--) {
+            const child = current.namedChildren[index];
+            if (child !== undefined)
+                stack.push(child);
+        }
+    }
+    return undefined;
+}
+function annotationFact(annotation) {
+    const nameNode = firstDescendantOfType(annotation, 'user_type');
+    if (nameNode === undefined)
+        return null;
+    const useSiteTarget = annotation.namedChildren
+        .find((child) => child.type === 'use_site_target')
+        ?.text.replace(/:\s*$/, '')
+        .trim();
+    return {
+        name: nameNode.text.trim(),
+        text: annotation.text.trim(),
+        line: annotation.startPosition.row + 1,
+        ...(useSiteTarget === undefined || useSiteTarget.length === 0 ? {} : { useSiteTarget }),
+    };
+}
+function annotationsFromModifierContainer(node) {
+    const facts = [];
+    for (const child of node.namedChildren) {
+        if (child.type !== 'annotation')
+            continue;
+        const fact = annotationFact(child);
+        if (fact !== null)
+            facts.push(fact);
+    }
+    return facts;
+}
+function kotlinSpringAnnotationFacts(node) {
+    const facts = [];
+    for (const child of node.namedChildren) {
+        if (child.type !== 'modifiers' && child.type !== 'parameter_modifiers')
+            continue;
+        facts.push(...annotationsFromModifierContainer(child));
+    }
+    return facts;
+}
+function directTypeNode(node) {
+    return node.namedChildren.find((child) => KOTLIN_TYPE_NODES.has(child.type));
+}
+function kotlinBeanFactoryReturnType(functionNode) {
+    const parametersIndex = functionNode.namedChildren.findIndex((child) => child.type === 'function_value_parameters');
+    if (parametersIndex === -1)
+        return undefined;
+    const afterParameters = functionNode.namedChildren.slice(parametersIndex + 1);
+    const explicit = afterParameters.find((child) => KOTLIN_TYPE_NODES.has(child.type));
+    if (explicit !== undefined)
+        return explicit.text.trim();
+    const body = afterParameters.find((child) => !KOTLIN_TYPE_NODES.has(child.type));
+    if (body === undefined)
+        return undefined;
+    const call = body.type === 'call_expression' ? body : firstDescendantOfType(body, 'call_expression');
+    const callee = call?.namedChildren.find((child) => child.type === 'simple_identifier');
+    const inferred = callee?.text.trim();
+    return inferred !== undefined && /^[A-Z_$]/.test(inferred) ? inferred : undefined;
+}
+function parameterDependency(parameter, precedingAnnotations = []) {
+    const nameNode = parameter.namedChildren.find((child) => child.type === 'simple_identifier');
+    const typeNode = directTypeNode(parameter);
+    if (nameNode === undefined || typeNode === undefined)
+        return null;
+    return {
+        name: nameNode.text.trim(),
+        rawType: typeNode.text.trim(),
+        annotations: [...precedingAnnotations, ...kotlinSpringAnnotationFacts(parameter)],
+    };
+}
+function functionDependencies(callable) {
+    const parameters = callable.namedChildren.find((child) => child.type === 'function_value_parameters');
+    if (parameters === undefined)
+        return [];
+    const dependencies = [];
+    let pendingAnnotations = [];
+    for (const child of parameters.namedChildren) {
+        if (child.type === 'parameter_modifiers') {
+            pendingAnnotations = annotationsFromModifierContainer(child);
+            continue;
+        }
+        if (child.type !== 'parameter')
+            continue;
+        const dependency = parameterDependency(child, pendingAnnotations);
+        pendingAnnotations = [];
+        if (dependency !== null)
+            dependencies.push(dependency);
+    }
+    return dependencies;
+}
+function primaryConstructorDependencies(constructor) {
+    const dependencies = [];
+    for (const parameter of constructor.namedChildren) {
+        if (parameter.type !== 'class_parameter')
+            continue;
+        const dependency = parameterDependency(parameter);
+        if (dependency !== null)
+            dependencies.push(dependency);
+    }
+    return dependencies;
+}
+function propertyDependency(property) {
+    const variable = property.namedChildren.find((child) => child.type === 'variable_declaration');
+    if (variable === undefined)
+        return null;
+    const nameNode = variable.namedChildren.find((child) => child.type === 'simple_identifier');
+    const typeNode = directTypeNode(variable);
+    if (nameNode === undefined || typeNode === undefined)
+        return null;
+    const annotations = kotlinSpringAnnotationFacts(property);
+    return {
+        name: nameNode.text.trim(),
+        rawType: typeNode.text.trim(),
+        annotations,
+    };
+}
+function isKotlinBeanCandidateClass(classNode) {
+    if (classNode.children.some((child) => child.type === 'interface' || child.type === 'enum')) {
+        return false;
+    }
+    const modifiers = classNode.namedChildren.find((child) => child.type === 'modifiers');
+    return !modifiers?.namedChildren.some((child) => child.type === 'class_modifier' && child.text.trim() === 'annotation');
+}
+/**
+ * Capture one class already surfaced by Kotlin's scope query. Kotlin-specific
+ * syntax is normalized here while import/FQN semantics remain deferred until
+ * post-resolution.
+ */
+function captureKotlinSpringDiClassFact(classNode, filePath) {
+    if (!isKotlinBeanCandidateClass(classNode))
+        return null;
+    const classAnnotations = kotlinSpringAnnotationFacts(classNode);
+    const injectionSites = [];
+    const beanFactoryMethods = [];
+    const body = classNode.namedChildren.find((child) => child.type === 'class_body');
+    const primaryConstructor = classNode.namedChildren.find((child) => child.type === 'primary_constructor');
+    const secondaryConstructors = body?.namedChildren.filter((child) => child.type === 'secondary_constructor') ?? [];
+    const constructorCount = (primaryConstructor === undefined ? 0 : 1) + secondaryConstructors.length;
+    if (primaryConstructor !== undefined) {
+        const annotations = kotlinSpringAnnotationFacts(primaryConstructor);
+        const implicitConstructor = constructorCount === 1 &&
+            (0, di_metadata_js_1.hasSpringStereotypeSyntax)(classAnnotations) &&
+            !(0, di_metadata_js_1.hasSpringDiRelevantAnnotation)(annotations);
+        if (implicitConstructor || (0, di_metadata_js_1.hasSpringDiRelevantAnnotation)(annotations)) {
+            injectionSites.push({
+                kind: 'constructor',
+                memberName: '<primary-constructor>',
+                implicitConstructor,
+                annotations,
+                dependencies: primaryConstructorDependencies(primaryConstructor),
+            });
+        }
+    }
+    for (const constructor of secondaryConstructors) {
+        const annotations = kotlinSpringAnnotationFacts(constructor);
+        const implicitConstructor = constructorCount === 1 &&
+            (0, di_metadata_js_1.hasSpringStereotypeSyntax)(classAnnotations) &&
+            !(0, di_metadata_js_1.hasSpringDiRelevantAnnotation)(annotations);
+        if (!implicitConstructor && !(0, di_metadata_js_1.hasSpringDiRelevantAnnotation)(annotations))
+            continue;
+        injectionSites.push({
+            kind: 'constructor',
+            memberName: '<secondary-constructor>',
+            implicitConstructor,
+            annotations,
+            dependencies: functionDependencies(constructor),
+        });
+    }
+    if (body !== undefined) {
+        for (const member of body.namedChildren) {
+            if (member.type === 'property_declaration') {
+                const annotations = kotlinSpringAnnotationFacts(member);
+                if (!(0, di_metadata_js_1.hasSpringDiRelevantAnnotation)(annotations))
+                    continue;
+                const dependency = propertyDependency(member);
+                if (dependency === null)
+                    continue;
+                injectionSites.push({
+                    kind: 'property',
+                    memberName: dependency.name,
+                    implicitConstructor: false,
+                    annotations,
+                    dependencies: [dependency],
+                });
+            }
+            else if (member.type === 'function_declaration') {
+                const annotations = kotlinSpringAnnotationFacts(member);
+                const name = member.namedChildren.find((child) => child.type === 'simple_identifier')?.text.trim() ??
+                    '<method>';
+                const factoryAnnotations = annotations.filter((annotation) => annotation.useSiteTarget === undefined);
+                const beanFactory = (0, bean_factories_js_1.hasSpringBeanFactorySyntax)(factoryAnnotations);
+                if (beanFactory) {
+                    const callableCapture = (0, ast_helpers_js_1.nodeToCapture)('@spring-bean.factory', member);
+                    const returnType = kotlinBeanFactoryReturnType(member);
+                    beanFactoryMethods.push({
+                        callableScopeId: (0, index_js_1.makeScopeId)({
+                            filePath,
+                            range: callableCapture.range,
+                            kind: 'Function',
+                        }),
+                        methodName: name,
+                        ...(returnType === undefined ? {} : { returnType }),
+                        annotations: factoryAnnotations,
+                        dependencies: functionDependencies(member),
+                    });
+                }
+                // @Bean parameters are already represented on the factory Method. Do not
+                // also attach them to the owning configuration Class when the method has
+                // an otherwise relevant annotation such as @Autowired or @Qualifier.
+                if (beanFactory)
+                    continue;
+                if (!(0, di_metadata_js_1.hasSpringDiRelevantAnnotation)(annotations))
+                    continue;
+                injectionSites.push({
+                    kind: 'method',
+                    memberName: name,
+                    implicitConstructor: false,
+                    annotations,
+                    dependencies: functionDependencies(member),
+                });
+            }
+        }
+    }
+    if (injectionSites.length === 0 &&
+        beanFactoryMethods.length === 0 &&
+        !(0, di_metadata_js_1.hasSpringDiRelevantAnnotation)(classAnnotations)) {
+        return null;
+    }
+    const classCapture = (0, ast_helpers_js_1.nodeToCapture)('@spring-di.class', classNode);
+    return {
+        classScopeId: (0, index_js_1.makeScopeId)({ filePath, range: classCapture.range, kind: 'Class' }),
+        classAnnotations,
+        injectionSites,
+        ...(beanFactoryMethods.length === 0 ? {} : { beanFactoryMethods }),
+    };
+}
+function isApplicableInjectionAnnotation(annotation, site) {
+    if (annotation.useSiteTarget === undefined)
+        return true;
+    if (site.kind === 'constructor')
+        return annotation.useSiteTarget === 'constructor';
+    if (site.kind === 'property') {
+        return annotation.useSiteTarget === 'field' || annotation.useSiteTarget === 'set';
+    }
+    return false;
+}
+function isApplicableQualifierAnnotation(annotation, site) {
+    if (annotation.useSiteTarget === undefined)
+        return true;
+    if (site.kind === 'property') {
+        return (annotation.useSiteTarget === 'field' ||
+            annotation.useSiteTarget === 'param' ||
+            annotation.useSiteTarget === 'setparam');
+    }
+    return annotation.useSiteTarget === 'param';
+}
+function isApplicableFactoryQualifierAnnotation(annotation) {
+    return annotation.useSiteTarget === undefined || annotation.useSiteTarget === 'param';
+}
+function parseKotlinSpringInjectionType(rawType) {
+    // Kotlin nullable suffixes, type projections, and mutable collection aliases
+    // do not change the JVM bean type selected by Spring. Normalize only those
+    // surface forms; stars, function types, arrays, and nested generic elements
+    // still fail closed in the shared parser.
+    const normalized = rawType
+        .replace(/\bMutable(List|Set|Collection|Map)(?=\s*<)/g, '$1')
+        .replace(/([<,])\s*(?:out|in)\s+/g, '$1')
+        .replace(/\?(?=\s*(?:[>,]|$))/g, '');
+    return (0, spring_js_1.parseSpringInjectionType)(normalized);
+}
+/** Attach resolved, framework-private DI metadata to Kotlin Class nodes. */
+exports.attachKotlinSpringDiMetadata = (0, di_metadata_js_1.createSpringDiMetadataAttacher)({
+    getFacts: capture_side_channel_js_1.getKotlinSpringDiFacts,
+    isPackageVisibilityIncomplete: package_siblings_js_1.isKotlinPackageSiblingVisibilityIncomplete,
+    parseInjectionType: parseKotlinSpringInjectionType,
+    capturedMemberKind: 'property',
+    isInjectionAnnotationApplicable: isApplicableInjectionAnnotation,
+    isQualifierAnnotationApplicable: isApplicableQualifierAnnotation,
+    isFactoryQualifierAnnotationApplicable: isApplicableFactoryQualifierAnnotation,
+});

package/dist/core/code/engine/core/ingestion/languages/kotlin.js

@@ -0,0 +1,189 @@
+"use strict";
+/**
+ * Kotlin language provider.
+ *
+ * Kotlin uses named imports with JVM wildcard/member resolution and
+ * Java-interop fallback. Default visibility is public (no modifier needed).
+ * Heritage uses EXTENDS by default with implements-split MRO for
+ * multiple interface implementation.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kotlinProvider = void 0;
+const index_js_1 = require("../../../../shared/index.js");
+const generic_js_1 = require("../class-extractors/generic.js");
+const jvm_js_1 = require("../class-extractors/configs/jvm.js");
+const language_provider_js_1 = require("../language-provider.js");
+const ast_helpers_js_1 = require("../utils/ast-helpers.js");
+const clone_safety_js_1 = require("../workers/clone-safety.js");
+const jvm_js_2 = require("../type-extractors/jvm.js");
+const export_detection_js_1 = require("../export-detection.js");
+const resolver_factory_js_1 = require("../import-resolvers/resolver-factory.js");
+const jvm_js_3 = require("../import-resolvers/configs/jvm.js");
+const jvm_js_4 = require("../import-resolvers/jvm.js");
+const tree_sitter_queries_js_1 = require("../tree-sitter-queries.js");
+const generic_js_2 = require("../call-extractors/generic.js");
+const jvm_js_5 = require("../call-extractors/configs/jvm.js");
+const kotlin_js_1 = require("../cfg/visitors/kotlin.js");
+const generic_js_3 = require("../field-extractors/generic.js");
+const jvm_js_6 = require("../field-extractors/configs/jvm.js");
+const generic_js_4 = require("../method-extractors/generic.js");
+const jvm_js_7 = require("../method-extractors/configs/jvm.js");
+const generic_js_5 = require("../variable-extractors/generic.js");
+const jvm_js_8 = require("../variable-extractors/configs/jvm.js");
+const index_js_2 = require("./kotlin/index.js");
+/** Check if a Kotlin function_declaration capture is inside a class_body (i.e., a method).
+ *  Kotlin grammar uses function_declaration for both top-level functions and class methods.
+ *  Returns true when the captured definition node has a class_body ancestor. */
+function isKotlinClassMethod(captureNode) {
+    let ancestor = captureNode?.parent;
+    while (ancestor) {
+        if (ancestor.type === 'class_body')
+            return true;
+        ancestor = ancestor.parent;
+    }
+    return false;
+}
+const BUILT_INS = new Set([
+    'println',
+    'print',
+    'readLine',
+    'require',
+    'requireNotNull',
+    'check',
+    'assert',
+    'lazy',
+    'error',
+    'listOf',
+    'mapOf',
+    'setOf',
+    'mutableListOf',
+    'mutableMapOf',
+    'mutableSetOf',
+    'arrayOf',
+    'sequenceOf',
+    'also',
+    'apply',
+    'run',
+    'with',
+    'takeIf',
+    'takeUnless',
+    'TODO',
+    'buildString',
+    'buildList',
+    'buildMap',
+    'buildSet',
+    'repeat',
+    'synchronized',
+    'launch',
+    'async',
+    'runBlocking',
+    'withContext',
+    'coroutineScope',
+    'supervisorScope',
+    'delay',
+    'flow',
+    'flowOf',
+    'collect',
+    'emit',
+    'onEach',
+    'catch',
+    'buffer',
+    'conflate',
+    'distinctUntilChanged',
+    'flatMapLatest',
+    'flatMapMerge',
+    'combine',
+    'stateIn',
+    'shareIn',
+    'launchIn',
+    'to',
+    'until',
+    'downTo',
+    'step',
+]);
+exports.kotlinProvider = (0, language_provider_js_1.defineLanguage)({
+    id: index_js_1.SupportedLanguages.Kotlin,
+    extensions: ['.kt', '.kts'],
+    entryPointPatterns: [
+        /^on(Create|Start|Resume|Pause|Stop|Destroy)$/,
+        /^do[A-Z]/,
+        /^create[A-Z]/,
+        /^build[A-Z]/,
+        /ViewModel$/,
+        /^module$/,
+        /Service$/,
+    ],
+    astFrameworkPatterns: [
+        {
+            framework: 'spring-kotlin',
+            entryPointMultiplier: 3.2,
+            reason: 'spring-kotlin-annotation',
+            patterns: [
+                '@RestController',
+                '@Controller',
+                '@GetMapping',
+                '@PostMapping',
+                '@RequestMapping',
+            ],
+        },
+        {
+            framework: 'jaxrs',
+            entryPointMultiplier: 3.0,
+            reason: 'jaxrs-annotation',
+            patterns: ['@Path', '@GET', '@POST', '@PUT', '@DELETE'],
+        },
+        {
+            framework: 'ktor',
+            entryPointMultiplier: 2.8,
+            reason: 'ktor-routing',
+            patterns: ['routing', 'embeddedServer', 'Application.module'],
+        },
+        {
+            framework: 'android-kotlin',
+            entryPointMultiplier: 2.5,
+            reason: 'android-annotation',
+            patterns: ['@AndroidEntryPoint', 'AppCompatActivity', 'Fragment('],
+        },
+    ],
+    treeSitterQueries: tree_sitter_queries_js_1.KOTLIN_QUERIES,
+    typeConfig: jvm_js_2.kotlinTypeConfig,
+    exportChecker: export_detection_js_1.kotlinExportChecker,
+    importResolver: (0, resolver_factory_js_1.createImportResolver)(jvm_js_3.kotlinImportConfig),
+    importPathPreprocessor: jvm_js_4.appendKotlinWildcard,
+    mroStrategy: 'implements-split',
+    callExtractor: (0, generic_js_2.createCallExtractor)(jvm_js_5.kotlinCallConfig),
+    fieldExtractor: (0, generic_js_3.createFieldExtractor)(jvm_js_6.kotlinConfig),
+    methodExtractor: (0, generic_js_4.createMethodExtractor)(jvm_js_7.kotlinMethodConfig),
+    variableExtractor: (0, generic_js_5.createVariableExtractor)(jvm_js_8.kotlinVariableConfig),
+    classExtractor: (0, generic_js_1.createClassExtractor)(jvm_js_1.kotlinClassConfig),
+    builtInNames: BUILT_INS,
+    // ── KDoc → description (issue #2270) ──
+    descriptionExtractor: (0, ast_helpers_js_1.createLeadingDocDescriptionExtractor)(),
+    labelOverride: (functionNode, defaultLabel) => {
+        if (defaultLabel !== 'Function')
+            return defaultLabel;
+        if (isKotlinClassMethod(functionNode))
+            return 'Method';
+        return defaultLabel;
+    },
+    // ── RFC #909 Ring 3: scope-based resolution hooks ──
+    emitScopeCaptures: index_js_2.emitKotlinScopeCaptures,
+    // ── #2195 PDG layer: Kotlin CFG visitor (vendored grammar) ──
+    cfgVisitor: (0, kotlin_js_1.createKotlinCfgVisitor)(),
+    // Worker-side: snapshot companion-scope marks, package visibility, class
+    // annotations, and Spring DI facts `emitKotlinScopeCaptures` just populated
+    // into plain data on `ParsedFile.captureSideChannel`, so the main thread can
+    // restore them via `applyCaptureSideChannel` WITHOUT a re-parse (#1983). See
+    // `kotlin/capture-side-channel.ts`.
+    // `assertCloneable` is a runtime identity; it makes a future non-serializable
+    // value in the side-channel payload a compile error here, at the source, rather
+    // than a DataCloneError at the worker boundary (#2143).
+    collectCaptureSideChannel: (filePath) => (0, clone_safety_js_1.assertCloneable)((0, index_js_2.collectKotlinCaptureSideChannel)(filePath)),
+    interpretImport: index_js_2.interpretKotlinImport,
+    interpretTypeBinding: index_js_2.interpretKotlinTypeBinding,
+    bindingScopeFor: index_js_2.kotlinBindingScopeFor,
+    importOwningScope: index_js_2.kotlinImportOwningScope,
+    mergeBindings: (_scope, bindings) => (0, index_js_2.kotlinMergeBindings)(bindings),
+    receiverBinding: index_js_2.kotlinReceiverBinding,
+    arityCompatibility: index_js_2.kotlinArityCompatibility,
+});

package/dist/core/code/engine/core/ingestion/languages/php/arity-metadata.js

@@ -0,0 +1,66 @@
+"use strict";
+/**
+ * Extract PHP arity metadata from a method-like tree-sitter node —
+ * `method_declaration` or `function_definition`.
+ *
+ * Reuses `phpMethodConfig.extractParameters` so scope-extracted defs
+ * carry the same arity semantics as the legacy parse-worker path:
+ *   - `variadic_parameter` (`...$args`) collapses `parameterCount` to
+ *     `undefined`, which `phpArityCompatibility` then treats as
+ *     "max unknown" — the candidate stays eligible at `argCount >= required`.
+ *   - Defaulted parameters (`= expr`) contribute to `optionalCount`;
+ *     `requiredParameterCount = total − optionalCount − (variadic ? 1 : 0)`.
+ *     The variadic slot itself accepts zero args so it is subtracted from
+ *     the required count — `f(int $a, ...$rest)` requires exactly 1 arg,
+ *     not 2, and `f(...$rest)` requires 0.
+ *   - `property_promotion_parameter` (constructor-promoted) is counted
+ *     the same as `simple_parameter` since both consume an argument slot.
+ *   - `parameterTypes` collects declared type names; a literal `'...'`
+ *     marker is appended for variadic methods so `phpArityCompatibility`
+ *     can detect them without re-reading the AST.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computePhpArityMetadata = computePhpArityMetadata;
+const php_js_1 = require("../../method-extractors/configs/php.js");
+function computePhpArityMetadata(fnNode) {
+    const params = php_js_1.phpMethodConfig.extractParameters?.(fnNode) ?? [];
+    let hasVariadic = false;
+    let optionalCount = 0;
+    const types = [];
+    for (const p of params) {
+        if (p.isVariadic) {
+            hasVariadic = true;
+        }
+        else if (p.isOptional) {
+            optionalCount++;
+        }
+        if (p.type !== null)
+            types.push(p.type);
+    }
+    // PHP variadic marker convention: append the literal '...' string to
+    // `parameterTypes`. This is intentionally DIFFERENT from C#, which uses
+    // the literal 'params' (its source-language keyword). The shared
+    // `narrowOverloadCandidates` pass in `scope-resolution/passes/overload-
+    // narrowing.ts` checks for the C# 'params' marker — that branch is
+    // dead code for PHP because PHP variadic methods set `parameterCount
+    // = undefined` (see line below), which skips the `max !== undefined`
+    // gate that hosts the 'params' check. PHP's actual variadic-aware
+    // arity logic lives in `phpArityCompatibility` (arity.ts) and now
+    // also in `phpEmitUnresolvedReceiverEdges` (scope-resolver.ts), both
+    // of which check `'...'`. Finding 9 of PR #1497 adversarial review.
+    if (hasVariadic)
+        types.push('...');
+    const total = params.length;
+    // Variadic methods accept any arg count ≥ required — leave `parameterCount`
+    // undefined so the registry treats max as unknown.
+    const parameterCount = hasVariadic ? undefined : total;
+    // The variadic slot itself accepts zero args; subtract it from the required
+    // count so PHP's ArgumentCountError-equivalent calls (too few args before
+    // the variadic) are correctly rejected by arity compatibility.
+    const requiredParameterCount = total - optionalCount - (hasVariadic ? 1 : 0);
+    return {
+        parameterCount,
+        requiredParameterCount,
+        parameterTypes: types.length > 0 ? types : undefined,
+    };
+}

package/dist/core/code/engine/core/ingestion/languages/php/arity.js

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * PHP arity check, accommodating variadic (`...$args`) and default parameters.
+ *
+ * The `def` metadata synthesized by `arity-metadata.ts`:
+ *   - `parameterCount`         — total formal parameters; `undefined` when
+ *                                the method has a variadic `...$param`.
+ *   - `requiredParameterCount` — min required (excludes defaulted params
+ *                                and the variadic itself).
+ *   - `parameterTypes`         — declared type strings; contains the
+ *                                literal `'...'` when the method is variadic.
+ *
+ * Verdicts:
+ *   - `'compatible'`   — `required <= argCount <= max`, OR the def has
+ *                        variadic (any `argCount >= required`).
+ *   - `'incompatible'` — argCount below required, or above max with no variadic.
+ *   - `'unknown'`      — metadata absent / incomplete; named-args can satisfy
+ *                        any arity so we return unknown when we detect them.
+ *
+ * PHP supports named arguments (PHP 8.0+): `save(force: true)`. Named-arg
+ * call sites cannot be arity-checked statically without parsing arg names,
+ * so we return `'unknown'` when the callsite carries named args (signalled
+ * by a negative `arity` value per the shared Callsite contract).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.phpArityCompatibility = phpArityCompatibility;
+function phpArityCompatibility(def, callsite) {
+    const max = def.parameterCount;
+    const min = def.requiredParameterCount;
+    if (max === undefined && min === undefined)
+        return 'unknown';
+    const argCount = callsite.arity;
+    // Negative arity signals named-argument call sites — can't narrow statically.
+    if (!Number.isFinite(argCount) || argCount < 0)
+        return 'unknown';
+    const hasVarArgs = def.parameterTypes !== undefined &&
+        def.parameterTypes.some((t) => t === '...' || t.startsWith('...'));
+    if (min !== undefined && argCount < min)
+        return 'incompatible';
+    if (max !== undefined && argCount > max && !hasVarArgs)
+        return 'incompatible';
+    return 'compatible';
+}