Repository: DesignLiquido/delegua (ts)

Issue:
[Dialeto Portugol Studio] Construções válidas não são reconhecidas pelo dialeto
Expressões na declaração de uma variável

```
inteiro a = 1 + 2
```

Declaração de vetor

```
inteiro numeros[5] = {23,42,10,24,66}
```


Pull request description:
Portugol studio vetores
Resolve #431 

Patch:
diff --git a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-portugol-studio.ts b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-portugol-studio.ts
index 7e7f319c..b299ed30 100644
--- a/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-portugol-studio.ts
+++ b/fontes/avaliador-sintatico/dialetos/avaliador-sintatico-portugol-studio.ts
@@ -9,6 +9,7 @@ import {
     Literal,
     Unario,
     Variavel,
+    Vetor,
 } from '../../construtos';
 import {
     Escreva,
@@ -391,6 +392,51 @@ export class AvaliadorSintaticoPortugolStudio extends AvaliadorSintaticoBase {
         return new Expressao(expressao);
     }
 
+    protected declaracaoVetorInteiros(
+        simboloInteiro: SimboloInterface, 
+        identificador: SimboloInterface,
+        posicoes: number
+    ) {
+        let valorInicializacao: Vetor = new Vetor(this.hashArquivo, Number(simboloInteiro.linha), []);
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IGUAL)) {
+            this.consumir(
+                tiposDeSimbolos.CHAVE_ESQUERDA, 
+                "Esperado chave esquerda após sinal de igual em lado direito da atribuição de vetor."
+            );
+
+            const valores = [];
+            do {
+                valores.push(this.primario());
+            } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA));
+
+            this.consumir(
+                tiposDeSimbolos.CHAVE_DIREITA, 
+                "Esperado chave direita após valores de vetor em lado direito da atribuição de vetor."
+            );
+
+            if (posicoes !== valores.length) {
+                throw this.erro(
+                    simboloInteiro, 
+                    `Esperado ${posicoes} números, mas foram fornecidos ${valores.length} valores do lado direito da atribuição.`
+                );
+            }
+            
+            valorInicializacao.valores = valores;
+        }
+
+        return new Var(identificador, valorInicializacao);
+    }
+
+    protected declaracaoTrivialInteiro(simboloInteiro: SimboloInterface, identificador: SimboloInterface) {
+        // Inicializações de variáveis podem ter valores definidos.
+        let valorInicializacao: Construto = new Literal(this.hashArquivo, Number(simboloInteiro.linha), 0);
+        if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IGUAL)) {
+            valorInicializacao = this.expressao();
+        }
+
+        return new Var(identificador, valorInicializacao);
+    }
+
     declaracaoInteiros(): Var[] {
         const simboloInteiro = this.consumir(tiposDeSimbolos.INTEIRO, '');
 
@@ -401,13 +447,22 @@ export class AvaliadorSintaticoPortugolStudio extends AvaliadorSintaticoBase {
                 "Esperado identificador após palavra reservada 'inteiro'."
             );
 
-            // Inicializações de variáveis podem ter valores definidos.
-            let valorInicializacao: Construto = new Literal(this.hashArquivo, Number(simboloInteiro.linha), 0);
-            if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.IGUAL)) {
-                valorInicializacao = this.expressao();
-            }
+            if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.COLCHETE_ESQUERDO)) {
+                // TODO
+                const numeroPosicoes = this.consumir(
+                    tiposDeSimbolos.INTEIRO, 
+                    "Esperado número inteiro para definir quantas posições terá o vetor."
+                );
+
+                this.consumir(
+                    tiposDeSimbolos.COLCHETE_DIREITO, 
+                    "Esperado fechamento de identificação de número de posições de uma declaração de vetor."
+                );
 
-            inicializacoes.push(new Var(identificador, valorInicializacao));
+                inicializacoes.push(this.declaracaoVetorInteiros(simboloInteiro, identificador, Number(numeroPosicoes.literal)));
+            } else {
+                inicializacoes.push(this.declaracaoTrivialInteiro(simboloInteiro, identificador));
+            }
         } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA));
 
         return inicializacoes;
diff --git a/fontes/interpretador/interpretador-base.ts b/fontes/interpretador/interpretador-base.ts
index d81b64ec..108ea468 100644
--- a/fontes/interpretador/interpretador-base.ts
+++ b/fontes/interpretador/interpretador-base.ts
@@ -55,6 +55,7 @@ import {
     TipoDe,
     Unario,
     Variavel,
+    Vetor,
 } from '../construtos';
 import { ErroInterpretador } from '../interfaces/erros/erro-interpretador';
 import { RetornoInterpretador } from '../interfaces/retornos/retorno-interpretador';
@@ -1318,7 +1319,7 @@ export class InterpretadorBase implements InterpretadorInterface {
         return dicionario;
     }
 
-    async visitarExpressaoVetor(expressao: any): Promise<any> {
+    async visitarExpressaoVetor(expressao: Vetor): Promise<any> {
         const valores = [];
         for (let i = 0; i < expressao.valores.length; i++) {
             valores.push(await this.avaliar(expressao.valores[i]));


Test patch:
diff --git a/testes/portugol-studio/avaliador-sintatico.test.ts b/testes/portugol-studio/avaliador-sintatico.test.ts
index d8beac0d..13cac69f 100644
--- a/testes/portugol-studio/avaliador-sintatico.test.ts
+++ b/testes/portugol-studio/avaliador-sintatico.test.ts
@@ -244,6 +244,22 @@ describe('Avaliador sintático (Portugol Studio)', () => {
                 expect(retornoAvaliadorSintatico).toBeTruthy();
                 expect(retornoAvaliadorSintatico.declaracoes.length).toBeGreaterThan(0);
             });
+
+            it('Atribuição de Vetores', () => {
+                const resultado = lexador.mapear([
+                    'programa {',
+                    '    funcao inicio() {',
+                    '        inteiro numeros[5] = {23,42,10,24,66}',
+                    '        escreva("zero:", numeros[5])',
+                    '    }',
+                    '}'
+                ], -1);
+
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(resultado, -1);
+
+                expect(retornoAvaliadorSintatico).toBeTruthy();
+                expect(retornoAvaliadorSintatico.declaracoes.length).toBeGreaterThan(0);
+            });
         });
 
         describe('Casos de Falha', () => {