@designliquido/delegua 0.0.1 → 0.0.2

package/src/resolver.js

@@ -1,7 +1,7 @@
 class ResolverError extends Error {
-    constructor(msg) {
-        super(msg);
-        this.message = msg;
+    constructor(mensagem) {
+        super(mensagem);
+        this.mensagem = mensagem;
     }
 }
 
@@ -57,9 +57,9 @@ const LoopType = {
  * No entanto, todas as variáveis declaradas dentro da classe A podem ser vistas tanto por M quanto por N.
  */
 module.exports = class Resolver {
-    constructor(interpreter, egua) {
-        this.interpreter = interpreter;
-        this.egua = egua;
+    constructor(interpretador, Delegua) {
+        this.interpretador = interpretador;
+        this.Delegua = Delegua;
         this.escopos = new Stack();
 
         this.FuncaoAtual = FunctionType.NONE;
@@ -67,20 +67,20 @@ module.exports = class Resolver {
         this.cicloAtual = ClassType.NONE;
     }
 
-    definir(name) {
+    definir(nome) {
         if (this.escopos.isEmpty()) return;
-        this.escopos.peek()[name.lexeme] = true;
+        this.escopos.peek()[nome.lexeme] = true;
     }
 
-    declarar(name) {
+    declarar(nome) {
         if (this.escopos.isEmpty()) return;
         let escopo = this.escopos.peek();
-        if (escopo.hasOwnProperty(name.lexeme))
-            this.egua.error(
-                name,
+        if (escopo.hasOwnProperty(nome.lexeme))
+            this.Delegua.erro(
+                nome,
                 "Variável com esse nome já declarada neste escopo."
             );
-            escopo[name.lexeme] = false;
+            escopo[nome.lexeme] = false;
     }
 
     inicioDoEscopo() {
@@ -91,27 +91,27 @@ module.exports = class Resolver {
         this.escopos.pop();
     }
 
-    resolver(statements) {
-        if (Array.isArray(statements)) {
-            for (let i = 0; i < statements.length; i++) {
-                statements[i].aceitar(this);
+    resolver(declaracoes) {
+        if (Array.isArray(declaracoes)) {
+            for (let i = 0; i < declaracoes.length; i++) {
+                declaracoes[i].aceitar(this);
             }
         } else {
-            statements.aceitar(this);
+            declaracoes.aceitar(this);
         }
     }
 
-    resolverLocal(expr, name) {
+    resolverLocal(expr, nome) {
         for (let i = this.escopos.stack.length - 1; i >= 0; i--) {
-            if (this.escopos.stack[i].hasOwnProperty(name.lexeme)) {
-                this.interpreter.resolver(expr, this.escopos.stack.length - 1 - i);
+            if (this.escopos.stack[i].hasOwnProperty(nome.lexeme)) {                
+                this.interpretador.resolver(expr, this.escopos.stack.length - 1 - i);
             }
         }
     }
 
     visitBlockStmt(stmt) {
         this.inicioDoEscopo();
-        this.resolver(stmt.statements);
+        this.resolver(stmt.declaracoes);
         this.finalDoEscopo();
         return null;
     }
@@ -119,28 +119,28 @@ module.exports = class Resolver {
     visitVariableExpr(expr) {
         if (
             !this.escopos.isEmpty() &&
-            this.escopos.peek()[expr.name.lexeme] === false
+            this.escopos.peek()[expr.nome.lexeme] === false
         ) {
             throw new ResolverError(
                 "Não é possível ler a variável local em seu próprio inicializador."
             );
         }
-        this.resolverLocal(expr, expr.name);
+        this.resolverLocal(expr, expr.nome);
         return null;
     }
 
     visitVarStmt(stmt) {
-        this.declarar(stmt.name);
-        if (stmt.initializer !== null) {
-            this.resolver(stmt.initializer);
+        this.declarar(stmt.nome);
+        if (stmt.inicializador !== null) {
+            this.resolver(stmt.inicializador);
         }
-        this.definir(stmt.name);
+        this.definir(stmt.nome);
         return null;
     }
 
     visitAssignExpr(expr) {
-        this.resolver(expr.value);
-        this.resolverLocal(expr, expr.name);
+        this.resolver(expr.valor);
+        this.resolverLocal(expr, expr.nome);
         return null;
     }
 
@@ -149,22 +149,22 @@ module.exports = class Resolver {
         this.FuncaoAtual = funcType;
 
         this.inicioDoEscopo();
-        let parametros = funcao.params;
+        let parametros = funcao.parametros;
         for (let i = 0; i < parametros.length; i++) {
-            this.declarar(parametros[i]["name"]);
-            this.definir(parametros[i]["name"]);
+            this.declarar(parametros[i]["nome"]);
+            this.definir(parametros[i]["nome"]);
         }
-        this.resolver(funcao.body);
+        this.resolver(funcao.corpo);
         this.finalDoEscopo();
 
         this.FuncaoAtual = enclosingFunc;
     }
 
     visitFunctionStmt(stmt) {
-        this.declarar(stmt.name);
-        this.definir(stmt.name);
+        this.declarar(stmt.nome);
+        this.definir(stmt.nome);
 
-        this.resolverFuncao(stmt.func, FunctionType.FUNCAO);
+        this.resolverFuncao(stmt.funcao, FunctionType.FUNCAO);
         return null;
     }
 
@@ -185,22 +185,22 @@ module.exports = class Resolver {
         let enclosingClass = this.ClasseAtual;
         this.ClasseAtual = ClassType.CLASSE;
 
-        this.declarar(stmt.name);
-        this.definir(stmt.name);
+        this.declarar(stmt.nome);
+        this.definir(stmt.nome);
 
         if (
-            stmt.superclass !== null &&
-            stmt.name.lexeme === stmt.superclass.name.lexeme
+            stmt.superClasse !== null &&
+            stmt.nome.lexeme === stmt.superClasse.nome.lexeme
         ) {
-            this.egua.error("Uma classe não pode herdar de si mesma.");
+            this.Delegua.error("Uma classe não pode herdar de si mesma.");
         }
 
-        if (stmt.superclass !== null) {
+        if (stmt.superClasse !== null) {
             this.ClasseAtual = ClassType.SUBCLASS;
-            this.resolver(stmt.superclass);
+            this.resolver(stmt.superClasse);
         }
 
-        if (stmt.superclass !== null) {
+        if (stmt.superClasse !== null) {
             this.inicioDoEscopo();
             this.escopos.peek()["super"] = true;
         }
@@ -208,20 +208,20 @@ module.exports = class Resolver {
         this.inicioDoEscopo();
         this.escopos.peek()["isto"] = true;
 
-        let metodos = stmt.methods;
+        let metodos = stmt.metodos;
         for (let i = 0; i < metodos.length; i++) {
             let declaracao = FunctionType.METHOD;
 
-            if (metodos[i].name.lexeme === "isto") {
+            if (metodos[i].nome.lexeme === "isto") {
                 declaracao = FunctionType.CONSTRUTOR;
             }
 
-            this.resolverFuncao(metodos[i].func, declaracao);
+            this.resolverFuncao(metodos[i].funcao, declaracao);
         }
 
         this.finalDoEscopo();
 
-        if (stmt.superclass !== null) this.finalDoEscopo();
+        if (stmt.superClasse !== null) this.finalDoEscopo();
 
         this.ClasseAtual = enclosingClass;
         return null;
@@ -229,34 +229,34 @@ module.exports = class Resolver {
 
     visitSuperExpr(expr) {
         if (this.ClasseAtual === ClassType.NONE) {
-            this.egua.error(expr.keyword, "Não pode usar 'super' fora de uma classe.");
+            this.Delegua.error(expr.palavraChave, "Não pode usar 'super' fora de uma classe.");
         } else if (this.ClasseAtual !== ClassType.SUBCLASS) {
-            this.egua.error(
-                expr.keyword,
-                "Não se usa 'super' numa classe sem superclasse."
+            this.Delegua.error(
+                expr.palavraChave,
+                "Não se usa 'super' numa classe sem SuperClasse."
             );
         }
 
-        this.resolverLocal(expr, expr.keyword);
+        this.resolverLocal(expr, expr.palavraChave);
         return null;
     }
 
     visitGetExpr(expr) {
-        this.resolver(expr.object);
+        this.resolver(expr.objeto);
         return null;
     }
 
     visitExpressionStmt(stmt) {
-        this.resolver(stmt.expression);
+        this.resolver(stmt.expressao);
         return null;
     }
 
     visitIfStmt(stmt) {
-        this.resolver(stmt.condition);
+        this.resolver(stmt.condicao);
         this.resolver(stmt.thenBranch);
 
         for (let i = 0; i < stmt.elifBranches.length; i++) {
-            this.resolver(stmt.elifBranches[i].condition);
+            this.resolver(stmt.elifBranches[i].condicao);
             this.resolver(stmt.elifBranches[i].branch);
         }
 
@@ -265,25 +265,25 @@ module.exports = class Resolver {
     }
 
     visitImportStmt(stmt) {
-        this.resolver(stmt.path);
+        this.resolver(stmt.caminho);
     }
 
     visitPrintStmt(stmt) {
-        this.resolver(stmt.expression);
+        this.resolver(stmt.expressao);
     }
 
     visitReturnStmt(stmt) {
         if (this.FuncaoAtual === FunctionType.NONE) {
-            this.egua.error(stmt.keyword, "Não é possível retornar do código do escopo superior.");
+            this.Delegua.error(stmt.palavraChave, "Não é possível retornar do código do escopo superior.");
         }
-        if (stmt.value !== null) {
+        if (stmt.valor !== null) {
             if (this.FuncaoAtual === FunctionType.CONSTRUTOR) {
-                this.egua.error(
-                    stmt.keyword,
+                this.Delegua.error(
+                    stmt.palavraChave,
                     "Não pode retornar o valor do construtor."
                 );
             }
-            this.resolver(stmt.value);
+            this.resolver(stmt.valor);
         }
         return null;
     }
@@ -305,25 +305,25 @@ module.exports = class Resolver {
     }
 
     visitWhileStmt(stmt) {
-        this.resolver(stmt.condition);
-        this.resolver(stmt.body);
+        this.resolver(stmt.condicao);
+        this.resolver(stmt.corpo);
         return null;
     }
 
     visitForStmt(stmt) {
-        if (stmt.initializer !== null) {
-            this.resolver(stmt.initializer);
+        if (stmt.inicializador !== null) {
+            this.resolver(stmt.inicializador);
         }
-        if (stmt.condition !== null) {
-            this.resolver(stmt.condition);
+        if (stmt.condicao !== null) {
+            this.resolver(stmt.condicao);
         }
-        if (stmt.increment !== null) {
-            this.resolver(stmt.increment);
+        if (stmt.incrementar !== null) {
+            this.resolver(stmt.incrementar);
         }
 
         let enclosingType = this.cicloAtual;
         this.cicloAtual = LoopType.ENQUANTO;
-        this.resolver(stmt.body);
+        this.resolver(stmt.corpo);
         this.cicloAtual = enclosingType;
 
         return null;
@@ -340,45 +340,45 @@ module.exports = class Resolver {
     }
 
     visitBinaryExpr(expr) {
-        this.resolver(expr.left);
-        this.resolver(expr.right);
+        this.resolver(expr.esquerda);
+        this.resolver(expr.direita);
         return null;
     }
 
     visitCallExpr(expr) {
         this.resolver(expr.callee);
 
-        let args = expr.args;
-        for (let i = 0; i < args.length; i++) {
-            this.resolver(args[i]);
+        let argumentos = expr.argumentos;
+        for (let i = 0; i < argumentos.length; i++) {
+            this.resolver(argumentos[i]);
         }
 
         return null;
     }
 
     visitGroupingExpr(expr) {
-        this.resolver(expr.expression);
+        this.resolver(expr.expressao);
         return null;
     }
 
     visitDictionaryExpr(expr) {
-        for (let i = 0; i < expr.keys.length; i++) {
-            this.resolver(expr.keys[i]);
-            this.resolver(expr.values[i]);
+        for (let i = 0; i < expr.chaves.length; i++) {
+            this.resolver(expr.chaves[i]);
+            this.resolver(expr.valores[i]);
         }
         return null;
     }
 
     visitArrayExpr(expr) {
-        for (let i = 0; i < expr.values.length; i++) {
-            this.resolver(expr.values[i]);
+        for (let i = 0; i < expr.valores.length; i++) {
+            this.resolver(expr.valores[i]);
         }
         return null;
     }
 
     visitSubscriptExpr(expr) {
         this.resolver(expr.callee);
-        this.resolver(expr.index);
+        this.resolver(expr.indice);
         return null;
     }
 
@@ -399,27 +399,27 @@ module.exports = class Resolver {
     }
 
     visitLogicalExpr(expr) {
-        this.resolver(expr.left);
-        this.resolver(expr.right);
+        this.resolver(expr.esquerda);
+        this.resolver(expr.direita);
         return null;
     }
 
     visitUnaryExpr(expr) {
-        this.resolver(expr.right);
+        this.resolver(expr.direita);
         return null;
     }
 
     visitSetExpr(expr) {
-        this.resolver(expr.value);
-        this.resolver(expr.object);
+        this.resolver(expr.valor);
+        this.resolver(expr.objeto);
         return null;
     }
 
     visitThisExpr(expr) {
         if (this.ClasseAtual == ClassType.NONE) {
-            this.egua.error(expr.keyword, "Não pode usar 'isto' fora da classe.");
+            this.Delegua.error(expr.palavraChave, "Não pode usar 'isto' fora da classe.");
         }
-        this.resolverLocal(expr, expr.keyword);
+        this.resolverLocal(expr, expr.palavraChave);
         return null;
     }
 };

package/src/stmt.js

@@ -2,10 +2,10 @@ class Stmt {
     aceitar(visitor) { }
 }
 
-class Expression extends Stmt {
-    constructor(expression) {
+class Expressao extends Stmt {
+    constructor(expressao) {
         super();
-        this.expression = expression;
+        this.expressao = expressao;
     }
 
     aceitar(visitor) {
@@ -14,10 +14,10 @@ class Expression extends Stmt {
 }
 
 class Funcao extends Stmt {
-    constructor(name, func) {
+    constructor(nome, funcao) {
         super();
-        this.name = name;
-        this.func = func;
+        this.nome = nome;
+        this.funcao = funcao;
     }
 
     aceitar(visitor) {
@@ -26,10 +26,10 @@ class Funcao extends Stmt {
 }
 
 class Retorna extends Stmt {
-    constructor(keyword, value) {
+    constructor(palavraChave, valor) {
         super();
-        this.keyword = keyword;
-        this.value = value;
+        this.palavraChave = palavraChave;
+        this.valor = valor;
     }
 
     aceitar(visitor) {
@@ -40,9 +40,9 @@ class Retorna extends Stmt {
 class Classe extends Stmt {
     constructor(nome, superClasse, metodos) {
         super();
-        this.name = nome;
-        this.superclass = superClasse;
-        this.methods = metodos;
+        this.nome = nome;
+        this.superClasse = superClasse;
+        this.metodos = metodos;
     }
 
     aceitar(visitor) {
@@ -51,9 +51,9 @@ class Classe extends Stmt {
 }
 
 class Block extends Stmt {
-    constructor(statements) {
+    constructor(declaracoes) {
         super();
-        this.statements = statements;
+        this.declaracoes = declaracoes;
     }
 
     aceitar(visitor) {
@@ -62,9 +62,9 @@ class Block extends Stmt {
 }
 
 class Escreva extends Stmt {
-    constructor(expression) {
+    constructor(expressao) {
         super();
-        this.expression = expression;
+        this.expressao = expressao;
     }
 
     aceitar(visitor) {
@@ -73,9 +73,9 @@ class Escreva extends Stmt {
 }
 
 class Importar extends Stmt {
-    constructor(path, closeBracket) {
+    constructor(caminho, closeBracket) {
         super();
-        this.path = path;
+        this.caminho = caminho;
         this.closeBracket = closeBracket;
     }
 
@@ -97,10 +97,10 @@ class Fazer extends Stmt {
   }
 
 class Enquanto extends Stmt {
-    constructor(condition, body) {
+    constructor(condicao, corpo) {
         super();
-        this.condition = condition;
-        this.body = body;
+        this.condicao = condicao;
+        this.corpo = corpo;
     }
 
     aceitar(visitor) {
@@ -109,12 +109,12 @@ class Enquanto extends Stmt {
 }
 
 class Para extends Stmt {
-    constructor(initializer, condition, increment, body) {
+    constructor(inicializador, condicao, incrementar, corpo) {
         super();
-        this.initializer = initializer;
-        this.condition = condition;
-        this.increment = increment;
-        this.body = body;
+        this.inicializador = inicializador;
+        this.condicao = condicao;
+        this.incrementar = incrementar;
+        this.corpo = corpo;
     }
 
     aceitar(visitor) {
@@ -137,9 +137,9 @@ class Tente extends Stmt {
 }
 
 class Se extends Stmt {
-    constructor(condition, thenBranch, elifBranches, elseBranch) {
+    constructor(condicao, thenBranch, elifBranches, elseBranch) {
         super();
-        this.condition = condition;
+        this.condicao = condicao;
         this.thenBranch = thenBranch;
         this.elifBranches = elifBranches;
         this.elseBranch = elseBranch;
@@ -151,9 +151,9 @@ class Se extends Stmt {
 }
 
 class Escolha extends Stmt {
-    constructor(condition, branches, defaultBranch) {
+    constructor(condicao, branches, defaultBranch) {
         super();
-        this.condition = condition;
+        this.condicao = condicao;
         this.branches = branches;
         this.defaultBranch = defaultBranch;
     }
@@ -184,10 +184,10 @@ class Continua extends Stmt {
 }
 
 class Var extends Stmt {
-    constructor(name, initializer) {
+    constructor(nome, inicializador) {
         super();
-        this.name = name;
-        this.initializer = initializer;
+        this.nome = nome;
+        this.inicializador = inicializador;
     }
 
     aceitar(visitor) {
@@ -196,7 +196,7 @@ class Var extends Stmt {
 }
 
 module.exports = {
-    Expression,
+    Expressao,
     Funcao,
     Retorna,
     Classe,

package/src/{tokenTypes.js → tiposDeSimbolos.js}

@@ -1,6 +1,6 @@
 module.exports = {
-    BANG: "BANG",
-    BANG_EQUAL: "BANG_EQUAL",
+    NEGACAO: "NEGACAO",
+    DIFERENTE: "DIFERENTE",
     BIT_AND: "BIT_AND",
     BIT_OR: "BIT_OR",
     BIT_XOR: "BIT_XOR",
@@ -15,48 +15,48 @@ module.exports = {
     EM: "EM",
     ENQUANTO: "ENQUANTO",
     EOF: "EOF",
-    EQUAL: "EQUAL",
-    EQUAL_EQUAL: "EQUAL_EQUAL",
+    IGUAL: "IGUAL",
+    IGUAL_IGUAL: "IGUAL_IGUAL",
     ESCOLHA: "ESCOLHA",
     ESCREVA: "ESCREVA",
     FALSO: "FALSO",
     FAZER: "FAZER",
     FINALMENTE: "FINALMENTE",
     FUNCAO: "FUNCAO",
-    GREATER: "GREATER",
-    GREATER_EQUAL: "GREATER_EQUAL",
-    GREATER_GREATER: "GREATER_GREATER",
+    MAIOR: "MAIOR",
+    MAIOR_IGUAL: "MAIOR_IGUAL",
+    MAIOR_MAIOR: "MAIOR_MAIOR",
     HERDA: "HERDA",
-    IDENTIFIER: "IDENTIFIER",
+    IDENTIFICADOR: "IDENTIFICADOR",
     IMPORTAR: "IMPORTAR",
     ISTO: "ISTO",
-    LEFT_BRACE: "LEFT_BRACE",
-    LEFT_PAREN: "LEFT_PAREN",
-    LEFT_SQUARE_BRACKET: "LEFT_SQUARE_BRACKET",
-    LESS: "LESS",
-    LESS_EQUAL: "LESS_EQUAL",
-    LESSER_LESSER: "LESSER_LESSER",
+    CHAVE_ESQUERDA: "CHAVE_ESQUERDA",
+    PARENTESE_ESQUERDO: "PARENTESE_ESQUERDO",
+    COLCHETE_ESQUERDO: "COLCHETE_ESQUERDO",
+    MENOR: "MENOR",
+    MENOR_IGUAL: "MENOR_IGUAL",
+    MENOR_MENOR: "MENOR_MENOR",
     MAIS_IGUAL: "MAIS_IGUAL",
     MENOR_IGUAL: "MENOR_IGUAL",
-    MINUS: "MINUS",
+    SUBTRACAO: "SUBTRACAO",
     MODULUS: "MODULUS",
     NULO: "NULO",
-    NUMBER: "NUMBER",
+    NUMERO: "NUMERO",
     OU: "OU",
     PADRAO: "PADRAO",
     PARA: "PARA",
     PAUSA: "PAUSA",
     PEGUE: "PEGUE",
-    PLUS: "PLUS",
+    ADICAO: "ADICAO",
     RETORNA: "RETORNA",
-    RIGHT_PAREN: "RIGHT_PAREN",
-    RIGHT_BRACE: "RIGHT_BRACE",
-    RIGHT_SQUARE_BRACKET: "RIGHT_SQUARE_BRACKET",
+    PARENTESE_DIREITO: "PARENTESE_DIREITO",
+    CHAVE_DIREITA: "CHAVE_DIREITA",
+    COLCHETE_DIREITO: "COLCHETE_DIREITO",
     SEMICOLON: "SEMICOLON",
     SLASH: "SLASH",
     STAR: "STAR",
     STAR_STAR: "STAR_STAR",
-    STRING: "STRING",
+    TEXTO: "TEXTO",
     SE: "SE",
     SENAO: "SENAO",
     SENAOSE: "SENAOSE",