@designliquido/delegua 0.29.3 → 0.30.0

package/fontes/formatadores/delegua.js

@@ -4,79 +4,590 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FormatadorDelegua = void 0;
+const construtos_1 = require("../construtos");
 const delegua_1 = __importDefault(require("../tipos-de-simbolos/delegua"));
 /**
  * O formatador de código Delégua.
  * Normalmente usado por IDEs, mas pode ser usado por linha de comando ou programaticamente.
  */
 class FormatadorDelegua {
-    constructor() {
-        this.indentacao = 0;
-        this.blocoAberto = true;
+    constructor(quebraLinha, tamanhoIndentacao = 4) {
+        this.quebraLinha = quebraLinha;
+        this.tamanhoIndentacao = tamanhoIndentacao;
+        this.indentacaoAtual = 0;
+        this.codigoFormatado = '';
+        this.devePularLinha = true;
+        this.deveIndentar = true;
+    }
+    visitarDeclaracaoClasse(declaracao) {
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}classe ${declaracao.simbolo.lexema} {${this.quebraLinha}`;
+        this.indentacaoAtual += this.tamanhoIndentacao;
+        for (let propriedade of declaracao.propriedades) {
+            this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}${propriedade.nome.lexema}: ${propriedade.tipo || 'qualquer'}${this.quebraLinha}`;
+        }
+        this.codigoFormatado += `${this.quebraLinha}`;
+        for (let metodo of declaracao.metodos) {
+            this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}${metodo.simbolo.lexema}`;
+            this.visitarExpressaoFuncaoConstruto(metodo.funcao);
+        }
+        this.indentacaoAtual -= this.tamanhoIndentacao;
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}}${this.quebraLinha}`;
+    }
+    visitarDeclaracaoConst(declaracao) {
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}constante ${declaracao.simbolo.lexema}`;
+        if (declaracao.inicializador) {
+            this.codigoFormatado += ` = `;
+            this.formatarDeclaracaoOuConstruto(declaracao.inicializador);
+        }
+        if (this.devePularLinha) {
+            this.codigoFormatado += this.quebraLinha;
+        }
+    }
+    visitarDeclaracaoConstMultiplo(declaracao) {
+        // TODO: Até então o código nunca passa por aqui, porque o avaliador sintático
+        // converte `ConstMultiplo` em várias declarações `const`.
+        // Talvez mudar a avaliação sintática para não fazer mais isso.
+        console.log(declaracao);
+    }
+    visitarDeclaracaoDeAtribuicao(expressao) {
+        if ([
+            delegua_1.default.MAIS_IGUAL,
+            delegua_1.default.MENOS_IGUAL,
+            delegua_1.default.MULTIPLICACAO_IGUAL,
+            delegua_1.default.DIVISAO_IGUAL,
+            delegua_1.default.DIVISAO_INTEIRA_IGUAL,
+            delegua_1.default.MODULO_IGUAL,
+        ].includes(expressao.valor.operador.tipo)) {
+            this.visitarExpressaoBinaria(expressao.valor);
+        }
+        else {
+            this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}`;
+            this.codigoFormatado += `${expressao.simbolo.lexema} = `;
+            this.formatarDeclaracaoOuConstruto(expressao.valor);
+        }
+        this.codigoFormatado += `${this.quebraLinha}`;
+    }
+    visitarDeclaracaoDeExpressao(declaracao) {
+        this.codigoFormatado += ' '.repeat(this.indentacaoAtual);
+        this.formatarDeclaracaoOuConstruto(declaracao.expressao);
+    }
+    visitarDeclaracaoDefinicaoFuncao(declaracao) {
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}função `;
+        if (declaracao.simbolo) {
+            this.codigoFormatado += `${declaracao.simbolo.lexema}`;
+        }
+        this.formatarDeclaracaoOuConstruto(declaracao.funcao);
+    }
+    visitarDeclaracaoEnquanto(declaracao) {
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}enquanto `;
+        this.formatarDeclaracaoOuConstruto(declaracao.condicao);
+        this.formatarDeclaracaoOuConstruto(declaracao.corpo);
+    }
+    visitarDeclaracaoEscolha(declaracao) {
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}escolha `;
+        this.formatarDeclaracaoOuConstruto(declaracao.identificadorOuLiteral);
+        this.codigoFormatado += ` {${this.quebraLinha}`;
+        this.indentacaoAtual += this.tamanhoIndentacao;
+        for (let caminho of declaracao.caminhos) {
+            for (let declaracoes of caminho.condicoes) {
+                this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}caso `;
+                this.formatarDeclaracaoOuConstruto(declaracoes);
+                this.codigoFormatado += ':';
+                this.codigoFormatado += this.quebraLinha;
+            }
+            for (let declaracoes of caminho.declaracoes) {
+                this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}`;
+                this.formatarDeclaracaoOuConstruto(declaracoes);
+            }
+        }
+        for (let padrao of declaracao.caminhoPadrao.declaracoes) {
+            this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}padrao:`;
+            this.codigoFormatado += this.quebraLinha;
+            this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}`;
+            this.formatarDeclaracaoOuConstruto(padrao);
+        }
+        this.indentacaoAtual -= this.tamanhoIndentacao;
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}}${this.quebraLinha}`;
+    }
+    visitarDeclaracaoEscreva(declaracao) {
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}escreva(`;
+        for (let argumento of declaracao.argumentos) {
+            this.formatarDeclaracaoOuConstruto(argumento);
+        }
+        this.codigoFormatado += `)${this.quebraLinha}`;
+    }
+    visitarDeclaracaoFazer(declaracao) {
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}fazer {${this.quebraLinha}`;
+        this.indentacaoAtual += this.tamanhoIndentacao;
+        for (let declaracaoBloco of declaracao.caminhoFazer.declaracoes) {
+            this.formatarDeclaracaoOuConstruto(declaracaoBloco);
+        }
+        this.indentacaoAtual -= this.tamanhoIndentacao;
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}} enquanto `;
+        this.formatarDeclaracaoOuConstruto(declaracao.condicaoEnquanto);
+        this.codigoFormatado += `${this.quebraLinha}`;
+    }
+    visitarDeclaracaoImportar(declaracao) {
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}importar(`;
+        this.formatarDeclaracaoOuConstruto(declaracao.caminho);
+        this.codigoFormatado += `)`;
+    }
+    visitarDeclaracaoPara(declaracao) {
+        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);
+            }
+        }
+        this.codigoFormatado += `; `;
+        this.formatarDeclaracaoOuConstruto(declaracao.condicao);
+        this.codigoFormatado += `; `;
+        this.formatarDeclaracaoOuConstruto(declaracao.incrementar);
+        this.devePularLinha = true;
+        this.codigoFormatado += ` {${this.quebraLinha}`;
+        this.indentacaoAtual += this.tamanhoIndentacao;
+        for (let declaracaoBloco of declaracao.corpo.declaracoes) {
+            this.formatarDeclaracaoOuConstruto(declaracaoBloco);
+        }
+        this.indentacaoAtual -= this.tamanhoIndentacao;
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}}${this.quebraLinha}`;
+    }
+    visitarDeclaracaoParaCada(declaracao) {
+        throw new Error('Método não implementado.');
+    }
+    visitarDeclaracaoSe(declaracao) {
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}se `;
+        this.formatarDeclaracaoOuConstruto(declaracao.condicao);
+        this.codigoFormatado += ` {${this.quebraLinha}`;
+        this.indentacaoAtual += this.tamanhoIndentacao;
+        for (let declaracaoBloco of declaracao.caminhoEntao.declaracoes) {
+            this.formatarDeclaracaoOuConstruto(declaracaoBloco);
+        }
+        this.indentacaoAtual -= this.tamanhoIndentacao;
+        if (declaracao.caminhoSenao) {
+            this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}} senão {${this.quebraLinha}`;
+            this.indentacaoAtual += this.tamanhoIndentacao;
+            for (let declaracaoBloco of declaracao.caminhoSenao.declaracoes) {
+                this.formatarDeclaracaoOuConstruto(declaracaoBloco);
+            }
+            this.indentacaoAtual -= this.tamanhoIndentacao;
+        }
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}}${this.quebraLinha}`;
+    }
+    visitarDeclaracaoTente(declaracao) {
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}tente {${this.quebraLinha}`;
+        this.indentacaoAtual += this.tamanhoIndentacao;
+        for (let declaracaoBloco of declaracao.caminhoTente) {
+            this.formatarDeclaracaoOuConstruto(declaracaoBloco);
+        }
+        this.indentacaoAtual -= this.tamanhoIndentacao;
+        if (declaracao.caminhoPegue) {
+            this.codigoFormatado += `} pegue {${this.quebraLinha}`;
+            if (declaracao.caminhoPegue instanceof construtos_1.FuncaoConstruto) {
+                // Se tem um parâmetro de erro.
+            }
+            else {
+                // Se não tem um parâmetro de erro.
+                this.indentacaoAtual += this.tamanhoIndentacao;
+                for (let declaracaoBloco of declaracao.caminhoPegue) {
+                    this.formatarDeclaracaoOuConstruto(declaracaoBloco);
+                }
+            }
+        }
+        this.indentacaoAtual -= this.tamanhoIndentacao;
+        if (declaracao.caminhoFinalmente) {
+            this.codigoFormatado += `} finalmente {${this.quebraLinha}`;
+            this.indentacaoAtual += this.tamanhoIndentacao;
+            for (let declaracaoBloco of declaracao.caminhoFinalmente) {
+                this.formatarDeclaracaoOuConstruto(declaracaoBloco);
+            }
+        }
+        this.indentacaoAtual -= this.tamanhoIndentacao;
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}}${this.quebraLinha}`;
+    }
+    visitarDeclaracaoVar(declaracao) {
+        if (this.deveIndentar) {
+            this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}`;
+        }
+        this.codigoFormatado += `var ${declaracao.simbolo.lexema}`;
+        if (declaracao.inicializador) {
+            this.codigoFormatado += ` = `;
+            this.formatarDeclaracaoOuConstruto(declaracao.inicializador);
+        }
+        if (this.devePularLinha) {
+            this.codigoFormatado += this.quebraLinha;
+        }
+    }
+    visitarDeclaracaoVarMultiplo(declaracao) {
+        // TODO: Até então o código nunca passa por aqui, porque o avaliador sintático
+        // converte `VarMultiplo` em várias declarações `var`.
+        // Talvez mudar a avaliação sintática para não fazer mais isso.
+        console.log(declaracao);
+    }
+    visitarExpressaoAcessoIndiceVariavel(expressao) {
+        this.formatarDeclaracaoOuConstruto(expressao.entidadeChamada);
+        this.codigoFormatado += `[`;
+        this.formatarDeclaracaoOuConstruto(expressao.indice);
+        this.codigoFormatado += `]`;
+    }
+    visitarExpressaoAcessoMetodo(expressao) {
+        this.formatarDeclaracaoOuConstruto(expressao.objeto);
+        this.codigoFormatado += '.';
+        this.codigoFormatado += expressao.simbolo.lexema;
+    }
+    visitarExpressaoAgrupamento(expressao) {
+        this.codigoFormatado += '(';
+        this.formatarDeclaracaoOuConstruto(expressao.expressao);
+        this.codigoFormatado += ')';
+    }
+    visitarExpressaoAtribuicaoPorIndice(expressao) {
+        this.formatarDeclaracaoOuConstruto(expressao.objeto);
+        this.codigoFormatado += '[';
+        this.formatarDeclaracaoOuConstruto(expressao.indice);
+        this.codigoFormatado += '] = ';
+        this.formatarDeclaracaoOuConstruto(expressao.valor);
+        this.codigoFormatado += this.quebraLinha;
+    }
+    visitarExpressaoAtribuicaoPorIndicesMatriz(expressao) {
+        // Implementar somente para VisuAlg que tem atribuição diferente de Delégua - matriz[1, 2] = 1
+        throw new Error('Método não implementado.');
+    }
+    visitarExpressaoAcessoElementoMatriz(expressao) {
+        // Implementar somente para VisuAlg que tem acesso ao elemento da matriz diferente de Delégua - var valor = matriz[1, 2]
+        throw new Error('Método não implementado.');
+    }
+    visitarExpressaoBinaria(expressao) {
+        this.formatarDeclaracaoOuConstruto(expressao.esquerda);
+        switch (expressao.operador.tipo) {
+            case delegua_1.default.ADICAO:
+                this.codigoFormatado += ` + `;
+                break;
+            case delegua_1.default.DIVISAO:
+                this.codigoFormatado += ` / `;
+                break;
+            case delegua_1.default.DIVISAO_IGUAL:
+                this.codigoFormatado += ` /= `;
+                break;
+            case delegua_1.default.DIVISAO_INTEIRA:
+                this.codigoFormatado += ` \\ `;
+                break;
+            case delegua_1.default.DIVISAO_INTEIRA_IGUAL:
+                this.codigoFormatado += ` \\= `;
+                break;
+            case delegua_1.default.EXPONENCIACAO:
+                this.codigoFormatado += ` ** `;
+                break;
+            case delegua_1.default.IGUAL_IGUAL:
+                this.codigoFormatado += ` == `;
+                break;
+            case delegua_1.default.MAIOR:
+                this.codigoFormatado += ` > `;
+                break;
+            case delegua_1.default.MAIOR_IGUAL:
+                this.codigoFormatado += ` >= `;
+                break;
+            case delegua_1.default.MAIS_IGUAL:
+                this.codigoFormatado += ` += `;
+                break;
+            case delegua_1.default.MENOR:
+                this.codigoFormatado += ` < `;
+                break;
+            case delegua_1.default.MENOR_IGUAL:
+                this.codigoFormatado += ` <= `;
+                break;
+            case delegua_1.default.MENOS_IGUAL:
+                this.codigoFormatado += ` -= `;
+                break;
+            case delegua_1.default.MODULO:
+                this.codigoFormatado += ` % `;
+                break;
+            case delegua_1.default.MODULO_IGUAL:
+                this.codigoFormatado += ` %= `;
+                break;
+            case delegua_1.default.MULTIPLICACAO:
+                this.codigoFormatado += ` * `;
+                break;
+            case delegua_1.default.MULTIPLICACAO_IGUAL:
+                this.codigoFormatado += ` * `;
+                break;
+            case delegua_1.default.SUBTRACAO:
+                this.codigoFormatado += ` - `;
+                break;
+        }
+        this.formatarDeclaracaoOuConstruto(expressao.direita);
+    }
+    formatarBlocoOuVetorDeclaracoes(declaracoes) {
+        this.codigoFormatado += ` {${this.quebraLinha}`;
+        this.indentacaoAtual += this.tamanhoIndentacao;
+        for (let declaracaoBloco of declaracoes) {
+            this.formatarDeclaracaoOuConstruto(declaracaoBloco);
+        }
+        this.indentacaoAtual -= this.tamanhoIndentacao;
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}}${this.quebraLinha}`;
+    }
+    visitarExpressaoBloco(declaracao) {
+        this.formatarBlocoOuVetorDeclaracoes(declaracao.declaracoes);
+    }
+    visitarExpressaoContinua(declaracao) {
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}continua${this.quebraLinha}`;
+    }
+    visitarExpressaoDeChamada(expressao) {
+        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) {
+        this.formatarDeclaracaoOuConstruto(expressao.objeto);
+        this.codigoFormatado += `.${expressao.nome.lexema} = `;
+        this.formatarDeclaracaoOuConstruto(expressao.valor);
+        this.codigoFormatado += `${this.quebraLinha}`;
+    }
+    visitarExpressaoDeleguaFuncao(expressao) {
+        throw new Error('Método não implementado.');
+    }
+    visitarExpressaoDeVariavel(expressao) {
+        this.codigoFormatado += expressao.simbolo.lexema;
+    }
+    visitarExpressaoDicionario(expressao) {
+        throw new Error('Método não implementado.');
+    }
+    visitarExpressaoExpressaoRegular(expressao) {
+        this.codigoFormatado += `||${expressao.valor}||`;
+    }
+    visitarDeclaracaoEscrevaMesmaLinha(declaracao) {
+        throw new Error('Método não implementado.');
+    }
+    visitarExpressaoFalhar(expressao) {
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}falhar`;
+        if (expressao.explicacao) {
+            this.codigoFormatado += ` `;
+            this.formatarDeclaracaoOuConstruto(expressao.explicacao);
+        }
+        this.codigoFormatado += `${this.quebraLinha}`;
+    }
+    visitarExpressaoFimPara(declaracao) {
+        throw new Error('Método não implementado.');
+    }
+    visitarExpressaoFormatacaoEscrita(declaracao) {
+        throw new Error('Método não implementado.');
+    }
+    visitarExpressaoFuncaoConstruto(expressao) {
+        this.codigoFormatado += `(`;
+        for (let argumento of expressao.parametros) {
+            this.codigoFormatado += `${argumento.nome.lexema}${argumento.tipoDado && argumento.tipoDado.tipo ? `: ${argumento.tipoDado.tipo}, ` : ', '}`;
+        }
+        if (expressao.parametros.length > 0) {
+            this.codigoFormatado = this.codigoFormatado.slice(0, -2);
+        }
+        this.codigoFormatado += `) `;
+        this.formatarBlocoOuVetorDeclaracoes(expressao.corpo);
+    }
+    visitarExpressaoIsto(expressao) {
+        this.codigoFormatado += `isto`;
+    }
+    visitarExpressaoLeia(expressao) {
+        throw new Error('Método não implementado.');
+    }
+    visitarExpressaoLeiaMultiplo(expressao) {
+        throw new Error('Método não implementado.');
+    }
+    visitarExpressaoLiteral(expressao) {
+        if (typeof expressao.valor === 'string') {
+            this.codigoFormatado += `'${expressao.valor}'`;
+            return;
+        }
+        this.codigoFormatado += expressao.valor;
+    }
+    visitarExpressaoLogica(expressao) {
+        throw new Error('Método não implementado.');
+    }
+    visitarExpressaoRetornar(declaracao) {
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}retorna`;
+        if (declaracao.valor) {
+            this.codigoFormatado += ` `;
+            this.formatarDeclaracaoOuConstruto(declaracao.valor);
+        }
+        this.codigoFormatado += `${this.quebraLinha}`;
+    }
+    visitarExpressaoSuper(expressao) {
+        // TODO: `expressao.metodo` deveria ser um `Construto`, não um `Simbolo` aqui. 
+        this.codigoFormatado += `super.${expressao.metodo.lexema}()`;
+        console.log(expressao);
+    }
+    visitarExpressaoSustar(declaracao) {
+        throw new Error('Método não implementado.');
+    }
+    visitarExpressaoTipoDe(expressao) {
+        throw new Error('Método não implementado.');
+    }
+    visitarExpressaoUnaria(expressao) {
+        let operador;
+        switch (expressao.operador.tipo) {
+            case delegua_1.default.INCREMENTAR:
+                operador = `++`;
+                break;
+            case delegua_1.default.DECREMENTAR:
+                operador = `--`;
+                break;
+        }
+        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) {
+        this.codigoFormatado += '[';
+        for (let valor of expressao.valores) {
+            this.formatarDeclaracaoOuConstruto(valor);
+            this.codigoFormatado += ', ';
+        }
+        if (expressao.valores.length > 0) {
+            this.codigoFormatado = this.codigoFormatado.slice(0, -2);
+        }
+        this.codigoFormatado += ']';
+    }
+    formatarDeclaracaoOuConstruto(declaracaoOuConstruto) {
+        switch (declaracaoOuConstruto.constructor.name) {
+            case 'AcessoIndiceVariavel':
+                this.visitarExpressaoAcessoIndiceVariavel(declaracaoOuConstruto);
+                break;
+            case 'AcessoMetodoOuPropriedade':
+                this.visitarExpressaoAcessoMetodo(declaracaoOuConstruto);
+                break;
+            case 'Agrupamento':
+                this.visitarExpressaoAgrupamento(declaracaoOuConstruto);
+                break;
+            case 'AtribuicaoPorIndice':
+                this.visitarExpressaoAtribuicaoPorIndice(declaracaoOuConstruto);
+                break;
+            case 'Atribuir':
+                this.visitarDeclaracaoDeAtribuicao(declaracaoOuConstruto);
+                break;
+            case 'Binario':
+                this.visitarExpressaoBinaria(declaracaoOuConstruto);
+                break;
+            case 'Bloco':
+                this.visitarExpressaoBloco(declaracaoOuConstruto);
+                break;
+            case 'Chamada':
+                this.visitarExpressaoDeChamada(declaracaoOuConstruto);
+                break;
+            case 'Classe':
+                this.visitarDeclaracaoClasse(declaracaoOuConstruto);
+                break;
+            case 'Continua':
+                this.visitarExpressaoContinua(declaracaoOuConstruto);
+                break;
+            case 'DefinirValor':
+                this.visitarExpressaoDefinirValor(declaracaoOuConstruto);
+                break;
+            case 'Escolha':
+                this.visitarDeclaracaoEscolha(declaracaoOuConstruto);
+                break;
+            case 'Enquanto':
+                this.visitarDeclaracaoEnquanto(declaracaoOuConstruto);
+                break;
+            case 'Escreva':
+                this.visitarDeclaracaoEscreva(declaracaoOuConstruto);
+                break;
+            case 'Expressao':
+                this.visitarDeclaracaoDeExpressao(declaracaoOuConstruto);
+                break;
+            case 'ExpressaoRegular':
+                this.visitarExpressaoExpressaoRegular(declaracaoOuConstruto);
+                break;
+            case 'Falhar':
+                this.visitarExpressaoFalhar(declaracaoOuConstruto);
+                break;
+            case 'Fazer':
+                this.visitarDeclaracaoFazer(declaracaoOuConstruto);
+                break;
+            case 'FuncaoConstruto':
+                this.visitarExpressaoFuncaoConstruto(declaracaoOuConstruto);
+                break;
+            case 'FuncaoDeclaracao':
+                this.visitarDeclaracaoDefinicaoFuncao(declaracaoOuConstruto);
+                break;
+            case 'Importar':
+                this.visitarDeclaracaoImportar(declaracaoOuConstruto);
+                break;
+            case 'Isto':
+                this.visitarExpressaoIsto(declaracaoOuConstruto);
+                break;
+            case 'Literal':
+                this.visitarExpressaoLiteral(declaracaoOuConstruto);
+                break;
+            case 'Para':
+                this.visitarDeclaracaoPara(declaracaoOuConstruto);
+                break;
+            case 'Retorna':
+                this.visitarExpressaoRetornar(declaracaoOuConstruto);
+                break;
+            case 'Se':
+                this.visitarDeclaracaoSe(declaracaoOuConstruto);
+                break;
+            case 'Super':
+                this.visitarExpressaoSuper(declaracaoOuConstruto);
+                break;
+            case 'Tente':
+                this.visitarDeclaracaoTente(declaracaoOuConstruto);
+                break;
+            case 'Unario':
+                this.visitarExpressaoUnaria(declaracaoOuConstruto);
+                break;
+            case 'Const':
+                this.visitarDeclaracaoConst(declaracaoOuConstruto);
+                break;
+            case 'Var':
+                this.visitarDeclaracaoVar(declaracaoOuConstruto);
+                break;
+            case 'Variavel':
+                this.visitarExpressaoDeVariavel(declaracaoOuConstruto);
+                break;
+            case 'Vetor':
+                this.visitarExpressaoVetor(declaracaoOuConstruto);
+                break;
+            default:
+                console.log(declaracaoOuConstruto.constructor.name);
+                break;
+        }
     }
     /**
      * Devolve código formatado de acordo com os símbolos encontrados.
-     * @param simbolos Um vetor de símbolos.
-     * @param quebraLinha O símbolo de quebra de linha. Normalmente `\r\n` para Windows e `\n` para outros sistemas operacionais.
-     * @param tamanhoIndentacao O tamanho de cada bloco de indentação (por padrão, 4)
+     * @param {Declaracao[]} declaracoes Um vetor de declarações.
      * @returns Código Delégua formatado.
      */
-    formatar(simbolos, quebraLinha, tamanhoIndentacao = 4) {
-        let resultado = '';
-        let deveQuebrarLinha = false;
-        for (let simbolo of simbolos) {
-            switch (simbolo.tipo) {
-                case delegua_1.default.CHAVE_ESQUERDA:
-                    this.indentacao += tamanhoIndentacao;
-                    resultado += '{' + quebraLinha;
-                    resultado += ' '.repeat(this.indentacao);
-                    break;
-                case delegua_1.default.CHAVE_DIREITA:
-                    this.indentacao -= tamanhoIndentacao;
-                    resultado += quebraLinha + ' '.repeat(this.indentacao) + '}' + quebraLinha;
-                    break;
-                case delegua_1.default.ESCREVA:
-                    deveQuebrarLinha = true;
-                case delegua_1.default.ENQUANTO:
-                case delegua_1.default.FAZER:
-                case delegua_1.default.FINALMENTE:
-                case delegua_1.default.PARA:
-                case delegua_1.default.PEGUE:
-                case delegua_1.default.RETORNA:
-                case delegua_1.default.SE:
-                case delegua_1.default.SENAO:
-                case delegua_1.default.SENÃO:
-                case delegua_1.default.TENTE:
-                case delegua_1.default.VARIAVEL:
-                    resultado += quebraLinha + ' '.repeat(this.indentacao) + simbolo.lexema + ' ';
-                    break;
-                case delegua_1.default.PARENTESE_ESQUERDO:
-                    resultado += '(';
-                    break;
-                case delegua_1.default.PARENTESE_DIREITO:
-                    resultado = resultado.trimEnd();
-                    resultado += ')';
-                    if (deveQuebrarLinha) {
-                        deveQuebrarLinha = false;
-                        resultado += quebraLinha;
-                    }
-                    else {
-                        resultado += ' ';
-                    }
-                    break;
-                case delegua_1.default.FUNCAO:
-                case delegua_1.default.FUNÇÃO:
-                case delegua_1.default.IDENTIFICADOR:
-                case delegua_1.default.IGUAL:
-                case delegua_1.default.IGUAL_IGUAL:
-                    resultado += simbolo.lexema + ' ';
-                    break;
-                default:
-                    resultado += simbolo.lexema;
-                    break;
-            }
+    formatar(declaracoes) {
+        this.codigoFormatado = '';
+        this.indentacaoAtual = 0;
+        for (let declaracao of declaracoes) {
+            this.formatarDeclaracaoOuConstruto(declaracao);
         }
-        return resultado;
+        return this.codigoFormatado;
     }
 }
 exports.FormatadorDelegua = FormatadorDelegua;