Melhoria validação de Tuplas e definição de tipos

fontes/avaliador-sintatico/avaliador-sintatico.ts

@@ -1,4 +1,5 @@
 import tiposDeSimbolos from '../tipos-de-simbolos/delegua';
+import tipoDeDadosDelegua from '../tipos-de-dados/delegua';
 import hrtime from 'browser-process-hrtime';
 
 import { AvaliadorSintaticoInterface, ParametroInterface, SimboloInterface } from '../interfaces';
@@ -107,13 +108,21 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
     }
 
     verificarDefinicaoTipoAtual(): TiposDadosInterface {
-        const tipos = ['inteiro', 'qualquer', 'real', 'texto', 'vazio', 'vetor'];
+        // const tipos = [
+        //     tipoDeDadosDelegua.INTEIRO, 
+        //     tipoDeDadosDelegua.QUALQUER,
+        //     tipoDeDadosDelegua.REAL, 
+        //     tipoDeDadosDelegua.TEXTO,
+        //     tipoDeDadosDelegua.VAZIO, 
+        //     tipoDeDadosDelegua.VETOR
+        // ];
+        const tipos = [...Object.values(tipoDeDadosDelegua)]
 
         const lexema = this.simboloAtual().lexema.toLowerCase();
         const contemTipo = tipos.find((tipo) => tipo === lexema);
 
         if (contemTipo && this.verificarTipoProximoSimbolo(tiposDeSimbolos.COLCHETE_ESQUERDO)) {
-            const tiposVetores = ['inteiro[]', 'qualquer[]', 'real[]', 'texto[]'];
+            const tiposVetores = ['inteiro[]', 'numero[]', 'número[]', 'qualquer[]', 'real[]', 'texto[]'];
             this.avancarEDevolverAnterior();
 
             if (!this.verificarTipoProximoSimbolo(tiposDeSimbolos.COLCHETE_DIREITO)) {
@@ -1131,6 +1140,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
         }
 
         for (let [indice, identificador] of identificadores.entries()) {
+            tipo = inicializadores[indice] instanceof Tupla ? tipoDeDadosDelegua.TUPLA : tipo;
             retorno.push(new Var(identificador, inicializadores[indice], tipo));
         }
 

fontes/interpretador/interpretador-base.ts

@@ -166,7 +166,7 @@ export class InterpretadorBase implements InterpretadorInterface {
         throw new Error('Método não implementado.');
     }
 
-    async visitarExpressaoTupla(expressao: any): Promise<any> {
+    async visitarExpressaoTupla(expressao: Tupla): Promise<any> {
         const chaves = Object.keys(expressao)
         const valores = [];
         for (let chave of chaves) {
@@ -207,11 +207,11 @@ export class InterpretadorBase implements InterpretadorInterface {
 
         if (
             tipoDe instanceof Binario ||
+            tipoDe instanceof Chamada ||
             tipoDe instanceof TipoDe ||
             tipoDe instanceof Unario ||
             tipoDe instanceof Variavel ||
-            tipoDe instanceof Agrupamento ||
-            tipoDe instanceof Chamada
+            tipoDe instanceof Agrupamento
         ) {
             tipoDe = await this.avaliar(tipoDe);
             return tipoDe.tipo || inferirTipoVariavel(tipoDe);
@@ -650,6 +650,24 @@ export class InterpretadorBase implements InterpretadorInterface {
 
             if (entidadeChamada instanceof MetodoPrimitiva) {
                 const argumentosResolvidos: any[] = [];
+
+                if (expressao instanceof Chamada) {
+                    if (expressao.entidadeChamada instanceof AcessoMetodoOuPropriedade) {
+                        if (expressao.entidadeChamada.objeto instanceof Variavel) {
+                            let eTupla = this.procurarVariavel(expressao.entidadeChamada.objeto.simbolo)
+                            if (eTupla.subtipo === tipoDeDadosDelegua.TUPLA) {
+                                return Promise.reject(
+                                    new ErroEmTempoDeExecucao(
+                                        expressao.entidadeChamada.objeto.simbolo,
+                                        'Tupla é imutável, seus elementos não podem ser alterados, adicionados ou removidos.',
+                                        expressao.linha
+                                    )
+                                );
+                            }
+                        }
+                    }
+                }
+
                 for (const argumento of expressao.argumentos) {
                     const valorResolvido: any = await this.avaliar(argumento);
                     argumentosResolvidos.push(
@@ -1206,7 +1224,7 @@ export class InterpretadorBase implements InterpretadorInterface {
         let indice = promises[1];
         const valor = promises[2];
 
-        if (objeto.imutavel) {
+        if (objeto.subtipo === tipoDeDadosDelegua.TUPLA) {
             return Promise.reject(
                 new ErroEmTempoDeExecucao(
                     expressao.objeto.simbolo.lexema,
@@ -1547,9 +1565,8 @@ export class InterpretadorBase implements InterpretadorInterface {
         if (declaracao.tipo !== undefined && declaracao.tipo !== null) {
             subtipo = declaracao.tipo;
         }
-
-        const eTupla = declaracao.inicializador instanceof Tupla;
 
+        let eTupla = declaracao.tipo === tipoDeDadosDelegua.TUPLA;
         this.pilhaEscoposExecucao.definirVariavel(declaracao.simbolo.lexema, valorFinal, subtipo, eTupla);
 
         return null;

fontes/interpretador/pilha-escopos-execucao.ts

@@ -91,7 +91,7 @@ export class PilhaEscoposExecucao implements PilhaEscoposExecucaoInterface {
             valor: this.converterValor(tipo, valor),
             tipo: tipo,
             subtipo: undefined,
-            imutavel: imutavel,
+            imutavel,
         };
 
         if (subtipo !== undefined) {

fontes/tipos-de-dados/delegua.ts

@@ -8,6 +8,10 @@ export default {
     NÚMERO: 'número',
     NULO: 'nulo',
     OBJETO: 'objeto',
+    QUALQUER: 'qualquer',
+    REAL: 'real',
     TEXTO: 'texto',
+    TUPLA: 'tupla',
+    VAZIO: 'vazio',
     VETOR: 'vetor'
 };

testes/interpretador.test.ts

@@ -1627,7 +1627,7 @@ describe('Interpretador', () => {
                     );
                 });
 
-                it('Tupla - Dupla', async () => {
+                it('Tupla Dupla - Atribuição por indice', async () => {
                     const retornoLexador = lexador.mapear([
                         "var t = [(1, 2)]",
                         "t[0] = 3",
@@ -1640,6 +1640,20 @@ describe('Interpretador', () => {
                         'Não é possível modificar uma tupla. As tuplas são estruturas de dados imutáveis.'
                     );
                 });
+
+                it('Tupla Dupla - Primitiva adicionar()', async () => {
+                    const retornoLexador = lexador.mapear([
+                        "var t = [(1, 2)]",
+                        "t.adicionar(3)"
+                    ], -1);
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                    const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                    expect(retornoInterpretador.erros[0].erroInterno.mensagem).toBe(
+                        'Tupla é imutável, seus elementos não podem ser alterados, adicionados ou removidos.'
+                    );
+                });
             })
         });
     });