@ugo-studio/jspp 0.1.3 → 0.1.4

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

@@ -7,41 +7,39 @@ export function visitSourceFile(node, context) {
         .filter(ts.isVariableStatement)
         .flatMap((stmt) => stmt.declarationList.declarations);
     const funcDecls = sourceFile.statements.filter(ts.isFunctionDeclaration);
-    const hoistedSymbols = new Set();
+    const classDecls = sourceFile.statements.filter(ts.isClassDeclaration);
+    const hoistedSymbols = new Map();
     // 1. Hoist function declarations
     funcDecls.forEach((func) => {
-        const funcName = func.name?.getText();
-        if (funcName && !hoistedSymbols.has(funcName)) {
-            hoistedSymbols.add(funcName);
-            code +=
-                `${this.indent()}auto ${funcName} = std::make_shared<jspp::AnyValue>(jspp::AnyValue::make_undefined());\n`;
-        }
+        code += this.hoistDeclaration(func, hoistedSymbols);
+    });
+    // Hoist class declarations
+    classDecls.forEach((cls) => {
+        code += this.hoistDeclaration(cls, hoistedSymbols);
     });
     // Hoist variable declarations
     varDecls.forEach((decl) => {
-        const name = decl.name.getText();
-        if (hoistedSymbols.has(name)) {
-            return;
-        }
-        hoistedSymbols.add(name);
-        const isLetOrConst = (decl.parent.flags & (ts.NodeFlags.Let | ts.NodeFlags.Const)) !==
-            0;
-        const initializer = isLetOrConst
-            ? "jspp::AnyValue::make_uninitialized()"
-            : "jspp::AnyValue::make_undefined()";
-        code +=
-            `${this.indent()}auto ${name} = std::make_shared<jspp::AnyValue>(${initializer});\n`;
+        code += this.hoistDeclaration(decl, hoistedSymbols);
     });
     // 2. Assign all hoisted functions first
+    const contextForFunctions = {
+        ...context,
+        currentScopeSymbols: new Map(context.currentScopeSymbols),
+    };
+    hoistedSymbols.forEach((v, k) => contextForFunctions.currentScopeSymbols.set(k, v));
     funcDecls.forEach((stmt) => {
         const funcName = stmt.name?.getText();
         if (funcName) {
-            const lambda = this.generateLambda(stmt, true);
+            const lambda = this.generateLambda(stmt, contextForFunctions, {
+                isAssignment: true,
+            });
             code += `${this.indent()}*${funcName} = ${lambda};\n`;
         }
     });
     // 3. Process other statements
     sourceFile.statements.forEach((stmt) => {
+        const topLevelScopeSymbols = this.prepareScopeSymbolsForVisit(context.topLevelScopeSymbols, context.currentScopeSymbols);
+        const currentScopeSymbols = hoistedSymbols; // hoistedSymbols becomes new local
         if (ts.isFunctionDeclaration(stmt)) {
             // Already handled
         }
@@ -51,6 +49,8 @@ export function visitSourceFile(node, context) {
                 0;
             const contextForVisit = {
                 ...context,
+                topLevelScopeSymbols,
+                currentScopeSymbols,
                 isAssignmentOnly: !isLetOrConst,
             };
             const assignments = this.visit(stmt.declarationList, contextForVisit);
@@ -59,7 +59,14 @@ export function visitSourceFile(node, context) {
             }
         }
         else {
-            code += this.visit(stmt, context);
+            code += this.visit(stmt, {
+                ...context,
+                isFunctionBody: false,
+                topLevelScopeSymbols,
+                currentScopeSymbols,
+                // currentScopeSymbols: undefined, // clear the currentScopeSymbols for nested visit
+                // topLevelScopeSymbols: undefined, // clear the topLevelScopeSymbols for nested visit
+            });
         }
     });
     return code;
@@ -72,41 +79,39 @@ export function visitBlock(node, context) {
         .filter(ts.isVariableStatement)
         .flatMap((stmt) => stmt.declarationList.declarations);
     const funcDecls = block.statements.filter(ts.isFunctionDeclaration);
-    const hoistedSymbols = new Set();
+    const classDecls = block.statements.filter(ts.isClassDeclaration);
+    const hoistedSymbols = new Map();
     // 1. Hoist all function declarations
     funcDecls.forEach((func) => {
-        const funcName = func.name?.getText();
-        if (funcName && !hoistedSymbols.has(funcName)) {
-            hoistedSymbols.add(funcName);
-            code +=
-                `${this.indent()}auto ${funcName} = std::make_shared<jspp::AnyValue>(jspp::AnyValue::make_undefined());\n`;
-        }
+        code += this.hoistDeclaration(func, hoistedSymbols);
+    });
+    // Hoist class declarations
+    classDecls.forEach((cls) => {
+        code += this.hoistDeclaration(cls, hoistedSymbols);
     });
     // Hoist variable declarations
     varDecls.forEach((decl) => {
-        const name = decl.name.getText();
-        if (hoistedSymbols.has(name)) {
-            return;
-        }
-        hoistedSymbols.add(name);
-        const isLetOrConst = (decl.parent.flags & (ts.NodeFlags.Let | ts.NodeFlags.Const)) !==
-            0;
-        const initializer = isLetOrConst
-            ? "jspp::AnyValue::make_uninitialized()"
-            : "jspp::AnyValue::make_undefined()";
-        code +=
-            `${this.indent()}auto ${name} = std::make_shared<jspp::AnyValue>(${initializer});\n`;
+        code += this.hoistDeclaration(decl, hoistedSymbols);
     });
     // 2. Assign all hoisted functions first
+    const contextForFunctions = {
+        ...context,
+        currentScopeSymbols: new Map(context.currentScopeSymbols),
+    };
+    hoistedSymbols.forEach((v, k) => contextForFunctions.currentScopeSymbols.set(k, v));
     funcDecls.forEach((stmt) => {
         const funcName = stmt.name?.getText();
         if (funcName) {
-            const lambda = this.generateLambda(stmt, true);
+            const lambda = this.generateLambda(stmt, contextForFunctions, {
+                isAssignment: true,
+            });
             code += `${this.indent()}*${funcName} = ${lambda};\n`;
         }
     });
     // 3. Process other statements
     block.statements.forEach((stmt) => {
+        const topLevelScopeSymbols = this.prepareScopeSymbolsForVisit(context.topLevelScopeSymbols, context.currentScopeSymbols);
+        const currentScopeSymbols = hoistedSymbols; // hoistedSymbols becomes new local
         if (ts.isFunctionDeclaration(stmt)) {
             // Do nothing, already handled
         }
@@ -116,6 +121,8 @@ export function visitBlock(node, context) {
                 0;
             const contextForVisit = {
                 ...context,
+                topLevelScopeSymbols,
+                currentScopeSymbols,
                 isAssignmentOnly: !isLetOrConst,
             };
             const assignments = this.visit(stmt.declarationList, contextForVisit);
@@ -124,13 +131,20 @@ export function visitBlock(node, context) {
             }
         }
         else {
-            code += this.visit(stmt, context);
+            code += this.visit(stmt, {
+                ...context,
+                isFunctionBody: false,
+                topLevelScopeSymbols,
+                currentScopeSymbols,
+                // currentScopeSymbols: undefined, // clear the currentScopeSymbols for nested visit
+                // topLevelScopeSymbols: undefined, // clear the topLevelScopeSymbols for nested visit
+            });
         }
     });
     if (context.isFunctionBody) {
         const lastStatement = block.statements[block.statements.length - 1];
         if (!lastStatement || !ts.isReturnStatement(lastStatement)) {
-            code += `${this.indent()}${this.getReturnCmd(context)} jspp::AnyValue::make_undefined();\n`;
+            code += `${this.indent()}${this.getReturnCommand(context)} jspp::AnyValue::make_undefined();\n`;
         }
     }
     this.indentationLevel--;
@@ -142,156 +156,47 @@ export function visitVariableStatement(node, context) {
         this.visit(node.declarationList, context) +
         ";\n");
 }
-export function visitForStatement(node, context) {
-    const forStmt = node;
-    let code = "";
-    this.indentationLevel++; // Enter a new scope for the for loop
-    // Handle initializer
-    let initializerCode = "";
-    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) {
-                // For `let` or `const` in for loop, they are block-scoped to the loop.
-                // Declare the variable within the loop's scope.
-                // The C++ for loop initializer can contain a declaration.
-                const decl = varDeclList.declarations[0]; // Assuming single declaration for simplicity
-                if (decl) {
-                    const name = decl.name.getText();
-                    const initValue = decl.initializer
-                        ? this.visit(decl.initializer, context)
-                        : "jspp::AnyValue::make_undefined()";
-                    initializerCode =
-                        `auto ${name} = std::make_unique<jspp::AnyValue>(${initValue})`;
-                }
-            }
-            else {
-                // For 'var', it's already hoisted, so this is an assignment.
-                initializerCode = this.visit(forStmt.initializer, {
-                    ...context,
-                    isAssignmentOnly: true,
-                });
-            }
-        }
-        else {
-            // If it's an expression (e.g., `i = 0`)
-            initializerCode = this.visit(forStmt.initializer, context);
-        }
-    }
-    code += `${this.indent()}for (${initializerCode}; `;
-    if (forStmt.condition) {
-        code += `(${this.visit(forStmt.condition, context)}).is_truthy()`;
+export function visitBreakStatement(node, context) {
+    if (node.label) {
+        return `${this.indent()}goto ${node.label.text}_break;\n`;
     }
-    code += "; ";
-    if (forStmt.incrementor) {
-        code += this.visit(forStmt.incrementor, context);
+    if (context.switchBreakLabel) {
+        return `${this.indent()}goto ${context.switchBreakLabel};\n`;
     }
-    code += ") ";
-    code += this.visit(forStmt.statement, {
-        ...context,
-        isFunctionBody: false,
-    });
-    this.indentationLevel--; // Exit the scope for the for loop
-    return code;
+    return `${this.indent()}break;\n`;
 }
-export function visitForInStatement(node, context) {
-    const forIn = node;
-    let code = `${this.indent()}{\n`;
-    this.indentationLevel++; // Enter a new scope for the for-in loop
-    let varName = "";
-    if (ts.isVariableDeclarationList(forIn.initializer)) {
-        const decl = forIn.initializer.declarations[0];
-        if (decl) {
-            varName = decl.name.getText();
-            // Declare the shared_ptr before the loop
-            code +=
-                `${this.indent()}auto ${varName} = std::make_shared<jspp::AnyValue>(jspp::AnyValue::make_undefined());\n`;
-        }
-    }
-    else if (ts.isIdentifier(forIn.initializer)) {
-        varName = forIn.initializer.getText();
-        // Assume it's already declared in an outer scope, just assign to it.
-        // No explicit declaration here.
-    }
-    const expr = forIn.expression;
-    const exprText = this.visit(expr, context);
-    let derefExpr = exprText;
-    if (ts.isIdentifier(expr)) {
-        derefExpr = `jspp::Access::deref(${exprText}, ${this.getJsVarName(expr)})`;
+export function visitContinueStatement(node, context) {
+    if (node.label) {
+        return `${this.indent()}goto ${node.label.text}_continue;\n`;
     }
-    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()}*${varName} = jspp::AnyValue::make_string(${varName}_str);\n`;
-    code += this.visit(forIn.statement, {
-        ...context,
-        isFunctionBody: false,
-    });
-    this.indentationLevel--;
-    code += `${this.indent()}}}\n`;
-    this.indentationLevel--; // Exit the scope for the for-in loop
-    return code;
+    return `${this.indent()}continue;\n`;
 }
-export function visitForOfStatement(node, context) {
-    const forOf = node;
-    let code = "";
-    this.indentationLevel++; // Enter a new scope for the for-of loop
-    let varName = "";
-    if (ts.isVariableDeclarationList(forOf.initializer)) {
-        const decl = forOf.initializer.declarations[0];
-        if (decl) {
-            varName = decl.name.getText();
-            // Declare the shared_ptr before the loop
-            code +=
-                `${this.indent()}{ auto ${varName} = std::make_shared<jspp::AnyValue>(jspp::AnyValue::make_undefined());\n`;
-        }
+export function visitLabeledStatement(node, context) {
+    const label = node.label.text;
+    const statement = node.statement;
+    const isLoop = ts.isForStatement(statement) ||
+        ts.isForInStatement(statement) ||
+        ts.isForOfStatement(statement) ||
+        ts.isWhileStatement(statement) ||
+        ts.isDoStatement(statement);
+    const statementContext = { ...context, currentLabel: label };
+    if (ts.isSwitchStatement(statement)) {
+        return this.visit(statement, statementContext);
     }
-    else if (ts.isIdentifier(forOf.initializer)) {
-        varName = forOf.initializer.getText();
-        // Assume it's already declared in an outer scope, just assign to it.
-        // No explicit declaration here.
-        code += `${this.indent()}{\n`;
+    const statementCode = this.visit(statement, statementContext);
+    if (isLoop) {
+        return statementCode;
     }
-    const iterableExpr = this.visit(forOf.expression, context);
-    const derefIterable = ts.isIdentifier(forOf.expression)
-        ? `jspp::Access::deref(${iterableExpr}, ${this.getJsVarName(forOf.expression)})`
-        : iterableExpr;
-    const iteratorFn = this.generateUniqueName("__iter_fn_", new Set());
-    const iteratorPtr = this.generateUniqueName("__iter_ptr_", new Set());
-    const nextRes = this.generateUniqueName("__res__", new Set());
-    code +=
-        `${this.indent()}auto ${iteratorFn} = ${derefIterable}.get_own_property(Symbol.get_own_property("iterator"));\n`;
-    code +=
-        `${this.indent()}if (!${iteratorFn}.is_generator()) { throw jspp::RuntimeError::make_error("${iterableExpr} is not iterable", "TypeError"); }\n`;
-    code +=
-        `${this.indent()}auto ${iteratorPtr} = ${iteratorFn}.as_function()->call({}).as_iterator();\n`;
-    code += `${this.indent()}auto ${nextRes} = ${iteratorPtr}->next();\n`;
-    code += `${this.indent()}while (!${nextRes}.done) {\n`;
+    // A non-loop statement can only be broken from.
+    // We wrap it in a labeled block.
+    let code = `${this.indent()}${label}: {\n`;
     this.indentationLevel++;
-    code +=
-        `${this.indent()}*${varName} = ${nextRes}.value.value_or(jspp::AnyValue::make_undefined());\n`;
-    code += this.visit(forOf.statement, {
-        ...context,
-        isFunctionBody: false,
-    });
-    code += `${this.indent()}${nextRes} = ${iteratorPtr}->next();\n`;
+    code += statementCode;
     this.indentationLevel--;
-    code += `${this.indent()}}}\n`;
-    this.indentationLevel--; // Exit the scope for the for-of loop
+    code += `${this.indent()}}\n`;
+    code += `${this.indent()}${label}_break:; // break target for ${label}\n`;
     return code;
 }
-export function visitBreakStatement(node, context) {
-    return "break;";
-}
-export function visitContinueStatement(node, context) {
-    return "continue;";
-}
 export function visitIfStatement(node, context) {
     const ifStmt = node;
     const condition = this.visit(ifStmt.expression, context);
@@ -317,7 +222,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::RuntimeError(${expr});
+    return `${this.indent()}throw jspp::Exception(${expr});
 `;
 }
 export function visitTryStatement(node, context) {
@@ -371,7 +276,7 @@ export function visitTryStatement(node, context) {
         else {
             code += `${this.indent()}catch (...) { throw; }\n`;
         }
-        code += `${this.indent()}${this.getReturnCmd(context)} jspp::AnyValue::make_undefined();\n`;
+        code += `${this.indent()}${this.getReturnCommand(context)} jspp::AnyValue::make_undefined();\n`;
         this.indentationLevel--;
         code += `${this.indent()}})();\n`;
         this.indentationLevel--;
@@ -420,9 +325,9 @@ export function visitCatchClause(node, context) {
         this.indentationLevel++;
         code += `${this.indent()}{\n`;
         this.indentationLevel++;
-        // Always create the JS exception variable.
+        // The JS exception variable is always local to the catch block
         code +=
-            `${this.indent()}auto ${varName} = std::make_shared<jspp::AnyValue>(jspp::RuntimeError::error_to_value(${exceptionName}));\n`;
+            `${this.indent()}jspp::AnyValue ${varName} = jspp::Exception::exception_to_any_value(${exceptionName});\n`;
         // Shadow the C++ exception variable *only if* the names don't clash.
         if (varName !== exceptionName) {
             code +=
@@ -446,54 +351,77 @@ export function visitCatchClause(node, context) {
 export function visitYieldExpression(node, context) {
     if (node.expression) {
         const expr = node.expression;
-        const exprText = this.visit(expr, context);
+        let exprText = this.visit(expr, context);
         if (ts.isIdentifier(expr)) {
             const scope = this.getScopeForNode(expr);
             const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(expr.text, scope);
             if (!typeInfo) {
-                return `${this.indent()}jspp::RuntimeError::throw_unresolved_reference_error(${this.getJsVarName(expr)})\n`; // THROWS, not returns
+                return `${this.indent()}jspp::Exception::throw_unresolved_reference(${this.getJsVarName(expr)})\n`; // THROWS, not returns
             }
             if (typeInfo &&
                 !typeInfo.isParameter &&
                 !typeInfo.isBuiltin) {
-                return `${this.indent()}co_yield jspp::Access::deref(${exprText}, ${this.getJsVarName(expr)})`;
+                exprText = this.getDerefCode(exprText, this.getJsVarName(expr), typeInfo);
             }
         }
+        // Handle `yield*` expression
+        if (!!node.asteriskToken) {
+            let code = `${this.indent()}{\n`;
+            this.indentationLevel++;
+            const declaredSymbols = this.getDeclaredSymbols(expr);
+            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(expr);
+            code += `${this.indent()}auto ${iterableRef} = ${exprText};\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`;
+            code +=
+                `${this.indent()}while (!${nextRes}.get_own_property("done").is_truthy()) {\n`;
+            this.indentationLevel++;
+            code +=
+                `${this.indent()}co_yield ${nextRes}.get_own_property("value");\n`;
+            code +=
+                `${this.indent()}${nextRes} = ${nextFunc}->call(${iterator}, {});\n`;
+            this.indentationLevel--;
+            code += `${this.indent()}}}\n`;
+            return code;
+        }
         return `${this.indent()}co_yield ${exprText}`;
     }
     return `${this.indent()}co_yield jspp::AnyValue::make_undefined()`;
 }
 export function visitReturnStatement(node, context) {
     if (context.isMainContext) {
-        return `${this.indent()}jspp::RuntimeError::throw_invalid_return_statement_error();\n`;
+        return `${this.indent()}jspp::Exception::throw_invalid_return_statement();\n`;
     }
     const returnStmt = node;
-    const returnCmd = this.getReturnCmd(context);
+    const returnCmd = this.getReturnCommand(context);
     if (context.isInsideTryCatchLambda && context.hasReturnedFlag) {
         let returnCode = `${this.indent()}${context.hasReturnedFlag} = true;\n`;
         if (returnStmt.expression) {
             const expr = returnStmt.expression;
             const exprText = this.visit(expr, context);
+            let finalExpr = exprText;
             if (ts.isIdentifier(expr)) {
                 const scope = this.getScopeForNode(expr);
                 const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(expr.text, scope);
                 if (!typeInfo) {
                     returnCode +=
-                        `${this.indent()}jspp::RuntimeError::throw_unresolved_reference_error(${this.getJsVarName(expr)});\n`; // THROWS, not returns
+                        `${this.indent()}jspp::Exception::throw_unresolved_reference(${this.getJsVarName(expr)});\n`; // THROWS, not returns
                 }
-                if (typeInfo &&
+                else if (typeInfo &&
                     !typeInfo.isParameter &&
                     !typeInfo.isBuiltin) {
-                    returnCode +=
-                        `${this.indent()}${returnCmd} jspp::Access::deref(${exprText}, ${this.getJsVarName(expr)});\n`;
+                    finalExpr = this.getDerefCode(exprText, this.getJsVarName(expr), typeInfo);
                 }
-                else {
-                    returnCode += `${this.indent()}${returnCmd} ${exprText};\n`;
-                }
-            }
-            else {
-                returnCode += `${this.indent()}${returnCmd} ${exprText};\n`;
             }
+            returnCode += `${this.indent()}${returnCmd} ${finalExpr};\n`;
         }
         else {
             returnCode +=
@@ -504,19 +432,20 @@ export function visitReturnStatement(node, context) {
     if (returnStmt.expression) {
         const expr = returnStmt.expression;
         const exprText = this.visit(expr, context);
+        let finalExpr = exprText;
         if (ts.isIdentifier(expr)) {
             const scope = this.getScopeForNode(expr);
             const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(expr.text, scope);
             if (!typeInfo) {
-                return `${this.indent()}jspp::RuntimeError::throw_unresolved_reference_error(${this.getJsVarName(expr)});\n`; // THROWS, not returns
+                return `${this.indent()}jspp::Exception::throw_unresolved_reference(${this.getJsVarName(expr)});\n`; // THROWS, not returns
             }
             if (typeInfo &&
                 !typeInfo.isParameter &&
                 !typeInfo.isBuiltin) {
-                return `${this.indent()}${returnCmd} jspp::Access::deref(${exprText}, ${this.getJsVarName(expr)});\n`;
+                finalExpr = this.getDerefCode(exprText, this.getJsVarName(expr), typeInfo);
             }
         }
-        return `${this.indent()}${returnCmd} ${exprText};\n`;
+        return `${this.indent()}${returnCmd} ${finalExpr};\n`;
     }
     return `${this.indent()}${returnCmd} jspp::AnyValue::make_undefined();\n`;
 }

package/dist/core/codegen/visitor.js

@@ -1,10 +1,12 @@
 import ts from "typescript";
 import { CodeGenerator } from "./";
+import { visitClassDeclaration } from "./class-handlers";
+import { visitCaseClause, visitDefaultClause, visitDoStatement, visitForInStatement, visitForOfStatement, visitForStatement, visitSwitchStatement, visitWhileStatement, } from "./control-flow-handlers";
 import { visitVariableDeclaration, visitVariableDeclarationList, } from "./declaration-handlers";
-import { visitArrayLiteralExpression, visitBinaryExpression, visitCallExpression, visitElementAccessExpression, visitObjectLiteralExpression, visitParenthesizedExpression, visitPostfixUnaryExpression, visitPrefixUnaryExpression, visitPropertyAccessExpression, visitTemplateExpression, visitVoidExpression, } from "./expression-handlers";
+import { visitArrayLiteralExpression, visitAwaitExpression, visitBinaryExpression, visitCallExpression, visitConditionalExpression, visitElementAccessExpression, visitNewExpression, visitObjectLiteralExpression, visitParenthesizedExpression, visitPostfixUnaryExpression, visitPrefixUnaryExpression, visitPropertyAccessExpression, visitTemplateExpression, visitTypeOfExpression, visitVoidExpression, } from "./expression-handlers";
 import { visitArrowFunction, visitFunctionDeclaration, visitFunctionExpression, } from "./function-handlers";
-import { visitFalseKeyword, visitIdentifier, visitNoSubstitutionTemplateLiteral, visitNullKeyword, visitNumericLiteral, visitStringLiteral, visitTrueKeyword, visitUndefinedKeyword, } from "./literal-handlers";
-import { visitBlock, visitBreakStatement, visitCatchClause, visitContinueStatement, visitExpressionStatement, visitForInStatement, visitForOfStatement, visitForStatement, visitIfStatement, visitReturnStatement, visitSourceFile, visitThrowStatement, visitTryStatement, visitVariableStatement, visitYieldExpression, } from "./statement-handlers";
+import { visitFalseKeyword, visitIdentifier, visitNoSubstitutionTemplateLiteral, visitNullKeyword, visitNumericLiteral, visitStringLiteral, visitThisKeyword, visitTrueKeyword, visitUndefinedKeyword, } from "./literal-handlers";
+import { visitBlock, visitBreakStatement, visitCatchClause, visitContinueStatement, visitExpressionStatement, visitIfStatement, visitLabeledStatement, visitReturnStatement, visitSourceFile, visitThrowStatement, visitTryStatement, visitVariableStatement, visitYieldExpression, } from "./statement-handlers";
 export function visit(node, context) {
     if (ts.isFunctionDeclaration(node)) {
         return visitFunctionDeclaration.call(this, node, context);
@@ -14,6 +16,8 @@ export function visit(node, context) {
             return visitArrowFunction.call(this, node, context);
         case ts.SyntaxKind.FunctionExpression:
             return visitFunctionExpression.call(this, node, context);
+        case ts.SyntaxKind.ClassDeclaration:
+            return visitClassDeclaration.call(this, node, context);
         case ts.SyntaxKind.SourceFile:
             return visitSourceFile.call(this, node, context);
         case ts.SyntaxKind.Block:
@@ -34,10 +38,22 @@ export function visit(node, context) {
             return visitForInStatement.call(this, node, context);
         case ts.SyntaxKind.ForOfStatement:
             return visitForOfStatement.call(this, node, context);
+        case ts.SyntaxKind.WhileStatement:
+            return visitWhileStatement.call(this, node, context);
+        case ts.SyntaxKind.DoStatement:
+            return visitDoStatement.call(this, node, context);
+        case ts.SyntaxKind.SwitchStatement:
+            return visitSwitchStatement.call(this, node, context);
+        case ts.SyntaxKind.CaseClause:
+            return visitCaseClause.call(this, node, context);
+        case ts.SyntaxKind.DefaultClause:
+            return visitDefaultClause.call(this, node, context);
         case ts.SyntaxKind.BreakStatement:
             return visitBreakStatement.call(this, node, context);
         case ts.SyntaxKind.ContinueStatement:
             return visitContinueStatement.call(this, node, context);
+        case ts.SyntaxKind.LabeledStatement:
+            return visitLabeledStatement.call(this, node, context);
         case ts.SyntaxKind.IfStatement:
             return visitIfStatement.call(this, node, context);
         case ts.SyntaxKind.PrefixUnaryExpression:
@@ -54,6 +70,8 @@ export function visit(node, context) {
             return visitExpressionStatement.call(this, node, context);
         case ts.SyntaxKind.BinaryExpression:
             return visitBinaryExpression.call(this, node, context);
+        case ts.SyntaxKind.ConditionalExpression:
+            return visitConditionalExpression.call(this, node, context);
         case ts.SyntaxKind.ThrowStatement:
             return visitThrowStatement.call(this, node, context);
         case ts.SyntaxKind.TryStatement:
@@ -76,6 +94,12 @@ export function visit(node, context) {
             return visitNoSubstitutionTemplateLiteral.call(this, node);
         case ts.SyntaxKind.TemplateExpression:
             return visitTemplateExpression.call(this, node, context);
+        case ts.SyntaxKind.AwaitExpression:
+            return visitAwaitExpression.call(this, node, context);
+        case ts.SyntaxKind.NewExpression:
+            return visitNewExpression.call(this, node, context);
+        case ts.SyntaxKind.TypeOfExpression:
+            return visitTypeOfExpression.call(this, node, context);
         case ts.SyntaxKind.TrueKeyword:
             return visitTrueKeyword.call(this);
         case ts.SyntaxKind.FalseKeyword:
@@ -86,6 +110,8 @@ export function visit(node, context) {
             return visitUndefinedKeyword.call(this);
         case ts.SyntaxKind.NullKeyword:
             return visitNullKeyword.call(this);
+        case ts.SyntaxKind.ThisKeyword:
+            return visitThisKeyword.call(this);
         default:
             return `/* Unhandled node: ${ts.SyntaxKind[node.kind]} */`;
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ugo-studio/jspp",
-  "version": "0.1.3",
-  "description": "A modern, experimental transpiler that converts JavaScript code into high-performance, standard C++23.",
+  "version": "0.1.4",
+  "description": "A modern transpiler that converts JavaScript code into high-performance, standard C++23.",
   "main": "dist/index.js",
   "module": "src/index.ts",
   "type": "module",
@@ -16,7 +16,7 @@
     "dev": "bun run src/cli.ts",
     "typecheck": "tsc --noEmit",
     "precompile": "bun run scripts/precompile-headers.ts",
-    "test": "bun run precompile && bun test",
+    "test": "bun test",
     "build": "tsc",
     "prepack": "bun run build",
     "publish:npm": "npm publish --access=public"