@designliquido/delegua 0.39.0 → 0.39.2

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;
             }
         }
@@ -389,22 +486,18 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             ].includes(expressao.operador.tipo)) {
             if (expressao.esquerda instanceof construtos_1.AcessoIndiceVariavel) {
                 const entidade = expressao.esquerda;
-                const simbolo = entidade.entidadeChamada.simbolo;
-                return new construtos_1.Atribuir(this.hashArquivo, simbolo, expressao, entidade.indice);
+                return new construtos_1.Atribuir(this.hashArquivo, entidade.entidadeChamada, expressao, entidade.indice, expressao.operador);
             }
-            const simbolo = expressao.esquerda.simbolo;
-            return new construtos_1.Atribuir(this.hashArquivo, simbolo, expressao);
+            return new construtos_1.Atribuir(this.hashArquivo, expressao.esquerda, expressao, undefined, expressao.operador);
         }
         else if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.IGUAL)) {
             const igual = this.simbolos[this.atual - 1];
             const valor = this.expressao();
             if (expressao instanceof construtos_1.Variavel) {
-                const simbolo = expressao.simbolo;
-                return new construtos_1.Atribuir(this.hashArquivo, simbolo, valor);
+                return new construtos_1.Atribuir(this.hashArquivo, expressao, 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 +963,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 +1041,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 +1094,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 +1119,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 +1199,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 +1218,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);
     }