@ugo-studio/jspp 0.2.9 → 0.3.1

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

@@ -84,11 +84,11 @@ export function visitObjectLiteralExpression(node, context) {
         ts.isMethodDeclaration(prop) || ts.isGetAccessor(prop) ||
         ts.isSetAccessor(prop) || ts.isSpreadAssignment(prop))) {
         // Empty object
-        return `jspp::AnyValue::make_object_with_proto({}, ::Object.get_own_property("prototype"))`;
+        return `jspp::AnyValue::make_object({}).set_prototype(::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`;
+        `${this.indent()}  auto ${objVar} = jspp::AnyValue::make_object({}).set_prototype(::Object.get_own_property("prototype"));\n`;
     this.indentationLevel++;
     for (const prop of properties) {
         if (ts.isPropertyAssignment(prop)) {
@@ -200,7 +200,7 @@ export function visitArrayLiteralExpression(node, context) {
         const elementsSpan = elements.length > 0
             ? `std::span<const jspp::AnyValue>((const jspp::AnyValue[]){${elementsJoined}}, ${elements.length})`
             : "std::span<const jspp::AnyValue>{}";
-        return `jspp::AnyValue::make_array_with_proto(${elementsSpan}, ::Array.get_own_property("prototype"))`;
+        return `jspp::AnyValue::make_array(${elementsSpan}).set_prototype(::Array.get_own_property("prototype"))`;
     }
     const arrVar = this.generateUniqueName("__arr_", this.getDeclaredSymbols(node));
     let code = `([&]() {\n`;
@@ -238,7 +238,7 @@ export function visitArrayLiteralExpression(node, context) {
     }
     this.indentationLevel--;
     code +=
-        `${this.indent()}  return jspp::AnyValue::make_array_with_proto(std::move(${arrVar}), ::Array.get_own_property("prototype"));\n`;
+        `${this.indent()}  return jspp::AnyValue::make_array(std::move(${arrVar})).set_prototype(::Array.get_own_property("prototype"));\n`;
     code += `${this.indent()}})()`;
     return code;
 }
@@ -254,7 +254,7 @@ export function visitPrefixUnaryExpression(node, context) {
             if (context.derefBeforeAssignment) {
                 target = this.getDerefCode(operand, operand, context, typeInfo);
             }
-            else if (typeInfo.needsHeapAllocation) {
+            else if (typeInfo?.needsHeapAllocation) {
                 target = `*${operand}`;
             }
         }
@@ -277,7 +277,7 @@ export function visitPrefixUnaryExpression(node, context) {
             if (context.derefBeforeAssignment) {
                 target = this.getDerefCode(operand, operand, context, typeInfo);
             }
-            else if (typeInfo.needsHeapAllocation) {
+            else if (typeInfo?.needsHeapAllocation) {
                 target = `*${operand}`;
             }
         }
@@ -296,7 +296,7 @@ export function visitPostfixUnaryExpression(node, context) {
         if (context.derefBeforeAssignment) {
             target = this.getDerefCode(operand, operand, context, typeInfo);
         }
-        else if (typeInfo.needsHeapAllocation) {
+        else if (typeInfo?.needsHeapAllocation) {
             target = `*${operand}`;
         }
     }
@@ -381,7 +381,6 @@ export function visitBinaryExpression(node, context) {
     const op = opToken.getText();
     const visitContext = {
         ...context,
-        supportedNativeLiterals: undefined,
     };
     const assignmentOperators = [
         ts.SyntaxKind.PlusEqualsToken,
@@ -409,7 +408,7 @@ export function visitBinaryExpression(node, context) {
             if (ts.isIdentifier(binExpr.left)) {
                 const scope = this.getScopeForNode(binExpr.left);
                 const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(binExpr.left.text, scope);
-                target = typeInfo.needsHeapAllocation
+                target = typeInfo?.needsHeapAllocation
                     ? `*${leftText}`
                     : leftText;
                 return `${target} = jspp::unsigned_right_shift(${target}, ${rightText})`;
@@ -422,7 +421,7 @@ export function visitBinaryExpression(node, context) {
             if (ts.isIdentifier(binExpr.left)) {
                 const scope = this.getScopeForNode(binExpr.left);
                 const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(binExpr.left.text, scope);
-                target = typeInfo.needsHeapAllocation
+                target = typeInfo?.needsHeapAllocation
                     ? `*${leftText}`
                     : leftText;
                 return `${target} = jspp::pow(${target}, ${rightText})`;
@@ -438,7 +437,7 @@ export function visitBinaryExpression(node, context) {
             if (ts.isIdentifier(binExpr.left)) {
                 const scope = this.getScopeForNode(binExpr.left);
                 const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(binExpr.left.text, scope);
-                target = typeInfo.needsHeapAllocation
+                target = typeInfo?.needsHeapAllocation
                     ? `*${leftText}`
                     : leftText;
                 if (opToken.kind === ts.SyntaxKind.AmpersandAmpersandEqualsToken) {
@@ -468,7 +467,7 @@ export function visitBinaryExpression(node, context) {
             if (context.derefBeforeAssignment) {
                 target = this.getDerefCode(leftText, leftText, visitContext, typeInfo);
             }
-            else if (typeInfo.needsHeapAllocation) {
+            else if (typeInfo?.needsHeapAllocation) {
                 target = `*${leftText}`;
             }
         }
@@ -575,7 +574,7 @@ export function visitBinaryExpression(node, context) {
         }
         const target = context.derefBeforeAssignment
             ? this.getDerefCode(leftText, leftText, visitContext, typeInfo)
-            : (typeInfo.needsHeapAllocation ? `*${leftText}` : leftText);
+            : (typeInfo?.needsHeapAllocation ? `*${leftText}` : leftText);
         // Update scope symbols on variable re-assignment
         // Reset features
         if (ts.isIdentifier(binExpr.left)) {
@@ -644,7 +643,8 @@ export function visitBinaryExpression(node, context) {
         return `jspp::nullish_coalesce(${finalLeft}, ${finalRight})`;
     }
     const isLiteral = (n) => ts.isNumericLiteral(n);
-    const supportsNativeBoolean = context.supportedNativeLiterals?.includes("boolean") || false;
+    const supportsNativeBoolean = ts.isIfStatement(node.parent) ||
+        ts.isConditionalExpression(node.parent);
     // Native values for lhs and rhs
     const literalLeft = isLiteral(binExpr.left)
         ? binExpr.left.getText()
@@ -744,10 +744,7 @@ export function visitConditionalExpression(node, context) {
     const condExpr = node;
     const isBinaryExpression = ts.isBinaryExpression(condExpr.condition) &&
         constants.booleanOperators.includes(condExpr.condition.operatorToken.kind);
-    const condition = this.visit(condExpr.condition, {
-        ...context,
-        supportedNativeLiterals: isBinaryExpression ? ["boolean"] : undefined,
-    });
+    const condition = this.visit(condExpr.condition, context);
     const whenTrueStmt = this.visit(condExpr.whenTrue, {
         ...context,
         isFunctionBody: false,
@@ -1023,6 +1020,7 @@ export function visitCallExpression(node, context) {
         if (nativeFeature && nativeFeature.type === "lambda") {
             const nativeName = nativeFeature.name;
             const parameters = nativeFeature.parameters || [];
+            const argumentKeywordIsUsed = nativeFeature.argumentKeywordIsUsed;
             if (!hasSpread) {
                 let argsPart = "";
                 if (parameters) {
@@ -1041,10 +1039,17 @@ export function visitCallExpression(node, context) {
                         .filter((_, i) => !parameters[i]?.dotDotDotToken).join(", ");
                     if (argsText)
                         argsPart += `, ${argsText}`;
-                    if (argsArray.length > parameters.length &&
+                    if (argsArray.length >= parameters.length &&
                         !!parameters[parameters.length - 1]?.dotDotDotToken) {
                         const restArgsText = `jspp::AnyValue::make_array(std::vector<jspp::AnyValue>{${argsArray.slice(parameters.length - 1).join(", ")}})`;
-                        argsPart += `, ${restArgsText}`;
+                        argsPart += `, ${restArgsText}${argumentKeywordIsUsed ? `, ${argsArray.length}` : ""}`;
+                    }
+                    else if (argsArray.length > parameters.length &&
+                        argumentKeywordIsUsed) {
+                        const restArgsArray = argsArray.slice(parameters.length);
+                        const nativeRestArgsText = `std::span<const jspp::AnyValue>((const jspp::AnyValue[]){${restArgsArray.join(", ")}}, ${restArgsArray.length})`;
+                        argsPart +=
+                            `, ${argsArray.length}, ${nativeRestArgsText}`;
                     }
                 }
                 const callImplementation = `${nativeName}(jspp::Constants::UNDEFINED${argsPart})`;
@@ -1070,28 +1075,34 @@ export function visitCallExpression(node, context) {
                     if (!p)
                         continue;
                     if (p.dotDotDotToken) {
-                        callArgs.push(`jspp::AnyValue::make_array(std::vector<jspp::AnyValue>(${argsVar}.begin() + std::min((size_t)${i}, ${argsVar}.size()), ${argsVar}.end()))`);
+                        callArgs.push(`jspp::AnyValue::make_array(std::vector<jspp::AnyValue>(${argsVar}.begin() + std::min((std::size_t)${i}, ${argsVar}.size()), ${argsVar}.end()))`);
                     }
                     else {
                         callArgs.push(`(${argsVar}.size() > ${i} ? ${argsVar}[${i}] : jspp::Constants::UNDEFINED)`);
                     }
                 }
-                let callExprStr = `${nativeName}(jspp::Constants::UNDEFINED${callArgs.length > 0 ? ", " + callArgs.join(", ") : ""})`;
+                const callArgsPart = callArgs.length > 0
+                    ? `, ${callArgs.join(", ")}`
+                    : "";
+                const totalArgsSizePart = argumentKeywordIsUsed
+                    ? `, ${argsVar}.size()`
+                    : "";
+                let callImplementation = `${nativeName}(jspp::Constants::UNDEFINED${callArgsPart}${totalArgsSizePart})`;
                 if (symbol.features.isGenerator) {
                     if (symbol.features.isAsync) {
-                        callExprStr =
-                            `jspp::AnyValue::from_async_iterator(${callExprStr})`;
+                        callImplementation =
+                            `jspp::AnyValue::from_async_iterator(${callImplementation})`;
                     }
                     else {
-                        callExprStr =
-                            `jspp::AnyValue::from_iterator(${callExprStr})`;
+                        callImplementation =
+                            `jspp::AnyValue::from_iterator(${callImplementation})`;
                     }
                 }
                 else if (symbol.features.isAsync) {
-                    callExprStr =
-                        `jspp::AnyValue::from_promise(${callExprStr})`;
+                    callImplementation =
+                        `jspp::AnyValue::from_promise(${callImplementation})`;
                 }
-                code += `${this.indent()}return ${callExprStr};\n`;
+                code += `${this.indent()}return ${callImplementation};\n`;
                 this.indentationLevel--;
                 code += `${this.indent()}})()`;
                 return code;

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

@@ -5,6 +5,8 @@ import { CodeGenerator } from "./index.js";
 export function generateLambdaComponents(node, context, options) {
     const declaredSymbols = this.getDeclaredSymbols(node);
     const argsName = this.generateUniqueName("__args_", declaredSymbols, context.globalScopeSymbols, context.localScopeSymbols);
+    const nativeExcessArgsName = this.generateUniqueName("__excess_args", declaredSymbols, context.globalScopeSymbols, context.localScopeSymbols);
+    const nativeTotalArgsSizeName = this.generateUniqueName("__total_args_size", declaredSymbols, context.globalScopeSymbols, context.localScopeSymbols);
     const isInsideGeneratorFunction = this.isGeneratorFunction(node);
     const isInsideAsyncFunction = this.isAsyncFunction(node);
     const isArrow = ts.isArrowFunction(node);
@@ -59,7 +61,7 @@ export function generateLambdaComponents(node, context, options) {
             nativePreamble +=
                 `${this.indent()}jspp::AnyValue ${this.globalThisVar} = ${finalThisParamName};\n`;
         }
-        // Note: Arguments are now automatically copied into the coroutine frame because 
+        // Note: Arguments are now automatically copied into the coroutine frame because
         // the lambda parameter is passed by value (std::vector).
         // We just need to define argsName as a reference to the parameter.
         preamble +=
@@ -69,17 +71,32 @@ export function generateLambdaComponents(node, context, options) {
     let nativeFuncArgs = "";
     let nativeParamsContent = "";
     this.validateFunctionParams(node.parameters).forEach((p, i) => {
-        const name = ts.isIdentifier(p.name)
-            ? p.name.text
-            : this.generateUniqueName(`__param_native_${i}_`, visitContext.localScopeSymbols);
+        const isIdentifier = ts.isIdentifier(p.name);
+        const name = isIdentifier ? p.name.text : this.generateUniqueName(`__param_native_${i}_`, visitContext.localScopeSymbols);
         const defaultValue = p.initializer
             ? this.visit(p.initializer, visitContext)
             : !!p.dotDotDotToken
                 ? "jspp::AnyValue::make_array(std::vector<jspp::AnyValue>{})"
                 : "jspp::Constants::UNDEFINED";
-        nativeFuncArgs += `, jspp::AnyValue ${name} = ${defaultValue}`;
-        if (!ts.isIdentifier(p.name)) {
-            nativeParamsContent += this.generateDestructuring(p.name, name, visitContext) + ";\n";
+        let signatureName = name;
+        let needsTemp = !isIdentifier;
+        if (isIdentifier) {
+            const scope = this.getScopeForNode(p);
+            const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(name, scope);
+            if (typeInfo?.needsHeapAllocation) {
+                needsTemp = true;
+                signatureName = this.generateUniqueName(`__${name}_param_`, visitContext.localScopeSymbols);
+            }
+        }
+        nativeFuncArgs += `, jspp::AnyValue ${signatureName} = ${defaultValue}`;
+        if (needsTemp) {
+            if (isIdentifier) {
+                nativeParamsContent +=
+                    `${this.indent()}auto ${name} = std::make_shared<jspp::AnyValue>(${signatureName});\n`;
+            }
+            else {
+                nativeParamsContent += this.generateDestructuring(p.name, signatureName, visitContext) + ";\n";
+            }
         }
     });
     // Extract lambda parameters from arguments span/vector
@@ -102,7 +119,7 @@ export function generateLambdaComponents(node, context, options) {
                 // Handle rest parameters
                 if (!!p.dotDotDotToken) {
                     const initValue = `jspp::AnyValue::make_array(${argsName}.subspan(${i}))`;
-                    if (typeInfo.needsHeapAllocation) {
+                    if (typeInfo?.needsHeapAllocation) {
                         paramsCode +=
                             `${this.indent()}auto ${name} = std::make_shared<jspp::AnyValue>(${initValue});\n`;
                     }
@@ -114,7 +131,7 @@ export function generateLambdaComponents(node, context, options) {
                 }
                 // Normal parameter
                 const initValue = `${argsName}.size() > ${i} ? ${argsName}[${i}] : ${defaultValue}`;
-                if (typeInfo && typeInfo.needsHeapAllocation) {
+                if (typeInfo?.needsHeapAllocation) {
                     paramsCode +=
                         `${this.indent()}auto ${name} = std::make_shared<jspp::AnyValue>(${initValue});\n`;
                 }
@@ -139,6 +156,31 @@ export function generateLambdaComponents(node, context, options) {
     // Generate params and function body
     let paramsContent = "";
     let blockContentWithoutOpeningBrace = "";
+    // Generate `arguments` variable if it used in the function body
+    if (this.isVariableUsedWithoutDeclaration("arguments", node.body)) {
+        // Add span parameter for holding the excess arguments from the caller of the native lambda
+        nativeFuncArgs +=
+            `, const std::size_t ${nativeTotalArgsSizeName}, std::span<const jspp::AnyValue> ${nativeExcessArgsName} = {}`;
+        // TODO: compile arguments array from parameters
+        // this.indentationLevel++;
+        // nativeParamsContent +=
+        //     `${this.indent()}jspp::AnyValue arguments = jspp::Constants::UNDEFINED;\n`;
+        // nativeParamsContent += `${this.indent()}{\n`;
+        // this.indentationLevel++;
+        // nativeParamsContent +=
+        //     `${this.indent()}std::vector<jspp::AnyValue> ${argsName};\n`;
+        // this.validateFunctionParams(node.parameters).forEach(
+        //     (p, i) => {
+        //     },
+        // );
+        // this.indentationLevel--;
+        // nativeParamsContent += `${this.indent()}}\n`;
+        // this.indentationLevel--;
+        // this.indentationLevel++;
+        // paramsContent =
+        //     `${this.indent()}jspp::AnyValue arguments = jspp::AnyValue::make_array(${argsName});\n`;
+        // this.indentationLevel--;
+    }
     if (node.body) {
         if (ts.isBlock(node.body)) {
             // Hoist var declarations in the function body
@@ -148,8 +190,16 @@ export function generateLambdaComponents(node, context, options) {
                 preamble += hoistCode;
                 nativePreamble += hoistCode;
             });
+            // Hoist parameters (especially for destructuring)
+            node.parameters.forEach((p) => {
+                if (!ts.isIdentifier(p.name)) {
+                    const hoistCode = this.hoistDeclaration(p, visitContext.localScopeSymbols, node.body);
+                    preamble += hoistCode;
+                    nativePreamble += hoistCode;
+                }
+            });
             this.indentationLevel++;
-            paramsContent = generateParamsBuilder();
+            paramsContent += generateParamsBuilder();
             this.indentationLevel--;
             // 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, {
@@ -163,7 +213,7 @@ export function generateLambdaComponents(node, context, options) {
         }
         else {
             this.indentationLevel++;
-            paramsContent = generateParamsBuilder();
+            paramsContent += generateParamsBuilder();
             blockContentWithoutOpeningBrace =
                 `${this.indent()}${returnCommand} ${this.visit(node.body, {
                     ...visitContext,
@@ -283,7 +333,23 @@ export function generateWrappedLambda(comps) {
             args += `, "${funcName}"`;
         }
     }
-    const fullExpression = `${method}(${args})`;
+    let prototypeExpr = "";
+    if (isInsideGeneratorFunction) {
+        if (isInsideAsyncFunction) {
+            prototypeExpr =
+                '::AsyncGeneratorFunction.get_own_property("prototype")';
+        }
+        else {
+            prototypeExpr = '::GeneratorFunction.get_own_property("prototype")';
+        }
+    }
+    else if (isInsideAsyncFunction) {
+        prototypeExpr = '::AsyncFunction.get_own_property("prototype")';
+    }
+    else {
+        prototypeExpr = '::Function.get_own_property("prototype")';
+    }
+    const fullExpression = `${method}(${args}).set_prototype(${prototypeExpr})`;
     if (ts.isFunctionDeclaration(node) && !isAssignment && node.name) {
         const funcName = node.name?.getText();
         return `${this.indent()}auto ${funcName} = ${fullExpression};\n`;

package/dist/core/codegen/helpers.js

@@ -161,6 +161,9 @@ export function getJsVarName(node) {
  * @returns The C++ code for accessing the variable's value.
  */
 export function getDerefCode(nodeText, varName, context, typeInfo) {
+    if (typeInfo?.isBuiltin) {
+        return nodeText;
+    }
     // Make sure varName is incased in quotes
     if (!varName.startsWith('"'))
         varName = '"' + varName;
@@ -230,21 +233,23 @@ export function getReturnCommand(context) {
  * @throws CompilerError if a duplicate declaration is found.
  */
 export function hoistDeclaration(decl, hoistedSymbols, scopeNode) {
-    const isLet = ts.isVariableDeclaration(decl) &&
-        (decl.parent.flags & (ts.NodeFlags.Let)) !== 0;
+    const isLet = ts.isParameter(decl) || (ts.isVariableDeclaration(decl) &&
+        (decl.parent.flags & (ts.NodeFlags.Let)) !== 0);
     const isConst = ts.isVariableDeclaration(decl) &&
         (decl.parent.flags & (ts.NodeFlags.Const)) !== 0;
-    const declType = isLet
+    const declType = ts.isParameter(decl)
         ? DeclarationType.let
-        : isConst
-            ? DeclarationType.const
-            : ts.isFunctionDeclaration(decl)
-                ? DeclarationType.function
-                : ts.isClassDeclaration(decl)
-                    ? DeclarationType.class
-                    : ts.isEnumDeclaration(decl)
-                        ? DeclarationType.enum
-                        : DeclarationType.var;
+        : isLet
+            ? DeclarationType.let
+            : isConst
+                ? DeclarationType.const
+                : ts.isFunctionDeclaration(decl)
+                    ? DeclarationType.function
+                    : ts.isClassDeclaration(decl)
+                        ? DeclarationType.class
+                        : ts.isEnumDeclaration(decl)
+                            ? DeclarationType.enum
+                            : DeclarationType.var;
     const hoistName = (nameNode) => {
         if (ts.isIdentifier(nameNode)) {
             const name = nameNode.text;
@@ -268,7 +273,8 @@ export function hoistDeclaration(decl, hoistedSymbols, scopeNode) {
                     (ts.isVariableDeclaration(decl) && decl.initializer &&
                         nameNode === decl.name &&
                         (ts.isArrowFunction(decl.initializer) ||
-                            ts.isFunctionExpression(decl.initializer)))) {
+                            (ts.isFunctionExpression(decl.initializer) &&
+                                !decl.initializer.name)))) {
                     const funcExpr = ts.isVariableDeclaration(decl)
                         ? decl.initializer
                         : decl;
@@ -294,7 +300,7 @@ export function hoistDeclaration(decl, hoistedSymbols, scopeNode) {
             const initializer = isLet || isConst || ts.isClassDeclaration(decl)
                 ? "jspp::Constants::UNINITIALIZED"
                 : "jspp::Constants::UNDEFINED";
-            if (typeInfo.needsHeapAllocation) {
+            if (typeInfo?.needsHeapAllocation) {
                 return `${this.indent()}auto ${name} = std::make_shared<jspp::AnyValue>(${initializer});\n`;
             }
             else {
@@ -638,6 +644,77 @@ export function isDeclarationUsedBeforeInitialization(name, root) {
     visit(root);
     return isUsedBefore;
 }
+/**
+ * Checks if a variable name is used within a node subtree without a preceding declaration.
+ * Returns true if:
+ * 1. The variable is used but never declared within the provided root node.
+ * 2. The variable is used lexically before its declaration within the root node.
+ *
+ * @param name The variable name to check.
+ * @param root The root node to search within.
+ * @returns True if used without/before declaration.
+ */
+export function isVariableUsedWithoutDeclaration(name, root) {
+    let declPos = -1;
+    let foundDecl = false;
+    // 1. Find the declaration position within this root
+    const findDecl = (node) => {
+        if (foundDecl)
+            return;
+        if ((ts.isFunctionDeclaration(node) ||
+            ts.isClassDeclaration(node) ||
+            ts.isVariableDeclaration(node) ||
+            ts.isEnumDeclaration(node) ||
+            ts.isParameter(node)) &&
+            node.name && ts.isIdentifier(node.name) && node.name.text === name) {
+            declPos = node.getStart();
+            foundDecl = true;
+        }
+        else {
+            ts.forEachChild(node, findDecl);
+        }
+    };
+    findDecl(root);
+    let isUsedIllegally = false;
+    // 2. Traverse for usages
+    const visit = (node) => {
+        if (isUsedIllegally)
+            return;
+        if (ts.isIdentifier(node) && node.text === name) {
+            const parent = node.parent;
+            // Skip if this identifier IS the declaration site
+            const isDeclarationSite = (ts.isFunctionDeclaration(parent) ||
+                ts.isVariableDeclaration(parent) ||
+                ts.isClassDeclaration(parent) ||
+                ts.isMethodDeclaration(parent) ||
+                ts.isEnumDeclaration(parent) ||
+                ts.isEnumMember(parent) ||
+                ts.isParameter(parent) ||
+                ts.isImportSpecifier(parent)) &&
+                parent.name === node;
+            // Skip if it's a property access (e.g., obj.name)
+            const isProperty = (ts.isPropertyAccessExpression(parent) &&
+                parent.name === node) ||
+                (ts.isPropertyAssignment(parent) && parent.name === node);
+            if (!isDeclarationSite && !isProperty) {
+                const usagePos = node.getStart();
+                // Case 1: Used but not declared in this node
+                if (!foundDecl) {
+                    isUsedIllegally = true;
+                    return;
+                }
+                // Case 2: Used lexically before declaration
+                if (usagePos < declPos) {
+                    isUsedIllegally = true;
+                    return;
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(root);
+    return isUsedIllegally;
+}
 /**
  * Validates and filters function parameters, checking for illegal "this"
  * and correctly positioned rest parameters.

package/dist/core/codegen/index.js

@@ -1,6 +1,6 @@
 import { DeclaredSymbols } from "../../ast/symbols.js";
 import { generateLambdaComponents, generateNativeLambda, generateWrappedLambda, } from "./function-handlers.js";
-import { escapeString, generateUniqueExceptionName, generateUniqueName, getDeclaredSymbols, getDerefCode, getJsVarName, getReturnCommand, getScopeForNode, hoistDeclaration, indent, isAsyncFunction, isBuiltinObject, isDeclarationCalledAsFunction, isDeclarationUsedAsValue, isDeclarationUsedBeforeInitialization, isGeneratorFunction, markSymbolAsInitialized, prepareScopeSymbolsForVisit, validateFunctionParams, } from "./helpers.js";
+import { escapeString, generateUniqueExceptionName, generateUniqueName, getDeclaredSymbols, getDerefCode, getJsVarName, getReturnCommand, getScopeForNode, hoistDeclaration, indent, isAsyncFunction, isBuiltinObject, isDeclarationCalledAsFunction, isDeclarationUsedAsValue, isDeclarationUsedBeforeInitialization, isVariableUsedWithoutDeclaration, isGeneratorFunction, markSymbolAsInitialized, prepareScopeSymbolsForVisit, validateFunctionParams, } from "./helpers.js";
 import { generateDestructuring } from "./destructuring-handlers.js";
 import { visit } from "./visitor.js";
 const MODULE_NAME = "__entry_point__";
@@ -31,6 +31,7 @@ export class CodeGenerator {
     isDeclarationCalledAsFunction = isDeclarationCalledAsFunction;
     isDeclarationUsedAsValue = isDeclarationUsedAsValue;
     isDeclarationUsedBeforeInitialization = isDeclarationUsedBeforeInitialization;
+    isVariableUsedWithoutDeclaration = isVariableUsedWithoutDeclaration;
     validateFunctionParams = validateFunctionParams;
     generateDestructuring = generateDestructuring;
     // function handlers
@@ -44,7 +45,7 @@ export class CodeGenerator {
         this.typeAnalyzer = analyzer;
         this.isTypescript = isTypescript;
         this.globalThisVar = this.generateUniqueName("__this_val__", this.getDeclaredSymbols(ast));
-        const declarations = `#include "index.hpp"\n\n`;
+        const declarations = `#include "jspp.hpp"\n#include "library/global_usings.hpp"\n\n`;
         let containerCode = `jspp::JsPromise ${MODULE_NAME}() {\n`;
         this.indentationLevel++;
         containerCode +=
@@ -63,6 +64,7 @@ export class CodeGenerator {
         containerCode += "}\n\n";
         let mainCode = "int main(int argc, char** argv) {\n";
         mainCode += `  try {\n`;
+        mainCode += `    jspp::initialize_runtime();\n`;
         mainCode += `    jspp::setup_process_argv(argc, argv);\n`;
         mainCode += `    auto p = ${MODULE_NAME}();\n`;
         mainCode += `    p.then(nullptr, [](jspp::AnyValue err) {\n`;

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

@@ -54,12 +54,14 @@ export function visitSourceFile(node, context) {
         this.markSymbolAsInitialized(funcName, globalScopeSymbols, localScopeSymbols);
         // Update features in the symbol registry
         const nativeName = this.generateUniqueName(`__${funcName}_native_`, hoistedSymbols);
+        const argumentKeywordIsUsed = this.isVariableUsedWithoutDeclaration("arguments", stmt.body);
         hoistedSymbols.update(funcName, {
             features: {
                 native: {
                     type: "lambda",
                     name: nativeName,
                     parameters: this.validateFunctionParams(stmt.parameters),
+                    argumentKeywordIsUsed,
                 },
             },
         });
@@ -151,12 +153,14 @@ export function visitBlock(node, context) {
         this.markSymbolAsInitialized(funcName, globalScopeSymbols, localScopeSymbols);
         // Update features in the symbol registry
         const nativeName = this.generateUniqueName(`__${funcName}_native_`, hoistedSymbols);
+        const argumentKeywordIsUsed = this.isVariableUsedWithoutDeclaration("arguments", stmt.body);
         hoistedSymbols.update(funcName, {
             features: {
                 native: {
                     type: "lambda",
                     name: nativeName,
                     parameters: this.validateFunctionParams(stmt.parameters),
+                    argumentKeywordIsUsed,
                 },
             },
         });
@@ -238,7 +242,7 @@ export function visitEnumDeclaration(node, context) {
     const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(name, scope);
     // Mark as initialized
     this.markSymbolAsInitialized(name, context.globalScopeSymbols, context.localScopeSymbols);
-    const enumVar = typeInfo.needsHeapAllocation ? `(*${name})` : name;
+    const enumVar = typeInfo?.needsHeapAllocation ? `(*${name})` : name;
     let code = `${this.indent()}${enumVar} = jspp::AnyValue::make_object({});\n`;
     code += `${this.indent()}{\n`;
     this.indentationLevel++;
@@ -337,10 +341,7 @@ export function visitIfStatement(node, context) {
     const ifStmt = node;
     const isBinaryExpression = ts.isBinaryExpression(ifStmt.expression) &&
         constants.booleanOperators.includes(ifStmt.expression.operatorToken.kind);
-    const condition = this.visit(ifStmt.expression, {
-        ...context,
-        supportedNativeLiterals: isBinaryExpression ? ["boolean"] : undefined,
-    });
+    const condition = this.visit(ifStmt.expression, context);
     const thenStmt = this.visit(ifStmt.thenStatement, {
         ...context,
         isFunctionBody: false,
@@ -366,7 +367,7 @@ export function visitExpressionStatement(node, context) {
 export function visitThrowStatement(node, context) {
     const throwStmt = node;
     const expr = this.visit(throwStmt.expression, context);
-    return `${this.indent()}throw jspp::Exception(${expr});
+    return `${this.indent()}throw jspp::Exception(${expr});
 `;
 }
 export function visitTryStatement(node, context) {
@@ -656,7 +657,8 @@ export function visitCatchClause(node, context) {
         const exceptionValueCode = `jspp::Exception::exception_to_any_value(${exceptionName})`;
         if (ts.isIdentifier(catchClause.variableDeclaration.name)) {
             const varName = catchClause.variableDeclaration.name.text;
-            code += `${this.indent()}jspp::AnyValue ${varName} = ${exceptionValueCode};\n`;
+            code +=
+                `${this.indent()}jspp::AnyValue ${varName} = ${exceptionValueCode};\n`;
         }
         else {
             code += this.generateDestructuring(catchClause.variableDeclaration.name, exceptionValueCode, context) + ";\n";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ugo-studio/jspp",
-  "version": "0.2.9",
+  "version": "0.3.1",
   "description": "A modern transpiler that converts JavaScript code into high-performance, standard C++23.",
   "main": "dist/index.js",
   "module": "src/index.ts",
@@ -14,7 +14,7 @@
     "scripts"
   ],
   "scripts": {
-    "postinstall": "bun run scripts/setup-compiler.ts",
+    "postinstall": "bun run scripts/setup-compiler.ts && bun run scripts/precompile-headers.ts",
     "dev": "bun run src/cli/index.ts",
     "typecheck": "tsc --noEmit",
     "precompile": "bun run scripts/precompile-headers.ts",