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

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

import { AcessoMetodoOuPropriedade, ArgumentoReferenciaFuncao, AjudaComoConstruto, Atribuir, Chamada, Construto, FormatacaoEscrita, Literal, ReferenciaFuncao, TipoDe, Variavel } from '../construtos';
import { Ajuda, Classe, Const, Declaracao, Enquanto, Escolha, Escreva, Expressao, Fazer, Falhar, FuncaoDeclaracao, Para, ParaCada, Retorna, Se, Var } from '../declaracoes';
import { ParametroInterface, SimboloInterface } from '../interfaces';
import { DiagnosticoAnalisadorSemantico } from '../interfaces/erros';
import { RetornoAnalisadorSemantico } from '../interfaces/retornos/retorno-analisador-semantico';
import { RetornoQuebra } from '../quebras';
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;
    };
    classesDeclararadas: Set<string>;
    classesRegistradas: Map<string, Classe>;
    classeAtualEmAnalise: Classe | null;
    atual: number;
    diagnosticos: DiagnosticoAnalisadorSemantico[];
    constructor();
    verificarTipoAtribuido(declaracao: Var | Const): void;
    visitarExpressaoTipoDe(expressao: TipoDe): Promise<any>;
    private verificarTipoDe;
    visitarExpressaoFalhar(expressao: Falhar): Promise<any>;
    private verificarFalhar;
    protected comparacaoArgumentosContraParametrosFuncao(simboloFuncao: SimboloInterface, parametros: ParametroInterface[], argumentos: Construto[]): void;
    visitarChamadaPorArgumentoReferenciaFuncao(argumentoReferenciaFuncao: ArgumentoReferenciaFuncao, argumentos: Construto[]): void;
    visitarChamadaPorReferenciaFuncao(referenciaFuncao: ReferenciaFuncao, argumentos: Construto[]): void;
    visitarChamadaPorVariavel(entidadeChamadaVariavel: Variavel, argumentos: Construto[]): Promise<void>;
    visitarExpressaoDeChamada(expressao: Chamada): Promise<void>;
    visitarExpressaoDeAtribuicao(expressao: Atribuir): Promise<void>;
    visitarDeclaracaoDeExpressao(declaracao: Expressao): 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
     */
    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 | Construto): Promise<any>;
    protected obterTipoExpressao(expressao: Construto): 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<RetornoAnalisadorSemantico>;
}
//# sourceMappingURL=analisador-semantico.d.ts.map