Repository: DesignLiquido/delegua
Pull request #626 (2024-02-06 19:59:38)

Formatador visualg
#579 


Patch:
diff --git a/fontes/avaliador-sintatico/avaliador-sintatico.ts b/fontes/avaliador-sintatico/avaliador-sintatico.ts
index 42571ba9..6a1e6ddf 100644
--- a/fontes/avaliador-sintatico/avaliador-sintatico.ts
+++ b/fontes/avaliador-sintatico/avaliador-sintatico.ts
@@ -57,6 +57,7 @@ import { RetornoLexador } from '../interfaces/retornos/retorno-lexador';
 import { RetornoDeclaracao } from './retornos';
 import { TiposDadosInterface } from '../interfaces/tipos-dados-interface';
 import { Simbolo } from '../lexador';
+import { SeletorTuplas, Tupla } from '../construtos/tuplas';
 
 /**
  * O avaliador sintático (_Parser_) é responsável por transformar os símbolos do Lexador em estruturas de alto nível.
@@ -191,7 +192,21 @@ export class AvaliadorSintatico implements AvaliadorSintaticoInterface<SimboloIn
                 }
 
                 while (!this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.COLCHETE_DIREITO)) {
-                    const valor = this.atribuir();
+                    let valor: any = null;
+                    if(this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.PARENTESE_ESQUERDO)) {
+                        const expressao = this.expressao();
+                        const argumentos = [expressao];
+                        while (this.simbolos[this.atual].tipo === tiposDeSimbolos.VIRGULA) {
+                            this.avancarEDevolverAnterior();
+                            argumentos.push(this.expressao());
+                        }
+        
+                        this.consumir(tiposDeSimbolos.PARENTESE_DIREITO, "Esperado ')' após a expressão.");
+                        this.consumir(tiposDeSimbolos.COLCHETE_DIREITO, "Esperado ']' após a expressão.");
+                        return new SeletorTuplas(...argumentos) as Tupla;
+                    }
+
+                    valor = this.atribuir();
                     valores.push(valor);
                     if (this.simbolos[this.atual].tipo !== tiposDeSimbolos.COLCHETE_DIREITO) {
                         this.consumir(tiposDeSimbolos.VIRGULA, 'Esperado vírgula antes da próxima expressão.');
diff --git a/fontes/formatadores/formatador-visualg.ts b/fontes/formatadores/formatador-visualg.ts
new file mode 100644
index 00000000..5da369c5
--- /dev/null
+++ b/fontes/formatadores/formatador-visualg.ts
@@ -0,0 +1,644 @@
+import { AcessoIndiceVariavel, AcessoMetodoOuPropriedade, Agrupamento, AtribuicaoPorIndice, Atribuir, Binario, Chamada, Construto, DefinirValor, Dicionario, ExpressaoRegular, FimPara, FormatacaoEscrita, FuncaoConstruto, Isto, Literal, Logico, Super, TipoDe, Unario, Variavel, Vetor } from "../construtos";
+import { Aleatorio, Classe, Const, ConstMultiplo, Expressao, FuncaoDeclaracao, Enquanto, Escolha, Escreva, Fazer, Importar, Para, ParaCada, Se, Tente, Var, VarMultiplo, Bloco, Continua, EscrevaMesmaLinha, Leia, LeiaMultiplo, Retorna, Sustar, Declaracao, Falhar } from "../declaracoes";
+import { SimboloInterface, VisitanteComumInterface } from "../interfaces";
+import { ContinuarQuebra, RetornoQuebra, SustarQuebra } from "../quebras";
+import tiposDeSimbolos from "../tipos-de-simbolos/visualg";
+
+export class FormatadorVisualG implements VisitanteComumInterface {
+    indentacaoAtual: number;
+    quebraLinha: string;
+    tamanhoIndentacao: number;
+    codigoFormatado: string;
+    devePularLinha: boolean;
+    deveIndentar: boolean;
+    contadorDeclaracaoVar: number;
+    deveAdicionarInicio: boolean;
+    retornoFuncaoAtual: SimboloInterface;
+
+    constructor(quebraLinha: string, tamanhoIndentacao: number = 4) {
+        this.quebraLinha = quebraLinha;
+        this.tamanhoIndentacao = tamanhoIndentacao;
+
+        this.indentacaoAtual = 0;
+        this.codigoFormatado = "";
+        this.devePularLinha = false;
+        this.deveIndentar = true;
+        this.contadorDeclaracaoVar = 0
+        this.deveAdicionarInicio = true;
+        this.retornoFuncaoAtual = undefined
+    }
+
+    visitarDeclaracaoAleatorio(declaracao: Aleatorio): any {
+        this.codigoFormatado += `${" ".repeat(this.indentacaoAtual)}aleatorio `
+        if ((declaracao.argumentos.max > 0) && (declaracao.argumentos.min > 0)) {
+            this.codigoFormatado += `${declaracao.argumentos.min}, ${declaracao.argumentos.max}${this.quebraLinha}`
+        } else {
+            this.codigoFormatado += `ON${this.quebraLinha}`
+        }
+        this.formatarDeclaracaoOuConstruto(declaracao.corpo)
+
+    }
+    visitarDeclaracaoClasse(declaracao: Classe) {
+        throw new Error("Método não implementado.");
+    }
+    visitarDeclaracaoConst(declaracao: Const): any {
+        throw new Error("Método não implementado.");
+    }
+    visitarDeclaracaoConstMultiplo(declaracao: ConstMultiplo): any {
+        throw new Error("Método não implementado.");
+    }
+    visitarExpressaoDeAtribuicao(expressao: Atribuir) {
+        this.codigoFormatado += `${expressao.simbolo.lexema} <- `;
+        this.formatarDeclaracaoOuConstruto(expressao.valor);
+
+        if (this.devePularLinha) {
+            this.codigoFormatado += `${this.quebraLinha}`;
+        }
+    }
+    visitarDeclaracaoDeExpressao(declaracao: Expressao) {
+        this.codigoFormatado += " ".repeat(this.indentacaoAtual);
+        this.formatarDeclaracaoOuConstruto(declaracao.expressao);
+    }
+    visitarDeclaracaoDefinicaoFuncao(declaracao: FuncaoDeclaracao) {
+        this.retornoFuncaoAtual = declaracao.tipoRetorno;
+        this.contadorDeclaracaoVar = 2;
+        this.codigoFormatado += `${" ".repeat(this.indentacaoAtual)}funcao `;
+        if (declaracao.simbolo) {
+            this.codigoFormatado += `${declaracao.simbolo.lexema}`;
+        }
+
+
+        let primeiraOcorrenciaVar = declaracao.funcao.corpo.findIndex(item => item instanceof Var);
+        var ultimaOcorrenciaIndex = declaracao.funcao.corpo.slice().reverse().findIndex(item => item instanceof Var);
+        var ultimaOcorrenciaPosicao = ultimaOcorrenciaIndex >= 0 ? declaracao.funcao.corpo.length - 1 - ultimaOcorrenciaIndex : -1;
+
+        let indiceParaRemover = [];
+        if (primeiraOcorrenciaVar > -1 && ultimaOcorrenciaPosicao > -1) {
+            this.codigoFormatado += this.quebraLinha;
+            for (let i = primeiraOcorrenciaVar; i <= ultimaOcorrenciaPosicao; i++) {
+                this.formatarDeclaracaoOuConstruto(declaracao.funcao.corpo[i]);
+                indiceParaRemover.push(i)
+            }
+        }
+
+        for (let posicao of indiceParaRemover) {
+            declaracao.funcao.corpo.splice(posicao, 1)
+        }
+        this.codigoFormatado += this.quebraLinha
+        this.codigoFormatado += `${" ".repeat(this.indentacaoAtual)}inicio${this.quebraLinha}`
+
+        this.formatarDeclaracaoOuConstruto(declaracao.funcao);
+        this.codigoFormatado += `${" ".repeat(this.indentacaoAtual)}fimfuncao${this.quebraLinha}`;
+    }
+    visitarDeclaracaoEnquanto(declaracao: Enquanto) {
+        this.codigoFormatado += `${" ".repeat(this.indentacaoAtual)}enquanto(`;
+        this.formatarDeclaracaoOuConstruto(declaracao.condicao);
+        this.codigoFormatado += ` ) faca`;
+        this.codigoFormatado += this.quebraLinha;
+
+        this.formatarDeclaracaoOuConstruto(declaracao.corpo);
+        this.codigoFormatado += `${" ".repeat(this.indentacaoAtual)}fimenquanto`;
+    }
+    visitarDeclaracaoEscolha(declaracao: Escolha) {
+        this.codigoFormatado += `${" ".repeat(this.indentacaoAtual)}escolha (`;
+        this.formatarDeclaracaoOuConstruto(declaracao.identificadorOuLiteral);
+
+        this.codigoFormatado += `)${this.quebraLinha}`;
+        this.indentacaoAtual += this.tamanhoIndentacao;
+        for (let caminho of declaracao.caminhos) {
+            this.codigoFormatado += `${" ".repeat(this.indentacaoAtual)}caso `;
+            for (let condicao of caminho.condicoes) {
+                this.formatarDeclaracaoOuConstruto(condicao)
+                this.codigoFormatado += ", "
+            }
+            if (caminho.condicoes.length > 0) {
+                this.codigoFormatado = this.codigoFormatado.slice(0, -2);
+            }
+            this.codigoFormatado += this.quebraLinha;
+            this.formatarBlocoOuVetorDeclaracoes(caminho.declaracoes)
+        }
+
+        if (declaracao.caminhoPadrao.declaracoes.length > 0) {
+            this.codigoFormatado += `${" ".repeat(this.indentacaoAtual)}outrocaso`;
+            this.codigoFormatado += this.quebraLinha;
+            this.formatarBlocoOuVetorDeclaracoes(declaracao.caminhoPadrao.declaracoes)
+        }
+
+        this.indentacaoAtual -= this.tamanhoIndentacao;
+        this.codigoFormatado += `${" ".repeat(this.indentacaoAtual)}fimescolha${this.quebraLinha}`;
+    }
+    visitarDeclaracaoEscreva(declaracao: Escreva) {
+        this.codigoFormatado += `${" ".repeat(this.indentacaoAtual)}escreva(`;
+        for (let argumento of declaracao.argumentos) {
+            this.formatarDeclaracaoOuConstruto(argumento);
+            this.codigoFormatado += ", ";
+        }
+        if (declaracao.argumentos.length && this.codigoFormatado[this.codigoFormatado.length - 2] === ",") {
+            this.codigoFormatado = this.codigoFormatado.slice(0, -2);
+        }
+        this.codigoFormatado += `)${this.quebraLinha}`;
+    }
+    visitarDeclaracaoFazer(declaracao: Fazer) {
+        this.codigoFormatado += `${" ".repeat(this.indentacaoAtual)}repita${this.quebraLinha}`
+        this.formatarDeclaracaoOuConstruto(declaracao.caminhoFazer);
+        this.codigoFormatado += `${" ".repeat(this.indentacaoAtual)}ate `
+        this.formatarDeclaracaoOuConstruto(declaracao.condicaoEnquanto)
+    }
+    visitarDeclaracaoImportar(declaracao: Importar) {
+        throw new Error("Método não implementado.");
+    }
+    visitarDeclaracaoPara(declaracao: Para): any {
+        this.codigoFormatado += `${" ".repeat(this.indentacaoAtual)}para `;
+        this.devePularLinha = false;
+        if (declaracao.inicializador) {
+            if (Array.isArray(declaracao.inicializador)) {
+                this.deveIndentar = false;
+                for (let declaracaoInicializador of declaracao.inicializador) {
+                    this.formatarDeclaracaoOuConstruto(declaracaoInicializador);
+                }
+                this.deveIndentar = true;
+            } else {
+                this.formatarDeclaracaoOuConstruto(declaracao.inicializador);
+            }
+        }
+
+        if (declaracao.condicao instanceof Binario)
+            this.codigoFormatado += ` ate ${declaracao.condicao.direita.valor}`;
+        else
+            this.formatarDeclaracaoOuConstruto(declaracao.condicao);
+
+
+        this.codigoFormatado += ` faca${this.quebraLinha}`;
+        this.formatarDeclaracaoOuConstruto(declaracao.incrementar);
+
+        this.formatarBlocoOuVetorDeclaracoes(declaracao.corpo.declaracoes)
+
+        this.codigoFormatado += `${" ".repeat(this.indentacaoAtual)}fimpara${this.quebraLinha}`;
+    }
+    visitarDeclaracaoParaCada(declaracao: ParaCada): any {
+        throw new Error("Método não implementado.");
+    }
+    visitarDeclaracaoSe(declaracao: Se) {
+        this.codigoFormatado += `${" ".repeat(this.indentacaoAtual)}se ( `;
+        this.formatarDeclaracaoOuConstruto(declaracao.condicao);
+        this.codigoFormatado += ` ) entao${this.quebraLinha}`;
+
+        this.indentacaoAtual += this.tamanhoIndentacao;
+        for (let declaracaoBloco of (declaracao.caminhoEntao as Bloco).declaracoes) {
+            this.formatarDeclaracaoOuConstruto(declaracaoBloco);
+        }
+
+        this.indentacaoAtual -= this.tamanhoIndentacao;
+        if (declaracao.caminhoSenao) {
+            this.codigoFormatado += `${" ".repeat(this.indentacaoAtual)}} senao `;
+            this.formatarDeclaracaoOuConstruto(declaracao.caminhoSenao);
+        } else {
+            this.codigoFormatado += `${" ".repeat(this.indentacaoAtual)}fimse${this.quebraLinha}`;
+        }
+    }
+    visitarDeclaracaoTente(declaracao: Tente) {
+        throw new Error("Método não implementado.");
+    }
+    visitarDeclaracaoVar(declaracao: Var): any {
+        switch (this.contadorDeclaracaoVar) {
+            case 0:
+                this.codigoFormatado += `var${this.quebraLinha}`
+                this.contadorDeclaracaoVar++;
+                break;
+            case 2:
+                this.codigoFormatado += `${" ".repeat(this.indentacaoAtual)}var${this.quebraLinha}`
+                this.contadorDeclaracaoVar++;
+                break;
+        }
+
+        if (this.contadorDeclaracaoVar > 2) {
+            this.indentacaoAtual += this.tamanhoIndentacao;
+        }
+
+        if (this.deveIndentar) {
+            this.codigoFormatado += `${" ".repeat(this.indentacaoAtual)}`;
+        }
+
+        this.codigoFormatado += `${declaracao.simbolo.lexema}`;
+
+        if (declaracao.inicializador) {
+            this.codigoFormatado += ` : ${declaracao.tipo.toLowerCase()}`;
+        }
+
+        if (this.devePularLinha) {
+            this.codigoFormatado += this.quebraLinha;
+        }
+        if (this.contadorDeclaracaoVar > 2) {
+            this.indentacaoAtual -= this.tamanhoIndentacao;
+        }
+    }
+    visitarDeclaracaoVarMultiplo(declaracao: VarMultiplo): any {
+        throw new Error("Método não implementado.");
+    }
+    visitarExpressaoAcessoIndiceVariavel(expressao: any) {
+        throw new Error("Método não implementado.");
+    }
+    visitarExpressaoAcessoElementoMatriz(expressao: any) {
+        throw new Error("Método não implementado.");
+    }
+    visitarExpressaoAcessoMetodo(expressao: any) {
+        throw new Error("Método não implementado.");
+    }
+    visitarExpressaoAgrupamento(expressao: any): any {
+        this.codigoFormatado += "(";
+        this.formatarDeclaracaoOuConstruto(expressao.expressao);
+        this.codigoFormatado += ")";
+    }
+    visitarExpressaoAtribuicaoPorIndice(expressao: any): any {
+        throw new Error("Método não implementado.");
+    }
+    visitarExpressaoAtribuicaoPorIndicesMatriz(expressao: any): any {
+        throw new Error("Método não implementado.");
+    }
+    visitarExpressaoBinaria(expressao: Binario) {
+        this.formatarDeclaracaoOuConstruto(expressao.esquerda);
+        switch (expressao.operador.tipo) {
+            case tiposDeSimbolos.ADICAO:
+                this.codigoFormatado += " + "
+                break;
+            case tiposDeSimbolos.DIVISAO:
+                this.codigoFormatado += " / "
+                break;
+            case tiposDeSimbolos.DIVISAO_INTEIRA:
+                this.codigoFormatado += " \ "
+                break;
+            case tiposDeSimbolos.IGUAL:
+                this.codigoFormatado += " = "
+                break;
+            case tiposDeSimbolos.MAIOR:
+                this.codigoFormatado += " > "
+                break;
+            case tiposDeSimbolos.MAIOR_IGUAL:
+                this.codigoFormatado += " >= "
+                break;
+            case tiposDeSimbolos.MENOR:
+                this.codigoFormatado += "<"
+                break;
+            case tiposDeSimbolos.MENOR_IGUAL:
+                this.codigoFormatado += " <= "
+                break;
+            case tiposDeSimbolos.SUBTRACAO:
+                this.codigoFormatado += ` - `;
+                break;
+            case tiposDeSimbolos.MULTIPLICACAO:
+                this.codigoFormatado += ` * `;
+                break;
+            case tiposDeSimbolos.MODULO:
+                this.codigoFormatado += ` % `;
+                break;
+            default:
+                console.log(expressao.operador.tipo);
+                break;
+
+        }
+        this.formatarDeclaracaoOuConstruto(expressao.direita)
+    }
+
+    private formatarBlocoOuVetorDeclaracoes(declaracoes: Declaracao[]) {
+        this.indentacaoAtual += this.tamanhoIndentacao;
+        for (let declaracaoBloco of declaracoes) {
+            this.formatarDeclaracaoOuConstruto(declaracaoBloco);
+        }
+        this.indentacaoAtual -= this.tamanhoIndentacao;
+    }
+
+    visitarExpressaoBloco(declaracao: Bloco): any {
+        this.formatarBlocoOuVetorDeclaracoes(declaracao.declaracoes);
+    }
+    visitarExpressaoContinua(declaracao?: Continua): ContinuarQuebra {
+        throw new Error("Método não implementado.");
+    }
+    visitarExpressaoDeChamada(expressao: any) {
+        this.formatarDeclaracaoOuConstruto(expressao.entidadeChamada);
+        this.codigoFormatado += "(";
+        for (let argumento of expressao.argumentos) {
+            this.formatarDeclaracaoOuConstruto(argumento);
+            this.codigoFormatado += ", ";
+        }
+
+        if (expressao.argumentos.length > 0) {
+            this.codigoFormatado = this.codigoFormatado.slice(0, -2);
+        }
+
+        this.codigoFormatado += ")";
+
+    }
+    visitarExpressaoDefinirValor(expressao: any) {
+        throw new Error("Método não implementado.");
+    }
+    visitarExpressaoDeleguaFuncao(expressao: any) {
+        throw new Error("Método não implementado.");
+    }
+    visitarExpressaoDeVariavel(expressao: Variavel) {
+        this.codigoFormatado += expressao.simbolo.lexema;
+    }
+    visitarExpressaoDicionario(expressao: any) {
+        throw new Error("Método não implementado.");
+    }
+    visitarExpressaoExpressaoRegular(expressao: ExpressaoRegular): Promise<RegExp> {
+        throw new Error("Método não implementado.");
+    }
+    visitarDeclaracaoEscrevaMesmaLinha(declaracao: EscrevaMesmaLinha) {
+        this.codigoFormatado += `${" ".repeat(this.indentacaoAtual)}escreva(`;
+        for (let argumento of declaracao.argumentos) {
+            const argumentoTratado = argumento as FormatacaoEscrita
+            this.formatarDeclaracaoOuConstruto(argumentoTratado);
+            this.codigoFormatado += ", ";
+        }
+        if (declaracao.argumentos.length && this.codigoFormatado[this.codigoFormatado.length - 2] === ",") {
+            this.codigoFormatado = this.codigoFormatado.slice(0, -2);
+        }
+        this.codigoFormatado += `)${this.quebraLinha}`;
+    }
+    visitarExpressaoFalhar(expressao: any): any {
+        throw new Error("Método não implementado.");
+    }
+    visitarExpressaoFimPara(declaracao: FimPara) {
+        throw new Error("Método não implementado.");
+    }
+    visitarExpressaoFormatacaoEscrita(declaracao: FormatacaoEscrita) {
+        this.formatarDeclaracaoOuConstruto(declaracao.expressao)
+    }
+    visitarExpressaoIsto(expressao: any) {
+        throw new Error("Método não implementado.");
+    }
+    visitarExpressaoLeia(expressao: Leia): any {
+        this.codigoFormatado += `${" ".repeat(this.tamanhoIndentacao)}leia(`;
+        for (let argumento of expressao.argumentos) {
+            this.formatarDeclaracaoOuConstruto(argumento);
+            this.codigoFormatado += `, `;
+        }
+
+        if (expressao.argumentos.length > 0) {
+            this.codigoFormatado = this.codigoFormatado.slice(0, -2);
+        }
+
+        this.codigoFormatado += `)${this.quebraLinha}`;
+    }
+    visitarExpressaoLeiaMultiplo(expressao: LeiaMultiplo): any {
+        return Promise.resolve()
+    }
+    visitarExpressaoLiteral(expressao: any): any {
+        if (typeof expressao.valor === "string") {
+            this.codigoFormatado += `"${expressao.valor}"`;
+            return;
+        } if (typeof expressao.valor === "boolean") {
+            switch (expressao.valor) {
+                case true:
+                    this.codigoFormatado += `verdadeiro`;
+                    break;
+                case false:
+                    this.codigoFormatado += `falso`;
+                    break;
+            }
+            return;
+        }
+
+        this.codigoFormatado += expressao.valor;
+    }
+    visitarExpressaoLogica(expressao: any) {
+        this.formatarDeclaracaoOuConstruto(expressao.esquerda);
+
+        switch (expressao.operador.tipo) {
+            case tiposDeSimbolos.E:
+                this.codigoFormatado += ` e `;
+                break;
+            case tiposDeSimbolos.XOU:
+                this.codigoFormatado += ` xou `;
+                break;
+            case tiposDeSimbolos.OU:
+                this.codigoFormatado += ` ou `;
+                break;
+            case tiposDeSimbolos.NEGACAO:
+                this.codigoFormatado += ` nao `;
+                break;
+        }
+
+        this.formatarDeclaracaoOuConstruto(expressao.direita);
+    }
+    visitarExpressaoRetornar(declaracao: Retorna): any {
+        this.codigoFormatado += `${" ".repeat(this.indentacaoAtual)}retorne`;
+        if (declaracao.valor) {
+            this.codigoFormatado += ` `;
+            this.formatarDeclaracaoOuConstruto(declaracao.valor);
+        }
+
+        this.codigoFormatado += `${this.quebraLinha}`;
+    }
+    visitarExpressaoSuper(expressao: Super) {
+        throw new Error("Método não implementado.");
+    }
+    visitarExpressaoSustar(declaracao?: Sustar): any {
+        this.codigoFormatado += `${" ".repeat(this.indentacaoAtual)}interrompa${this.quebraLinha}`;
+
+    }
+    visitarExpressaoTipoDe(expressao: TipoDe): any {
+        throw new Error("Método não implementado.");
+    }
+    visitarExpressaoUnaria(expressao: Unario) {
+        let operador: string;
+        switch (expressao.operador.tipo) {
+            case tiposDeSimbolos.SUBTRACAO:
+                operador = `-`;
+                break;
+            case tiposDeSimbolos.ADICAO:
+                operador = `+`;
+                break;
+            case tiposDeSimbolos.NEGACAO:
+                operador = `nao `
+        }
+
+        switch (expressao.incidenciaOperador) {
+            case "ANTES":
+                this.codigoFormatado += operador;
+                this.formatarDeclaracaoOuConstruto(expressao.operando);
+                break;
+            case "DEPOIS":
+                this.formatarDeclaracaoOuConstruto(expressao.operando);
+                this.codigoFormatado += operador;
+                break;
+        }
+
+        if (this.devePularLinha) {
+            this.codigoFormatado += this.quebraLinha;
+        }
+    }
+    visitarExpressaoVetor(expressao: any) {
+        throw new Error("Método não implementado.");
+    }
+
+    formatarDeclaracaoOuConstruto(declaracaoOuConstruto: Declaracao | Construto): void {
+        switch (declaracaoOuConstruto.constructor.name) {
+            case "AcessoIndiceVariavel":
+                this.visitarExpressaoAcessoIndiceVariavel(declaracaoOuConstruto as AcessoIndiceVariavel);
+                break;
+            case "AcessoMetodoOuPropriedade":
+                this.visitarExpressaoAcessoMetodo(declaracaoOuConstruto as AcessoMetodoOuPropriedade);
+                break;
+            case "Aleatorio":
+                this.visitarDeclaracaoAleatorio(declaracaoOuConstruto as Aleatorio);
+                break;
+            case "Agrupamento":
+                this.visitarExpressaoAgrupamento(declaracaoOuConstruto as Agrupamento);
+                break;
+            case "AtribuicaoPorIndice":
+                this.visitarExpressaoAtribuicaoPorIndice(declaracaoOuConstruto as AtribuicaoPorIndice);
+                break;
+            case "Atribuir":
+                this.visitarExpressaoDeAtribuicao(declaracaoOuConstruto as Atribuir);
+                break;
+            case "Binario":
+                this.visitarExpressaoBinaria(declaracaoOuConstruto as Binario);
+                break;
+            case "Bloco":
+                this.visitarExpressaoBloco(declaracaoOuConstruto as Bloco);
+                break;
+            case "Chamada":
+                this.visitarExpressaoDeChamada(declaracaoOuConstruto as Chamada);
+                break;
+            case "Classe":
+                this.visitarDeclaracaoClasse(declaracaoOuConstruto as Classe);
+                break;
+            case "Continua":
+                this.visitarExpressaoContinua(declaracaoOuConstruto as Continua);
+                break;
+            case "DefinirValor":
+                this.visitarExpressaoDefinirValor(declaracaoOuConstruto as DefinirValor);
+                break;
+            case "Dicionario":
+                this.visitarExpressaoDicionario(declaracaoOuConstruto as Dicionario);
+                break;
+            case "Escolha":
+                this.visitarDeclaracaoEscolha(declaracaoOuConstruto as Escolha);
+                break;
+            case "Enquanto":
+                this.visitarDeclaracaoEnquanto(declaracaoOuConstruto as Enquanto);
+                break;
+            case "Escreva":
+                this.visitarDeclaracaoEscreva(declaracaoOuConstruto as Escreva);
+                break;
+            case "EscrevaMesmaLinha":
+                this.visitarDeclaracaoEscrevaMesmaLinha(declaracaoOuConstruto as Escreva);
+                break;
+            case "Expressao":
+                this.visitarDeclaracaoDeExpressao(declaracaoOuConstruto as Expressao);
+                break;
+            case "ExpressaoRegular":
+                this.visitarExpressaoExpressaoRegular(declaracaoOuConstruto as ExpressaoRegular);
+                break;
+            case "Falhar":
+                this.visitarExpressaoFalhar(declaracaoOuConstruto as Falhar)
+                break;
+            case "Fazer":
+                this.visitarDeclaracaoFazer(declaracaoOuConstruto as Fazer);
+                break;
+            case "FormatacaoEscrita":
+                this.visitarExpressaoFormatacaoEscrita(declaracaoOuConstruto as FormatacaoEscrita);
+                break;
+            case "FuncaoConstruto":
+                this.visitarExpressaoFuncaoConstruto(declaracaoOuConstruto as FuncaoConstruto);
+                break;
+            case "FuncaoDeclaracao":
+                this.visitarDeclaracaoDefinicaoFuncao(declaracaoOuConstruto as FuncaoDeclaracao);
+                break;
+            case "Importar":
+                this.visitarDeclaracaoImportar(declaracaoOuConstruto as Importar);
+                break;
+            case "Isto":
+                this.visitarExpressaoIsto(declaracaoOuConstruto as Isto);
+                break;
+            case "Leia":
+                this.visitarExpressaoLeia(declaracaoOuConstruto as Leia);
+                break;
+            case "Literal":
+                this.visitarExpressaoLiteral(declaracaoOuConstruto as Literal);
+                break;
+            case "Logico":
+                this.visitarExpressaoLogica(declaracaoOuConstruto as Logico);
+                break;
+            case "Para":
+                this.visitarDeclaracaoPara(declaracaoOuConstruto as Para);
+                break;
+            case "ParaCada":
+                this.visitarDeclaracaoParaCada(declaracaoOuConstruto as ParaCada);
+                break;
+            case "Retorna":
+                this.visitarExpressaoRetornar(declaracaoOuConstruto as Retorna);
+                break;
+            case "Se":
+                this.visitarDeclaracaoSe(declaracaoOuConstruto as Se);
+                break;
+            case "Super":
+                this.visitarExpressaoSuper(declaracaoOuConstruto as Super);
+                break;
+            case "Sustar":
+                this.visitarExpressaoSustar(declaracaoOuConstruto as Sustar);
+                break;
+            case "Tente":
+                this.visitarDeclaracaoTente(declaracaoOuConstruto as Tente);
+                break;
+            case "TipoDe":
+                this.visitarExpressaoTipoDe(declaracaoOuConstruto as TipoDe);
+                break;
+            case "Unario":
+                this.visitarExpressaoUnaria(declaracaoOuConstruto as Unario);
+                break;
+            case "Const":
+                this.visitarDeclaracaoConst(declaracaoOuConstruto as Const);
+                break;
+            case "Var":
+                this.visitarDeclaracaoVar(declaracaoOuConstruto as Var);
+                break;
+            case "Variavel":
+                this.visitarExpressaoDeVariavel(declaracaoOuConstruto as Variavel);
+                break;
+            case "Vetor":
+                this.visitarExpressaoVetor(declaracaoOuConstruto as Vetor);
+                break;
+            default:
+                console.log(declaracaoOuConstruto.constructor.name);
+                break;
+        }
+    }
+    visitarExpressaoFuncaoConstruto(expressao: FuncaoConstruto) {
+        if (expressao.parametros.length > 0) {
+            this.codigoFormatado += `(`;
+            for (let argumento of expressao.parametros) {
+                this.codigoFormatado += `${argumento.nome.lexema}${argumento.tipoDado && argumento.tipoDado.tipo ? `: ${argumento.tipoDado.tipo}, ` : ", "
+                    }`;
+            }
+            this.codigoFormatado = this.codigoFormatado.slice(0, -2);
+            this.codigoFormatado += `) `;
+        }
+        this.codigoFormatado += ` : ${this.retornoFuncaoAtual}${this.quebraLinha}`;
+        this.formatarBlocoOuVetorDeclaracoes(expressao.corpo);
+    }
+
+    formatar(declaracoes: Declaracao[]): string {
+        this.indentacaoAtual = 0;
+        this.codigoFormatado = `algoritmo ""${this.quebraLinha}`;
+        this.devePularLinha = true;
+        this.deveIndentar = true;
+        this.indentacaoAtual += this.tamanhoIndentacao;
+
+        for (let declaracao of declaracoes) {
+            if (!(declaracao instanceof Var) && this.deveAdicionarInicio) {
+                this.codigoFormatado += `${this.quebraLinha}inicio${this.quebraLinha}`
+                this.deveAdicionarInicio = false;
+            } else if (declaracao instanceof Var) this.deveAdicionarInicio = true
+
+
+            this.formatarDeclaracaoOuConstruto(declaracao);
+        }
+
+        this.indentacaoAtual -= this.tamanhoIndentacao;
+        this.codigoFormatado += `${this.quebraLinha}fimalgoritmo`
+        return this.codigoFormatado;
+    }
+
+}
\ No newline at end of file
diff --git a/fontes/formatadores/index.ts b/fontes/formatadores/index.ts
index 72f662f9..dd180e1f 100644
--- a/fontes/formatadores/index.ts
+++ b/fontes/formatadores/index.ts
@@ -1,2 +1,3 @@
 export * from './formatador-delegua';
 export * from './formatador-portugol-studio';
+export * from './formatador-visualg';


Test patch:
diff --git a/testes/avaliador-sintatico.test.ts b/testes/avaliador-sintatico.test.ts
index 0f0a6485..11c2ae88 100644
--- a/testes/avaliador-sintatico.test.ts
+++ b/testes/avaliador-sintatico.test.ts
@@ -232,6 +232,98 @@ describe('Avaliador sintático', () => {
             });
         });
 
+        describe('Declarações de tuplas', () => {
+            it('Dupla', () => {
+                const retornoLexador = lexador.mapear([
+                    'var t = [(1, 2)]'
+                ], -1);
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                expect(retornoAvaliadorSintatico).toBeTruthy();
+                expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+            });
+
+            it('Trio', () => {
+                const retornoLexador = lexador.mapear([
+                    'var t = [(1, 2, 3)]'
+                ], -1);
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                expect(retornoAvaliadorSintatico).toBeTruthy();
+                expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+            });
+
+            it('Quarteto', () => {
+                const retornoLexador = lexador.mapear([
+                    'var t = [(1, 2, 3, 4)]'
+                ], -1);
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                expect(retornoAvaliadorSintatico).toBeTruthy();
+                expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+            });
+
+            it('Quinteto', () => {
+                const retornoLexador = lexador.mapear([
+                    'var t = [(1, 2, 3, 4, 5)]'
+                ], -1);
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                expect(retornoAvaliadorSintatico).toBeTruthy();
+                expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+            });
+
+            it('Sexteto', () => {
+                const retornoLexador = lexador.mapear([
+                    'var t = [(1, 2, 3, 4, 5, 6)]'
+                ], -1);
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                expect(retornoAvaliadorSintatico).toBeTruthy();
+                expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+            });
+
+            it('Septeto', () => {
+                const retornoLexador = lexador.mapear([
+                    'var t = [(1, 2, 3, 4, 5, 6, 7)]'
+                ], -1);
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                expect(retornoAvaliadorSintatico).toBeTruthy();
+                expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+            });
+
+            it('Octeto', () => {
+                const retornoLexador = lexador.mapear([
+                    'var t = [(1, 2, 3, 4, 5, 6, 7, 8)]'
+                ], -1);
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                expect(retornoAvaliadorSintatico).toBeTruthy();
+                expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+            });
+
+            it('Noneto', () => {
+                const retornoLexador = lexador.mapear([
+                    'var t = [(1, 2, 3, 4, 5, 6, 7, 8, 9)]'
+                ], -1);
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                expect(retornoAvaliadorSintatico).toBeTruthy();
+                expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+            });
+
+            it('Deceto', () => {
+                const retornoLexador = lexador.mapear([
+                    'var t = [(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)]'
+                ], -1);
+                const retornoAvaliadorSintatico = avaliadorSintatico.analisar(retornoLexador, -1);
+
+                expect(retornoAvaliadorSintatico).toBeTruthy();
+                expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(1);
+            });
+        });
+
         describe('Cenários de falha', () => {
             it('Falha - declaração de variáveis com identificadores à esquerda do igual diferente da quantidade de valores à direita', async () => {
                 const retornoLexador = lexador.mapear(['var a, b, c = 1, 2'], -1);
diff --git a/testes/visualg/formatador-visualg.test.ts b/testes/visualg/formatador-visualg.test.ts
new file mode 100644
index 00000000..c330fbba
--- /dev/null
+++ b/testes/visualg/formatador-visualg.test.ts
@@ -0,0 +1,349 @@
+import * as sistemaOperacional from 'os';
+
+import { FormatadorVisualG } from '../../fontes/formatadores';
+import { LexadorVisuAlg } from '../../fontes/lexador/dialetos';
+import { AvaliadorSintaticoVisuAlg } from '../../fontes/avaliador-sintatico/dialetos';
+
+describe('Formatadores > VisualG', () => {
+    const formatadorVisualG = new FormatadorVisualG(sistemaOperacional.EOL);
+    const avaliadorSintaticoVisualG = new AvaliadorSintaticoVisuAlg();
+    const lexadorVisuAlg = new LexadorVisuAlg();
+
+    it('Olá mundo', () => {
+        const retornoLexador = lexadorVisuAlg.mapear([
+            'algoritmo "olá mundo"',
+            'inicio',
+            'escreva("Olá mundo")',
+            'fimalgoritmo'
+        ], -1);
+
+        const retornoAvaliadorSintatico = avaliadorSintaticoVisualG.analisar(retornoLexador, -1);
+
+        const resultado = formatadorVisualG.formatar(retornoAvaliadorSintatico.declaracoes);
+        const linhasResultado = resultado.split(sistemaOperacional.EOL)
+
+        expect(linhasResultado).toHaveLength(6)
+    })
+
+    it('Lendo variaveis', () => {
+        const retornoLexador = lexadorVisuAlg.mapear([
+            'algoritmo "Soma dos números"',
+            'var',
+            'numero1: inteiro',
+            'numero2: inteiro',
+            'inicio',
+            'escreva("Digite o primeiro número: ")',
+            'leia(numero1)',
+            'leia(numero2)',
+            'escreva("Digite o segundo número: ")',
+            'escreva("A soma de ", numero1 , "por " , numero2 , "é igual à: " , numero1 , numero2)',
+            'fimalgoritmo'
+        ], -1);
+
+        const retornoAvaliadorSintatico = avaliadorSintaticoVisualG.analisar(retornoLexador, -1);
+
+        const resultado = formatadorVisualG.formatar(retornoAvaliadorSintatico.declaracoes);
+        const linhasResultado = resultado.split(sistemaOperacional.EOL)
+
+        expect(linhasResultado).toHaveLength(13)
+    })
+
+    it('Atribuição', () => {
+        const retornoLexador = lexadorVisuAlg.mapear(
+            [
+                'algoritmo "Atribuição"',
+                'var a: inteiro',
+                'var b: caracter',
+                'inicio',
+                'a <- 1',
+                'b := "b"',
+                'escreva (a)',
+                'escreva (b)',
+                'fimalgoritmo',
+            ],
+            -1
+        );
+
+        const retornoAvaliadorSintatico = avaliadorSintaticoVisualG.analisar(retornoLexador, -1);
+        const resultado = formatadorVisualG.formatar(retornoAvaliadorSintatico.declaracoes);
+
+        const linhasResultado = resultado.split(sistemaOperacional.EOL)
+        expect(linhasResultado).toHaveLength(11)
+    })
+
+    it('Enquanto', () => {
+        const retornoLexador = lexadorVisuAlg.mapear(
+            [
+                'algoritmo "Números de 1 a 10 (com enquanto...faca)"',
+                'var j: inteiro',
+                'inicio',
+                'j <- 1',
+                'enquanto j <= 10 faca',
+                'escreva (j)',
+                'j <- j + 1',
+                'fimenquanto',
+                'fimalgoritmo',
+            ],
+            -1
+        );
+
+        const retornoAvaliadorSintatico = avaliadorSintaticoVisualG.analisar(retornoLexador, -1);
+        const resultado = formatadorVisualG.formatar(retornoAvaliadorSintatico.declaracoes);
+
+        const linhasResultado = resultado.split(sistemaOperacional.EOL)
+        expect(linhasResultado).toHaveLength(10)
+    })
+
+    it('Escolha', () => {
+        const retornoLexador = lexadorVisuAlg.mapear(
+            [
+                'algoritmo "Times"',
+                'var time: caractere',
+                'inicio',
+                'escreva ("Entre com o nome de um time de futebol: ")',
+                'leia (time)',
+                'escolha time',
+                'caso "Flamengo", "Fluminense", "Vasco", "Botafogo"',
+                'escreval ("É um time carioca.")',
+                'caso "São Paulo", "Palmeiras", "Santos", "Corínthians"',
+                'escreval ("É um time paulista.")',
+                'outrocaso',
+                'escreval ("É de outro estado.")',
+                'fimescolha',
+                'fimalgoritmo',
+            ],
+            -1
+        );
+        const retornoAvaliadorSintatico = avaliadorSintaticoVisualG.analisar(retornoLexador, -1);
+        const resultado = formatadorVisualG.formatar(retornoAvaliadorSintatico.declaracoes);
+
+        const linhasResultado = resultado.split(sistemaOperacional.EOL)
+        expect(linhasResultado).toHaveLength(16)
+    });
+
+    it('Função', () => {
+        const retornoLexador = lexadorVisuAlg.mapear(
+            [
+                'Algoritmo "exemplo-funcoes"',
+                'Var',
+                'n: inteiro',
+                'm: inteiro',
+                'res: inteiro',
+                'Inicio',
+                'funcao soma: inteiro',
+                'var aux: inteiro',
+                'inicio',
+                'aux <- n + m',
+                'retorne aux',
+                'fimfuncao',
+                'n <- 4',
+                'm <- -9',
+                'res <- soma',
+                'escreva(res)',
+                'Fimalgoritmo',
+            ],
+            -1
+        );
+        const retornoAvaliadorSintatico = avaliadorSintaticoVisualG.analisar(retornoLexador, -1);
+
+        const resultado = formatadorVisualG.formatar(retornoAvaliadorSintatico.declaracoes);
+
+        const linhasResultado = resultado.split(sistemaOperacional.EOL)
+        expect(linhasResultado).toHaveLength(22)
+    });
+
+    it('Interrompa', () => {
+        const retornoLexador = lexadorVisuAlg.mapear(
+            [
+                'algoritmo "Números de 1 a 10 (com interrompa)"',
+                'var x: inteiro',
+                'inicio',
+                'x <- 0',
+                'repita',
+                '   x <- x + 1',
+                '   escreva (x)',
+                '   se x = 10 entao',
+                '      interrompa',
+                '   fimse',
+                'ate falso',
+                'fimalgoritmo',
+            ],
+            -1
+        );
+        const retornoAvaliadorSintatico = avaliadorSintaticoVisualG.analisar(retornoLexador, -1);
+        const resultado = formatadorVisualG.formatar(retornoAvaliadorSintatico.declaracoes)
+        const linhasResultado = resultado.split(sistemaOperacional.EOL)
+
+        expect(linhasResultado).toHaveLength(13)
+        expect(retornoAvaliadorSintatico).toBeTruthy();
+        expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(3);
+    });
+
+    it('Leia', () => {
+        const retornoLexador = lexadorVisuAlg.mapear(
+            [
+                'Algoritmo "Soma 5"',
+                'Var',
+                '   n1, n2, n3, n4, n5: inteiro',
+                'Inicio',
+                '      leia(n1, n2, n3, n4, n5)',
+                '      escreva(n1 + n2 + n3 + n4 + n5)',
+                'Fimalgoritmo', 'Algoritmo "Soma 5"',
+                'Var',
+                '   n1, n2, n3, n4, n5: inteiro',
+                'Inicio',
+                '      leia(n1, n2, n3, n4, n5)',
+                '      escreva(n1 + n2 + n3 + n4 + n5)',
+                'Fimalgoritmo',
+            ],
+            -1
+        );
+
+        const retornoAvaliadorSintatico = avaliadorSintaticoVisualG.analisar(retornoLexador, -1);
+        const resultado = formatadorVisualG.formatar(retornoAvaliadorSintatico.declaracoes)
+        const linhasResultado = resultado.split(sistemaOperacional.EOL)
+
+        expect(linhasResultado).toHaveLength(12)
+
+        expect(retornoAvaliadorSintatico).toBeTruthy();
+        expect(retornoAvaliadorSintatico.declaracoes.length).toBeGreaterThan(0);
+    });
+
+    it('Para', () => {
+        const retornoLexador = lexadorVisuAlg.mapear(
+            [
+                'algoritmo "Numeros de 1 a 10"',
+                'var j: inteiro',
+                'inicio',
+                '    para j de 1 ate 10 faca',
+                '        escreva(j)',
+                '    fimpara',
+                'fimalgoritmo',
+            ],
+            -1
+        );
+        const retornoAvaliadorSintatico = avaliadorSintaticoVisualG.analisar(retornoLexador, -1);
+        const resultado = formatadorVisualG.formatar(retornoAvaliadorSintatico.declaracoes)
+        const linhasResultado = resultado.split(sistemaOperacional.EOL)
+
+        expect(linhasResultado).toHaveLength(9)
+        expect(retornoAvaliadorSintatico).toBeTruthy();
+        expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(2);
+    });
+
+    /* it('Procedimento', () => {
+        const retornoLexador = lexadorVisuAlg.mapear(
+            [
+                'algoritmo "semnome"',
+                'var',
+                'a,b:inteiro',
+                'procedimento mostranumero (a:inteiro;b:inteiro)',
+                'inicio',
+                'se a > b entao',
+                '     escreval ("A variavel escolhida é ",a)',
+                'senao',
+                '     escreval ("A variavel escolhida é ",b)',
+                'fimse',
+                'fimprocedimento',
+                'inicio',
+                'escreval ("Digite dois valores: ")',
+                'leia (a,b)',
+                'mostranumero (a,b)',
+                '',
+                'fimalgoritmo',
+            ],
+            -1
+        );
+        const retornoAvaliadorSintatico = avaliadorSintaticoVisualG.analisar(retornoLexador, -1);
+        const resultado = formatadorVisualG.formatar(retornoAvaliadorSintatico.declaracoes)
+        const linhasResultado = resultado.split(sistemaOperacional.EOL)
+        console.log(resultado);
+
+        expect(retornoAvaliadorSintatico).toBeTruthy();
+        expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(2);
+    }); */
+
+    it('Repita', () => {
+        const retornoLexador = lexadorVisuAlg.mapear(
+            [
+                'algoritmo "Números de 1 a 10 (com repita)"',
+                'var j: inteiro',
+                'inicio',
+                'j <- 1',
+                'repita',
+                '   escreva (j)',
+                '   j <- j + 1',
+                'ate j > 10',
+                'fimalgoritmo',
+            ],
+            -1
+        );
+        const retornoAvaliadorSintatico = avaliadorSintaticoVisualG.analisar(retornoLexador, -1);
+        const resultado = formatadorVisualG.formatar(retornoAvaliadorSintatico.declaracoes)
+        const linhasResultado = resultado.split(sistemaOperacional.EOL)
+
+        expect(linhasResultado).toHaveLength(10);
+        expect(retornoAvaliadorSintatico).toBeTruthy();
+        expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(3);
+    });
+
+    it('XOU', () => {
+        const retornoLexador = lexadorVisuAlg.mapear(
+            [
+                'algoritmo "Exemplo Xou"',
+                'var A, B, C, resultA, resultB, resultC: logico',
+                'inicio',
+                'A <- verdadeiro',
+                'B <- verdadeiro',
+                'C <- falso',
+                'resultA <- A ou B',
+                'escreval("A ", resultA)',
+                'resultA <- A xou B',
+                'escreval("A ", resultA)',
+                'resultA <- nao B',
+                'escreval("A ", resultA)',
+                'resultB <- B',
+                'resultA <- (A e B) ou (A xou B)',
+                'resultB <- (A ou B) e (A e C)',
+                'resultC <- A ou C e B xou A e nao B',
+                'escreval("A ", resultA)',
+                'escreval("B ", resultB)',
+                'escreval("C ", resultC)',
+                'fimalgoritmo',
+            ],
+            -1
+        );
+        const retornoAvaliadorSintatico = avaliadorSintaticoVisualG.analisar(retornoLexador, -1);
+        const resultado = formatadorVisualG.formatar(retornoAvaliadorSintatico.declaracoes)
+        const linhasResultado = resultado.split(sistemaOperacional.EOL)
+
+        expect(linhasResultado).toHaveLength(29);
+        expect(retornoAvaliadorSintatico).toBeTruthy();
+        expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(22);
+    });
+
+    it('Sucesso - Aleatorio - Números', () => {
+        const retornoLexador = lexadorVisuAlg.mapear(
+            [
+                'algoritmo "Exemplo Xou"',
+                'var',
+                'numero: inteiro',
+                'inicio',
+                'aleatorio 1, 6',
+                'leia(numero)',
+                'fimalgoritmo',
+            ],
+            -1
+        );
+
+        const retornoAvaliadorSintatico = avaliadorSintaticoVisualG.analisar(retornoLexador, -1);
+
+
+        const resultado = formatadorVisualG.formatar(retornoAvaliadorSintatico.declaracoes)
+        const linhasResultado = resultado.split(sistemaOperacional.EOL)
+
+        expect(linhasResultado).toHaveLength(8);
+        expect(retornoAvaliadorSintatico).toBeTruthy();
+        expect(retornoAvaliadorSintatico.declaracoes).toHaveLength(2);
+    });
+});
\ No newline at end of file