@designliquido/delegua 0.36.1 → 0.37.0

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

@@ -1,70 +1,70 @@
-import { Atribuir, AcessoIndiceVariavel, AcessoElementoMatriz, AcessoMetodoOuPropriedade, Agrupamento, AtribuicaoPorIndice, AtribuicaoPorIndicesMatriz, Binario, Chamada, DefinirValor, FuncaoConstruto, Dicionario, ExpressaoRegular, FimPara, FormatacaoEscrita, Isto, Literal, Logico, Super, Tupla, TipoDe, Unario, Vetor, Comentario } 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 { DiagnosticoAnalisadorSemantico, DiagnosticoSeveridade, SimboloInterface } from '../interfaces';
-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 {
-    diagnosticos: DiagnosticoAnalisadorSemantico[];
-    abstract analisar(declaracoes: Declaracao[]): RetornoAnalisadorSemantico;
-    adicionarDiagnostico(simbolo: SimboloInterface, mensagem: string, severidade?: DiagnosticoSeveridade): void;
-    visitarDeclaracaoAleatorio(declaracao: Aleatorio): Promise<any>;
-    visitarDeclaracaoCabecalhoPrograma(declaracao: CabecalhoPrograma): Promise<any>;
-    visitarDeclaracaoClasse(declaracao: Classe): Promise<any>;
-    visitarDeclaracaoComentario(declaracao: Comentario): void | 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>;
-    visitarDeclaracaoInicioAlgoritmo(declaracao: InicioAlgoritmo): Promise<any>;
-    visitarDeclaracaoPara(declaracao: Para): Promise<any>;
-    visitarDeclaracaoParaCada(declaracao: ParaCada): Promise<any>;
-    visitarDeclaracaoSe(declaracao: Se): Promise<any>;
-    visitarDeclaracaoTendoComo(declaracao: TendoComo): 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>;
-}
+import { Atribuir, AcessoIndiceVariavel, AcessoElementoMatriz, AcessoMetodoOuPropriedade, Agrupamento, AtribuicaoPorIndice, AtribuicaoPorIndicesMatriz, Binario, Chamada, DefinirValor, FuncaoConstruto, Dicionario, ExpressaoRegular, FimPara, FormatacaoEscrita, Isto, Literal, Logico, Super, Tupla, TipoDe, Unario, Vetor, Comentario } 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 { DiagnosticoAnalisadorSemantico, DiagnosticoSeveridade, SimboloInterface } from '../interfaces';
+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 {
+    diagnosticos: DiagnosticoAnalisadorSemantico[];
+    abstract analisar(declaracoes: Declaracao[]): RetornoAnalisadorSemantico;
+    adicionarDiagnostico(simbolo: SimboloInterface, mensagem: string, severidade?: DiagnosticoSeveridade): void;
+    visitarDeclaracaoAleatorio(declaracao: Aleatorio): Promise<any>;
+    visitarDeclaracaoCabecalhoPrograma(declaracao: CabecalhoPrograma): Promise<any>;
+    visitarDeclaracaoClasse(declaracao: Classe): Promise<any>;
+    visitarDeclaracaoComentario(declaracao: Comentario): void | 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>;
+    visitarDeclaracaoInicioAlgoritmo(declaracao: InicioAlgoritmo): Promise<any>;
+    visitarDeclaracaoPara(declaracao: Para): Promise<any>;
+    visitarDeclaracaoParaCada(declaracao: ParaCada): Promise<any>;
+    visitarDeclaracaoSe(declaracao: Se): Promise<any>;
+    visitarDeclaracaoTendoComo(declaracao: TendoComo): 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>;
+}
 //# sourceMappingURL=analisador-semantico-base.d.ts.map

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

@@ -1,181 +1,181 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AnalisadorSemanticoBase = void 0;
-const interfaces_1 = require("../interfaces");
-/**
- * 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 {
-    adicionarDiagnostico(simbolo, mensagem, severidade = interfaces_1.DiagnosticoSeveridade.ERRO) {
-        this.diagnosticos.push({
-            simbolo: simbolo,
-            mensagem: mensagem,
-            hashArquivo: simbolo.hashArquivo,
-            linha: simbolo.linha,
-            severidade: severidade,
-        });
-    }
-    visitarDeclaracaoAleatorio(declaracao) {
-        return Promise.resolve();
-    }
-    visitarDeclaracaoCabecalhoPrograma(declaracao) {
-        return Promise.resolve();
-    }
-    visitarDeclaracaoClasse(declaracao) {
-        return Promise.resolve();
-    }
-    visitarDeclaracaoComentario(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();
-    }
-    visitarDeclaracaoInicioAlgoritmo(declaracao) {
-        return Promise.resolve();
-    }
-    visitarDeclaracaoPara(declaracao) {
-        return Promise.resolve();
-    }
-    visitarDeclaracaoParaCada(declaracao) {
-        return Promise.resolve();
-    }
-    visitarDeclaracaoSe(declaracao) {
-        return Promise.resolve();
-    }
-    visitarDeclaracaoTendoComo(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;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnalisadorSemanticoBase = void 0;
+const interfaces_1 = require("../interfaces");
+/**
+ * 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 {
+    adicionarDiagnostico(simbolo, mensagem, severidade = interfaces_1.DiagnosticoSeveridade.ERRO) {
+        this.diagnosticos.push({
+            simbolo: simbolo,
+            mensagem: mensagem,
+            hashArquivo: simbolo.hashArquivo,
+            linha: simbolo.linha,
+            severidade: severidade,
+        });
+    }
+    visitarDeclaracaoAleatorio(declaracao) {
+        return Promise.resolve();
+    }
+    visitarDeclaracaoCabecalhoPrograma(declaracao) {
+        return Promise.resolve();
+    }
+    visitarDeclaracaoClasse(declaracao) {
+        return Promise.resolve();
+    }
+    visitarDeclaracaoComentario(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();
+    }
+    visitarDeclaracaoInicioAlgoritmo(declaracao) {
+        return Promise.resolve();
+    }
+    visitarDeclaracaoPara(declaracao) {
+        return Promise.resolve();
+    }
+    visitarDeclaracaoParaCada(declaracao) {
+        return Promise.resolve();
+    }
+    visitarDeclaracaoSe(declaracao) {
+        return Promise.resolve();
+    }
+    visitarDeclaracaoTendoComo(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/analisador-semantico/analisador-semantico.d.ts

@@ -1,60 +1,60 @@
-import { Atribuir, Chamada, TipoDe } from '../construtos';
-import { Const, Declaracao, Enquanto, Escolha, Escreva, Expressao, Falhar, FuncaoDeclaracao, Retorna, Var } from '../declaracoes';
-import { SimboloInterface } from '../interfaces';
-import { DiagnosticoAnalisadorSemantico } from '../interfaces/erros';
-import { RetornoAnalisadorSemantico } from '../interfaces/retornos/retorno-analisador-semantico';
-import { TipoDadosElementar } from '../tipo-dados-elementar';
-import { RetornoQuebra } from '../quebras';
-import { AnalisadorSemanticoBase } from './analisador-semantico-base';
-import { PilhaVariaveis } from './pilha-variaveis';
-interface VariavelHipoteticaInterface {
-    tipo: TipoDadosElementar;
-    subtipo?: 'texto' | 'número' | 'inteiro' | 'longo' | 'lógico';
-    imutavel: boolean;
-    valor?: any;
-}
-interface FuncaoHipoteticaInterface {
-    valor: any;
-}
-export declare class AnalisadorSemantico extends AnalisadorSemanticoBase {
-    pilhaVariaveis: PilhaVariaveis;
-    variaveis: {
-        [nomeVariavel: string]: VariavelHipoteticaInterface;
-    };
-    funcoes: {
-        [nomeFuncao: string]: FuncaoHipoteticaInterface;
-    };
-    atual: number;
-    diagnosticos: DiagnosticoAnalisadorSemantico[];
-    constructor();
-    erro(simbolo: SimboloInterface, mensagem: string): void;
-    aviso(simbolo: SimboloInterface, mensagem: string): void;
-    verificarTipoAtribuido(declaracao: Var | Const): void;
-    visitarExpressaoTipoDe(expressao: TipoDe): Promise<any>;
-    private verificarTipoDe;
-    visitarExpressaoFalhar(expressao: Falhar): Promise<any>;
-    private verificarFalhar;
-    visitarExpressaoDeChamada(expressao: Chamada): Promise<void>;
-    visitarExpressaoDeAtribuicao(expressao: Atribuir): Promise<void>;
-    visitarDeclaracaoDeExpressao(declaracao: Expressao): Promise<any>;
-    visitarDeclaracaoEscolha(declaracao: Escolha): Promise<void>;
-    visitarDeclaracaoEnquanto(declaracao: Enquanto): Promise<void>;
-    private verificarCondicao;
-    private verificarVariavelBinaria;
-    private verificarVariavel;
-    private verificarBinario;
-    private verificarOperadorBinario;
-    private verificarLadoBinario;
-    private verificarLogico;
-    private verificarChamada;
-    private verificarLadoLogico;
-    visitarDeclaracaoEscreva(declaracao: Escreva): Promise<void>;
-    visitarDeclaracaoConst(declaracao: Const): Promise<any>;
-    virificarTipoDeclaracaoConst(declaracao: Const): Promise<any>;
-    visitarDeclaracaoVar(declaracao: Var): Promise<any>;
-    visitarExpressaoRetornar(declaracao: Retorna): Promise<RetornoQuebra>;
-    visitarDeclaracaoDefinicaoFuncao(declaracao: FuncaoDeclaracao): Promise<void>;
-    analisar(declaracoes: Declaracao[]): RetornoAnalisadorSemantico;
-}
-export {};
+import { Atribuir, Chamada, TipoDe } from '../construtos';
+import { Const, Declaracao, Enquanto, Escolha, Escreva, Expressao, Falhar, FuncaoDeclaracao, Retorna, Var } from '../declaracoes';
+import { SimboloInterface } from '../interfaces';
+import { DiagnosticoAnalisadorSemantico } from '../interfaces/erros';
+import { RetornoAnalisadorSemantico } from '../interfaces/retornos/retorno-analisador-semantico';
+import { TipoDadosElementar } from '../tipo-dados-elementar';
+import { RetornoQuebra } from '../quebras';
+import { AnalisadorSemanticoBase } from './analisador-semantico-base';
+import { PilhaVariaveis } from './pilha-variaveis';
+interface VariavelHipoteticaInterface {
+    tipo: TipoDadosElementar;
+    subtipo?: 'texto' | 'número' | 'inteiro' | 'longo' | 'lógico';
+    imutavel: boolean;
+    valor?: any;
+}
+interface FuncaoHipoteticaInterface {
+    valor: any;
+}
+export declare class AnalisadorSemantico extends AnalisadorSemanticoBase {
+    pilhaVariaveis: PilhaVariaveis;
+    variaveis: {
+        [nomeVariavel: string]: VariavelHipoteticaInterface;
+    };
+    funcoes: {
+        [nomeFuncao: string]: FuncaoHipoteticaInterface;
+    };
+    atual: number;
+    diagnosticos: DiagnosticoAnalisadorSemantico[];
+    constructor();
+    erro(simbolo: SimboloInterface, mensagem: string): void;
+    aviso(simbolo: SimboloInterface, mensagem: string): void;
+    verificarTipoAtribuido(declaracao: Var | Const): void;
+    visitarExpressaoTipoDe(expressao: TipoDe): Promise<any>;
+    private verificarTipoDe;
+    visitarExpressaoFalhar(expressao: Falhar): Promise<any>;
+    private verificarFalhar;
+    visitarExpressaoDeChamada(expressao: Chamada): Promise<void>;
+    visitarExpressaoDeAtribuicao(expressao: Atribuir): Promise<void>;
+    visitarDeclaracaoDeExpressao(declaracao: Expressao): Promise<any>;
+    visitarDeclaracaoEscolha(declaracao: Escolha): Promise<void>;
+    visitarDeclaracaoEnquanto(declaracao: Enquanto): Promise<void>;
+    private verificarCondicao;
+    private verificarVariavelBinaria;
+    private verificarVariavel;
+    private verificarBinario;
+    private verificarOperadorBinario;
+    private verificarLadoBinario;
+    private verificarLogico;
+    private verificarChamada;
+    private verificarLadoLogico;
+    visitarDeclaracaoEscreva(declaracao: Escreva): Promise<void>;
+    visitarDeclaracaoConst(declaracao: Const): Promise<any>;
+    virificarTipoDeclaracaoConst(declaracao: Const): Promise<any>;
+    visitarDeclaracaoVar(declaracao: Var): Promise<any>;
+    visitarExpressaoRetornar(declaracao: Retorna): Promise<RetornoQuebra>;
+    visitarDeclaracaoDefinicaoFuncao(declaracao: FuncaoDeclaracao): Promise<void>;
+    analisar(declaracoes: Declaracao[]): RetornoAnalisadorSemantico;
+}
+export {};
 //# sourceMappingURL=analisador-semantico.d.ts.map