@designliquido/potigol 0.4.4 → 0.4.6

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

@@ -14,15 +14,14 @@ const construtos_2 = require("../construtos");
 const declaracoes_2 = require("../declaracoes");
 const micro_avaliador_sintatico_potigol_1 = require("./micro-avaliador-sintatico-potigol");
 const pilha_escopos_variaveis_conhecidas_1 = require("./pilha-escopos-variaveis-conhecidas");
+const tipos_de_dados_1 = __importDefault(require("../tipos-de-dados"));
 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 {
-    expressaoLeia() {
-        throw new Error('Method not implemented.');
-    }
     constructor() {
         super();
         this.tiposPotigolParaDelegua = {
@@ -68,15 +67,15 @@ class AvaliadorSintaticoPotigol extends avaliador_sintatico_base_1.AvaliadorSint
         return true;
     }
     /**
-     * Retorna uma declaração de função iniciada por igual,
+     * Retorna uma declaração de função iniciada por igual ou seta,
      * ou seja, com apenas uma instrução.
      * @param simboloPrimario O símbolo que identifica a função (nome),
-     *                        também usado para fins de pragma.
+     *                        também usado para fins de localização.
      * @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, parametros, tipoRetorno) {
+    declaracaoFuncaoPotigolIniciadaPorIgualOuSeta(simboloPrimario, parametros, tipoRetorno) {
         const corpo = new construtos_1.FuncaoConstruto(simboloPrimario.hashArquivo, simboloPrimario.linha, parametros, [
             new declaracoes_1.Retorna(simboloPrimario, this.expressao()),
         ]);
@@ -86,10 +85,10 @@ class AvaliadorSintaticoPotigol extends avaliador_sintatico_base_1.AvaliadorSint
         return new declaracoes_1.FuncaoDeclaracao(simboloPrimario, corpo, tipoRetorno ? tipoRetorno.lexema : 'qualquer');
     }
     /**
-     * Retorna uma declaração de função terminada por fim,
+     * 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 parenteseEsquerdo O parêntese esquerdo, usado para fins de localização.
      * @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`.
@@ -101,13 +100,20 @@ class AvaliadorSintaticoPotigol extends avaliador_sintatico_base_1.AvaliadorSint
         }
         return new declaracoes_1.FuncaoDeclaracao(simboloPrimario, corpo, tipoRetorno.lexema);
     }
-    corpoDaFuncao(nomeFuncao, simboloPragma, parametros) {
+    corpoDaFuncao(nomeFuncao, simboloLocalizacao, parametros) {
         const corpo = this.blocoEscopo();
-        return new construtos_1.FuncaoConstruto(this.hashArquivo, Number(simboloPragma.linha), parametros, corpo);
+        return new construtos_1.FuncaoConstruto(this.hashArquivo, Number(simboloLocalizacao.linha), parametros, corpo);
     }
-    declaracaoDeFuncaoOuMetodo(construtoPrimario) {
+    /**
+     * Ponto comum entre declarações de funções com nome. Em Potigol, usar `def` para definir
+     * uma função é opcional. Essa lógica serve tanto para quando a palavra `def` é usada,
+     * como para casos em que a função começa pelo seu nome, seguida de parênteses.
+     * @param {SimboloInterface} simboloNomeFuncao Normalmente um `Simbolo` do tipo `IDENTIFICADOR`.
+     * @returns
+     */
+    logicaComumDefinicaoFuncaoComNome(simboloNomeFuncao) {
         // O parêntese esquerdo é considerado o símbolo inicial para
-        // fins de pragma.
+        // fins de localização.
         const parenteseEsquerdo = this.avancarEDevolverAnterior();
         const simbolosEntreParenteses = [];
         while (!this.verificarTipoSimboloAtual(lexico_regular_1.default.PARENTESE_DIREITO)) {
@@ -126,9 +132,17 @@ class AvaliadorSintaticoPotigol extends avaliador_sintatico_base_1.AvaliadorSint
         // 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();
-            return this.declaracaoFuncaoPotigolIniciadaPorIgual(construtoPrimario.simbolo, resolucaoParametros.parametros, tipoRetorno);
+            return this.declaracaoFuncaoPotigolIniciadaPorIgualOuSeta(simboloNomeFuncao, resolucaoParametros.parametros, tipoRetorno);
         }
-        return this.declaracaoFuncaoPotigolTerminadaPorFim(construtoPrimario.simbolo, parenteseEsquerdo, resolucaoParametros.parametros, tipoRetorno);
+        return this.declaracaoFuncaoPotigolTerminadaPorFim(simboloNomeFuncao, parenteseEsquerdo, resolucaoParametros.parametros, tipoRetorno);
+    }
+    declaracaoDeFuncaoComDef() {
+        this.avancarEDevolverAnterior(); // `def`
+        const simboloNomeFuncao = this.consumir(lexico_regular_1.default.IDENTIFICADOR, `Esperado nome da função após palavra reservada 'def'. Atual: ${this.simbolos[this.atual].tipo}.`);
+        return this.logicaComumDefinicaoFuncaoComNome(simboloNomeFuncao);
+    }
+    declaracaoDeFuncaoOuMetodo(construtoPrimario) {
+        return this.logicaComumDefinicaoFuncaoComNome(construtoPrimario.simbolo);
     }
     finalizarChamada(entidadeChamada) {
         const simbolosEntreParenteses = [];
@@ -179,6 +193,7 @@ class AvaliadorSintaticoPotigol extends avaliador_sintatico_base_1.AvaliadorSint
                 const resolucaoTipo = this.tiposPotigolParaDelegua[tipoParametro.lexema];
                 parametro.tipoDado = resolucaoTipo;
                 tipagemDefinida = true;
+                indice++;
             }
             // TODO: Verificar se Potigol trabalha com valores padrão em argumentos.
             /* if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IGUAL)) {
@@ -186,7 +201,7 @@ class AvaliadorSintaticoPotigol extends avaliador_sintatico_base_1.AvaliadorSint
             } */
             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.');
             }
@@ -211,6 +226,67 @@ class AvaliadorSintaticoPotigol extends avaliador_sintatico_base_1.AvaliadorSint
                 return new construtos_2.LeiaTextos(simboloLeiaMultiplo, argumento);
         }
     }
+    /**
+     * Lógica para leitura de argumentos tipados de função. Ocorre em casos de leitura
+     * de funções anônimas.
+     * @param primeiroArgumento O primeiro argumento, já resolvido como construto.
+     */
+    logicaArgumentosTipados(primeiroArgumento) {
+        // Quando esta função executa, já sabemos que o próximo símbolo será um 
+        // dois-pontos.
+    }
+    logicaFuncaoAnonimaOuTupla(primeiroConstruto) {
+        const simbolosEntreParenteses = [];
+        while (!this.verificarTipoSimboloAtual(lexico_regular_1.default.PARENTESE_DIREITO)) {
+            simbolosEntreParenteses.push(this.avancarEDevolverAnterior());
+        }
+        // Se houver algum dois-pontos nos símbolos lidos, os símbolos devem ser parâmetros.
+        if (simbolosEntreParenteses.some(s => s.tipo === lexico_regular_1.default.DOIS_PONTOS)) {
+            // Colocamos o primeiro símbolo de volta porque se cada parâmetro possui um tipo
+            // definido, precisamos avaliar o primeiro símbolo novamente.
+            const simboloPrimeiroConstruto = primeiroConstruto.simbolo;
+            const todosOsSimbolos = [simboloPrimeiroConstruto, ...simbolosEntreParenteses];
+            const resolucaoParametros = this.logicaComumParametrosPotigol(todosOsSimbolos);
+            // Pelo menos o último símbolo precisa ter um tipo.
+            if (!resolucaoParametros.tipagemDefinida) {
+                throw this.erro(simboloPrimeiroConstruto, `Não foi encontrado um tipo válido na definição de parâmetros para função.`);
+            }
+            this.consumir(lexico_regular_1.default.PARENTESE_DIREITO, "Esperado ')' após parâmetros ou argumentos.");
+            const tipoUltimoParametro = resolucaoParametros.parametros[resolucaoParametros.parametros.length - 1].tipoDado;
+            for (const parametro of resolucaoParametros.parametros) {
+                if (parametro.tipoDado === undefined) {
+                    parametro.tipoDado = tipoUltimoParametro;
+                }
+            }
+            // Pode haver uma dica do tipo de retorno ou não.
+            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.avancarEDevolverAnterior();
+            }
+            // Em funções anônimas, logo após o fechamento dos parênteses, e com ou sem dica de retorno, 
+            // o próximo símbolo precisa ser uma seta.
+            this.consumir(lexico_regular_1.default.SETA, `Esperado seta para definição de corpo de função anônima após leitura de parâmetros. Atual: ${this.simbolos[this.atual].tipo}.`);
+            return this.declaracaoFuncaoPotigolIniciadaPorIgualOuSeta({ hashArquivo: primeiroConstruto.hashArquivo, linha: primeiroConstruto.linha }, resolucaoParametros.parametros, tipoRetorno);
+        }
+        else { // Senão, são tuplas.
+            // Remove a primeira vírgula
+            simbolosEntreParenteses.shift();
+            const retornoMicroAvaliadorSintatico = this.microAvaliadorSintatico.analisar({ simbolos: simbolosEntreParenteses }, primeiroConstruto.linha);
+            this.consumir(lexico_regular_1.default.PARENTESE_DIREITO, "Esperado ')' após parâmetros ou argumentos.");
+            return new tuplas_1.SeletorTuplas(primeiroConstruto, ...retornoMicroAvaliadorSintatico.declaracoes);
+        }
+        // Se próximo símbolo for fechamento de parênteses, é uma tupla. 
+        // Se for dois-pontos (ou seja, especificação de tipos de parâmetros), provavelmente é uma função anônima.
+        /* switch (this.simbolos[this.atual].tipo) {
+            case tiposDeSimbolos.DOIS_PONTOS:
+                // TODO: Terminar
+                throw this.erro(this.simbolos[this.atual], 'Terminar.');
+            case tiposDeSimbolos.PARENTESE_DIREITO:
+                this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após a expressão.");
+                return new SeletorTuplas(...argumentos) as Tupla;
+        } */
+    }
     primario() {
         const simboloAtual = this.simbolos[this.atual];
         switch (simboloAtual.tipo) {
@@ -218,15 +294,12 @@ class AvaliadorSintaticoPotigol extends avaliador_sintatico_base_1.AvaliadorSint
                 this.avancarEDevolverAnterior();
                 const expressao = this.ou();
                 switch (this.simbolos[this.atual].tipo) {
+                    case lexico_regular_1.default.DOIS_PONTOS:
+                        const argumentosFuncao = this.logicaArgumentosTipados(expressao);
+                        console.log('argumentosFuncao', argumentosFuncao);
+                        break;
                     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.ou());
-                        }
-                        this.consumir(lexico_regular_1.default.PARENTESE_DIREITO, "Esperado ')' após a expressão.");
-                        return new tuplas_1.SeletorTuplas(...argumentos);
+                        return this.logicaFuncaoAnonimaOuTupla(expressao);
                     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);
@@ -385,6 +458,200 @@ class AvaliadorSintaticoPotigol extends avaliador_sintatico_base_1.AvaliadorSint
         }
         return expressao;
     }
+    verificarDefinicaoTipoAtual() {
+        const tipos = [...Object.values(tipos_de_dados_1.default)];
+        // TODO: Habilitar isso no futuro.
+        /* if (this.simbolos[this.atual].lexema in this.tiposDefinidosEmCodigo) {
+            return this.simbolos[this.atual].lexema;
+        } */
+        const lexemaElementar = this.simbolos[this.atual].lexema.toLowerCase();
+        const tipoElementarResolvido = tipos.find((tipo) => tipo.toLowerCase() === lexemaElementar);
+        if (!tipoElementarResolvido) {
+            throw this.erro(this.simbolos[this.atual], `Tipo de dados desconhecido: '${this.simbolos[this.atual].lexema}'.`);
+        }
+        // TODO: Verificar se precisa de alguma avaliação de vetor.
+        /* if (this.verificarTipoProximoSimbolo(tiposDeSimbolos.COLCHETE_ESQUERDO)) {
+            const tiposVetores = [
+                'inteiro[]',
+                'numero[]',
+                'número[]',
+                'qualquer[]',
+                'real[]',
+                'texto[]',
+            ];
+            this.avancarEDevolverAnterior();
+
+            if (!this.verificarTipoProximoSimbolo(tiposDeSimbolos.COLCHETE_DIREITO)) {
+                throw this.erro(
+                    this.simbolos[this.atual],
+                    `Esperado símbolo de fechamento do vetor: ']'. Atual: ${this.simbolos[this.atual].lexema}`
+                );
+            }
+
+            const tipoVetor = tiposVetores.find((tipo) => tipo === `${lexemaElementar}[]`);
+            this.avancarEDevolverAnterior();
+            return tipoVetor as TipoDadosElementar;
+        } */
+        return tipoElementarResolvido;
+    }
+    logicaComumInicializadorLeia(inicializador, identificadores) {
+        switch (inicializador.constructor) {
+            case construtos_2.LeiaInteiro:
+                const inicializadorTipadoInteiro = inicializador;
+                return new construtos_2.LeiaInteiros(inicializadorTipadoInteiro.simbolo, new construtos_1.Literal(this.hashArquivo, Number(inicializadorTipadoInteiro.simbolo.linha), identificadores.length));
+            case construtos_2.LeiaReal:
+                const inicializadorTipadoReal = inicializador;
+                return new construtos_2.LeiaReais(inicializadorTipadoReal.simbolo, new construtos_1.Literal(this.hashArquivo, Number(inicializadorTipadoReal.simbolo.linha), identificadores.length));
+            case construtos_2.LeiaTexto:
+                const inicializadorTipadoTexto = inicializador;
+                return new construtos_2.LeiaTextos(inicializadorTipadoTexto.simbolo, new construtos_1.Literal(this.hashArquivo, Number(inicializadorTipadoTexto.simbolo.linha), identificadores.length));
+        }
+    }
+    logicaComumInferenciaTiposLeia(inicializador) {
+        // Por algum motivo (muito) estranho, `inicializador.constructor.name` não funciona aqui.
+        // O nome da classe vai parar numa propriedade `name`.
+        switch (inicializador.name) {
+            case 'LeiaInteiros':
+                return 'inteiro[]';
+            case 'LeiaInteiro':
+                return 'inteiro';
+            case 'LeiaReais':
+                return 'real[]';
+            case 'LeiaReal':
+                return 'real';
+            case 'LeiaTextos':
+                return 'texto[]';
+            case 'LeiaTexto':
+                return 'texto';
+            default:
+                return 'qualquer';
+        }
+    }
+    /**
+     * Em Potigol, a palavra reservada `val` indica uma constante.
+     */
+    declaracaoDeConstanteExplicita() {
+        this.avancarEDevolverAnterior(); // `val`
+        const nomeConstante = this.consumir(lexico_regular_1.default.IDENTIFICADOR, 'Esperado nome da constante.');
+        let tipo = null;
+        if (this.verificarSeSimboloAtualEIgualA(lexico_regular_1.default.DOIS_PONTOS)) {
+            const tipoConstante = this.verificarDefinicaoTipoAtual();
+            if (!tipoConstante) {
+                throw this.erro(this.simbolos[this.atual], '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 'val'.");
+        let inicializador = this.expressao();
+        if (['LeiaInteiro', 'LeiaReal', 'LeiaTexto'].includes(inicializador.constructor.name)) {
+            inicializador = this.logicaComumInicializadorLeia(inicializador, [nomeConstante]);
+        }
+        return new declaracoes_1.Const(nomeConstante, inicializador, tipo);
+    }
+    declaracaoDeConstantes(primeiroIdentificador) {
+        // Normalmente o símbolo atual aqui será uma vírgula.
+        this.avancarEDevolverAnterior();
+        const identificadores = [primeiroIdentificador.simbolo];
+        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));
+        // TODO: Aparentemente, não é possível definir tipo para atribuição
+        // múltipla de constantes. Se algo mudar nisso, o código abaixo poderá
+        // voltar a ser usado.
+        /* 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 (identificadores.length > 1 &&
+                ['LeiaInteiro', 'LeiaReal', 'LeiaTexto'].includes(inicializador.constructor.name)) {
+                inicializador = this.logicaComumInicializadorLeia(inicializador, identificadores);
+            }
+            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 &&
+                ['LeiaInteiros', 'LeiaReais', 'LeiaTextos'].includes(inicializadores[0].constructor.name))) {
+                throw this.erro(this.simbolos[this.atual], 'Quantidade de identificadores à esquerda do igual é diferente da quantidade de valores à direita.');
+            }
+            const tipoConversao = this.logicaComumInferenciaTiposLeia(inicializadores[0].constructor);
+            return new declaracoes_1.ConstMultiplo(identificadores, inicializadores[0], tipoConversao);
+        }
+        let retorno = [];
+        for (let [indice, identificador] of identificadores.entries()) {
+            retorno.push(new declaracoes_1.Const(identificador, inicializadores[indice], tipo));
+        }
+        return retorno;
+    }
+    /**
+     * Este método contempla dois cenários:
+     *
+     * - A atribuição de variáveis em si (o primeiro símbolo é a palavra reservada `var`);
+     * - Uma reatribuição de uma ou mais variáveis (o primeiro símbolo a ser lido é uma
+     * vírgula, e o primeiro identificador é passado como argumento). Neste caso, não há
+     * a palavra reservada `var`.
+     * @param primeiroIdentificador Um construto de variável. É defiido em reatribuições.
+     * @returns Um vetor de declarações `Var`.
+     */
+    declaracaoDeVariaveisPotigol(primeiroIdentificador) {
+        const identificadores = [];
+        let simboloVar;
+        // Se houver primeiro identificador definido (reatribuição),
+        // o símbolo atual aqui será uma vírgula.
+        if (primeiroIdentificador) {
+            this.avancarEDevolverAnterior();
+            identificadores.push(primeiroIdentificador.simbolo);
+        }
+        else {
+            simboloVar = this.avancarEDevolverAnterior();
+        }
+        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 = [];
+        const escopoAtual = this.pilhaEscoposVariaveisConhecidas.topoDaPilha();
+        for (let [indice, identificador] of identificadores.entries()) {
+            retorno.push(new declaracoes_1.Var(identificador, inicializadores[indice]));
+            escopoAtual.push(identificador.lexema);
+        }
+        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();
+    }
     /**
      * Em Potigol, `escreva` aceita apenas um argumento.
      * @returns Uma declaração `Escreva`.
@@ -554,145 +821,6 @@ class AvaliadorSintaticoPotigol extends avaliador_sintatico_base_1.AvaliadorSint
         }
         return new declaracoes_1.Escolha(condicao, caminhos, caminhoPadrao);
     }
-    declaracaoDeConstantes(primeiroIdentificador) {
-        // Normalmente o símbolo atual aqui será uma vírgula.
-        this.avancarEDevolverAnterior();
-        const identificadores = [primeiroIdentificador.simbolo];
-        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));
-        // TODO: Aparentemente, não é possível definir tipo para atribuição
-        // múltipla de constantes. Se algo mudar nisso, o código abaixo poderá
-        // voltar a ser usado.
-        /* 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 (identificadores.length > 1 &&
-                ['LeiaInteiro', 'LeiaReal', 'LeiaTexto'].includes(inicializador.constructor.name)) {
-                switch (inicializador.constructor.name) {
-                    case 'LeiaInteiro':
-                        const inicializadorTipadoInteiro = inicializador;
-                        inicializador = new construtos_2.LeiaInteiros(inicializadorTipadoInteiro.simbolo, new construtos_1.Literal(this.hashArquivo, Number(inicializadorTipadoInteiro.simbolo.linha), identificadores.length));
-                        break;
-                    case 'LeiaReal':
-                        const inicializadorTipadoReal = inicializador;
-                        inicializador = new construtos_2.LeiaReais(inicializadorTipadoReal.simbolo, new construtos_1.Literal(this.hashArquivo, Number(inicializadorTipadoReal.simbolo.linha), identificadores.length));
-                        break;
-                    case 'LeiaTexto':
-                        const inicializadorTipadoTexto = inicializador;
-                        inicializador = new construtos_2.LeiaTextos(inicializadorTipadoTexto.simbolo, new construtos_1.Literal(this.hashArquivo, Number(inicializadorTipadoTexto.simbolo.linha), identificadores.length));
-                        break;
-                }
-            }
-            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 &&
-                ['LeiaInteiros', 'LeiaReais', 'LeiaTextos'].includes(inicializadores[0].constructor.name))) {
-                throw this.erro(this.simbolos[this.atual], 'Quantidade de identificadores à esquerda do igual é diferente da quantidade de valores à direita.');
-            }
-            let tipoConversao;
-            switch (inicializadores[0].constructor.name) {
-                case 'LeiaInteiros':
-                    tipoConversao = 'inteiro[]';
-                    break;
-                case 'LeiaInteiro':
-                    tipoConversao = 'inteiro';
-                    break;
-                case 'LeiaReais':
-                    tipoConversao = 'real[]';
-                    break;
-                case 'LeiaReal':
-                    tipoConversao = 'real';
-                    break;
-                case 'LeiaTextos':
-                    tipoConversao = 'texto[]';
-                    break;
-                case 'LeiaTexto':
-                    tipoConversao = 'texto';
-                    break;
-                default:
-                    tipoConversao = 'qualquer';
-                    break;
-            }
-            return new declaracoes_1.ConstMultiplo(identificadores, inicializadores[0], tipoConversao);
-        }
-        let retorno = [];
-        for (let [indice, identificador] of identificadores.entries()) {
-            retorno.push(new declaracoes_1.Const(identificador, inicializadores[indice], tipo));
-        }
-        return retorno;
-    }
-    /**
-     * Este método contempla dois cenários:
-     *
-     * - A atribuição de variáveis em si (o primeiro símbolo é a palavra reservada `var`);
-     * - Uma reatribuição de uma ou mais variáveis (o primeiro símbolo a ser lido é uma
-     * vírgula, e o primeiro identificador é passado como argumento). Neste caso, não há
-     * a palavra reservada `var`.
-     * @param primeiroIdentificador Um construto de variável. É defiido em reatribuições.
-     * @returns Um vetor de declarações `Var`.
-     */
-    declaracaoDeVariaveisPotigol(primeiroIdentificador) {
-        const identificadores = [];
-        let simboloVar;
-        // Se houver primeiro identificador definido (reatribuição),
-        // o símbolo atual aqui será uma vírgula.
-        if (primeiroIdentificador) {
-            this.avancarEDevolverAnterior();
-            identificadores.push(primeiroIdentificador.simbolo);
-        }
-        else {
-            simboloVar = this.avancarEDevolverAnterior();
-        }
-        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 = [];
-        const escopoAtual = this.pilhaEscoposVariaveisConhecidas.topoDaPilha();
-        for (let [indice, identificador] of identificadores.entries()) {
-            retorno.push(new declaracoes_1.Var(identificador, inicializadores[indice]));
-            escopoAtual.push(identificador.lexema);
-        }
-        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.');
     }
@@ -783,7 +911,15 @@ class AvaliadorSintaticoPotigol extends avaliador_sintatico_base_1.AvaliadorSint
         return expressao;
     }
     /**
-     * Em Potigol, uma definição de função normalmente começa com um
+     * Potigol não possui simplesmente um `leia`. Seus comandos `leia` são todos tipados.
+     * São eles: `leia_inteiro`, `leia_inteiros`, `leia_real`, `leia_reais`, `leia_texto` e
+     * `leia_textos`.
+     */
+    expressaoLeia() {
+        throw new Error('Método não implementado.');
+    }
+    /**
+     * Em Potigol, uma definição de função pode simplesmente começar 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.
      *
@@ -810,6 +946,8 @@ class AvaliadorSintaticoPotigol extends avaliador_sintatico_base_1.AvaliadorSint
     resolverDeclaracaoForaDeBloco() {
         const simboloAtual = this.simbolos[this.atual];
         switch (simboloAtual.tipo) {
+            case lexico_regular_1.default.DEF:
+                return this.declaracaoDeFuncaoComDef();
             case lexico_regular_1.default.ENQUANTO:
                 return this.declaracaoEnquanto();
             case lexico_regular_1.default.ESCOLHA:
@@ -824,6 +962,8 @@ class AvaliadorSintaticoPotigol extends avaliador_sintatico_base_1.AvaliadorSint
                 return this.declaracaoSe();
             case lexico_regular_1.default.TIPO:
                 return this.declaracaoTipo();
+            case lexico_regular_1.default.VAL:
+                return this.declaracaoDeConstanteExplicita();
             case lexico_regular_1.default.VARIAVEL:
                 return this.declaracaoDeVariaveisPotigol();
             default: