vladx 1.3.2 → 1.5.1

package/src/lexer/lexer.js

@@ -270,7 +270,11 @@ class Lexer {
             case ';': this.addToken(TokenType.PUNTO_VIRGOLA, ';'); break;
             case '.': this.addToken(TokenType.PUNTO, '.'); break;
             case ':': this.addToken(TokenType.DUE_PUNTI, ':'); break;
-            case '?': this.addToken(TokenType.PUNTO_INTERROGATIVO, '?'); break;
+            case '?':
+                if (this.match('?')) this.addToken(TokenType.NULLISH, '??');
+                else if (this.match('.')) this.addToken(TokenType.OPTIONAL_CHAINING, '?.');
+                else this.addToken(TokenType.PUNTO_INTERROGATIVO, '?');
+                break;
 
             case '+':
                 if (this.match('+')) this.addToken(TokenType.INCREMENTA, '++');

package/src/lexer/tokens.js

@@ -39,6 +39,9 @@ const TokenType = {
     ATTENDI: 'ATTENDI',
     INTERROMPI: 'INTERROMPI',
     CONTINUA: 'CONTINUA',
+    SCEGLI: 'SCEGLI',
+    CASO: 'CASO',
+    PREDEFINITO: 'PREDEFINITO',
 
     // Operators
     PIU: 'PIU',
@@ -62,6 +65,8 @@ const TokenType = {
     FRECCIA: 'FRECCIA',
     AND: 'AND',
     OR: 'OR',
+    NULLISH: 'NULLISH',
+    OPTIONAL_CHAINING: 'OPTIONAL_CHAINING',
 
     // Delimiters
     PARENTESI_APERTA: 'PARENTESI_APERTA',
@@ -116,7 +121,10 @@ const KEYWORDS = {
     'asincrono': TokenType.ASINCRONO,
     'attendi': TokenType.ATTENDI,
     'interrompi': TokenType.INTERROMPI,
-    'continua': TokenType.CONTINUA
+    'continua': TokenType.CONTINUA,
+    'scegli': TokenType.SCEGLI,
+    'caso': TokenType.CASO,
+    'predefinito': TokenType.PREDEFINITO
 };
 
 module.exports = { TokenType, KEYWORDS };

package/src/parser/ast.js

@@ -27,12 +27,27 @@ class VariableDeclaration extends ASTNode {
     }
 }
 
+class ArrayPattern extends ASTNode {
+    constructor(elements) {
+        super('ArrayPattern');
+        this.elements = elements;
+    }
+}
+
+class ObjectPattern extends ASTNode {
+    constructor(properties) {
+        super('ObjectPattern');
+        this.properties = properties;
+    }
+}
+
 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 +75,13 @@ class NewExpression extends ASTNode {
     }
 }
 
+class AwaitExpression extends ASTNode {
+    constructor(argument) {
+        super('AwaitExpression');
+        this.argument = argument;
+    }
+}
+
 // === Statements ===
 class BlockStatement extends ASTNode {
     constructor(body) {
@@ -68,6 +90,22 @@ class BlockStatement extends ASTNode {
     }
 }
 
+class SwitchStatement extends ASTNode {
+    constructor(discriminant, cases) {
+        super('SwitchStatement');
+        this.discriminant = discriminant;
+        this.cases = cases;
+    }
+}
+
+class SwitchCase extends ASTNode {
+    constructor(test, consequent) {
+        super('SwitchCase');
+        this.test = test; // null se predefinito
+        this.consequent = consequent;
+    }
+}
+
 class IfStatement extends ASTNode {
     constructor(condition, consequent, alternate = null) {
         super('IfStatement');
@@ -254,19 +292,21 @@ class CallExpression extends ASTNode {
 }
 
 class MemberExpression extends ASTNode {
-    constructor(object, property, computed = false) {
+    constructor(object, property, computed = false, optional = false) {
         super('MemberExpression');
         this.object = object;
         this.property = property;
         this.computed = computed;
+        this.optional = optional;
     }
 }
 
 class ArrowFunction extends ASTNode {
-    constructor(params, body) {
+    constructor(params, body, isAsync = false) {
         super('ArrowFunction');
         this.params = params;
         this.body = body;
+        this.isAsync = isAsync;
     }
 }
 
@@ -279,6 +319,15 @@ class UpdateExpression extends ASTNode {
     }
 }
 
+class ConditionalExpression extends ASTNode {
+    constructor(test, consequent, alternate) {
+        super('ConditionalExpression');
+        this.test = test;
+        this.consequent = consequent;
+        this.alternate = alternate;
+    }
+}
+
 class LogicalExpression extends ASTNode {
     constructor(operator, left, right) {
         super('LogicalExpression');
@@ -350,5 +399,11 @@ module.exports = {
     LogicalExpression,
     ThisExpression,
     NewExpression,
-    TemplateLiteral
+    TemplateLiteral,
+    AwaitExpression,
+    SwitchStatement,
+    SwitchCase,
+    ConditionalExpression,
+    ArrayPattern,
+    ObjectPattern
 };

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) {
@@ -83,6 +89,34 @@ class Parser {
     }
 
     variableDeclaration(isConstant) {
+        if (this.match(TokenType.QUADRA_APERTA)) {
+            const elements = [];
+            if (!this.check(TokenType.QUADRA_CHIUSA)) {
+                do {
+                    elements.push(this.consume(TokenType.IDENTIFICATORE, 'Nome variabile atteso in destrutturazione array').value);
+                } while (this.match(TokenType.VIRGOLA));
+            }
+            this.consume(TokenType.QUADRA_CHIUSA, 'Atteso "]" dopo destrutturazione array');
+            this.consume(TokenType.ASSEGNA, 'Inizializzazione richiesta per destrutturazione');
+            const value = this.expression();
+            this.match(TokenType.PUNTO_VIRGOLA);
+            return new AST.VariableDeclaration(new AST.ArrayPattern(elements), value, isConstant);
+        }
+
+        if (this.match(TokenType.GRAFFA_APERTA)) {
+            const properties = [];
+            if (!this.check(TokenType.GRAFFA_CHIUSA)) {
+                do {
+                    properties.push(this.consume(TokenType.IDENTIFICATORE, 'Nome proprietà atteso in destrutturazione oggetto').value);
+                } while (this.match(TokenType.VIRGOLA));
+            }
+            this.consume(TokenType.GRAFFA_CHIUSA, 'Atteso "}" dopo destrutturazione oggetto');
+            this.consume(TokenType.ASSEGNA, 'Inizializzazione richiesta per destrutturazione');
+            const value = this.expression();
+            this.match(TokenType.PUNTO_VIRGOLA);
+            return new AST.VariableDeclaration(new AST.ObjectPattern(properties), value, isConstant);
+        }
+
         const name = this.consume(TokenType.IDENTIFICATORE, 'Nome variabile atteso').value;
         let value = null;
         if (this.match(TokenType.ASSEGNA)) {
@@ -97,20 +131,24 @@ class Parser {
         const specifiers = [];
         if (!this.check(TokenType.GRAFFA_CHIUSA)) {
             do {
-                const name = this.consume(TokenType.IDENTIFICATORE, 'Nome import atteso').value;
-                specifiers.push(name);
+                specifiers.push(this.consume(TokenType.IDENTIFICATORE, 'Nome simbolo atteso').value);
             } 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.consume(TokenType.GRAFFA_CHIUSA, 'Atteso "}" dopo i simboli');
+        this.consume(TokenType.DA, 'Atteso "da" dopo i simboli importati');
+        const source = this.consume(TokenType.STRINGA, 'Atteso percorso modulo').value;
         this.match(TokenType.PUNTO_VIRGOLA);
         return new AST.ImportDeclaration(specifiers, source);
     }
 
     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 +166,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 +178,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 +202,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 +221,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());
             }
         }
@@ -193,6 +238,7 @@ class Parser {
 
     statement() {
         if (this.match(TokenType.SE)) return this.ifStatement();
+        if (this.match(TokenType.SCEGLI)) return this.switchStatement();
         if (this.match(TokenType.MENTRE)) return this.whileStatement();
         if (this.match(TokenType.PER)) return this.forStatement();
         if (this.match(TokenType.RITORNA)) return this.returnStatement();
@@ -205,6 +251,38 @@ class Parser {
         return this.expressionStatement();
     }
 
+    switchStatement() {
+        this.consume(TokenType.PARENTESI_APERTA, 'Atteso "(" dopo "scegli"');
+        const discriminant = this.expression();
+        this.consume(TokenType.PARENTESI_CHIUSA, 'Atteso ")" dopo discriminante');
+        this.consume(TokenType.GRAFFA_APERTA, 'Atteso "{" dopo "scegli"');
+
+        const cases = [];
+        while (!this.check(TokenType.GRAFFA_CHIUSA) && !this.isAtEnd()) {
+            if (this.match(TokenType.CASO)) {
+                const test = this.expression();
+                this.consume(TokenType.DUE_PUNTI, 'Atteso ":" dopo il caso');
+                const consequent = [];
+                while (!this.check(TokenType.CASO) && !this.check(TokenType.PREDEFINITO) && !this.check(TokenType.GRAFFA_CHIUSA) && !this.isAtEnd()) {
+                    consequent.push(this.declaration());
+                }
+                cases.push(new AST.SwitchCase(test, consequent));
+            } else if (this.match(TokenType.PREDEFINITO)) {
+                this.consume(TokenType.DUE_PUNTI, 'Atteso ":" dopo "predefinito"');
+                const consequent = [];
+                while (!this.check(TokenType.CASO) && !this.check(TokenType.PREDEFINITO) && !this.check(TokenType.GRAFFA_CHIUSA) && !this.isAtEnd()) {
+                    consequent.push(this.declaration());
+                }
+                cases.push(new AST.SwitchCase(null, consequent));
+            } else {
+                throw new ParserError('Atteso "caso" o "predefinito" all\'interno di "scegli"', this.peek());
+            }
+        }
+
+        this.consume(TokenType.GRAFFA_CHIUSA, 'Atteso "}" dopo "scegli"');
+        return new AST.SwitchStatement(discriminant, cases);
+    }
+
     blockStatement() {
         const statements = [];
         while (!this.check(TokenType.GRAFFA_CHIUSA) && !this.isAtEnd()) {
@@ -342,7 +420,7 @@ class Parser {
     }
 
     assignment() {
-        const expr = this.logicalOr();
+        const expr = this.conditional();
 
         if (this.match(TokenType.ASSEGNA, TokenType.PIU_ASSEGNA, TokenType.MENO_ASSEGNA)) {
             const operator = this.previous().value;
@@ -353,18 +431,42 @@ class Parser {
         return expr;
     }
 
+    conditional() {
+        let expr = this.logicalOr();
+
+        if (this.match(TokenType.PUNTO_INTERROGATIVO)) {
+            const consequent = this.expression();
+            this.consume(TokenType.DUE_PUNTI, 'Atteso ":" dopo espressione del ternario');
+            const alternate = this.conditional();
+            return new AST.ConditionalExpression(expr, consequent, alternate);
+        }
+
+        return expr;
+    }
+
     logicalOr() {
-        let expr = this.logicalAnd();
+        let expr = this.nullishCoalescing();
 
         while (this.match(TokenType.O, TokenType.OR)) {
             const operator = '||';
-            const right = this.logicalAnd();
+            const right = this.nullishCoalescing();
             expr = new AST.LogicalExpression(operator, expr, right);
         }
 
         return expr;
     }
 
+    nullishCoalescing() {
+        let expr = this.logicalAnd();
+
+        while (this.match(TokenType.NULLISH)) {
+            const right = this.logicalAnd();
+            expr = new AST.LogicalExpression('??', expr, right);
+        }
+
+        return expr;
+    }
+
     logicalAnd() {
         let expr = this.equality();
 
@@ -426,6 +528,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();
@@ -454,11 +561,14 @@ class Parser {
                 expr = this.finishCall(expr);
             } else if (this.match(TokenType.PUNTO)) {
                 const property = this.consume(TokenType.IDENTIFICATORE, 'Nome proprietà atteso dopo "."');
-                expr = new AST.MemberExpression(expr, new AST.Identifier(property.value), false);
+                expr = new AST.MemberExpression(expr, new AST.Identifier(property.value), false, false);
+            } else if (this.match(TokenType.OPTIONAL_CHAINING)) {
+                const property = this.consume(TokenType.IDENTIFICATORE, 'Nome proprietà atteso dopo "?."');
+                expr = new AST.MemberExpression(expr, new AST.Identifier(property.value), false, true);
             } else if (this.match(TokenType.QUADRA_APERTA)) {
                 const property = this.expression();
                 this.consume(TokenType.QUADRA_CHIUSA, 'Atteso "]" dopo indice');
-                expr = new AST.MemberExpression(expr, property, true);
+                expr = new AST.MemberExpression(expr, property, true, false);
             } else {
                 break;
             }
@@ -548,6 +658,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 +707,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'));
                         }