@ugo-studio/jspp 0.1.2 → 0.1.4

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

@@ -1,13 +1,41 @@
 import ts from "typescript";
 import { CodeGenerator } from "./";
-export function generateLambda(node, isAssignment = false, capture = "[=]") {
+export function generateLambda(node, context, options) {
+    const isAssignment = options?.isAssignment || false;
+    const capture = options?.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 isInsideAsyncFunction = this.isAsyncFunction(node);
+    const returnCmd = this.getReturnCommand({
+        isInsideGeneratorFunction: isInsideGeneratorFunction,
+        isInsideAsyncFunction: isInsideAsyncFunction,
+    });
+    const funcReturnType = isInsideGeneratorFunction
+        ? "jspp::JsIterator<jspp::AnyValue>"
+        : (isInsideAsyncFunction ? "jspp::JsPromise" : "jspp::AnyValue");
+    const isArrow = ts.isArrowFunction(node);
+    // For generators and async functions, we MUST copy arguments because the coroutine suspends immediately
+    // and references to temporary arguments would dangle.
+    const paramThisType = (isInsideGeneratorFunction || isInsideAsyncFunction)
+        ? "jspp::AnyValue"
+        : "const jspp::AnyValue&";
+    const paramArgsType = (isInsideGeneratorFunction || isInsideAsyncFunction)
+        ? "std::vector<jspp::AnyValue>"
+        : "const std::vector<jspp::AnyValue>&";
+    const thisArgParam = isArrow
+        ? "const jspp::AnyValue&" // Arrow functions are never generators in this parser
+        : `${paramThisType} ${this.globalThisVar}`;
+    let lambda = `${capture}(${thisArgParam}, ${paramArgsType} ${argsName}) mutable -> ${funcReturnType} `;
+    const topLevelScopeSymbols = this.prepareScopeSymbolsForVisit(context.topLevelScopeSymbols, context.currentScopeSymbols);
     const visitContext = {
         isMainContext: false,
         isInsideFunction: true,
         isFunctionBody: false,
+        lambdaName: undefined,
+        topLevelScopeSymbols,
+        currentScopeSymbols: new Map(),
+        superClassVar: context.superClassVar,
     };
     if (node.body) {
         if (ts.isBlock(node.body)) {
@@ -18,14 +46,49 @@ export function generateLambda(node, isAssignment = false, capture = "[=]") {
                 const defaultValue = p.initializer
                     ? this.visit(p.initializer, visitContext)
                     : "jspp::AnyValue::make_undefined()";
-                paramExtraction +=
-                    `${this.indent()}auto ${name} = ${argsName}.size() > ${i} ? ${argsName}[${i}] : ${defaultValue};\n`;
+                if (!!p.dotDotDotToken) {
+                    if (node.parameters.length - 1 !== i) {
+                        throw new SyntaxError("Rest parameter must be last formal parameter.");
+                    }
+                    const tempName = `temp_${name}`;
+                    paramExtraction +=
+                        `${this.indent()}auto ${name} = jspp::AnyValue::make_undefined();\n`;
+                    paramExtraction += `${this.indent()}{\n`;
+                    this.indentationLevel++;
+                    paramExtraction +=
+                        `${this.indent()}std::vector<std::optional<jspp::AnyValue>> ${tempName};\n`;
+                    paramExtraction +=
+                        `${this.indent()}if (${argsName}.size() > ${i}) {\n`;
+                    this.indentationLevel++;
+                    paramExtraction +=
+                        `${this.indent()}${tempName}.reserve(${argsName}.size() - ${i});\n`;
+                    this.indentationLevel--;
+                    paramExtraction += `${this.indent()}}\n`;
+                    paramExtraction +=
+                        `${this.indent()}for (size_t i = ${i}; i < ${argsName}.size(); i++) {\n`;
+                    this.indentationLevel++;
+                    paramExtraction +=
+                        `${this.indent()}${tempName}.push_back(${argsName}[i]);\n`;
+                    this.indentationLevel--;
+                    paramExtraction += `${this.indent()}}\n`;
+                    paramExtraction +=
+                        `${this.indent()}${name} = jspp::AnyValue::make_array(std::move(${tempName}));\n`;
+                    this.indentationLevel--;
+                    paramExtraction += `${this.indent()}}\n`;
+                }
+                else {
+                    paramExtraction +=
+                        `${this.indent()}auto ${name} = ${argsName}.size() > ${i} ? ${argsName}[${i}] : ${defaultValue};\n`;
+                }
             });
             this.indentationLevel--;
             const blockContent = this.visit(node.body, {
+                ...visitContext,
                 isMainContext: false,
                 isInsideFunction: true,
                 isFunctionBody: true,
+                isInsideGeneratorFunction: isInsideGeneratorFunction,
+                isInsideAsyncFunction: isInsideAsyncFunction,
             });
             // The block visitor already adds braces, so we need to inject the param extraction.
             lambda += "{\n" + paramExtraction + blockContent.substring(2);
@@ -41,10 +104,13 @@ 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, {
+                ...visitContext,
                 isMainContext: false,
                 isInsideFunction: true,
                 isFunctionBody: false,
+                isInsideGeneratorFunction: isInsideGeneratorFunction,
+                isInsideAsyncFunction: isInsideAsyncFunction,
             })};
 `;
             this.indentationLevel--;
@@ -52,12 +118,37 @@ 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 jspp::AnyValue&, const std::vector<jspp::AnyValue>&)";
+        callable = `std::function<${signature}>(${lambda})`;
+        method = `jspp::AnyValue::make_generator`;
+    } // Handle async function
+    else if (isInsideAsyncFunction) {
+        signature =
+            "jspp::JsPromise(const jspp::AnyValue&, const std::vector<jspp::AnyValue>&)";
+        callable = `std::function<${signature}>(${lambda})`;
+        method = `jspp::AnyValue::make_async_function`;
+    } // Handle normal function
+    else {
+        signature =
+            `jspp::AnyValue(const jspp::AnyValue&, const std::vector<jspp::AnyValue>&)`;
+        callable = `std::function<${signature}>(${lambda})`;
+        if (options?.isClass) {
+            method = `jspp::AnyValue::make_class`;
+        }
+        else {
+            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}, "${context?.lambdaName || funcName || ""}")`;
     if (ts.isFunctionDeclaration(node) && !isAssignment && funcName) {
         return `${this.indent()}auto ${funcName} = ${fullExpression};\n`;
     }
@@ -68,12 +159,12 @@ export function visitFunctionDeclaration(node, context) {
         // This will now be handled by the Block visitor for hoisting.
         // However, we still need to generate the lambda for assignment.
         // The block visitor will wrap this in an assignment.
-        return this.generateLambda(node);
+        return this.generateLambda(node, context);
     }
     return "";
 }
 export function visitArrowFunction(node, context) {
-    return this.generateLambda(node);
+    return this.generateLambda(node, context);
 }
 export function visitFunctionExpression(node, context) {
     const funcExpr = node;
@@ -83,12 +174,18 @@ export function visitFunctionExpression(node, context) {
         this.indentationLevel++;
         code +=
             `${this.indent()}auto ${funcName} = std::make_shared<jspp::AnyValue>();\n`;
-        const lambda = this.generateLambda(funcExpr, false, "[=]");
+        const lambda = this.generateLambda(funcExpr, {
+            ...context,
+            lambdaName: funcName,
+        }, {
+            isAssignment: true,
+            capture: "[=]",
+        });
         code += `${this.indent()}*${funcName} = ${lambda};\n`;
         code += `${this.indent()}return *${funcName};\n`;
         this.indentationLevel--;
         code += `${this.indent()}})()`;
         return code;
     }
-    return this.generateLambda(node);
+    return this.generateLambda(node, context);
 }

package/dist/core/codegen/helpers.js

@@ -1,14 +1,9 @@
 import ts from "typescript";
-import { Scope } from "../../analysis/scope";
+import { BUILTIN_OBJECTS, Scope } from "../../analysis/scope";
+import { DeclaredSymbolType } from "../../ast/types";
 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();
@@ -21,6 +16,10 @@ export function getDeclaredSymbols(node) {
             // Handles function declarations
             symbols.add(child.name.getText());
         }
+        else if (ts.isClassDeclaration(child) && child.name) {
+            // Handles class declarations
+            symbols.add(child.name.getText());
+        }
         else if (ts.isParameter(child)) {
             // Handles function parameters
             symbols.add(child.name.getText());
@@ -81,3 +80,72 @@ export function escapeString(str) {
 export function getJsVarName(node) {
     return `"${node.text}"`;
 }
+export function getDerefCode(nodeText, varName, typeInfo) {
+    // Make sure varName is incased in quotes
+    if (!varName.startsWith('"'))
+        varName = '"' + varName;
+    if (!varName.endsWith('"'))
+        varName = varName + '"';
+    if (typeInfo && typeInfo.needsHeapAllocation) {
+        return `jspp::Access::deref_ptr(${nodeText}, ${varName})`;
+    }
+    return `jspp::Access::deref_stack(${nodeText}, ${varName})`;
+}
+export function getReturnCommand(context) {
+    return (context.isInsideGeneratorFunction || context.isInsideAsyncFunction) ? "co_return" : "return";
+}
+export function hoistDeclaration(decl, hoistedSymbols) {
+    const name = decl.name?.getText();
+    if (!name) {
+        return `/* Unknown declaration name: ${ts.SyntaxKind[decl.kind]} */`;
+    }
+    const isLetOrConst = (decl.parent.flags & (ts.NodeFlags.Let | ts.NodeFlags.Const)) !==
+        0;
+    const symbolType = isLetOrConst
+        ? DeclaredSymbolType.letOrConst
+        : (ts.isFunctionDeclaration(decl)
+            ? DeclaredSymbolType.function
+            : (ts.isClassDeclaration(decl) ? DeclaredSymbolType.letOrConst : DeclaredSymbolType.var));
+    if (hoistedSymbols.has(name)) {
+        const existingType = hoistedSymbols.get(name);
+        // Don't allow multiple declaration of `letOrConst` or `function` or `class` variables
+        if (existingType === DeclaredSymbolType.letOrConst ||
+            existingType === DeclaredSymbolType.function ||
+            existingType !== symbolType) {
+            throw new SyntaxError(`Identifier '${name}' has already been declared`);
+        }
+        // `var` variables can be declared multiple times
+        return "";
+    }
+    hoistedSymbols.set(name, symbolType);
+    const scope = this.getScopeForNode(decl);
+    const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(name, scope);
+    const initializer = isLetOrConst || ts.isClassDeclaration(decl)
+        ? "jspp::AnyValue::make_uninitialized()"
+        : "jspp::AnyValue::make_undefined()";
+    if (typeInfo.needsHeapAllocation) {
+        return `${this.indent()}auto ${name} = std::make_shared<jspp::AnyValue>(${initializer});\n`;
+    }
+    else {
+        return `${this.indent()}jspp::AnyValue ${name} = ${initializer};\n`;
+    }
+}
+export function isGeneratorFunction(node) {
+    return ((ts.isFunctionDeclaration(node) ||
+        ts.isFunctionExpression(node) ||
+        ts.isMethodDeclaration(node)) &&
+        !!node.asteriskToken // generator indicator
+    );
+}
+export function isAsyncFunction(node) {
+    return ((ts.isFunctionDeclaration(node) ||
+        ts.isFunctionExpression(node) ||
+        ts.isMethodDeclaration(node) ||
+        ts.isArrowFunction(node)) &&
+        (ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Async) !== 0);
+}
+export function prepareScopeSymbolsForVisit(topLevel, local) {
+    const newTopLevel = new Map(topLevel);
+    local.forEach((v, k) => newTopLevel.set(k, v));
+    return newTopLevel;
+}

package/dist/core/codegen/index.js

@@ -1,11 +1,12 @@
 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, getDerefCode, getJsVarName, getReturnCommand, getScopeForNode, hoistDeclaration, indent, isAsyncFunction, isBuiltinObject, isGeneratorFunction, prepareScopeSymbolsForVisit, } from "./helpers";
 import { visit } from "./visitor";
 const CONTAINER_FUNCTION_NAME = "__container__";
 export class CodeGenerator {
     indentationLevel = 0;
     typeAnalyzer;
+    globalThisVar;
     exceptionCounter = 0;
     // visitor
     visit = visit;
@@ -13,11 +14,17 @@ export class CodeGenerator {
     getDeclaredSymbols = getDeclaredSymbols;
     generateUniqueName = generateUniqueName;
     generateUniqueExceptionName = generateUniqueExceptionName;
+    hoistDeclaration = hoistDeclaration;
     getScopeForNode = getScopeForNode;
     indent = indent;
     escapeString = escapeString;
     getJsVarName = getJsVarName;
+    getDerefCode = getDerefCode;
+    getReturnCommand = getReturnCommand;
     isBuiltinObject = isBuiltinObject;
+    isGeneratorFunction = isGeneratorFunction;
+    isAsyncFunction = isAsyncFunction;
+    prepareScopeSymbolsForVisit = prepareScopeSymbolsForVisit;
     // function handlers
     generateLambda = generateLambda;
     /**
@@ -25,27 +32,33 @@ export class CodeGenerator {
      */
     generate(ast, analyzer) {
         this.typeAnalyzer = analyzer;
+        this.globalThisVar = this.generateUniqueName("__this_val__", this.getDeclaredSymbols(ast));
         const declarations = `#include "index.hpp"\n\n`;
         let containerCode = `jspp::AnyValue ${CONTAINER_FUNCTION_NAME}() {\n`;
         this.indentationLevel++;
+        containerCode +=
+            `${this.indent()}jspp::AnyValue ${this.globalThisVar} = global;\n`;
         containerCode += this.visit(ast, {
             isMainContext: true,
             isInsideFunction: true,
             isFunctionBody: true,
+            topLevelScopeSymbols: new Map(),
+            currentScopeSymbols: new Map(),
         });
         this.indentationLevel--;
         containerCode += "  return jspp::AnyValue::make_undefined();\n";
         containerCode += "}\n\n";
         let mainCode = "int main() {\n";
-        mainCode += `  std::ios::sync_with_stdio(false);\n`;
-        mainCode += `  std::cin.tie(nullptr);\n`;
+        // std::ios::sync_with_stdio(false); // Removed to fix console output buffering
+        // std::cin.tie(nullptr);            // Removed to fix console output buffering
         mainCode += `  try {\n`;
         mainCode += `    ${CONTAINER_FUNCTION_NAME}();\n`;
+        mainCode += `    jspp::Scheduler::instance().run();\n`;
         mainCode += `  } catch (const std::exception& ex) {\n`;
         mainCode +=
-            "    auto error = std::make_shared<jspp::AnyValue>(jspp::RuntimeError::error_to_value(ex));\n{\n";
+            "    auto error = std::make_shared<jspp::AnyValue>(jspp::Exception::exception_to_any_value(ex));\n{\n";
         mainCode +=
-            `    console.get_own_property("error").as_function("console.error")->call({*error});\n`;
+            `    ([&](){ auto __obj = console; return __obj.get_own_property("error").as_function("console.error")->call(__obj, {*error}); })();\n`;
         mainCode += `    return 1;\n}\n`;
         mainCode += `  }\n`;
         mainCode += "  return 0;\n}";

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

@@ -30,3 +30,6 @@ export function visitUndefinedKeyword() {
 export function visitNullKeyword() {
     return "jspp::AnyValue::make_null()";
 }
+export function visitThisKeyword() {
+    return `${this.globalThisVar}`;
+}