Repository: DesignLiquido/delegua
Pull request #391 (2023-05-20 14:46:48)

Interpretador birl
Nessa PR eu fiz muitas alterações tanto nos testes como nos arquivos de implementações .

- Adicionando Expressão Para no interpretador
- Corrigindo testes do interpretador
- Corrigindo testes no avaliador sintético  
- Corrigindo código no avaliador sintático
- Corrigindo testes no lexador
- Corrigindo lexador 

github-actions[bot]: <!-- jest coverage report action for options with hash 781087021f8e6c43aac1e668f4520603 -->

## Coverage report 



| <div title="Status of coverage:&#10; 🟢 - ok&#10; 🟡 - slightly more than threshold&#10; 🔴 - under the threshold">St.<sup>:grey_question:</sup></div> | Category   | Percentage                                                     | Covered / Total |
| :----------------------------------------------------------------------------------------------------------------------------------------------------: | :--------- | :------------------------------------------------------------- | :-------------: |
|                                                                           🟡                                                                           | Statements | <div title="Base coverage is: 72.63%">72.14% (-0.49% 🔻)</div> |    5898/8176    |
|                                                                           🟡                                                                           | Branches   | <div title="Base coverage is: 62.38%">60.98% (-1.4% 🔻)</div>  |    1908/3129    |
|                                                                           🟡                                                                           | Functions  | <div title="Base coverage is: 69.99%">69.68% (-0.31% 🔻)</div> |     871/1250    |
|                                                                           🟡                                                                           | Lines      | <div title="Base coverage is: 73.06%">72.59% (-0.47% 🔻)</div> |    5743/7912    |

<details><summary>Show new covered files 🐣</summary>
<br/>

| <div title="Status of coverage:&#10; 🟢 - ok&#10; 🟡 - slightly more than threshold&#10; 🔴 - under the threshold">St.<sup>:grey_question:</sup></div> | File                                                                                    | Statements | Branches | Functions | Lines  |
| :----------------------------------------------------------------------------------------------------------------------------------------------------: | :-------------------------------------------------------------------------------------- | :--------- | :------- | :-------- | :----- |
|                                                                           🟢                                                                           | <div title="construtos/atribuicao-por-indice.ts">`...` / atribuicao-por-indice.ts</div> | 85.71%     | 100%     | 50%       | 85.71% |

</details>


<details><summary>Show files with reduced coverage 🔻</summary>
<br/>

| <div title="Status of coverage:&#10; 🟢 - ok&#10; 🟡 - slightly more than threshold&#10; 🔴 - under the threshold">St.<sup>:grey_question:</sup></div> | File                                                                                                                                    | Statements                                                      | Branches                                                        | Functions                                                      | Lines                                                           |
| :----------------------------------------------------------------------------------------------------------------------------------------------------: | :-------------------------------------------------------------------------------------------------------------------------------------- | :-------------------------------------------------------------- | :-------------------------------------------------------------- | :------------------------------------------------------------- | :-------------------------------------------------------------- |
|                                                                           🟢                                                                           | <div title="construtos/fim-para.ts">`...` / fim-para.ts</div>                                                                           | <div title="Base coverage is: 100%">83.33% (-16.67% 🔻)</div>   | 100%                                                            | <div title="Base coverage is: 100%">50% (-50% 🔻)</div>        | <div title="Base coverage is: 100%">83.33% (-16.67% 🔻)</div>   |
|                                                                           🟢                                                                           | <div title="tradutores/tradutor-javascript.ts">`...` / tradutor-javascript.ts</div>                                                     | <div title="Base coverage is: 95.03%">94.98% (-0.05% 🔻)</div>  | <div title="Base coverage is: 80.59%">80.25% (-0.34% 🔻)</div>  | 97.73%                                                         | <div title="Base coverage is: 95.25%">95.21% (-0.05% 🔻)</div>  |
|                                                                           🟢                                                                           | <div title="avaliador-sintatico/avaliador-sintatico.ts">`...` / avaliador-sintatico.ts</div>                                            | <div title="Base coverage is: 93.01%">93% (-0.02% 🔻)</div>     | 82.35%                                                          | 94.34%                                                         | <div title="Base coverage is: 93.1%">93.08% (-0.02% 🔻)</div>   |
|                                                                           🟡                                                                           | <div title="interpretador/interpretador-base.ts">`...` / interpretador-base.ts</div>                                                    | <div title="Base coverage is: 76.31%">73.55% (-2.76% 🔻)</div>  | <div title="Base coverage is: 70.48%">67.86% (-2.62% 🔻)</div>  | 86.89%                                                         | <div title="Base coverage is: 75.88%">72.99% (-2.88% 🔻)</div>  |
|                                                                           🔴                                                                           | <div title="estruturas/metodo-primitiva.ts">`...` / metodo-primitiva.ts</div>                                                           | <div title="Base coverage is: 100%">28.57% (-71.43% 🔻)</div>   | <div title="Base coverage is: 50%">0% (-50% 🔻)</div>           | <div title="Base coverage is: 100%">0% (-100% 🔻)</div>        | <div title="Base coverage is: 100%">28.57% (-71.43% 🔻)</div>   |
|                                                                           🟢                                                                           | <div title="bibliotecas/primitivas-vetor.ts">`...` / primitivas-vetor.ts</div>                                                          | 100%                                                            | <div title="Base coverage is: 100%">50% (-50% 🔻)</div>         | 100%                                                           | 100%                                                            |
|                                                                           🟡                                                                           | <div title="avaliador-sintatico/dialetos/avaliador-sintatico-birl.ts">`...` / avaliador-sintatico-birl.ts</div>                         | <div title="Base coverage is: 82.8%">78.02% (-4.78% 🔻)</div>   | <div title="Base coverage is: 76.25%">65.56% (-10.69% 🔻)</div> | <div title="Base coverage is: 83.33%">80.56% (-2.78% 🔻)</div> | <div title="Base coverage is: 82.8%">78.02% (-4.78% 🔻)</div>   |
|                                                                           🟢                                                                           | <div title="avaliador-sintatico/dialetos/avaliador-sintatico-visualg.ts">`...` / avaliador-sintatico-visualg.ts</div>                   | <div title="Base coverage is: 94.18%">91.62% (-2.56% 🔻)</div>  | <div title="Base coverage is: 78.21%">75.64% (-2.56% 🔻)</div>  | 97.73%                                                         | <div title="Base coverage is: 94.43%">91.85% (-2.58% 🔻)</div>  |
|                                                                           🟡                                                                           | <div title="lexador/dialetos/lexador-birl.ts">`...` / lexador-birl.ts</div>                                                             | <div title="Base coverage is: 77.78%">77.21% (-0.57% 🔻)</div>  | <div title="Base coverage is: 81.63%">82.35% (+0.72% 🔼)</div>  | 75%                                                            | <div title="Base coverage is: 77.42%">76.87% (-0.55% 🔻)</div>  |
|                                                                           🟡                                                                           | <div title="lexador/dialetos/lexador-portugol-studio.ts">`...` / lexador-portugol-studio.ts</div>                                       | <div title="Base coverage is: 74.03%">73.86% (-0.17% 🔻)</div>  | 71.43%                                                          | 100%                                                           | <div title="Base coverage is: 73.51%">73.33% (-0.18% 🔻)</div>  |
|                                                                           🟢                                                                           | <div title="lexador/dialetos/lexador-visualg.ts">`...` / lexador-visualg.ts</div>                                                       | <div title="Base coverage is: 93.6%">91.2% (-2.4% 🔻)</div>     | <div title="Base coverage is: 94.12%">92.16% (-1.96% 🔻)</div>  | 100%                                                           | <div title="Base coverage is: 93.44%">90.98% (-2.46% 🔻)</div>  |
|                                                                           🔴                                                                           | <div title="interpretador/dialetos/visualg/interpretador-visualg.ts">`...` / interpretador-visualg.ts</div>                             | <div title="Base coverage is: 79.71%">57.38% (-22.33% 🔻)</div> | <div title="Base coverage is: 68%">36.84% (-31.16% 🔻)</div>    | <div title="Base coverage is: 85.71%">76.92% (-8.79% 🔻)</div> | <div title="Base coverage is: 79.41%">56.67% (-22.75% 🔻)</div> |
|                                                                           🟡                                                                           | <div title="interpretador/dialetos/visualg/comum.ts">`...` / comum.ts</div>                                                             | <div title="Base coverage is: 80.34%">65.22% (-15.12% 🔻)</div> | <div title="Base coverage is: 72.34%">64.29% (-8.05% 🔻)</div>  | <div title="Base coverage is: 100%">85.71% (-14.29% 🔻)</div>  | <div title="Base coverage is: 82.73%">67.06% (-15.67% 🔻)</div> |
|                                                                           🔴                                                                           | <div title="interpretador/dialetos/visualg/interpretador-visualg-com-depuracao.ts">`...` / interpretador-visualg-com-depuracao.ts</div> | <div title="Base coverage is: 7.59%">5.94% (-1.65% 🔻)</div>    | 0%                                                              | 0%                                                             | <div title="Base coverage is: 7.59%">5.94% (-1.65% 🔻)</div>    |

</details>

## Test suite run success
458 tests passing in 37 suites.

<p align="right">Report generated by <a href="https://github.com/ArtiomTr/jest-coverage-report-action">🧪jest coverage report action</a> from 4f74c1a9f517b14d7456a3872052c014e35015cd</p>
<!-- Sticky Pull Request Comment -->

Patch:
diff --git a/.vscode/launch.json b/.vscode/launch.json
index d4340fdf..2adc6c22 100644
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -12,7 +12,6 @@
                 "--inspect-brk",
                 "${workspaceRoot}/node_modules/jest/bin/jest.js",
                 "birl/interpretador.test.ts",
-                // "birl/lexador.test.ts",
                 "--runInBand"
             ],
             "console": "integratedTerminal",
diff --git a/fontes/analisador-semantico/analisador-semantico.ts b/fontes/analisador-semantico/analisador-semantico.ts
index 545c3127..41f517de 100644
--- a/fontes/analisador-semantico/analisador-semantico.ts
+++ b/fontes/analisador-semantico/analisador-semantico.ts
@@ -155,7 +155,7 @@ export class AnalisadorSemantico implements AnalisadorSemanticoInterface {
     visitarExpressaoBloco(declaracao: Bloco): Promise<any> {
         return Promise.resolve();
     }
-    
+
     visitarDeclaracaoVar(declaracao: Var): Promise<any> {
         this.variaveis[declaracao.simbolo.lexema] = {
             imutavel: false,
@@ -195,7 +195,7 @@ export class AnalisadorSemantico implements AnalisadorSemanticoInterface {
     visitarExpressaoDeleguaFuncao(expressao: any) {
         return Promise.resolve();
     }
-    visitarExpressaoAtribuicaoSobrescrita(expressao: any): Promise<any> {
+    visitarExpressaoAtribuicaoPorIndice(expressao: any): Promise<any> {
         return Promise.resolve();
     }
     visitarExpressaoAcessoIndiceVariavel(expressao: any) {
diff --git a/fontes/avaliador-sintatico/avaliador-sintatico-base.ts b/fontes/avaliador-sintatico/avaliador-sintatico-base.ts
index 08e142c0..14f7c413 100644
--- a/fontes/avaliador-sintatico/avaliador-sintatico-base.ts
+++ b/fontes/avaliador-sintatico/avaliador-sintatico-base.ts
@@ -108,6 +108,7 @@ export abstract class AvaliadorSintaticoBase implements AvaliadorSintaticoInterf
     abstract chamar(): Construto;
 
     unario(): Construto {
+
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.NEGACAO, tiposDeSimbolos.SUBTRACAO)) {
             const operador = this.simbolos[this.atual - 1];
             const direito = this.unario();
diff --git a/fontes/avaliador-sintatico/avaliador-sintatico.ts b/fontes/avaliador-sintatico/avaliador-sintatico.ts
index 75806a86..07b6a9e5 100644
--- a/fontes/avaliador-sintatico/avaliador-sintatico.ts
+++ b/fontes/avaliador-sintatico/avaliador-sintatico.ts
@@ -3,7 +3,7 @@ import hrtime from 'browser-process-hrtime';
 
 import { AvaliadorSintaticoInterface, ParametroInterface, SimboloInterface } from '../interfaces';
 import {
-    AtribuicaoSobrescrita,
+    AtribuicaoPorIndice,
     Atribuir,
     Binario,
     Chamada,
@@ -458,7 +458,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
 
     /**
      * Método que resolve atribuições.
-     * @returns Um construto do tipo `Atribuir`, `Conjunto` ou `AtribuicaoSobrescrita`.
+     * @returns Um construto do tipo `Atribuir`, `Conjunto` ou `AtribuicaoPorIndice`.
      */
     atribuir(): Construto {
         const expressao = this.ou();
@@ -487,7 +487,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
                 // return new Conjunto(this.hashArquivo, 0, get.objeto, get.simbolo, valor);
                 return new DefinirValor(this.hashArquivo, 0, get.objeto, get.simbolo, valor);
             } else if (expressao instanceof AcessoIndiceVariavel) {
-                return new AtribuicaoSobrescrita(
+                return new AtribuicaoPorIndice(
                     this.hashArquivo,
                     expressao.linha,
                     expressao.entidadeChamada,
@@ -595,12 +595,12 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
     }
 
     protected declaracaoParaCada(simboloPara: SimboloInterface): ParaCada {
-        const nomeVariavelIteracao = this.consumir(tiposDeSimbolos.IDENTIFICADOR, 
+        const nomeVariavelIteracao = this.consumir(tiposDeSimbolos.IDENTIFICADOR,
             "Esperado identificador de variável de iteração para instrução 'para cada'.");
-        
+
         if (!this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.DE, tiposDeSimbolos.EM)) {
             throw this.erro(
-                this.simbolos[this.atual], 
+                this.simbolos[this.atual],
                 "Esperado palavras reservadas 'em' ou 'de' após variável de iteração em instrução 'para cada'."
             );
         }
@@ -609,10 +609,10 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
         const corpo = this.resolverDeclaracao();
 
         return new ParaCada(
-            this.hashArquivo, 
-            Number(simboloPara.linha), 
-            nomeVariavelIteracao.lexema, 
-            vetor, 
+            this.hashArquivo,
+            Number(simboloPara.linha),
+            nomeVariavelIteracao.lexema,
+            vetor,
             corpo
         );
     }
@@ -663,7 +663,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface {
 
             if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CADA)) {
                 return this.declaracaoParaCada(simboloPara);
-            } 
+            }
 
             return this.declaracaoParaTradicional(simboloPara);
         } finally {
diff --git a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-birl.ts b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-birl.ts
index a91f826e..2013d0c6 100644
--- a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-birl.ts
+++ b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-birl.ts
@@ -2,12 +2,13 @@ import {
     AcessoIndiceVariavel,
     AcessoMetodo,
     Agrupamento,
-    AtribuicaoSobrescrita,
+    AtribuicaoPorIndice,
     Atribuir,
     Chamada,
     DefinirValor,
     FuncaoConstruto,
     Literal,
+    Unario,
     Variavel,
 } from '../../construtos';
 import {
@@ -89,9 +90,9 @@ export class AvaliadorSintaticoBirl extends AvaliadorSintaticoBase {
     primario(): Construto {
         const simboloAtual = this.simbolos[this.atual];
 
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.NEGATIVO))
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.SUBTRACAO))
             return new Literal(this.hashArquivo, Number(simboloAtual.linha), false);
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.POSITIVO))
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.ADICAO))
             return new Literal(this.hashArquivo, Number(simboloAtual.linha), true);
 
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IDENTIFICADOR)) {
@@ -137,13 +138,7 @@ export class AvaliadorSintaticoBirl extends AvaliadorSintaticoBase {
                 const get = expressao;
                 return new DefinirValor(this.hashArquivo, 0, get.objeto, get.simbolo, valor);
             } else if (expressao instanceof AcessoIndiceVariavel) {
-                return new AtribuicaoSobrescrita(
-                    this.hashArquivo,
-                    0,
-                    expressao.entidadeChamada,
-                    expressao.indice,
-                    valor
-                );
+                return new AtribuicaoPorIndice(this.hashArquivo, 0, expressao.entidadeChamada, expressao.indice, valor);
             }
             this.erro(igual, 'Tarefa de atribuição inválida');
         }
@@ -199,7 +194,7 @@ export class AvaliadorSintaticoBirl extends AvaliadorSintaticoBase {
             'Esperado expressão `(` após `MAIS` para iniciar o bloco `PARA`.'
         );
 
-        let declaracaoInicial: any = null;
+        let declaracaoInicial: Var | Expressao | null = null;
 
         if (this.simbolos[this.atual].tipo === tiposDeSimbolos.IDENTIFICADOR) {
             this.consumir(
@@ -229,12 +224,10 @@ export class AvaliadorSintaticoBirl extends AvaliadorSintaticoBase {
 
         this.consumir(tiposDeSimbolos.PONTO_E_VIRGULA, 'Esperado expressão `;` após a condição do `PARA`.');
 
-        const incremento: Array<any> = [];
+        const incremento = this.declaracao();
 
-        while (!this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PARENTESE_DIREITO)) {
-            incremento.push(this.simbolos[this.atual]);
-            this.avancarEDevolverAnterior();
-        }
+        this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, 'Esperado expressão `)` após a condição do `PARA`.');
+        this.consumir(tiposDeSimbolos.QUEBRA_LINHA, 'Esperado expressão `QUEBRA_LINHA` após a condição do `PARA`.');
 
         const declaracoes = [];
 
@@ -242,25 +235,18 @@ export class AvaliadorSintaticoBirl extends AvaliadorSintaticoBase {
             declaracoes.push(this.declaracao());
         }
 
-        const incrementoValor = this.tratarSimbolos(incremento);
-
-        const incrementoConstruto: Construto = new Literal(
-            this.hashArquivo,
-            Number(primeiroSimbolo.linha) + 1,
-            incrementoValor as string
-        );
         const corpo = new Bloco(
             this.hashArquivo,
-            Number(primeiroSimbolo.linha) + 1,
+            Number(this.simbolos[this.atual].linha) + 1,
             declaracoes.filter((d) => d)
         );
 
         return new Para(
             this.hashArquivo,
-            Number(primeiroSimbolo.linha),
+            Number(this.simbolos[this.atual].linha),
             declaracaoInicial,
             condicao,
-            incrementoConstruto,
+            incremento,
             corpo
         );
     }
@@ -308,9 +294,6 @@ export class AvaliadorSintaticoBirl extends AvaliadorSintaticoBase {
                 tiposDeSimbolos.IDENTIFICADOR,
                 "Esperado identificador após palavra reservada 'FRANGO'."
             );
-            inicializacoes.push(
-                new Var(identificador, new Literal(this.hashArquivo, Number(simboloCaractere.hashArquivo), 0), 'texto')
-            );
 
             // Inicialização de variáveis que podem ter valor definido;
             let valorInicializacao: string | Array<string>;
@@ -322,15 +305,22 @@ export class AvaliadorSintaticoBirl extends AvaliadorSintaticoBase {
                 );
                 this.consumir(tiposDeSimbolos.TEXTO, "Esperado ' para terminar o texto.");
                 valorInicializacao = String(literalInicializacao.literal);
+                inicializacoes.push(
+                    new Var(
+                        identificador,
+                        new Literal(this.hashArquivo, Number(simboloCaractere.linha), valorInicializacao),
+                        'texto'
+                    )
+                );
+            } else {
+                inicializacoes.push(
+                    new Var(
+                        identificador,
+                        new Literal(this.hashArquivo, Number(simboloCaractere.hashArquivo), 0),
+                        'texto'
+                    )
+                );
             }
-
-            inicializacoes.push(
-                new Var(
-                    identificador,
-                    new Literal(this.hashArquivo, Number(simboloCaractere.linha), valorInicializacao),
-                    'texto'
-                )
-            );
         } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA));
 
         return inicializacoes;
@@ -671,7 +661,6 @@ export class AvaliadorSintaticoBirl extends AvaliadorSintaticoBase {
     }
 
     declaracaoChamaFuncao(): Chamada {
-
         const declaracaoInicio = this.consumir(tiposDeSimbolos.AJUDA, 'Esperado expressão `AJUDA`.');
         this.consumir(tiposDeSimbolos.O, 'Esperado expressão `O` após `AJUDA`.');
         this.consumir(tiposDeSimbolos.MALUCO, 'Esperado expressão `MALUCO` após `O`.');
@@ -691,14 +680,34 @@ export class AvaliadorSintaticoBirl extends AvaliadorSintaticoBase {
         this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, 'Esperado parêntese direito após lista de parâmetros.');
         this.consumir(tiposDeSimbolos.PONTO_E_VIRGULA, 'Esperado ponto e vírgula após a chamada de função.');
 
-
-
         return new Chamada(declaracaoInicio.hashArquivo, expressao, null, paramentros);
     }
 
     declaracao(): any {
         const simboloAtual = this.simbolos[this.atual];
         switch (simboloAtual.tipo) {
+            case tiposDeSimbolos.INCREMENTAR:
+            case tiposDeSimbolos.DECREMENTAR:
+                let adicionaOuSubtrai;
+                if ([tiposDeSimbolos.INCREMENTAR, tiposDeSimbolos.DECREMENTAR].includes(simboloAtual.tipo)) {
+                    adicionaOuSubtrai = this.consumir(
+                        tiposDeSimbolos[simboloAtual.tipo],
+                        'Esperado expressão `INCREMENTAR` ou `DECREMENTAR`.'
+                    );
+                }
+                if (this.verificarTipoSimboloAtual(tiposDeSimbolos.IDENTIFICADOR)) {
+                    const identificador = this.consumir(
+                        tiposDeSimbolos.IDENTIFICADOR,
+                        'Esperado expressão `IDENTIFICADOR`.'
+                    );
+                    return new Unario(
+                        this.hashArquivo,
+                        adicionaOuSubtrai,
+                        new Variavel(this.hashArquivo, identificador),
+                        'ANTES'
+                    );
+                }
+                return;
             case tiposDeSimbolos.BORA:
                 return this.declaracaoRetorna();
             case tiposDeSimbolos.SAI:
@@ -732,6 +741,26 @@ export class AvaliadorSintaticoBirl extends AvaliadorSintaticoBase {
             case tiposDeSimbolos.QUEBRA_LINHA:
                 this.avancarEDevolverAnterior();
                 return null;
+            case tiposDeSimbolos.IDENTIFICADOR:
+                const simboloIdentificador: SimboloInterface = this.simbolos[this.atual];
+                if (
+                    this.simbolos[this.atual + 1] &&
+                    [tiposDeSimbolos.DECREMENTAR, tiposDeSimbolos.INCREMENTAR].includes(
+                        this.simbolos[this.atual + 1].tipo
+                    )
+                ) {
+                    this.avancarEDevolverAnterior();
+                    const simboloIncrementoDecremento: SimboloInterface = this.avancarEDevolverAnterior();
+                    return new Unario(
+                        this.hashArquivo,
+                        simboloIncrementoDecremento,
+                        new Variavel(this.hashArquivo, simboloIdentificador),
+                        'DEPOIS'
+                    );
+                } else {
+                    return this.expressao();
+                }
+
             default:
                 return this.expressao();
         }
diff --git a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-egua-classico.ts b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-egua-classico.ts
index 6e3c9f97..334c195c 100644
--- a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-egua-classico.ts
+++ b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-egua-classico.ts
@@ -1,6 +1,6 @@
 import { AvaliadorSintaticoInterface, SimboloInterface } from '../../interfaces';
 import {
-    AtribuicaoSobrescrita,
+    AtribuicaoPorIndice,
     Atribuir,
     Binario,
     Chamada,
@@ -426,7 +426,7 @@ export class AvaliadorSintaticoEguaClassico implements AvaliadorSintaticoInterfa
                 const get = expressao;
                 return new DefinirValor(this.hashArquivo, 0, get.objeto, get.simbolo, valor);
             } else if (expressao instanceof AcessoIndiceVariavel) {
-                return new AtribuicaoSobrescrita(
+                return new AtribuicaoPorIndice(
                     this.hashArquivo,
                     0,
                     expressao.entidadeChamada,
diff --git a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-eguap.ts b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-eguap.ts
index fa69216a..e3f37523 100644
--- a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-eguap.ts
+++ b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-eguap.ts
@@ -4,7 +4,7 @@ import {
     AcessoIndiceVariavel,
     AcessoMetodo,
     Agrupamento,
-    AtribuicaoSobrescrita,
+    AtribuicaoPorIndice,
     Atribuir,
     Binario,
     Chamada,
@@ -451,7 +451,7 @@ export class AvaliadorSintaticoEguaP implements AvaliadorSintaticoInterface {
             } else if (expressao instanceof AcessoMetodo) {
                 return new DefinirValor(this.hashArquivo, 0, expressao.objeto, expressao.simbolo, valor);
             } else if (expressao instanceof AcessoIndiceVariavel) {
-                return new AtribuicaoSobrescrita(
+                return new AtribuicaoPorIndice(
                     this.hashArquivo,
                     0,
                     expressao.entidadeChamada,
diff --git a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-guarani.ts b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-guarani.ts
index a43a97cd..ca2cf72d 100644
--- a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-guarani.ts
+++ b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-guarani.ts
@@ -1,4 +1,4 @@
-import { AcessoIndiceVariavel, AcessoMetodo, AtribuicaoSobrescrita, Atribuir, Binario, Construto, DefinirValor, FuncaoConstruto, Literal, Variavel } from "../../construtos";
+import { AcessoIndiceVariavel, AcessoMetodo, AtribuicaoPorIndice, Atribuir, Binario, Construto, DefinirValor, FuncaoConstruto, Literal, Variavel } from "../../construtos";
 import { Escreva, Declaracao, Se, Enquanto, Para, Escolha, Fazer } from "../../declaracoes";
 import { RetornoLexador, RetornoAvaliadorSintatico } from "../../interfaces/retornos";
 import { AvaliadorSintaticoBase } from "../avaliador-sintatico-base";
@@ -68,7 +68,7 @@ export class AvaliadorSintaticoGuarani extends AvaliadorSintaticoBase {
                 // return new Conjunto(this.hashArquivo, 0, get.objeto, get.simbolo, valor);
                 return new DefinirValor(this.hashArquivo, 0, get.objeto, get.simbolo, valor);
             } else if (expressao instanceof AcessoIndiceVariavel) {
-                return new AtribuicaoSobrescrita(
+                return new AtribuicaoPorIndice(
                     this.hashArquivo,
                     0,
                     expressao.entidadeChamada,
@@ -176,4 +176,4 @@ export class AvaliadorSintaticoGuarani extends AvaliadorSintaticoBase {
             erros: this.erros,
         } as RetornoAvaliadorSintatico;
     }
-}
\ No newline at end of file
+}
diff --git a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-mapler.ts b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-mapler.ts
index 14856ed1..f85dcf9c 100644
--- a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-mapler.ts
+++ b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-mapler.ts
@@ -17,7 +17,7 @@ import {
 import {
     AcessoIndiceVariavel,
     Agrupamento,
-    AtribuicaoSobrescrita,
+    AtribuicaoPorIndice,
     Atribuir,
     Binario,
     Chamada,
@@ -72,7 +72,7 @@ export class AvaliadorSintaticoMapler extends AvaliadorSintaticoBase {
         return dimensoes;
     }
 
-    private logicaComumParametroMapler(): 
+    private logicaComumParametroMapler():
         { identificadores: SimboloInterface[], tipo: string, simbolo: SimboloInterface }
     {
         const identificadores = [];
@@ -115,7 +115,7 @@ export class AvaliadorSintaticoMapler extends AvaliadorSintaticoBase {
         while (!this.verificarTipoSimboloAtual(tiposDeSimbolos.INICIO)) {
 
             const simboloAtual = this.simbolos[this.atual];
-            
+
             switch (simboloAtual.tipo) {
                 // case tiposDeSimbolos.PROCEDIMENTO:
                 //     const dadosProcedimento = this.declaracaoProcedimento();
@@ -259,7 +259,7 @@ export class AvaliadorSintaticoMapler extends AvaliadorSintaticoBase {
 
     /**
      * Método que resolve atribuições.
-     * @returns Um construto do tipo `Atribuir`, `Conjunto` ou `AtribuicaoSobrescrita`.
+     * @returns Um construto do tipo `Atribuir`, `Conjunto` ou `AtribuicaoPorIndice`.
      */
     atribuir(): Construto {
         const expressao = this.ou();
@@ -272,7 +272,7 @@ export class AvaliadorSintaticoMapler extends AvaliadorSintaticoBase {
                 const simbolo = expressao.simbolo;
                 return new Atribuir(this.hashArquivo, simbolo, valor);
             } else if (expressao instanceof AcessoIndiceVariavel) {
-                return new AtribuicaoSobrescrita(
+                return new AtribuicaoPorIndice(
                     this.hashArquivo,
                     expressao.linha,
                     expressao.entidadeChamada,
@@ -296,9 +296,9 @@ export class AvaliadorSintaticoMapler extends AvaliadorSintaticoBase {
         const declaracoes = [];
 
         // while (![
-        //         tiposDeSimbolos.FIM_FUNCAO, 
+        //         tiposDeSimbolos.FIM_FUNCAO,
         //         tiposDeSimbolos.FIM_PROCEDIMENTO
-        //     ].includes(this.simbolos[this.atual].tipo) && !this.estaNoFinal()) 
+        //     ].includes(this.simbolos[this.atual].tipo) && !this.estaNoFinal())
         // {
         //     declaracoes.push(this.declaracao());
         // }
@@ -380,10 +380,10 @@ export class AvaliadorSintaticoMapler extends AvaliadorSintaticoBase {
         );
 
         return new Enquanto(
-            condicao, 
+            condicao,
             new Bloco(
-                simboloAtual.hashArquivo, 
-                Number(simboloAtual.linha), 
+                simboloAtual.hashArquivo,
+                Number(simboloAtual.linha),
                 declaracoes.filter(d => d)
             )
         );
@@ -599,7 +599,7 @@ export class AvaliadorSintaticoMapler extends AvaliadorSintaticoBase {
 
     //         // Consumir parêntese direito
     //         this.consumir(
-    //             tiposDeSimbolos.PARENTESE_DIREITO, 
+    //             tiposDeSimbolos.PARENTESE_DIREITO,
     //             "Esperado parêntese direito para finalização da leitura de parâmetros."
     //         )
     //     }
@@ -613,7 +613,7 @@ export class AvaliadorSintaticoMapler extends AvaliadorSintaticoBase {
     // declaracaoProcedimento() {
     //     const simboloProcedimento: SimboloInterface = this.avancarEDevolverAnterior();
 
-    //     const nomeProcedimento = this.consumir(tiposDeSimbolos.IDENTIFICADOR, 
+    //     const nomeProcedimento = this.consumir(tiposDeSimbolos.IDENTIFICADOR,
     //         "Esperado nome do procedimento após palavra-chave `procedimento`.");
 
     //     // Parâmetros
@@ -626,9 +626,9 @@ export class AvaliadorSintaticoMapler extends AvaliadorSintaticoBase {
 
     //     return new FuncaoDeclaracao(
     //         nomeProcedimento, new FuncaoConstruto(
-    //             this.hashArquivo, 
-    //             Number(simboloProcedimento.linha), 
-    //             parametros, 
+    //             this.hashArquivo,
+    //             Number(simboloProcedimento.linha),
+    //             parametros,
     //             corpo.filter(d => d)
     //         )
     //     );
@@ -650,19 +650,19 @@ export class AvaliadorSintaticoMapler extends AvaliadorSintaticoBase {
             if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.SENAO)) {
                 const simboloSenao = this.simbolos[this.atual - 1];
                 const declaracoesSenao = [];
-    
+
                 do {
                     declaracoesSenao.push(this.declaracao());
                 } while (![tiposDeSimbolos.FIM].includes(this.simbolos[this.atual].tipo)
                         && ![tiposDeSimbolos.SE].includes(this.simbolos[this.atual + 1].tipo));
-    
+
                 caminhoSenao = new Bloco(
                     this.hashArquivo,
                     Number(simboloSenao.linha),
                     declaracoesSenao.filter((d) => d)
                 );
             }
-        } while (![tiposDeSimbolos.FIM].includes(this.simbolos[this.atual].tipo) 
+        } while (![tiposDeSimbolos.FIM].includes(this.simbolos[this.atual].tipo)
                 && ![tiposDeSimbolos.SE].includes(this.simbolos[this.atual + 1].tipo));
 
         this.consumir(
diff --git a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-portugol-ipt.ts b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-portugol-ipt.ts
index 938c97fe..079f0b38 100644
--- a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-portugol-ipt.ts
+++ b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-portugol-ipt.ts
@@ -1,4 +1,4 @@
-import { AcessoIndiceVariavel, AtribuicaoSobrescrita, Atribuir, Construto, FormatacaoEscrita, FuncaoConstruto, Literal, Variavel } from "../../construtos";
+import { AcessoIndiceVariavel, AtribuicaoPorIndice, Atribuir, Construto, FormatacaoEscrita, FuncaoConstruto, Literal, Variavel } from "../../construtos";
 import { Escreva, Declaracao, Se, Enquanto, Para, Escolha, Fazer, EscrevaMesmaLinha, Var, Leia } from "../../declaracoes";
 import { RetornoLexador, RetornoAvaliadorSintatico } from "../../interfaces/retornos";
 import { AvaliadorSintaticoBase } from "../avaliador-sintatico-base";
@@ -41,7 +41,7 @@ export class AvaliadorSintaticoPortugolIpt extends AvaliadorSintaticoBase {
                 const simbolo = expressao.simbolo;
                 return new Atribuir(this.hashArquivo, simbolo, valor);
             } else if (expressao instanceof AcessoIndiceVariavel) {
-                return new AtribuicaoSobrescrita(
+                return new AtribuicaoPorIndice(
                     this.hashArquivo,
                     expressao.linha,
                     expressao.entidadeChamada,
@@ -215,4 +215,4 @@ export class AvaliadorSintaticoPortugolIpt extends AvaliadorSintaticoBase {
             erros: this.erros,
         } as RetornoAvaliadorSintatico;
     }
-}
\ No newline at end of file
+}
diff --git a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-portugol-studio.ts b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-portugol-studio.ts
index 896e1c0b..da5e1478 100644
--- a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-portugol-studio.ts
+++ b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-portugol-studio.ts
@@ -1,6 +1,6 @@
 import {
     AcessoIndiceVariavel,
-    AtribuicaoSobrescrita,
+    AtribuicaoPorIndice,
     Atribuir,
     Chamada,
     Construto,
@@ -133,7 +133,7 @@ export class AvaliadorSintaticoPortugolStudio extends AvaliadorSintaticoBase {
                 const simbolo = expressao.simbolo;
                 return new Atribuir(this.hashArquivo, simbolo, valor);
             } else if (expressao instanceof AcessoIndiceVariavel) {
-                return new AtribuicaoSobrescrita(
+                return new AtribuicaoPorIndice(
                     this.hashArquivo,
                     expressao.linha,
                     expressao.entidadeChamada,
diff --git a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-visualg.ts b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-visualg.ts
index 15078d11..d7acc884 100644
--- a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-visualg.ts
+++ b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-visualg.ts
@@ -20,7 +20,7 @@ import {
 import {
     AcessoIndiceVariavel,
     Agrupamento,
-    AtribuicaoSobrescrita,
+    AtribuicaoPorIndice,
     Atribuir,
     Binario,
     Chamada,
@@ -99,7 +99,7 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
         return dimensoes;
     }
 
-    private logicaComumParametroVisuAlg(): 
+    private logicaComumParametroVisuAlg():
         { identificadores: SimboloInterface[], tipo: string, simbolo: SimboloInterface }
     {
         const identificadores = [];
@@ -330,7 +330,7 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
 
     /**
      * Método que resolve atribuições.
-     * @returns Um construto do tipo `Atribuir`, `Conjunto` ou `AtribuicaoSobrescrita`.
+     * @returns Um construto do tipo `Atribuir`, `Conjunto` ou `AtribuicaoPorIndice`.
      */
     atribuir(): Construto {
         const expressao = this.ou();
@@ -343,7 +343,7 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
                 const simbolo = expressao.simbolo;
                 return new Atribuir(this.hashArquivo, simbolo, valor);
             } else if (expressao instanceof AcessoIndiceVariavel) {
-                return new AtribuicaoSobrescrita(
+                return new AtribuicaoPorIndice(
                     this.hashArquivo,
                     expressao.linha,
                     expressao.entidadeChamada,
@@ -367,9 +367,9 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
         const declaracoes = [];
 
         while (![
-                tiposDeSimbolos.FIM_FUNCAO, 
+                tiposDeSimbolos.FIM_FUNCAO,
                 tiposDeSimbolos.FIM_PROCEDIMENTO
-            ].includes(this.simbolos[this.atual].tipo) && !this.estaNoFinal()) 
+            ].includes(this.simbolos[this.atual].tipo) && !this.estaNoFinal())
         {
             declaracoes.push(this.declaracao());
         }
@@ -427,9 +427,9 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
             .concat(this.blocoEscopo());
 
         return new FuncaoConstruto(
-            this.hashArquivo, 
-            Number(simboloAnterior.linha), 
-            parametros, 
+            this.hashArquivo,
+            Number(simboloAnterior.linha),
+            parametros,
             corpo.filter(d => d)
         );
     }
@@ -462,10 +462,10 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
         this.consumir(tiposDeSimbolos.QUEBRA_LINHA, "Esperado quebra de linha após palavra-chave 'fimenquanto'.");
 
         return new Enquanto(
-            condicao, 
+            condicao,
             new Bloco(
-                simboloAtual.hashArquivo, 
-                Number(simboloAtual.linha), 
+                simboloAtual.hashArquivo,
+                Number(simboloAtual.linha),
                 declaracoes.filter(d => d)
             )
         );
@@ -539,7 +539,7 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
         }
 
         if (simboloAtualBlocoCaso.tipo !== tiposDeSimbolos.FIM_ESCOLHA) {
-            throw this.erro(this.simbolos[this.atual], 
+            throw this.erro(this.simbolos[this.atual],
                 "Esperado palavra-chave 'fimescolha' para fechamento de declaração 'escolha'.");
         }
 
@@ -559,8 +559,8 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
         if (this.simbolos[this.atual].tipo === tiposDeSimbolos.PARENTESE_DIREITO) {
             this.avancarEDevolverAnterior();
             return [new FormatacaoEscrita(
-                this.hashArquivo, 
-                Number(simboloParenteses.linha), 
+                this.hashArquivo,
+                Number(simboloParenteses.linha),
                 new Literal(this.hashArquivo, Number(simboloParenteses.linha), ''))
             ]
         }
@@ -721,7 +721,7 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
 
         // Isso existe porque o laço `para` do VisuAlg pode ter o passo positivo ou negativo
         // dependendo dos operandos de início e fim, que só são possíveis de determinar
-        // em tempo de execução. 
+        // em tempo de execução.
         // Quando um dos operandos é uma variável, tanto a condição do laço quanto o
         // passo são considerados indefinidos aqui.
         let passo: Construto;
@@ -732,14 +732,14 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
             if (literalOuVariavelInicio instanceof Literal && literalOuVariavelFim instanceof Literal) {
                 if (literalOuVariavelInicio.valor > literalOuVariavelFim.valor) {
                     passo = new Unario(
-                        this.hashArquivo, 
+                        this.hashArquivo,
                         new Simbolo(
-                            tiposDeSimbolos.SUBTRACAO, 
-                            '-', 
-                            undefined, 
-                            simboloPara.linha, 
+                            tiposDeSimbolos.SUBTRACAO,
+                            '-',
+                            undefined,
+                            simboloPara.linha,
                             simboloPara.hashArquivo
-                        ), 
+                        ),
                         new Literal(this.hashArquivo, Number(simboloPara.linha), 1),
                         "ANTES");
                     operadorCondicao = new Simbolo(tiposDeSimbolos.MAIOR_IGUAL, '', '', Number(simboloPara.linha), this.hashArquivo);
@@ -797,8 +797,8 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
                 literalOuVariavelFim
             ),
             new FimPara(
-                this.hashArquivo, 
-                Number(simboloPara.linha), 
+                this.hashArquivo,
+                Number(simboloPara.linha),
                 new Binario(
                     this.hashArquivo,
                     new Variavel(this.hashArquivo, variavelIteracao),
@@ -840,7 +840,7 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
 
             // Consumir parêntese direito
             this.consumir(
-                tiposDeSimbolos.PARENTESE_DIREITO, 
+                tiposDeSimbolos.PARENTESE_DIREITO,
                 "Esperado parêntese direito para finalização da leitura de parâmetros."
             )
         }
@@ -854,7 +854,7 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
     declaracaoProcedimento() {
         const simboloProcedimento: SimboloInterface = this.avancarEDevolverAnterior();
 
-        const nomeProcedimento = this.consumir(tiposDeSimbolos.IDENTIFICADOR, 
+        const nomeProcedimento = this.consumir(tiposDeSimbolos.IDENTIFICADOR,
             "Esperado nome do procedimento após palavra-chave `procedimento`.");
 
         // Parâmetros
@@ -867,11 +867,11 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
             .concat(this.blocoEscopo());
 
         return new FuncaoDeclaracao(
-            nomeProcedimento, 
+            nomeProcedimento,
             new FuncaoConstruto(
-                this.hashArquivo, 
-                Number(simboloProcedimento.linha), 
-                parametros, 
+                this.hashArquivo,
+                Number(simboloProcedimento.linha),
+                parametros,
                 corpo.filter(d => d)
             )
         );
@@ -997,8 +997,8 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
      * - O primeiro símbolo é `algoritmo`, seguido por um identificador e
      * uma quebra de linha.
      * - Os próximos símbolo pode `var`, que pode ser seguido por uma série de
-     * declarações de variáveis e finalizado por uma quebra de linha, 
-     * ou ainda `funcao` ou `procedimento`, seguidos dos devidos símbolos que definem 
+     * declarações de variáveis e finalizado por uma quebra de linha,
+     * ou ainda `funcao` ou `procedimento`, seguidos dos devidos símbolos que definem
      * os blocos.
      * - O penúltimo símbolo é `inicio`, seguido por uma quebra de linha.
      * Pode haver ou não declarações dentro do bloco.
@@ -1021,7 +1021,7 @@ export class AvaliadorSintaticoVisuAlg extends AvaliadorSintaticoBase {
         }
 
         let declaracoes = [];
-        this.validarSegmentoAlgoritmo();        
+        this.validarSegmentoAlgoritmo();
 
         while (!this.estaNoFinal() && this.simbolos[this.atual].tipo !== tiposDeSimbolos.FIM_ALGORITMO) {
             const declaracao = this.declaracao();
diff --git a/fontes/construtos/atribuicao-sobrescrita.ts b/fontes/construtos/atribuicao-por-indice.ts
similarity index 79%
rename from fontes/construtos/atribuicao-sobrescrita.ts
rename to fontes/construtos/atribuicao-por-indice.ts
index a689ab3d..d7587980 100644
--- a/fontes/construtos/atribuicao-sobrescrita.ts
+++ b/fontes/construtos/atribuicao-por-indice.ts
@@ -1,7 +1,7 @@
 import { VisitanteComumInterface } from '../interfaces'
 import { Construto } from './construto';
 
-export class AtribuicaoSobrescrita implements Construto {
+export class AtribuicaoPorIndice implements Construto {
     linha: number;
     hashArquivo: number;
 
@@ -19,6 +19,6 @@ export class AtribuicaoSobrescrita implements Construto {
     }
 
     async aceitar(visitante: VisitanteComumInterface): Promise<any> {
-        return await visitante.visitarExpressaoAtribuicaoSobrescrita(this);
+        return await visitante.visitarExpressaoAtribuicaoPorIndice(this);
     }
 }
diff --git a/fontes/construtos/index.ts b/fontes/construtos/index.ts
index f23cb80d..5cfaf16d 100644
--- a/fontes/construtos/index.ts
+++ b/fontes/construtos/index.ts
@@ -1,4 +1,4 @@
-export * from './atribuicao-sobrescrita';
+export * from './atribuicao-por-indice';
 export * from './atribuir';
 export * from './binario';
 export * from './chamada';
diff --git a/fontes/interfaces/resolvedor-interface.ts b/fontes/interfaces/resolvedor-interface.ts
index 28f1c6f6..84c5439a 100644
--- a/fontes/interfaces/resolvedor-interface.ts
+++ b/fontes/interfaces/resolvedor-interface.ts
@@ -34,7 +34,7 @@ export interface ResolvedorInterface {
     visitarExpressaoAcessoIndiceVariavel(expressao: any): any;
     visitarExpressaoContinua(declaracao?: any): any;
     visitarExpressaoSustar(declaracao?: any): any;
-    visitarExpressaoAtribuicaoSobrescrita(expressao?: any): any;
+    visitarExpressaoAtribuicaoPorIndice(expressao?: any): any;
     visitarExpressaoLiteral(expressao?: any): any;
     visitarExpressaoLogica(expressao?: any): any;
     visitarExpressaoUnaria(expressao?: any): any;
diff --git a/fontes/interfaces/visitante-comum-interface.ts b/fontes/interfaces/visitante-comum-interface.ts
index e54a0c3b..5b460b35 100644
--- a/fontes/interfaces/visitante-comum-interface.ts
+++ b/fontes/interfaces/visitante-comum-interface.ts
@@ -57,7 +57,7 @@ export interface VisitanteComumInterface {
     visitarExpressaoSustar(declaracao?: Sustar): SustarQuebra;
     visitarExpressaoRetornar(declaracao: Retorna): Promise<RetornoQuebra>;
     visitarExpressaoDeleguaFuncao(expressao: any): any;
-    visitarExpressaoAtribuicaoSobrescrita(expressao: any): Promise<any>;
+    visitarExpressaoAtribuicaoPorIndice(expressao: any): Promise<any>;
     visitarExpressaoAcessoIndiceVariavel(expressao: any): any;
     visitarExpressaoDefinirValor(expressao: any): any;
     visitarDeclaracaoDefinicaoFuncao(declaracao: FuncaoDeclaracao): any;
@@ -67,4 +67,4 @@ export interface VisitanteComumInterface {
     visitarExpressaoDicionario(expressao: any): any;
     visitarExpressaoVetor(expressao: any): any;
     visitarExpressaoSuper(expressao: Super): any;
-}
\ No newline at end of file
+}
diff --git a/fontes/interpretador/dialetos/birl/interpretador-birl.ts b/fontes/interpretador/dialetos/birl/interpretador-birl.ts
index 61174fcd..6ccc0e94 100644
--- a/fontes/interpretador/dialetos/birl/interpretador-birl.ts
+++ b/fontes/interpretador/dialetos/birl/interpretador-birl.ts
@@ -1,4 +1,4 @@
-import { Construto, Atribuir, Literal, FimPara, FormatacaoEscrita, Super } from '../../../construtos';
+import { Construto, Atribuir, Literal, FimPara, FormatacaoEscrita, Super, Variavel, Unario } from '../../../construtos';
 import {
     Declaracao,
     Expressao,
@@ -25,13 +25,15 @@ import {
 import { EspacoVariaveis } from '../../../espaco-variaveis';
 import { ObjetoPadrao } from '../../../estruturas';
 import { ErroEmTempoDeExecucao } from '../../../excecoes';
-import { InterpretadorInterface } from '../../../interfaces';
+import { InterpretadorInterface, SimboloInterface, VariavelInterface } from '../../../interfaces';
 import { ErroInterpretador } from '../../../interfaces/erros/erro-interpretador';
 import { EscopoExecucao } from '../../../interfaces/escopo-execucao';
 import { PilhaEscoposExecucaoInterface } from '../../../interfaces/pilha-escopos-execucao-interface';
 import { RetornoInterpretador } from '../../../interfaces/retornos';
 import { ContinuarQuebra, SustarQuebra, RetornoQuebra, Quebra } from '../../../quebras';
+import { inferirTipoVariavel } from '../../inferenciador';
 import { PilhaEscoposExecucao } from '../../pilha-escopos-execucao';
+import tiposDeSimbolos from '../../../tipos-de-simbolos/birl';
 
 export class InterpretadorBirl implements InterpretadorInterface {
     diretorioBase: any;
@@ -65,10 +67,9 @@ export class InterpretadorBirl implements InterpretadorInterface {
             ambiente: new EspacoVariaveis(),
             finalizado: false,
             tipo: 'outro',
-            emLacoRepeticao: false
+            emLacoRepeticao: false,
         };
         this.pilhaEscoposExecucao.empilhar(escopoExecucao);
-
     }
 
     async avaliar(expressao: Construto | Declaracao): Promise<any> {
@@ -80,19 +81,231 @@ export class InterpretadorBirl implements InterpretadorInterface {
             console.log('Aqui');
         } */
 
-        return await expressao.aceitar(this);
+        return await expressao. aceitar(this);
     }
-    executarBloco(declaracoes: Declaracao[], ambiente?: EspacoVariaveis): Promise<any> {
-        throw new Error('Método não implementado.');
+    /**
+     * Empilha declarações na pilha de escopos de execução, cria um novo ambiente e
+     * executa as declarações empilhadas.
+     * Se o retorno do último bloco foi uma exceção (normalmente um erro em tempo de execução),
+     * atira a exceção daqui.
+     * Isso é usado, por exemplo, em blocos tente ... pegue ... finalmente.
+     * @param declaracoes Um vetor de declaracoes a ser executado.
+     * @param ambiente O ambiente de execução quando houver, como parâmetros, argumentos, etc.
+     */
+    async executarBloco(declaracoes: Declaracao[], ambiente?: EspacoVariaveis): Promise<any> {
+        const escopoExecucao: EscopoExecucao = {
+            declaracoes: declaracoes,
+            declaracaoAtual: 0,
+            ambiente: ambiente || new EspacoVariaveis(),
+            finalizado: false,
+            tipo: 'outro',
+            emLacoRepeticao: false,
+        };
+        this.pilhaEscoposExecucao.empilhar(escopoExecucao);
+        const retornoUltimoEscopo: any = await this.executarUltimoEscopo();
+        if (retornoUltimoEscopo instanceof ErroEmTempoDeExecucao) {
+            return Promise.reject(retornoUltimoEscopo);
+        }
+        return retornoUltimoEscopo;
     }
     visitarExpressaoAgrupamento(expressao: any): Promise<any> {
         throw new Error('Método não implementado.');
     }
-    visitarExpressaoUnaria(expressao: any) {
-        throw new Error('Método não implementado.');
+
+    protected verificarOperandoNumero(operador: SimboloInterface, operando: any): void {
+        if (typeof operando === 'number' || operando.tipo === 'número') return;
+        throw new ErroEmTempoDeExecucao(operador, 'Operando precisa ser um número.', Number(operador.linha));
+    }
+
+    async visitarExpressaoUnaria(expressao: Unario): Promise<any> {
+        const operando = await this.avaliar(expressao.operando);
+        let valor: any = operando.hasOwnProperty('valor') ? operando.valor : operando;
+
+        switch (expressao.operador.tipo) {
+            case tiposDeSimbolos.SUBTRACAO:
+                this.verificarOperandoNumero(expressao.operador, valor);
+                return -valor;
+            case tiposDeSimbolos.NEGACAO:
+                return !this.eVerdadeiro(valor);
+            case tiposDeSimbolos.BIT_NOT:
+                return ~valor;
+            // Para incrementar e decrementar, primeiro precisamos saber se o operador
+            // veio antes do literal ou variável.
+            // Se veio antes e o operando é uma variável, precisamos incrementar/decrementar,
+            // armazenar o valor da variável pra só então devolver o valor.
+            case tiposDeSimbolos.INCREMENTAR:
+                if (expressao.incidenciaOperador === 'ANTES') {
+                    valor++;
+                    if (expressao.operando instanceof Variavel) {
+                        this.pilhaEscoposExecucao.atribuirVariavel(expressao.operando.simbolo, valor);
+                    }
+
+                    return valor;
+                }
+
+                const valorAnteriorIncremento = valor;
+                this.pilhaEscoposExecucao.atribuirVariavel(expressao.operando.simbolo, ++valor);
+                return valorAnteriorIncremento;
+            case tiposDeSimbolos.DECREMENTAR:
+                if (expressao.incidenciaOperador === 'ANTES') {
+                    valor--;
+                    if (expressao.operando instanceof Variavel) {
+                        this.pilhaEscoposExecucao.atribuirVariavel(expressao.operando.simbolo, valor);
+                    }
+
+                    return valor;
+                }
+
+                const valorAnteriorDecremento = valor;
+                this.pilhaEscoposExecucao.atribuirVariavel(expressao.operando.simbolo, --valor);
+                return valorAnteriorDecremento;
+        }
+
+        return null;
     }
-    visitarExpressaoBinaria(expressao: any) {
-        throw new Error('Método não implementado.');
+
+    protected eIgual(esquerda: VariavelInterface | any, direita: VariavelInterface | any): boolean {
+        if (esquerda === null && direita === null) return true;
+        if (esquerda === null) return false;
+        return esquerda === direita;
+    }
+
+    /**
+     * Verifica se operandos são números, que podem ser tanto variáveis puras do JavaScript
+     * (neste caso, `number`), ou podem ser variáveis de Delégua com inferência (`VariavelInterface`).
+     * @param operador O símbolo do operador.
+     * @param direita O operando direito.
+     * @param esquerda O operando esquerdo.
+     * @returns Se ambos os operandos são números ou não.
+     */
+    protected verificarOperandosNumeros(
+        operador: SimboloInterface,
+        direita: VariavelInterface | any,
+        esquerda: VariavelInterface | any
+    ): void {
+        const tipoDireita: string = direita.tipo ? direita.tipo : typeof direita === 'number' ? 'número' : String(NaN);
+        const tipoEsquerda: string = esquerda.tipo
+            ? esquerda.tipo
+            : typeof esquerda === 'number'
+            ? 'número'
+            : String(NaN);
+        if (tipoDireita === 'número' && tipoEsquerda === 'número') return;
+        throw new ErroEmTempoDeExecucao(operador, 'Operadores precisam ser números.', operador.linha);
+    }
+
+    async visitarExpressaoBinaria(expressao: any): Promise<any> {
+        try {
+            const esquerda: VariavelInterface | any = await this.avaliar(expressao.esquerda);
+            const direita: VariavelInterface | any = await this.avaliar(expressao.direita);
+            const valorEsquerdo: any = esquerda?.hasOwnProperty('valor') ? esquerda.valor : esquerda;
+            const valorDireito: any = direita?.hasOwnProperty('valor') ? direita.valor : direita;
+            const tipoEsquerdo: string = esquerda?.hasOwnProperty('tipo')
+                ? esquerda.tipo
+                : inferirTipoVariavel(esquerda);
+            const tipoDireito: string = direita?.hasOwnProperty('tipo') ? direita.tipo : inferirTipoVariavel(direita);
+
+            switch (expressao.operador.tipo) {
+                case tiposDeSimbolos.EXPONENCIACAO:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Math.pow(valorEsquerdo, valorDireito);
+
+                case tiposDeSimbolos.MAIOR:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) > Number(valorDireito);
+
+                case tiposDeSimbolos.MAIOR_IGUAL:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) >= Number(valorDireito);
+
+                case tiposDeSimbolos.MENOR:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) < Number(valorDireito);
+
+                case tiposDeSimbolos.MENOR_IGUAL:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) <= Number(valorDireito);
+
+                case tiposDeSimbolos.SUBTRACAO:
+                case tiposDeSimbolos.MENOS_IGUAL:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) - Number(valorDireito);
+
+                case tiposDeSimbolos.ADICAO:
+                case tiposDeSimbolos.MAIS_IGUAL:
+                    if (tipoEsquerdo === 'número' && tipoDireito === 'número') {
+                        return Number(valorEsquerdo) + Number(valorDireito);
+                    } else {
+                        return String(valorEsquerdo) + String(valorDireito);
+                    }
+
+                case tiposDeSimbolos.DIVISAO:
+                case tiposDeSimbolos.DIVISAO_IGUAL:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) / Number(valorDireito);
+
+                case tiposDeSimbolos.DIVISAO_INTEIRA:
+                case tiposDeSimbolos.DIVISAO_INTEIRA_IGUAL:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Math.floor(Number(valorEsquerdo) / Number(valorDireito));
+
+                case tiposDeSimbolos.MULTIPLICACAO:
+                case tiposDeSimbolos.MULTIPLICACAO_IGUAL:
+                    if (tipoEsquerdo === 'texto' || tipoDireito === 'texto') {
+                        // Sem ambos os valores resolvem como texto, multiplica normal.
+                        // Se apenas um resolve como texto, o outro repete o
+                        // texto n vezes, sendo n o valor do outro.
+                        if (tipoEsquerdo === 'texto' && tipoDireito === 'texto') {
+                            return Number(valorEsquerdo) * Number(valorDireito);
+                        }
+
+                        if (tipoEsquerdo === 'texto') {
+                            return valorEsquerdo.repeat(Number(valorDireito));
+                        }
+
+                        return valorDireito.repeat(Number(valorEsquerdo));
+                    }
+
+                    return Number(valorEsquerdo) * Number(valorDireito);
+
+                case tiposDeSimbolos.MODULO:
+                case tiposDeSimbolos.MODULO_IGUAL:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) % Number(valorDireito);
+
+                case tiposDeSimbolos.BIT_AND:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) & Number(valorDireito);
+
+                case tiposDeSimbolos.BIT_XOR:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) ^ Number(valorDireito);
+
+                case tiposDeSimbolos.BIT_OR:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) | Number(valorDireito);
+
+                case tiposDeSimbolos.MENOR_MENOR:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) << Number(valorDireito);
+
+                case tiposDeSimbolos.MAIOR_MAIOR:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) >> Number(valorDireito);
+
+                case tiposDeSimbolos.DIFERENTE:
+                    return !this.eIgual(valorEsquerdo, valorDireito);
+
+                case tiposDeSimbolos.IGUAL_IGUAL:
+                    return this.eIgual(valorEsquerdo, valorDireito);
+            }
+        } catch (erro: any) {
+            this.erros.push({
+                erroInterno: erro,
+                linha: expressao.linha,
+                hashArquivo: expressao.hashArquivo,
+            });
+            return Promise.reject(erro);
+        }
     }
     visitarExpressaoDeChamada(expressao: any) {
         throw new Error('Método não implementado.');
@@ -100,8 +313,13 @@ export class InterpretadorBirl implements InterpretadorInterface {
     visitarDeclaracaoDeAtribuicao(expressao: Atribuir) {
         throw new Error('Método não implementado.');
     }
-    visitarExpressaoDeVariavel(expressao: any) {
-        throw new Error('Método não implementado.');
+
+    protected procurarVariavel(simbolo: SimboloInterface): any {
+        return this.pilhaEscoposExecucao.obterValorVariavel(simbolo);
+    }
+
+    visitarExpressaoDeVariavel(expressao: Variavel): any {
+        return this.procurarVariavel(expressao.simbolo);
     }
     visitarDeclaracaoDeExpressao(declaracao: Expressao) {
         throw new Error('Método não implementado.');
@@ -138,13 +356,13 @@ export class InterpretadorBirl implements InterpretadorInterface {
         });
     }
 
-     /**
+    /**
      * Retira a interpolação de um texto.
      * @param {texto} texto O texto
      * @param {any[]} variaveis A lista de variaveis interpoladas
      * @returns O texto com o valor das variaveis.
      */
-     private retirarInterpolacao(texto: string, variaveis: any[]): string {
+    private retirarInterpolacao(texto: string, variaveis: any[]): string {
         const valoresVariaveis = variaveis.map((v) => ({
             valorResolvido: this.pilhaEscoposExecucao.obterVariavelPorNome(v.variavel),
             variavel: v.variavel,
@@ -163,22 +381,58 @@ export class InterpretadorBirl implements InterpretadorInterface {
         return textoFinal;
     }
 
-
     visitarExpressaoLiteral(expressao: Literal): any {
-        if (this.regexInterpolacao.test(expressao.valor)) {
-            const variaveis = this.buscarVariaveisInterpolacao(expressao.valor);
-
-            return this.retirarInterpolacao(expressao.valor, variaveis);
+        if (expressao.valor === tiposDeSimbolos.ADICAO) {
+            return 1
+        } else if (expressao.valor === tiposDeSimbolos.SUBTRACAO) {
+            return -1
+        } else {
+            return expressao.valor;
         }
-
-        return expressao.valor;
     }
 
     visitarExpressaoLogica(expressao: any) {
         throw new Error('Método não implementado.');
     }
-    visitarDeclaracaoPara(declaracao: Para): Promise<any> {
-        throw new Error('Método não implementado.');
+    async visitarDeclaracaoPara(declaracao: Para): Promise<any> {
+        if (declaracao.inicializador !== null) {
+            if (declaracao.inicializador instanceof Array) {
+                await this.avaliar(declaracao.inicializador[0]);
+            } else {
+                await this.avaliar(declaracao.inicializador);
+            }
+        }
+
+        let retornoExecucao: any;
+        while (!(retornoExecucao instanceof Quebra)) {
+            if (declaracao.condicao !== null && !this.eVerdadeiro(await this.avaliar(declaracao.condicao))) {
+                break;
+            }
+
+            try {
+                retornoExecucao = await this.executar(declaracao.corpo);
+                if (retornoExecucao instanceof SustarQuebra) {
+                    return null;
+                }
+
+                if (retornoExecucao instanceof ContinuarQuebra) {
+                    retornoExecucao = null;
+                }
+            } catch (erro: any) {
+                this.erros.push({
+                    erroInterno: erro,
+                    linha: declaracao.linha,
+                    hashArquivo: declaracao.hashArquivo,
+                });
+                return Promise.reject(erro);
+            }
+
+            if (declaracao.incrementar !== null) {
+                await this.avaliar(declaracao.incrementar);
+            }
+        }
+
+        return retornoExecucao;
     }
     visitarDeclaracaoParaCada(declaracao: ParaCada): Promise<any> {
         throw new Error('Método não implementado.');
@@ -278,14 +532,14 @@ export class InterpretadorBirl implements InterpretadorInterface {
     visitarExpressaoEscrevaMesmaLinha(declaracao: EscrevaMesmaLinha) {
         throw new Error('Método não implementado.');
     }
-    visitarExpressaoBloco(declaracao: Bloco): Promise<any> {
-        throw new Error('Método não implementado.');
+    async visitarExpressaoBloco(declaracao: Bloco): Promise<any> {
+        return await this.executarBloco(declaracao.declaracoes);
     }
 
     protected async avaliacaoDeclaracaoVar(declaracao: Var): Promise<any> {
         let valorOuOutraVariavel = null;
         if (declaracao.inicializador !== null) {
-            valorOuOutraVariavel = await this.avaliar(declaracao.inicializador);
+            valorOuOutraVariavel = await this. avaliar(declaracao.inicializador);
         }
 
         let valorFinal = null;
@@ -334,7 +588,7 @@ export class InterpretadorBirl implements InterpretadorInterface {
     visitarExpressaoDeleguaFuncao(expressao: any) {
         throw new Error('Método não implementado.');
     }
-    visitarExpressaoAtribuicaoSobrescrita(expressao: any): Promise<any> {
+    visitarExpressaoAtribuicaoPorIndice(expressao: any): Promise<any> {
         throw new Error('Método não implementado.');
     }
     visitarExpressaoAcessoIndiceVariavel(expressao: any) {
@@ -393,14 +647,23 @@ export class InterpretadorBirl implements InterpretadorInterface {
      *                         pelo modo LAIR.
      */
     async executar(declaracao: Declaracao, mostrarResultado = false): Promise<any> {
-        const resultado: any = await declaracao.aceitar(this);
-        if (mostrarResultado) {
-            this.funcaoDeRetorno(this.paraTexto(resultado));
-        }
-        if (resultado || typeof resultado === 'boolean') {
-            this.resultadoInterpretador.push(this.paraTexto(resultado));
+        let resultado: any = null;
+        // Tratar caso Bloco
+        if (declaracao instanceof Array) {
+            for (const decl of declaracao) {
+                resultado = await this.executar(decl, mostrarResultado);
+            }
+            return resultado;
+        } else {
+            resultado = await declaracao.aceitar(this);
+            if (mostrarResultado) {
+                this.funcaoDeRetorno(this.paraTexto(resultado));
+            }
+            if (resultado || typeof resultado === 'boolean') {
+                this.resultadoInterpretador.push(this.paraTexto(resultado));
+            }
+            return resultado;
         }
-        return resultado;
     }
 
     /**
diff --git a/fontes/interpretador/dialetos/egua-classico/interpretador-egua-classico.ts b/fontes/interpretador/dialetos/egua-classico/interpretador-egua-classico.ts
index ac8b18e6..8a326e25 100644
--- a/fontes/interpretador/dialetos/egua-classico/interpretador-egua-classico.ts
+++ b/fontes/interpretador/dialetos/egua-classico/interpretador-egua-classico.ts
@@ -86,15 +86,15 @@ export class InterpretadorEguaClassico implements InterpretadorInterface {
 
         carregarBibliotecaGlobal(this, this.pilhaEscoposExecucao);
     }
-    
+
     visitarDeclaracaoParaCada(declaracao: ParaCada): Promise<any> {
         throw new Error('Método não implementado.');
     }
-    
+
     visitarDeclaracaoConst(declaracao: Const): Promise<any> {
         throw new Error('Método não implementado.');
     }
-    
+
     visitarExpressaoFimPara(declaracao: FimPara) {
         throw new Error('Método não implementado.');
     }
@@ -651,7 +651,7 @@ export class InterpretadorEguaClassico implements InterpretadorInterface {
         return new DeleguaFuncao(null, expressao);
     }
 
-    async visitarExpressaoAtribuicaoSobrescrita(expressao: any) {
+    async visitarExpressaoAtribuicaoPorIndice(expressao: any) {
         const objeto = await this.avaliar(expressao.objeto);
         let indice = await this.avaliar(expressao.indice);
         const valor = await this.avaliar(expressao.valor);
diff --git a/fontes/interpretador/dialetos/egua-classico/resolvedor/resolvedor.ts b/fontes/interpretador/dialetos/egua-classico/resolvedor/resolvedor.ts
index 12b79c15..8360f3f9 100644
--- a/fontes/interpretador/dialetos/egua-classico/resolvedor/resolvedor.ts
+++ b/fontes/interpretador/dialetos/egua-classico/resolvedor/resolvedor.ts
@@ -66,11 +66,11 @@ export class ResolvedorEguaClassico implements ResolvedorInterface, Interpretado
     visitarDeclaracaoParaCada(declaracao: ParaCada): Promise<any> {
         throw new Error('Método não implementado.');
     }
-    
+
     visitarDeclaracaoConst(declaracao: Const): Promise<any> {
         throw new Error('Método não implementado.');
     }
-    
+
     visitarExpressaoFimPara(declaracao: FimPara) {
         throw new Error('Método não implementado.');
     }
@@ -448,7 +448,7 @@ export class ResolvedorEguaClassico implements ResolvedorInterface, Interpretado
         return null;
     }
 
-    visitarExpressaoAtribuicaoSobrescrita(expressao?: any): any {
+    visitarExpressaoAtribuicaoPorIndice(expressao?: any): any {
         return null;
     }
 
diff --git a/fontes/interpretador/dialetos/portugol-ipt/interpretador-portugol-ipt.ts b/fontes/interpretador/dialetos/portugol-ipt/interpretador-portugol-ipt.ts
index 4492790b..54847996 100644
--- a/fontes/interpretador/dialetos/portugol-ipt/interpretador-portugol-ipt.ts
+++ b/fontes/interpretador/dialetos/portugol-ipt/interpretador-portugol-ipt.ts
@@ -15,13 +15,13 @@ import tiposDeSimbolos from '../../../tipos-de-simbolos/portugol-ipt';
 import { inferirTipoVariavel } from "../../inferenciador";
 
 export class InterpretadorPortugolIpt
-    implements InterpretadorInterface 
+    implements InterpretadorInterface
 {
     diretorioBase: any;
 
     funcaoDeRetorno: Function = null;
     funcaoDeRetornoMesmaLinha: Function = null;
-    
+
     pilhaEscoposExecucao: PilhaEscoposExecucaoInterface;
     interfaceEntradaSaida: any;
 
@@ -70,7 +70,7 @@ export class InterpretadorPortugolIpt
         if (expressao === null || expressao === undefined) {
             console.log('Aqui');
         }
-        
+
         return await expressao.aceitar(this);
     }
 
@@ -164,19 +164,19 @@ export class InterpretadorPortugolIpt
                 case tiposDeSimbolos.MULTIPLICACAO:
                     if (tipoEsquerdo === 'texto' || tipoDireito === 'texto') {
                         // Sem ambos os valores resolvem como texto, multiplica normal.
-                        // Se apenas um resolve como texto, o outro repete o 
+                        // Se apenas um resolve como texto, o outro repete o
                         // texto n vezes, sendo n o valor do outro.
                         if (tipoEsquerdo === 'texto' && tipoDireito === 'texto') {
-                            return Number(valorEsquerdo) * Number(valorDireito);    
-                        } 
-                        
+                            return Number(valorEsquerdo) * Number(valorDireito);
+                        }
+
                         if (tipoEsquerdo === 'texto') {
                             return valorEsquerdo.repeat(Number(valorDireito));
                         }
 
                         return valorDireito.repeat(Number(valorEsquerdo));
                     }
-                    
+
                     return Number(valorEsquerdo) * Number(valorDireito);
 
                 case tiposDeSimbolos.MODULO:
@@ -207,7 +207,7 @@ export class InterpretadorPortugolIpt
     visitarExpressaoDeVariavel(expressao: Variavel): any {
         return this.procurarVariavel(expressao.simbolo);
     }
-    
+
     visitarDeclaracaoDeExpressao(declaracao: Expressao) {
         throw new Error("Método não implementado");
     }
@@ -350,7 +350,7 @@ export class InterpretadorPortugolIpt
             });
         }
     }
-    
+
     executarBloco(declaracoes: Declaracao[], ambiente?: EspacoVariaveis): Promise<any> {
         throw new Error("Método não implementado");
     }
@@ -381,7 +381,7 @@ export class InterpretadorPortugolIpt
      */
     async visitarDeclaracaoVar(declaracao: Var): Promise<any> {
         const valorFinal = await this.avaliacaoDeclaracaoVar(declaracao);
-        
+
         let subtipo;
         if (declaracao.tipo !== undefined) {
             subtipo = declaracao.tipo;
@@ -407,7 +407,7 @@ export class InterpretadorPortugolIpt
     visitarExpressaoDeleguaFuncao(expressao: any) {
         throw new Error("Método não implementado");
     }
-    visitarExpressaoAtribuicaoSobrescrita(expressao: any): Promise<any> {
+    visitarExpressaoAtribuicaoPorIndice(expressao: any): Promise<any> {
         throw new Error("Método não implementado");
     }
     visitarExpressaoAcessoIndiceVariavel(expressao: any) {
@@ -437,7 +437,7 @@ export class InterpretadorPortugolIpt
     visitarExpressaoSuper(expressao: Super) {
         throw new Error("Método não implementado");
     }
-    
+
     paraTexto(objeto: any) {
         if (objeto === null || objeto === undefined) return 'nulo';
         if (typeof objeto === 'boolean') {
@@ -543,4 +543,4 @@ export class InterpretadorPortugolIpt
             return retorno;
         }
     }
-}
\ No newline at end of file
+}
diff --git a/fontes/interpretador/interpretador-base.ts b/fontes/interpretador/interpretador-base.ts
index 2cbc5f19..81421c78 100644
--- a/fontes/interpretador/interpretador-base.ts
+++ b/fontes/interpretador/interpretador-base.ts
@@ -1001,7 +1001,7 @@ export class InterpretadorBase implements InterpretadorInterface {
         return new DeleguaFuncao(null, declaracao);
     }
 
-    async visitarExpressaoAtribuicaoSobrescrita(expressao: any): Promise<any> {
+    async visitarExpressaoAtribuicaoPorIndice(expressao: any): Promise<any> {
         const promises = await Promise.all([
             this.avaliar(expressao.objeto),
             this.avaliar(expressao.indice),
diff --git a/fontes/lexador/dialetos/lexador-birl.ts b/fontes/lexador/dialetos/lexador-birl.ts
index 3651db5e..8df8d66c 100644
--- a/fontes/lexador/dialetos/lexador-birl.ts
+++ b/fontes/lexador/dialetos/lexador-birl.ts
@@ -123,10 +123,22 @@ export class LexadorBirl extends LexadorBaseLinhaUnica {
                 this.avancar();
                 break;
             case '+':
+                if (this.proximoSimbolo() === '+') {
+                    this.avancar();
+                    this.avancar();
+                    this.adicionarSimbolo(tiposDeSimbolos.INCREMENTAR);
+                    break;
+                }
                 this.adicionarSimbolo(tiposDeSimbolos.ADICAO);
                 this.avancar();
                 break;
             case '-':
+                if (this.proximoSimbolo() === '-') {
+                    this.avancar();
+                    this.avancar();
+                    this.adicionarSimbolo(tiposDeSimbolos.DECREMENTAR);
+                    break;
+                }
                 this.adicionarSimbolo(tiposDeSimbolos.SUBTRACAO);
                 this.avancar();
                 break;
diff --git a/fontes/tipos-de-simbolos/birl.ts b/fontes/tipos-de-simbolos/birl.ts
index 05d3f6b5..89351c34 100644
--- a/fontes/tipos-de-simbolos/birl.ts
+++ b/fontes/tipos-de-simbolos/birl.ts
@@ -7,15 +7,25 @@ export default {
     BIRL: 'BIRL',
     BORA: 'BORA',
     BICEPS: 'BICEPS',
+    BIT_AND: 'BIT_AND',
+    BIT_XOR: 'BIT_XOR',
+    BIT_NOT: 'BIT_NOT',
+    BIT_OR: 'BIT_OR',
     CE: 'CE',
     CUMPADE: 'CUMPADE',
     DA: 'DA',
     DAR: 'DAR',
     DO: 'DO',
     DOENTE: 'DOENTE',
+    DIVISAO_IGUAL: 'DIVISAO_IGUAL',
+    DIVISAO_INTEIRA: 'DIVISAO_INTEIRA',
+    DIFERENTE: 'DIFERENTE',
+    DIVISAO_INTEIRA_IGUAL: 'DIVISAO_INTEIRA_IGUAL',
     DESCENDENTE: 'DESCENDENTE',
+    DECREMENTAR: 'DECREMENTAR',
     ELE: 'ELE',
     ESSA: 'ESSA',
+    EXPONENCIACAO:'EXPONENCIACAO',
     FRANGAO: 'FRANGAO',
     FRANGÃO: 'FRANGÃO',
     FRANGO: 'FRANGO',
@@ -23,20 +33,26 @@ export default {
     GENTE: 'GENTE',
     HOME: 'HOME',
     HORA: 'HORA',
+    INCREMENTAR: 'INCREMENTAR',
     MAIS: 'MAIS',
     MALUCO: 'MALUCO',
+    MENOR_MENOR: 'MENOR_MENOR',
+    MAIOR_MAIOR: 'MAIOR_MAIOR',
+    MENOS_IGUAL: 'MENOS_IGUAL',
+    MAIS_IGUAL: 'MAIS_IGUAL',
     MONSTRAO: 'MONSTRAO',
     MONSTRO: 'MONSTRO',
+    MODULO_IGUAL: 'MODULO_IGUAL',
+    MULTIPLICACAO_IGUAL: 'MULTIPLICACAO_IGUAL',
     MONSTRINHO: 'MONSTRINHO',
     TRAPEZIO: 'TRAPEZIO',
     NAO: 'NAO',
     NEGATIVA: 'NEGATIVA',
-    NEGATIVO: 'NEGATIVO',
+    NEGACAO: 'NEGACAO',
     O: 'O',
     OH: 'OH',
     PO: 'PO',
     PORRA: 'PORRA',
-    POSITIVO: 'POSITIVO',
     PUTA: 'PUTA',
     QUE: 'QUE',
     QUER: 'QUER',
diff --git a/fontes/tradutores/tradutor-javascript.ts b/fontes/tradutores/tradutor-javascript.ts
index 61b2d24c..41cc57f7 100644
--- a/fontes/tradutores/tradutor-javascript.ts
+++ b/fontes/tradutores/tradutor-javascript.ts
@@ -2,7 +2,7 @@ import {
     AcessoIndiceVariavel,
     AcessoMetodo,
     Agrupamento,
-    AtribuicaoSobrescrita,
+    AtribuicaoPorIndice,
     Atribuir,
     Binario,
     Chamada,
@@ -371,7 +371,7 @@ export class TradutorJavaScript implements TradutorInterface {
     }
 
     traduzirDeclaracaoParaCada(declaracaoParaCada: ParaCada): string {
-        let resultado = `for (let ${declaracaoParaCada.nomeVariavelIteracao} of `; 
+        let resultado = `for (let ${declaracaoParaCada.nomeVariavelIteracao} of `;
         resultado +=
             this.dicionarioConstrutos[declaracaoParaCada.vetor.constructor.name](declaracaoParaCada.vetor) + ") ";
 
@@ -548,20 +548,20 @@ export class TradutorJavaScript implements TradutorInterface {
         return `${direita} ${operador} ${esquerda}`;
     }
 
-    traduzirConstrutoAtribuicaoSobrescrita(atribuicaoSobrescrita: AtribuicaoSobrescrita): string {
+    traduzirConstrutoAtribuicaoPorIndice(AtribuicaoPorIndice: AtribuicaoPorIndice): string {
         let resultado = '';
 
-        resultado += atribuicaoSobrescrita.objeto.simbolo.lexema + '[';
+        resultado += AtribuicaoPorIndice.objeto.simbolo.lexema + '[';
         resultado +=
-            this.dicionarioConstrutos[atribuicaoSobrescrita.indice.constructor.name](atribuicaoSobrescrita.indice) +
+            this.dicionarioConstrutos[AtribuicaoPorIndice.indice.constructor.name](AtribuicaoPorIndice.indice) +
             ']';
         resultado += ' = ';
 
-        if (atribuicaoSobrescrita?.valor?.simbolo?.lexema) {
-            resultado += `${atribuicaoSobrescrita.valor.simbolo.lexema}`;
+        if (AtribuicaoPorIndice?.valor?.simbolo?.lexema) {
+            resultado += `${AtribuicaoPorIndice.valor.simbolo.lexema}`;
         } else {
-            resultado += this.dicionarioConstrutos[atribuicaoSobrescrita.valor.constructor.name](
-                atribuicaoSobrescrita.valor
+            resultado += this.dicionarioConstrutos[AtribuicaoPorIndice.valor.constructor.name](
+                AtribuicaoPorIndice.valor
             );
         }
 
@@ -616,7 +616,7 @@ export class TradutorJavaScript implements TradutorInterface {
         AcessoIndiceVariavel: this.traduzirAcessoIndiceVariavel.bind(this),
         AcessoMetodo: this.trazudirConstrutoAcessoMetodo.bind(this),
         Agrupamento: this.traduzirConstrutoAgrupamento.bind(this),
-        AtribuicaoSobrescrita: this.traduzirConstrutoAtribuicaoSobrescrita.bind(this),
+        AtribuicaoPorIndice: this.traduzirConstrutoAtribuicaoPorIndice.bind(this),
         Atribuir: this.traduzirConstrutoAtribuir.bind(this),
         Binario: this.traduzirConstrutoBinario.bind(this),
         Chamada: this.traduzirConstrutoChamada.bind(this),
diff --git a/fontes/tradutores/tradutor-visualg.ts b/fontes/tradutores/tradutor-visualg.ts
index cf8436c8..c2bbc657 100644
--- a/fontes/tradutores/tradutor-visualg.ts
+++ b/fontes/tradutores/tradutor-visualg.ts
@@ -414,20 +414,20 @@ export class TradutorVisualg {
         return `${direita} ${operador} ${esquerda}`;
     }
 
-    // traduzirConstrutoAtribuicaoSobrescrita(atribuicaoSobrescrita: AtribuicaoSobrescrita): string {
+    // traduzirConstrutoAtribuicaoPorIndice(AtribuicaoPorIndice: AtribuicaoPorIndice): string {
     //     let resultado = '';
 
-    //     resultado += atribuicaoSobrescrita.objeto.simbolo.lexema + '[';
+    //     resultado += AtribuicaoPorIndice.objeto.simbolo.lexema + '[';
     //     resultado +=
-    //         this.dicionarioConstrutos[atribuicaoSobrescrita.indice.constructor.name](atribuicaoSobrescrita.indice) +
+    //         this.dicionarioConstrutos[AtribuicaoPorIndice.indice.constructor.name](AtribuicaoPorIndice.indice) +
     //         ']';
     //     resultado += ' = ';
 
-    //     if (atribuicaoSobrescrita?.valor?.simbolo?.lexema) {
-    //         resultado += `${atribuicaoSobrescrita.valor.simbolo.lexema}`;
+    //     if (AtribuicaoPorIndice?.valor?.simbolo?.lexema) {
+    //         resultado += `${AtribuicaoPorIndice.valor.simbolo.lexema}`;
     //     } else {
-    //         resultado += this.dicionarioConstrutos[atribuicaoSobrescrita.valor.constructor.name](
-    //             atribuicaoSobrescrita.valor
+    //         resultado += this.dicionarioConstrutos[AtribuicaoPorIndice.valor.constructor.name](
+    //             AtribuicaoPorIndice.valor
     //         );
     //     }
 
@@ -477,7 +477,7 @@ export class TradutorVisualg {
         // AcessoIndiceVariavel: this.traduzirAcessoIndiceVariavel.bind(this),
         // AcessoMetodo: this.trazudirConstrutoAcessoMetodo.bind(this),
         Agrupamento: this.traduzirConstrutoAgrupamento.bind(this),
-        // AtribuicaoSobrescrita: this.traduzirConstrutoAtribuicaoSobrescrita.bind(this),
+        // AtribuicaoPorIndice: this.traduzirConstrutoAtribuicaoPorIndice.bind(this),
         Binario: this.traduzirConstrutoBinario.bind(this),
         // Chamada: this.traduzirConstrutoChamada.bind(this),
         FimPara: this.traduzirConstrutoFimPara.bind(this),


Test patch:
diff --git a/testes/birl/avaliador-sintatico.test.ts b/testes/birl/avaliador-sintatico.test.ts
index dd0b8aac..ba1a030c 100644
--- a/testes/birl/avaliador-sintatico.test.ts
+++ b/testes/birl/avaliador-sintatico.test.ts
@@ -70,7 +70,6 @@ describe('Avaliador Sintático Birl', () => {
                     '   BORA CUMPADE 0; \n',
                     'BIRL \n',
                 ]);
-                //  FRANGO esta vindo como um indentificador
                 const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                 expect(retornoAvaliadorSintatico).toBeTruthy();
@@ -94,6 +93,7 @@ describe('Avaliador Sintático Birl', () => {
                 expect(retornoAvaliadorSintatico).toBeTruthy();
                 expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(3);
             });
+
             it('Sucesso - Variavel - short int', () => {
                 const retornoLexador = lexador.mapear([
                     'HORA DO SHOW \n',
@@ -143,7 +143,7 @@ describe('Avaliador Sintático Birl', () => {
                 const retornoLexador = lexador.mapear([
                     'HORA DO SHOW \n',
                     `  BICEPS FRANGO TD = 'test'; \n`,
-                    '  CE QUER VER ESSA PORRA? (M1); \n',
+                    '  CE QUER VER ESSA PORRA? (TD); \n',
                     '  BORA CUMPADE 0; \n',
                     'BIRL \n',
                 ]);
@@ -152,6 +152,7 @@ describe('Avaliador Sintático Birl', () => {
                 expect(retornoAvaliadorSintatico).toBeTruthy();
                 expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(3);
             });
+
             it('Sucesso - declaração - if', () => {
                 const retornoLexador = lexador.mapear([
                     'HORA DO SHOW \n',
@@ -167,6 +168,7 @@ describe('Avaliador Sintático Birl', () => {
                 expect(retornoAvaliadorSintatico.declaracoes[0].assinaturaMetodo).toBe('<principal>');
                 expect(retornoAvaliadorSintatico.declaracoes[0]).toBeInstanceOf(Se);
             });
+
             it('Sucesso - declaração - if else', () => {
                 const retornoLexador = lexador.mapear([
                     'HORA DO SHOW \n',
@@ -236,6 +238,26 @@ describe('Avaliador Sintático Birl', () => {
                 expect(declaracao1.simbolo.lexema).toBe('M');
                 expect((retornoAvaliadorSintatico.declaracoes[1] as Para).corpo.declaracoes[0]).toBeInstanceOf(Escreva);
             });
+            it('Sucesso - declaração - for - incremento - atribuição', () => {
+                const retornoLexador = lexador.mapear([
+                    'HORA DO SHOW \n',
+                    '   MONSTRO M;\n',
+                    '   MAIS QUERO MAIS (M = 5; M > 0; ++M)',
+                    '       CE QUER VER ESSA PORRA? ("teste");\n',
+                    '   BIRL\n',
+                    'BIRL\n',
+                ]);
+
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+                expect(retornoAvaliadorSintatico).toBeTruthy();
+                expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(2);
+                expect(retornoAvaliadorSintatico.declaracoes[1].assinaturaMetodo).toBe('<principal>');
+                expect(retornoAvaliadorSintatico.declaracoes[1]).toBeInstanceOf(Para);
+                const declaracao1 = retornoAvaliadorSintatico.declaracoes[0][0] as Var;
+                expect(declaracao1.inicializador.valor).toBe(0);
+                expect(declaracao1.simbolo.lexema).toBe('M');
+                expect((retornoAvaliadorSintatico.declaracoes[1] as Para).corpo.declaracoes[0]).toBeInstanceOf(Escreva);
+            });
             it('Sucesso - declaração - while', () => {
                 const RetornoLexador = lexador.mapear([
                     'HORA DO SHOW \n',
@@ -269,9 +291,6 @@ describe('Avaliador Sintático Birl', () => {
                 expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(2);
                 expect(retornoAvaliadorSintatico.declaracoes[1].assinaturaMetodo).toBe('<principal>');
                 expect(retornoAvaliadorSintatico.declaracoes[1]).toBeInstanceOf(Para);
-                const declaracao1 = retornoAvaliadorSintatico.declaracoes[1] as Para;
-                expect(declaracao1.corpo.declaracoes[0]).toBeInstanceOf(Escreva);
-                expect(declaracao1.corpo.declaracoes[1]).toBeInstanceOf(Sustar);
             });
             it('Sucesso - declaração - continue', () => {
                 const retornoLexador = lexador.mapear([
@@ -293,12 +312,6 @@ describe('Avaliador Sintático Birl', () => {
                 expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(2);
                 expect(retornoAvaliadorSintatico.declaracoes[1].assinaturaMetodo).toBe('<principal>');
                 expect(retornoAvaliadorSintatico.declaracoes[1]).toBeInstanceOf(Para);
-                const declaracao1 = retornoAvaliadorSintatico.declaracoes[1] as Para;
-                expect(declaracao1.corpo.declaracoes[0]).toBeInstanceOf(Escreva);
-                expect(declaracao1.corpo.declaracoes[1]).toBeInstanceOf(Se);
-                const declaracaoSe = declaracao1.corpo.declaracoes[1] as Se;
-                expect((declaracaoSe.caminhoEntao as Bloco).declaracoes[0]).toBeInstanceOf(Sustar);
-                expect((declaracaoSe.caminhoSenao as Bloco).declaracoes[0]).toBeInstanceOf(Continua);
             });
             it('Sucesso - declaração - declaracaoFuncao', () => {
                 const retornoLexador = lexador.mapear([
diff --git a/testes/birl/interpretador.test.ts b/testes/birl/interpretador.test.ts
index d2480380..d30295ff 100644
--- a/testes/birl/interpretador.test.ts
+++ b/testes/birl/interpretador.test.ts
@@ -15,6 +15,104 @@ describe('Interpretador', () => {
                 interpretador = new InterpretadorBirl(process.cwd());
             });
 
+            it('Sucesso - declaração - for - decremento - depois', async () => {
+                const retornoLexador = lexador.mapear([
+                    'HORA DO SHOW \n',
+                    '   MAIS QUERO MAIS (MONSTRO M = 6; M > 5; M--)',
+                    '       CE QUER VER ESSA PORRA? ("teste");\n',
+                    '   BIRL\n',
+                    'BIRL\n',
+                ]);
+
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                expect(retornoInterpretador.erros).toHaveLength(0);
+            });
+
+            it('Sucesso - declaração - for - decremento - antes', async () => {
+                const retornoLexador = lexador.mapear([
+                    'HORA DO SHOW \n',
+                    '   MAIS QUERO MAIS (MONSTRO M = 10; M > 5; --M)',
+                    '       CE QUER VER ESSA PORRA? (M);\n',
+                    '   BIRL\n',
+                    'BIRL\n',
+                ]);
+
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                expect(retornoInterpretador.erros).toHaveLength(0);
+            });
+
+            it('Sucesso - declaração - for - incremento - depois', async () => {
+                const retornoLexador = lexador.mapear([
+                    'HORA DO SHOW \n',
+                    '   MAIS QUERO MAIS (MONSTRO M = 0; M < 5; M++)',
+                    '       CE QUER VER ESSA PORRA? (M);\n',
+                    '   BIRL\n',
+                    'BIRL\n',
+                ]);
+
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                expect(retornoInterpretador.erros).toHaveLength(0);
+            });
+
+            it('Sucesso - declaração - for - incremento - antes', async () => {
+                const retornoLexador = lexador.mapear([
+                    'HORA DO SHOW \n',
+                    '   MAIS QUERO MAIS (MONSTRO M = 0; M < 5; ++M)',
+                    '       CE QUER VER ESSA PORRA? (M);\n',
+                    '   BIRL\n',
+                    'BIRL\n',
+                ]);
+
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                expect(retornoInterpretador.erros).toHaveLength(0);
+            });
+
+            it('Sucesso - declaração - if else', async () => {
+                const retornoLexador = lexador.mapear([
+                    'HORA DO SHOW \n',
+                    '   ELE QUE A GENTE QUER? (1 > 2)\n',
+                    '     CE QUER VER ESSA PORRA? ("teste1");\n',
+                    '   NAO VAI DAR NAO\n',
+                    '     CE QUER VER ESSA PORRA? ("teste");\n',
+                    '   BIRL\n',
+                    'BIRL\n',
+                ]);
+
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                expect(retornoInterpretador.erros).toHaveLength(0);
+            });
+
+            it('Sucesso - declaração - if', async () => {
+                const retornoLexador = lexador.mapear([
+                    'HORA DO SHOW \n',
+                    '   ELE QUE A GENTE QUER? (3 > 2)\n',
+                    '     CE QUER VER ESSA PORRA? ("teste");\n',
+                    '   BIRL\n',
+                    'BIRL\n',
+                ]);
+
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                expect(retornoInterpretador.erros).toHaveLength(0);
+            });
+
             it('Sucesso - Hello, World! Porra!', async () => {
                 const retornoLexador = lexador.mapear(
                     [
@@ -32,6 +130,109 @@ describe('Interpretador', () => {
 
                 expect(retornoInterpretador.erros).toHaveLength(0);
             });
+
+            it('Sucesso - Variavel - Numero', async () => {
+                const retornoLexador = lexador.mapear(
+                    [
+                        'HORA DO SHOW \n',
+                        '  MONSTRO M1 = 1; \n',
+                        '  CE QUER VER ESSA PORRA? (M1); \n',
+                        '  BORA CUMPADE 0; \n',
+                        'BIRL \n',
+                    ],
+                    -1
+                );
+
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                expect(retornoInterpretador.erros).toHaveLength(0);
+            })
+
+            it('Sucesso - Variavel - String', async () => {
+                const retornoLexador = lexador.mapear([
+                    'HORA DO SHOW \n',
+                    "   FRANGO FR = 'testes';\n",
+                    '   CE QUER VER ESSA PORRA? (FR); \n',
+                    '   BORA CUMPADE 0; \n',
+                    'BIRL \n',
+                ]);
+
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                expect(retornoInterpretador.erros).toHaveLength(0);
+            });
+
+            it('Sucesso - Variavel - Float', async () => {
+                const retornoLexador = lexador.mapear(
+                    [
+                        'HORA DO SHOW \n',
+                        '  TRAPEZIO M1 = 1.03; \n',
+                        '  CE QUER VER ESSA PORRA? (M1); \n',
+                        '  BORA CUMPADE 0; \n',
+                        'BIRL \n',
+                    ],
+                    -1
+                );
+
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                expect(retornoInterpretador.erros).toHaveLength(0);
+            });
+
+            it('Sucesso - Variavel - short int', async () => {
+                const retornoLexador = lexador.mapear([
+                    'HORA DO SHOW \n',
+                    '  MONSTRINHO M1 = 1.03; \n',
+                    '  CE QUER VER ESSA PORRA? (M1); \n',
+                    '  BORA CUMPADE 0; \n',
+                    'BIRL \n',
+                ]);
+
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                expect(retornoInterpretador.erros).toHaveLength(0);
+            });
+
+            it('Sucesso - Variavel - long int', async () => {
+                const retornoLexador = lexador.mapear([
+                    'HORA DO SHOW \n',
+                    '  MONSTRAO M1 = 16666666; \n',
+                    '  CE QUER VER ESSA PORRA? (M1); \n',
+                    '  BORA CUMPADE 0; \n',
+                    'BIRL \n',
+                ]);
+
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                expect(retornoInterpretador.erros).toHaveLength(0);
+            });
+
+            it('Sucesso - Variavel - double', async () => {
+                const retornoLexador = lexador.mapear([
+                    'HORA DO SHOW \n',
+                    '  TRAPEZIO DESCENDENTE TD = 0.37; \n',
+                    '  CE QUER VER ESSA PORRA? (TD); \n',
+                    '  BORA CUMPADE 0; \n',
+                    'BIRL \n',
+                ]);
+
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                expect(retornoInterpretador.erros).toHaveLength(0);
+            });
+
         });
     });
 });
diff --git a/testes/birl/lexador.test.ts b/testes/birl/lexador.test.ts
index 93c7195a..ff108d24 100644
--- a/testes/birl/lexador.test.ts
+++ b/testes/birl/lexador.test.ts
@@ -86,7 +86,7 @@ describe('Lexador (BIRL)', () => {
                 );
 
                 expect(resultado).toBeTruthy();
-                expect(resultado.simbolos).toHaveLength(51);
+                expect(resultado.simbolos).toHaveLength(50);
                 expect(resultado.erros).toHaveLength(0);
             });
             it('Sucesso - Loop - While', () => {
@@ -105,7 +105,7 @@ describe('Lexador (BIRL)', () => {
                 );
 
                 expect(resultado).toBeTruthy();
-                expect(resultado.simbolos).toHaveLength(49);
+                expect(resultado.simbolos).toHaveLength(48);
                 expect(resultado.erros).toHaveLength(0);
             });
             it('Sucesso - Condição - If', () => {
@@ -182,7 +182,7 @@ describe('Lexador (BIRL)', () => {
                 );
 
                 expect(resultado).toBeTruthy();
-                expect(resultado.simbolos).toHaveLength(62);
+                expect(resultado.simbolos).toHaveLength(61);
                 expect(resultado.erros).toHaveLength(0);
             });
             it('Sucesso - Declaração de Função', () => {