@designliquido/delegua/avaliador-sintatico/avaliador-sintatico.d.ts

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

import { AcessoMetodoOuPropriedade, AjudaComoConstruto, Chamada, Construto, Decorador, Dicionario, EnquantoComoConstruto, FuncaoConstruto, ImportarComoConstruto, Leia, ListaCompreensao, ParaCadaComoConstruto, ParaComoConstruto, Tupla, Variavel } from '../construtos';
import { AvaliadorSintaticoInterface, ParametroInterface, SimboloInterface } from '../interfaces';
import { ErroAvaliadorSintatico } from './erro-avaliador-sintatico';
import { Ajuda, Bloco, Classe, Comentario, Const, Continua, Declaracao, Enquanto, Escolha, Escreva, Expressao, Extensao, Falhar, Fazer, FuncaoDeclaracao, Importar, InterfaceDeclaracao, Para, ParaCada, Retorna, Se, Sustar, TendoComo, Tente, Var } from '../declaracoes';
import { RetornoAvaliadorSintatico } from '../interfaces/retornos/retorno-avaliador-sintatico';
import { RetornoLexador } from '../interfaces/retornos/retorno-lexador';
import { AvaliadorSintaticoBase } from './avaliador-sintatico-base';
import { PilhaEscopos } from './pilha-escopos';
import { InformacaoElementoSintatico } from '../informacao-elemento-sintatico';
import { MontaoTipos } from './montao-tipos';
import { ElementoMontaoTipos } from './elemento-montao-tipos';
import { ClasseDeModulo } from '../interpretador/estruturas';
/**
 * O avaliador sintático (_Parser_) é responsável por transformar os símbolos do Lexador em estruturas de alto nível.
 * Essas estruturas de alto nível são as partes que executam lógica de programação de fato.
 * Há dois grupos de estruturas de alto nível: Construtos e Declarações.
 *
 * Construtos não existem por si só: cada construto precisa estar dentro de uma declaração para ser
 * aceito pela próxima etapa, como tradução, interpretação, análise semântica, etc.
 *
 * Este é o avaliador sintático de Delégua que, assim como todos os demais dialetos baseados
 * neste núcleo, são uma derivação do avaliador sintático base. Aqui estão implementadas várias mecânicas
 * a mais relacionadas a tipagem e registros de bibliotecas externas:
 *
 * - `tiposDeFerramentasExternas` é utilizada em [Liquido](https://github.com/DesignLiquido/liquido)
 * para registro de tipos exclusivos de Liquido, como classes de requisição e resposta;
 * - `primitivasConhecidas` é utilizada aqui para registro de métodos relacionados a tipos, e também
 * para as bibliotecas externas de Delégua registrarem suas respectivas resoluções de tipos;
 * - `montaoTipos` é uma implementação de montão muito semelhante ao montão do interpretador, para
 * tipos complexos com N níveis de profundidade, como dicionários e objetos.
 */
export declare class AvaliadorSintatico extends AvaliadorSintaticoBase implements AvaliadorSintaticoInterface<SimboloInterface, Declaracao> {
    pilhaDecoradores: Decorador[];
    simbolos: SimboloInterface[];
    erros: ErroAvaliadorSintatico[];
    tiposDefinidosEmCodigo: {
        [nomeTipo: string]: Declaracao;
    };
    interfacesDeclaradas: {
        [nomeInterface: string]: InterfaceDeclaracao;
    };
    tiposDefinidosPorBibliotecas: {
        [nomeTipo: string]: ClasseDeModulo;
    };
    pilhaEscopos: PilhaEscopos;
    tiposDeFerramentasExternas: {
        [nomeFerramenta: string]: {
            [nomeTipo: string]: string;
        };
    };
    primitivasConhecidas: {
        [nomeModuloOuClasse: string]: {
            [nomePrimitiva: string]: InformacaoElementoSintatico;
        };
    };
    montaoTipos: MontaoTipos;
    hashArquivo: number;
    atual: number;
    blocos: number;
    performance: boolean;
    superclasseAtual: string | undefined;
    intuirTipoQualquerParaIdentificadores: boolean;
    emAjuda: boolean;
    constructor(performance?: boolean);
    protected verificarDefinicaoTipoAtual(): string;
    protected construtoAjuda(): Promise<AjudaComoConstruto>;
    protected obterChaveDicionario(): Promise<Construto>;
    protected construtoDicionario(simboloChaveEsquerda: SimboloInterface): Promise<Dicionario>;
    /**
     * `delegua-node` e a extensão para VSCode precisam que este método seja assíncrono.
     * @returns
     */
    protected construtoImportar(): Promise<ImportarComoConstruto>;
    protected construtoTupla(): Promise<Tupla>;
    protected enquantoComoConstruto(): Promise<EnquantoComoConstruto>;
    protected fazerComoConstruto(simboloFazer: SimboloInterface): Promise<Construto>;
    protected paraCadaComoConstrutoVetor(simboloPara: SimboloInterface): Promise<ParaCadaComoConstruto>;
    protected paraCadaComoConstrutoDicionario(simboloPara: SimboloInterface): Promise<ParaCadaComoConstruto>;
    protected paraCadaComoConstruto(simboloPara: SimboloInterface): Promise<ParaCadaComoConstruto>;
    protected paraTradicionalComoConstruto(simboloPara: SimboloInterface): Promise<ParaComoConstruto>;
    /**
     * Método que resolve `para` ou `para cada` como construto.
     */
    protected paraComoConstruto(simboloPara: SimboloInterface): Promise<ParaCadaComoConstruto | ParaComoConstruto>;
    /**
     * Resolve uma lista de compreensão.
     * @returns {ListaCompreensao} A lista de compreensão resolvida.
     */
    protected resolverCompreensaoDeLista(retornoExpressao: Construto): Promise<ListaCompreensao>;
    primario(): Promise<Construto>;
    protected resolverTipoAcessoIndiceVariavel(expressaoAnterior: Construto): string;
    /**
     * Resolve um construto do tipo `Variavel`, `AcessoMetodoOuPropriedade` ou `AcessoIndiceVariavel`
     * para um `ElementoMontaoTipos` correspondente, caso exista.
     * @param construto O construto.
     * @returns O `ElementoMontaoTipos` correspondente ou `null` se não existir.
     */
    protected resolverElementoMontao(construto: Construto): ElementoMontaoTipos | null;
    protected resolverCadeiaChamadas(expressaoAnterior: Construto, tipoAnterior?: string): any;
    chamar(): Promise<Construto>;
    /**
     * `AcessoMetodoOuPropriedade` é um construto intermediário em Delégua, e deve ser resolvido como outro
     * construto antes de qualquer outra próxima etapa. Algumas validações adicionais também ocorrem aqui.
     * @param {AcessoMetodoOuPropriedade} entidadeChamadaResolvida O construto original.
     * @returns {Construto} O construto resolvido como um tipo mais específico.
     * @see finalizarChamada
     */
    protected resolverEntidadeChamadaAcessoMetodoOuPropriedade(entidadeChamadaResolvida: AcessoMetodoOuPropriedade): Construto;
    private obterTiposParaConsultaPrimitiva;
    private resolverAcessoMetodoConhecido;
    protected validarArgumentosEntidadeChamada(argumentosEntidadeChamada: InformacaoElementoSintatico[], argumentosUtilizados: Construto[]): string[];
    /**
     * Diversas verificações de resolução de entidade chamada, como resolver chamada da pilha ou usar referência, argumentos, etc.
     * @param entidadeChamada O construto da entidade chamada.
     * @param argumentos Os argumentos utilizados na chamada.
     * @param tipoPrimitiva Se for uma primitiva, o tipo dela. Senão, `undefined`.
     * @returns A entidade chamada resolvida, se as validações passarem.
     */
    protected resolverEntidadeChamada(entidadeChamada: Construto, argumentos: Construto[], tipoPrimitiva?: string | undefined): Construto;
    finalizarChamada(entidadeChamada: Construto, tipoPrimitiva?: string | undefined): Promise<Chamada>;
    unario(): Promise<Construto>;
    /**
     * A exponenciacão é uma exceção na ordem de avaliação (resolve primeiro à direita).
     * Por isso `direito` chama `exponenciacao()`, e não `unario()`.
     * @returns {Binario} A expressão binária na forma do construto `Binario`.
     */
    exponenciacao(): Promise<Construto>;
    /**
     * Verifica recursivamente se um construto é ou contém uma operação unária em um vetor.
     * Isso bloqueia padrões de ofuscação como !![] usado em operações aritméticas.
     */
    private verificarOperacaoUnariaEmVetor;
    protected verificacaoOperacoesBinariasIlegais(esquerdo: Construto, direito: Construto, operador: SimboloInterface): void;
    multiplicar(): Promise<Construto>;
    /**
     * Se símbolo de operação é `+`, `-`, `+=` ou `-=`, monta objeto `Binario` para
     * ser avaliado pelo Interpretador.
     * @returns Um Construto, normalmente um `Binario`, ou `Unario` se houver alguma operação unária para ser avaliada.
     */
    adicaoOuSubtracao(): Promise<Construto>;
    bitShift(): Promise<Construto>;
    bitE(): Promise<Construto>;
    bitOu(): Promise<Construto>;
    comparar(): Promise<Construto>;
    comparacaoIgualdade(): Promise<Construto>;
    em(): Promise<Construto>;
    e(): Promise<Construto>;
    protected elvis(): Promise<Construto>;
    protected seTernario(): Promise<Construto>;
    /**
     * Método que resolve atribuições.
     * @returns Um construto do tipo `Atribuir`, `Conjunto` ou `AtribuicaoPorIndice`.
     */
    /**
     * Processa tuplas, que são expressões separadas por vírgula entre parênteses.
     * Se não houver vírgula, retorna apenas a expressão simples.
     * Sobrescreve o método da base para usar seTernario() em vez de ou().
     */
    tupla(): Promise<Construto>;
    /**
     * Método que resolve atribuições.
     * @returns Um construto do tipo `Atribuir`, `Conjunto` ou `AtribuicaoPorIndice`.
     */
    atribuir(): Promise<Construto>;
    /**
     * Declaração para comando `leia`, para ler dados de entrada do usuário.
     * @returns Um objeto da classe `Leia`.
     */
    expressaoLeia(): Promise<Leia>;
    expressao(): Promise<Construto>;
    blocoEscopo(): Promise<Array<Declaracao>>;
    protected declaracaoComentarioMultilinha(): Comentario;
    protected declaracaoComentarioUmaLinha(): Comentario;
    declaracaoContinua(): Continua;
    protected logicaComumEnquanto(): Promise<{
        condicao: Construto;
        corpo: Bloco;
    }>;
    declaracaoEnquanto(): Promise<Enquanto>;
    protected declaracaoEscolha(): Promise<Escolha>;
    declaracaoEscreva(): Promise<Escreva>;
    protected declaracaoExpressao(): Promise<Expressao>;
    protected declaracaoFalhar(): Promise<Falhar>;
    protected logicaComumFazer(): Promise<{
        caminhoFazer: Bloco;
        condicaoEnquanto: Construto;
    }>;
    protected declaracaoFazer(simboloFazer: SimboloInterface): Promise<Fazer>;
    /**
     * O símbolo é emitido aqui para fins de formatação, mas este método é
     * sobrescrito em `delegua-node`.
     * @returns {Importar} Uma declaração `Importar`.
     */
    declaracaoImportar(): Promise<Importar>;
    declaracaoPara(): Promise<Para | ParaCada>;
    protected logicaParaCadaDicionario(simboloPara: SimboloInterface): Promise<{
        nomeVariavelChave: SimboloInterface<string>;
        nomeVariavelValor: SimboloInterface<string>;
        dicionario: Construto;
        corpo: Bloco;
    }>;
    protected declaracaoParaCadaDicionario(simboloPara: SimboloInterface): Promise<ParaCada>;
    protected logicaComumParaCadaVetor(simboloPara: SimboloInterface): Promise<{
        variavelIteracao: Variavel<string>;
        vetor: Construto;
        corpo: Bloco;
    }>;
    protected declaracaoParaCadaVetor(simboloPara: SimboloInterface): Promise<ParaCada>;
    protected declaracaoParaCada(simboloPara: SimboloInterface): Promise<ParaCada>;
    protected logicaComumPara(): Promise<{
        inicializador: Expressao | Var | Const[];
        condicao: any;
        incrementar: any;
        corpo: Bloco;
    }>;
    protected declaracaoParaTradicional(simboloPara: SimboloInterface): Promise<Para>;
    declaracaoRetorna(): Promise<Retorna>;
    declaracaoSe(): Promise<Se>;
    declaracaoSustar(): Sustar;
    declaracaoTente(): Promise<Tente>;
    protected resolverDecoradores(): Promise<void>;
    protected declaracaoTendoComo(): Promise<TendoComo>;
    protected declaracaoDesestruturacaoVariavel(): Promise<Var[]>;
    protected logicaComumInferenciaTiposAcessoMetodoOuPropriedade(entidadeChamada: AcessoMetodoOuPropriedade): string;
    protected logicaComumInferenciaTiposVariaveisEConstantes(inicializador: Construto, tipo: string): string;
    protected resolverValorConstruto(construto: Construto): string;
    protected resolverInformacaoElementoSintaticoDeDicionario(construto: Construto): ElementoMontaoTipos;
    /**
     * Caso símbolo atual seja `var`, devolve uma declaração de variável.
     * @returns Um Construto do tipo Var.
     */
    protected declaracaoDeVariaveis(): Promise<Var[]>;
    protected declaracaoDesestruturacaoConstante(): Promise<Const[]>;
    /**
     * Caso símbolo atual seja `const, constante ou fixo`, devolve uma declaração de const.
     * @returns Um Construto do tipo Const.
     */
    declaracaoDeConstantes(): Promise<Const[]>;
    protected funcao(tipo: string): Promise<FuncaoDeclaracao>;
    protected logicaComumParametros(): Promise<ParametroInterface[]>;
    corpoDaFuncao(tipo: string): Promise<FuncaoConstruto>;
    /**
     * Analisa uma declaração de interface.
     * Interfaces definem contratos de métodos e propriedades que as classes devem implementar.
     * A verificação é feita em tempo de análise (parse-time).
     */
    declaracaoDeInterface(): Promise<InterfaceDeclaracao>;
    declaracaoDeClasse(): Promise<Classe>;
    /**
     * Analisa uma declaração de extensão:
     * `extensão [global] de <tipo> { <métodos> }`
     */
    declaracaoDeExtensao(): Promise<Extensao>;
    /**
     * Declarações fora de bloco precisam ser verificadas primeiro por
     * uma série de motivos, como, por exemplo:
     *
     * - Não é possível declarar uma classe/função dentro de um bloco `enquanto`,
     *   `fazer ... enquanto`, `para`, `escolha`, etc;
     * - Qualquer declaração pode ter um decorador.
     * @returns Uma função ou classe se o símbolo atual resolver aqui.
     *          O retorno de `resolverDeclaracao()` em caso contrário.
     * @see resolverDeclaracao
     * @see resolverDecoradores
     */
    resolverDeclaracaoForaDeBloco(): Promise<Declaracao | Declaracao[]>;
    /**
     * Usado quando há erros na avaliação sintática.
     * Garante que o código não entre em _loop_ infinito.
     * @returns Sempre retorna `void`.
     */
    protected sincronizar(): void;
    /**
     * Todas as resoluções triviais da linguagem, ou seja, todas as
     * resoluções que podem ocorrer dentro ou fora de um bloco.
     * @returns Normalmente uma `Declaracao`, mas há casos em que
     * outros objetos podem ser retornados.
     * @see resolverDeclaracaoForaDeBloco para as declarações que não podem
     * ocorrer em blocos de escopo elementares.
     */
    protected resolverDeclaracao(): Promise<Declaracao | Declaracao[]>;
    declaracaoAjuda(): Promise<Ajuda>;
    /**
     * Inicializa o primeiro nível da pilha de escopos, normalmente com ítens da biblioteca global.
     * É separada da inicialização do avaliador sintático, pois é necessário manipular essa
     * inicialização de outra forma em `delegua-node`.
     */
    protected inicializarPilhaEscopos(): void;
    analisar(retornoLexador: RetornoLexador<SimboloInterface>, hashArquivo: number): Promise<RetornoAvaliadorSintatico<Declaracao>>;
}
//# sourceMappingURL=avaliador-sintatico.d.ts.map