Repository: DesignLiquido/delegua (ts)

Issue:
Propriedades de classe ficam como indefinidos quando seus valores são alterados utilizando operadores de incremento ou decremento
```js

classe Carteira {
  saldo: numero

  construtor() {
    isto.saldo = 100
  }

  depositar(dinheiro) {
    isto.saldo += dinheiro 
  }
}

var carteira = Carteira();
carteira.depositar(200)
escreva(carteira.saldo);

```

![Image](https://github.com/user-attachments/assets/0fcdf797-e364-44e0-8fed-5b9a5757a236)

Pull request:
#706: Propriedades de classe ficam como indefinidos quando seus valores são alterados utilizando operadores de incremento ou decremento
- Resolve #706 

Patch:
diff --git a/fontes/analisador-semantico/analisador-semantico.ts b/fontes/analisador-semantico/analisador-semantico.ts
index 01036348..24ce3777 100644
--- a/fontes/analisador-semantico/analisador-semantico.ts
+++ b/fontes/analisador-semantico/analisador-semantico.ts
@@ -219,22 +219,34 @@ export class AnalisadorSemantico extends AnalisadorSemanticoBase {
     }
 
     visitarExpressaoDeAtribuicao(expressao: Atribuir) {
-        let valor = this.variaveis[expressao.simbolo.lexema];
+        // TODO: Readaptar para trabalhar com `expressao.alvo` sendo um construto.
+        let simboloAlvo: SimboloInterface;
+        switch (expressao.alvo.constructor.name) {
+            case 'Variavel':
+                const alvoVariavel = expressao.alvo as Variavel;
+                simboloAlvo = alvoVariavel.simbolo;
+                break;
+            default:
+                // throw new Error(`Implementar atribuição para ${expressao.alvo.constructor.name}.`);
+                return Promise.resolve();
+        }
+
+        let valor = this.variaveis[simboloAlvo.lexema];
         if (!valor) {
             this.erro(
-                expressao.simbolo,
-                `Variável ${expressao.simbolo.lexema} ainda não foi declarada até este ponto.`
+                simboloAlvo,
+                `Variável ${simboloAlvo.lexema} ainda não foi declarada até este ponto.`
             );
             return Promise.resolve();
         }
 
         if (valor.tipo) {
             if (expressao.valor instanceof Literal && valor.tipo.includes('[]')) {
-                this.erro(expressao.simbolo, `Atribuição inválida, esperado tipo '${valor.tipo}' na atribuição.`);
+                this.erro(simboloAlvo, `Atribuição inválida, esperado tipo '${valor.tipo}' na atribuição.`);
                 return Promise.resolve();
             }
             if (expressao.valor instanceof Vetor && !valor.tipo.includes('[]')) {
-                this.erro(expressao.simbolo, `Atribuição inválida, esperado tipo '${valor.tipo}' na atribuição.`);
+                this.erro(simboloAlvo, `Atribuição inválida, esperado tipo '${valor.tipo}' na atribuição.`);
                 return Promise.resolve();
             }
             if (expressao.valor instanceof Literal) {
@@ -242,13 +254,13 @@ export class AnalisadorSemantico extends AnalisadorSemanticoBase {
                 if (!['qualquer'].includes(valor.tipo)) {
                     if (valorLiteral === 'string') {
                         if (valor.tipo != 'texto') {
-                            this.erro(expressao.simbolo, `Esperado tipo '${valor.tipo}' na atribuição.`);
+                            this.erro(simboloAlvo, `Esperado tipo '${valor.tipo}' na atribuição.`);
                             return Promise.resolve();
                         }
                     }
                     if (valorLiteral === 'number') {
                         if (!['inteiro', 'número', 'real'].includes(valor.tipo)) {
-                            this.erro(expressao.simbolo, `Esperado tipo '${valor.tipo}' na atribuição.`);
+                            this.erro(simboloAlvo, `Esperado tipo '${valor.tipo}' na atribuição.`);
                             return Promise.resolve();
                         }
                     }
@@ -259,13 +271,13 @@ export class AnalisadorSemantico extends AnalisadorSemanticoBase {
                 if (!['qualquer[]'].includes(valor.tipo)) {
                     if (valor.tipo === 'texto[]') {
                         if (!valores.every((v) => typeof v.valor === 'string')) {
-                            this.erro(expressao.simbolo, `Esperado tipo '${valor.tipo}' na atribuição.`);
+                            this.erro(simboloAlvo, `Esperado tipo '${valor.tipo}' na atribuição.`);
                             return Promise.resolve();
                         }
                     }
                     if (['inteiro[]', 'numero[]'].includes(valor.tipo)) {
                         if (!valores.every((v) => typeof v.valor === 'number')) {
-                            this.erro(expressao.simbolo, `Esperado tipo '${valor.tipo}' na atribuição.`);
+                            this.erro(simboloAlvo, `Esperado tipo '${valor.tipo}' na atribuição.`);
                             return Promise.resolve();
                         }
                     }
@@ -274,11 +286,11 @@ export class AnalisadorSemantico extends AnalisadorSemanticoBase {
         }
 
         if (valor.imutavel) {
-            this.erro(expressao.simbolo, `Constante ${expressao.simbolo.lexema} não pode ser modificada.`);
+            this.erro(simboloAlvo, `Constante ${simboloAlvo.lexema} não pode ser modificada.`);
             return Promise.resolve();
         } else {
-            if (this.variaveis[expressao.simbolo.lexema]) {
-                this.variaveis[expressao.simbolo.lexema].valor = expressao.valor;
+            if (this.variaveis[simboloAlvo.lexema]) {
+                this.variaveis[simboloAlvo.lexema].valor = expressao.valor;
             }
         }
     }
diff --git a/fontes/avaliador-sintatico/avaliador-sintatico.ts b/fontes/avaliador-sintatico/avaliador-sintatico.ts
index 30507635..d5576212 100644
--- a/fontes/avaliador-sintatico/avaliador-sintatico.ts
+++ b/fontes/avaliador-sintatico/avaliador-sintatico.ts
@@ -792,19 +792,16 @@ export class AvaliadorSintatico
         ) {
             if (expressao.esquerda instanceof AcessoIndiceVariavel) {
                 const entidade = expressao.esquerda as AcessoIndiceVariavel;
-                const simbolo = (entidade.entidadeChamada as Variavel).simbolo;
-                return new Atribuir(this.hashArquivo, simbolo, expressao, entidade.indice);
+                return new Atribuir(this.hashArquivo, entidade.entidadeChamada, expressao, entidade.indice);
             }
 
-            const simbolo = (expressao.esquerda as Variavel).simbolo;
-            return new Atribuir(this.hashArquivo, simbolo, expressao);
+            return new Atribuir(this.hashArquivo, expressao.esquerda, expressao);
         } else if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IGUAL)) {
             const igual = this.simbolos[this.atual - 1];
             const valor = this.expressao();
 
             if (expressao instanceof Variavel) {
-                const simbolo = expressao.simbolo;
-                return new Atribuir(this.hashArquivo, simbolo, valor);
+                return new Atribuir(this.hashArquivo, expressao, valor);
             }
 
             if (expressao instanceof AcessoMetodoOuPropriedade) {
diff --git a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-egua-classico.ts b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-egua-classico.ts
index cd494d8c..42f66926 100644
--- a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-egua-classico.ts
+++ b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-egua-classico.ts
@@ -432,8 +432,7 @@ export class AvaliadorSintaticoEguaClassico implements AvaliadorSintaticoInterfa
             const valor = this.atribuir();
 
             if (expressao instanceof Variavel) {
-                const simbolo = expressao.simbolo;
-                return new Atribuir(this.hashArquivo, simbolo, valor);
+                return new Atribuir(this.hashArquivo, expressao, valor);
             } else if (expressao instanceof AcessoMetodoOuPropriedade) {
                 const get = expressao;
                 return new DefinirValor(this.hashArquivo, 0, get.objeto, get.simbolo, valor);
diff --git a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-pitugues.ts b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-pitugues.ts
index fc83001b..7df12cc9 100644
--- a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-pitugues.ts
+++ b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-pitugues.ts
@@ -495,8 +495,7 @@ export class AvaliadorSintaticoPitugues implements AvaliadorSintaticoInterface<S
             const valor = this.atribuir();
 
             if (expressao instanceof Variavel) {
-                const simbolo = expressao.simbolo;
-                return new Atribuir(this.hashArquivo, simbolo, valor);
+                return new Atribuir(this.hashArquivo, expressao, valor);
             } 
             
             if (expressao instanceof AcessoMetodoOuPropriedade) {
diff --git a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-portugol-ipt.ts b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-portugol-ipt.ts
index 37aad14a..406b0391 100644
--- a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-portugol-ipt.ts
+++ b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-portugol-ipt.ts
@@ -56,9 +56,10 @@ export class AvaliadorSintaticoPortugolIpt extends AvaliadorSintaticoBase {
             const valor = this.atribuir();
 
             if (expressao instanceof Variavel) {
-                const simbolo = expressao.simbolo;
-                return new Atribuir(this.hashArquivo, simbolo, valor);
-            } else if (expressao instanceof AcessoIndiceVariavel) {
+                return new Atribuir(this.hashArquivo, expressao, valor);
+            } 
+            
+            if (expressao instanceof AcessoIndiceVariavel) {
                 return new AtribuicaoPorIndice(
                     this.hashArquivo,
                     expressao.linha,
diff --git a/fontes/construtos/atribuir.ts b/fontes/construtos/atribuir.ts
index aa263d9e..ec57ce3c 100644
--- a/fontes/construtos/atribuir.ts
+++ b/fontes/construtos/atribuir.ts
@@ -4,27 +4,27 @@ import { Construto } from './construto';
 /**
  * Construto de atribuição de um valor a um símbolo.
  */
-export class Atribuir<TTipoSimbolo extends string = string> implements Construto {
+export class Atribuir implements Construto {
     linha: number;
     hashArquivo: number;
 
     indice?: Construto;
 
-    simbolo: SimboloInterface<TTipoSimbolo>;
+    alvo: Construto;
     valor: any;
 
     constructor(
         hashArquivo: number,
-        simbolo: SimboloInterface<TTipoSimbolo>,
+        alvo: Construto,
         valor: any,
         // indice so é usado para variaveis de vetores
         // TODO: criar alguma validaçao para garantir que `indice` só seja passado para variáveis de vetores
         indice?: Construto
     ) {
-        this.linha = Number(simbolo.linha);
+        this.linha = Number(alvo.linha);
         this.hashArquivo = hashArquivo;
 
-        this.simbolo = simbolo;
+        this.alvo = alvo;
         this.valor = valor;
 
         if (indice !== undefined) {
diff --git a/fontes/formatadores/formatador-delegua.ts b/fontes/formatadores/formatador-delegua.ts
index 42843129..032f5d98 100644
--- a/fontes/formatadores/formatador-delegua.ts
+++ b/fontes/formatadores/formatador-delegua.ts
@@ -189,7 +189,7 @@ export class FormatadorDelegua implements VisitanteComumInterface {
         ) {
             this.visitarExpressaoBinaria(expressao.valor);
         } else {
-            this.codigoFormatado += `${expressao.simbolo.lexema} = `;
+            this.codigoFormatado += `${this.formatarDeclaracaoOuConstruto(expressao.alvo)} = `;
             this.formatarDeclaracaoOuConstruto(expressao.valor);
         }
 
diff --git a/fontes/interpretador/dialetos/egua-classico/interpretador-egua-classico.ts b/fontes/interpretador/dialetos/egua-classico/interpretador-egua-classico.ts
index ee2feeaa..bc5d7d1b 100644
--- a/fontes/interpretador/dialetos/egua-classico/interpretador-egua-classico.ts
+++ b/fontes/interpretador/dialetos/egua-classico/interpretador-egua-classico.ts
@@ -434,7 +434,8 @@ export class InterpretadorEguaClassico implements InterpretadorInterface {
 
     async visitarExpressaoDeAtribuicao(expressao: Atribuir) {
         const valor = await this.avaliar(expressao.valor);
-        this.pilhaEscoposExecucao.atribuirVariavel(expressao.simbolo, valor);
+        const alvoVariavel = expressao.alvo as Variavel;
+        this.pilhaEscoposExecucao.atribuirVariavel(alvoVariavel.simbolo, valor);
 
         return valor;
     }
diff --git a/fontes/interpretador/dialetos/egua-classico/resolvedor/resolvedor.ts b/fontes/interpretador/dialetos/egua-classico/resolvedor/resolvedor.ts
index 572cc884..7ec12e8d 100644
--- a/fontes/interpretador/dialetos/egua-classico/resolvedor/resolvedor.ts
+++ b/fontes/interpretador/dialetos/egua-classico/resolvedor/resolvedor.ts
@@ -1,6 +1,7 @@
 import {
     AcessoMetodoOuPropriedade,
     AcessoPropriedade,
+    Atribuir,
     Comentario,
     Construto,
     ExpressaoRegular,
@@ -286,9 +287,10 @@ export class ResolvedorEguaClassico implements ResolvedorInterface, Interpretado
         throw new Error('Método não implementado.');
     }
 
-    visitarExpressaoDeAtribuicao(expressao: any): any {
+    visitarExpressaoDeAtribuicao(expressao: Atribuir): any {
         this.resolver(expressao.valor);
-        this.resolverLocal(expressao, expressao.simbolo);
+        const alvoVariavel = expressao.alvo as Variavel;
+        this.resolverLocal(expressao, alvoVariavel.simbolo);
         return null;
     }
 
diff --git a/fontes/interpretador/interpretador-base.ts b/fontes/interpretador/interpretador-base.ts
index 5746b3e2..a69d6394 100644
--- a/fontes/interpretador/interpretador-base.ts
+++ b/fontes/interpretador/interpretador-base.ts
@@ -834,7 +834,26 @@ export class InterpretadorBase implements InterpretadorInterface {
             indice = await this.avaliar(expressao.indice);
         }
 
-        this.pilhaEscoposExecucao.atribuirVariavel(expressao.simbolo, valorResolvido, indice);
+        switch (expressao.alvo.constructor.name) {
+            case 'Variavel':
+                const alvoVariavel = expressao.alvo as Variavel;
+                this.pilhaEscoposExecucao.atribuirVariavel(alvoVariavel.simbolo, valorResolvido, indice);
+                break;
+            case 'AcessoMetodoOuPropriedade':
+                // Nunca será método aqui: apenas propriedade.
+                const alvoPropriedade = expressao.alvo as AcessoMetodoOuPropriedade;
+                const variavelObjeto = await this.avaliar(alvoPropriedade.objeto);
+                const objeto = variavelObjeto.hasOwnProperty('valor') ? variavelObjeto.valor : variavelObjeto;
+
+                const valor = await this.avaliar(expressao.valor);
+                if (objeto.constructor.name === 'ObjetoDeleguaClasse') {
+                    const objetoDeleguaClasse = objeto as ObjetoDeleguaClasse;
+                    objetoDeleguaClasse.definir(alvoPropriedade.simbolo, valor);
+                }
+                break;
+            default:
+                throw new ErroEmTempoDeExecucao(null, `Atribuição com caso faltante: ${expressao.alvo.constructor.name}.`);
+        }
 
         return valorResolvido;
     }
diff --git a/fontes/tradutores/tradutor-assemblyscript.ts b/fontes/tradutores/tradutor-assemblyscript.ts
index 4fd00807..ab8c9b44 100644
--- a/fontes/tradutores/tradutor-assemblyscript.ts
+++ b/fontes/tradutores/tradutor-assemblyscript.ts
@@ -626,7 +626,7 @@ export class TradutorAssemblyScript {
     }
 
     traduzirConstrutoAtribuir(atribuir: Atribuir): string {
-        let resultado = atribuir.simbolo.lexema;
+        let resultado = this.dicionarioConstrutos[atribuir.alvo.constructor.name](atribuir.alvo);
         resultado += ' = ' + this.dicionarioConstrutos[atribuir.valor.constructor.name](atribuir.valor);
         return resultado;
     }
diff --git a/fontes/tradutores/tradutor-javascript.ts b/fontes/tradutores/tradutor-javascript.ts
index 79b21793..bf71f4ac 100644
--- a/fontes/tradutores/tradutor-javascript.ts
+++ b/fontes/tradutores/tradutor-javascript.ts
@@ -139,7 +139,7 @@ export class TradutorJavaScript implements TradutorInterface<Declaracao> {
     }
 
     traduzirConstrutoAtribuir(atribuir: Atribuir): string {
-        let resultado = atribuir.simbolo.lexema;
+        let resultado = this.dicionarioConstrutos[atribuir.alvo.constructor.name](atribuir.alvo);
         resultado += ' = ' + this.dicionarioConstrutos[atribuir.valor.constructor.name](atribuir.valor);
         return resultado;
     }
diff --git a/fontes/tradutores/tradutor-python.ts b/fontes/tradutores/tradutor-python.ts
index 03f1e695..ea3ae289 100644
--- a/fontes/tradutores/tradutor-python.ts
+++ b/fontes/tradutores/tradutor-python.ts
@@ -217,7 +217,7 @@ export class TradutorPython implements TradutorInterface<Declaracao> {
     }
 
     traduzirConstrutoAtribuir(atribuir: Atribuir): string {
-        let resultado = atribuir.simbolo.lexema;
+        let resultado = this.dicionarioConstrutos[atribuir.alvo.constructor.name](atribuir.alvo);
         resultado += ' = ' + this.dicionarioConstrutos[atribuir.valor.constructor.name](atribuir.valor);
         return resultado;
     }


Test patch:
diff --git a/testes/analisador-semantico.test.ts b/testes/analisador-semantico.test.ts
index 23a2bd54..68e4d32a 100644
--- a/testes/analisador-semantico.test.ts
+++ b/testes/analisador-semantico.test.ts
@@ -153,7 +153,7 @@ describe('Analisador semântico', () => {
                 expect(retornoAnalisadorSemantico.diagnosticos[4].mensagem).toBe('Atribuição inválida para \'v3\', é esperado um vetor de elementos.');
             });
 
-            // TODO: Provavelmente obsoleto por causa do avaliador sintático.
+            // TODO: `retornoAnalisadorSemantico.diagnosticos` vazio.
             it.skip('Retorno vazio', () => {
                 const retornoLexador = lexador.mapear([
                     "funcao olaMundo (): vazio {",
diff --git a/testes/interpretador/interpretador.test.ts b/testes/interpretador/interpretador.test.ts
index d74b106c..ace978a6 100644
--- a/testes/interpretador/interpretador.test.ts
+++ b/testes/interpretador/interpretador.test.ts
@@ -15,12 +15,12 @@ describe('Interpretador', () => {
         });
 
         describe('Cenários de sucesso', () => {
-            describe('Acesso a operações matemáticas em posições de array', () => {
+            describe('Acesso a operações matemáticas em posições de vetor', () => {
                 it('Espera-se que atribuição com acumulador seja bem sucedida', async () => {
                     const retornoLexador = lexador.mapear(
                         [
-                            'var pilha = [1, 2, 3, 4]', 
-                            'pilha[0] += 8', 
+                            'var pilha = [1, 2, 3, 4]',
+                            'pilha[0] += 8',
                             'escreva(pilha[0])'
                         ],
                         -1
@@ -39,7 +39,10 @@ describe('Interpretador', () => {
 
             describe('Acesso a variáveis e objetos', () => {
                 it('Acesso a elementos de vetor', async () => {
-                    const retornoLexador = lexador.mapear(['var a = [1, 2, 3]', 'escreva(a[1])'], -1);
+                    const retornoLexador = lexador.mapear([
+                        'var a = [1, 2, 3]', 
+                        'escreva(a[1])'
+                    ], -1);
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
 
                     interpretador.funcaoDeRetorno = (saida: any) => {
@@ -255,13 +258,13 @@ describe('Interpretador', () => {
 
                     const retornoLexador = lexador.mapear([
                         'classe Vendedor {',
-                        'nome: texto',
-                        'construtor(nome) {',
-                        'isto.nome = nome',
-                        '}',
-                        'recebaCliente() {',
-                        'escreva(\'Olá, meu nome é ${isto.nome}, como posso lhe ajudar?\')',
-                        '}',
+                        '  nome: texto',
+                        '  construtor(nome) {',
+                        '    isto.nome = nome',
+                        '  }',
+                        '  recebaCliente() {',
+                        '    escreva(\'Olá, meu nome é ${isto.nome}, como posso lhe ajudar?\')',
+                        '  }',
                         '}',
                         'var vendedor = Vendedor(\'Fernando\')',
                         'vendedor.recebaCliente()'
@@ -375,8 +378,8 @@ describe('Interpretador', () => {
                     let _saida: string = '';
                     const retornoLexador = lexador.mapear(
                         [
-                            'var a = { "prop1": "b" }', 
-                            'var { prop1 } = a', 
+                            'var a = { "prop1": "b" }',
+                            'var { prop1 } = a',
                             'escreva(prop1)'
                         ],
                         -1
@@ -396,8 +399,8 @@ describe('Interpretador', () => {
                     let _saida: string = '';
                     const retornoLexador = lexador.mapear(
                         [
-                            'const a = { "prop1": "c" }', 
-                            'const { prop1 } = a', 
+                            'const a = { "prop1": "c" }',
+                            'const { prop1 } = a',
                             'escreva(prop1)'
                         ],
                         -1
@@ -436,8 +439,8 @@ describe('Interpretador', () => {
                     let _saida: string = '';
                     const retornoLexador = lexador.mapear(
                         [
-                            'funcao retorneAlgo(a, b) {', 
-                            '}', 
+                            'funcao retorneAlgo(a, b) {',
+                            '}',
                             'escreva(retorneAlgo)'
                         ],
                         -1
@@ -456,7 +459,11 @@ describe('Interpretador', () => {
                 it('Descrever função com retorno - DeleguaFuncao', async () => {
                     let _saida: string = '';
                     const retornoLexador = lexador.mapear(
-                        ['funcao retorneAlgo() {', '   retorna "Algo"', '}', 'escreva(retorneAlgo)'],
+                        [
+                            'funcao retorneAlgo() {', 
+                            '   retorna "Algo"', '}', 
+                            'escreva(retorneAlgo)'
+                        ],
                         -1
                     );
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
@@ -603,7 +610,7 @@ describe('Interpretador', () => {
                     const saidasMensagens = ['verdadeiro', 'falso'];
                     const retornoLexador = lexador.mapear(
                         [
-                            "escreva('batata' > 'arroz')", 
+                            "escreva('batata' > 'arroz')",
                             "escreva('batata' < 'arroz')"
                         ],
                         -1
@@ -622,8 +629,8 @@ describe('Interpretador', () => {
                 it('Escreva múltiplas variáveis', async () => {
                     const retornoLexador = lexador.mapear(
                         [
-                            "const a = 'batata'", 
-                            "const b = 'arroz'", 
+                            "const a = 'batata'",
+                            "const b = 'arroz'",
                             'escreva(a, b)'
                         ],
                         -1
@@ -1043,7 +1050,7 @@ describe('Interpretador', () => {
                     const saidasMensagens = ['Valor:  1', 'Valor:  2', 'Valor:  3'];
                     const retornoLexador = lexador.mapear(
                         [
-                            'para cada elemento em [1, 2, 3] {', 
+                            'para cada elemento em [1, 2, 3] {',
                             "   escreva('Valor: ', elemento)", '}'
                         ],
                         -1
@@ -1063,8 +1070,8 @@ describe('Interpretador', () => {
                     const saidasMensagens = ['Valor:  1', 'Valor:  2', 'Valor:  3'];
                     const retornoLexador = lexador.mapear(
                         [
-                            'var v = [1, 2, 3]', 
-                            'para cada elemento em v {', 
+                            'var v = [1, 2, 3]',
+                            'para cada elemento em v {',
                             "   escreva('Valor: ', elemento)", '}'
                         ],
                         -1
@@ -1309,6 +1316,37 @@ describe('Interpretador', () => {
                     expect(_saidas.length).toBeGreaterThan(0);
                     expect(_saidas).toBe("Olá, meu nome é Fernando, como posso lhe ajudar?");
                 });
+
+                it('Incremento e decremento com `isto`', async () => {
+                    let _saidas = "";
+                    interpretador.funcaoDeRetorno = (saida: string) => {
+                        _saidas += saida;
+                    }
+
+                    const retornoLexador = lexador.mapear(
+                        [
+                            'classe Carteira {',
+                            '  saldo: numero',
+                            '  construtor() {',
+                            '    isto.saldo = 100',
+                            '  }',
+                            '  depositar(dinheiro) {',
+                            '    isto.saldo += dinheiro ',
+                            '  }',
+                            '}',
+                            'var carteira = Carteira();',
+                            'carteira.depositar(200)',
+                            'escreva(carteira.saldo);'
+                        ],
+                        -1
+                    );
+
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+                    const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                    expect(retornoInterpretador.erros).toHaveLength(0);
+                    expect(_saidas).toBe('300');
+                })
             });
 
             describe('Declaração e chamada de funções', () => {
@@ -1700,12 +1738,12 @@ describe('Interpretador', () => {
                         const retornoLexador = lexador.mapear(
                             [
                                 "funcao retorneLista() {",
-                                    "var lista = []",
+                                "var lista = []",
 
-                                    "retorna lista",
-                                  "}",
+                                "retorna lista",
+                                "}",
 
-                                  "escreva(retorneLista())"
+                                "escreva(retorneLista())"
                             ],
                             -1
                         );
@@ -2105,7 +2143,7 @@ describe('Interpretador', () => {
                 it('Tupla Dupla - Atribuição por indice', async () => {
                     const retornoLexador = lexador.mapear(
                         [
-                            'var t = [(1, 2)]', 
+                            'var t = [(1, 2)]',
                             't[0] = 3'
                         ], -1);
                     const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);