@ugo-studio/jspp 0.2.5 → 0.2.6

package/dist/cli/spinner.js

@@ -0,0 +1,55 @@
+import { COLORS } from "./colors.js";
+export class Spinner {
+    frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+    interval = null;
+    frameIndex = 0;
+    text;
+    constructor(text) {
+        this.text = text;
+    }
+    start() {
+        process.stdout.write("\x1b[?25l"); // Hide cursor
+        this.frameIndex = 0;
+        this.render();
+        this.interval = setInterval(() => {
+            this.frameIndex = (this.frameIndex + 1) % this.frames.length;
+            this.render();
+        }, 80);
+    }
+    update(text) {
+        this.text = text;
+        this.render();
+    }
+    stop(symbol = "", color = COLORS.reset) {
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = null;
+        }
+        this.clearLine();
+        process.stdout.write(`${color}${symbol} ${COLORS.reset} ${this.text}\n`);
+        process.stdout.write("\x1b[?25h"); // Show cursor
+    }
+    succeed(text) {
+        if (text)
+            this.text = text;
+        this.stop("✔", COLORS.green);
+    }
+    fail(text) {
+        if (text)
+            this.text = text;
+        this.stop("✖", COLORS.red);
+    }
+    info(text) {
+        if (text)
+            this.text = text;
+        this.stop("ℹ", COLORS.cyan);
+    }
+    render() {
+        this.clearLine();
+        const frame = this.frames[this.frameIndex];
+        process.stdout.write(`${COLORS.cyan}${frame} ${COLORS.reset} ${this.text}`);
+    }
+    clearLine() {
+        process.stdout.write("\r\x1b[K");
+    }
+}

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

@@ -44,11 +44,11 @@ export function visitForStatement(node, context) {
                         : DeclarationType.const;
                     conditionContext.localScopeSymbols.add(name, {
                         type: declType,
-                        checked: { initialized: true },
+                        checks: { initialized: true },
                     });
                     statementContext.localScopeSymbols.add(name, {
                         type: declType,
-                        checked: { initialized: true },
+                        checks: { initialized: true },
                     });
                     if (typeInfo.needsHeapAllocation) {
                         initializerCode =

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

@@ -1,4 +1,5 @@
 import ts from "typescript";
+import { CompilerError } from "../error.js";
 import { CodeGenerator } from "./index.js";
 export function visitVariableDeclarationList(node, context) {
     return node.declarations
@@ -69,7 +70,14 @@ export function visitVariableDeclaration(node, context) {
     if (isLetOrConst) {
         // If there's no initializer, it should be assigned undefined.
         if (!initializer) {
-            return `${nativeLambdaCode}${assignmentTarget} = jspp::Constants::UNDEFINED`;
+            // Constant variables must be initialized
+            const isConst = (varDecl.parent.flags & (ts.NodeFlags.Const)) !== 0;
+            if (isConst) {
+                throw new CompilerError(`The constant "${name}" must be initialized`, varDecl, "SyntaxError");
+            }
+            else {
+                return `${nativeLambdaCode}${assignmentTarget} = jspp::Constants::UNDEFINED`;
+            }
         }
         return `${nativeLambdaCode}${assignmentTarget}${initializer}`;
     }

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

@@ -1,4 +1,6 @@
 import ts from "typescript";
+import { constants } from "../constants.js";
+import { CompilerError } from "../error.js";
 import { CodeGenerator } from "./index.js";
 export function visitObjectPropertyName(node, context) {
     if (ts.isNumericLiteral(node)) {
@@ -190,7 +192,7 @@ export function visitPropertyAccessExpression(node, context) {
     const propAccess = node;
     if (propAccess.expression.kind === ts.SyntaxKind.SuperKeyword) {
         if (!context.superClassVar) {
-            throw new Error("super.prop accessed but no super class variable found in context");
+            throw new CompilerError("super.prop accessed but no super class variable found in context", propAccess.expression, "SyntaxError");
         }
         const propName = propAccess.name.getText();
         return `jspp::AnyValue::resolve_property_for_read((${context.superClassVar}).get_own_property("prototype").get_own_property("${propName}"), ${this.globalThisVar}, "${this.escapeString(propName)}")`;
@@ -258,7 +260,11 @@ export function visitElementAccessExpression(node, context) {
 export function visitBinaryExpression(node, context) {
     const binExpr = node;
     const opToken = binExpr.operatorToken;
-    let op = opToken.getText();
+    const op = opToken.getText();
+    const visitContext = {
+        ...context,
+        supportedNativeLiterals: undefined,
+    };
     const assignmentOperators = [
         ts.SyntaxKind.PlusEqualsToken,
         ts.SyntaxKind.MinusEqualsToken,
@@ -279,8 +285,8 @@ export function visitBinaryExpression(node, context) {
     if (assignmentOperators.includes(opToken.kind)) {
         if (opToken.kind ===
             ts.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken) {
-            const leftText = this.visit(binExpr.left, context);
-            const rightText = this.visit(binExpr.right, context);
+            const leftText = this.visit(binExpr.left, visitContext);
+            const rightText = this.visit(binExpr.right, visitContext);
             let target = leftText;
             if (ts.isIdentifier(binExpr.left)) {
                 const scope = this.getScopeForNode(binExpr.left);
@@ -292,8 +298,8 @@ export function visitBinaryExpression(node, context) {
             }
         }
         if (opToken.kind === ts.SyntaxKind.AsteriskAsteriskEqualsToken) {
-            const leftText = this.visit(binExpr.left, context);
-            const rightText = this.visit(binExpr.right, context);
+            const leftText = this.visit(binExpr.left, visitContext);
+            const rightText = this.visit(binExpr.right, visitContext);
             let target = leftText;
             if (ts.isIdentifier(binExpr.left)) {
                 const scope = this.getScopeForNode(binExpr.left);
@@ -308,8 +314,8 @@ export function visitBinaryExpression(node, context) {
         if (opToken.kind === ts.SyntaxKind.AmpersandAmpersandEqualsToken ||
             opToken.kind === ts.SyntaxKind.BarBarEqualsToken ||
             opToken.kind === ts.SyntaxKind.QuestionQuestionEqualsToken) {
-            const leftText = this.visit(binExpr.left, context);
-            const rightText = this.visit(binExpr.right, context);
+            const leftText = this.visit(binExpr.left, visitContext);
+            const rightText = this.visit(binExpr.right, visitContext);
             let target = leftText;
             if (ts.isIdentifier(binExpr.left)) {
                 const scope = this.getScopeForNode(binExpr.left);
@@ -328,21 +334,21 @@ export function visitBinaryExpression(node, context) {
                 }
             }
         }
-        const leftText = this.visit(binExpr.left, context);
+        const leftText = this.visit(binExpr.left, visitContext);
         let rightText = ts.isNumericLiteral(binExpr.right)
             ? binExpr.right.getText()
-            : this.visit(binExpr.right, context);
+            : this.visit(binExpr.right, visitContext);
         if (ts.isIdentifier(binExpr.right)) {
             const scope = this.getScopeForNode(binExpr.right);
             const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(binExpr.right.getText(), scope);
-            rightText = this.getDerefCode(rightText, this.getJsVarName(binExpr.right), context, typeInfo);
+            rightText = this.getDerefCode(rightText, this.getJsVarName(binExpr.right), visitContext, typeInfo);
         }
         let target = leftText;
         if (ts.isIdentifier(binExpr.left)) {
             const scope = this.getScopeForNode(binExpr.left);
             const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(binExpr.left.getText(), scope);
             if (context.derefBeforeAssignment) {
-                target = this.getDerefCode(leftText, leftText, context, typeInfo);
+                target = this.getDerefCode(leftText, leftText, visitContext, typeInfo);
             }
             else if (typeInfo.needsHeapAllocation) {
                 target = `*${leftText}`;
@@ -350,8 +356,9 @@ export function visitBinaryExpression(node, context) {
         }
         return `${target} ${op} ${rightText}`;
     }
+    // Assignment expression `a = 1`
     if (opToken.kind === ts.SyntaxKind.EqualsToken) {
-        let rightText = this.visit(binExpr.right, context);
+        let rightText = this.visit(binExpr.right, visitContext);
         if (ts.isPropertyAccessExpression(binExpr.left)) {
             const propAccess = binExpr.left;
             if (propAccess.expression.kind === ts.SyntaxKind.SuperKeyword) {
@@ -365,13 +372,13 @@ export function visitBinaryExpression(node, context) {
                     if (rightTypeInfo &&
                         !rightTypeInfo.isParameter &&
                         !rightTypeInfo.isBuiltin) {
-                        finalRightText = this.getDerefCode(rightText, this.getJsVarName(binExpr.right), context, rightTypeInfo);
+                        finalRightText = this.getDerefCode(rightText, this.getJsVarName(binExpr.right), visitContext, rightTypeInfo);
                     }
                 }
                 // Approximate super assignment as setting property on 'this'
                 return `(${this.globalThisVar}).set_own_property("${propName}", ${finalRightText})`;
             }
-            const objExprText = this.visit(propAccess.expression, context);
+            const objExprText = this.visit(propAccess.expression, visitContext);
             const propName = propAccess.name.getText();
             let finalObjExpr = objExprText;
             if (ts.isIdentifier(propAccess.expression)) {
@@ -396,14 +403,14 @@ export function visitBinaryExpression(node, context) {
         }
         else if (ts.isElementAccessExpression(binExpr.left)) {
             const elemAccess = binExpr.left;
-            const objExprText = this.visit(elemAccess.expression, context);
-            let argText = visitObjectPropertyName.call(this, elemAccess.argumentExpression, { ...context, isBracketNotationPropertyAccess: true });
+            const objExprText = this.visit(elemAccess.expression, visitContext);
+            let argText = visitObjectPropertyName.call(this, elemAccess.argumentExpression, { ...visitContext, isBracketNotationPropertyAccess: true });
             let finalObjExpr = objExprText;
             if (ts.isIdentifier(elemAccess.expression)) {
                 const scope = this.getScopeForNode(elemAccess.expression);
                 const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(elemAccess.expression.getText(), scope);
                 if (typeInfo && !typeInfo.isParameter && !typeInfo.isBuiltin) {
-                    finalObjExpr = this.getDerefCode(objExprText, this.getJsVarName(elemAccess.expression), context, typeInfo);
+                    finalObjExpr = this.getDerefCode(objExprText, this.getJsVarName(elemAccess.expression), visitContext, typeInfo);
                 }
             }
             if (ts.isIdentifier(elemAccess.argumentExpression)) {
@@ -413,7 +420,7 @@ export function visitBinaryExpression(node, context) {
                 if (argTypeInfo &&
                     !argTypeInfo.isParameter &&
                     !argTypeInfo.isBuiltin) {
-                    argText = this.getDerefCode(argText, this.getJsVarName(elemAccess.argumentExpression), context, argTypeInfo);
+                    argText = this.getDerefCode(argText, this.getJsVarName(elemAccess.argumentExpression), visitContext, argTypeInfo);
                 }
             }
             let finalRightText = rightText;
@@ -424,12 +431,12 @@ export function visitBinaryExpression(node, context) {
                 if (rightTypeInfo &&
                     !rightTypeInfo.isParameter &&
                     !rightTypeInfo.isBuiltin) {
-                    finalRightText = this.getDerefCode(rightText, this.getJsVarName(binExpr.right), context, rightTypeInfo);
+                    finalRightText = this.getDerefCode(rightText, this.getJsVarName(binExpr.right), visitContext, rightTypeInfo);
                 }
             }
             return `${finalObjExpr}.set_own_property(${argText}, ${finalRightText})`;
         }
-        const leftText = this.visit(binExpr.left, context);
+        const leftText = this.visit(binExpr.left, visitContext);
         const scope = this.getScopeForNode(binExpr.left);
         const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(binExpr.left.text, scope);
         if (!typeInfo && !this.isBuiltinObject(binExpr.left)) {
@@ -442,7 +449,7 @@ export function visitBinaryExpression(node, context) {
             rightText = binExpr.right.getText();
         }
         const target = context.derefBeforeAssignment
-            ? this.getDerefCode(leftText, leftText, context, typeInfo)
+            ? this.getDerefCode(leftText, leftText, visitContext, typeInfo)
             : (typeInfo.needsHeapAllocation ? `*${leftText}` : leftText);
         // Update scope symbols on variable re-assignment
         if (ts.isIdentifier(binExpr.left)) {
@@ -461,8 +468,9 @@ export function visitBinaryExpression(node, context) {
         }
         return `${target} ${op} ${rightText}`;
     }
-    const leftText = this.visit(binExpr.left, context);
-    const rightText = this.visit(binExpr.right, context);
+    const leftText = this.visit(binExpr.left, visitContext);
+    const rightText = this.visit(binExpr.right, visitContext);
+    // Generate lhs and rhs code
     let finalLeft = leftText;
     if (ts.isIdentifier(binExpr.left)) {
         const scope = this.getScopeForNode(binExpr.left);
@@ -471,7 +479,7 @@ export function visitBinaryExpression(node, context) {
             return `jspp::Exception::throw_unresolved_reference(${this.getJsVarName(binExpr.left)})`;
         }
         if (typeInfo && !typeInfo.isParameter && !typeInfo.isBuiltin) {
-            finalLeft = this.getDerefCode(leftText, this.getJsVarName(binExpr.left), context, typeInfo);
+            finalLeft = this.getDerefCode(leftText, this.getJsVarName(binExpr.left), visitContext, typeInfo);
         }
     }
     let finalRight = rightText;
@@ -483,7 +491,7 @@ export function visitBinaryExpression(node, context) {
             return `jspp::Exception::throw_unresolved_reference(${this.getJsVarName(binExpr.right)})`;
         }
         if (typeInfo && !typeInfo.isParameter && !typeInfo.isBuiltin) {
-            finalRight = this.getDerefCode(rightText, this.getJsVarName(binExpr.right), context, typeInfo);
+            finalRight = this.getDerefCode(rightText, this.getJsVarName(binExpr.right), visitContext, typeInfo);
         }
     }
     if (opToken.kind === ts.SyntaxKind.InKeyword) {
@@ -501,35 +509,63 @@ export function visitBinaryExpression(node, context) {
     if (opToken.kind === ts.SyntaxKind.QuestionQuestionToken) {
         return `jspp::nullish_coalesce(${finalLeft}, ${finalRight})`;
     }
-    // Optimizations to prevent calling make_number multiple times
-    if (ts.isNumericLiteral(binExpr.left)) {
-        finalLeft = binExpr.left.getText();
-    }
-    if (ts.isNumericLiteral(binExpr.right)) {
-        finalRight = binExpr.right.getText();
-    }
+    const isLiteral = (n) => ts.isNumericLiteral(n);
+    const supportsNativeBoolean = context.supportedNativeLiterals?.includes("boolean") || false;
+    // Native values for lhs and rhs
+    const literalLeft = isLiteral(binExpr.left)
+        ? binExpr.left.getText()
+        : finalLeft;
+    const literalRight = isLiteral(binExpr.right)
+        ? binExpr.right.getText()
+        : finalRight;
+    // Operations that returns boolean should return the native boolean if supported
+    if (constants.booleanOperators.includes(opToken.kind) &&
+        supportsNativeBoolean) {
+        if (opToken.kind === ts.SyntaxKind.EqualsEqualsEqualsToken) {
+            return `jspp::is_strictly_equal_to_primitive(${literalLeft}, ${literalRight})`;
+        }
+        if (opToken.kind === ts.SyntaxKind.EqualsEqualsToken) {
+            return `jspp::is_equal_to_primitive(${literalLeft}, ${literalRight})`;
+        }
+        if (opToken.kind === ts.SyntaxKind.ExclamationEqualsEqualsToken) {
+            return `!jspp::is_strictly_equal_to_primitive(${literalLeft}, ${literalRight})`;
+        }
+        if (opToken.kind === ts.SyntaxKind.ExclamationEqualsToken) {
+            return `!jspp::is_equal_to_primitive(${literalLeft}, ${literalRight})`;
+        }
+        if (isLiteral(binExpr.left) && isLiteral(binExpr.right)) {
+            return `(${literalLeft} ${op} ${literalRight})`;
+        }
+        else
+            return `(${literalLeft} ${op} ${literalRight}).as_boolean()`;
+    }
+    // Return boxed value
     if (opToken.kind === ts.SyntaxKind.EqualsEqualsEqualsToken) {
-        return `jspp::is_strictly_equal_to(${finalLeft}, ${finalRight})`;
+        return `jspp::is_strictly_equal_to(${literalLeft}, ${literalRight})`;
     }
     if (opToken.kind === ts.SyntaxKind.EqualsEqualsToken) {
-        return `jspp::is_equal_to(${finalLeft}, ${finalRight})`;
+        return `jspp::is_equal_to(${literalLeft}, ${literalRight})`;
     }
     if (opToken.kind === ts.SyntaxKind.ExclamationEqualsEqualsToken) {
-        return `jspp::not_strictly_equal_to(${finalLeft}, ${finalRight})`;
+        return `jspp::not_strictly_equal_to(${literalLeft}, ${literalRight})`;
     }
     if (opToken.kind === ts.SyntaxKind.ExclamationEqualsToken) {
-        return `jspp::not_equal_to(${finalLeft}, ${finalRight})`;
+        return `jspp::not_equal_to(${literalLeft}, ${literalRight})`;
     }
     if (opToken.kind === ts.SyntaxKind.AsteriskAsteriskToken) {
-        return `jspp::pow(${finalLeft}, ${finalRight})`;
+        return `jspp::pow(${literalLeft}, ${literalRight})`;
     }
     if (opToken.kind === ts.SyntaxKind.GreaterThanGreaterThanGreaterThanToken) {
-        return `jspp::unsigned_right_shift(${finalLeft}, ${finalRight})`;
+        return `jspp::unsigned_right_shift(${literalLeft}, ${literalRight})`;
+    }
+    // Use literal for at most one side
+    if (isLiteral(binExpr.left)) {
+        finalLeft = binExpr.left.getText();
     }
-    // Optimizations to prevent calling make_number multiple times
-    if (ts.isNumericLiteral(binExpr.left) && ts.isNumericLiteral(binExpr.right)) {
-        return `jspp::AnyValue::make_number(${finalLeft} ${op} ${finalRight})`;
+    else if (isLiteral(binExpr.right)) {
+        finalRight = binExpr.right.getText();
     }
+    // For other arithmetic and bitwise operations, use native operations if possible
     if (op === "+" ||
         op === "-" ||
         op === "*" ||
@@ -546,7 +582,12 @@ export function visitBinaryExpression(node, context) {
 }
 export function visitConditionalExpression(node, context) {
     const condExpr = node;
-    const condition = this.visit(condExpr.condition, context);
+    const isBinaryExpression = ts.isBinaryExpression(condExpr.condition) &&
+        constants.booleanOperators.includes(condExpr.condition.operatorToken.kind);
+    const condition = this.visit(condExpr.condition, {
+        ...context,
+        supportedNativeLiterals: isBinaryExpression ? ["boolean"] : undefined,
+    });
     const whenTrueStmt = this.visit(condExpr.whenTrue, {
         ...context,
         isFunctionBody: false,
@@ -555,6 +596,9 @@ export function visitConditionalExpression(node, context) {
         ...context,
         isFunctionBody: false,
     });
+    if (isBinaryExpression) {
+        return `${condition} ? ${whenTrueStmt} : ${whenFalseStmt}`;
+    }
     return `jspp::is_truthy(${condition}) ? ${whenTrueStmt} : ${whenFalseStmt}`;
 }
 export function visitCallExpression(node, context) {
@@ -562,7 +606,7 @@ export function visitCallExpression(node, context) {
     const callee = callExpr.expression;
     if (callee.kind === ts.SyntaxKind.SuperKeyword) {
         if (!context.superClassVar) {
-            throw new Error("super() called but no super class variable found in context");
+            throw new CompilerError("super() called but no super class variable found in context", callee, "SyntaxError");
         }
         const args = callExpr.arguments.map((arg) => this.visit(arg, context))
             .join(", ");
@@ -593,7 +637,7 @@ export function visitCallExpression(node, context) {
         const propAccess = callee;
         if (propAccess.expression.kind === ts.SyntaxKind.SuperKeyword) {
             if (!context.superClassVar) {
-                throw new Error("super.method() called but no super class variable found in context");
+                throw new CompilerError("super.method() called but no super class variable found in context", propAccess.expression, "SyntaxError");
             }
             const propName = propAccess.name.getText();
             return `(${context.superClassVar}).get_own_property("prototype").get_own_property("${propName}").call(${this.globalThisVar}, ${argsSpan}, "${this.escapeString(propName)}")`;
@@ -827,3 +871,15 @@ export function visitDeleteExpression(node, context) {
     }
     return "jspp::Constants::TRUE"; // delete on non-property is true in JS
 }
+export function visitAsExpression(node, context) {
+    return this.visit(node.expression, context);
+}
+export function visitTypeAssertionExpression(node, context) {
+    return this.visit(node.expression, context);
+}
+export function visitNonNullExpression(node, context) {
+    return this.visit(node.expression, context);
+}
+export function visitSatisfiesExpression(node, context) {
+    return this.visit(node.expression, context);
+}

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

@@ -1,5 +1,6 @@
 import ts from "typescript";
-import { DeclaredSymbols } from "../../ast/symbols.js";
+import { DeclarationType, DeclaredSymbols } from "../../ast/symbols.js";
+import { CompilerError } from "../error.js";
 import { collectFunctionScopedDeclarations } from "./helpers.js";
 import { CodeGenerator } from "./index.js";
 export function generateLambda(node, context, options) {
@@ -84,17 +85,27 @@ export function generateLambda(node, context, options) {
     // So subsequent code using `argsName` and `visit` (using `globalThisVar`) works correctly.
     const paramExtractor = (parameters) => {
         let code = "";
-        parameters.forEach((p, i) => {
+        parameters.filter((p) => this.isTypescript && p.name.getText() === "this" ? false : true // Ignore "this" parameters
+        ).forEach((p, i) => {
             const name = p.name.getText();
             const defaultValue = p.initializer
                 ? this.visit(p.initializer, visitContext)
                 : "jspp::Constants::UNDEFINED";
+            // Catch invalid parameters
+            if (name === "this") {
+                throw new CompilerError(`Cannot use '${name}' as a parameter name.`, p, "SyntaxError");
+            }
+            // Add paramerter to local context
+            visitContext.localScopeSymbols.add(name, {
+                type: DeclarationType.let,
+                checks: { initialized: true },
+            });
             const scope = this.getScopeForNode(p);
             const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(name, scope);
             // Handle rest parameters
             if (!!p.dotDotDotToken) {
                 if (parameters.length - 1 !== i) {
-                    throw new SyntaxError("Rest parameter must be last formal parameter.");
+                    throw new CompilerError("Rest parameter must be last formal parameter.", p, "SyntaxError");
                 }
                 if (typeInfo.needsHeapAllocation) {
                     code +=

package/dist/core/codegen/helpers.js

@@ -1,6 +1,7 @@
 import ts from "typescript";
 import { BUILTIN_OBJECTS, Scope } from "../../analysis/scope.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;
 }
@@ -88,7 +93,7 @@ export function getDerefCode(nodeText, varName, context, typeInfo) {
     const symbolName = varName.slice(1).slice(0, -1);
     const symbol = context.localScopeSymbols.get(symbolName) ??
         context.globalScopeSymbols.get(symbolName);
-    const isInitialized = symbol?.checked.initialized ||
+    const isInitialized = symbol?.checks.initialized ||
         false;
     // Mark the symbol as checked
     this.markSymbolAsInitialized(symbolName, context.globalScopeSymbols, context.localScopeSymbols);
@@ -109,12 +114,12 @@ export function getDerefCode(nodeText, varName, context, typeInfo) {
 export function markSymbolAsInitialized(name, topLevel, local) {
     if (topLevel.has(name)) {
         topLevel.update(name, {
-            checked: { initialized: true },
+            checks: { initialized: true },
         });
     }
     else if (local.has(name)) {
         local.update(name, {
-            checked: { initialized: true },
+            checks: { initialized: true },
         });
     }
 }
@@ -138,16 +143,19 @@ export function hoistDeclaration(decl, hoistedSymbols, scopeNode) {
                 ? DeclarationType.function
                 : ts.isClassDeclaration(decl)
                     ? DeclarationType.class
-                    : DeclarationType.var;
+                    : ts.isEnumDeclaration(decl)
+                        ? DeclarationType.enum
+                        : DeclarationType.var;
     if (hoistedSymbols.has(name)) {
         const existingSymbol = hoistedSymbols.get(name);
-        // Don't allow multiple declaration of `let`,`const`,`function` or `class` variables
+        // 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 SyntaxError(`Identifier '${name}' has already been declared.\n\n${" ".repeat(6) + decl.getText()}\n`);
+            throw new CompilerError(`Identifier '${name}' has already been declared.`, decl, "SyntaxError");
         }
         // `var` variables can be declared multiple times
         return "";
@@ -203,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) {
@@ -257,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) {

package/dist/core/codegen/index.js

@@ -2,10 +2,11 @@ import { DeclaredSymbols } from "../../ast/symbols.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
@@ -34,8 +35,9 @@ export class CodeGenerator {
     /**
      * 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`;
@@ -68,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;