@ugo-studio/jspp 0.2.6 → 0.2.8

package/dist/analysis/typeAnalyzer.js

@@ -3,6 +3,41 @@ import { isBuiltinObject, shouldIgnoreStatement, } from "../core/codegen/helpers
 import { CompilerError } from "../core/error.js";
 import { Traverser } from "../core/traverser.js";
 import { Scope, ScopeManager } from "./scope.js";
+function getParameterType(node) {
+    if (node.type) {
+        switch (node.type.kind) {
+            case ts.SyntaxKind.StringKeyword:
+                return "string";
+            case ts.SyntaxKind.NumberKeyword:
+                return "number";
+            case ts.SyntaxKind.BooleanKeyword:
+                return "boolean";
+            case ts.SyntaxKind.AnyKeyword:
+                return "any";
+            case ts.SyntaxKind.VoidKeyword:
+                return "void";
+            case ts.SyntaxKind.ObjectKeyword:
+                return "object";
+            case ts.SyntaxKind.SymbolKeyword:
+                return "symbol";
+            case ts.SyntaxKind.UndefinedKeyword:
+                return "undefined";
+            case ts.SyntaxKind.UnknownKeyword:
+                return "unknown";
+            case ts.SyntaxKind.NeverKeyword:
+                return "never";
+            case ts.SyntaxKind.ArrayType:
+                return "array";
+            case ts.SyntaxKind.FunctionType:
+                return "function";
+        }
+        if (ts.isTypeReferenceNode(node.type)) {
+            return node.type.typeName.getText();
+        }
+        return node.type.getText();
+    }
+    return "auto";
+}
 export class TypeAnalyzer {
     traverser = new Traverser();
     scopeManager = new ScopeManager();
@@ -206,18 +241,17 @@ export class TypeAnalyzer {
                         this.functionTypeInfo.set(node, funcType);
                         this.scopeManager.enterScope(node);
                         this.nodeToScope.set(node, this.scopeManager.currentScope);
-                        // Catch invalid parameters
+                        // Define parameters in the new scope
                         node.parameters.forEach((p) => {
-                            if (p.getText() == "this") {
+                            if (p.getText() == "this") { // Catch invalid parameters
                                 throw new CompilerError("Cannot use 'this' as a parameter name.", p, "SyntaxError");
                             }
+                            this.scopeManager.define(p.name.getText(), {
+                                type: getParameterType(p),
+                                isParameter: true,
+                                declaration: p,
+                            });
                         });
-                        // Define parameters in the new scope
-                        node.parameters.forEach((p) => this.scopeManager.define(p.name.getText(), {
-                            type: "auto",
-                            isParameter: true,
-                            declaration: p,
-                        }));
                         this.functionStack.push(node);
                     }
                 },
@@ -245,18 +279,17 @@ export class TypeAnalyzer {
                         if (node.name) {
                             this.scopeManager.define(node.name.getText(), funcType);
                         }
-                        // Catch invalid parameters
+                        // Define parameters in the new scope
                         node.parameters.forEach((p) => {
-                            if (p.getText() == "this") {
+                            if (p.getText() == "this") { // Catch invalid parameters
                                 throw new CompilerError("Cannot use 'this' as a parameter name.", p, "SyntaxError");
                             }
+                            this.scopeManager.define(p.name.getText(), {
+                                type: getParameterType(p),
+                                isParameter: true,
+                                declaration: p,
+                            });
                         });
-                        // Define parameters in the new scope
-                        node.parameters.forEach((p) => this.scopeManager.define(p.name.getText(), {
-                            type: "auto",
-                            isParameter: true,
-                            declaration: p,
-                        }));
                         this.functionStack.push(node);
                     }
                 },
@@ -285,18 +318,17 @@ export class TypeAnalyzer {
                         }
                         this.scopeManager.enterScope(node);
                         this.nodeToScope.set(node, this.scopeManager.currentScope);
-                        // Catch invalid parameters
+                        // Define parameters in the new scope
                         node.parameters.forEach((p) => {
-                            if (p.getText() == "this") {
+                            if (p.getText() == "this") { // Catch invalid parameters
                                 throw new CompilerError("Cannot use 'this' as a parameter name.", p, "SyntaxError");
                             }
+                            this.scopeManager.define(p.name.getText(), {
+                                type: getParameterType(p),
+                                isParameter: true,
+                                declaration: p,
+                            });
                         });
-                        // Define parameters in the new scope
-                        node.parameters.forEach((p) => this.scopeManager.define(p.name.getText(), {
-                            type: "auto",
-                            isParameter: true,
-                            declaration: p,
-                        }));
                         this.functionStack.push(node);
                     }
                 },

package/dist/ast/symbols.js

@@ -10,13 +10,11 @@ export var DeclarationType;
 export class DeclaredSymbol {
     type;
     checks;
-    func;
+    features;
     constructor(type) {
         this.type = type;
-        this.checks = {
-            initialized: false,
-        };
-        this.func = null;
+        this.checks = { initialized: false };
+        this.features = {};
     }
     get isMutable() {
         return this.type === DeclarationType.let ||
@@ -28,13 +26,11 @@ export class DeclaredSymbol {
             ...update,
         };
     }
-    updateFunc(update) {
-        this.func = update
-            ? {
-                ...this.func,
-                ...update,
-            }
-            : null;
+    updateFeatures(update) {
+        this.features = {
+            ...this.features,
+            ...update,
+        };
     }
 }
 export class DeclaredSymbols {
@@ -54,21 +50,34 @@ export class DeclaredSymbols {
     }
     add(name, value) {
         const sym = new DeclaredSymbol(value.type);
-        if (value.checks !== undefined)
+        if (value.checks)
             sym.updateChecked(value.checks);
-        if (value.func !== undefined)
-            sym.updateFunc(value.func);
+        if (value.features)
+            sym.updateFeatures(value.features);
         return this.symbols.set(name, sym);
     }
     update(name, update) {
         const sym = this.get(name);
         if (sym) {
-            if (update.type !== undefined)
+            if (update.type)
                 sym.type = update.type;
-            if (update.checks !== undefined)
+            if (update.checks)
                 sym.updateChecked(update.checks);
-            if (update.func !== undefined)
-                sym.updateFunc(update.func);
+            if (update.features) {
+                sym.updateFeatures(update.features);
+            }
+            return this.symbols.set(name, sym);
+        }
+    }
+    set(name, update) {
+        const sym = this.get(name);
+        if (sym) {
+            if (update.type)
+                sym.type = update.type;
+            if (update.checks)
+                sym.checks = update.checks;
+            if (update.features)
+                sym.features = update.features;
             return this.symbols.set(name, sym);
         }
     }

package/dist/cli/index.js

@@ -3,8 +3,8 @@ import { spawn } from "child_process";
 import fs from "fs/promises";
 import path from "path";
 import pkg from "../../package.json" with { type: "json" };
-import { Interpreter } from "../index.js";
 import { CompilerError } from "../core/error.js";
+import { Interpreter } from "../index.js";
 import { parseArgs } from "./args.js";
 import { COLORS } from "./colors.js";
 import { getLatestMtime } from "./file-utils.js";

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

@@ -32,11 +32,11 @@ export function visitClassDeclaration(node, context) {
     const constructor = node.members.find(ts.isConstructorDeclaration);
     let constructorLambda = "";
     if (constructor) {
-        constructorLambda = this.generateLambda(constructor, {
+        constructorLambda = this.generateWrappedLambda(this.generateLambdaComponents(constructor, {
             ...classContext,
             isInsideFunction: true,
             lambdaName: className,
-        }, { isClass: true });
+        }, { isClass: true }));
     }
     else {
         // Default constructor
@@ -75,10 +75,10 @@ export function visitClassDeclaration(node, context) {
                 isObjectLiteralExpression: true, // Reuse this flag to handle computed properties
             });
             const isStatic = member.modifiers?.some((m) => m.kind === ts.SyntaxKind.StaticKeyword);
-            const methodLambda = this.generateLambda(member, {
+            const methodLambda = this.generateWrappedLambda(this.generateLambdaComponents(member, {
                 ...classContext,
                 isInsideFunction: true,
-            });
+            }));
             if (isStatic) {
                 code +=
                     `${this.indent()}(*${className}).set_own_property(${methodName}, ${methodLambda});\n`;
@@ -94,10 +94,10 @@ export function visitClassDeclaration(node, context) {
                 isObjectLiteralExpression: true,
             });
             const isStatic = member.modifiers?.some((m) => m.kind === ts.SyntaxKind.StaticKeyword);
-            const lambda = this.generateLambda(member, {
+            const lambda = this.generateWrappedLambda(this.generateLambdaComponents(member, {
                 ...classContext,
                 isInsideFunction: true,
-            });
+            }));
             if (isStatic) {
                 code +=
                     `${this.indent()}(*${className}).define_getter(${methodName}, ${lambda});\n`;
@@ -113,10 +113,10 @@ export function visitClassDeclaration(node, context) {
                 isObjectLiteralExpression: true,
             });
             const isStatic = member.modifiers?.some((m) => m.kind === ts.SyntaxKind.StaticKeyword);
-            const lambda = this.generateLambda(member, {
+            const lambda = this.generateWrappedLambda(this.generateLambdaComponents(member, {
                 ...classContext,
                 isInsideFunction: true,
-            });
+            }));
             if (isStatic) {
                 code +=
                     `${this.indent()}(*${className}).define_setter(${methodName}, ${lambda});\n`;

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

@@ -440,19 +440,29 @@ export function visitSwitchStatement(node, context) {
         this.markSymbolAsInitialized(funcName, globalScopeSymbols, localScopeSymbols);
         // Generate native name
         const nativeName = this.generateUniqueName(`__${funcName}_native_`, hoistedSymbols);
-        hoistedSymbols.update(funcName, { func: { nativeName } });
-        // Generate lambda
-        const lambda = this.generateLambda(stmt, contextForFunctions, {
+        hoistedSymbols.update(funcName, {
+            features: {
+                native: {
+                    type: "lambda",
+                    name: nativeName,
+                    parameters: this.validateFunctionParams(stmt.parameters),
+                },
+            },
+        });
+        // Generate lambda components
+        const lambdaComps = this.generateLambdaComponents(stmt, contextForFunctions, {
             isAssignment: true,
-            generateOnlyLambda: true,
             nativeName,
+            noTypeSignature: true,
         });
-        code += `${this.indent()}auto ${nativeName} = ${lambda};\n`;
+        // Generate native lambda
+        const nativeLambda = this.generateNativeLambda(lambdaComps);
+        code += `${this.indent()}auto ${nativeName} = ${nativeLambda};\n`;
         // Generate AnyValue wrapper
         if (this.isFunctionUsedAsValue(stmt, node) ||
             this.isFunctionUsedBeforeDeclaration(funcName, node)) {
-            const fullExpression = this.generateFullLambdaExpression(stmt, contextForFunctions, nativeName, { isAssignment: true, noTypeSignature: true });
-            code += `${this.indent()}*${funcName} = ${fullExpression};\n`;
+            const wrappedLambda = this.generateWrappedLambda(lambdaComps);
+            code += `${this.indent()}*${funcName} = ${wrappedLambda};\n`;
         }
     });
     let firstIf = true;

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

@@ -38,24 +38,34 @@ export function visitVariableDeclaration(node, context) {
                 initText = this.getDerefCode(initText, varName, context, initTypeInfo);
             }
         }
-        else if (ts.isArrowFunction(initExpr)) {
+        else if (ts.isArrowFunction(initExpr) ||
+            (ts.isFunctionExpression(initExpr) && !initExpr.name)) {
             const initContext = {
                 ...context,
                 lambdaName: name, // Use the variable name as function name
             };
-            // Generate and update self name
             const nativeName = this.generateUniqueName(`__${name}_native_`, context.localScopeSymbols, context.globalScopeSymbols);
-            context.localScopeSymbols.update(name, { func: { nativeName } });
-            // Generate lambda
-            const lambda = this.generateLambda(initExpr, initContext, {
+            // Mark before further visits
+            context.localScopeSymbols.update(name, {
+                features: {
+                    native: {
+                        type: "lambda",
+                        name: nativeName,
+                        parameters: this.validateFunctionParams(initExpr.parameters),
+                    },
+                },
+            });
+            // Generate lambda components
+            const lambdaComps = this.generateLambdaComponents(initExpr, initContext, {
                 isAssignment: true,
-                generateOnlyLambda: true,
                 nativeName,
+                noTypeSignature: true,
             });
-            nativeLambdaCode =
-                `auto ${nativeName} = ${lambda};\n${this.indent()}`;
+            const nativeLambda = this.generateNativeLambda(lambdaComps);
+            // Generate native lambda
+            nativeLambdaCode = `auto ${nativeName} = ${nativeLambda}`;
             // Generate AnyValue wrapper
-            initText = this.generateFullLambdaExpression(initExpr, initContext, nativeName, { isAssignment: true, noTypeSignature: true });
+            initText = this.generateWrappedLambda(lambdaComps);
         }
         initializer = " = " + initText;
     }
@@ -67,6 +77,8 @@ export function visitVariableDeclaration(node, context) {
         : (typeInfo.needsHeapAllocation && !shouldSkipDeref
             ? `*${name}`
             : name);
+    if (nativeLambdaCode)
+        nativeLambdaCode += `;\n${this.indent()}`;
     if (isLetOrConst) {
         // If there's no initializer, it should be assigned undefined.
         if (!initializer) {