@designliquido/delegua 1.1.0 → 1.3.0

package/tradutores/tradutor-mermaidjs.js

@@ -4,8 +4,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TradutorMermaidJs = void 0;
-const delegua_1 = __importDefault(require("../tipos-de-simbolos/delegua"));
 const mermaid_1 = require("./mermaid");
+const delegua_1 = __importDefault(require("../tipos-de-simbolos/delegua"));
 /**
  * [MermaidJs](https://mermaid.js.org/) é uma especificação que nos permite
  * criar fluxogramas através de uma notação por texto.
@@ -19,305 +19,160 @@ const mermaid_1 = require("./mermaid");
  * @see VerticeFluxograma
  */
 class TradutorMermaidJs {
-    constructor() {
-        this.dicionarioConstrutos = {
-            AcessoIndiceVariavel: this.traduzirConstrutoAcessoIndiceVariavel.bind(this),
-            AcessoMetodo: this.traduzirConstrutoAcessoMetodo.bind(this),
-            AcessoMetodoOuPropriedade: this.traduzirConstrutoAcessoMetodoOuPropriedade.bind(this),
-            AcessoPropriedade: this.traduzirConstrutoAcessoPropriedade.bind(this),
-            Agrupamento: this.traduzirConstrutoAgrupamento.bind(this),
-            Atribuir: this.traduzirConstrutoAtribuir.bind(this),
-            Binario: this.traduzirConstrutoBinario.bind(this),
-            Chamada: this.traduzirConstrutoChamada.bind(this),
-            ComentarioComoConstruto: () => '',
-            DefinirValor: this.traduzirConstrutoDefinirValor.bind(this),
-            Dicionario: this.traduzirConstrutoDicionario.bind(this),
-            // FuncaoConstruto: this.traduzirFuncaoConstruto.bind(this),
-            FuncaoConstruto: () => { throw new Error("Fluxogramas de funções ainda não é suportado."); },
-            Isto: () => 'this',
-            Leia: this.traduzirConstrutoLeia.bind(this),
-            Literal: this.traduzirConstrutoLiteral.bind(this),
-            Separador: this.traduzirConstrutoSeparador.bind(this),
-            Unario: this.traduzirConstrutoUnario.bind(this),
-            Variavel: this.traduzirConstrutoVariavel.bind(this),
-            Vetor: this.traduzirConstrutoVetor.bind(this),
-        };
-        this.dicionarioDeclaracoes = {
-            Bloco: this.traduzirDeclaracaoBloco.bind(this),
-            // Classe: this.traduzirDeclaracaoClasse.bind(this),
-            Classe: () => { throw new Error("Fluxogramas de classes ainda não é suportado."); },
-            Comentario: () => '',
-            Const: this.traduzirDeclaracaoConst.bind(this),
-            Enquanto: this.traduzirDeclaracaoEnquanto.bind(this),
-            Escolha: this.traduzirDeclaracaoEscolha.bind(this),
-            Expressao: this.traduzirDeclaracaoExpressao.bind(this),
-            Escreva: this.traduzirDeclaracaoEscreva.bind(this),
-            Fazer: this.traduzirDeclaracaoFazerEnquanto.bind(this),
-            // FuncaoDeclaracao: this.traduzirDeclaracaoFuncao.bind(this),
-            FuncaoDeclaracao: () => { throw new Error("Fluxogramas de funções ainda não é suportado."); },
-            Para: this.traduzirDeclaracaoPara.bind(this),
-            ParaCada: this.traduzirDeclaracaoParaCada.bind(this),
-            Se: this.traduzirDeclaracaoSe.bind(this),
-            Var: this.traduzirDeclaracaoVar.bind(this),
-        };
-    }
-    traduzirConstrutoAcessoIndiceVariavel(acessoIndiceVariavel) {
-        const textoIndice = this.dicionarioConstrutos[acessoIndiceVariavel.indice.constructor.name](acessoIndiceVariavel.indice);
-        return `no índice ${textoIndice}`;
-    }
-    traduzirConstrutoAcessoMetodo(acessoMetodo) {
-        return `método ${acessoMetodo.nomeMetodo}`;
-    }
-    traduzirConstrutoAcessoMetodoOuPropriedade(acessoMetodoOuPropriedade) {
-        return `método ou propriedade ${acessoMetodoOuPropriedade.simbolo.lexema}`;
-    }
-    traduzirConstrutoAcessoPropriedade(acessoPropriedade) {
-        return `propriedade ${acessoPropriedade.nomePropriedade}`;
-    }
-    traduzirConstrutoAgrupamento(agrupamento) {
-        return this.dicionarioConstrutos[agrupamento.expressao.constructor.name](agrupamento.expressao);
-    }
-    traduzirConstrutoAtribuir(atribuir) {
-        const textoAlvo = this.dicionarioConstrutos[atribuir.alvo.constructor.name](atribuir.alvo);
-        const textoValor = this.dicionarioConstrutos[atribuir.valor.constructor.name](atribuir.valor);
-        return `${textoAlvo} recebe: ${textoValor}`;
-    }
-    traduzirConstrutoBinario(binario) {
-        const operandoEsquerdo = this.dicionarioConstrutos[binario.esquerda.constructor.name](binario.esquerda);
-        const operandoDireito = this.dicionarioConstrutos[binario.direita.constructor.name](binario.direita);
-        switch (binario.operador.tipo) {
-            case delegua_1.default.ADICAO:
-                return `somar ${operandoEsquerdo} e ${operandoDireito}`;
-            case delegua_1.default.MENOR:
-                return `${operandoEsquerdo} for menor que ${operandoDireito}`;
-        }
-        return '';
-    }
-    traduzirConstrutoChamada(chamada) {
-        const textoEntidadeChamada = this.dicionarioConstrutos[chamada.entidadeChamada.constructor.name](chamada.entidadeChamada);
-        let texto = `chamada a ${textoEntidadeChamada}`;
-        if (chamada.argumentos.length > 0) {
-            texto += `, com argumentos: `;
-            for (const argumento of chamada.argumentos) {
-                const textoArgumento = this.dicionarioConstrutos[argumento.constructor.name](argumento);
-                texto += `${textoArgumento}, `;
+    visitarDeclaracaoCabecalhoPrograma(declaracao) {
+        throw new Error('Método não implementado.');
+    }
+    async visitarDeclaracaoClasse(declaracao) {
+        var _a, _b;
+        const nomeClasse = declaracao.simbolo.lexema;
+        const superClasse = declaracao.superClasse
+            ? (((_a = declaracao.superClasse.simbolo) === null || _a === void 0 ? void 0 : _a.lexema) || ((_b = declaracao.superClasse.nome) === null || _b === void 0 ? void 0 : _b.lexema))
+            : undefined;
+        const linha = declaracao.linha;
+        // Cria arestas de entrada e saída para a classe
+        const textoInicio = `Classe${nomeClasse}Inicio[Início: Classe ${nomeClasse}]`;
+        const arestaInicial = new mermaid_1.ArestaFluxograma(declaracao, textoInicio);
+        const textoFim = `Classe${nomeClasse}Fim[Fim: Classe ${nomeClasse}]`;
+        const arestaFinal = new mermaid_1.ArestaFluxograma(declaracao, textoFim);
+        // Cria o subgrafo da classe
+        const subgrafo = new mermaid_1.SubgrafoClasse(nomeClasse, linha, arestaInicial, arestaFinal, superClasse);
+        // Salva o estado anterior
+        const anterioresAntes = [...this.anteriores];
+        // Processa métodos
+        if (declaracao.metodos && declaracao.metodos.length > 0) {
+            for (const metodoDeclaracao of declaracao.metodos) {
+                const nomeMetodo = metodoDeclaracao.simbolo.lexema;
+                const linhaMetodo = metodoDeclaracao.linha;
+                const ehConstrutor = nomeMetodo === 'construtor' || nomeMetodo === 'iniciar';
+                // Cria arestas de entrada e saída para o método
+                const textoInicioMetodo = `Metodo${nomeMetodo}${nomeClasse}Inicio[Início: ${nomeMetodo}()]`;
+                const arestaInicialMetodo = new mermaid_1.ArestaFluxograma(metodoDeclaracao, textoInicioMetodo);
+                const textoFimMetodo = `Metodo${nomeMetodo}${nomeClasse}Fim[Fim: ${nomeMetodo}()]`;
+                const arestaFinalMetodo = new mermaid_1.ArestaFluxograma(metodoDeclaracao, textoFimMetodo);
+                // Cria o subgrafo do método
+                const subgrafoMetodo = new mermaid_1.SubgrafoMetodo(nomeMetodo, nomeClasse, linhaMetodo, arestaInicialMetodo, arestaFinalMetodo, ehConstrutor);
+                // Traduz o corpo do método
+                this.anteriores = [arestaInicialMetodo];
+                if (metodoDeclaracao.funcao.corpo && metodoDeclaracao.funcao.corpo.length > 0) {
+                    for (const declaracaoCorpo of metodoDeclaracao.funcao.corpo) {
+                        const verticesCorpo = await declaracaoCorpo.aceitar(this);
+                        subgrafoMetodo.vertices = subgrafoMetodo.vertices.concat(verticesCorpo);
+                    }
+                }
+                // Conecta o último vértice do corpo ao fim do método
+                if (this.anteriores.length > 0) {
+                    for (const anterior of this.anteriores) {
+                        subgrafoMetodo.vertices.push(new mermaid_1.VerticeFluxograma(anterior, arestaFinalMetodo));
+                    }
+                }
+                // Adiciona o método ao subgrafo da classe
+                if (ehConstrutor) {
+                    subgrafo.construtor = subgrafoMetodo;
+                }
+                else {
+                    subgrafo.metodos.push(subgrafoMetodo);
+                }
             }
-            texto = texto.slice(0, -2);
-        }
-        else {
-            texto += `, sem argumentos`;
         }
-        return texto;
+        // Restaura o estado anterior
+        this.anteriores = anterioresAntes;
+        // Armazena o subgrafo da classe
+        this.declaracoesClasses[nomeClasse] = subgrafo;
+        return Promise.resolve([]);
     }
-    traduzirConstrutoDefinirValor(definirValor) {
-        const textoObjeto = this.dicionarioConstrutos[definirValor.objeto.constructor.name](definirValor.objeto);
-        const textoValor = this.dicionarioConstrutos[definirValor.valor.constructor.name](definirValor.valor);
-        return `${definirValor.nome.lexema} em ${textoObjeto} recebe ${textoValor}`;
+    async visitarDeclaracaoComentario(declaracao) {
+        return Promise.resolve('');
     }
-    traduzirConstrutoDicionario(dicionario) {
-        let texto = `dicionário`;
-        if (dicionario.chaves.length > 0) {
-            texto += `, com `;
-            for (const [chave, indice] of Object.entries(dicionario.chaves)) {
-                texto += `chave ${chave} definida com o valor ${dicionario.valores[0]}`;
+    async visitarDeclaracaoConst(declaracao) {
+        let texto = `Linha${declaracao.linha}(variável: ${declaracao.simbolo.lexema}`;
+        texto += await this.logicaComumTraducaoVarEConst(declaracao, texto);
+        const aresta = new mermaid_1.ArestaFluxograma(declaracao, texto);
+        const vertices = this.logicaComumConexaoArestas(aresta);
+        this.anteriores.push(aresta);
+        return Promise.resolve(vertices);
+    }
+    visitarDeclaracaoConstMultiplo(declaracao) {
+        throw new Error('Método não implementado.');
+    }
+    async visitarDeclaracaoDeExpressao(declaracao) {
+        // Verifica se é uma chamada de função
+        if (declaracao.expressao.constructor.name === 'Chamada') {
+            const chamada = declaracao.expressao;
+            const verticesChamada = await this.traduzirChamadaFuncao(declaracao, chamada);
+            if (verticesChamada.length > 0) {
+                return Promise.resolve(verticesChamada);
             }
         }
-        else {
-            texto += ' vazio';
-        }
-        return texto;
-    }
-    traduzirFuncaoConstruto(funcaoConstruto) {
-        let vertices = [];
-        let arestas = [];
-        if (funcaoConstruto.corpo && funcaoConstruto.corpo.length > 0) {
-            for (const declaracaoCorpo of funcaoConstruto.corpo) {
-                // Usa o mesmo caminho de outras declarações,
-                // então todas as arestas passam por logicaComumConexaoArestas.
-                const verticesCorpo = this.dicionarioDeclaracoes[declaracaoCorpo.constructor.name](declaracaoCorpo);
-                vertices = vertices.concat(verticesCorpo);
-                arestas = arestas.concat(this.anteriores);
-                this.anteriores = [];
+        // Se não for uma chamada de função ou não for uma função conhecida,
+        // trata como expressão normal
+        let texto = `Linha${declaracao.linha}(`;
+        const textoConstruto = await declaracao.expressao.aceitar(this);
+        texto += textoConstruto + ')';
+        const aresta = new mermaid_1.ArestaFluxograma(declaracao, texto);
+        const vertices = this.logicaComumConexaoArestas(aresta);
+        this.anteriores.push(aresta);
+        return Promise.resolve(vertices);
+    }
+    async visitarDeclaracaoDefinicaoFuncao(declaracao) {
+        const nomeFuncao = declaracao.simbolo.lexema;
+        const linha = declaracao.linha;
+        // Cria arestas de entrada e saída para a função
+        const textoInicio = `Func${nomeFuncao}Inicio[Início: ${nomeFuncao}()]`;
+        const arestaInicial = new mermaid_1.ArestaFluxograma(declaracao, textoInicio);
+        const textoFim = `Func${nomeFuncao}Fim[Fim: ${nomeFuncao}()]`;
+        const arestaFinal = new mermaid_1.ArestaFluxograma(declaracao, textoFim);
+        // Cria o subgrafo da função
+        const subgrafo = new mermaid_1.SubgrafoFuncao(nomeFuncao, linha, arestaInicial, arestaFinal);
+        // Salva o estado atual de anteriores
+        const anterioresAntes = [...this.anteriores];
+        this.anteriores = [arestaInicial];
+        // Processa o corpo da função
+        if (declaracao.funcao.corpo && declaracao.funcao.corpo.length > 0) {
+            for (const declaracaoCorpo of declaracao.funcao.corpo) {
+                const verticesCorpo = await declaracaoCorpo.aceitar(this);
+                subgrafo.vertices = subgrafo.vertices.concat(verticesCorpo);
             }
         }
-        let primeiraAresta = undefined;
+        // Conecta o fim do corpo à aresta final
         if (this.anteriores.length > 0) {
-            primeiraAresta = this.anteriores[0];
-            const verticesRestantes = this.logicaComumConexaoArestas(primeiraAresta);
-            console.log(verticesRestantes);
-        }
-        return vertices;
-    }
-    traduzirConstrutoLeia(leia) {
-        let texto = 'leia da entrada';
-        if (leia.argumentos && leia.argumentos.length > 0) {
-            const textoArgumento = this.dicionarioConstrutos[leia.argumentos[0].constructor.name](leia.argumentos[0]);
-            texto += `, imprimindo antes: \\'${textoArgumento}\\'`;
-        }
-        return texto;
-    }
-    traduzirConstrutoLiteral(literal) {
-        switch (literal.tipo) {
-            case 'lógico':
-                return literal.valor ? 'verdadeiro' : 'falso';
-            case 'texto':
-                return `\\'${literal.valor}\\'`;
-            default:
-                return String(literal.valor);
-        }
-    }
-    traduzirConstrutoSeparador(separador) {
-        return `${separador.conteudo} `;
-    }
-    traduzirConstrutoUnario(unario) {
-        const textoOperando = this.dicionarioConstrutos[unario.operando.constructor.name](unario.operando);
-        let textoOperador = '';
-        switch (unario.operador.tipo) {
-            case delegua_1.default.INCREMENTAR:
-                textoOperador = `incrementar ${textoOperando} em 1`;
-                break;
-            case delegua_1.default.DECREMENTAR:
-                textoOperador = `decrementar ${textoOperando} de 1`;
-                break;
-        }
-        switch (unario.incidenciaOperador) {
-            case 'ANTES':
-                return `${textoOperador}, devolver valor de ${textoOperando}`;
-            case 'DEPOIS':
-                return `devolver valor de ${textoOperando}, ${textoOperador}`;
-        }
-    }
-    traduzirConstrutoVariavel(variavel) {
-        return variavel.simbolo.lexema;
-    }
-    traduzirConstrutoVetor(vetor) {
-        let texto = `vetor: `;
-        for (const elemento of vetor.valores) {
-            texto += this.dicionarioConstrutos[elemento.constructor.name](elemento);
-        }
-        return texto;
-    }
-    logicaComumConexaoArestas(aresta) {
-        const vertices = [];
-        while (this.anteriores.length > 0) {
-            const anterior = this.anteriores.shift();
-            let textoVertice = undefined;
-            if (this.ultimaDicaVertice) {
-                textoVertice = String(this.ultimaDicaVertice);
-                this.ultimaDicaVertice = undefined;
-            }
-            vertices.push(new mermaid_1.VerticeFluxograma(anterior, aresta, textoVertice));
-        }
-        return vertices;
-    }
-    traduzirDeclaracaoBloco(declaracaoBloco) {
-        let vertices = [];
-        for (const declaracao of declaracaoBloco.declaracoes) {
-            const verticesDeclaracao = this.dicionarioDeclaracoes[declaracao.constructor.name](declaracao);
-            vertices = vertices.concat(verticesDeclaracao);
-        }
-        return vertices;
-    }
-    traduzirDeclaracaoClasse(declaracaoClasse) {
-        const nomeClasse = declaracaoClasse.simbolo.lexema;
-        const superClasse = declaracaoClasse.superClasse
-            ? declaracaoClasse.superClasse.nome.lexema
-            : undefined;
-        // Cria o diagrama de classe
-        const diagramaClasse = new mermaid_1.DiagramaClasse(nomeClasse, superClasse);
-        // Adiciona métodos ao diagrama
-        if (declaracaoClasse.metodos && declaracaoClasse.metodos.length > 0) {
-            for (const metodo of declaracaoClasse.metodos) {
-                const parametros = [];
-                if (metodo.funcao.parametros && metodo.funcao.parametros.length > 0) {
-                    for (const param of metodo.funcao.parametros) {
-                        const nomeParam = param.nome.lexema;
-                        const tipoParam = param.tipoDado || 'qualquer';
-                        parametros.push(`${nomeParam}: ${tipoParam}`);
-                    }
-                }
-                const tipoRetorno = metodo.funcao.tipo;
-                diagramaClasse.metodos.push({
-                    nome: metodo.simbolo.lexema,
-                    parametros,
-                    tipoRetorno
-                });
+            for (const anterior of this.anteriores) {
+                subgrafo.vertices.push(new mermaid_1.VerticeFluxograma(anterior, arestaFinal));
             }
         }
-        // Adiciona o diagrama à lista
-        this.classes.push(diagramaClasse);
-        // No fluxograma principal, apenas mostra a definição da classe
-        const texto = `Linha${declaracaoClasse.linha}[Classe ${nomeClasse}${superClasse ? ` herda ${superClasse}` : ''}]`;
-        const aresta = new mermaid_1.ArestaFluxograma(declaracaoClasse, texto);
-        const vertices = this.logicaComumConexaoArestas(aresta);
-        this.anteriores.push(aresta);
-        return vertices;
-    }
-    traduzirDeclaracaoConst(declaracaoConst) {
-        let texto = `Linha${declaracaoConst.linha}(variável: ${declaracaoConst.simbolo.lexema}`;
-        texto += this.logicaComumTraducaoVarEConst(declaracaoConst, texto);
-        const aresta = new mermaid_1.ArestaFluxograma(declaracaoConst, texto);
-        const vertices = this.logicaComumConexaoArestas(aresta);
-        this.anteriores.push(aresta);
-        return vertices;
+        // Restaura o estado anterior
+        this.anteriores = anterioresAntes;
+        // Armazena o subgrafo
+        this.declaracoesFuncoes[nomeFuncao] = subgrafo;
+        // Não adiciona ao fluxo principal
+        return Promise.resolve([]);
     }
-    traduzirDeclaracaoEnquanto(declaracaoEnquanto) {
-        let texto = `Linha${declaracaoEnquanto.linha}(enquanto `;
-        const condicao = this.dicionarioConstrutos[declaracaoEnquanto.condicao.constructor.name](declaracaoEnquanto.condicao);
+    async visitarDeclaracaoEnquanto(declaracao) {
+        let texto = `Linha${declaracao.linha}(enquanto `;
+        const condicao = await declaracao.condicao.aceitar(this);
         texto += condicao + ')';
-        const aresta = new mermaid_1.ArestaFluxograma(declaracaoEnquanto, texto);
+        const aresta = new mermaid_1.ArestaFluxograma(declaracao, texto);
         let vertices = this.logicaComumConexaoArestas(aresta);
         this.anteriores.push(aresta);
         // Corpo, normalmente um `Bloco`.
-        const verticesCorpo = this.dicionarioDeclaracoes[declaracaoEnquanto.corpo.constructor.name](declaracaoEnquanto.corpo);
+        const verticesCorpo = await declaracao.corpo.aceitar(this);
         vertices = vertices.concat(verticesCorpo);
         const ultimaArestaCorpo = verticesCorpo[verticesCorpo.length - 1].destino;
         const verticeLaco = new mermaid_1.VerticeFluxograma(ultimaArestaCorpo, aresta);
         vertices.push(verticeLaco);
-        return vertices;
+        return Promise.resolve(vertices);
     }
-    logicaComumCaminhoEscolha(declaracaoEscolha, caminhoEscolha, linha, textoIdentificadorOuLiteral, caminhoPadrao) {
-        let textoCaso = '';
-        if (!caminhoPadrao) {
-            textoCaso = `caso ${textoIdentificadorOuLiteral} seja igual a `;
-            for (const condicao of caminhoEscolha.condicoes) {
-                const textoCondicao = this.dicionarioConstrutos[condicao.constructor.name](condicao);
-                textoCaso += `${textoCondicao} ou `;
-            }
-            textoCaso = textoCaso.slice(0, -4);
-            textoCaso += ':';
-        }
-        else {
-            textoCaso = `caso ${textoIdentificadorOuLiteral} tenha qualquer outro valor:`;
-        }
-        let textoCaminho = `Linha${linha}(${textoCaso})`;
-        const arestaCondicaoCaminho = new mermaid_1.ArestaFluxograma(declaracaoEscolha, textoCaminho);
-        this.anteriores.push(arestaCondicaoCaminho);
-        let verticesResolvidos = [];
-        for (const declaracaoCaminho of caminhoEscolha.declaracoes) {
-            const verticesDeclaracoes = this.dicionarioDeclaracoes[declaracaoCaminho.constructor.name](declaracaoCaminho);
-            verticesResolvidos = verticesResolvidos.concat(verticesDeclaracoes);
-            this.anteriores.pop();
-            this.anteriores.push(verticesDeclaracoes[verticesDeclaracoes.length - 1].destino);
-        }
-        this.anteriores.pop();
-        return {
-            caminho: arestaCondicaoCaminho,
-            declaracoesCaminho: verticesResolvidos,
-        };
-    }
-    traduzirDeclaracaoEscolha(declaracaoEscolha) {
-        let texto = `Linha${declaracaoEscolha.linha}(escolha um caminho pelo valor de `;
-        const textoIdentificadorOuLiteral = this.dicionarioConstrutos[declaracaoEscolha.identificadorOuLiteral.constructor.name](declaracaoEscolha.identificadorOuLiteral);
+    async visitarDeclaracaoEscolha(declaracao) {
+        let texto = `Linha${declaracao.linha}(escolha um caminho pelo valor de `;
+        const textoIdentificadorOuLiteral = await declaracao.identificadorOuLiteral.aceitar(this);
         texto += textoIdentificadorOuLiteral + ')';
-        const aresta = new mermaid_1.ArestaFluxograma(declaracaoEscolha, texto);
+        const aresta = new mermaid_1.ArestaFluxograma(declaracao, texto);
         let vertices = this.logicaComumConexaoArestas(aresta);
         const arestasCaminho = [];
-        for (const caminho of declaracaoEscolha.caminhos) {
-            arestasCaminho.push(this.logicaComumCaminhoEscolha(declaracaoEscolha, caminho, caminho.condicoes[0].linha, textoIdentificadorOuLiteral, false));
+        for (const caminho of declaracao.caminhos) {
+            arestasCaminho.push(await this.logicaComumCaminhoEscolha(declaracao, caminho, caminho.condicoes[0].linha, textoIdentificadorOuLiteral, false));
         }
-        if (declaracaoEscolha.caminhoPadrao) {
-            arestasCaminho.push(this.logicaComumCaminhoEscolha(declaracaoEscolha, declaracaoEscolha.caminhoPadrao, declaracaoEscolha.caminhoPadrao.declaracoes[0].linha - 1, textoIdentificadorOuLiteral, true));
+        if (declaracao.caminhoPadrao) {
+            arestasCaminho.push(await this.logicaComumCaminhoEscolha(declaracao, declaracao.caminhoPadrao, declaracao.caminhoPadrao.declaracoes[0].linha - 1, textoIdentificadorOuLiteral, true));
         }
         for (const conjunto of Object.values(arestasCaminho)) {
             const verticeEscolhaECaminho = new mermaid_1.VerticeFluxograma(aresta, conjunto.caminho);
@@ -325,101 +180,91 @@ class TradutorMermaidJs {
             vertices = vertices.concat(conjunto.declaracoesCaminho);
             this.anteriores.push(conjunto.declaracoesCaminho[conjunto.declaracoesCaminho.length - 1].destino);
         }
-        return vertices;
+        return Promise.resolve(vertices);
     }
-    traduzirDeclaracaoEscreva(declaracaoEscreva) {
-        let texto = `Linha${declaracaoEscreva.linha}(escreva: `;
-        for (const argumento of declaracaoEscreva.argumentos) {
-            const valor = this.dicionarioConstrutos[argumento.constructor.name](argumento);
+    async visitarDeclaracaoEscreva(declaracao) {
+        let texto = `Linha${declaracao.linha}(escreva: `;
+        for (const argumento of declaracao.argumentos) {
+            const valor = await argumento.aceitar(this);
             texto += valor + ', ';
         }
         texto = texto.slice(0, -2);
         texto += ')';
-        const aresta = new mermaid_1.ArestaFluxograma(declaracaoEscreva, texto);
+        const aresta = new mermaid_1.ArestaFluxograma(declaracao, texto);
         const vertices = this.logicaComumConexaoArestas(aresta);
         this.anteriores.push(aresta);
-        return vertices;
+        return Promise.resolve(vertices);
     }
-    traduzirDeclaracaoExpressao(declaracaoExpressao) {
-        let texto = `Linha${declaracaoExpressao.linha}(`;
-        const textoConstruto = this.dicionarioConstrutos[declaracaoExpressao.expressao.constructor.name](declaracaoExpressao.expressao);
-        texto += textoConstruto + ')';
-        const aresta = new mermaid_1.ArestaFluxograma(declaracaoExpressao, texto);
-        const vertices = this.logicaComumConexaoArestas(aresta);
-        this.anteriores.push(aresta);
-        return vertices;
+    visitarDeclaracaoEscrevaMesmaLinha(declaracao) {
+        throw new Error('Método não implementado.');
     }
-    traduzirDeclaracaoFazerEnquanto(declaracaoFazerEnquanto) {
-        const texto = `Linha${declaracaoFazerEnquanto.linha}(fazer)`;
-        const aresta = new mermaid_1.ArestaFluxograma(declaracaoFazerEnquanto, texto);
+    async visitarDeclaracaoFazer(declaracao) {
+        const texto = `Linha${declaracao.linha}(fazer)`;
+        const aresta = new mermaid_1.ArestaFluxograma(declaracao, texto);
         let vertices = this.logicaComumConexaoArestas(aresta);
         this.anteriores.push(aresta);
         // Corpo, normalmente um `Bloco`.
-        const verticesCorpo = this.dicionarioDeclaracoes[declaracaoFazerEnquanto.caminhoFazer.constructor.name](declaracaoFazerEnquanto.caminhoFazer);
+        const verticesCorpo = await declaracao.caminhoFazer.aceitar(this);
         vertices = vertices.concat(verticesCorpo);
         const ultimaArestaCorpo = verticesCorpo[verticesCorpo.length - 1].destino;
-        const condicao = this.dicionarioConstrutos[declaracaoFazerEnquanto.condicaoEnquanto.constructor.name](declaracaoFazerEnquanto.condicaoEnquanto);
-        let textoEnquanto = `Linha${declaracaoFazerEnquanto.condicaoEnquanto.linha}(enquanto ${condicao})`;
-        const arestaEnquanto = new mermaid_1.ArestaFluxograma(declaracaoFazerEnquanto, textoEnquanto);
+        const condicao = await declaracao.condicaoEnquanto.aceitar(this);
+        let textoEnquanto = `Linha${declaracao.condicaoEnquanto.linha}(enquanto ${condicao})`;
+        const arestaEnquanto = new mermaid_1.ArestaFluxograma(declaracao, textoEnquanto);
         const verticeEnquanto = new mermaid_1.VerticeFluxograma(ultimaArestaCorpo, arestaEnquanto);
         vertices.push(verticeEnquanto);
         const verticeCondicaoComFazer = new mermaid_1.VerticeFluxograma(arestaEnquanto, aresta);
         vertices.push(verticeCondicaoComFazer);
         this.anteriores.pop();
         this.anteriores.push(arestaEnquanto);
-        return vertices;
+        return Promise.resolve(vertices);
+    }
+    visitarDeclaracaoInicioAlgoritmo(declaracao) {
+        throw new Error('Método não implementado.');
     }
-    traduzirDeclaracaoFuncao(declaracaoFuncao) {
-        // Gera o corpo como vértices, mas não conecta nada ao fluxo principal
-        const verticesCorpo = this.traduzirFuncaoConstruto(declaracaoFuncao.funcao);
-        if (verticesCorpo.length === 0) {
-            return [];
-        }
-        // Descobre o texto dos nós do corpo
-        /* let textoSubgrafo = `subgraph função ${declaracaoFuncao.simbolo.lexema}\n`;
-        for (const vertice of verticesCorpo) {
-            textoSubgrafo += vertice.paraTexto();
-        }
-        textoSubgrafo += `end;\n`; */
-        // Armazena o subgraph para imprimir depois de graph TD;
-        // this.subgrafosFuncoes.push(textoSubgrafo);
-        // IMPORTANTE: não altera this.anteriores aqui, para a função
-        // não entrar no fluxo principal. O fluxo principal continua
-        // sendo só as declarações "top-level" (como a chamada em Linha4).
-        // Também não precisa devolver vértices, porque eles já
-        // foram adicionados em this.vertices pelos próprios tradutores
-        // das declarações do corpo (via dicionarioDeclaracoes).
-        return [];
-    }
-    traduzirDeclaracaoPara(declaracaoPara) {
-        let texto = `Linha${declaracaoPara.linha}(para `;
-        if (declaracaoPara.inicializador) {
-            for (const declaracaoInicializadora of declaracaoPara.inicializador) {
+    async visitarDeclaracaoParaCada(declaracao) {
+        const textoVariavelIteracao = await declaracao.variavelIteracao.aceitar(this);
+        let texto = `Linha${declaracao.linha}(para cada ${textoVariavelIteracao} em `;
+        const textoVariavelIterada = await declaracao.vetorOuDicionario.aceitar(this);
+        texto += textoVariavelIterada + ')';
+        const aresta = new mermaid_1.ArestaFluxograma(declaracao, texto);
+        let vertices = this.logicaComumConexaoArestas(aresta);
+        this.anteriores.push(aresta);
+        // Corpo, normalmente um `Bloco`.
+        const verticesCorpo = await declaracao.corpo.aceitar(this);
+        vertices = vertices.concat(verticesCorpo);
+        const ultimaArestaCorpo = verticesCorpo[verticesCorpo.length - 1].destino;
+        vertices.push(new mermaid_1.VerticeFluxograma(ultimaArestaCorpo, aresta));
+        return Promise.resolve(vertices);
+    }
+    async visitarDeclaracaoPara(declaracao) {
+        let texto = `Linha${declaracao.linha}(para `;
+        if (declaracao.inicializador) {
+            for (const declaracaoInicializadora of declaracao.inicializador) {
                 // Normalmente é `Var`.
                 const declaracaoVar = declaracaoInicializadora;
-                const valorInicializacao = this.dicionarioConstrutos[declaracaoVar.inicializador.constructor.name](declaracaoVar.inicializador);
+                const valorInicializacao = await declaracaoVar.inicializador.aceitar(this);
                 texto += `uma variável ${declaracaoVar.simbolo.lexema} inicializada com ${valorInicializacao}, `;
             }
             texto = texto.slice(0, -2);
         }
         texto += ')';
-        const aresta = new mermaid_1.ArestaFluxograma(declaracaoPara, texto);
+        const aresta = new mermaid_1.ArestaFluxograma(declaracao, texto);
         let vertices = this.logicaComumConexaoArestas(aresta);
         this.anteriores.push(aresta);
         // Condição
-        const textoCondicao = this.dicionarioConstrutos[declaracaoPara.condicao.constructor.name](declaracaoPara.condicao);
-        const textoArestaCondicao = `Linha${declaracaoPara.linha}Condicao{se ${textoCondicao}}`;
-        const arestaCondicao = new mermaid_1.ArestaFluxograma(declaracaoPara, textoArestaCondicao);
+        const textoCondicao = await declaracao.condicao.aceitar(this);
+        const textoArestaCondicao = `Linha${declaracao.linha}Condicao{se ${textoCondicao}}`;
+        const arestaCondicao = new mermaid_1.ArestaFluxograma(declaracao, textoArestaCondicao);
         vertices = vertices.concat(this.logicaComumConexaoArestas(arestaCondicao));
         this.anteriores.push(arestaCondicao);
         this.ultimaDicaVertice = 'Sim';
         // Corpo, normalmente um `Bloco`.
-        const verticesCorpo = this.dicionarioDeclaracoes[declaracaoPara.corpo.constructor.name](declaracaoPara.corpo);
+        const verticesCorpo = await declaracao.corpo.aceitar(this);
         vertices = vertices.concat(verticesCorpo);
         // Incremento
         const ultimaArestaCorpo = verticesCorpo[verticesCorpo.length - 1].destino;
-        const textoIncremento = this.dicionarioConstrutos[declaracaoPara.incrementar.constructor.name](declaracaoPara.incrementar);
-        const arestaIncremento = new mermaid_1.ArestaFluxograma(declaracaoPara, `Linha${declaracaoPara.linha}Incremento(${textoIncremento})`);
+        const textoIncremento = await declaracao.incrementar.aceitar(this);
+        const arestaIncremento = new mermaid_1.ArestaFluxograma(declaracao, `Linha${declaracao.linha}Incremento(${textoIncremento})`);
         const verticeIncremento = new mermaid_1.VerticeFluxograma(ultimaArestaCorpo, arestaIncremento);
         vertices.push(verticeIncremento);
         const verticeLaco = new mermaid_1.VerticeFluxograma(arestaIncremento, arestaCondicao);
@@ -428,80 +273,364 @@ class TradutorMermaidJs {
         this.anteriores.pop();
         this.anteriores.push(arestaCondicao);
         this.ultimaDicaVertice = 'Não';
-        return vertices;
+        return Promise.resolve(vertices);
     }
-    traduzirDeclaracaoParaCada(declaracaoParaCada) {
-        const textoVariavelIteracao = this.dicionarioConstrutos[declaracaoParaCada.variavelIteracao.constructor.name](declaracaoParaCada.variavelIteracao);
-        let texto = `Linha${declaracaoParaCada.linha}(para cada ${textoVariavelIteracao} em `;
-        const textoVariavelIterada = this.dicionarioConstrutos[declaracaoParaCada.vetorOuDicionario.constructor.name](declaracaoParaCada.vetorOuDicionario);
-        texto += textoVariavelIterada + ')';
-        const aresta = new mermaid_1.ArestaFluxograma(declaracaoParaCada, texto);
-        let vertices = this.logicaComumConexaoArestas(aresta);
-        this.anteriores.push(aresta);
-        // Corpo, normalmente um `Bloco`.
-        const verticesCorpo = this.dicionarioDeclaracoes[declaracaoParaCada.corpo.constructor.name](declaracaoParaCada.corpo);
-        vertices = vertices.concat(verticesCorpo);
-        const ultimaArestaCorpo = verticesCorpo[verticesCorpo.length - 1].destino;
-        vertices.push(new mermaid_1.VerticeFluxograma(ultimaArestaCorpo, aresta));
-        return vertices;
-    }
-    traduzirDeclaracaoSe(declaracaoSe) {
-        let texto = `Linha${declaracaoSe.linha}{se `;
-        const condicao = this.dicionarioConstrutos[declaracaoSe.condicao.constructor.name](declaracaoSe.condicao);
+    async visitarDeclaracaoSe(declaracao) {
+        let texto = `Linha${declaracao.linha}{se `;
+        const condicao = await declaracao.condicao.aceitar(this);
         texto += condicao;
         texto += `}`;
-        const aresta = new mermaid_1.ArestaFluxograma(declaracaoSe, texto);
+        const aresta = new mermaid_1.ArestaFluxograma(declaracao, texto);
         let vertices = this.logicaComumConexaoArestas(aresta);
         this.anteriores.push(aresta);
         this.ultimaDicaVertice = 'Sim';
         // Caminho então, normalmente um `Bloco`.
-        const verticesEntao = this.dicionarioDeclaracoes[declaracaoSe.caminhoEntao.constructor.name](declaracaoSe.caminhoEntao);
+        const verticesEntao = await declaracao.caminhoEntao.aceitar(this);
         vertices = vertices.concat(verticesEntao);
         const ultimaArestaEntao = verticesEntao[verticesEntao.length - 1].destino;
-        if (declaracaoSe.caminhoSenao) {
+        if (declaracao.caminhoSenao) {
             this.anteriores = [];
-            const arestaSenao = new mermaid_1.ArestaFluxograma(declaracaoSe, `Linha${declaracaoSe.caminhoSenao.linha}(senão)`);
+            const arestaSenao = new mermaid_1.ArestaFluxograma(declaracao, `Linha${declaracao.caminhoSenao.linha}(senão)`);
             vertices.push(new mermaid_1.VerticeFluxograma(aresta, arestaSenao, 'Não'));
             this.anteriores.push(arestaSenao);
-            const verticesSenao = this.dicionarioDeclaracoes[declaracaoSe.caminhoSenao.constructor.name](declaracaoSe.caminhoSenao);
+            const verticesSenao = await declaracao.caminhoSenao.aceitar(this);
             vertices = vertices.concat(verticesSenao);
         }
         this.anteriores.push(ultimaArestaEntao);
-        return vertices;
+        return Promise.resolve(vertices);
     }
-    logicaComumTraducaoVarEConst(declaracaoVarOuConst, textoInicial) {
-        if (declaracaoVarOuConst.inicializador) {
-            textoInicial += `, iniciada com: ${this.dicionarioConstrutos[declaracaoVarOuConst.inicializador.constructor.name](declaracaoVarOuConst.inicializador)}`;
+    async visitarDeclaracaoTendoComo(declaracao) {
+        const textoVariavelIteracao = await declaracao.inicializacaoVariavel.aceitar(this);
+        let texto = `Linha${declaracao.linha}(tendo ${textoVariavelIteracao} como `;
+        texto += declaracao.simboloVariavel.lexema + ')';
+        const aresta = new mermaid_1.ArestaFluxograma(declaracao, texto);
+        let vertices = this.logicaComumConexaoArestas(aresta);
+        this.anteriores.push(aresta);
+        // Corpo, normalmente um `Bloco`.
+        const verticesCorpo = await declaracao.corpo.aceitar(this);
+        vertices = vertices.concat(verticesCorpo);
+        const ultimaArestaCorpo = verticesCorpo[verticesCorpo.length - 1].destino;
+        vertices.push(new mermaid_1.VerticeFluxograma(ultimaArestaCorpo, aresta));
+        return Promise.resolve(vertices);
+    }
+    visitarDeclaracaoTente(declaracao) {
+        throw new Error('Método não implementado.');
+    }
+    visitarDeclaracaoTextoDocumentacao(declaracao) {
+        throw new Error('Método não implementado.');
+    }
+    async visitarDeclaracaoVar(declaracao) {
+        let texto = `Linha${declaracao.linha}(variável: ${declaracao.simbolo.lexema}`;
+        texto += await this.logicaComumTraducaoVarEConst(declaracao, texto);
+        const aresta = new mermaid_1.ArestaFluxograma(declaracao, texto);
+        const vertices = this.logicaComumConexaoArestas(aresta);
+        this.anteriores.push(aresta);
+        return Promise.resolve(vertices);
+    }
+    visitarDeclaracaoVarMultiplo(declaracao) {
+        throw new Error('Método não implementado.');
+    }
+    async visitarExpressaoDeAtribuicao(expressao) {
+        const textoAlvo = await expressao.alvo.aceitar(this);
+        const textoValor = await expressao.valor.aceitar(this);
+        return Promise.resolve(`${textoAlvo} recebe: ${textoValor}`);
+    }
+    async visitarExpressaoAcessoIndiceVariavel(expressao) {
+        const textoIndice = await expressao.indice.aceitar(this);
+        return Promise.resolve(`no índice ${textoIndice}`);
+    }
+    visitarExpressaoAcessoIntervaloVariavel(expressao) {
+        throw new Error('Método não implementado.');
+    }
+    visitarExpressaoAcessoElementoMatriz(expressao) {
+        throw new Error('Método não implementado.');
+    }
+    async visitarExpressaoAcessoMetodo(expressao) {
+        return Promise.resolve(`método ${expressao.nomeMetodo}`);
+    }
+    async visitarExpressaoAcessoMetodoOuPropriedade(expressao) {
+        return Promise.resolve(`método ou propriedade ${expressao.simbolo.lexema}`);
+    }
+    async visitarExpressaoAcessoPropriedade(expressao) {
+        return Promise.resolve(`propriedade ${expressao.nomePropriedade}`);
+    }
+    async visitarExpressaoAgrupamento(expressao) {
+        return await expressao.expressao.aceitar(this);
+    }
+    visitarExpressaoArgumentoReferenciaFuncao(expressao) {
+        throw new Error('Método não implementado.');
+    }
+    visitarExpressaoAtribuicaoPorIndice(expressao) {
+        throw new Error('Método não implementado.');
+    }
+    visitarExpressaoAtribuicaoPorIndicesMatriz(expressao) {
+        throw new Error('Método não implementado.');
+    }
+    async visitarExpressaoBinaria(expressao) {
+        const operandoEsquerdo = await expressao.esquerda.aceitar(this);
+        const operandoDireito = await expressao.direita.aceitar(this);
+        switch (expressao.operador.tipo) {
+            case delegua_1.default.ADICAO:
+                return Promise.resolve(`somar ${operandoEsquerdo} e ${operandoDireito}`);
+            case delegua_1.default.MENOR:
+                return Promise.resolve(`${operandoEsquerdo} for menor que ${operandoDireito}`);
         }
-        textoInicial += ')';
-        return textoInicial;
+        return Promise.resolve('');
+    }
+    async visitarExpressaoBloco(bloco) {
+        let vertices = [];
+        for (const declaracao of bloco.declaracoes) {
+            const verticesDeclaracao = await declaracao.aceitar(this);
+            vertices = vertices.concat(verticesDeclaracao);
+        }
+        return Promise.resolve(vertices);
+    }
+    async visitarExpressaoComentario(expressao) {
+        return Promise.resolve('');
+    }
+    visitarExpressaoContinua(declaracao) {
+        throw new Error('Método não implementado.');
+    }
+    async visitarExpressaoDeChamada(expressao) {
+        const textoEntidadeChamada = await expressao.entidadeChamada.aceitar(this);
+        let texto = `chamada a ${textoEntidadeChamada}`;
+        if (expressao.argumentos.length > 0) {
+            texto += `, com argumentos: `;
+            for (const argumento of expressao.argumentos) {
+                const textoArgumento = await argumento.aceitar(this);
+                texto += `${textoArgumento}, `;
+            }
+            texto = texto.slice(0, -2);
+        }
+        else {
+            texto += `, sem argumentos`;
+        }
+        return Promise.resolve(texto);
+    }
+    async visitarExpressaoDefinirValor(expressao) {
+        const textoObjeto = await expressao.objeto.aceitar(this);
+        const textoValor = await expressao.valor.aceitar(this);
+        return Promise.resolve(`${expressao.nome.lexema} em ${textoObjeto} recebe ${textoValor}`);
+    }
+    visitarExpressaoFuncaoConstruto(expressao) {
+        throw new Error('Método não implementado.');
+    }
+    async visitarExpressaoDeVariavel(expressao) {
+        return Promise.resolve(expressao.simbolo.lexema);
+    }
+    async visitarExpressaoDicionario(expressao) {
+        let texto = `dicionário`;
+        if (expressao.chaves.length > 0) {
+            texto += `, com `;
+            for (const [chave, indice] of Object.entries(expressao.chaves)) {
+                texto += `chave ${chave} definida com o valor ${expressao.valores[0]}`;
+            }
+        }
+        else {
+            texto += ' vazio';
+        }
+        return Promise.resolve(texto);
+    }
+    visitarExpressaoExpressaoRegular(expressao) {
+        throw new Error('Método não implementado.');
+    }
+    visitarExpressaoFalhar(expressao) {
+        throw new Error('Método não implementado.');
+    }
+    visitarExpressaoFimPara(declaracao) {
+        throw new Error('Método não implementado.');
+    }
+    visitarExpressaoFormatacaoEscrita(declaracao) {
+        throw new Error('Método não implementado.');
+    }
+    async visitarExpressaoIsto(expressao) {
+        return Promise.resolve('this');
+    }
+    async visitarExpressaoLeia(expressao) {
+        let texto = 'leia da entrada';
+        if (expressao.argumentos && expressao.argumentos.length > 0) {
+            const textoArgumento = await expressao.argumentos[0].aceitar(this);
+            texto += `, imprimindo antes: \\'${textoArgumento}\\'`;
+        }
+        return Promise.resolve(texto);
+    }
+    async visitarExpressaoLiteral(expressao) {
+        switch (expressao.tipo) {
+            case 'lógico':
+                return Promise.resolve(expressao.valor ? 'verdadeiro' : 'falso');
+            case 'texto':
+                return Promise.resolve(`\\'${expressao.valor}\\'`);
+            default:
+                return Promise.resolve(String(expressao.valor));
+        }
+    }
+    visitarExpressaoLogica(expressao) {
+        throw new Error('Método não implementado.');
+    }
+    visitarExpressaoReferenciaFuncao(expressao) {
+        throw new Error('Método não implementado.');
     }
-    traduzirDeclaracaoVar(declaracaoVar) {
-        let texto = `Linha${declaracaoVar.linha}(variável: ${declaracaoVar.simbolo.lexema}`;
-        texto += this.logicaComumTraducaoVarEConst(declaracaoVar, texto);
-        const aresta = new mermaid_1.ArestaFluxograma(declaracaoVar, texto);
+    async visitarExpressaoRetornar(expressao) {
+        let texto = `Linha${expressao.linha}(retorna`;
+        if (expressao.valor) {
+            texto += `: ${await expressao.valor.aceitar(this)}`;
+        }
+        texto += ')';
+        const aresta = new mermaid_1.ArestaFluxograma(expressao, texto);
         const vertices = this.logicaComumConexaoArestas(aresta);
         this.anteriores.push(aresta);
+        return Promise.resolve(vertices);
+    }
+    async visitarExpressaoSeparador(expressao) {
+        return Promise.resolve(`${expressao.conteudo} `);
+    }
+    visitarExpressaoSuper(expressao) {
+        throw new Error('Método não implementado.');
+    }
+    visitarExpressaoSustar(declaracao) {
+        throw new Error('Método não implementado.');
+    }
+    visitarExpressaoTupla(expressao) {
+        throw new Error('Método não implementado.');
+    }
+    visitarExpressaoTuplaN(expressao) {
+        throw new Error('Método não implementado.');
+    }
+    visitarExpressaoTipoDe(expressao) {
+        throw new Error('Método não implementado.');
+    }
+    async visitarExpressaoUnaria(expressao) {
+        const textoOperando = await expressao.operando.aceitar(this);
+        let textoOperador = '';
+        switch (expressao.operador.tipo) {
+            case delegua_1.default.INCREMENTAR:
+                textoOperador = `incrementar ${textoOperando} em 1`;
+                break;
+            case delegua_1.default.DECREMENTAR:
+                textoOperador = `decrementar ${textoOperando} de 1`;
+                break;
+        }
+        switch (expressao.incidenciaOperador) {
+            case 'ANTES':
+                return Promise.resolve(`${textoOperador}, devolver valor de ${textoOperando}`);
+            case 'DEPOIS':
+                return Promise.resolve(`devolver valor de ${textoOperando}, ${textoOperador}`);
+        }
+    }
+    async visitarExpressaoVetor(expressao) {
+        let texto = `vetor: `;
+        for (const elemento of expressao.valores) {
+            texto += await elemento.aceitar(this);
+        }
+        return Promise.resolve(texto);
+    }
+    /**
+     * Traduz uma declaração de Expressao que contém uma chamada de função,
+     * criando os vértices necessários para conectar ao subgrafo da função.
+     */
+    async traduzirChamadaFuncao(declaracaoExpressao, chamada) {
+        // Verifica se é uma chamada a uma função conhecida
+        if (chamada.entidadeChamada.constructor.name === 'Variavel') {
+            const variavel = chamada.entidadeChamada;
+            const nomeFuncao = variavel.simbolo.lexema;
+            if (this.declaracoesFuncoes[nomeFuncao]) {
+                const subgrafo = this.declaracoesFuncoes[nomeFuncao];
+                let vertices = [];
+                // Conecta do fluxo atual para a entrada da função
+                const textoPreChamada = `Linha${declaracaoExpressao.linha}(${await chamada.aceitar(this)})`;
+                const arestaPreChamada = new mermaid_1.ArestaFluxograma(declaracaoExpressao, textoPreChamada);
+                vertices = vertices.concat(this.logicaComumConexaoArestas(arestaPreChamada));
+                // Conecta a pré-chamada ao início da função
+                vertices.push(new mermaid_1.VerticeFluxograma(arestaPreChamada, subgrafo.arestaInicial));
+                // A saída da função volta para o fluxo principal
+                this.anteriores = [subgrafo.arestaFinal];
+                return Promise.resolve(vertices);
+            }
+        }
+        // Se não for uma função conhecida, trata como expressão normal
+        return Promise.resolve([]);
+    }
+    logicaComumConexaoArestas(aresta) {
+        const vertices = [];
+        while (this.anteriores.length > 0) {
+            const anterior = this.anteriores.shift();
+            let textoVertice = undefined;
+            if (this.ultimaDicaVertice) {
+                textoVertice = String(this.ultimaDicaVertice);
+                this.ultimaDicaVertice = undefined;
+            }
+            vertices.push(new mermaid_1.VerticeFluxograma(anterior, aresta, textoVertice));
+        }
         return vertices;
     }
+    async logicaComumCaminhoEscolha(declaracaoEscolha, caminhoEscolha, linha, textoIdentificadorOuLiteral, caminhoPadrao) {
+        let textoCaso = '';
+        if (!caminhoPadrao) {
+            textoCaso = `caso ${textoIdentificadorOuLiteral} seja igual a `;
+            for (const condicao of caminhoEscolha.condicoes) {
+                const textoCondicao = await condicao.aceitar(this);
+                textoCaso += `${textoCondicao} ou `;
+            }
+            textoCaso = textoCaso.slice(0, -4);
+            textoCaso += ':';
+        }
+        else {
+            textoCaso = `caso ${textoIdentificadorOuLiteral} tenha qualquer outro valor:`;
+        }
+        let textoCaminho = `Linha${linha}(${textoCaso})`;
+        const arestaCondicaoCaminho = new mermaid_1.ArestaFluxograma(declaracaoEscolha, textoCaminho);
+        this.anteriores.push(arestaCondicaoCaminho);
+        let verticesResolvidos = [];
+        for (const declaracaoCaminho of caminhoEscolha.declaracoes) {
+            const verticesDeclaracoes = await declaracaoCaminho.aceitar(this);
+            verticesResolvidos = verticesResolvidos.concat(verticesDeclaracoes);
+            this.anteriores.pop();
+            this.anteriores.push(verticesDeclaracoes[verticesDeclaracoes.length - 1].destino);
+        }
+        this.anteriores.pop();
+        return Promise.resolve({
+            caminho: arestaCondicaoCaminho,
+            declaracoesCaminho: verticesResolvidos,
+        });
+    }
+    async logicaComumTraducaoVarEConst(declaracaoVarOuConst, textoInicial) {
+        if (declaracaoVarOuConst.inicializador) {
+            textoInicial += `, iniciada com: ${await declaracaoVarOuConst.inicializador.aceitar(this)}`;
+        }
+        textoInicial += ')';
+        return Promise.resolve(textoInicial);
+    }
     /**
      * Ponto de entrada para a tradução de declarações em um fluxograma
      * no formato MermaidJs.
      * @param {Declaracao[]} declaracoes As declarações a serem traduzidas.
      * @returns {string} Texto no formato MermaidJs representando o fluxograma.
      */
-    traduzir(declaracoes) {
+    async traduzir(declaracoes) {
         this.anteriores = [];
         this.vertices = [];
         let resultado = 'graph TD;\n';
         this.indentacaoAtual = 4;
-        this.subgrafosFuncoes = {};
+        this.declaracoesFuncoes = {};
+        this.declaracoesClasses = {};
         for (const declaracao of declaracoes) {
-            this.vertices = this.vertices.concat(this.dicionarioDeclaracoes[declaracao.constructor.name](declaracao));
+            this.vertices = this.vertices.concat(await declaracao.aceitar(this));
+        }
+        // Renderiza os subgrafos de funções
+        if (Object.keys(this.declaracoesFuncoes).length > 0) {
+            for (const [nomeFuncao, subgrafo] of Object.entries(this.declaracoesFuncoes)) {
+                resultado += `    subgraph ${nomeFuncao}["Função: ${nomeFuncao}()"]\n`;
+                // Renderiza os vértices da função
+                for (const vertice of subgrafo.vertices) {
+                    resultado += '    ' + vertice.paraTexto();
+                }
+                resultado += `    end\n`;
+            }
         }
-        if (Object.keys(this.subgrafosFuncoes).length > 0) {
-            for (const subgrafo of Object.values(this.subgrafosFuncoes)) {
-                resultado += subgrafo;
+        // Renderiza os subgrafos de classes
+        if (Object.keys(this.declaracoesClasses).length > 0) {
+            for (const [nomeClasse, subgrafo] of Object.entries(this.declaracoesClasses)) {
+                resultado += subgrafo.paraTexto();
             }
         }
         if (this.vertices.length === 0 && this.anteriores.length === 0) {