vladx 1.3.2 → 1.5.1

package/src/interpreter/interpreter.js

@@ -59,20 +59,31 @@ class ReturnValue {
 class BreakSignal { }
 class ContinueSignal { }
 
+class VladXPromise {
+    constructor(promise) {
+        this.promise = promise;
+    }
+
+    async wait() {
+        return await this.promise;
+    }
+}
+
 class VladXFunction {
-    constructor(declaration, closure) {
+    constructor(declaration, closure, isAsync = false) {
         this.declaration = declaration;
         this.closure = closure;
+        this.isAsync = isAsync;
     }
 
-    call(interpreter, args) {
+    async call(interpreter, args) {
         const env = new Environment(this.closure);
         for (let i = 0; i < this.declaration.params.length; i++) {
             env.define(this.declaration.params[i], args[i] !== undefined ? args[i] : null);
         }
 
         try {
-            interpreter.executeBlock(this.declaration.body.body, env);
+            await interpreter.executeBlock(this.declaration.body.body, env);
         } catch (e) {
             if (e instanceof ReturnValue) {
                 return e.value;
@@ -84,13 +95,15 @@ class VladXFunction {
 }
 
 class ArrowFunc {
-    constructor(params, body, closure) {
+    constructor(params, body, closure, isAsync = false) {
         this.params = params;
         this.body = body;
         this.closure = closure;
+        this.isAsync = isAsync;
     }
+    // ... call unchanged except it returns result ...
 
-    call(interpreter, args) {
+    async call(interpreter, args) {
         const env = new Environment(this.closure);
         for (let i = 0; i < this.params.length; i++) {
             env.define(this.params[i], args[i] !== undefined ? args[i] : null);
@@ -98,7 +111,7 @@ class ArrowFunc {
 
         if (this.body.type === 'BlockStatement') {
             try {
-                interpreter.executeBlock(this.body.body, env);
+                await interpreter.executeBlock(this.body.body, env);
             } catch (e) {
                 if (e instanceof ReturnValue) {
                     return e.value;
@@ -107,11 +120,7 @@ class ArrowFunc {
             }
             return null;
         } else {
-            const previousEnv = interpreter.environment;
-            interpreter.environment = env;
-            const result = interpreter.evaluate(this.body);
-            interpreter.environment = previousEnv;
-            return result;
+            return await interpreter.evaluate(this.body, env);
         }
     }
 }
@@ -163,7 +172,11 @@ class BoundMethod {
         this.instance = instance;
     }
 
-    call(interpreter, args) {
+    get isAsync() {
+        return this.method.isAsync;
+    }
+
+    async call(interpreter, args) {
         const env = new Environment(this.method.closure);
         env.define('questo', this.instance);
         for (let i = 0; i < this.method.declaration.params.length; i++) {
@@ -171,7 +184,7 @@ class BoundMethod {
         }
 
         try {
-            interpreter.executeBlock(this.method.declaration.body.body, env);
+            await interpreter.executeBlock(this.method.declaration.body.body, env);
         } catch (e) {
             if (e instanceof ReturnValue) {
                 return e.value;
@@ -187,8 +200,11 @@ const path = require('path');
 const http = require('http');
 const https = require('https');
 const { execSync } = require('child_process');
+const sqlite3 = require('better-sqlite3');
+const mysql = require('mysql2/promise');
 const { Lexer } = require('../lexer/lexer.js');
 const { Parser } = require('../parser/parser.js');
+const stdRegistry = require('../stdlib/registry.js');
 
 class Interpreter {
     constructor() {
@@ -210,7 +226,11 @@ class Interpreter {
         });
 
         this.globals.define('tipo', {
-            call: (_, args) => typeof args[0]
+            call: (_, args) => {
+                const val = args[0];
+                if (val instanceof VladXPromise) return 'promessa';
+                return typeof val;
+            }
         });
 
         this.globals.define('numero', {
@@ -242,6 +262,21 @@ class Interpreter {
             }
         });
 
+        this.globals.define('Buffer', {
+            alloc: { call: (_, args) => Buffer.alloc(args[0]) },
+            from: { call: (_, args) => Buffer.from(args[0], args[1]) },
+            isBuffer: { call: (_, args) => Buffer.isBuffer(args[0]) }
+        });
+
+        this.globals.define('Base64', {
+            codifica: {
+                call: (_, args) => Buffer.from(String(args[0])).toString('base64')
+            },
+            decodifica: {
+                call: (_, args) => Buffer.from(String(args[0]), 'base64').toString('utf8')
+            }
+        });
+
         this.globals.define('aspetta', {
             call: (_, args) => {
                 const ms = args[0];
@@ -306,6 +341,68 @@ class Interpreter {
         };
         this.globals.define('Archivio', Archivio);
 
+        // --- DATABASE (SQLite) ---
+        const SQLite = {
+            apri: {
+                call: (_, args) => {
+                    const db = new sqlite3(args[0]);
+                    return {
+                        interroga: {
+                            call: (_, qArgs) => {
+                                try {
+                                    return db.prepare(qArgs[0]).all(qArgs.slice(1));
+                                } catch (e) {
+                                    throw new Error(`Errore query SQLite: ${e.message}`);
+                                }
+                            }
+                        },
+                        esegui: {
+                            call: (_, qArgs) => {
+                                try {
+                                    const result = db.prepare(qArgs[0]).run(qArgs.slice(1));
+                                    return {
+                                        modifiche: result.changes,
+                                        ultimoId: result.lastInsertRowid
+                                    };
+                                } catch (e) {
+                                    throw new Error(`Errore esecuzione SQLite: ${e.message}`);
+                                }
+                            }
+                        },
+                        chiudi: { call: () => db.close() }
+                    };
+                }
+            }
+        };
+        this.globals.define('SQLite', SQLite);
+
+        // --- DATABASE (MySQL) ---
+        const MySQL = {
+            connetti: {
+                call: async (_, args) => {
+                    try {
+                        const conn = await mysql.createConnection(args[0]);
+                        return {
+                            interroga: {
+                                call: async (_, qArgs) => {
+                                    try {
+                                        const [rows] = await conn.execute(qArgs[0], qArgs.slice(1));
+                                        return rows;
+                                    } catch (e) {
+                                        throw new Error(`Errore query MySQL: ${e.message}`);
+                                    }
+                                }
+                            },
+                            chiudi: { call: async () => await conn.end() }
+                        };
+                    } catch (e) {
+                        throw new Error(`Errore connessione MySQL: ${e.message}`);
+                    }
+                }
+            }
+        };
+        this.globals.define('MySQL', MySQL);
+
         // --- SISTEMA (Process/OS) ---
         const Sistema = {
             esegui: {
@@ -374,13 +471,34 @@ class Interpreter {
             }
         };
         this.globals.define('Rete', Rete);
+
+        // --- MATEMATICA ---
+        const Matematica = {
+            casuale: { call: () => Math.random() },
+            rotonda: { call: (_, args) => Math.round(args[0]) },
+            radice: { call: (_, args) => Math.sqrt(args[0]) },
+            min: { call: (_, args) => Math.min(...args) },
+            max: { call: (_, args) => Math.max(...args) },
+            piGreco: Math.PI,
+            E: Math.E
+        };
+        this.globals.define('Matematica', Matematica);
+
+        // --- TEMPO ---
+        const Tempo = {
+            ora: { call: () => new Date().toLocaleTimeString() },
+            data: { call: () => new Date().toLocaleDateString() },
+            timestamp: { call: () => Date.now() },
+            pausa: { call: async (_, args) => new Promise(res => setTimeout(res, args[0])) }
+        };
+        this.globals.define('Tempo', Tempo);
     }
 
-    interpret(program) {
+    async interpret(program) {
         this.output = [];
         try {
             for (const statement of program.body) {
-                this.execute(statement);
+                await this.execute(statement, this.globals);
             }
         } catch (error) {
             if (error instanceof ReturnValue) {
@@ -391,59 +509,102 @@ class Interpreter {
         return this.output;
     }
 
-    execute(node) {
+    async execute(node, env) {
         switch (node.type) {
             case 'VariableDeclaration':
-                return this.executeVariableDeclaration(node);
+                return await this.executeVariableDeclaration(node, env);
             case 'FunctionDeclaration':
-                return this.executeFunctionDeclaration(node);
+                return this.executeFunctionDeclaration(node, env);
             case 'ClassDeclaration':
-                return this.executeClassDeclaration(node);
+                return this.executeClassDeclaration(node, env);
             case 'BlockStatement':
-                return this.executeBlock(node.body, new Environment(this.environment));
+                return await this.executeBlock(node.body, new Environment(env));
             case 'IfStatement':
-                return this.executeIfStatement(node);
+                return await this.executeIfStatement(node, env);
             case 'WhileStatement':
-                return this.executeWhileStatement(node);
+                return await this.executeWhileStatement(node, env);
             case 'ForStatement':
-                return this.executeForStatement(node);
+                return await this.executeForStatement(node, env);
+            case 'SwitchStatement':
+                return await this.executeSwitchStatement(node, env);
             case 'ReturnStatement':
-                throw new ReturnValue(node.argument ? this.evaluate(node.argument) : null);
+                throw new ReturnValue(node.argument ? await this.evaluate(node.argument, env) : null);
             case 'BreakStatement':
                 throw new BreakSignal();
             case 'ContinueStatement':
                 throw new ContinueSignal();
             case 'TryStatement':
-                return this.executeTryStatement(node);
+                return await this.executeTryStatement(node, env);
             case 'ThrowStatement':
-                return this.executeThrowStatement(node);
+                return await this.executeThrowStatement(node, env);
             case 'ExportNamedDeclaration':
-                return this.executeExportNamedDeclaration(node);
+                return await this.executeExportNamedDeclaration(node, env);
             case 'ImportDeclaration':
-                return this.executeImportDeclaration(node);
+                return await this.executeImportDeclaration(node, env);
             case 'PrintStatement':
-                return this.executePrintStatement(node);
+                return await this.executePrintStatement(node, env);
             case 'ExpressionStatement':
-                return this.evaluate(node.expression);
+                return await this.evaluate(node.expression, env);
             default:
                 throw new Error(`Tipo statement sconosciuto: ${node.type}`);
         }
     }
 
-    executeVariableDeclaration(node) {
-        const value = node.value ? this.evaluate(node.value) : null;
-        this.environment.define(node.name, value, node.isConstant);
+    async executeVariableDeclaration(node, env) {
+        const value = node.value ? await this.evaluate(node.value, env) : null;
+
+        if (typeof node.name === 'string') {
+            env.define(node.name, value, node.isConstant);
+        } else if (node.name.type === 'ArrayPattern') {
+            if (!Array.isArray(value)) throw new Error('Destrutturazione array fallita: il valore non è un array');
+            for (let i = 0; i < node.name.elements.length; i++) {
+                env.define(node.name.elements[i], value[i] !== undefined ? value[i] : null, node.isConstant);
+            }
+        } else if (node.name.type === 'ObjectPattern') {
+            if (typeof value !== 'object' || value === null) throw new Error('Destrutturazione oggetto fallita: il valore non è un oggetto');
+            for (const prop of node.name.properties) {
+                env.define(prop, value[prop] !== undefined ? value[prop] : null, node.isConstant);
+            }
+        }
     }
 
-    executeFunctionDeclaration(node) {
-        const func = new VladXFunction(node, this.environment);
-        this.environment.define(node.name, func);
+    async executeSwitchStatement(node, env) {
+        const discriminant = await this.evaluate(node.discriminant, env);
+        let matched = false;
+        let defaultCase = null;
+
+        for (const switchCase of node.cases) {
+            if (switchCase.test === null) {
+                defaultCase = switchCase;
+                continue;
+            }
+
+            const testValue = await this.evaluate(switchCase.test, env);
+            if (matched || discriminant === testValue) {
+                matched = true;
+                try {
+                    await this.executeBlock(switchCase.consequent, env);
+                } catch (e) {
+                    if (e instanceof BreakSignal) return;
+                    throw e;
+                }
+            }
+        }
+
+        if (!matched && defaultCase) {
+            await this.executeBlock(defaultCase.consequent, env);
+        }
+    }
+
+    executeFunctionDeclaration(node, env) {
+        const func = new VladXFunction(node, env, node.isAsync);
+        env.define(node.name, func);
     }
 
-    executeClassDeclaration(node) {
+    executeClassDeclaration(node, env) {
         let superclass = null;
         if (node.superclass) {
-            const superclassValue = this.environment.get(node.superclass);
+            const superclassValue = env.get(node.superclass);
             if (!(superclassValue instanceof VladXClass)) {
                 throw new Error(`"${node.superclass}" non è una classe`);
             }
@@ -452,40 +613,34 @@ class Interpreter {
 
         const methods = new Map();
         if (node.constructor) {
-            methods.set('costruttore', new VladXFunction(node.constructor, this.environment));
+            methods.set('costruttore', new VladXFunction(node.constructor, env, false));
         }
         for (const method of node.methods) {
-            methods.set(method.name, new VladXFunction(method, this.environment));
+            methods.set(method.name, new VladXFunction(method, env, method.isAsync));
         }
 
         const klass = new VladXClass(node.name, superclass, node.constructor, methods);
-        this.environment.define(node.name, klass);
+        env.define(node.name, klass);
     }
 
-    executeBlock(statements, env) {
-        const previousEnv = this.environment;
-        this.environment = env;
-        try {
-            for (const statement of statements) {
-                this.execute(statement);
-            }
-        } finally {
-            this.environment = previousEnv;
+    async executeBlock(statements, env) {
+        for (const statement of statements) {
+            await this.execute(statement, env);
         }
     }
 
-    executeIfStatement(node) {
-        if (this.isTruthy(this.evaluate(node.condition))) {
-            this.execute(node.consequent);
+    async executeIfStatement(node, env) {
+        if (this.isTruthy(await this.evaluate(node.condition, env))) {
+            await this.execute(node.consequent, env);
         } else if (node.alternate) {
-            this.execute(node.alternate);
+            await this.execute(node.alternate, env);
         }
     }
 
-    executeWhileStatement(node) {
-        while (this.isTruthy(this.evaluate(node.condition))) {
+    async executeWhileStatement(node, env) {
+        while (this.isTruthy(await this.evaluate(node.condition, env))) {
             try {
-                this.execute(node.body);
+                await this.execute(node.body, env);
             } catch (e) {
                 if (e instanceof BreakSignal) break;
                 if (e instanceof ContinueSignal) continue;
@@ -494,35 +649,33 @@ class Interpreter {
         }
     }
 
-    executeForStatement(node) {
-        const forEnv = new Environment(this.environment);
-        const previousEnv = this.environment;
-        this.environment = forEnv;
+    async executeForStatement(node, env) {
+        const forEnv = new Environment(env);
 
         try {
-            if (node.init) this.execute(node.init);
+            if (node.init) await this.execute(node.init, forEnv);
 
-            while (!node.condition || this.isTruthy(this.evaluate(node.condition))) {
+            while (!node.condition || this.isTruthy(await this.evaluate(node.condition, forEnv))) {
                 try {
-                    this.execute(node.body);
+                    await this.execute(node.body, forEnv);
                 } catch (e) {
                     if (e instanceof BreakSignal) break;
                     if (e instanceof ContinueSignal) {
-                        if (node.update) this.evaluate(node.update);
+                        if (node.update) await this.evaluate(node.update, forEnv);
                         continue;
                     }
                     throw e;
                 }
-                if (node.update) this.evaluate(node.update);
+                if (node.update) await this.evaluate(node.update, forEnv);
             }
         } finally {
-            this.environment = previousEnv;
+            // No need to restore since we didn't mutate this.environment
         }
     }
 
-    executeTryStatement(node) {
+    async executeTryStatement(node, env) {
         try {
-            this.execute(node.block);
+            await this.execute(node.block, env);
         } catch (error) {
             // Se è un ReturnValue o Break/Continue Signal, non catturarlo qui
             if (error instanceof ReturnValue || error instanceof BreakSignal || error instanceof ContinueSignal) {
@@ -530,100 +683,105 @@ class Interpreter {
             }
 
             if (node.handler) {
-                const catchEnv = new Environment(this.environment);
+                const catchEnv = new Environment(env);
                 // Il valore errore può essere quello lanciato da LANCIA o un errore JS
+                // Se è un errore JS, potrebbe essere un Error object o stringa
                 const errorValue = error instanceof Error ? error.message : error;
                 catchEnv.define(node.handler.param, errorValue);
 
-                const previousEnv = this.environment;
-                this.environment = catchEnv;
-                try {
-                    this.execute(node.handler.body);
-                } finally {
-                    this.environment = previousEnv;
-                }
+                await this.execute(node.handler.body, catchEnv);
             } else if (!node.finalizer) {
                 throw error;
             }
         } finally {
             if (node.finalizer) {
-                this.execute(node.finalizer);
+                await this.execute(node.finalizer, env);
             }
         }
     }
 
-    executeThrowStatement(node) {
-        const value = this.evaluate(node.argument);
+    async executeThrowStatement(node, env) {
+        const value = await this.evaluate(node.argument, env);
         throw value;
     }
 
-    executeExportNamedDeclaration(node) {
-        this.execute(node.declaration);
+    async executeExportNamedDeclaration(node, env) {
+        await this.execute(node.declaration, env);
         const name = node.declaration.name;
-        const value = this.environment.get(name);
+        const value = env.get(name);
         this.exportedSymbols.set(name, value);
     }
 
-    executeImportDeclaration(node) {
+    async executeImportDeclaration(node, env) {
         const sourcePath = node.source;
-        let fullPath;
+        let moduleExports;
 
-        if (sourcePath.startsWith('./') || sourcePath.startsWith('../')) {
-            fullPath = path.resolve(path.dirname(this.currentPath), sourcePath);
-        } else {
-            // Check vladx_modules
-            fullPath = path.resolve(process.cwd(), 'vladx_modules', sourcePath);
-            if (!fullPath.endsWith('.vx')) fullPath += '.vx';
-            if (!fs.existsSync(fullPath)) {
-                // Try index.vx inside the module folder
-                const folderPath = path.resolve(process.cwd(), 'vladx_modules', sourcePath);
-                fullPath = path.join(folderPath, 'index.vx');
+        // Check if it's a standard library module
+        if (sourcePath.startsWith('@std/')) {
+            if (stdRegistry[sourcePath]) {
+                moduleExports = stdRegistry[sourcePath];
+            } else {
+                throw new Error(`Modulo standard non trovato: ${sourcePath}`);
             }
-        }
-
-        if (!fs.existsSync(fullPath)) {
-            throw new Error(`Modulo non trovato: ${sourcePath}`);
-        }
-
-        let moduleExports;
-        if (this.modules.has(fullPath)) {
-            moduleExports = this.modules.get(fullPath);
         } else {
-            // Load and execute module
-            const content = fs.readFileSync(fullPath, 'utf8');
-            const lexer = new Lexer(content);
-            const tokens = lexer.tokenize();
-            const parser = new Parser(tokens);
-            const program = parser.parse();
+            let fullPath;
 
-            const subInterpreter = new Interpreter();
-            // Sharing the same modules cache
-            subInterpreter.modules = this.modules;
-            subInterpreter.currentPath = fullPath;
+            if (sourcePath.startsWith('./') || sourcePath.startsWith('../')) {
+                fullPath = path.resolve(path.dirname(this.currentPath), sourcePath);
+            } else {
+                // Check vladx_modules
+                fullPath = path.resolve(process.cwd(), 'vladx_modules', sourcePath);
+                if (!fullPath.endsWith('.vx')) fullPath += '.vx';
+                if (!fs.existsSync(fullPath)) {
+                    // Try index.vx inside the module folder
+                    const folderPath = path.resolve(process.cwd(), 'vladx_modules', sourcePath);
+                    fullPath = path.join(folderPath, 'index.vx');
+                }
+            }
+
+            if (!fs.existsSync(fullPath)) {
+                throw new Error(`Modulo non trovato: ${sourcePath}`);
+            }
 
-            subInterpreter.interpret(program);
-            moduleExports = subInterpreter.exportedSymbols;
-            this.modules.set(fullPath, moduleExports);
+            if (this.modules.has(fullPath)) {
+                moduleExports = this.modules.get(fullPath);
+            } else {
+                // Load and execute module
+                const content = fs.readFileSync(fullPath, 'utf8');
+                const lexer = new Lexer(content);
+                const tokens = lexer.tokenize();
+                const parser = new Parser(tokens);
+                const program = parser.parse();
+
+                const subInterpreter = new Interpreter();
+                // Sharing the same modules cache
+                subInterpreter.modules = this.modules;
+                subInterpreter.currentPath = fullPath;
+
+                await subInterpreter.interpret(program);
+                moduleExports = subInterpreter.exportedSymbols;
+                this.modules.set(fullPath, moduleExports);
+            }
         }
 
         // Import specified symbols
         for (const specifier of node.specifiers) {
             if (moduleExports.has(specifier)) {
-                this.environment.define(specifier, moduleExports.get(specifier));
+                env.define(specifier, moduleExports.get(specifier));
             } else {
                 throw new Error(`Il modulo "${sourcePath}" non esporta "${specifier}"`);
             }
         }
     }
 
-    executePrintStatement(node) {
-        const value = this.evaluate(node.argument);
+    async executePrintStatement(node, env) {
+        const value = await this.evaluate(node.argument, env);
         const output = this.stringify(value);
         console.log(output);
         this.output.push(output);
     }
 
-    evaluate(node) {
+    async evaluate(node, env) {
         switch (node.type) {
             case 'NumericLiteral':
                 return node.value;
@@ -634,47 +792,59 @@ class Interpreter {
             case 'NullLiteral':
                 return null;
             case 'Identifier':
-                return this.environment.get(node.name);
+                return env.get(node.name);
             case 'ThisExpression':
-                return this.environment.get('questo');
+                return env.get('questo');
             case 'ArrayLiteral':
-                return node.elements.map(el => this.evaluate(el));
+                return await Promise.all(node.elements.map(el => this.evaluate(el, env)));
             case 'ObjectLiteral':
                 const obj = {};
                 for (const prop of node.properties) {
-                    obj[prop.key] = this.evaluate(prop.value);
+                    obj[prop.key] = await this.evaluate(prop.value, env);
                 }
                 return obj;
             case 'BinaryExpression':
-                return this.evaluateBinaryExpression(node);
+                return await this.evaluateBinaryExpression(node, env);
             case 'LogicalExpression':
-                return this.evaluateLogicalExpression(node);
+                return await this.evaluateLogicalExpression(node, env);
             case 'UnaryExpression':
-                return this.evaluateUnaryExpression(node);
+                return await this.evaluateUnaryExpression(node, env);
             case 'AssignmentExpression':
-                return this.evaluateAssignment(node);
+                return await this.evaluateAssignment(node, env);
             case 'UpdateExpression':
-                return this.evaluateUpdateExpression(node);
+                return await this.evaluateUpdateExpression(node, env);
             case 'CallExpression':
-                return this.evaluateCallExpression(node);
+                return await this.evaluateCallExpression(node, env);
             case 'NewExpression':
-                return this.evaluateNewExpression(node);
+                return await this.evaluateNewExpression(node, env);
             case 'MemberExpression':
-                return this.evaluateMemberExpression(node);
+                return await this.evaluateMemberExpression(node, env);
             case 'ArrowFunction':
-                return new ArrowFunc(node.params, node.body, this.environment);
+                return new ArrowFunc(node.params, node.body, env, node.isAsync);
+            case 'ConditionalExpression':
+                return await this.evaluateConditionalExpression(node, env);
             case 'TemplateLiteral':
-                return this.evaluateTemplateLiteral(node);
+                return await this.evaluateTemplateLiteral(node, env);
+            case 'AwaitExpression':
+                return await this.evaluateAwaitExpression(node, env);
             default:
                 throw new Error(`Tipo espressione sconosciuto: ${node.type}`);
         }
     }
 
-    evaluateTemplateLiteral(node) {
+    async evaluateAwaitExpression(node, env) {
+        const value = await this.evaluate(node.argument, env);
+        if (value instanceof VladXPromise) {
+            return await value.wait();
+        }
+        return value;
+    }
+
+    async evaluateTemplateLiteral(node, env) {
         let result = node.quasis[0];
 
         for (let i = 0; i < node.expressions.length; i++) {
-            const value = this.evaluate(node.expressions[i]);
+            const value = await this.evaluate(node.expressions[i], env);
             result += this.stringify(value);
             result += node.quasis[i + 1];
         }
@@ -682,9 +852,9 @@ class Interpreter {
         return result;
     }
 
-    evaluateBinaryExpression(node) {
-        const left = this.evaluate(node.left);
-        const right = this.evaluate(node.right);
+    async evaluateBinaryExpression(node, env) {
+        const left = await this.evaluate(node.left, env);
+        const right = await this.evaluate(node.right, env);
 
         switch (node.operator) {
             case '+':
@@ -709,17 +879,27 @@ class Interpreter {
         }
     }
 
-    evaluateLogicalExpression(node) {
-        const left = this.evaluate(node.left);
+    async evaluateLogicalExpression(node, env) {
+        const left = await this.evaluate(node.left, env);
         if (node.operator === '||') {
-            return this.isTruthy(left) ? left : this.evaluate(node.right);
+            return this.isTruthy(left) ? left : await this.evaluate(node.right, env);
+        } else if (node.operator === '&&') {
+            return !this.isTruthy(left) ? left : await this.evaluate(node.right, env);
+        } else if (node.operator === '??') {
+            return (left !== null && left !== undefined) ? left : await this.evaluate(node.right, env);
+        }
+    }
+
+    async evaluateConditionalExpression(node, env) {
+        if (this.isTruthy(await this.evaluate(node.test, env))) {
+            return await this.evaluate(node.consequent, env);
         } else {
-            return !this.isTruthy(left) ? left : this.evaluate(node.right);
+            return await this.evaluate(node.alternate, env);
         }
     }
 
-    evaluateUnaryExpression(node) {
-        const argument = this.evaluate(node.argument);
+    async evaluateUnaryExpression(node, env) {
+        const argument = await this.evaluate(node.argument, env);
         switch (node.operator) {
             case '-': return -argument;
             case '!': return !this.isTruthy(argument);
@@ -728,20 +908,20 @@ class Interpreter {
         }
     }
 
-    evaluateAssignment(node) {
-        let value = this.evaluate(node.right);
+    async evaluateAssignment(node, env) {
+        let value = await this.evaluate(node.right, env);
 
         if (node.operator === '+=' || node.operator === '-=') {
-            const current = this.evaluate(node.left);
+            const current = await this.evaluate(node.left, env);
             value = node.operator === '+=' ? current + value : current - value;
         }
 
         if (node.left.type === 'Identifier') {
-            this.environment.set(node.left.name, value);
+            env.set(node.left.name, value);
         } else if (node.left.type === 'MemberExpression') {
-            const obj = this.evaluate(node.left.object);
+            const obj = await this.evaluate(node.left.object, env);
             const prop = node.left.computed
-                ? this.evaluate(node.left.property)
+                ? await this.evaluate(node.left.property, env)
                 : node.left.property.name;
 
             // Handle class instances
@@ -755,30 +935,36 @@ class Interpreter {
         return value;
     }
 
-    evaluateUpdateExpression(node) {
-        const current = this.evaluate(node.argument);
+    async evaluateUpdateExpression(node, env) {
+        const current = await this.evaluate(node.argument, env);
         const newValue = node.operator === '++' ? current + 1 : current - 1;
 
         if (node.argument.type === 'Identifier') {
-            this.environment.set(node.argument.name, newValue);
+            env.set(node.argument.name, newValue);
         }
 
         return node.prefix ? newValue : current;
     }
 
-    evaluateCallExpression(node) {
-        const callee = this.evaluate(node.callee);
-        const args = node.arguments.map(arg => this.evaluate(arg));
+    async evaluateCallExpression(node, env) {
+        const callee = await this.evaluate(node.callee, env);
+        const args = await Promise.all(node.arguments.map(el => this.evaluate(el, env)));
 
         if (callee && typeof callee.call === 'function') {
-            return callee.call(this, args);
+            const result = callee.call(this, args);
+            if (callee.isAsync) {
+                // If async, return the Promise wrapped in a box
+                // to prevent the interpreter's automatic await
+                return new VladXPromise(result);
+            }
+            return await result;
         }
 
         throw new Error(`"${node.callee.name || 'valore'}" non è una funzione`);
     }
 
-    evaluateNewExpression(node) {
-        const klass = this.evaluate(node.callee);
+    async evaluateNewExpression(node, env) {
+        const klass = await this.evaluate(node.callee, env);
 
         if (!(klass instanceof VladXClass)) {
             throw new Error(`"${node.callee.name || 'valore'}" non è una classe`);
@@ -789,23 +975,28 @@ class Interpreter {
 
         if (constructor) {
             const boundConstructor = new BoundMethod(constructor, instance);
-            const args = node.arguments.map(arg => this.evaluate(arg));
-            boundConstructor.call(this, args);
+            const args = await Promise.all(node.arguments.map(el => this.evaluate(el, env)));
+            await boundConstructor.call(this, args);
         }
 
         return instance;
     }
 
-    evaluateMemberExpression(node) {
-        const obj = this.evaluate(node.object);
-        if (obj === null || obj === undefined) {
-            throw new Error('Impossibile accedere a proprietà di null/undefined');
+    async evaluateMemberExpression(node, env) {
+        const obj = await this.evaluate(node.object, env);
+
+        if (node.optional && (obj === undefined || obj === null)) {
+            return null;
         }
 
         const prop = node.computed
-            ? this.evaluate(node.property)
+            ? await this.evaluate(node.property, env)
             : node.property.name;
 
+        if (obj === undefined || obj === null) {
+            throw new Error(`Impossibile leggere proprietà "${prop}" di ${obj}`);
+        }
+
         // Handle array methods
         if (Array.isArray(obj)) {
             if (prop === 'aggiungi' || prop === 'push') {
@@ -817,9 +1008,36 @@ class Interpreter {
             if (prop === 'lunghezza' || prop === 'length') {
                 return obj.length;
             }
+            if (prop === 'mappa' || prop === 'map') {
+                return {
+                    isAsync: true,
+                    call: async (interpreter, args) => {
+                        const callback = args[0];
+                        const results = [];
+                        for (let i = 0; i < obj.length; i++) {
+                            results.push(await callback.call(interpreter, [obj[i], i, obj]));
+                        }
+                        return results;
+                    }
+                };
+            }
+            if (prop === 'filtra' || prop === 'filter') {
+                return {
+                    isAsync: true,
+                    call: async (interpreter, args) => {
+                        const callback = args[0];
+                        const results = [];
+                        for (let i = 0; i < obj.length; i++) {
+                            if (interpreter.isTruthy(await callback.call(interpreter, [obj[i], i, obj]))) {
+                                results.push(obj[i]);
+                            }
+                        }
+                        return results;
+                    }
+                };
+            }
         }
 
-        // Handle class instances
         if (obj instanceof VladXInstance) {
             return obj.get(prop);
         }