@ugo-studio/jspp 0.1.2 → 0.1.3

package/README.md

@@ -33,6 +33,8 @@ JSPP reserves certain keywords to avoid conflicts with the generated C++ code an
 
 - `std`: Reserved to prevent conflicts with the C++ standard library namespace.
 - `jspp`: Reserved for internal use by the JSPP transpiler.
+- `co_yield`: Reserved to prevent conflicts with the c++ generator functions.
+- `co_return`: Reserved to prevent conflicts with the c++ generator functions.
 
 Using these keywords as variable names will result in a `SyntaxError`.
 
@@ -45,7 +47,7 @@ The transpilation process is a classic three-stage pipeline:
 2.  **Analysis:** The `TypeAnalyzer` traverses the AST. While it doesn't perform traditional static type checking, it plays a crucial role in understanding the code's structure. It identifies scopes (global, function, block) and detects when variables are "captured" by closures.
 
 3.  **Code Generation:** The `CodeGenerator` performs a final traversal of the AST. It translates each node into its C++ equivalent.
-    - All variables are declared as `std::shared_ptr<AnyValue>` (where `AnyValue` uses a [Tagged Union](https://en.wikipedia.org/wiki/Tagged_union) system for managing dynamic types like JavaScript). This approach elegantly mimics JavaScript's dynamic types and reference-based memory model.
+    - All variables are declared as `std::shared_ptr<AnyValue>` (where `AnyValue` uses a [Tagged Union](https://en.wikipedia.org/wiki/Tagged_union) method for managing dynamic types like JavaScript). This approach elegantly mimics JavaScript's dynamic types and reference-based memory model.
     - Closures are implemented as C++ lambdas that capture `shared_ptr`s by value, ensuring variable lifetimes are correctly extended beyond their original scope.
     - The entire script is wrapped into a single `main` function, with hoisting logic carefully replicated to ensure correct execution order.
 

package/dist/analysis/scope.js

@@ -1,4 +1,18 @@
-const RESERVED_KEYWORDS = ["std", "jspp"];
+export const RESERVED_KEYWORDS = new Set([
+    "jspp",
+    "std",
+    "co_yield",
+    "co_return",
+]);
+export const BUILTIN_OBJECTS = new Set([
+    { name: "undefined", isConst: true },
+    { name: "null", isConst: true },
+    { name: "Symbol", isConst: false },
+    { name: "console", isConst: false },
+    { name: "performance", isConst: false },
+    { name: "global", isConst: false },
+    { name: "globalThis", isConst: false },
+]);
 // Represents a single scope (e.g., a function body or a block statement)
 export class Scope {
     parent;
@@ -31,16 +45,13 @@ export class ScopeManager {
         const rootScope = new Scope(null); // The global scope
         this.currentScope = rootScope;
         this.allScopes.push(rootScope); // Add the root scope to our list
-        this.define("undefined", {
-            type: "undefined",
-            isConst: true,
-            isBuiltin: true,
-        });
-        this.define("null", {
-            type: "null",
-            isConst: true,
-            isBuiltin: true,
-        });
+        for (const { name, isConst } of BUILTIN_OBJECTS) {
+            this.define(name, {
+                type: name,
+                isConst: isConst,
+                isBuiltin: true,
+            });
+        }
     }
     // Enters a new, nested scope.
     enterScope() {

package/dist/analysis/typeAnalyzer.js

@@ -1,4 +1,5 @@
 import * as ts from "typescript";
+import { isBuiltinObject } from "../core/codegen/helpers";
 import { Traverser } from "../core/traverser";
 import { Scope, ScopeManager } from "./scope";
 export class TypeAnalyzer {
@@ -55,7 +56,8 @@ export class TypeAnalyzer {
                         const varDecl = forIn.initializer.declarations[0];
                         if (varDecl) {
                             const name = varDecl.name.getText();
-                            const isConst = (varDecl.parent.flags & ts.NodeFlags.Const) !== 0;
+                            const isConst = (varDecl.parent.flags & ts.NodeFlags.Const) !==
+                                0;
                             const typeInfo = {
                                 type: "string", // Keys are always strings
                                 declaration: varDecl,
@@ -186,9 +188,8 @@ export class TypeAnalyzer {
             Identifier: {
                 enter: (node, parent) => {
                     if (ts.isIdentifier(node)) {
-                        if (node.text === "console") {
+                        if (isBuiltinObject.call(this, node))
                             return;
-                        }
                         const currentFuncNode = this.functionStack[this.functionStack.length - 1];
                         if (currentFuncNode &&
                             (ts.isFunctionDeclaration(currentFuncNode) ||

package/dist/cli.js

@@ -25,13 +25,13 @@ async function main() {
         const compile = Bun.spawnSync({
             cmd: [
                 "g++",
-                "-std=c++20",
+                "-std=c++23",
                 cppFilePath,
                 "-o",
                 exeFilePath,
                 "-I",
                 preludePath,
-                "-O2",
+                "-O3",
                 "-DNDEBUG",
                 // "-include",
                 // path.join(process.cwd(), "prelude-build", "index.hpp"),

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

@@ -1,7 +1,10 @@
 import ts from "typescript";
 import { CodeGenerator } from "./";
 function visitObjectPropertyName(node, context) {
-    if (ts.isStringLiteral(node)) {
+    if (ts.isNumericLiteral(node)) {
+        return node.getText();
+    }
+    else if (ts.isStringLiteral(node)) {
         return `"${node.getText().substring(1, node.getText().length - 1) // remove trailing "' from original name
         }"`;
     }
@@ -12,9 +15,12 @@ function visitObjectPropertyName(node, context) {
         name += ".to_std_string()";
         return name;
     }
-    return context.isPropertyNameAccess
-        ? node.getText()
-        : `"${node.getText()}"`;
+    else if (context.isPropertyNameAccess) {
+        return this.visit(node, context);
+    }
+    else {
+        return `"${node.getText()}"`;
+    }
 }
 export function visitObjectLiteralExpression(node, context) {
     const obj = node;
@@ -86,7 +92,6 @@ export function visitPropertyAccessExpression(node, context) {
         finalExpr = exprText;
     }
     return `${finalExpr}.get_own_property("${propName}")`;
-    // return `${finalExpr}["${propName}"]`;
 }
 export function visitElementAccessExpression(node, context) {
     const elemAccess = node;
@@ -116,7 +121,6 @@ export function visitElementAccessExpression(node, context) {
         }
     }
     return `${finalExpr}.get_own_property(${argText})`;
-    // return `${finalExpr}[${argText}]`;
 }
 export function visitBinaryExpression(node, context) {
     const binExpr = node;

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

@@ -3,7 +3,14 @@ import { CodeGenerator } from "./";
 export function generateLambda(node, isAssignment = false, capture = "[=]") {
     const declaredSymbols = this.getDeclaredSymbols(node);
     const argsName = this.generateUniqueName("__args_", declaredSymbols);
-    let lambda = `${capture}(const std::vector<jspp::AnyValue>& ${argsName}) mutable -> jspp::AnyValue `;
+    const isInsideGeneratorFunction = this.isGeneratorFunction(node);
+    const returnCmd = this.getReturnCmd({
+        isInsideGeneratorFunction: isInsideGeneratorFunction,
+    });
+    const funcReturnType = isInsideGeneratorFunction
+        ? "jspp::JsIterator<jspp::AnyValue>"
+        : "jspp::AnyValue";
+    let lambda = `${capture}(const std::vector<jspp::AnyValue>& ${argsName}) mutable -> ${funcReturnType} `;
     const visitContext = {
         isMainContext: false,
         isInsideFunction: true,
@@ -26,6 +33,7 @@ export function generateLambda(node, isAssignment = false, capture = "[=]") {
                 isMainContext: false,
                 isInsideFunction: true,
                 isFunctionBody: true,
+                isInsideGeneratorFunction: isInsideGeneratorFunction,
             });
             // The block visitor already adds braces, so we need to inject the param extraction.
             lambda += "{\n" + paramExtraction + blockContent.substring(2);
@@ -41,7 +49,7 @@ export function generateLambda(node, isAssignment = false, capture = "[=]") {
                 lambda +=
                     `${this.indent()}auto ${name} = ${argsName}.size() > ${i} ? ${argsName}[${i}] : ${defaultValue};\n`;
             });
-            lambda += `${this.indent()}return ${this.visit(node.body, {
+            lambda += `${this.indent()}${returnCmd} ${this.visit(node.body, {
                 isMainContext: false,
                 isInsideFunction: true,
                 isFunctionBody: false,
@@ -52,12 +60,25 @@ export function generateLambda(node, isAssignment = false, capture = "[=]") {
         }
     }
     else {
-        lambda += "{ return jspp::AnyValue::make_undefined(); }\n";
+        lambda += `{ ${returnCmd} jspp::AnyValue::make_undefined(); }\n`;
+    }
+    let signature = "";
+    let callable = "";
+    let method = "";
+    // Handle generator function
+    if (isInsideGeneratorFunction) {
+        signature =
+            "jspp::JsIterator<jspp::AnyValue>(const std::vector<jspp::AnyValue>&)";
+        callable = `std::function<${signature}>(${lambda})`;
+        method = `jspp::AnyValue::make_function`;
+    } // Handle normal function
+    else {
+        signature = `jspp::AnyValue(const std::vector<jspp::AnyValue>&)`;
+        callable = `std::function<${signature}>(${lambda})`;
+        method = `jspp::AnyValue::make_function`;
     }
-    const signature = `jspp::AnyValue(const std::vector<jspp::AnyValue>&)`;
-    const callable = `std::function<${signature}>(${lambda})`;
     const funcName = node.name?.getText();
-    const fullExpression = `jspp::AnyValue::make_function(${callable}, "${funcName || ""}")`;
+    const fullExpression = `${method}(${callable}, "${funcName || ""}")`;
     if (ts.isFunctionDeclaration(node) && !isAssignment && funcName) {
         return `${this.indent()}auto ${funcName} = ${fullExpression};\n`;
     }

package/dist/core/codegen/helpers.js

@@ -1,14 +1,8 @@
 import ts from "typescript";
-import { Scope } from "../../analysis/scope";
+import { BUILTIN_OBJECTS, Scope } from "../../analysis/scope";
 import { CodeGenerator } from "./";
-const BUILTIN_OBJECTS = new Set([
-    "global",
-    "globalThis",
-    "console",
-    "Symbol",
-]);
 export function isBuiltinObject(node) {
-    return BUILTIN_OBJECTS.has(node.text);
+    return BUILTIN_OBJECTS.values().some((obj) => obj.name === node.text);
 }
 export function getDeclaredSymbols(node) {
     const symbols = new Set();
@@ -81,3 +75,13 @@ export function escapeString(str) {
 export function getJsVarName(node) {
     return `"${node.text}"`;
 }
+export function getReturnCmd(context) {
+    return context.isInsideGeneratorFunction ? "co_return" : "return";
+}
+export function isGeneratorFunction(node) {
+    return ((ts.isFunctionDeclaration(node) ||
+        ts.isFunctionExpression(node) ||
+        ts.isMethodDeclaration(node)) &&
+        !!node.asteriskToken // generator indicator
+    );
+}

package/dist/core/codegen/index.js

@@ -1,6 +1,6 @@
 import { TypeAnalyzer } from "../../analysis/typeAnalyzer";
 import { generateLambda } from "./function-handlers";
-import { escapeString, generateUniqueExceptionName, generateUniqueName, getDeclaredSymbols, getJsVarName, getScopeForNode, indent, isBuiltinObject, } from "./helpers";
+import { escapeString, generateUniqueExceptionName, generateUniqueName, getDeclaredSymbols, getJsVarName, getReturnCmd, getScopeForNode, indent, isBuiltinObject, isGeneratorFunction, } from "./helpers";
 import { visit } from "./visitor";
 const CONTAINER_FUNCTION_NAME = "__container__";
 export class CodeGenerator {
@@ -17,7 +17,9 @@ export class CodeGenerator {
     indent = indent;
     escapeString = escapeString;
     getJsVarName = getJsVarName;
+    getReturnCmd = getReturnCmd;
     isBuiltinObject = isBuiltinObject;
+    isGeneratorFunction = isGeneratorFunction;
     // function handlers
     generateLambda = generateLambda;
     /**

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

@@ -130,8 +130,7 @@ export function visitBlock(node, context) {
     if (context.isFunctionBody) {
         const lastStatement = block.statements[block.statements.length - 1];
         if (!lastStatement || !ts.isReturnStatement(lastStatement)) {
-            code +=
-                `${this.indent()}return jspp::AnyValue::make_undefined();\n`;
+            code += `${this.indent()}${this.getReturnCmd(context)} jspp::AnyValue::make_undefined();\n`;
         }
     }
     this.indentationLevel--;
@@ -250,32 +249,49 @@ export function visitForOfStatement(node, context) {
             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`;
+                `${this.indent()}{ auto ${varName} = std::make_shared<jspp::AnyValue>(jspp::AnyValue::make_undefined());\n`;
         }
     }
     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 iterableExpr = this.visit(forOf.expression, context);
-    const derefIterable = `jspp::Access::deref(${iterableExpr}, ${this.getJsVarName(forOf.expression)})`;
-    const arrayPtr = this.generateUniqueName("__array_ptr_", new Set());
+    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 ${arrayPtr} = std::any_cast<std::shared_ptr<jspp::JsArray>>(${derefIterable});\n`;
+        `${this.indent()}auto ${iteratorFn} = ${derefIterable}.get_own_property(Symbol.get_own_property("iterator"));\n`;
     code +=
-        `${this.indent()}for (const auto& ${varName}_val : ${arrayPtr}->items) {\n`;
+        `${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`;
     this.indentationLevel++;
-    code += `${this.indent()}*${varName} = ${varName}_val;\n`;
+    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`;
     this.indentationLevel--;
     code += `${this.indent()}}}\n`;
     this.indentationLevel--; // Exit the scope for the for-of loop
     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);
@@ -355,7 +371,7 @@ export function visitTryStatement(node, context) {
         else {
             code += `${this.indent()}catch (...) { throw; }\n`;
         }
-        code += `${this.indent()}return jspp::AnyValue::make_undefined();\n`;
+        code += `${this.indent()}${this.getReturnCmd(context)} jspp::AnyValue::make_undefined();\n`;
         this.indentationLevel--;
         code += `${this.indent()}})();\n`;
         this.indentationLevel--;
@@ -427,11 +443,32 @@ export function visitCatchClause(node, context) {
         return code;
     }
 }
+export function visitYieldExpression(node, context) {
+    if (node.expression) {
+        const expr = node.expression;
+        const 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
+            }
+            if (typeInfo &&
+                !typeInfo.isParameter &&
+                !typeInfo.isBuiltin) {
+                return `${this.indent()}co_yield jspp::Access::deref(${exprText}, ${this.getJsVarName(expr)})`;
+            }
+        }
+        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`;
     }
     const returnStmt = node;
+    const returnCmd = this.getReturnCmd(context);
     if (context.isInsideTryCatchLambda && context.hasReturnedFlag) {
         let returnCode = `${this.indent()}${context.hasReturnedFlag} = true;\n`;
         if (returnStmt.expression) {
@@ -448,19 +485,19 @@ export function visitReturnStatement(node, context) {
                     !typeInfo.isParameter &&
                     !typeInfo.isBuiltin) {
                     returnCode +=
-                        `${this.indent()}return jspp::Access::deref(${exprText}, ${this.getJsVarName(expr)});\n`;
+                        `${this.indent()}${returnCmd} jspp::Access::deref(${exprText}, ${this.getJsVarName(expr)});\n`;
                 }
                 else {
-                    returnCode += `${this.indent()}return ${exprText};\n`;
+                    returnCode += `${this.indent()}${returnCmd} ${exprText};\n`;
                 }
             }
             else {
-                returnCode += `${this.indent()}return ${exprText};\n`;
+                returnCode += `${this.indent()}${returnCmd} ${exprText};\n`;
             }
         }
         else {
             returnCode +=
-                `${this.indent()}return jspp::AnyValue::make_undefined();\n`;
+                `${this.indent()}${returnCmd} jspp::AnyValue::make_undefined();\n`;
         }
         return returnCode;
     }
@@ -476,10 +513,10 @@ export function visitReturnStatement(node, context) {
             if (typeInfo &&
                 !typeInfo.isParameter &&
                 !typeInfo.isBuiltin) {
-                return `${this.indent()}return jspp::Access::deref(${exprText}, ${this.getJsVarName(expr)});\n`;
+                return `${this.indent()}${returnCmd} jspp::Access::deref(${exprText}, ${this.getJsVarName(expr)});\n`;
             }
         }
-        return `${this.indent()}return ${exprText};\n`;
+        return `${this.indent()}${returnCmd} ${exprText};\n`;
     }
-    return `${this.indent()}return jspp::AnyValue::make_undefined();\n`;
+    return `${this.indent()}${returnCmd} jspp::AnyValue::make_undefined();\n`;
 }

package/dist/core/codegen/visitor.js

@@ -4,7 +4,7 @@ import { visitVariableDeclaration, visitVariableDeclarationList, } from "./decla
 import { visitArrayLiteralExpression, visitBinaryExpression, visitCallExpression, visitElementAccessExpression, visitObjectLiteralExpression, visitParenthesizedExpression, visitPostfixUnaryExpression, visitPrefixUnaryExpression, visitPropertyAccessExpression, visitTemplateExpression, 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, visitCatchClause, visitExpressionStatement, visitForInStatement, visitForOfStatement, visitForStatement, visitIfStatement, visitReturnStatement, visitSourceFile, visitThrowStatement, visitTryStatement, visitVariableStatement, } from "./statement-handlers";
+import { visitBlock, visitBreakStatement, visitCatchClause, visitContinueStatement, visitExpressionStatement, visitForInStatement, visitForOfStatement, visitForStatement, visitIfStatement, visitReturnStatement, visitSourceFile, visitThrowStatement, visitTryStatement, visitVariableStatement, visitYieldExpression, } from "./statement-handlers";
 export function visit(node, context) {
     if (ts.isFunctionDeclaration(node)) {
         return visitFunctionDeclaration.call(this, node, context);
@@ -34,6 +34,10 @@ export function visit(node, context) {
             return visitForInStatement.call(this, node, context);
         case ts.SyntaxKind.ForOfStatement:
             return visitForOfStatement.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.IfStatement:
             return visitIfStatement.call(this, node, context);
         case ts.SyntaxKind.PrefixUnaryExpression:
@@ -58,6 +62,8 @@ export function visit(node, context) {
             return visitCatchClause.call(this, node, context);
         case ts.SyntaxKind.CallExpression:
             return visitCallExpression.call(this, node, context);
+        case ts.SyntaxKind.YieldExpression:
+            return visitYieldExpression.call(this, node, context);
         case ts.SyntaxKind.ReturnStatement:
             return visitReturnStatement.call(this, node, context);
         case ts.SyntaxKind.Identifier:

package/package.json

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

package/src/prelude/access.hpp

@@ -1,8 +1,11 @@
 #pragma once
 
 #include "types.hpp"
+#include "well_known_symbols.hpp"
 #include "values/function.hpp"
+#include "values/symbol.hpp"
 #include "error.hpp"
+#include "any_value.hpp"
 #include <ranges>
 
 namespace jspp
@@ -52,7 +55,8 @@ namespace jspp
                 auto ptr = obj.as_object();
                 for (const auto &pair : ptr->props)
                 {
-                    keys.push_back(pair.first);
+                    if (!JsSymbol::is_internal_key(pair.first))
+                        keys.push_back(pair.first);
                 }
             }
             if (obj.is_function())
@@ -60,7 +64,8 @@ namespace jspp
                 auto ptr = obj.as_function();
                 for (const auto &pair : ptr->props)
                 {
-                    keys.push_back(pair.first);
+                    if (!JsSymbol::is_internal_key(pair.first))
+                        keys.push_back(pair.first);
                 }
             }
             if (obj.is_array())
@@ -73,7 +78,7 @@ namespace jspp
             }
             if (obj.is_string())
             {
-                auto len = obj.as_string()->length();
+                auto len = obj.as_string()->value.length();
                 for (auto i = 0; i < len; ++i)
                 {
                     keys.push_back(std::to_string(i));