gitnexus 1.6.6-rc.98 → 1.6.6

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

@@ -14,7 +14,6 @@ import { kotlinTypeConfig } from '../type-extractors/jvm.js';
 import { kotlinExportChecker } from '../export-detection.js';
 import { createImportResolver } from '../import-resolvers/resolver-factory.js';
 import { kotlinImportConfig } from '../import-resolvers/configs/jvm.js';
-import { extractKotlinNamedBindings } from '../named-bindings/kotlin.js';
 import { appendKotlinWildcard } from '../import-resolvers/jvm.js';
 import { KOTLIN_QUERIES } from '../tree-sitter-queries.js';
 import { createCallExtractor } from '../call-extractors/generic.js';
@@ -25,8 +24,7 @@ import { createMethodExtractor } from '../method-extractors/generic.js';
 import { kotlinMethodConfig } from '../method-extractors/configs/jvm.js';
 import { createVariableExtractor } from '../variable-extractors/generic.js';
 import { kotlinVariableConfig } from '../variable-extractors/configs/jvm.js';
-import { createHeritageExtractor } from '../heritage-extractors/generic.js';
-import { emitKotlinScopeCaptures, interpretKotlinImport, interpretKotlinTypeBinding, kotlinArityCompatibility, kotlinBindingScopeFor, kotlinImportOwningScope, kotlinMergeBindings, kotlinReceiverBinding, } from './kotlin/index.js';
+import { collectKotlinCaptureSideChannel, emitKotlinScopeCaptures, interpretKotlinImport, interpretKotlinTypeBinding, kotlinArityCompatibility, kotlinBindingScopeFor, kotlinImportOwningScope, kotlinMergeBindings, kotlinReceiverBinding, } from './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. */
@@ -145,7 +143,6 @@ export const kotlinProvider = defineLanguage({
     typeConfig: kotlinTypeConfig,
     exportChecker: kotlinExportChecker,
     importResolver: createImportResolver(kotlinImportConfig),
-    namedBindingExtractor: extractKotlinNamedBindings,
     importPathPreprocessor: appendKotlinWildcard,
     mroStrategy: 'implements-split',
     callExtractor: createCallExtractor(kotlinCallConfig),
@@ -153,7 +150,6 @@ export const kotlinProvider = defineLanguage({
     methodExtractor: createMethodExtractor(kotlinMethodConfig),
     variableExtractor: createVariableExtractor(kotlinVariableConfig),
     classExtractor: createClassExtractor(kotlinClassConfig),
-    heritageExtractor: createHeritageExtractor(SupportedLanguages.Kotlin),
     builtInNames: BUILT_INS,
     labelOverride: (functionNode, defaultLabel) => {
         if (defaultLabel !== 'Function')
@@ -164,6 +160,13 @@ export const kotlinProvider = defineLanguage({
     },
     // ── RFC #909 Ring 3: scope-based resolution hooks ──
     emitScopeCaptures: emitKotlinScopeCaptures,
+    // Worker-side: snapshot the module-level companion-scope marks
+    // `emitKotlinScopeCaptures` just populated for this file (`markCompanionScope`
+    // → `companionScopesByFile`) into plain data on `ParsedFile.captureSideChannel`,
+    // so the main thread can restore them via `applyCaptureSideChannel` WITHOUT a
+    // re-parse (#1983). Without this, companion/static dispatch emits no CALLS
+    // edges on the worker path. See `kotlin/capture-side-channel.ts`.
+    collectCaptureSideChannel: collectKotlinCaptureSideChannel,
     interpretImport: interpretKotlinImport,
     interpretTypeBinding: interpretKotlinTypeBinding,
     bindingScopeFor: kotlinBindingScopeFor,

package/dist/core/ingestion/languages/php/captures.js

@@ -30,7 +30,7 @@
  *
  * Pure given the input source text. No I/O, no globals consulted.
  */
-import { findNodeAtRange, nodeToCapture, syntheticCapture } from '../../utils/ast-helpers.js';
+import { nodeIfType, nodeToCapture, syntheticCapture, walkNamedTree, } from '../../utils/ast-helpers.js';
 import { splitNamespaceUseDeclaration } from './import-decomposer.js';
 import { computePhpArityMetadata } from './arity-metadata.js';
 import { synthesizePhpReceiverBinding } from './receiver-binding.js';
@@ -89,9 +89,16 @@ export function emitPhpScopeCaptures(sourceText, _filePath, cachedTree) {
         // Group captures by their tag name. Tree-sitter strips the leading
         // `@`; we put it back so the central extractor's prefix lookups work.
         const grouped = {};
+        // Parallel tag -> captured SyntaxNode map: the query hands us each matched
+        // node as c.node, so anchors resolve via a type-guarded lookup (nodeIfType)
+        // instead of re-deriving them with findNodeAtRange(tree.rootNode, ...) per
+        // match — the O(matches x rootChildren) root-walk fixed for go #1915 /
+        // python #1918, mirrored here.
+        const nodeMap = {};
         for (const c of m.captures) {
             const tag = '@' + c.name;
             grouped[tag] = nodeToCapture(tag, c.node);
+            nodeMap[tag] = c.node;
         }
         if (Object.keys(grouped).length === 0)
             continue;
@@ -157,8 +164,7 @@ export function emitPhpScopeCaptures(sourceText, _filePath, cachedTree) {
         // Decompose each `namespace_use_declaration` so `interpretPhpImport`
         // sees the kind/source/name/alias markers it consumes.
         if (grouped['@import.statement'] !== undefined) {
-            const stmtCapture = grouped['@import.statement'];
-            const stmtNode = findNodeAtRange(tree.rootNode, stmtCapture.range, 'namespace_use_declaration');
+            const stmtNode = nodeIfType(nodeMap['@import.statement'], 'namespace_use_declaration');
             if (stmtNode !== null) {
                 const decomposed = splitNamespaceUseDeclaration(stmtNode);
                 if (decomposed.length > 0) {
@@ -175,8 +181,7 @@ export function emitPhpScopeCaptures(sourceText, _filePath, cachedTree) {
         // non-static method-like. Mirrors C#'s `this` / `base` synthesis.
         if (grouped['@scope.function'] !== undefined) {
             out.push(grouped);
-            const anchor = grouped['@scope.function'];
-            const fnNode = findFunctionNode(tree.rootNode, anchor.range);
+            const fnNode = nodeIfType(nodeMap['@scope.function'], ...FUNCTION_NODE_TYPES);
             if (fnNode !== null) {
                 for (const synth of synthesizePhpReceiverBinding(fnNode)) {
                     out.push(synth);
@@ -196,8 +201,7 @@ export function emitPhpScopeCaptures(sourceText, _filePath, cachedTree) {
         // registry can narrow overloads.
         const declTag = FUNCTION_DECL_TAGS.find((t) => grouped[t] !== undefined);
         if (declTag !== undefined) {
-            const anchor = grouped[declTag];
-            const fnNode = findFunctionNode(tree.rootNode, anchor.range);
+            const fnNode = nodeIfType(nodeMap[declTag], ...FUNCTION_NODE_TYPES);
             if (fnNode !== null) {
                 const arity = computePhpArityMetadata(fnNode);
                 if (arity.parameterCount !== undefined) {
@@ -217,12 +221,7 @@ export function emitPhpScopeCaptures(sourceText, _filePath, cachedTree) {
         // lines 149-186). PHP needs this for arity-based dispatch (Cluster H).
         const callTag = ['@reference.call.free', '@reference.call.member', '@reference.call.constructor'].find((t) => grouped[t] !== undefined);
         if (callTag !== undefined && grouped['@reference.arity'] === undefined) {
-            const anchor = grouped[callTag];
-            const callNode = findNodeAtRange(tree.rootNode, anchor.range, 'function_call_expression') ??
-                findNodeAtRange(tree.rootNode, anchor.range, 'member_call_expression') ??
-                findNodeAtRange(tree.rootNode, anchor.range, 'nullsafe_member_call_expression') ??
-                findNodeAtRange(tree.rootNode, anchor.range, 'scoped_call_expression') ??
-                findNodeAtRange(tree.rootNode, anchor.range, 'object_creation_expression');
+            const callNode = nodeIfType(nodeMap[callTag], 'function_call_expression', 'member_call_expression', 'nullsafe_member_call_expression', 'scoped_call_expression', 'object_creation_expression');
             if (callNode !== null) {
                 const argList = callNode.childForFieldName('arguments');
                 const args = [];
@@ -242,17 +241,134 @@ export function emitPhpScopeCaptures(sourceText, _filePath, cachedTree) {
         }
         out.push(grouped);
     }
+    out.push(...synthesizePhpInheritanceReferences(tree.rootNode));
     return out;
 }
-/** Find the first PHP function-like node at the given range. */
-function findFunctionNode(rootNode, range) {
-    for (const nodeType of FUNCTION_NODE_TYPES) {
-        const n = findNodeAtRange(rootNode, range, nodeType);
-        if (n !== null)
-            return n;
+// ─── PHP inheritance synthesis ───────────────────────────────────────────────
+/**
+ * Synthesize `@reference.inherits` captures from PHP class/trait heritage so
+ * the registry-primary scope-resolution path emits EXTENDS / IMPLEMENTS edges
+ * (mirrors C# `synthesizeCsharpInheritanceReferences` / C++
+ * `emitCppInheritanceCaptures`). Without this, PHP inheritance edges came only
+ * from the legacy heritage-capture leg (removed in #942), which the worker
+ * pipeline drops for registry-primary languages (issue #1951).
+ *
+ * Scope matches the legacy PHP heritage query (tree-sitter-queries.ts
+ * PHP_QUERIES extends / implements / trait-use captures):
+ *
+ *   1. `class_declaration` > `base_clause` > [(name) (qualified_name)] — extends
+ *   2. `class_declaration` > `class_interface_clause` > [(name) (qualified_name)] — implements
+ *   3. `class_declaration` body `use_declaration` > [(name) (qualified_name)] — trait use
+ *   4. `trait_declaration` body `use_declaration` > [(name) (qualified_name)] — trait use
+ *
+ * The EXTENDS-vs-IMPLEMENTS split is decided downstream from the resolved
+ * target's symbol kind (`preEmitInheritanceEdges`: `Interface` → IMPLEMENTS,
+ * else EXTENDS), so all bases emit the same `inherits` kind here. The base
+ * lookup name is normalized to its bare simple identifier (`Foo\Bar\Base` →
+ * `Base`) to match the V1 simple-name `findClassBindingInScope` contract.
+ *
+ * NOTE (#1951 trait-use parity): a PHP `use Trait;` is emitted as an IMPLEMENTS
+ * edge — `preEmitInheritanceEdges` (run.ts) maps a
+ * resolved `Interface` OR `Trait` target to IMPLEMENTS (`type === 'Interface'
+ * || type === 'Trait' ? 'IMPLEMENTS' : 'EXTENDS'`), so `use Trait` resolves to
+ * IMPLEMENTS on both the legacy and registry-primary paths.
+ */
+function synthesizePhpInheritanceReferences(root) {
+    const out = [];
+    walkNamedTree(root, (node) => {
+        if (node.type === 'class_declaration') {
+            // extends: single base_clause child carrying one base name.
+            const baseClause = findNamedChild(node, 'base_clause');
+            if (baseClause !== null)
+                emitPhpBaseNames(baseClause, out);
+            // implements: class_interface_clause may list several interfaces.
+            const ifaceClause = findNamedChild(node, 'class_interface_clause');
+            if (ifaceClause !== null)
+                emitPhpBaseNames(ifaceClause, out);
+            // trait use: `use TraitName;` inside the class body.
+            emitPhpTraitUses(node, out);
+        }
+        else if (node.type === 'trait_declaration') {
+            // trait-uses-trait: `use OtherTrait;` inside a trait body.
+            emitPhpTraitUses(node, out);
+        }
+    });
+    return out;
+}
+/**
+ * Emit `@reference.inherits` for every `use_declaration` (trait use) in the
+ * declaration body of `node` (a class_declaration or trait_declaration).
+ * Class-body `use_declaration` is the trait-use node (distinct from the
+ * top-level `namespace_use_declaration` import node).
+ */
+function emitPhpTraitUses(node, out) {
+    const body = node.childForFieldName('body');
+    if (body === null || body.type !== 'declaration_list')
+        return;
+    for (let i = 0; i < body.namedChildCount; i++) {
+        const child = body.namedChild(i);
+        if (child !== null && child.type === 'use_declaration') {
+            emitPhpBaseNames(child, out);
+        }
+    }
+}
+/**
+ * Walk the named children of a heritage clause (`base_clause`,
+ * `class_interface_clause`, or `use_declaration`) and emit one
+ * `@reference.inherits` match per `name` / `qualified_name` base. The lookup
+ * name is the bare tail identifier so `findClassBindingInScope` resolves it.
+ */
+function emitPhpBaseNames(clause, out) {
+    for (let i = 0; i < clause.namedChildCount; i++) {
+        const base = clause.namedChild(i);
+        if (base === null)
+            continue;
+        if (base.type !== 'name' && base.type !== 'qualified_name')
+            continue;
+        const bareName = phpBareBaseName(base);
+        if (bareName === '')
+            continue;
+        out.push({
+            '@reference.inherits': nodeToCapture('@reference.inherits', base),
+            '@reference.name': syntheticCapture('@reference.name', base, bareName),
+        });
+    }
+}
+/**
+ * Normalize a PHP base node to its bare simple identifier:
+ *   `Base`            (name)          → `Base`
+ *   `Foo\Bar\Base`    (qualified_name)→ `Base`  (last `name` child)
+ *   `\Foo\Base`       (qualified_name)→ `Base`
+ * Mirrors C#'s `terminalTypeNameNode`: strip the qualifier tail so the V1
+ * simple-name scope-chain lookup resolves the target def.
+ */
+function phpBareBaseName(base) {
+    if (base.type === 'name')
+        return base.text;
+    if (base.type === 'qualified_name') {
+        // qualified_name holds one or more `name` children (plus `\` separators);
+        // the bare class is the last `name` child.
+        for (let i = base.namedChildCount - 1; i >= 0; i--) {
+            const child = base.namedChild(i);
+            if (child !== null && child.type === 'name')
+                return child.text;
+        }
+        // Fallback: split the raw text on the namespace separator.
+        const segs = base.text.split('\\').filter((s) => s.length > 0);
+        return segs.length > 0 ? segs[segs.length - 1] : '';
+    }
+    return '';
+}
+/** Find the first named child of `node` with the given type. */
+function findNamedChild(node, type) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child !== null && child.type === type)
+            return child;
     }
     return null;
 }
+/** Pre-order walk over named children, invoking `cb` on each node. */
 // ─── PHP receiver normalization ──────────────────────────────────────────────
 /**
  * Normalize a PHP receiver expression so the language-agnostic

package/dist/core/ingestion/languages/php/import-decomposer.js

@@ -36,11 +36,21 @@ export function splitNamespaceUseDeclaration(stmtNode) {
     if (groupNode !== null) {
         return decomposeGrouped(stmtNode, groupNode, qualifier);
     }
-    // Single use clause (possibly aliased).
-    const spec = parseSingleUseClause(stmtNode, qualifier);
-    if (spec === null)
-        return [];
-    return [buildImportMatch(stmtNode, spec)];
+    // Non-grouped: iterate namespace_use_clause children (one per comma-separated
+    // import in `use A, B, C;`). The first import is also a namespace_use_clause
+    // in the grammar version used by the monorepo; namespace_name child handling
+    // was removed after confirming the clause wrapper covers all positions.
+    const out = [];
+    for (let i = 0; i < stmtNode.namedChildCount; i++) {
+        const child = stmtNode.namedChild(i);
+        if (child === null || child.type !== 'namespace_use_clause')
+            continue;
+        const spec = parseUseClause(child, qualifier);
+        if (spec !== null) {
+            out.push(buildImportMatch(stmtNode, spec));
+        }
+    }
+    return out;
 }
 // ── Qualifier detection ────────────────────────────────────────────────────
 /**
@@ -61,29 +71,6 @@ function detectQualifier(node) {
         return 'const';
     return 'namespace';
 }
-// ── Single clause parsing ──────────────────────────────────────────────────
-function parseSingleUseClause(node, qualifier) {
-    // A plain `namespace_use_declaration` has one or more
-    // `namespace_use_clause` named children (each clause is one import,
-    // comma-separated for multiple).  For the single case there is one.
-    const clause = findNamedChild(node, 'namespace_use_clause');
-    if (clause !== null)
-        return parseUseClause(clause, qualifier);
-    // Older grammar versions may put the qualified_name directly under
-    // the declaration node. Check for a qualified_name or name child.
-    const qualName = findNamedChild(node, 'qualified_name') ?? findNamedChild(node, 'name');
-    if (qualName === null)
-        return null;
-    const source = qualName.text.trim();
-    if (source === '')
-        return null;
-    return {
-        kind: qualifier,
-        source,
-        name: lastSegment(source),
-        atNode: node,
-    };
-}
 function parseUseClause(clause, qualifier) {
     // namespace_use_clause:
     //   qualified_name (or name)
@@ -97,23 +84,7 @@ function parseUseClause(clause, qualifier) {
     const source = qualName.text.trim();
     if (source === '')
         return null;
-    // Strategy 1: explicit alias_clause wrapper (older grammar versions).
-    const aliasClause = findNamedChild(clause, 'alias_clause');
-    if (aliasClause !== null) {
-        // alias_clause: "as" name
-        const aliasName = findNamedChild(aliasClause, 'name') ?? aliasClause.firstNamedChild;
-        const alias = aliasName?.text.trim() ?? '';
-        if (alias === '')
-            return null;
-        return {
-            kind: 'alias',
-            source,
-            name: alias,
-            alias,
-            atNode: clause,
-        };
-    }
-    // Strategy 2: bare sibling `name` node after the qualified_name.
+    // Strategy: bare sibling `name` node after the qualified_name.
     // tree-sitter-php (≥ 0.22) emits `use Foo\Bar as Baz` as:
     //   namespace_use_clause
     //     qualified_name "Foo\Bar"
@@ -152,8 +123,10 @@ function parseUseClause(clause, qualifier) {
  * `const` keyword inside the group.
  */
 function decomposeGrouped(stmtNode, groupNode, outerQualifier) {
-    // The prefix is the qualified_name that precedes the `{...}` group.
-    const prefixNode = findNamedChild(stmtNode, 'qualified_name') ?? findNamedChild(stmtNode, 'name');
+    // The prefix is the namespace_name that precedes the `{...}` group.
+    // tree-sitter-php emits the leading path as a namespace_name child,
+    // not qualified_name.
+    const prefixNode = findNamedChild(stmtNode, 'namespace_name') ?? findNamedChild(stmtNode, 'name');
     const prefix = prefixNode?.text.trim() ?? '';
     const out = [];
     for (let i = 0; i < groupNode.namedChildCount; i++) {
@@ -197,22 +170,7 @@ function parseInnerClause(clause, prefix, qualifier) {
     if (innerPath === '')
         return null;
     const source = prefix !== '' ? `${prefix}\\${innerPath}` : innerPath;
-    // Strategy 1: explicit alias_clause wrapper (older grammar versions).
-    const aliasClause = findNamedChild(clause, 'alias_clause');
-    if (aliasClause !== null) {
-        const aliasName = findNamedChild(aliasClause, 'name') ?? aliasClause.firstNamedChild;
-        const alias = aliasName?.text.trim() ?? '';
-        if (alias === '')
-            return null;
-        return {
-            kind: 'alias',
-            source,
-            name: alias,
-            alias,
-            atNode: clause,
-        };
-    }
-    // Strategy 2: bare sibling `name` node after the qualified_name (tree-sitter-php ≥ 0.22).
+    // Strategy: bare sibling `name` node after the qualified_name (tree-sitter-php ≥ 0.22).
     if (clause.namedChildCount >= 2) {
         const lastChild = clause.namedChild(clause.namedChildCount - 1);
         if (lastChild !== null && lastChild !== qualName && lastChild.type === 'name') {

package/dist/core/ingestion/languages/php/index.d.ts

@@ -54,10 +54,9 @@
  *   6. **Intersection types in parameters** — `T&U $param` takes the first
  *      named part (`T`). This matches the legacy type-extractor's behavior.
  *
- * Shadow-harness corpus parity is the authoritative signal for which of
- * these matter in practice. The CI parity gate blocks any PR that regresses
- * either the legacy or registry-primary run of
- * `test/integration/resolvers/php.test.ts`.
+ * The `test/integration/resolvers/php.test.ts` resolver suite is the
+ * authoritative signal for which of these matter in practice; it runs in
+ * the standard CI test workflow, so a regression blocks the merge.
  */
 export { emitPhpScopeCaptures } from './captures.js';
 export { getPhpCaptureCacheStats, resetPhpCaptureCacheStats } from './cache-stats.js';

package/dist/core/ingestion/languages/php/index.js

@@ -54,10 +54,9 @@
  *   6. **Intersection types in parameters** — `T&U $param` takes the first
  *      named part (`T`). This matches the legacy type-extractor's behavior.
  *
- * Shadow-harness corpus parity is the authoritative signal for which of
- * these matter in practice. The CI parity gate blocks any PR that regresses
- * either the legacy or registry-primary run of
- * `test/integration/resolvers/php.test.ts`.
+ * The `test/integration/resolvers/php.test.ts` resolver suite is the
+ * authoritative signal for which of these matter in practice; it runs in
+ * the standard CI test workflow, so a regression blocks the merge.
  */
 export { emitPhpScopeCaptures } from './captures.js';
 export { getPhpCaptureCacheStats, resetPhpCaptureCacheStats } from './cache-stats.js';

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

@@ -51,6 +51,7 @@ const PHP_SCOPE_QUERY = `
 (interface_declaration) @scope.class
 (trait_declaration)     @scope.class
 (enum_declaration)      @scope.class
+(anonymous_class)       @scope.class
 
 (method_declaration)                        @scope.function
 (function_definition)                       @scope.function
@@ -71,6 +72,10 @@ const PHP_SCOPE_QUERY = `
 (enum_declaration
   name: (name) @declaration.name) @declaration.enum
 
+;; Enum case
+(enum_case
+  name: (name) @declaration.name) @declaration.const
+
 ;; ── Declarations — methods / functions / constructors ─────────────────────
 
 (method_declaration

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

@@ -24,6 +24,11 @@ const TYPE_DECL_NODE_TYPES = new Set([
     'interface_declaration',
     'trait_declaration',
     'enum_declaration',
+    // tree-sitter-php node for `new class {...}` (real node is `anonymous_class`,
+    // not `anonymous_class_declaration`). Included so the enclosing-type walk
+    // stops AT the anon class and the guard below skips it (otherwise a method in
+    // an anon class nested in a named class would mis-bind $this to the outer class).
+    'anonymous_class',
 ]);
 const FUNCTION_NODE_TYPES = new Set([
     'method_declaration',
@@ -94,7 +99,7 @@ export function synthesizePhpReceiverBinding(fnNode) {
     if (enclosingType === null)
         return [];
     // Anonymous class — skip (no stable name).
-    if (enclosingType.type === 'anonymous_class_declaration')
+    if (enclosingType.type === 'anonymous_class')
         return [];
     const enclosingName = typeName(enclosingType);
     if (enclosingName === null)
@@ -102,9 +107,8 @@ export function synthesizePhpReceiverBinding(fnNode) {
     // Anchor the synthesized captures to the method body (compound_statement)
     // so they land inside the function scope, not at the class scope.
     // For interface/abstract methods that have no body, skip.
-    const bodyNode = fnNode.childForFieldName('body') ??
-        // arrow_function: body is the expression after `=>`
-        fnNode.childForFieldName('return_value');
+    // tree-sitter-php arrow_function also exposes its expression via the `body` field.
+    const bodyNode = fnNode.childForFieldName('body');
     if (bodyNode === null)
         return [];
     const out = [];

package/dist/core/ingestion/languages/php.js

@@ -14,7 +14,6 @@ import { typeConfig as phpConfig } from '../type-extractors/php.js';
 import { phpExportChecker } from '../export-detection.js';
 import { createImportResolver } from '../import-resolvers/resolver-factory.js';
 import { phpImportConfig } from '../import-resolvers/configs/php.js';
-import { extractPhpNamedBindings } from '../named-bindings/php.js';
 import { PHP_QUERIES } from '../tree-sitter-queries.js';
 import { findDescendant, extractStringContent } from '../utils/ast-helpers.js';
 import { createFieldExtractor } from '../field-extractors/generic.js';
@@ -25,7 +24,6 @@ import { createVariableExtractor } from '../variable-extractors/generic.js';
 import { phpVariableConfig } from '../variable-extractors/configs/php.js';
 import { createCallExtractor } from '../call-extractors/generic.js';
 import { phpCallConfig } from '../call-extractors/configs/php.js';
-import { createHeritageExtractor } from '../heritage-extractors/generic.js';
 const BUILT_INS = new Set([
     'echo',
     'isset',
@@ -263,13 +261,11 @@ export const phpProvider = defineLanguage({
     typeConfig: phpConfig,
     exportChecker: phpExportChecker,
     importResolver: createImportResolver(phpImportConfig),
-    namedBindingExtractor: extractPhpNamedBindings,
     callExtractor: createCallExtractor(phpCallConfig),
     fieldExtractor: createFieldExtractor(phpFieldConfig),
     methodExtractor: createMethodExtractor(phpMethodConfig),
     variableExtractor: createVariableExtractor(phpVariableConfig),
     classExtractor: createClassExtractor(phpClassConfig),
-    heritageExtractor: createHeritageExtractor(SupportedLanguages.PHP),
     descriptionExtractor: phpDescriptionExtractor,
     isRouteFile: isPhpRouteFile,
     builtInNames: BUILT_INS,