Repository: DesignLiquido/delegua
Pull request #223 (2022-12-30 23:48:44)

Ajustes EguaP
- Revisitando vários testes e instruções;
- `construtor` passa a ser palavra reservada em EguaP e Delégua.


Patch:
diff --git a/.vscode/launch.json b/.vscode/launch.json
index f198c5f4..c8d151fe 100644
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -7,7 +7,7 @@
         {
             "type": "node",
             "request": "launch",
-            "name": "Birl > Teste",
+            "name": "Birl > Teste 1",
             "skipFiles": ["<node_internals>/**", "node_modules/**"],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
@@ -20,6 +20,20 @@
             "runtimeExecutable": "node",
             "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
         },
+        {
+            "name": "BIRL > Testes unitários",
+            "type": "node",
+            "request": "launch",
+            "runtimeArgs": [
+                "--inspect-brk",
+                "${workspaceRoot}/node_modules/jest/bin/jest.js",
+                // "interpretador.test.ts",
+                "birl",
+                "--runInBand"
+            ],
+            "console": "integratedTerminal",
+            "internalConsoleOptions": "neverOpen"
+        },
         {
             "type": "node",
             "request": "launch",
@@ -34,6 +48,59 @@
             "runtimeExecutable": "node",
             "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
         },
+        {
+            "type": "node",
+            "request": "launch",
+            "name": "Delégua > Bloco Enquanto",
+            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "cwd": "${workspaceRoot}",
+            "console": "integratedTerminal",
+            "args": [
+                "${workspaceFolder}${pathSeparator}execucao.ts",
+                "./testes/exemplos/estruturas-de-repeticao/enquanto.delegua"
+            ],
+            "runtimeExecutable": "node",
+            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+        },
+        {
+            "type": "node",
+            "request": "launch",
+            "name": "Delégua > Bloco Fazer ... Enquanto",
+            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "cwd": "${workspaceRoot}",
+            "console": "integratedTerminal",
+            "args": [
+                "${workspaceFolder}${pathSeparator}execucao.ts",
+                "./testes/exemplos/estruturas-de-repeticao/fazer-enquanto.egua"
+            ],
+            "runtimeExecutable": "node",
+            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+        },
+        {
+            "type": "node",
+            "request": "launch",
+            "name": "Delégua > Bloco Para",
+            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "cwd": "${workspaceRoot}",
+            "console": "integratedTerminal",
+            "args": [
+                "${workspaceFolder}${pathSeparator}execucao.ts",
+                "./testes/exemplos/estruturas-de-repeticao/para.egua"
+            ],
+            "runtimeExecutable": "node",
+            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+        },
+        {
+            "type": "node",
+            "request": "launch",
+            "name": "Delégua > Bloco Se",
+            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "cwd": "${workspaceRoot}",
+            "console": "integratedTerminal",
+            "args": ["${workspaceFolder}${pathSeparator}execucao.ts", "./testes/exemplos/condicionais/se.delegua"],
+            "runtimeExecutable": "node",
+            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+        },
         {
             "type": "node",
             "request": "launch",
@@ -41,7 +108,7 @@
             "skipFiles": ["<node_internals>/**", "node_modules/**"],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
-            "args": ["${workspaceFolder}${pathSeparator}execucao.ts", "./testes/exemplos/classes/construtor-classe.egua"],
+            "args": ["${workspaceFolder}${pathSeparator}execucao.ts", "./testes/exemplos/classes/construtor-classe.delegua"],
             "runtimeExecutable": "node",
             "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
         },
@@ -249,66 +316,94 @@
             "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
         },
         {
+            "name": "Testes unitários",
             "type": "node",
             "request": "launch",
-            "name": "Égua Clássico > REPL",
+            "runtimeArgs": [
+                "--inspect-brk",
+                "${workspaceRoot}/node_modules/jest/bin/jest.js",
+                // "interpretador.test.ts",
+                "--runInBand"
+            ],
+            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "console": "integratedTerminal",
+            "internalConsoleOptions": "neverOpen"
+        },
+        {
+            "type": "node",
+            "request": "launch",
+            "name": "Todos os Testes de Delégua",
             "skipFiles": ["<node_internals>/**", "node_modules/**"],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
-            "args": ["${workspaceFolder}${pathSeparator}execucao.ts", "--dialeto", "egua"],
+            "args": [
+                "${workspaceFolder}${pathSeparator}execucao.ts",
+                // "--depurador",
+                "./testes/exemplos/index.delegua"
+            ],
             "runtimeExecutable": "node",
             "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
         },
         {
             "type": "node",
             "request": "launch",
-            "name": "ÉguaP > REPL",
+            "name": "Égua Clássico > Bhaskara",
             "skipFiles": ["<node_internals>/**", "node_modules/**"],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
-            "args": ["${workspaceFolder}${pathSeparator}execucao.ts", "--dialeto", "eguap"],
+            "args": [
+                "${workspaceFolder}${pathSeparator}execucao.ts",
+                "--dialeto",
+                "egua",
+                "./testes/exemplos/dialetos/egua-classico/bhaskara.egua"
+            ],
             "runtimeExecutable": "node",
             "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
         },
         {
-            "name": "Testes unitários",
             "type": "node",
             "request": "launch",
-            "runtimeArgs": [
-                "--inspect-brk",
-                "${workspaceRoot}/node_modules/jest/bin/jest.js",
-                // "interpretador.test.ts",
-                "--runInBand"
-            ],
+            "name": "Égua Clássico > Fibonacci",
             "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
-            "internalConsoleOptions": "neverOpen"
+            "args": [
+                "${workspaceFolder}${pathSeparator}execucao.ts",
+                "--dialeto",
+                "egua",
+                "./testes/exemplos/dialetos/egua-classico/fibonacci.egua"
+            ],
+            "runtimeExecutable": "node",
+            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
         },
         {
-            "name": "BIRL > Testes unitários",
             "type": "node",
             "request": "launch",
-            "runtimeArgs": [
-                "--inspect-brk",
-                "${workspaceRoot}/node_modules/jest/bin/jest.js",
-                // "interpretador.test.ts",
-                "birl",
-                "--runInBand"
-            ],
+            "name": "Égua Clássico > Classes > Construtor",
+            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
-            "internalConsoleOptions": "neverOpen"
+            "args": [
+                "${workspaceFolder}${pathSeparator}execucao.ts",
+                "--dialeto",
+                "egua",
+                "./testes/exemplos/classes/construtor-classe.egua"
+            ],
+            "runtimeExecutable": "node",
+            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
         },
         {
             "type": "node",
             "request": "launch",
-            "name": "Todos os Testes de Delégua",
+            "name": "Égua Clássico > Merge Sort",
             "skipFiles": ["<node_internals>/**", "node_modules/**"],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
             "args": [
                 "${workspaceFolder}${pathSeparator}execucao.ts",
-                // "--depurador",
-                "./testes/exemplos/index.delegua"
+                "--dialeto",
+                "egua",
+                "./testes/exemplos/dialetos/egua-classico/merge-sort.egua"
             ],
             "runtimeExecutable": "node",
             "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
@@ -316,7 +411,7 @@
         {
             "type": "node",
             "request": "launch",
-            "name": "Égua Clássico > Todos os Testes de Égua",
+            "name": "Égua Clássico > Fila Estática",
             "skipFiles": ["<node_internals>/**", "node_modules/**"],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
@@ -324,7 +419,7 @@
                 "${workspaceFolder}${pathSeparator}execucao.ts",
                 "--dialeto",
                 "egua",
-                "./testes/exemplos/dialetos/egua-classico/testes.egua"
+                "./testes/exemplos/dialetos/egua-classico/fila-estatica.egua"
             ],
             "runtimeExecutable": "node",
             "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
@@ -332,7 +427,7 @@
         {
             "type": "node",
             "request": "launch",
-            "name": "Égua Clássico > Teste de Classe",
+            "name": "Égua Clássico > Perceptron",
             "skipFiles": ["<node_internals>/**", "node_modules/**"],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
@@ -340,7 +435,7 @@
                 "${workspaceFolder}${pathSeparator}execucao.ts",
                 "--dialeto",
                 "egua",
-                "./testes/exemplos/dialetos/egua-classico/teste-classe.egua"
+                "./testes/exemplos/dialetos/egua-classico/perceptron.egua"
             ],
             "runtimeExecutable": "node",
             "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
@@ -348,7 +443,18 @@
         {
             "type": "node",
             "request": "launch",
-            "name": "Égua Clássico > Bhaskara",
+            "name": "Égua Clássico > REPL",
+            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "cwd": "${workspaceRoot}",
+            "console": "integratedTerminal",
+            "args": ["${workspaceFolder}${pathSeparator}execucao.ts", "--dialeto", "egua"],
+            "runtimeExecutable": "node",
+            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+        },
+        {
+            "type": "node",
+            "request": "launch",
+            "name": "Égua Clássico > Todos os Testes de Égua",
             "skipFiles": ["<node_internals>/**", "node_modules/**"],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
@@ -356,7 +462,7 @@
                 "${workspaceFolder}${pathSeparator}execucao.ts",
                 "--dialeto",
                 "egua",
-                "./testes/exemplos/dialetos/egua-classico/bhaskara.egua"
+                "./testes/exemplos/dialetos/egua-classico/testes.egua"
             ],
             "runtimeExecutable": "node",
             "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
@@ -364,7 +470,7 @@
         {
             "type": "node",
             "request": "launch",
-            "name": "Égua Clássico > Fibonacci",
+            "name": "Égua Clássico > Teste de Classe",
             "skipFiles": ["<node_internals>/**", "node_modules/**"],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
@@ -372,7 +478,7 @@
                 "${workspaceFolder}${pathSeparator}execucao.ts",
                 "--dialeto",
                 "egua",
-                "./testes/exemplos/dialetos/egua-classico/fibonacci.egua"
+                "./testes/exemplos/dialetos/egua-classico/teste-classe.egua"
             ],
             "runtimeExecutable": "node",
             "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
@@ -380,15 +486,15 @@
         {
             "type": "node",
             "request": "launch",
-            "name": "Égua Clássico > Classes > Construtor",
+            "name": "EguaP > Bhaskara",
             "skipFiles": ["<node_internals>/**", "node_modules/**"],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
             "args": [
                 "${workspaceFolder}${pathSeparator}execucao.ts",
                 "--dialeto",
-                "egua",
-                "./testes/exemplos/classes/construtor-classe.egua"
+                "eguap",
+                "./testes/exemplos/dialetos/eguap/bhaskara.eguap"
             ],
             "runtimeExecutable": "node",
             "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
@@ -396,15 +502,15 @@
         {
             "type": "node",
             "request": "launch",
-            "name": "Égua Clássico > Merge Sort",
+            "name": "EguaP > Bloco Enquanto",
             "skipFiles": ["<node_internals>/**", "node_modules/**"],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
             "args": [
                 "${workspaceFolder}${pathSeparator}execucao.ts",
                 "--dialeto",
-                "egua",
-                "./testes/exemplos/dialetos/egua-classico/merge-sort.egua"
+                "eguap",
+                "./testes/exemplos/dialetos/eguap/estruturas-de-repeticao/enquanto.eguap"
             ],
             "runtimeExecutable": "node",
             "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
@@ -412,15 +518,15 @@
         {
             "type": "node",
             "request": "launch",
-            "name": "Égua Clássico > Fila Estática",
+            "name": "EguaP > Bloco Escolha",
             "skipFiles": ["<node_internals>/**", "node_modules/**"],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
             "args": [
-                "${workspaceFolder}${pathSeparator}execucao.ts",
+                "${workspaceFolder}${pathSeparator}execucao.ts", 
                 "--dialeto",
-                "egua",
-                "./testes/exemplos/dialetos/egua-classico/fila-estatica.egua"
+                "eguap",
+                "./testes/exemplos/dialetos/eguap/condicionais/escolha.eguap"
             ],
             "runtimeExecutable": "node",
             "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
@@ -428,7 +534,7 @@
         {
             "type": "node",
             "request": "launch",
-            "name": "EguaP > Bhaskara",
+            "name": "EguaP > Bloco Fazer ... Enquanto",
             "skipFiles": ["<node_internals>/**", "node_modules/**"],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
@@ -436,7 +542,7 @@
                 "${workspaceFolder}${pathSeparator}execucao.ts",
                 "--dialeto",
                 "eguap",
-                "./testes/exemplos/dialetos/eguap/bhaskara.eguap"
+                "./testes/exemplos/dialetos/eguap/estruturas-de-repeticao/fazer-enquanto.eguap"
             ],
             "runtimeExecutable": "node",
             "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
@@ -444,7 +550,7 @@
         {
             "type": "node",
             "request": "launch",
-            "name": "EguaP > FizzBuzz",
+            "name": "EguaP > Bloco Para",
             "skipFiles": ["<node_internals>/**", "node_modules/**"],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
@@ -452,7 +558,7 @@
                 "${workspaceFolder}${pathSeparator}execucao.ts",
                 "--dialeto",
                 "eguap",
-                "./testes/exemplos/dialetos/eguap/fizzbuzz.eguap"
+                "./testes/exemplos/dialetos/eguap/estruturas-de-repeticao/para.eguap"
             ],
             "runtimeExecutable": "node",
             "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
@@ -460,15 +566,15 @@
         {
             "type": "node",
             "request": "launch",
-            "name": "Égua Clássico > Perception",
+            "name": "EguaP > Bloco Se",
             "skipFiles": ["<node_internals>/**", "node_modules/**"],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
             "args": [
-                "${workspaceFolder}${pathSeparator}execucao.ts",
+                "${workspaceFolder}${pathSeparator}execucao.ts", 
                 "--dialeto",
-                "egua",
-                "./testes/exemplos/dialetos/egua-classico/perceptron.egua"
+                "eguap",
+                "./testes/exemplos/dialetos/eguap/condicionais/se.eguap"
             ],
             "runtimeExecutable": "node",
             "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
@@ -476,13 +582,15 @@
         {
             "type": "node",
             "request": "launch",
-            "name": "Delégua > Bloco Enquanto",
+            "name": "EguaP > Classes",
             "skipFiles": ["<node_internals>/**", "node_modules/**"],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
             "args": [
                 "${workspaceFolder}${pathSeparator}execucao.ts",
-                "./testes/exemplos/estruturas-de-repeticao/enquanto.egua"
+                "--dialeto",
+                "eguap",
+                "./testes/exemplos/dialetos/eguap/classes/teste-classe.eguap"
             ],
             "runtimeExecutable": "node",
             "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
@@ -490,13 +598,15 @@
         {
             "type": "node",
             "request": "launch",
-            "name": "Delégua > Bloco Fazer ... Enquanto",
+            "name": "EguaP > Classes > Construtor",
             "skipFiles": ["<node_internals>/**", "node_modules/**"],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
             "args": [
                 "${workspaceFolder}${pathSeparator}execucao.ts",
-                "./testes/exemplos/estruturas-de-repeticao/fazer-enquanto.egua"
+                "--dialeto",
+                "eguap",
+                "./testes/exemplos/dialetos/eguap/classes/construtor-classe.eguap"
             ],
             "runtimeExecutable": "node",
             "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
@@ -504,13 +614,15 @@
         {
             "type": "node",
             "request": "launch",
-            "name": "Delégua > Bloco Para",
+            "name": "EguaP > FizzBuzz",
             "skipFiles": ["<node_internals>/**", "node_modules/**"],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
             "args": [
                 "${workspaceFolder}${pathSeparator}execucao.ts",
-                "./testes/exemplos/estruturas-de-repeticao/para.egua"
+                "--dialeto",
+                "eguap",
+                "./testes/exemplos/dialetos/eguap/fizzbuzz.eguap"
             ],
             "runtimeExecutable": "node",
             "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
@@ -518,11 +630,27 @@
         {
             "type": "node",
             "request": "launch",
-            "name": "Delégua > Bloco Se",
+            "name": "EguaP > Média",
             "skipFiles": ["<node_internals>/**", "node_modules/**"],
             "cwd": "${workspaceRoot}",
             "console": "integratedTerminal",
-            "args": ["${workspaceFolder}${pathSeparator}execucao.ts", "./testes/exemplos/condicionais/se.egua"],
+            "args": [
+                "${workspaceFolder}${pathSeparator}execucao.ts", 
+                "--dialeto",
+                "eguap",
+                "./testes/exemplos/dialetos/eguap/media.eguap"
+            ],
+            "runtimeExecutable": "node",
+            "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
+        },
+        {
+            "type": "node",
+            "request": "launch",
+            "name": "EguaP > REPL",
+            "skipFiles": ["<node_internals>/**", "node_modules/**"],
+            "cwd": "${workspaceRoot}",
+            "console": "integratedTerminal",
+            "args": ["${workspaceFolder}${pathSeparator}execucao.ts", "--dialeto", "eguap"],
             "runtimeExecutable": "node",
             "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"]
         },
diff --git a/fontes/avaliador-sintatico/avaliador-sintatico.ts b/fontes/avaliador-sintatico/avaliador-sintatico.ts
index 848210c7..d4d303c4 100644
--- a/fontes/avaliador-sintatico/avaliador-sintatico.ts
+++ b/fontes/avaliador-sintatico/avaliador-sintatico.ts
@@ -47,6 +47,7 @@ import {
 import { RetornoAvaliadorSintatico } from '../interfaces/retornos/retorno-avaliador-sintatico';
 import { RetornoLexador } from '../interfaces/retornos/retorno-lexador';
 import { RetornoDeclaracao, RetornoResolverDeclaracao } from './retornos';
+import { Simbolo } from '../lexador';
 
 /**
  * O avaliador sintático (Parser) é responsável por transformar os símbolos do Lexador em estruturas de alto nível.
@@ -124,7 +125,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.SUPER)) {
             const simboloChave = this.simbolos[this.atual - 1];
             this.consumir(tiposDeSimbolos.PONTO, "Esperado '.' após 'super'.");
-            const metodo = this.consumir(tiposDeSimbolos.IDENTIFICADOR, 'Esperado nome do método da SuperClasse.');
+            const metodo = this.consumir(tiposDeSimbolos.IDENTIFICADOR, 'Esperado nome do método da Superclasse.');
             return new Super(this.hashArquivo, simboloChave, metodo);
         }
 
@@ -536,7 +537,6 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
 
         const caminhoEntao = this.resolverDeclaracao();
 
-        const caminhosSeSenao = [];
         // TODO: `senãose` não existe na língua portuguesa, e a forma separada, `senão se`,
         // funciona do jeito que deveria.
         // Marcando este código para ser removido em versões futuras.
@@ -558,7 +558,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
             caminhoSenao = this.resolverDeclaracao();
         }
 
-        return new Se(condicao, caminhoEntao, caminhosSeSenao, caminhoSenao);
+        return new Se(condicao, caminhoEntao, [], caminhoSenao);
     }
 
     declaracaoEnquanto(): Enquanto {
@@ -842,7 +842,15 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
     }
 
     funcao(tipo: string): FuncaoDeclaracao {
-        const simbolo: SimboloInterface = this.consumir(tiposDeSimbolos.IDENTIFICADOR, `Esperado nome ${tipo}.`);
+        let simbolo: SimboloInterface;
+        switch (this.simbolos[this.atual].tipo) {
+            case tiposDeSimbolos.CONSTRUTOR:
+                simbolo = this.avancarEDevolverAnterior();
+                break;
+            default:
+                simbolo = this.consumir(tiposDeSimbolos.IDENTIFICADOR, `Esperado nome de ${tipo}.`);
+                break;
+        }
         return new FuncaoDeclaracao(simbolo, this.corpoDaFuncao(tipo));
     }
 
@@ -902,7 +910,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
 
         let superClasse = null;
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.HERDA)) {
-            this.consumir(tiposDeSimbolos.IDENTIFICADOR, 'Esperado nome da SuperClasse.');
+            this.consumir(tiposDeSimbolos.IDENTIFICADOR, 'Esperado nome da Superclasse.');
             superClasse = new Variavel(this.hashArquivo, this.simbolos[this.atual - 1]);
         }
 
diff --git a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-egua-classico.ts b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-egua-classico.ts
index fd05049d..c8765452 100644
--- a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-egua-classico.ts
+++ b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-egua-classico.ts
@@ -150,7 +150,7 @@ export class AvaliadorSintaticoEguaClassico implements AvaliadorSintaticoInterfa
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.SUPER)) {
             const simboloChave = this.simboloAnterior();
             this.consumir(tiposDeSimbolos.PONTO, "Esperado '.' após 'super'.");
-            const metodo = this.consumir(tiposDeSimbolos.IDENTIFICADOR, 'Esperado nome do método da SuperClasse.');
+            const metodo = this.consumir(tiposDeSimbolos.IDENTIFICADOR, 'Esperado nome do método da Superclasse.');
             return new Super(this.hashArquivo, simboloChave, metodo);
         }
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.COLCHETE_ESQUERDO)) {
@@ -799,7 +799,7 @@ export class AvaliadorSintaticoEguaClassico implements AvaliadorSintaticoInterfa
 
         let superClasse = null;
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.HERDA)) {
-            this.consumir(tiposDeSimbolos.IDENTIFICADOR, 'Esperado nome da SuperClasse.');
+            this.consumir(tiposDeSimbolos.IDENTIFICADOR, 'Esperado nome da Superclasse.');
             superClasse = new Variavel(this.hashArquivo, this.simboloAnterior());
         }
 
diff --git a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-eguap.ts b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-eguap.ts
index 23d7b6b5..6e24322a 100644
--- a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-eguap.ts
+++ b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-eguap.ts
@@ -43,14 +43,16 @@ import {
 
 import { AvaliadorSintaticoInterface, SimboloInterface } from '../../interfaces';
 import { Pragma } from '../../lexador/dialetos/pragma';
-import tiposDeSimbolos from '../../tipos-de-simbolos/eguap';
 import { RetornoLexador } from '../../interfaces/retornos/retorno-lexador';
 import { ErroAvaliadorSintatico } from '../erro-avaliador-sintatico';
 import { RetornoAvaliadorSintatico } from '../../interfaces/retornos/retorno-avaliador-sintatico';
 import { RetornoDeclaracao, RetornoPrimario, RetornoResolverDeclaracao } from '../retornos';
 
+import tiposDeSimbolos from '../../tipos-de-simbolos/eguap';
+import { Simbolo } from '../../lexador';
+
 /**
- * O avaliador sintático (Parser) é responsável por transformar os símbolos do Lexador em estruturas de alto nível.
+ * O avaliador sintático (_Parser_) é responsável por transformar os símbolos do Lexador em estruturas de alto nível.
  * Essas estruturas de alto nível são as partes que executam lógica de programação de fato.
  * Há dois grupos de estruturas de alto nível: Construtos e Declarações.
  *
@@ -154,7 +156,7 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.SUPER)) {
             const simboloChave = this.simboloAnterior();
             this.consumir(tiposDeSimbolos.PONTO, "Esperado '.' após 'super'.");
-            const metodo = this.consumir(tiposDeSimbolos.IDENTIFICADOR, 'Esperado nome do método da SuperClasse.');
+            const metodo = this.consumir(tiposDeSimbolos.IDENTIFICADOR, 'Esperado nome do método da Superclasse.');
             return new Super(this.hashArquivo, simboloChave, metodo);
         }
 
@@ -513,7 +515,7 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
         return new Leia(simboloAtual.hashArquivo, Number(simboloAtual.linha), argumentos);
     }
 
-    blocoEscopo() {
+    blocoEscopo(): any[] {
         const declaracoes = [];
         let simboloAtual = this.simboloAtual();
         const simboloAnterior = this.simboloAnterior();
@@ -559,51 +561,78 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
         return declaracoes;
     }
 
-    declaracaoSe(): Se {
-        const condicao = this.expressao();
-
-        const caminhoEntao = this.resolverDeclaracao();
-
-        const caminhosSeSenao = [];
-        // TODO: `senãose` não existe na língua portuguesa, e a forma separada, `senão se`,
-        // funciona do jeito que deveria.
-        // Marcando este código para ser removido em versões futuras.
-        /* while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.SENAOSE, tiposDeSimbolos.SENÃOSE)) {
-            this.consumir(tiposDeSimbolos.PARENTESE_ESQUERDO, "Esperado '(' após 'senaose' ou 'senãose'.");
-            const condicaoSeSenao = this.expressao();
-            this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após codição do 'senaose' ou 'senãose'.");
-
-            const caminho = this.resolverDeclaracao();
+    declaracaoEnquanto(): Enquanto {
+        try {
+            this.blocos += 1;
 
-            caminhosSeSenao.push({
-                condicao: condicaoSeSenao,
-                caminho: caminho,
-            });
-        } */
+            const condicao = this.expressao();
 
-        // Se há algum escopo aberto, conferir antes do senão se símbolo
-        // atual é um espaço de indentação
-        /* if (this.escopos.length > 0) {
-            this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.ESPACO_INDENTACAO);
-        } */
+            const bloco = this.resolverDeclaracao();
 
-        let caminhoSenao = null;
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.SENAO, tiposDeSimbolos.SENÃO)) {
-            caminhoSenao = this.resolverDeclaracao();
+            return new Enquanto(condicao, bloco);
+        } finally {
+            this.blocos -= 1;
         }
-
-        return new Se(condicao, caminhoEntao, caminhosSeSenao, caminhoSenao);
     }
 
-    declaracaoEnquanto(): Enquanto {
+    declaracaoEscolha(): Escolha {
         try {
             this.blocos += 1;
 
             const condicao = this.expressao();
 
-            const corpo = this.resolverDeclaracao();
+            this.consumir(tiposDeSimbolos.DOIS_PONTOS, "Esperado ':' após 'escolha'.");
 
-            return new Enquanto(condicao, corpo);
+            const caminhos = [];
+            let caminhoPadrao = null;
+            while (!this.estaNoFinal() && [tiposDeSimbolos.CASO, tiposDeSimbolos.PADRAO].includes(this.simbolos[this.atual].tipo)) {
+                if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CASO)) {
+                    const caminhoCondicoes = [this.expressao()];
+                    this.consumir(tiposDeSimbolos.DOIS_PONTOS, "Esperado ':' após o 'caso'.");
+
+                    while (this.verificarTipoSimboloAtual(tiposDeSimbolos.CASO)) {
+                        this.consumir(tiposDeSimbolos.CASO, null);
+                        caminhoCondicoes.push(this.expressao());
+                        this.consumir(tiposDeSimbolos.DOIS_PONTOS, "Esperado ':' após declaração do 'caso'.");
+                    }
+
+                    // Como dois-pontos é um símbolo usado para conferir se há um início de bloco, 
+                    // não podemos simplesmente chamar `this.resolverDeclaracao()` porque o dois-pontos já
+                    // foi consumido na verificação.
+                    // Outro problema é que, aparentemente, o Interpretador não espera um Bloco, e sim
+                    // um vetor de Declaracao, o qual obtemos com `this.blocoEscopo()`.
+                    const declaracoes = this.blocoEscopo();
+
+                    caminhos.push({
+                        condicoes: caminhoCondicoes,
+                        declaracoes,
+                    });
+                } else if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PADRAO)) {
+                    if (caminhoPadrao !== null) {
+                        const excecao = new ErroAvaliadorSintatico(
+                            this.simboloAtual(),
+                            "Você só pode ter um caminho padrão em cada declaração de 'escolha'."
+                        );
+                        this.erros.push(excecao);
+                        throw excecao;
+                    }
+
+                    this.consumir(tiposDeSimbolos.DOIS_PONTOS, "Esperado ':' após declaração do 'padrao'.");
+
+                    // Como dois-pontos é um símbolo usado para conferir se há um início de bloco, 
+                    // não podemos simplesmente chamar `this.resolverDeclaracao()` porque o dois-pontos já
+                    // foi consumido na verificação.
+                    // Outro problema é que, aparentemente, o Interpretador não espera um Bloco, e sim
+                    // um vetor de Declaracao, o qual obtemos com `this.blocoEscopo()`.
+                    const declaracoes = this.blocoEscopo();
+
+                    caminhoPadrao = {
+                        declaracoes,
+                    };
+                }
+            }
+
+            return new Escolha(condicao, caminhos, caminhoPadrao);
         } finally {
             this.blocos -= 1;
         }
@@ -629,7 +658,7 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
             }
 
             let incrementar = null;
-            if (!this.verificarTipoSimboloAtual(tiposDeSimbolos.PARENTESE_DIREITO)) {
+            if (this.simbolos[this.atual].tipo !== tiposDeSimbolos.DOIS_PONTOS) {
                 incrementar = this.expressao();
             }
 
@@ -643,6 +672,44 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
         }
     }
 
+    declaracaoSe(): Se {
+        const condicao = this.expressao();
+
+        // this.consumir(tiposDeSimbolos.DOIS_PONTOS, "Esperado ':' após condição de declaração 'se'.");
+
+        const caminhoEntao = this.resolverDeclaracao();
+        // const caminhoEntao = this.blocoEscopo();
+
+        // TODO: `senãose` não existe na língua portuguesa, e a forma separada, `senão se`,
+        // funciona do jeito que deveria.
+        // Marcando este código para ser removido em versões futuras.
+        /* while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.SENAOSE, tiposDeSimbolos.SENÃOSE)) {
+            this.consumir(tiposDeSimbolos.PARENTESE_ESQUERDO, "Esperado '(' após 'senaose' ou 'senãose'.");
+            const condicaoSeSenao = this.expressao();
+            this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após codição do 'senaose' ou 'senãose'.");
+
+            const caminho = this.resolverDeclaracao();
+
+            caminhosSeSenao.push({
+                condicao: condicaoSeSenao,
+                caminho: caminho,
+            });
+        } */
+
+        // Se há algum escopo aberto, conferir antes do senão se símbolo
+        // atual é um espaço de indentação
+        /* if (this.escopos.length > 0) {
+            this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.ESPACO_INDENTACAO);
+        } */
+
+        let caminhoSenao = null;
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.SENAO, tiposDeSimbolos.SENÃO)) {
+            caminhoSenao = this.resolverDeclaracao();
+        }
+
+        return new Se(condicao, caminhoEntao, [], caminhoSenao);
+    }
+
     declaracaoSustar() {
         if (this.blocos < 1) {
             this.erro(this.simboloAnterior(), "'sustar' deve estar dentro de um laço de repetição.");
@@ -670,73 +737,6 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
         return new Retorna(palavraChave, valor);
     }
 
-    declaracaoEscolha(): Escolha {
-        try {
-            this.blocos += 1;
-
-            this.consumir(tiposDeSimbolos.DOIS_PONTOS, "Esperado ':' após 'escolha'.");
-
-            const condicao = this.expressao();
-
-            const caminhos = [];
-            let caminhoPadrao = null;
-            while (!this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CHAVE_DIREITA) && !this.estaNoFinal()) {
-                if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CASO)) {
-                    const caminhoCondicoes = [this.expressao()];
-                    this.consumir(tiposDeSimbolos.DOIS_PONTOS, "Esperado ':' após o 'caso'.");
-
-                    while (this.verificarTipoSimboloAtual(tiposDeSimbolos.CASO)) {
-                        this.consumir(tiposDeSimbolos.CASO, null);
-                        caminhoCondicoes.push(this.expressao());
-                        this.consumir(tiposDeSimbolos.DOIS_PONTOS, "Esperado ':' após declaração do 'caso'.");
-                    }
-
-                    const declaracoes = [];
-                    do {
-                        declaracoes.push(this.resolverDeclaracao());
-                    } while (
-                        !this.verificarTipoSimboloAtual(tiposDeSimbolos.CASO) &&
-                        !this.verificarTipoSimboloAtual(tiposDeSimbolos.PADRAO) &&
-                        !this.verificarTipoSimboloAtual(tiposDeSimbolos.CHAVE_DIREITA)
-                    );
-
-                    caminhos.push({
-                        condicoes: caminhoCondicoes,
-                        declaracoes,
-                    });
-                } else if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PADRAO)) {
-                    if (caminhoPadrao !== null) {
-                        const excecao = new ErroAvaliadorSintatico(
-                            this.simboloAtual(),
-                            "Você só pode ter um 'padrao' em cada declaração de 'escolha'."
-                        );
-                        this.erros.push(excecao);
-                        throw excecao;
-                    }
-
-                    this.consumir(tiposDeSimbolos.DOIS_PONTOS, "Esperado ':' após declaração do 'padrao'.");
-
-                    const declaracoes = [];
-                    do {
-                        declaracoes.push(this.resolverDeclaracao());
-                    } while (
-                        !this.verificarTipoSimboloAtual(tiposDeSimbolos.CASO) &&
-                        !this.verificarTipoSimboloAtual(tiposDeSimbolos.PADRAO) &&
-                        !this.verificarTipoSimboloAtual(tiposDeSimbolos.CHAVE_DIREITA)
-                    );
-
-                    caminhoPadrao = {
-                        declaracoes,
-                    };
-                }
-            }
-
-            return new Escolha(condicao, caminhos, caminhoPadrao);
-        } finally {
-            this.blocos -= 1;
-        }
-    }
-
     declaracaoImportar(): Importar {
         this.consumir(tiposDeSimbolos.PARENTESE_ESQUERDO, "Esperado '(' após declaração.");
 
@@ -786,19 +786,17 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
 
     declaracaoFazer(): Fazer {
         const simboloFazer: SimboloInterface = this.simboloAnterior();
+
         try {
             this.blocos += 1;
 
-            const caminhoFazer = this.resolverDeclaracao();
+            const declaracaoOuBlocoFazer = this.resolverDeclaracao();
 
-            this.consumir(tiposDeSimbolos.ENQUANTO, "Esperado declaração do 'enquanto' após o escopo do 'fazer'.");
-            this.consumir(tiposDeSimbolos.PARENTESE_ESQUERDO, "Esperado '(' após declaração 'enquanto'.");
+            this.consumir(tiposDeSimbolos.ENQUANTO, "Esperado declaração do 'enquanto' após o escopo da declaração 'fazer'.");
 
             const condicaoEnquanto = this.expressao();
 
-            this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após declaração do 'enquanto'.");
-
-            return new Fazer(simboloFazer.hashArquivo, Number(simboloFazer.linha), caminhoFazer, condicaoEnquanto);
+            return new Fazer(simboloFazer.hashArquivo, Number(simboloFazer.linha), declaracaoOuBlocoFazer, condicaoEnquanto);
         } finally {
             this.blocos -= 1;
         }
@@ -840,8 +838,10 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
         return new Var(simbolo, inicializador);
     }
 
-    funcao(tipo: string): FuncaoDeclaracao {
-        const simbolo: SimboloInterface = this.consumir(tiposDeSimbolos.IDENTIFICADOR, `Esperado nome ${tipo}.`);
+    funcao(tipo: string, construtor?: boolean): FuncaoDeclaracao {
+        const simbolo: SimboloInterface = !construtor ? 
+            this.consumir(tiposDeSimbolos.IDENTIFICADOR, `Esperado nome ${tipo}.`) :
+            new Simbolo(tiposDeSimbolos.CONSTRUTOR, 'construtor', null, -1, -1);
         return new FuncaoDeclaracao(simbolo, this.corpoDaFuncao(tipo));
     }
 
@@ -897,15 +897,26 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
 
         let superClasse = null;
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.HERDA)) {
-            this.consumir(tiposDeSimbolos.IDENTIFICADOR, 'Esperado nome da SuperClasse.');
+            this.consumir(tiposDeSimbolos.IDENTIFICADOR, 'Esperado nome da Superclasse.');
             superClasse = new Variavel(this.hashArquivo, this.simboloAnterior());
         }
 
         this.consumir(tiposDeSimbolos.DOIS_PONTOS, "Esperado ':' antes do escopo da classe.");
 
         const metodos = [];
-        while (!this.verificarTipoSimboloAtual(tiposDeSimbolos.CHAVE_DIREITA) && !this.estaNoFinal()) {
-            metodos.push(this.funcao('método'));
+        while (!this.estaNoFinal() && 
+                this.verificarSeSimboloAtualEIgualA(
+                    tiposDeSimbolos.CONSTRUTOR, 
+                    tiposDeSimbolos.FUNCAO, 
+                    tiposDeSimbolos.FUNÇÃO)
+            ) 
+        {
+            metodos.push(
+                this.funcao(
+                    'método', 
+                    this.simbolos[this.atual - 1].tipo === tiposDeSimbolos.CONSTRUTOR
+                ), 
+            );
         }
 
         return new Classe(simbolo, superClasse, metodos);
diff --git a/fontes/declaracoes/se.ts b/fontes/declaracoes/se.ts
index 2f2a4b62..6a750537 100644
--- a/fontes/declaracoes/se.ts
+++ b/fontes/declaracoes/se.ts
@@ -6,13 +6,13 @@ export class Se extends Declaracao {
     condicao: Construto;
     caminhoEntao: Declaracao;
     caminhosSeSenao: any[];
-    caminhoSenao: any;
+    caminhoSenao: Declaracao;
 
     constructor(
         condicao: Construto,
         caminhoEntao: Declaracao,
         caminhosSeSenao: any[],
-        caminhoSenao: any
+        caminhoSenao: Declaracao
     ) {
         super(condicao.linha, condicao.hashArquivo);
         this.condicao = condicao;
diff --git a/fontes/interpretador/dialetos/egua-classico/interpretador-egua-classico.ts b/fontes/interpretador/dialetos/egua-classico/interpretador-egua-classico.ts
index 2e5844f8..00803bba 100644
--- a/fontes/interpretador/dialetos/egua-classico/interpretador-egua-classico.ts
+++ b/fontes/interpretador/dialetos/egua-classico/interpretador-egua-classico.ts
@@ -905,7 +905,7 @@ export class InterpretadorEguaClassico implements InterpretadorInterface {
             if (!(superClasse instanceof DeleguaClasse)) {
                 throw new ErroEmTempoDeExecucao(
                     declaracao.superClasse.nome,
-                    'SuperClasse precisa ser uma classe.',
+                    'Superclasse precisa ser uma classe.',
                     declaracao.linha
                 );
             }
diff --git a/fontes/interpretador/interpretador.ts b/fontes/interpretador/interpretador.ts
index 616bcd37..cd478074 100644
--- a/fontes/interpretador/interpretador.ts
+++ b/fontes/interpretador/interpretador.ts
@@ -748,7 +748,7 @@ export class Interpretador implements InterpretadorInterface {
                 }
             }
 
-            if (caminhoPadrao !== null && encontrado === false) {
+            if (caminhoPadrao !== null && !encontrado) {
                 await this.executarBloco(caminhoPadrao.declaracoes);
             }
         } catch (erro: any) {
@@ -1125,7 +1125,7 @@ export class Interpretador implements InterpretadorInterface {
             if (!(superClasse instanceof DeleguaClasse)) {
                 throw new ErroEmTempoDeExecucao(
                     declaracao.superClasse.nome,
-                    'SuperClasse precisa ser uma classe.',
+                    'Superclasse precisa ser uma classe.',
                     declaracao.linha
                 );
             }
diff --git a/fontes/lexador/palavras-reservadas.ts b/fontes/lexador/palavras-reservadas.ts
index 044f8d85..98aa47fa 100644
--- a/fontes/lexador/palavras-reservadas.ts
+++ b/fontes/lexador/palavras-reservadas.ts
@@ -6,6 +6,7 @@ export default {
     caso: tiposDeSimbolos.CASO,
     classe: tiposDeSimbolos.CLASSE,
     continua: tiposDeSimbolos.CONTINUA,
+    construtor: tiposDeSimbolos.CONSTRUTOR,
     enquanto: tiposDeSimbolos.ENQUANTO,
     escolha: tiposDeSimbolos.ESCOLHA,
     escreva: tiposDeSimbolos.ESCREVA,
diff --git a/fontes/tipos-de-simbolos/delegua.ts b/fontes/tipos-de-simbolos/delegua.ts
index 630dd9a9..0598f61c 100644
--- a/fontes/tipos-de-simbolos/delegua.ts
+++ b/fontes/tipos-de-simbolos/delegua.ts
@@ -11,6 +11,7 @@ export default {
     COLCHETE_DIREITO: 'COLCHETE_DIREITO',
     COLCHETE_ESQUERDO: 'COLCHETE_ESQUERDO',
     CONTINUA: 'CONTINUA',
+    CONSTRUTOR: 'CONSTRUTOR',
     DECREMENTAR: 'DECREMENTAR',
     DIFERENTE: 'DIFERENTE',
     DIVISAO: 'DIVISAO',
diff --git a/fontes/tipos-de-simbolos/eguap.ts b/fontes/tipos-de-simbolos/eguap.ts
index 6bcccc15..dc49b697 100644
--- a/fontes/tipos-de-simbolos/eguap.ts
+++ b/fontes/tipos-de-simbolos/eguap.ts
@@ -10,6 +10,7 @@ export default {
     CLASSE: 'CLASSE',
     COLCHETE_DIREITO: 'COLCHETE_DIREITO',
     COLCHETE_ESQUERDO: 'COLCHETE_ESQUERDO',
+    CONSTRUTOR: 'CONSTRUTOR',
     CONTINUA: 'CONTINUA',
     DIFERENTE: 'DIFERENTE',
     DIVISAO: 'DIVISAO',


Test patch:
diff --git a/testes/eguap/interpretador.test.ts b/testes/eguap/interpretador.test.ts
index 65a4529a..ee7a2bdb 100644
--- a/testes/eguap/interpretador.test.ts
+++ b/testes/eguap/interpretador.test.ts
@@ -160,7 +160,7 @@ describe('Interpretador (EguaP)', () => {
                     expect(retornoInterpretador.erros).toHaveLength(0);
                 });
 
-                it.skip('Laços de repetição - fazer ... enquanto', async () => {
+                it('Laços de repetição - fazer ... enquanto', async () => {
                     const retornoLexador = delegua.lexador.mapear(["var a = 0\nfazer:\n    a = a + 1\nenquanto a < 10"], -1);
                     const retornoAvaliadorSintatico = delegua.avaliadorSintatico.analisar(retornoLexador);
 
@@ -184,7 +184,7 @@ describe('Interpretador (EguaP)', () => {
             });
 
             describe('Classes', () => {
-                it.skip('Trivial', async () => {
+                it('Trivial', async () => {
                     const codigo = [
                         "classe Animal:",
                         "    correr():",
diff --git a/testes/exemplos/classes/construtor-classe.delegua b/testes/exemplos/classes/construtor-classe.delegua
new file mode 100644
index 00000000..ccbcd3ee
--- /dev/null
+++ b/testes/exemplos/classes/construtor-classe.delegua
@@ -0,0 +1,7 @@
+classe Teste {
+  construtor() {
+    escreva("começou")
+  }
+}
+
+var teste = Teste()
diff --git a/testes/exemplos/classes/teste-classe.delegua b/testes/exemplos/classes/teste-classe.delegua
index 17b5e31a..bcf3563c 100644
--- a/testes/exemplos/classes/teste-classe.delegua
+++ b/testes/exemplos/classes/teste-classe.delegua
@@ -10,5 +10,5 @@ classe Resposta {
     }
 }
 
-var resp = Resposta();
+var resp = Resposta()
 escreva(resp.enviar("Ok").status(200))
diff --git a/testes/exemplos/classes/teste-classe.egua b/testes/exemplos/classes/teste-classe.egua
deleted file mode 100644
index 1b77e2a9..00000000
--- a/testes/exemplos/classes/teste-classe.egua
+++ /dev/null
@@ -1,19 +0,0 @@
-escreva("--------------------------------")
-escreva("Iniciando Teste: Classe")
-escreva("--------------------------------")
-
-classe Animal {
-    correr() {
-        escreva("Correndo Loucamente")
-    }
-}
-classe Cachorro herda Animal {
-    latir() {
-        escreva("Au Au Au Au")
-    }
-}
-
-var nomeDoCachorro = Cachorro()
-nomeDoCachorro.correr()
-nomeDoCachorro.latir()
-escreva("Classe: OK!")
diff --git a/testes/exemplos/condicionais/se.egua b/testes/exemplos/condicionais/se.delegua
similarity index 100%
rename from testes/exemplos/condicionais/se.egua
rename to testes/exemplos/condicionais/se.delegua
diff --git a/testes/exemplos/classes/construtor-classe.egua b/testes/exemplos/dialetos/egua-classico/classes/construtor-classe.egua
similarity index 100%
rename from testes/exemplos/classes/construtor-classe.egua
rename to testes/exemplos/dialetos/egua-classico/classes/construtor-classe.egua
diff --git a/testes/exemplos/dialetos/egua-classico/classes/teste-classe.egua b/testes/exemplos/dialetos/egua-classico/classes/teste-classe.egua
new file mode 100644
index 00000000..6581e6aa
--- /dev/null
+++ b/testes/exemplos/dialetos/egua-classico/classes/teste-classe.egua
@@ -0,0 +1,19 @@
+escreva("--------------------------------");
+escreva("Iniciando Teste: Classe");
+escreva("--------------------------------");
+
+classe Animal {
+    correr() {
+        escreva("Correndo Loucamente");
+    }
+}
+classe Cachorro herda Animal {
+    latir() {
+        escreva("Au Au Au Au");
+    }
+}
+
+var nomeDoCachorro = Cachorro();
+nomeDoCachorro.correr();
+nomeDoCachorro.latir();
+escreva("Classe: OK!");
diff --git a/testes/exemplos/dialetos/egua-classico/condicionais/escolha.egua b/testes/exemplos/dialetos/egua-classico/condicionais/escolha.egua
new file mode 100644
index 00000000..d65d7b17
--- /dev/null
+++ b/testes/exemplos/dialetos/egua-classico/condicionais/escolha.egua
@@ -0,0 +1,12 @@
+escolha (2) {
+    caso "1":
+        escreva("correspondente à opção 1");
+        escreva("escreva de novo 1");
+    caso 1:
+    caso 2:
+        escreva("correspondente à opção 2");
+        escreva("escreva de novo 2");
+        escreva("escreva de novo 3");
+    padrao:
+        escreva("Sem opção correspondente");
+}
diff --git a/testes/exemplos/dialetos/egua-classico/condicionais/se.egua b/testes/exemplos/dialetos/egua-classico/condicionais/se.egua
new file mode 100644
index 00000000..b1d6e208
--- /dev/null
+++ b/testes/exemplos/dialetos/egua-classico/condicionais/se.egua
@@ -0,0 +1,6 @@
+var a = 1;
+var b = 1;
+se (a == b)
+    escreva("Se - Se não: OK!");
+senao
+    escreva("Se - Se não: ERRO!");
diff --git a/testes/exemplos/estruturas-de-repeticao/enquanto.egua b/testes/exemplos/dialetos/egua-classico/estruturas-de-repeticao/enquanto.egua
similarity index 100%
rename from testes/exemplos/estruturas-de-repeticao/enquanto.egua
rename to testes/exemplos/dialetos/egua-classico/estruturas-de-repeticao/enquanto.egua
diff --git a/testes/exemplos/estruturas-de-repeticao/para.egua b/testes/exemplos/dialetos/egua-classico/estruturas-de-repeticao/para.egua
similarity index 100%
rename from testes/exemplos/estruturas-de-repeticao/para.egua
rename to testes/exemplos/dialetos/egua-classico/estruturas-de-repeticao/para.egua
diff --git a/testes/exemplos/dialetos/eguap/classes/construtor-classe.eguap b/testes/exemplos/dialetos/eguap/classes/construtor-classe.eguap
new file mode 100644
index 00000000..4d911b10
--- /dev/null
+++ b/testes/exemplos/dialetos/eguap/classes/construtor-classe.eguap
@@ -0,0 +1,5 @@
+classe Teste:
+  construtor():
+    escreva("começou")
+
+var teste = Teste()
diff --git a/testes/exemplos/dialetos/eguap/classes/teste-classe.eguap b/testes/exemplos/dialetos/eguap/classes/teste-classe.eguap
new file mode 100644
index 00000000..46cb603c
--- /dev/null
+++ b/testes/exemplos/dialetos/eguap/classes/teste-classe.eguap
@@ -0,0 +1,11 @@
+classe Resposta:
+    funcao enviar(codigo):
+        isto.codigo = codigo
+        retorna(isto)
+
+    função status(statusHttp):
+        isto.statusHttp = statusHttp
+        retorna(isto)
+
+var resp = Resposta()
+escreva(resp.enviar("Ok").status(200))
diff --git a/testes/exemplos/dialetos/eguap/condicionais/escolha.eguap b/testes/exemplos/dialetos/eguap/condicionais/escolha.eguap
new file mode 100644
index 00000000..7f353b89
--- /dev/null
+++ b/testes/exemplos/dialetos/eguap/condicionais/escolha.eguap
@@ -0,0 +1,11 @@
+escolha 2:
+    caso "1":
+        escreva("correspondente à opção 1")
+        escreva("escreva de novo 1")
+    caso 1:
+    caso 2:
+        escreva("correspondente à opção 2")
+        escreva("escreva de novo 2")
+        escreva("escreva de novo 3")
+    padrao:
+        escreva("Sem opção correspondente")
diff --git a/testes/exemplos/dialetos/eguap/condicionais/se.eguap b/testes/exemplos/dialetos/eguap/condicionais/se.eguap
new file mode 100644
index 00000000..2b6b1779
--- /dev/null
+++ b/testes/exemplos/dialetos/eguap/condicionais/se.eguap
@@ -0,0 +1,8 @@
+var a = 1
+var b = 1
+se a == b:
+    escreva(a, b)
+    escreva("Se - Se não: OK!")
+senao:
+    escreva(a, b)
+    escreva("Se - Se não: ERRO!")
diff --git a/testes/exemplos/dialetos/eguap/estruturas-de-repeticao/enquanto.eguap b/testes/exemplos/dialetos/eguap/estruturas-de-repeticao/enquanto.eguap
new file mode 100644
index 00000000..059b6992
--- /dev/null
+++ b/testes/exemplos/dialetos/eguap/estruturas-de-repeticao/enquanto.eguap
@@ -0,0 +1,11 @@
+var a = 0
+enquanto a < 5:
+    a = a + 1
+    escreva('a', a)
+
+se a == 5:
+    escreva("Enquanto: OK!")
+senao:
+    escreva("Enquanto: ERRO!")
+
+escreva(a)
diff --git a/testes/exemplos/dialetos/eguap/estruturas-de-repeticao/fazer-enquanto.eguap b/testes/exemplos/dialetos/eguap/estruturas-de-repeticao/fazer-enquanto.eguap
new file mode 100644
index 00000000..ad32240b
--- /dev/null
+++ b/testes/exemplos/dialetos/eguap/estruturas-de-repeticao/fazer-enquanto.eguap
@@ -0,0 +1,10 @@
+var a = 0
+fazer:
+    a = a + 1
+    escreva('a', a)
+enquanto a < 5
+
+se a == 5:
+    escreva("Faça - Enquanto: OK!")
+senao:
+    escreva("Faça - Enquanto: ERRO!")
diff --git a/testes/exemplos/dialetos/eguap/estruturas-de-repeticao/para.eguap b/testes/exemplos/dialetos/eguap/estruturas-de-repeticao/para.eguap
new file mode 100644
index 00000000..d5d95b7c
--- /dev/null
+++ b/testes/exemplos/dialetos/eguap/estruturas-de-repeticao/para.eguap
@@ -0,0 +1,10 @@
+var a = 0
+para var i = 0; i < 5; i = i + 1:
+    a = a + 1
+    escreva('a', a)
+
+se a == 5:
+    escreva("Para: OK!")
+senao:
+    escreva("a: " + a)
+    escreva("Para: ERRO!")
diff --git a/testes/exemplos/dialetos/eguap/media.eguap b/testes/exemplos/dialetos/eguap/media.eguap
new file mode 100644
index 00000000..3f44168b
--- /dev/null
+++ b/testes/exemplos/dialetos/eguap/media.eguap
@@ -0,0 +1,8 @@
+var lista = [1, 5, 8, 3, 5, 6, 4, 7, 6, 8, 5, 4, 9]
+var tamanhoLista = tamanho(lista)
+var valorTotal = 0
+
+para var i = 0; i < tamanhoLista; i = i + 1:
+    valorTotal = valorTotal + lista[i]
+
+escreva("Média: " + valorTotal / tamanhoLista)
diff --git a/testes/exemplos/estruturas-de-repeticao/enquanto.delegua b/testes/exemplos/estruturas-de-repeticao/enquanto.delegua
new file mode 100644
index 00000000..073dbee7
--- /dev/null
+++ b/testes/exemplos/estruturas-de-repeticao/enquanto.delegua
@@ -0,0 +1,11 @@
+var a = 0
+enquanto(a < 5) {
+    a = a + 1
+}
+
+se (a == 5)
+    escreva("Enquanto: OK!")
+senao {
+    escreva("Enquanto: ERRO!")
+}
+escreva(a)
diff --git a/testes/exemplos/estruturas-de-repeticao/para.delegua b/testes/exemplos/estruturas-de-repeticao/para.delegua
new file mode 100644
index 00000000..abb05124
--- /dev/null
+++ b/testes/exemplos/estruturas-de-repeticao/para.delegua
@@ -0,0 +1,11 @@
+var a = 0
+para (var i = 0; i < 5; i = i + 1) {
+    a = a + 1
+}
+
+se (a == 5)
+    escreva("Para: OK!")
+senao {
+    escreva("a: " + a)
+    escreva("Para: ERRO!")
+}
diff --git a/testes/interpretador.test.ts b/testes/interpretador.test.ts
index 4e1055c5..a7d5ed1d 100644
--- a/testes/interpretador.test.ts
+++ b/testes/interpretador.test.ts
@@ -576,7 +576,7 @@ describe('Interpretador', () => {
                     const retornoInterpretador = await delegua.interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
 
                     expect(retornoInterpretador.erros).toHaveLength(1);
-                    expect(retornoInterpretador.erros[0].mensagem).toBe('SuperClasse precisa ser uma classe.');
+                    expect(retornoInterpretador.erros[0].mensagem).toBe('Superclasse precisa ser uma classe.');
                 });
 
                 it('Trivial', async () => {