@ugo-studio/jspp 0.2.6 → 0.2.7

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

@@ -1,16 +1,14 @@
 import ts from "typescript";
 import { DeclarationType, DeclaredSymbols } from "../../ast/symbols.js";
-import { CompilerError } from "../error.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,
     });
@@ -19,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,
@@ -43,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;
@@ -64,37 +43,44 @@ 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.filter((p) => this.isTypescript && p.name.getText() === "this" ? false : true // Ignore "this" 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";
-            // Catch invalid parameters
-            if (name === "this") {
-                throw new CompilerError(`Cannot use '${name}' as a parameter name.`, p, "SyntaxError");
-            }
             // Add paramerter to local context
             visitContext.localScopeSymbols.add(name, {
                 type: DeclarationType.let,
@@ -104,108 +90,114 @@ export function generateLambda(node, context, options) {
             const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(name, scope);
             // Handle rest parameters
             if (!!p.dotDotDotToken) {
-                if (parameters.length - 1 !== i) {
-                    throw new CompilerError("Rest parameter must be last formal parameter.", p, "SyntaxError");
-                }
+                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
@@ -247,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;
@@ -280,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;
@@ -295,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

@@ -167,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
@@ -293,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) {
@@ -336,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;
         }
@@ -359,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) ||
@@ -410,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,6 +1,6 @@
 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 = "__entry_point__";
 export class CodeGenerator {
@@ -29,9 +29,11 @@ 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.
      */

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)})`;
 }

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

@@ -52,21 +52,31 @@ export function visitSourceFile(node, context) {
         // Mark before further visits
         this.markSymbolAsInitialized(funcName, contextForFunctions.globalScopeSymbols, contextForFunctions.localScopeSymbols);
         this.markSymbolAsInitialized(funcName, globalScopeSymbols, localScopeSymbols);
-        // Generate and update self name
+        // Update features in the symbol registry
         const nativeName = this.generateUniqueName(`__${funcName}_native_`, hoistedSymbols);
-        hoistedSymbols.update(funcName, { func: { nativeName } });
-        // Generate lambda
-        const lambda = this.generateLambda(stmt, contextForFunctions, {
+        hoistedSymbols.update(funcName, {
+            features: {
+                native: {
+                    type: "lambda",
+                    name: nativeName,
+                    parameters: this.validateFunctionParams(stmt.parameters),
+                },
+            },
+        });
+        // Generate lambda components
+        const lambdaComps = this.generateLambdaComponents(stmt, contextForFunctions, {
             isAssignment: true,
-            generateOnlyLambda: true,
             nativeName,
+            noTypeSignature: true,
         });
-        code += `${this.indent()}auto ${nativeName} = ${lambda};\n`;
-        // Generate AnyValue wrapper
+        // Generate native lambda
+        const nativeLambda = this.generateNativeLambda(lambdaComps);
+        code += `${this.indent()}auto ${nativeName} = ${nativeLambda};\n`;
+        // Generate AnyValue wrapped lamda
         if (this.isFunctionUsedAsValue(stmt, node) ||
             this.isFunctionUsedBeforeDeclaration(funcName, node)) {
-            const fullExpression = this.generateFullLambdaExpression(stmt, contextForFunctions, nativeName, { isAssignment: true, noTypeSignature: true });
-            code += `${this.indent()}*${funcName} = ${fullExpression};\n`;
+            const wrappedLambda = this.generateWrappedLambda(lambdaComps);
+            code += `${this.indent()}*${funcName} = ${wrappedLambda};\n`;
         }
     });
     // 3. Process other statements
@@ -137,21 +147,31 @@ export function visitBlock(node, context) {
         // Mark before further visits
         this.markSymbolAsInitialized(funcName, contextForFunctions.globalScopeSymbols, contextForFunctions.localScopeSymbols);
         this.markSymbolAsInitialized(funcName, globalScopeSymbols, localScopeSymbols);
-        // Generate and update self name
+        // Update features in the symbol registry
         const nativeName = this.generateUniqueName(`__${funcName}_native_`, hoistedSymbols);
-        hoistedSymbols.update(funcName, { func: { nativeName } });
-        // Generate lambda
-        const lambda = this.generateLambda(stmt, contextForFunctions, {
+        hoistedSymbols.update(funcName, {
+            features: {
+                native: {
+                    type: "lambda",
+                    name: nativeName,
+                    parameters: this.validateFunctionParams(stmt.parameters),
+                },
+            },
+        });
+        // Generate lambda components
+        const lambdaComps = this.generateLambdaComponents(stmt, contextForFunctions, {
             isAssignment: true,
-            generateOnlyLambda: true,
             nativeName,
+            noTypeSignature: true,
         });
-        code += `${this.indent()}auto ${nativeName} = ${lambda};\n`;
-        // Generate AnyValue wrapper
+        // Generate native lambda
+        const nativeLambda = this.generateNativeLambda(lambdaComps);
+        code += `${this.indent()}auto ${nativeName} = ${nativeLambda};\n`;
+        // Generate AnyValue wrapped lamda
         if (this.isFunctionUsedAsValue(stmt, node) ||
             this.isFunctionUsedBeforeDeclaration(funcName, node)) {
-            const fullExpression = this.generateFullLambdaExpression(stmt, contextForFunctions, nativeName, { isAssignment: true, noTypeSignature: true });
-            code += `${this.indent()}*${funcName} = ${fullExpression};\n`;
+            const wrappedLambda = this.generateWrappedLambda(lambdaComps);
+            code += `${this.indent()}*${funcName} = ${wrappedLambda};\n`;
         }
     });
     // 3. Process other statements
@@ -242,7 +262,7 @@ export function visitEnumDeclaration(node, context) {
         }
         else {
             // Auto-increment
-            valueCode = `lastVal + 1`;
+            valueCode = `jspp::add(lastVal, 1)`;
         }
         code += `${this.indent()}lastVal = ${valueCode};\n`;
         code +=

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ugo-studio/jspp",
-  "version": "0.2.6",
+  "version": "0.2.7",
   "description": "A modern transpiler that converts JavaScript code into high-performance, standard C++23.",
   "main": "dist/index.js",
   "module": "src/index.ts",