@designliquido/delegua 0.11.14 → 0.12.0

package/fontes/interpretador/interpretador-com-depuracao.d.ts

@@ -1,9 +1,12 @@
 import { EspacoVariaveis } from '../espaco-variaveis';
-import { Declaracao } from '../declaracoes';
+import { Declaracao, Retorna, Var } from '../declaracoes';
 import { PontoParada } from '../depuracao';
-import { ImportadorInterface, InterpretadorComDepuracaoInterface } from '../interfaces';
+import { ComandoDepurador, ImportadorInterface, InterpretadorComDepuracaoInterface } from '../interfaces';
+import { TipoEscopoExecucao } from '../interfaces/escopo-execucao';
+import { RetornoQuebra } from '../quebras';
 import { Interpretador } from './interpretador';
 import { RetornoInterpretador } from '../interfaces/retornos/retorno-interpretador';
+import { Atribuir, Chamada } from '../construtos';
 /**
  * Implementação do Interpretador com suporte a depuração.
  * Herda o Interpretador padrão de Delégua e implementa métodos a mais, que são
@@ -29,9 +32,42 @@ export declare class InterpretadorComDepuracao extends Interpretador implements
     finalizacaoDaExecucao: Function;
     pontoDeParadaAtivo: boolean;
     escopoAtual: number;
-    comandoAdentrarEscopo: boolean;
-    comandoProximo: boolean;
+    comando?: ComandoDepurador;
+    executandoChamada: boolean;
+    proximoEscopo?: TipoEscopoExecucao;
+    idChamadaAtual?: string;
+    passos: number;
     constructor(importador: ImportadorInterface, diretorioBase: string, funcaoDeRetorno: Function);
+    private gerarIdResolucaoChamada;
+    visitarExpressaoDeChamada(expressao: Chamada): Promise<any>;
+    /**
+     * A execução de uma atribuição de variável no interpretador com depuração pode ser em duas etapas.
+     * O desenvolvedor pode inspecionar o lado direito e ir parando a execução usando
+     * F10, por exemplo. Neste caso, a instrução aqui é executada duas vezes:
+     * A primeira para armazenar o valor do lado direito em `this.valorRetornoEscopoAnterior`, e a
+     * segunda para efetivamente atribuir o valor da variável.
+     * @param expressao
+     * @returns
+     */
+    visitarDeclaracaoDeAtribuicao(expressao: Atribuir): Promise<any>;
+    /**
+     * A execução de `var` no interpretador com depuração pode ser em duas etapas.
+     * O desenvolvedor pode inspecionar o lado direito e ir parando a execução usando
+     * F10, por exemplo. Neste caso, a instrução aqui é executada duas vezes:
+     * A primeira para armazenar o valor do lado direito em `this.valorRetornoEscopoAnterior`, e a
+     * segunda para efetivamente atribuir o valor da variável.
+     * @param declaracao A declaração Var
+     * @returns O valor do resultado resolvido, se a declaração resolveu.
+     * Nulo ou indefinido em caso contrário.
+     */
+    visitarDeclaracaoVar(declaracao: Var): Promise<any>;
+    /**
+     * Ao executar um retorno, manter o valor retornado no Interpretador para
+     * uso por linhas que foram executadas com o comando `próximo` do depurador.
+     * @param declaracao Uma declaracao Retorna
+     * @returns O resultado da execução da visita.
+     */
+    visitarExpressaoRetornar(declaracao: Retorna): Promise<RetornoQuebra>;
     /**
      * Se bloco de execução já foi instanciado antes (por exemplo, quando há um ponto de parada e a
      * execução do código é retomada pelo depurador), retoma a execução do bloco do ponto em que havia parado.
@@ -48,7 +84,21 @@ export declare class InterpretadorComDepuracao extends Interpretador implements
      * @param declaracao A declaração a ser executada.
      * @returns True quando execução deve parar. False caso contrário.
      */
-    verificarPontoParada(declaracao: Declaracao): boolean;
+    private verificarPontoParada;
+    /**
+     * No interpretador com depuração, este método é dividido em dois outros métodos privados:
+     * - `this.executarUmPassoNoEscopo`, que executa apenas uma instrução e nada mais;
+     * - `this.executarUltimoEscopoComandoContinuar`, que é a execução trivial de um escopo inteiro,
+     *      ou com todas as instruções, ou até encontrar um ponto de parada.
+     * @param manterAmbiente Se verdadeiro, junta elementos do último escopo com o escopo
+     *                       imediatamente abaixo.
+     * @param naoVerificarPrimeiraExecucao Booleano que pede ao Interpretador para não
+     *                                     verificar o ponto de parada na primeira execução.
+     *                                     Normalmente usado pelo Servidor de Depuração para continuar uma linha.
+     * @returns O retorno da execução.
+     */
+    executarUltimoEscopo(manterAmbiente?: boolean, naoVerificarPrimeiraExecucao?: boolean): Promise<any>;
+    private executarUmPassoNoEscopo;
     /**
      * Continua a interpretação parcial do último ponto em que parou.
      * Pode ser tanto o começo da execução inteira, ou pós comando do depurador
@@ -60,7 +110,7 @@ export declare class InterpretadorComDepuracao extends Interpretador implements
      *                                     Normalmente usado pelo Servidor de Depuração para continuar uma linha.
      * @returns Um objeto de retorno, com erros encontrados se houverem.
      */
-    executarUltimoEscopo(manterAmbiente?: boolean, naoVerificarPrimeiraExecucao?: boolean): Promise<any>;
+    private executarUltimoEscopoComandoContinuar;
     /**
      * Continua a interpretação, conforme comando do depurador.
      * Quando um ponto de parada é ativado, a pilha de execução do TypeScript é perdida.
@@ -69,34 +119,55 @@ export declare class InterpretadorComDepuracao extends Interpretador implements
      * Diferentemente de `executarUltimoEscopo`, este método descarta apenas um escopo (o que foi chamado).
      * @see executarBloco
      */
-    continuarInterpretacao(): Promise<any>;
-    private descartarEscoposFinalizados;
+    instrucaoContinuarInterpretacao(): Promise<any>;
+    /**
+     * Empilha um escopo se for possível.
+     * Se não for, apenas executa a instrução corrente.
+     */
+    adentrarEscopo(): Promise<any>;
     /**
      * Interpreta apenas uma instrução a partir do ponto de parada ativo, conforme comando do depurador.
      * Esse método cria uma nova pilha de execução do lado do JS, começando do último elemento executado do
      * primeiro escopo, subindo até o último elemento executado do último escopo.
      * @param escopo Indica o escopo a ser visitado. Usado para construir uma pilha de chamadas do lado JS.
      */
-    interpretarApenasUmaInstrucao(escopo?: number): Promise<void>;
+    instrucaoPasso(escopo?: number): Promise<any>;
     /**
      * Interpreta restante do bloco de execução em que o ponto de parada está, conforme comando do depurador.
      * Se houver outros pontos de parada no mesmo escopo à frente da instrução atual, todos são ignorados.
      * @param escopo Indica o escopo a ser visitado. Usado para construir uma pilha de chamadas do lado JS.
      */
-    proximoESair(escopo?: number): Promise<void>;
+    instrucaoProximoESair(): Promise<void>;
     /**
      * Prepara a pilha de escopos para uma situação de depuração.
      * Não há execução de código neste caso.
      * @param declaracoes Um vetor de declarações.
      */
     prepararParaDepuracao(declaracoes: Declaracao[]): void;
+    private abrirNovoBlocoEscopo;
+    /**
+     * Reimplementando este método aqui porque a execução por depuração não requer
+     * mostrar o resultado em momento algum, ou lidar com o retorno.
+     * @param declaracao A declaracao a ser executada.
+     * @param mostrarResultado Sempre falso.
+     * @returns O resultado da execução.
+     */
+    executar(declaracao: Declaracao, mostrarResultado?: boolean): Promise<any>;
     /**
-     * Interpretação utilizada pelo depurador. Pode encerrar ao encontrar um
-     * ponto de parada ou não.
+     * Interpretação utilizada pelo depurador para avaliar valores de variáveis.
      * Diferentemente da interpretação tradicional, não possui indicadores
      * de performance porque eles não fazem sentido aqui.
      * @param declaracoes Um vetor de declarações.
      * @returns Um objeto de retorno, com erros encontrados se houverem.
      */
     interpretar(declaracoes: Declaracao[], manterAmbiente?: boolean): Promise<RetornoInterpretador>;
+    /**
+     * Obtém o valor de uma variável por nome.
+     * Em versões anteriores, o mecanismo de avaliação fazia toda a avaliação tradicional,
+     * passando por Lexador, Avaliador Sintático e Interpretador.
+     * Isso tem sua cota de problemas, sobretudo porque a avaliação insere e descarta escopos,
+     * entrando em condição de corrida com a interpretação com depuração.
+     * @param nome O nome da variável.
+     */
+    obterVariavel(nome: string): any;
 }

package/fontes/interpretador/interpretador-com-depuracao.js

@@ -4,6 +4,8 @@ exports.InterpretadorComDepuracao = void 0;
 const espaco_variaveis_1 = require("../espaco-variaveis");
 const quebras_1 = require("../quebras");
 const interpretador_1 = require("./interpretador");
+const construtos_1 = require("../construtos");
+const inferenciador_1 = require("./inferenciador");
 /**
  * Implementação do Interpretador com suporte a depuração.
  * Herda o Interpretador padrão de Delégua e implementa métodos a mais, que são
@@ -30,8 +32,101 @@ class InterpretadorComDepuracao extends interpretador_1.Interpretador {
         this.pontosParada = [];
         this.pontoDeParadaAtivo = false;
         this.escopoAtual = 0;
-        this.comandoAdentrarEscopo = false;
-        this.comandoProximo = false;
+        this.executandoChamada = false;
+        this.passos = 0;
+    }
+    async gerarIdResolucaoChamada(expressao) {
+        const argumentosResolvidos = [];
+        for (let argumento of expressao.argumentos) {
+            argumentosResolvidos.push(await this.avaliar(argumento));
+        }
+        return argumentosResolvidos.reduce((acumulador, argumento) => acumulador += `,${argumento.hasOwnProperty('valor') ? argumento.valor : argumento}`, expressao.id);
+    }
+    async visitarExpressaoDeChamada(expressao) {
+        const _idChamadaComArgumentos = await this.gerarIdResolucaoChamada(expressao);
+        // Usado na abertura do bloco de escopo da chamada.
+        this.idChamadaAtual = _idChamadaComArgumentos;
+        this.executandoChamada = true;
+        this.proximoEscopo = 'funcao';
+        const retorno = await super.visitarExpressaoDeChamada(expressao);
+        this.executandoChamada = false;
+        const escopoAtual = this.pilhaEscoposExecucao.topoDaPilha();
+        escopoAtual.ambiente.resolucoesChamadas[_idChamadaComArgumentos] = retorno;
+        return retorno;
+    }
+    /**
+     * A execução de uma atribuição de variável no interpretador com depuração pode ser em duas etapas.
+     * O desenvolvedor pode inspecionar o lado direito e ir parando a execução usando
+     * F10, por exemplo. Neste caso, a instrução aqui é executada duas vezes:
+     * A primeira para armazenar o valor do lado direito em `this.valorRetornoEscopoAnterior`, e a
+     * segunda para efetivamente atribuir o valor da variável.
+     * @param expressao
+     * @returns
+     */
+    async visitarDeclaracaoDeAtribuicao(expressao) {
+        if (expressao.valor instanceof construtos_1.Chamada) {
+            const escopoAtual = this.pilhaEscoposExecucao.topoDaPilha();
+            const idChamadaComArgumentos = await this.gerarIdResolucaoChamada(expressao.valor);
+            if (escopoAtual.ambiente.resolucoesChamadas.hasOwnProperty(idChamadaComArgumentos)) {
+                const retornar = escopoAtual.ambiente.resolucoesChamadas[idChamadaComArgumentos];
+                this.pilhaEscoposExecucao.atribuirVariavel(expressao.simbolo, retornar);
+                delete escopoAtual.ambiente.resolucoesChamadas[idChamadaComArgumentos];
+                return retornar;
+            }
+        }
+        const valor = await this.avaliar(expressao.valor);
+        this.pilhaEscoposExecucao.atribuirVariavel(expressao.simbolo, valor);
+        return valor;
+    }
+    /**
+     * A execução de `var` no interpretador com depuração pode ser em duas etapas.
+     * O desenvolvedor pode inspecionar o lado direito e ir parando a execução usando
+     * F10, por exemplo. Neste caso, a instrução aqui é executada duas vezes:
+     * A primeira para armazenar o valor do lado direito em `this.valorRetornoEscopoAnterior`, e a
+     * segunda para efetivamente atribuir o valor da variável.
+     * @param declaracao A declaração Var
+     * @returns O valor do resultado resolvido, se a declaração resolveu.
+     * Nulo ou indefinido em caso contrário.
+     */
+    async visitarDeclaracaoVar(declaracao) {
+        if (declaracao.inicializador instanceof construtos_1.Chamada) {
+            const escopoAtual = this.pilhaEscoposExecucao.topoDaPilha();
+            const idChamadaComArgumentos = await this.gerarIdResolucaoChamada(declaracao.inicializador);
+            if (escopoAtual.ambiente.resolucoesChamadas.hasOwnProperty(idChamadaComArgumentos)) {
+                const retornar = escopoAtual.ambiente.resolucoesChamadas[idChamadaComArgumentos];
+                this.pilhaEscoposExecucao.definirVariavel(declaracao.simbolo.lexema, retornar);
+                delete escopoAtual.ambiente.resolucoesChamadas[idChamadaComArgumentos];
+                return retornar;
+            }
+        }
+        const valorFinal = await this.avaliacaoDeclaracaoVar(declaracao);
+        if (valorFinal !== null && valorFinal !== undefined) {
+            this.pilhaEscoposExecucao.definirVariavel(declaracao.simbolo.lexema, valorFinal);
+        }
+        return valorFinal;
+    }
+    /**
+     * Ao executar um retorno, manter o valor retornado no Interpretador para
+     * uso por linhas que foram executadas com o comando `próximo` do depurador.
+     * @param declaracao Uma declaracao Retorna
+     * @returns O resultado da execução da visita.
+     */
+    async visitarExpressaoRetornar(declaracao) {
+        const retorno = await super.visitarExpressaoRetornar(declaracao);
+        // O escopo atual é marcado como finalizado, para notificar a
+        // instrução de que deve ser descartado.
+        const escopoAtual = this.pilhaEscoposExecucao.topoDaPilha();
+        escopoAtual.finalizado = true;
+        // Acha o primeiro escopo de função.
+        const escopoFuncao = this.pilhaEscoposExecucao.obterEscopoPorTipo('funcao');
+        if (escopoFuncao === undefined) {
+            return Promise.reject('retorna() chamado fora de execução de função.');
+        }
+        if (escopoFuncao.idChamada !== undefined) {
+            escopoAtual.ambiente.resolucoesChamadas[escopoFuncao.idChamada] =
+                retorno && retorno.hasOwnProperty('valor') ? retorno.valor : retorno;
+        }
+        return retorno;
     }
     /**
      * Se bloco de execução já foi instanciado antes (por exemplo, quando há um ponto de parada e a
@@ -44,6 +139,7 @@ class InterpretadorComDepuracao extends interpretador_1.Interpretador {
      * @param ambiente O ambiente de execução quando houver, como parâmetros, argumentos, etc.
      */
     async executarBloco(declaracoes, ambiente) {
+        // Se o escopo atual não é o último.
         if (this.escopoAtual < this.pilhaEscoposExecucao.elementos() - 1) {
             this.escopoAtual++;
             const proximoEscopo = this.pilhaEscoposExecucao.naPosicao(this.escopoAtual);
@@ -59,25 +155,26 @@ class InterpretadorComDepuracao extends interpretador_1.Interpretador {
                     break;
                 }
                 retornoExecucao = await this.executar(proximoEscopo.declaracoes[proximoEscopo.declaracaoAtual]);
+                // Um ponto de parada ativo pode ter vindo de um escopo mais interno.
+                // Por isso verificamos outra parada aqui para evitar que 
+                // `this.declaracaoAtual` seja incrementado.
+                if (this.pontoDeParadaAtivo) {
+                    break;
+                }
             }
             this.pilhaEscoposExecucao.removerUltimo();
             this.escopoAtual--;
             return retornoExecucao;
         }
         else {
-            const escopoExecucao = {
-                declaracoes: declaracoes,
-                declaracaoAtual: 0,
-                ambiente: ambiente || new espaco_variaveis_1.EspacoVariaveis(),
-            };
-            this.pilhaEscoposExecucao.empilhar(escopoExecucao);
-            this.escopoAtual++;
-            if (this.comandoProximo) {
-                // Quando o comando for 'próximo', não executa.
-                // Aguarda o usuário com a próxima instrução vinda do depurador.
-                return null;
+            this.abrirNovoBlocoEscopo(declaracoes, ambiente, this.proximoEscopo || 'outro');
+            const ultimoEscopo = this.pilhaEscoposExecucao.topoDaPilha();
+            if (this.idChamadaAtual) {
+                ultimoEscopo.idChamada = this.idChamadaAtual;
+                this.idChamadaAtual = undefined;
             }
-            if (!this.comandoAdentrarEscopo) {
+            this.proximoEscopo = undefined;
+            if (this.comando !== 'adentrarEscopo') {
                 return await this.executarUltimoEscopo();
             }
         }
@@ -91,11 +188,68 @@ class InterpretadorComDepuracao extends interpretador_1.Interpretador {
         const buscaPontoParada = this.pontosParada.filter((p) => p.hashArquivo === declaracao.hashArquivo &&
             p.linha === declaracao.linha);
         if (buscaPontoParada.length > 0) {
-            console.log('Ponto de parada encontrado.');
+            console.log(`Ponto de parada encontrado. Linha: ${declaracao.linha}.`);
             return true;
         }
         return false;
     }
+    /**
+     * No interpretador com depuração, este método é dividido em dois outros métodos privados:
+     * - `this.executarUmPassoNoEscopo`, que executa apenas uma instrução e nada mais;
+     * - `this.executarUltimoEscopoComandoContinuar`, que é a execução trivial de um escopo inteiro,
+     *      ou com todas as instruções, ou até encontrar um ponto de parada.
+     * @param manterAmbiente Se verdadeiro, junta elementos do último escopo com o escopo
+     *                       imediatamente abaixo.
+     * @param naoVerificarPrimeiraExecucao Booleano que pede ao Interpretador para não
+     *                                     verificar o ponto de parada na primeira execução.
+     *                                     Normalmente usado pelo Servidor de Depuração para continuar uma linha.
+     * @returns O retorno da execução.
+     */
+    async executarUltimoEscopo(manterAmbiente = false, naoVerificarPrimeiraExecucao = false) {
+        switch (this.comando) {
+            case 'adentrarEscopo':
+            case 'proximo':
+                if (!this.executandoChamada) {
+                    return this.executarUmPassoNoEscopo();
+                }
+                else {
+                    return this.executarUltimoEscopoComandoContinuar(manterAmbiente, naoVerificarPrimeiraExecucao);
+                }
+            default:
+                return this.executarUltimoEscopoComandoContinuar(manterAmbiente, naoVerificarPrimeiraExecucao);
+        }
+    }
+    async executarUmPassoNoEscopo() {
+        const ultimoEscopo = this.pilhaEscoposExecucao.topoDaPilha();
+        let retornoExecucao;
+        if (this.passos > 0) {
+            this.passos--;
+            retornoExecucao = await this.executar(ultimoEscopo.declaracoes[ultimoEscopo.declaracaoAtual]);
+            if (!this.pontoDeParadaAtivo) {
+                ultimoEscopo.declaracaoAtual++;
+            }
+            if (ultimoEscopo.declaracaoAtual >= ultimoEscopo.declaracoes.length || ultimoEscopo.finalizado) {
+                let outroEscopo = this.pilhaEscoposExecucao.topoDaPilha();
+                if (retornoExecucao instanceof quebras_1.RetornoQuebra) {
+                    while (outroEscopo.tipo !== 'funcao') {
+                        this.pilhaEscoposExecucao.removerUltimo();
+                        const escopoAnterior = this.pilhaEscoposExecucao.topoDaPilha();
+                        escopoAnterior.ambiente.resolucoesChamadas = Object.assign(escopoAnterior.ambiente.resolucoesChamadas, outroEscopo.ambiente.resolucoesChamadas);
+                        this.escopoAtual--;
+                        outroEscopo = this.pilhaEscoposExecucao.topoDaPilha();
+                    }
+                }
+                this.pilhaEscoposExecucao.removerUltimo();
+                const escopoAnterior = this.pilhaEscoposExecucao.topoDaPilha();
+                escopoAnterior.ambiente.resolucoesChamadas = Object.assign(escopoAnterior.ambiente.resolucoesChamadas, outroEscopo.ambiente.resolucoesChamadas);
+                this.escopoAtual--;
+            }
+            if (this.pilhaEscoposExecucao.elementos() === 1) {
+                this.finalizacaoDaExecucao();
+            }
+        }
+        return retornoExecucao;
+    }
     /**
      * Continua a interpretação parcial do último ponto em que parou.
      * Pode ser tanto o começo da execução inteira, ou pós comando do depurador
@@ -107,10 +261,10 @@ class InterpretadorComDepuracao extends interpretador_1.Interpretador {
      *                                     Normalmente usado pelo Servidor de Depuração para continuar uma linha.
      * @returns Um objeto de retorno, com erros encontrados se houverem.
      */
-    async executarUltimoEscopo(manterAmbiente = false, naoVerificarPrimeiraExecucao = false) {
+    async executarUltimoEscopoComandoContinuar(manterAmbiente = false, naoVerificarPrimeiraExecucao = false) {
         const ultimoEscopo = this.pilhaEscoposExecucao.topoDaPilha();
+        let retornoExecucao;
         try {
-            let retornoExecucao;
             for (; !(retornoExecucao instanceof quebras_1.Quebra) &&
                 ultimoEscopo.declaracaoAtual < ultimoEscopo.declaracoes.length; ultimoEscopo.declaracaoAtual++) {
                 if (naoVerificarPrimeiraExecucao) {
@@ -123,14 +277,21 @@ class InterpretadorComDepuracao extends interpretador_1.Interpretador {
                     }
                 }
                 retornoExecucao = await this.executar(ultimoEscopo.declaracoes[ultimoEscopo.declaracaoAtual]);
+                // Um ponto de parada ativo pode ter vindo de um escopo mais interno.
+                // Por isso verificamos outra parada aqui para evitar que 
+                // `this.declaracaoAtual` seja incrementado.
+                if (this.pontoDeParadaAtivo) {
+                    break;
+                }
             }
             return retornoExecucao;
         }
         finally {
-            if (!this.pontoDeParadaAtivo) {
+            if (!this.pontoDeParadaAtivo && this.comando !== 'adentrarEscopo') {
                 this.pilhaEscoposExecucao.removerUltimo();
+                const escopoAnterior = this.pilhaEscoposExecucao.topoDaPilha();
+                escopoAnterior.ambiente.resolucoesChamadas = Object.assign(escopoAnterior.ambiente.resolucoesChamadas, ultimoEscopo.ambiente.resolucoesChamadas);
                 if (manterAmbiente) {
-                    const escopoAnterior = this.pilhaEscoposExecucao.topoDaPilha();
                     escopoAnterior.ambiente.valores = Object.assign(escopoAnterior.ambiente.valores, ultimoEscopo.ambiente.valores);
                 }
                 this.escopoAtual--;
@@ -148,45 +309,15 @@ class InterpretadorComDepuracao extends interpretador_1.Interpretador {
      * Diferentemente de `executarUltimoEscopo`, este método descarta apenas um escopo (o que foi chamado).
      * @see executarBloco
      */
-    async continuarInterpretacao() {
-        this.escopoAtual = 1;
-        const primeiroEscopo = this.pilhaEscoposExecucao.naPosicao(1);
-        let retornoExecucao;
-        // Primeira execução sempre ocorre, independente de pontos de parada.
-        retornoExecucao = await this.executar(primeiroEscopo.declaracoes[primeiroEscopo.declaracaoAtual]);
-        primeiroEscopo.declaracaoAtual++;
-        for (; !(retornoExecucao instanceof quebras_1.Quebra) &&
-            primeiroEscopo.declaracaoAtual < primeiroEscopo.declaracoes.length; primeiroEscopo.declaracaoAtual++) {
-            this.pontoDeParadaAtivo = this.verificarPontoParada(primeiroEscopo.declaracoes[primeiroEscopo.declaracaoAtual]);
-            if (this.pontoDeParadaAtivo) {
-                break;
-            }
-            retornoExecucao = await this.executar(primeiroEscopo.declaracoes[primeiroEscopo.declaracaoAtual]);
-        }
-        if (primeiroEscopo.declaracaoAtual >= primeiroEscopo.declaracoes.length) {
-            this.pilhaEscoposExecucao.removerUltimo();
-        }
-        if (this.pilhaEscoposExecucao.elementos() === 1) {
-            this.finalizacaoDaExecucao();
-        }
+    async instrucaoContinuarInterpretacao() {
+        this.executarUltimoEscopoComandoContinuar(false, true);
     }
-    descartarEscoposFinalizados(numeroEscopo, escopoVisitado) {
-        // Se última instrução do escopo atual foi executada, e
-        // escopos adicionais não foram criados com a última execução,
-        // descartar este e todos os escopos abaixo deste que também estejam na última instrução.
-        if (escopoVisitado.declaracoes.length ==
-            escopoVisitado.declaracaoAtual &&
-            numeroEscopo == this.pilhaEscoposExecucao.pilha.length - 1) {
-            let numeroEscopoAtual = numeroEscopo;
-            while (numeroEscopoAtual > 0) {
-                const escopo = this.pilhaEscoposExecucao.pilha[numeroEscopoAtual];
-                if (escopo.declaracoes.length == escopo.declaracaoAtual) {
-                    this.pilhaEscoposExecucao.removerUltimo();
-                    this.escopoAtual--;
-                }
-                numeroEscopoAtual--;
-            }
-        }
+    /**
+     * Empilha um escopo se for possível.
+     * Se não for, apenas executa a instrução corrente.
+     */
+    async adentrarEscopo() {
+        throw new Error('Método não implementado.');
     }
     /**
      * Interpreta apenas uma instrução a partir do ponto de parada ativo, conforme comando do depurador.
@@ -194,28 +325,20 @@ class InterpretadorComDepuracao extends interpretador_1.Interpretador {
      * primeiro escopo, subindo até o último elemento executado do último escopo.
      * @param escopo Indica o escopo a ser visitado. Usado para construir uma pilha de chamadas do lado JS.
      */
-    async interpretarApenasUmaInstrucao(escopo = 1) {
+    async instrucaoPasso(escopo = 1) {
+        this.passos = 1;
         const escopoVisitado = this.pilhaEscoposExecucao.naPosicao(escopo);
+        if (escopoVisitado.declaracaoAtual >= escopoVisitado.declaracoes.length || escopoVisitado.finalizado) {
+            this.pilhaEscoposExecucao.removerUltimo();
+        }
+        if (this.pilhaEscoposExecucao.elementos() === 1) {
+            return this.finalizacaoDaExecucao();
+        }
         if (escopo < this.escopoAtual) {
-            this.interpretarApenasUmaInstrucao(escopo + 1);
+            this.instrucaoPasso(escopo + 1);
         }
         else {
-            const declaracaoAtual = escopoVisitado.declaracoes[escopoVisitado.declaracaoAtual];
-            await this.executar(declaracaoAtual);
-            if (this.comandoAdentrarEscopo) {
-                // Depurador comandou instrução 'adentrar-escopo', ou bloco de escopo
-                // não é de uma função.
-                // Instrução só foi realmente executada se não abriu novo bloco de escopo.
-                // Por isso, `declaracaoAtual` não deve ser incrementada aqui.
-                this.comandoAdentrarEscopo = false;
-            }
-            else {
-                escopoVisitado.declaracaoAtual++;
-            }
-            this.descartarEscoposFinalizados(escopo, escopoVisitado);
-        }
-        if (this.pilhaEscoposExecucao.elementos() === 1) {
-            this.finalizacaoDaExecucao();
+            await this.executarUmPassoNoEscopo();
         }
     }
     /**
@@ -223,30 +346,8 @@ class InterpretadorComDepuracao extends interpretador_1.Interpretador {
      * Se houver outros pontos de parada no mesmo escopo à frente da instrução atual, todos são ignorados.
      * @param escopo Indica o escopo a ser visitado. Usado para construir uma pilha de chamadas do lado JS.
      */
-    async proximoESair(escopo = 1) {
-        const escopoVisitado = this.pilhaEscoposExecucao.naPosicao(escopo);
-        if (escopo < this.escopoAtual - 1) {
-            this.proximoESair(escopo + 1);
-        }
-        else {
-            const ultimoEscopo = this.pilhaEscoposExecucao.topoDaPilha();
-            let retornoExecucao;
-            for (; !(retornoExecucao instanceof quebras_1.Quebra) &&
-                ultimoEscopo.declaracaoAtual < ultimoEscopo.declaracoes.length; ultimoEscopo.declaracaoAtual++) {
-                retornoExecucao = await this.executar(ultimoEscopo.declaracoes[ultimoEscopo.declaracaoAtual]);
-            }
-            this.pilhaEscoposExecucao.removerUltimo();
-            this.escopoAtual--;
-            escopoVisitado.declaracaoAtual++;
-        }
-        // Se última instrução do escopo atual foi executada, descartar escopo.
-        if (escopoVisitado.declaracoes.length <= escopoVisitado.declaracaoAtual) {
-            this.pilhaEscoposExecucao.removerUltimo();
-            this.escopoAtual--;
-        }
-        if (this.pilhaEscoposExecucao.elementos() === 1) {
-            this.finalizacaoDaExecucao();
-        }
+    async instrucaoProximoESair() {
+        this.executarUltimoEscopoComandoContinuar(false, true);
     }
     /**
      * Prepara a pilha de escopos para uma situação de depuração.
@@ -255,17 +356,31 @@ class InterpretadorComDepuracao extends interpretador_1.Interpretador {
      */
     prepararParaDepuracao(declaracoes) {
         this.declaracoes = declaracoes;
+        this.abrirNovoBlocoEscopo(declaracoes);
+    }
+    abrirNovoBlocoEscopo(declaracoes, ambiente, tipoEscopo = 'outro') {
         const escopoExecucao = {
             declaracoes: declaracoes,
             declaracaoAtual: 0,
-            ambiente: new espaco_variaveis_1.EspacoVariaveis(),
+            ambiente: ambiente || new espaco_variaveis_1.EspacoVariaveis(),
+            finalizado: false,
+            tipo: tipoEscopo
         };
         this.pilhaEscoposExecucao.empilhar(escopoExecucao);
         this.escopoAtual++;
     }
     /**
-     * Interpretação utilizada pelo depurador. Pode encerrar ao encontrar um
-     * ponto de parada ou não.
+     * Reimplementando este método aqui porque a execução por depuração não requer
+     * mostrar o resultado em momento algum, ou lidar com o retorno.
+     * @param declaracao A declaracao a ser executada.
+     * @param mostrarResultado Sempre falso.
+     * @returns O resultado da execução.
+     */
+    async executar(declaracao, mostrarResultado = false) {
+        return await declaracao.aceitar(this);
+    }
+    /**
+     * Interpretação utilizada pelo depurador para avaliar valores de variáveis.
      * Diferentemente da interpretação tradicional, não possui indicadores
      * de performance porque eles não fazem sentido aqui.
      * @param declaracoes Um vetor de declarações.
@@ -274,21 +389,33 @@ class InterpretadorComDepuracao extends interpretador_1.Interpretador {
     async interpretar(declaracoes, manterAmbiente = false) {
         this.erros = [];
         this.declaracoes = declaracoes;
-        const escopoExecucao = {
-            declaracoes: declaracoes,
-            declaracaoAtual: 0,
-            ambiente: new espaco_variaveis_1.EspacoVariaveis(),
-        };
-        this.pilhaEscoposExecucao.empilhar(escopoExecucao);
-        this.escopoAtual++;
-        await this.executarUltimoEscopo(manterAmbiente);
+        this.abrirNovoBlocoEscopo(declaracoes);
+        const resultado = await super.executarUltimoEscopo(manterAmbiente);
+        // Corrigir contador de escopos
+        this.escopoAtual--;
         const retorno = {
             erros: this.erros,
-            resultado: this.resultadoInterpretador,
+            // resultado: this.resultadoInterpretador // Removido para simplificar `this.executar()`.
+            resultado: [resultado]
         };
         this.resultadoInterpretador = [];
         return retorno;
     }
+    /**
+     * Obtém o valor de uma variável por nome.
+     * Em versões anteriores, o mecanismo de avaliação fazia toda a avaliação tradicional,
+     * passando por Lexador, Avaliador Sintático e Interpretador.
+     * Isso tem sua cota de problemas, sobretudo porque a avaliação insere e descarta escopos,
+     * entrando em condição de corrida com a interpretação com depuração.
+     * @param nome O nome da variável.
+     */
+    obterVariavel(nome) {
+        const valorOuVariavel = this.pilhaEscoposExecucao.obterValorVariavel({ lexema: nome });
+        return valorOuVariavel.hasOwnProperty('valor') ? valorOuVariavel : {
+            valor: valorOuVariavel,
+            tipo: (0, inferenciador_1.inferirTipoVariavel)(valorOuVariavel)
+        };
+    }
 }
 exports.InterpretadorComDepuracao = InterpretadorComDepuracao;
 //# sourceMappingURL=interpretador-com-depuracao.js.map