@designliquido/delegua 0.32.2 → 0.33.0

package/bin/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@designliquido/delegua",
-    "version": "0.32.1",
+    "version": "0.32.2",
     "description": "Linguagem de programação simples e moderna usando português estruturado, com suporte a múltiplos dialetos",
     "main": "index.js",
     "scripts": {
@@ -14,7 +14,7 @@
         "observar-testes-unitarios": "jest --watchAll",
         "observar-testes-unitarios-com-coverage": "jest --coverage --watchAll",
         "lint": "eslint . --ext .ts",
-        "prettier-format": "prettier --config .prettierrc --write fontes/**/*.ts"
+        "deixar-codigo-bonito": "prettier --config .prettierrc --write fontes/**/*.ts"
     },
     "repository": {
         "type": "git",

package/fontes/analisador-semantico/analisador-semantico-base.d.ts

@@ -0,0 +1,65 @@
+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 { 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 declare abstract class AnalisadorSemanticoBase implements AnalisadorSemanticoInterface {
+    abstract analisar(declaracoes: Declaracao[]): RetornoAnalisadorSemantico;
+    visitarDeclaracaoTendoComo(declaracao: TendoComo): Promise<any>;
+    visitarDeclaracaoInicioAlgoritmo(declaracao: InicioAlgoritmo): Promise<any>;
+    visitarDeclaracaoAleatorio(declaracao: Aleatorio): Promise<any>;
+    visitarDeclaracaoCabecalhoPrograma(declaracao: CabecalhoPrograma): Promise<any>;
+    visitarDeclaracaoClasse(declaracao: Classe): Promise<any>;
+    visitarDeclaracaoConst(declaracao: Const): Promise<any>;
+    visitarDeclaracaoConstMultiplo(declaracao: ConstMultiplo): Promise<any>;
+    visitarExpressaoDeAtribuicao(expressao: Atribuir): Promise<any>;
+    visitarDeclaracaoDeExpressao(declaracao: Expressao): Promise<any>;
+    visitarDeclaracaoDefinicaoFuncao(declaracao: FuncaoDeclaracao): void;
+    visitarDeclaracaoEnquanto(declaracao: Enquanto): Promise<any>;
+    visitarDeclaracaoEscolha(declaracao: Escolha): Promise<any>;
+    visitarDeclaracaoEscreva(declaracao: Escreva): Promise<any>;
+    visitarDeclaracaoFazer(declaracao: Fazer): Promise<any>;
+    visitarDeclaracaoImportar(declaracao: Importar): Promise<any>;
+    visitarDeclaracaoPara(declaracao: Para): Promise<any>;
+    visitarDeclaracaoParaCada(declaracao: ParaCada): Promise<any>;
+    visitarDeclaracaoSe(declaracao: Se): Promise<any>;
+    visitarDeclaracaoTente(declaracao: Tente): Promise<any>;
+    visitarDeclaracaoVar(declaracao: Var): Promise<any>;
+    visitarDeclaracaoVarMultiplo(declaracao: VarMultiplo): Promise<any>;
+    visitarExpressaoAcessoIndiceVariavel(expressao: AcessoIndiceVariavel): Promise<any>;
+    visitarExpressaoAcessoElementoMatriz(expressao: AcessoElementoMatriz): Promise<any>;
+    visitarExpressaoAcessoMetodo(expressao: AcessoMetodoOuPropriedade): Promise<any>;
+    visitarExpressaoAgrupamento(expressao: Agrupamento): Promise<any>;
+    visitarExpressaoAtribuicaoPorIndice(expressao: AtribuicaoPorIndice): Promise<any>;
+    visitarExpressaoAtribuicaoPorIndicesMatriz(expressao: AtribuicaoPorIndicesMatriz): Promise<any>;
+    visitarExpressaoBinaria(expressao: Binario): Promise<any>;
+    visitarExpressaoBloco(declaracao: Bloco): Promise<any>;
+    visitarExpressaoContinua(declaracao?: Continua): ContinuarQuebra;
+    visitarExpressaoDeChamada(expressao: Chamada): Promise<any>;
+    visitarExpressaoDefinirValor(expressao: DefinirValor): Promise<any>;
+    visitarExpressaoDeleguaFuncao(expressao: FuncaoConstruto): Promise<any>;
+    visitarExpressaoDeVariavel(expressao: Var): Promise<any>;
+    visitarExpressaoDicionario(expressao: Dicionario): Promise<any>;
+    visitarExpressaoExpressaoRegular(expressao: ExpressaoRegular): Promise<RegExp>;
+    visitarDeclaracaoEscrevaMesmaLinha(declaracao: EscrevaMesmaLinha): Promise<any>;
+    visitarExpressaoFalhar(expressao: Falhar): Promise<any>;
+    visitarExpressaoFimPara(declaracao: FimPara): Promise<any>;
+    visitarExpressaoFormatacaoEscrita(declaracao: FormatacaoEscrita): Promise<any>;
+    visitarExpressaoIsto(expressao: Isto): Promise<any>;
+    visitarExpressaoLeia(expressao: Leia): Promise<any>;
+    visitarExpressaoLeiaMultiplo(expressao: LeiaMultiplo): Promise<any>;
+    visitarExpressaoLiteral(expressao: Literal): Promise<any>;
+    visitarExpressaoLogica(expressao: Logico): Promise<any>;
+    visitarExpressaoRetornar(declaracao: Retorna): Promise<RetornoQuebra>;
+    visitarExpressaoSuper(expressao: Super): Promise<any>;
+    visitarExpressaoSustar(declaracao?: Sustar): SustarQuebra;
+    visitarExpressaoTupla(expressao: Tupla): Promise<any>;
+    visitarExpressaoTipoDe(expressao: TipoDe): Promise<any>;
+    visitarExpressaoUnaria(expressao: Unario): Promise<any>;
+    visitarExpressaoVetor(expressao: Vetor): Promise<any>;
+}

package/fontes/analisador-semantico/analisador-semantico-base.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnalisadorSemanticoBase = void 0;
+/**
+ * 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()`).
+ */
+class AnalisadorSemanticoBase {
+    visitarDeclaracaoTendoComo(declaracao) {
+        return Promise.resolve();
+    }
+    visitarDeclaracaoInicioAlgoritmo(declaracao) {
+        return Promise.resolve();
+    }
+    visitarDeclaracaoAleatorio(declaracao) {
+        return Promise.resolve();
+    }
+    visitarDeclaracaoCabecalhoPrograma(declaracao) {
+        return Promise.resolve();
+    }
+    visitarDeclaracaoClasse(declaracao) {
+        return Promise.resolve();
+    }
+    visitarDeclaracaoConst(declaracao) {
+        return Promise.resolve();
+    }
+    visitarDeclaracaoConstMultiplo(declaracao) {
+        return Promise.resolve();
+    }
+    visitarExpressaoDeAtribuicao(expressao) {
+        return Promise.resolve();
+    }
+    visitarDeclaracaoDeExpressao(declaracao) {
+        return Promise.resolve();
+    }
+    visitarDeclaracaoDefinicaoFuncao(declaracao) {
+        // Nada acontece.
+    }
+    visitarDeclaracaoEnquanto(declaracao) {
+        return Promise.resolve();
+    }
+    visitarDeclaracaoEscolha(declaracao) {
+        return Promise.resolve();
+    }
+    visitarDeclaracaoEscreva(declaracao) {
+        return Promise.resolve();
+    }
+    visitarDeclaracaoFazer(declaracao) {
+        return Promise.resolve();
+    }
+    visitarDeclaracaoImportar(declaracao) {
+        return Promise.resolve();
+    }
+    visitarDeclaracaoPara(declaracao) {
+        return Promise.resolve();
+    }
+    visitarDeclaracaoParaCada(declaracao) {
+        return Promise.resolve();
+    }
+    visitarDeclaracaoSe(declaracao) {
+        return Promise.resolve();
+    }
+    visitarDeclaracaoTente(declaracao) {
+        return Promise.resolve();
+    }
+    visitarDeclaracaoVar(declaracao) {
+        return Promise.resolve();
+    }
+    visitarDeclaracaoVarMultiplo(declaracao) {
+        return Promise.resolve();
+    }
+    visitarExpressaoAcessoIndiceVariavel(expressao) {
+        return Promise.resolve();
+    }
+    visitarExpressaoAcessoElementoMatriz(expressao) {
+        return Promise.resolve();
+    }
+    visitarExpressaoAcessoMetodo(expressao) {
+        return Promise.resolve();
+    }
+    visitarExpressaoAgrupamento(expressao) {
+        return Promise.resolve();
+    }
+    visitarExpressaoAtribuicaoPorIndice(expressao) {
+        return Promise.resolve();
+    }
+    visitarExpressaoAtribuicaoPorIndicesMatriz(expressao) {
+        return Promise.resolve();
+    }
+    visitarExpressaoBinaria(expressao) {
+        return Promise.resolve();
+    }
+    visitarExpressaoBloco(declaracao) {
+        return Promise.resolve();
+    }
+    visitarExpressaoContinua(declaracao) {
+        return Promise.resolve();
+    }
+    visitarExpressaoDeChamada(expressao) {
+        return Promise.resolve();
+    }
+    visitarExpressaoDefinirValor(expressao) {
+        return Promise.resolve();
+    }
+    visitarExpressaoDeleguaFuncao(expressao) {
+        return Promise.resolve();
+    }
+    visitarExpressaoDeVariavel(expressao) {
+        return Promise.resolve();
+    }
+    visitarExpressaoDicionario(expressao) {
+        return Promise.resolve();
+    }
+    visitarExpressaoExpressaoRegular(expressao) {
+        return;
+    }
+    visitarDeclaracaoEscrevaMesmaLinha(declaracao) {
+        return Promise.resolve();
+    }
+    visitarExpressaoFalhar(expressao) {
+        return Promise.resolve();
+    }
+    visitarExpressaoFimPara(declaracao) {
+        return Promise.resolve();
+    }
+    visitarExpressaoFormatacaoEscrita(declaracao) {
+        return Promise.resolve();
+    }
+    visitarExpressaoIsto(expressao) {
+        return Promise.resolve();
+    }
+    visitarExpressaoLeia(expressao) {
+        return Promise.resolve();
+    }
+    visitarExpressaoLeiaMultiplo(expressao) {
+        return Promise.resolve();
+    }
+    visitarExpressaoLiteral(expressao) {
+        return Promise.resolve();
+    }
+    visitarExpressaoLogica(expressao) {
+        return Promise.resolve();
+    }
+    visitarExpressaoRetornar(declaracao) {
+        return;
+    }
+    visitarExpressaoSuper(expressao) {
+        return Promise.resolve();
+    }
+    visitarExpressaoSustar(declaracao) {
+        return Promise.resolve();
+    }
+    visitarExpressaoTupla(expressao) {
+        return Promise.resolve();
+    }
+    visitarExpressaoTipoDe(expressao) {
+        return Promise.resolve();
+    }
+    visitarExpressaoUnaria(expressao) {
+        return Promise.resolve();
+    }
+    visitarExpressaoVetor(expressao) {
+        return Promise.resolve();
+    }
+}
+exports.AnalisadorSemanticoBase = AnalisadorSemanticoBase;
+//# sourceMappingURL=analisador-semantico-base.js.map

package/fontes/analisador-semantico/analisador-semantico-base.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"analisador-semantico-base.js","sourceRoot":"","sources":["../../../fontes/analisador-semantico/analisador-semantico-base.ts"],"names":[],"mappings":"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"}

package/fontes/analisador-semantico/analisador-semantico.d.ts

@@ -1,12 +1,11 @@
-import { Atribuir, Chamada, ExpressaoRegular, FimPara, FormatacaoEscrita, Literal, Super, TipoDe, Tupla } from '../construtos';
-import { Aleatorio, Bloco, CabecalhoPrograma, Classe, Const, ConstMultiplo, Continua, Declaracao, Enquanto, Escolha, Escreva, EscrevaMesmaLinha, Expressao, Falhar, Fazer, FuncaoDeclaracao, Importar, Leia, LeiaMultiplo, Para, ParaCada, Retorna, Se, Sustar, Tente, Var, VarMultiplo } from '../declaracoes';
-import { InicioAlgoritmo } from '../declaracoes/inicio-algoritmo';
+import { Atribuir, Chamada, TipoDe } from '../construtos';
+import { Const, Declaracao, Enquanto, Escolha, Escreva, Expressao, Falhar, FuncaoDeclaracao, Retorna, Var } from '../declaracoes';
 import { SimboloInterface } from '../interfaces';
-import { AnalisadorSemanticoInterface } from '../interfaces/analisador-semantico-interface';
 import { DiagnosticoAnalisadorSemantico } from '../interfaces/erros';
 import { RetornoAnalisadorSemantico } from '../interfaces/retornos/retorno-analisador-semantico';
 import { TiposDadosInterface } from '../interfaces/tipos-dados-interface';
-import { ContinuarQuebra, RetornoQuebra, SustarQuebra } from '../quebras';
+import { RetornoQuebra } from '../quebras';
+import { AnalisadorSemanticoBase } from './analisador-semantico-base';
 import { PilhaVariaveis } from './pilha-variaveis';
 interface VariavelHipoteticaInterface {
     tipo: TiposDadosInterface;
@@ -17,7 +16,7 @@ interface VariavelHipoteticaInterface {
 interface FuncaoHipoteticaInterface {
     valor: any;
 }
-export declare class AnalisadorSemantico implements AnalisadorSemanticoInterface {
+export declare class AnalisadorSemantico extends AnalisadorSemanticoBase {
     pilhaVariaveis: PilhaVariaveis;
     variaveis: {
         [nomeVariavel: string]: VariavelHipoteticaInterface;
@@ -28,13 +27,6 @@ export declare class AnalisadorSemantico implements AnalisadorSemanticoInterface
     atual: number;
     diagnosticos: DiagnosticoAnalisadorSemantico[];
     constructor();
-    visitarDeclaracaoCabecalhoPrograma(declaracao: CabecalhoPrograma): Promise<any>;
-    visitarExpressaoTupla(expressao: Tupla): Promise<any>;
-    visitarDeclaracaoAleatorio(declaracao: Aleatorio): Promise<any>;
-    visitarExpressaoAcessoElementoMatriz(expressao: any): Promise<void>;
-    visitarExpressaoAtribuicaoPorIndicesMatriz(expressao: any): Promise<any>;
-    visitarExpressaoExpressaoRegular(expressao: ExpressaoRegular): Promise<any>;
-    visitarDeclaracaoInicioAlgoritmo(declaracao: InicioAlgoritmo): Promise<any>;
     erro(simbolo: SimboloInterface, mensagem: string): void;
     aviso(simbolo: SimboloInterface, mensagem: string): void;
     verificarTipoAtribuido(declaracao: Var | Const): void;
@@ -42,25 +34,10 @@ export declare class AnalisadorSemantico implements AnalisadorSemanticoInterface
     private verificarTipoDe;
     visitarExpressaoFalhar(expressao: Falhar): Promise<any>;
     private verificarFalhar;
-    visitarExpressaoLiteral(expressao: Literal): Promise<any>;
-    visitarExpressaoAgrupamento(expressao: any): Promise<any>;
-    visitarExpressaoUnaria(expressao: any): Promise<void>;
-    visitarExpressaoBinaria(expressao: any): Promise<void>;
     visitarExpressaoDeChamada(expressao: Chamada): Promise<void>;
     visitarExpressaoDeAtribuicao(expressao: Atribuir): Promise<void>;
-    visitarExpressaoDeVariavel(expressao: any): Promise<void>;
     visitarDeclaracaoDeExpressao(declaracao: Expressao): Promise<any>;
-    visitarExpressaoLeia(expressao: Leia): Promise<void>;
-    visitarExpressaoLeiaMultiplo(expressao: LeiaMultiplo): Promise<void>;
-    visitarExpressaoLogica(expressao: any): Promise<void>;
-    visitarDeclaracaoPara(declaracao: Para): Promise<any>;
-    visitarDeclaracaoParaCada(declaracao: ParaCada): Promise<any>;
-    visitarDeclaracaoSe(declaracao: Se): Promise<void>;
-    visitarExpressaoFimPara(declaracao: FimPara): Promise<void>;
-    visitarDeclaracaoFazer(declaracao: Fazer): Promise<void>;
-    visitarExpressaoFormatacaoEscrita(declaracao: FormatacaoEscrita): Promise<void>;
     visitarDeclaracaoEscolha(declaracao: Escolha): Promise<void>;
-    visitarDeclaracaoTente(declaracao: Tente): Promise<void>;
     visitarDeclaracaoEnquanto(declaracao: Enquanto): Promise<void>;
     private verificarCondicao;
     private verificarVariavelBinaria;
@@ -71,29 +48,12 @@ export declare class AnalisadorSemantico implements AnalisadorSemanticoInterface
     private verificarLogico;
     private verificarChamada;
     private verificarLadoLogico;
-    visitarDeclaracaoImportar(declaracao: Importar): Promise<void>;
     visitarDeclaracaoEscreva(declaracao: Escreva): Promise<void>;
-    visitarDeclaracaoEscrevaMesmaLinha(declaracao: EscrevaMesmaLinha): Promise<void>;
-    visitarExpressaoBloco(declaracao: Bloco): Promise<any>;
     visitarDeclaracaoConst(declaracao: Const): Promise<any>;
     virificarTipoDeclaracaoConst(declaracao: Const): Promise<any>;
-    visitarDeclaracaoConstMultiplo(declaracao: ConstMultiplo): Promise<any>;
     visitarDeclaracaoVar(declaracao: Var): Promise<any>;
-    visitarDeclaracaoVarMultiplo(declaracao: VarMultiplo): Promise<any>;
-    visitarExpressaoContinua(declaracao?: Continua): ContinuarQuebra;
-    visitarExpressaoSustar(declaracao?: Sustar): SustarQuebra;
     visitarExpressaoRetornar(declaracao: Retorna): Promise<RetornoQuebra>;
-    visitarExpressaoDeleguaFuncao(expressao: any): Promise<void>;
-    visitarExpressaoAtribuicaoPorIndice(expressao: any): Promise<any>;
-    visitarExpressaoAcessoIndiceVariavel(expressao: any): Promise<void>;
-    visitarExpressaoDefinirValor(expressao: any): Promise<void>;
     visitarDeclaracaoDefinicaoFuncao(declaracao: FuncaoDeclaracao): Promise<void>;
-    visitarDeclaracaoClasse(declaracao: Classe): Promise<void>;
-    visitarExpressaoAcessoMetodo(expressao: any): Promise<void>;
-    visitarExpressaoIsto(expressao: any): Promise<void>;
-    visitarExpressaoDicionario(expressao: any): Promise<void>;
-    visitarExpressaoVetor(expressao: any): Promise<void>;
-    visitarExpressaoSuper(expressao: Super): Promise<void>;
     analisar(declaracoes: Declaracao[]): RetornoAnalisadorSemantico;
 }
 export {};

package/fontes/analisador-semantico/analisador-semantico.js

@@ -4,43 +4,24 @@ exports.AnalisadorSemantico = void 0;
 const construtos_1 = require("../construtos");
 const declaracoes_1 = require("../declaracoes");
 const erros_1 = require("../interfaces/erros");
+const analisador_semantico_base_1 = require("./analisador-semantico-base");
 const pilha_variaveis_1 = require("./pilha-variaveis");
-class AnalisadorSemantico {
+class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemanticoBase {
     constructor() {
+        super();
         this.pilhaVariaveis = new pilha_variaveis_1.PilhaVariaveis();
         this.variaveis = {};
         this.funcoes = {};
         this.atual = 0;
         this.diagnosticos = [];
     }
-    visitarDeclaracaoCabecalhoPrograma(declaracao) {
-        return Promise.resolve();
-    }
-    visitarExpressaoTupla(expressao) {
-        return Promise.resolve();
-    }
-    visitarDeclaracaoAleatorio(declaracao) {
-        return Promise.resolve();
-    }
-    visitarExpressaoAcessoElementoMatriz(expressao) {
-        return Promise.resolve();
-    }
-    visitarExpressaoAtribuicaoPorIndicesMatriz(expressao) {
-        return Promise.resolve();
-    }
-    visitarExpressaoExpressaoRegular(expressao) {
-        return Promise.resolve();
-    }
-    visitarDeclaracaoInicioAlgoritmo(declaracao) {
-        return Promise.resolve();
-    }
     erro(simbolo, mensagem) {
         this.diagnosticos.push({
             simbolo: simbolo,
             mensagem: mensagem,
             hashArquivo: simbolo.hashArquivo,
             linha: simbolo.linha,
-            severidade: erros_1.DiagnosticoSeveridade.ERRO
+            severidade: erros_1.DiagnosticoSeveridade.ERRO,
         });
     }
     aviso(simbolo, mensagem) {
@@ -49,7 +30,7 @@ class AnalisadorSemantico {
             mensagem: mensagem,
             hashArquivo: simbolo.hashArquivo,
             linha: simbolo.linha,
-            severidade: erros_1.DiagnosticoSeveridade.AVISO
+            severidade: erros_1.DiagnosticoSeveridade.AVISO,
         });
     }
     verificarTipoAtribuido(declaracao) {
@@ -58,13 +39,13 @@ class AnalisadorSemantico {
                 if (declaracao.inicializador instanceof construtos_1.Vetor) {
                     const vetor = declaracao.inicializador;
                     if (declaracao.tipo === 'inteiro[]') {
-                        const v = vetor.valores.find(v => typeof (v === null || v === void 0 ? void 0 : v.valor) !== 'number');
+                        const v = vetor.valores.find((v) => typeof (v === null || v === void 0 ? void 0 : v.valor) !== 'number');
                         if (v) {
                             this.erro(declaracao.simbolo, `Atribuição inválida para '${declaracao.simbolo.lexema}', é esperado um vetor de 'inteiros' ou 'real'.`);
                         }
                     }
                     if (declaracao.tipo === 'texto[]') {
-                        const v = vetor.valores.find(v => typeof (v === null || v === void 0 ? void 0 : v.valor) !== 'string');
+                        const v = vetor.valores.find((v) => typeof (v === null || v === void 0 ? void 0 : v.valor) !== 'string');
                         if (v) {
                             this.erro(declaracao.simbolo, `Atribuição inválida para '${declaracao.simbolo.lexema}', é esperado um vetor de 'texto'.`);
                         }
@@ -126,18 +107,6 @@ class AnalisadorSemantico {
         }
         return Promise.resolve();
     }
-    visitarExpressaoLiteral(expressao) {
-        return Promise.resolve();
-    }
-    visitarExpressaoAgrupamento(expressao) {
-        return Promise.resolve();
-    }
-    visitarExpressaoUnaria(expressao) {
-        return Promise.resolve();
-    }
-    visitarExpressaoBinaria(expressao) {
-        return Promise.resolve();
-    }
     visitarExpressaoDeChamada(expressao) {
         var _a, _b;
         if (expressao.entidadeChamada instanceof construtos_1.Variavel) {
@@ -157,8 +126,7 @@ class AnalisadorSemantico {
                     if (((_a = arg0.tipoDado) === null || _a === void 0 ? void 0 : _a.tipo) === 'texto' && typeof arg1.valor !== 'string') {
                         this.erro(expressao.entidadeChamada.simbolo, `O valor passado para o parâmetro '${arg0.tipoDado.nome}' é diferente do esperado pela função.`);
                     }
-                    else if (['inteiro', 'real'].includes((_b = arg0.tipoDado) === null || _b === void 0 ? void 0 : _b.tipo)
-                        && typeof arg1.valor !== 'number') {
+                    else if (['inteiro', 'real'].includes((_b = arg0.tipoDado) === null || _b === void 0 ? void 0 : _b.tipo) && typeof arg1.valor !== 'number') {
                         this.erro(expressao.entidadeChamada.simbolo, `O valor passado para o parâmetro '${arg0.tipoDado.nome}' é diferente do esperado pela função.`);
                     }
                 }
@@ -226,38 +194,8 @@ class AnalisadorSemantico {
             }
         }
     }
-    visitarExpressaoDeVariavel(expressao) {
-        return Promise.resolve();
-    }
-    visitarDeclaracaoDeExpressao(declaracao) {
-        return declaracao.expressao.aceitar(this);
-    }
-    visitarExpressaoLeia(expressao) {
-        return Promise.resolve();
-    }
-    visitarExpressaoLeiaMultiplo(expressao) {
-        return Promise.resolve();
-    }
-    visitarExpressaoLogica(expressao) {
-        return Promise.resolve();
-    }
-    visitarDeclaracaoPara(declaracao) {
-        return Promise.resolve();
-    }
-    visitarDeclaracaoParaCada(declaracao) {
-        return Promise.resolve();
-    }
-    visitarDeclaracaoSe(declaracao) {
-        return Promise.resolve();
-    }
-    visitarExpressaoFimPara(declaracao) {
-        return Promise.resolve();
-    }
-    visitarDeclaracaoFazer(declaracao) {
-        return Promise.resolve();
-    }
-    visitarExpressaoFormatacaoEscrita(declaracao) {
-        return Promise.resolve();
+    async visitarDeclaracaoDeExpressao(declaracao) {
+        return await declaracao.expressao.aceitar(this);
     }
     visitarDeclaracaoEscolha(declaracao) {
         var _a, _b;
@@ -277,9 +215,6 @@ class AnalisadorSemantico {
         }
         return Promise.resolve();
     }
-    visitarDeclaracaoTente(declaracao) {
-        return Promise.resolve();
-    }
     visitarDeclaracaoEnquanto(declaracao) {
         return this.verificarCondicao(declaracao.condicao);
     }
@@ -304,7 +239,9 @@ class AnalisadorSemantico {
     verificarVariavelBinaria(variavel) {
         this.verificarVariavel(variavel);
         const variavelHipotetica = this.variaveis[variavel.simbolo.lexema];
-        if (variavelHipotetica && !(variavelHipotetica.valor instanceof construtos_1.Binario) && (typeof variavelHipotetica.valor !== 'boolean')) {
+        if (variavelHipotetica &&
+            !(variavelHipotetica.valor instanceof construtos_1.Binario) &&
+            typeof variavelHipotetica.valor !== 'boolean') {
             this.erro(variavel.simbolo, `Esperado tipo 'lógico' na condição do 'enquanto'.`);
         }
         return Promise.resolve();
@@ -354,7 +291,6 @@ class AnalisadorSemantico {
             this.verificarBinario(lado);
             return;
         }
-        return;
     }
     verificarLogico(logio) {
         this.verificarLadoLogico(logio.direita);
@@ -365,8 +301,8 @@ class AnalisadorSemantico {
         let funcaoChamada = chamada.entidadeChamada;
         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();
     }
     verificarLadoLogico(lado) {
         if (lado instanceof construtos_1.Variavel) {
@@ -374,12 +310,9 @@ class AnalisadorSemantico {
             this.verificarVariavelBinaria(variavel);
         }
     }
-    visitarDeclaracaoImportar(declaracao) {
-        return Promise.resolve();
-    }
     visitarDeclaracaoEscreva(declaracao) {
         var _a;
-        const variaveis = declaracao.argumentos.filter(arg => arg instanceof construtos_1.Variavel);
+        const variaveis = declaracao.argumentos.filter((arg) => arg instanceof construtos_1.Variavel);
         for (let variavel of variaveis) {
             if (!this.variaveis[variavel.simbolo.lexema]) {
                 this.erro(variavel.simbolo, `Variável '${variavel.simbolo.lexema}' não existe.`);
@@ -390,12 +323,6 @@ class AnalisadorSemantico {
         }
         return Promise.resolve();
     }
-    visitarDeclaracaoEscrevaMesmaLinha(declaracao) {
-        return Promise.resolve();
-    }
-    visitarExpressaoBloco(declaracao) {
-        return Promise.resolve();
-    }
     visitarDeclaracaoConst(declaracao) {
         this.verificarTipoAtribuido(declaracao);
         if (this.variaveis.hasOwnProperty(declaracao.simbolo.lexema)) {
@@ -405,7 +332,7 @@ class AnalisadorSemantico {
             this.variaveis[declaracao.simbolo.lexema] = {
                 imutavel: true,
                 tipo: declaracao.tipo,
-                valor: declaracao.inicializador.valor
+                valor: declaracao.inicializador.valor,
             };
         }
         this.virificarTipoDeclaracaoConst(declaracao);
@@ -425,9 +352,6 @@ class AnalisadorSemantico {
         }
         return Promise.resolve();
     }
-    visitarDeclaracaoConstMultiplo(declaracao) {
-        return Promise.resolve();
-    }
     visitarDeclaracaoVar(declaracao) {
         this.verificarTipoAtribuido(declaracao);
         if (declaracao.inicializador instanceof construtos_1.FuncaoConstruto) {
@@ -439,34 +363,17 @@ class AnalisadorSemantico {
         this.variaveis[declaracao.simbolo.lexema] = {
             imutavel: false,
             tipo: declaracao.tipo,
-            valor: declaracao.inicializador !== null ? declaracao.inicializador.valor !== undefined ? declaracao.inicializador.valor : declaracao.inicializador : undefined
+            valor: declaracao.inicializador !== null
+                ? declaracao.inicializador.valor !== undefined
+                    ? declaracao.inicializador.valor
+                    : declaracao.inicializador
+                : undefined,
         };
         return Promise.resolve();
     }
-    visitarDeclaracaoVarMultiplo(declaracao) {
-        return Promise.resolve();
-    }
-    visitarExpressaoContinua(declaracao) {
-        return Promise.resolve();
-    }
-    visitarExpressaoSustar(declaracao) {
-        return Promise.resolve();
-    }
     visitarExpressaoRetornar(declaracao) {
         return Promise.resolve(null);
     }
-    visitarExpressaoDeleguaFuncao(expressao) {
-        return Promise.resolve();
-    }
-    visitarExpressaoAtribuicaoPorIndice(expressao) {
-        return Promise.resolve();
-    }
-    visitarExpressaoAcessoIndiceVariavel(expressao) {
-        return Promise.resolve();
-    }
-    visitarExpressaoDefinirValor(expressao) {
-        return Promise.resolve();
-    }
     visitarDeclaracaoDefinicaoFuncao(declaracao) {
         for (let parametro of declaracao.funcao.parametros) {
             if (parametro.hasOwnProperty('tipoDado') && !parametro.tipoDado.tipo) {
@@ -507,28 +414,10 @@ class AnalisadorSemantico {
             }
         }
         this.funcoes[declaracao.simbolo.lexema] = {
-            valor: declaracao.funcao
+            valor: declaracao.funcao,
         };
         return Promise.resolve();
     }
-    visitarDeclaracaoClasse(declaracao) {
-        return Promise.resolve();
-    }
-    visitarExpressaoAcessoMetodo(expressao) {
-        return Promise.resolve();
-    }
-    visitarExpressaoIsto(expressao) {
-        return Promise.resolve();
-    }
-    visitarExpressaoDicionario(expressao) {
-        return Promise.resolve();
-    }
-    visitarExpressaoVetor(expressao) {
-        return Promise.resolve();
-    }
-    visitarExpressaoSuper(expressao) {
-        return Promise.resolve();
-    }
     analisar(declaracoes) {
         // this.pilhaVariaveis = new PilhaVariaveis();
         // this.pilhaVariaveis.empilhar()