Repository: DesignLiquido/delegua
Pull request #701 (2025-03-02 14:56:25)

#693 Não é possível usar operador de incremento ou decremento com dicionários


Patch:
diff --git a/fontes/interpretador/interpretador-base.ts b/fontes/interpretador/interpretador-base.ts
index d3460ca1..ed2da61a 100644
--- a/fontes/interpretador/interpretador-base.ts
+++ b/fontes/interpretador/interpretador-base.ts
@@ -1692,6 +1692,10 @@ export class InterpretadorBase implements InterpretadorInterface {
         if (Array.isArray(objeto)) {
             let retornoVetor: string = '[';
             for (let elemento of objeto) {
+                if (typeof elemento === 'object') {
+                    retornoVetor += `${JSON.stringify(elemento)}, `
+                    continue;
+                }
                 retornoVetor += typeof elemento === 'string' ? `'${elemento}', ` : `${this.paraTexto(elemento)}, `;
             }
 
diff --git a/fontes/interpretador/pilha-escopos-execucao.ts b/fontes/interpretador/pilha-escopos-execucao.ts
index e86bec29..ea0e68f5 100644
--- a/fontes/interpretador/pilha-escopos-execucao.ts
+++ b/fontes/interpretador/pilha-escopos-execucao.ts
@@ -162,10 +162,11 @@ export class PilhaEscoposExecucao implements PilhaEscoposExecucaoInterface {
                 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 ErroEmTempoDeExecucao(simbolo, 'Variável não é um vetor.');
+                    }
+                    else {
+                        throw new ErroEmTempoDeExecucao(simbolo, 'Variável não é um vetor ou dicionário.');
                     }
                 } else {
                     ambiente.valores[simbolo.lexema] = {


Test patch:
diff --git a/testes/interpretador/interpretador.test.ts b/testes/interpretador/interpretador.test.ts
index 2229bf3d..92a9791b 100644
--- a/testes/interpretador/interpretador.test.ts
+++ b/testes/interpretador/interpretador.test.ts
@@ -219,6 +219,36 @@ describe('Interpretador', () => {
                     expect(retornoInterpretador.erros).toHaveLength(0);
                 });
 
+                it('Incremento e decremento em propriedades de dicionário', async () => {
+                    const saidasMensagens = [
+                        '4',
+                        '-2'
+                    ];
+                    const retornoLexador = lexador.mapear(
+                        [
+                            'var macacos = {',
+                            '"Joe": 0,',
+                            '"Milo": 0,',
+                            '"Kiko": 0,',
+                            '}',
+                            "macacos['Joe'] += 4",
+                            "macacos['Milo'] -= 2",
+                            "escreva(macacos['Joe']);",
+                            "escreva(macacos['Milo']);",
+                        ],
+                        -1
+                    );
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                    interpretador.funcaoDeRetorno = (saida: any) => {
+                        expect(saidasMensagens.includes(saida)).toBeTruthy();
+                    };
+
+                    const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                    expect(retornoInterpretador.erros).toHaveLength(0);
+                });
+
                 it('Incremento e decremento após variável ou literal', async () => {
                     const saidasMensagens = ['1', '1', '2', '0', '6', '4'];
                     const retornoLexador = lexador.mapear(
@@ -1488,6 +1518,38 @@ describe('Interpretador', () => {
                         expect(saidas[0]).toEqual('[\'a\', \'b\', \'c\']');
                         expect(saidas[1]).toEqual('[1, 2, 3]');
                     });
+
+                    it('Obter valores do dicionário dentro de outro dicionário', async () => {
+                        const retornoLexador = lexador.mapear(
+                            [
+                                `var planos = {`,
+                                `"base secreta": "Lua Oculta",`,
+                                `"armas": {`,
+                                `"tipo": "blaster 72",`,
+                                `"tempo de recuo": 120,`,
+                                `},`,
+                                `"defesa": "campo energético",`,
+                                `"duracao de ataque": 700`,
+                                `}`,
+                                `var dados = planos.valores()`,
+                                `escreva(dados)`
+                            ],
+                            -1
+                        );
+
+                        const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+                        const saidas: string[] = ["['Lua Oculta', {\"tipo\":\"blaster 72\",\"tempo de recuo\":120}, 'campo energético', 700]"];
+
+                        interpretador.funcaoDeRetorno = (saida: string) => {
+                            saidas.push(saida);
+                        };
+
+                        const retornoInterpretador = await interpretador.interpretar(
+                            retornoAvaliadorSintatico.declaracoes
+                        );
+
+                        expect(retornoInterpretador.erros).toHaveLength(0);
+                    });
                 });
 
                 describe('Vetores', () => {