From 13f1baeed28b320a377bb86c3593657ec484f02b Mon Sep 17 00:00:00 2001 From: Samuel Vaz Date: Tue, 26 Sep 2023 13:03:10 -0300 Subject: [PATCH 1/7] =?UTF-8?q?Mudan=C3=A7a=20de=20l=C3=B3gica=20avaliador?= =?UTF-8?q?=20sint=C3=A1tico=20para=20avaliador-sem=C3=A2ntico?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../analisador-semantico.ts | 35 +++++++++++++++++++ .../avaliador-sintatico.ts | 33 ----------------- testes/analisador-semantico.test.ts | 32 +++++++++++++++-- testes/avaliador-sintatico.test.ts | 26 -------------- 4 files changed, 65 insertions(+), 61 deletions(-) diff --git a/fontes/analisador-semantico/analisador-semantico.ts b/fontes/analisador-semantico/analisador-semantico.ts index c56bd34c..1d39eaea 100644 --- a/fontes/analisador-semantico/analisador-semantico.ts +++ b/fontes/analisador-semantico/analisador-semantico.ts @@ -286,6 +286,41 @@ export class AnalisadorSemantico implements AnalisadorSemanticoInterface { } visitarDeclaracaoDefinicaoFuncao(declaracao: FuncaoDeclaracao) { + let tipoRetornoFuncao = declaracao.funcao.tipoRetorno; + if (tipoRetornoFuncao) { + let funcaoContemRetorno = declaracao.funcao.corpo.find((c) => c instanceof Retorna) as Retorna; + if (funcaoContemRetorno) { + if (tipoRetornoFuncao === 'vazio') { + this.erro(declaracao.simbolo, `A função não pode ter nenhum tipo de retorno.`); + return Promise.resolve(); + } + + const tipoValor = typeof funcaoContemRetorno.valor.valor; + if (!['qualquer'].includes(tipoRetornoFuncao)) { + if (tipoValor === 'string') { + if (tipoRetornoFuncao != 'texto') { + this.erro( + declaracao.simbolo, + `Esperado retorno do tipo '${tipoRetornoFuncao}' dentro da função.` + ); + } + } + if (tipoValor === 'number') { + if (!['inteiro', 'real'].includes(tipoRetornoFuncao)) { + this.erro( + declaracao.simbolo, + `Esperado retorno do tipo '${tipoRetornoFuncao}' dentro da função.` + ); + } + } + } + } else { + if (tipoRetornoFuncao !== 'vazio') { + this.erro(declaracao.simbolo, `Esperado retorno do tipo '${tipoRetornoFuncao}' dentro da função.`); + } + } + } + return Promise.resolve(); } diff --git a/fontes/avaliador-sintatico/avaliador-sintatico.ts b/fontes/avaliador-sintatico/avaliador-sintatico.ts index 29566e30..05bfbc4a 100644 --- a/fontes/avaliador-sintatico/avaliador-sintatico.ts +++ b/fontes/avaliador-sintatico/avaliador-sintatico.ts @@ -1218,39 +1218,6 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface c instanceof Retorna) as Retorna; - if (funcaoContemRetorno) { - if (tipoRetorno === 'vazio') { - throw this.erro(this.simboloAtual(), `A função não pode ter nenhum tipo de retorno.`); - } - - const tipoValor = typeof funcaoContemRetorno.valor.valor; - if (!['qualquer'].includes(tipoRetorno)) { - if (tipoValor === 'string') { - if (tipoRetorno != 'texto') { - this.erro( - this.simboloAtual(), - `Esperado retorno do tipo '${tipoRetorno}' dentro da função.` - ); - } - } - if (tipoValor === 'number') { - if (!['inteiro', 'real'].includes(tipoRetorno)) { - this.erro( - this.simboloAtual(), - `Esperado retorno do tipo '${tipoRetorno}' dentro da função.` - ); - } - } - } - } else { - if (tipoRetorno !== 'vazio') { - this.erro(this.simboloAtual(), `Esperado retorno do tipo '${tipoRetorno}' dentro da função.`); - } - } - } - return new FuncaoConstruto(this.hashArquivo, Number(parenteseEsquerdo.linha), parametros, corpo, tipoRetorno); } diff --git a/testes/analisador-semantico.test.ts b/testes/analisador-semantico.test.ts index 4bd68fcf..692ac34b 100644 --- a/testes/analisador-semantico.test.ts +++ b/testes/analisador-semantico.test.ts @@ -112,7 +112,7 @@ describe('Analisador semântico', () => { expect(retornoAnalisadorSemantico.erros).toHaveLength(8); }); - it.skip('Retorno vazio', () => { + it('Retorno vazio', () => { const retornoLexador = lexador.mapear([ "funcao olaMundo (): vazio {", " retorna \"Olá Mundo!!!\"", @@ -122,7 +122,35 @@ describe('Analisador semântico', () => { const retornoAnalisadorSemantico = analisadorSemantico.analisar(retornoAvaliadorSintatico.declaracoes); expect(retornoAnalisadorSemantico).toBeTruthy(); - expect(retornoAnalisadorSemantico.erros).toHaveLength(1); + expect(retornoAnalisadorSemantico.erros[0].mensagem).toBe('A função não pode ter nenhum tipo de retorno.'); + }); + + it('Não retornando o tipo que a função definiu', () => { + const retornoLexador = lexador.mapear([ + "funcao executar(valor1, valor2): texto {", + " var resultado = valor1 + valor2", + " retorna 10", + "}", + ], -1); + const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); + const retornoAnalisadorSemantico = analisadorSemantico.analisar(retornoAvaliadorSintatico.declaracoes); + + expect(retornoAnalisadorSemantico).toBeTruthy(); + expect(retornoAnalisadorSemantico.erros[0].mensagem).toBe('Esperado retorno do tipo \'texto\' dentro da função.'); + }); + + it('Retorno vazio mas com retorno de valor', () => { + const retornoLexador = lexador.mapear([ + "funcao executar(valor1, valor2): vazio {", + " var resultado = valor1 + valor2", + " retorna resultado", + "}", + ], -1); + const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); + const retornoAnalisadorSemantico = analisadorSemantico.analisar(retornoAvaliadorSintatico.declaracoes); + + expect(retornoAnalisadorSemantico).toBeTruthy(); + expect(retornoAnalisadorSemantico.erros[0].mensagem).toBe('A função não pode ter nenhum tipo de retorno.'); }); }); }); diff --git a/testes/avaliador-sintatico.test.ts b/testes/avaliador-sintatico.test.ts index 9a1d7472..d3e458dd 100644 --- a/testes/avaliador-sintatico.test.ts +++ b/testes/avaliador-sintatico.test.ts @@ -230,32 +230,6 @@ describe('Avaliador sintático', () => { expect(retornoAvaliadorSintatico.erros[0].message).toBe('Não pode haver mais de 255 parâmetros'); }); - it('Retorno vazio mas com retorno de valor', () => { - const retornoLexador = lexador.mapear([ - "funcao executar(valor1, valor2): vazio {", - " var resultado = valor1 + valor2", - " retorna resultado", - "}", - ], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(retornoAvaliadorSintatico.erros[0].message).toBe('A função não pode ter nenhum tipo de retorno.'); - }); - - it('Não retornando o tipo que a função definiu', () => { - const retornoLexador = lexador.mapear([ - "funcao executar(valor1, valor2): texto {", - " var resultado = valor1 + valor2", - " retorna 10", - "}", - ], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(retornoAvaliadorSintatico.erros[0].message).toBe('Esperado retorno do tipo \'texto\' dentro da função.'); - }); - it('Parametro com definição de tipo inválido', () => { const retornoLexador = lexador.mapear([ "funcao executar(valor1: algum, valor2): texto {", From 6b105fae0ff0d747c32f95174fdf9af61e59de3c Mon Sep 17 00:00:00 2001 From: Samuel Vaz Date: Tue, 26 Sep 2023 14:45:14 -0300 Subject: [PATCH 2/7] =?UTF-8?q?Valida=C3=A7=C3=A3o=20de=20tipo=20inv=C3=A1?= =?UTF-8?q?lido=20agora=20=C3=A9=20feita=20no=20analisador-sem=C3=A2ntico?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../analisador-semantico.ts | 6 +++++ .../avaliador-sintatico.ts | 22 ++++++++++--------- .../dialetos/avaliador-sintatico-birl.ts | 7 ++++-- .../potigol/avaliador-sintatico-potigol.ts | 6 ++++- fontes/interfaces/parametro-interface.ts | 6 ++++- fontes/tradutores/tradutor-assemblyscript.ts | 2 +- testes/analisador-semantico.test.ts | 13 +++++++++++ testes/avaliador-sintatico.test.ts | 12 ---------- 8 files changed, 47 insertions(+), 27 deletions(-) diff --git a/fontes/analisador-semantico/analisador-semantico.ts b/fontes/analisador-semantico/analisador-semantico.ts index 1d39eaea..c66350fb 100644 --- a/fontes/analisador-semantico/analisador-semantico.ts +++ b/fontes/analisador-semantico/analisador-semantico.ts @@ -286,6 +286,12 @@ export class AnalisadorSemantico implements AnalisadorSemanticoInterface { } visitarDeclaracaoDefinicaoFuncao(declaracao: FuncaoDeclaracao) { + for (let parametro of declaracao.funcao.parametros) { + if(parametro.hasOwnProperty('tipoDado') && !parametro.tipoDado.tipo) { + this.erro(declaracao.simbolo, `O tipo '${parametro.tipoDado.nome}' não é válido.`); + } + } + let tipoRetornoFuncao = declaracao.funcao.tipoRetorno; if (tipoRetornoFuncao) { let funcaoContemRetorno = declaracao.funcao.corpo.find((c) => c instanceof Retorna) as Retorna; diff --git a/fontes/avaliador-sintatico/avaliador-sintatico.ts b/fontes/avaliador-sintatico/avaliador-sintatico.ts index 05bfbc4a..fdbfadd7 100644 --- a/fontes/avaliador-sintatico/avaliador-sintatico.ts +++ b/fontes/avaliador-sintatico/avaliador-sintatico.ts @@ -1,7 +1,11 @@ import tiposDeSimbolos from '../tipos-de-simbolos/delegua'; import hrtime from 'browser-process-hrtime'; -import { AvaliadorSintaticoInterface, ParametroInterface, SimboloInterface } from '../interfaces'; +import { + AvaliadorSintaticoInterface, + ParametroInterface, + SimboloInterface, +} from '../interfaces'; import { AcessoMetodo as AcessoMetodo, Agrupamento, @@ -100,7 +104,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface { expect(retornoAnalisadorSemantico).toBeTruthy(); expect(retornoAnalisadorSemantico.erros[0].mensagem).toBe('A função não pode ter nenhum tipo de retorno.'); }); + + it('Parametro com definição de tipo inválido', () => { + const retornoLexador = lexador.mapear([ + "funcao executar(valor1: algum, valor2): texto {", + " retorna \'Olá Mundo!!!\'", + "}", + ], -1); + const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); + const retornoAnalisadorSemantico = analisadorSemantico.analisar(retornoAvaliadorSintatico.declaracoes); + + expect(retornoAnalisadorSemantico).toBeTruthy(); + expect(retornoAnalisadorSemantico.erros[0].mensagem).toBe('O tipo \'algum\' não é válido.'); + }); }); }); }); diff --git a/testes/avaliador-sintatico.test.ts b/testes/avaliador-sintatico.test.ts index d3e458dd..19713919 100644 --- a/testes/avaliador-sintatico.test.ts +++ b/testes/avaliador-sintatico.test.ts @@ -230,18 +230,6 @@ describe('Avaliador sintático', () => { expect(retornoAvaliadorSintatico.erros[0].message).toBe('Não pode haver mais de 255 parâmetros'); }); - it('Parametro com definição de tipo inválido', () => { - const retornoLexador = lexador.mapear([ - "funcao executar(valor1: algum, valor2): texto {", - " retorna \'Olá Mundo!!!\'", - "}", - ], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(retornoAvaliadorSintatico.erros[0].message).toBe('O tipo \'algum\' não é válido.'); - }); - it('Função com retorno de vetor', () => { const retornoLexador = lexador.mapear([ "funcao executar(): texto[] {", From 8846aa50084766129238613ea8ca1a9722ee0679 Mon Sep 17 00:00:00 2001 From: Samuel Vaz Date: Tue, 26 Sep 2023 15:48:01 -0300 Subject: [PATCH 3/7] Melhorias gerais avaliador semantico --- .../analisador-semantico.ts | 51 ++++++++++++++++- .../avaliador-sintatico.ts | 56 +------------------ testes/analisador-semantico.test.ts | 35 ++++++++++++ testes/avaliador-sintatico.test.ts | 18 ------ 4 files changed, 86 insertions(+), 74 deletions(-) diff --git a/fontes/analisador-semantico/analisador-semantico.ts b/fontes/analisador-semantico/analisador-semantico.ts index c66350fb..8f7369eb 100644 --- a/fontes/analisador-semantico/analisador-semantico.ts +++ b/fontes/analisador-semantico/analisador-semantico.ts @@ -61,6 +61,49 @@ export class AnalisadorSemantico implements AnalisadorSemanticoInterface { }); } + verificarTipoAtribuido(declaracao: Var | Const) { + if (declaracao.tipo) { + if (['vetor', 'qualquer[]', 'inteiro[]', 'texto[]'].includes(declaracao.tipo)) { + if (declaracao.inicializador instanceof Vetor) { + const vetor = declaracao.inicializador as Vetor; + if (declaracao.tipo === 'inteiro[]') { + const v = vetor.valores.find(v => typeof v?.valor !== 'number') + if(v) { + this.erro( + declaracao.simbolo, + `Atribuição inválida para '${declaracao.simbolo.lexema}', é esperado um vetor de 'inteiros' ou 'real'.` + ); + } + } + if (declaracao.tipo === 'texto[]') { + const v = vetor.valores.find(v => typeof v?.valor !== 'string') + if(v) { + this.erro( + declaracao.simbolo, + `Atribuição inválida para '${declaracao.simbolo.lexema}', é esperado um vetor de 'texto'.` + ); + } + } + } else { + this.erro(declaracao.simbolo, 'Atribuição inválida, é esperado um vetor de elementos.'); + } + } + if (declaracao.inicializador instanceof Literal) { + const literal = declaracao.inicializador as Literal; + if (declaracao.tipo === 'texto') { + if (typeof literal.valor !== 'string') { + this.erro(declaracao.simbolo, `Atribuição inválida para '${declaracao.simbolo.lexema}', é esperado um 'texto'.`); + } + } + if (['inteiro', 'real'].includes(declaracao.tipo)) { + if (typeof literal.valor !== 'number') { + this.erro(declaracao.simbolo, `Atribuição inválida '${declaracao.simbolo.lexema}', é esperado um 'número'.`); + } + } + } + } + } + visitarExpressaoTipoDe(expressao: TipoDe): Promise { return Promise.resolve(); } @@ -223,6 +266,9 @@ export class AnalisadorSemantico implements AnalisadorSemanticoInterface { } visitarDeclaracaoConst(declaracao: Const): Promise { + + this.verificarTipoAtribuido(declaracao); + if (this.variaveis.hasOwnProperty(declaracao.simbolo.lexema)) { this.erros.push({ simbolo: declaracao.simbolo, @@ -245,6 +291,9 @@ export class AnalisadorSemantico implements AnalisadorSemanticoInterface { } visitarDeclaracaoVar(declaracao: Var): Promise { + + this.verificarTipoAtribuido(declaracao); + this.variaveis[declaracao.simbolo.lexema] = { imutavel: false, tipo: declaracao.tipo, @@ -291,7 +340,7 @@ export class AnalisadorSemantico implements AnalisadorSemanticoInterface { this.erro(declaracao.simbolo, `O tipo '${parametro.tipoDado.nome}' não é válido.`); } } - + let tipoRetornoFuncao = declaracao.funcao.tipoRetorno; if (tipoRetornoFuncao) { let funcaoContemRetorno = declaracao.funcao.corpo.find((c) => c instanceof Retorna) as Retorna; diff --git a/fontes/avaliador-sintatico/avaliador-sintatico.ts b/fontes/avaliador-sintatico/avaliador-sintatico.ts index fdbfadd7..fa9e6ca8 100644 --- a/fontes/avaliador-sintatico/avaliador-sintatico.ts +++ b/fontes/avaliador-sintatico/avaliador-sintatico.ts @@ -988,52 +988,6 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface { expect(retornoAnalisadorSemantico.erros).toHaveLength(0); }); + it('Sucesso - Definição Tipo Variável', () => { + const retornoLexador = lexador.mapear([ + "var t: texto = \"Variável com tipo\"", + "const n: inteiro = 10", + "var v1: texto[] = [\'oi\']", + "var v2: inteiro[] = [1]", + "const a: vetor = ['1', '2', '3']", + "const b: vetor = [1, 2, 3]", + "const c: qualquer[] = [1, 2, 3]", + "const d: qualquer[] = [1, '2', 3, 'Olá Mundo']", + "const f: qualquer = [1, '2', 3, 'Olá Mundo']", + ], -1); + const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); + + expect(retornoAvaliadorSintatico).toBeTruthy(); + expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(9); + }); + it('Sucesso - Atribuindo tipos válidos para variáveis', () => { const retornoLexador = lexador.mapear([ "var a: inteiro = 1", @@ -112,6 +130,23 @@ describe('Analisador semântico', () => { expect(retornoAnalisadorSemantico.erros).toHaveLength(8); }); + it('Declaração de variáveis inválidas', () => { + const retornoLexador = lexador.mapear([ + "var t: texto = 1", + "const n: inteiro = \"10\"", + "var v1: texto[] = [1, 2]", + "var v2: inteiro[] = ['1']", + ], -1); + const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); + const retornoAnalisadorSemantico = analisadorSemantico.analisar(retornoAvaliadorSintatico.declaracoes); + + expect(retornoAnalisadorSemantico).toBeTruthy(); + expect(retornoAnalisadorSemantico.erros[0].mensagem).toBe('Atribuição inválida para \'t\', é esperado um \'texto\'.'); + expect(retornoAnalisadorSemantico.erros[1].mensagem).toBe('Atribuição inválida \'n\', é esperado um \'número\'.'); + expect(retornoAnalisadorSemantico.erros[2].mensagem).toBe('Atribuição inválida para \'v1\', é esperado um vetor de \'texto\'.'); + expect(retornoAnalisadorSemantico.erros[3].mensagem).toBe('Atribuição inválida para \'v2\', é esperado um vetor de \'inteiros\' ou \'real\'.'); + }); + it('Retorno vazio', () => { const retornoLexador = lexador.mapear([ "funcao olaMundo (): vazio {", diff --git a/testes/avaliador-sintatico.test.ts b/testes/avaliador-sintatico.test.ts index 19713919..f051e24e 100644 --- a/testes/avaliador-sintatico.test.ts +++ b/testes/avaliador-sintatico.test.ts @@ -14,24 +14,6 @@ describe('Avaliador sintático', () => { expect(retornoAvaliadorSintatico).toBeTruthy(); expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1); }); - - it('Sucesso - Definição Tipo Variável', () => { - const retornoLexador = lexador.mapear([ - "var t: texto = \"Variável com tipo\"", - "const n: inteiro = 10", - "var v1: texto[] = [\'oi\']", - "var v2: inteiro[] = [1]", - "const a: vetor = ['1', '2', '3']", - "const b: vetor = [1, 2, 3]", - "const c: qualquer[] = [1, 2, 3]", - "const d: qualquer[] = [1, '2', 3, 'Olá Mundo']", - "const f: qualquer = [1, '2', 3, 'Olá Mundo']", - ], -1); - const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); - - expect(retornoAvaliadorSintatico).toBeTruthy(); - expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(9); - }); it('Sucesso - Vetor vazio', () => { const retornoLexador = lexador.mapear(['var vetorVazio = []'], -1); From 091c5ca02d1c3d09c5c0db0902167a30951fd0b6 Mon Sep 17 00:00:00 2001 From: Samuel Vaz Date: Tue, 26 Sep 2023 15:57:34 -0300 Subject: [PATCH 4/7] Aumenta cobertura testes --- fontes/analisador-semantico/analisador-semantico.ts | 2 +- testes/analisador-semantico.test.ts | 2 ++ 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/fontes/analisador-semantico/analisador-semantico.ts b/fontes/analisador-semantico/analisador-semantico.ts index 8f7369eb..8f393ff1 100644 --- a/fontes/analisador-semantico/analisador-semantico.ts +++ b/fontes/analisador-semantico/analisador-semantico.ts @@ -85,7 +85,7 @@ export class AnalisadorSemantico implements AnalisadorSemanticoInterface { } } } else { - this.erro(declaracao.simbolo, 'Atribuição inválida, é esperado um vetor de elementos.'); + this.erro(declaracao.simbolo, `Atribuição inválida para '${declaracao.simbolo.lexema}', é esperado um vetor de elementos.`); } } if (declaracao.inicializador instanceof Literal) { diff --git a/testes/analisador-semantico.test.ts b/testes/analisador-semantico.test.ts index bc3b8b5d..544a9c9f 100644 --- a/testes/analisador-semantico.test.ts +++ b/testes/analisador-semantico.test.ts @@ -136,6 +136,7 @@ describe('Analisador semântico', () => { "const n: inteiro = \"10\"", "var v1: texto[] = [1, 2]", "var v2: inteiro[] = ['1']", + "var v3: inteiro[] = 1" ], -1); const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); const retornoAnalisadorSemantico = analisadorSemantico.analisar(retornoAvaliadorSintatico.declaracoes); @@ -145,6 +146,7 @@ describe('Analisador semântico', () => { expect(retornoAnalisadorSemantico.erros[1].mensagem).toBe('Atribuição inválida \'n\', é esperado um \'número\'.'); expect(retornoAnalisadorSemantico.erros[2].mensagem).toBe('Atribuição inválida para \'v1\', é esperado um vetor de \'texto\'.'); expect(retornoAnalisadorSemantico.erros[3].mensagem).toBe('Atribuição inválida para \'v2\', é esperado um vetor de \'inteiros\' ou \'real\'.'); + expect(retornoAnalisadorSemantico.erros[4].mensagem).toBe('Atribuição inválida para \'v3\', é esperado um vetor de elementos.'); }); it('Retorno vazio', () => { From abe597be72e663afd1d6fb32cc9f366e1010ca62 Mon Sep 17 00:00:00 2001 From: Samuel Vaz Date: Tue, 26 Sep 2023 16:07:23 -0300 Subject: [PATCH 5/7] Aumenta cobertura de testes --- testes/analisador-semantico.test.ts | 29 ++++++++++++++++++++++++++++- 1 file changed, 28 insertions(+), 1 deletion(-) diff --git a/testes/analisador-semantico.test.ts b/testes/analisador-semantico.test.ts index 544a9c9f..b658055f 100644 --- a/testes/analisador-semantico.test.ts +++ b/testes/analisador-semantico.test.ts @@ -162,7 +162,7 @@ describe('Analisador semântico', () => { expect(retornoAnalisadorSemantico.erros[0].mensagem).toBe('A função não pode ter nenhum tipo de retorno.'); }); - it('Não retornando o tipo que a função definiu', () => { + it('Não retornando o tipo que a função definiu - texto', () => { const retornoLexador = lexador.mapear([ "funcao executar(valor1, valor2): texto {", " var resultado = valor1 + valor2", @@ -176,6 +176,20 @@ describe('Analisador semântico', () => { expect(retornoAnalisadorSemantico.erros[0].mensagem).toBe('Esperado retorno do tipo \'texto\' dentro da função.'); }); + it('Não retornando o tipo que a função definiu - inteiro', () => { + const retornoLexador = lexador.mapear([ + "funcao executar(valor1, valor2): inteiro {", + " var resultado = valor1 + valor2", + " retorna 'a'", + "}", + ], -1); + const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); + const retornoAnalisadorSemantico = analisadorSemantico.analisar(retornoAvaliadorSintatico.declaracoes); + + expect(retornoAnalisadorSemantico).toBeTruthy(); + expect(retornoAnalisadorSemantico.erros[0].mensagem).toBe('Esperado retorno do tipo \'inteiro\' dentro da função.'); + }); + it('Retorno vazio mas com retorno de valor', () => { const retornoLexador = lexador.mapear([ "funcao executar(valor1, valor2): vazio {", @@ -190,6 +204,19 @@ describe('Analisador semântico', () => { expect(retornoAnalisadorSemantico.erros[0].mensagem).toBe('A função não pode ter nenhum tipo de retorno.'); }); + it('Função sem retorno de valor', () => { + const retornoLexador = lexador.mapear([ + "funcao executar(valor1, valor2): texto {", + " var resultado = valor1 + valor2", + "}", + ], -1); + const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1); + const retornoAnalisadorSemantico = analisadorSemantico.analisar(retornoAvaliadorSintatico.declaracoes); + + expect(retornoAnalisadorSemantico).toBeTruthy(); + expect(retornoAnalisadorSemantico.erros[0].mensagem).toBe('Esperado retorno do tipo \'texto\' dentro da função.'); + }); + it('Parametro com definição de tipo inválido', () => { const retornoLexador = lexador.mapear([ "funcao executar(valor1: algum, valor2): texto {", From 00f0034ccc1e39a2663c934a2cbfef06d7039220 Mon Sep 17 00:00:00 2001 From: Samuel Vaz Date: Tue, 26 Sep 2023 16:16:08 -0300 Subject: [PATCH 6/7] =?UTF-8?q?remove=20m=C3=A9todo=20simbolo=20anterior?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- fontes/avaliador-sintatico/avaliador-sintatico.ts | 4 ---- 1 file changed, 4 deletions(-) diff --git a/fontes/avaliador-sintatico/avaliador-sintatico.ts b/fontes/avaliador-sintatico/avaliador-sintatico.ts index fa9e6ca8..b264f150 100644 --- a/fontes/avaliador-sintatico/avaliador-sintatico.ts +++ b/fontes/avaliador-sintatico/avaliador-sintatico.ts @@ -132,10 +132,6 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface Date: Tue, 26 Sep 2023 16:19:40 -0300 Subject: [PATCH 7/7] =?UTF-8?q?Removendo=20valida=C3=A7=C3=A3o=20de=20tipa?= =?UTF-8?q?gem?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- fontes/avaliador-sintatico/avaliador-sintatico.ts | 12 ++---------- 1 file changed, 2 insertions(+), 10 deletions(-) diff --git a/fontes/avaliador-sintatico/avaliador-sintatico.ts b/fontes/avaliador-sintatico/avaliador-sintatico.ts index b264f150..5804ed4f 100644 --- a/fontes/avaliador-sintatico/avaliador-sintatico.ts +++ b/fontes/avaliador-sintatico/avaliador-sintatico.ts @@ -998,11 +998,7 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface