Repository: DesignLiquido/delegua
Pull request #639 (2024-02-11 22:14:05)

Declaração `tendo ... como`
- Implementa parcialmente o que foi discutido em https://github.com/DesignLiquido/delegua/discussions/637
- Possui algumas refatorações, especialmente nos analisadores semânticos.


Patch:
diff --git a/fontes/analisador-semantico/analisador-semantico-base.ts b/fontes/analisador-semantico/analisador-semantico-base.ts
new file mode 100644
index 00000000..cb66f3d5
--- /dev/null
+++ b/fontes/analisador-semantico/analisador-semantico-base.ts
@@ -0,0 +1,277 @@
+import {
+    Atribuir,
+    AcessoIndiceVariavel,
+    AcessoElementoMatriz,
+    AcessoMetodoOuPropriedade,
+    Agrupamento,
+    AtribuicaoPorIndice,
+    AtribuicaoPorIndicesMatriz,
+    Binario,
+    Chamada,
+    DefinirValor,
+    FuncaoConstruto,
+    Dicionario,
+    ExpressaoRegular,
+    FimPara,
+    FormatacaoEscrita,
+    Isto,
+    Literal,
+    Logico,
+    Super,
+    Tupla,
+    TipoDe,
+    Unario,
+    Vetor,
+} from '../construtos';
+import {
+    Declaracao,
+    TendoComo,
+    InicioAlgoritmo,
+    Aleatorio,
+    CabecalhoPrograma,
+    Classe,
+    Const,
+    ConstMultiplo,
+    Expressao,
+    FuncaoDeclaracao,
+    Enquanto,
+    Escolha,
+    Escreva,
+    Fazer,
+    Importar,
+    Para,
+    ParaCada,
+    Se,
+    Tente,
+    Var,
+    VarMultiplo,
+    Bloco,
+    Continua,
+    EscrevaMesmaLinha,
+    Falhar,
+    Leia,
+    LeiaMultiplo,
+    Retorna,
+    Sustar,
+} from '../declaracoes';
+import { DeleguaFuncao } from '../estruturas';
+import { AnalisadorSemanticoInterface } from '../interfaces/analisador-semantico-interface';
+import { RetornoAnalisadorSemantico } from '../interfaces/retornos/retorno-analisador-semantico';
+import { ContinuarQuebra, RetornoQuebra, SustarQuebra } from '../quebras';
+
+/**
+ * Essa classe só existe para eliminar redundância entre todos os analisadores
+ * sintáticos. Por padrão, quando um método não é implementado, ao invés de dar erro,
+ * simplesmente passa por ele (`return Promise.resolve()`).
+ */
+export abstract class AnalisadorSemanticoBase implements AnalisadorSemanticoInterface {
+    abstract analisar(declaracoes: Declaracao[]): RetornoAnalisadorSemantico;
+
+    visitarDeclaracaoTendoComo(declaracao: TendoComo): Promise<any> {
+        return Promise.resolve();
+    }
+
+    visitarDeclaracaoInicioAlgoritmo(declaracao: InicioAlgoritmo): Promise<any> {
+        return Promise.resolve();
+    }
+
+    visitarDeclaracaoAleatorio(declaracao: Aleatorio): Promise<any> {
+        return Promise.resolve();
+    }
+
+    visitarDeclaracaoCabecalhoPrograma(declaracao: CabecalhoPrograma): Promise<any> {
+        return Promise.resolve();
+    }
+
+    visitarDeclaracaoClasse(declaracao: Classe): Promise<any> {
+        return Promise.resolve();
+    }
+
+    visitarDeclaracaoConst(declaracao: Const): Promise<any> {
+        return Promise.resolve();
+    }
+
+    visitarDeclaracaoConstMultiplo(declaracao: ConstMultiplo): Promise<any> {
+        return Promise.resolve();
+    }
+
+    visitarExpressaoDeAtribuicao(expressao: Atribuir): Promise<any> {
+        return Promise.resolve();
+    }
+
+    visitarDeclaracaoDeExpressao(declaracao: Expressao): Promise<any> {
+        return Promise.resolve();
+    }
+
+    visitarDeclaracaoDefinicaoFuncao(declaracao: FuncaoDeclaracao): void {
+        // Nada acontece.
+    }
+
+    visitarDeclaracaoEnquanto(declaracao: Enquanto): Promise<any> {
+        return Promise.resolve();
+    }
+
+    visitarDeclaracaoEscolha(declaracao: Escolha): Promise<any> {
+        return Promise.resolve();
+    }
+
+    visitarDeclaracaoEscreva(declaracao: Escreva): Promise<any> {
+        return Promise.resolve();
+    }
+
+    visitarDeclaracaoFazer(declaracao: Fazer): Promise<any> {
+        return Promise.resolve();
+    }
+
+    visitarDeclaracaoImportar(declaracao: Importar): Promise<any> {
+        return Promise.resolve();
+    }
+
+    visitarDeclaracaoPara(declaracao: Para): Promise<any> {
+        return Promise.resolve();
+    }
+
+    visitarDeclaracaoParaCada(declaracao: ParaCada): Promise<any> {
+        return Promise.resolve();
+    }
+
+    visitarDeclaracaoSe(declaracao: Se): Promise<any> {
+        return Promise.resolve();
+    }
+
+    visitarDeclaracaoTente(declaracao: Tente): Promise<any> {
+        return Promise.resolve();
+    }
+
+    visitarDeclaracaoVar(declaracao: Var): Promise<any> {
+        return Promise.resolve();
+    }
+
+    visitarDeclaracaoVarMultiplo(declaracao: VarMultiplo): Promise<any> {
+        return Promise.resolve();
+    }
+
+    visitarExpressaoAcessoIndiceVariavel(expressao: AcessoIndiceVariavel): Promise<any> {
+        return Promise.resolve();
+    }
+
+    visitarExpressaoAcessoElementoMatriz(expressao: AcessoElementoMatriz): Promise<any> {
+        return Promise.resolve();
+    }
+
+    visitarExpressaoAcessoMetodo(expressao: AcessoMetodoOuPropriedade): Promise<any> {
+        return Promise.resolve();
+    }
+
+    visitarExpressaoAgrupamento(expressao: Agrupamento): Promise<any> {
+        return Promise.resolve();
+    }
+
+    visitarExpressaoAtribuicaoPorIndice(expressao: AtribuicaoPorIndice): Promise<any> {
+        return Promise.resolve();
+    }
+
+    visitarExpressaoAtribuicaoPorIndicesMatriz(expressao: AtribuicaoPorIndicesMatriz): Promise<any> {
+        return Promise.resolve();
+    }
+
+    visitarExpressaoBinaria(expressao: Binario): Promise<any> {
+        return Promise.resolve();
+    }
+
+    visitarExpressaoBloco(declaracao: Bloco): Promise<any> {
+        return Promise.resolve();
+    }
+
+    visitarExpressaoContinua(declaracao?: Continua): ContinuarQuebra {
+        return Promise.resolve();
+    }
+
+    visitarExpressaoDeChamada(expressao: Chamada): Promise<any> {
+        return Promise.resolve();
+    }
+
+    visitarExpressaoDefinirValor(expressao: DefinirValor): Promise<any> {
+        return Promise.resolve();
+    }
+
+    visitarExpressaoDeleguaFuncao(expressao: FuncaoConstruto): Promise<any> {
+        return Promise.resolve();
+    }
+
+    visitarExpressaoDeVariavel(expressao: Var): Promise<any> {
+        return Promise.resolve();
+    }
+
+    visitarExpressaoDicionario(expressao: Dicionario): Promise<any> {
+        return Promise.resolve();
+    }
+
+    visitarExpressaoExpressaoRegular(expressao: ExpressaoRegular): Promise<RegExp> {
+        return;
+    }
+
+    visitarDeclaracaoEscrevaMesmaLinha(declaracao: EscrevaMesmaLinha): Promise<any> {
+        return Promise.resolve();
+    }
+
+    visitarExpressaoFalhar(expressao: Falhar): Promise<any> {
+        return Promise.resolve();
+    }
+
+    visitarExpressaoFimPara(declaracao: FimPara): Promise<any> {
+        return Promise.resolve();
+    }
+
+    visitarExpressaoFormatacaoEscrita(declaracao: FormatacaoEscrita): Promise<any> {
+        return Promise.resolve();
+    }
+
+    visitarExpressaoIsto(expressao: Isto): Promise<any> {
+        return Promise.resolve();
+    }
+
+    visitarExpressaoLeia(expressao: Leia): Promise<any> {
+        return Promise.resolve();
+    }
+
+    visitarExpressaoLeiaMultiplo(expressao: LeiaMultiplo): Promise<any> {
+        return Promise.resolve();
+    }
+
+    visitarExpressaoLiteral(expressao: Literal): Promise<any> {
+        return Promise.resolve();
+    }
+
+    visitarExpressaoLogica(expressao: Logico): Promise<any> {
+        return Promise.resolve();
+    }
+
+    visitarExpressaoRetornar(declaracao: Retorna): Promise<RetornoQuebra> {
+        return;
+    }
+
+    visitarExpressaoSuper(expressao: Super): Promise<any> {
+        return Promise.resolve();
+    }
+
+    visitarExpressaoSustar(declaracao?: Sustar): SustarQuebra {
+        return Promise.resolve();
+    }
+
+    visitarExpressaoTupla(expressao: Tupla): Promise<any> {
+        return Promise.resolve();
+    }
+
+    visitarExpressaoTipoDe(expressao: TipoDe): Promise<any> {
+        return Promise.resolve();
+    }
+
+    visitarExpressaoUnaria(expressao: Unario): Promise<any> {
+        return Promise.resolve();
+    }
+
+    visitarExpressaoVetor(expressao: Vetor): Promise<any> {
+        return Promise.resolve();
+    }
+}
diff --git a/fontes/analisador-semantico/analisador-semantico.ts b/fontes/analisador-semantico/analisador-semantico.ts
index 84c6bb0a..e2ebd064 100644
--- a/fontes/analisador-semantico/analisador-semantico.ts
+++ b/fontes/analisador-semantico/analisador-semantico.ts
@@ -52,6 +52,7 @@ import { DiagnosticoAnalisadorSemantico, DiagnosticoSeveridade } from '../interf
 import { RetornoAnalisadorSemantico } from '../interfaces/retornos/retorno-analisador-semantico';
 import { TiposDadosInterface } from '../interfaces/tipos-dados-interface';
 import { ContinuarQuebra, RetornoQuebra, SustarQuebra } from '../quebras';
+import { AnalisadorSemanticoBase } from './analisador-semantico-base';
 import { PilhaVariaveis } from './pilha-variaveis';
 
 interface VariavelHipoteticaInterface {
@@ -65,7 +66,7 @@ interface FuncaoHipoteticaInterface {
     valor: any;
 }
 
-export class AnalisadorSemantico implements AnalisadorSemanticoInterface {
+export class AnalisadorSemantico extends AnalisadorSemanticoBase {
     pilhaVariaveis: PilhaVariaveis;
     variaveis: { [nomeVariavel: string]: VariavelHipoteticaInterface };
     funcoes: { [nomeFuncao: string]: FuncaoHipoteticaInterface };
@@ -73,6 +74,7 @@ export class AnalisadorSemantico implements AnalisadorSemanticoInterface {
     diagnosticos: DiagnosticoAnalisadorSemantico[];
 
     constructor() {
+        super();
         this.pilhaVariaveis = new PilhaVariaveis();
         this.variaveis = {};
         this.funcoes = {};
@@ -80,34 +82,6 @@ export class AnalisadorSemantico implements AnalisadorSemanticoInterface {
         this.diagnosticos = [];
     }
 
-    visitarDeclaracaoCabecalhoPrograma(declaracao: CabecalhoPrograma): Promise<any> {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoTupla(expressao: Tupla): Promise<any> {
-        return Promise.resolve();
-    }
-
-    visitarDeclaracaoAleatorio(declaracao: Aleatorio): Promise<any> {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoAcessoElementoMatriz(expressao: any) {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoAtribuicaoPorIndicesMatriz(expressao: any): Promise<any> {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoExpressaoRegular(expressao: ExpressaoRegular): Promise<any> {
-        return Promise.resolve();
-    }
-
-    visitarDeclaracaoInicioAlgoritmo(declaracao: InicioAlgoritmo): Promise<any> {
-        return Promise.resolve();
-    }
-
     erro(simbolo: SimboloInterface, mensagem: string): void {
         this.diagnosticos.push({
             simbolo: simbolo,
@@ -224,22 +198,6 @@ export class AnalisadorSemantico implements AnalisadorSemanticoInterface {
         return Promise.resolve();
     }
 
-    visitarExpressaoLiteral(expressao: Literal): Promise<any> {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoAgrupamento(expressao: any): Promise<any> {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoUnaria(expressao: any) {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoBinaria(expressao: any) {
-        return Promise.resolve();
-    }
-
     visitarExpressaoDeChamada(expressao: Chamada) {
         if (expressao.entidadeChamada instanceof Variavel) {
             const variavel = expressao.entidadeChamada as Variavel;
@@ -345,48 +303,8 @@ export class AnalisadorSemantico implements AnalisadorSemanticoInterface {
         }
     }
 
-    visitarExpressaoDeVariavel(expressao: any) {
-        return Promise.resolve();
-    }
-
-    visitarDeclaracaoDeExpressao(declaracao: Expressao) {
-        return declaracao.expressao.aceitar(this);
-    }
-
-    visitarExpressaoLeia(expressao: Leia) {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoLeiaMultiplo(expressao: LeiaMultiplo) {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoLogica(expressao: any) {
-        return Promise.resolve();
-    }
-
-    visitarDeclaracaoPara(declaracao: Para): Promise<any> {
-        return Promise.resolve();
-    }
-
-    visitarDeclaracaoParaCada(declaracao: ParaCada): Promise<any> {
-        return Promise.resolve();
-    }
-
-    visitarDeclaracaoSe(declaracao: Se) {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoFimPara(declaracao: FimPara) {
-        return Promise.resolve();
-    }
-
-    visitarDeclaracaoFazer(declaracao: Fazer) {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoFormatacaoEscrita(declaracao: FormatacaoEscrita) {
-        return Promise.resolve();
+    async visitarDeclaracaoDeExpressao(declaracao: Expressao): Promise<any> {
+        return await declaracao.expressao.aceitar(this);
     }
 
     visitarDeclaracaoEscolha(declaracao: Escolha) {
@@ -408,10 +326,6 @@ export class AnalisadorSemantico implements AnalisadorSemanticoInterface {
         return Promise.resolve();
     }
 
-    visitarDeclaracaoTente(declaracao: Tente) {
-        return Promise.resolve();
-    }
-
     visitarDeclaracaoEnquanto(declaracao: Enquanto) {
         return this.verificarCondicao(declaracao.condicao);
     }
@@ -496,7 +410,6 @@ export class AnalisadorSemantico implements AnalisadorSemanticoInterface {
             this.verificarBinario(lado);
             return;
         }
-        return;
     }
 
     private verificarLogico(logio: Logico): Promise<void> {
@@ -509,8 +422,9 @@ export class AnalisadorSemantico implements AnalisadorSemanticoInterface {
         let funcaoChamada = chamada.entidadeChamada as Variavel;
         if (!this.funcoes[funcaoChamada.simbolo.lexema]) {
             this.erro(funcaoChamada.simbolo, `Chamada da função '${funcaoChamada.simbolo.lexema}' não existe.`);
-            return Promise.resolve();
         }
+
+        return Promise.resolve();
     }
 
     private verificarLadoLogico(lado: any): void {
@@ -520,10 +434,6 @@ export class AnalisadorSemantico implements AnalisadorSemanticoInterface {
         }
     }
 
-    visitarDeclaracaoImportar(declaracao: Importar) {
-        return Promise.resolve();
-    }
-
     visitarDeclaracaoEscreva(declaracao: Escreva) {
         const variaveis = declaracao.argumentos.filter((arg) => arg instanceof Variavel);
 
@@ -531,6 +441,7 @@ export class AnalisadorSemantico implements AnalisadorSemanticoInterface {
             if (!this.variaveis[variavel.simbolo.lexema]) {
                 this.erro(variavel.simbolo, `Variável '${variavel.simbolo.lexema}' não existe.`);
             }
+
             if (this.variaveis[variavel.simbolo.lexema]?.valor === undefined) {
                 this.aviso(variavel.simbolo, `Variável '${variavel.simbolo.lexema}' não foi inicializada.`);
             }
@@ -539,14 +450,6 @@ export class AnalisadorSemantico implements AnalisadorSemanticoInterface {
         return Promise.resolve();
     }
 
-    visitarDeclaracaoEscrevaMesmaLinha(declaracao: EscrevaMesmaLinha) {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoBloco(declaracao: Bloco): Promise<any> {
-        return Promise.resolve();
-    }
-
     visitarDeclaracaoConst(declaracao: Const): Promise<any> {
         this.verificarTipoAtribuido(declaracao);
 
@@ -583,10 +486,6 @@ export class AnalisadorSemantico implements AnalisadorSemanticoInterface {
         return Promise.resolve();
     }
 
-    visitarDeclaracaoConstMultiplo(declaracao: ConstMultiplo): Promise<any> {
-        return Promise.resolve();
-    }
-
     visitarDeclaracaoVar(declaracao: Var): Promise<any> {
         this.verificarTipoAtribuido(declaracao);
 
@@ -611,38 +510,10 @@ export class AnalisadorSemantico implements AnalisadorSemanticoInterface {
         return Promise.resolve();
     }
 
-    visitarDeclaracaoVarMultiplo(declaracao: VarMultiplo): Promise<any> {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoContinua(declaracao?: Continua): ContinuarQuebra {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoSustar(declaracao?: Sustar): SustarQuebra {
-        return Promise.resolve();
-    }
-
     visitarExpressaoRetornar(declaracao: Retorna): Promise<RetornoQuebra> {
         return Promise.resolve(null);
     }
 
-    visitarExpressaoDeleguaFuncao(expressao: any) {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoAtribuicaoPorIndice(expressao: any): Promise<any> {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoAcessoIndiceVariavel(expressao: any) {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoDefinirValor(expressao: any) {
-        return Promise.resolve();
-    }
-
     visitarDeclaracaoDefinicaoFuncao(declaracao: FuncaoDeclaracao) {
         for (let parametro of declaracao.funcao.parametros) {
             if (parametro.hasOwnProperty('tipoDado') && !parametro.tipoDado.tipo) {
@@ -699,30 +570,6 @@ export class AnalisadorSemantico implements AnalisadorSemanticoInterface {
         return Promise.resolve();
     }
 
-    visitarDeclaracaoClasse(declaracao: Classe) {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoAcessoMetodo(expressao: any) {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoIsto(expressao: any) {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoDicionario(expressao: any) {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoVetor(expressao: any) {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoSuper(expressao: Super) {
-        return Promise.resolve();
-    }
-
     analisar(declaracoes: Declaracao[]): RetornoAnalisadorSemantico {
         // this.pilhaVariaveis = new PilhaVariaveis();
         // this.pilhaVariaveis.empilhar()
diff --git a/fontes/analisador-semantico/dialetos/analisador-semantico-birl.ts b/fontes/analisador-semantico/dialetos/analisador-semantico-birl.ts
index 6f58e707..bd1e53c7 100644
--- a/fontes/analisador-semantico/dialetos/analisador-semantico-birl.ts
+++ b/fontes/analisador-semantico/dialetos/analisador-semantico-birl.ts
@@ -42,6 +42,7 @@ import { AnalisadorSemanticoInterface } from '../../interfaces/analisador-semant
 import { DiagnosticoAnalisadorSemantico, DiagnosticoSeveridade } from '../../interfaces/erros';
 import { RetornoAnalisadorSemantico } from '../../interfaces/retornos/retorno-analisador-semantico';
 import { ContinuarQuebra, RetornoQuebra, SustarQuebra } from '../../quebras';
+import { AnalisadorSemanticoBase } from '../analisador-semantico-base';
 import { PilhaVariaveis } from '../pilha-variaveis';
 
 interface VariavelHipoteticaBirlInterface {
@@ -61,60 +62,20 @@ interface VariavelHipoteticaBirlInterface {
     imutavel: boolean;
 }
 
-export class AnalisadorSemanticoBirl implements AnalisadorSemanticoInterface {
+export class AnalisadorSemanticoBirl extends AnalisadorSemanticoBase {
     pilhaVariaveis: PilhaVariaveis;
     variaveis: { [nomeVariavel: string]: VariavelHipoteticaBirlInterface };
     atual: number;
     diagnosticos: DiagnosticoAnalisadorSemantico[];
 
     constructor() {
+        super();
         this.pilhaVariaveis = new PilhaVariaveis();
         this.variaveis = {};
         this.atual = 0;
         this.diagnosticos = [];
     }
 
-    visitarDeclaracaoInicioAlgoritmo(declaracao: InicioAlgoritmo): Promise<any> {
-        return Promise.resolve();
-    }
-
-    visitarDeclaracaoCabecalhoPrograma(declaracao: CabecalhoPrograma): Promise<any> {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoTupla(expressao: Tupla): Promise<any> {
-        return Promise.resolve();
-    }
-    visitarExpressaoAcessoElementoMatriz(expressao: any) {
-        return Promise.resolve();
-    }
-    visitarExpressaoAtribuicaoPorIndicesMatriz(expressao: any): Promise<any> {
-        return Promise.resolve();
-    }
-    visitarExpressaoExpressaoRegular(expressao: ExpressaoRegular): Promise<any> {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoTipoDe(expressao: TipoDe): Promise<any> {
-        return Promise.resolve();
-    }
-
-    visitarDeclaracaoClasse(declaracao: Classe) {
-        return Promise.resolve();
-    }
-
-    visitarDeclaracaoConst(declaracao: Const): Promise<any> {
-        return Promise.resolve();
-    }
-
-    visitarDeclaracaoConstMultiplo(declaracao: ConstMultiplo): Promise<any> {
-        return Promise.resolve();
-    }
-
-    visitarDeclaracaoAleatorio(declaracao: Aleatorio): Promise<any> {
-        return Promise.resolve();
-    }
-
     visitarExpressaoDeAtribuicao(expressao: Atribuir) {
         if (!this.variaveis.hasOwnProperty(expressao.simbolo.lexema)) {
             this.diagnosticos.push({
@@ -143,46 +104,6 @@ export class AnalisadorSemanticoBirl implements AnalisadorSemanticoInterface {
         return declaracao.expressao.aceitar(this);
     }
 
-    visitarDeclaracaoDefinicaoFuncao(declaracao: FuncaoDeclaracao) {
-        return Promise.resolve();
-    }
-
-    visitarDeclaracaoEnquanto(declaracao: Enquanto) {
-        return Promise.resolve();
-    }
-
-    visitarDeclaracaoEscolha(declaracao: Escolha) {
-        return Promise.resolve();
-    }
-
-    visitarDeclaracaoEscreva(declaracao: Escreva) {
-        return Promise.resolve();
-    }
-
-    visitarDeclaracaoFazer(declaracao: Fazer) {
-        return Promise.resolve();
-    }
-
-    visitarDeclaracaoImportar(declaracao: Importar) {
-        return Promise.resolve();
-    }
-
-    visitarDeclaracaoPara(declaracao: Para): Promise<any> {
-        return Promise.resolve();
-    }
-
-    visitarDeclaracaoParaCada(declaracao: ParaCada): Promise<any> {
-        return Promise.resolve();
-    }
-
-    visitarDeclaracaoSe(declaracao: Se) {
-        return Promise.resolve();
-    }
-
-    visitarDeclaracaoTente(declaracao: Tente) {
-        return Promise.resolve();
-    }
-
     visitarDeclaracaoVar(declaracao: Var): Promise<any> {
         this.variaveis[declaracao.simbolo.lexema] = {
             imutavel: false,
@@ -192,78 +113,6 @@ export class AnalisadorSemanticoBirl implements AnalisadorSemanticoInterface {
         return Promise.resolve();
     }
 
-    visitarDeclaracaoVarMultiplo(declaracao: VarMultiplo): Promise<any> {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoAcessoIndiceVariavel(expressao: any) {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoAcessoMetodo(expressao: any) {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoAgrupamento(expressao: any): Promise<any> {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoAtribuicaoPorIndice(expressao: any): Promise<any> {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoBinaria(expressao: any) {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoBloco(declaracao: Bloco): Promise<any> {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoContinua(declaracao?: Continua): ContinuarQuebra {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoDeChamada(expressao: any) {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoDefinirValor(expressao: any) {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoDeleguaFuncao(expressao: any) {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoDeVariavel(expressao: any) {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoDicionario(expressao: any) {
-        return Promise.resolve();
-    }
-
-    visitarDeclaracaoEscrevaMesmaLinha(declaracao: EscrevaMesmaLinha) {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoFalhar(expressao: any): Promise<any> {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoFimPara(declaracao: FimPara) {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoFormatacaoEscrita(declaracao: FormatacaoEscrita) {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoIsto(expressao: any) {
-        return Promise.resolve();
-    }
-
     visitarExpressaoLeia(expressao: Leia) {
         if (!this.variaveis.hasOwnProperty((expressao.argumentos[0] as Variavel).simbolo.lexema)) {
             this.diagnosticos.push({
@@ -289,44 +138,15 @@ export class AnalisadorSemanticoBirl implements AnalisadorSemanticoInterface {
                 linha: expressao.linha,
                 severidade: DiagnosticoSeveridade.ERRO,
             });
-            return Promise.resolve();
         }
 
         return Promise.resolve();
     }
 
-    visitarExpressaoLeiaMultiplo(expressao: LeiaMultiplo): Promise<any> {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoLiteral(expressao: Literal): Promise<any> {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoLogica(expressao: any) {
-        return Promise.resolve();
-    }
-
     visitarExpressaoRetornar(declaracao: Retorna): Promise<RetornoQuebra> {
         return Promise.resolve(null);
     }
 
-    visitarExpressaoSuper(expressao: Super) {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoSustar(declaracao?: Sustar): SustarQuebra {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoUnaria(expressao: any) {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoVetor(expressao: any) {
-        return Promise.resolve();
-    }
-
     analisar(declaracoes: Declaracao[]): RetornoAnalisadorSemantico {
         this.variaveis = {};
         this.atual = 0;
diff --git a/fontes/analisador-semantico/dialetos/analisador-semantico-mapler.ts b/fontes/analisador-semantico/dialetos/analisador-semantico-mapler.ts
index e4ccca5f..0d0544b8 100644
--- a/fontes/analisador-semantico/dialetos/analisador-semantico-mapler.ts
+++ b/fontes/analisador-semantico/dialetos/analisador-semantico-mapler.ts
@@ -43,15 +43,15 @@ import {
 } from '../../declaracoes';
 import { InicioAlgoritmo } from '../../declaracoes/inicio-algoritmo';
 import { SimboloInterface } from '../../interfaces';
-import { AnalisadorSemanticoInterface } from '../../interfaces/analisador-semantico-interface';
 import { DiagnosticoAnalisadorSemantico, DiagnosticoSeveridade } from '../../interfaces/erros';
 import { FuncaoHipoteticaInterface } from '../../interfaces/funcao-hipotetica-interface';
 import { RetornoAnalisadorSemantico } from '../../interfaces/retornos/retorno-analisador-semantico';
 import { VariavelHipoteticaInterface } from '../../interfaces/variavel-hipotetica-interface';
 import { ContinuarQuebra, RetornoQuebra, SustarQuebra } from '../../quebras';
+import { AnalisadorSemanticoBase } from '../analisador-semantico-base';
 import { PilhaVariaveis } from './../pilha-variaveis';
 
-export class AnalisadorSemanticoMapler implements AnalisadorSemanticoInterface {
+export class AnalisadorSemanticoMapler extends AnalisadorSemanticoBase {
     pilhaVariaveis: PilhaVariaveis;
     variaveis: { [nomeVariavel: string]: VariavelHipoteticaInterface };
     funcoes: { [nomeFuncao: string]: FuncaoHipoteticaInterface };
@@ -59,6 +59,7 @@ export class AnalisadorSemanticoMapler implements AnalisadorSemanticoInterface {
     diagnosticos: DiagnosticoAnalisadorSemantico[];
 
     constructor() {
+        super();
         this.pilhaVariaveis = new PilhaVariaveis();
         this.variaveis = {};
         this.funcoes = {};
@@ -66,31 +67,6 @@ export class AnalisadorSemanticoMapler implements AnalisadorSemanticoInterface {
         this.diagnosticos = [];
     }
 
-    visitarDeclaracaoInicioAlgoritmo(declaracao: InicioAlgoritmo): Promise<any> {
-        return Promise.resolve();
-    }
-
-    visitarDeclaracaoCabecalhoPrograma(declaracao: CabecalhoPrograma): Promise<any> {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoTupla(expressao: Tupla): Promise<any> {
-        return Promise.resolve();
-    }
-    visitarExpressaoAcessoElementoMatriz(expressao: any) {
-        return Promise.resolve();
-    }
-    visitarExpressaoAtribuicaoPorIndicesMatriz(expressao: any): Promise<any> {
-        return Promise.resolve();
-    }
-    visitarExpressaoExpressaoRegular(expressao: ExpressaoRegular): Promise<any> {
-        return Promise.resolve();
-    }
-
-    visitarDeclaracaoAleatorio(declaracao: Aleatorio): Promise<any> {
-        return Promise.resolve();
-    }
-
     erro(simbolo: SimboloInterface, mensagem: string): void {
         this.diagnosticos.push({
             simbolo: simbolo,
@@ -111,34 +87,6 @@ export class AnalisadorSemanticoMapler implements AnalisadorSemanticoInterface {
         });
     }
 
-    visitarExpressaoTipoDe(expressao: TipoDe): Promise<any> {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoFalhar(expressao: Falhar): Promise<any> {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoLiteral(expressao: Literal): Promise<any> {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoAgrupamento(expressao: any): Promise<any> {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoUnaria(expressao: any) {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoBinaria(expressao: any) {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoDeChamada(expressao: Chamada) {
-        return Promise.resolve();
-    }
-
     visitarExpressaoDeAtribuicao(expressao: Atribuir) {
         let valor = this.variaveis[expressao.simbolo.lexema];
         if (!valor) {
@@ -154,10 +102,12 @@ export class AnalisadorSemanticoMapler implements AnalisadorSemanticoInterface {
                 this.erro(expressao.simbolo, `Atribuição inválida, esperado tipo '${valor.tipo}' na atribuição.`);
                 return Promise.resolve();
             }
+
             if (expressao.valor instanceof Vetor && !valor.tipo.includes('[]')) {
                 this.erro(expressao.simbolo, `Atribuição inválida, esperado tipo '${valor.tipo}' na atribuição.`);
                 return Promise.resolve();
             }
+
             if (expressao.valor instanceof Literal) {
                 let valorLiteral = typeof (expressao.valor as Literal).valor;
                 if (!['qualquer'].includes(valor.tipo)) {
@@ -182,90 +132,10 @@ export class AnalisadorSemanticoMapler implements AnalisadorSemanticoInterface {
         }
     }
 
-    visitarExpressaoDeVariavel(expressao: any) {
-        return Promise.resolve();
-    }
-
     visitarDeclaracaoDeExpressao(declaracao: Expressao) {
         return declaracao.expressao.aceitar(this);
     }
 
-    visitarExpressaoLeia(expressao: Leia) {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoLeiaMultiplo(expressao: LeiaMultiplo) {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoLogica(expressao: any) {
-        return Promise.resolve();
-    }
-
-    visitarDeclaracaoPara(declaracao: Para): Promise<any> {
-        return Promise.resolve();
-    }
-
-    visitarDeclaracaoParaCada(declaracao: ParaCada): Promise<any> {
-        return Promise.resolve();
-    }
-
-    visitarDeclaracaoSe(declaracao: Se) {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoFimPara(declaracao: FimPara) {
-        return Promise.resolve();
-    }
-
-    visitarDeclaracaoFazer(declaracao: Fazer) {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoFormatacaoEscrita(declaracao: FormatacaoEscrita) {
-        return Promise.resolve();
-    }
-
-    visitarDeclaracaoEscolha(declaracao: Escolha) {
-        return Promise.resolve();
-    }
-
-    visitarDeclaracaoTente(declaracao: Tente) {
-        return Promise.resolve();
-    }
-
-    visitarDeclaracaoEnquanto(declaracao: Enquanto) {
-        return Promise.resolve();
-    }
-
-    visitarDeclaracaoImportar(declaracao: Importar) {
-        return Promise.resolve();
-    }
-
-    visitarDeclaracaoEscreva(declaracao: Escreva) {
-        return Promise.resolve();
-    }
-
-    visitarDeclaracaoEscrevaMesmaLinha(declaracao: EscrevaMesmaLinha) {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoBloco(declaracao: Bloco): Promise<any> {
-        return Promise.resolve();
-    }
-
-    visitarDeclaracaoConst(declaracao: Const): Promise<any> {
-        return Promise.resolve();
-    }
-
-    virificarTipoDeclaracaoConst(declaracao: Const): Promise<any> {
-        return Promise.resolve();
-    }
-
-    visitarDeclaracaoConstMultiplo(declaracao: ConstMultiplo): Promise<any> {
-        return Promise.resolve();
-    }
-
     visitarDeclaracaoVar(declaracao: Var): Promise<any> {
         this.variaveis[declaracao.simbolo.lexema] = {
             imutavel: false,
@@ -281,66 +151,10 @@ export class AnalisadorSemanticoMapler implements AnalisadorSemanticoInterface {
         return Promise.resolve();
     }
 
-    visitarDeclaracaoVarMultiplo(declaracao: VarMultiplo): Promise<any> {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoContinua(declaracao?: Continua): ContinuarQuebra {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoSustar(declaracao?: Sustar): SustarQuebra {
-        return Promise.resolve();
-    }
-
     visitarExpressaoRetornar(declaracao: Retorna): Promise<RetornoQuebra> {
         return Promise.resolve(null);
     }
 
-    visitarExpressaoDeleguaFuncao(expressao: any) {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoAtribuicaoPorIndice(expressao: any): Promise<any> {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoAcessoIndiceVariavel(expressao: any) {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoDefinirValor(expressao: any) {
-        return Promise.resolve();
-    }
-
-    visitarDeclaracaoDefinicaoFuncao(declaracao: FuncaoDeclaracao) {
-        return Promise.resolve();
-    }
-
-    visitarDeclaracaoClasse(declaracao: Classe) {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoAcessoMetodo(expressao: any) {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoIsto(expressao: any) {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoDicionario(expressao: any) {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoVetor(expressao: any) {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoSuper(expressao: Super) {
-        return Promise.resolve();
-    }
-
     analisar(declaracoes: Declaracao[]): RetornoAnalisadorSemantico {
         this.variaveis = {};
         this.atual = 0;
diff --git a/fontes/analisador-semantico/dialetos/analisador-semantico-visualg.ts b/fontes/analisador-semantico/dialetos/analisador-semantico-visualg.ts
index 003bcc66..73310ca8 100644
--- a/fontes/analisador-semantico/dialetos/analisador-semantico-visualg.ts
+++ b/fontes/analisador-semantico/dialetos/analisador-semantico-visualg.ts
@@ -48,9 +48,10 @@ import { FuncaoHipoteticaInterface } from '../../interfaces/funcao-hipotetica-in
 import { RetornoAnalisadorSemantico } from '../../interfaces/retornos/retorno-analisador-semantico';
 import { VariavelHipoteticaInterface } from '../../interfaces/variavel-hipotetica-interface';
 import { ContinuarQuebra, RetornoQuebra, SustarQuebra } from '../../quebras';
+import { AnalisadorSemanticoBase } from '../analisador-semantico-base';
 import { PilhaVariaveis } from '../pilha-variaveis';
 
-export class AnalisadorSemanticoVisuAlg implements AnalisadorSemanticoInterface {
+export class AnalisadorSemanticoVisuAlg extends AnalisadorSemanticoBase {
     pilhaVariaveis: PilhaVariaveis;
     variaveis: { [nomeVariavel: string]: VariavelHipoteticaInterface };
     funcoes: { [nomeFuncao: string]: FuncaoHipoteticaInterface };
@@ -58,6 +59,7 @@ export class AnalisadorSemanticoVisuAlg implements AnalisadorSemanticoInterface
     diagnosticos: DiagnosticoAnalisadorSemantico[];
 
     constructor() {
+        super();
         this.pilhaVariaveis = new PilhaVariaveis();
         this.variaveis = {};
         this.funcoes = {};
@@ -65,18 +67,6 @@ export class AnalisadorSemanticoVisuAlg implements AnalisadorSemanticoInterface
         this.diagnosticos = [];
     }
 
-    visitarDeclaracaoInicioAlgoritmo(declaracao: InicioAlgoritmo): Promise<any> {
-        return Promise.resolve();
-    }
-
-    visitarDeclaracaoCabecalhoPrograma(declaracao: CabecalhoPrograma): Promise<any> {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoTupla(expressao: Tupla): Promise<any> {
-        return Promise.resolve();
-    }
-
     erro(simbolo: SimboloInterface, mensagem: string): void {
         this.diagnosticos.push({
             simbolo: simbolo,
@@ -215,18 +205,6 @@ export class AnalisadorSemanticoVisuAlg implements AnalisadorSemanticoInterface
         return Promise.resolve();
     }
 
-    visitarDeclaracaoClasse(declaracao: Classe) {
-        return Promise.resolve();
-    }
-
-    visitarDeclaracaoConst(declaracao: Const): Promise<any> {
-        return Promise.resolve();
-    }
-
-    visitarDeclaracaoConstMultiplo(declaracao: ConstMultiplo): Promise<any> {
-        return Promise.resolve();
-    }
-
     visitarDeclaracaoDeExpressao(declaracao: Expressao) {
         switch (declaracao.expressao.constructor.name) {
             case 'Atribuir':
@@ -265,18 +243,6 @@ export class AnalisadorSemanticoVisuAlg implements AnalisadorSemanticoInterface
         return Promise.resolve();
     }
 
-    visitarDeclaracaoEnquanto(declaracao: Enquanto) {
-        return Promise.resolve();
-    }
-
-    visitarDeclaracaoEscolha(declaracao: Escolha) {
-        return Promise.resolve();
-    }
-
-    visitarDeclaracaoEscreva(declaracao: Escreva) {
-        return Promise.resolve();
-    }
-
     visitarDeclaracaoEscrevaMesmaLinha(declaracao: EscrevaMesmaLinha) {
         declaracao.argumentos.forEach((argumento: FormatacaoEscrita) => {
             if (argumento.expressao instanceof Variavel) {
@@ -287,12 +253,12 @@ export class AnalisadorSemanticoVisuAlg implements AnalisadorSemanticoInterface
                     );
                     return Promise.resolve();
                 }
+
                 if (this.variaveis[argumento.expressao.simbolo.lexema]?.valor === undefined) {
                     this.aviso(
                         argumento.expressao.simbolo,
                         `Variável '${argumento.expressao.simbolo.lexema}' não foi inicializada.`
                     );
-                    return Promise.resolve();
                 }
             }
         });
@@ -300,65 +266,6 @@ export class AnalisadorSemanticoVisuAlg implements AnalisadorSemanticoInterface
         return Promise.resolve();
     }
 
-    visitarDeclaracaoFazer(declaracao: Fazer) {
-        return Promise.resolve();
-    }
-
-    visitarDeclaracaoImportar(declaracao: Importar) {
-        return Promise.resolve();
-    }
-
-    visitarDeclaracaoPara(declaracao: Para): Promise<any> {
-        return Promise.resolve();
-    }
-
-    visitarDeclaracaoParaCada(declaracao: ParaCada): Promise<any> {
-        return Promise.resolve();
-    }
-
-    visitarDeclaracaoSe(declaracao: Se) {
-        return Promise.resolve();
-    }
-
-    visitarDeclaracaoTente(declaracao: Tente) {
-        return Promise.resolve();
-    }
-
-    visitarDeclaracaoVarMultiplo(declaracao: VarMultiplo): Promise<any> {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoAcessoIndiceVariavel(expressao: any) {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoVetor(expressao: any) {
-        return Promise.resolve();
-    }
-    visitarExpressaoAcessoMetodo(expressao: any) {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoAgrupamento(expressao: any): Promise<any> {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoAtribuicaoPorIndice(expressao: any): Promise<any> {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoBinaria(expressao: any) {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoBloco(declaracao: Bloco): Promise<any> {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoContinua(declaracao?: Continua): ContinuarQuebra {
-        return Promise.resolve();
-    }
-
     visitarExpressaoDeChamada(expressao: Chamada) {
         if (expressao.entidadeChamada instanceof Variavel) {
             const variavel = expressao.entidadeChamada as Variavel;
@@ -403,84 +310,10 @@ export class AnalisadorSemanticoVisuAlg implements AnalisadorSemanticoInterface
         return Promise.resolve();
     }
 
-    visitarExpressaoDeVariavel(expressao: any) {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoDefinirValor(expressao: any) {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoDeleguaFuncao(expressao: any) {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoDicionario(expressao: any) {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoExpressaoRegular(expressao: ExpressaoRegular): Promise<any> {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoFalhar(expressao: any): Promise<any> {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoFimPara(declaracao: FimPara) {
-        return Promise.resolve();
-    }
-    visitarExpressaoFormatacaoEscrita(declaracao: FormatacaoEscrita) {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoIsto(expressao: any) {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoLeia(expressao: Leia): Promise<any> {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoLeiaMultiplo(expressao: LeiaMultiplo): Promise<any> {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoLiteral(expressao: Literal): Promise<any> {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoLogica(expressao: any) {
-        return Promise.resolve();
-    }
-
     visitarExpressaoRetornar(declaracao: Retorna): Promise<RetornoQuebra> {
         return Promise.resolve(null);
     }
 
-    visitarExpressaoSuper(expressao: Super) {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoSustar(declaracao?: Sustar): SustarQuebra {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoTipoDe(expressao: TipoDe): Promise<any> {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoUnaria(expressao: any) {
-        return Promise.resolve();
-    }
-    visitarExpressaoAcessoElementoMatriz(expressao: any) {
-        return Promise.resolve();
-    }
-
-    visitarExpressaoAtribuicaoPorIndicesMatriz(expressao: any): Promise<any> {
-        return Promise.resolve();
-    }
-
     analisar(declaracoes: Declaracao[]): RetornoAnalisadorSemantico {
         this.variaveis = {};
         this.atual = 0;
diff --git a/fontes/avaliador-sintatico/avaliador-sintatico.ts b/fontes/avaliador-sintatico/avaliador-sintatico.ts
index 7bbe21ad..445ac584 100644
--- a/fontes/avaliador-sintatico/avaliador-sintatico.ts
+++ b/fontes/avaliador-sintatico/avaliador-sintatico.ts
@@ -52,6 +52,7 @@ import {
     ParaCada,
     Falhar,
     PropriedadeClasse,
+    TendoComo,
 } from '../declaracoes';
 import { RetornoAvaliadorSintatico } from '../interfaces/retornos/retorno-avaliador-sintatico';
 import { RetornoLexador } from '../interfaces/retornos/retorno-lexador';
@@ -1046,6 +1047,9 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
             case tiposDeSimbolos.RETORNA:
                 this.avancarEDevolverAnterior();
                 return this.declaracaoRetorna();
+            case tiposDeSimbolos.TENDO:
+                this.avancarEDevolverAnterior();
+                return this.declaracaoTendoComo();
             case tiposDeSimbolos.TENTE:
                 this.avancarEDevolverAnterior();
                 return this.declaracaoTente();
@@ -1076,6 +1080,26 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
         return this.declaracaoExpressao();
     }
 
+    protected declaracaoTendoComo(): TendoComo {
+        const simboloTendo = this.simbolos[this.atual - 1];
+        const expressaoInicializacao = this.expressao();
+        this.consumir(tiposDeSimbolos.COMO, "Esperado palavra reservada 'como' após expressão de inicialização de variável, em declaração 'tendo'.");
+        const simboloNomeVariavel = this.consumir(tiposDeSimbolos.IDENTIFICADOR, "Esperado nome do identificador em declaração 'tendo'.");
+        this.consumir(tiposDeSimbolos.CHAVE_ESQUERDA, "Esperado chave esquerda para abertura de bloco em declaração 'tendo'.");
+        const blocoCorpo = this.blocoEscopo();
+        return new TendoComo(
+            simboloTendo.linha, 
+            simboloTendo.hashArquivo, 
+            simboloNomeVariavel, 
+            expressaoInicializacao, 
+            new Bloco(
+                simboloTendo.linha,
+                simboloTendo.hashArquivo, 
+                blocoCorpo
+            )
+        );
+    }
+
     protected declaracaoDesestruturacaoVariavel(): Declaracao[] {
         const identificadores: SimboloInterface[] = [];
 
diff --git a/fontes/declaracoes/index.ts b/fontes/declaracoes/index.ts
index 0d127da3..99df107d 100644
--- a/fontes/declaracoes/index.ts
+++ b/fontes/declaracoes/index.ts
@@ -10,6 +10,7 @@ export * from './escolha';
 export * from './escreva';
 export * from './escreva-mesma-linha';
 export * from './expressao';
+export * from './inicio-algoritmo';
 export * from './falhar';
 export * from './fazer';
 export * from './funcao';
@@ -23,6 +24,7 @@ export * from './propriedade-classe';
 export * from './sustar';
 export * from './retorna';
 export * from './se';
+export * from './tendo-como';
 export * from './tente';
 export * from './var';
 export * from './var-multiplo';
diff --git a/fontes/declaracoes/tendo-como.ts b/fontes/declaracoes/tendo-como.ts
new file mode 100644
index 00000000..3bea2fd8
--- /dev/null
+++ b/fontes/declaracoes/tendo-como.ts
@@ -0,0 +1,26 @@
+import { SimboloInterface, VisitanteComumInterface } from '../interfaces';
+import { Declaracao } from './declaracao';
+import { Bloco } from './bloco';
+import { Construto } from '../construtos';
+
+/**
+ * Esta declaração funciona para designar uma variável que deve ser encerrada
+ * após a execução do bloco.
+ * Por exemplo, abertura de arquivos, variáveis de fluxo (`streams`), etc.
+ */
+export class TendoComo extends Declaracao {
+    simboloVariavel: SimboloInterface;
+    inicializacaoVariavel: Construto;
+    corpo: Bloco;
+
+    constructor(linha: number, hashArquivo: number, simboloVariavel: SimboloInterface, inicializacaoVariavel: Construto, corpo: Bloco) {
+        super(linha, hashArquivo);
+        this.simboloVariavel = simboloVariavel;
+        this.inicializacaoVariavel = inicializacaoVariavel;
+        this.corpo = corpo;
+    }
+
+    async aceitar(visitante: VisitanteComumInterface): Promise<any> {
+        return await visitante.visitarDeclaracaoTendoComo(this);
+    }
+}
diff --git a/fontes/formatadores/formatador-delegua.ts b/fontes/formatadores/formatador-delegua.ts
index 7790d5e7..2a864688 100644
--- a/fontes/formatadores/formatador-delegua.ts
+++ b/fontes/formatadores/formatador-delegua.ts
@@ -51,6 +51,7 @@ import {
     Falhar,
     Aleatorio,
     CabecalhoPrograma,
+    TendoComo,
 } from '../declaracoes';
 import { InicioAlgoritmo } from '../declaracoes/inicio-algoritmo';
 import { VisitanteComumInterface } from '../interfaces';
@@ -79,6 +80,13 @@ export class FormatadorDelegua implements VisitanteComumInterface {
         this.deveIndentar = true;
     }
 
+    visitarDeclaracaoTendoComo(declaracao: TendoComo): void {
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}tendo `;
+        this.formatarDeclaracaoOuConstruto(declaracao.inicializacaoVariavel);
+        this.codigoFormatado += ` como ${declaracao.simboloVariavel.lexema} `;
+        this.formatarDeclaracaoOuConstruto(declaracao.corpo);
+    }
+
     visitarDeclaracaoInicioAlgoritmo(declaracao: InicioAlgoritmo): Promise<any> {
         throw new Error('Método não implementado.');
     }
@@ -665,7 +673,7 @@ export class FormatadorDelegua implements VisitanteComumInterface {
         }
     }
 
-    visitarExpressaoVetor(expressao: Vetor) {
+    visitarExpressaoVetor(expressao: Vetor): void {
         this.codigoFormatado += '[';
         for (let valor of expressao.valores) {
             this.formatarDeclaracaoOuConstruto(valor);
@@ -777,6 +785,9 @@ export class FormatadorDelegua implements VisitanteComumInterface {
             case 'Sustar':
                 this.visitarExpressaoSustar(declaracaoOuConstruto as Sustar);
                 break;
+            case 'TendoComo':
+                this.visitarDeclaracaoTendoComo(declaracaoOuConstruto as TendoComo);
+                break;
             case 'Tente':
                 this.visitarDeclaracaoTente(declaracaoOuConstruto as Tente);
                 break;
diff --git a/fontes/formatadores/formatador-portugol-studio.ts b/fontes/formatadores/formatador-portugol-studio.ts
index 92d80619..042acfd6 100644
--- a/fontes/formatadores/formatador-portugol-studio.ts
+++ b/fontes/formatadores/formatador-portugol-studio.ts
@@ -51,6 +51,7 @@ import {
     Falhar,
     Aleatorio,
     CabecalhoPrograma,
+    TendoComo,
 } from '../declaracoes';
 import { InicioAlgoritmo } from '../declaracoes/inicio-algoritmo';
 import { VisitanteComumInterface } from '../interfaces';
@@ -74,6 +75,10 @@ export class FormatadorPortugolStudio implements VisitanteComumInterface {
         this.deveIndentar = true;
     }
 
+    visitarDeclaracaoTendoComo(declaracao: TendoComo): void | Promise<any> {
+        throw new Error('Método não implementado.');
+    }
+
     visitarDeclaracaoInicioAlgoritmo(declaracao: InicioAlgoritmo): Promise<any> {
         throw new Error('Método não implementado.');
     }
diff --git a/fontes/formatadores/formatador-visualg.ts b/fontes/formatadores/formatador-visualg.ts
index 85dc9f2f..f34cdf52 100644
--- a/fontes/formatadores/formatador-visualg.ts
+++ b/fontes/formatadores/formatador-visualg.ts
@@ -51,6 +51,7 @@ import {
     Declaracao,
     Falhar,
     CabecalhoPrograma,
+    TendoComo,
 } from '../declaracoes';
 import { InicioAlgoritmo } from '../declaracoes/inicio-algoritmo';
 import { SimboloInterface, VisitanteComumInterface } from '../interfaces';
@@ -79,6 +80,10 @@ export class FormatadorVisuAlg implements VisitanteComumInterface {
         this.retornoFuncaoAtual = undefined;
     }
 
+    visitarDeclaracaoTendoComo(declaracao: TendoComo): void | Promise<any> {
+        throw new Error('Método não implementado.');
+    }
+
     visitarDeclaracaoInicioAlgoritmo(declaracao: InicioAlgoritmo): any {
         this.codigoFormatado += `inicio${this.quebraLinha}`;
     }
diff --git a/fontes/interfaces/resolvedor-interface.ts b/fontes/interfaces/resolvedor-interface.ts
index 84c5439a..6cadbb8c 100644
--- a/fontes/interfaces/resolvedor-interface.ts
+++ b/fontes/interfaces/resolvedor-interface.ts
@@ -16,7 +16,7 @@ export interface ResolvedorInterface {
     declarar(simbolo: SimboloInterface): void;
     inicioDoEscopo(): void;
     finalDoEscopo(): void;
-    resolver(declaracoes: any): RetornoResolvedor;
+    resolver(declaracoes: any): Promise<RetornoResolvedor>;
     resolverLocal(expressao: any, nome: any): void;
     visitarExpressaoBloco(declaracao: any): any;
     visitarExpressaoDeVariavel(expressao: any): any;
diff --git a/fontes/interfaces/visitante-comum-interface.ts b/fontes/interfaces/visitante-comum-interface.ts
index 13b12494..fac0d81a 100644
--- a/fontes/interfaces/visitante-comum-interface.ts
+++ b/fontes/interfaces/visitante-comum-interface.ts
@@ -1,12 +1,29 @@
 import {
+    AcessoElementoMatriz,
+    AcessoIndiceVariavel,
     AcessoMetodoOuPropriedade,
+    Agrupamento,
+    AtribuicaoPorIndice,
+    AtribuicaoPorIndicesMatriz,
     Atribuir,
+    Binario,
+    Chamada,
+    Constante,
+    DefinirValor,
+    Dicionario,
     ExpressaoRegular,
     FimPara,
+    FormatacaoEscrita,
+    FuncaoConstruto,
+    Isto,
     Literal,
+    Logico,
     Super,
     TipoDe,
     Tupla,
+    Unario,
+    Variavel,
+    Vetor,
 } from '../construtos';
 import {
     Aleatorio,
@@ -14,82 +31,83 @@ import {
     CabecalhoPrograma,
     Classe,
     Const,
+    ConstMultiplo,
     Continua,
     Enquanto,
     Escolha,
     Escreva,
+    EscrevaMesmaLinha,
     Expressao,
+    Falhar,
     Fazer,
     FuncaoDeclaracao,
     Importar,
+    InicioAlgoritmo,
     Leia,
+    LeiaMultiplo,
     Para,
     ParaCada,
     Retorna,
     Se,
     Sustar,
+    TendoComo,
     Tente,
     Var,
+    VarMultiplo,
 } from '../declaracoes';
 import { ContinuarQuebra, RetornoQuebra, SustarQuebra } from '../quebras';
 
-import { EscrevaMesmaLinha } from '../declaracoes/escreva-mesma-linha';
-import { FormatacaoEscrita } from '../construtos/formatacao-escrita';
-import { LeiaMultiplo } from '../declaracoes/leia-multiplo';
-import { ConstMultiplo } from '../declaracoes/const-multiplo';
-import { VarMultiplo } from '../declaracoes/var-multiplo';
-import { InicioAlgoritmo } from '../declaracoes/inicio-algoritmo';
-
 export interface VisitanteComumInterface {
-    visitarDeclaracaoInicioAlgoritmo(declaracao: InicioAlgoritmo): Promise<any>;
     visitarDeclaracaoAleatorio(declaracao: Aleatorio): Promise<any>;
     visitarDeclaracaoCabecalhoPrograma(declaracao: CabecalhoPrograma): Promise<any>;
-    visitarDeclaracaoClasse(declaracao: Classe): any;
+    visitarDeclaracaoClasse(declaracao: Classe): Promise<any> | void;
     visitarDeclaracaoConst(declaracao: Const): Promise<any>;
     visitarDeclaracaoConstMultiplo(declaracao: ConstMultiplo): Promise<any>;
-    visitarExpressaoDeAtribuicao(expressao: Atribuir): any;
-    visitarDeclaracaoDeExpressao(declaracao: Expressao): any;
-    visitarDeclaracaoDefinicaoFuncao(declaracao: FuncaoDeclaracao): any;
-    visitarDeclaracaoEnquanto(declaracao: Enquanto): any;
-    visitarDeclaracaoEscolha(declaracao: Escolha): any;
-    visitarDeclaracaoEscreva(declaracao: Escreva): any;
-    visitarDeclaracaoFazer(declaracao: Fazer): any;
-    visitarDeclaracaoImportar(declaracao: Importar): any;
+    visitarDeclaracaoDeExpressao(declaracao: Expressao): Promise<any> | void;
+    visitarDeclaracaoDefinicaoFuncao(declaracao: FuncaoDeclaracao): void;
+    visitarDeclaracaoEnquanto(declaracao: Enquanto): Promise<any> | void;
+    visitarDeclaracaoEscolha(declaracao: Escolha): Promise<any> | void;
+    visitarDeclaracaoEscreva(declaracao: Escreva): Promise<any> | void;
+    visitarDeclaracaoEscrevaMesmaLinha(declaracao: EscrevaMesmaLinha): Promise<any> | void;
+    visitarDeclaracaoFazer(declaracao: Fazer): Promise<any> | void;
+    visitarDeclaracaoImportar(declaracao: Importar): Promise<any> | void;
+    visitarDeclaracaoInicioAlgoritmo(declaracao: InicioAlgoritmo): Promise<any>;
     visitarDeclaracaoPara(declaracao: Para): Promise<any>;
     visitarDeclaracaoParaCada(declaracao: ParaCada): Promise<any>;
-    visitarDeclaracaoSe(declaracao: Se): any;
-    visitarDeclaracaoTente(declaracao: Tente): any;
+    visitarDeclaracaoSe(declaracao: Se): Promise<any> | void;
+    visitarDeclaracaoTendoComo(declaracao: TendoComo): Promise<any> | void;
+    visitarDeclaracaoTente(declaracao: Tente): Promise<any> | void;
     visitarDeclaracaoVar(declaracao: Var): Promise<any>;
     visitarDeclaracaoVarMultiplo(declaracao: VarMultiplo): Promise<any>;
-    visitarExpressaoAcessoIndiceVariavel(expressao: any): any;
-    visitarExpressaoAcessoElementoMatriz(expressao: any): any;
-    visitarExpressaoAcessoMetodo(expressao: AcessoMetodoOuPropriedade): any;
-    visitarExpressaoAgrupamento(expressao: any): Promise<any>;
-    visitarExpressaoAtribuicaoPorIndice(expressao: any): Promise<any>;
-    visitarExpressaoAtribuicaoPorIndicesMatriz(expressao: any): Promise<any>;
-    visitarExpressaoBinaria(expressao: any): any;
+    visitarExpressaoDeAtribuicao(expressao: Atribuir): Promise<any> | void;
+    visitarExpressaoAcessoIndiceVariavel(expressao: AcessoIndiceVariavel): Promise<any> | void;
+    visitarExpressaoAcessoElementoMatriz(expressao: AcessoElementoMatriz): Promise<any> | void;
+    visitarExpressaoAcessoMetodo(expressao: AcessoMetodoOuPropriedade): Promise<any> | void;
+    visitarExpressaoAgrupamento(expressao: Agrupamento): Promise<any>;
+    visitarExpressaoAtribuicaoPorIndice(expressao: AtribuicaoPorIndice): Promise<any>;
+    visitarExpressaoAtribuicaoPorIndicesMatriz(expressao: AtribuicaoPorIndicesMatriz): Promise<any>;
+    visitarExpressaoBinaria(expressao: Binario): Promise<any> | void;
     visitarExpressaoBloco(declaracao: Bloco): Promise<any>;
     visitarExpressaoContinua(declaracao?: Continua): ContinuarQuebra;
-    visitarExpressaoDeChamada(expressao: any): any;
-    visitarExpressaoDefinirValor(expressao: any): any;
-    visitarExpressaoDeleguaFuncao(expressao: any): any;
-    visitarExpressaoDeVariavel(expressao: any): any;
-    visitarExpressaoDicionario(expressao: any): any;
+    visitarExpressaoDeChamada(expressao: Chamada): Promise<any> | void;
+    visitarExpressaoDefinirValor(expressao: DefinirValor): Promise<any> | void;
+    visitarExpressaoDeleguaFuncao(expressao: FuncaoConstruto): Promise<any> | void;
+    visitarExpressaoDeVariavel(expressao: Variavel | Constante): Promise<any> | void;
+    visitarExpressaoDicionario(expressao: Dicionario): Promise<any> | void;
     visitarExpressaoExpressaoRegular(expressao: ExpressaoRegular): Promise<RegExp>;
-    visitarDeclaracaoEscrevaMesmaLinha(declaracao: EscrevaMesmaLinha): any;
-    visitarExpressaoFalhar(expressao: any): Promise<any>;
-    visitarExpressaoFimPara(declaracao: FimPara): any;
-    visitarExpressaoFormatacaoEscrita(declaracao: FormatacaoEscrita): any;
-    visitarExpressaoIsto(expressao: any): any;
+    visitarExpressaoFalhar(expressao: Falhar): Promise<any>;
+    visitarExpressaoFimPara(declaracao: FimPara): Promise<any> | void;
+    visitarExpressaoFormatacaoEscrita(declaracao: FormatacaoEscrita): Promise<any> | void;
+    visitarExpressaoIsto(expressao: Isto): Promise<any> | void;
     visitarExpressaoLeia(expressao: Leia): Promise<any>;
     visitarExpressaoLeiaMultiplo(expressao: LeiaMultiplo): Promise<any>;
     visitarExpressaoLiteral(expressao: Literal): Promise<any>;
-    visitarExpressaoLogica(expressao: any): any;
+    visitarExpressaoLogica(expressao: Logico): Promise<any> | void;
     visitarExpressaoRetornar(declaracao: Retorna): Promise<RetornoQuebra>;
-    visitarExpressaoSuper(expressao: Super): any;
+    visitarExpressaoSuper(expressao: Super): Promise<any> | void;
     visitarExpressaoSustar(declaracao?: Sustar): SustarQuebra;
     visitarExpressaoTupla(expressao: Tupla): Promise<any>;
     visitarExpressaoTipoDe(expressao: TipoDe): Promise<any>;
-    visitarExpressaoUnaria(expressao: any): any;
-    visitarExpressaoVetor(expressao: any): any;
+    visitarExpressaoUnaria(expressao: Unario): Promise<any> | void;
+    visitarExpressaoVetor(expressao: Vetor): Promise<any> | void;
 }
diff --git a/fontes/interpretador/dialetos/birl/interpretador-birl.ts b/fontes/interpretador/dialetos/birl/interpretador-birl.ts
index 98fb32d0..b6ee327e 100644
--- a/fontes/interpretador/dialetos/birl/interpretador-birl.ts
+++ b/fontes/interpretador/dialetos/birl/interpretador-birl.ts
@@ -595,21 +595,22 @@ export class InterpretadorBirl extends InterpretadorBase implements Interpretado
         return null;
     }
 
-    async visitarExpressaoFimPara(declaracao: FimPara) {
+    visitarExpressaoFimPara(declaracao: FimPara): never {
         throw new Error('Método não implementado.');
     }
+
     async visitarDeclaracaoFazer(declaracao: Fazer) {
         throw new Error('Método não implementado.');
     }
-    // async visitarExpressaoFormatacaoEscrita(declaracao: FormatacaoEscrita) {
-    //     throw new Error('Método não implementado.');
-    // }
+
     async visitarDeclaracaoEscolha(declaracao: Escolha) {
         throw new Error('Método não implementado.');
     }
+
     async visitarDeclaracaoTente(declaracao: Tente) {
         throw new Error('Método não implementado.');
     }
+    
     async visitarDeclaracaoEnquanto(declaracao: Enquanto): Promise<any> {
         let retornoExecucao: any;
         while (!(retornoExecucao instanceof Quebra) && this.eVerdadeiro(await this.avaliar(declaracao.condicao))) {
@@ -727,38 +728,45 @@ export class InterpretadorBirl extends InterpretadorBase implements Interpretado
 
         return new RetornoQuebra(valor);
     }
-    // async visitarExpressaoDeleguaFuncao(expressao: any) {
-    //     throw new Error('Método não implementado.');
-    // }
+
     visitarExpressaoAtribuicaoPorIndice(expressao: any): Promise<any> {
         throw new Error('Método não implementado.');
     }
+
     async visitarExpressaoAcessoIndiceVariavel(expressao: any) {
         throw new Error('Método não implementado.');
     }
+
     async visitarExpressaoDefinirValor(expressao: any) {
         throw new Error('Método não implementado.');
     }
+
     visitarDeclaracaoDefinicaoFuncao(declaracao: FuncaoDeclaracao) {
         const funcao = new DeleguaFuncao(declaracao.simbolo.lexema, declaracao.funcao);
         this.pilhaEscoposExecucao.definirVariavel(declaracao.simbolo.lexema, funcao);
     }
+
     async visitarDeclaracaoClasse(declaracao: Classe) {
         throw new Error('Método não implementado.');
     }
+
     async visitarExpressaoAcessoMetodo(expressao: any) {
         throw new Error('Método não implementado.');
     }
-    visitarExpressaoIsto(expressao: any) {
+
+    visitarExpressaoIsto(expressao: any): never {
         throw new Error('Método não implementado.');
     }
+
     async visitarExpressaoDicionario(expressao: any) {
         throw new Error('Método não implementado.');
     }
+
     async visitarExpressaoVetor(expressao: any) {
         throw new Error('Método não implementado.');
     }
-    visitarExpressaoSuper(expressao: Super) {
+
+    visitarExpressaoSuper(expressao: Super): never {
         throw new Error('Método não implementado.');
     }
 
diff --git a/fontes/interpretador/dialetos/egua-classico/interpretador-egua-classico.ts b/fontes/interpretador/dialetos/egua-classico/interpretador-egua-classico.ts
index e113e68e..1db1ad52 100644
--- a/fontes/interpretador/dialetos/egua-classico/interpretador-egua-classico.ts
+++ b/fontes/interpretador/dialetos/egua-classico/interpretador-egua-classico.ts
@@ -14,6 +14,7 @@ import {
     ExpressaoRegular,
     FimPara,
     FormatacaoEscrita,
+    Isto,
     Literal,
     QualTipo,
     Super,
@@ -41,6 +42,7 @@ import {
     Para,
     ParaCada,
     Se,
+    TendoComo,
     Tente,
     Var,
     VarMultiplo,
@@ -62,7 +64,7 @@ import { ArgumentoInterface } from '../../argumento-interface';
 import { InicioAlgoritmo } from '../../../declaracoes/inicio-algoritmo';
 
 /**
- * O Interpretador visita todos os elementos complexos gerados pelo analisador sintático (Parser)
+ * O Interpretador visita todos os elementos complexos gerados pelo analisador sintático (_Parser_)
  * e de fato executa a lógica de programação descrita no código.
  */
 export class InterpretadorEguaClassico implements InterpretadorInterface {
@@ -102,6 +104,10 @@ export class InterpretadorEguaClassico implements InterpretadorInterface {
         carregarBibliotecaGlobal(this, this.pilhaEscoposExecucao);
     }
 
+    visitarDeclaracaoTendoComo(declaracao: TendoComo): Promise<any> {
+        throw new Error('Método não implementado.');
+    }
+
     visitarDeclaracaoInicioAlgoritmo(declaracao: InicioAlgoritmo): Promise<any> {
         throw new Error('Método não implementado.');
     }
@@ -114,7 +120,7 @@ export class InterpretadorEguaClassico implements InterpretadorInterface {
         throw new Error('Método não implementado.');
     }
 
-    visitarExpressaoAcessoElementoMatriz(expressao: any) {
+    visitarExpressaoAcessoElementoMatriz(expressao: any): never {
         throw new Error('Método não implementado.');
     }
 
@@ -150,15 +156,15 @@ export class InterpretadorEguaClassico implements InterpretadorInterface {
         throw new Error('Método não implementado.');
     }
 
-    visitarExpressaoFimPara(declaracao: FimPara) {
+    visitarExpressaoFimPara(declaracao: FimPara): never {
         throw new Error('Método não implementado.');
     }
 
-    visitarExpressaoFormatacaoEscrita(declaracao: FormatacaoEscrita) {
+    visitarExpressaoFormatacaoEscrita(declaracao: FormatacaoEscrita): never {
         throw new Error('Método não implementado.');
     }
 
-    visitarDeclaracaoEscrevaMesmaLinha(declaracao: EscrevaMesmaLinha) {
+    visitarDeclaracaoEscrevaMesmaLinha(declaracao: EscrevaMesmaLinha): never {
         throw new Error('Método não implementado.');
     }
 
@@ -420,8 +426,8 @@ export class InterpretadorEguaClassico implements InterpretadorInterface {
         return this.pilhaEscoposExecucao.obterValorVariavel(simbolo);
     }
 
-    visitarExpressaoDeVariavel(expressao: Variavel): VariavelInterface {
-        return this.procurarVariavel(expressao.simbolo, expressao);
+    visitarExpressaoDeVariavel(expressao: Variavel): Promise<VariavelInterface> {
+        return Promise.resolve(this.procurarVariavel(expressao.simbolo, expressao));
     }
 
     async visitarDeclaracaoDeExpressao(declaracao: Expressao): Promise<any> {
@@ -723,7 +729,7 @@ export class InterpretadorEguaClassico implements InterpretadorInterface {
         return new RetornoQuebra(valor);
     }
 
-    visitarExpressaoDeleguaFuncao(expressao: any) {
+    async visitarExpressaoDeleguaFuncao(expressao: any): Promise<DeleguaFuncao> {
         return new DeleguaFuncao(null, expressao);
     }
 
@@ -915,8 +921,8 @@ export class InterpretadorEguaClassico implements InterpretadorInterface {
         );
     }
 
-    visitarExpressaoIsto(expressao: any) {
-        return this.procurarVariavel(expressao.palavraChave, expressao);
+    async visitarExpressaoIsto(expressao: Isto): Promise<any> {
+        return Promise.resolve(this.procurarVariavel(expressao.palavraChave, expressao));
     }
 
     async visitarExpressaoDicionario(expressao: any) {
@@ -1014,7 +1020,7 @@ export class InterpretadorEguaClassico implements InterpretadorInterface {
     async interpretar(declaracoes: Declaracao[]): Promise<RetornoInterpretador> {
         this.erros = [];
 
-        const retornoResolvedor = this.resolvedor.resolver(declaracoes);
+        const retornoResolvedor = await this.resolvedor.resolver(declaracoes);
         this.locais = retornoResolvedor.locais;
 
         const escopoExecucao: EscopoExecucao = {
diff --git a/fontes/interpretador/dialetos/egua-classico/resolvedor/resolvedor.ts b/fontes/interpretador/dialetos/egua-classico/resolvedor/resolvedor.ts
index 8009c7a0..694f6028 100644
--- a/fontes/interpretador/dialetos/egua-classico/resolvedor/resolvedor.ts
+++ b/fontes/interpretador/dialetos/egua-classico/resolvedor/resolvedor.ts
@@ -23,6 +23,7 @@ import {
     LeiaMultiplo,
     ParaCada,
     Se,
+    TendoComo,
     Var,
     VarMultiplo,
 } from '../../../../declaracoes';
@@ -49,7 +50,7 @@ const TipoClasse = {
     SUBCLASSE: 'SUBCLASSE',
 };
 
-const LoopType = {
+const TipoLoop = {
     NENHUM: 'NENHUM',
     ENQUANTO: 'ENQUANTO',
     ESCOLHA: 'ESCOLHA',
@@ -90,6 +91,10 @@ export class ResolvedorEguaClassico implements ResolvedorInterface, Interpretado
         this.cicloAtual = TipoClasse.NENHUM;
     }
 
+    visitarDeclaracaoTendoComo(declaracao: TendoComo): Promise<any> {
+        throw new Error('Método não implementado.');
+    }
+
     visitarDeclaracaoInicioAlgoritmo(declaracao: InicioAlgoritmo): Promise<any> {
         throw new Error('Método não implementado.');
     }
@@ -102,7 +107,7 @@ export class ResolvedorEguaClassico implements ResolvedorInterface, Interpretado
         throw new Error('Método não implementado.');
     }
 
-    visitarExpressaoAcessoElementoMatriz(expressao: any) {
+    visitarExpressaoAcessoElementoMatriz(expressao: any): never {
         throw new Error('Método não implementado.');
     }
 
@@ -138,15 +143,15 @@ export class ResolvedorEguaClassico implements ResolvedorInterface, Interpretado
         throw new Error('Método não implementado.');
     }
 
-    visitarExpressaoFimPara(declaracao: FimPara) {
+    visitarExpressaoFimPara(declaracao: FimPara): never {
         throw new Error('Método não implementado.');
     }
 
-    visitarExpressaoFormatacaoEscrita(declaracao: FormatacaoEscrita) {
+    visitarExpressaoFormatacaoEscrita(declaracao: FormatacaoEscrita): never {
         throw new Error('Método não implementado.');
     }
 
-    visitarDeclaracaoEscrevaMesmaLinha(declaracao: EscrevaMesmaLinha) {
+    visitarDeclaracaoEscrevaMesmaLinha(declaracao: EscrevaMesmaLinha): never {
         throw new Error('Método não implementado.');
     }
 
@@ -394,11 +399,11 @@ export class ResolvedorEguaClassico implements ResolvedorInterface, Interpretado
         return null;
     }
 
-    visitarDeclaracaoImportar(declaracao: any): void {
+    async visitarDeclaracaoImportar(declaracao: any): Promise<void> {
         this.resolver(declaracao.caminho);
     }
 
-    visitarDeclaracaoEscreva(declaracao: any): void {
+    async visitarDeclaracaoEscreva(declaracao: any): Promise<void> {
         this.resolver(declaracao.expressao);
     }
 
@@ -421,9 +426,9 @@ export class ResolvedorEguaClassico implements ResolvedorInterface, Interpretado
         return null;
     }
 
-    visitarDeclaracaoEscolha(declaracao: any): void {
+    async visitarDeclaracaoEscolha(declaracao: any): Promise<void> {
         const enclosingType = this.cicloAtual;
-        this.cicloAtual = LoopType.ESCOLHA;
+        this.cicloAtual = TipoLoop.ESCOLHA;
 
         const caminhos = declaracao.caminhos;
         const caminhoPadrao = declaracao.caminhoPadrao;
@@ -455,7 +460,7 @@ export class ResolvedorEguaClassico implements ResolvedorInterface, Interpretado
         }
 
         const enclosingType = this.cicloAtual;
-        this.cicloAtual = LoopType.ENQUANTO;
+        this.cicloAtual = TipoLoop.ENQUANTO;
         this.resolver(declaracao.corpo);
         this.cicloAtual = enclosingType;
 
@@ -466,7 +471,7 @@ export class ResolvedorEguaClassico implements ResolvedorInterface, Interpretado
         this.resolver(declaracao.condicaoEnquanto);
 
         const enclosingType = this.cicloAtual;
-        this.cicloAtual = LoopType.FAZER;
+        this.cicloAtual = TipoLoop.FAZER;
         this.resolver(declaracao.caminhoFazer);
         this.cicloAtual = enclosingType;
         return null;
@@ -561,15 +566,15 @@ export class ResolvedorEguaClassico implements ResolvedorInterface, Interpretado
         throw new Error('Método não implementado.');
     }
 
-    resolver(declaracoes: Construto | Declaracao | Declaracao[]): RetornoResolvedor {
+    async resolver(declaracoes: Construto | Declaracao | Declaracao[]): Promise<RetornoResolvedor> {
         if (Array.isArray(declaracoes)) {
             for (let i = 0; i < declaracoes.length; i++) {
                 if (declaracoes[i] && declaracoes[i].aceitar) {
-                    declaracoes[i].aceitar(this);
+                    await declaracoes[i].aceitar(this);
                 }
             }
         } else if (declaracoes) {
-            declaracoes.aceitar(this);
+            await declaracoes.aceitar(this);
         }
 
         return {
diff --git a/fontes/interpretador/dialetos/portugol-ipt/interpretador-portugol-ipt.ts b/fontes/interpretador/dialetos/portugol-ipt/interpretador-portugol-ipt.ts
index f0a852f7..7f28a88e 100644
--- a/fontes/interpretador/dialetos/portugol-ipt/interpretador-portugol-ipt.ts
+++ b/fontes/interpretador/dialetos/portugol-ipt/interpretador-portugol-ipt.ts
@@ -35,6 +35,7 @@ import {
     Retorna,
     Se,
     Sustar,
+    TendoComo,
     Tente,
     Var,
     VarMultiplo,
@@ -89,6 +90,10 @@ export class InterpretadorPortugolIpt implements InterpretadorInterface {
         this.pilhaEscoposExecucao.empilhar(escopoExecucao);
     }
 
+    visitarDeclaracaoTendoComo(declaracao: TendoComo): Promise<any> {
+        throw new Error('Método não implementado.');
+    }
+
     visitarDeclaracaoInicioAlgoritmo(declaracao: InicioAlgoritmo): Promise<any> {
         throw new Error('Método não implementado.');
     }
@@ -101,7 +106,7 @@ export class InterpretadorPortugolIpt implements InterpretadorInterface {
         throw new Error('Método não implementado.');
     }
 
-    visitarExpressaoAcessoElementoMatriz(expressao: any) {
+    visitarExpressaoAcessoElementoMatriz(expressao: any): never {
         throw new Error('Método não implementado.');
     }
 
@@ -148,7 +153,7 @@ export class InterpretadorPortugolIpt implements InterpretadorInterface {
         throw new Error('Método não implementado');
     }
 
-    visitarExpressaoUnaria(expressao: any) {
+    visitarExpressaoUnaria(expressao: any): never {
         throw new Error('Método não implementado');
     }
 
@@ -266,11 +271,11 @@ export class InterpretadorPortugolIpt implements InterpretadorInterface {
         }
     }
 
-    visitarExpressaoDeChamada(expressao: any) {
+    visitarExpressaoDeChamada(expressao: any): never {
         throw new Error('Método não implementado');
     }
 
-    visitarExpressaoDeAtribuicao(expressao: Atribuir) {
+    visitarExpressaoDeAtribuicao(expressao: Atribuir): never {
         throw new Error('Método não implementado');
     }
 
@@ -282,7 +287,7 @@ export class InterpretadorPortugolIpt implements InterpretadorInterface {
         return this.procurarVariavel(expressao.simbolo);
     }
 
-    visitarDeclaracaoDeExpressao(declaracao: Expressao) {
+    visitarDeclaracaoDeExpressao(declaracao: Expressao): never {
         throw new Error('Método não implementado');
     }
 
@@ -305,7 +310,7 @@ export class InterpretadorPortugolIpt implements InterpretadorInterface {
         throw new Error('Método não implementado');
     }
 
-    visitarExpressaoLogica(expressao: any) {
+    visitarExpressaoLogica(expressao: any): never {
         throw new Error('Método não implementado');
     }
 
@@ -341,11 +346,11 @@ export class InterpretadorPortugolIpt implements InterpretadorInterface {
         return Promise.reject('Método não implementado');
     }
 
-    visitarExpressaoFimPara(declaracao: FimPara) {
+    visitarExpressaoFimPara(declaracao: FimPara): never {
         throw new Error('Método não implementado');
     }
 
-    visitarDeclaracaoFazer(declaracao: Fazer) {
+    visitarDeclaracaoFazer(declaracao: Fazer): never {
         throw new Error('Método não implementado');
     }
 
@@ -369,16 +374,19 @@ export class InterpretadorPortugolIpt implements InterpretadorInterface {
         return resultado;
     }
 
-    visitarDeclaracaoEscolha(declaracao: Escolha) {
+    visitarDeclaracaoEscolha(declaracao: Escolha): never {
         throw new Error('Método não implementado');
     }
-    visitarDeclaracaoTente(declaracao: Tente) {
+
+    visitarDeclaracaoTente(declaracao: Tente): never {
         throw new Error('Método não implementado');
     }
-    visitarDeclaracaoEnquanto(declaracao: Enquanto) {
+
+    visitarDeclaracaoEnquanto(declaracao: Enquanto): never {
         throw new Error('Método não implementado');
     }
-    visitarDeclaracaoImportar(declaracao: Importar) {
+    
+    visitarDeclaracaoImportar(declaracao: Importar): never {
         throw new Error('Método não implementado');
     }
 
@@ -489,7 +497,7 @@ export class InterpretadorPortugolIpt implements InterpretadorInterface {
         throw new Error('Método não implementado');
     }
 
-    visitarExpressaoDeleguaFuncao(expressao: any) {
+    visitarExpressaoDeleguaFuncao(expressao: any): never {
         throw new Error('Método não implementado');
     }
 
@@ -497,11 +505,11 @@ export class InterpretadorPortugolIpt implements InterpretadorInterface {
         throw new Error('Método não implementado');
     }
 
-    visitarExpressaoAcessoIndiceVariavel(expressao: any) {
+    visitarExpressaoAcessoIndiceVariavel(expressao: any): never {
         throw new Error('Método não implementado');
     }
 
-    visitarExpressaoDefinirValor(expressao: any) {
+    visitarExpressaoDefinirValor(expressao: any): never {
         throw new Error('Método não implementado');
     }
 
@@ -509,27 +517,27 @@ export class InterpretadorPortugolIpt implements InterpretadorInterface {
         throw new Error('Método não implementado');
     }
 
-    visitarDeclaracaoClasse(declaracao: Classe) {
+    visitarDeclaracaoClasse(declaracao: Classe): never {
         throw new Error('Método não implementado');
     }
 
-    visitarExpressaoAcessoMetodo(expressao: any) {
+    visitarExpressaoAcessoMetodo(expressao: any): never {
         throw new Error('Método não implementado');
     }
 
-    visitarExpressaoIsto(expressao: any) {
+    visitarExpressaoIsto(expressao: any): never {
         throw new Error('Método não implementado');
     }
 
-    visitarExpressaoDicionario(expressao: any) {
+    visitarExpressaoDicionario(expressao: any): never {
         throw new Error('Método não implementado');
     }
 
-    visitarExpressaoVetor(expressao: any) {
+    visitarExpressaoVetor(expressao: any): never {
         throw new Error('Método não implementado');
     }
 
-    visitarExpressaoSuper(expressao: Super) {
+    visitarExpressaoSuper(expressao: Super): never {
         throw new Error('Método não implementado');
     }
 
diff --git a/fontes/interpretador/dialetos/visualg/interpretador-visualg.ts b/fontes/interpretador/dialetos/visualg/interpretador-visualg.ts
index 93ba6e63..f92c27e1 100644
--- a/fontes/interpretador/dialetos/visualg/interpretador-visualg.ts
+++ b/fontes/interpretador/dialetos/visualg/interpretador-visualg.ts
@@ -57,11 +57,11 @@ export class InterpretadorVisuAlg extends InterpretadorBase {
         throw new Error('Método não implementado.');
     }
 
-    async visitarExpressaoAcessoElementoMatriz(expressao: AcessoElementoMatriz): Promise<any> {
+    override async visitarExpressaoAcessoElementoMatriz(expressao: AcessoElementoMatriz): Promise<any> {
         return await comum.visitarExpressaoAcessoElementoMatriz(this, expressao);
     }
 
-    async visitarExpressaoAtribuicaoPorIndicesMatriz(expressao: AtribuicaoPorIndicesMatriz): Promise<any> {
+    override async visitarExpressaoAtribuicaoPorIndicesMatriz(expressao: AtribuicaoPorIndicesMatriz): Promise<any> {
         return await comum.visitarExpressaoAtribuicaoPorIndicesMatriz(this, expressao);
     }
 
diff --git a/fontes/interpretador/interpretador-base.ts b/fontes/interpretador/interpretador-base.ts
index 54b0a883..d52da7a0 100644
--- a/fontes/interpretador/interpretador-base.ts
+++ b/fontes/interpretador/interpretador-base.ts
@@ -26,12 +26,14 @@ import {
     Fazer,
     FuncaoDeclaracao,
     Importar,
+    InicioAlgoritmo,
     Leia,
     LeiaMultiplo,
     Para,
     ParaCada,
     Retorna,
     Se,
+    TendoComo,
     Tente,
     Var,
     VarMultiplo,
@@ -56,6 +58,7 @@ import {
     ExpressaoRegular,
     FimPara,
     FormatacaoEscrita,
+    FuncaoConstruto,
     Literal,
     Logico,
     QualTipo,
@@ -84,7 +87,6 @@ import primitivasVetor from '../bibliotecas/primitivas-vetor';
 import tiposDeSimbolos from '../tipos-de-simbolos/delegua';
 import tipoDeDadosPrimitivos from '../tipos-de-dados/primitivos';
 import tipoDeDadosDelegua from '../tipos-de-dados/delegua';
-import { InicioAlgoritmo } from '../declaracoes/inicio-algoritmo';
 
 /**
  * O Interpretador visita todos os elementos complexos gerados pelo avaliador sintático (_parser_),
@@ -169,6 +171,22 @@ export class InterpretadorBase implements InterpretadorInterface {
         carregarBibliotecasGlobais(this, this.pilhaEscoposExecucao);
     }
 
+    async visitarDeclaracaoTendoComo(declaracao: TendoComo): Promise<any> {
+        const retornoInicializacao = await this.avaliar(declaracao.inicializacaoVariavel);
+        this.pilhaEscoposExecucao.definirConstante(declaracao.simboloVariavel.lexema, retornoInicializacao);
+        await this.executar(declaracao.corpo);
+
+        if (retornoInicializacao instanceof ObjetoDeleguaClasse) {
+            const metodoFinalizar = retornoInicializacao.classe.metodos['finalizar'];
+            if (metodoFinalizar) {
+                const chamavel = metodoFinalizar.funcaoPorMetodoDeClasse(retornoInicializacao);
+                chamavel.chamar(this, []);
+            }
+        }
+
+        return null;
+    }
+
     async visitarDeclaracaoInicioAlgoritmo(declaracao: InicioAlgoritmo): Promise<any> {
         throw new Error('Método não implementado.');
     }
@@ -188,11 +206,11 @@ export class InterpretadorBase implements InterpretadorInterface {
         return valores;
     }
 
-    visitarExpressaoAtribuicaoPorIndicesMatriz(expressao: any): Promise<any> {
+    async visitarExpressaoAtribuicaoPorIndicesMatriz(expressao: any): Promise<any> {
         throw new Error('Método não implementado.');
     }
 
-    visitarExpressaoAcessoElementoMatriz(expressao: any) {
+    async visitarExpressaoAcessoElementoMatriz(expressao: any): Promise<any> {
         throw new Error('Método não implementado.');
     }
 
@@ -240,7 +258,7 @@ export class InterpretadorBase implements InterpretadorInterface {
         throw new ErroEmTempoDeExecucao(expressao.simbolo, textoFalha, expressao.linha);
     }
 
-    visitarExpressaoFimPara(declaracao: FimPara) {
+    async visitarExpressaoFimPara(declaracao: FimPara): Promise<any> {
         throw new Error('Método não implementado.');
     }
 
@@ -1207,8 +1225,8 @@ export class InterpretadorBase implements InterpretadorInterface {
         return new RetornoQuebra(valor);
     }
 
-    visitarExpressaoDeleguaFuncao(declaracao: any): DeleguaFuncao {
-        return new DeleguaFuncao(null, declaracao);
+    async visitarExpressaoDeleguaFuncao(corpoDeclaracao: FuncaoConstruto): Promise<DeleguaFuncao> {
+        return new DeleguaFuncao(null, corpoDeclaracao);
     }
 
     async visitarExpressaoAtribuicaoPorIndice(expressao: any): Promise<any> {
diff --git a/fontes/lexador/palavras-reservadas.ts b/fontes/lexador/palavras-reservadas.ts
index 789e8e6c..a07a4b30 100644
--- a/fontes/lexador/palavras-reservadas.ts
+++ b/fontes/lexador/palavras-reservadas.ts
@@ -4,6 +4,7 @@ export const palavrasReservadas = {
     cada: tiposDeSimbolos.CADA,
     caso: tiposDeSimbolos.CASO,
     classe: tiposDeSimbolos.CLASSE,
+    como: tiposDeSimbolos.COMO,
     construtor: tiposDeSimbolos.CONSTRUTOR,
     continua: tiposDeSimbolos.CONTINUA,
     constante: tiposDeSimbolos.CONSTANTE,
@@ -37,6 +38,7 @@ export const palavrasReservadas = {
     senão: tiposDeSimbolos.SENÃO,
     super: tiposDeSimbolos.SUPER,
     sustar: tiposDeSimbolos.SUSTAR,
+    tendo: tiposDeSimbolos.TENDO,
     tente: tiposDeSimbolos.TENTE,
     tipo: tiposDeSimbolos.TIPO,
     var: tiposDeSimbolos.VARIAVEL,
diff --git a/fontes/tipos-de-simbolos/delegua.ts b/fontes/tipos-de-simbolos/delegua.ts
index 531c046c..7738b99d 100644
--- a/fontes/tipos-de-simbolos/delegua.ts
+++ b/fontes/tipos-de-simbolos/delegua.ts
@@ -12,6 +12,7 @@ export default {
     CLASSE: 'CLASSE',
     COLCHETE_DIREITO: 'COLCHETE_DIREITO',
     COLCHETE_ESQUERDO: 'COLCHETE_ESQUERDO',
+    COMO: 'COMO',
     CONSTANTE: 'CONSTANTE',
     CONSTRUTOR: 'CONSTRUTOR',
     CONTINUA: 'CONTINUA',
@@ -77,6 +78,7 @@ export default {
     SENÃO: 'SENÃO',
     SUPER: 'SUPER',
     SUSTAR: 'SUSTAR',
+    TENDO: 'TENDO',
     TENTE: 'TENTE',
     TEXTO: 'TEXTO',
     TIPO: 'TIPO',


Test patch:
diff --git a/testes/avaliador-sintatico.test.ts b/testes/avaliador-sintatico.test.ts
index 11c2ae88..72a1a4a0 100644
--- a/testes/avaliador-sintatico.test.ts
+++ b/testes/avaliador-sintatico.test.ts
@@ -1,5 +1,7 @@
 import { Lexador } from '../fontes/lexador';
 import { AvaliadorSintatico } from '../fontes/avaliador-sintatico';
+import { Bloco, TendoComo } from '../fontes/declaracoes';
+import { Chamada } from '../fontes/construtos';
 
 describe('Avaliador sintático', () => {
     describe('analisar()', () => {
@@ -10,100 +12,86 @@ describe('Avaliador sintático', () => {
             it('Sucesso - Olá Mundo', () => {
                 const retornoLexador = lexador.mapear(["escreva('Olá mundo')"], -1);
                 const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
-    
+
                 expect(retornoAvaliadorSintatico).toBeTruthy();
                 expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
             });
-    
+
             it('Sucesso - Vetor vazio', () => {
                 const retornoLexador = lexador.mapear(['var vetorVazio = []'], -1);
                 const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
-    
+
                 expect(retornoAvaliadorSintatico).toBeTruthy();
                 expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
             });
-    
+
             it('Sucesso - Dicionário vazio', () => {
                 const retornoLexador = lexador.mapear(['var dicionarioVazio = {}'], -1);
                 const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
-    
+
                 expect(retornoAvaliadorSintatico).toBeTruthy();
                 expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
             });
-    
+
             it('Sucesso - Undefined', () => {
                 const retornoAvaliadorSintatico = avaliadorSintatico.analisar(undefined as any, -1);
-    
+
                 expect(retornoAvaliadorSintatico).toBeTruthy();
                 expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(0);
             });
-    
+
             it('Sucesso - Null', () => {
                 const retornoAvaliadorSintatico = avaliadorSintatico.analisar(null as any, -1);
-    
+
                 expect(retornoAvaliadorSintatico).toBeTruthy();
                 expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(0);
             });
 
             it('Sucesso - Incremento e decremento após variável ou literal', () => {
-                const retornoLexador = lexador.mapear([
-                    'var a = 1',
-                    'a++',
-                    'a--',
-                    '++5',
-                    '--5'
-                ], -1);
+                const retornoLexador = lexador.mapear(['var a = 1', 'a++', 'a--', '++5', '--5'], -1);
 
                 const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
-    
+
                 expect(retornoAvaliadorSintatico).toBeTruthy();
                 expect(retornoAvaliadorSintatico.erros).toHaveLength(0);
             });
-    
+
             it('Sucesso - leia sem parâmetro', () => {
                 const retornoLexador = lexador.mapear(['var nome = leia()'], -1);
                 const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
-    
+
                 expect(retornoAvaliadorSintatico).toBeTruthy();
                 expect(retornoAvaliadorSintatico.erros).toHaveLength(0);
             });
-    
+
             it('Sucesso - leia com parâmetro', () => {
                 const retornoLexador = lexador.mapear(["var nome = leia('Digite seu nome:')"], -1);
                 const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
-    
+
                 expect(retornoAvaliadorSintatico).toBeTruthy();
                 expect(retornoAvaliadorSintatico.erros).toHaveLength(0);
             });
 
             it('Sucesso - para cada', async () => {
                 const retornoLexador = lexador.mapear(
-                    [
-                        'para cada elemento em [1, 2, 3] {',
-                        "   escreva('Valor: ', elemento)",
-                        '}',
-                    ],
+                    ['para cada elemento em [1, 2, 3] {', "   escreva('Valor: ', elemento)", '}'],
                     -1
                 );
                 const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
-    
+
                 expect(retornoAvaliadorSintatico.erros).toHaveLength(0);
             });
 
             it('Sucesso - para cada com ponto e vírgula no final', async () => {
                 const retornoLexador = lexador.mapear(
-                    [
-                        'para cada elemento em [1, 2, 3] {',
-                        "   escreva('Valor: ', elemento)",
-                        '};',
-                    ],
+                    ['para cada elemento em [1, 2, 3] {', "   escreva('Valor: ', elemento)", '};'],
                     -1
                 );
                 const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
-    
+
                 expect(retornoAvaliadorSintatico.erros).toHaveLength(0);
             });
-    
+
             it('Sucesso - para/sustar', async () => {
                 const retornoLexador = lexador.mapear(
                     [
@@ -115,212 +103,214 @@ describe('Avaliador sintático', () => {
                     -1
                 );
                 const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
-    
+
                 expect(retornoAvaliadorSintatico.erros).toHaveLength(0);
             });
 
             it('Sucesso - desestruturação de variáveis', async () => {
-                const retornoLexador = lexador.mapear(
-                    [
-                        'var { prop1 } = a'
-                    ],
-                    -1
-                );
+                const retornoLexador = lexador.mapear(['var { prop1 } = a'], -1);
 
                 const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
-    
+
                 expect(retornoAvaliadorSintatico.erros).toHaveLength(0);
             });
 
             it('Sucesso - desestruturação de constantes', async () => {
-                const retornoLexador = lexador.mapear(
-                    [
-                        'const { prop1 } = a'
-                    ],
-                    -1
-                );
+                const retornoLexador = lexador.mapear(['const { prop1 } = a'], -1);
 
                 const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
-    
+
                 expect(retornoAvaliadorSintatico.erros).toHaveLength(0);
             });
 
             describe('Classes, propriedades e métodos', () => {
                 it('Trivial', () => {
-                    const retornoLexador = lexador.mapear([
-                        'classe Triangulo {',
-                        '    base: numero;',
-                        '    altura: número',
-                        '    area() {',
-                        '        escreva((isto.base * isto.altura) / 2)',
-                        '    }',
-                        '}',
-                    ], -1);
+                    const retornoLexador = lexador.mapear(
+                        [
+                            'classe Triangulo {',
+                            '    base: numero;',
+                            '    altura: número',
+                            '    area() {',
+                            '        escreva((isto.base * isto.altura) / 2)',
+                            '    }',
+                            '}',
+                        ],
+                        -1
+                    );
 
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
-        
+
                     expect(retornoAvaliadorSintatico.erros).toHaveLength(0);
                 });
             });
 
             describe('Decoradores', () => {
                 it('Sucesso - decorador de classe simples', () => {
-                    const retornoLexador = lexador.mapear([
-                        '@meu.decorador1',
-                        '@meu.decorador2',
-                        'classe Teste {',
+                    const retornoLexador = lexador.mapear(
+                        [
+                            '@meu.decorador1',
+                            '@meu.decorador2',
+                            'classe Teste {',
                             'testeFuncao() {',
-                              'escreva("olá")',
+                            'escreva("olá")',
                             '}',
-                        '}',
-                    ], -1);
-    
+                            '}',
+                        ],
+                        -1
+                    );
+
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
-        
+
                     expect(retornoAvaliadorSintatico.erros).toHaveLength(0);
                 });
-    
+
                 it('Sucesso - decorador de classe com parametros', () => {
-                    const retornoLexador = lexador.mapear([
-                        '@decorador1(atributo1="123", atributo2=4)',
-                        'classe Teste {',
+                    const retornoLexador = lexador.mapear(
+                        [
+                            '@decorador1(atributo1="123", atributo2=4)',
+                            'classe Teste {',
                             '@decorador2(atributo1="123", atributo2=4)',
                             'testeFuncao() {',
-                              'escreva("olá")',
+                            'escreva("olá")',
                             '}',
-                        '}',
-                    ], -1);
-    
+                            '}',
+                        ],
+                        -1
+                    );
+
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
-        
+
                     expect(retornoAvaliadorSintatico.erros).toHaveLength(0);
                 });
-    
+
                 it('Sucesso - decorador de classe/método', () => {
-                    const retornoLexador = lexador.mapear([
-                        '@meu.decorador1',
-                        'classe Teste {',
+                    const retornoLexador = lexador.mapear(
+                        [
+                            '@meu.decorador1',
+                            'classe Teste {',
                             '@meu.decorador2',
                             'testeFuncao() {',
-                              'escreva("olá")',
+                            'escreva("olá")',
                             '}',
-                        '}',
-                    ], -1);
-    
+                            '}',
+                        ],
+                        -1
+                    );
+
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
-        
+
                     expect(retornoAvaliadorSintatico.erros).toHaveLength(0);
                 });
-    
+
                 it('Sucesso - decorador de classe/método/propriedade', () => {
-                    const retornoLexador = lexador.mapear([
-                        '@meu.decorador1',
-                        'classe Teste {',
+                    const retornoLexador = lexador.mapear(
+                        [
+                            '@meu.decorador1',
+                            'classe Teste {',
                             '@meu.decorador3',
                             'propriedade1: texto',
                             '@meu.decorador2',
                             'testeFuncao() {',
-                              'escreva("olá")',
+                            'escreva("olá")',
                             '}',
-                        '}',
-                    ], -1);
-    
+                            '}',
+                        ],
+                        -1
+                    );
+
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
-        
+
                     expect(retornoAvaliadorSintatico.erros).toHaveLength(0);
                 });
             });
-        });
 
-        describe('Declarações de tuplas', () => {
-            it('Dupla', () => {
-                const retornoLexador = lexador.mapear([
-                    'var t = [(1, 2)]'
-                ], -1);
-                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+            describe('Declaração `tendo ... como`', () => {
+                it('Trivial', () => {
+                    const retornoLexador = lexador.mapear(['tendo teste() como a {}'], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
-                expect(retornoAvaliadorSintatico).toBeTruthy();
-                expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                    const declaracaoTendoComo: TendoComo = retornoAvaliadorSintatico.declaracoes.shift() as TendoComo;
+                    expect(declaracaoTendoComo.simboloVariavel.lexema).toBe('a');
+                    expect(declaracaoTendoComo.inicializacaoVariavel).toBeInstanceOf(Chamada);
+                    expect(declaracaoTendoComo.corpo).toBeInstanceOf(Bloco);
+                    expect(declaracaoTendoComo.corpo.declaracoes).toHaveLength(0);
+                })
             });
 
-            it('Trio', () => {
-                const retornoLexador = lexador.mapear([
-                    'var t = [(1, 2, 3)]'
-                ], -1);
-                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+            describe('Declarações de tuplas', () => {
+                it('Dupla', () => {
+                    const retornoLexador = lexador.mapear(['var t = [(1, 2)]'], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
-                expect(retornoAvaliadorSintatico).toBeTruthy();
-                expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
-            });
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                });
 
-            it('Quarteto', () => {
-                const retornoLexador = lexador.mapear([
-                    'var t = [(1, 2, 3, 4)]'
-                ], -1);
-                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+                it('Trio', () => {
+                    const retornoLexador = lexador.mapear(['var t = [(1, 2, 3)]'], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
-                expect(retornoAvaliadorSintatico).toBeTruthy();
-                expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
-            });
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                });
 
-            it('Quinteto', () => {
-                const retornoLexador = lexador.mapear([
-                    'var t = [(1, 2, 3, 4, 5)]'
-                ], -1);
-                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+                it('Quarteto', () => {
+                    const retornoLexador = lexador.mapear(['var t = [(1, 2, 3, 4)]'], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
-                expect(retornoAvaliadorSintatico).toBeTruthy();
-                expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
-            });
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                });
 
-            it('Sexteto', () => {
-                const retornoLexador = lexador.mapear([
-                    'var t = [(1, 2, 3, 4, 5, 6)]'
-                ], -1);
-                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+                it('Quinteto', () => {
+                    const retornoLexador = lexador.mapear(['var t = [(1, 2, 3, 4, 5)]'], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
-                expect(retornoAvaliadorSintatico).toBeTruthy();
-                expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
-            });
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                });
 
-            it('Septeto', () => {
-                const retornoLexador = lexador.mapear([
-                    'var t = [(1, 2, 3, 4, 5, 6, 7)]'
-                ], -1);
-                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+                it('Sexteto', () => {
+                    const retornoLexador = lexador.mapear(['var t = [(1, 2, 3, 4, 5, 6)]'], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
-                expect(retornoAvaliadorSintatico).toBeTruthy();
-                expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
-            });
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                });
 
-            it('Octeto', () => {
-                const retornoLexador = lexador.mapear([
-                    'var t = [(1, 2, 3, 4, 5, 6, 7, 8)]'
-                ], -1);
-                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+                it('Septeto', () => {
+                    const retornoLexador = lexador.mapear(['var t = [(1, 2, 3, 4, 5, 6, 7)]'], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
-                expect(retornoAvaliadorSintatico).toBeTruthy();
-                expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
-            });
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                });
 
-            it('Noneto', () => {
-                const retornoLexador = lexador.mapear([
-                    'var t = [(1, 2, 3, 4, 5, 6, 7, 8, 9)]'
-                ], -1);
-                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+                it('Octeto', () => {
+                    const retornoLexador = lexador.mapear(['var t = [(1, 2, 3, 4, 5, 6, 7, 8)]'], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
-                expect(retornoAvaliadorSintatico).toBeTruthy();
-                expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
-            });
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                });
 
-            it('Deceto', () => {
-                const retornoLexador = lexador.mapear([
-                    'var t = [(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)]'
-                ], -1);
-                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+                it('Noneto', () => {
+                    const retornoLexador = lexador.mapear(['var t = [(1, 2, 3, 4, 5, 6, 7, 8, 9)]'], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
-                expect(retornoAvaliadorSintatico).toBeTruthy();
-                expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                });
+
+                it('Deceto', () => {
+                    const retornoLexador = lexador.mapear(['var t = [(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)]'], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                    expect(retornoAvaliadorSintatico).toBeTruthy();
+                    expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+                });
             });
         });
 
@@ -328,93 +318,94 @@ describe('Avaliador sintático', () => {
             it('Falha - declaração de variáveis com identificadores à esquerda do igual diferente da quantidade de valores à direita', async () => {
                 const retornoLexador = lexador.mapear(['var a, b, c = 1, 2'], -1);
                 const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
-    
+
                 expect(retornoAvaliadorSintatico.erros.length).toBeGreaterThan(0);
                 expect(retornoAvaliadorSintatico.erros[0].message).toBe(
-                    "Quantidade de identificadores à esquerda do igual é diferente da quantidade de valores à direita."
+                    'Quantidade de identificadores à esquerda do igual é diferente da quantidade de valores à direita.'
                 );
             });
 
             it('Falha - declaração de constantes com identificadores à esquerda do igual diferente da quantidade de valores à direita', async () => {
                 const retornoLexador = lexador.mapear(['const a, b, c = 1, 2'], -1);
                 const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
-    
+
                 expect(retornoAvaliadorSintatico.erros.length).toBeGreaterThan(0);
                 expect(retornoAvaliadorSintatico.erros[0].message).toBe(
-                    "Quantidade de identificadores à esquerda do igual é diferente da quantidade de valores à direita."
+                    'Quantidade de identificadores à esquerda do igual é diferente da quantidade de valores à direita.'
                 );
             });
 
             it('Falha - sustar fora de laço de repetição', async () => {
                 const retornoLexador = lexador.mapear(['sustar;'], -1);
                 const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
-    
+
                 expect(retornoAvaliadorSintatico.erros.length).toBeGreaterThan(0);
                 expect(retornoAvaliadorSintatico.erros[0].message).toBe(
                     "'sustar' ou 'pausa' deve estar dentro de um laço de repetição."
                 );
             });
-    
+
             it('Falha - continua fora de laço de repetição', async () => {
                 const retornoLexador = lexador.mapear(['continua;'], -1);
                 const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
-    
+
                 expect(retornoAvaliadorSintatico.erros.length).toBeGreaterThan(0);
                 expect(retornoAvaliadorSintatico.erros[0].message).toBe(
                     "'continua' precisa estar em um laço de repetição."
                 );
             });
-    
+
             it('Falha - Não é permitido ter dois identificadores seguidos na mesma linha', () => {
                 const retornoLexador = lexador.mapear(["escreva('Olá mundo') identificador1 identificador2"], -1);
                 const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
-    
+
                 expect(retornoAvaliadorSintatico.erros.length).toBeGreaterThan(0);
                 expect(retornoAvaliadorSintatico.erros[0].message).toBe(
                     'Não é permitido ter dois identificadores seguidos na mesma linha.'
                 );
             });
-    
+
             describe('Funções Anônimas', () => {
                 it('Função retorna vazio mas tem retorno de valores', async () => {
-                    const retornoLexador = lexador.mapear([
-                        "funcao executar(valor1, valor2): vazio {",
-                        "   var resultado = valor1 + valor2",
-                        "   retorna resultado",
-                        "}",
-                    ], -1);
+                    const retornoLexador = lexador.mapear(
+                        [
+                            'funcao executar(valor1, valor2): vazio {',
+                            '   var resultado = valor1 + valor2',
+                            '   retorna resultado',
+                            '}',
+                        ],
+                        -1
+                    );
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     expect(retornoAvaliadorSintatico.erros.length).toBeGreaterThanOrEqual(0);
                 });
 
                 it('Retorno texto sem retorno dentro da função', async () => {
-                    const retornoLexador = lexador.mapear([
-                        "funcao executar(valor1, valor2): texto {",
-                        "   var resultado = valor1 + valor2",
-                        "}",
-                    ], -1);
+                    const retornoLexador = lexador.mapear(
+                        ['funcao executar(valor1, valor2): texto {', '   var resultado = valor1 + valor2', '}'],
+                        -1
+                    );
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     expect(retornoAvaliadorSintatico.erros.length).toBeGreaterThanOrEqual(0);
                 });
 
                 it('Função com retorno de vetor', () => {
-                    const retornoLexador = lexador.mapear([
-                        "funcao executar(): texto[] {",
-                        "   retorna [\"1\", \"2\"]",
-                        "}",
-                    ], -1);
+                    const retornoLexador = lexador.mapear(
+                        ['funcao executar(): texto[] {', '   retorna ["1", "2"]', '}'],
+                        -1
+                    );
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
-    
+
                     expect(retornoAvaliadorSintatico).toBeTruthy();
                 });
             });
-    
+
             it('Declaração `tente`', () => {
                 const retornoLexador = lexador.mapear(['tente { i = i + 1 } pegue (erro) { escreva(erro) }'], -1);
                 const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
-    
+
                 expect(retornoAvaliadorSintatico).toBeTruthy();
             });
         });
diff --git a/testes/formatadores/formatador-delegua.test.ts b/testes/formatadores/formatador-delegua.test.ts
index ac18fe03..133cfb89 100644
--- a/testes/formatadores/formatador-delegua.test.ts
+++ b/testes/formatadores/formatador-delegua.test.ts
@@ -1,8 +1,8 @@
 import * as sistemaOperacional from 'os';
 
-import { FormatadorDelegua } from '../../fontes/formatadores';
 import { Lexador } from '../../fontes/lexador';
 import { AvaliadorSintatico } from '../../fontes/avaliador-sintatico';
+import { FormatadorDelegua } from '../../fontes/formatadores';
 
 describe('Formatadores > Delégua', () => {
     const formatador = new FormatadorDelegua(sistemaOperacional.EOL);
@@ -298,6 +298,24 @@ describe('Formatadores > Delégua', () => {
         expect(linhasResultado).toHaveLength(6);
     });
 
+    it('Tendo ... como', () => {
+        const resultadoLexador = lexador.mapear(
+            [
+                'funcao teste(){retorna "Ok" }',
+                'tendo teste() como a{escreva(a)',
+                '}'
+            ], 
+            -1
+        );
+
+        const resultadoAvaliacaoSintatica = avaliadorSintatico.analisar(resultadoLexador, -1);
+        const resultado = formatador.formatar(resultadoAvaliacaoSintatica.declaracoes);
+        const linhasResultado = resultado.split(sistemaOperacional.EOL);
+        
+        // console.log(resultado);
+        expect(linhasResultado).toHaveLength(7);
+    });
+
     it('Tente', () => {
         const resultadoLexador = lexador.mapear(
             ["tente { escreva('sucesso') } pegue {escreva('pegue')} finalmente { escreva('pronto') }"], 
diff --git a/testes/interpretador.test.ts b/testes/interpretador.test.ts
index 707f748d..5fdab8fd 100644
--- a/testes/interpretador.test.ts
+++ b/testes/interpretador.test.ts
@@ -1,6 +1,6 @@
-import { AvaliadorSintatico } from "../fontes/avaliador-sintatico";
-import { InterpretadorBase } from "../fontes/interpretador";
-import { Lexador } from "../fontes/lexador";
+import { AvaliadorSintatico } from '../fontes/avaliador-sintatico';
+import { InterpretadorBase } from '../fontes/interpretador';
+import { Lexador } from '../fontes/lexador';
 
 describe('Interpretador', () => {
     describe('interpretar()', () => {
@@ -15,97 +15,52 @@ describe('Interpretador', () => {
         });
 
         describe('Cenários de sucesso', () => {
-
-            describe('Descrever objetos - paraTexto()', () => {
-                it('Descrever função com parametros e tipos - DeleguaFuncao', async () => {
-                    let _saida: string = ""
-                    const retornoLexador = lexador.mapear([
-                        "funcao retorneAlgo(a: inteiro, b: texto) {",
-                        "}",
-                        "escreva(retorneAlgo)"
-                    ], -1);
+            describe('Acesso a variáveis e objetos', () => {
+                it('Acesso a elementos de vetor', async () => {
+                    const retornoLexador = lexador.mapear(['var a = [1, 2, 3]', 'escreva(a[1])'], -1);
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
-    
-                    interpretador.funcaoDeRetorno = (saida: any) => {
-                        _saida = saida;
-                    }
-    
-                    await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
-    
-                    expect(_saida).toBe("<função retorneAlgo argumentos=<a: inteiro, b: texto>>");
-                });
 
-                it('Descrever função com parametros sem tipos - DeleguaFuncao', async () => {
-                    let _saida: string = ""
-                    const retornoLexador = lexador.mapear([
-                        "funcao retorneAlgo(a, b) {",
-                        "}",
-                        "escreva(retorneAlgo)"
-                    ], -1);
-                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
-    
                     interpretador.funcaoDeRetorno = (saida: any) => {
-                        _saida = saida;
-                    }
-    
-                    await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
-    
-                    expect(_saida).toBe("<função retorneAlgo argumentos=<a, b>>");
-                });
+                        expect(saida).toEqual('2');
+                    };
 
-                it('Descrever função com retorno - DeleguaFuncao', async () => {
-                    let _saida: string = ""
-                    const retornoLexador = lexador.mapear([
-                        "funcao retorneAlgo() {",
-                        "   retorna \"Algo\"",
-                        "}",
-                        "escreva(retorneAlgo)"
-                    ], -1);
-                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
-    
-                    interpretador.funcaoDeRetorno = (saida: any) => {
-                        _saida = saida;
-                    }
-    
-                    await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
-    
-                    expect(_saida).toBe("<função retorneAlgo retorna=<'Algo'>>");
+                    const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                    expect(retornoInterpretador.erros).toHaveLength(0);
                 });
 
-                it('Descrever nome função - DeleguaFuncao', async () => {
-                    let _saida: string = ""
-                    const retornoLexador = lexador.mapear([
-                        "funcao retorneAlgo() {",
-                        "}",
-                        "escreva(retorneAlgo)"
-                    ], -1);
+                it('Acesso a elementos de dicionário', async () => {
+                    const retornoLexador = lexador.mapear(["var a = {'a': 1, 'b': 2}", "escreva(a['b'])"], -1);
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
-    
+
                     interpretador.funcaoDeRetorno = (saida: any) => {
-                        _saida = saida;
-                    }
-    
-                    await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
-    
-                    expect(_saida).toBe("<função retorneAlgo>");
+                        expect(saida).toEqual('2');
+                    };
+
+                    const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                    expect(retornoInterpretador.erros).toHaveLength(0);
                 });
-            })
+            });
 
             describe('Atribuições', () => {
                 it('Trivial var/variavel', async () => {
-                    const retornoLexador = lexador.mapear([
-                        "var a = 1",
-                        "variavel b = 2",
-                        "variável c = 3",
-                        "var a1, a2, a3 = 1, 2, 3",
-                        "var bb1, bb2, bb3: vetor = [1, 2, 3], ['1', '2', '3'], ['Olá Mundo!']",
-
-                        "const aa = 1",
-                        "constante bb = 2",
-                        "fixo cc = 3",
-                        "const aa1, aa2, aa3 = 1, 2, 3",
-                        "const bb1, bb2, bb3: vetor = [1, 2, 3], ['1', '2', '3'], ['Olá Mundo!']",
-                    ], -1);
+                    const retornoLexador = lexador.mapear(
+                        [
+                            'var a = 1',
+                            'variavel b = 2',
+                            'variável c = 3',
+                            'var a1, a2, a3 = 1, 2, 3',
+                            "var bb1, bb2, bb3: vetor = [1, 2, 3], ['1', '2', '3'], ['Olá Mundo!']",
+
+                            'const aa = 1',
+                            'constante bb = 2',
+                            'fixo cc = 3',
+                            'const aa1, aa2, aa3 = 1, 2, 3',
+                            "const bb1, bb2, bb3: vetor = [1, 2, 3], ['1', '2', '3'], ['Olá Mundo!']",
+                        ],
+                        -1
+                    );
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
@@ -114,12 +69,10 @@ describe('Interpretador', () => {
                 });
 
                 it('Trivial const/constante/fixo', async () => {
-                    const retornoLexador = lexador.mapear([
-                        "const a = 1",
-                        "constante b = \"b\"",
-                        "fixo c = 3",
-                        "const a1, a2, a3 = 1, 2, 3"
-                    ], -1);
+                    const retornoLexador = lexador.mapear(
+                        ['const a = 1', 'constante b = "b"', 'fixo c = 3', 'const a1, a2, a3 = 1, 2, 3'],
+                        -1
+                    );
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
@@ -128,7 +81,7 @@ describe('Interpretador', () => {
                 });
 
                 it('Vetor', async () => {
-                    const retornoLexador = lexador.mapear(["var a = [1, 2, 3]"], -1);
+                    const retornoLexador = lexador.mapear(['var a = [1, 2, 3]'], -1);
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
@@ -145,7 +98,7 @@ describe('Interpretador', () => {
                     expect(retornoInterpretador.erros).toHaveLength(0);
                 });
 
-                it('Concatenação', async () => {
+                it('Concatenação com um operador sendo tipo texto e outro operador qualquer', async () => {
                     const retornoLexador = lexador.mapear(["var a = 1 + '1'"], -1);
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
@@ -161,28 +114,31 @@ describe('Interpretador', () => {
                         'somar com ponto flutuante: 9 = 9',
                         '2',
                         'Valor: falso e verdadeiro',
-                        "0"
-                    ]
-                    const retornoLexador = lexador.mapear([
-                        "var comidaFavorita = 'strogonoff'",
-                        'escreva("Minha comida favorita é ${comidaFavorita}")',
-                        "funcao somar(num1, num2) {",
-                        "retorna num1 + num2;",
-                        "}",
-                        "escreva('somar: ${somar(5, 3)} = ${4 + 5 - 1}');",
-                        "escreva('somar com ponto flutuante: ${somar(5.7, 3.3)} = ${5 + 5 - 1}');",
-                        "escreva('${4 - 2 / 1}');",
-                        "var logico1 = falso",
-                        "var logico2 = verdadeiro",
-                        "var zero = 0",
-                        "escreva(\"${zero}\")",
-                        "escreva('Valor: ${logico1} e ${logico2}')",
-                    ], -1);
+                        '0',
+                    ];
+                    const retornoLexador = lexador.mapear(
+                        [
+                            "var comidaFavorita = 'strogonoff'",
+                            'escreva("Minha comida favorita é ${comidaFavorita}")',
+                            'funcao somar(num1, num2) {',
+                            'retorna num1 + num2;',
+                            '}',
+                            "escreva('somar: ${somar(5, 3)} = ${4 + 5 - 1}');",
+                            "escreva('somar com ponto flutuante: ${somar(5.7, 3.3)} = ${5 + 5 - 1}');",
+                            "escreva('${4 - 2 / 1}');",
+                            'var logico1 = falso',
+                            'var logico2 = verdadeiro',
+                            'var zero = 0',
+                            'escreva("${zero}")',
+                            "escreva('Valor: ${logico1} e ${logico2}')",
+                        ],
+                        -1
+                    );
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     interpretador.funcaoDeRetorno = (saida: any) => {
                         expect(saidasMensagens.includes(saida)).toBeTruthy();
-                    }
+                    };
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
 
@@ -190,29 +146,25 @@ describe('Interpretador', () => {
                 });
 
                 it('Incremento e decremento após variável ou literal', async () => {
-                    const saidasMensagens = [
-                        '1',
-                        '1',
-                        '2',
-                        '0',
-                        '6',
-                        '4',
-                    ]
-                    const retornoLexador = lexador.mapear([
-                        'var a = 1',
-                        'escreva(a++)',
-                        'escreva(a--)',
-                        'escreva(++a)',
-                        'escreva(--a)',
-                        'escreva(++5)',
-                        'escreva(--5)'
-                    ], -1);
+                    const saidasMensagens = ['1', '1', '2', '0', '6', '4'];
+                    const retornoLexador = lexador.mapear(
+                        [
+                            'var a = 1',
+                            'escreva(a++)',
+                            'escreva(a--)',
+                            'escreva(++a)',
+                            'escreva(--a)',
+                            'escreva(++5)',
+                            'escreva(--5)',
+                        ],
+                        -1
+                    );
 
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     interpretador.funcaoDeRetorno = (saida: any) => {
                         expect(saidasMensagens.includes(saida)).toBeTruthy();
-                    }
+                    };
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
 
@@ -220,75 +172,126 @@ describe('Interpretador', () => {
                 });
 
                 it('Desestruturação de variáveis', async () => {
-                    let _saida: string = ""
+                    let _saida: string = '';
                     const retornoLexador = lexador.mapear(
-                        [
-                            'var a = { "prop1": "b" }',
-                            'var { prop1 } = a',
-                            'escreva(prop1)'
-                        ],
+                        ['var a = { "prop1": "b" }', 'var { prop1 } = a', 'escreva(prop1)'],
                         -1
                     );
 
                     interpretador.funcaoDeRetorno = (saida: any) => {
                         _saida = saida;
-                    }
-    
+                    };
+
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
                     await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
 
-                    expect(_saida).toBe("b");
+                    expect(_saida).toBe('b');
                 });
 
                 it('Desestruturação de constantes', async () => {
-                    let _saida: string = ""
+                    let _saida: string = '';
                     const retornoLexador = lexador.mapear(
-                        [
-                            'const a = { "prop1": "c" }',
-                            'const { prop1 } = a',
-                            'escreva(prop1)'
-                        ],
+                        ['const a = { "prop1": "c" }', 'const { prop1 } = a', 'escreva(prop1)'],
                         -1
                     );
 
                     interpretador.funcaoDeRetorno = (saida: any) => {
                         _saida = saida;
-                    }
-    
+                    };
+
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
                     await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
 
-                    expect(_saida).toBe("c");
+                    expect(_saida).toBe('c');
                 });
             });
 
-            describe('Acesso a variáveis e objetos', () => {
-                it('Acesso a elementos de vetor', async () => {
-                    const retornoLexador = lexador.mapear([
-                        "var a = [1, 2, 3]",
-                        "escreva(a[1])"
-                    ], -1);
+            describe('Descrever objetos - paraTexto()', () => {
+                it('Descrever função com parametros e tipos - DeleguaFuncao', async () => {
+                    let _saida: string = '';
+                    const retornoLexador = lexador.mapear(
+                        ['funcao retorneAlgo(a: inteiro, b: texto) {', '}', 'escreva(retorneAlgo)'],
+                        -1
+                    );
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     interpretador.funcaoDeRetorno = (saida: any) => {
-                        expect(saida).toEqual("2");
-                    }
+                        _saida = saida;
+                    };
 
-                    const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+                    await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
 
-                    expect(retornoInterpretador.erros).toHaveLength(0);
+                    expect(_saida).toBe('<função retorneAlgo argumentos=<a: inteiro, b: texto>>');
                 });
 
-                it('Acesso a elementos de dicionário', async () => {
-                    const retornoLexador = lexador.mapear([
-                        "var a = {'a': 1, 'b': 2}",
-                        "escreva(a['b'])"
-                    ], -1);
+                it('Descrever função com parametros sem tipos - DeleguaFuncao', async () => {
+                    let _saida: string = '';
+                    const retornoLexador = lexador.mapear(
+                        ['funcao retorneAlgo(a, b) {', '}', 'escreva(retorneAlgo)'],
+                        -1
+                    );
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                    interpretador.funcaoDeRetorno = (saida: any) => {
+                        _saida = saida;
+                    };
+
+                    await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                    expect(_saida).toBe('<função retorneAlgo argumentos=<a, b>>');
+                });
+
+                it('Descrever função com retorno - DeleguaFuncao', async () => {
+                    let _saida: string = '';
+                    const retornoLexador = lexador.mapear(
+                        ['funcao retorneAlgo() {', '   retorna "Algo"', '}', 'escreva(retorneAlgo)'],
+                        -1
+                    );
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                    interpretador.funcaoDeRetorno = (saida: any) => {
+                        _saida = saida;
+                    };
+
+                    await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                    expect(_saida).toBe("<função retorneAlgo retorna=<'Algo'>>");
+                });
+
+                it('Descrever nome função - DeleguaFuncao', async () => {
+                    let _saida: string = '';
+                    const retornoLexador = lexador.mapear(['funcao retorneAlgo() {', '}', 'escreva(retorneAlgo)'], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                    interpretador.funcaoDeRetorno = (saida: any) => {
+                        _saida = saida;
+                    };
+
+                    await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                    expect(_saida).toBe('<função retorneAlgo>');
+                });
+            });
+
+            describe('Escolha - Caso', () => {
+                it('Escolha', async () => {
+                    const codigo = [
+                        'escolha (1) {',
+                        'caso 1:',
+                        "escreva('correspondente à opção 1');",
+                        'caso 2:',
+                        "escreva('correspondente à opção 2');",
+                        'padrao:',
+                        "escreva('Sem opção correspondente');",
+                        '}',
+                    ];
+
+                    const retornoLexador = lexador.mapear(codigo, -1);
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     interpretador.funcaoDeRetorno = (saida: any) => {
-                        expect(saida).toEqual("2");
-                    }
+                        expect(saida).toBe('correspondente à opção 1');
+                    };
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
 
@@ -302,8 +305,8 @@ describe('Interpretador', () => {
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     interpretador.funcaoDeRetorno = (saida: any) => {
-                        expect(saida).toEqual("Olá mundo");
-                    }
+                        expect(saida).toEqual('Olá mundo');
+                    };
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
 
@@ -311,12 +314,12 @@ describe('Interpretador', () => {
                 });
 
                 it('nulo', async () => {
-                    const retornoLexador = lexador.mapear(["escreva(nulo)"], -1);
+                    const retornoLexador = lexador.mapear(['escreva(nulo)'], -1);
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     interpretador.funcaoDeRetorno = (saida: any) => {
-                        expect(saida).toEqual("nulo");
-                    }
+                        expect(saida).toEqual('nulo');
+                    };
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
 
@@ -324,12 +327,12 @@ describe('Interpretador', () => {
                 });
 
                 it('nulo igual a nulo', async () => {
-                    const retornoLexador = lexador.mapear(["escreva(nulo == nulo)"], -1);
+                    const retornoLexador = lexador.mapear(['escreva(nulo == nulo)'], -1);
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     interpretador.funcaoDeRetorno = (saida: any) => {
-                        expect(saida).toEqual("verdadeiro");
-                    }
+                        expect(saida).toEqual('verdadeiro');
+                    };
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
 
@@ -337,12 +340,12 @@ describe('Interpretador', () => {
                 });
 
                 it('verdadeiro', async () => {
-                    const retornoLexador = lexador.mapear(["escreva(verdadeiro)"], -1);
+                    const retornoLexador = lexador.mapear(['escreva(verdadeiro)'], -1);
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     interpretador.funcaoDeRetorno = (saida: any) => {
-                        expect(saida).toEqual("verdadeiro");
-                    }
+                        expect(saida).toEqual('verdadeiro');
+                    };
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
 
@@ -350,12 +353,12 @@ describe('Interpretador', () => {
                 });
 
                 it('falso', async () => {
-                    const retornoLexador = lexador.mapear(["escreva(falso)"], -1);
+                    const retornoLexador = lexador.mapear(['escreva(falso)'], -1);
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     interpretador.funcaoDeRetorno = (saida: any) => {
-                        expect(saida).toEqual("falso");
-                    }
+                        expect(saida).toEqual('falso');
+                    };
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
 
@@ -382,41 +385,44 @@ describe('Interpretador', () => {
                         'objeto',
                         'nulo',
                         'texto',
-                        'número'
-                    ]
-                    const retornoLexador = lexador.mapear([
-                        "escreva(tipo de verdadeiro)",
-                        "escreva(tipo de falso)",
-                        "escreva(tipo de 123)",
-                        "escreva(tipo de -1)",
-                        "escreva(tipo de \"123\")",
-                        "escreva(tipo de [1,2,3])",
-                        "escreva(tipo de [])",
-                        "escreva(tipo de [1, '2'])",
-                        "var f = funcao(algumTexto) { }",
-                        "var a;",
-                        "var c = 1",
-                        "var d = \'2\'",
-                        "escreva(tipo de f)",
-                        "escreva(tipo de a)",
-                        "escreva(tipo de c)",
-                        "escreva(tipo de d)",
-                        "escreva(tipo de 4 + 2)",
-                        "escreva(tipo de 4 * 2 + (3 ^ 2))",
-                        "classe Teste {}",
-                        "escreva(tipo de Teste)",
-                        "classe OutroTeste {}",
-                        "escreva(tipo de OutroTeste)",
-                        "escreva(tipo de nulo)",
-                        "escreva(tipo de tipo de tipo de \"a\")",
-                        "var letras = \"abc\"",
-                        "escreva(tipo de letras.tamanho())",
-                    ], -1);
+                        'número',
+                    ];
+                    const retornoLexador = lexador.mapear(
+                        [
+                            'escreva(tipo de verdadeiro)',
+                            'escreva(tipo de falso)',
+                            'escreva(tipo de 123)',
+                            'escreva(tipo de -1)',
+                            'escreva(tipo de "123")',
+                            'escreva(tipo de [1,2,3])',
+                            'escreva(tipo de [])',
+                            "escreva(tipo de [1, '2'])",
+                            'var f = funcao(algumTexto) { }',
+                            'var a;',
+                            'var c = 1',
+                            "var d = '2'",
+                            'escreva(tipo de f)',
+                            'escreva(tipo de a)',
+                            'escreva(tipo de c)',
+                            'escreva(tipo de d)',
+                            'escreva(tipo de 4 + 2)',
+                            'escreva(tipo de 4 * 2 + (3 ^ 2))',
+                            'classe Teste {}',
+                            'escreva(tipo de Teste)',
+                            'classe OutroTeste {}',
+                            'escreva(tipo de OutroTeste)',
+                            'escreva(tipo de nulo)',
+                            'escreva(tipo de tipo de tipo de "a")',
+                            'var letras = "abc"',
+                            'escreva(tipo de letras.tamanho())',
+                        ],
+                        -1
+                    );
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     interpretador.funcaoDeRetorno = (saida: any) => {
                         expect(saidasMensagens.includes(saida)).toBeTruthy();
-                    }
+                    };
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
 
@@ -424,12 +430,10 @@ describe('Interpretador', () => {
                 });
 
                 it('Tipo de número', async () => {
-                    const retornoLexador = lexador.mapear([
-                        "escreva(tipo de 123)",
-                    ], -1);
+                    const retornoLexador = lexador.mapear(['escreva(tipo de 123)'], -1);
 
                     interpretador.funcaoDeRetorno = (saida: any) => {
-                        expect(saida).toEqual("número");
+                        expect(saida).toEqual('número');
                     };
 
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
@@ -439,16 +443,12 @@ describe('Interpretador', () => {
                     expect(retornoInterpretador.erros).toHaveLength(0);
                 });
 
-                it ('Tipo de com agrupamento', async () => {
-                    const retornoLexador = lexador.mapear([
-                        'var a = 1',
-                        'var b = tipo de (a)',
-                        'escreva(b)',
-                    ], -1);
+                it('Tipo de com agrupamento', async () => {
+                    const retornoLexador = lexador.mapear(['var a = 1', 'var b = tipo de (a)', 'escreva(b)'], -1);
                     interpretador.funcaoDeRetorno = (saida: any) => {
-                        expect(saida).toEqual("número");
+                        expect(saida).toEqual('número');
                     };
-    
+
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
@@ -457,92 +457,33 @@ describe('Interpretador', () => {
                 });
 
                 it('Ordem lexicográfica de textos', async () => {
-                    const saidasMensagens = [
-                        'verdadeiro',
-                        'falso',
-                    ]
-                    const retornoLexador = lexador.mapear([
-                        "escreva('batata' > 'arroz')",
-                        "escreva('batata' < 'arroz')"
-                    ], -1);
+                    const saidasMensagens = ['verdadeiro', 'falso'];
+                    const retornoLexador = lexador.mapear(
+                        ["escreva('batata' > 'arroz')", "escreva('batata' < 'arroz')"],
+                        -1
+                    );
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     interpretador.funcaoDeRetorno = (saida: any) => {
                         expect(saidasMensagens.includes(saida)).toBeTruthy();
-                    }
-
+                    };
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
 
                     expect(retornoInterpretador.erros).toHaveLength(0);
                 });
 
-                it('Escreva múltiplas variáveis', async () => {                    
-                    const retornoLexador = lexador.mapear([
-                        "const a = 'batata'",
-                        "const b = 'arroz'",
-                        "escreva(a, b)"
-                    ], -1);
-
-                    interpretador.funcaoDeRetorno = (saida: any) => {
-                        expect(saida).toEqual("batata arroz");
-                    }
-
-                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
-                    const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
-
-                    expect(retornoInterpretador.erros).toHaveLength(0);
-                })
-            });
-
-            describe('Operações matemáticas', () => {
-                it('Operações matemáticas - Trivial', async () => {
-                    const retornoLexador = lexador.mapear(["escreva(5 + 4 * 3 - 2 ** 1 / 6 % 10)"], -1);
-                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+                it('Escreva múltiplas variáveis', async () => {
+                    const retornoLexador = lexador.mapear(
+                        ["const a = 'batata'", "const b = 'arroz'", 'escreva(a, b)'],
+                        -1
+                    );
 
                     interpretador.funcaoDeRetorno = (saida: any) => {
-                        expect(saida).toEqual('16.666666666666668');
-                    }
-
-                    const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
-
-                    expect(retornoInterpretador.erros).toHaveLength(0);
-                });
+                        expect(saida).toEqual('batata arroz');
+                    };
 
-                it('Operações matemáticas - Subtração', async () => {
-                    const retornoLexador = lexador.mapear(["-1"], -1);
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
-
-                    const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
-
-                    expect(retornoInterpretador.erros).toHaveLength(0);
-                });
-
-                it('Operações matemáticas - Subtração de número e texto', async () => {
-                    const codigo = [
-                        "var a = 1 - \'2\'",
-                    ];
-                    const retornoLexador = lexador.mapear(codigo, -1);
-                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
-
-                    const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
-
-                    expect(retornoInterpretador.erros).toHaveLength(2);
-                    expect(retornoInterpretador.erros[0].erroInterno.mensagem).toBe('Operadores precisam ser números.');
-                });
-
-                it('Operações matemáticas - Divisão de inteiro', async () => {
-                    const codigo = [
-                        "var a = 10 \\ 2",
-                        "escreva(a)"
-                    ];
-                    const retornoLexador = lexador.mapear(codigo, -1);
-                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
-
-                    interpretador.funcaoDeRetorno = (saida: any) => {
-                        expect(saida).toBe('5');
-                    }
-
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
 
                     expect(retornoInterpretador.erros).toHaveLength(0);
@@ -551,11 +492,14 @@ describe('Interpretador', () => {
 
             describe('Operações lógicas', () => {
                 it('Operações lógicas - concatenação de texto', async () => {
-                    const retornoLexador = lexador.mapear([
-                        "var eVerdadeiro = verdadeiro",
-                        "var eFalso = falso",
-                        "escreva(\"Valores: \" + eVerdadeiro + \" : \" + eFalso)"
-                    ], -1);
+                    const retornoLexador = lexador.mapear(
+                        [
+                            'var eVerdadeiro = verdadeiro',
+                            'var eFalso = falso',
+                            'escreva("Valores: " + eVerdadeiro + " : " + eFalso)',
+                        ],
+                        -1
+                    );
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
@@ -564,12 +508,12 @@ describe('Interpretador', () => {
                 });
 
                 it('Operações lógicas - ou', async () => {
-                    const retornoLexador = lexador.mapear(["escreva(verdadeiro ou falso)"], -1);
+                    const retornoLexador = lexador.mapear(['escreva(verdadeiro ou falso)'], -1);
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     interpretador.funcaoDeRetorno = (saida: any) => {
                         expect(saida).toBe('verdadeiro');
-                    }
+                    };
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
 
@@ -577,12 +521,12 @@ describe('Interpretador', () => {
                 });
 
                 it('Operações lógicas - e', async () => {
-                    const retornoLexador = lexador.mapear(["escreva(verdadeiro e falso)"], -1);
+                    const retornoLexador = lexador.mapear(['escreva(verdadeiro e falso)'], -1);
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     interpretador.funcaoDeRetorno = (saida: any) => {
                         expect(saida).toBe('falso');
-                    }
+                    };
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
 
@@ -590,7 +534,7 @@ describe('Interpretador', () => {
                 });
 
                 it('Operações lógicas - nulo e verdadeiro', async () => {
-                    const retornoLexador = lexador.mapear(["nulo == verdadeiro"], -1);
+                    const retornoLexador = lexador.mapear(['nulo == verdadeiro'], -1);
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
@@ -600,7 +544,7 @@ describe('Interpretador', () => {
                 });
 
                 it('Operações lógicas - negação', async () => {
-                    const retornoLexador = lexador.mapear(["!verdadeiro"], -1);
+                    const retornoLexador = lexador.mapear(['!verdadeiro'], -1);
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
@@ -609,12 +553,12 @@ describe('Interpretador', () => {
                 });
 
                 it('Operações lógicas - em', async () => {
-                    const retornoLexador = lexador.mapear(["escreva(2 em [1, 2, 3])"], -1);
+                    const retornoLexador = lexador.mapear(['escreva(2 em [1, 2, 3])'], -1);
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     interpretador.funcaoDeRetorno = (saida: any) => {
                         expect(saida).toBe('verdadeiro');
-                    }
+                    };
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
 
@@ -622,7 +566,7 @@ describe('Interpretador', () => {
                 });
 
                 it('Operações lógicas - bit a bit não', async () => {
-                    const retornoLexador = lexador.mapear(["~1"], -1);
+                    const retornoLexador = lexador.mapear(['~1'], -1);
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
@@ -631,7 +575,7 @@ describe('Interpretador', () => {
                 });
 
                 it('Operações lógicas - menor menor', async () => {
-                    const retornoLexador = lexador.mapear(["1 << 2"], -1);
+                    const retornoLexador = lexador.mapear(['1 << 2'], -1);
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
@@ -640,7 +584,7 @@ describe('Interpretador', () => {
                 });
 
                 it('Operações lógicas - maior maior', async () => {
-                    const retornoLexador = lexador.mapear(["2 >> 1"], -1);
+                    const retornoLexador = lexador.mapear(['2 >> 1'], -1);
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
@@ -649,7 +593,7 @@ describe('Interpretador', () => {
                 });
 
                 it('Operações lógicas - bit ou', async () => {
-                    const retornoLexador = lexador.mapear(["1 | 2"], -1);
+                    const retornoLexador = lexador.mapear(['1 | 2'], -1);
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
@@ -658,7 +602,7 @@ describe('Interpretador', () => {
                 });
 
                 it('Operações lógicas - bit e', async () => {
-                    const retornoLexador = lexador.mapear(["1 & 1"], -1);
+                    const retornoLexador = lexador.mapear(['1 & 1'], -1);
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
@@ -667,7 +611,7 @@ describe('Interpretador', () => {
                 });
 
                 it('Operações lógicas - bit xor', async () => {
-                    const retornoLexador = lexador.mapear(["1 ^ 2"], -1);
+                    const retornoLexador = lexador.mapear(['1 ^ 2'], -1);
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
@@ -676,46 +620,66 @@ describe('Interpretador', () => {
                 });
             });
 
-            describe('Escolha - Caso', () => {
-                it('Escolha', async () => {
-                    const codigo = [
-                        "escolha (1) {",
-                            "caso 1:",
-                                "escreva('correspondente à opção 1');",
-                            "caso 2:",
-                                "escreva('correspondente à opção 2');",
-                            "padrao:",
-                                "escreva('Sem opção correspondente');",
-                        "}"
-                    ];
+            describe('Operações matemáticas', () => {
+                it('Operações matemáticas - Trivial', async () => {
+                    const retornoLexador = lexador.mapear(['escreva(5 + 4 * 3 - 2 ** 1 / 6 % 10)'], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                    interpretador.funcaoDeRetorno = (saida: any) => {
+                        expect(saida).toEqual('16.666666666666668');
+                    };
+
+                    const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
 
+                    expect(retornoInterpretador.erros).toHaveLength(0);
+                });
+
+                it('Operações matemáticas - Subtração', async () => {
+                    const retornoLexador = lexador.mapear(['-1'], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                    const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                    expect(retornoInterpretador.erros).toHaveLength(0);
+                });
+
+                it('Operações matemáticas - Subtração de número e texto', async () => {
+                    const codigo = ["var a = 1 - '2'"];
+                    const retornoLexador = lexador.mapear(codigo, -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                    const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                    expect(retornoInterpretador.erros).toHaveLength(2);
+                    expect(retornoInterpretador.erros[0].erroInterno.mensagem).toBe('Operadores precisam ser números.');
+                });
+
+                it('Operações matemáticas - Divisão de inteiro', async () => {
+                    const codigo = ['var a = 10 \\ 2', 'escreva(a)'];
                     const retornoLexador = lexador.mapear(codigo, -1);
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     interpretador.funcaoDeRetorno = (saida: any) => {
-                        expect(saida).toBe('correspondente à opção 1');
-                    }
+                        expect(saida).toBe('5');
+                    };
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
 
                     expect(retornoInterpretador.erros).toHaveLength(0);
                 });
-            })
+            });
 
             describe('Tente - Pegue - Finalmente', () => {
                 it('Tente', async () => {
-                    const saidasMensagens = [
-                        "sucesso",
-                        "pronto"
-                    ]
+                    const saidasMensagens = ['sucesso', 'pronto'];
                     const codigo = [
-                        "tente {",
-                            "escreva('sucesso');",
-                        "} pegue {",
-                            "escreva('pegue');",
-                        "} finalmente {",
-                            "escreva('pronto');",
-                        "}"
+                        'tente {',
+                        "escreva('sucesso');",
+                        '} pegue {',
+                        "escreva('pegue');",
+                        '} finalmente {',
+                        "escreva('pronto');",
+                        '}',
                     ];
 
                     const retornoLexador = lexador.mapear(codigo, -1);
@@ -723,20 +687,16 @@ describe('Interpretador', () => {
 
                     interpretador.funcaoDeRetorno = (saida: any) => {
                         expect(saidasMensagens.includes(saida)).toBeTruthy();
-                    }
+                    };
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
 
                     expect(retornoInterpretador.erros).toHaveLength(0);
                 });
 
-                it("Tente com Pegue parametrizado", async () => {
-                    const retornoLexador = lexador.mapear(
-                        ["tente { i = i + 1 } pegue (erro) { escreva(erro) }"],
-                        -1
-                    );
-                    const retornoAvaliadorSintatico =
-                        avaliadorSintatico.analisar(retornoLexador, -1);
+                it('Tente com Pegue parametrizado', async () => {
+                    const retornoLexador = lexador.mapear(['tente { i = i + 1 } pegue (erro) { escreva(erro) }'], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     expect(retornoAvaliadorSintatico).toBeTruthy();
 
@@ -746,23 +706,20 @@ describe('Interpretador', () => {
                 });
 
                 it('Tente com senão interno', async () => {
-                    const saidasMensagens = [
-                        "é diferente",
-                        "pronto"
-                    ]
+                    const saidasMensagens = ['é diferente', 'pronto'];
                     const codigo = [
-                        "tente {",
-                            "se (1 != 1) {",
-                                "escreva('sucesso');",
-                            "}",
-                            "senao {",
-                                "escreva('é diferente');",
-                            "}",
-                        "} pegue {",
-                            "escreva('pegue');",
-                        "} finalmente {",
-                            "escreva('pronto');",
-                        "}"
+                        'tente {',
+                        'se (1 != 1) {',
+                        "escreva('sucesso');",
+                        '}',
+                        'senao {',
+                        "escreva('é diferente');",
+                        '}',
+                        '} pegue {',
+                        "escreva('pegue');",
+                        '} finalmente {',
+                        "escreva('pronto');",
+                        '}',
                     ];
 
                     const retornoLexador = lexador.mapear(codigo, -1);
@@ -770,7 +727,7 @@ describe('Interpretador', () => {
 
                     interpretador.funcaoDeRetorno = (saida: any) => {
                         expect(saidasMensagens.includes(saida)).toBeTruthy();
-                    }
+                    };
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
 
@@ -779,14 +736,14 @@ describe('Interpretador', () => {
 
                 it('Pegue', async () => {
                     const codigo = [
-                        "tente {",
-                            "1 > '1';",
-                            "escreva('sucesso');",
-                        "} pegue {",
-                            "escreva('captura');",
-                        "} finalmente {",
-                            "escreva('pronto');",
-                        "}"
+                        'tente {',
+                        "1 > '1';",
+                        "escreva('sucesso');",
+                        '} pegue {',
+                        "escreva('captura');",
+                        '} finalmente {',
+                        "escreva('pronto');",
+                        '}',
                     ];
 
                     const retornoLexador = lexador.mapear(codigo, -1);
@@ -796,16 +753,19 @@ describe('Interpretador', () => {
 
                     expect(retornoInterpretador.erros).toHaveLength(0);
                 });
-            }),
+            });
 
             describe('Condicionais', () => {
                 it('Condicionais - condição verdadeira', async () => {
-                    const retornoLexador = lexador.mapear(["se (1 < 2) { escreva('Um menor que dois') } senão { escreva('Nunca será executado') }"], -1);
+                    const retornoLexador = lexador.mapear(
+                        ["se (1 < 2) { escreva('Um menor que dois') } senão { escreva('Nunca será executado') }"],
+                        -1
+                    );
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     interpretador.funcaoDeRetorno = (saida: any) => {
-                        expect(saida).toEqual("Um menor que dois");
-                    }
+                        expect(saida).toEqual('Um menor que dois');
+                    };
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
 
@@ -813,12 +773,15 @@ describe('Interpretador', () => {
                 });
 
                 it('Condicionais - condição falsa', async () => {
-                    const retornoLexador = lexador.mapear(["se (1 > 2) { escreva('Nunca acontece') } senão { escreva('Um não é maior que dois') }"], -1);
+                    const retornoLexador = lexador.mapear(
+                        ["se (1 > 2) { escreva('Nunca acontece') } senão { escreva('Um não é maior que dois') }"],
+                        -1
+                    );
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     interpretador.funcaoDeRetorno = (saida: any) => {
-                        expect(saida).toEqual("Um não é maior que dois")
-                    }
+                        expect(saida).toEqual('Um não é maior que dois');
+                    };
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
 
@@ -826,12 +789,17 @@ describe('Interpretador', () => {
                 });
 
                 it('Condicionais - condição menor igual', async () => {
-                    const retornoLexador = lexador.mapear(["se (1 <= 2) { escreva('Um é menor e igual a dois') } senão { escreva('Nunca será executado') }"], -1);
+                    const retornoLexador = lexador.mapear(
+                        [
+                            "se (1 <= 2) { escreva('Um é menor e igual a dois') } senão { escreva('Nunca será executado') }",
+                        ],
+                        -1
+                    );
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     interpretador.funcaoDeRetorno = (saida: any) => {
-                        expect(saida).toEqual("Um é menor e igual a dois")
-                    }
+                        expect(saida).toEqual('Um é menor e igual a dois');
+                    };
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
 
@@ -839,12 +807,17 @@ describe('Interpretador', () => {
                 });
 
                 it('Condicionais - condição maior igual', async () => {
-                    const retornoLexador = lexador.mapear(["se (2 >= 1) { escreva('Dois é maior ou igual a um') } senão { escreva('Nunca será executado') }"], -1);
+                    const retornoLexador = lexador.mapear(
+                        [
+                            "se (2 >= 1) { escreva('Dois é maior ou igual a um') } senão { escreva('Nunca será executado') }",
+                        ],
+                        -1
+                    );
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     interpretador.funcaoDeRetorno = (saida: any) => {
-                        expect(saida).toEqual("Dois é maior ou igual a um")
-                    }
+                        expect(saida).toEqual('Dois é maior ou igual a um');
+                    };
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
 
@@ -852,12 +825,15 @@ describe('Interpretador', () => {
                 });
 
                 it('Condicionais - condição diferente', async () => {
-                    const retornoLexador = lexador.mapear(["se (2 != 1) { escreva('Dois é diferente de um') } senão { escreva('Nunca será executado') }"], -1);
+                    const retornoLexador = lexador.mapear(
+                        ["se (2 != 1) { escreva('Dois é diferente de um') } senão { escreva('Nunca será executado') }"],
+                        -1
+                    );
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     interpretador.funcaoDeRetorno = (saida: any) => {
-                        expect(saida).toEqual("Dois é diferente de um")
-                    }
+                        expect(saida).toEqual('Dois é diferente de um');
+                    };
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
 
@@ -867,7 +843,7 @@ describe('Interpretador', () => {
 
             describe('Laços de repetição', () => {
                 it('Laços de repetição - enquanto', async () => {
-                    const retornoLexador = lexador.mapear(["var a = 0;\nenquanto (a < 10) { a = a + 1 }"], -1);
+                    const retornoLexador = lexador.mapear(['var a = 0;\nenquanto (a < 10) { a = a + 1 }'], -1);
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
@@ -876,10 +852,7 @@ describe('Interpretador', () => {
                 });
 
                 it('Laços de repetição - fazer ... enquanto', async () => {
-                    const retornoLexador = lexador.mapear([
-                        "var a = 0",
-                        "fazer { a = a + 1 } enquanto (a < 10)"
-                    ], -1);
+                    const retornoLexador = lexador.mapear(['var a = 0', 'fazer { a = a + 1 } enquanto (a < 10)'], -1);
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
@@ -888,22 +861,16 @@ describe('Interpretador', () => {
                 });
 
                 it('Laços de repetição - para cada - trivial', async () => {
-                    const saidasMensagens = [
-                        'Valor:  1',
-                        'Valor:  2',
-                        'Valor:  3'
-                    ]
-                    const retornoLexador = lexador.mapear([
-                        "para cada elemento em [1, 2, 3] {",
-                        "   escreva('Valor: ', elemento)",
-                        "}",
-                    ], -1);
+                    const saidasMensagens = ['Valor:  1', 'Valor:  2', 'Valor:  3'];
+                    const retornoLexador = lexador.mapear(
+                        ['para cada elemento em [1, 2, 3] {', "   escreva('Valor: ', elemento)", '}'],
+                        -1
+                    );
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     interpretador.funcaoDeRetorno = (saida: any) => {
                         expect(saidasMensagens.includes(saida)).toBeTruthy();
-                    }
-
+                    };
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
 
@@ -911,22 +878,16 @@ describe('Interpretador', () => {
                 });
 
                 it('Laços de repetição - para cada - vetor variável', async () => {
-                    const saidasMensagens = [
-                        'Valor:  1',
-                        'Valor:  2',
-                        'Valor:  3'
-                    ]
-                    const retornoLexador = lexador.mapear([
-                        "var v = [1, 2, 3]",
-                        "para cada elemento em v {",
-                        "   escreva('Valor: ', elemento)",
-                        "}",
-                    ], -1);
+                    const saidasMensagens = ['Valor:  1', 'Valor:  2', 'Valor:  3'];
+                    const retornoLexador = lexador.mapear(
+                        ['var v = [1, 2, 3]', 'para cada elemento em v {', "   escreva('Valor: ', elemento)", '}'],
+                        -1
+                    );
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     interpretador.funcaoDeRetorno = (saida: any) => {
                         expect(saidasMensagens.includes(saida)).toBeTruthy();
-                    }
+                    };
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
 
@@ -934,12 +895,10 @@ describe('Interpretador', () => {
                 });
 
                 it('Laços de repetição - para cada - vetor inválido', async () => {
-                    const retornoLexador = lexador.mapear([
-                        "var v = falso",
-                        "para cada elemento em v {",
-                        "   escreva('Valor: ', elemento)",
-                        "}",
-                    ], -1);
+                    const retornoLexador = lexador.mapear(
+                        ['var v = falso', 'para cada elemento em v {', "   escreva('Valor: ', elemento)", '}'],
+                        -1
+                    );
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
@@ -948,24 +907,13 @@ describe('Interpretador', () => {
                 });
 
                 it('Laços de repetição - para', async () => {
-                    const saidasMensagens = [
-                        '0',
-                        '1',
-                        '2',
-                        '3',
-                        '4',
-                        '5',
-                        '6',
-                        '7',
-                        '8',
-                        '9'
-                    ]
-                    const retornoLexador = lexador.mapear(["para (var i = 0; i < 10; i = i + 1) { escreva(i) }"], -1);
+                    const saidasMensagens = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'];
+                    const retornoLexador = lexador.mapear(['para (var i = 0; i < 10; i = i + 1) { escreva(i) }'], -1);
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     interpretador.funcaoDeRetorno = (saida: any) => {
                         expect(saidasMensagens.includes(saida)).toBeTruthy();
-                    }
+                    };
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
 
@@ -975,26 +923,22 @@ describe('Interpretador', () => {
 
             describe('Classes', () => {
                 it('Trivial', async () => {
-                    const saidasMensagens = [
-                        'Correndo Loucamente',
-                        "Au Au Au Au",
-                        'Classe: OK!'
-                    ]
+                    const saidasMensagens = ['Correndo Loucamente', 'Au Au Au Au', 'Classe: OK!'];
                     const codigo = [
-                        "classe Animal {",
-                        "    correr() {",
+                        'classe Animal {',
+                        '    correr() {',
                         "        escreva('Correndo Loucamente')",
-                        "    }",
-                        "}",
-                        "classe Cachorro herda Animal {",
-                        "    latir() {",
+                        '    }',
+                        '}',
+                        'classe Cachorro herda Animal {',
+                        '    latir() {',
                         "        escreva('Au Au Au Au')",
-                        "    }",
-                        "}",
-                        "var nomeDoCachorro = Cachorro()",
-                        "nomeDoCachorro.correr()",
-                        "nomeDoCachorro.latir()",
-                        "escreva('Classe: OK!')"
+                        '    }',
+                        '}',
+                        'var nomeDoCachorro = Cachorro()',
+                        'nomeDoCachorro.correr()',
+                        'nomeDoCachorro.latir()',
+                        "escreva('Classe: OK!')",
                     ];
 
                     const retornoLexador = lexador.mapear(codigo, -1);
@@ -1002,7 +946,7 @@ describe('Interpretador', () => {
 
                     interpretador.funcaoDeRetorno = (saida: any) => {
                         expect(saidasMensagens.includes(saida)).toBeTruthy();
-                    }
+                    };
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
 
@@ -1011,25 +955,25 @@ describe('Interpretador', () => {
 
                 it('Chamada de método com `super`', async () => {
                     const codigo = [
-                        "classe A {",
-                            "data(data) {",
-                              "escreva(data);",
-                            "}",
-                        "}",
-                        "classe B herda A {",
-                            "construtor(data) {",
-                              "super.data(data);",
-                            "}",
-                        "}",
-                        "var a = B(\"13/12/1981\");",
+                        'classe A {',
+                        'data(data) {',
+                        'escreva(data);',
+                        '}',
+                        '}',
+                        'classe B herda A {',
+                        'construtor(data) {',
+                        'super.data(data);',
+                        '}',
+                        '}',
+                        'var a = B("13/12/1981");',
                     ];
 
                     const retornoLexador = lexador.mapear(codigo, -1);
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     interpretador.funcaoDeRetorno = (saida: any) => {
-                        expect(saida).toEqual("13/12/1981");
-                    }
+                        expect(saida).toEqual('13/12/1981');
+                    };
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
 
@@ -1038,22 +982,22 @@ describe('Interpretador', () => {
 
                 it('Chamada de método com `super` e definição de propriedade com `isto`', async () => {
                     const codigo = [
-                        "classe A {",
-                        "   dataA: texto",
-                        "   construtor() {",
-                            "   isto.dataA = \'01/01/2001\'",
-                            "}",
-                            "data(data1) {",
-                              "escreva(isto.dataA + \" - \", data1)",
-                            "}",
-                        "}",
-                        "classe B herda A {",
-                            "construtor(data) {",
-                              "super();",
-                              "super.data(data);",
-                            "}",
-                        "}",
-                        "var a = B(\"13/12/1981\");",
+                        'classe A {',
+                        '   dataA: texto',
+                        '   construtor() {',
+                        "   isto.dataA = '01/01/2001'",
+                        '}',
+                        'data(data1) {',
+                        'escreva(isto.dataA + " - ", data1)',
+                        '}',
+                        '}',
+                        'classe B herda A {',
+                        'construtor(data) {',
+                        'super();',
+                        'super.data(data);',
+                        '}',
+                        '}',
+                        'var a = B("13/12/1981");',
                     ];
 
                     const retornoLexador = lexador.mapear(codigo, -1);
@@ -1093,41 +1037,41 @@ describe('Interpretador', () => {
             });
 
             describe('Declaração e chamada de funções', () => {
-                it('Chamada de função com retorno \'vazio\'', async () => {
+                it("Chamada de função com retorno 'vazio'", async () => {
                     const codigo = [
-                        "funcao executar(valor1, valor2): vazio {",
-                        "   var resultado = valor1 + valor2",
-                        "}",
-                        "escreva(executar(1, 2))"
+                        'funcao executar(valor1, valor2): vazio {',
+                        '   var resultado = valor1 + valor2',
+                        '}',
+                        'escreva(executar(1, 2))',
                     ];
 
                     const retornoLexador = lexador.mapear(codigo, -1);
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     interpretador.funcaoDeRetorno = (saida: any) => {
-                        expect(saida).toEqual("nulo");
-                    }
+                        expect(saida).toEqual('nulo');
+                    };
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
 
                     expect(retornoInterpretador.erros).toHaveLength(0);
                 });
 
-                it('Chamada de função com retorno \'qualquer\'', async () => {
+                it("Chamada de função com retorno 'qualquer'", async () => {
                     const codigo = [
-                        "funcao executar(valor1, valor2): qualquer {",
-                        "   var resultado = valor1 + valor2",
-                        "   retorna resultado",
-                        "}",
-                        "escreva(executar(1, 2))"
+                        'funcao executar(valor1, valor2): qualquer {',
+                        '   var resultado = valor1 + valor2',
+                        '   retorna resultado',
+                        '}',
+                        'escreva(executar(1, 2))',
                     ];
 
                     const retornoLexador = lexador.mapear(codigo, -1);
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     interpretador.funcaoDeRetorno = (saida: any) => {
-                        expect(saida).toEqual("3");
-                    }
+                        expect(saida).toEqual('3');
+                    };
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
 
@@ -1136,18 +1080,18 @@ describe('Interpretador', () => {
 
                 it('Chamada de função com definição de tipos inteiros e retorno texto', async () => {
                     const codigo = [
-                        "funcao executar(valor1: inteiro, valor2: inteiro): texto {",
-                        "   retorna valor1 + valor2",
-                        "}",
-                        "escreva(executar(1, 2))"
+                        'funcao executar(valor1: inteiro, valor2: inteiro): texto {',
+                        '   retorna valor1 + valor2',
+                        '}',
+                        'escreva(executar(1, 2))',
                     ];
 
                     const retornoLexador = lexador.mapear(codigo, -1);
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     interpretador.funcaoDeRetorno = (saida: any) => {
-                        expect(saida).toEqual("3");
-                    }
+                        expect(saida).toEqual('3');
+                    };
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
 
@@ -1155,19 +1099,14 @@ describe('Interpretador', () => {
                 });
 
                 it('Chamada de função com retorno de vetor', async () => {
-                    const codigo = [
-                        "funcao executar() {",
-                        "   retorna [1, 2, \'3\']",
-                        "}",
-                        "escreva(executar())"
-                    ];
+                    const codigo = ['funcao executar() {', "   retorna [1, 2, '3']", '}', 'escreva(executar())'];
 
                     const retornoLexador = lexador.mapear(codigo, -1);
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     interpretador.funcaoDeRetorno = (saida: any) => {
                         expect(saida).toEqual('1,2,3');
-                    }
+                    };
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
 
@@ -1176,12 +1115,12 @@ describe('Interpretador', () => {
 
                 it('Chamada de função com inferência de tipos na passagem de parametros', async () => {
                     const codigo = [
-                        "funcao escreverMensagem(vetor) {",
+                        'funcao escreverMensagem(vetor) {',
                         "   se (vetor.inclui('mundo')) {",
-                        "       escreva(vetor);",
-                        "   }",
-                        "}",
-                        "escreverMensagem([\"Olá\", \"mundo\"]);"
+                        '       escreva(vetor);',
+                        '   }',
+                        '}',
+                        'escreverMensagem(["Olá", "mundo"]);',
                     ];
 
                     const retornoLexador = lexador.mapear(codigo, -1);
@@ -1189,7 +1128,7 @@ describe('Interpretador', () => {
 
                     interpretador.funcaoDeRetorno = (saida: any) => {
                         expect(saida).toEqual('Olá,mundo');
-                    }
+                    };
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
 
@@ -1198,9 +1137,9 @@ describe('Interpretador', () => {
 
                 it('Chamada de função primitiva com parâmetro nulo', async () => {
                     const codigo = [
-                        "var frutas = [\"maçã\", \"banana\", \"morango\", \"laranja\", \"uva\"]",
-                        "var alimentos = frutas.encaixar(0, 3, nulo, verdadeiro);",
-                        "escreva(alimentos);",
+                        'var frutas = ["maçã", "banana", "morango", "laranja", "uva"]',
+                        'var alimentos = frutas.encaixar(0, 3, nulo, verdadeiro);',
+                        'escreva(alimentos);',
                     ];
 
                     const retornoLexador = lexador.mapear(codigo, -1);
@@ -1208,7 +1147,7 @@ describe('Interpretador', () => {
 
                     interpretador.funcaoDeRetorno = (saida: any) => {
                         expect(saida).toEqual('maçã,banana,morango');
-                    }
+                    };
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
 
@@ -1216,12 +1155,7 @@ describe('Interpretador', () => {
                 });
 
                 it('Aglutinação de argumentos', async () => {
-                    const codigo = [
-                        "função teste(*argumentos) {",
-                        "   escreva(argumentos)",
-                        "}",
-                        "teste(1, 2, 3)"
-                    ];
+                    const codigo = ['função teste(*argumentos) {', '   escreva(argumentos)', '}', 'teste(1, 2, 3)'];
 
                     const retornoLexador = lexador.mapear(codigo, -1);
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
@@ -1232,40 +1166,40 @@ describe('Interpretador', () => {
                 });
 
                 it('Fibonacci', async () => {
-                    const saidasMensagens = ['0', '1', '1', '2', '3', '5']
+                    const saidasMensagens = ['0', '1', '1', '2', '3', '5'];
                     const codigo = [
-                        "função fibonacci(n) {",
-                        "    se (n == 0) {",
-                        "      retorna(0);",
-                        "    }",
-                        "    se (n == 1) {",
-                        "      retorna(1);",
-                        "    }",
-                        "    var n1 = n - 1;",
-                        "    var n2 = n - 2;",
-                        "    var f1 = fibonacci(n1);",
-                        "    var f2 = fibonacci(n2);",
-                        "    retorna(f1 + f2);",
-                        "}",
-                        "var a = fibonacci(0);",
-                        "escreva(a);",
-                        "a = fibonacci(1);",
-                        "escreva(a);",
-                        "a = fibonacci(2);",
-                        "escreva(a);",
-                        "a = fibonacci(3);",
-                        "escreva(a);",
-                        "a = fibonacci(4);",
-                        "escreva(a);",
-                        "a = fibonacci(5);",
-                        "escreva(a);"
+                        'função fibonacci(n) {',
+                        '    se (n == 0) {',
+                        '      retorna(0);',
+                        '    }',
+                        '    se (n == 1) {',
+                        '      retorna(1);',
+                        '    }',
+                        '    var n1 = n - 1;',
+                        '    var n2 = n - 2;',
+                        '    var f1 = fibonacci(n1);',
+                        '    var f2 = fibonacci(n2);',
+                        '    retorna(f1 + f2);',
+                        '}',
+                        'var a = fibonacci(0);',
+                        'escreva(a);',
+                        'a = fibonacci(1);',
+                        'escreva(a);',
+                        'a = fibonacci(2);',
+                        'escreva(a);',
+                        'a = fibonacci(3);',
+                        'escreva(a);',
+                        'a = fibonacci(4);',
+                        'escreva(a);',
+                        'a = fibonacci(5);',
+                        'escreva(a);',
                     ];
                     const retornoLexador = lexador.mapear(codigo, -1);
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     interpretador.funcaoDeRetorno = (saida: any) => {
                         expect(saidasMensagens.includes(saida)).toBeTruthy();
-                    }
+                    };
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
 
@@ -1274,16 +1208,16 @@ describe('Interpretador', () => {
 
                 it('Número repetido (com retorna)', async () => {
                     const codigo = [
-                        "funcao temDigitoRepetido(num) {",
-                        "    var str = texto(num);",
-                        "    para (var i = 1; i < tamanho(str); i++) {",
-                        "      se (str[i] != str[0]) {",
-                        "        retorna falso;",
-                        "      }",
-                        "    }",
-                        "    retorna verdadeiro;",
-                        "}",
-                        "escreva(temDigitoRepetido(123));"
+                        'funcao temDigitoRepetido(num) {',
+                        '    var str = texto(num);',
+                        '    para (var i = 1; i < tamanho(str); i++) {',
+                        '      se (str[i] != str[0]) {',
+                        '        retorna falso;',
+                        '      }',
+                        '    }',
+                        '    retorna verdadeiro;',
+                        '}',
+                        'escreva(temDigitoRepetido(123));',
                     ];
 
                     const retornoLexador = lexador.mapear(codigo, -1);
@@ -1291,7 +1225,7 @@ describe('Interpretador', () => {
 
                     interpretador.funcaoDeRetorno = (saida: any) => {
                         expect(saida).toEqual('falso');
-                    }
+                    };
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
 
@@ -1300,16 +1234,16 @@ describe('Interpretador', () => {
 
                 it('Número repetido (com sustar)', async () => {
                     const codigo = [
-                        "funcao temDigitoRepetido(num) {",
-                        "    var str = texto(num);",
-                        "    para (var i = 1; i < tamanho(str); i++) {",
-                        "      se (str[i] != str[0]) {",
-                        "        sustar;",
-                        "      }",
-                        "    }",
-                        "    retorna verdadeiro;",
-                        "}",
-                        "escreva(temDigitoRepetido(123));"
+                        'funcao temDigitoRepetido(num) {',
+                        '    var str = texto(num);',
+                        '    para (var i = 1; i < tamanho(str); i++) {',
+                        '      se (str[i] != str[0]) {',
+                        '        sustar;',
+                        '      }',
+                        '    }',
+                        '    retorna verdadeiro;',
+                        '}',
+                        'escreva(temDigitoRepetido(123));',
                     ];
 
                     const retornoLexador = lexador.mapear(codigo, -1);
@@ -1317,7 +1251,7 @@ describe('Interpretador', () => {
 
                     interpretador.funcaoDeRetorno = (saida: any) => {
                         expect(saida).toEqual('verdadeiro');
-                    }
+                    };
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
 
@@ -1327,13 +1261,13 @@ describe('Interpretador', () => {
 
             describe('Entrada e saída', () => {
                 it('Enquanto (verdadeiro) e Sustar', async () => {
-                    const saidasMensagens = ['opção invalida', 'opção invalida', 'resultado 4']
+                    const saidasMensagens = ['opção invalida', 'opção invalida', 'resultado 4'];
                     // Aqui vamos simular a resposta para cinco variáveis de `leia()`.
                     const respostas = ['5', '5', '5', '4', '4'];
                     interpretador.interfaceEntradaSaida = {
                         question: (mensagem: string, callback: Function) => {
                             callback(respostas.shift());
-                        }
+                        },
                     };
 
                     const codigo = [
@@ -1359,14 +1293,14 @@ describe('Interpretador', () => {
                         '        escreva("opção invalida");',
                         '    }',
                         '}',
-                        'escreva("resultado " + resultado);'
+                        'escreva("resultado " + resultado);',
                     ];
                     const retornoLexador = lexador.mapear(codigo, -1);
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     interpretador.funcaoDeRetorno = (saida: any) => {
                         expect(saidasMensagens.includes(saida)).toBeTruthy();
-                    }
+                    };
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
 
@@ -1379,20 +1313,20 @@ describe('Interpretador', () => {
                     interpretador.interfaceEntradaSaida = {
                         question: (mensagem: string, callback: Function) => {
                             callback(respostas.shift());
-                        }
+                        },
                     };
 
                     const codigo = [
                         'var n1 = leia("digite sua idade");',
                         'var n2 = (365*n1);',
-                        'escreva("Você tem " +n2+" dias de vida");'
+                        'escreva("Você tem " +n2+" dias de vida");',
                     ];
                     const retornoLexador = lexador.mapear(codigo, -1);
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     interpretador.funcaoDeRetorno = (saida: any) => {
                         expect(saida).toEqual('Você tem 13870 dias de vida');
-                    }
+                    };
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
 
@@ -1403,21 +1337,26 @@ describe('Interpretador', () => {
             describe('Métodos de primitivas com dependência no Interpretador', () => {
                 describe('Dicionários', () => {
                     it('chaves() e valores()', async () => {
-                        const retornoLexador = lexador.mapear([
-                            `var meuDicionario = {"a": 1, "b": 2, "c": 3}`,
-                            `escreva(meuDicionario.chaves())`,
-                            `escreva(meuDicionario.valores())`
-                        ], -1);
+                        const retornoLexador = lexador.mapear(
+                            [
+                                `var meuDicionario = {"a": 1, "b": 2, "c": 3}`,
+                                `escreva(meuDicionario.chaves())`,
+                                `escreva(meuDicionario.valores())`,
+                            ],
+                            -1
+                        );
 
                         const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
                         const saidas: string[] = [];
-    
+
                         interpretador.funcaoDeRetorno = (saida: string) => {
                             saidas.push(saida);
-                        }
-    
-                        const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
-    
+                        };
+
+                        const retornoInterpretador = await interpretador.interpretar(
+                            retornoAvaliadorSintatico.declaracoes
+                        );
+
                         expect(retornoInterpretador.erros).toHaveLength(0);
                         expect(saidas).toHaveLength(2);
                         expect(saidas[0]).toEqual('a,b,c');
@@ -1427,33 +1366,41 @@ describe('Interpretador', () => {
 
                 describe('Vetores', () => {
                     it('ordenar() de vetor com parâmetro função', async () => {
-                        const retornoLexador = lexador.mapear([
-                            "var numeros = [4, 2, 12, 8];",
-                            "numeros.ordenar(funcao(a, b) {",
-                            "    retorna b - a;",
-                            "});",
-                            "escreva(numeros);"
-                        ], -1);
+                        const retornoLexador = lexador.mapear(
+                            [
+                                'var numeros = [4, 2, 12, 8];',
+                                'numeros.ordenar(funcao(a, b) {',
+                                '    retorna b - a;',
+                                '});',
+                                'escreva(numeros);',
+                            ],
+                            -1
+                        );
                         const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
-    
+
                         interpretador.funcaoDeRetorno = (saida: string) => {
                             expect(saida).toEqual('12,8,4,2');
-                        }
-    
-                        const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
-    
+                        };
+
+                        const retornoInterpretador = await interpretador.interpretar(
+                            retornoAvaliadorSintatico.declaracoes
+                        );
+
                         expect(retornoInterpretador.erros).toHaveLength(0);
                     });
                 });
-            })
+            });
 
             describe('Expressões Regulares', () => {
                 it('Método substituir()', async () => {
-                    const retornoLexador = lexador.mapear([
-                        "var str = \"olá mundo, olá universo\";",
-                        "var novaStr = str.substituir(||/olá/g||, \"oi\");",
-                        "escreva(novaStr);",
-                    ], -1);
+                    const retornoLexador = lexador.mapear(
+                        [
+                            'var str = "olá mundo, olá universo";',
+                            'var novaStr = str.substituir(||/olá/g||, "oi");',
+                            'escreva(novaStr);',
+                        ],
+                        -1
+                    );
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     interpretador.funcaoDeRetorno = (saida: any) => {
@@ -1468,9 +1415,7 @@ describe('Interpretador', () => {
 
             describe('Falhar', () => {
                 it('Trivial', async () => {
-                    const retornoLexador = lexador.mapear([
-                        "falhar 'teste de falha'"
-                    ], -1);
+                    const retornoLexador = lexador.mapear(["falhar 'teste de falha'"], -1);
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
@@ -1479,31 +1424,69 @@ describe('Interpretador', () => {
                 });
 
                 it('Trivial com atribuição', async () => {
-                    const retornoLexador = lexador.mapear([
-                        "var mensagem = \"teste de falha\"",
-                        "falhar mensagem"
-                    ], -1);
+                    const retornoLexador = lexador.mapear(['var mensagem = "teste de falha"', 'falhar mensagem'], -1);
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
-                    
+
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
 
                     expect(retornoInterpretador.erros.length).toBeGreaterThanOrEqual(0);
                 });
             });
+
+            describe('Tendo ... Como', () => {
+                it('Trivial, sem finalizar() definido', async () => {
+                    let _saida: string = '';
+                    interpretador.funcaoDeRetorno = (saida: any) => {
+                        _saida = saida;
+                    };
+
+                    const retornoLexador = lexador.mapear([
+                        'funcao teste() { retorna "Ok" }',
+                        'tendo teste() como a {',
+                        '    escreva(a)',
+                        '}'], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                    const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                    expect(retornoInterpretador.erros).toHaveLength(0);
+                    expect(_saida).toBe('Ok');
+                });
+
+                it('Trivial, com finalizar() definido, classe em Delégua', async () => {
+                    let _saida: string = '';
+                    interpretador.funcaoDeRetorno = (saida: any) => {
+                        _saida = saida;
+                    };
+
+                    const retornoLexador = lexador.mapear([
+                        'classe MinhaClasse {',
+                        '    finalizar() {',
+                        '        escreva("Finalizei")',
+                        '    }',
+                        '}',
+                        'funcao teste() { retorna "Ok" }',
+                        'tendo MinhaClasse() como a {',
+                        '}'], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                    const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                    expect(retornoInterpretador.erros).toHaveLength(0);
+                    expect(_saida).toBe('Finalizei');
+                });
+            });
         });
 
         describe('Cenários de falha', () => {
             describe('Acesso a variáveis e objetos', () => {
                 it('Acesso a elementos de vetor', async () => {
-                    const retornoLexador = lexador.mapear([
-                        "var a = [1, 2, 3];",
-                        "escreva(a[4]);"
-                    ], -1);
+                    const retornoLexador = lexador.mapear(['var a = [1, 2, 3];', 'escreva(a[4]);'], -1);
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     interpretador.funcaoDeRetorno = (saida: string) => {
                         expect(saida).toEqual('nulo');
-                    }
+                    };
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
 
@@ -1511,15 +1494,12 @@ describe('Interpretador', () => {
                 });
 
                 it('Acesso a elementos de dicionário', async () => {
-                    const retornoLexador = lexador.mapear([
-                        "var a = {'a': 1, 'b': 2};",
-                        "escreva(a['c']);"
-                    ], -1);
+                    const retornoLexador = lexador.mapear(["var a = {'a': 1, 'b': 2};", "escreva(a['c']);"], -1);
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     interpretador.funcaoDeRetorno = (saida: string) => {
                         expect(saida).toEqual('nulo');
-                    }
+                    };
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
 
@@ -1527,9 +1507,7 @@ describe('Interpretador', () => {
                 });
 
                 it('Métodos inexistentes', async () => {
-                    const retornoLexador = lexador.mapear([
-                        'nescreva("Qualquer coisa")'
-                    ], -1);
+                    const retornoLexador = lexador.mapear(['nescreva("Qualquer coisa")'], -1);
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
@@ -1552,7 +1530,7 @@ describe('Interpretador', () => {
                         '    retorna 4 * isto.lado',
                         '  }',
                         '}',
-                        'var q1 = Quadrado(10)'
+                        'var q1 = Quadrado(10)',
                     ];
 
                     const retornoLexador = lexador.mapear(codigo, -1);
@@ -1565,13 +1543,13 @@ describe('Interpretador', () => {
 
                 it('Super Classe precisa ser uma classe', async () => {
                     const codigo = [
-                        "funcao A(data) { }",
-                        "classe B herda A {",
-                            "construtor(data) {",
-                                "super.data(data);",
-                            "}",
-                        "}",
-                        "var a = B(\"13/12/1981\");"
+                        'funcao A(data) { }',
+                        'classe B herda A {',
+                        'construtor(data) {',
+                        'super.data(data);',
+                        '}',
+                        '}',
+                        'var a = B("13/12/1981");',
                     ];
 
                     const retornoLexador = lexador.mapear(codigo, -1);
@@ -1580,58 +1558,48 @@ describe('Interpretador', () => {
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
 
                     expect(retornoInterpretador.erros).toHaveLength(2);
-                    expect(retornoInterpretador.erros[0].erroInterno.mensagem).toBe('Superclasse precisa ser uma classe.');
+                    expect(retornoInterpretador.erros[0].erroInterno.mensagem).toBe(
+                        'Superclasse precisa ser uma classe.'
+                    );
                 });
             });
 
             describe('Mutabilidade', () => {
                 it('const', async () => {
-                    const retornoLexador = lexador.mapear([
-                        "const a = 1",
-                        "a = 2",
-                    ], -1);
+                    const retornoLexador = lexador.mapear(['const a = 1', 'a = 2'], -1);
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
 
                     expect(retornoInterpretador.erros[0].erroInterno.mensagem).toBe(
-                        'Constante \'a\' não pode receber novos valores.'
+                        "Constante 'a' não pode receber novos valores."
                     );
                 });
 
                 it('constante', async () => {
-                    const retornoLexador = lexador.mapear([
-                        "constante b = \"b\"",
-                        "b = 3",
-                    ], -1);
+                    const retornoLexador = lexador.mapear(['constante b = "b"', 'b = 3'], -1);
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
 
                     expect(retornoInterpretador.erros[0].erroInterno.mensagem).toBe(
-                        'Constante \'b\' não pode receber novos valores.'
+                        "Constante 'b' não pode receber novos valores."
                     );
                 });
 
                 it('fixo', async () => {
-                    const retornoLexador = lexador.mapear([
-                        "fixo c = 3",
-                        "c = 1"
-                    ], -1);
+                    const retornoLexador = lexador.mapear(['fixo c = 3', 'c = 1'], -1);
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
 
                     expect(retornoInterpretador.erros[0].erroInterno.mensagem).toBe(
-                        'Constante \'c\' não pode receber novos valores.'
+                        "Constante 'c' não pode receber novos valores."
                     );
                 });
 
                 it('Tupla Dupla - Atribuição por indice', async () => {
-                    const retornoLexador = lexador.mapear([
-                        "var t = [(1, 2)]",
-                        "t[0] = 3",
-                    ], -1);
+                    const retornoLexador = lexador.mapear(['var t = [(1, 2)]', 't[0] = 3'], -1);
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
@@ -1654,7 +1622,7 @@ describe('Interpretador', () => {
                 //         'Tupla é imutável, seus elementos não podem ser alterados, adicionados ou removidos.'
                 //     );
                 // });
-            })
+            });
         });
     });
 });