@ugo-studio/jspp 0.2.5 → 0.2.7

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

@@ -1,15 +1,14 @@
 import ts from "typescript";
-import { DeclaredSymbols } from "../../ast/symbols.js";
+import { DeclarationType, DeclaredSymbols } from "../../ast/symbols.js";
 import { collectFunctionScopedDeclarations } from "./helpers.js";
 import { CodeGenerator } from "./index.js";
-export function generateLambda(node, context, options) {
-    const capture = options?.capture || "[=]";
-    const nativeName = options?.nativeName;
+export function generateLambdaComponents(node, context, options) {
     const declaredSymbols = this.getDeclaredSymbols(node);
     const argsName = this.generateUniqueName("__args_", declaredSymbols, context.globalScopeSymbols, context.localScopeSymbols);
     const isInsideGeneratorFunction = this.isGeneratorFunction(node);
     const isInsideAsyncFunction = this.isAsyncFunction(node);
-    const returnCmd = this.getReturnCommand({
+    const isArrow = ts.isArrowFunction(node);
+    const returnCommand = this.getReturnCommand({
         isInsideGeneratorFunction: isInsideGeneratorFunction,
         isInsideAsyncFunction: isInsideAsyncFunction,
     });
@@ -18,17 +17,10 @@ export function generateLambda(node, context, options) {
         : (isInsideGeneratorFunction
             ? "jspp::JsIterator<jspp::AnyValue>"
             : (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 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}(${selfParamPart}${thisArgParam}, ${paramArgsType} ${argsName}) ${mutablePart}-> ${funcReturnType} `;
     const globalScopeSymbols = this.prepareScopeSymbolsForVisit(context.globalScopeSymbols, context.localScopeSymbols);
     const visitContext = {
         currentScopeNode: context.currentScopeNode,
@@ -42,18 +34,6 @@ export function generateLambda(node, context, options) {
         isInsideGeneratorFunction: isInsideGeneratorFunction,
         isInsideAsyncFunction: isInsideAsyncFunction,
     };
-    // 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`;
-        }
-        preamble +=
-            `${this.indent()}std::vector<jspp::AnyValue> ${argsCopy}(${argsName}.begin(), ${argsName}.end());\n`;
-    }
     // Adjust parameter names for generator/async to allow shadowing/copying
     let finalThisParamName = isArrow ? "" : this.globalThisVar;
     let finalArgsParamName = argsName;
@@ -63,138 +43,161 @@ export function generateLambda(node, context, options) {
         }
         finalArgsParamName = this.generateUniqueName("__args_ref", declaredSymbols);
     }
-    const thisArgParamFinal = isArrow
-        ? "const jspp::AnyValue&"
+    const thisArgParam = isArrow
+        ? "const jspp::AnyValue&" // Arrow functions use captured 'this' or are never generators in this parser context
         : `${paramThisType} ${finalThisParamName}`;
-    // Re-construct lambda header with potentially new param names
-    lambda =
-        `${capture}(${selfParamPart}${thisArgParamFinal}, ${paramArgsType} ${finalArgsParamName}) ${mutablePart}-> ${funcReturnType} `;
-    // Regenerate preamble
-    preamble = "";
+    const funcArgs = `${paramArgsType} ${finalArgsParamName}`;
+    // Preamble to copy arguments for coroutines
+    let preamble = "";
+    let nativePreamble = "";
     if (isInsideGeneratorFunction || isInsideAsyncFunction) {
         if (!isArrow) {
             preamble +=
                 `${this.indent()}jspp::AnyValue ${this.globalThisVar} = ${finalThisParamName};\n`;
+            nativePreamble +=
+                `${this.indent()}jspp::AnyValue ${this.globalThisVar} = ${finalThisParamName};\n`;
         }
+        // Note: Do not add argument copy to native lambda
         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) => {
+    // Native function arguments for native lambda
+    let nativeFuncArgs = "";
+    let nativeParamsContent = "";
+    this.validateFunctionParams(node.parameters).forEach((p, i) => {
+        const name = p.name.getText();
+        const defaultValue = p.initializer
+            ? this.visit(p.initializer, visitContext)
+            : !!p.dotDotDotToken
+                ? "jspp::AnyValue::make_array(std::vector<jspp::AnyValue>{})"
+                : "jspp::Constants::UNDEFINED";
+        nativeFuncArgs += `, const jspp::AnyValue& ${name} = ${defaultValue}`;
+    });
+    // Extract lambda parameters from arguments span/vector
+    const generateParamsBuilder = () => {
+        let paramsCode = "";
+        this.validateFunctionParams(node.parameters).forEach((p, i) => {
             const name = p.name.getText();
             const defaultValue = p.initializer
                 ? this.visit(p.initializer, visitContext)
                 : "jspp::Constants::UNDEFINED";
+            // Add paramerter to local context
+            visitContext.localScopeSymbols.add(name, {
+                type: DeclarationType.let,
+                checks: { initialized: true },
+            });
             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.");
-                }
+                const initValue = `jspp::AnyValue::make_array(${argsName}.subspan(${i}))`;
                 if (typeInfo.needsHeapAllocation) {
-                    code +=
-                        `${this.indent()}auto ${name} = std::make_shared<jspp::AnyValue>(jspp::Constants::UNDEFINED);\n`;
+                    paramsCode +=
+                        `${this.indent()}auto ${name} = std::make_shared<jspp::AnyValue>(${initValue});\n`;
                 }
                 else {
-                    code +=
-                        `${this.indent()}jspp::AnyValue ${name} = jspp::Constants::UNDEFINED;\n`;
+                    paramsCode +=
+                        `${this.indent()}jspp::AnyValue ${name} = ${initValue};\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 +=
+                paramsCode +=
                     `${this.indent()}auto ${name} = std::make_shared<jspp::AnyValue>(${initValue});\n`;
             }
             else {
-                code +=
+                paramsCode +=
                     `${this.indent()}jspp::AnyValue ${name} = ${initValue};\n`;
             }
         });
-        return code;
+        return paramsCode;
     };
+    // Generate params and function body
+    let paramsContent = "";
+    let blockContentWithoutOpeningBrace = "";
     if (node.body) {
         if (ts.isBlock(node.body)) {
             // Hoist var declarations in the function body
             const varDecls = collectFunctionScopedDeclarations(node.body);
             varDecls.forEach((decl) => {
-                preamble += this.hoistDeclaration(decl, visitContext.localScopeSymbols, node.body);
+                const hoistCode = this.hoistDeclaration(decl, visitContext.localScopeSymbols, node.body);
+                preamble += hoistCode;
+                nativePreamble += hoistCode;
             });
             this.indentationLevel++;
-            const paramExtraction = paramExtractor(node.parameters);
+            paramsContent = generateParamsBuilder();
             this.indentationLevel--;
-            const blockContent = this.visit(node.body, {
+            // The block visitor already adds braces, so we need to remove the opening brace to inject the preamble and param extraction.
+            blockContentWithoutOpeningBrace = 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 preamble and param extraction.
-            lambda += "{\n" + preamble + paramExtraction +
-                blockContent.trimStart().substring(2);
+            }).trimStart().substring(2);
         }
         else {
-            lambda += "{\n";
             this.indentationLevel++;
-            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`;
+            paramsContent = generateParamsBuilder();
+            blockContentWithoutOpeningBrace =
+                `${this.indent()}${returnCommand} ${this.visit(node.body, {
+                    ...visitContext,
+                    isMainContext: false,
+                    isInsideFunction: true,
+                    isFunctionBody: false,
+                    isInsideGeneratorFunction: isInsideGeneratorFunction,
+                    isInsideAsyncFunction: isInsideAsyncFunction,
+                })};\n`;
             this.indentationLevel--;
-            lambda += `${this.indent()}}`;
+            blockContentWithoutOpeningBrace += `${this.indent()}}`;
         }
     }
     else {
-        lambda += `{ ${preamble} ${returnCmd} jspp::Constants::UNDEFINED; }\n`;
-    }
-    // Return only lambda if required
-    if (options?.generateOnlyLambda) {
-        return lambda.trimEnd();
+        blockContentWithoutOpeningBrace =
+            `${returnCommand} jspp::Constants::UNDEFINED; }\n`;
     }
-    return this.generateFullLambdaExpression(node, context, lambda, options);
+    return {
+        node,
+        context,
+        options,
+        visitContext,
+        thisArgParam,
+        funcArgs,
+        nativeFuncArgs,
+        funcReturnType,
+        preamble,
+        nativePreamble,
+        paramsContent,
+        nativeParamsContent,
+        blockContentWithoutOpeningBrace,
+        isInsideGeneratorFunction,
+        isInsideAsyncFunction,
+    };
 }
-export function generateFullLambdaExpression(node, context, lambda, options) {
+export function generateNativeLambda(comps) {
+    const { options, thisArgParam, nativeFuncArgs, funcReturnType, nativePreamble, nativeParamsContent, blockContentWithoutOpeningBrace, } = comps;
+    const capture = options?.capture || "[=]";
+    const nativeName = options?.nativeName;
+    const selfParam = nativeName ? `this auto&& ${nativeName}, ` : "";
+    const mutableLabel = nativeName ? "" : "mutable ";
+    let lambda = `${capture}(${selfParam}${thisArgParam}${nativeFuncArgs}) ${mutableLabel}-> ${funcReturnType} {\n`;
+    lambda += nativePreamble;
+    lambda += nativeParamsContent;
+    lambda += blockContentWithoutOpeningBrace;
+    return lambda;
+}
+export function generateWrappedLambda(comps) {
+    const { node, context, options, thisArgParam, funcArgs, funcReturnType, preamble, paramsContent, blockContentWithoutOpeningBrace, isInsideGeneratorFunction, isInsideAsyncFunction, } = comps;
+    const capture = options?.capture || "[=]";
     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 lambda = `${capture}(${thisArgParam}, ${funcArgs}) mutable -> ${funcReturnType} {\n`;
+    lambda += preamble;
+    lambda += paramsContent;
+    lambda += blockContentWithoutOpeningBrace;
     let callable = lambda;
     let method = "";
     // Handle generator function
@@ -236,6 +239,7 @@ export function generateFullLambdaExpression(node, context, lambda, options) {
     const funcName = context?.lambdaName || node.name?.getText();
     const hasName = !!funcName && funcName.length > 0;
     let args = callable;
+    const isArrow = ts.isArrowFunction(node);
     const isMethod = ts.isMethodDeclaration(node);
     const isAccessor = ts.isGetAccessor(node) || ts.isSetAccessor(node);
     const isConstructor = !isArrow && !isMethod && !isAccessor;
@@ -269,12 +273,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, context);
+        return this.generateWrappedLambda(this.generateLambdaComponents(node, context));
     }
     return "";
 }
 export function visitArrowFunction(node, context) {
-    return this.generateLambda(node, context);
+    return this.generateWrappedLambda(this.generateLambdaComponents(node, context));
 }
 export function visitFunctionExpression(node, context) {
     const funcExpr = node;
@@ -284,18 +288,18 @@ export function visitFunctionExpression(node, context) {
         this.indentationLevel++;
         code +=
             `${this.indent()}auto ${funcName} = std::make_shared<jspp::AnyValue>();\n`;
-        const lambda = this.generateLambda(funcExpr, {
+        const lambda = this.generateWrappedLambda(this.generateLambdaComponents(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, context);
+    return this.generateWrappedLambda(this.generateLambdaComponents(node, context));
 }

package/dist/core/codegen/helpers.js

@@ -1,6 +1,7 @@
 import ts from "typescript";
 import { BUILTIN_OBJECTS, Scope } from "../../analysis/scope.js";
 import { DeclarationType, DeclaredSymbols } from "../../ast/symbols.js";
+import { CompilerError } from "../error.js";
 import { CodeGenerator } from "./index.js";
 export function isBuiltinObject(node) {
     return BUILTIN_OBJECTS.values().some((obj) => obj.name === node.text);
@@ -20,6 +21,10 @@ export function getDeclaredSymbols(node) {
             // Handles class declarations
             symbols.add(child.name.getText());
         }
+        else if (ts.isEnumDeclaration(child) && child.name) {
+            // Handles enum declarations
+            symbols.add(child.name.getText());
+        }
         else if (ts.isParameter(child)) {
             // Handles function parameters
             symbols.add(child.name.getText());
@@ -60,7 +65,7 @@ export function getScopeForNode(node) {
     }
     const rootScope = this.typeAnalyzer.scopeManager.getAllScopes()[0];
     if (!rootScope) {
-        throw new Error("Compiler bug: Could not find a root scope.");
+        throw new CompilerError("Could not find a root scope.", node, "CompilerBug");
     }
     return rootScope;
 }
@@ -88,7 +93,7 @@ export function getDerefCode(nodeText, varName, context, typeInfo) {
     const symbolName = varName.slice(1).slice(0, -1);
     const symbol = context.localScopeSymbols.get(symbolName) ??
         context.globalScopeSymbols.get(symbolName);
-    const isInitialized = symbol?.checked.initialized ||
+    const isInitialized = symbol?.checks.initialized ||
         false;
     // Mark the symbol as checked
     this.markSymbolAsInitialized(symbolName, context.globalScopeSymbols, context.localScopeSymbols);
@@ -109,12 +114,12 @@ export function getDerefCode(nodeText, varName, context, typeInfo) {
 export function markSymbolAsInitialized(name, topLevel, local) {
     if (topLevel.has(name)) {
         topLevel.update(name, {
-            checked: { initialized: true },
+            checks: { initialized: true },
         });
     }
     else if (local.has(name)) {
         local.update(name, {
-            checked: { initialized: true },
+            checks: { initialized: true },
         });
     }
 }
@@ -138,16 +143,19 @@ export function hoistDeclaration(decl, hoistedSymbols, scopeNode) {
                 ? DeclarationType.function
                 : ts.isClassDeclaration(decl)
                     ? DeclarationType.class
-                    : DeclarationType.var;
+                    : ts.isEnumDeclaration(decl)
+                        ? DeclarationType.enum
+                        : DeclarationType.var;
     if (hoistedSymbols.has(name)) {
         const existingSymbol = hoistedSymbols.get(name);
-        // Don't allow multiple declaration of `let`,`const`,`function` or `class` variables
+        // Don't allow multiple declaration of `let`,`const`,`function`, `class` or `enum` variables
         if (existingSymbol?.type === DeclarationType.let ||
             existingSymbol?.type === DeclarationType.const ||
             existingSymbol?.type === DeclarationType.function ||
             existingSymbol?.type === DeclarationType.class ||
+            existingSymbol?.type === DeclarationType.enum ||
             existingSymbol?.type !== declType) {
-            throw new SyntaxError(`Identifier '${name}' has already been declared.\n\n${" ".repeat(6) + decl.getText()}\n`);
+            throw new CompilerError(`Identifier '${name}' has already been declared.`, decl, "SyntaxError");
         }
         // `var` variables can be declared multiple times
         return "";
@@ -159,7 +167,7 @@ export function hoistDeclaration(decl, hoistedSymbols, scopeNode) {
             const isGenerator = this.isGeneratorFunction(decl);
             hoistedSymbols.add(name, {
                 type: declType,
-                func: { isAsync, isGenerator },
+                features: { isAsync, isGenerator },
             });
             // Don't hoist functions not used as a variable
             // they will be called with their native lambdas
@@ -203,10 +211,24 @@ export function prepareScopeSymbolsForVisit(topLevel, local) {
     // Join the top and local scopes
     return new DeclaredSymbols(topLevel, local);
 }
+export function shouldIgnoreStatement(stmt) {
+    // Ignore variable statements with 'declare' modifier
+    if (ts.isVariableStatement(stmt)) {
+        if (stmt.modifiers &&
+            stmt.modifiers.some((m) => m.kind === ts.SyntaxKind.DeclareKeyword)) {
+            return true;
+        }
+    }
+    return false;
+}
 export function collectFunctionScopedDeclarations(node) {
     const decls = [];
     function visit(n) {
         if (ts.isVariableStatement(n)) {
+            // Ignore Declare modifier
+            if (shouldIgnoreStatement(n))
+                return;
+            // Only collect let/const declarations
             const isLetOrConst = (n.declarationList.flags &
                 (ts.NodeFlags.Let | ts.NodeFlags.Const)) !== 0;
             if (!isLetOrConst) {
@@ -257,6 +279,10 @@ export function collectBlockScopedDeclarations(statements) {
     const decls = [];
     for (const stmt of statements) {
         if (ts.isVariableStatement(stmt)) {
+            // Ignore Declare modifier
+            if (shouldIgnoreStatement(stmt))
+                continue;
+            // Only collect let/const declarations
             const isLetOrConst = (stmt.declarationList.flags &
                 (ts.NodeFlags.Let | ts.NodeFlags.Const)) !== 0;
             if (isLetOrConst) {
@@ -267,14 +293,14 @@ export function collectBlockScopedDeclarations(statements) {
     return decls;
 }
 export function isFunctionUsedAsValue(decl, root) {
-    const funcName = decl.name?.getText();
-    if (!funcName)
+    const name = decl.name?.getText();
+    if (!name)
         return false;
     let isUsed = false;
     const visitor = (node) => {
         if (isUsed)
             return;
-        if (ts.isIdentifier(node) && node.text === funcName) {
+        if (ts.isIdentifier(node) && node.text === name) {
             const scope = this.getScopeForNode(node);
             const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(node.text, scope);
             if (typeInfo?.declaration === decl) {
@@ -310,14 +336,14 @@ export function isFunctionUsedAsValue(decl, root) {
     ts.forEachChild(root, visitor);
     return isUsed;
 }
-export function isFunctionUsedBeforeDeclaration(funcName, root) {
+export function isFunctionUsedBeforeDeclaration(name, 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) {
+        if (ts.isFunctionDeclaration(node) && node.name?.text === name) {
             declPos = node.getStart();
             foundDecl = true;
         }
@@ -333,7 +359,7 @@ export function isFunctionUsedBeforeDeclaration(funcName, root) {
     function visit(node) {
         if (isUsedBefore)
             return;
-        if (ts.isIdentifier(node) && node.text === funcName) {
+        if (ts.isIdentifier(node) && node.text === name) {
             const parent = node.parent;
             // Ignore declarations where the identifier is the name being declared
             if ((ts.isFunctionDeclaration(parent) ||
@@ -384,3 +410,24 @@ export function isFunctionUsedBeforeDeclaration(funcName, root) {
     visit(root);
     return isUsedBefore;
 }
+export function validateFunctionParams(parameters) {
+    return parameters.filter((p) => {
+        if (p.name.getText() === "this") {
+            if (!this.isTypescript) {
+                // Throw error for "this" parameters in javascript files
+                throw new CompilerError('Cannot use "this" as a parameter name.', p, "SyntaxError");
+            }
+            else
+                return false; // Ignore "this" parameters in typescript files
+        }
+        else
+            return true;
+    }).map((p, i, parameters) => {
+        if (!!p.dotDotDotToken) {
+            if (parameters.length - 1 !== i) {
+                throw new CompilerError("Rest parameter must be last formal parameter.", p, "SyntaxError");
+            }
+        }
+        return p;
+    }) || [];
+}

package/dist/core/codegen/index.js

@@ -1,11 +1,12 @@
 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 { generateLambdaComponents, generateNativeLambda, generateWrappedLambda, } from "./function-handlers.js";
+import { escapeString, generateUniqueExceptionName, generateUniqueName, getDeclaredSymbols, getDerefCode, getJsVarName, getReturnCommand, getScopeForNode, hoistDeclaration, indent, isAsyncFunction, isBuiltinObject, isFunctionUsedAsValue, isFunctionUsedBeforeDeclaration, isGeneratorFunction, markSymbolAsInitialized, prepareScopeSymbolsForVisit, validateFunctionParams, } from "./helpers.js";
 import { visit } from "./visitor.js";
-const MODULE_NAME = "__main_function__";
+const MODULE_NAME = "__entry_point__";
 export class CodeGenerator {
     indentationLevel = 0;
     typeAnalyzer;
+    isTypescript = false;
     globalThisVar;
     uniqueNameCounter = 0;
     // visitor
@@ -28,14 +29,17 @@ export class CodeGenerator {
     markSymbolAsInitialized = markSymbolAsInitialized;
     isFunctionUsedAsValue = isFunctionUsedAsValue;
     isFunctionUsedBeforeDeclaration = isFunctionUsedBeforeDeclaration;
+    validateFunctionParams = validateFunctionParams;
     // function handlers
-    generateLambda = generateLambda;
-    generateFullLambdaExpression = generateFullLambdaExpression;
+    generateLambdaComponents = generateLambdaComponents;
+    generateNativeLambda = generateNativeLambda;
+    generateWrappedLambda = generateWrappedLambda;
     /**
      * Main entry point for the code generation process.
      */
-    generate(ast, analyzer) {
+    generate(ast, analyzer, isTypescript) {
         this.typeAnalyzer = analyzer;
+        this.isTypescript = isTypescript;
         this.globalThisVar = this.generateUniqueName("__this_val__", this.getDeclaredSymbols(ast));
         const declarations = `#include "index.hpp"\n\n`;
         let containerCode = `jspp::JsPromise ${MODULE_NAME}() {\n`;
@@ -68,10 +72,10 @@ export class CodeGenerator {
         mainCode += `    jspp::Scheduler::instance().run();\n`;
         mainCode += `  } catch (const std::exception& ex) {\n`;
         mainCode +=
-            "    auto error = std::make_shared<jspp::AnyValue>(jspp::Exception::exception_to_any_value(ex));\n    {\n";
+            "    auto error = std::make_shared<jspp::AnyValue>(jspp::Exception::exception_to_any_value(ex));\n";
         mainCode +=
-            `      console.call_own_property("error", std::span<const jspp::AnyValue>((const jspp::AnyValue[]){*error}, 1));\n`;
-        mainCode += `      return 1;\n    }\n`;
+            `    console.call_own_property("error", std::span<const jspp::AnyValue>((const jspp::AnyValue[]){*error}, 1));\n`;
+        mainCode += `    return 1;\n`;
         mainCode += `  }\n`;
         mainCode += "  return 0;\n}";
         return declarations + containerCode + mainCode;

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

@@ -11,9 +11,11 @@ export function visitIdentifier(node) {
     return node.text;
 }
 export function visitNumericLiteral(node) {
-    if (node.text === "0")
+    if (node.text === "0" || (node.text.startsWith("0.") &&
+        !node.text.substring(2).split("").some((c) => c !== "0")))
         return "jspp::Constants::ZERO";
-    if (node.text === "1")
+    if (node.text === "1" || (node.text.startsWith("1.") &&
+        !node.text.substring(2).split("").some((c) => c !== "0")))
         return "jspp::Constants::ONE";
     return `jspp::AnyValue::make_number(${this.escapeString(node.text)})`;
 }