@designliquido/delegua 1.11.0 → 1.12.0

package/avaliador-sintatico/dialetos/avaliador-sintatico-pitugues.js

@@ -53,20 +53,16 @@ class AvaliadorSintaticoPitugues {
         // Uma delas é a variável/constante ser uma classe padrão.
         // Isso ocorre quando a importação é feita de uma biblioteca Node.js.
         // Nesse caso, o tipo de `entidadeChamada.objeto` começa com uma letra maiúscula.
-        if (entidadeChamada.objeto.tipo &&
-            entidadeChamada.objeto.tipo.match(/^[A-Z]/)) {
+        if (entidadeChamada.objeto.tipo && entidadeChamada.objeto.tipo.match(/^[A-Z]/)) {
             const tipoCorrespondente = this.tiposDefinidosPorBibliotecas[entidadeChamada.objeto.tipo];
             if (!tipoCorrespondente) {
                 throw new erro_avaliador_sintatico_1.ErroAvaliadorSintatico(entidadeChamada.simbolo, `Tipo '${entidadeChamada.objeto.tipo}' não foi encontrado entre os tipos definidos por bibliotecas.`);
             }
-            if (!(entidadeChamada.simbolo.lexema in
-                tipoCorrespondente.metodos) &&
-                !(entidadeChamada.simbolo.lexema in
-                    tipoCorrespondente.propriedades)) {
+            if (!(entidadeChamada.simbolo.lexema in tipoCorrespondente.metodos) &&
+                !(entidadeChamada.simbolo.lexema in tipoCorrespondente.propriedades)) {
                 throw new erro_avaliador_sintatico_1.ErroAvaliadorSintatico(entidadeChamada.simbolo, `Membro '${entidadeChamada.simbolo.lexema}' não existe no tipo '${entidadeChamada.objeto.tipo}'.`);
             }
-            if (entidadeChamada.simbolo.lexema in
-                tipoCorrespondente.metodos) {
+            if (entidadeChamada.simbolo.lexema in tipoCorrespondente.metodos) {
                 const metodoCorrespondente = tipoCorrespondente.metodos[entidadeChamada.simbolo.lexema];
                 return metodoCorrespondente.tipoRetorno || 'qualquer';
             }
@@ -199,7 +195,8 @@ class AvaliadorSintaticoPitugues {
                 pos++;
             }
             // Verifica se há um identificador obrigatório
-            if (pos >= this.simbolos.length || this.simbolos[pos].tipo !== pitugues_2.default.IDENTIFICADOR) {
+            if (pos >= this.simbolos.length ||
+                this.simbolos[pos].tipo !== pitugues_2.default.IDENTIFICADOR) {
                 return false;
             }
             pos++;
@@ -222,7 +219,7 @@ class AvaliadorSintaticoPitugues {
     }
     temPadraoVarComoPalavraChave() {
         // Verifica padrão: var identificador = ...
-        if (this.simbolos[this.atual].lexema !== "var") {
+        if (this.simbolos[this.atual].lexema !== 'var') {
             return false;
         }
         const proximo = this.simbolos[this.atual + 1];
@@ -255,7 +252,9 @@ class AvaliadorSintaticoPitugues {
                 this.consumir(pitugues_2.default.MULTIPLICACAO, '');
                 ehRestoAtual = true;
             }
-            const identificador = this.consumir(pitugues_2.default.IDENTIFICADOR, ehRestoAtual ? 'Esperado nome de variável após operador *.' : 'Esperado nome de variável.');
+            const identificador = this.consumir(pitugues_2.default.IDENTIFICADOR, ehRestoAtual
+                ? 'Esperado nome de variável após operador *.'
+                : 'Esperado nome de variável.');
             // Verifica * no nome da variável
             if (identificador.lexema.startsWith('*')) {
                 ehRestoAtual = true;
@@ -283,10 +282,10 @@ class AvaliadorSintaticoPitugues {
     }
     construirValidacaoDesempacotamento(identificador, origem, qtdEsperada) {
         const linha = identificador.linha;
-        const chamadaTamanho = new construtos_1.Chamada(this.hashArquivo, new construtos_1.Variavel(this.hashArquivo, new lexador_1.Simbolo(pitugues_2.default.IDENTIFICADOR, "tamanho", null, linha, -1)), [origem]);
-        const condicaoErro = new construtos_1.Binario(this.hashArquivo, chamadaTamanho, new lexador_1.Simbolo(pitugues_2.default.DIFERENTE, "!=", null, linha, -1), new construtos_1.Literal(this.hashArquivo, linha, qtdEsperada, 'número'));
+        const chamadaTamanho = new construtos_1.Chamada(this.hashArquivo, new construtos_1.Variavel(this.hashArquivo, new lexador_1.Simbolo(pitugues_2.default.IDENTIFICADOR, 'tamanho', null, linha, -1)), [origem]);
+        const condicaoErro = new construtos_1.Binario(this.hashArquivo, chamadaTamanho, new lexador_1.Simbolo(pitugues_2.default.DIFERENTE, '!=', null, linha, -1), new construtos_1.Literal(this.hashArquivo, linha, qtdEsperada, 'número'));
         const mensagem = `Erro de execução: Você tentou desempacotar em ${qtdEsperada} variáveis, mas o vetor possui tamanho diferente.`;
-        const falha = new declaracoes_1.Falhar(new lexador_1.Simbolo(pitugues_2.default.FALHAR, "falhar", null, linha, -1), new construtos_1.Literal(this.hashArquivo, linha, mensagem, 'texto'));
+        const falha = new declaracoes_1.Falhar(new lexador_1.Simbolo(pitugues_2.default.FALHAR, 'falhar', null, linha, -1), new construtos_1.Literal(this.hashArquivo, linha, mensagem, 'texto'));
         return new declaracoes_1.Se(condicaoErro, new declaracoes_1.Bloco(this.hashArquivo, linha, [falha]), [], null);
     }
     async declaracaoDeVariaveis() {
@@ -298,7 +297,8 @@ class AvaliadorSintaticoPitugues {
         const ehDesempacotamento = qtdIdentificadores > 1 && qtdValores === 1;
         if (indexResto > -1) {
             if (qtdValores < qtdIdentificadores - 1) {
-                if (!ehDesempacotamento || (ehDesempacotamento && inicializadores[0] instanceof construtos_1.Literal)) {
+                if (!ehDesempacotamento ||
+                    (ehDesempacotamento && inicializadores[0] instanceof construtos_1.Literal)) {
                     throw this.erro(this.simboloAnterior(), 'Quantidade insuficiente de valores para desempacotamento com operador de resto.');
                 }
             }
@@ -334,7 +334,7 @@ class AvaliadorSintaticoPitugues {
         for (let i = 0; i < identificadores.length; i++) {
             const identificador = identificadores[i];
             let inicializador;
-            let tipo = "qualquer";
+            let tipo = 'qualquer';
             if (i === indexResto) {
                 const valoresResto = inicializadores.slice(cursorValores, cursorValores + qtdParaResto);
                 let tipoInferido = (0, inferenciador_1.inferirTipoVariavel)(valoresResto);
@@ -381,7 +381,8 @@ class AvaliadorSintaticoPitugues {
         }
     }
     erro(simbolo, mensagemDeErro) {
-        const excecao = new erro_avaliador_sintatico_1.ErroAvaliadorSintatico(simbolo, mensagemDeErro);
+        const simboloParaErro = simbolo || this.simboloAnterior();
+        const excecao = new erro_avaliador_sintatico_1.ErroAvaliadorSintatico(simboloParaErro, mensagemDeErro);
         this.erros.push(excecao);
         return excecao;
     }
@@ -396,7 +397,7 @@ class AvaliadorSintaticoPitugues {
         return this.simboloAtual().tipo === tipo;
     }
     verificarTipoProximoSimbolo(tipo) {
-        if (this.estaNoFinal())
+        if (this.atual + 1 >= this.simbolos.length)
             return false;
         return this.simbolos[this.atual + 1].tipo === tipo;
     }
@@ -541,17 +542,19 @@ class AvaliadorSintaticoPitugues {
             case pitugues_2.default.INTERPOLACAO:
                 const simboloInterpolacao = this.avancarEDevolverAnterior();
                 const conteudoOriginal = simboloInterpolacao.literal;
-                const codigoTransformado = '"' + conteudoOriginal.replace(/\{(.*?)\}/g, (_, miolo) => {
-                    // 'miolo' é o texto que estava dentro das chaves. Ex: "valor" ou "valor:.2f"
-                    if (miolo.includes(':')) {
-                        const [variavel, formato] = miolo.split(':').map(s => s.trim());
-                        if (variavel !== "") {
-                            // Transforma {valor:.2f} em "{:.2f}".formatar(valor)
-                            return '" + "{:' + formato + '}".formatar(' + variavel + ') + "';
+                const codigoTransformado = '"' +
+                    conteudoOriginal.replace(/\{(.*?)\}/g, (_, miolo) => {
+                        // 'miolo' é o texto que estava dentro das chaves. Ex: "valor" ou "valor:.2f"
+                        if (miolo.includes(':')) {
+                            const [variavel, formato] = miolo.split(':').map((s) => s.trim());
+                            if (variavel !== '') {
+                                // Transforma {valor:.2f} em "{:.2f}".formatar(valor)
+                                return '" + "{:' + formato + '}".formatar(' + variavel + ') + "';
+                            }
                         }
-                    }
-                    return '" + (' + miolo.trim() + ') + "';
-                }) + '"';
+                        return '" + (' + miolo.trim() + ') + "';
+                    }) +
+                    '"';
                 const microLexador = new micro_lexador_pitugues_1.MicroLexadorPitugues();
                 const retornoMicroLexador = microLexador.mapear(codigoTransformado);
                 const microAvaliadorSintatico = new micro_avaliador_sintatico_pitugues_1.MicroAvaliadorSintaticoPitugues();
@@ -564,7 +567,7 @@ class AvaliadorSintaticoPitugues {
                 }
                 catch (erro) {
                     this.erros.push(erro);
-                    return new construtos_1.Literal(this.hashArquivo, simboloInterpolacao.linha, "");
+                    return new construtos_1.Literal(this.hashArquivo, simboloInterpolacao.linha, '');
                 }
                 const declaracao = retornoMicroAvaliador.declaracoes[0];
                 return declaracao.expressao;
@@ -622,11 +625,11 @@ class AvaliadorSintaticoPitugues {
                 let passo = null;
                 if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.DOIS_PONTOS)) {
                     ehFatiamento = true;
-                    if (!this.verificarTipoSimboloAtual(pitugues_2.default.DOIS_PONTOS)
-                        && !this.verificarTipoSimboloAtual(pitugues_2.default.COLCHETE_DIREITO))
+                    if (!this.verificarTipoSimboloAtual(pitugues_2.default.DOIS_PONTOS) &&
+                        !this.verificarTipoSimboloAtual(pitugues_2.default.COLCHETE_DIREITO))
                         fim = await this.expressao();
-                    if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.DOIS_PONTOS)
-                        && !this.verificarTipoSimboloAtual(pitugues_2.default.COLCHETE_DIREITO))
+                    if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.DOIS_PONTOS) &&
+                        !this.verificarTipoSimboloAtual(pitugues_2.default.COLCHETE_DIREITO))
                         passo = await this.expressao();
                 }
                 const simboloFechamento = this.consumir(pitugues_2.default.COLCHETE_DIREITO, "Esperado ']' após escrita do indice.");
@@ -758,7 +761,9 @@ class AvaliadorSintaticoPitugues {
     }
     async seTernario() {
         let expressaoEntao = await this.ou();
-        if (this.simbolos[this.atual] && this.simbolos[this.atual].tipo === pitugues_2.default.SE && expressaoEntao.linha === this.simbolos[this.atual].linha) {
+        if (this.simbolos[this.atual] &&
+            this.simbolos[this.atual].tipo === pitugues_2.default.SE &&
+            expressaoEntao.linha === this.simbolos[this.atual].linha) {
             while (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.SE)) {
                 const operador = this.simbolos[this.atual - 1];
                 const expressaoOuCondicao = await this.seTernario();
@@ -860,54 +865,40 @@ class AvaliadorSintaticoPitugues {
         let declaracoes = [];
         let simboloAtual = this.simboloAtual();
         const simboloAnterior = this.simboloAnterior();
-        // Situação 1: não tem bloco de escopo.
-        //
-        // Exemplo: `se verdadeiro: escreva('Alguma coisa')`.
-        // Neste caso, linha do símbolo atual é igual à linha do símbolo anterior.
+        if (!simboloAtual) {
+            throw this.erro(simboloAnterior, 'Esperado corpo do escopo após a declaração.');
+        }
+        // Declaração na mesma linha (ex: 'se verdadeiro: escreva("Oi")')
         if (simboloAtual.linha === simboloAnterior.linha) {
-            const declaracoesBloco = await this.resolverDeclaracaoForaDeBloco();
-            if (declaracoesBloco !== null) {
-                if (Array.isArray(declaracoesBloco)) {
-                    declaracoes = declaracoes.concat(declaracoesBloco);
-                }
-                else {
-                    declaracoes.push(declaracoesBloco);
-                }
-            }
+            const retorno = await this.resolverDeclaracaoForaDeBloco();
+            if (retorno !== null)
+                declaracoes = declaracoes.concat(retorno);
         }
         else {
-            // Situação 2: símbolo atual fica na próxima linha.
-            //
-            // Verifica-se o número de espaços à esquerda da linha através dos pragmas.
-            // Se número de espaços da linha do símbolo atual é menor ou igual ao número de espaços
-            // da linha anterior, e bloco ainda não começou, é uma situação de erro.
-            let espacosIndentacaoLinhaAtual = this.localizacoes[simboloAtual.linha].espacosIndentacao;
-            const espacosIndentacaoLinhaAnterior = this.localizacoes[simboloAnterior.linha].espacosIndentacao;
-            if (espacosIndentacaoLinhaAtual <= espacosIndentacaoLinhaAnterior) {
+            // Bloco de múltiplas linhas baseado em indentação
+            let espacosAtual = this
+                .localizacoes[simboloAtual.linha]
+                .espacosIndentacao;
+            const espacosAnterior = this
+                .localizacoes[simboloAnterior.linha]
+                .espacosIndentacao;
+            if (espacosAtual <= espacosAnterior) {
                 throw this.erro(simboloAtual, `Indentação inconsistente na linha ${simboloAtual.linha}. ` +
-                    `Esperado: >= ${espacosIndentacaoLinhaAnterior}. ` +
-                    `Atual: ${espacosIndentacaoLinhaAtual}`);
-            }
-            // Indentação ok, é um bloco de escopo.
-            // Inclui todas as declarações cujas linhas tenham o mesmo número de espaços
-            // de indentação do bloco.
-            // Se `simboloAtual` for definido em algum momento como indefinido,
-            // Significa que o código acabou, então o bloco também acabou.
-            const espacosIndentacaoBloco = espacosIndentacaoLinhaAtual;
-            while (espacosIndentacaoLinhaAtual === espacosIndentacaoBloco) {
-                const retornoDeclaracao = await this.resolverDeclaracaoForaDeBloco();
-                if (retornoDeclaracao !== null) {
-                    if (Array.isArray(retornoDeclaracao)) {
-                        declaracoes = declaracoes.concat(retornoDeclaracao);
-                    }
-                    else {
-                        declaracoes.push(retornoDeclaracao);
-                    }
-                }
+                    `Esperado: >= ${espacosAnterior}. ` +
+                    `Atual: ${espacosAtual}`);
+            }
+            const indentacaoBloco = espacosAtual;
+            // Consome as declarações enquanto a indentação for estritamente igual à do bloco
+            while (simboloAtual && espacosAtual === indentacaoBloco) {
+                const retorno = await this.resolverDeclaracaoForaDeBloco();
+                if (retorno !== null)
+                    declaracoes = declaracoes.concat(retorno);
                 simboloAtual = this.simboloAtual();
-                if (!simboloAtual)
-                    break;
-                espacosIndentacaoLinhaAtual = this.localizacoes[simboloAtual.linha].espacosIndentacao;
+                if (simboloAtual) {
+                    espacosAtual = this
+                        .localizacoes[simboloAtual.linha]
+                        .espacosIndentacao;
+                }
             }
         }
         this.pilhaEscopos.removerUltimo();
@@ -917,7 +908,7 @@ class AvaliadorSintaticoPitugues {
         try {
             this.blocos += 1;
             const condicao = await this.expressao();
-            const bloco = await this.resolverDeclaracao();
+            const bloco = (await this.resolverDeclaracao());
             return new declaracoes_1.Enquanto(condicao, bloco);
         }
         finally {
@@ -991,7 +982,7 @@ class AvaliadorSintaticoPitugues {
         }
         this.pilhaEscopos.definirInformacoesVariavel(nomeVariavelIteracao.lexema, new informacao_elemento_sintatico_1.InformacaoElementoSintatico(nomeVariavelIteracao.lexema, tipoVetor.slice(0, -2)));
         // TODO: Talvez não seja uma ideia melhor chamar o método de `Bloco` aqui?
-        const corpo = await this.resolverDeclaracao();
+        const corpo = (await this.resolverDeclaracao());
         return new declaracoes_1.ParaCada(this.hashArquivo, Number(simboloPara.linha), new construtos_1.Variavel(this.hashArquivo, nomeVariavelIteracao), vetor, corpo);
     }
     async declaracaoPara() {
@@ -1023,7 +1014,7 @@ class AvaliadorSintaticoPitugues {
                 this.pilhaEscopos.definirInformacoesVariavel(simboloSegundaVariavel.lexema, new informacao_elemento_sintatico_1.InformacaoElementoSintatico(simboloSegundaVariavel.lexema, 'qualquer'));
             }
             // TODO: Talvez não seja uma ideia melhor chamar o método de `Bloco` aqui?
-            const corpo = await this.resolverDeclaracao();
+            const corpo = (await this.resolverDeclaracao());
             return new declaracoes_1.ParaCada(this.hashArquivo, Number(simboloPara.linha), variavelIteracao, alvoIteracao, corpo);
         }
         finally {
@@ -1052,7 +1043,7 @@ class AvaliadorSintaticoPitugues {
     }
     async declaracaoSe() {
         const condicao = await this.expressao();
-        const caminhoEntao = await this.resolverDeclaracao();
+        const caminhoEntao = (await this.resolverDeclaracao());
         let caminhoSenao = null;
         if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.SENAO, pitugues_2.default.SENÃO)) {
             caminhoSenao = await this.resolverDeclaracao();
@@ -1130,11 +1121,13 @@ class AvaliadorSintaticoPitugues {
                 this.consumir(pitugues_2.default.DOIS_PONTOS, `Esperado ':' antes do escopo do bloco 'pegue'.`);
                 this.pilhaEscopos.definirInformacoesVariavel(variavelExcecao.lexema, new informacao_elemento_sintatico_1.InformacaoElementoSintatico(variavelExcecao.lexema, 'qualquer'));
                 const corpo = await this.blocoEscopo();
-                blocoPegue = new construtos_1.FuncaoConstruto(this.hashArquivo, simboloTente.linha, [{
-                        abrangencia: "padrao",
+                blocoPegue = new construtos_1.FuncaoConstruto(this.hashArquivo, simboloTente.linha, [
+                    {
+                        abrangencia: 'padrao',
                         nome: variavelExcecao,
-                        tipoDado: "qualquer",
-                    }], corpo, "vazio", false);
+                        tipoDado: 'qualquer',
+                    },
+                ], corpo, 'vazio', false);
             }
             else {
                 // Caso 2: sem parâmetro de erro.
@@ -1159,7 +1152,7 @@ class AvaliadorSintaticoPitugues {
         const simboloFazer = this.simboloAnterior();
         try {
             this.blocos += 1;
-            const declaracaoOuBlocoFazer = await this.resolverDeclaracao();
+            const declaracaoOuBlocoFazer = (await this.resolverDeclaracao());
             this.consumir(pitugues_2.default.ENQUANTO, "Esperado declaração do 'enquanto' após o escopo da declaração 'fazer'.");
             const condicaoEnquanto = await this.expressao();
             return new declaracoes_1.Fazer(simboloFazer.hashArquivo, Number(simboloFazer.linha), declaracaoOuBlocoFazer, condicaoEnquanto);
@@ -1325,7 +1318,7 @@ class AvaliadorSintaticoPitugues {
             const simboloAnterior = this.simbolos[this.atual - 1];
             if (simboloAnterior.tipo === pitugues_2.default.IDENTIFICADOR) {
                 this.consumir(pitugues_2.default.DOIS_PONTOS, "Esperado ':' antes do escopo da classe.");
-                const tipoPropriedade = this.consumir(pitugues_2.default.IDENTIFICADOR, "Esperado tipo de propriedade após dois-pontos, em declaração de classe.");
+                const tipoPropriedade = this.consumir(pitugues_2.default.IDENTIFICADOR, 'Esperado tipo de propriedade após dois-pontos, em declaração de classe.');
                 const propriedade = new declaracoes_1.PropriedadeClasse(simboloAnterior, tipoPropriedade.lexema, []);
                 propriedades.push(propriedade);
             }
@@ -1381,11 +1374,10 @@ class AvaliadorSintaticoPitugues {
      */
     async resolverDeclaracaoForaDeBloco() {
         try {
-            if ((this.verificarTipoSimboloAtual(pitugues_2.default.FUNCAO) ||
-                this.verificarTipoSimboloAtual(pitugues_2.default.FUNÇÃO)) &&
-                this.verificarTipoProximoSimbolo(pitugues_2.default.IDENTIFICADOR)) {
+            if (this.verificarTipoSimboloAtual(pitugues_2.default.FUNCAO) ||
+                this.verificarTipoSimboloAtual(pitugues_2.default.FUNÇÃO)) {
                 this.avancarEDevolverAnterior();
-                return await this.funcao('funcao');
+                return await this.funcao('da função');
             }
             if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.CLASSE))
                 return await this.declaracaoDeClasse();
@@ -1480,8 +1472,10 @@ class AvaliadorSintaticoPitugues {
             case pitugues_2.default.DE: {
                 const proximo = this.simbolos[this.atual + 1];
                 const aposProximo = this.simbolos[this.atual + 2];
-                if (proximo && proximo.tipo === pitugues_2.default.IDENTIFICADOR &&
-                    aposProximo && aposProximo.tipo === pitugues_2.default.IMPORTAR) {
+                if (proximo &&
+                    proximo.tipo === pitugues_2.default.IDENTIFICADOR &&
+                    aposProximo &&
+                    aposProximo.tipo === pitugues_2.default.IMPORTAR) {
                     this.avancarEDevolverAnterior();
                     return this.declaracaoImportarDe();
                 }
@@ -1596,7 +1590,7 @@ class AvaliadorSintaticoPitugues {
             new informacao_elemento_sintatico_1.InformacaoElementoSintatico('elemento', 'qualquer'),
         ]));
         this.pilhaEscopos.definirInformacoesVariavel('todos', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('todos', 'lógico', true, [
-            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('iteravel', 'qualquer')
+            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('iteravel', 'qualquer'),
         ]));
         this.pilhaEscopos.definirInformacoesVariavel('todosEmCondicao', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('todosEmCondicao', 'lógico', true, [
             new informacao_elemento_sintatico_1.InformacaoElementoSintatico('iteravel', 'qualquer'),
@@ -1606,7 +1600,7 @@ class AvaliadorSintaticoPitugues {
             new informacao_elemento_sintatico_1.InformacaoElementoSintatico('vetor', 'qualquer[]'),
         ]));
         this.pilhaEscopos.definirInformacoesVariavel('vetor', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('vetor', 'vetor', true, [
-            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('tupla', 'qualquer')
+            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('tupla', 'qualquer'),
         ]));
     }
     async analisar(retornoLexador, hashArquivo) {
@@ -1633,7 +1627,8 @@ class AvaliadorSintaticoPitugues {
             else {
                 declaracoes.push(retornoDeclaracao);
             }
-            if (!this.estaNoFinal() && this.verificarTipoSimboloAtual(pitugues_2.default.PONTO_E_VIRGULA)) {
+            if (!this.estaNoFinal() &&
+                this.verificarTipoSimboloAtual(pitugues_2.default.PONTO_E_VIRGULA)) {
                 // Verificar se este ; está na mesma linha da declaração anterior
                 const declaracaoAnterior = declaracoes[declaracoes.length - 1];
                 const linhaDeclaraoAnterior = declaracaoAnterior.linha || 0;