[potigol] - implementação qual_tipo

Ajustes QualTipo Potigol

fontes/avaliador-sintatico/dialetos/potigol/avaliador-sintatico-potigol.ts

@@ -13,6 +13,7 @@ import {
     FuncaoConstruto,
     Isto,
     Literal,
+    QualTipo,
     Unario,
     Variavel,
     Vetor,
@@ -307,6 +308,9 @@ export class AvaliadorSintaticoPotigol extends AvaliadorSintaticoBase {
     primario(): Construto {
         const simboloAtual = this.simbolos[this.atual];
 
+        // var a = 1
+        // escreva(tipo de a)
+
         switch (simboloAtual.tipo) {
             case tiposDeSimbolos.PARENTESE_ESQUERDO:
                 this.avancarEDevolverAnterior();
@@ -409,9 +413,26 @@ export class AvaliadorSintaticoPotigol extends AvaliadorSintaticoBase {
                 }
                 expressao = this.finalizarChamada(expressao);
             } else if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PONTO)) {
-                const nome = this.consumir(tiposDeSimbolos.IDENTIFICADOR, "Esperado nome do método após '.'.");
-                const variavelMetodo = new Variavel(expressao.hashArquivo, (expressao as any).simbolo);
-                expressao = new AcessoMetodo(this.hashArquivo, variavelMetodo, nome);
+                if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.QUAL_TIPO)) {
+
+                    // tipo de 1
+                    // a.qual_tipo()
+                    let c = this.simbolos[this.atual - 1];
+                    let d = this.simbolos[this.atual - 3];
+                    // this.avancarEDevolverAnterior();
+                    // this.consumir(tiposDeSimbolos.DE, "Esperado 'de' após 'tipo'.");
+                    // const _expressao = this.expressao() as any;
+                    return new QualTipo(
+                        this.hashArquivo,
+                        c,
+                        d.lexema
+                    );
+
+                } else {
+                    const nome = this.consumir(tiposDeSimbolos.IDENTIFICADOR, "Esperado nome do método após '.'.");
+                    const variavelMetodo = new Variavel(expressao.hashArquivo, (expressao as any).simbolo);
+                    expressao = new AcessoMetodo(this.hashArquivo, variavelMetodo, nome);   
+                }
             } else if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.COLCHETE_ESQUERDO)) {
                 const indice = this.expressao();
                 const simboloFechamento = this.consumir(
@@ -449,10 +470,14 @@ export class AvaliadorSintaticoPotigol extends AvaliadorSintaticoBase {
 
         const argumentos: Construto[] = [];
 
+        this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PARENTESE_ESQUERDO)
+
         do {
             argumentos.push(this.expressao());
         } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.VIRGULA));
 
+        this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PARENTESE_DIREITO)
+
         return new Escreva(Number(simboloAtual.linha), simboloAtual.hashArquivo, argumentos);
     }
 

fontes/construtos/index.ts

@@ -21,3 +21,4 @@ export * from './tipo-de';
 export * from './unario';
 export * from './variavel';
 export * from './vetor';
+export * from './qual-tipo';

fontes/construtos/qual-tipo.ts

@@ -0,0 +1,22 @@
+import { VisitanteComumInterface, SimboloInterface, VariavelInterface } from '../interfaces';
+import { Construto } from './construto';
+
+
+export class QualTipo implements Construto {
+    linha: number;
+    hashArquivo: number;
+    valor: any;
+
+    simbolo: SimboloInterface;
+
+    constructor(hashArquivo: number, simbolo: SimboloInterface, valor: any) {
+        this.linha = Number(simbolo.linha);
+        this.hashArquivo = hashArquivo;
+        this.valor = valor;
+        this.simbolo = simbolo;
+    }
+
+    async aceitar(visitante: VisitanteComumInterface): Promise<VariavelInterface> {
+        return Promise.resolve(visitante.visitarExpressaoQualTipo(this));
+    }
+}

fontes/interfaces/visitante-comum-interface.ts

@@ -73,4 +73,5 @@ export interface VisitanteComumInterface {
     visitarExpressaoTipoDe(expressao: TipoDe): Promise<any>;
     visitarExpressaoUnaria(expressao: any): any;
     visitarExpressaoVetor(expressao: any): any;
+    visitarExpressaoQualTipo(expressao: any): Promise<any>;
 }

fontes/interpretador/dialetos/egua-classico/interpretador-egua-classico.ts

@@ -14,6 +14,7 @@ import {
     FimPara,
     FormatacaoEscrita,
     Literal,
+    QualTipo,
     Super,
     TipoDe,
     Variavel,
@@ -94,6 +95,10 @@ export class InterpretadorEguaClassico implements InterpretadorInterface {
         throw new Error('Método não implementado.');
     }
 
+    visitarExpressaoQualTipo(expressao: QualTipo): Promise<any> {
+        throw new Error('Método não implementado.');
+    }
+
     visitarExpressaoFalhar(expressao: any): Promise<any> {
         throw new Error('Método não implementado.');
     }

fontes/interpretador/dialetos/egua-classico/resolvedor/resolvedor.ts

@@ -1,4 +1,4 @@
-import { AcessoMetodo, Construto, FimPara, FormatacaoEscrita, Super, TipoDe, Variavel } from '../../../../construtos';
+import { AcessoMetodo, Construto, FimPara, FormatacaoEscrita, QualTipo, Super, TipoDe, Variavel } from '../../../../construtos';
 import {
     Bloco,
     Const,
@@ -80,6 +80,10 @@ export class ResolvedorEguaClassico implements ResolvedorInterface, Interpretado
         throw new Error('Método não implementado.');
     }
 
+    visitarExpressaoQualTipo(expressao: QualTipo): Promise<any> {
+        throw new Error('Método não implementado.');
+    }
+
     visitarExpressaoFalhar(expressao: any): Promise<any> {
         throw new Error('Método não implementado.');
     }

fontes/interpretador/dialetos/portugol-ipt/interpretador-portugol-ipt.ts

@@ -1,4 +1,4 @@
-import { Atribuir, Construto, FimPara, FormatacaoEscrita, Literal, Super, TipoDe, Variavel } from '../../../construtos';
+import { Atribuir, Construto, FimPara, FormatacaoEscrita, Literal, QualTipo, Super, TipoDe, Variavel } from '../../../construtos';
 import {
     Bloco,
     Classe,
@@ -78,6 +78,10 @@ export class InterpretadorPortugolIpt implements InterpretadorInterface {
         throw new Error('Método não implementado.');
     }
 
+    visitarExpressaoQualTipo(expressao: QualTipo): Promise<any> {
+        throw new Error('Método não implementado.');
+    }
+
     visitarExpressaoFalhar(expressao: any): Promise<any> {
         throw new Error('Método não implementado.');
     }

fontes/interpretador/dialetos/potigol/interpretador-potigol.ts

@@ -1,10 +1,11 @@
 import { InterpretadorBase } from '../../interpretador-base';
 
 import { registrarBibliotecaGlobalPotigol } from '../../../bibliotecas/dialetos/potigol/biblioteca-global';
-import { AcessoMetodo } from '../../../construtos';
+import { AcessoMetodo, Binario, QualTipo, Unario, Variavel } from '../../../construtos';
 
 import * as comum from './comum';
 import { ObjetoPadrao } from '../../../estruturas';
+import { inferirTipoVariavel } from './inferenciador';
 
 /**
  * Uma implementação do interpretador de Potigol.
@@ -55,4 +56,22 @@ export class InterpretadorPotigol extends InterpretadorBase {
     async visitarExpressaoAcessoMetodo(expressao: AcessoMetodo): Promise<any> {
         return comum.visitarExpressaoAcessoMetodo(this, expressao);
     }
+
+    async visitarExpressaoQualTipo(expressao: QualTipo): Promise<string> {
+        // let qualTipo = expressao.valor;
+        let d = this.pilhaEscoposExecucao.pilha[1].ambiente.valores[expressao.valor].tipo;
+        return d;
+
+        // if (
+        //     qualTipo instanceof Binario ||
+        //     qualTipo instanceof QualTipo ||
+        //     qualTipo instanceof Unario ||
+        //     qualTipo instanceof Variavel
+        // ) {
+        //     qualTipo = await this.avaliar(qualTipo);
+        //     return qualTipo.tipo || inferirTipoVariavel(qualTipo);
+        // }
+
+        // return inferirTipoVariavel(qualTipo?.valores || qualTipo);
+    }
 }

fontes/interpretador/interpretador-base.ts

@@ -54,6 +54,7 @@ import {
     FormatacaoEscrita,
     Literal,
     Logico,
+    QualTipo,
     Super,
     TipoDe,
     Unario,
@@ -152,6 +153,10 @@ export class InterpretadorBase implements InterpretadorInterface {
         return inferirTipoVariavel(tipoDe?.valores || tipoDe);
     }
 
+    async visitarExpressaoQualTipo(expressao: QualTipo): Promise<string> {
+        throw new Error('Método não implementado.');
+    }
+
     visitarExpressaoFalhar(expressao: Falhar): Promise<any> {
         throw new ErroEmTempoDeExecucao(expressao.simbolo, expressao.explicacao, expressao.linha);
     }

fontes/lexador/dialetos/palavras-reservadas/potigol.ts

@@ -42,4 +42,5 @@ export const palavrasReservadas = {
     tipo: tiposDeSimbolos.TIPO,
     var: tiposDeSimbolos.VARIAVEL,
     verdadeiro: tiposDeSimbolos.VERDADEIRO,
+    qual_tipo: tiposDeSimbolos.QUAL_TIPO,
 };

fontes/tipos-de-simbolos/potigol.ts

@@ -59,4 +59,5 @@ export default {
     VERDADEIRO: 'VERDADEIRO',
     VARIAVEL: 'VARIAVEL',
     VIRGULA: 'VIRGULA',
+    QUAL_TIPO: 'QUAL_TIPO',
 };

testes/interpretador.test.ts

@@ -224,6 +224,22 @@ describe('Interpretador', () => {
                     expect(retornoInterpretador.erros).toHaveLength(0);
                 });
 
+                it('Tipo de número', async () => {
+                    const retornoLexador = lexador.mapear([
+                        "escreva(tipo de 123)",
+                    ], -1);
+
+                    interpretador.funcaoDeRetorno = (saida: any) => {
+                        expect(saida).toEqual("número");
+                    };
+
+                    const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                    const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+
+                    expect(retornoInterpretador.erros).toHaveLength(0);
+                });
+
                 it('Ordem lexicográfica de textos', async () => {
                     const retornoLexador = lexador.mapear([
                         "escreva('batata' > 'arroz')",

testes/potigol/interpretador.test.ts

@@ -45,38 +45,58 @@ describe('Interpretador', () => {
             });
         });
 
-        describe('Declaração de lista', () => {
-            it('Dado em vetor, escreva deve imprirmir o vetor', async () => {
+        describe('qual_tipo', () => {
+            it.only('Dado um inteiro, escreva qual_tipo deve imprirmir Inteiro', async () => {
+                const retornoLexador = lexador.mapear([
+                    'a = 3',
+                    'escreva(a.qual_tipo)'
+                ], -1);
+
+                // Substitua a função de saída
+                // interpretador.funcaoDeRetorno = (saida: any) => {
+                //     expect(saida).toEqual("Inteiro");
+                // };
+
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+                const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
+                expect(retornoInterpretador.erros).toHaveLength(0);
+            });
+
+            it('Dado um vetor, escreva qual_tipo deve imprirmir Lista', async () => {
                 const retornoLexador = lexador.mapear([
                     'a = [3, 4]',
-                    'escreva (a)'
+                    'escreva (a.qual_tipo)'
                 ], -1);
 
                 // Substitua a função de saída
                 interpretador.funcaoDeRetorno = (saida: any) => {
-                    expect(saida).toEqual('[3, 4]');
+                    expect(saida).toEqual("Lista");
                 };
 
                 const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
                 const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
                 expect(retornoInterpretador.erros).toHaveLength(0);
             });
-
-            it.skip('WIP: Dado em vetor, escreva qual_tipo deve imprirmir Lista', async () => {
+        });
+
+        describe('Declaração de lista', () => {
+            it('Dado um vetor, escreva deve imprirmir o vetor', async () => {
                 const retornoLexador = lexador.mapear([
                     'a = [3, 4]',
-                    'escreva (a.qual_tipo)'
+                    'escreva (a)'
                 ], -1);
 
                 // Substitua a função de saída
                 interpretador.funcaoDeRetorno = (saida: any) => {
-                    expect(saida).toEqual("Lista");
+                    expect(saida).toEqual('[3, 4]');
                 };
 
                 const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
                 const retornoInterpretador = await interpretador.interpretar(retornoAvaliadorSintatico.declaracoes);
                 expect(retornoInterpretador.erros).toHaveLength(0);
             });
+
+
         })
     });
 });