@generaltranslation/python-extractor 0.0.0

package/dist/parseStringExpression.js

@@ -0,0 +1,607 @@
+import { PYTHON_DECLARE_STATIC, PYTHON_DECLARE_VAR } from './constants.js';
+import { resolveFunctionInCurrentFile, resolveFunctionInFile, } from './resolveFunctionVariants.js';
+import { resolveImportPath } from './resolveImport.js';
+import { declareVar } from 'generaltranslation/internal';
+/**
+ * Checks if an expression contains declare_static or declare_var calls.
+ */
+export function containsStaticCalls(node, imports) {
+    const staticNames = getStaticImportNames(imports);
+    if (staticNames.size === 0)
+        return false;
+    return hasStaticCallRecursive(node, staticNames);
+}
+function hasStaticCallRecursive(node, names) {
+    if (node.type === 'call') {
+        const funcNode = node.childForFieldName('function');
+        if (funcNode &&
+            funcNode.type === 'identifier' &&
+            names.has(funcNode.text)) {
+            return true;
+        }
+    }
+    for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child && hasStaticCallRecursive(child, names))
+            return true;
+    }
+    return false;
+}
+/**
+ * Parses the first argument of t() into a StringNode tree.
+ * Handles: plain strings, f-strings with declare_static/declare_var,
+ * binary + concatenation, and standalone declare_static calls.
+ */
+export async function parseStringExpression(node, ctx) {
+    // Plain string (no f-string)
+    if (node.type === 'string' && !isFString(node)) {
+        const content = extractStringContent(node);
+        if (content === undefined)
+            return null;
+        return { type: 'text', text: content };
+    }
+    // F-string with interpolations
+    if (node.type === 'string' && isFString(node)) {
+        return parseFString(node, ctx);
+    }
+    // Binary operator: string concatenation with +
+    if (node.type === 'binary_operator') {
+        return parseBinaryOperator(node, ctx);
+    }
+    // Standalone call: declare_static(...)
+    if (node.type === 'call') {
+        const funcNode = node.childForFieldName('function');
+        if (funcNode && funcNode.type === 'identifier') {
+            const originalName = getOriginalImportName(funcNode.text, ctx.imports);
+            if (originalName === PYTHON_DECLARE_STATIC) {
+                return resolveDeclareStaticArg(node, ctx);
+            }
+            if (originalName === PYTHON_DECLARE_VAR) {
+                return resolveDeclareVarArg(node, ctx);
+            }
+        }
+    }
+    ctx.errors.push(`${locationStr(node)}: unsupported expression type "${node.type}" in translation call`);
+    return null;
+}
+/**
+ * Parses an f-string into a StringNode tree.
+ * string_content → text nodes, interpolation → check for declare_static/declare_var
+ */
+async function parseFString(node, ctx) {
+    const parts = [];
+    for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (!child)
+            continue;
+        if (child.type === 'string_content') {
+            if (child.text.length > 0) {
+                parts.push({ type: 'text', text: child.text });
+            }
+            continue;
+        }
+        if (child.type === 'interpolation') {
+            const result = await parseInterpolation(child, ctx);
+            if (result) {
+                parts.push(result);
+            }
+            continue;
+        }
+        // Skip string_start, string_end, etc.
+    }
+    if (parts.length === 0)
+        return { type: 'text', text: '' };
+    if (parts.length === 1)
+        return parts[0];
+    return { type: 'sequence', nodes: parts };
+}
+/**
+ * Parses an interpolation within an f-string.
+ * Must be a declare_static() or declare_var() call.
+ */
+async function parseInterpolation(interpNode, ctx) {
+    // Find the expression inside the interpolation (skip { and })
+    let expr = null;
+    for (let i = 0; i < interpNode.childCount; i++) {
+        const child = interpNode.child(i);
+        if (child &&
+            child.type !== '{' &&
+            child.type !== '}' &&
+            child.type !== 'type_conversion' &&
+            child.type !== 'format_specifier') {
+            expr = child;
+            break;
+        }
+    }
+    if (!expr) {
+        ctx.errors.push(`${locationStr(interpNode)}: empty interpolation in f-string`);
+        return null;
+    }
+    if (expr.type === 'call') {
+        const funcNode = expr.childForFieldName('function');
+        if (funcNode && funcNode.type === 'identifier') {
+            const originalName = getOriginalImportName(funcNode.text, ctx.imports);
+            if (originalName === PYTHON_DECLARE_STATIC) {
+                return resolveDeclareStaticArg(expr, ctx);
+            }
+            if (originalName === PYTHON_DECLARE_VAR) {
+                return resolveDeclareVarArg(expr, ctx);
+            }
+        }
+    }
+    // Not a declare_static/declare_var call — error
+    ctx.errors.push(`${locationStr(interpNode)}: f-string interpolation must use declare_static() or declare_var(), got "${expr.text}"`);
+    return null;
+}
+/**
+ * Parses binary + concatenation into a sequence node.
+ */
+async function parseBinaryOperator(node, ctx) {
+    const left = node.childForFieldName('left');
+    const operator = node.childForFieldName('operator');
+    const right = node.childForFieldName('right');
+    if (!left || !right) {
+        ctx.errors.push(`${locationStr(node)}: binary operator missing operands`);
+        return null;
+    }
+    // Verify it's a + operator
+    if (operator && operator.text !== '+') {
+        ctx.errors.push(`${locationStr(node)}: unsupported binary operator "${operator.text}" in translation call`);
+        return null;
+    }
+    const leftNode = await parseStringExpression(left, ctx);
+    const rightNode = await parseStringExpression(right, ctx);
+    if (!leftNode || !rightNode)
+        return null;
+    // Flatten nested sequences
+    const parts = [];
+    if (leftNode.type === 'sequence') {
+        parts.push(...leftNode.nodes);
+    }
+    else {
+        parts.push(leftNode);
+    }
+    if (rightNode.type === 'sequence') {
+        parts.push(...rightNode.nodes);
+    }
+    else {
+        parts.push(rightNode);
+    }
+    return { type: 'sequence', nodes: parts };
+}
+/**
+ * Resolves the argument of a declare_static() call into a StringNode.
+ * Handles: string literals, ternary expressions, function calls.
+ */
+async function resolveDeclareStaticArg(callNode, ctx) {
+    const arg = getFirstPositionalArg(callNode);
+    if (!arg) {
+        ctx.errors.push(`${locationStr(callNode)}: declare_static() requires an argument`);
+        return null;
+    }
+    return resolveStaticValue(arg, ctx);
+}
+/**
+ * Resolves a value expression that should produce string variants.
+ * Handles: string literals, ternary, function calls, binary concat,
+ * and declare_var() calls (nested inside declare_static).
+ */
+async function resolveStaticValue(node, ctx) {
+    // Parenthesized expression: unwrap and recurse
+    if (node.type === 'parenthesized_expression') {
+        for (let i = 0; i < node.childCount; i++) {
+            const child = node.child(i);
+            if (child && child.type !== '(' && child.type !== ')') {
+                return resolveStaticValue(child, ctx);
+            }
+        }
+        return null;
+    }
+    // String literal
+    if (node.type === 'string' && !isFString(node)) {
+        const content = extractStringContent(node);
+        if (content === undefined)
+            return null;
+        return { type: 'text', text: content };
+    }
+    // Ternary / conditional expression: "day" if cond else "night"
+    if (node.type === 'conditional_expression') {
+        return resolveConditional(node, ctx);
+    }
+    // Binary operator: string concatenation with +
+    if (node.type === 'binary_operator') {
+        return resolveStaticBinaryOperator(node, ctx);
+    }
+    // Function call — could be a user function or declare_var()
+    if (node.type === 'call') {
+        const funcNode = node.childForFieldName('function');
+        if (funcNode && funcNode.type === 'identifier') {
+            const originalName = getOriginalImportName(funcNode.text, ctx.imports);
+            if (originalName === PYTHON_DECLARE_VAR) {
+                return resolveDeclareVarArg(node, ctx);
+            }
+        }
+        return resolveFunctionCall(node, ctx);
+    }
+    ctx.errors.push(`${locationStr(node)}: unsupported declare_static argument type "${node.type}"`);
+    return null;
+}
+/**
+ * Handles binary + concatenation within a static value context.
+ */
+async function resolveStaticBinaryOperator(node, ctx) {
+    const left = node.childForFieldName('left');
+    const right = node.childForFieldName('right');
+    if (!left || !right) {
+        ctx.errors.push(`${locationStr(node)}: binary operator missing operands`);
+        return null;
+    }
+    // Check for + operator (tree-sitter may not expose operator as a named field)
+    // Look for a non-expression child that is '+'
+    let isPlus = true;
+    for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child &&
+            child.type !== 'identifier' &&
+            child.type !== 'string' &&
+            child.type !== 'call' &&
+            child.type !== 'binary_operator' &&
+            child.type !== 'conditional_expression' &&
+            child.type !== 'parenthesized_expression') {
+            if (child.text !== '+') {
+                isPlus = false;
+            }
+        }
+    }
+    if (!isPlus) {
+        ctx.errors.push(`${locationStr(node)}: unsupported binary operator in static expression`);
+        return null;
+    }
+    const leftNode = await resolveStaticValue(left, ctx);
+    const rightNode = await resolveStaticValue(right, ctx);
+    if (!leftNode || !rightNode)
+        return null;
+    // Flatten nested sequences
+    const parts = [];
+    if (leftNode.type === 'sequence') {
+        parts.push(...leftNode.nodes);
+    }
+    else {
+        parts.push(leftNode);
+    }
+    if (rightNode.type === 'sequence') {
+        parts.push(...rightNode.nodes);
+    }
+    else {
+        parts.push(rightNode);
+    }
+    return { type: 'sequence', nodes: parts };
+}
+/**
+ * Resolves a Python conditional expression (ternary):
+ * "day" if cond else "night"
+ * tree-sitter: conditional_expression → [consequent, if, condition, else, alternate]
+ */
+async function resolveConditional(node, ctx) {
+    // In Python's tree-sitter, the conditional_expression fields are:
+    // body = consequent (the value if true)
+    // condition = the test
+    // alternative = the else value (named 'alternative' field)
+    // But field names vary by tree-sitter version. Let's use positional children.
+    // Structure: consequent "if" condition "else" alternative
+    // The tree-sitter Python grammar uses named children:
+    // body (first expression), if keyword, condition, else keyword, alternative
+    // But let's find them by field name first, then fall back to positional.
+    // Try using children directly: first non-keyword child is consequent,
+    // child after "else" keyword is alternate
+    let consequent = null;
+    let alternate = null;
+    let seenElse = false;
+    for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (!child)
+            continue;
+        if (child.type === 'if')
+            continue;
+        if (child.type === 'else') {
+            seenElse = true;
+            continue;
+        }
+        if (!seenElse && !consequent) {
+            consequent = child;
+        }
+        else if (seenElse && !alternate) {
+            alternate = child;
+        }
+    }
+    if (!consequent || !alternate) {
+        ctx.errors.push(`${locationStr(node)}: could not parse conditional expression`);
+        return null;
+    }
+    // Recursively resolve both branches (handles nested ternaries)
+    const consequentNode = await resolveStaticValue(consequent, ctx);
+    const alternateNode = await resolveStaticValue(alternate, ctx);
+    if (!consequentNode || !alternateNode)
+        return null;
+    // Flatten choices
+    const branches = [];
+    if (consequentNode.type === 'choice') {
+        branches.push(...consequentNode.nodes);
+    }
+    else {
+        branches.push(consequentNode);
+    }
+    if (alternateNode.type === 'choice') {
+        branches.push(...alternateNode.nodes);
+    }
+    else {
+        branches.push(alternateNode);
+    }
+    return { type: 'choice', nodes: branches };
+}
+/**
+ * Resolves a function call to its string return variants.
+ * Looks up the function locally, then in imported files.
+ */
+async function resolveFunctionCall(callNode, ctx) {
+    const funcNode = callNode.childForFieldName('function');
+    if (!funcNode || funcNode.type !== 'identifier') {
+        ctx.errors.push(`${locationStr(callNode)}: cannot resolve non-identifier function call`);
+        return null;
+    }
+    const funcName = funcNode.text;
+    // Expression parser callback for resolving return expressions.
+    // For local functions, use the current context's imports.
+    // For cross-file, build context from the target file's imports.
+    const makeExprParser = (targetCtx) => {
+        return (node, _rootNode) => resolveStaticValue(node, targetCtx);
+    };
+    // Try resolving in current file
+    const localResult = await resolveFunctionInCurrentFile(funcName, ctx.rootNode, makeExprParser(ctx));
+    if (localResult)
+        return localResult;
+    // Try resolving from imports
+    const importInfo = findImportForName(funcName, ctx);
+    if (importInfo) {
+        // Build a context for the target file
+        const targetCtx = {
+            rootNode: ctx.rootNode, // Will be replaced by the actual target rootNode inside resolveFunctionInFile
+            imports: ctx.imports, // Use caller's imports as fallback
+            filePath: importInfo.filePath,
+            errors: ctx.errors,
+        };
+        const result = await resolveFunctionInFile(importInfo.originalName, importInfo.filePath, async (node, targetRootNode) => {
+            // Build proper context using target file's root and imports
+            const targetImports = extractImportsFromRoot(targetRootNode, ctx.imports);
+            return resolveStaticValue(node, {
+                rootNode: targetRootNode,
+                imports: targetImports,
+                filePath: importInfo.filePath,
+                errors: ctx.errors,
+            });
+        });
+        if (result)
+            return result;
+    }
+    ctx.errors.push(`${locationStr(callNode)}: could not resolve function "${funcName}" to string return values`);
+    return null;
+}
+/**
+ * Extracts import aliases from a target file's root node.
+ * Merges with parent imports for GT package functions (declare_var, etc.)
+ * that may not be imported in the target file.
+ */
+function extractImportsFromRoot(rootNode, parentImports) {
+    // Import extractImports dynamically to avoid issues
+    const result = [];
+    // Carry over GT package imports from the calling context
+    // (declare_var, declare_static may be used without importing in helper files
+    // if passed through function calls, but the name resolution still needs them)
+    for (const imp of parentImports) {
+        if (imp.originalName === PYTHON_DECLARE_STATIC ||
+            imp.originalName === PYTHON_DECLARE_VAR) {
+            result.push(imp);
+        }
+    }
+    // Also check the target file's own imports for GT functions
+    for (let i = 0; i < rootNode.childCount; i++) {
+        const node = rootNode.child(i);
+        if (!node || node.type !== 'import_from_statement')
+            continue;
+        const moduleName = getModuleName(node);
+        if (!moduleName)
+            continue;
+        for (let j = 0; j < node.childCount; j++) {
+            const child = node.child(j);
+            if (!child)
+                continue;
+            if (child.type === 'dotted_name' && child.text !== moduleName) {
+                result.push({
+                    localName: child.text,
+                    originalName: child.text,
+                    packageName: moduleName,
+                });
+            }
+            else if (child.type === 'aliased_import') {
+                const nameNode = child.childForFieldName('name');
+                const aliasNode = child.childForFieldName('alias');
+                if (nameNode) {
+                    result.push({
+                        localName: aliasNode?.text ?? nameNode.text,
+                        originalName: nameNode.text,
+                        packageName: moduleName,
+                    });
+                }
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Resolves the argument of a declare_var() call.
+ * Produces ICU placeholder text using declareVar from generaltranslation.
+ */
+async function resolveDeclareVarArg(callNode, ctx) {
+    const argsNode = callNode.childForFieldName('arguments');
+    if (!argsNode) {
+        ctx.errors.push(`${locationStr(callNode)}: declare_var() requires arguments`);
+        return null;
+    }
+    // Get the first positional arg (the variable - we use empty string since it's runtime)
+    const firstArg = getFirstPositionalArg(callNode);
+    if (!firstArg) {
+        ctx.errors.push(`${locationStr(callNode)}: declare_var() requires a variable argument`);
+        return null;
+    }
+    // Extract optional _name kwarg
+    let nameOption;
+    for (let i = 0; i < argsNode.childCount; i++) {
+        const child = argsNode.child(i);
+        if (!child || child.type !== 'keyword_argument')
+            continue;
+        const nameNode = child.childForFieldName('name');
+        const valueNode = child.childForFieldName('value');
+        if (!nameNode || !valueNode)
+            continue;
+        if (nameNode.text === '_name') {
+            if (valueNode.type === 'string' && !isFString(valueNode)) {
+                nameOption = extractStringContent(valueNode);
+            }
+        }
+    }
+    // Use declareVar with empty string for the runtime variable value
+    const options = nameOption ? { $name: nameOption } : undefined;
+    const icuText = declareVar('', options);
+    return { type: 'text', text: icuText };
+}
+// ===== Helpers ===== //
+function getFirstPositionalArg(callNode) {
+    const argsNode = callNode.childForFieldName('arguments');
+    if (!argsNode)
+        return null;
+    for (let i = 0; i < argsNode.childCount; i++) {
+        const child = argsNode.child(i);
+        if (child &&
+            child.type !== '(' &&
+            child.type !== ')' &&
+            child.type !== ',' &&
+            child.type !== 'keyword_argument') {
+            return child;
+        }
+    }
+    return null;
+}
+function getOriginalImportName(localName, imports) {
+    for (const imp of imports) {
+        if (imp.localName === localName) {
+            return imp.originalName;
+        }
+    }
+    return null;
+}
+function getStaticImportNames(imports) {
+    const names = new Set();
+    for (const imp of imports) {
+        if (imp.originalName === PYTHON_DECLARE_STATIC ||
+            imp.originalName === PYTHON_DECLARE_VAR) {
+            names.add(imp.localName);
+        }
+    }
+    return names;
+}
+/**
+ * Finds import info for a given local name (for cross-file function resolution).
+ * Only looks at non-GT imports (user function imports).
+ */
+function findImportForName(localName, ctx) {
+    // Walk the AST to find import_from_statement nodes
+    for (let i = 0; i < ctx.rootNode.childCount; i++) {
+        const node = ctx.rootNode.child(i);
+        if (!node || node.type !== 'import_from_statement')
+            continue;
+        const moduleName = getModuleName(node);
+        if (!moduleName)
+            continue;
+        // Check all imported names in this statement
+        for (let j = 0; j < node.childCount; j++) {
+            const child = node.child(j);
+            if (!child)
+                continue;
+            if (child.type === 'aliased_import') {
+                const nameNode = child.childForFieldName('name');
+                const aliasNode = child.childForFieldName('alias');
+                const importedName = nameNode?.text;
+                const alias = aliasNode?.text ?? importedName;
+                if (alias === localName && importedName) {
+                    const filePath = resolveImportPath(moduleName, ctx.filePath);
+                    if (filePath) {
+                        return { originalName: importedName, filePath };
+                    }
+                }
+            }
+            else if (child.type === 'dotted_name') {
+                if (child.text === moduleName)
+                    continue; // Skip module name itself
+                if (child.text === localName) {
+                    const filePath = resolveImportPath(moduleName, ctx.filePath);
+                    if (filePath) {
+                        return { originalName: localName, filePath };
+                    }
+                }
+            }
+        }
+    }
+    return null;
+}
+function getModuleName(importNode) {
+    const moduleNode = importNode.childForFieldName('module_name');
+    if (moduleNode)
+        return moduleNode.text;
+    for (let i = 0; i < importNode.childCount; i++) {
+        const child = importNode.child(i);
+        if (!child)
+            continue;
+        if (child.type === 'import')
+            break;
+        if (child.type === 'dotted_name')
+            return child.text;
+        if (child.type === 'relative_import')
+            return child.text;
+    }
+    return undefined;
+}
+function isFString(stringNode) {
+    for (let i = 0; i < stringNode.childCount; i++) {
+        const child = stringNode.child(i);
+        if (child && child.type === 'string_start') {
+            return /^[fF]/.test(child.text);
+        }
+        if (child && child.type === 'interpolation') {
+            return true;
+        }
+    }
+    return false;
+}
+function extractStringContent(stringNode) {
+    for (let i = 0; i < stringNode.childCount; i++) {
+        const child = stringNode.child(i);
+        if (child && child.type === 'string_content') {
+            return child.text;
+        }
+    }
+    let hasStart = false;
+    let hasEnd = false;
+    for (let i = 0; i < stringNode.childCount; i++) {
+        const child = stringNode.child(i);
+        if (child?.type === 'string_start')
+            hasStart = true;
+        if (child?.type === 'string_end')
+            hasEnd = true;
+    }
+    if (hasStart && hasEnd)
+        return '';
+    return undefined;
+}
+function locationStr(node) {
+    return `line ${node.startPosition.row + 1}, col ${node.startPosition.column}`;
+}

package/dist/parser.d.ts

@@ -0,0 +1,8 @@
+import { Parser } from 'web-tree-sitter';
+/**
+ * Lazily initializes and returns a singleton tree-sitter Parser
+ * configured for Python.
+ */
+export declare function getParser(): Promise<Parser>;
+export type { Parser };
+export { type Tree, type Node as SyntaxNode } from 'web-tree-sitter';

package/dist/parser.js

@@ -0,0 +1,22 @@
+import { Parser, Language } from 'web-tree-sitter';
+import { createRequire } from 'module';
+let parserPromise = null;
+/**
+ * Lazily initializes and returns a singleton tree-sitter Parser
+ * configured for Python.
+ */
+export function getParser() {
+    if (!parserPromise) {
+        parserPromise = initParser();
+    }
+    return parserPromise;
+}
+async function initParser() {
+    await Parser.init();
+    const parser = new Parser();
+    const require = createRequire(import.meta.url);
+    const wasmPath = require.resolve('tree-sitter-python/tree-sitter-python.wasm');
+    const Python = await Language.load(wasmPath);
+    parser.setLanguage(Python);
+    return parser;
+}

package/dist/resolveFunctionVariants.d.ts

@@ -0,0 +1,20 @@
+import type { SyntaxNode } from './parser.js';
+import type { StringNode } from './stringNode.js';
+/**
+ * Callback to parse a return expression into a StringNode.
+ * Provided by the caller so function resolution doesn't need to know about
+ * declare_var, declare_static, imports, etc.
+ */
+export type ExpressionParser = (node: SyntaxNode, rootNode: SyntaxNode) => Promise<StringNode | null>;
+/**
+ * Resolves all return values of a function defined in the current file's AST.
+ * Uses the provided expression parser to handle complex return expressions
+ * (concat, declare_var, etc.).
+ */
+export declare function resolveFunctionInCurrentFile(functionName: string, rootNode: SyntaxNode, parseExpr: ExpressionParser): Promise<StringNode | null>;
+/**
+ * Resolves all return values of a function defined in an external file.
+ * Results are cached by filePath::functionName.
+ */
+export declare function resolveFunctionInFile(functionName: string, filePath: string, parseExpr: ExpressionParser): Promise<StringNode | null>;
+export declare function clearFunctionCache(): void;