gitnexus 1.6.10-rc.99 → 1.6.10

package/dist/core/ingestion/route-extractors/spring-shared.js

@@ -15,6 +15,7 @@
  * `ingestion/import-resolvers/utils.ts`). It MUST NOT import anything from
  * `group/` to avoid a dependency cycle.
  */
+import { parseSpringAnnotationArguments } from '../frameworks/spring/annotation-arguments.js';
 /**
  * Spring shortcut method-annotation → HTTP verb.
  *
@@ -30,6 +31,94 @@ export const METHOD_ANNOTATION_TO_HTTP = {
     DeleteMapping: 'DELETE',
     PatchMapping: 'PATCH',
 };
+/**
+ * Parse one `RequestMethod.X` literal or a Java annotation array of literals.
+ * An empty array is valid and means Spring's unrestricted/default method set.
+ * Runtime expressions fail closed instead of producing a guessed route.
+ */
+function parseRequestMethodValues(value) {
+    let trimmed = '';
+    for (let index = 0; index < value.length; index += 1) {
+        const char = value[index];
+        const next = value[index + 1];
+        if (/\s/.test(char))
+            continue;
+        if (char === '/' && next === '*') {
+            const commentEnd = value.indexOf('*/', index + 2);
+            if (commentEnd < 0)
+                return null;
+            index = commentEnd + 1;
+            continue;
+        }
+        if (char === '/' && next === '/') {
+            const lineEnd = value.slice(index + 2).search(/[\r\n]/);
+            if (lineEnd < 0)
+                return null;
+            index += lineEnd + 1;
+            continue;
+        }
+        trimmed += char;
+    }
+    const hasOpeningBrace = trimmed.startsWith('{');
+    const hasClosingBrace = trimmed.endsWith('}');
+    if (hasOpeningBrace !== hasClosingBrace)
+        return null;
+    const body = hasOpeningBrace ? trimmed.slice(1, -1).trim() : trimmed;
+    if (body.length === 0)
+        return [];
+    if (!hasOpeningBrace && body.includes(','))
+        return null;
+    const methods = [];
+    const parts = body.split(',');
+    if (hasOpeningBrace && parts[parts.length - 1].trim() === '')
+        parts.pop();
+    for (const rawPart of parts) {
+        const part = rawPart.trim();
+        const match = /^(?:(?:[A-Za-z_$][A-Za-z0-9_$]*\.)*RequestMethod\.)?(GET|HEAD|POST|PUT|PATCH|DELETE|OPTIONS|TRACE)$/.exec(part);
+        if (!match)
+            return null;
+        if (!methods.includes(match[1]))
+            methods.push(match[1]);
+    }
+    return methods;
+}
+/**
+ * Resolve a method-level Spring mapping annotation to its HTTP method(s).
+ *
+ * Shortcut annotations have one implicit verb. `@RequestMapping` may declare
+ * one or more static `RequestMethod.X` values; when its `method` member is
+ * absent or an empty array, `'*'` preserves Spring's method-agnostic semantics.
+ * A present but non-static method expression yields no methods (fail closed).
+ */
+export function springAnnotationHttpMethods(annotationName, annotationText) {
+    const shortcut = METHOD_ANNOTATION_TO_HTTP[annotationName];
+    if (shortcut)
+        return [shortcut];
+    if (annotationName !== 'RequestMapping')
+        return [];
+    const args = parseSpringAnnotationArguments(annotationText);
+    if (args === null)
+        return [];
+    const methodArgs = args.filter((arg) => arg.name === 'method');
+    if (methodArgs.length === 0)
+        return ['*'];
+    if (methodArgs.length !== 1)
+        return [];
+    const methods = parseRequestMethodValues(methodArgs[0].value);
+    if (methods === null)
+        return [];
+    return methods.length > 0 ? methods : ['*'];
+}
+/** Intersect class- and method-level Spring mapping constraints. */
+export function intersectSpringHttpMethods(classMethods, methodMethods) {
+    if (classMethods.length === 0 || methodMethods.length === 0)
+        return [];
+    if (classMethods.includes('*'))
+        return methodMethods;
+    if (methodMethods.includes('*'))
+        return classMethods;
+    return methodMethods.filter((method) => classMethods.includes(method));
+}
 /**
  * A named annotation argument contributes a route only when its member key is
  * `path` or `value`; a positional argument (no key node) always qualifies.

package/dist/core/ingestion/route-extractors/spring.js

@@ -20,7 +20,8 @@
  */
 import Parser from 'tree-sitter';
 import Java from 'tree-sitter-java';
-import { METHOD_ANNOTATION_TO_HTTP, isRouteMemberKey, findEnclosingType, unquoteSpringLiteral, } from './spring-shared.js';
+import { intersectSpringHttpMethods, springAnnotationHttpMethods, isRouteMemberKey, findEnclosingType, unquoteSpringLiteral, } from './spring-shared.js';
+import { parseJavaConstOperands } from './java-const-resolver.js';
 /**
  * Single predicate-free tree-sitter query that captures all route annotations
  * on classes and methods. Discrimination by annotation name and node type
@@ -43,20 +44,27 @@ import { METHOD_ANNOTATION_TO_HTTP, isRouteMemberKey, findEnclosingType, unquote
  * suppresses that class's method-level array routes rather than emit them with a
  * dropped prefix (a wrong route). Full class-array cross-product support is left
  * to a follow-up (#2280).
+ *
+ * The class-level `@value_expr` branches exist for the same reason: a
+ * CONSTANT-valued class prefix (`@RequestMapping(ApiPaths.BASE)`) cannot be
+ * folded here — the repo-wide constant map only exists in the parse phase — so
+ * they only DETECT it, and Phase 2 suppresses every method route under such a
+ * class. Without them the prefix was invisible and the method route was emitted
+ * unprefixed, i.e. at a path the application does not serve.
  */
 const ROUTE_ANNOTATION_QUERY = new Parser.Query(Java, `
   [
     (class_declaration
       (modifiers
         (annotation
-          name: (identifier) @ann
+          name: [(identifier) (scoped_identifier)] @ann
           arguments: (annotation_argument_list
             [(string_literal) @value
              (element_value_array_initializer (string_literal) @value)])))) @node
     (class_declaration
       (modifiers
         (annotation
-          name: (identifier) @ann
+          name: [(identifier) (scoped_identifier)] @ann
           arguments: (annotation_argument_list
             (element_value_pair
               key: (identifier) @key
@@ -65,19 +73,55 @@ const ROUTE_ANNOTATION_QUERY = new Parser.Query(Java, `
     (method_declaration
       (modifiers
         (annotation
-          name: (identifier) @ann
+          name: [(identifier) (scoped_identifier)] @ann
           arguments: (annotation_argument_list
             [(string_literal) @value
              (element_value_array_initializer (string_literal) @value)])))) @node
     (method_declaration
       (modifiers
         (annotation
-          name: (identifier) @ann
+          name: [(identifier) (scoped_identifier)] @ann
           arguments: (annotation_argument_list
             (element_value_pair
               key: (identifier) @key
               value: [(string_literal) @value
                       (element_value_array_initializer (string_literal) @value)]))))) @node
+    (class_declaration
+      (modifiers
+        (annotation
+          name: [(identifier) (scoped_identifier)] @ann
+          arguments: (annotation_argument_list
+            [(identifier) @value_expr
+             (field_access) @value_expr
+             (binary_expression) @value_expr])))) @node
+    (class_declaration
+      (modifiers
+        (annotation
+          name: [(identifier) (scoped_identifier)] @ann
+          arguments: (annotation_argument_list
+            (element_value_pair
+              key: (identifier) @key
+              value: [(identifier) @value_expr
+                      (field_access) @value_expr
+                      (binary_expression) @value_expr]))))) @node
+    (method_declaration
+      (modifiers
+        (annotation
+          name: [(identifier) (scoped_identifier)] @ann
+          arguments: (annotation_argument_list
+            [(identifier) @value_expr
+             (field_access) @value_expr
+             (binary_expression) @value_expr])))) @node
+    (method_declaration
+      (modifiers
+        (annotation
+          name: [(identifier) (scoped_identifier)] @ann
+          arguments: (annotation_argument_list
+            (element_value_pair
+              key: (identifier) @key
+              value: [(identifier) @value_expr
+                      (field_access) @value_expr
+                      (binary_expression) @value_expr]))))) @node
   ]
 `);
 /**
@@ -103,6 +147,18 @@ export function extractSpringRoutes(tree, filePath, lineOffset = 0) {
     // class-array cross-product support is out of scope here.
     const prefixByClassId = new Map();
     const classesWithArrayPrefix = new Set();
+    // Classes whose `@RequestMapping` prefix is a constant reference or concat.
+    // Same treatment as the array form, for the same reason: no single prefix
+    // string is knowable at extraction time, so emitting the methods below would
+    // publish them at a WRONG (unprefixed) path rather than not at all.
+    const classesWithUnfoldablePrefix = new Set();
+    const classHttpMethodsById = new Map();
+    for (const match of TYPE_DECLARATION_QUERY.matches(tree.rootNode)) {
+        const typeNode = match.captures.find((capture) => capture.name === 'type')?.node;
+        if (typeNode?.type === 'class_declaration') {
+            classHttpMethodsById.set(typeNode.id, typeRequestMethods(typeNode));
+        }
+    }
     for (const match of matches) {
         const caps = {};
         for (const { name, node } of match.captures) {
@@ -112,11 +168,17 @@ export function extractSpringRoutes(tree, filePath, lineOffset = 0) {
         const node = caps['node'];
         const valueNode = caps['value'];
         const keyNode = caps['key'];
-        if (!annNode || !node || !valueNode)
+        const valueExprNode = caps['value_expr'];
+        if (!annNode || !node || (!valueNode && !valueExprNode))
             continue;
-        if (node.type === 'class_declaration' && annNode.text === 'RequestMapping') {
+        const capturedAnnotationName = annNode.text.split('.').pop() ?? annNode.text;
+        if (node.type === 'class_declaration' && capturedAnnotationName === 'RequestMapping') {
             if (!isRouteMemberKey(keyNode))
                 continue;
+            if (!valueNode) {
+                classesWithUnfoldablePrefix.add(node.id);
+                continue;
+            }
             if (valueNode.parent?.type === 'element_value_array_initializer') {
                 classesWithArrayPrefix.add(node.id);
                 continue;
@@ -128,6 +190,7 @@ export function extractSpringRoutes(tree, filePath, lineOffset = 0) {
     }
     // Phase 2: collect method-level routes and resolve their class prefix
     const routes = [];
+    const httpMethodsByAnnotationId = new Map();
     for (const match of matches) {
         const caps = {};
         for (const { name, node } of match.captures) {
@@ -137,18 +200,33 @@ export function extractSpringRoutes(tree, filePath, lineOffset = 0) {
         const node = caps['node'];
         const valueNode = caps['value'];
         const keyNode = caps['key'];
-        if (!annNode || !node || !valueNode)
+        // A constant-referencing value arrives as @value_expr, not @value — the
+        // match carries exactly one of the two. Require @value only when no
+        // @value_expr is present; the operand branch below folds the expression.
+        const valueExprCapture = match.captures.find((c) => c.name === 'value_expr')?.node ?? null;
+        if (!annNode || !node || (!valueNode && !valueExprCapture))
             continue;
         if (node.type !== 'method_declaration')
             continue;
-        const ann = annNode.text;
-        const httpMethod = METHOD_ANNOTATION_TO_HTTP[ann];
-        if (!httpMethod)
-            continue; // skip @RequestMapping on methods (ambiguous verb)
+        const ann = annNode.text.split('.').pop() ?? annNode.text;
+        const annotationNode = annNode.parent;
+        if (!annotationNode)
+            continue;
+        let methodMethods = httpMethodsByAnnotationId.get(annotationNode.id);
+        if (!methodMethods) {
+            methodMethods = springAnnotationHttpMethods(ann, annotationNode.text);
+            httpMethodsByAnnotationId.set(annotationNode.id, methodMethods);
+        }
+        if (methodMethods.length === 0)
+            continue;
         if (!isRouteMemberKey(keyNode))
             continue;
-        const routePath = unquoteSpringLiteral(valueNode.text);
-        if (routePath === null)
+        // #2391-style non-literal path (constant ref or `+`-concat): emit with
+        // operands for cross-file folding in the parse phase. The match carries
+        // either @value (literal) or @value_expr (non-literal) — never both.
+        const valueExprNode = valueExprCapture;
+        const routePath = valueNode ? unquoteSpringLiteral(valueNode.text) : null;
+        if (routePath === null && !valueExprNode)
             continue;
         const enclosingType = findEnclosingType(node);
         // Interface-declared `@*Mapping`s are not concrete routes on their own — the
@@ -159,6 +237,9 @@ export function extractSpringRoutes(tree, filePath, lineOffset = 0) {
         if (enclosingType?.kind === 'interface')
             continue;
         const enclosingClass = enclosingType?.kind === 'class' ? enclosingType.node : null;
+        const httpMethods = intersectSpringHttpMethods(enclosingClass ? (classHttpMethodsById.get(enclosingClass.id) ?? ['*']) : ['*'], methodMethods);
+        if (httpMethods.length === 0)
+            continue;
         // Suppress a method-level *array-form* route nested under a class-level
         // array-form @RequestMapping. The class prefix is one of several values that
         // cannot be resolved to a single string here, so emitting the route would
@@ -167,23 +248,96 @@ export function extractSpringRoutes(tree, filePath, lineOffset = 0) {
         // scan — safe under routeCoverage:'partial'. Full class-array cross-product
         // support is tracked in #2280. (Scalar method paths under an array class
         // prefix are left unchanged: that pre-existing divergence is out of scope.)
-        const isArrayElement = valueNode.parent?.type === 'element_value_array_initializer';
+        const isArrayElement = valueNode?.parent?.type === 'element_value_array_initializer';
         if (isArrayElement && enclosingClass && classesWithArrayPrefix.has(enclosingClass.id)) {
             continue;
         }
+        // Same rule for a CONSTANT-valued class prefix (`@RequestMapping(ApiPaths.BASE)`),
+        // and for every method route under it — not just array-form ones. The prefix
+        // needs the repo-wide constant map, which does not exist at extraction time,
+        // so the prefix would simply be dropped and the route emitted at a path the
+        // application never serves. On base such a route was not emitted at all;
+        // turning a missing fact into a wrong one is the failure this module's skip
+        // floor exists to prevent. Folding class prefixes cross-file is a follow-up.
+        if (enclosingClass && classesWithUnfoldablePrefix.has(enclosingClass.id)) {
+            continue;
+        }
         const classPrefix = enclosingClass ? (prefixByClassId.get(enclosingClass.id) ?? '') : '';
         // `node` is the annotated `method_declaration`; its name field is the
         // handler method name (resolved to a symbol UID later by the routes phase).
         const handlerName = node.childForFieldName('name')?.text;
-        routes.push({
-            filePath,
-            routePath,
-            httpMethod,
-            decoratorName: ann,
-            lineNumber: annNode.startPosition.row + lineOffset,
-            ...(classPrefix ? { prefix: classPrefix } : {}),
-            ...(handlerName ? { handlerName } : {}),
-        });
+        for (const httpMethod of httpMethods) {
+            if (routePath === null && valueExprNode) {
+                // Non-literal annotation value: parse operands now; the parse phase
+                // folds them against the repo-wide Java constant map (KTD5 skip floor
+                // on failure — never a phantom `POST /`).
+                const operands = parseJavaConstOperands(valueExprNode);
+                if (operands === null)
+                    continue;
+                routes.push({
+                    filePath,
+                    routePath: '',
+                    routePathExpr: valueExprNode.text,
+                    routePathOperands: operands,
+                    httpMethod,
+                    decoratorName: ann,
+                    lineNumber: annNode.startPosition.row + lineOffset,
+                    ...(classPrefix ? { prefix: classPrefix } : {}),
+                    ...(handlerName ? { handlerName } : {}),
+                });
+                continue;
+            }
+            routes.push({
+                filePath,
+                routePath,
+                httpMethod,
+                decoratorName: ann,
+                lineNumber: annNode.startPosition.row + lineOffset,
+                ...(classPrefix ? { prefix: classPrefix } : {}),
+                ...(handlerName ? { handlerName } : {}),
+            });
+        }
+    }
+    // Mapping annotations without a path bind to the enclosing class prefix.
+    for (const match of TYPE_DECLARATION_QUERY.matches(tree.rootNode)) {
+        const typeNode = match.captures.find((capture) => capture.name === 'type')?.node;
+        if (typeNode?.type !== 'class_declaration')
+            continue;
+        // A no-argument `@GetMapping` IS the class prefix, so a class prefix that
+        // cannot be folded here leaves nothing to emit — the route would ship with
+        // `routePath: ''` and no prefix, i.e. an empty-path Route. The Phase 2 loop
+        // above already suppresses these classes; this loop needs the same guard, or
+        // the suppression is one-sided and the group side (which routes both shapes
+        // through `methodRoutes`) disagrees with ingestion.
+        if (classesWithUnfoldablePrefix.has(typeNode.id))
+            continue;
+        const classPrefix = prefixByClassId.get(typeNode.id) ?? '';
+        const classMethods = classHttpMethodsById.get(typeNode.id) ?? ['*'];
+        for (const methodNode of directMethods(typeNode)) {
+            const handlerName = methodNode.childForFieldName('name')?.text;
+            if (!handlerName)
+                continue;
+            for (const annotationNode of declarationAnnotations(methodNode)) {
+                const ann = annotationName(annotationNode) ?? '';
+                if (annotationHasRouteMember(annotationNode))
+                    continue;
+                const methodMethods = springAnnotationHttpMethods(ann, annotationNode.text);
+                const httpMethods = intersectSpringHttpMethods(classMethods, methodMethods);
+                if (httpMethods.length === 0)
+                    continue;
+                for (const httpMethod of httpMethods) {
+                    routes.push({
+                        filePath,
+                        routePath: '',
+                        httpMethod,
+                        decoratorName: ann,
+                        lineNumber: annotationNode.startPosition.row + lineOffset,
+                        ...(classPrefix ? { prefix: classPrefix } : {}),
+                        handlerName,
+                    });
+                }
+            }
+        }
     }
     return routes;
 }
@@ -250,6 +404,35 @@ function annotationRoutePaths(ann) {
     }
     return out;
 }
+/** Whether an annotation explicitly supplies a positional or path/value member. */
+function annotationHasRouteMember(ann) {
+    const args = ann.childForFieldName('arguments');
+    if (!args)
+        return false;
+    for (const child of args.namedChildren) {
+        if (child.type !== 'element_value_pair')
+            return true;
+        const key = child.childForFieldName('key');
+        if (isRouteMemberKey(key ?? undefined))
+            return true;
+    }
+    return false;
+}
+/** Static class/interface-level RequestMapping method constraint, or wildcard by default. */
+function typeRequestMethods(typeNode) {
+    const mappings = declarationAnnotations(typeNode).filter((ann) => annotationName(ann) === 'RequestMapping');
+    if (mappings.length === 0)
+        return ['*'];
+    if (mappings.length !== 1)
+        return [];
+    return springAnnotationHttpMethods('RequestMapping', mappings[0].text);
+}
+function annotationRoutePathsOrDefault(ann) {
+    const paths = annotationRoutePaths(ann);
+    if (paths.length > 0)
+        return paths;
+    return annotationHasRouteMember(ann) ? [] : [''];
+}
 /** Class-level `@RequestMapping` prefixes for a type (array-aware; may be []). */
 function typeClassPrefixes(typeNode) {
     const prefixes = [];
@@ -319,6 +502,7 @@ export function extractSpringTypes(tree, filePath) {
         const kind = typeNode.type === 'interface_declaration' ? 'interface' : 'class';
         const annNames = declarationAnnotations(typeNode).map(annotationName);
         const isController = kind === 'class' && (annNames.includes('RestController') || annNames.includes('Controller'));
+        const classMethods = typeRequestMethods(typeNode);
         const methods = directMethods(typeNode)
             .map((methodNode) => {
             const methodName = methodNode.childForFieldName('name')?.text;
@@ -326,11 +510,12 @@ export function extractSpringTypes(tree, filePath) {
                 return null;
             const routes = [];
             for (const ann of declarationAnnotations(methodNode)) {
-                const verb = METHOD_ANNOTATION_TO_HTTP[annotationName(ann) ?? ''];
-                if (!verb)
-                    continue;
-                for (const path of annotationRoutePaths(ann))
-                    routes.push({ method: verb, path });
+                const methodMethods = springAnnotationHttpMethods(annotationName(ann) ?? '', ann.text);
+                const verbs = intersectSpringHttpMethods(classMethods, methodMethods);
+                for (const verb of verbs) {
+                    for (const path of annotationRoutePathsOrDefault(ann))
+                        routes.push({ method: verb, path });
+                }
             }
             return { name: methodName, routes };
         })

package/dist/core/ingestion/scope-extractor-bridge.js

@@ -36,7 +36,15 @@ export function extractParsedFile(provider, sourceText, filePath, onWarn, cached
     if (sourceText.trim().length === 0)
         return undefined;
     try {
-        const captures = provider.emitScopeCaptures(sourceText, filePath, cachedTree, { sourceKind });
+        // A provider that rewrites source before parsing must see the same text
+        // here that the parse worker fed tree-sitter, or the two halves of the
+        // pipeline analyze different programs. Only the cache-miss path re-parses;
+        // with a cached tree the emitter ignores the text. The transform is
+        // length-preserving, so every offset still indexes the original.
+        const parseText = cachedTree === undefined
+            ? (provider.preprocessSource?.(sourceText, filePath) ?? sourceText)
+            : sourceText;
+        const captures = provider.emitScopeCaptures(parseText, filePath, cachedTree, { sourceKind });
         return extractScope(captures, filePath, provider);
     }
     catch (err) {

package/dist/core/ingestion/scope-extractor.d.ts

@@ -34,9 +34,24 @@
  *      as `ownedDefs` + a local `BindingRef { origin: 'local' }`.
  *   3. **Collect raw imports.** Walk `@import.*` matches. Call
  *      `provider.interpretImport` per match; attach the returned
- *      `ParsedImport` to the ParsedFile (not to any `Scope` — finalize
- *      reconstructs the owning scope via `provider.importOwningScope`
- *      during Phase 2).
+ *      `ParsedImport` to the ParsedFile — not to any `Scope`.
+ *      `provider.importOwningScope` is declared on `LanguageProvider` and
+ *      implemented by a dozen providers, but has no call site anywhere; this
+ *      step's output is a flat per-file list.
+ *
+ *      One scope fact is read before that list flattens it away:
+ *      `runsOnlyWhenCalled`, set when the statement sits anywhere inside a
+ *      `Function`. It is decided here because here is the last stage that can
+ *      — finalize receives the flat list, and its consumer receives a map
+ *      keyed by the file's Module scope only (see
+ *      `ParsedImport.runsOnlyWhenCalled`). This is a position fact, not a
+ *      syntax one, so it is decided centrally for every language rather than
+ *      per provider — with one capability a provider may declare to opt out
+ *      of it entirely, `importsExecuteWhereWritten: false`, because position
+ *      cannot defer an import that never executes (C/C++ `#include`, Rust
+ *      `use`, COBOL `COPY`). Providers still decide their own *syntactic* nesting
+ *      facts in their capture emitters, where the node is in hand (see
+ *      `languages/python/import-decomposer.ts`).
  *   4. **Collect type bindings.** Walk `@type-binding.*` matches. Call
  *      `provider.interpretTypeBinding` per match. Attach the resulting
  *      `TypeRef` to the innermost containing scope's `typeBindings`
@@ -61,10 +76,10 @@
 import type { CaptureMatch, ParsedFile, SymbolDefinition } from '../../_shared/index.js';
 import type { LanguageProvider } from './language-provider.js';
 /**
- * The subset of `LanguageProvider` hooks that `extract()` reads. Declared
- * as its own type so:
+ * The subset of `LanguageProvider` members that `extract()` reads — the hooks
+ * it calls plus the capability flags it consults. Declared as its own type so:
  *
- *   - Tests can implement just these six hooks without faking the whole
+ *   - Tests can implement just these members without faking the whole
  *     `LanguageProvider` interface (which is ~40 fields including the
  *     legacy-DAG surface).
  *   - The extractor's dependency contract stays explicit — adding a new
@@ -73,7 +88,7 @@ import type { LanguageProvider } from './language-provider.js';
  * Real callers pass a full `LanguageProvider` — structural typing makes it
  * a `ScopeExtractorHooks` for free.
  */
-export type ScopeExtractorHooks = Pick<LanguageProvider, 'resolveScopeKind' | 'bindingScopeFor' | 'interpretImport' | 'interpretTypeBinding' | 'classifyCallForm'>;
+export type ScopeExtractorHooks = Pick<LanguageProvider, 'resolveScopeKind' | 'scopeOwnsReceivers' | 'bindingScopeFor' | 'interpretImport' | 'importsExecuteWhereWritten' | 'interpretTypeBinding' | 'classifyCallForm'>;
 /**
  * Drive the five extraction passes and return a `ParsedFile`.
  *