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

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

import { AcessoMetodoOuPropriedade, Chamada, Construto, Decorador, Dicionario, FuncaoConstruto, Leia } from '../construtos';
import { AvaliadorSintaticoInterface, ParametroInterface, SimboloInterface } from '../interfaces';
import { ErroAvaliadorSintatico } from './erro-avaliador-sintatico';
import { Tupla } from '../construtos/tuplas';
import { Bloco, Classe, Comentario, Const, Continua, Declaracao, Enquanto, Escolha, Escreva, Expressao, Falhar, Fazer, FuncaoDeclaracao, Importar, 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 { InformacaoVariavelOuConstante } from '../informacao-variavel-ou-constante';
/**
 * 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. Por exemplo, `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.
 */
export declare class AvaliadorSintatico extends AvaliadorSintaticoBase implements AvaliadorSintaticoInterface<SimboloInterface, Declaracao> {
    pilhaDecoradores: Decorador[];
    simbolos: SimboloInterface[];
    erros: ErroAvaliadorSintatico[];
    tiposDefinidosEmCodigo: {
        [nomeTipo: string]: Declaracao;
    };
    pilhaEscopos: PilhaEscopos;
    tiposDeFerramentasExternas: {
        [nomeFerramenta: string]: {
            [nomeTipo: string]: string;
        };
    };
    primitivasConhecidas: {
        [nomeModuloOuClasse: string]: {
            [nomePrimitiva: string]: InformacaoVariavelOuConstante;
        };
    };
    hashArquivo: number;
    atual: number;
    blocos: number;
    performance: boolean;
    superclasseAtual: string | undefined;
    constructor(performance?: boolean);
    protected verificarDefinicaoTipoAtual(): string;
    protected obterChaveDicionario(): Construto;
    protected construtoDicionario(simboloChaveEsquerda: SimboloInterface): Dicionario;
    protected construtoTupla(): Tupla;
    primario(): Construto;
    chamar(): 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;
    protected validarArgumentosEntidadeChamada(argumentosEntidadeChamada: InformacaoVariavelOuConstante[], 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): Chamada;
    unario(): Construto;
    multiplicar(): 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(): Construto;
    bitShift(): Construto;
    bitE(): Construto;
    bitOu(): Construto;
    comparar(): Construto;
    comparacaoIgualdade(): Construto;
    em(): Construto;
    e(): Construto;
    /**
     * Método que resolve atribuições.
     * @returns Um construto do tipo `Atribuir`, `Conjunto` ou `AtribuicaoPorIndice`.
     */
    atribuir(): Construto;
    /**
     * Declaração para comando `leia`, para ler dados de entrada do usuário.
     * @returns Um objeto da classe `Leia`.
     */
    expressaoLeia(): Leia;
    expressao(): Construto;
    blocoEscopo(): Array<Declaracao>;
    protected declaracaoComentarioMultilinha(): Comentario;
    protected declaracaoComentarioUmaLinha(): Comentario;
    declaracaoContinua(): Continua;
    declaracaoEnquanto(): Enquanto;
    protected declaracaoEscolha(): Escolha;
    declaracaoEscreva(): Escreva;
    protected declaracaoExpressao(): Expressao;
    protected declaracaoFalhar(): Falhar;
    protected declaracaoFazer(): 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(): Importar;
    declaracaoPara(): Para | ParaCada;
    protected declaracaoParaCadaDicionario(simboloPara: SimboloInterface): ParaCada;
    protected declaracaoParaCadaVetor(simboloPara: SimboloInterface): ParaCada;
    protected declaracaoParaCada(simboloPara: SimboloInterface): ParaCada;
    protected declaracaoParaTradicional(simboloPara: SimboloInterface): Para;
    declaracaoRetorna(): Retorna;
    declaracaoSe(): Se;
    declaracaoSustar(): Sustar;
    declaracaoTente(): Tente;
    protected resolverDecorador(): 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(): Declaracao | Declaracao[];
    protected declaracaoTendoComo(): TendoComo;
    protected declaracaoDesestruturacaoVariavel(): Var[];
    protected logicaComumInferenciaTiposVariaveisEConstantes(inicializador: Construto, tipo: string): string;
    /**
     * Caso símbolo atual seja `var`, devolve uma declaração de variável.
     * @returns Um Construto do tipo Var.
     */
    protected declaracaoDeVariaveis(): Var[];
    protected declaracaoDesestruturacaoConstante(): Const[];
    /**
     * Caso símbolo atual seja `const, constante ou fixo`, devolve uma declaração de const.
     * @returns Um Construto do tipo Const.
     */
    declaracaoDeConstantes(): Const[];
    protected funcao(tipo: string): FuncaoDeclaracao;
    protected logicaComumParametros(): ParametroInterface[];
    protected buscarRetornosEmBloco(construtoBloco: Bloco): Generator<Retorna>;
    protected buscarRetornosEmSe(construtoSe: Se): Generator<Retorna>;
    protected buscarRetornos(declaracao: Declaracao): Retorna[];
    corpoDaFuncao(tipo: string): FuncaoConstruto;
    declaracaoDeClasse(): Classe;
    /**
     * 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 resolverDecorador
     */
    resolverDeclaracaoForaDeBloco(): 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;
    /**
     * 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): RetornoAvaliadorSintatico<Declaracao>;
}
//# sourceMappingURL=avaliador-sintatico.d.ts.map