vladx 1.3.2 → 1.4.1

package/bin/vladx

@@ -7,4 +7,7 @@
 
 const { run } = require('../src/cli/cli.js');
 
-run(process.argv.slice(2));
+run(process.argv.slice(2)).catch(err => {
+    console.error(err);
+    process.exit(1);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vladx",
-  "version": "1.3.2",
+  "version": "1.4.1",
   "description": "VladX - Linguaggio di programmazione con sintassi italiana",
   "main": "src/index.js",
   "type": "commonjs",
@@ -19,5 +19,9 @@
     "interpreter"
   ],
   "author": "VladX Team",
-  "license": "MIT"
+  "license": "MIT",
+  "dependencies": {
+    "better-sqlite3": "^12.6.2",
+    "mysql2": "^3.16.2"
+  }
 }

package/programs/main/index.vx

@@ -7,6 +7,5 @@ se(passport.eta >= 18) {
 } altrimenti {
     stampa("Sei minorenne")
 }
-stampa(passport)
 
-Archivio.scrivi(`passports/${passport.nome}.txt`, JSON.stringify(passport))
+Archivio.scrivi(`passports/${passport.nome}.json`, JSON.stringify(passport))

package/programs/main/passports/Alina.json

@@ -0,0 +1 @@
+{"nome":"Alina","eta":"39"}

package/programs/main/passports/Vlad.json

@@ -0,0 +1 @@
+{"nome":"Vlad","eta":"25"}

package/programs/main/test_async.vx

@@ -0,0 +1,25 @@
+stampa("--- Test Async/Await ---")
+
+asincrono funzione aspetta_e_ritorna(ms, val) {
+    stampa(`Attendo ${ms}ms...`)
+    aspetta(ms) // Nota: 'aspetta' è sincrono bloccante nella mia implementazione attuale, ma simula lavoro.
+    // Per testare await vero, avrei bisogno di funzioni async native che ritornano promise.
+    // Ma 'asincrono' funzione ritorna Promise, quindi 'attendi' dovrebbe funzionare su di essa.
+    stampa("Fatto!")
+    ritorna val
+}
+
+asincrono funzione main() {
+    stampa("Inizio main")
+    variabile p = aspetta_e_ritorna(500, 42)
+    stampa(`P è una Promise? ${tipo(p) == 'promessa'}`) // Dovrebbe essere vero (promessa)
+    
+    variabile risultato = attendi p
+    stampa(`Risultato: ${risultato}`)
+    
+    variabile diretto = attendi aspetta_e_ritorna(200, 100)
+    stampa(`Diretto: ${diretto}`)
+}
+
+attendi main()
+stampa("Fine script")

package/programs/main/test_async_advanced.vx

@@ -0,0 +1,35 @@
+stampa("--- Test Async Advanced ---")
+
+// 1. Async Arrow Function
+variabile saluta = asincrono (nome) => {
+    aspetta(100)
+    ritorna `Ciao, ${nome}!`
+}
+
+// 2. Async Class Method
+classe Lavoratore {
+    funzione costruttore(nome) {
+        questo.nome = nome
+    }
+
+    asincrono funzione lavora(compito) {
+        stampa(`${questo.nome} sta lavorando a: ${compito}...`)
+        aspetta(300)
+        ritorna `${compito} completato`
+    }
+}
+
+asincrono funzione test() {
+    stampa("Test Arrow Function...")
+    variabile promessa = saluta("Vlad")
+    stampa(`Tipo: ${tipo(promessa)}`)
+    stampa(attendi promessa)
+
+    stampa("\nTest Class Method...")
+    variabile v = nuovo Lavoratore("Vlado")
+    variabile res = attendi v.lavora("Refactoring")
+    stampa(res)
+}
+
+attendi test()
+stampa("\nFine Test Advanced")

package/programs/main/test_backend.vx

@@ -0,0 +1,33 @@
+stampa("--- Test Base64 ---")
+variabile testo = "Ciao VladX"
+variabile enc = Base64.codifica(testo)
+stampa(`Encoded: ${enc}`)
+variabile dec = Base64.decodifica(enc)
+stampa(`Decoded: ${dec}`)
+
+stampa("\n--- Test Buffer ---")
+variabile buf = Buffer.from("Hello", "utf8")
+stampa(`Is Buffer: ${Buffer.isBuffer(buf)}`)
+
+stampa("\n--- Test SQLite ---")
+variabile db = SQLite.apri("test.db")
+db.esegui("CREATE TABLE IF NOT EXISTS utenti (id INTEGER PRIMARY KEY, nome TEXT)")
+variabile result = db.esegui("INSERT INTO utenti (nome) VALUES ('Marco')")
+stampa(`Inserito ID: ${result.ultimoId}`)
+variabile utenti = db.interroga("SELECT * FROM utenti")
+stampa(`Utenti: ${JSON.stringify(utenti)}`)
+db.chiudi()
+Archivio.elimina("test.db")
+
+stampa("\n--- Test MySQL (connection failure expected) ---")
+prova {
+    variabile conn = MySQL.connetti({
+        host: "127.0.0.1",
+        user: "root",
+        password: "wrong_password",
+        connectTimeout: 2000
+    })
+    conn.chiudi()
+} cattura (err) {
+    stampa(`Errore catturato correttamente: ${err}`)
+}

package/src/cli/cli.js

@@ -52,7 +52,7 @@ function showVersion() {
     console.log(`VladX v${VERSION}`);
 }
 
-function runFile(filePath) {
+async function runFile(filePath) {
     const absolutePath = path.resolve(filePath);
 
     if (!fs.existsSync(absolutePath)) {
@@ -71,7 +71,7 @@ function runFile(filePath) {
 
         const interpreter = new Interpreter();
         interpreter.currentPath = absolutePath;
-        interpreter.interpret(ast);
+        await interpreter.interpret(ast);
     } catch (error) {
         console.error(colorize(`✗ Errore: ${error.message}`, 'red'));
         process.exit(1);
@@ -129,9 +129,11 @@ function showAST(filePath) {
     }
 }
 
-function run(args) {
+async function run(args) {
     if (args.length === 0) {
-        startREPL();
+        startREPL(); // REPL start is synchronous in loop initialization but internal loop is async, it doesn't return promise of completion?
+        // startREPL calls repl.start(). repl.start() sets up listeners and returns. 
+        // It keeps process alive via readline.
         return;
     }
 
@@ -159,7 +161,7 @@ function run(args) {
                 console.error(colorize('✗ Errore: Specificare un file da eseguire', 'red'));
                 process.exit(1);
             }
-            runFile(args[1]);
+            await runFile(args[1]);
             break;
 
         case 'lex':
@@ -181,7 +183,7 @@ function run(args) {
         default:
             // Assume it's a file path
             if (command.endsWith('.vx') || fs.existsSync(command)) {
-                runFile(command);
+                await runFile(command);
             } else {
                 console.error(colorize(`✗ Comando sconosciuto: ${command}`, 'red'));
                 console.log('Usa "vladx --help" per vedere i comandi disponibili.');

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,6 +200,8 @@ 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');
 
@@ -210,7 +225,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 +261,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 +340,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: {
@@ -376,11 +472,11 @@ class Interpreter {
         this.globals.define('Rete', Rete);
     }
 
-    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 +487,59 @@ 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 '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;
+        env.define(node.name, value, node.isConstant);
     }
 
-    executeFunctionDeclaration(node) {
-        const func = new VladXFunction(node, this.environment);
-        this.environment.define(node.name, func);
+    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 +548,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 +584,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,41 +618,36 @@ 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;
 
@@ -601,7 +684,7 @@ class Interpreter {
             subInterpreter.modules = this.modules;
             subInterpreter.currentPath = fullPath;
 
-            subInterpreter.interpret(program);
+            await subInterpreter.interpret(program);
             moduleExports = subInterpreter.exportedSymbols;
             this.modules.set(fullPath, moduleExports);
         }
@@ -609,21 +692,21 @@ class Interpreter {
         // 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 +717,57 @@ 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 '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 +775,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 +802,17 @@ 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 {
-            return !this.isTruthy(left) ? left : this.evaluate(node.right);
+            return !this.isTruthy(left) ? left : await this.evaluate(node.right, 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 +821,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 +848,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 +888,23 @@ 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);
         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') {
@@ -819,7 +918,6 @@ class Interpreter {
             }
         }
 
-        // Handle class instances
         if (obj instanceof VladXInstance) {
             return obj.get(prop);
         }

package/src/parser/ast.js

@@ -28,11 +28,12 @@ class VariableDeclaration extends ASTNode {
 }
 
 class FunctionDeclaration extends ASTNode {
-    constructor(name, params, body) {
+    constructor(name, params, body, isAsync = false) {
         super('FunctionDeclaration');
         this.name = name;
         this.params = params;
         this.body = body;
+        this.isAsync = isAsync;
     }
 }
 
@@ -60,6 +61,13 @@ class NewExpression extends ASTNode {
     }
 }
 
+class AwaitExpression extends ASTNode {
+    constructor(argument) {
+        super('AwaitExpression');
+        this.argument = argument;
+    }
+}
+
 // === Statements ===
 class BlockStatement extends ASTNode {
     constructor(body) {
@@ -76,6 +84,8 @@ class IfStatement extends ASTNode {
         this.alternate = alternate;
     }
 }
+// ... skip ...
+
 
 class WhileStatement extends ASTNode {
     constructor(condition, body) {
@@ -263,10 +273,11 @@ class MemberExpression extends ASTNode {
 }
 
 class ArrowFunction extends ASTNode {
-    constructor(params, body) {
+    constructor(params, body, isAsync = false) {
         super('ArrowFunction');
         this.params = params;
         this.body = body;
+        this.isAsync = isAsync;
     }
 }
 
@@ -350,5 +361,6 @@ module.exports = {
     LogicalExpression,
     ThisExpression,
     NewExpression,
-    TemplateLiteral
+    TemplateLiteral,
+    AwaitExpression
 };

package/src/parser/parser.js

@@ -73,7 +73,13 @@ class Parser {
             if (this.match(TokenType.ESPORTA)) return this.exportDeclaration();
             if (this.match(TokenType.VARIABILE)) return this.variableDeclaration(false);
             if (this.match(TokenType.COSTANTE)) return this.variableDeclaration(true);
-            if (this.match(TokenType.FUNZIONE)) return this.functionDeclaration();
+
+            if (this.match(TokenType.ASINCRONO)) {
+                this.consume(TokenType.FUNZIONE, 'Atteso "funzione" dopo "asincrono"');
+                return this.functionDeclaration(true);
+            }
+
+            if (this.match(TokenType.FUNZIONE)) return this.functionDeclaration(false);
             if (this.match(TokenType.CLASSE)) return this.classDeclaration();
             return this.statement();
         } catch (error) {
@@ -92,25 +98,16 @@ class Parser {
         return new AST.VariableDeclaration(name, value, isConstant);
     }
 
-    importDeclaration() {
-        this.consume(TokenType.GRAFFA_APERTA, 'Atteso "{" dopo "importa"');
-        const specifiers = [];
-        if (!this.check(TokenType.GRAFFA_CHIUSA)) {
-            do {
-                const name = this.consume(TokenType.IDENTIFICATORE, 'Nome import atteso').value;
-                specifiers.push(name);
-            } while (this.match(TokenType.VIRGOLA));
-        }
-        this.consume(TokenType.GRAFFA_CHIUSA, 'Atteso "}" dopo i nomi importati');
-        this.consume(TokenType.DA, 'Attesa parola chiave "da" dopo gli import');
-        const source = this.consume(TokenType.STRINGA, 'Percorso modulo atteso come stringa').value;
-        this.match(TokenType.PUNTO_VIRGOLA);
-        return new AST.ImportDeclaration(specifiers, source);
-    }
+    // ... imports ...
 
     exportDeclaration() {
+        if (this.match(TokenType.ASINCRONO)) {
+            this.consume(TokenType.FUNZIONE, 'Atteso "funzione" dopo "asincrono"');
+            const decl = this.functionDeclaration(true);
+            return new AST.ExportNamedDeclaration(decl);
+        }
         if (this.match(TokenType.FUNZIONE)) {
-            const decl = this.functionDeclaration();
+            const decl = this.functionDeclaration(false);
             return new AST.ExportNamedDeclaration(decl);
         }
         if (this.match(TokenType.CLASSE)) {
@@ -128,7 +125,7 @@ class Parser {
         throw new ParserError('Atteso funzione, classe o variabile dopo "esporta"', this.peek());
     }
 
-    functionDeclaration() {
+    functionDeclaration(isAsync = false) {
         const name = this.consume(TokenType.IDENTIFICATORE, 'Nome funzione atteso').value;
         this.consume(TokenType.PARENTESI_APERTA, 'Atteso "(" dopo nome funzione');
         const params = [];
@@ -140,7 +137,7 @@ class Parser {
         this.consume(TokenType.PARENTESI_CHIUSA, 'Atteso ")" dopo parametri');
         this.consume(TokenType.GRAFFA_APERTA, 'Atteso "{" prima del corpo funzione');
         const body = this.blockStatement();
-        return new AST.FunctionDeclaration(name, params, body);
+        return new AST.FunctionDeclaration(name, params, body, isAsync);
     }
 
     classDeclaration() {
@@ -164,6 +161,11 @@ class Parser {
         const methods = [];
 
         while (!this.check(TokenType.GRAFFA_CHIUSA) && !this.isAtEnd()) {
+            let isAsync = false;
+            if (this.match(TokenType.ASINCRONO)) {
+                isAsync = true;
+            }
+
             if (this.match(TokenType.FUNZIONE)) {
                 const funcName = this.consume(TokenType.IDENTIFICATORE, 'Nome metodo atteso').value;
                 this.consume(TokenType.PARENTESI_APERTA, 'Atteso "(" dopo nome metodo');
@@ -178,11 +180,13 @@ class Parser {
                 const body = this.blockStatement();
 
                 if (funcName === 'costruttore') {
-                    constructor = new AST.FunctionDeclaration('costruttore', params, body);
+                    if (isAsync) throw new ParserError('Il costruttore non può essere asincrono', this.previous());
+                    constructor = new AST.FunctionDeclaration('costruttore', params, body, false);
                 } else {
-                    methods.push(new AST.FunctionDeclaration(funcName, params, body));
+                    methods.push(new AST.FunctionDeclaration(funcName, params, body, isAsync));
                 }
             } else {
+                if (isAsync) throw new ParserError('Atteso metodo dopo "asincrono"', this.peek());
                 throw new ParserError('Atteso metodo nella classe', this.peek());
             }
         }
@@ -426,6 +430,11 @@ class Parser {
     }
 
     unary() {
+        if (this.match(TokenType.ATTENDI)) {
+            const argument = this.unary();
+            return new AST.AwaitExpression(argument);
+        }
+
         if (this.match(TokenType.NON, TokenType.MENO)) {
             const operator = this.previous().value === 'non' ? '!' : this.previous().value;
             const argument = this.unary();
@@ -548,6 +557,30 @@ class Parser {
             return this.objectLiteral();
         }
 
+        if (this.match(TokenType.ASINCRONO)) {
+            // Async Arrow Function: asincrono (param) => ...
+            if (this.match(TokenType.PARENTESI_APERTA)) {
+                const params = [];
+                if (!this.check(TokenType.PARENTESI_CHIUSA)) {
+                    do {
+                        params.push(this.consume(TokenType.IDENTIFICATORE, 'Nome parametro atteso').value);
+                    } while (this.match(TokenType.VIRGOLA));
+                }
+                this.consume(TokenType.PARENTESI_CHIUSA, 'Atteso ")" dopo parametri');
+
+                if (this.match(TokenType.FRECCIA)) {
+                    if (this.match(TokenType.GRAFFA_APERTA)) {
+                        const body = this.blockStatement();
+                        return new AST.ArrowFunction(params, body, true);
+                    } else {
+                        const body = this.expression();
+                        return new AST.ArrowFunction(params, body, true);
+                    }
+                }
+            }
+            throw new ParserError('Atteso funzione freccia asincrona', this.peek());
+        }
+
         if (this.match(TokenType.PARENTESI_APERTA)) {
             // Potrebbe essere una arrow function o un'espressione raggruppata
             const startPos = this.current - 1;
@@ -573,10 +606,10 @@ class Parser {
                     // È una arrow function
                     if (this.match(TokenType.GRAFFA_APERTA)) {
                         const body = this.blockStatement();
-                        return new AST.ArrowFunction(params, body);
+                        return new AST.ArrowFunction(params, body, false);
                     } else {
                         const body = this.expression();
-                        return new AST.ArrowFunction(params, body);
+                        return new AST.ArrowFunction(params, body, false);
                     }
                 } else {
                     // Non è una arrow function, torna indietro

package/src/repl/repl.js

@@ -48,7 +48,7 @@ class REPL {
 
         rl.prompt();
 
-        rl.on('line', (line) => {
+        rl.on('line', async (line) => {
             const trimmed = line.trim();
 
             // Handle special commands
@@ -92,7 +92,7 @@ class REPL {
 
             if (code) {
                 this.history.push(code);
-                this.execute(code);
+                await this.execute(code);
             }
 
             rl.setPrompt(colorize('vladx> ', 'green'));
@@ -105,7 +105,7 @@ class REPL {
         });
     }
 
-    execute(code) {
+    async execute(code) {
         try {
             const lexer = new Lexer(code);
             const tokens = lexer.tokenize();
@@ -113,7 +113,7 @@ class REPL {
             const parser = new Parser(tokens);
             const ast = parser.parse();
 
-            const result = this.interpreter.interpret(ast);
+            const result = await this.interpreter.interpret(ast);
 
             // Show result if it's not just print statements
             if (result.length === 0 && ast.body.length > 0) {
@@ -130,7 +130,7 @@ class REPL {
                     tempInterpreter.environment = this.interpreter.environment;
 
                     try {
-                        const value = tempInterpreter.evaluate(lastStmt.expression);
+                        const value = await tempInterpreter.evaluate(lastStmt.expression);
                         if (value !== undefined && value !== null) {
                             console.log(colorize('→ ', 'dim') + colorize(this.interpreter.stringify(value), 'yellow'));
                         }

package/programs/main/passports/Vlad.txt

@@ -1 +0,0 @@
-{"nome":"Vlad","eta":"12"}