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

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

import { ConstrutoInterface } from '../../interfaces/construtos/construto-interface';
import { AcessoMetodoOuPropriedade, Decorador, FuncaoConstruto, Leia, ListaCompreensao, ImportarComoConstruto } from '../../construtos';
import { Escreva, Se, Enquanto, Continua, Retorna, Escolha, Tente, Fazer, Var, FuncaoDeclaracao, Classe, Declaracao, Expressao, Sustar, Falhar, ParaCada, Comentario, PropriedadeClasse, TextoDocumentacao, Importar } from '../../declaracoes';
import { AvaliadorSintaticoInterface, ParametroInterface, SimboloInterface } from '../../interfaces';
import { Localizacao } from '../../lexador/dialetos/localizacao';
import { RetornoLexadorInterface } from '../../interfaces/retornos/retorno-lexador-interface';
import { ErroAvaliadorSintatico } from '../erro-avaliador-sintatico';
import { RetornoAvaliadorSintaticoInterface } from '../../interfaces/retornos/retorno-avaliador-sintatico-interface';
import { PilhaEscopos } from '../pilha-escopos';
import { InformacaoElementoSintatico } from '../../informacao-elemento-sintatico';
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.
 *
 * A grande diferença entre este avaliador e os demais é a forma como são entendidos os blocos de escopo.
 * Este avaliador espera uma estrutura de pragmas, que explica quantos espaços há na frente de cada linha.
 */
export declare class AvaliadorSintaticoPitugues implements AvaliadorSintaticoInterface<SimboloInterface, Declaracao> {
    simbolos: SimboloInterface[];
    erros: ErroAvaliadorSintatico[];
    localizacoes: {
        [linha: number]: Localizacao;
    };
    tiposDefinidosEmCodigo: {
        [nomeTipo: string]: Declaracao;
    };
    tiposDefinidosPorBibliotecas: {
        [nomeTipo: string]: ClasseDeModulo;
    };
    pilhaEscopos: PilhaEscopos;
    tiposDeFerramentasExternas: {
        [nomeFerramenta: string]: {
            [nomeTipo: string]: string;
        };
    };
    primitivasConhecidas: {
        [nomeModuloOuClasse: string]: {
            [nomePrimitiva: string]: InformacaoElementoSintatico;
        };
    };
    hashArquivo: number;
    atual: number;
    blocos: number;
    escopos: number[];
    performance: boolean;
    superclasseAtual: string | undefined;
    intuirTipoQualquerParaIdentificadores: boolean;
    pilhaDecoradores: Decorador[];
    constructor(performance?: boolean);
    protected logicaComumInferenciaTiposAcessoMetodoOuPropriedade(entidadeChamada: AcessoMetodoOuPropriedade): string;
    protected logicaComumInferenciaTiposVariaveisEConstantes(inicializador: ConstrutoInterface, tipoPrevio: string): string;
    expressaoLeia(): Promise<Leia>;
    declaracaoDeVariavel(): Var;
    private variavelJaDeclarada;
    private declaracaoImplicitaVariaveis;
    private temPadraoMultiplaAtribuicao;
    private temPadraoVarComoPalavraChave;
    private consumirIdentificadores;
    private consumirInicializadores;
    private construirValidacaoDesempacotamento;
    declaracaoDeVariaveis(): Promise<any>;
    sincronizar(): void;
    erro(simbolo: SimboloInterface, mensagemDeErro: string, codigoDiagnostico?: string, simboloRelacionado?: SimboloInterface): ErroAvaliadorSintatico;
    consumir(tipo: string, mensagemDeErro: string): SimboloInterface<string>;
    verificarTipoSimboloAtual(tipo: string): boolean;
    verificarTipoProximoSimbolo(tipo: string): boolean;
    simboloAtual(): SimboloInterface;
    simboloAnterior(): SimboloInterface;
    simboloNaPosicao(posicao: number): SimboloInterface;
    estaNoFinal(): boolean;
    avancarEDevolverAnterior(): SimboloInterface<string>;
    verificarSeSimboloAtualEIgualA(...argumentos: string[]): boolean;
    /**
     * Transforma uma string com interpolações (f-string) em código equivalente usando o método formatar.
     * Exemplo: f"Olá {nome}, você tem {idade} anos" -> "Olá " + nome + " você tem " + idade + " anos"
     * Com formatadores: f"{valor:.2f}" -> "" + "{:.2f}".formatar(valor) + ""
     * Com depuração: f"{usuario=}" -> "" + "{usuario=}".formatar(usuario) + ""
     */
    private transformarInterpolacaoEmFormatacao;
    private ignorarComentarios;
    primario(): Promise<ConstrutoInterface>;
    finalizarChamada(entidadeChamada: ConstrutoInterface): Promise<ConstrutoInterface>;
    chamar(): Promise<ConstrutoInterface>;
    unario(): Promise<ConstrutoInterface>;
    exponenciacao(): Promise<ConstrutoInterface>;
    multiplicar(): Promise<ConstrutoInterface>;
    adicaoOuSubtracao(): Promise<ConstrutoInterface>;
    bitShift(): Promise<ConstrutoInterface>;
    bitE(): Promise<ConstrutoInterface>;
    bitOu(): Promise<ConstrutoInterface>;
    comparar(): Promise<ConstrutoInterface>;
    comparacaoIgualdade(): Promise<ConstrutoInterface>;
    em(): Promise<ConstrutoInterface>;
    e(): Promise<ConstrutoInterface>;
    ou(): Promise<ConstrutoInterface>;
    protected seTernario(): Promise<ConstrutoInterface>;
    tupla(): Promise<ConstrutoInterface>;
    bote(): Promise<ConstrutoInterface>;
    atribuir(): Promise<ConstrutoInterface>;
    declaracaoEscreva(simboloEscreva: SimboloInterface): Promise<Escreva>;
    declaracaoExpressao(): Promise<Expressao>;
    blocoEscopo(): Promise<any[]>;
    declaracaoEnquanto(): Promise<Enquanto>;
    declaracaoEscolha(): Promise<Escolha>;
    protected declaracaoParaCada(simboloPara: SimboloInterface): Promise<ParaCada>;
    declaracaoPara(): Promise<ParaCada>;
    /**
     * Função auxiliar para validar se o alvo pode ser iterado.
     */
    private validarSeAlvoEIteravel;
    declaracaoSe(): Promise<Se>;
    declaracaoSustar(): Sustar;
    protected resolverDecoradores(): Promise<void>;
    declaracaoComentario(): Comentario;
    declaracaoContinua(): Continua;
    declaracaoRetorna(): Promise<Retorna>;
    construtoImportar(): Promise<ImportarComoConstruto>;
    declaracaoImportar(): Promise<Importar>;
    declaracaoImportarDe(): Promise<Importar>;
    declaracaoTente(): Promise<Tente>;
    declaracaoFazer(): Promise<Fazer>;
    funcao(tipo: string, construtor?: boolean): Promise<FuncaoDeclaracao>;
    logicaComumParametros(): Promise<Array<Partial<ParametroInterface>>>;
    /**
     * Resolve uma lista de compreensão.
     * @param retornoExpressao A expressão já resolvida que representa o valor a ser retornado.
     * @returns {ListaCompreensao} A lista de compreensão resolvida.
     */
    protected resolverCompreensaoDeLista(retornoExpressao: ConstrutoInterface): Promise<ListaCompreensao>;
    protected verificarDefinicaoTipoAtual(): string;
    declaracaoTextoDeDocumentacao(): TextoDocumentacao | undefined;
    corpoDaFuncao(tipo: string): Promise<FuncaoConstruto>;
    private resolverDecoradorDeAcesso;
    private resolverPropriedadeDeClasse;
    private resolverMetodoOuConstrutor;
    protected resolverMembroDeClasse(metodos: any[], propriedadesDeClasse: PropriedadeClasse[]): Promise<void>;
    declaracaoDeClasse(): Promise<Classe>;
    declaracaoFalhar(): Falhar;
    /**
     * Verifica se há pontos e vírgula no final de sentenças.
     * Em Pituguês, ; só é permitido para separar múltiplos comandos na mesma linha,
     * mas não no final de uma sentença/linha.
     */
    private verificarPontosEVirgulasInvalidos;
    /**
     * Encontra o próximo símbolo que não seja comentário.
     * Isso é importante porque comentários não afetam a validade do ponto e vírgula.
     */
    private encontrarProximoSimboloNaoComentario;
    /**
     * Consome o símbolo atual, verificando se é uma declaração de função, variável, classe
     * ou uma expressão.
     * @returns Objeto do tipo `Declaracao`.
     */
    resolverDeclaracaoForaDeBloco(): Promise<Declaracao | Declaracao[]>;
    resolverDeclaracao(): Promise<Declaracao | Declaracao[]>;
    /**
     * 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: RetornoLexadorInterface<SimboloInterface>, hashArquivo: number): Promise<RetornoAvaliadorSintaticoInterface<Declaracao>>;
}
//# sourceMappingURL=avaliador-sintatico-pitugues.d.ts.map