@designliquido/potigol 0.0.0 → 0.0.2

package/avaliador-sintatico/avaliador-sintatico-potigol.js

@@ -1,709 +1,726 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AvaliadorSintaticoPotigol = void 0;
-const construtos_1 = require("@designliquido/delegua/construtos");
-const declaracoes_1 = require("@designliquido/delegua/declaracoes");
-const avaliador_sintatico_base_1 = require("@designliquido/delegua/avaliador-sintatico/avaliador-sintatico-base");
-const lexador_1 = require("@designliquido/delegua/lexador");
-const erro_avaliador_sintatico_1 = require("@designliquido/delegua/avaliador-sintatico/erro-avaliador-sintatico");
-const potigol_1 = __importDefault(require("@designliquido/delegua/tipos-de-simbolos/potigol"));
-const tuplas_1 = require("@designliquido/delegua/construtos/tuplas");
-const micro_avaliador_sintatico_potigol_1 = require("./micro-avaliador-sintatico-potigol");
-/**
- * TODO: Pensar numa forma de avaliar múltiplas constantes sem
- * transformar o retorno de `primario()` em um vetor.
- */
-class AvaliadorSintaticoPotigol extends avaliador_sintatico_base_1.AvaliadorSintaticoBase {
-    constructor() {
-        super(...arguments);
-        this.tiposPotigolParaDelegua = {
-            Caractere: 'texto',
-            Inteiro: 'numero',
-            Logico: 'lógico',
-            Lógico: 'lógico',
-            Real: 'numero',
-            Texto: 'texto',
-            undefined: undefined,
-        };
-    }
-    /**
-     * Testa se o primeiro parâmetro na lista de símbolos
-     * pertence a uma declaração ou não.
-     * @param simbolos Os símbolos que fazem parte da lista de argumentos
-     * de uma chamada ou declaração de função.
-     * @returns `true` se parâmetros são de declaração. `false` caso contrário.
-     */
-    testePrimeiroParametro(simbolos) {
-        let atual = 0;
-        // Primeiro teste: literal ou identificador
-        if ([potigol_1.default.INTEIRO, potigol_1.default.LOGICO, potigol_1.default.REAL, potigol_1.default.TEXTO].includes(simbolos[atual].tipo)) {
-            return false;
-        }
-        // Segundo teste: vírgula imediatamente após identificador,
-        // ou simplesmente fim da lista de símbolos.
-        atual++;
-        if (atual === simbolos.length || simbolos[atual].tipo === potigol_1.default.VIRGULA) {
-            return false;
-        }
-        // Outros casos: dois-pontos após identificador, etc.
-        return true;
-    }
-    /**
-     * Retorna uma declaração de função iniciada por igual,
-     * ou seja, com apenas uma instrução.
-     * @param simboloPrimario O símbolo que identifica a função (nome).
-     * @param parenteseEsquerdo O parêntese esquerdo, usado para fins de pragma.
-     * @param parametros A lista de parâmetros da função.
-     * @param tipoRetorno O tipo de retorno da função.
-     * @returns Um construto do tipo `FuncaoDeclaracao`.
-     */
-    declaracaoFuncaoPotigolIniciadaPorIgual(simboloPrimario, parenteseEsquerdo, parametros, tipoRetorno) {
-        const corpo = new construtos_1.FuncaoConstruto(simboloPrimario.hashArquivo, simboloPrimario.linha, parametros, [
-            new declaracoes_1.Expressao(this.expressao()),
-        ]);
-        return new declaracoes_1.FuncaoDeclaracao(simboloPrimario, corpo, tipoRetorno);
-    }
-    /**
-     * Retorna uma declaração de função terminada por fim,
-     * ou seja, com mais de uma instrução.
-     * @param simboloPrimario O símbolo que identifica a função (nome).
-     * @param parenteseEsquerdo O parêntese esquerdo, usado para fins de pragma.
-     * @param parametros A lista de parâmetros da função.
-     * @param tipoRetorno O tipo de retorno da função.
-     * @returns Um construto do tipo `FuncaoDeclaracao`.
-     */
-    declaracaoFuncaoPotigolTerminadaPorFim(simboloPrimario, parenteseEsquerdo, parametros, tipoRetorno) {
-        const corpo = this.corpoDaFuncao(simboloPrimario.lexema, parenteseEsquerdo, parametros);
-        return new declaracoes_1.FuncaoDeclaracao(simboloPrimario, corpo, tipoRetorno);
-    }
-    corpoDaFuncao(nomeFuncao, simboloPragma, parametros) {
-        // this.consumir(tiposDeSimbolos.IGUAL, `Esperado '=' antes do escopo da função ${nomeFuncao}.`);
-        const corpo = this.blocoEscopo();
-        return new construtos_1.FuncaoConstruto(this.hashArquivo, Number(simboloPragma.linha), parametros, corpo);
-    }
-    declaracaoDeFuncaoOuMetodo(construtoPrimario) {
-        // O parêntese esquerdo é considerado o símbolo inicial para
-        // fins de pragma.
-        const parenteseEsquerdo = this.avancarEDevolverAnterior();
-        const simbolosEntreParenteses = [];
-        while (!this.verificarTipoSimboloAtual(potigol_1.default.PARENTESE_DIREITO)) {
-            simbolosEntreParenteses.push(this.avancarEDevolverAnterior());
-        }
-        const resolucaoParametros = this.logicaComumParametrosPotigol(simbolosEntreParenteses);
-        const parenteseDireito = this.consumir(potigol_1.default.PARENTESE_DIREITO, "Esperado ')' após parâmetros.");
-        // Pode haver uma dica do tipo de retorno ou não.
-        // Se houver, é uma declaração de função (verificado mais abaixo).
-        let tipoRetorno = undefined;
-        if (this.verificarSeSimboloAtualEIgualA(potigol_1.default.DOIS_PONTOS)) {
-            this.verificacaoTipo(this.simbolos[this.atual], 'Esperado tipo válido após dois-pontos como retorno de função.');
-            tipoRetorno = this.simbolos[this.atual - 1];
-        }
-        // Se houver símbolo de igual, seja após fechamento de parênteses,
-        // seja após a dica de retorno, é uma declaração de função.
-        if (this.simbolos[this.atual].tipo === potigol_1.default.IGUAL) {
-            this.avancarEDevolverAnterior();
-            this.declaracoesAnteriores[construtoPrimario.simbolo.lexema] = [];
-            return this.declaracaoFuncaoPotigolIniciadaPorIgual(construtoPrimario.simbolo, parenteseEsquerdo, resolucaoParametros.parametros, tipoRetorno);
-        }
-        return this.declaracaoFuncaoPotigolTerminadaPorFim(construtoPrimario.simbolo, parenteseEsquerdo, resolucaoParametros.parametros, tipoRetorno);
-    }
-    finalizarChamada(entidadeChamada) {
-        // Parêntese esquerdo
-        // this.avancarEDevolverAnterior();
-        const simbolosEntreParenteses = [];
-        while (!this.verificarTipoSimboloAtual(potigol_1.default.PARENTESE_DIREITO)) {
-            simbolosEntreParenteses.push(this.avancarEDevolverAnterior());
-        }
-        const parenteseDireito = this.consumir(potigol_1.default.PARENTESE_DIREITO, "Esperado ')' após parâmetros.");
-        const argumentos = this.microAvaliadorSintatico.analisar({ simbolos: simbolosEntreParenteses }, entidadeChamada.linha);
-        return new construtos_1.Chamada(this.hashArquivo, entidadeChamada, parenteseDireito, argumentos.declaracoes.filter((d) => d));
-    }
-    /**
-     * Verificação comum de tipos.
-     * Avança o símbolo se não houver erros.
-     * @param simbolo O símbolo sendo analisado.
-     * @param mensagemErro A mensagem de erro caso o símbolo atual não seja de tipo.
-     */
-    verificacaoTipo(simbolo, mensagemErro) {
-        if (![potigol_1.default.INTEIRO, potigol_1.default.LOGICO, potigol_1.default.REAL, potigol_1.default.TEXTO].includes(simbolo.tipo)) {
-            throw this.erro(simbolo, mensagemErro);
-        }
-    }
-    logicaComumParametrosPotigol(simbolos) {
-        const parametros = [];
-        let indice = 0;
-        let tipagemDefinida = false;
-        while (indice < simbolos.length) {
-            if (parametros.length >= 255) {
-                this.erro(simbolos[indice], 'Não pode haver mais de 255 parâmetros');
-            }
-            const parametro = {};
-            // TODO: verificar se Potigol trabalha com número variável de parâmetros.
-            /* if (this.simbolos[this.atual].tipo === tiposDeSimbolos.MULTIPLICACAO) {
-                this.consumir(tiposDeSimbolos.MULTIPLICACAO, null);
-                parametro.abrangencia = 'multiplo';
-            } else {
-                parametro.abrangencia = 'padrao';
-            } */
-            parametro.abrangencia = 'padrao';
-            if (simbolos[indice].tipo !== potigol_1.default.IDENTIFICADOR) {
-                throw this.erro(simbolos[indice], 'Esperado nome do parâmetro.');
-            }
-            parametro.nome = simbolos[indice];
-            indice++;
-            if (simbolos[indice].tipo === potigol_1.default.DOIS_PONTOS) {
-                // throw this.erro(simbolos[indice], 'Esperado dois-pontos após nome de argumento para função.');
-                indice++;
-                this.verificacaoTipo(simbolos[indice], 'Esperado tipo do argumento após dois-pontos, em definição de função.');
-                const tipoParametro = simbolos[indice];
-                const resolucaoTipo = this.tiposPotigolParaDelegua[tipoParametro.lexema];
-                parametro.tipoDado = {
-                    nome: simbolos[indice - 2].lexema,
-                    tipo: resolucaoTipo,
-                };
-                tipagemDefinida = true;
-            }
-            // TODO: Verificar se Potigol trabalha com valores padrão em argumentos.
-            /* if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IGUAL)) {
-                parametro.valorPadrao = this.primario();
-            } */
-            parametros.push(parametro);
-            // if (parametro.abrangencia === 'multiplo') break;
-            indice++;
-            if (indice < simbolos.length && simbolos[indice].tipo !== potigol_1.default.VIRGULA) {
-                throw this.erro(simbolos[indice], 'Esperado vírgula entre parâmetros de função.');
-            }
-            indice++;
-        }
-        return {
-            parametros,
-            tipagemDefinida,
-        };
-    }
-    primario() {
-        const simboloAtual = this.simbolos[this.atual];
-        switch (simboloAtual.tipo) {
-            case potigol_1.default.PARENTESE_ESQUERDO:
-                this.avancarEDevolverAnterior();
-                const expressao = this.expressao();
-                switch (this.simbolos[this.atual].tipo) {
-                    case potigol_1.default.VIRGULA:
-                        // Tupla
-                        const argumentos = [expressao];
-                        while (this.simbolos[this.atual].tipo === potigol_1.default.VIRGULA) {
-                            this.avancarEDevolverAnterior();
-                            argumentos.push(this.expressao());
-                        }
-                        this.consumir(potigol_1.default.PARENTESE_DIREITO, "Esperado ')' após a expressão.");
-                        return new tuplas_1.SeletorTuplas(...argumentos);
-                    default:
-                        this.consumir(potigol_1.default.PARENTESE_DIREITO, "Esperado ')' após a expressão.");
-                        return new construtos_1.Agrupamento(this.hashArquivo, Number(simboloAtual.linha), expressao);
-                }
-            case potigol_1.default.COLCHETE_ESQUERDO:
-                this.avancarEDevolverAnterior();
-                let valores = [];
-                if (this.verificarSeSimboloAtualEIgualA(potigol_1.default.COLCHETE_DIREITO)) {
-                    return new construtos_1.Vetor(this.hashArquivo, Number(simboloAtual.linha), []);
-                }
-                while (!this.verificarSeSimboloAtualEIgualA(potigol_1.default.COLCHETE_DIREITO)) {
-                    const valor = this.atribuir();
-                    valores.push(valor);
-                    if (this.simbolos[this.atual].tipo !== potigol_1.default.COLCHETE_DIREITO) {
-                        this.consumir(potigol_1.default.VIRGULA, 'Esperado vírgula antes da próxima expressão.');
-                    }
-                }
-                return new construtos_1.Vetor(this.hashArquivo, Number(simboloAtual.linha), valores);
-            case potigol_1.default.CARACTERE:
-            case potigol_1.default.INTEIRO:
-            case potigol_1.default.LOGICO:
-            case potigol_1.default.REAL:
-            case potigol_1.default.TEXTO:
-                const simboloLiteral = this.avancarEDevolverAnterior();
-                return new construtos_1.Literal(this.hashArquivo, Number(simboloLiteral.linha), simboloLiteral.literal);
-            case potigol_1.default.FALSO:
-            case potigol_1.default.VERDADEIRO:
-                const simboloVerdadeiroFalso = this.avancarEDevolverAnterior();
-                return new construtos_1.Literal(this.hashArquivo, Number(simboloVerdadeiroFalso.linha), simboloVerdadeiroFalso.tipo === potigol_1.default.VERDADEIRO);
-            case potigol_1.default.LEIA_INTEIRO:
-            case potigol_1.default.LEIA_REAL:
-            case potigol_1.default.LEIA_TEXTO:
-                const simboloLeia = this.avancarEDevolverAnterior();
-                return new declaracoes_1.Leia(simboloLeia, []);
-            case potigol_1.default.LEIA_INTEIROS:
-            case potigol_1.default.LEIA_REAIS:
-            case potigol_1.default.LEIA_TEXTOS:
-                const simboloLeiaDefinido = this.avancarEDevolverAnterior();
-                this.consumir(potigol_1.default.PARENTESE_ESQUERDO, `Esperado parêntese esquerdo após ${simboloLeiaDefinido.lexema}.`);
-                const argumento = this.expressao();
-                this.consumir(potigol_1.default.PARENTESE_DIREITO, `Esperado parêntese direito após número de parâmetros em chamada de ${simboloLeiaDefinido.lexema}.`);
-                const leiaDefinido = new declaracoes_1.LeiaMultiplo(simboloLeiaDefinido, argumento);
-                return leiaDefinido;
-            default:
-                const simboloIdentificador = this.avancarEDevolverAnterior();
-                return new construtos_1.ConstanteOuVariavel(this.hashArquivo, simboloIdentificador);
-        }
-    }
-    /**
-     * Em Potigol, só é possível determinar a diferença entre uma chamada e uma
-     * declaração de função depois dos argumentos.
-     *
-     * Chamadas não aceitam dicas de tipos de parâmetros.
-     * @returns Um construto do tipo `AcessoMetodo`, `AcessoIndiceVariavel` ou `Constante`,
-     * dependendo dos símbolos encontrados.
-     */
-    chamar() {
-        let expressao = this.primario();
-        while (true) {
-            if (this.verificarSeSimboloAtualEIgualA(potigol_1.default.PARENTESE_ESQUERDO)) {
-                if (expressao instanceof construtos_1.ConstanteOuVariavel) {
-                    expressao = new construtos_1.Constante(expressao.hashArquivo, expressao.simbolo);
-                }
-                expressao = this.finalizarChamada(expressao);
-            }
-            else if (this.verificarSeSimboloAtualEIgualA(potigol_1.default.PONTO)) {
-                if (this.verificarTipoSimboloAtual(potigol_1.default.QUAL_TIPO)) {
-                    const identificador = this.simbolos[this.atual - 2];
-                    const simbolo = this.simbolos[this.atual];
-                    const valor = expressao ? expressao : identificador.lexema;
-                    this.avancarEDevolverAnterior();
-                    return new construtos_1.QualTipo(this.hashArquivo, simbolo, valor);
-                }
-                else {
-                    const nome = this.consumir(potigol_1.default.IDENTIFICADOR, "Esperado nome do método após '.'.");
-                    const variavelMetodo = new construtos_1.Variavel(expressao.hashArquivo, expressao.simbolo);
-                    expressao = new construtos_1.AcessoMetodoOuPropriedade(this.hashArquivo, variavelMetodo, nome);
-                }
-            }
-            else if (this.verificarSeSimboloAtualEIgualA(potigol_1.default.COLCHETE_ESQUERDO)) {
-                const indice = this.expressao();
-                const simboloFechamento = this.consumir(potigol_1.default.COLCHETE_DIREITO, "Esperado ']' após escrita do indice.");
-                const variavelVetor = new construtos_1.Variavel(expressao.hashArquivo, expressao.simbolo);
-                expressao = new construtos_1.AcessoIndiceVariavel(this.hashArquivo, variavelVetor, indice, simboloFechamento);
-            }
-            else {
-                if (expressao instanceof construtos_1.ConstanteOuVariavel) {
-                    expressao = new construtos_1.Constante(expressao.hashArquivo, expressao.simbolo);
-                }
-                break;
-            }
-        }
-        return expressao;
-    }
-    comparacaoIgualdade() {
-        let expressao = this.comparar();
-        while (this.verificarSeSimboloAtualEIgualA(potigol_1.default.DIFERENTE, potigol_1.default.IGUAL_IGUAL)) {
-            const operador = this.simbolos[this.atual - 1];
-            const direito = this.comparar();
-            expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
-        }
-        return expressao;
-    }
-    declaracaoEscreva() {
-        const simboloAtual = this.avancarEDevolverAnterior();
-        const argumentos = [];
-        this.verificarSeSimboloAtualEIgualA(potigol_1.default.PARENTESE_ESQUERDO);
-        do {
-            argumentos.push(this.ou());
-        } while (this.verificarSeSimboloAtualEIgualA(potigol_1.default.VIRGULA));
-        this.verificarSeSimboloAtualEIgualA(potigol_1.default.PARENTESE_DIREITO);
-        return new declaracoes_1.Escreva(Number(simboloAtual.linha), simboloAtual.hashArquivo, argumentos);
-    }
-    declaracaoImprima() {
-        const simboloAtual = this.avancarEDevolverAnterior();
-        const argumentos = [];
-        do {
-            argumentos.push(this.expressao());
-        } while (this.verificarSeSimboloAtualEIgualA(potigol_1.default.VIRGULA));
-        return new declaracoes_1.EscrevaMesmaLinha(Number(simboloAtual.linha), simboloAtual.hashArquivo, argumentos);
-    }
-    /**
-     * Blocos de escopo em Potigol existem quando:
-     *
-     * - Em uma declaração de função ou método, após fecha parênteses, o próximo
-     * símbolo obrigatório não é `=` e há pelo menos um `fim` até o final do código;
-     * - Em uma declaração `se`;
-     * - Em uma declaração `enquanto`;
-     * - Em uma declaração `para`.
-     * @returns Um vetor de `Declaracao`.
-     */
-    blocoEscopo() {
-        let declaracoes = [];
-        while (!this.estaNoFinal() && !this.verificarTipoSimboloAtual(potigol_1.default.FIM)) {
-            const retornoDeclaracao = this.resolverDeclaracaoForaDeBloco();
-            if (Array.isArray(retornoDeclaracao)) {
-                declaracoes = declaracoes.concat(retornoDeclaracao);
-            }
-            else {
-                declaracoes.push(retornoDeclaracao);
-            }
-        }
-        return declaracoes;
-    }
-    declaracaoSe() {
-        const simboloSe = this.avancarEDevolverAnterior();
-        const condicao = this.expressao();
-        this.consumir(potigol_1.default.ENTAO, "Esperado palavra reservada 'entao' após condição em declaração 'se'.");
-        const declaracoes = [];
-        do {
-            declaracoes.push(this.resolverDeclaracaoForaDeBloco());
-        } while (![potigol_1.default.SENAO, potigol_1.default.FIM].includes(this.simbolos[this.atual].tipo));
-        let caminhoSenao = null;
-        if (this.verificarSeSimboloAtualEIgualA(potigol_1.default.SENAO)) {
-            const simboloSenao = this.simbolos[this.atual - 1];
-            const declaracoesSenao = [];
-            do {
-                declaracoesSenao.push(this.resolverDeclaracaoForaDeBloco());
-            } while (![potigol_1.default.FIM].includes(this.simbolos[this.atual].tipo));
-            caminhoSenao = new declaracoes_1.Bloco(this.hashArquivo, Number(simboloSenao.linha), declaracoesSenao.filter((d) => d));
-        }
-        this.consumir(potigol_1.default.FIM, "Esperado palavra-chave 'fim' para fechamento de declaração 'se'.");
-        return new declaracoes_1.Se(condicao, new declaracoes_1.Bloco(this.hashArquivo, Number(simboloSe.linha), declaracoes.filter((d) => d)), [], caminhoSenao);
-    }
-    declaracaoEnquanto() {
-        const simboloAtual = this.avancarEDevolverAnterior();
-        const condicao = this.expressao();
-        this.consumir(potigol_1.default.FACA, "Esperado paravra reservada 'faca' após condição de continuidade em declaracão 'enquanto'.");
-        const declaracoes = [];
-        do {
-            declaracoes.push(this.resolverDeclaracaoForaDeBloco());
-        } while (![potigol_1.default.FIM].includes(this.simbolos[this.atual].tipo));
-        this.consumir(potigol_1.default.FIM, "Esperado palavra-chave 'fim' para fechamento de declaração 'enquanto'.");
-        return new declaracoes_1.Enquanto(condicao, new declaracoes_1.Bloco(simboloAtual.hashArquivo, Number(simboloAtual.linha), declaracoes.filter((d) => d)));
-    }
-    declaracaoPara() {
-        const simboloPara = this.avancarEDevolverAnterior();
-        const variavelIteracao = this.consumir(potigol_1.default.IDENTIFICADOR, "Esperado identificador de variável após 'para'.");
-        this.consumir(potigol_1.default.DE, "Esperado palavra reservada 'de' após variável de controle de 'para'.");
-        const literalOuVariavelInicio = this.adicaoOuSubtracao();
-        this.consumir(potigol_1.default.ATE, "Esperado palavra reservada 'ate' após valor inicial do laço de repetição 'para'.");
-        const literalOuVariavelFim = this.adicaoOuSubtracao();
-        let operadorCondicao = new lexador_1.Simbolo(potigol_1.default.MENOR_IGUAL, '', '', Number(simboloPara.linha), this.hashArquivo);
-        let operadorCondicaoIncremento = new lexador_1.Simbolo(potigol_1.default.MENOR, '', '', Number(simboloPara.linha), this.hashArquivo);
-        // Isso existe porque o laço `para` do Potigol pode ter o passo positivo ou negativo
-        // dependendo dos operandos de início e fim, que só são possíveis de determinar
-        // em tempo de execução.
-        // Quando um dos operandos é uma variável, tanto a condição do laço quanto o
-        // passo são considerados indefinidos aqui.
-        let passo;
-        let resolverIncrementoEmExecucao = false;
-        if (this.verificarSeSimboloAtualEIgualA(potigol_1.default.PASSO)) {
-            passo = this.unario();
-        }
-        else {
-            if (literalOuVariavelInicio instanceof construtos_1.Literal && literalOuVariavelFim instanceof construtos_1.Literal) {
-                if (literalOuVariavelInicio.valor > literalOuVariavelFim.valor) {
-                    passo = new construtos_1.Unario(this.hashArquivo, new lexador_1.Simbolo(potigol_1.default.SUBTRACAO, '-', undefined, simboloPara.linha, simboloPara.hashArquivo), new construtos_1.Literal(this.hashArquivo, Number(simboloPara.linha), 1), 'ANTES');
-                    operadorCondicao = new lexador_1.Simbolo(potigol_1.default.MAIOR_IGUAL, '', '', Number(simboloPara.linha), this.hashArquivo);
-                    operadorCondicaoIncremento = new lexador_1.Simbolo(potigol_1.default.MAIOR, '', '', Number(simboloPara.linha), this.hashArquivo);
-                }
-                else {
-                    passo = new construtos_1.Literal(this.hashArquivo, Number(simboloPara.linha), 1);
-                }
-            }
-            else {
-                // Passo e operador de condição precisam ser resolvidos em tempo de execução.
-                passo = undefined;
-                operadorCondicao = undefined;
-                operadorCondicaoIncremento = undefined;
-                resolverIncrementoEmExecucao = true;
-            }
-        }
-        this.consumir(potigol_1.default.FACA, "Esperado palavra reservada 'faca' após valor final do laço de repetição 'para'.");
-        const declaracoesBlocoPara = [];
-        let simboloAtualBlocoPara = this.simbolos[this.atual];
-        while (simboloAtualBlocoPara.tipo !== potigol_1.default.FIM) {
-            declaracoesBlocoPara.push(this.resolverDeclaracaoForaDeBloco());
-            simboloAtualBlocoPara = this.simbolos[this.atual];
-        }
-        this.consumir(potigol_1.default.FIM, '');
-        const corpo = new declaracoes_1.Bloco(this.hashArquivo, Number(simboloPara.linha) + 1, declaracoesBlocoPara.filter((d) => d));
-        const para = new declaracoes_1.Para(this.hashArquivo, Number(simboloPara.linha), new construtos_1.Atribuir(this.hashArquivo, variavelIteracao, literalOuVariavelInicio), new construtos_1.Binario(this.hashArquivo, new construtos_1.Variavel(this.hashArquivo, variavelIteracao), operadorCondicao, literalOuVariavelFim), new construtos_1.FimPara(this.hashArquivo, Number(simboloPara.linha), new construtos_1.Binario(this.hashArquivo, new construtos_1.Variavel(this.hashArquivo, variavelIteracao), operadorCondicaoIncremento, literalOuVariavelFim), new declaracoes_1.Expressao(new construtos_1.Atribuir(this.hashArquivo, variavelIteracao, new construtos_1.Binario(this.hashArquivo, new construtos_1.Variavel(this.hashArquivo, variavelIteracao), new lexador_1.Simbolo(potigol_1.default.ADICAO, '', null, Number(simboloPara.linha), this.hashArquivo), passo)))), corpo);
-        para.blocoPosExecucao = corpo;
-        para.resolverIncrementoEmExecucao = resolverIncrementoEmExecucao;
-        return para;
-    }
-    declaracaoEscolha() {
-        this.avancarEDevolverAnterior();
-        const condicao = this.expressao();
-        const caminhos = [];
-        let caminhoPadrao = null;
-        while (!this.verificarSeSimboloAtualEIgualA(potigol_1.default.FIM)) {
-            this.consumir(potigol_1.default.CASO, "Esperado palavra reservada 'caso' após condição de 'escolha'.");
-            if (this.verificarSeSimboloAtualEIgualA(potigol_1.default.TRACO_BAIXO)) {
-                // Caso padrão
-                if (caminhoPadrao !== null) {
-                    const excecao = new erro_avaliador_sintatico_1.ErroAvaliadorSintatico(this.simbolos[this.atual], "Você só pode ter um caminho padrão em cada declaração de 'escolha'.");
-                    this.erros.push(excecao);
-                    throw excecao;
-                }
-                this.consumir(potigol_1.default.SETA, "Esperado '=>' após palavra reservada 'caso'.");
-                const declaracoesPadrao = [this.resolverDeclaracaoForaDeBloco()];
-                // TODO: Verificar se Potigol admite bloco de escopo para `escolha`.
-                /* const declaracoesPadrao = [];
-                do {
-                    declaracoesPadrao.push(this.declaracao());
-                } while (!this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CASO, tiposDeSimbolos.FIM)); */
-                caminhoPadrao = {
-                    declaracoes: declaracoesPadrao,
-                };
-                continue;
-            }
-            const caminhoCondicoes = [this.expressao()];
-            this.consumir(potigol_1.default.SETA, "Esperado '=>' após palavra reservada 'caso'.");
-            const declaracoes = [this.resolverDeclaracaoForaDeBloco()];
-            // TODO: Verificar se Potigol admite bloco de escopo para `escolha`.
-            /* const declaracoes = [];
-            do {
-                declaracoes.push(this.declaracao());
-            } while (!this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CASO, tiposDeSimbolos.FIM)); */
-            caminhos.push({
-                condicoes: caminhoCondicoes,
-                declaracoes,
-            });
-        }
-        return new declaracoes_1.Escolha(condicao, caminhos, caminhoPadrao);
-    }
-    declaracaoDeConstantes() {
-        const identificadores = [];
-        let tipo = null;
-        do {
-            identificadores.push(this.consumir(potigol_1.default.IDENTIFICADOR, 'Esperado nome da constante.'));
-        } while (this.verificarSeSimboloAtualEIgualA(potigol_1.default.VIRGULA));
-        /* if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.DOIS_PONTOS)) {
-            const tipoConstante = this.verificarDefinicaoTipoAtual();
-            if (!tipoConstante) {
-                throw this.erro(this.simboloAtual(), 'Tipo definido na constante não é válido.');
-            }
-            tipo = tipoConstante;
-            this.avancarEDevolverAnterior();
-        } */
-        this.consumir(potigol_1.default.IGUAL, "Esperado '=' após identificador em instrução 'constante'.");
-        const inicializadores = [];
-        do {
-            let inicializador = this.expressao();
-            if (inicializador instanceof declaracoes_1.Leia && identificadores.length > 1) {
-                inicializador = new declaracoes_1.LeiaMultiplo(inicializador.simbolo, new construtos_1.Literal(this.hashArquivo, Number(inicializador.simbolo.linha), identificadores.length));
-            }
-            inicializadores.push(inicializador);
-        } while (this.verificarSeSimboloAtualEIgualA(potigol_1.default.VIRGULA));
-        if (identificadores.length !== inicializadores.length) {
-            // Pode ser que a inicialização seja feita por uma das
-            // funções `leia`, que podem ler vários valores. Neste caso, não deve dar erro.
-            if (!(inicializadores.length === 1 && inicializadores[0] instanceof declaracoes_1.LeiaMultiplo)) {
-                throw this.erro(this.simbolos[this.atual], 'Quantidade de identificadores à esquerda do igual é diferente da quantidade de valores à direita.');
-            }
-            const inicializadorLeia = inicializadores[0];
-            let tipoConversao;
-            switch (inicializadorLeia.simbolo.tipo) {
-                case potigol_1.default.LEIA_INTEIROS:
-                    tipoConversao = 'inteiro[]';
-                    break;
-                case potigol_1.default.LEIA_INTEIRO:
-                    tipoConversao = 'inteiro';
-                    break;
-                case potigol_1.default.LEIA_REAL:
-                case potigol_1.default.LEIA_REAIS:
-                    tipoConversao = 'real';
-                    break;
-                default:
-                    tipoConversao = 'texto';
-                    break;
-            }
-            return new declaracoes_1.ConstMultiplo(identificadores, inicializadores[0], tipoConversao);
-        }
-        let retorno = [];
-        for (let [indice, identificador] of identificadores.entries()) {
-            // const inicializador = inicializadores[indice];
-            // this.verificarTipoAtribuido(tipo, inicializador);
-            retorno.push(new declaracoes_1.Const(identificador, inicializadores[indice], tipo));
-        }
-        // this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PONTO_E_VIRGULA);
-        return retorno;
-    }
-    declaracaoDeVariaveis() {
-        const simboloVar = this.avancarEDevolverAnterior();
-        const identificadores = [];
-        do {
-            identificadores.push(this.consumir(potigol_1.default.IDENTIFICADOR, 'Esperado nome de variável.'));
-        } while (this.verificarSeSimboloAtualEIgualA(potigol_1.default.VIRGULA));
-        this.consumir(potigol_1.default.REATRIBUIR, "Esperado ':=' após identificador em instrução 'var'.");
-        const inicializadores = [];
-        do {
-            inicializadores.push(this.expressao());
-        } while (this.verificarSeSimboloAtualEIgualA(potigol_1.default.VIRGULA));
-        if (identificadores.length !== inicializadores.length) {
-            throw this.erro(simboloVar, 'Quantidade de identificadores à esquerda do igual é diferente da quantidade de valores à direita.');
-        }
-        const retorno = [];
-        for (let [indice, identificador] of identificadores.entries()) {
-            retorno.push(new declaracoes_1.Var(identificador, inicializadores[indice]));
-        }
-        return retorno;
-    }
-    logicaAtribuicaoComDicaDeTipo(expressao) {
-        // A dica de tipo é opcional.
-        // Só que, se a avaliação entra na dica, só
-        // podemos ter uma constante apenas.
-        this.avancarEDevolverAnterior();
-        if (![
-            potigol_1.default.CARACTERE,
-            potigol_1.default.INTEIRO,
-            potigol_1.default.LOGICO,
-            potigol_1.default.REAL,
-            potigol_1.default.TEXTO,
-        ].includes(this.simbolos[this.atual].tipo)) {
-            throw this.erro(this.simbolos[this.atual], 'Esperado tipo após dois-pontos e nome de identificador.');
-        }
-        return this.avancarEDevolverAnterior();
-    }
-    declaracaoFazer() {
-        throw new Error('Método não implementado.');
-    }
-    /**
-     * Uma declaração de tipo nada mais é do que um declaração de classe.
-     * Em Potigol, classe e tipo são praticamente a mesma coisa.
-     *
-     * @returns Um construto do tipo `Classe`.
-     */
-    declaracaoTipo() {
-        const simboloTipo = this.avancarEDevolverAnterior();
-        const construto = this.primario();
-        // TODO: Verificar se Potigol trabalha com herança.
-        /* let superClasse = null;
-        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.HERDA)) {
-            this.consumir(tiposDeSimbolos.IDENTIFICADOR, 'Esperado nome da Superclasse.');
-            superClasse = new Variavel(this.hashArquivo, this.simbolos[this.atual - 1]);
-        } */
-        const metodos = [];
-        const propriedades = [];
-        while (!this.verificarTipoSimboloAtual(potigol_1.default.FIM) && !this.estaNoFinal()) {
-            const identificador = this.consumir(potigol_1.default.IDENTIFICADOR, 'Esperado nome de propriedade ou método.');
-            if (this.simbolos[this.atual].tipo === potigol_1.default.PARENTESE_ESQUERDO) {
-                // Método
-                const construtoMetodo = new construtos_1.Constante(identificador.hashArquivo, identificador);
-                metodos.push(this.declaracaoDeFuncaoOuMetodo(construtoMetodo));
-            }
-            else {
-                // Propriedade
-                this.consumir(potigol_1.default.DOIS_PONTOS, 'Esperado dois-pontos após nome de propriedade em declaração de tipo.');
-                this.verificacaoTipo(this.simbolos[this.atual], 'Esperado tipo do argumento após dois-pontos, em definição de função.');
-                const tipoPropriedade = this.avancarEDevolverAnterior();
-                propriedades.push(new declaracoes_1.PropriedadeClasse(identificador, this.tiposPotigolParaDelegua[tipoPropriedade.lexema]));
-            }
-        }
-        this.consumir(potigol_1.default.FIM, "Esperado 'fim' após o escopo do tipo.");
-        // Depois de verificadas todas as propriedades anotadas com tipo,
-        // Precisamos gerar um construtor com todas elas na ordem em que
-        // foram lidas.
-        const instrucoesConstrutor = [];
-        for (let propriedade of propriedades) {
-            instrucoesConstrutor.push(new declaracoes_1.Expressao(new construtos_1.DefinirValor(propriedade.hashArquivo, propriedade.linha, new construtos_1.Isto(propriedade.hashArquivo, propriedade.linha, new lexador_1.Simbolo(potigol_1.default.ISTO, 'isto', undefined, simboloTipo.linha, simboloTipo.hashArquivo)), propriedade.nome, new construtos_1.Variavel(propriedade.hashArquivo, propriedade.nome))));
-        }
-        const construtorConstruto = new construtos_1.FuncaoConstruto(simboloTipo.hashArquivo, simboloTipo.linha, propriedades.map((p) => ({
-            abrangencia: 'padrao',
-            nome: p.nome,
-        })), instrucoesConstrutor);
-        const construtor = new declaracoes_1.FuncaoDeclaracao(new lexador_1.Simbolo(potigol_1.default.CONSTRUTOR, 'construtor', undefined, simboloTipo.hashArquivo, simboloTipo.linha), construtorConstruto, undefined);
-        metodos.unshift(construtor);
-        return new declaracoes_1.Classe(construto.simbolo, undefined, metodos, propriedades);
-    }
-    atribuir() {
-        const expressao = this.ou();
-        if (!this.estaNoFinal() && expressao instanceof construtos_1.Constante) {
-            let tipoVariavelOuConstante;
-            // Atribuição constante.
-            if (this.simbolos[this.atual].tipo === potigol_1.default.DOIS_PONTOS) {
-                tipoVariavelOuConstante = this.logicaAtribuicaoComDicaDeTipo(expressao);
-            }
-            switch (this.simbolos[this.atual].tipo) {
-                case potigol_1.default.VIRGULA:
-                    this.atual--;
-                    return this.declaracaoDeConstantes();
-                case potigol_1.default.IGUAL:
-                    this.avancarEDevolverAnterior();
-                    const valorAtribuicao = this.ou();
-                    return new declaracoes_1.Const(expressao.simbolo, valorAtribuicao, tipoVariavelOuConstante
-                        ? this.tiposPotigolParaDelegua[tipoVariavelOuConstante.lexema]
-                        : undefined);
-            }
-        }
-        return expressao;
-    }
-    /**
-     * Em Potigol, uma definição de função normalmente começa com um
-     * identificador - que não é uma palavra reservada - seguido de parênteses.
-     * Este ponto de entrada verifica o símbolo atual e o próximo.
-     *
-     * Diferentemente dos demais dialetos, verificamos logo de cara se
-     * temos uma definição ou chamada de função, isto porque definições
-     * nunca aparecem do lado direito de uma atribuição, a não ser que
-     * estejam entre parênteses (_currying_).
-     *
-     * Se o próximo símbolo for parênteses, ou é uma definiçao de função,
-     * ou uma chamada de função.
-     */
-    expressaoOuDefinicaoFuncao() {
-        if (!this.estaNoFinal() && this.simbolos[this.atual].tipo === potigol_1.default.IDENTIFICADOR) {
-            if (this.atual + 1 < this.simbolos.length) {
-                switch (this.simbolos[this.atual + 1].tipo) {
-                    case potigol_1.default.PARENTESE_ESQUERDO:
-                        const construtoPrimario = this.primario();
-                        return this.declaracaoDeFuncaoOuMetodo(construtoPrimario);
-                }
-            }
-        }
-        return this.atribuir();
-    }
-    resolverDeclaracaoForaDeBloco() {
-        const simboloAtual = this.simbolos[this.atual];
-        switch (simboloAtual.tipo) {
-            case potigol_1.default.ENQUANTO:
-                return this.declaracaoEnquanto();
-            case potigol_1.default.ESCOLHA:
-                return this.declaracaoEscolha();
-            case potigol_1.default.ESCREVA:
-                return this.declaracaoEscreva();
-            case potigol_1.default.IMPRIMA:
-                return this.declaracaoImprima();
-            case potigol_1.default.PARA:
-                return this.declaracaoPara();
-            case potigol_1.default.SE:
-                return this.declaracaoSe();
-            case potigol_1.default.TIPO:
-                return this.declaracaoTipo();
-            case potigol_1.default.VARIAVEL:
-                return this.declaracaoDeVariaveis();
-            default:
-                return this.expressaoOuDefinicaoFuncao();
-        }
-    }
-    analisar(retornoLexador, hashArquivo) {
-        this.microAvaliadorSintatico = new micro_avaliador_sintatico_potigol_1.MicroAvaliadorSintaticoPotigol(hashArquivo);
-        this.erros = [];
-        this.atual = 0;
-        this.blocos = 0;
-        this.declaracoesAnteriores = {};
-        this.hashArquivo = hashArquivo || 0;
-        this.simbolos = (retornoLexador === null || retornoLexador === void 0 ? void 0 : retornoLexador.simbolos) || [];
-        let declaracoes = [];
-        while (!this.estaNoFinal()) {
-            const retornoDeclaracao = this.resolverDeclaracaoForaDeBloco();
-            if (Array.isArray(retornoDeclaracao)) {
-                declaracoes = declaracoes.concat(retornoDeclaracao);
-            }
-            else {
-                declaracoes.push(retornoDeclaracao);
-            }
-        }
-        return {
-            declaracoes: declaracoes,
-            erros: this.erros,
-        };
-    }
-}
-exports.AvaliadorSintaticoPotigol = AvaliadorSintaticoPotigol;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvaliadorSintaticoPotigol = void 0;
+const construtos_1 = require("@designliquido/delegua/construtos");
+const declaracoes_1 = require("@designliquido/delegua/declaracoes");
+const avaliador_sintatico_base_1 = require("@designliquido/delegua/avaliador-sintatico/avaliador-sintatico-base");
+const lexador_1 = require("@designliquido/delegua/lexador");
+const erro_avaliador_sintatico_1 = require("@designliquido/delegua/avaliador-sintatico/erro-avaliador-sintatico");
+const tuplas_1 = require("@designliquido/delegua/construtos/tuplas");
+const micro_avaliador_sintatico_potigol_1 = require("./micro-avaliador-sintatico-potigol");
+const lexico_regular_1 = __importDefault(require("../tipos-de-simbolos/lexico-regular"));
+/**
+ * TODO: Pensar numa forma de avaliar múltiplas constantes sem
+ * transformar o retorno de `primario()` em um vetor.
+ */
+class AvaliadorSintaticoPotigol extends avaliador_sintatico_base_1.AvaliadorSintaticoBase {
+    constructor() {
+        super();
+        this.tiposPotigolParaDelegua = {
+            Caractere: 'texto',
+            Inteiro: 'numero',
+            Logico: 'lógico',
+            Lógico: 'lógico',
+            Real: 'numero',
+            Texto: 'texto',
+            undefined: undefined,
+        };
+        this.declaracoes = [];
+    }
+    /**
+     * Testa se o primeiro parâmetro na lista de símbolos
+     * pertence a uma declaração ou não.
+     * @param simbolos Os símbolos que fazem parte da lista de argumentos
+     * de uma chamada ou declaração de função.
+     * @returns `true` se parâmetros são de declaração. `false` caso contrário.
+     */
+    testePrimeiroParametro(simbolos) {
+        let atual = 0;
+        // Primeiro teste: literal ou identificador
+        if ([lexico_regular_1.default.INTEIRO, lexico_regular_1.default.LOGICO, lexico_regular_1.default.REAL, lexico_regular_1.default.TEXTO].includes(simbolos[atual].tipo)) {
+            return false;
+        }
+        // Segundo teste: vírgula imediatamente após identificador,
+        // ou simplesmente fim da lista de símbolos.
+        atual++;
+        if (atual === simbolos.length || simbolos[atual].tipo === lexico_regular_1.default.VIRGULA) {
+            return false;
+        }
+        // Outros casos: dois-pontos após identificador, etc.
+        return true;
+    }
+    /**
+     * Retorna uma declaração de função iniciada por igual,
+     * ou seja, com apenas uma instrução.
+     * @param simboloPrimario O símbolo que identifica a função (nome).
+     * @param parenteseEsquerdo O parêntese esquerdo, usado para fins de pragma.
+     * @param parametros A lista de parâmetros da função.
+     * @param tipoRetorno O tipo de retorno da função.
+     * @returns Um construto do tipo `FuncaoDeclaracao`.
+     */
+    declaracaoFuncaoPotigolIniciadaPorIgual(simboloPrimario, parenteseEsquerdo, parametros, tipoRetorno) {
+        const corpo = new construtos_1.FuncaoConstruto(simboloPrimario.hashArquivo, simboloPrimario.linha, parametros, [
+            new declaracoes_1.Expressao(this.expressao()),
+        ]);
+        return new declaracoes_1.FuncaoDeclaracao(simboloPrimario, corpo, tipoRetorno);
+    }
+    /**
+     * Retorna uma declaração de função terminada por fim,
+     * ou seja, com mais de uma instrução.
+     * @param simboloPrimario O símbolo que identifica a função (nome).
+     * @param parenteseEsquerdo O parêntese esquerdo, usado para fins de pragma.
+     * @param parametros A lista de parâmetros da função.
+     * @param tipoRetorno O tipo de retorno da função.
+     * @returns Um construto do tipo `FuncaoDeclaracao`.
+     */
+    declaracaoFuncaoPotigolTerminadaPorFim(simboloPrimario, parenteseEsquerdo, parametros, tipoRetorno) {
+        const corpo = this.corpoDaFuncao(simboloPrimario.lexema, parenteseEsquerdo, parametros);
+        return new declaracoes_1.FuncaoDeclaracao(simboloPrimario, corpo, tipoRetorno);
+    }
+    corpoDaFuncao(nomeFuncao, simboloPragma, parametros) {
+        // this.consumir(tiposDeSimbolos.IGUAL, `Esperado '=' antes do escopo da função ${nomeFuncao}.`);
+        const corpo = this.blocoEscopo();
+        return new construtos_1.FuncaoConstruto(this.hashArquivo, Number(simboloPragma.linha), parametros, corpo);
+    }
+    declaracaoDeFuncaoOuMetodo(construtoPrimario) {
+        // O parêntese esquerdo é considerado o símbolo inicial para
+        // fins de pragma.
+        const parenteseEsquerdo = this.avancarEDevolverAnterior();
+        const simbolosEntreParenteses = [];
+        while (!this.verificarTipoSimboloAtual(lexico_regular_1.default.PARENTESE_DIREITO)) {
+            simbolosEntreParenteses.push(this.avancarEDevolverAnterior());
+        }
+        const resolucaoParametros = this.logicaComumParametrosPotigol(simbolosEntreParenteses);
+        const parenteseDireito = this.consumir(lexico_regular_1.default.PARENTESE_DIREITO, "Esperado ')' após parâmetros.");
+        // Pode haver uma dica do tipo de retorno ou não.
+        // Se houver, é uma declaração de função (verificado mais abaixo).
+        let tipoRetorno = undefined;
+        if (this.verificarSeSimboloAtualEIgualA(lexico_regular_1.default.DOIS_PONTOS)) {
+            this.verificacaoTipo(this.simbolos[this.atual], 'Esperado tipo válido após dois-pontos como retorno de função.');
+            tipoRetorno = this.simbolos[this.atual - 1];
+        }
+        // Se houver símbolo de igual, seja após fechamento de parênteses,
+        // seja após a dica de retorno, é uma declaração de função.
+        if (this.simbolos[this.atual].tipo === lexico_regular_1.default.IGUAL) {
+            this.avancarEDevolverAnterior();
+            this.declaracoesAnteriores[construtoPrimario.simbolo.lexema] = [];
+            return this.declaracaoFuncaoPotigolIniciadaPorIgual(construtoPrimario.simbolo, parenteseEsquerdo, resolucaoParametros.parametros, tipoRetorno);
+        }
+        return this.declaracaoFuncaoPotigolTerminadaPorFim(construtoPrimario.simbolo, parenteseEsquerdo, resolucaoParametros.parametros, tipoRetorno);
+    }
+    finalizarChamada(entidadeChamada) {
+        // Parêntese esquerdo
+        // this.avancarEDevolverAnterior();
+        const simbolosEntreParenteses = [];
+        while (!this.verificarTipoSimboloAtual(lexico_regular_1.default.PARENTESE_DIREITO)) {
+            simbolosEntreParenteses.push(this.avancarEDevolverAnterior());
+        }
+        const parenteseDireito = this.consumir(lexico_regular_1.default.PARENTESE_DIREITO, "Esperado ')' após parâmetros.");
+        const argumentos = this.microAvaliadorSintatico.analisar({ simbolos: simbolosEntreParenteses }, entidadeChamada.linha);
+        return new construtos_1.Chamada(this.hashArquivo, entidadeChamada, parenteseDireito, argumentos.declaracoes.filter((d) => d));
+    }
+    /**
+     * Verificação comum de tipos.
+     * Avança o símbolo se não houver erros.
+     * @param simbolo O símbolo sendo analisado.
+     * @param mensagemErro A mensagem de erro caso o símbolo atual não seja de tipo.
+     */
+    verificacaoTipo(simbolo, mensagemErro) {
+        if (![lexico_regular_1.default.INTEIRO, lexico_regular_1.default.LOGICO, lexico_regular_1.default.REAL, lexico_regular_1.default.TEXTO].includes(simbolo.tipo)) {
+            throw this.erro(simbolo, mensagemErro);
+        }
+    }
+    logicaComumParametrosPotigol(simbolos) {
+        const parametros = [];
+        let indice = 0;
+        let tipagemDefinida = false;
+        while (indice < simbolos.length) {
+            if (parametros.length >= 255) {
+                this.erro(simbolos[indice], 'Não pode haver mais de 255 parâmetros');
+            }
+            const parametro = {};
+            // TODO: verificar se Potigol trabalha com número variável de parâmetros.
+            /* if (this.simbolos[this.atual].tipo === tiposDeSimbolos.MULTIPLICACAO) {
+                this.consumir(tiposDeSimbolos.MULTIPLICACAO, null);
+                parametro.abrangencia = 'multiplo';
+            } else {
+                parametro.abrangencia = 'padrao';
+            } */
+            parametro.abrangencia = 'padrao';
+            if (simbolos[indice].tipo !== lexico_regular_1.default.IDENTIFICADOR) {
+                throw this.erro(simbolos[indice], 'Esperado nome do parâmetro.');
+            }
+            parametro.nome = simbolos[indice];
+            indice++;
+            if (simbolos[indice].tipo === lexico_regular_1.default.DOIS_PONTOS) {
+                // throw this.erro(simbolos[indice], 'Esperado dois-pontos após nome de argumento para função.');
+                indice++;
+                this.verificacaoTipo(simbolos[indice], 'Esperado tipo do argumento após dois-pontos, em definição de função.');
+                const tipoParametro = simbolos[indice];
+                const resolucaoTipo = this.tiposPotigolParaDelegua[tipoParametro.lexema];
+                parametro.tipoDado = {
+                    nome: simbolos[indice - 2].lexema,
+                    tipo: resolucaoTipo,
+                };
+                tipagemDefinida = true;
+            }
+            // TODO: Verificar se Potigol trabalha com valores padrão em argumentos.
+            /* if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IGUAL)) {
+                parametro.valorPadrao = this.primario();
+            } */
+            parametros.push(parametro);
+            // if (parametro.abrangencia === 'multiplo') break;
+            indice++;
+            if (indice < simbolos.length && simbolos[indice].tipo !== lexico_regular_1.default.VIRGULA) {
+                throw this.erro(simbolos[indice], 'Esperado vírgula entre parâmetros de função.');
+            }
+            indice++;
+        }
+        return {
+            parametros,
+            tipagemDefinida,
+        };
+    }
+    primario() {
+        const simboloAtual = this.simbolos[this.atual];
+        switch (simboloAtual.tipo) {
+            case lexico_regular_1.default.PARENTESE_ESQUERDO:
+                this.avancarEDevolverAnterior();
+                const expressao = this.expressao();
+                switch (this.simbolos[this.atual].tipo) {
+                    case lexico_regular_1.default.VIRGULA:
+                        // Tupla
+                        const argumentos = [expressao];
+                        while (this.simbolos[this.atual].tipo === lexico_regular_1.default.VIRGULA) {
+                            this.avancarEDevolverAnterior();
+                            argumentos.push(this.expressao());
+                        }
+                        this.consumir(lexico_regular_1.default.PARENTESE_DIREITO, "Esperado ')' após a expressão.");
+                        return new tuplas_1.SeletorTuplas(...argumentos);
+                    default:
+                        this.consumir(lexico_regular_1.default.PARENTESE_DIREITO, "Esperado ')' após a expressão.");
+                        return new construtos_1.Agrupamento(this.hashArquivo, Number(simboloAtual.linha), expressao);
+                }
+            case lexico_regular_1.default.COLCHETE_ESQUERDO:
+                this.avancarEDevolverAnterior();
+                let valores = [];
+                if (this.verificarSeSimboloAtualEIgualA(lexico_regular_1.default.COLCHETE_DIREITO)) {
+                    return new construtos_1.Vetor(this.hashArquivo, Number(simboloAtual.linha), []);
+                }
+                while (!this.verificarSeSimboloAtualEIgualA(lexico_regular_1.default.COLCHETE_DIREITO)) {
+                    const valor = this.atribuir();
+                    valores.push(valor);
+                    if (this.simbolos[this.atual].tipo !== lexico_regular_1.default.COLCHETE_DIREITO) {
+                        this.consumir(lexico_regular_1.default.VIRGULA, 'Esperado vírgula antes da próxima expressão.');
+                    }
+                }
+                return new construtos_1.Vetor(this.hashArquivo, Number(simboloAtual.linha), valores);
+            case lexico_regular_1.default.CARACTERE:
+            case lexico_regular_1.default.INTEIRO:
+            case lexico_regular_1.default.LOGICO:
+            case lexico_regular_1.default.REAL:
+            case lexico_regular_1.default.TEXTO:
+                const simboloLiteral = this.avancarEDevolverAnterior();
+                return new construtos_1.Literal(this.hashArquivo, Number(simboloLiteral.linha), simboloLiteral.literal);
+            case lexico_regular_1.default.FALSO:
+            case lexico_regular_1.default.VERDADEIRO:
+                const simboloVerdadeiroFalso = this.avancarEDevolverAnterior();
+                return new construtos_1.Literal(this.hashArquivo, Number(simboloVerdadeiroFalso.linha), simboloVerdadeiroFalso.tipo === lexico_regular_1.default.VERDADEIRO);
+            case lexico_regular_1.default.LEIA_INTEIRO:
+            case lexico_regular_1.default.LEIA_REAL:
+            case lexico_regular_1.default.LEIA_TEXTO:
+                const simboloLeia = this.avancarEDevolverAnterior();
+                return new declaracoes_1.Leia(simboloLeia, []);
+            case lexico_regular_1.default.LEIA_INTEIROS:
+            case lexico_regular_1.default.LEIA_REAIS:
+            case lexico_regular_1.default.LEIA_TEXTOS:
+                const simboloLeiaDefinido = this.avancarEDevolverAnterior();
+                this.consumir(lexico_regular_1.default.PARENTESE_ESQUERDO, `Esperado parêntese esquerdo após ${simboloLeiaDefinido.lexema}.`);
+                const argumento = this.expressao();
+                this.consumir(lexico_regular_1.default.PARENTESE_DIREITO, `Esperado parêntese direito após número de parâmetros em chamada de ${simboloLeiaDefinido.lexema}.`);
+                const leiaDefinido = new declaracoes_1.LeiaMultiplo(simboloLeiaDefinido, argumento);
+                return leiaDefinido;
+            default:
+                const simboloIdentificador = this.avancarEDevolverAnterior();
+                return new construtos_1.ConstanteOuVariavel(this.hashArquivo, simboloIdentificador);
+        }
+    }
+    formato() {
+        const expressao = this.primario();
+        if (this.verificarSeSimboloAtualEIgualA(lexico_regular_1.default.FORMATO)) {
+            // O próximo símbolo precisa ser um texto no padrão "%Nd" ou "%.Nf", onde N é um inteiro.
+            const simboloMascaraFormato = this.consumir(lexico_regular_1.default.TEXTO, "Esperado máscara de formato após método 'formato'.");
+            if (!/%((\d+)d|\.(\d+)f)/gi.test(simboloMascaraFormato.literal)) {
+                throw this.erro(simboloMascaraFormato, "Máscara para função de formato inválida.");
+            }
+            return new construtos_1.Chamada(this.hashArquivo, // new Expressao(new MetodoPrimitiva(expressao, primitivasNumero.formato)), undefined, [expressao]);
+            new construtos_1.AcessoMetodoOuPropriedade(this.hashArquivo, expressao, new lexador_1.Simbolo(lexico_regular_1.default.FORMATO, 'formato', 'formato', expressao.linha, this.hashArquivo)), undefined, [new construtos_1.Literal(this.hashArquivo, expressao.linha, simboloMascaraFormato.literal)]);
+        }
+        return expressao;
+    }
+    /**
+     * Em Potigol, só é possível determinar a diferença entre uma chamada e uma
+     * declaração de função depois dos argumentos.
+     *
+     * Chamadas não aceitam dicas de tipos de parâmetros.
+     * @returns Um construto do tipo `AcessoMetodo`, `AcessoIndiceVariavel` ou `Constante`,
+     * dependendo dos símbolos encontrados.
+     */
+    chamar() {
+        let expressao = this.formato();
+        while (true) {
+            if (this.verificarSeSimboloAtualEIgualA(lexico_regular_1.default.PARENTESE_ESQUERDO)) {
+                if (expressao instanceof construtos_1.ConstanteOuVariavel) {
+                    expressao = new construtos_1.Constante(expressao.hashArquivo, expressao.simbolo);
+                }
+                expressao = this.finalizarChamada(expressao);
+            }
+            else if (this.verificarSeSimboloAtualEIgualA(lexico_regular_1.default.PONTO)) {
+                if (this.verificarTipoSimboloAtual(lexico_regular_1.default.QUAL_TIPO)) {
+                    const identificador = this.simbolos[this.atual - 2];
+                    const simbolo = this.simbolos[this.atual];
+                    const valor = expressao ? expressao : identificador.lexema;
+                    this.avancarEDevolverAnterior();
+                    return new construtos_1.QualTipo(this.hashArquivo, simbolo, valor);
+                }
+                else {
+                    const nome = this.consumir(lexico_regular_1.default.IDENTIFICADOR, "Esperado nome do método após '.'.");
+                    const variavelMetodo = new construtos_1.Variavel(expressao.hashArquivo, expressao.simbolo);
+                    expressao = new construtos_1.AcessoMetodoOuPropriedade(this.hashArquivo, variavelMetodo, nome);
+                }
+            }
+            else if (this.verificarSeSimboloAtualEIgualA(lexico_regular_1.default.COLCHETE_ESQUERDO)) {
+                const indice = this.expressao();
+                const simboloFechamento = this.consumir(lexico_regular_1.default.COLCHETE_DIREITO, "Esperado ']' após escrita do indice.");
+                const variavelVetor = new construtos_1.Variavel(expressao.hashArquivo, expressao.simbolo);
+                expressao = new construtos_1.AcessoIndiceVariavel(this.hashArquivo, variavelVetor, indice, simboloFechamento);
+            }
+            else {
+                if (expressao instanceof construtos_1.ConstanteOuVariavel) {
+                    expressao = new construtos_1.Constante(expressao.hashArquivo, expressao.simbolo);
+                }
+                break;
+            }
+        }
+        return expressao;
+    }
+    comparacaoIgualdade() {
+        let expressao = this.comparar();
+        while (this.verificarSeSimboloAtualEIgualA(lexico_regular_1.default.DIFERENTE, lexico_regular_1.default.IGUAL_IGUAL)) {
+            const operador = this.simbolos[this.atual - 1];
+            const direito = this.comparar();
+            expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
+        }
+        return expressao;
+    }
+    /**
+     * Em Potigol, `escreva` aceita apenas um argumento.
+     * @returns Uma declaração `Escreva`.
+     */
+    declaracaoEscreva() {
+        const simboloAtual = this.avancarEDevolverAnterior();
+        const argumento = this.ou();
+        return new declaracoes_1.Escreva(Number(simboloAtual.linha), simboloAtual.hashArquivo, [argumento]);
+    }
+    /**
+     * Em Potigol, `imprima` aceita apenas um argumento.
+     * @returns Uma declaração `EscrevaMesmaLinha`, já que `imprima` em Potigol escreve
+     * o resultado na saída na mesma linha.
+     * @see https://potigol.github.io/docs/basico/entrada_saida.html
+     */
+    declaracaoImprima() {
+        const simboloAtual = this.avancarEDevolverAnterior();
+        const argumento = this.ou();
+        return new declaracoes_1.EscrevaMesmaLinha(Number(simboloAtual.linha), simboloAtual.hashArquivo, [argumento]);
+    }
+    /**
+     * Blocos de escopo em Potigol existem quando:
+     *
+     * - Em uma declaração de função ou método, após fecha parênteses, o próximo
+     * símbolo obrigatório não é `=` e há pelo menos um `fim` até o final do código;
+     * - Em uma declaração `se`;
+     * - Em uma declaração `enquanto`;
+     * - Em uma declaração `para`.
+     * @returns Um vetor de `Declaracao`.
+     */
+    blocoEscopo() {
+        let declaracoes = [];
+        while (!this.estaNoFinal() && !this.verificarTipoSimboloAtual(lexico_regular_1.default.FIM)) {
+            const retornoDeclaracao = this.resolverDeclaracaoForaDeBloco();
+            if (Array.isArray(retornoDeclaracao)) {
+                declaracoes = declaracoes.concat(retornoDeclaracao);
+            }
+            else {
+                declaracoes.push(retornoDeclaracao);
+            }
+        }
+        return declaracoes;
+    }
+    declaracaoSe() {
+        const simboloSe = this.avancarEDevolverAnterior();
+        const condicao = this.expressao();
+        this.consumir(lexico_regular_1.default.ENTAO, "Esperado palavra reservada 'entao' após condição em declaração 'se'.");
+        const declaracoes = [];
+        do {
+            declaracoes.push(this.resolverDeclaracaoForaDeBloco());
+        } while (![lexico_regular_1.default.SENAO, lexico_regular_1.default.FIM].includes(this.simbolos[this.atual].tipo));
+        let caminhoSenao = null;
+        if (this.verificarSeSimboloAtualEIgualA(lexico_regular_1.default.SENAO)) {
+            const simboloSenao = this.simbolos[this.atual - 1];
+            const declaracoesSenao = [];
+            do {
+                declaracoesSenao.push(this.resolverDeclaracaoForaDeBloco());
+            } while (![lexico_regular_1.default.FIM].includes(this.simbolos[this.atual].tipo));
+            caminhoSenao = new declaracoes_1.Bloco(this.hashArquivo, Number(simboloSenao.linha), declaracoesSenao.filter((d) => d));
+        }
+        this.consumir(lexico_regular_1.default.FIM, "Esperado palavra-chave 'fim' para fechamento de declaração 'se'.");
+        return new declaracoes_1.Se(condicao, new declaracoes_1.Bloco(this.hashArquivo, Number(simboloSe.linha), declaracoes.filter((d) => d)), [], caminhoSenao);
+    }
+    declaracaoEnquanto() {
+        const simboloAtual = this.avancarEDevolverAnterior();
+        const condicao = this.expressao();
+        this.consumir(lexico_regular_1.default.FACA, "Esperado paravra reservada 'faca' após condição de continuidade em declaracão 'enquanto'.");
+        const declaracoes = [];
+        do {
+            declaracoes.push(this.resolverDeclaracaoForaDeBloco());
+        } while (![lexico_regular_1.default.FIM].includes(this.simbolos[this.atual].tipo));
+        this.consumir(lexico_regular_1.default.FIM, "Esperado palavra-chave 'fim' para fechamento de declaração 'enquanto'.");
+        return new declaracoes_1.Enquanto(condicao, new declaracoes_1.Bloco(simboloAtual.hashArquivo, Number(simboloAtual.linha), declaracoes.filter((d) => d)));
+    }
+    declaracaoPara() {
+        const simboloPara = this.avancarEDevolverAnterior();
+        const variavelIteracao = this.consumir(lexico_regular_1.default.IDENTIFICADOR, "Esperado identificador de variável após 'para'.");
+        this.consumir(lexico_regular_1.default.DE, "Esperado palavra reservada 'de' após variável de controle de 'para'.");
+        const literalOuVariavelInicio = this.adicaoOuSubtracao();
+        this.consumir(lexico_regular_1.default.ATE, "Esperado palavra reservada 'ate' após valor inicial do laço de repetição 'para'.");
+        const literalOuVariavelFim = this.adicaoOuSubtracao();
+        let operadorCondicao = new lexador_1.Simbolo(lexico_regular_1.default.MENOR_IGUAL, '', '', Number(simboloPara.linha), this.hashArquivo);
+        let operadorCondicaoIncremento = new lexador_1.Simbolo(lexico_regular_1.default.MENOR, '', '', Number(simboloPara.linha), this.hashArquivo);
+        // Isso existe porque o laço `para` do Potigol pode ter o passo positivo ou negativo
+        // dependendo dos operandos de início e fim, que só são possíveis de determinar
+        // em tempo de execução.
+        // Quando um dos operandos é uma variável, tanto a condição do laço quanto o
+        // passo são considerados indefinidos aqui.
+        let passo;
+        let resolverIncrementoEmExecucao = false;
+        if (this.verificarSeSimboloAtualEIgualA(lexico_regular_1.default.PASSO)) {
+            passo = this.unario();
+        }
+        else {
+            if (literalOuVariavelInicio instanceof construtos_1.Literal && literalOuVariavelFim instanceof construtos_1.Literal) {
+                if (literalOuVariavelInicio.valor > literalOuVariavelFim.valor) {
+                    passo = new construtos_1.Unario(this.hashArquivo, new lexador_1.Simbolo(lexico_regular_1.default.SUBTRACAO, '-', undefined, simboloPara.linha, simboloPara.hashArquivo), new construtos_1.Literal(this.hashArquivo, Number(simboloPara.linha), 1), 'ANTES');
+                    operadorCondicao = new lexador_1.Simbolo(lexico_regular_1.default.MAIOR_IGUAL, '', '', Number(simboloPara.linha), this.hashArquivo);
+                    operadorCondicaoIncremento = new lexador_1.Simbolo(lexico_regular_1.default.MAIOR, '', '', Number(simboloPara.linha), this.hashArquivo);
+                }
+                else {
+                    passo = new construtos_1.Literal(this.hashArquivo, Number(simboloPara.linha), 1);
+                }
+            }
+            else {
+                // Passo e operador de condição precisam ser resolvidos em tempo de execução.
+                passo = undefined;
+                operadorCondicao = undefined;
+                operadorCondicaoIncremento = undefined;
+                resolverIncrementoEmExecucao = true;
+            }
+        }
+        this.consumir(lexico_regular_1.default.FACA, "Esperado palavra reservada 'faca' após valor final do laço de repetição 'para'.");
+        const declaracoesBlocoPara = [];
+        let simboloAtualBlocoPara = this.simbolos[this.atual];
+        while (simboloAtualBlocoPara.tipo !== lexico_regular_1.default.FIM) {
+            declaracoesBlocoPara.push(this.resolverDeclaracaoForaDeBloco());
+            simboloAtualBlocoPara = this.simbolos[this.atual];
+        }
+        this.consumir(lexico_regular_1.default.FIM, '');
+        const corpo = new declaracoes_1.Bloco(this.hashArquivo, Number(simboloPara.linha) + 1, declaracoesBlocoPara.filter((d) => d));
+        const para = new declaracoes_1.Para(this.hashArquivo, Number(simboloPara.linha), new construtos_1.Atribuir(this.hashArquivo, variavelIteracao, literalOuVariavelInicio), new construtos_1.Binario(this.hashArquivo, new construtos_1.Variavel(this.hashArquivo, variavelIteracao), operadorCondicao, literalOuVariavelFim), new construtos_1.FimPara(this.hashArquivo, Number(simboloPara.linha), new construtos_1.Binario(this.hashArquivo, new construtos_1.Variavel(this.hashArquivo, variavelIteracao), operadorCondicaoIncremento, literalOuVariavelFim), new declaracoes_1.Expressao(new construtos_1.Atribuir(this.hashArquivo, variavelIteracao, new construtos_1.Binario(this.hashArquivo, new construtos_1.Variavel(this.hashArquivo, variavelIteracao), new lexador_1.Simbolo(lexico_regular_1.default.ADICAO, '', null, Number(simboloPara.linha), this.hashArquivo), passo)))), corpo);
+        para.blocoPosExecucao = corpo;
+        para.resolverIncrementoEmExecucao = resolverIncrementoEmExecucao;
+        return para;
+    }
+    declaracaoEscolha() {
+        this.avancarEDevolverAnterior();
+        const condicao = this.expressao();
+        const caminhos = [];
+        let caminhoPadrao = null;
+        while (!this.verificarSeSimboloAtualEIgualA(lexico_regular_1.default.FIM)) {
+            this.consumir(lexico_regular_1.default.CASO, "Esperado palavra reservada 'caso' após condição de 'escolha'.");
+            if (this.verificarSeSimboloAtualEIgualA(lexico_regular_1.default.TRACO_BAIXO)) {
+                // Caso padrão
+                if (caminhoPadrao !== null) {
+                    const excecao = new erro_avaliador_sintatico_1.ErroAvaliadorSintatico(this.simbolos[this.atual], "Você só pode ter um caminho padrão em cada declaração de 'escolha'.");
+                    this.erros.push(excecao);
+                    throw excecao;
+                }
+                this.consumir(lexico_regular_1.default.SETA, "Esperado '=>' após palavra reservada 'caso'.");
+                const declaracoesPadrao = [this.resolverDeclaracaoForaDeBloco()];
+                // TODO: Verificar se Potigol admite bloco de escopo para `escolha`.
+                /* const declaracoesPadrao = [];
+                do {
+                    declaracoesPadrao.push(this.declaracao());
+                } while (!this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CASO, tiposDeSimbolos.FIM)); */
+                caminhoPadrao = {
+                    declaracoes: declaracoesPadrao,
+                };
+                continue;
+            }
+            const caminhoCondicoes = [this.expressao()];
+            this.consumir(lexico_regular_1.default.SETA, "Esperado '=>' após palavra reservada 'caso'.");
+            const declaracoes = [this.resolverDeclaracaoForaDeBloco()];
+            // TODO: Verificar se Potigol admite bloco de escopo para `escolha`.
+            /* const declaracoes = [];
+            do {
+                declaracoes.push(this.declaracao());
+            } while (!this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.CASO, tiposDeSimbolos.FIM)); */
+            caminhos.push({
+                condicoes: caminhoCondicoes,
+                declaracoes,
+            });
+        }
+        return new declaracoes_1.Escolha(condicao, caminhos, caminhoPadrao);
+    }
+    declaracaoDeConstantes() {
+        const identificadores = [];
+        let tipo = null;
+        do {
+            identificadores.push(this.consumir(lexico_regular_1.default.IDENTIFICADOR, 'Esperado nome da constante.'));
+        } while (this.verificarSeSimboloAtualEIgualA(lexico_regular_1.default.VIRGULA));
+        /* if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.DOIS_PONTOS)) {
+            const tipoConstante = this.verificarDefinicaoTipoAtual();
+            if (!tipoConstante) {
+                throw this.erro(this.simboloAtual(), 'Tipo definido na constante não é válido.');
+            }
+            tipo = tipoConstante;
+            this.avancarEDevolverAnterior();
+        } */
+        this.consumir(lexico_regular_1.default.IGUAL, "Esperado '=' após identificador em instrução 'constante'.");
+        const inicializadores = [];
+        do {
+            let inicializador = this.expressao();
+            if (inicializador instanceof declaracoes_1.Leia && identificadores.length > 1) {
+                inicializador = new declaracoes_1.LeiaMultiplo(inicializador.simbolo, new construtos_1.Literal(this.hashArquivo, Number(inicializador.simbolo.linha), identificadores.length));
+            }
+            inicializadores.push(inicializador);
+        } while (this.verificarSeSimboloAtualEIgualA(lexico_regular_1.default.VIRGULA));
+        if (identificadores.length !== inicializadores.length) {
+            // Pode ser que a inicialização seja feita por uma das
+            // funções `leia`, que podem ler vários valores. Neste caso, não deve dar erro.
+            if (!(inicializadores.length === 1 && inicializadores[0] instanceof declaracoes_1.LeiaMultiplo)) {
+                throw this.erro(this.simbolos[this.atual], 'Quantidade de identificadores à esquerda do igual é diferente da quantidade de valores à direita.');
+            }
+            const inicializadorLeia = inicializadores[0];
+            let tipoConversao;
+            switch (inicializadorLeia.simbolo.tipo) {
+                case lexico_regular_1.default.LEIA_INTEIROS:
+                    tipoConversao = 'inteiro[]';
+                    break;
+                case lexico_regular_1.default.LEIA_INTEIRO:
+                    tipoConversao = 'inteiro';
+                    break;
+                case lexico_regular_1.default.LEIA_REAL:
+                case lexico_regular_1.default.LEIA_REAIS:
+                    tipoConversao = 'real';
+                    break;
+                default:
+                    tipoConversao = 'texto';
+                    break;
+            }
+            return new declaracoes_1.ConstMultiplo(identificadores, inicializadores[0], tipoConversao);
+        }
+        let retorno = [];
+        for (let [indice, identificador] of identificadores.entries()) {
+            // const inicializador = inicializadores[indice];
+            // this.verificarTipoAtribuido(tipo, inicializador);
+            retorno.push(new declaracoes_1.Const(identificador, inicializadores[indice], tipo));
+        }
+        // this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PONTO_E_VIRGULA);
+        return retorno;
+    }
+    declaracaoDeVariaveis() {
+        const simboloVar = this.avancarEDevolverAnterior();
+        const identificadores = [];
+        do {
+            identificadores.push(this.consumir(lexico_regular_1.default.IDENTIFICADOR, 'Esperado nome de variável.'));
+        } while (this.verificarSeSimboloAtualEIgualA(lexico_regular_1.default.VIRGULA));
+        this.consumir(lexico_regular_1.default.REATRIBUIR, "Esperado ':=' após identificador em instrução 'var'.");
+        const inicializadores = [];
+        do {
+            inicializadores.push(this.expressao());
+        } while (this.verificarSeSimboloAtualEIgualA(lexico_regular_1.default.VIRGULA));
+        if (identificadores.length !== inicializadores.length) {
+            throw this.erro(simboloVar, 'Quantidade de identificadores à esquerda do igual é diferente da quantidade de valores à direita.');
+        }
+        const retorno = [];
+        for (let [indice, identificador] of identificadores.entries()) {
+            retorno.push(new declaracoes_1.Var(identificador, inicializadores[indice]));
+        }
+        return retorno;
+    }
+    logicaAtribuicaoComDicaDeTipo(expressao) {
+        // A dica de tipo é opcional.
+        // Só que, se a avaliação entra na dica, só
+        // podemos ter uma constante apenas.
+        this.avancarEDevolverAnterior();
+        if (![
+            lexico_regular_1.default.CARACTERE,
+            lexico_regular_1.default.INTEIRO,
+            lexico_regular_1.default.LOGICO,
+            lexico_regular_1.default.LÓGICO,
+            lexico_regular_1.default.REAL,
+            lexico_regular_1.default.TEXTO,
+        ].includes(this.simbolos[this.atual].tipo)) {
+            throw this.erro(this.simbolos[this.atual], 'Esperado tipo após dois-pontos e nome de identificador.');
+        }
+        return this.avancarEDevolverAnterior();
+    }
+    declaracaoFazer() {
+        throw new Error('Método não implementado.');
+    }
+    /**
+     * Uma declaração de tipo nada mais é do que um declaração de classe.
+     * Em Potigol, classe e tipo são praticamente a mesma coisa.
+     *
+     * @returns Um construto do tipo `Classe`.
+     */
+    declaracaoTipo() {
+        const simboloTipo = this.avancarEDevolverAnterior();
+        const construto = this.primario();
+        // TODO: Verificar se Potigol trabalha com herança.
+        /* let superClasse = null;
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.HERDA)) {
+            this.consumir(tiposDeSimbolos.IDENTIFICADOR, 'Esperado nome da Superclasse.');
+            superClasse = new Variavel(this.hashArquivo, this.simbolos[this.atual - 1]);
+        } */
+        const metodos = [];
+        const propriedades = [];
+        while (!this.verificarTipoSimboloAtual(lexico_regular_1.default.FIM) && !this.estaNoFinal()) {
+            const identificador = this.consumir(lexico_regular_1.default.IDENTIFICADOR, 'Esperado nome de propriedade ou método.');
+            if (this.simbolos[this.atual].tipo === lexico_regular_1.default.PARENTESE_ESQUERDO) {
+                // Método
+                const construtoMetodo = new construtos_1.Constante(identificador.hashArquivo, identificador);
+                metodos.push(this.declaracaoDeFuncaoOuMetodo(construtoMetodo));
+            }
+            else {
+                // Propriedade
+                this.consumir(lexico_regular_1.default.DOIS_PONTOS, 'Esperado dois-pontos após nome de propriedade em declaração de tipo.');
+                this.verificacaoTipo(this.simbolos[this.atual], 'Esperado tipo do argumento após dois-pontos, em definição de função.');
+                const tipoPropriedade = this.avancarEDevolverAnterior();
+                propriedades.push(new declaracoes_1.PropriedadeClasse(identificador, this.tiposPotigolParaDelegua[tipoPropriedade.lexema]));
+            }
+        }
+        this.consumir(lexico_regular_1.default.FIM, "Esperado 'fim' após o escopo do tipo.");
+        // Depois de verificadas todas as propriedades anotadas com tipo,
+        // Precisamos gerar um construtor com todas elas na ordem em que
+        // foram lidas.
+        const instrucoesConstrutor = [];
+        for (let propriedade of propriedades) {
+            instrucoesConstrutor.push(new declaracoes_1.Expressao(new construtos_1.DefinirValor(propriedade.hashArquivo, propriedade.linha, new construtos_1.Isto(propriedade.hashArquivo, propriedade.linha, new lexador_1.Simbolo(lexico_regular_1.default.ISTO, 'isto', undefined, simboloTipo.linha, simboloTipo.hashArquivo)), propriedade.nome, new construtos_1.Variavel(propriedade.hashArquivo, propriedade.nome))));
+        }
+        const construtorConstruto = new construtos_1.FuncaoConstruto(simboloTipo.hashArquivo, simboloTipo.linha, propriedades.map((p) => ({
+            abrangencia: 'padrao',
+            nome: p.nome,
+        })), instrucoesConstrutor);
+        const construtor = new declaracoes_1.FuncaoDeclaracao(new lexador_1.Simbolo(lexico_regular_1.default.CONSTRUTOR, 'construtor', undefined, simboloTipo.hashArquivo, simboloTipo.linha), construtorConstruto, undefined);
+        metodos.unshift(construtor);
+        return new declaracoes_1.Classe(construto.simbolo, undefined, metodos, propriedades);
+    }
+    atribuir() {
+        const expressao = this.ou();
+        if (!this.estaNoFinal() && expressao instanceof construtos_1.Constante) {
+            let tipoVariavelOuConstante;
+            // Atribuição constante.
+            if (this.simbolos[this.atual].tipo === lexico_regular_1.default.DOIS_PONTOS) {
+                tipoVariavelOuConstante = this.logicaAtribuicaoComDicaDeTipo(expressao);
+            }
+            switch (this.simbolos[this.atual].tipo) {
+                case lexico_regular_1.default.VIRGULA:
+                    this.atual--;
+                    return this.declaracaoDeConstantes();
+                case lexico_regular_1.default.IGUAL:
+                    this.avancarEDevolverAnterior();
+                    const valorAtribuicao = this.ou();
+                    return new declaracoes_1.Const(expressao.simbolo, valorAtribuicao, tipoVariavelOuConstante
+                        ? this.tiposPotigolParaDelegua[tipoVariavelOuConstante.lexema]
+                        : undefined);
+            }
+        }
+        return expressao;
+    }
+    /**
+     * Em Potigol, uma definição de função normalmente começa com um
+     * identificador - que não é uma palavra reservada - seguido de parênteses.
+     * Este ponto de entrada verifica o símbolo atual e o próximo.
+     *
+     * Diferentemente dos demais dialetos, verificamos logo de cara se
+     * temos uma definição ou chamada de função, isto porque definições
+     * nunca aparecem do lado direito de uma atribuição, a não ser que
+     * estejam entre parênteses (_currying_).
+     *
+     * Se o próximo símbolo for parênteses, ou é uma definiçao de função,
+     * ou uma chamada de função.
+     */
+    expressaoOuDefinicaoFuncao() {
+        if (!this.estaNoFinal() && this.simbolos[this.atual].tipo === lexico_regular_1.default.IDENTIFICADOR) {
+            if (this.atual + 1 < this.simbolos.length) {
+                switch (this.simbolos[this.atual + 1].tipo) {
+                    case lexico_regular_1.default.PARENTESE_ESQUERDO:
+                        const construtoPrimario = this.primario();
+                        return this.declaracaoDeFuncaoOuMetodo(construtoPrimario);
+                }
+            }
+        }
+        return this.atribuir();
+    }
+    resolverDeclaracaoForaDeBloco() {
+        const simboloAtual = this.simbolos[this.atual];
+        switch (simboloAtual.tipo) {
+            case lexico_regular_1.default.ENQUANTO:
+                return this.declaracaoEnquanto();
+            case lexico_regular_1.default.ESCOLHA:
+                return this.declaracaoEscolha();
+            case lexico_regular_1.default.ESCREVA:
+                return this.declaracaoEscreva();
+            case lexico_regular_1.default.IMPRIMA:
+                return this.declaracaoImprima();
+            case lexico_regular_1.default.PARA:
+                return this.declaracaoPara();
+            case lexico_regular_1.default.SE:
+                return this.declaracaoSe();
+            case lexico_regular_1.default.TIPO:
+                return this.declaracaoTipo();
+            case lexico_regular_1.default.VARIAVEL:
+                return this.declaracaoDeVariaveis();
+            default:
+                return this.expressaoOuDefinicaoFuncao();
+        }
+    }
+    analisar(retornoLexador, hashArquivo) {
+        this.microAvaliadorSintatico = new micro_avaliador_sintatico_potigol_1.MicroAvaliadorSintaticoPotigol(hashArquivo);
+        this.erros = [];
+        this.atual = 0;
+        this.blocos = 0;
+        this.declaracoesAnteriores = {};
+        this.hashArquivo = hashArquivo || 0;
+        this.simbolos = (retornoLexador === null || retornoLexador === void 0 ? void 0 : retornoLexador.simbolos) || [];
+        this.declaracoes = [];
+        while (!this.estaNoFinal()) {
+            const retornoDeclaracao = this.resolverDeclaracaoForaDeBloco();
+            if (Array.isArray(retornoDeclaracao)) {
+                this.declaracoes = this.declaracoes.concat(retornoDeclaracao);
+            }
+            else {
+                this.declaracoes.push(retornoDeclaracao);
+            }
+        }
+        return {
+            declaracoes: this.declaracoes,
+            erros: this.erros,
+        };
+    }
+}
+exports.AvaliadorSintaticoPotigol = AvaliadorSintaticoPotigol;
 //# sourceMappingURL=avaliador-sintatico-potigol.js.map