@designliquido/delegua 0.39.0 → 0.39.1

package/avaliador-sintatico/avaliador-sintatico.d.ts

@@ -1,6 +1,7 @@
-import { Chamada, Comentario, Construto, Decorador, FuncaoConstruto } from '../construtos';
+import { Chamada, Comentario, Construto, Decorador, Dicionario, FuncaoConstruto } from '../construtos';
 import { AvaliadorSintaticoInterface, ParametroInterface, SimboloInterface } from '../interfaces';
 import { ErroAvaliadorSintatico } from './erro-avaliador-sintatico';
+import { Tupla } from '../construtos/tuplas';
 import { Bloco, Classe, Const, Continua, Declaracao, Enquanto, Escolha, Escreva, Expressao, Falhar, Fazer, FuncaoDeclaracao, Importar, Leia, Para, ParaCada, Retorna, Se, Sustar, TendoComo, Tente, Var } from '../declaracoes';
 import { RetornoAvaliadorSintatico } from '../interfaces/retornos/retorno-avaliador-sintatico';
 import { RetornoLexador } from '../interfaces/retornos/retorno-lexador';
@@ -37,6 +38,9 @@ export declare class AvaliadorSintatico extends AvaliadorSintaticoBase implement
     performance: boolean;
     constructor(performance?: boolean);
     protected verificarDefinicaoTipoAtual(): string;
+    protected obterChaveDicionario(): Construto;
+    protected construtoDicionario(simboloChaveEsquerda: SimboloInterface): Dicionario;
+    protected construtoTupla(): Tupla;
     primario(): Construto;
     chamar(): Construto;
     finalizarChamada(entidadeChamada: Construto): Chamada;
@@ -96,6 +100,7 @@ export declare class AvaliadorSintatico extends AvaliadorSintaticoBase implement
     protected resolverDeclaracao(): any;
     protected declaracaoTendoComo(): TendoComo;
     protected declaracaoDesestruturacaoVariavel(): Var[];
+    protected logicaComumInferenciaTiposVariaveisEConstantes(inicializador: Construto, tipo: string): string;
     /**
      * Caso símbolo atual seja `var`, devolve uma declaração de variável.
      * @returns Um Construto do tipo Var.

package/avaliador-sintatico/avaliador-sintatico.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"avaliador-sintatico.d.ts","sourceRoot":"","sources":["../../fontes/avaliador-sintatico/avaliador-sintatico.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"avaliador-sintatico.d.ts","sourceRoot":"","sources":["../../fontes/avaliador-sintatico/avaliador-sintatico.ts"],"names":[],"mappings":"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"}

package/avaliador-sintatico/avaliador-sintatico.js

@@ -5,8 +5,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AvaliadorSintatico = void 0;
 const browser_process_hrtime_1 = __importDefault(require("browser-process-hrtime"));
-const delegua_1 = __importDefault(require("../tipos-de-dados/delegua"));
-const delegua_2 = __importDefault(require("../tipos-de-simbolos/delegua"));
 const construtos_1 = require("../construtos");
 const erro_avaliador_sintatico_1 = require("./erro-avaliador-sintatico");
 const tuplas_1 = require("../construtos/tuplas");
@@ -16,6 +14,9 @@ const avaliador_sintatico_base_1 = require("./avaliador-sintatico-base");
 const inferenciador_1 = require("../inferenciador");
 const pilha_escopos_1 = require("./pilha-escopos");
 const informacao_escopo_1 = require("./informacao-escopo");
+const delegua_1 = __importDefault(require("../tipos-de-dados/delegua"));
+const delegua_2 = __importDefault(require("../tipos-de-simbolos/delegua"));
+const primitivas_dicionario_1 = __importDefault(require("../bibliotecas/primitivas-dicionario"));
 const primitivas_numero_1 = __importDefault(require("../bibliotecas/primitivas-numero"));
 const primitivas_texto_1 = __importDefault(require("../bibliotecas/primitivas-texto"));
 const primitivas_vetor_1 = __importDefault(require("../bibliotecas/primitivas-vetor"));
@@ -64,28 +65,72 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         }
         return tipoElementarResolvido;
     }
+    obterChaveDicionario() {
+        switch (this.simbolos[this.atual].tipo) {
+            case delegua_2.default.NUMERO:
+            case delegua_2.default.TEXTO:
+            case delegua_2.default.FALSO:
+            case delegua_2.default.VERDADEIRO:
+                return this.primario();
+            case delegua_2.default.IDENTIFICADOR:
+                const simboloIdentificador = this.avancarEDevolverAnterior();
+                let tipoOperando;
+                if (simboloIdentificador.lexema in this.tiposDefinidosEmCodigo) {
+                    tipoOperando = simboloIdentificador.lexema;
+                }
+                else {
+                    tipoOperando = this.pilhaEscopos.obterTipoVariavelPorNome(simboloIdentificador.lexema);
+                }
+                if (!['numero', 'número', 'texto', 'lógico'].includes(tipoOperando)) {
+                    throw this.erro(simboloIdentificador, `Tipo ${tipoOperando} de identificador ${simboloIdentificador.lexema} não é válido como chave de dicionário.`);
+                }
+                return new construtos_1.Variavel(this.hashArquivo, simboloIdentificador, tipoOperando);
+            case delegua_2.default.COLCHETE_ESQUERDO:
+                this.avancarEDevolverAnterior();
+                if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.PARENTESE_ESQUERDO)) {
+                    return this.construtoTupla();
+                }
+                throw this.erro(this.simbolos[this.atual], `Esperado parêntese esquerdo após colchete esquerdo para definição de chave de dicionário. Atual: ${this.simbolos[this.atual].tipo}.`);
+            default:
+                throw this.erro(this.simbolos[this.atual], `Símbolo ${this.simbolos[this.atual].tipo} inesperado ou inválido como chave de dicionário.`);
+        }
+    }
+    construtoDicionario(simboloChaveEsquerda) {
+        this.avancarEDevolverAnterior();
+        const chaves = [];
+        const valores = [];
+        if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.CHAVE_DIREITA)) {
+            return new construtos_1.Dicionario(this.hashArquivo, Number(simboloChaveEsquerda.linha), [], []);
+        }
+        while (!this.verificarSeSimboloAtualEIgualA(delegua_2.default.CHAVE_DIREITA)) {
+            const chave = this.obterChaveDicionario();
+            this.consumir(delegua_2.default.DOIS_PONTOS, "Esperado ':' entre chave e valor.");
+            const valor = this.atribuir();
+            chaves.push(chave);
+            valores.push(valor);
+            if (this.simbolos[this.atual].tipo !== delegua_2.default.CHAVE_DIREITA) {
+                this.consumir(delegua_2.default.VIRGULA, 'Esperado vírgula antes da próxima expressão.');
+            }
+        }
+        return new construtos_1.Dicionario(this.hashArquivo, Number(simboloChaveEsquerda.linha), chaves, valores);
+    }
+    construtoTupla() {
+        const expressao = this.expressao();
+        const argumentos = [expressao];
+        while (this.simbolos[this.atual].tipo === delegua_2.default.VIRGULA) {
+            this.avancarEDevolverAnterior();
+            argumentos.push(this.expressao());
+        }
+        this.consumir(delegua_2.default.PARENTESE_DIREITO, "Esperado ')' após a expressão.");
+        this.consumir(delegua_2.default.COLCHETE_DIREITO, "Esperado ']' após a expressão.");
+        return new tuplas_1.SeletorTuplas(...argumentos);
+    }
     primario() {
         const simboloAtual = this.simbolos[this.atual];
         let valores = [];
         switch (simboloAtual.tipo) {
             case delegua_2.default.CHAVE_ESQUERDA:
-                this.avancarEDevolverAnterior();
-                const chaves = [];
-                valores = [];
-                if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.CHAVE_DIREITA)) {
-                    return new construtos_1.Dicionario(this.hashArquivo, Number(simboloAtual.linha), [], []);
-                }
-                while (!this.verificarSeSimboloAtualEIgualA(delegua_2.default.CHAVE_DIREITA)) {
-                    const chave = this.atribuir();
-                    this.consumir(delegua_2.default.DOIS_PONTOS, "Esperado ':' entre chave e valor.");
-                    const valor = this.atribuir();
-                    chaves.push(chave);
-                    valores.push(valor);
-                    if (this.simbolos[this.atual].tipo !== delegua_2.default.CHAVE_DIREITA) {
-                        this.consumir(delegua_2.default.VIRGULA, 'Esperado vírgula antes da próxima expressão.');
-                    }
-                }
-                return new construtos_1.Dicionario(this.hashArquivo, Number(simboloAtual.linha), chaves, valores);
+                return this.construtoDicionario(simboloAtual);
             case delegua_2.default.COLCHETE_ESQUERDO:
                 this.avancarEDevolverAnterior();
                 valores = [];
@@ -93,19 +138,10 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                     return new construtos_1.Vetor(this.hashArquivo, Number(simboloAtual.linha), [], 0, 'qualquer');
                 }
                 while (!this.verificarSeSimboloAtualEIgualA(delegua_2.default.COLCHETE_DIREITO)) {
-                    let valor = null;
                     if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.PARENTESE_ESQUERDO)) {
-                        const expressao = this.expressao();
-                        const argumentos = [expressao];
-                        while (this.simbolos[this.atual].tipo === delegua_2.default.VIRGULA) {
-                            this.avancarEDevolverAnterior();
-                            argumentos.push(this.expressao());
-                        }
-                        this.consumir(delegua_2.default.PARENTESE_DIREITO, "Esperado ')' após a expressão.");
-                        this.consumir(delegua_2.default.COLCHETE_DIREITO, "Esperado ']' após a expressão.");
-                        return new tuplas_1.SeletorTuplas(...argumentos);
+                        return this.construtoTupla();
                     }
-                    valor = this.atribuir();
+                    const valor = this.atribuir();
                     valores.push(valor);
                     if (this.simbolos[this.atual].tipo !== delegua_2.default.COLCHETE_DIREITO) {
                         this.consumir(delegua_2.default.VIRGULA, 'Esperado vírgula antes da próxima expressão.');
@@ -146,7 +182,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                 return new construtos_1.Isto(this.hashArquivo, Number(simboloAtual.linha), simboloAtual);
             case delegua_2.default.NULO:
                 this.avancarEDevolverAnterior();
-                return new construtos_1.Literal(this.hashArquivo, Number(simboloAtual.linha), null);
+                return new construtos_1.Literal(this.hashArquivo, Number(simboloAtual.linha), null, 'nulo');
             case delegua_2.default.NUMERO:
             case delegua_2.default.TEXTO:
                 const simboloNumeroTexto = this.avancarEDevolverAnterior();
@@ -178,14 +214,67 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             case delegua_2.default.TIPO:
                 this.avancarEDevolverAnterior();
                 this.consumir(delegua_2.default.DE, "Esperado 'de' após 'tipo'.");
-                let _expressao;
+                let construto;
                 if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.ESCREVA, delegua_2.default.LEIA, delegua_2.default.FUNCAO, delegua_2.default.FUNÇÃO, delegua_2.default.SE, delegua_2.default.ENQUANTO, delegua_2.default.PARA, delegua_2.default.RETORNA, delegua_1.default.INTEIRO, delegua_1.default.TEXTO, delegua_1.default.VETOR, delegua_1.default.LOGICO, delegua_1.default.LÓGICO, delegua_1.default.VAZIO)) {
-                    _expressao = this.simboloAnterior();
+                    construto = new construtos_1.ComponenteLinguagem(this.hashArquivo, this.simboloAnterior());
                 }
                 else {
-                    _expressao = this.expressao();
+                    construto = this.expressao();
+                }
+                if (construto.constructor.name === 'AcessoMetodoOuPropriedade') {
+                    const construtoTipado = construto;
+                    switch (construtoTipado.tipo) {
+                        case delegua_1.default.DICIONARIO:
+                        case delegua_1.default.DICIONÁRIO:
+                            if (!(construtoTipado.simbolo.lexema in primitivas_dicionario_1.default)) {
+                                throw this.erro(construtoTipado.simbolo, `${construtoTipado.simbolo.lexema} não é uma primitiva de dicionário.`);
+                            }
+                            const primitivaDicionarioSelecionada = primitivas_dicionario_1.default[construtoTipado.simbolo.lexema];
+                            construto = new construtos_1.AcessoMetodo(construtoTipado.hashArquivo, construtoTipado.objeto, construtoTipado.simbolo.lexema, primitivaDicionarioSelecionada.tipoRetorno);
+                            break;
+                        case delegua_1.default.INTEIRO:
+                        case delegua_1.default.NUMERO:
+                        case delegua_1.default.NÚMERO:
+                            if (!(construtoTipado.simbolo.lexema in primitivas_numero_1.default)) {
+                                throw this.erro(construtoTipado.simbolo, `${construtoTipado.simbolo.lexema} não é uma primitiva de número.`);
+                            }
+                            const primitivaNumeroSelecionada = primitivas_numero_1.default[construtoTipado.simbolo.lexema];
+                            construto = new construtos_1.AcessoMetodo(construtoTipado.hashArquivo, construtoTipado.objeto, construtoTipado.simbolo.lexema, primitivaNumeroSelecionada.tipoRetorno);
+                            break;
+                        case delegua_1.default.TEXTO:
+                            if (!(construtoTipado.simbolo.lexema in primitivas_texto_1.default)) {
+                                throw this.erro(construtoTipado.simbolo, `${construtoTipado.simbolo.lexema} não é uma primitiva de texto.`);
+                            }
+                            const primitivaTextoSelecionada = primitivas_texto_1.default[construtoTipado.simbolo.lexema];
+                            construto = new construtos_1.AcessoMetodo(construtoTipado.hashArquivo, construtoTipado.objeto, construtoTipado.simbolo.lexema, primitivaTextoSelecionada.tipoRetorno);
+                            break;
+                        case delegua_1.default.VETOR:
+                        case delegua_1.default.VETOR_NUMERO:
+                        case delegua_1.default.VETOR_NÚMERO:
+                        case delegua_1.default.VETOR_TEXTO:
+                            if (!(construtoTipado.simbolo.lexema in primitivas_vetor_1.default)) {
+                                throw this.erro(construtoTipado.simbolo, `${construtoTipado.simbolo.lexema} não é uma primitiva de vetor.`);
+                            }
+                            const primitivaVetorSelecionada = primitivas_vetor_1.default[construtoTipado.simbolo.lexema];
+                            construto = new construtos_1.AcessoMetodo(construtoTipado.hashArquivo, construtoTipado.objeto, construtoTipado.simbolo.lexema, primitivaVetorSelecionada.tipoRetorno);
+                            break;
+                        default:
+                            if (construtoTipado.tipo in this.tiposDefinidosEmCodigo) {
+                                const tipoCorrespondente = this.tiposDefinidosEmCodigo[construtoTipado.tipo];
+                                const possivelMetodo = tipoCorrespondente.metodos.filter(m => m.simbolo.lexema === construtoTipado.simbolo.lexema);
+                                if (possivelMetodo.length > 0) {
+                                    construto = new construtos_1.AcessoMetodo(construtoTipado.hashArquivo, construtoTipado.objeto, construtoTipado.simbolo.lexema, possivelMetodo[0].tipoRetorno);
+                                    break;
+                                }
+                                const possivelPropriedade = tipoCorrespondente.propriedades.filter(p => p.nome.lexema === construtoTipado.simbolo.lexema);
+                                if (possivelPropriedade.length > 0) {
+                                    construto = new construtos_1.AcessoPropriedade(construtoTipado.hashArquivo, construtoTipado.objeto, construtoTipado.simbolo.lexema, possivelPropriedade[0].tipo);
+                                    break;
+                                }
+                            }
+                    }
                 }
-                return new construtos_1.TipoDe(this.hashArquivo, simboloAtual, _expressao instanceof construtos_1.Literal ? _expressao.valor : _expressao);
+                return new construtos_1.TipoDe(this.hashArquivo, simboloAtual, construto);
             case delegua_2.default.EXPRESSAO_REGULAR:
                 let valor = '';
                 let linhaAtual = this.simbolos[this.atual].linha;
@@ -241,33 +330,41 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         // Toda chamada precisa saber de antemão qual o tipo resolvido.
         let entidadeChamadaResolvida = entidadeChamada;
         if (entidadeChamadaResolvida.constructor.name === 'AcessoMetodoOuPropriedade') {
-            const acessoMetodoOuPropriedade = entidadeChamadaResolvida;
+            const construtoTipado = entidadeChamadaResolvida;
             switch (entidadeChamadaResolvida.tipo) {
+                case delegua_1.default.DICIONARIO:
+                case delegua_1.default.DICIONÁRIO:
+                    if (!(construtoTipado.simbolo.lexema in primitivas_dicionario_1.default)) {
+                        throw this.erro(construtoTipado.simbolo, `${construtoTipado.simbolo.lexema} não é uma primitiva de dicionário.`);
+                    }
+                    const primitivaDicionarioSelecionada = primitivas_dicionario_1.default[construtoTipado.simbolo.lexema];
+                    entidadeChamadaResolvida = new construtos_1.AcessoMetodo(construtoTipado.hashArquivo, construtoTipado.objeto, construtoTipado.simbolo.lexema, primitivaDicionarioSelecionada.tipoRetorno);
+                    break;
                 case delegua_1.default.INTEIRO:
                 case delegua_1.default.NUMERO:
                 case delegua_1.default.NÚMERO:
-                    if (!(acessoMetodoOuPropriedade.simbolo.lexema in primitivas_numero_1.default)) {
-                        throw this.erro(acessoMetodoOuPropriedade.simbolo, `${acessoMetodoOuPropriedade.simbolo.lexema} não é uma primitiva de número.`);
+                    if (!(construtoTipado.simbolo.lexema in primitivas_numero_1.default)) {
+                        throw this.erro(construtoTipado.simbolo, `${construtoTipado.simbolo.lexema} não é uma primitiva de número.`);
                     }
-                    const primitivaNumeroSelecionada = primitivas_numero_1.default[acessoMetodoOuPropriedade.simbolo.lexema];
-                    entidadeChamadaResolvida = new construtos_1.AcessoMetodo(acessoMetodoOuPropriedade.hashArquivo, acessoMetodoOuPropriedade.objeto, acessoMetodoOuPropriedade.simbolo.lexema, primitivaNumeroSelecionada.tipoRetorno);
+                    const primitivaNumeroSelecionada = primitivas_numero_1.default[construtoTipado.simbolo.lexema];
+                    entidadeChamadaResolvida = new construtos_1.AcessoMetodo(construtoTipado.hashArquivo, construtoTipado.objeto, construtoTipado.simbolo.lexema, primitivaNumeroSelecionada.tipoRetorno);
                     break;
                 case delegua_1.default.TEXTO:
-                    if (!(acessoMetodoOuPropriedade.simbolo.lexema in primitivas_texto_1.default)) {
-                        throw this.erro(acessoMetodoOuPropriedade.simbolo, `${acessoMetodoOuPropriedade.simbolo.lexema} não é uma primitiva de texto.`);
+                    if (!(construtoTipado.simbolo.lexema in primitivas_texto_1.default)) {
+                        throw this.erro(construtoTipado.simbolo, `${construtoTipado.simbolo.lexema} não é uma primitiva de texto.`);
                     }
-                    const primitivaTextoSelecionada = primitivas_texto_1.default[acessoMetodoOuPropriedade.simbolo.lexema];
-                    entidadeChamadaResolvida = new construtos_1.AcessoMetodo(acessoMetodoOuPropriedade.hashArquivo, acessoMetodoOuPropriedade.objeto, acessoMetodoOuPropriedade.simbolo.lexema, primitivaTextoSelecionada.tipoRetorno);
+                    const primitivaTextoSelecionada = primitivas_texto_1.default[construtoTipado.simbolo.lexema];
+                    entidadeChamadaResolvida = new construtos_1.AcessoMetodo(construtoTipado.hashArquivo, construtoTipado.objeto, construtoTipado.simbolo.lexema, primitivaTextoSelecionada.tipoRetorno);
                     break;
                 case delegua_1.default.VETOR:
                 case delegua_1.default.VETOR_NUMERO:
                 case delegua_1.default.VETOR_NÚMERO:
                 case delegua_1.default.VETOR_TEXTO:
-                    if (!(acessoMetodoOuPropriedade.simbolo.lexema in primitivas_vetor_1.default)) {
-                        throw this.erro(acessoMetodoOuPropriedade.simbolo, `${acessoMetodoOuPropriedade.simbolo.lexema} não é uma primitiva de vetor.`);
+                    if (!(construtoTipado.simbolo.lexema in primitivas_vetor_1.default)) {
+                        throw this.erro(construtoTipado.simbolo, `${construtoTipado.simbolo.lexema} não é uma primitiva de vetor.`);
                     }
-                    const primitivaVetorSelecionada = primitivas_vetor_1.default[acessoMetodoOuPropriedade.simbolo.lexema];
-                    entidadeChamadaResolvida = new construtos_1.AcessoMetodo(acessoMetodoOuPropriedade.hashArquivo, acessoMetodoOuPropriedade.objeto, acessoMetodoOuPropriedade.simbolo.lexema, primitivaVetorSelecionada.tipoRetorno);
+                    const primitivaVetorSelecionada = primitivas_vetor_1.default[construtoTipado.simbolo.lexema];
+                    entidadeChamadaResolvida = new construtos_1.AcessoMetodo(construtoTipado.hashArquivo, construtoTipado.objeto, construtoTipado.simbolo.lexema, primitivaVetorSelecionada.tipoRetorno);
                     break;
             }
         }
@@ -403,8 +500,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                 return new construtos_1.Atribuir(this.hashArquivo, simbolo, valor);
             }
             if (expressao instanceof construtos_1.AcessoMetodoOuPropriedade) {
-                const get = expressao;
-                return new construtos_1.DefinirValor(this.hashArquivo, igual.linha, get.objeto, get.simbolo, valor);
+                return new construtos_1.DefinirValor(this.hashArquivo, igual.linha, expressao.objeto, expressao.simbolo, valor);
             }
             if (expressao instanceof construtos_1.AcessoIndiceVariavel) {
                 return new construtos_1.AtribuicaoPorIndice(this.hashArquivo, expressao.linha, expressao.entidadeChamada, expressao.indice, valor);
@@ -870,6 +966,47 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         this.pilhaDecoradores = [];
         return retornos;
     }
+    logicaComumInferenciaTiposVariaveisEConstantes(inicializador, tipo) {
+        if (tipo !== 'qualquer') {
+            return tipo;
+        }
+        switch (inicializador.constructor.name) {
+            case 'AcessoIndiceVariavel':
+                const entidadeChamadaAcessoIndiceVariavel = inicializador.entidadeChamada;
+                return entidadeChamadaAcessoIndiceVariavel.tipo.slice(0, -2);
+            case 'Chamada':
+                const entidadeChamadaChamada = inicializador.entidadeChamada;
+                switch (entidadeChamadaChamada.constructor.name) {
+                    case 'AcessoMetodo':
+                        const entidadeChamadaAcessoMetodo = entidadeChamadaChamada;
+                        return entidadeChamadaAcessoMetodo.tipoRetornoMetodo;
+                    case 'AcessoPropriedade':
+                        const entidadeChamadaAcessoPropriedade = entidadeChamadaChamada;
+                        return entidadeChamadaAcessoPropriedade.tipoRetornoPropriedade;
+                    case 'Variavel':
+                        const entidadeChamadaVariavel = entidadeChamadaChamada;
+                        return entidadeChamadaVariavel.tipo;
+                }
+                break;
+            case 'FuncaoConstruto':
+                const funcaoConstruto = inicializador;
+                return `função<${funcaoConstruto.tipoRetorno}>`;
+            case 'Leia':
+                return 'texto';
+            case 'Dupla':
+            case 'Trio':
+            case 'Quarteto':
+            case 'Quinteto':
+            case 'Sexteto':
+            case 'Septeto':
+            case 'Octeto':
+            case 'Noneto':
+            case 'Deceto':
+                return delegua_1.default.TUPLA;
+            default:
+                return inicializador.tipo;
+        }
+    }
     /**
      * Caso símbolo atual seja `var`, devolve uma declaração de variável.
      * @returns Um Construto do tipo Var.
@@ -907,43 +1044,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         }
         for (let [indice, identificador] of identificadores.entries()) {
             // Se tipo ainda não foi definido, infere.
-            if (tipo === 'qualquer') {
-                switch (inicializadores[indice].constructor.name) {
-                    case 'AcessoIndiceVariavel':
-                        const entidadeChamadaAcessoIndiceVariavel = inicializadores[indice].entidadeChamada;
-                        tipo = entidadeChamadaAcessoIndiceVariavel.tipo.slice(0, -2);
-                        break;
-                    case 'Chamada':
-                        const entidadeChamadaChamada = inicializadores[indice].entidadeChamada;
-                        switch (entidadeChamadaChamada.constructor.name) {
-                            case 'AcessoMetodo':
-                                const entidadeChamadaAcessoMetodo = entidadeChamadaChamada;
-                                tipo = entidadeChamadaAcessoMetodo.tipoRetornoMetodo;
-                                break;
-                            case 'AcessoPropriedade':
-                                const entidadeChamadaAcessoPropriedade = entidadeChamadaChamada;
-                                tipo = entidadeChamadaAcessoPropriedade.tipoRetornoPropriedade;
-                                break;
-                        }
-                        break;
-                    case 'Dupla':
-                    case 'Trio':
-                    case 'Quarteto':
-                    case 'Quinteto':
-                    case 'Sexteto':
-                    case 'Septeto':
-                    case 'Octeto':
-                    case 'Noneto':
-                    case 'Deceto':
-                        tipo = delegua_1.default.TUPLA;
-                        break;
-                    case 'Literal':
-                    case 'Variavel':
-                    case 'Vetor':
-                        tipo = inicializadores[indice].tipo;
-                        break;
-                }
-            }
+            tipo = this.logicaComumInferenciaTiposVariaveisEConstantes(inicializadores[indice], tipo);
             this.pilhaEscopos.definirTipoVariavel(identificador.lexema, tipo);
             retorno.push(new declaracoes_1.Var(identificador, inicializadores[indice], tipo, Array.from(this.pilhaDecoradores)));
         }
@@ -996,30 +1097,8 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         }
         let retorno = [];
         for (let [indice, identificador] of identificadores.entries()) {
-            if (tipo === 'qualquer') {
-                switch (inicializadores[indice].constructor.name) {
-                    case 'AcessoIndiceVariavel':
-                        const entidadeChamada = inicializadores[indice].entidadeChamada;
-                        tipo = entidadeChamada.tipo.slice(0, -2);
-                        break;
-                    case 'Dupla':
-                    case 'Trio':
-                    case 'Quarteto':
-                    case 'Quinteto':
-                    case 'Sexteto':
-                    case 'Septeto':
-                    case 'Octeto':
-                    case 'Noneto':
-                    case 'Deceto':
-                        tipo = delegua_1.default.TUPLA;
-                        break;
-                    case 'Literal':
-                    case 'Variavel':
-                    case 'Vetor':
-                        tipo = inicializadores[indice].tipo;
-                        break;
-                }
-            }
+            // Se tipo ainda não foi definido, infere.
+            tipo = this.logicaComumInferenciaTiposVariaveisEConstantes(inicializadores[indice], tipo);
             this.pilhaEscopos.definirTipoVariavel(identificador.lexema, tipo);
             retorno.push(new declaracoes_1.Const(identificador, inicializadores[indice], tipo, Array.from(this.pilhaDecoradores)));
         }
@@ -1043,8 +1122,8 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         // para ela. Vai ser atualizado após avaliação do corpo da função.
         this.pilhaEscopos.definirTipoVariavel(simbolo.lexema, 'qualquer');
         const corpoDaFuncao = this.corpoDaFuncao(tipo);
-        this.pilhaEscopos.definirTipoVariavel(simbolo.lexema, corpoDaFuncao.tipoRetorno || 'qualquer');
-        return new declaracoes_1.FuncaoDeclaracao(simbolo, corpoDaFuncao, corpoDaFuncao.tipoRetorno || 'qualquer', decoradores);
+        this.pilhaEscopos.definirTipoVariavel(simbolo.lexema, corpoDaFuncao.tipoRetorno);
+        return new declaracoes_1.FuncaoDeclaracao(simbolo, corpoDaFuncao, corpoDaFuncao.tipoRetorno, decoradores);
     }
     logicaComumParametros() {
         const parametros = [];
@@ -1123,9 +1202,11 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         }
         this.consumir(delegua_2.default.PARENTESE_DIREITO, "Esperado ')' após parâmetros.");
         let tipoRetorno = 'qualquer';
+        let definicaoExplicitaDeTipo = false;
         if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.DOIS_PONTOS)) {
             tipoRetorno = this.verificarDefinicaoTipoAtual();
             this.avancarEDevolverAnterior();
+            definicaoExplicitaDeTipo = true;
         }
         this.consumir(delegua_2.default.CHAVE_ESQUERDA, `Esperado '{' antes do escopo do ${tipo}.`);
         const corpo = this.blocoEscopo();
@@ -1140,19 +1221,25 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             }
         }
         const tiposRetornos = new Set(expressoesRetorna.map(e => e.tipo));
-        // if (tiposRetornos.size > 1 && !tiposRetornos.has('qualquer')) {
         if (tiposRetornos.size > 1 && tipoRetorno !== 'qualquer') {
             let tiposEncontrados = Array.from(tiposRetornos).reduce((acumulador, valor) => acumulador += valor + ', ', '');
             tiposEncontrados = tiposEncontrados.slice(0, -2);
             throw this.erro(parenteseEsquerdo, `Função retorna valores com mais de um tipo. Tipo esperado: ${tipoRetorno}. Tipos encontrados: ${tiposEncontrados}.`);
         }
         tiposRetornos.delete('qualquer');
-        if (tipoRetorno === 'qualquer' && tiposRetornos.size === 1) {
-            // Se o tipo de retorno é 'qualquer', seja implícito ou explícito,
-            // este avaliador sintático pode restringir o tipo baseado nos retornos 
-            // encontrados nos blocos internos da função.
-            const tipoRetornoDeduzido = tiposRetornos.values().next().value;
-            tipoRetorno = tipoRetornoDeduzido;
+        if (tipoRetorno === 'qualquer') {
+            if (tiposRetornos.size > 0) {
+                // Se o tipo de retorno é 'qualquer', seja implícito ou explícito,
+                // este avaliador sintático pode restringir o tipo baseado nos construtos
+                // de retornos encontrados nos blocos internos da função.
+                const tipoRetornoDeduzido = tiposRetornos.values().next().value;
+                tipoRetorno = tipoRetornoDeduzido;
+            }
+            else if (!definicaoExplicitaDeTipo) {
+                // Ou, se esses retornos sequer existem, e o tipo explícito não é
+                // 'qualquer', o tipo inferido é 'vazio'.
+                tipoRetorno = 'vazio';
+            }
         }
         return new construtos_1.FuncaoConstruto(this.hashArquivo, Number(parenteseEsquerdo.linha), parametros, corpo, tipoRetorno);
     }