@designliquido/delegua 0.38.2 → 0.38.4

package/umd/delegua.js

@@ -22,7 +22,8 @@ class AvaliadorSintaticoBase {
     }
     erro(simbolo, mensagemDeErro) {
         const excecao = new erro_avaliador_sintatico_1.ErroAvaliadorSintatico(simbolo, mensagemDeErro);
-        this.erros.push(excecao);
+        // TODO: Estudar remover.
+        // this.erros.push(excecao);
         return excecao;
     }
     simboloAnterior() {
@@ -165,7 +166,7 @@ class AvaliadorSintaticoBase {
         const parametros = [];
         do {
             if (parametros.length >= 255) {
-                this.erro(this.simbolos[this.atual], 'Função não pode ter mais de 255 parâmetros.');
+                throw this.erro(this.simbolos[this.atual], 'Função não pode ter mais de 255 parâmetros.');
             }
             const parametro = {};
             if (this.simbolos[this.atual].tipo === comum_1.default.MULTIPLICACAO) {
@@ -255,6 +256,12 @@ const informacao_escopo_1 = require("./informacao-escopo");
  * O avaliador sintático (_Parser_) é responsável por transformar os símbolos do Lexador em estruturas de alto nível.
  * Essas estruturas de alto nível são as partes que executam lógica de programação de fato.
  * Há dois grupos de estruturas de alto nível: Construtos e Declarações.
+ *
+ * Construtos não existem por si só: cada construto precisa estar dentro de uma declaração para ser
+ * aceito pela próxima etapa, como tradução, interpretação, análise semântica, etc.
+ *
+ * Diferentemente de outros dialetos, em Delégua um construto normalmente retorna um tipo.
+ * Por isso a separação deste avaliador sintático do avaliador sintático base.
  */
 class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBase {
     constructor(performance = false) {
@@ -361,9 +368,9 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                 if (this.simbolos[this.atual] &&
                     [delegua_2.default.INCREMENTAR, delegua_2.default.DECREMENTAR].includes(this.simbolos[this.atual].tipo)) {
                     const simboloIncrementoDecremento = this.avancarEDevolverAnterior();
-                    return new construtos_1.Unario(this.hashArquivo, simboloIncrementoDecremento, new construtos_1.Variavel(this.hashArquivo, simboloIdentificador, tipoOperando), 'DEPOIS');
+                    return new construtos_1.Unario(this.hashArquivo, simboloIncrementoDecremento, new construtos_1.Variavel(this.hashArquivo, simboloIdentificador, tipoOperando || 'qualquer'), 'DEPOIS');
                 }
-                return new construtos_1.Variavel(this.hashArquivo, simboloIdentificador, tipoOperando);
+                return new construtos_1.Variavel(this.hashArquivo, simboloIdentificador, tipoOperando || 'qualquer');
             case delegua_2.default.IMPORTAR:
                 this.avancarEDevolverAnterior();
                 return this.declaracaoImportar();
@@ -583,7 +590,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             if (expressao instanceof construtos_1.AcessoIndiceVariavel) {
                 return new construtos_1.AtribuicaoPorIndice(this.hashArquivo, expressao.linha, expressao.entidadeChamada, expressao.indice, valor);
             }
-            this.erro(igual, 'Tarefa de atribuição inválida');
+            throw this.erro(igual, 'Tarefa de atribuição inválida');
         }
         return expressao;
     }
@@ -650,7 +657,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         do {
             simboloComentario = this.avancarEDevolverAnterior();
             conteudos.push(simboloComentario.literal);
-        } while (simboloComentario.tipo === delegua_2.default.LINHA_COMENTARIO);
+        } while (this.verificarTipoSimboloAtual(delegua_2.default.LINHA_COMENTARIO));
         return new construtos_1.Comentario(simboloComentario.hashArquivo, simboloComentario.linha, conteudos, true);
     }
     declaracaoComentarioUmaLinha() {
@@ -659,7 +666,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
     }
     declaracaoContinua() {
         if (this.blocos < 1) {
-            this.erro(this.simbolos[this.atual - 1], "'continua' precisa estar em um laço de repetição.");
+            throw this.erro(this.simbolos[this.atual - 1], "'continua' precisa estar em um laço de repetição.");
         }
         // Ponto-e-vírgula é opcional aqui.
         this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA);
@@ -857,7 +864,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
     }
     declaracaoSustar() {
         if (this.blocos < 1) {
-            this.erro(this.simbolos[this.atual - 1], "'sustar' ou 'pausa' deve estar dentro de um laço de repetição.");
+            throw this.erro(this.simbolos[this.atual - 1], "'sustar' ou 'pausa' deve estar dentro de um laço de repetição.");
         }
         // Ponto-e-vírgula é opcional aqui.
         this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA);
@@ -993,7 +1000,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             if (!!simboloAnterior &&
                 simboloAnterior.tipo === delegua_2.default.IDENTIFICADOR &&
                 simboloAnterior.linha === simboloAtual.linha) {
-                this.erro(this.simbolos[this.atual], 'Não é permitido ter dois identificadores seguidos na mesma linha.');
+                throw this.erro(this.simbolos[this.atual], 'Não é permitido ter dois identificadores seguidos na mesma linha.');
             }
         }
         return this.declaracaoExpressao();
@@ -1036,7 +1043,6 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         const inicializador = this.expressao();
         const retornos = [];
         for (let identificador of identificadores) {
-            // TODO: Melhorar dicionário para intuir o tipo de cada propriedade.
             this.pilhaEscopos.definirTipoVariavel(identificador.lexema, 'qualquer');
             const declaracaoVar = new declaracoes_1.Var(identificador, new construtos_1.AcessoMetodoOuPropriedade(this.hashArquivo, inicializador, identificador));
             declaracaoVar.decoradores = Array.from(this.pilhaDecoradores);
@@ -1052,7 +1058,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
     declaracaoDeVariaveis() {
         const identificadores = [];
         const retorno = [];
-        let tipo = null;
+        let tipo = 'qualquer';
         if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.CHAVE_ESQUERDA)) {
             return this.declaracaoDesestruturacaoVariavel();
         }
@@ -1082,8 +1088,12 @@ 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) {
+            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':
@@ -1096,6 +1106,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                         tipo = delegua_1.default.TUPLA;
                         break;
                     case 'Literal':
+                    case 'Variavel':
                     case 'Vetor':
                         tipo = inicializadores[indice].tipo;
                         break;
@@ -1132,7 +1143,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
      */
     declaracaoDeConstantes() {
         const identificadores = [];
-        let tipo = null;
+        let tipo = 'qualquer';
         if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.CHAVE_ESQUERDA)) {
             return this.declaracaoDesestruturacaoConstante();
         }
@@ -1153,8 +1164,29 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         }
         let retorno = [];
         for (let [indice, identificador] of identificadores.entries()) {
-            if (!tipo) {
-                tipo = (0, inferenciador_1.inferirTipoVariavel)(inicializadores[indice]);
+            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;
+                }
             }
             this.pilhaEscopos.definirTipoVariavel(identificador.lexema, tipo);
             retorno.push(new declaracoes_1.Const(identificador, inicializadores[indice], tipo, Array.from(this.pilhaDecoradores)));
@@ -1180,7 +1212,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         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, null, decoradores);
+        return new declaracoes_1.FuncaoDeclaracao(simbolo, corpoDaFuncao, corpoDaFuncao.tipoRetorno || 'qualquer', decoradores);
     }
     logicaComumParametros() {
         const parametros = [];
@@ -1210,6 +1242,45 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         } while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.VIRGULA));
         return parametros;
     }
+    *buscarRetornosEmBloco(construtoBloco) {
+        for (const declaracao of construtoBloco.declaracoes) {
+            if (declaracao.constructor.name === 'Retorna') {
+                yield declaracao;
+            }
+        }
+    }
+    *buscarRetornosEmSe(construtoSe) {
+        const blocoEntao = construtoSe.caminhoEntao;
+        for (const declaracao of this.buscarRetornosEmBloco(blocoEntao)) {
+            if (declaracao.constructor.name === 'Retorna') {
+                yield declaracao;
+            }
+        }
+        const blocoSenao = construtoSe.caminhoSenao;
+        if (!blocoSenao)
+            return;
+        for (const declaracao of blocoSenao.declaracoes) {
+            if (declaracao.constructor.name === 'Retorna') {
+                yield declaracao;
+            }
+        }
+    }
+    buscarRetornos(declaracao) {
+        let retornasEncontrados = [];
+        switch (declaracao.constructor.name) {
+            case 'Retorna':
+                retornasEncontrados.push(declaracao);
+                break;
+            case 'Se':
+                for (const retorna of this.buscarRetornosEmSe(declaracao)) {
+                    retornasEncontrados.push(retorna);
+                }
+                break;
+            default:
+                break;
+        }
+        return retornasEncontrados;
+    }
     corpoDaFuncao(tipo) {
         // O parêntese esquerdo é considerado o símbolo inicial para
         // fins de pragma.
@@ -1226,6 +1297,31 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         }
         this.consumir(delegua_2.default.CHAVE_ESQUERDA, `Esperado '{' antes do escopo do ${tipo}.`);
         const corpo = this.blocoEscopo();
+        let expressoesRetorna = [];
+        for (const declaracao of corpo) {
+            expressoesRetorna = expressoesRetorna.concat(this.buscarRetornos(declaracao));
+        }
+        if (tipoRetorno === 'vazio' && expressoesRetorna.length > 0) {
+            const retornosNaoVazios = expressoesRetorna.filter(e => e.tipo !== 'vazio');
+            if (retornosNaoVazios.length > 0) {
+                throw this.erro(retornosNaoVazios[0].simboloChave, `Função declara explicitamente 'vazio', mas usa expressão 'retorna' com tipo de retorno diferente de vazio.`);
+            }
+        }
+        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;
+        }
         return new construtos_1.FuncaoConstruto(this.hashArquivo, Number(parenteseEsquerdo.linha), parametros, corpo, tipoRetorno);
     }
     declaracaoDeClasse() {
@@ -1234,6 +1330,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         let superClasse = null;
         if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.HERDA)) {
             const simboloSuperclasse = this.consumir(delegua_2.default.IDENTIFICADOR, 'Esperado nome da Superclasse.');
+            // TODO: Colocar tipo aqui?
             superClasse = new construtos_1.Variavel(this.hashArquivo, this.simbolos[this.atual - 1], simboloSuperclasse.lexema);
         }
         this.consumir(delegua_2.default.CHAVE_ESQUERDA, "Esperado '{' antes do escopo da classe.");
@@ -1367,7 +1464,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             if (Array.isArray(retornoDeclaracao)) {
                 declaracoes = declaracoes.concat(retornoDeclaracao);
             }
-            else {
+            else if (retornoDeclaracao !== null) {
                 declaracoes.push(retornoDeclaracao);
             }
         }
@@ -1703,7 +1800,7 @@ class AvaliadorSintaticoEguaClassico {
             else if (expressao instanceof construtos_1.AcessoIndiceVariavel) {
                 return new construtos_1.AtribuicaoPorIndice(this.hashArquivo, 0, expressao.entidadeChamada, expressao.indice, valor);
             }
-            this.erro(igual, 'Tarefa de atribuição inválida');
+            throw this.erro(igual, 'Tarefa de atribuição inválida');
         }
         return expressao;
     }
@@ -1800,14 +1897,14 @@ class AvaliadorSintaticoEguaClassico {
     }
     declaracaoSustar() {
         if (this.blocos < 1) {
-            this.erro(this.simboloAnterior(), "'pausa' deve estar dentro de um loop.");
+            throw this.erro(this.simboloAnterior(), "'pausa' deve estar dentro de um loop.");
         }
         this.consumir(egua_classico_1.default.PONTO_E_VIRGULA, "Esperado ';' após 'pausa'.");
         return new declaracoes_1.Sustar(this.simboloAtual());
     }
     declaracaoContinua() {
         if (this.blocos < 1) {
-            this.erro(this.simboloAnterior(), "'continua' precisa estar em um laço de repetição.");
+            throw this.erro(this.simboloAnterior(), "'continua' precisa estar em um laço de repetição.");
         }
         this.consumir(egua_classico_1.default.PONTO_E_VIRGULA, "Esperado ';' após 'continua'.");
         return new declaracoes_1.Continua(this.simboloAtual());
@@ -1958,7 +2055,7 @@ class AvaliadorSintaticoEguaClassico {
         if (!this.verificarTipoSimboloAtual(egua_classico_1.default.PARENTESE_DIREITO)) {
             do {
                 if (parametros.length >= 255) {
-                    this.erro(this.simboloAtual(), 'Função não pode ter mais de 255 parâmetros.');
+                    throw this.erro(this.simboloAtual(), 'Função não pode ter mais de 255 parâmetros.');
                 }
                 const parametro = {};
                 if (this.simboloAtual().tipo === egua_classico_1.default.MULTIPLICACAO) {
@@ -2373,13 +2470,13 @@ class AvaliadorSintaticoPitugues {
                 const simbolo = expressao.simbolo;
                 return new construtos_1.Atribuir(this.hashArquivo, simbolo, valor);
             }
-            else if (expressao instanceof construtos_1.AcessoMetodoOuPropriedade) {
+            if (expressao instanceof construtos_1.AcessoMetodoOuPropriedade) {
                 return new construtos_1.DefinirValor(this.hashArquivo, 0, expressao.objeto, expressao.simbolo, valor);
             }
-            else if (expressao instanceof construtos_1.AcessoIndiceVariavel) {
+            if (expressao instanceof construtos_1.AcessoIndiceVariavel) {
                 return new construtos_1.AtribuicaoPorIndice(this.hashArquivo, 0, expressao.entidadeChamada, expressao.indice, valor);
             }
-            this.erro(igual, 'Tarefa de atribuição inválida');
+            throw this.erro(igual, 'Tarefa de atribuição inválida');
         }
         return expressao;
     }
@@ -2432,7 +2529,7 @@ class AvaliadorSintaticoPitugues {
             let espacosIndentacaoLinhaAtual = this.pragmas[simboloAtual.linha].espacosIndentacao;
             const espacosIndentacaoLinhaAnterior = this.pragmas[simboloAnterior.linha].espacosIndentacao;
             if (espacosIndentacaoLinhaAtual <= espacosIndentacaoLinhaAnterior) {
-                this.erro(simboloAtual, `Indentação inconsistente na linha ${simboloAtual.linha}. ` +
+                throw this.erro(simboloAtual, `Indentação inconsistente na linha ${simboloAtual.linha}. ` +
                     `Esperado: >= ${espacosIndentacaoLinhaAnterior}. ` +
                     `Atual: ${espacosIndentacaoLinhaAtual}`);
             }
@@ -2566,13 +2663,13 @@ class AvaliadorSintaticoPitugues {
     }
     declaracaoSustar() {
         if (this.blocos < 1) {
-            this.erro(this.simboloAnterior(), "'sustar' deve estar dentro de um laço de repetição.");
+            throw this.erro(this.simboloAnterior(), "'sustar' deve estar dentro de um laço de repetição.");
         }
         return new declaracoes_1.Sustar(this.simboloAtual());
     }
     declaracaoContinua() {
         if (this.blocos < 1) {
-            this.erro(this.simboloAnterior(), "'continua' precisa estar em um laço de repetição.");
+            throw this.erro(this.simboloAnterior(), "'continua' precisa estar em um laço de repetição.");
         }
         return new declaracoes_1.Continua(this.simboloAtual());
     }
@@ -2701,7 +2798,7 @@ class AvaliadorSintaticoPitugues {
         const parametros = [];
         do {
             if (parametros.length >= 255) {
-                this.erro(this.simboloAtual(), 'Função não pode ter mais de 255 parâmetros.');
+                throw this.erro(this.simboloAtual(), 'Função não pode ter mais de 255 parâmetros.');
             }
             const parametro = {};
             if (this.simboloAtual().tipo === pitugues_1.default.MULTIPLICACAO) {
@@ -2847,7 +2944,7 @@ class AvaliadorSintaticoPortugolIpt extends avaliador_sintatico_base_1.Avaliador
             else if (expressao instanceof construtos_1.AcessoIndiceVariavel) {
                 return new construtos_1.AtribuicaoPorIndice(this.hashArquivo, expressao.linha, expressao.entidadeChamada, expressao.indice, valor);
             }
-            this.erro(setaAtribuicao, 'Tarefa de atribuição inválida');
+            throw this.erro(setaAtribuicao, 'Tarefa de atribuição inválida');
         }
         return expressao;
     }
@@ -2907,7 +3004,7 @@ class AvaliadorSintaticoPortugolIpt extends avaliador_sintatico_base_1.Avaliador
                 const literalInicializacao = this.consumir(portugol_ipt_1.default.INTEIRO, 'Esperado literal inteiro após símbolo de igual em declaração de variável.');
                 valorInicializacao = Number(literalInicializacao.literal);
             }
-            inicializacoes.push(new declaracoes_1.Var(identificador, new construtos_1.Literal(this.hashArquivo, Number(simboloInteiro.linha), valorInicializacao)));
+            inicializacoes.push(new declaracoes_1.Var(identificador, new construtos_1.Literal(this.hashArquivo, Number(simboloInteiro.linha), valorInicializacao, 'inteiro')));
         } while (this.verificarSeSimboloAtualEIgualA(portugol_ipt_1.default.VIRGULA));
         return inicializacoes;
     }
@@ -4064,7 +4161,9 @@ exports.default = {
         let elemento = vetor.pop();
         return Promise.resolve(elemento);
     },
-    somar: (interpretador, vetor) => Promise.resolve(vetor.reduce((a, b) => a + b)),
+    somar: (interpretador, vetor) => {
+        return Promise.resolve(vetor.reduce((acc, item) => acc + (typeof item === 'number' ? item : item.valor), 0));
+    },
     tamanho: (interpretador, vetor) => Promise.resolve(vetor.length),
 };
 
@@ -4118,11 +4217,12 @@ exports.AcessoMetodoOuPropriedade = void 0;
  * classe.
  */
 class AcessoMetodoOuPropriedade {
-    constructor(hashArquivo, objeto, simbolo) {
+    constructor(hashArquivo, objeto, simbolo, tipo = 'qualquer') {
         this.linha = objeto.linha;
         this.hashArquivo = hashArquivo;
         this.objeto = objeto;
         this.simbolo = simbolo;
+        this.tipo = objeto.tipo || tipo;
     }
     async aceitar(visitante) {
         return await visitante.visitarExpressaoAcessoMetodo(this);
@@ -4144,6 +4244,7 @@ class Agrupamento {
         this.linha = linha;
         this.hashArquivo = hashArquivo;
         this.expressao = expressao;
+        this.tipo = expressao.tipo;
     }
     async aceitar(visitante) {
         return await visitante.visitarExpressaoAgrupamento(this);
@@ -4263,6 +4364,7 @@ class Binario {
         if (['numero', 'número'].includes(this.esquerda.tipo) || ['numero', 'número'].includes(this.direita.tipo)) {
             return 'número';
         }
+        return 'qualquer';
     }
     async aceitar(visitante) {
         return await visitante.visitarExpressaoBinaria(this);
@@ -5058,11 +5160,16 @@ const declaracao_1 = require("./declaracao");
  * Uma declaração de constante.
  */
 class Const extends declaracao_1.Declaracao {
-    constructor(simbolo, inicializador, tipo = undefined, decoradores = []) {
+    constructor(simbolo, inicializador, tipo = 'qualquer', decoradores = []) {
         super(Number(simbolo.linha), simbolo.hashArquivo, decoradores);
         this.simbolo = simbolo;
         this.inicializador = inicializador;
-        this.tipo = tipo;
+        if (tipo !== 'qualquer') {
+            this.tipo = tipo;
+        }
+        else {
+            this.tipo = (inicializador === null || inicializador === void 0 ? void 0 : inicializador.tipo) || tipo;
+        }
     }
     async aceitar(visitante) {
         return await visitante.visitarDeclaracaoConst(this);
@@ -5230,8 +5337,11 @@ exports.Fazer = Fazer;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FuncaoDeclaracao = void 0;
 const declaracao_1 = require("./declaracao");
+/**
+ * Uma declaração de função.
+ */
 class FuncaoDeclaracao extends declaracao_1.Declaracao {
-    constructor(simbolo, funcao, tipoRetorno, decoradores = []) {
+    constructor(simbolo, funcao, tipoRetorno = 'qualquer', decoradores = []) {
         super(Number(simbolo.linha), simbolo.hashArquivo);
         this.simbolo = simbolo;
         this.funcao = funcao;
@@ -5443,7 +5553,13 @@ class Retorna extends declaracao_1.Declaracao {
     constructor(simboloChave, valor) {
         super(Number(simboloChave.linha), simboloChave.hashArquivo);
         this.simboloChave = simboloChave;
-        this.valor = valor;
+        if (valor) {
+            this.valor = valor;
+            this.tipo = valor.tipo;
+        }
+        else {
+            this.tipo = 'vazio';
+        }
     }
     async aceitar(visitante) {
         return await visitante.visitarExpressaoRetornar(this);
@@ -5561,11 +5677,16 @@ const declaracao_1 = require("./declaracao");
  * Uma declaração de variável.
  */
 class Var extends declaracao_1.Declaracao {
-    constructor(simbolo, inicializador, tipo = undefined, decoradores = []) {
+    constructor(simbolo, inicializador, tipo = 'qualquer', decoradores = []) {
         super(Number(simbolo.linha), simbolo.hashArquivo, decoradores);
         this.simbolo = simbolo;
         this.inicializador = inicializador;
-        this.tipo = tipo;
+        if (tipo !== 'qualquer') {
+            this.tipo = tipo;
+        }
+        else {
+            this.tipo = (inicializador === null || inicializador === void 0 ? void 0 : inicializador.tipo) || tipo;
+        }
         this.referencia = false;
         this.desestruturacao = false;
     }
@@ -6958,7 +7079,7 @@ var TipoNativoSimbolo;
     TipoNativoSimbolo["VAZIO"] = "<palavra reservada vazio ajuda=\"palavra reservada usada para definir fun\u00E7\u00F5es que n\u00E3o retornam valores\">";
 })(TipoNativoSimbolo || (exports.TipoNativoSimbolo = TipoNativoSimbolo = {}));
 function inferirVetor(vetor) {
-    const tiposEmVetor = new Set(vetor.map((elemento) => typeof elemento));
+    const tiposEmVetor = new Set(vetor.map((elemento) => elemento.constructor.name));
     if (tiposEmVetor.size > 1) {
         return 'vetor';
     }
@@ -6978,62 +7099,73 @@ function inferirVetor(vetor) {
                 return 'vetor';
             }
             return `${tiposObjetosEmVetor.values().next().value}[]`;
+        case 'Literal':
+            // TODO: Não sei se é seguro inferir pelo primeiro valor do vetor.
+            return `${vetor[0].tipo}[]`;
         default:
             return 'vetor';
     }
 }
 function inferirTipoVariavel(variavel) {
-    const tipo = typeof variavel;
+    if (variavel === null) {
+        return 'nulo';
+    }
+    const tipo = variavel.constructor.name;
     switch (tipo) {
+        case 'String':
         case 'string':
             return 'texto';
+        case 'Number':
         case 'number':
             return 'número';
         case 'bigint':
             return 'longo';
+        case 'Boolean':
         case 'boolean':
             return 'lógico';
         case 'undefined':
             return 'nulo';
+        case 'Object':
         case 'object':
-            if (Array.isArray(variavel)) {
-                return inferirVetor(variavel);
-            }
             if (variavel === null)
                 return 'nulo';
-            if (variavel.constructor.name === 'DeleguaFuncao')
-                return 'função';
-            if (variavel.constructor.name === 'DeleguaModulo')
-                return 'módulo';
-            if (variavel.constructor.name === 'Classe')
-                return 'objeto';
-            if (variavel.constructor.name === 'Simbolo') {
-                if (typeof variavel === 'object') {
-                    const simbolo = variavel;
-                    if (simbolo.tipo === delegua_2.default.ESCREVA)
-                        return TipoNativoSimbolo.ESCREVA;
-                    if (simbolo.tipo === delegua_2.default.FUNCAO || simbolo.tipo === delegua_2.default.FUNÇÃO)
-                        return TipoNativoSimbolo.FUNCAO;
-                    if (simbolo.tipo === delegua_2.default.LEIA)
-                        return TipoNativoSimbolo.LEIA;
-                    if (simbolo.tipo === delegua_2.default.SE)
-                        return TipoNativoSimbolo.SE;
-                    if (simbolo.tipo === delegua_2.default.ENQUANTO)
-                        return TipoNativoSimbolo.ENQUANTO;
-                    if (simbolo.tipo === delegua_2.default.PARA)
-                        return TipoNativoSimbolo.PARA;
-                    if (simbolo.tipo === delegua_2.default.RETORNA)
-                        return TipoNativoSimbolo.RETORNA;
-                    if (simbolo.tipo === primitivos_1.default.TEXTO)
-                        return TipoNativoSimbolo.TEXTO;
-                    if (simbolo.tipo === primitivos_1.default.BOOLEANO)
-                        return TipoNativoSimbolo.BOOLEANO;
-                    if (simbolo.tipo === delegua_1.default.VAZIO)
-                        return TipoNativoSimbolo.VAZIO;
-                }
-            }
             return 'dicionário';
+        case 'Array':
+        case 'Vetor':
+            return inferirVetor(variavel);
+        case 'DeleguaFuncao':
+            return 'função';
+        case 'DeleguaModulo':
+            return 'módulo';
+        case 'Classe':
+            return 'objeto';
+        case 'Simbolo': // TODO: Repensar.
+            const simbolo = variavel;
+            switch (simbolo.tipo) {
+                case primitivos_1.default.BOOLEANO:
+                    return TipoNativoSimbolo.BOOLEANO;
+                case delegua_2.default.ENQUANTO:
+                    return TipoNativoSimbolo.ENQUANTO;
+                case delegua_2.default.ESCREVA:
+                    return TipoNativoSimbolo.ESCREVA;
+                case delegua_2.default.FUNCAO:
+                case delegua_2.default.FUNÇÃO:
+                    return TipoNativoSimbolo.FUNCAO;
+                case delegua_2.default.LEIA:
+                    return TipoNativoSimbolo.LEIA;
+                case delegua_2.default.PARA:
+                    return TipoNativoSimbolo.PARA;
+                case delegua_2.default.RETORNA:
+                    return TipoNativoSimbolo.RETORNA;
+                case delegua_2.default.SE:
+                    return TipoNativoSimbolo.SE;
+                case primitivos_1.default.TEXTO:
+                    return TipoNativoSimbolo.TEXTO;
+                case delegua_1.default.VAZIO:
+                    return TipoNativoSimbolo.VAZIO;
+            }
         case 'function':
+        case 'FuncaoPadrao':
             return 'função';
         case 'symbol':
             return 'símbolo';
@@ -7643,6 +7775,10 @@ class InterpretadorBase {
                 : String(NaN);
         if (this.tiposNumericos.includes(tipoDireita) && this.tiposNumericos.includes(tipoEsquerda))
             return;
+        if (this.tiposNumericos.includes(tipoEsquerda) && tipoDireita === 'qualquer')
+            return;
+        if (this.tiposNumericos.includes(tipoDireita) && tipoEsquerda === 'qualquer')
+            return;
         throw new excecoes_1.ErroEmTempoDeExecucao(operador, 'Operadores precisam ser números.', operador.linha);
     }
     async visitarExpressaoBinaria(expressao) {
@@ -7681,6 +7817,11 @@ class InterpretadorBase {
                 if (this.tiposNumericos.includes(tipoEsquerdo) && this.tiposNumericos.includes(tipoDireito)) {
                     return Number(valorEsquerdo) + Number(valorDireito);
                 }
+                // TODO: Se tipo for 'qualquer', seria uma boa confiar nos operadores
+                // tradicionais do JavaScript?
+                if (tipoEsquerdo === 'qualquer' || tipoDireito === 'qualquer') {
+                    return valorEsquerdo + valorDireito;
+                }
                 return this.paraTexto(valorEsquerdo) + this.paraTexto(valorDireito);
             case delegua_1.default.DIVISAO:
             case delegua_1.default.DIVISAO_IGUAL:
@@ -8310,6 +8451,8 @@ class InterpretadorBase {
             objeto instanceof estruturas_1.DeleguaFuncao ||
             objeto instanceof estruturas_1.DescritorTipoClasse ||
             objeto instanceof estruturas_1.DeleguaModulo) {
+            if (objeto[valorIndice] === 0)
+                return 0;
             return objeto[valorIndice] || null;
         }
         if (typeof objeto === primitivos_1.default.TEXTO) {
@@ -8537,6 +8680,10 @@ class InterpretadorBase {
         if (Array.isArray(objeto)) {
             let retornoVetor = '[';
             for (let elemento of objeto) {
+                if (typeof elemento === 'object') {
+                    retornoVetor += `${JSON.stringify(elemento)}, `;
+                    continue;
+                }
                 retornoVetor += typeof elemento === 'string' ? `'${elemento}', ` : `${this.paraTexto(elemento)}, `;
             }
             if (retornoVetor.length > 1) {
@@ -9343,6 +9490,9 @@ class PilhaEscoposExecucao {
         if (variavel && variavel.hasOwnProperty('tipo')) {
             tipoVariavel = variavel.tipo;
         }
+        else if (valor && valor.constructor.name === 'DeleguaFuncao') {
+            tipoVariavel = 'função';
+        }
         else if (tipo) {
             tipoVariavel = tipo;
         }
@@ -9391,14 +9541,17 @@ class PilhaEscoposExecucao {
                 if (variavel.imutavel) {
                     throw new excecoes_1.ErroEmTempoDeExecucao(simbolo, `Constante '${simbolo.lexema}' não pode receber novos valores.`);
                 }
-                const tipo = (variavel && variavel.hasOwnProperty('tipo') ? variavel.tipo : (0, inferenciador_1.inferirTipoVariavel)(valor)).toLowerCase();
+                const tipoInferido = variavel && variavel.hasOwnProperty('tipo') && variavel.tipo ?
+                    variavel.tipo :
+                    (0, inferenciador_1.inferirTipoVariavel)(valor);
+                const tipo = tipoInferido.toLowerCase();
                 const valorResolvido = this.converterValor(tipo, valor);
                 if (indice !== undefined && indice !== null) {
-                    if (variavel.valor instanceof Array) {
+                    if (variavel.valor instanceof Array || variavel.valor instanceof Object) {
                         variavel.valor[indice] = valorResolvido;
                     }
                     else {
-                        throw new excecoes_1.ErroEmTempoDeExecucao(simbolo, 'Variável não é um vetor.');
+                        throw new excecoes_1.ErroEmTempoDeExecucao(simbolo, 'Variável não é um vetor ou dicionário.');
                     }
                 }
                 else {
@@ -11274,6 +11427,9 @@ class Lexador {
         this.atual = 0;
         this.linha = 0;
         this.codigo = codigo || [''];
+        if (codigo.length === 0) {
+            this.codigo = [''];
+        }
         this.hashArquivo = hashArquivo;
         for (let iterador = 0; iterador < this.codigo.length; iterador++) {
             this.codigo[iterador] += '\0';
@@ -24661,9 +24817,12 @@ class TradutorAssemblyScript {
             case 'texto':
                 return ': string';
             case 'inteiro':
+            case 'numero':
+            case 'número':
             case 'real':
                 return ': f64';
             case 'logico':
+            case 'lógico':
                 return ': bool';
             case 'nulo':
                 return ': null';
@@ -24673,6 +24832,7 @@ class TradutorAssemblyScript {
             case 'texto[]':
                 return ': string[]';
             case 'logico[]':
+            case 'lógico[]':
                 return ': bool[]';
             default:
                 return ': any';