@ugo-studio/jspp 0.2.4 → 0.2.6

package/dist/core/codegen/helpers.js

@@ -1,6 +1,7 @@
 import ts from "typescript";
 import { BUILTIN_OBJECTS, Scope } from "../../analysis/scope.js";
-import { DeclaredSymbols, DeclaredSymbolType } from "../../ast/symbols.js";
+import { DeclarationType, DeclaredSymbols } from "../../ast/symbols.js";
+import { CompilerError } from "../error.js";
 import { CodeGenerator } from "./index.js";
 export function isBuiltinObject(node) {
     return BUILTIN_OBJECTS.values().some((obj) => obj.name === node.text);
@@ -20,6 +21,10 @@ export function getDeclaredSymbols(node) {
             // Handles class declarations
             symbols.add(child.name.getText());
         }
+        else if (ts.isEnumDeclaration(child) && child.name) {
+            // Handles enum declarations
+            symbols.add(child.name.getText());
+        }
         else if (ts.isParameter(child)) {
             // Handles function parameters
             symbols.add(child.name.getText());
@@ -60,7 +65,7 @@ export function getScopeForNode(node) {
     }
     const rootScope = this.typeAnalyzer.scopeManager.getAllScopes()[0];
     if (!rootScope) {
-        throw new Error("Compiler bug: Could not find a root scope.");
+        throw new CompilerError("Could not find a root scope.", node, "CompilerBug");
     }
     return rootScope;
 }
@@ -73,7 +78,8 @@ export function escapeString(str) {
         .replace(/"/g, '\\"')
         .replace(/\n/g, "\\n")
         .replace(/\r/g, "\\r")
-        .replace(/\t/g, "\\t");
+        .replace(/\t/g, "\\t")
+        .replace(/\?/g, "\\?");
 }
 export function getJsVarName(node) {
     return `"${node.text}"`;
@@ -86,13 +92,13 @@ export function getDerefCode(nodeText, varName, context, typeInfo) {
         varName = varName + '"';
     const symbolName = varName.slice(1).slice(0, -1);
     const symbol = context.localScopeSymbols.get(symbolName) ??
-        context.topLevelScopeSymbols.get(symbolName);
-    const checkedIfUninitialized = symbol?.checkedIfUninitialized ||
+        context.globalScopeSymbols.get(symbolName);
+    const isInitialized = symbol?.checks.initialized ||
         false;
     // Mark the symbol as checked
-    this.markSymbolAsChecked(symbolName, context.topLevelScopeSymbols, context.localScopeSymbols);
+    this.markSymbolAsInitialized(symbolName, context.globalScopeSymbols, context.localScopeSymbols);
     // Apply deref code
-    if (checkedIfUninitialized) {
+    if (isInitialized) {
         if (typeInfo && typeInfo.needsHeapAllocation) {
             return `(*${nodeText})`;
         }
@@ -105,15 +111,15 @@ export function getDerefCode(nodeText, varName, context, typeInfo) {
         return `jspp::Access::deref_stack(${nodeText}, ${varName})`;
     }
 }
-export function markSymbolAsChecked(name, topLevel, local) {
+export function markSymbolAsInitialized(name, topLevel, local) {
     if (topLevel.has(name)) {
         topLevel.update(name, {
-            checkedIfUninitialized: true,
+            checks: { initialized: true },
         });
     }
     else if (local.has(name)) {
         local.update(name, {
-            checkedIfUninitialized: true,
+            checks: { initialized: true },
         });
     }
 }
@@ -122,39 +128,61 @@ export function getReturnCommand(context) {
         ? "co_return"
         : "return";
 }
-export function hoistDeclaration(decl, hoistedSymbols) {
+export function hoistDeclaration(decl, hoistedSymbols, scopeNode) {
     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;
-    // if (name === "letVal") console.log("hoistDeclaration: letVal isLetOrConst=", isLetOrConst, " flags=", decl.parent.flags);
-    const symbolType = isLetOrConst
-        ? DeclaredSymbolType.letOrConst
-        : (ts.isFunctionDeclaration(decl)
-            ? DeclaredSymbolType.function
-            : (ts.isClassDeclaration(decl)
-                ? DeclaredSymbolType.letOrConst
-                : DeclaredSymbolType.var));
+    const isLet = (decl.parent.flags & (ts.NodeFlags.Let)) !== 0;
+    const isConst = (decl.parent.flags & (ts.NodeFlags.Const)) !== 0;
+    const declType = isLet
+        ? DeclarationType.let
+        : isConst
+            ? DeclarationType.const
+            : ts.isFunctionDeclaration(decl)
+                ? DeclarationType.function
+                : ts.isClassDeclaration(decl)
+                    ? DeclarationType.class
+                    : ts.isEnumDeclaration(decl)
+                        ? DeclarationType.enum
+                        : DeclarationType.var;
     if (hoistedSymbols.has(name)) {
-        const existingType = hoistedSymbols.get(name)?.type;
-        // 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`);
+        const existingSymbol = hoistedSymbols.get(name);
+        // Don't allow multiple declaration of `let`,`const`,`function`, `class` or `enum` variables
+        if (existingSymbol?.type === DeclarationType.let ||
+            existingSymbol?.type === DeclarationType.const ||
+            existingSymbol?.type === DeclarationType.function ||
+            existingSymbol?.type === DeclarationType.class ||
+            existingSymbol?.type === DeclarationType.enum ||
+            existingSymbol?.type !== declType) {
+            throw new CompilerError(`Identifier '${name}' has already been declared.`, decl, "SyntaxError");
         }
         // `var` variables can be declared multiple times
         return "";
     }
-    hoistedSymbols.set(name, {
-        type: symbolType,
-        checkedIfUninitialized: false,
-    });
+    else {
+        // Add the symbol to the hoisted symbols
+        if (declType === DeclarationType.function) {
+            const isAsync = this.isAsyncFunction(decl);
+            const isGenerator = this.isGeneratorFunction(decl);
+            hoistedSymbols.add(name, {
+                type: declType,
+                func: { isAsync, isGenerator },
+            });
+            // Don't hoist functions not used as a variable
+            // they will be called with their native lambdas
+            if (!this.isFunctionUsedAsValue(decl, scopeNode) &&
+                !this.isFunctionUsedBeforeDeclaration(name, scopeNode)) {
+                return "";
+            }
+        }
+        else {
+            hoistedSymbols.add(name, { type: declType });
+        }
+    }
     const scope = this.getScopeForNode(decl);
     const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(name, scope);
-    const initializer = isLetOrConst || ts.isClassDeclaration(decl)
+    const initializer = isLet || isConst || ts.isClassDeclaration(decl)
         ? "jspp::Constants::UNINITIALIZED"
         : "jspp::Constants::UNDEFINED";
     if (typeInfo.needsHeapAllocation) {
@@ -183,10 +211,24 @@ export function prepareScopeSymbolsForVisit(topLevel, local) {
     // Join the top and local scopes
     return new DeclaredSymbols(topLevel, local);
 }
+export function shouldIgnoreStatement(stmt) {
+    // Ignore variable statements with 'declare' modifier
+    if (ts.isVariableStatement(stmt)) {
+        if (stmt.modifiers &&
+            stmt.modifiers.some((m) => m.kind === ts.SyntaxKind.DeclareKeyword)) {
+            return true;
+        }
+    }
+    return false;
+}
 export function collectFunctionScopedDeclarations(node) {
     const decls = [];
     function visit(n) {
         if (ts.isVariableStatement(n)) {
+            // Ignore Declare modifier
+            if (shouldIgnoreStatement(n))
+                return;
+            // Only collect let/const declarations
             const isLetOrConst = (n.declarationList.flags &
                 (ts.NodeFlags.Let | ts.NodeFlags.Const)) !== 0;
             if (!isLetOrConst) {
@@ -237,6 +279,10 @@ export function collectBlockScopedDeclarations(statements) {
     const decls = [];
     for (const stmt of statements) {
         if (ts.isVariableStatement(stmt)) {
+            // Ignore Declare modifier
+            if (shouldIgnoreStatement(stmt))
+                continue;
+            // Only collect let/const declarations
             const isLetOrConst = (stmt.declarationList.flags &
                 (ts.NodeFlags.Let | ts.NodeFlags.Const)) !== 0;
             if (isLetOrConst) {
@@ -246,3 +292,121 @@ export function collectBlockScopedDeclarations(statements) {
     }
     return decls;
 }
+export function isFunctionUsedAsValue(decl, root) {
+    const funcName = decl.name?.getText();
+    if (!funcName)
+        return false;
+    let isUsed = false;
+    const visitor = (node) => {
+        if (isUsed)
+            return;
+        if (ts.isIdentifier(node) && node.text === funcName) {
+            const scope = this.getScopeForNode(node);
+            const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(node.text, scope);
+            if (typeInfo?.declaration === decl) {
+                const parent = node.parent;
+                // Ignore declarations where the identifier is the name being declared
+                if ((ts.isFunctionDeclaration(parent) ||
+                    ts.isVariableDeclaration(parent) ||
+                    ts.isClassDeclaration(parent) ||
+                    ts.isMethodDeclaration(parent) ||
+                    ts.isParameter(parent) ||
+                    ts.isImportSpecifier(parent)) &&
+                    parent.name === node) {
+                    // Declaration, do nothing
+                } // Ignore property names (e.g. obj.funcName)
+                else if ((ts.isPropertyAccessExpression(parent) &&
+                    parent.name === node) ||
+                    (ts.isPropertyAssignment(parent) && parent.name === node)) {
+                    // Property name, do nothing
+                } // Ignore direct calls (e.g. funcName())
+                else if (ts.isCallExpression(parent) && parent.expression === node) {
+                    // Call, do nothing
+                }
+                else {
+                    // Used as a value
+                    isUsed = true;
+                }
+            }
+        }
+        if (!isUsed) {
+            ts.forEachChild(node, visitor);
+        }
+    };
+    ts.forEachChild(root, visitor);
+    return isUsed;
+}
+export function isFunctionUsedBeforeDeclaration(funcName, root) {
+    let declPos = -1;
+    let foundDecl = false;
+    // Helper to find the function declaration position
+    function findDecl(node) {
+        if (foundDecl)
+            return;
+        if (ts.isFunctionDeclaration(node) && node.name?.text === funcName) {
+            declPos = node.getStart();
+            foundDecl = true;
+        }
+        else {
+            ts.forEachChild(node, findDecl);
+        }
+    }
+    findDecl(root);
+    // If not declared in this scope (or at least not found), assume it's not a local forward-ref issue
+    if (!foundDecl)
+        return false;
+    let isUsedBefore = false;
+    function visit(node) {
+        if (isUsedBefore)
+            return;
+        if (ts.isIdentifier(node) && node.text === funcName) {
+            const parent = node.parent;
+            // Ignore declarations where the identifier is the name being declared
+            if ((ts.isFunctionDeclaration(parent) ||
+                ts.isVariableDeclaration(parent) ||
+                ts.isClassDeclaration(parent) ||
+                ts.isMethodDeclaration(parent) ||
+                ts.isParameter(parent) ||
+                ts.isImportSpecifier(parent)) &&
+                parent.name === node) {
+                // Declaration (or shadowing), do nothing
+            } // Ignore property names (e.g. obj.funcName)
+            else if ((ts.isPropertyAccessExpression(parent) &&
+                parent.name === node) ||
+                (ts.isPropertyAssignment(parent) && parent.name === node)) {
+                // Property name, do nothing
+            }
+            else {
+                // It is a usage (call or value usage)
+                const usagePos = node.getStart();
+                // Check 1: Lexically before
+                if (usagePos < declPos) {
+                    isUsedBefore = true;
+                    return;
+                }
+                // Check 2: Inside a function declared before
+                let current = parent;
+                while (current && current !== root) {
+                    if (ts.isFunctionDeclaration(current) ||
+                        ts.isMethodDeclaration(current) ||
+                        ts.isArrowFunction(current) ||
+                        ts.isFunctionExpression(current) ||
+                        ts.isGetAccessor(current) ||
+                        ts.isSetAccessor(current) ||
+                        ts.isConstructorDeclaration(current)) {
+                        if (current.getStart() < declPos) {
+                            isUsedBefore = true;
+                            return;
+                        }
+                        // Once we hit a function boundary, we stop bubbling up for this usage.
+                        break;
+                    }
+                    current = current.parent;
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(root);
+    return isUsedBefore;
+}

package/dist/core/codegen/index.js

@@ -1,11 +1,12 @@
 import { DeclaredSymbols } from "../../ast/symbols.js";
-import { generateLambda } from "./function-handlers.js";
-import { escapeString, generateUniqueExceptionName, generateUniqueName, getDeclaredSymbols, getDerefCode, getJsVarName, getReturnCommand, getScopeForNode, hoistDeclaration, indent, isAsyncFunction, isBuiltinObject, isGeneratorFunction, markSymbolAsChecked, prepareScopeSymbolsForVisit, } from "./helpers.js";
+import { generateFullLambdaExpression, generateLambda, } from "./function-handlers.js";
+import { escapeString, generateUniqueExceptionName, generateUniqueName, getDeclaredSymbols, getDerefCode, getJsVarName, getReturnCommand, getScopeForNode, hoistDeclaration, indent, isAsyncFunction, isBuiltinObject, isFunctionUsedAsValue, isFunctionUsedBeforeDeclaration, isGeneratorFunction, markSymbolAsInitialized, prepareScopeSymbolsForVisit, } from "./helpers.js";
 import { visit } from "./visitor.js";
-const MODULE_NAME = "__main_function__";
+const MODULE_NAME = "__entry_point__";
 export class CodeGenerator {
     indentationLevel = 0;
     typeAnalyzer;
+    isTypescript = false;
     globalThisVar;
     uniqueNameCounter = 0;
     // visitor
@@ -25,14 +26,18 @@ export class CodeGenerator {
     isGeneratorFunction = isGeneratorFunction;
     isAsyncFunction = isAsyncFunction;
     prepareScopeSymbolsForVisit = prepareScopeSymbolsForVisit;
-    markSymbolAsChecked = markSymbolAsChecked;
+    markSymbolAsInitialized = markSymbolAsInitialized;
+    isFunctionUsedAsValue = isFunctionUsedAsValue;
+    isFunctionUsedBeforeDeclaration = isFunctionUsedBeforeDeclaration;
     // function handlers
     generateLambda = generateLambda;
+    generateFullLambdaExpression = generateFullLambdaExpression;
     /**
      * Main entry point for the code generation process.
      */
-    generate(ast, analyzer) {
+    generate(ast, analyzer, isTypescript) {
         this.typeAnalyzer = analyzer;
+        this.isTypescript = isTypescript;
         this.globalThisVar = this.generateUniqueName("__this_val__", this.getDeclaredSymbols(ast));
         const declarations = `#include "index.hpp"\n\n`;
         let containerCode = `jspp::JsPromise ${MODULE_NAME}() {\n`;
@@ -40,11 +45,12 @@ export class CodeGenerator {
         containerCode +=
             `${this.indent()}jspp::AnyValue ${this.globalThisVar} = global;\n`;
         containerCode += this.visit(ast, {
+            currentScopeNode: ast,
             isMainContext: true,
             isInsideFunction: true,
             isFunctionBody: true,
             isInsideAsyncFunction: true,
-            topLevelScopeSymbols: new DeclaredSymbols(),
+            globalScopeSymbols: new DeclaredSymbols(),
             localScopeSymbols: new DeclaredSymbols(),
         });
         this.indentationLevel--;
@@ -64,10 +70,10 @@ export class CodeGenerator {
         mainCode += `    jspp::Scheduler::instance().run();\n`;
         mainCode += `  } catch (const std::exception& ex) {\n`;
         mainCode +=
-            "    auto error = std::make_shared<jspp::AnyValue>(jspp::Exception::exception_to_any_value(ex));\n    {\n";
+            "    auto error = std::make_shared<jspp::AnyValue>(jspp::Exception::exception_to_any_value(ex));\n";
         mainCode +=
-            `      console.call_own_property("error", std::span<const jspp::AnyValue>((const jspp::AnyValue[]){*error}, 1));\n`;
-        mainCode += `      return 1;\n    }\n`;
+            `    console.call_own_property("error", std::span<const jspp::AnyValue>((const jspp::AnyValue[]){*error}, 1));\n`;
+        mainCode += `    return 1;\n`;
         mainCode += `  }\n`;
         mainCode += "  return 0;\n}";
         return declarations + containerCode + mainCode;