@ugo-studio/jspp 0.1.3 → 0.1.5

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

@@ -1,66 +1,209 @@
 import ts from "typescript";
+import { DeclaredSymbols } from "../../ast/symbols";
 import { CodeGenerator } from "./";
-export function generateLambda(node, isAssignment = false, capture = "[=]") {
+import { collectFunctionScopedDeclarations } from "./helpers";
+export function generateLambda(node, context, options) {
+    const isAssignment = options?.isAssignment || false;
+    const capture = options?.capture || "[=]";
     const declaredSymbols = this.getDeclaredSymbols(node);
     const argsName = this.generateUniqueName("__args_", declaredSymbols);
     const isInsideGeneratorFunction = this.isGeneratorFunction(node);
-    const returnCmd = this.getReturnCmd({
+    const isInsideAsyncFunction = this.isAsyncFunction(node);
+    const returnCmd = this.getReturnCommand({
         isInsideGeneratorFunction: isInsideGeneratorFunction,
+        isInsideAsyncFunction: isInsideAsyncFunction,
     });
     const funcReturnType = isInsideGeneratorFunction
         ? "jspp::JsIterator<jspp::AnyValue>"
-        : "jspp::AnyValue";
-    let lambda = `${capture}(const std::vector<jspp::AnyValue>& ${argsName}) mutable -> ${funcReturnType} `;
+        : (isInsideAsyncFunction ? "jspp::JsPromise" : "jspp::AnyValue");
+    const isArrow = ts.isArrowFunction(node);
+    // Lambda arguments are ALWAYS const references/spans to avoid copy overhead for normal functions.
+    // For generators/async, we manually copy them inside the body.
+    const paramThisType = "const jspp::AnyValue&";
+    const paramArgsType = "std::span<const jspp::AnyValue>";
+    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);
     const visitContext = {
         isMainContext: false,
         isInsideFunction: true,
         isFunctionBody: false,
+        lambdaName: undefined,
+        topLevelScopeSymbols,
+        localScopeSymbols: new DeclaredSymbols(),
+        superClassVar: context.superClassVar,
+    };
+    // 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) {
+        const thisCopy = this.generateUniqueName("__this_copy", declaredSymbols);
+        const argsCopy = this.generateUniqueName("__args_copy", declaredSymbols);
+        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;
+    let finalArgsParamName = argsName;
+    if (isInsideGeneratorFunction || isInsideAsyncFunction) {
+        if (!isArrow) {
+            finalThisParamName = this.generateUniqueName("__this_ref", declaredSymbols);
+        }
+        finalArgsParamName = this.generateUniqueName("__args_ref", declaredSymbols);
+    }
+    const thisArgParamFinal = isArrow
+        ? "const jspp::AnyValue&"
+        : `${paramThisType} ${finalThisParamName}`;
+    // Re-construct lambda header with potentially new param names
+    lambda = `${capture}(${thisArgParamFinal}, ${paramArgsType} ${finalArgsParamName}) mutable -> ${funcReturnType} `;
+    // Regenerate preamble
+    preamble = "";
+    if (isInsideGeneratorFunction || isInsideAsyncFunction) {
+        if (!isArrow) {
+            preamble += `${this.indent()}jspp::AnyValue ${this.globalThisVar} = ${finalThisParamName};\n`;
+        }
+        preamble += `${this.indent()}std::vector<jspp::AnyValue> ${argsName}(${finalArgsParamName}.begin(), ${finalArgsParamName}.end());\n`;
+    }
+    // Now 'argsName' refers to the vector (if copied) or the span (if not). 
+    // And 'this.globalThisVar' refers to the copy (if copied) or the param (if not).
+    // So subsequent code using `argsName` and `visit` (using `globalThisVar`) works correctly.
+    const paramExtractor = (parameters) => {
+        let code = "";
+        parameters.forEach((p, i) => {
+            const name = p.name.getText();
+            const defaultValue = p.initializer
+                ? this.visit(p.initializer, visitContext)
+                : "jspp::Constants::UNDEFINED";
+            const scope = this.getScopeForNode(p);
+            const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(name, scope);
+            // Handle rest parameters
+            if (!!p.dotDotDotToken) {
+                if (parameters.length - 1 !== i) {
+                    throw new SyntaxError("Rest parameter must be last formal parameter.");
+                }
+                if (typeInfo.needsHeapAllocation) {
+                    code +=
+                        `${this.indent()}auto ${name} = std::make_shared<jspp::AnyValue>(jspp::Constants::UNDEFINED);\n`;
+                }
+                else {
+                    code +=
+                        `${this.indent()}jspp::AnyValue ${name} = jspp::Constants::UNDEFINED;\n`;
+                }
+                // Extract rest parameters
+                const tempName = `temp_${name}`;
+                code += `${this.indent()}{\n`;
+                this.indentationLevel++;
+                code +=
+                    `${this.indent()}std::vector<std::optional<jspp::AnyValue>> ${tempName};\n`;
+                code += `${this.indent()}if (${argsName}.size() > ${i}) {\n`;
+                this.indentationLevel++;
+                code +=
+                    `${this.indent()}${tempName}.reserve(${argsName}.size() - ${i});\n`;
+                this.indentationLevel--;
+                code += `${this.indent()}}\n`;
+                code +=
+                    `${this.indent()}for (size_t j = ${i}; j < ${argsName}.size(); j++) {\n`;
+                this.indentationLevel++;
+                code +=
+                    `${this.indent()}${tempName}.push_back(${argsName}[j]);\n`;
+                this.indentationLevel--;
+                code += `${this.indent()}}\n`;
+                code += `${this.indent()}${typeInfo.needsHeapAllocation ? "*" : ""}${name} = jspp::AnyValue::make_array(std::move(${tempName}));\n`;
+                this.indentationLevel--;
+                code += `${this.indent()}}\n`;
+                return;
+            }
+            // Normal parameter
+            const initValue = `${argsName}.size() > ${i} ? ${argsName}[${i}] : ${defaultValue}`;
+            if (typeInfo && typeInfo.needsHeapAllocation) {
+                code +=
+                    `${this.indent()}auto ${name} = std::make_shared<jspp::AnyValue>(${initValue});\n`;
+            }
+            else {
+                code +=
+                    `${this.indent()}jspp::AnyValue ${name} = ${initValue};\n`;
+            }
+        });
+        return code;
     };
     if (node.body) {
         if (ts.isBlock(node.body)) {
-            let paramExtraction = "";
-            this.indentationLevel++;
-            node.parameters.forEach((p, i) => {
-                const name = p.name.getText();
-                const defaultValue = p.initializer
-                    ? this.visit(p.initializer, visitContext)
-                    : "jspp::AnyValue::make_undefined()";
-                paramExtraction +=
-                    `${this.indent()}auto ${name} = ${argsName}.size() > ${i} ? ${argsName}[${i}] : ${defaultValue};\n`;
+            // Hoist var declarations in the function body
+            const varDecls = collectFunctionScopedDeclarations(node.body);
+            varDecls.forEach(decl => {
+                preamble += this.hoistDeclaration(decl, visitContext.localScopeSymbols);
             });
+            this.indentationLevel++;
+            const paramExtraction = paramExtractor(node.parameters);
             this.indentationLevel--;
             const blockContent = this.visit(node.body, {
+                ...visitContext,
                 isMainContext: false,
                 isInsideFunction: true,
                 isFunctionBody: true,
                 isInsideGeneratorFunction: isInsideGeneratorFunction,
+                isInsideAsyncFunction: isInsideAsyncFunction,
             });
-            // The block visitor already adds braces, so we need to inject the param extraction.
-            lambda += "{\n" + paramExtraction + blockContent.substring(2);
+            // The block visitor already adds braces, so we need to inject the preamble and param extraction.
+            lambda += "{\n" + preamble + paramExtraction + blockContent.substring(2);
         }
         else {
             lambda += "{\n";
             this.indentationLevel++;
-            node.parameters.forEach((p, i) => {
-                const name = p.name.getText();
-                const defaultValue = p.initializer
-                    ? this.visit(p.initializer, visitContext)
-                    : "jspp::AnyValue::make_undefined()";
-                lambda +=
-                    `${this.indent()}auto ${name} = ${argsName}.size() > ${i} ? ${argsName}[${i}] : ${defaultValue};\n`;
-            });
+            lambda += preamble;
+            lambda += paramExtractor(node.parameters);
             lambda += `${this.indent()}${returnCmd} ${this.visit(node.body, {
+                ...visitContext,
                 isMainContext: false,
                 isInsideFunction: true,
                 isFunctionBody: false,
-            })};
-`;
+                isInsideGeneratorFunction: isInsideGeneratorFunction,
+                isInsideAsyncFunction: isInsideAsyncFunction,
+            })};\n`;
             this.indentationLevel--;
             lambda += `${this.indent()}}`;
         }
     }
     else {
-        lambda += `{ ${returnCmd} jspp::AnyValue::make_undefined(); }\n`;
+        lambda += `{ ${preamble} ${returnCmd} jspp::Constants::UNDEFINED; }\n`;
     }
     let signature = "";
     let callable = "";
@@ -68,18 +211,54 @@ export function generateLambda(node, isAssignment = false, capture = "[=]") {
     // Handle generator function
     if (isInsideGeneratorFunction) {
         signature =
-            "jspp::JsIterator<jspp::AnyValue>(const std::vector<jspp::AnyValue>&)";
+            "jspp::JsIterator<jspp::AnyValue>(const jspp::AnyValue&, std::span<const jspp::AnyValue>)";
         callable = `std::function<${signature}>(${lambda})`;
-        method = `jspp::AnyValue::make_function`;
+        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})`;
+        method = `jspp::AnyValue::make_async_function`;
     } // Handle normal function
     else {
-        signature = `jspp::AnyValue(const std::vector<jspp::AnyValue>&)`;
+        signature =
+            `jspp::AnyValue(const jspp::AnyValue&, std::span<const jspp::AnyValue>)`;
         callable = `std::function<${signature}>(${lambda})`;
-        method = `jspp::AnyValue::make_function`;
+        if (options?.isClass) {
+            method = `jspp::AnyValue::make_class`;
+        }
+        else {
+            method = `jspp::AnyValue::make_function`;
+        }
+    }
+    const funcName = context?.lambdaName || node.name?.getText();
+    const hasName = !!funcName && funcName.length > 0;
+    let args = callable;
+    const isMethod = ts.isMethodDeclaration(node);
+    const isAccessor = ts.isGetAccessor(node) || ts.isSetAccessor(node);
+    const isConstructor = !isArrow && !isMethod && !isAccessor;
+    // make_function(callable, name, is_constructor)
+    if (method === `jspp::AnyValue::make_function`) {
+        if (hasName) {
+            args += `, "${funcName}"`;
+        }
+        else if (!isConstructor) {
+            args += `, std::nullopt`;
+        }
+        if (!isConstructor) {
+            args += `, false`;
+        }
+    }
+    else {
+        // make_class, make_generator, make_async_function
+        if (hasName) {
+            args += `, "${funcName}"`;
+        }
     }
-    const funcName = node.name?.getText();
-    const fullExpression = `${method}(${callable}, "${funcName || ""}")`;
-    if (ts.isFunctionDeclaration(node) && !isAssignment && funcName) {
+    const fullExpression = `${method}(${args})`;
+    if (ts.isFunctionDeclaration(node) && !isAssignment && node.name) {
+        const funcName = node.name?.getText();
         return `${this.indent()}auto ${funcName} = ${fullExpression};\n`;
     }
     return fullExpression;
@@ -89,12 +268,12 @@ export function visitFunctionDeclaration(node, context) {
         // This will now be handled by the Block visitor for hoisting.
         // However, we still need to generate the lambda for assignment.
         // The block visitor will wrap this in an assignment.
-        return this.generateLambda(node);
+        return this.generateLambda(node, context);
     }
     return "";
 }
 export function visitArrowFunction(node, context) {
-    return this.generateLambda(node);
+    return this.generateLambda(node, context);
 }
 export function visitFunctionExpression(node, context) {
     const funcExpr = node;
@@ -104,12 +283,18 @@ export function visitFunctionExpression(node, context) {
         this.indentationLevel++;
         code +=
             `${this.indent()}auto ${funcName} = std::make_shared<jspp::AnyValue>();\n`;
-        const lambda = this.generateLambda(funcExpr, false, "[=]");
+        const lambda = this.generateLambda(funcExpr, {
+            ...context,
+            lambdaName: funcName,
+        }, {
+            isAssignment: true,
+            capture: "[=]",
+        });
         code += `${this.indent()}*${funcName} = ${lambda};\n`;
         code += `${this.indent()}return *${funcName};\n`;
         this.indentationLevel--;
         code += `${this.indent()}})()`;
         return code;
     }
-    return this.generateLambda(node);
+    return this.generateLambda(node, context);
 }

package/dist/core/codegen/helpers.js

@@ -1,5 +1,6 @@
 import ts from "typescript";
 import { BUILTIN_OBJECTS, Scope } from "../../analysis/scope";
+import { DeclaredSymbols, DeclaredSymbolType } from "../../ast/symbols";
 import { CodeGenerator } from "./";
 export function isBuiltinObject(node) {
     return BUILTIN_OBJECTS.values().some((obj) => obj.name === node.text);
@@ -15,6 +16,10 @@ export function getDeclaredSymbols(node) {
             // Handles function declarations
             symbols.add(child.name.getText());
         }
+        else if (ts.isClassDeclaration(child) && child.name) {
+            // Handles class declarations
+            symbols.add(child.name.getText());
+        }
         else if (ts.isParameter(child)) {
             // Handles function parameters
             symbols.add(child.name.getText());
@@ -28,9 +33,9 @@ export function getDeclaredSymbols(node) {
     visitor(node);
     return symbols;
 }
-export function generateUniqueName(prefix, namesToAvoid) {
+export function generateUniqueName(prefix, ...namesToAvoid) {
     let name = `${prefix}${this.exceptionCounter}`;
-    while (namesToAvoid.has(name)) {
+    while (namesToAvoid.some((names) => names.has(name))) {
         this.exceptionCounter++;
         name = `${prefix}${this.exceptionCounter}`;
     }
@@ -75,8 +80,91 @@ export function escapeString(str) {
 export function getJsVarName(node) {
     return `"${node.text}"`;
 }
-export function getReturnCmd(context) {
-    return context.isInsideGeneratorFunction ? "co_return" : "return";
+export function getDerefCode(nodeText, varName, context, typeInfo) {
+    // Make sure varName is incased in quotes
+    if (!varName.startsWith('"'))
+        varName = '"' + varName;
+    if (!varName.endsWith('"'))
+        varName = varName + '"';
+    const symbolName = varName.slice(1).slice(0, -1);
+    const symbol = context.localScopeSymbols.get(symbolName) ??
+        context.topLevelScopeSymbols.get(symbolName);
+    const checkedIfUninitialized = symbol?.checkedIfUninitialized ||
+        false;
+    // Mark the symbol as checked
+    this.markSymbolAsChecked(symbolName, context.topLevelScopeSymbols, context.localScopeSymbols);
+    // Apply deref code
+    if (checkedIfUninitialized) {
+        if (typeInfo && typeInfo.needsHeapAllocation) {
+            return `(*${nodeText})`;
+        }
+        return `${nodeText}`;
+    }
+    else {
+        if (typeInfo && typeInfo.needsHeapAllocation) {
+            return `jspp::Access::deref_ptr(${nodeText}, ${varName})`;
+        }
+        return `jspp::Access::deref_stack(${nodeText}, ${varName})`;
+    }
+}
+export function markSymbolAsChecked(name, topLevel, local) {
+    if (topLevel.has(name)) {
+        topLevel.update(name, {
+            checkedIfUninitialized: true,
+        });
+    }
+    else if (local.has(name)) {
+        local.update(name, {
+            checkedIfUninitialized: true,
+        });
+    }
+}
+export function getReturnCommand(context) {
+    return (context.isInsideGeneratorFunction || context.isInsideAsyncFunction)
+        ? "co_return"
+        : "return";
+}
+export function hoistDeclaration(decl, hoistedSymbols) {
+    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));
+    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`);
+        }
+        // `var` variables can be declared multiple times
+        return "";
+    }
+    hoistedSymbols.set(name, {
+        type: symbolType,
+        checkedIfUninitialized: false,
+    });
+    const scope = this.getScopeForNode(decl);
+    const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(name, scope);
+    const initializer = isLetOrConst || ts.isClassDeclaration(decl)
+        ? "jspp::Constants::UNINITIALIZED"
+        : "jspp::Constants::UNDEFINED";
+    if (typeInfo.needsHeapAllocation) {
+        return `${this.indent()}auto ${name} = std::make_shared<jspp::AnyValue>(${initializer});\n`;
+    }
+    else {
+        return `${this.indent()}jspp::AnyValue ${name} = ${initializer};\n`;
+    }
 }
 export function isGeneratorFunction(node) {
     return ((ts.isFunctionDeclaration(node) ||
@@ -85,3 +173,69 @@ export function isGeneratorFunction(node) {
         !!node.asteriskToken // generator indicator
     );
 }
+export function isAsyncFunction(node) {
+    return ((ts.isFunctionDeclaration(node) ||
+        ts.isFunctionExpression(node) ||
+        ts.isMethodDeclaration(node) ||
+        ts.isArrowFunction(node)) &&
+        (ts.getCombinedModifierFlags(node) &
+            ts.ModifierFlags.Async) !== 0);
+}
+export function prepareScopeSymbolsForVisit(topLevel, local) {
+    // Join the top and local scopes
+    return new DeclaredSymbols(topLevel, local);
+}
+export function collectFunctionScopedDeclarations(node) {
+    const decls = [];
+    function visit(n) {
+        if (ts.isVariableStatement(n)) {
+            const isLetOrConst = (n.declarationList.flags & (ts.NodeFlags.Let | ts.NodeFlags.Const)) !== 0;
+            if (!isLetOrConst) {
+                decls.push(...n.declarationList.declarations);
+            }
+        }
+        else if (ts.isForStatement(n)) {
+            if (n.initializer && ts.isVariableDeclarationList(n.initializer)) {
+                const isLetOrConst = (n.initializer.flags & (ts.NodeFlags.Let | ts.NodeFlags.Const)) !== 0;
+                if (!isLetOrConst) {
+                    decls.push(...n.initializer.declarations);
+                }
+            }
+        }
+        else if (ts.isForInStatement(n)) {
+            if (ts.isVariableDeclarationList(n.initializer)) {
+                const isLetOrConst = (n.initializer.flags & (ts.NodeFlags.Let | ts.NodeFlags.Const)) !== 0;
+                if (!isLetOrConst) {
+                    decls.push(...n.initializer.declarations);
+                }
+            }
+        }
+        else if (ts.isForOfStatement(n)) {
+            if (ts.isVariableDeclarationList(n.initializer)) {
+                const isLetOrConst = (n.initializer.flags & (ts.NodeFlags.Let | ts.NodeFlags.Const)) !== 0;
+                if (!isLetOrConst) {
+                    decls.push(...n.initializer.declarations);
+                }
+            }
+        }
+        // Stop recursion at function boundaries (but not the root node if it is a function)
+        if (n !== node && (ts.isFunctionDeclaration(n) || ts.isFunctionExpression(n) || ts.isArrowFunction(n) || ts.isMethodDeclaration(n) || ts.isGetAccessor(n) || ts.isSetAccessor(n) || ts.isClassDeclaration(n))) {
+            return;
+        }
+        ts.forEachChild(n, visit);
+    }
+    ts.forEachChild(node, visit);
+    return decls;
+}
+export function collectBlockScopedDeclarations(statements) {
+    const decls = [];
+    for (const stmt of statements) {
+        if (ts.isVariableStatement(stmt)) {
+            const isLetOrConst = (stmt.declarationList.flags & (ts.NodeFlags.Let | ts.NodeFlags.Const)) !== 0;
+            if (isLetOrConst) {
+                decls.push(...stmt.declarationList.declarations);
+            }
+        }
+    }
+    return decls;
+}

package/dist/core/codegen/index.js

@@ -1,11 +1,13 @@
 import { TypeAnalyzer } from "../../analysis/typeAnalyzer";
+import { DeclaredSymbols } from "../../ast/symbols";
 import { generateLambda } from "./function-handlers";
-import { escapeString, generateUniqueExceptionName, generateUniqueName, getDeclaredSymbols, getJsVarName, getReturnCmd, getScopeForNode, indent, isBuiltinObject, isGeneratorFunction, } from "./helpers";
+import { escapeString, generateUniqueExceptionName, generateUniqueName, getDeclaredSymbols, getDerefCode, getJsVarName, getReturnCommand, getScopeForNode, hoistDeclaration, indent, isAsyncFunction, isBuiltinObject, isGeneratorFunction, markSymbolAsChecked, prepareScopeSymbolsForVisit, } from "./helpers";
 import { visit } from "./visitor";
 const CONTAINER_FUNCTION_NAME = "__container__";
 export class CodeGenerator {
     indentationLevel = 0;
     typeAnalyzer;
+    globalThisVar;
     exceptionCounter = 0;
     // visitor
     visit = visit;
@@ -13,13 +15,18 @@ export class CodeGenerator {
     getDeclaredSymbols = getDeclaredSymbols;
     generateUniqueName = generateUniqueName;
     generateUniqueExceptionName = generateUniqueExceptionName;
+    hoistDeclaration = hoistDeclaration;
     getScopeForNode = getScopeForNode;
     indent = indent;
     escapeString = escapeString;
     getJsVarName = getJsVarName;
-    getReturnCmd = getReturnCmd;
+    getDerefCode = getDerefCode;
+    getReturnCommand = getReturnCommand;
     isBuiltinObject = isBuiltinObject;
     isGeneratorFunction = isGeneratorFunction;
+    isAsyncFunction = isAsyncFunction;
+    prepareScopeSymbolsForVisit = prepareScopeSymbolsForVisit;
+    markSymbolAsChecked = markSymbolAsChecked;
     // function handlers
     generateLambda = generateLambda;
     /**
@@ -27,27 +34,32 @@ export class CodeGenerator {
      */
     generate(ast, analyzer) {
         this.typeAnalyzer = analyzer;
+        this.globalThisVar = this.generateUniqueName("__this_val__", this.getDeclaredSymbols(ast));
         const declarations = `#include "index.hpp"\n\n`;
         let containerCode = `jspp::AnyValue ${CONTAINER_FUNCTION_NAME}() {\n`;
         this.indentationLevel++;
+        containerCode +=
+            `${this.indent()}jspp::AnyValue ${this.globalThisVar} = global;\n`;
         containerCode += this.visit(ast, {
             isMainContext: true,
             isInsideFunction: true,
             isFunctionBody: true,
+            topLevelScopeSymbols: new DeclaredSymbols(),
+            localScopeSymbols: new DeclaredSymbols(),
         });
         this.indentationLevel--;
-        containerCode += "  return jspp::AnyValue::make_undefined();\n";
+        containerCode += "  return jspp::Constants::UNDEFINED;\n";
         containerCode += "}\n\n";
-        let mainCode = "int main() {\n";
-        mainCode += `  std::ios::sync_with_stdio(false);\n`;
-        mainCode += `  std::cin.tie(nullptr);\n`;
+        let mainCode = "int main(int argc, char** argv) {\n";
         mainCode += `  try {\n`;
+        mainCode += `    jspp::setup_process_argv(argc, argv);\n`;
         mainCode += `    ${CONTAINER_FUNCTION_NAME}();\n`;
+        mainCode += `    jspp::Scheduler::instance().run();\n`;
         mainCode += `  } catch (const std::exception& ex) {\n`;
         mainCode +=
-            "    auto error = std::make_shared<jspp::AnyValue>(jspp::RuntimeError::error_to_value(ex));\n{\n";
+            "    auto error = std::make_shared<jspp::AnyValue>(jspp::Exception::exception_to_any_value(ex));\n{\n";
         mainCode +=
-            `    console.get_own_property("error").as_function("console.error")->call({*error});\n`;
+            `    ([&](){ auto __obj = console; return __obj.get_own_property("error").call(__obj, std::span<const jspp::AnyValue>((const jspp::AnyValue[]){*error}, 1), "console.error"); })();\n`;
         mainCode += `    return 1;\n}\n`;
         mainCode += `  }\n`;
         mainCode += "  return 0;\n}";

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

@@ -2,14 +2,19 @@ import ts from "typescript";
 import { CodeGenerator } from "./";
 export function visitIdentifier(node) {
     if (node.text === "NaN") {
-        return "jspp::AnyValue::make_nan()";
+        // return "jspp::AnyValue::make_nan()";
+        return "jspp::Constants::NaN";
     }
     if (node.text === "undefined") {
-        return "jspp::AnyValue::make_undefined()";
+        return visitUndefinedKeyword();
     }
     return node.text;
 }
 export function visitNumericLiteral(node) {
+    if (node.text === "0")
+        return "jspp::Constants::ZERO";
+    if (node.text === "1")
+        return "jspp::Constants::ONE";
     return `jspp::AnyValue::make_number(${this.escapeString(node.text)})`;
 }
 export function visitStringLiteral(node) {
@@ -19,14 +24,21 @@ export function visitNoSubstitutionTemplateLiteral(node) {
     return `jspp::AnyValue::make_string("${this.escapeString(node.text)}")`;
 }
 export function visitTrueKeyword() {
-    return "jspp::AnyValue::make_boolean(true)";
+    // return "jspp::AnyValue::make_boolean(true)";
+    return "jspp::Constants::TRUE";
 }
 export function visitFalseKeyword() {
-    return "jspp::AnyValue::make_boolean(false)";
+    // return "jspp::AnyValue::make_boolean(false)";
+    return "jspp::Constants::FALSE";
 }
 export function visitUndefinedKeyword() {
-    return "jspp::AnyValue::make_undefined()";
+    // return "jspp::AnyValue::make_undefined()";
+    return "jspp::Constants::UNDEFINED";
 }
 export function visitNullKeyword() {
-    return "jspp::AnyValue::make_null()";
+    // return "jspp::AnyValue::make_null()";
+    return "jspp::Constants::Null";
+}
+export function visitThisKeyword() {
+    return `${this.globalThisVar}`;
 }