ucn 3.8.23 → 3.8.25

package/languages/python.js

@@ -10,7 +10,8 @@ const {
     traverseTreeCached,
     nodeToLocation,
     parseStructuredParams,
-    extractPythonDocstring
+    extractPythonDocstring,
+    paramTypesFromStructured
 } = require('./utils');
 const { PARSE_OPTIONS, safeParse } = require('./index');
 
@@ -117,16 +118,19 @@ function _processFunction(node, functions, processedRanges, lines, code) {
             // Only set when different from startLine (i.e., when decorators push startLine earlier)
             const nameLine = nameNode.startPosition.row + 1;
 
+            const paramsStructured = parseStructuredParams(paramsNode, 'python');
+            const paramTypes = paramTypesFromStructured(paramsStructured);
             functions.push({
                 name: nameNode.text,
                 params: extractPythonParams(paramsNode),
-                paramsStructured: parseStructuredParams(paramsNode, 'python'),
+                paramsStructured,
                 startLine: decoratorStartLine,
                 endLine,
                 indent,
                 isAsync,
                 modifiers: isAsync ? ['async'] : [],
                 ...(returnType && { returnType }),
+                ...(paramTypes && { paramTypes }),
                 ...(docstring && { docstring }),
                 ...(decorators.length > 0 && { decorators }),
                 ...(nameLine !== decoratorStartLine && { nameLine })
@@ -365,16 +369,21 @@ function extractClassMembers(classNode, code) {
                 // nameLine: where the name identifier lives (differs from startLine when decorated)
                 const nameLine = nameNode.startPosition.row + 1;
 
+                const paramsStructured = parseStructuredParams(paramsNode, 'python');
+                const paramTypes = paramTypesFromStructured(paramsStructured);
                 members.push({
                     name,
                     params: extractPythonParams(paramsNode),
-                    paramsStructured: parseStructuredParams(paramsNode, 'python'),
+                    paramsStructured,
                     startLine,
                     endLine,
                     memberType,
                     isAsync,
                     isMethod: true,  // Mark as method for context() lookups
+                    // Match top-level Python functions: `async def` → ['async'] modifiers.
+                    modifiers: isAsync ? ['async'] : [],
                     ...(returnType && { returnType }),
+                    ...(paramTypes && { paramTypes }),
                     ...(docstring && { docstring }),
                     ...(memberDecorators.length > 0 && { decorators: memberDecorators }),
                     ...(nameLine !== startLine && { nameLine })
@@ -450,6 +459,37 @@ function findCallsInCode(code, parser) {
     const localVarTypes = new Map();  // Track local variable types: varName -> typeName (for receiverType inference)
     const localVarTypesStack = [];  // Stack for function-scoped save/restore of localVarTypes
 
+    // Helper: extract first string-arg literal from a call node.
+    // Used by route extraction to capture path arg of requests.get('/users'), httpx.get('/users') etc.
+    // Handles both plain strings and f-strings (returns interp:true with literal prefix).
+    const { extractStringArg: _extractStringArg } = require('./utils');
+    const getFirstStringArg = (callNode) => {
+        const argsNode = callNode.childForFieldName('arguments');
+        if (!argsNode) return null;
+        for (let i = 0; i < argsNode.namedChildCount; i++) {
+            const arg = argsNode.namedChild(i);
+            if (arg.type === 'comment') continue;
+            // Handle f-string explicitly
+            if (arg.type === 'string') {
+                // f-string detection: tree-sitter-python wraps interpolations as 'interpolation' children.
+                // If any interpolation child exists, this is interpolated; extract literal prefix.
+                let interp = false;
+                let prefix = '';
+                for (let j = 0; j < arg.namedChildCount; j++) {
+                    const sc = arg.namedChild(j);
+                    if (sc.type === 'interpolation') { interp = true; break; }
+                    if (sc.type === 'string_content') prefix += sc.text;
+                }
+                if (interp) {
+                    return { value: prefix + (prefix.endsWith('*') ? '' : '*'), interp: true };
+                }
+                return _extractStringArg(arg);
+            }
+            return _extractStringArg(arg);
+        }
+        return null;
+    };
+
     // Helper to check if a node is a non-callable literal
     const isNonCallableInit = (node) => {
         // Primitive literals
@@ -615,13 +655,15 @@ function findCallsInCode(code, parser) {
             if (funcNode.type === 'identifier') {
                 // Direct call: foo()
                 const resolvedName = aliases.get(funcNode.text);
+                const firstArg = getFirstStringArg(node);
                 calls.push({
                     name: funcNode.text,
                     ...(resolvedName && { resolvedName }),
                     line: node.startPosition.row + 1,
                     isMethod: false,
                     enclosingFunction,
-                    uncertain
+                    uncertain,
+                    ...(firstArg && { firstStringArg: firstArg.value, firstStringArgInterp: firstArg.interp })
                 });
             } else if (funcNode.type === 'attribute') {
                 // Method/attribute call: obj.foo() or self.attr.foo()
@@ -653,6 +695,7 @@ function findCallsInCode(code, parser) {
                     }
 
                     const receiverType = receiver ? localVarTypes.get(receiver) : undefined;
+                    const firstArg = getFirstStringArg(node);
                     calls.push({
                         name: attrNode.text,
                         line: node.startPosition.row + 1,
@@ -661,7 +704,8 @@ function findCallsInCode(code, parser) {
                         ...(receiverType && { receiverType }),
                         ...(selfAttribute && { selfAttribute }),
                         enclosingFunction,
-                        uncertain
+                        uncertain,
+                        ...(firstArg && { firstStringArg: firstArg.value, firstStringArgInterp: firstArg.interp })
                     });
                 }
             }
@@ -1198,17 +1242,39 @@ function extractConstructorName(node) {
     return null;
 }
 
+/**
+ * Classify a Python symbol as a runtime entry point of a specific kind.
+ * Returns 'test' | 'framework' | null.
+ *
+ * - 'test': pytest discovery (`test_*` functions, methods on `Test*` classes,
+ *           `setUp`/`tearDown` lifecycle, pytest plugin hooks).
+ * - 'framework': dunder methods (`__init__`, `__repr__`, etc.) — invoked by
+ *                the Python runtime as part of the type protocol.
+ *
+ * Note: Python has no fn-level `main` entry point convention (the
+ * `if __name__ == '__main__':` guard wraps statements, not a function).
+ *
+ * Used by tracing/search so `affectedTests` only tags genuine test functions.
+ */
+function getEntryPointKind(symbol) {
+    const { name } = symbol;
+    // Test entries first — pytest naming + unittest lifecycle hooks
+    if (/^test_/.test(name)) return 'test';
+    if (/^(setUp|tearDown)(Class|Module)?$/.test(name)) return 'test';
+    if (/^pytest_/.test(name)) return 'test';
+    // Methods inside a class whose name starts with Test (unittest/pytest discovery)
+    if (symbol.isMethod && symbol.className && /^Test[A-Z_0-9]?/.test(symbol.className)) return 'test';
+    // Dunder methods are framework entries (Python protocol)
+    if (/^__\w+__$/.test(name)) return 'framework';
+    return null;
+}
+
 /**
  * Check if a symbol is a Python-convention entry point.
  * These are invoked by the Python runtime, test runners, or frameworks.
  */
 function isEntryPoint(symbol) {
-    const { name } = symbol;
-    if (/^__\w+__$/.test(name)) return true;
-    if (/^test_/.test(name)) return true;
-    if (/^(setUp|tearDown)(Class|Module)?$/.test(name)) return true;
-    if (/^pytest_/.test(name)) return true;
-    return false;
+    return getEntryPointKind(symbol) !== null;
 }
 
 module.exports = {
@@ -1221,5 +1287,6 @@ module.exports = {
     findUsagesInCode,
     findInstanceAttributeTypes,
     isEntryPoint,
+    getEntryPointKind,
     parse
 };

package/languages/rust.js

@@ -93,11 +93,98 @@ function extractAttributes(node, codeOrLines) {
     return attributes;
 }
 
+/**
+ * Extract attributes WITH their argument tokens (for routing decorator detection).
+ * Returns array of { name, args: rawArgString } objects.
+ *   #[get("/users")] → [{ name: 'get', args: '"/users"' }]
+ *   #[tokio::main] → [{ name: 'tokio::main', args: null }]
+ *
+ * @param {Node} node - Function AST node
+ * @param {string|string[]} codeOrLines - Source code or pre-split lines
+ * @returns {Array<{name: string, args: string|null}>}
+ */
+function extractAttributesWithArgs(node, codeOrLines) {
+    const result = [];
+    const lines = Array.isArray(codeOrLines) ? codeOrLines : codeOrLines.split('\n');
+
+    const startLine = node.startPosition.row;
+    for (let i = startLine - 1; i >= 0 && i >= startLine - 5; i--) {
+        const line = lines[i]?.trim();
+        if (!line) break;
+        if (line.startsWith('#[')) {
+            // Match #[name(...args...)] or #[name]
+            // Need to handle nested parens; use a simple bracket-matching approach.
+            const m = line.match(/^#\[(.+)\]\s*$/);
+            if (m) {
+                const attrContent = m[1];
+                const parenIdx = attrContent.indexOf('(');
+                if (parenIdx === -1) {
+                    result.unshift({ name: attrContent.trim(), args: null });
+                } else {
+                    const name = attrContent.slice(0, parenIdx).trim();
+                    // Extract content within outer parens (find matching close)
+                    let depth = 0;
+                    let endIdx = -1;
+                    for (let k = parenIdx; k < attrContent.length; k++) {
+                        const ch = attrContent[k];
+                        if (ch === '(') depth++;
+                        else if (ch === ')') {
+                            depth--;
+                            if (depth === 0) { endIdx = k; break; }
+                        }
+                    }
+                    const args = endIdx > parenIdx
+                        ? attrContent.slice(parenIdx + 1, endIdx).trim()
+                        : attrContent.slice(parenIdx + 1).trim();
+                    result.unshift({ name, args });
+                }
+            }
+        } else if (!line.startsWith('//')) {
+            break;
+        }
+    }
+    return result;
+}
+
 // --- Module-scope constants for state object detection ---
 const _STATE_PATTERN = /^([A-Z][A-Z0-9_]+|DEFAULT_[A-Z_]+)$/;
 
 // --- Single-pass helpers: extracted from find* callbacks ---
 
+/**
+ * Walk up AST ancestors to detect whether `node` is enclosed in a
+ * `#[cfg(test)]` (or `#[cfg(any(test, ...))]`) module. Used to flag
+ * functions inside a `mod tests` block as test entry points even when
+ * they don't carry a direct `#[test]` attribute (BUG-CY).
+ */
+function _isInsideCfgTestModule(node, lines) {
+    let parent = node.parent;
+    while (parent) {
+        if (parent.type === 'mod_item') {
+            const startRow = parent.startPosition.row;
+            // Look at preceding lines for #[cfg(test)] or #[cfg(any(test,...))] / #[cfg(all(...,test,...))]
+            for (let i = startRow - 1; i >= 0 && i >= startRow - 5; i--) {
+                const line = lines[i]?.trim();
+                if (!line) break;
+                if (line.startsWith('#[')) {
+                    // Match #[cfg(...)] forms that include a `test` predicate.
+                    // Conservatively look for the literal token `test` inside the cfg(...) args.
+                    const m = line.match(/#\[\s*cfg\s*\(([^\]]*)\)\s*\]/);
+                    if (m) {
+                        const args = m[1];
+                        // Word-boundary match for `test` to avoid matching e.g. `testing_module`.
+                        if (/\btest\b/.test(args)) return true;
+                    }
+                } else if (!line.startsWith('//')) {
+                    break;
+                }
+            }
+        }
+        parent = parent.parent;
+    }
+    return false;
+}
+
 /**
  * Process a node for function extraction (single-pass helper)
  * Returns true if node was matched, false otherwise
@@ -138,6 +225,8 @@ function _processFunction(node, functions, processedRanges, lines, code) {
             const docstring = extractRustDocstring(lines, startLine);
             const generics = extractGenerics(node);
             const attributes = extractAttributes(node, lines);
+            const attributesWithArgs = extractAttributesWithArgs(node, lines);
+            const inCfgTest = _isInsideCfgTestModule(node, lines);
 
             const modifiers = [];
             if (visibility) modifiers.push(visibility);
@@ -149,6 +238,9 @@ function _processFunction(node, functions, processedRanges, lines, code) {
             for (const attr of attributes) {
                 modifiers.push(attr);
             }
+            // Mark functions inside #[cfg(test)] modules — they are test-only code
+            // even if they lack a direct #[test] attribute (helpers used by tests).
+            if (inCfgTest) modifiers.push('cfg_test_module');
 
             functions.push({
                 name: nameNode.text,
@@ -160,7 +252,8 @@ function _processFunction(node, functions, processedRanges, lines, code) {
                 modifiers,
                 ...(returnType && { returnType }),
                 ...(docstring && { docstring }),
-                ...(generics && { generics })
+                ...(generics && { generics }),
+                ...(attributesWithArgs.length > 0 && { attributesWithArgs })
             });
         }
         return true;
@@ -695,9 +788,11 @@ function extractImplMembers(implNode, codeOrLines, typeName) {
 
                 // Extract attributes (#[test], #[inline], etc.) for impl members
                 const attributes = extractAttributes(child, codeOrLines);
+                const inCfgTest = _isInsideCfgTestModule(child, Array.isArray(codeOrLines) ? codeOrLines : codeOrLines.split('\n'));
                 const modifiers = [];
                 if (visibility) modifiers.push(visibility);
                 for (const attr of attributes) modifiers.push(attr);
+                if (inCfgTest) modifiers.push('cfg_test_module');
 
                 members.push({
                     name: nameNode.text,
@@ -760,6 +855,57 @@ function parse(code, parser) {
     return { language: 'rust', totalLines: lines.length, functions, classes, stateObjects, imports: [], exports: [] };
 }
 
+/**
+ * Walk a Rust call chain to find its root constructor type.
+ *
+ * Examples:
+ *   Router::new()                         → 'Router'
+ *   Router::new().route(...)              → 'Router'
+ *   Router::new().nest(...).route(...)    → 'Router' (recursively unwraps method chain)
+ *   axum::Router::new().route(...)        → 'Router'
+ *   foo()                                 → null (not a constructor pattern)
+ *
+ * Returns the root type name when the chain begins with `<Type>::new()` or
+ * `<Type>::*` (associated function call). Returns null otherwise.
+ *
+ * Used to detect axum's chained Router pattern where `.route(...)` is called on
+ * the result of `Router::new()` rather than a named variable.
+ *
+ * @param {Node} callNode - call_expression node
+ * @returns {string|null} root type name, or null
+ */
+function _findRustChainRootType(callNode) {
+    if (!callNode || callNode.type !== 'call_expression') return null;
+    const funcNode = callNode.childForFieldName('function');
+    if (!funcNode) return null;
+
+    // Base case: scoped path like Router::new or axum::Router::new
+    if (funcNode.type === 'scoped_identifier') {
+        const segments = funcNode.text.split('::');
+        // Need at least Type::method (associated function call)
+        if (segments.length < 2) return null;
+        // The type is the second-to-last segment (last is the method)
+        const typeName = segments[segments.length - 2];
+        // Must be a Capitalized type name (filter out module::func calls)
+        if (!/^[A-Z]/.test(typeName)) return null;
+        return typeName;
+    }
+
+    // Recursive case: chained method call on prior call result
+    //   Router::new().route(...)  →  unwrap .route(...) and recurse on Router::new()
+    if (funcNode.type === 'field_expression') {
+        const valueNode = funcNode.childForFieldName('value');
+        if (valueNode?.type === 'call_expression') {
+            return _findRustChainRootType(valueNode);
+        }
+        // Chain rooted at a named identifier: skip — we detect this elsewhere
+        // via the existing receiver-name path in bridge.js.
+        return null;
+    }
+
+    return null;
+}
+
 /**
  * Find all function calls in Rust code using tree-sitter AST
  * @param {string} code - Source code to analyze
@@ -773,6 +919,29 @@ function findCallsInCode(code, parser) {
     // Track variable -> type mappings per function scope (scopeStartLine -> Map<varName, typeName>)
     const scopeTypes = new Map();
 
+    // Helper: extract first string-arg literal from a call_expression node.
+    // Used by route extraction to capture path arg of client.get("/users") and
+    // detect format!() macro interpolation: format!("/users/{}", id).
+    const { extractStringArg: _extractStringArg } = require('./utils');
+    const getFirstStringArg = (callNode) => {
+        const argsNode = callNode.childForFieldName('arguments');
+        if (!argsNode) return null;
+        for (let i = 0; i < argsNode.namedChildCount; i++) {
+            const arg = argsNode.namedChild(i);
+            if (arg.type === 'comment') continue;
+            // format!() macro inside an arg: client.get(format!("/users/{}", id))
+            if (arg.type === 'macro_invocation') {
+                const macroNode = arg.childForFieldName('macro');
+                const macroName = macroNode ? macroNode.text.replace(/!$/, '') : '';
+                if (macroName === 'format') {
+                    return _extractStringArg(arg);
+                }
+            }
+            return _extractStringArg(arg);
+        }
+        return null;
+    };
+
     // Helper to check if a node creates a function scope
     const isFunctionNode = (node) => {
         return ['function_item', 'closure_expression'].includes(node.type);
@@ -877,11 +1046,13 @@ function findCallsInCode(code, parser) {
 
             if (funcNode.type === 'identifier') {
                 // Direct call: foo()
+                const firstArg = getFirstStringArg(node);
                 calls.push({
                     name: funcNode.text,
                     line: node.startPosition.row + 1,
                     isMethod: false,
-                    enclosingFunction
+                    enclosingFunction,
+                    ...(firstArg && { firstStringArg: firstArg.value, firstStringArgInterp: firstArg.interp })
                 });
             } else if (funcNode.type === 'field_expression') {
                 // Method call: obj.method()
@@ -889,15 +1060,37 @@ function findCallsInCode(code, parser) {
                 const valueNode = funcNode.childForFieldName('value');
 
                 if (fieldNode) {
-                    const receiver = (valueNode?.type === 'identifier' || valueNode?.type === 'self') ? valueNode.text : undefined;
+                    let receiver = (valueNode?.type === 'identifier' || valueNode?.type === 'self') ? valueNode.text : undefined;
+                    // Detect chained Router::new()-rooted method calls. axum's canonical
+                    // idiom is `Router::new().route("/p", get(h)).route(...)` where the
+                    // receiver of `.route(...)` is itself a call_expression. Walk the
+                    // chain to its root: if the chain originates at Router::new() or
+                    // any Router-typed call, set a synthetic receiver string so the
+                    // bridge layer can recognize this as a Router method invocation.
+                    if (!receiver && valueNode?.type === 'call_expression') {
+                        const rootType = _findRustChainRootType(valueNode);
+                        if (rootType) {
+                            // Synthetic marker — ROUTER_CHAIN:<RootTypeName>. The
+                            // <RootTypeName> portion lets the bridge match
+                            // /^router/i case-insensitively.
+                            receiver = rootType;
+                        }
+                    }
                     const receiverType = (receiver && receiver !== 'self') ? getReceiverType(receiver) : undefined;
+                    const firstArg = getFirstStringArg(node);
+                    // RUST-2: For chained calls like `a().b().parse::<T>().ok()`,
+                    // each method should report the line where its OWN identifier
+                    // appears, not the line where the outer expression begins.
+                    // Tree-sitter gives us fieldNode (the identifier) — use its
+                    // startPosition.row instead of the wrapping call_expression's.
                     calls.push({
                         name: fieldNode.text,
-                        line: node.startPosition.row + 1,
+                        line: fieldNode.startPosition.row + 1,
                         isMethod: true,
                         receiver,
                         ...(receiverType && { receiverType }),
-                        enclosingFunction
+                        enclosingFunction,
+                        ...(firstArg && { firstStringArg: firstArg.value, firstStringArgInterp: firstArg.interp })
                     });
                 }
             } else if (funcNode.type === 'scoped_identifier') {
@@ -906,18 +1099,57 @@ function findCallsInCode(code, parser) {
                 const pathText = funcNode.text;
                 const segments = pathText.split('::');
                 const name = segments[segments.length - 1];
+                const firstArg = getFirstStringArg(node);
                 calls.push({
                     name: name,
                     line: node.startPosition.row + 1,
                     isMethod: segments.length > 1,
                     isPathCall: true,  // Distinguishes Type::func()/module::func() from obj.method()
                     receiver: segments.length > 1 ? segments.slice(0, -1).join('::') : undefined,
-                    enclosingFunction
+                    enclosingFunction,
+                    ...(firstArg && { firstStringArg: firstArg.value, firstStringArgInterp: firstArg.interp })
                 });
             }
             return true;
         }
 
+        // R3-NEW-3: Detect Rust struct expressions as constructor calls.
+        //   Foo { x: 1 }      → call(name='Foo', isConstructor:true)
+        //   path::Foo { ... } → call(name='Foo', isConstructor:true) — strip path
+        //   Foo::Variant { } (enum struct variant) → name=Variant, receiver=Foo
+        //
+        // Detection happens as a separate AST node visit, so it doesn't conflict
+        // with existing call/method handlers.
+        if (node.type === 'struct_expression') {
+            const nameNode = node.childForFieldName('name');
+            if (nameNode) {
+                let typeName = null;
+                if (nameNode.type === 'type_identifier') {
+                    typeName = nameNode.text;
+                } else if (nameNode.type === 'scoped_type_identifier') {
+                    // path::Foo or Enum::Variant — emit as the rightmost name.
+                    const innerNameNode = nameNode.childForFieldName('name');
+                    if (innerNameNode) {
+                        typeName = innerNameNode.text;
+                    } else {
+                        // Fallback: split by ::
+                        const parts = nameNode.text.split('::');
+                        typeName = parts[parts.length - 1];
+                    }
+                }
+                if (typeName) {
+                    const enclosingFunction = getCurrentEnclosingFunction();
+                    calls.push({
+                        name: typeName,
+                        line: node.startPosition.row + 1,
+                        isMethod: false,
+                        isConstructor: true,
+                        enclosingFunction
+                    });
+                }
+            }
+        }
+
         // Handle macro invocations: println!(), vec![]
         if (node.type === 'macro_invocation') {
             const macroNode = node.childForFieldName('macro');
@@ -950,9 +1182,10 @@ function findCallsInCode(code, parser) {
                     const receiver = (valueNode?.type === 'identifier' || valueNode?.type === 'self') ? valueNode.text : undefined;
                     const receiverType = (receiver && receiver !== 'self') ? getReceiverType(receiver) : undefined;
                     const enclosingFunction = getCurrentEnclosingFunction();
+                    // RUST-2: use the field identifier's line, not the wrapping field_expression's
                     calls.push({
                         name: fieldNode.text,
-                        line: node.startPosition.row + 1,
+                        line: fieldNode.startPosition.row + 1,
                         isMethod: true,
                         receiver,
                         ...(receiverType && { receiverType }),
@@ -1499,16 +1732,37 @@ function findUsagesInCode(code, name, parser) {
     return usages;
 }
 
+/**
+ * Classify a Rust symbol as a runtime entry point of a specific kind.
+ * Returns 'test' | 'main' | 'framework' | null.
+ *
+ * - 'test': harness-invoked — #[test], #[bench], or anything inside a
+ *           #[cfg(test)] module (which only compiles for `cargo test`).
+ * - 'main': program entry — fn main()
+ * - 'framework': trait-impl methods (invoked by the trait contract holder)
+ *
+ * Used by tracing/search to distinguish test-coverage producers from runtime
+ * entry points so `affectedTests` doesn't mis-tag fn main() as a test case.
+ */
+function getEntryPointKind(symbol) {
+    const m = symbol.modifiers || [];
+    // Test entries first — #[test]/#[bench] take precedence even over fn main().
+    if (m.includes('test') || m.includes('bench')) return 'test';
+    // Functions inside #[cfg(test)] mod blocks — test-only code, even if they
+    // lack a direct #[test] attribute (e.g. shared helpers in `mod tests`).
+    if (m.includes('cfg_test_module')) return 'test';
+    if (symbol.name === 'main') return 'main';
+    // Trait-impl methods are framework entry points (invoked by trait holder).
+    if (symbol.isMethod && symbol.className && symbol.traitImpl) return 'framework';
+    return null;
+}
+
 /**
  * Check if a symbol is a Rust-convention entry point.
  * These are invoked by the Rust runtime, test harness, or required by trait contracts.
  */
 function isEntryPoint(symbol) {
-    const m = symbol.modifiers || [];
-    if (symbol.name === 'main') return true;
-    if (m.includes('test') || m.includes('bench')) return true;
-    if (symbol.isMethod && symbol.className && symbol.traitImpl) return true;
-    return false;
+    return getEntryPointKind(symbol) !== null;
 }
 
 module.exports = {
@@ -1520,5 +1774,6 @@ module.exports = {
     findExportsInCode,
     findUsagesInCode,
     isEntryPoint,
+    getEntryPointKind,
     parse
 };