@ugo-studio/jspp 0.1.3 → 0.1.5

package/dist/core/codegen/control-flow-handlers.js

@@ -0,0 +1,474 @@
+import ts from "typescript";
+import { DeclaredSymbols, DeclaredSymbolType } from "../../ast/symbols";
+import { CodeGenerator } from "./";
+export function visitForStatement(node, context) {
+    const forStmt = node;
+    let code = "";
+    if (context.currentLabel) {
+        code += `${this.indent()}${context.currentLabel}: {\n`;
+        this.indentationLevel++;
+    }
+    this.indentationLevel++; // Enter a new scope for the for loop
+    // Handle initializer
+    let initializerCode = "";
+    let conditionContext = {
+        ...context,
+        topLevelScopeSymbols: this.prepareScopeSymbolsForVisit(context.topLevelScopeSymbols, context.localScopeSymbols),
+    };
+    if (forStmt.initializer) {
+        if (ts.isVariableDeclarationList(forStmt.initializer)) {
+            const varDeclList = forStmt.initializer;
+            const isLetOrConst = (varDeclList.flags &
+                (ts.NodeFlags.Let | ts.NodeFlags.Const)) !==
+                0;
+            if (isLetOrConst) {
+                const decl = varDeclList.declarations[0];
+                if (decl) {
+                    const name = decl.name.getText();
+                    const initValue = decl.initializer
+                        ? this.visit(decl.initializer, context)
+                        : "jspp::Constants::UNDEFINED";
+                    const scope = this.getScopeForNode(decl);
+                    const typeInfo = this.typeAnalyzer.scopeManager
+                        .lookupFromScope(name, scope);
+                    conditionContext.localScopeSymbols = new DeclaredSymbols();
+                    conditionContext.localScopeSymbols.set(name, {
+                        type: DeclaredSymbolType.letOrConst,
+                        checkedIfUninitialized: true,
+                    });
+                    if (typeInfo.needsHeapAllocation) {
+                        initializerCode =
+                            `auto ${name} = std::make_shared<jspp::AnyValue>(${initValue})`;
+                    }
+                    else {
+                        initializerCode =
+                            `jspp::AnyValue ${name} = ${initValue}`;
+                    }
+                }
+            }
+            else {
+                initializerCode = this.visit(forStmt.initializer, {
+                    ...context,
+                    isAssignmentOnly: true,
+                });
+            }
+        }
+        else {
+            initializerCode = this.visit(forStmt.initializer, context);
+        }
+    }
+    code += `${this.indent()}for (${initializerCode}; `;
+    if (forStmt.condition) {
+        code += `is_truthy(${this.visit(forStmt.condition, conditionContext)})`;
+    }
+    code += "; ";
+    if (forStmt.incrementor) {
+        code += this.visit(forStmt.incrementor, context);
+    }
+    code += ") ";
+    const statementCode = this.visit(forStmt.statement, {
+        ...context,
+        currentLabel: undefined,
+        isFunctionBody: false,
+    });
+    if (ts.isBlock(node.statement)) {
+        let blockContent = statementCode.substring(1, statementCode.length - 2); // remove curly braces
+        if (context.currentLabel) {
+            blockContent +=
+                `${this.indent()}${context.currentLabel}_continue:;\n`;
+        }
+        code += `{\n${blockContent}}\n`;
+    }
+    else {
+        code += `{\n`;
+        code += statementCode;
+        if (context.currentLabel) {
+            code += `${this.indent()}${context.currentLabel}_continue:;\n`;
+        }
+        code += `${this.indent()}}\n`;
+    }
+    this.indentationLevel--; // Exit the scope for the for loop
+    if (context.currentLabel) {
+        this.indentationLevel--;
+        code += `${this.indent()}}\n`;
+        code +=
+            `${this.indent()}${context.currentLabel}_break:; // break target\n`;
+    }
+    return code;
+}
+export function visitForInStatement(node, context) {
+    const forIn = node;
+    let code = "";
+    if (context.currentLabel) {
+        code += `${this.indent()}${context.currentLabel}: {\n`;
+        this.indentationLevel++;
+    }
+    code += `${this.indent()}{\n`;
+    this.indentationLevel++; // Enter a new scope for the for-in loop
+    let varName = "";
+    let assignmentTarget = "";
+    if (ts.isVariableDeclarationList(forIn.initializer)) {
+        const decl = forIn.initializer.declarations[0];
+        if (decl) {
+            varName = decl.name.getText();
+            const scope = this.getScopeForNode(decl);
+            const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(varName, scope);
+            if (typeInfo.needsHeapAllocation) {
+                code +=
+                    `${this.indent()}auto ${varName} = std::make_shared<jspp::AnyValue>(jspp::Constants::UNDEFINED);\n`;
+                assignmentTarget = `*${varName}`;
+            }
+            else {
+                code +=
+                    `${this.indent()}jspp::AnyValue ${varName} = jspp::Constants::UNDEFINED;\n`;
+                assignmentTarget = varName;
+            }
+        }
+    }
+    else if (ts.isIdentifier(forIn.initializer)) {
+        varName = forIn.initializer.getText();
+        const scope = this.getScopeForNode(forIn.initializer);
+        const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(varName, scope);
+        assignmentTarget = typeInfo.needsHeapAllocation
+            ? `*${varName}`
+            : varName;
+    }
+    const expr = forIn.expression;
+    const exprText = this.visit(expr, context);
+    let derefExpr = exprText;
+    if (ts.isIdentifier(expr)) {
+        const scope = this.getScopeForNode(expr);
+        const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(expr.getText(), scope);
+        derefExpr = this.getDerefCode(exprText, this.getJsVarName(expr), context, typeInfo);
+    }
+    const keysVar = this.generateUniqueName("__keys_", new Set([varName]));
+    code +=
+        `${this.indent()}std::vector<std::string> ${keysVar} = jspp::Access::get_object_keys(${derefExpr});\n`;
+    code += `${this.indent()}for (const auto& ${varName}_str : ${keysVar}) {\n`;
+    this.indentationLevel++;
+    code +=
+        `${this.indent()}${assignmentTarget} = jspp::AnyValue::make_string(${varName}_str);\n`;
+    code += this.visit(forIn.statement, {
+        ...context,
+        currentLabel: undefined,
+        isFunctionBody: false,
+    });
+    this.indentationLevel--;
+    if (context.currentLabel) {
+        code += `${this.indent()}${context.currentLabel}_continue:;\n`;
+    }
+    code += `${this.indent()}}\n`;
+    this.indentationLevel--; // Exit the scope for the for-in loop
+    code += `${this.indent()}}\n`;
+    if (context.currentLabel) {
+        this.indentationLevel--;
+        code += `${this.indent()}}\n`;
+        code +=
+            `${this.indent()}${context.currentLabel}_break:; // break target\n`;
+    }
+    return code;
+}
+export function visitForOfStatement(node, context) {
+    const forOf = node;
+    let code = "";
+    if (context.currentLabel) {
+        code += `${this.indent()}${context.currentLabel}: {\n`;
+        this.indentationLevel++;
+    }
+    this.indentationLevel++; // Enter a new scope for the for-of loop
+    let elemName = "";
+    let assignmentTarget = "";
+    code += `${this.indent()}{\n`;
+    if (ts.isVariableDeclarationList(forOf.initializer)) {
+        const decl = forOf.initializer.declarations[0];
+        if (decl) {
+            elemName = decl.name.getText();
+            const scope = this.getScopeForNode(decl);
+            const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(elemName, scope);
+            if (typeInfo.needsHeapAllocation) {
+                code +=
+                    `${this.indent()}auto ${elemName} = std::make_shared<jspp::AnyValue>(jspp::Constants::UNDEFINED);\n`;
+                assignmentTarget = `*${elemName}`;
+            }
+            else {
+                code +=
+                    `${this.indent()}jspp::AnyValue ${elemName} = jspp::Constants::UNDEFINED;\n`;
+                assignmentTarget = elemName;
+            }
+        }
+    }
+    else if (ts.isIdentifier(forOf.initializer)) {
+        elemName = forOf.initializer.getText();
+        const scope = this.getScopeForNode(forOf.initializer);
+        const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(elemName, scope);
+        assignmentTarget = typeInfo.needsHeapAllocation
+            ? `*${elemName}`
+            : elemName;
+    }
+    const iterableExpr = this.visit(forOf.expression, context);
+    let derefIterable = iterableExpr;
+    if (ts.isIdentifier(forOf.expression)) {
+        const scope = this.getScopeForNode(forOf.expression);
+        const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(forOf.expression.getText(), scope);
+        const varName = this.getJsVarName(forOf.expression);
+        derefIterable = this.getDerefCode(iterableExpr, varName, context, typeInfo);
+    }
+    const declaredSymbols = this.getDeclaredSymbols(forOf.statement);
+    const iterableRef = this.generateUniqueName("__iter_ref", declaredSymbols);
+    const iterator = this.generateUniqueName("__iter", declaredSymbols);
+    const nextFunc = this.generateUniqueName("__next_func", declaredSymbols);
+    const nextRes = this.generateUniqueName("__next_res", declaredSymbols);
+    const varName = this.getJsVarName(forOf.expression);
+    code += `${this.indent()}auto ${iterableRef} = ${derefIterable};\n`;
+    code +=
+        `${this.indent()}auto ${iterator} = jspp::Access::get_object_value_iterator(${iterableRef}, ${varName});\n`;
+    code +=
+        `${this.indent()}auto ${nextFunc} = ${iterator}.get_own_property("next");\n`;
+    code +=
+        `${this.indent()}auto ${nextRes} = ${nextFunc}.call(${iterator}, {}, "next");\n`;
+    code +=
+        `${this.indent()}while (!is_truthy(${nextRes}.get_own_property("done"))) {\n`;
+    this.indentationLevel++;
+    code +=
+        `${this.indent()}${assignmentTarget} = ${nextRes}.get_own_property("value");\n`;
+    code += this.visit(forOf.statement, {
+        ...context,
+        currentLabel: undefined,
+        isFunctionBody: false,
+    });
+    if (context.currentLabel) {
+        code += `${this.indent()}${context.currentLabel}_continue:;\n`;
+    }
+    code +=
+        `${this.indent()}${nextRes} = ${nextFunc}.call(${iterator}, {}, "next");\n`;
+    this.indentationLevel--;
+    code += `${this.indent()}}\n`;
+    this.indentationLevel--; // Exit the scope for the for-of loop
+    code += `${this.indent()}}\n`;
+    if (context.currentLabel) {
+        this.indentationLevel--;
+        code += `${this.indent()}}\n`;
+        code +=
+            `${this.indent()}${context.currentLabel}_break:; // break target\n`;
+    }
+    return code;
+}
+export function visitWhileStatement(node, context) {
+    const condition = node.expression;
+    const conditionText = condition.kind === ts.SyntaxKind.TrueKeyword ||
+        condition.kind === ts.SyntaxKind.FalseKeyword
+        ? condition.getText()
+        : `is_truthy(${this.visit(condition, context)})`;
+    let code = "";
+    if (context.currentLabel) {
+        code += `${this.indent()}${context.currentLabel}: {\n`;
+        this.indentationLevel++;
+    }
+    code += `${this.indent()}while (${conditionText}) `;
+    const statementCode = this.visit(node.statement, {
+        ...context,
+        currentLabel: undefined,
+        isFunctionBody: false,
+    });
+    if (ts.isBlock(node.statement)) {
+        let blockContent = statementCode.substring(1, statementCode.length - 2); // remove curly braces
+        if (context.currentLabel) {
+            blockContent +=
+                `${this.indent()}${context.currentLabel}_continue:;\n`;
+        }
+        code += `{\n${blockContent}}\n`;
+    }
+    else {
+        code += `{\n`;
+        this.indentationLevel++;
+        code += statementCode;
+        if (context.currentLabel) {
+            code += `${this.indent()}${context.currentLabel}_continue:;\n`;
+        }
+        this.indentationLevel--;
+        code += `${this.indent()}}\n`;
+    }
+    if (context.currentLabel) {
+        this.indentationLevel--;
+        code += `${this.indent()}}\n`;
+        code +=
+            `${this.indent()}${context.currentLabel}_break:; // break target\n`;
+    }
+    return code;
+}
+export function visitDoStatement(node, context) {
+    const condition = node.expression;
+    const conditionText = `is_truthy(${this.visit(condition, context)})`;
+    let code = "";
+    if (context.currentLabel) {
+        code += `${this.indent()}${context.currentLabel}: {\n`;
+        this.indentationLevel++;
+    }
+    code += `${this.indent()}do `;
+    const statementCode = this.visit(node.statement, {
+        ...context,
+        currentLabel: undefined,
+        isFunctionBody: false,
+    });
+    if (ts.isBlock(node.statement)) {
+        let blockContent = statementCode.substring(1, statementCode.length - 2); // remove curly braces
+        if (context.currentLabel) {
+            blockContent +=
+                `${this.indent()}${context.currentLabel}_continue:;\n`;
+        }
+        code += `{\n${blockContent}}`;
+    }
+    else {
+        code += `{\n`;
+        this.indentationLevel++;
+        code += statementCode;
+        if (context.currentLabel) {
+            code += `${this.indent()}${context.currentLabel}_continue:;\n`;
+        }
+        this.indentationLevel--;
+        code += `${this.indent()}}`;
+    }
+    code += ` while (${conditionText});\n`;
+    if (context.currentLabel) {
+        this.indentationLevel--;
+        code += `${this.indent()}}\n`;
+        code +=
+            `${this.indent()}${context.currentLabel}_break:; // break target\n`;
+    }
+    return code;
+}
+export function visitSwitchStatement(node, context) {
+    const switchStmt = node;
+    let code = "";
+    const declaredSymbols = this.getDeclaredSymbols(switchStmt.caseBlock);
+    const switchBreakLabel = this.generateUniqueName("__switch_break_", declaredSymbols);
+    const fallthroughVar = this.generateUniqueName("__switch_fallthrough_", declaredSymbols);
+    if (context.currentLabel) {
+        code += `${this.indent()}${context.currentLabel}: {\n`;
+        this.indentationLevel++;
+    }
+    code += `${this.indent()}{\n`; // Wrap the entire switch logic in a block
+    this.indentationLevel++;
+    // Evaluate the switch expression once
+    const expressionCode = this.visit(switchStmt.expression, context);
+    const switchValueVar = this.generateUniqueName("__switch_value_", declaredSymbols);
+    code +=
+        `${this.indent()}const jspp::AnyValue ${switchValueVar} = ${expressionCode};\n`;
+    code += `${this.indent()}bool ${fallthroughVar} = false;\n`;
+    // Hoist variable declarations
+    const hoistedSymbols = new DeclaredSymbols();
+    for (const clause of switchStmt.caseBlock.clauses) {
+        if (ts.isCaseClause(clause) || ts.isDefaultClause(clause)) {
+            for (const stmt of clause.statements) {
+                if (ts.isVariableStatement(stmt)) {
+                    const varDecls = stmt.declarationList.declarations;
+                    for (const decl of varDecls) {
+                        code += this.hoistDeclaration(decl, hoistedSymbols);
+                    }
+                }
+                else if (ts.isFunctionDeclaration(stmt)) {
+                    code += this.hoistDeclaration(stmt, hoistedSymbols);
+                }
+            }
+        }
+    }
+    // Prepare scope symbols for the switch block
+    const topLevelScopeSymbols = this.prepareScopeSymbolsForVisit(context.topLevelScopeSymbols, context.localScopeSymbols);
+    let firstIf = true;
+    for (const clause of switchStmt.caseBlock.clauses) {
+        if (ts.isCaseClause(clause)) {
+            const caseExprCode = this.visit(clause.expression, {
+                ...context,
+                currentLabel: undefined, // Clear currentLabel for nested visits
+            });
+            let condition = "";
+            if (firstIf) {
+                condition =
+                    `(${fallthroughVar} || jspp::is_strictly_equal_to_primitive(${switchValueVar}, ${caseExprCode}))`;
+                code += `${this.indent()}if ${condition} {\n`;
+                firstIf = false;
+            }
+            else {
+                condition =
+                    `(${fallthroughVar} || jspp::is_strictly_equal_to_primitive(${switchValueVar}, ${caseExprCode}))`;
+                code += `${this.indent()}if ${condition} {\n`;
+            }
+            this.indentationLevel++;
+            code += `${this.indent()}${fallthroughVar} = true;\n`;
+            for (const stmt of clause.statements) {
+                if (ts.isFunctionDeclaration(stmt)) {
+                    const funcName = stmt.name?.getText();
+                    if (funcName) {
+                        const contextForFunction = {
+                            ...context,
+                            topLevelScopeSymbols,
+                            localScopeSymbols: hoistedSymbols,
+                        };
+                        const lambda = this.generateLambda(stmt, contextForFunction, { isAssignment: true });
+                        code += `${this.indent()}*${funcName} = ${lambda};\n`;
+                    }
+                }
+                else {
+                    code += this.visit(stmt, {
+                        ...context,
+                        switchBreakLabel,
+                        currentLabel: undefined, // Clear currentLabel for nested visits
+                        topLevelScopeSymbols,
+                        localScopeSymbols: hoistedSymbols,
+                        derefBeforeAssignment: true,
+                        isAssignmentOnly: ts.isVariableStatement(stmt),
+                    });
+                }
+            }
+            this.indentationLevel--;
+            code += `${this.indent()}}\n`;
+        }
+        else if (ts.isDefaultClause(clause)) {
+            // Default clause
+            code +=
+                `${this.indent()}if (!${fallthroughVar}) ${fallthroughVar} = true;\n`;
+            if (firstIf) {
+                code += `${this.indent()}if (true) {\n`; // Always execute if no prior cases match and it's the first clause
+                firstIf = false;
+            }
+            else {
+                code += `${this.indent()}if (${fallthroughVar}) {\n`; // Only execute if no prior case (or default) has matched and caused fallthrough
+            }
+            this.indentationLevel++;
+            for (const stmt of clause.statements) {
+                code += this.visit(stmt, {
+                    ...context,
+                    switchBreakLabel,
+                    currentLabel: undefined, // Clear currentLabel for nested visits
+                    topLevelScopeSymbols,
+                    localScopeSymbols: hoistedSymbols,
+                    derefBeforeAssignment: true,
+                    isAssignmentOnly: ts.isVariableStatement(stmt),
+                });
+            }
+            this.indentationLevel--;
+            code += `${this.indent()}}\n`;
+        }
+    }
+    this.indentationLevel--;
+    code += `${this.indent()}}\n`; // End of the switch block
+    code +=
+        `${this.indent()}${switchBreakLabel}:; // break target for switch\n`;
+    if (context.currentLabel) {
+        this.indentationLevel--;
+        code += `${this.indent()}}\n`;
+        code +=
+            `${this.indent()}${context.currentLabel}_break:; // break target for labeled switch\n`;
+    }
+    return code;
+}
+export function visitCaseClause(node, context) {
+    // Case clauses are handled inline by visitSwitchStatement, not generated directly
+    // This function will likely not be called, or can return an empty string
+    return "";
+}
+export function visitDefaultClause(node, context) {
+    // Default clauses are handled inline by visitSwitchStatement, not generated directly
+    // This function will likely not be called, or can return an empty string
+    return "";
+}

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

@@ -9,41 +9,62 @@ export function visitVariableDeclarationList(node, context) {
 export function visitVariableDeclaration(node, context) {
     const varDecl = node;
     const name = varDecl.name.getText();
+    const scope = this.getScopeForNode(varDecl);
+    const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(name, scope);
+    // Mark the symbol as checked
+    this.markSymbolAsChecked(name, context.topLevelScopeSymbols, context.localScopeSymbols);
     let initializer = "";
     if (varDecl.initializer) {
         const initExpr = varDecl.initializer;
-        let initText = this.visit(initExpr, context);
+        const initContext = {
+            ...context,
+            lambdaName: ts.isArrowFunction(initExpr) ? name : undefined, // Pass the variable name for arrow functions
+        };
+        let initText = ts.isNumericLiteral(initExpr)
+            ? initExpr.getText()
+            : this.visit(initExpr, initContext);
         if (ts.isIdentifier(initExpr)) {
-            const scope = this.getScopeForNode(initExpr);
-            const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(initExpr.text, scope);
+            const initScope = this.getScopeForNode(initExpr);
+            const initTypeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(initExpr.text, initScope);
             const varName = this.getJsVarName(initExpr);
-            if (typeInfo && !typeInfo.isParameter && !typeInfo.isBuiltin) {
-                initText = `jspp::Access::deref(${initText}, ${varName})`;
+            if (initTypeInfo &&
+                !initTypeInfo.isParameter &&
+                !initTypeInfo.isBuiltin) {
+                initText = this.getDerefCode(initText, varName, initContext, initTypeInfo);
             }
         }
         initializer = " = " + initText;
     }
     const isLetOrConst = (varDecl.parent.flags & (ts.NodeFlags.Let | ts.NodeFlags.Const)) !== 0;
+    const shouldDeref = context.derefBeforeAssignment &&
+        (!context.localScopeSymbols.has(name));
+    const assignmentTarget = shouldDeref
+        ? this.getDerefCode(name, name, context, typeInfo)
+        : (typeInfo.needsHeapAllocation ? `*${name}` : name);
     if (isLetOrConst) {
         // If there's no initializer, it should be assigned undefined.
-        if (!initializer)
-            return `*${name} = jspp::AnyValue::make_undefined()`;
-        return `*${name}${initializer}`;
+        if (!initializer) {
+            return `${assignmentTarget} = jspp::Constants::UNDEFINED`;
+        }
+        return `${assignmentTarget}${initializer}`;
     }
     // For 'var', it's a bit more complex.
-    // If we are in a non-function-body block, 'var' is hoisted, so it's an assignment.
-    // If we are at the top level or in a function body, it's a declaration if not already hoisted.
-    // The current logic hoists at the function level, so we need to decide if this is the *hoisting* declaration or a later assignment.
-    // The `isAssignmentOnly` flag helps here.
     if (context.isAssignmentOnly) {
         if (!initializer)
             return "";
-        return `*${name}${initializer}`;
+        return `${assignmentTarget}${initializer}`;
     }
     else {
+        // This case should not be hit with the new hoisting logic,
+        // but is kept for safety.
         const initValue = initializer
             ? initializer.substring(3)
-            : "jspp::AnyValue::make_undefined()";
-        return `auto ${name} = std::make_shared<jspp::AnyValue>(${initValue})`;
+            : "jspp::Constants::UNDEFINED";
+        if (typeInfo.needsHeapAllocation) {
+            return `auto ${name} = std::make_shared<jspp::AnyValue>(${initValue})`;
+        }
+        else {
+            return `jspp::AnyValue ${name} = ${initValue}`;
+        }
     }
 }