Repository: DesignLiquido/delegua (ts)

Issue:
`a, b, c = leia_inteiro` deve inicializar múltiplas variáveis
Dado a entrada 1, 2, 3, o seguinte código deverá imprimir (1, 2, 3)
```
a, b, c = leia_inteiro
escreva(a, b, c)
```
![image](https://github.com/DesignLiquido/delegua/assets/3980593/b6df63a0-4b04-498a-8597-928530c515fc)


Pull request:
[potigol] > #553 `a, b, c = leia_inteiro` deve inicializar múltiplas variáveis
resolve #553

Patch:
diff --git a/fontes/avaliador-sintatico/dialetos/potigol/avaliador-sintatico-potigol.ts b/fontes/avaliador-sintatico/dialetos/potigol/avaliador-sintatico-potigol.ts
index 661dae38..7cfedc9f 100644
--- a/fontes/avaliador-sintatico/dialetos/potigol/avaliador-sintatico-potigol.ts
+++ b/fontes/avaliador-sintatico/dialetos/potigol/avaliador-sintatico-potigol.ts
@@ -454,6 +454,7 @@ export class AvaliadorSintaticoPotigol extends AvaliadorSintaticoBase {
         return expressao;
     }
 
+
     declaracaoEscreva(): Escreva {
         const simboloAtual = this.avancarEDevolverAnterior();
 
@@ -462,7 +463,7 @@ export class AvaliadorSintaticoPotigol extends AvaliadorSintaticoBase {
         this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PARENTESE_ESQUERDO)
 
         do {
-            argumentos.push(this.expressao());
+            argumentos.push(this.ou());
         } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA));
 
         this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PARENTESE_DIREITO)
@@ -800,7 +801,7 @@ export class AvaliadorSintaticoPotigol extends AvaliadorSintaticoBase {
             if (inicializador instanceof Leia && identificadores.length > 1) {
                 inicializador = new LeiaMultiplo(
                     inicializador.simbolo,
-                    inicializador.argumentos[0],
+                    new Literal(this.hashArquivo, Number(inicializador.simbolo.linha), identificadores.length)
                 );
             }
 
@@ -994,10 +995,10 @@ export class AvaliadorSintaticoPotigol extends AvaliadorSintaticoBase {
             simboloTipo.linha,
             propriedades.map(
                 (p) =>
-                    ({
-                        abrangencia: 'padrao',
-                        nome: p.nome,
-                    } as ParametroInterface)
+                ({
+                    abrangencia: 'padrao',
+                    nome: p.nome,
+                } as ParametroInterface)
             ),
             instrucoesConstrutor
         );
diff --git a/fontes/declaracoes/leia-multiplo.ts b/fontes/declaracoes/leia-multiplo.ts
index 263a9426..793d5570 100644
--- a/fontes/declaracoes/leia-multiplo.ts
+++ b/fontes/declaracoes/leia-multiplo.ts
@@ -10,10 +10,9 @@ import { Declaracao } from './declaracao';
 export class LeiaMultiplo extends Declaracao {
     simbolo: SimboloInterface;
     id: string;
+    argumento?: Construto;
 
-    argumento: Construto;
-
-    constructor(simbolo: SimboloInterface, argumento: Construto) {
+    constructor(simbolo: SimboloInterface, argumento?: Construto) {
         super(simbolo.linha, simbolo.hashArquivo);
         this.simbolo = simbolo;
         this.id = uuidv4();
diff --git a/fontes/interpretador/dialetos/potigol/interpretador-potigol.ts b/fontes/interpretador/dialetos/potigol/interpretador-potigol.ts
index 82cffbf3..0c5ece7b 100644
--- a/fontes/interpretador/dialetos/potigol/interpretador-potigol.ts
+++ b/fontes/interpretador/dialetos/potigol/interpretador-potigol.ts
@@ -1,7 +1,7 @@
 import { InterpretadorBase } from '../../interpretador-base';
 
 import { registrarBibliotecaGlobalPotigol } from '../../../bibliotecas/dialetos/potigol/biblioteca-global';
-import { AcessoMetodo, Binario, ConstanteOuVariavel, Literal, QualTipo, Unario, Variavel } from '../../../construtos';
+import { AcessoMetodo, Binario, ConstanteOuVariavel, Construto, Literal, QualTipo, Unario, Variavel } from '../../../construtos';
 
 import * as comum from './comum';
 import { ObjetoPadrao } from '../../../estruturas';
@@ -79,4 +79,23 @@ export class InterpretadorPotigol extends InterpretadorBase implements Interpret
 
          return inferirTipoVariavel(qualTipo?.valores || qualTipo);
     }
+
+    protected async avaliarArgumentosEscreva(argumentos: Construto[]): Promise<string> {
+        let formatoTexto: string = '';
+    
+        for (const argumento of argumentos) {
+            const resultadoAvaliacao = await this.avaliar(argumento);
+            let valor = resultadoAvaliacao?.hasOwnProperty('valor') ? resultadoAvaliacao.valor : resultadoAvaliacao;
+            formatoTexto += `${this.paraTexto(valor)},`;
+        }
+    
+        formatoTexto = formatoTexto.slice(0, -1);
+
+        if (argumentos.length > 1) {
+            formatoTexto = `(${formatoTexto})`;
+        }
+    
+        return formatoTexto;
+    }
+    
 }


Test patch:
diff --git a/testes/interpretador.test.ts b/testes/interpretador.test.ts
index 57530ce3..ef875866 100644
--- a/testes/interpretador.test.ts
+++ b/testes/interpretador.test.ts
@@ -352,6 +352,23 @@ describe('Interpretador', () => {
 
                     expect(retornoInterpretador.erros).toHaveLength(0);
                 });
+
+                it('Escreva múltiplas variáveis', async () => {                    
+                    const retornoLexador = lexador.mapear([
+                        "const a = 'batata'",
+                        "const b = 'arroz'",
+                        "escreva(a, b)"
+                    ], -1);
+
+                    interpretador.funcaoDeRetorno = (saida: any) => {
+                        expect(saida).toEqual("batata arroz");
+                    }
+
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+                    const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                    expect(retornoInterpretador.erros).toHaveLength(0);
+                })
             });
 
             describe('Operações matemáticas', () => {
diff --git a/testes/potigol/interpretador.test.ts b/testes/potigol/interpretador.test.ts
index caee27a4..5b10ac38 100644
--- a/testes/potigol/interpretador.test.ts
+++ b/testes/potigol/interpretador.test.ts
@@ -156,7 +156,121 @@ describe('Interpretador', () => {
             });
         })
 
-        describe('Leia Multiplo', () => {
+        describe('Leia', () => {
+            it('Dado um leia_inteiro, escreva deve imprimir o valor lido', async () => {
+                const retornoLexador = lexador.mapear([
+                    'escreva(leia_inteiro)'
+                ], -1);
+
+                const resposta = 1;
+                interpretador.interfaceEntradaSaida = {
+                    question: (mensagem: string, callback: Function) => {
+                        callback(resposta);
+                    }
+                };
+
+                interpretador.funcaoDeRetorno = (saida: any) => {
+                    expect(saida).toEqual('1');
+                };
+
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+                const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                expect(retornoInterpretador.erros).toHaveLength(0);
+            });
+
+            it('Dado um leia_real, escreva deve imprimir o valor lido', async () => {
+                const retornoLexador = lexador.mapear([
+                    'escreva(leia_real)'
+                ], -1);
+
+                const resposta = 1.2;
+                interpretador.interfaceEntradaSaida = {
+                    question: (mensagem: string, callback: Function) => {
+                        callback(resposta);
+                    }
+                };
+
+                interpretador.funcaoDeRetorno = (saida: any) => {
+                    expect(saida).toEqual('1.2');
+                };
+
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+                const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                expect(retornoInterpretador.erros).toHaveLength(0);
+            });
+
+            it('Dado um leia_texto, escreva deve imprimir o valor lido', async () => {
+                const retornoLexador = lexador.mapear([
+                    'escreva(leia_texto)'
+                ], -1);
+
+                const resposta = "texto";
+                interpretador.interfaceEntradaSaida = {
+                    question: (mensagem: string, callback: Function) => {
+                        callback(resposta);
+                    }
+                };
+
+                interpretador.funcaoDeRetorno = (saida: any) => {
+                    expect(saida).toEqual('texto');
+                };
+
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+                const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                expect(retornoInterpretador.erros).toHaveLength(0);
+            });
+
+            it('Dado um leia_inteiro, escreva deve imprimir os valores inicializados', async () => {
+                const retornoLexador = lexador.mapear([
+                    'a, b, c = leia_inteiro',
+                    'escreva(a, b, c)'
+                ], -1);
+
+                const resposta = [1, 2, 3];
+                interpretador.interfaceEntradaSaida = {
+                    question: (mensagem: string, callback: Function) => {
+                        callback(resposta.shift());
+                    }
+                };
+
+                interpretador.funcaoDeRetorno = (saida: any) => {
+                    expect(saida).toEqual('(1,2,3)');
+                };
+
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+                const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                expect(retornoInterpretador.erros).toHaveLength(0);
+            });
+
+            it('Dado um leia_inteiro, escreva deve imprimir o valor inicializado', async () => {
+                const retornoLexador = lexador.mapear([
+                    'a = leia_inteiro',
+                    'escreva(a)'
+                ], -1);
+
+                const resposta = [1];
+                interpretador.interfaceEntradaSaida = {
+                    question: (mensagem: string, callback: Function) => {
+                        callback(resposta.shift());
+                    }
+                };
+
+                interpretador.funcaoDeRetorno = (saida: any) => {
+                    expect(saida).toEqual('1');
+                };
+
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+                const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                expect(retornoInterpretador.erros).toHaveLength(0);
+            });
+        });
+
+        describe('Leia vetores', () => {
             it('Dado um leia_inteiros separador por virgula, escreva deve imprimir o valor lido', async () => {
                 const retornoLexador = lexador.mapear([
                     'escreva(leia_inteiros(","))'