@ugo-studio/jspp 0.1.4 → 0.1.6

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

@@ -1,4 +1,5 @@
 import ts from "typescript";
+import { DeclaredSymbols, DeclaredSymbolType } from "../../ast/symbols";
 import { CodeGenerator } from "./";
 export function visitForStatement(node, context) {
     const forStmt = node;
@@ -10,6 +11,10 @@ export function visitForStatement(node, context) {
     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;
@@ -22,10 +27,15 @@ export function visitForStatement(node, context) {
                     const name = decl.name.getText();
                     const initValue = decl.initializer
                         ? this.visit(decl.initializer, context)
-                        : "jspp::AnyValue::make_undefined()";
+                        : "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})`;
@@ -49,7 +59,7 @@ export function visitForStatement(node, context) {
     }
     code += `${this.indent()}for (${initializerCode}; `;
     if (forStmt.condition) {
-        code += `(${this.visit(forStmt.condition, context)}).is_truthy()`;
+        code += `is_truthy(${this.visit(forStmt.condition, conditionContext)})`;
     }
     code += "; ";
     if (forStmt.incrementor) {
@@ -60,7 +70,7 @@ export function visitForStatement(node, context) {
         ...context,
         currentLabel: undefined,
         isFunctionBody: false,
-    });
+    }).trim();
     if (ts.isBlock(node.statement)) {
         let blockContent = statementCode.substring(1, statementCode.length - 2); // remove curly braces
         if (context.currentLabel) {
@@ -105,12 +115,12 @@ export function visitForInStatement(node, context) {
             const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(varName, scope);
             if (typeInfo.needsHeapAllocation) {
                 code +=
-                    `${this.indent()}auto ${varName} = std::make_shared<jspp::AnyValue>(jspp::AnyValue::make_undefined());\n`;
+                    `${this.indent()}auto ${varName} = std::make_shared<jspp::AnyValue>(jspp::Constants::UNDEFINED);\n`;
                 assignmentTarget = `*${varName}`;
             }
             else {
                 code +=
-                    `${this.indent()}jspp::AnyValue ${varName} = jspp::AnyValue::make_undefined();\n`;
+                    `${this.indent()}jspp::AnyValue ${varName} = jspp::Constants::UNDEFINED;\n`;
                 assignmentTarget = varName;
             }
         }
@@ -129,7 +139,7 @@ export function visitForInStatement(node, context) {
     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), typeInfo);
+        derefExpr = this.getDerefCode(exprText, this.getJsVarName(expr), context, typeInfo);
     }
     const keysVar = this.generateUniqueName("__keys_", new Set([varName]));
     code +=
@@ -177,12 +187,12 @@ export function visitForOfStatement(node, context) {
             const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(elemName, scope);
             if (typeInfo.needsHeapAllocation) {
                 code +=
-                    `${this.indent()}auto ${elemName} = std::make_shared<jspp::AnyValue>(jspp::AnyValue::make_undefined());\n`;
+                    `${this.indent()}auto ${elemName} = std::make_shared<jspp::AnyValue>(jspp::Constants::UNDEFINED);\n`;
                 assignmentTarget = `*${elemName}`;
             }
             else {
                 code +=
-                    `${this.indent()}jspp::AnyValue ${elemName} = jspp::AnyValue::make_undefined();\n`;
+                    `${this.indent()}jspp::AnyValue ${elemName} = jspp::Constants::UNDEFINED;\n`;
                 assignmentTarget = elemName;
             }
         }
@@ -201,23 +211,36 @@ export function visitForOfStatement(node, context) {
         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, typeInfo);
+        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 isAwait = forOf.awaitModifier !== undefined;
     const varName = this.getJsVarName(forOf.expression);
     code += `${this.indent()}auto ${iterableRef} = ${derefIterable};\n`;
+    if (isAwait) {
+        code +=
+            `${this.indent()}auto ${iterator} = jspp::Access::get_async_object_value_iterator(${iterableRef}, ${varName});\n`;
+    }
+    else {
+        code +=
+            `${this.indent()}auto ${iterator} = jspp::Access::get_object_value_iterator(${iterableRef}, ${varName});\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").as_function();\n`;
-    code +=
-        `${this.indent()}auto ${nextRes} = ${nextFunc}->call(${iterator}, {});\n`;
+        `${this.indent()}auto ${nextFunc} = ${iterator}.get_own_property("next");\n`;
+    if (isAwait) {
+        code +=
+            `${this.indent()}auto ${nextRes} = co_await ${nextFunc}.call(${iterator}, {}, "next");\n`;
+    }
+    else {
+        code +=
+            `${this.indent()}auto ${nextRes} = ${nextFunc}.call(${iterator}, {}, "next");\n`;
+    }
     code +=
-        `${this.indent()}while (!${nextRes}.get_own_property("done").is_truthy()) {\n`;
+        `${this.indent()}while (!is_truthy(${nextRes}.get_own_property("done"))) {\n`;
     this.indentationLevel++;
     code +=
         `${this.indent()}${assignmentTarget} = ${nextRes}.get_own_property("value");\n`;
@@ -229,8 +252,14 @@ export function visitForOfStatement(node, context) {
     if (context.currentLabel) {
         code += `${this.indent()}${context.currentLabel}_continue:;\n`;
     }
-    code +=
-        `${this.indent()}${nextRes} = ${nextFunc}->call(${iterator}, {});\n`;
+    if (isAwait) {
+        code +=
+            `${this.indent()}${nextRes} = co_await ${nextFunc}.call(${iterator}, {}, "next");\n`;
+    }
+    else {
+        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
@@ -248,7 +277,7 @@ export function visitWhileStatement(node, context) {
     const conditionText = condition.kind === ts.SyntaxKind.TrueKeyword ||
         condition.kind === ts.SyntaxKind.FalseKeyword
         ? condition.getText()
-        : `(${this.visit(condition, context)}).is_truthy()`;
+        : `is_truthy(${this.visit(condition, context)})`;
     let code = "";
     if (context.currentLabel) {
         code += `${this.indent()}${context.currentLabel}: {\n`;
@@ -259,7 +288,7 @@ export function visitWhileStatement(node, context) {
         ...context,
         currentLabel: undefined,
         isFunctionBody: false,
-    });
+    }).trim();
     if (ts.isBlock(node.statement)) {
         let blockContent = statementCode.substring(1, statementCode.length - 2); // remove curly braces
         if (context.currentLabel) {
@@ -288,7 +317,7 @@ export function visitWhileStatement(node, context) {
 }
 export function visitDoStatement(node, context) {
     const condition = node.expression;
-    const conditionText = `(${this.visit(condition, context)}).is_truthy()`;
+    const conditionText = `is_truthy(${this.visit(condition, context)})`;
     let code = "";
     if (context.currentLabel) {
         code += `${this.indent()}${context.currentLabel}: {\n`;
@@ -299,7 +328,7 @@ export function visitDoStatement(node, context) {
         ...context,
         currentLabel: undefined,
         isFunctionBody: false,
-    });
+    }).trim();
     if (ts.isBlock(node.statement)) {
         let blockContent = statementCode.substring(1, statementCode.length - 2); // remove curly braces
         if (context.currentLabel) {
@@ -346,7 +375,7 @@ export function visitSwitchStatement(node, context) {
         `${this.indent()}const jspp::AnyValue ${switchValueVar} = ${expressionCode};\n`;
     code += `${this.indent()}bool ${fallthroughVar} = false;\n`;
     // Hoist variable declarations
-    const hoistedSymbols = new Map();
+    const hoistedSymbols = new DeclaredSymbols();
     for (const clause of switchStmt.caseBlock.clauses) {
         if (ts.isCaseClause(clause) || ts.isDefaultClause(clause)) {
             for (const stmt of clause.statements) {
@@ -363,7 +392,7 @@ export function visitSwitchStatement(node, context) {
         }
     }
     // Prepare scope symbols for the switch block
-    const topLevelScopeSymbols = this.prepareScopeSymbolsForVisit(context.topLevelScopeSymbols, context.currentScopeSymbols);
+    const topLevelScopeSymbols = this.prepareScopeSymbolsForVisit(context.topLevelScopeSymbols, context.localScopeSymbols);
     let firstIf = true;
     for (const clause of switchStmt.caseBlock.clauses) {
         if (ts.isCaseClause(clause)) {
@@ -374,13 +403,13 @@ export function visitSwitchStatement(node, context) {
             let condition = "";
             if (firstIf) {
                 condition =
-                    `(${fallthroughVar} || ${switchValueVar}.is_strictly_equal_to_primitive(${caseExprCode}))`;
+                    `(${fallthroughVar} || jspp::is_strictly_equal_to_primitive(${switchValueVar}, ${caseExprCode}))`;
                 code += `${this.indent()}if ${condition} {\n`;
                 firstIf = false;
             }
             else {
                 condition =
-                    `(${fallthroughVar} || ${switchValueVar}.is_strictly_equal_to_primitive(${caseExprCode}))`;
+                    `(${fallthroughVar} || jspp::is_strictly_equal_to_primitive(${switchValueVar}, ${caseExprCode}))`;
                 code += `${this.indent()}if ${condition} {\n`;
             }
             this.indentationLevel++;
@@ -392,7 +421,7 @@ export function visitSwitchStatement(node, context) {
                         const contextForFunction = {
                             ...context,
                             topLevelScopeSymbols,
-                            currentScopeSymbols: hoistedSymbols,
+                            localScopeSymbols: hoistedSymbols,
                         };
                         const lambda = this.generateLambda(stmt, contextForFunction, { isAssignment: true });
                         code += `${this.indent()}*${funcName} = ${lambda};\n`;
@@ -404,7 +433,7 @@ export function visitSwitchStatement(node, context) {
                         switchBreakLabel,
                         currentLabel: undefined, // Clear currentLabel for nested visits
                         topLevelScopeSymbols,
-                        currentScopeSymbols: hoistedSymbols,
+                        localScopeSymbols: hoistedSymbols,
                         derefBeforeAssignment: true,
                         isAssignmentOnly: ts.isVariableStatement(stmt),
                     });
@@ -431,7 +460,7 @@ export function visitSwitchStatement(node, context) {
                     switchBreakLabel,
                     currentLabel: undefined, // Clear currentLabel for nested visits
                     topLevelScopeSymbols,
-                    currentScopeSymbols: hoistedSymbols,
+                    localScopeSymbols: hoistedSymbols,
                     derefBeforeAssignment: true,
                     isAssignmentOnly: ts.isVariableStatement(stmt),
                 });

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

@@ -11,6 +11,8 @@ export function visitVariableDeclaration(node, context) {
     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;
@@ -18,7 +20,9 @@ export function visitVariableDeclaration(node, context) {
             ...context,
             lambdaName: ts.isArrowFunction(initExpr) ? name : undefined, // Pass the variable name for arrow functions
         };
-        let initText = this.visit(initExpr, initContext);
+        let initText = ts.isNumericLiteral(initExpr)
+            ? initExpr.getText()
+            : this.visit(initExpr, initContext);
         if (ts.isIdentifier(initExpr)) {
             const initScope = this.getScopeForNode(initExpr);
             const initTypeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(initExpr.text, initScope);
@@ -26,21 +30,21 @@ export function visitVariableDeclaration(node, context) {
             if (initTypeInfo &&
                 !initTypeInfo.isParameter &&
                 !initTypeInfo.isBuiltin) {
-                initText = this.getDerefCode(initText, varName, initTypeInfo);
+                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.currentScopeSymbols.has(name));
+        (!context.localScopeSymbols.has(name));
     const assignmentTarget = shouldDeref
-        ? this.getDerefCode(name, name, typeInfo)
+        ? 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 `${assignmentTarget} = jspp::AnyValue::make_undefined()`;
+            return `${assignmentTarget} = jspp::Constants::UNDEFINED`;
         }
         return `${assignmentTarget}${initializer}`;
     }
@@ -55,7 +59,7 @@ export function visitVariableDeclaration(node, context) {
         // but is kept for safety.
         const initValue = initializer
             ? initializer.substring(3)
-            : "jspp::AnyValue::make_undefined()";
+            : "jspp::Constants::UNDEFINED";
         if (typeInfo.needsHeapAllocation) {
             return `auto ${name} = std::make_shared<jspp::AnyValue>(${initValue})`;
         }