@ugo-studio/jspp 0.2.3 → 0.2.5

package/dist/core/codegen/declaration-handlers.js

@@ -1,5 +1,5 @@
 import ts from "typescript";
-import { CodeGenerator } from "./";
+import { CodeGenerator } from "./index.js";
 export function visitVariableDeclarationList(node, context) {
     return node.declarations
         .map((d) => this.visit(d, context))
@@ -12,27 +12,50 @@ export function visitVariableDeclaration(node, context) {
     const scope = this.getScopeForNode(varDecl);
     const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(name, scope);
     // Mark the symbol as checked
-    this.markSymbolAsChecked(name, context.topLevelScopeSymbols, context.localScopeSymbols);
+    this.markSymbolAsInitialized(name, context.globalScopeSymbols, context.localScopeSymbols);
+    let nativeLambdaCode = "";
     let initializer = "";
+    let shouldSkipDeref = false;
     if (varDecl.initializer) {
         const initExpr = varDecl.initializer;
-        const initContext = {
-            ...context,
-            lambdaName: ts.isArrowFunction(initExpr) ? name : undefined, // Pass the variable name for arrow functions
-        };
         let initText = ts.isNumericLiteral(initExpr)
             ? initExpr.getText()
-            : this.visit(initExpr, initContext);
+            : this.visit(initExpr, context);
         if (ts.isIdentifier(initExpr)) {
             const initScope = this.getScopeForNode(initExpr);
             const initTypeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(initExpr.text, initScope);
             const varName = this.getJsVarName(initExpr);
+            // Check if both target and initializer are heap allocated
+            if (typeInfo.needsHeapAllocation &&
+                initTypeInfo?.needsHeapAllocation) {
+                shouldSkipDeref = true;
+            }
             if (initTypeInfo &&
                 !initTypeInfo.isParameter &&
-                !initTypeInfo.isBuiltin) {
-                initText = this.getDerefCode(initText, varName, initContext, initTypeInfo);
+                !initTypeInfo.isBuiltin &&
+                !shouldSkipDeref) {
+                initText = this.getDerefCode(initText, varName, context, initTypeInfo);
             }
         }
+        else if (ts.isArrowFunction(initExpr)) {
+            const initContext = {
+                ...context,
+                lambdaName: name, // Use the variable name as function name
+            };
+            // Generate and update self name
+            const nativeName = this.generateUniqueName(`__${name}_native_`, context.localScopeSymbols, context.globalScopeSymbols);
+            context.localScopeSymbols.update(name, { func: { nativeName } });
+            // Generate lambda
+            const lambda = this.generateLambda(initExpr, initContext, {
+                isAssignment: true,
+                generateOnlyLambda: true,
+                nativeName,
+            });
+            nativeLambdaCode =
+                `auto ${nativeName} = ${lambda};\n${this.indent()}`;
+            // Generate AnyValue wrapper
+            initText = this.generateFullLambdaExpression(initExpr, initContext, nativeName, { isAssignment: true, noTypeSignature: true });
+        }
         initializer = " = " + initText;
     }
     const isLetOrConst = (varDecl.parent.flags & (ts.NodeFlags.Let | ts.NodeFlags.Const)) !== 0;
@@ -40,19 +63,21 @@ export function visitVariableDeclaration(node, context) {
         (!context.localScopeSymbols.has(name));
     const assignmentTarget = shouldDeref
         ? this.getDerefCode(name, name, context, typeInfo)
-        : (typeInfo.needsHeapAllocation ? `*${name}` : name);
+        : (typeInfo.needsHeapAllocation && !shouldSkipDeref
+            ? `*${name}`
+            : name);
     if (isLetOrConst) {
         // If there's no initializer, it should be assigned undefined.
         if (!initializer) {
-            return `${assignmentTarget} = jspp::Constants::UNDEFINED`;
+            return `${nativeLambdaCode}${assignmentTarget} = jspp::Constants::UNDEFINED`;
         }
-        return `${assignmentTarget}${initializer}`;
+        return `${nativeLambdaCode}${assignmentTarget}${initializer}`;
     }
     // For 'var', it's a bit more complex.
     if (context.isAssignmentOnly) {
         if (!initializer)
             return "";
-        return `${assignmentTarget}${initializer}`;
+        return `${nativeLambdaCode}${assignmentTarget}${initializer}`;
     }
     else {
         // This case should not be hit with the new hoisting logic,

package/dist/core/codegen/expression-handlers.js

@@ -1,5 +1,5 @@
 import ts from "typescript";
-import { CodeGenerator } from "./";
+import { CodeGenerator } from "./index.js";
 export function visitObjectPropertyName(node, context) {
     if (ts.isNumericLiteral(node)) {
         return context.isBracketNotationPropertyAccess
@@ -28,6 +28,13 @@ export function visitObjectPropertyName(node, context) {
 export function visitObjectLiteralExpression(node, context) {
     const obj = node;
     const objVar = this.generateUniqueName("__obj_", this.getDeclaredSymbols(node));
+    if (!obj.properties.some((prop) => ts.isPropertyAssignment(prop) ||
+        ts.isShorthandPropertyAssignment(prop) ||
+        ts.isMethodDeclaration(prop) || ts.isGetAccessor(prop) ||
+        ts.isSetAccessor(prop))) {
+        // Empty object
+        return `jspp::AnyValue::make_object_with_proto({}, ::Object.get_own_property("prototype"))`;
+    }
     let code = `([&]() {\n`;
     code +=
         `${this.indent()}  auto ${objVar} = jspp::AnyValue::make_object_with_proto({}, ::Object.get_own_property("prototype"));\n`;
@@ -102,8 +109,6 @@ export function visitObjectLiteralExpression(node, context) {
         }
     }
     this.indentationLevel--;
-    // code +=
-    //     `${this.indent()}  ${returnCmd} ${objVar};\n${this.indent()}} )() ))`;
     code += `${this.indent()}  return ${objVar};\n${this.indent()}})()`;
     return code;
 }
@@ -439,6 +444,21 @@ export function visitBinaryExpression(node, context) {
         const target = context.derefBeforeAssignment
             ? this.getDerefCode(leftText, leftText, context, typeInfo)
             : (typeInfo.needsHeapAllocation ? `*${leftText}` : leftText);
+        // Update scope symbols on variable re-assignment
+        if (ts.isIdentifier(binExpr.left)) {
+            if (!ts.isFunctionDeclaration(binExpr.right)) {
+                if (context.localScopeSymbols.has(binExpr.left.text)) {
+                    context.localScopeSymbols.update(binExpr.left.text, {
+                        func: null,
+                    });
+                }
+                else if (context.globalScopeSymbols.has(binExpr.left.text)) {
+                    context.globalScopeSymbols.update(binExpr.left.text, {
+                        func: null,
+                    });
+                }
+            }
+        }
         return `${target} ${op} ${rightText}`;
     }
     const leftText = this.visit(binExpr.left, context);
@@ -535,7 +555,7 @@ export function visitConditionalExpression(node, context) {
         ...context,
         isFunctionBody: false,
     });
-    return `is_truthy(${condition}) ? ${whenTrueStmt} : ${whenFalseStmt}`;
+    return `jspp::is_truthy(${condition}) ? ${whenTrueStmt} : ${whenFalseStmt}`;
 }
 export function visitCallExpression(node, context) {
     const callExpr = node;
@@ -645,6 +665,21 @@ export function visitCallExpression(node, context) {
             derefCallee = calleeCode;
         }
         else if (typeInfo) {
+            const name = callee.getText();
+            const symbol = context.localScopeSymbols.get(name) ??
+                context.globalScopeSymbols.get(name);
+            // Optimization: Direct lambda call
+            if (symbol && symbol.func?.nativeName) {
+                const callExpr = `${symbol.func.nativeName}(jspp::Constants::UNDEFINED, ${argsSpan})`;
+                if (symbol.func.isGenerator) {
+                    if (symbol.func.isAsync) {
+                        return `jspp::AnyValue::from_async_iterator(${callExpr})`;
+                    }
+                    return `jspp::AnyValue::from_iterator(${callExpr})`;
+                }
+                return callExpr;
+            }
+            // AnyValue function call
             derefCallee = this.getDerefCode(calleeCode, this.getJsVarName(callee), context, typeInfo);
         }
     }

package/dist/core/codegen/function-handlers.js

@@ -1,12 +1,12 @@
 import ts from "typescript";
-import { DeclaredSymbols } from "../../ast/symbols";
-import { CodeGenerator } from "./";
-import { collectFunctionScopedDeclarations } from "./helpers";
+import { DeclaredSymbols } from "../../ast/symbols.js";
+import { collectFunctionScopedDeclarations } from "./helpers.js";
+import { CodeGenerator } from "./index.js";
 export function generateLambda(node, context, options) {
-    const isAssignment = options?.isAssignment || false;
     const capture = options?.capture || "[=]";
+    const nativeName = options?.nativeName;
     const declaredSymbols = this.getDeclaredSymbols(node);
-    const argsName = this.generateUniqueName("__args_", declaredSymbols);
+    const argsName = this.generateUniqueName("__args_", declaredSymbols, context.globalScopeSymbols, context.localScopeSymbols);
     const isInsideGeneratorFunction = this.isGeneratorFunction(node);
     const isInsideAsyncFunction = this.isAsyncFunction(node);
     const returnCmd = this.getReturnCommand({
@@ -23,26 +23,25 @@ export function generateLambda(node, context, options) {
     // For generators/async, we manually copy them inside the body.
     const paramThisType = "const jspp::AnyValue&";
     const paramArgsType = "std::span<const jspp::AnyValue>";
+    const selfParamPart = nativeName ? `this auto&& ${nativeName}, ` : "";
+    const mutablePart = nativeName ? "" : "mutable ";
     const thisArgParam = isArrow
         ? "const jspp::AnyValue&" // Arrow functions use captured 'this' or are never generators in this parser context
         : `${paramThisType} ${this.globalThisVar}`;
-    let lambda = `${capture}(${thisArgParam}, ${paramArgsType} ${argsName}) mutable -> ${funcReturnType} `;
-    const topLevelScopeSymbols = this.prepareScopeSymbolsForVisit(context.topLevelScopeSymbols, context.localScopeSymbols);
+    let lambda = `${capture}(${selfParamPart}${thisArgParam}, ${paramArgsType} ${argsName}) ${mutablePart}-> ${funcReturnType} `;
+    const globalScopeSymbols = this.prepareScopeSymbolsForVisit(context.globalScopeSymbols, context.localScopeSymbols);
     const visitContext = {
+        currentScopeNode: context.currentScopeNode,
         isMainContext: false,
         isInsideFunction: true,
         isFunctionBody: false,
         lambdaName: undefined,
-        topLevelScopeSymbols,
+        globalScopeSymbols,
         localScopeSymbols: new DeclaredSymbols(),
         superClassVar: context.superClassVar,
         isInsideGeneratorFunction: isInsideGeneratorFunction,
         isInsideAsyncFunction: isInsideAsyncFunction,
     };
-    // Name of 'this' and 'args' to be used in the body.
-    // If generator/async, we use the copied versions.
-    let bodyThisVar = this.globalThisVar;
-    let bodyArgsVar = argsName;
     // Preamble to copy arguments for coroutines
     let preamble = "";
     if (isInsideGeneratorFunction || isInsideAsyncFunction) {
@@ -51,40 +50,9 @@ export function generateLambda(node, context, options) {
         if (!isArrow) {
             preamble +=
                 `${this.indent()}jspp::AnyValue ${thisCopy} = ${this.globalThisVar};\n`;
-            bodyThisVar = thisCopy;
         }
         preamble +=
             `${this.indent()}std::vector<jspp::AnyValue> ${argsCopy}(${argsName}.begin(), ${argsName}.end());\n`;
-        bodyArgsVar = argsCopy;
-        // Update visitContext to use the new 'this' variable if needed?
-        // CodeGenerator.globalThisVar is a member of the class, so we can't easily change it for the recursive visit
-        // without changing the class state or passing it down.
-        // BUT: visitThisKeyword uses `this.globalThisVar`.
-        // We need to temporarily swap `this.globalThisVar` or handle it.
-        // Actually, `this.globalThisVar` is set once in `generate`.
-        // Wait, `visitThisKeyword` uses `this.globalThisVar`.
-        // If we change the variable name for 'this', we must ensure `visitThisKeyword` generates the correct name.
-        // `generateLambda` does NOT create a new CodeGenerator instance, so `this.globalThisVar` is the global one.
-        //
-        // We need to support shadowing `globalThisVar` for the duration of the visit.
-        // The current `CodeGenerator` doesn't seem to support changing `globalThisVar` recursively easily
-        // because it's a property of the class, not `VisitContext`.
-        //
-        // However, `visitFunctionDeclaration` etc don't update `globalThisVar`.
-        // `visitThisKeyword` just returns `this.globalThisVar`.
-        //
-        // If we are inside a function, `this` should refer to the function's `this`.
-        // `this.globalThisVar` is generated in `generate()`: `__this_val__...`.
-        // And `generateLambda` uses `this.globalThisVar` as the parameter name.
-        //
-        // So, if we copy it to `__this_copy`, `visitThisKeyword` will still print `__this_val__...`.
-        // This is BAD for generators because `__this_val__...` is a reference that dies.
-        //
-        // FIX: We must reuse the SAME name for the local copy, and shadow the parameter.
-        // But we can't declare a variable with the same name as the parameter in the same scope.
-        //
-        // We can rename the PARAMETER to something else, and declare the local variable with `this.globalThisVar`.
-        //
     }
     // Adjust parameter names for generator/async to allow shadowing/copying
     let finalThisParamName = isArrow ? "" : this.globalThisVar;
@@ -100,7 +68,7 @@ export function generateLambda(node, context, options) {
         : `${paramThisType} ${finalThisParamName}`;
     // Re-construct lambda header with potentially new param names
     lambda =
-        `${capture}(${thisArgParamFinal}, ${paramArgsType} ${finalArgsParamName}) mutable -> ${funcReturnType} `;
+        `${capture}(${selfParamPart}${thisArgParamFinal}, ${paramArgsType} ${finalArgsParamName}) ${mutablePart}-> ${funcReturnType} `;
     // Regenerate preamble
     preamble = "";
     if (isInsideGeneratorFunction || isInsideAsyncFunction) {
@@ -178,7 +146,7 @@ export function generateLambda(node, context, options) {
             // Hoist var declarations in the function body
             const varDecls = collectFunctionScopedDeclarations(node.body);
             varDecls.forEach((decl) => {
-                preamble += this.hoistDeclaration(decl, visitContext.localScopeSymbols);
+                preamble += this.hoistDeclaration(decl, visitContext.localScopeSymbols, node.body);
             });
             this.indentationLevel++;
             const paramExtraction = paramExtractor(node.parameters);
@@ -215,34 +183,49 @@ export function generateLambda(node, context, options) {
     else {
         lambda += `{ ${preamble} ${returnCmd} jspp::Constants::UNDEFINED; }\n`;
     }
-    let signature = "";
-    let callable = "";
+    // Return only lambda if required
+    if (options?.generateOnlyLambda) {
+        return lambda.trimEnd();
+    }
+    return this.generateFullLambdaExpression(node, context, lambda, options);
+}
+export function generateFullLambdaExpression(node, context, lambda, options) {
+    const isAssignment = options?.isAssignment || false;
+    const noTypeSignature = options?.noTypeSignature || false;
+    const isInsideGeneratorFunction = this.isGeneratorFunction(node);
+    const isInsideAsyncFunction = this.isAsyncFunction(node);
+    const isArrow = ts.isArrowFunction(node);
+    let callable = lambda;
     let method = "";
     // Handle generator function
     if (isInsideGeneratorFunction) {
         if (isInsideAsyncFunction) {
-            signature =
-                "jspp::JsAsyncIterator<jspp::AnyValue>(const jspp::AnyValue&, std::span<const jspp::AnyValue>)";
-            callable = `std::function<${signature}>(${lambda})`;
+            if (!noTypeSignature) {
+                const signature = "jspp::JsAsyncIterator<jspp::AnyValue>(const jspp::AnyValue&, std::span<const jspp::AnyValue>)";
+                callable = `std::function<${signature}>(${lambda})`;
+            }
             method = `jspp::AnyValue::make_async_generator`;
         }
         else {
-            signature =
-                "jspp::JsIterator<jspp::AnyValue>(const jspp::AnyValue&, std::span<const jspp::AnyValue>)";
-            callable = `std::function<${signature}>(${lambda})`;
+            if (!noTypeSignature) {
+                const signature = "jspp::JsIterator<jspp::AnyValue>(const jspp::AnyValue&, std::span<const jspp::AnyValue>)";
+                callable = `std::function<${signature}>(${lambda})`;
+            }
             method = `jspp::AnyValue::make_generator`;
         }
     } // Handle async function
     else if (isInsideAsyncFunction) {
-        signature =
-            "jspp::JsPromise(const jspp::AnyValue&, std::span<const jspp::AnyValue>)";
-        callable = `std::function<${signature}>(${lambda})`;
+        if (!noTypeSignature) {
+            const signature = "jspp::JsPromise(const jspp::AnyValue&, std::span<const jspp::AnyValue>)";
+            callable = `std::function<${signature}>(${lambda})`;
+        }
         method = `jspp::AnyValue::make_async_function`;
     } // Handle normal function
     else {
-        signature =
-            `jspp::AnyValue(const jspp::AnyValue&, std::span<const jspp::AnyValue>)`;
-        callable = `std::function<${signature}>(${lambda})`;
+        if (!noTypeSignature) {
+            const signature = `jspp::AnyValue(const jspp::AnyValue&, std::span<const jspp::AnyValue>)`;
+            callable = `std::function<${signature}>(${lambda})`;
+        }
         if (options?.isClass) {
             method = `jspp::AnyValue::make_class`;
         }

package/dist/core/codegen/helpers.js

@@ -1,7 +1,7 @@
 import ts from "typescript";
-import { BUILTIN_OBJECTS, Scope } from "../../analysis/scope";
-import { DeclaredSymbols, DeclaredSymbolType } from "../../ast/symbols";
-import { CodeGenerator } from "./";
+import { BUILTIN_OBJECTS, Scope } from "../../analysis/scope.js";
+import { DeclarationType, DeclaredSymbols } from "../../ast/symbols.js";
+import { CodeGenerator } from "./index.js";
 export function isBuiltinObject(node) {
     return BUILTIN_OBJECTS.values().some((obj) => obj.name === node.text);
 }
@@ -73,7 +73,8 @@ export function escapeString(str) {
         .replace(/"/g, '\\"')
         .replace(/\n/g, "\\n")
         .replace(/\r/g, "\\r")
-        .replace(/\t/g, "\\t");
+        .replace(/\t/g, "\\t")
+        .replace(/\?/g, "\\?");
 }
 export function getJsVarName(node) {
     return `"${node.text}"`;
@@ -86,13 +87,13 @@ export function getDerefCode(nodeText, varName, context, typeInfo) {
         varName = varName + '"';
     const symbolName = varName.slice(1).slice(0, -1);
     const symbol = context.localScopeSymbols.get(symbolName) ??
-        context.topLevelScopeSymbols.get(symbolName);
-    const checkedIfUninitialized = symbol?.checkedIfUninitialized ||
+        context.globalScopeSymbols.get(symbolName);
+    const isInitialized = symbol?.checked.initialized ||
         false;
     // Mark the symbol as checked
-    this.markSymbolAsChecked(symbolName, context.topLevelScopeSymbols, context.localScopeSymbols);
+    this.markSymbolAsInitialized(symbolName, context.globalScopeSymbols, context.localScopeSymbols);
     // Apply deref code
-    if (checkedIfUninitialized) {
+    if (isInitialized) {
         if (typeInfo && typeInfo.needsHeapAllocation) {
             return `(*${nodeText})`;
         }
@@ -105,15 +106,15 @@ export function getDerefCode(nodeText, varName, context, typeInfo) {
         return `jspp::Access::deref_stack(${nodeText}, ${varName})`;
     }
 }
-export function markSymbolAsChecked(name, topLevel, local) {
+export function markSymbolAsInitialized(name, topLevel, local) {
     if (topLevel.has(name)) {
         topLevel.update(name, {
-            checkedIfUninitialized: true,
+            checked: { initialized: true },
         });
     }
     else if (local.has(name)) {
         local.update(name, {
-            checkedIfUninitialized: true,
+            checked: { initialized: true },
         });
     }
 }
@@ -122,39 +123,58 @@ export function getReturnCommand(context) {
         ? "co_return"
         : "return";
 }
-export function hoistDeclaration(decl, hoistedSymbols) {
+export function hoistDeclaration(decl, hoistedSymbols, scopeNode) {
     const name = decl.name?.getText();
     if (!name) {
         return `/* Unknown declaration name: ${ts.SyntaxKind[decl.kind]} */`;
     }
-    const isLetOrConst = (decl.parent.flags & (ts.NodeFlags.Let | ts.NodeFlags.Const)) !==
-        0;
-    // if (name === "letVal") console.log("hoistDeclaration: letVal isLetOrConst=", isLetOrConst, " flags=", decl.parent.flags);
-    const symbolType = isLetOrConst
-        ? DeclaredSymbolType.letOrConst
-        : (ts.isFunctionDeclaration(decl)
-            ? DeclaredSymbolType.function
-            : (ts.isClassDeclaration(decl)
-                ? DeclaredSymbolType.letOrConst
-                : DeclaredSymbolType.var));
+    const isLet = (decl.parent.flags & (ts.NodeFlags.Let)) !== 0;
+    const isConst = (decl.parent.flags & (ts.NodeFlags.Const)) !== 0;
+    const declType = isLet
+        ? DeclarationType.let
+        : isConst
+            ? DeclarationType.const
+            : ts.isFunctionDeclaration(decl)
+                ? DeclarationType.function
+                : ts.isClassDeclaration(decl)
+                    ? DeclarationType.class
+                    : DeclarationType.var;
     if (hoistedSymbols.has(name)) {
-        const existingType = hoistedSymbols.get(name)?.type;
-        // Don't allow multiple declaration of `letOrConst` or `function` or `class` variables
-        if (existingType === DeclaredSymbolType.letOrConst ||
-            existingType === DeclaredSymbolType.function ||
-            existingType !== symbolType) {
-            throw new SyntaxError(`Identifier '${name}' has already been declared`);
+        const existingSymbol = hoistedSymbols.get(name);
+        // Don't allow multiple declaration of `let`,`const`,`function` or `class` variables
+        if (existingSymbol?.type === DeclarationType.let ||
+            existingSymbol?.type === DeclarationType.const ||
+            existingSymbol?.type === DeclarationType.function ||
+            existingSymbol?.type === DeclarationType.class ||
+            existingSymbol?.type !== declType) {
+            throw new SyntaxError(`Identifier '${name}' has already been declared.\n\n${" ".repeat(6) + decl.getText()}\n`);
         }
         // `var` variables can be declared multiple times
         return "";
     }
-    hoistedSymbols.set(name, {
-        type: symbolType,
-        checkedIfUninitialized: false,
-    });
+    else {
+        // Add the symbol to the hoisted symbols
+        if (declType === DeclarationType.function) {
+            const isAsync = this.isAsyncFunction(decl);
+            const isGenerator = this.isGeneratorFunction(decl);
+            hoistedSymbols.add(name, {
+                type: declType,
+                func: { isAsync, isGenerator },
+            });
+            // Don't hoist functions not used as a variable
+            // they will be called with their native lambdas
+            if (!this.isFunctionUsedAsValue(decl, scopeNode) &&
+                !this.isFunctionUsedBeforeDeclaration(name, scopeNode)) {
+                return "";
+            }
+        }
+        else {
+            hoistedSymbols.add(name, { type: declType });
+        }
+    }
     const scope = this.getScopeForNode(decl);
     const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(name, scope);
-    const initializer = isLetOrConst || ts.isClassDeclaration(decl)
+    const initializer = isLet || isConst || ts.isClassDeclaration(decl)
         ? "jspp::Constants::UNINITIALIZED"
         : "jspp::Constants::UNDEFINED";
     if (typeInfo.needsHeapAllocation) {
@@ -246,3 +266,121 @@ export function collectBlockScopedDeclarations(statements) {
     }
     return decls;
 }
+export function isFunctionUsedAsValue(decl, root) {
+    const funcName = decl.name?.getText();
+    if (!funcName)
+        return false;
+    let isUsed = false;
+    const visitor = (node) => {
+        if (isUsed)
+            return;
+        if (ts.isIdentifier(node) && node.text === funcName) {
+            const scope = this.getScopeForNode(node);
+            const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(node.text, scope);
+            if (typeInfo?.declaration === decl) {
+                const parent = node.parent;
+                // Ignore declarations where the identifier is the name being declared
+                if ((ts.isFunctionDeclaration(parent) ||
+                    ts.isVariableDeclaration(parent) ||
+                    ts.isClassDeclaration(parent) ||
+                    ts.isMethodDeclaration(parent) ||
+                    ts.isParameter(parent) ||
+                    ts.isImportSpecifier(parent)) &&
+                    parent.name === node) {
+                    // Declaration, do nothing
+                } // Ignore property names (e.g. obj.funcName)
+                else if ((ts.isPropertyAccessExpression(parent) &&
+                    parent.name === node) ||
+                    (ts.isPropertyAssignment(parent) && parent.name === node)) {
+                    // Property name, do nothing
+                } // Ignore direct calls (e.g. funcName())
+                else if (ts.isCallExpression(parent) && parent.expression === node) {
+                    // Call, do nothing
+                }
+                else {
+                    // Used as a value
+                    isUsed = true;
+                }
+            }
+        }
+        if (!isUsed) {
+            ts.forEachChild(node, visitor);
+        }
+    };
+    ts.forEachChild(root, visitor);
+    return isUsed;
+}
+export function isFunctionUsedBeforeDeclaration(funcName, root) {
+    let declPos = -1;
+    let foundDecl = false;
+    // Helper to find the function declaration position
+    function findDecl(node) {
+        if (foundDecl)
+            return;
+        if (ts.isFunctionDeclaration(node) && node.name?.text === funcName) {
+            declPos = node.getStart();
+            foundDecl = true;
+        }
+        else {
+            ts.forEachChild(node, findDecl);
+        }
+    }
+    findDecl(root);
+    // If not declared in this scope (or at least not found), assume it's not a local forward-ref issue
+    if (!foundDecl)
+        return false;
+    let isUsedBefore = false;
+    function visit(node) {
+        if (isUsedBefore)
+            return;
+        if (ts.isIdentifier(node) && node.text === funcName) {
+            const parent = node.parent;
+            // Ignore declarations where the identifier is the name being declared
+            if ((ts.isFunctionDeclaration(parent) ||
+                ts.isVariableDeclaration(parent) ||
+                ts.isClassDeclaration(parent) ||
+                ts.isMethodDeclaration(parent) ||
+                ts.isParameter(parent) ||
+                ts.isImportSpecifier(parent)) &&
+                parent.name === node) {
+                // Declaration (or shadowing), do nothing
+            } // Ignore property names (e.g. obj.funcName)
+            else if ((ts.isPropertyAccessExpression(parent) &&
+                parent.name === node) ||
+                (ts.isPropertyAssignment(parent) && parent.name === node)) {
+                // Property name, do nothing
+            }
+            else {
+                // It is a usage (call or value usage)
+                const usagePos = node.getStart();
+                // Check 1: Lexically before
+                if (usagePos < declPos) {
+                    isUsedBefore = true;
+                    return;
+                }
+                // Check 2: Inside a function declared before
+                let current = parent;
+                while (current && current !== root) {
+                    if (ts.isFunctionDeclaration(current) ||
+                        ts.isMethodDeclaration(current) ||
+                        ts.isArrowFunction(current) ||
+                        ts.isFunctionExpression(current) ||
+                        ts.isGetAccessor(current) ||
+                        ts.isSetAccessor(current) ||
+                        ts.isConstructorDeclaration(current)) {
+                        if (current.getStart() < declPos) {
+                            isUsedBefore = true;
+                            return;
+                        }
+                        // Once we hit a function boundary, we stop bubbling up for this usage.
+                        break;
+                    }
+                    current = current.parent;
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(root);
+    return isUsedBefore;
+}

package/dist/core/codegen/index.js

@@ -1,7 +1,7 @@
-import { DeclaredSymbols } from "../../ast/symbols";
-import { generateLambda } from "./function-handlers";
-import { escapeString, generateUniqueExceptionName, generateUniqueName, getDeclaredSymbols, getDerefCode, getJsVarName, getReturnCommand, getScopeForNode, hoistDeclaration, indent, isAsyncFunction, isBuiltinObject, isGeneratorFunction, markSymbolAsChecked, prepareScopeSymbolsForVisit, } from "./helpers";
-import { visit } from "./visitor";
+import { DeclaredSymbols } from "../../ast/symbols.js";
+import { generateFullLambdaExpression, generateLambda, } from "./function-handlers.js";
+import { escapeString, generateUniqueExceptionName, generateUniqueName, getDeclaredSymbols, getDerefCode, getJsVarName, getReturnCommand, getScopeForNode, hoistDeclaration, indent, isAsyncFunction, isBuiltinObject, isFunctionUsedAsValue, isFunctionUsedBeforeDeclaration, isGeneratorFunction, markSymbolAsInitialized, prepareScopeSymbolsForVisit, } from "./helpers.js";
+import { visit } from "./visitor.js";
 const MODULE_NAME = "__main_function__";
 export class CodeGenerator {
     indentationLevel = 0;
@@ -25,9 +25,12 @@ export class CodeGenerator {
     isGeneratorFunction = isGeneratorFunction;
     isAsyncFunction = isAsyncFunction;
     prepareScopeSymbolsForVisit = prepareScopeSymbolsForVisit;
-    markSymbolAsChecked = markSymbolAsChecked;
+    markSymbolAsInitialized = markSymbolAsInitialized;
+    isFunctionUsedAsValue = isFunctionUsedAsValue;
+    isFunctionUsedBeforeDeclaration = isFunctionUsedBeforeDeclaration;
     // function handlers
     generateLambda = generateLambda;
+    generateFullLambdaExpression = generateFullLambdaExpression;
     /**
      * Main entry point for the code generation process.
      */
@@ -40,11 +43,12 @@ export class CodeGenerator {
         containerCode +=
             `${this.indent()}jspp::AnyValue ${this.globalThisVar} = global;\n`;
         containerCode += this.visit(ast, {
+            currentScopeNode: ast,
             isMainContext: true,
             isInsideFunction: true,
             isFunctionBody: true,
             isInsideAsyncFunction: true,
-            topLevelScopeSymbols: new DeclaredSymbols(),
+            globalScopeSymbols: new DeclaredSymbols(),
             localScopeSymbols: new DeclaredSymbols(),
         });
         this.indentationLevel--;

package/dist/core/codegen/literal-handlers.js

@@ -1,5 +1,5 @@
 import ts from "typescript";
-import { CodeGenerator } from "./";
+import { CodeGenerator } from "./index.js";
 export function visitIdentifier(node) {
     if (node.text === "NaN") {
         // return "jspp::AnyValue::make_nan()";