vladx 1.2.3 → 1.2.4

package/DOCUMENTAZIONE.md

@@ -174,6 +174,61 @@ costante quadrato = (n) => n * n;
 stampa(quadrato(4)); // 16
 ```
 
+## 🏛️ Classi
+
+VladX supporta la programmazione orientata agli oggetti con classi.
+
+### Dichiarazione Classe
+```javascript
+classe Persona {
+    funzione costruttore(nome, eta) {
+        questo.nome = nome;
+        questo.eta = eta;
+    }
+
+    funzione saluta() {
+        stampa("Ciao, sono " + questo.nome);
+    }
+}
+```
+
+### Creazione Istanze
+Usa la parola chiave `nuovo` per creare un'istanza di una classe:
+```javascript
+variabile p = nuovo Persona("Mario", 25);
+p.saluta(); // "Ciao, sono Mario"
+```
+
+### Ereditarietà
+Le classi possono estendere altre classi usando `da`:
+```javascript
+classe Studente da Persona {
+    funzione costruttore(nome, eta, scuola) {
+        questo.nome = nome;
+        questo.eta = eta;
+        questo.scuola = scuola;
+    }
+
+    funzione studia() {
+        stampa(questo.nome + " studia alla " + questo.scuola);
+    }
+}
+```
+
+### Parola Chiave `questo`
+Usa `questo` per riferirti all'istanza corrente della classe:
+```javascript
+classe Contatore {
+    funzione costruttore() {
+        questo.valore = 0;
+    }
+
+    funzione incrementa() {
+        questo.valore++;
+    }
+}
+```
+
 ---
 
 ## 🧩 Moduli

package/README.md

@@ -63,6 +63,23 @@ funzione saluta(nome) {
 costante somma = (a, b) => a + b;
 ```
 
+### Classi
+```javascript
+classe Persona {
+    funzione costruttore(nome, eta) {
+        questo.nome = nome;
+        questo.eta = eta;
+    }
+
+    funzione saluta() {
+        stampa("Ciao, sono " + questo.nome);
+    }
+}
+
+variabile p = nuovo Persona("Mario", 25);
+p.saluta();
+```
+
 ### Gestione Errori (Try/Catch)
 ```javascript
 prova {

package/examples/test_classi.vx

@@ -0,0 +1,42 @@
+// Test delle classi in VladX
+
+classe Persona {
+    funzione costruttore(nome, eta) {
+        questo.nome = nome;
+        questo.eta = eta;
+    }
+
+    funzione saluta() {
+        stampa("Ciao, sono " + questo.nome + " e ho " + questo.eta + " anni");
+    }
+
+    funzione compieAnni() {
+        questo.eta++;
+        stampa(questo.nome + " ora ha " + questo.eta + " anni");
+    }
+}
+
+variabile p1 = nuovo Persona("Mario", 25);
+p1.saluta();
+p1.compieAnni();
+
+variabile p2 = nuovo Persona("Luigi", 30);
+p2.saluta();
+
+// Test con classe derivata (ereditarietà)
+classe Studente da Persona {
+    funzione costruttore(nome, eta, scuola) {
+        // Chiamata al costruttore padre (se supportato)
+        questo.nome = nome;
+        questo.eta = eta;
+        questo.scuola = scuola;
+    }
+
+    funzione studia() {
+        stampa(questo.nome + " studia alla " + questo.scuola);
+    }
+}
+
+variabile s1 = nuovo Studente("Anna", 20, "Università");
+s1.saluta();
+s1.studia();

package/examples/test_classi_semplice.vx

@@ -0,0 +1,15 @@
+// Test semplice delle classi
+
+classe Test {
+    funzione costruttore(nome) {
+        questo.nome = nome;
+    }
+
+    funzione saluta() {
+        stampa("Ciao " + questo.nome);
+    }
+}
+
+variabile t = nuovo Test("Mario");
+stampa("Istanza creata");
+t.saluta();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vladx",
-  "version": "1.2.3",
+  "version": "1.2.4",
   "description": "VladX - Linguaggio di programmazione con sintassi italiana",
   "main": "src/index.js",
   "type": "commonjs",

package/src/interpreter/interpreter.js

@@ -116,6 +116,72 @@ class ArrowFunc {
     }
 }
 
+class VladXClass {
+    constructor(name, superclass, constructor, methods) {
+        this.name = name;
+        this.superclass = superclass;
+        this.constructor = constructor;
+        this.methods = methods;
+    }
+
+    findMethod(name) {
+        if (this.methods.has(name)) {
+            return this.methods.get(name);
+        }
+        if (this.superclass) {
+            return this.superclass.findMethod(name);
+        }
+        return null;
+    }
+}
+
+class VladXInstance {
+    constructor(klass) {
+        this.klass = klass;
+        this.fields = new Map();
+    }
+
+    get(name) {
+        if (this.fields.has(name)) {
+            return this.fields.get(name);
+        }
+        const method = this.klass.findMethod(name);
+        if (method) {
+            return new BoundMethod(method, this);
+        }
+        throw new Error(`Proprietà "${name}" non definita nella classe "${this.klass.name}"`);
+    }
+
+    set(name, value) {
+        this.fields.set(name, value);
+    }
+}
+
+class BoundMethod {
+    constructor(method, instance) {
+        this.method = method;
+        this.instance = instance;
+    }
+
+    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++) {
+            env.define(this.method.declaration.params[i], args[i] !== undefined ? args[i] : null);
+        }
+
+        try {
+            interpreter.executeBlock(this.method.declaration.body.body, env);
+        } catch (e) {
+            if (e instanceof ReturnValue) {
+                return e.value;
+            }
+            throw e;
+        }
+        return null;
+    }
+}
+
 const fs = require('fs');
 const path = require('path');
 const http = require('http');
@@ -288,6 +354,8 @@ class Interpreter {
                 return this.executeVariableDeclaration(node);
             case 'FunctionDeclaration':
                 return this.executeFunctionDeclaration(node);
+            case 'ClassDeclaration':
+                return this.executeClassDeclaration(node);
             case 'BlockStatement':
                 return this.executeBlock(node.body, new Environment(this.environment));
             case 'IfStatement':
@@ -329,6 +397,28 @@ class Interpreter {
         this.environment.define(node.name, func);
     }
 
+    executeClassDeclaration(node) {
+        let superclass = null;
+        if (node.superclass) {
+            const superclassValue = this.environment.get(node.superclass);
+            if (!(superclassValue instanceof VladXClass)) {
+                throw new Error(`"${node.superclass}" non è una classe`);
+            }
+            superclass = superclassValue;
+        }
+
+        const methods = new Map();
+        if (node.constructor) {
+            methods.set('costruttore', new VladXFunction(node.constructor, this.environment));
+        }
+        for (const method of node.methods) {
+            methods.set(method.name, new VladXFunction(method, this.environment));
+        }
+
+        const klass = new VladXClass(node.name, superclass, node.constructor, methods);
+        this.environment.define(node.name, klass);
+    }
+
     executeBlock(statements, env) {
         const previousEnv = this.environment;
         this.environment = env;
@@ -502,6 +592,8 @@ class Interpreter {
                 return null;
             case 'Identifier':
                 return this.environment.get(node.name);
+            case 'ThisExpression':
+                return this.environment.get('questo');
             case 'ArrayLiteral':
                 return node.elements.map(el => this.evaluate(el));
             case 'ObjectLiteral':
@@ -522,6 +614,8 @@ class Interpreter {
                 return this.evaluateUpdateExpression(node);
             case 'CallExpression':
                 return this.evaluateCallExpression(node);
+            case 'NewExpression':
+                return this.evaluateNewExpression(node);
             case 'MemberExpression':
                 return this.evaluateMemberExpression(node);
             case 'ArrowFunction':
@@ -592,7 +686,13 @@ class Interpreter {
             const prop = node.left.computed
                 ? this.evaluate(node.left.property)
                 : node.left.property.name;
-            obj[prop] = value;
+            
+            // Handle class instances
+            if (obj instanceof VladXInstance) {
+                obj.set(prop, value);
+            } else {
+                obj[prop] = value;
+            }
         }
 
         return value;
@@ -620,6 +720,25 @@ class Interpreter {
         throw new Error(`"${node.callee.name || 'valore'}" non è una funzione`);
     }
 
+    evaluateNewExpression(node) {
+        const klass = this.evaluate(node.callee);
+        
+        if (!(klass instanceof VladXClass)) {
+            throw new Error(`"${node.callee.name || 'valore'}" non è una classe`);
+        }
+
+        const instance = new VladXInstance(klass);
+        const constructor = klass.findMethod('costruttore');
+        
+        if (constructor) {
+            const boundConstructor = new BoundMethod(constructor, instance);
+            const args = node.arguments.map(arg => this.evaluate(arg));
+            boundConstructor.call(this, args);
+        }
+
+        return instance;
+    }
+
     evaluateMemberExpression(node) {
         const obj = this.evaluate(node.object);
         if (obj === null || obj === undefined) {
@@ -643,6 +762,11 @@ class Interpreter {
             }
         }
 
+        // Handle class instances
+        if (obj instanceof VladXInstance) {
+            return obj.get(prop);
+        }
+
         return obj[prop];
     }
 
@@ -674,4 +798,4 @@ class Interpreter {
     }
 }
 
-module.exports = { Interpreter, Environment };
+module.exports = { Interpreter, Environment, VladXClass, VladXInstance };

package/src/parser/ast.js

@@ -36,6 +36,30 @@ class FunctionDeclaration extends ASTNode {
     }
 }
 
+class ClassDeclaration extends ASTNode {
+    constructor(name, superclass, constructor, methods) {
+        super('ClassDeclaration');
+        this.name = name;
+        this.superclass = superclass;
+        this.constructor = constructor;
+        this.methods = methods;
+    }
+}
+
+class ThisExpression extends ASTNode {
+    constructor() {
+        super('ThisExpression');
+    }
+}
+
+class NewExpression extends ASTNode {
+    constructor(callee, args) {
+        super('NewExpression');
+        this.callee = callee;
+        this.arguments = args;
+    }
+}
+
 // === Statements ===
 class BlockStatement extends ASTNode {
     constructor(body) {
@@ -284,6 +308,7 @@ module.exports = {
     Program,
     VariableDeclaration,
     FunctionDeclaration,
+    ClassDeclaration,
     BlockStatement,
     IfStatement,
     WhileStatement,
@@ -314,5 +339,7 @@ module.exports = {
     MemberExpression,
     ArrowFunction,
     UpdateExpression,
-    LogicalExpression
+    LogicalExpression,
+    ThisExpression,
+    NewExpression
 };

package/src/parser/parser.js

@@ -74,6 +74,7 @@ class Parser {
             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.CLASSE)) return this.classDeclaration();
             return this.statement();
         } catch (error) {
             this.synchronize();
@@ -112,6 +113,10 @@ class Parser {
             const decl = this.functionDeclaration();
             return new AST.ExportNamedDeclaration(decl);
         }
+        if (this.match(TokenType.CLASSE)) {
+            const decl = this.classDeclaration();
+            return new AST.ExportNamedDeclaration(decl);
+        }
         if (this.match(TokenType.VARIABILE)) {
             const decl = this.variableDeclaration(false);
             return new AST.ExportNamedDeclaration(decl);
@@ -120,7 +125,7 @@ class Parser {
             const decl = this.variableDeclaration(true);
             return new AST.ExportNamedDeclaration(decl);
         }
-        throw new ParserError('Atteso funzione o variabile dopo "esporta"', this.peek());
+        throw new ParserError('Atteso funzione, classe o variabile dopo "esporta"', this.peek());
     }
 
     functionDeclaration() {
@@ -138,6 +143,54 @@ class Parser {
         return new AST.FunctionDeclaration(name, params, body);
     }
 
+    classDeclaration() {
+        // Il token CLASSE è già stato consumato se chiamato da exportDeclaration
+        // Ma se chiamato direttamente, dobbiamo consumarlo
+        if (!this.previous() || this.previous().type !== TokenType.CLASSE) {
+            if (this.check(TokenType.CLASSE)) {
+                this.advance();
+            }
+        }
+        const name = this.consume(TokenType.IDENTIFICATORE, 'Nome classe atteso').value;
+        
+        let superclass = null;
+        if (this.match(TokenType.DA)) {
+            superclass = this.consume(TokenType.IDENTIFICATORE, 'Nome classe padre atteso').value;
+        }
+
+        this.consume(TokenType.GRAFFA_APERTA, 'Atteso "{" dopo nome classe');
+
+        let constructor = null;
+        const methods = [];
+
+        while (!this.check(TokenType.GRAFFA_CHIUSA) && !this.isAtEnd()) {
+            if (this.match(TokenType.FUNZIONE)) {
+                const funcName = this.consume(TokenType.IDENTIFICATORE, 'Nome metodo atteso').value;
+                this.consume(TokenType.PARENTESI_APERTA, 'Atteso "(" dopo nome metodo');
+                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');
+                this.consume(TokenType.GRAFFA_APERTA, 'Atteso "{" prima del corpo metodo');
+                const body = this.blockStatement();
+
+                if (funcName === 'costruttore') {
+                    constructor = new AST.FunctionDeclaration('costruttore', params, body);
+                } else {
+                    methods.push(new AST.FunctionDeclaration(funcName, params, body));
+                }
+            } else {
+                throw new ParserError('Atteso metodo nella classe', this.peek());
+            }
+        }
+
+        this.consume(TokenType.GRAFFA_CHIUSA, 'Atteso "}" alla fine della classe');
+        return new AST.ClassDeclaration(name, superclass, constructor, methods);
+    }
+
     statement() {
         if (this.match(TokenType.SE)) return this.ifStatement();
         if (this.match(TokenType.MENTRE)) return this.whileStatement();
@@ -414,6 +467,19 @@ class Parser {
         return expr;
     }
 
+    newExpression() {
+        const callee = this.consume(TokenType.IDENTIFICATORE, 'Nome classe atteso dopo "nuovo"').value;
+        this.consume(TokenType.PARENTESI_APERTA, 'Atteso "(" dopo nome classe');
+        const args = [];
+        if (!this.check(TokenType.PARENTESI_CHIUSA)) {
+            do {
+                args.push(this.expression());
+            } while (this.match(TokenType.VIRGOLA));
+        }
+        this.consume(TokenType.PARENTESI_CHIUSA, 'Atteso ")" dopo argomenti');
+        return new AST.NewExpression(new AST.Identifier(callee), args);
+    }
+
     finishCall(callee) {
         const args = [];
         if (!this.check(TokenType.PARENTESI_CHIUSA)) {
@@ -438,12 +504,16 @@ class Parser {
             return new AST.StringLiteral(this.previous().value);
         }
 
+        if (this.match(TokenType.NUOVO)) {
+            return this.newExpression();
+        }
+
         if (this.match(TokenType.IDENTIFICATORE)) {
             return new AST.Identifier(this.previous().value);
         }
 
         if (this.match(TokenType.QUESTO)) {
-            return new AST.Identifier('questo');
+            return new AST.ThisExpression();
         }
 
         if (this.match(TokenType.QUADRA_APERTA)) {