@designliquido/delegua/analisador-semantico/analisador-semantico.d.ts

Linguagem de programação simples e moderna usando português estruturado.

import { AcessoIndiceVariavel, AcessoMetodoOuPropriedade, ArgumentoReferenciaFuncao, AjudaComoConstruto, AtribuicaoPorIndice, Atribuir, Chamada, FormatacaoEscrita, Literal, ReferenciaFuncao, TipoDe, Variavel } from '../construtos';
import { Ajuda, Bloco, Classe, Const, Declaracao, Enquanto, Escolha, Escreva, Expressao, Fazer, Falhar, FuncaoDeclaracao, Para, ParaCada, Retorna, Se, Var } from '../declaracoes';
import { ParametroInterface, SimboloInterface } from '../interfaces';
import { ConstrutoInterface } from '../interfaces/construtos/construto-interface';
import { DiagnosticoAnalisadorSemanticoInterface } from '../interfaces/erros';
import { RetornoAnalisadorSemanticoInterface } from '../interfaces/retornos/retorno-analisador-semantico-interface';
import { RetornoQuebra } from '../quebras';
import { MicroAvaliadorSintatico } from '../avaliador-sintatico/micro-avaliador-sintatico';
import { MicroLexador } from '../lexador/micro-lexador';
import { AnalisadorSemanticoBase } from './analisador-semantico-base';
import { FuncaoHipoteticaInterface } from './funcao-hipotetica-interface';
import { PilhaVariaveis } from './pilha-variaveis';
/**
 * O Analisador Semântico de Delégua.
 */
export declare class AnalisadorSemantico extends AnalisadorSemanticoBase {
    pilhaVariaveis: PilhaVariaveis;
    funcoes: {
        [nomeFuncao: string]: FuncaoHipoteticaInterface;
    };
    classesDeclaradas: Set<string>;
    classesRegistradas: Map<string, Classe>;
    private classesExternasRegistradas;
    classeAtualEmAnalise: Classe | null;
    atual: number;
    diagnosticos: DiagnosticoAnalisadorSemanticoInterface[];
    protected readonly microLexador: MicroLexador;
    protected readonly microAvaliadorSintatico: MicroAvaliadorSintatico;
    constructor();
    registrarClassesExternas(classes: Classe[]): void;
    verificarTipoAtribuido(declaracao: Var | Const): void;
    visitarExpressaoTipoDe(expressao: TipoDe): Promise<any>;
    /**
     * Método recursivo para verificar o tipo de um construto, usado principalmente para validar
     * o uso de `tipoDe` e `falhar()`.
     * @param {ConstrutoInterface} valor O construto a ser avaliado.
     * @returns {Promise<any>} O tipo do construto, ou `Promise.resolve()` se o tipo não puder ser
     * determinado neste estágio da análise.
     */
    private verificarTipoDe;
    visitarExpressaoFalhar(expressao: Falhar): Promise<any>;
    /**
     * Método recursivo para verificar se um construto passado para `falhar()` é válido, ou seja, se é
     * do tipo texto ou pode ser avaliado como texto.
     * @param {ConstrutoInterface} valor O construto a ser avaliado.
     * @returns {Promise<any>} O tipo do construto, ou `Promise.resolve()` se o tipo não puder ser
     * determinado neste estágio da análise.
     */
    private verificarFalhar;
    protected comparacaoArgumentosContraParametrosFuncao(simboloFuncao: SimboloInterface, parametros: ParametroInterface[], argumentos: ConstrutoInterface[]): void;
    visitarChamadaPorArgumentoReferenciaFuncao(argumentoReferenciaFuncao: ArgumentoReferenciaFuncao, argumentos: ConstrutoInterface[]): void;
    visitarChamadaPorReferenciaFuncao(referenciaFuncao: ReferenciaFuncao, argumentos: ConstrutoInterface[]): void;
    visitarChamadaPorVariavel(entidadeChamadaVariavel: Variavel, argumentos: ConstrutoInterface[]): Promise<void>;
    visitarExpressaoDeChamada(expressao: Chamada): Promise<void>;
    visitarExpressaoDeAtribuicao(expressao: Atribuir): Promise<any>;
    visitarDeclaracaoDeExpressao(declaracao: Expressao): Promise<any>;
    visitarExpressaoBloco(declaracao: Bloco): Promise<any>;
    visitarExpressaoAcessoIndiceVariavel(expressao: AcessoIndiceVariavel): Promise<any>;
    visitarExpressaoAtribuicaoPorIndice(expressao: AtribuicaoPorIndice): Promise<any>;
    visitarDeclaracaoAjuda(declaracao: Ajuda): Promise<any>;
    visitarExpressaoAjuda(expressao: AjudaComoConstruto): Promise<any>;
    visitarDeclaracaoEscolha(declaracao: Escolha): Promise<void>;
    visitarDeclaracaoEnquanto(declaracao: Enquanto): Promise<void>;
    visitarDeclaracaoFazer(declaracao: Fazer): Promise<void>;
    visitarDeclaracaoPara(declaracao: Para): Promise<any>;
    visitarDeclaracaoParaCada(declaracao: ParaCada): Promise<void>;
    visitarDeclaracaoSe(declaracao: Se): Promise<void>;
    /**
     * Verifica uma expressão recursivamente, incluindo operações binárias
     */
    private verificarExpressao;
    private verificarCondicao;
    private verificarVariavelBinaria;
    private verificarVariavel;
    private verificarBinario;
    private verificarOperadorBinario;
    /**
     * Verifica se os tipos dos operandos são compatíveis
     */
    private verificarTiposOperandos;
    /**
     * Verifica se os tipos dos operandos em uma comparação são compatíveis
     */
    private verificarTiposComparacao;
    /**
     * Verifica divisão por zero recursivamente
     */
    private verificarDivisaoPorZero;
    /**
     * Tenta avaliar uma expressão em tempo de compilação para detectar valores constantes
     * Retorna o valor se puder ser determinado, ou null caso contrário
     */
    private avaliarExpressaoConstante;
    /**
     * Calcula o resultado de uma operação binária em tempo de compilação
     */
    private calcularOperacaoBinaria;
    private verificarExistenciaConstruto;
    private verificarLogico;
    private verificarChamada;
    private verificarLadoLogico;
    /**
     * Verifica interpolações de texto e marca variáveis como usadas,
     * compreendendo cada expressão interpolada com MicroLexador e MicroAvaliadorSintatico.
     */
    protected verificarInterpolacaoTexto(texto: string, literal: Literal): void;
    visitarDeclaracaoEscreva(declaracao: Escreva): Promise<any>;
    visitarDeclaracaoConst(declaracao: Const): Promise<any>;
    visitarDeclaracaoVar(declaracao: Var): Promise<any>;
    visitarExpressaoFormatacaoEscrita(expressao: FormatacaoEscrita): Promise<any>;
    visitarExpressaoRetornar(declaracao: Retorna): Promise<RetornoQuebra>;
    visitarExpressaoDeVariavel(expressao: Variavel | ConstrutoInterface): Promise<any>;
    protected obterTipoExpressao(expressao: ConstrutoInterface): string | null;
    private resolverTipoObjeto;
    private estaEmClasseOuSubclasse;
    visitarExpressaoAcessoMetodoOuPropriedade(expressao: AcessoMetodoOuPropriedade): Promise<any>;
    visitarDeclaracaoClasse(declaracao: Classe): Promise<any>;
    visitarDeclaracaoDefinicaoFuncao(declaracao: FuncaoDeclaracao): Promise<any>;
    verificarVariaveisNaoUsadas(): void;
    analisar(declaracoes: Declaracao[]): Promise<RetornoAnalisadorSemanticoInterface>;
}
//# sourceMappingURL=analisador-semantico.d.ts.map