@designliquido/delegua 0.43.5 → 0.44.0

package/bin/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@designliquido/delegua",
-    "version": "0.43.4",
+    "version": "0.43.5",
     "description": "Linguagem de programação simples e moderna usando português estruturado.",
     "main": "index.js",
     "types": "index.d.ts",

package/interfaces/interpretador-com-depuracao-interface.d.ts

@@ -1,5 +1,6 @@
 import { Declaracao } from '../declaracoes';
 import { PontoParada } from '../depuracao';
+import { TipoEscopoExecucao } from './escopo-execucao';
 import { InterpretadorInterface } from './interpretador-interface';
 export type ComandoDepurador = 'proximo' | 'adentrarEscopo' | 'proximoESair' | 'continuar';
 export interface InterpretadorComDepuracaoInterface extends InterpretadorInterface {
@@ -8,11 +9,15 @@ export interface InterpretadorComDepuracaoInterface extends InterpretadorInterfa
     pontosParada: PontoParada[];
     avisoPontoParadaAtivado: Function;
     finalizacaoDaExecucao: Function;
+    escopoAtual: number;
+    executandoChamada: boolean;
+    passos: number;
+    idChamadaAtual?: string;
+    proximoEscopo?: TipoEscopoExecucao;
     adentrarEscopo(): Promise<any>;
     instrucaoPasso(): Promise<any>;
     instrucaoContinuarInterpretacao(): Promise<any>;
     instrucaoProximoESair(): Promise<any>;
     prepararParaDepuracao(declaracoes: Declaracao[]): void;
-    obterVariavel(nome: string): Promise<any>;
 }
 //# sourceMappingURL=interpretador-com-depuracao-interface.d.ts.map

package/interfaces/interpretador-com-depuracao-interface.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"interpretador-com-depuracao-interface.d.ts","sourceRoot":"","sources":["../../fontes/interfaces/interpretador-com-depuracao-interface.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAC3C,OAAO,EAAE,sBAAsB,EAAE,MAAM,2BAA2B,CAAC;AAEnE,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,gBAAgB,GAAG,cAAc,GAAG,WAAW,CAAC;AAE3F,MAAM,WAAW,kCAAmC,SAAQ,sBAAsB;IAC9E,OAAO,CAAC,EAAE,gBAAgB,CAAC;IAC3B,kBAAkB,EAAE,OAAO,CAAC;IAC5B,YAAY,EAAE,WAAW,EAAE,CAAC;IAC5B,uBAAuB,EAAE,QAAQ,CAAC;IAClC,qBAAqB,EAAE,QAAQ,CAAC;IAEhC,cAAc,IAAI,OAAO,CAAC,GAAG,CAAC,CAAC;IAC/B,cAAc,IAAI,OAAO,CAAC,GAAG,CAAC,CAAC;IAC/B,+BAA+B,IAAI,OAAO,CAAC,GAAG,CAAC,CAAC;IAChD,qBAAqB,IAAI,OAAO,CAAC,GAAG,CAAC,CAAC;IACtC,qBAAqB,CAAC,WAAW,EAAE,UAAU,EAAE,GAAG,IAAI,CAAC;IACvD,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;CAC7C"}
+{"version":3,"file":"interpretador-com-depuracao-interface.d.ts","sourceRoot":"","sources":["../../fontes/interfaces/interpretador-com-depuracao-interface.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAC3C,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,EAAE,sBAAsB,EAAE,MAAM,2BAA2B,CAAC;AAEnE,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,gBAAgB,GAAG,cAAc,GAAG,WAAW,CAAC;AAE3F,MAAM,WAAW,kCAAmC,SAAQ,sBAAsB;IAC9E,OAAO,CAAC,EAAE,gBAAgB,CAAC;IAC3B,kBAAkB,EAAE,OAAO,CAAC;IAC5B,YAAY,EAAE,WAAW,EAAE,CAAC;IAC5B,uBAAuB,EAAE,QAAQ,CAAC;IAClC,qBAAqB,EAAE,QAAQ,CAAC;IAChC,WAAW,EAAE,MAAM,CAAC;IACpB,iBAAiB,EAAE,OAAO,CAAC;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,aAAa,CAAC,EAAE,kBAAkB,CAAC;IAEnC,cAAc,IAAI,OAAO,CAAC,GAAG,CAAC,CAAC;IAC/B,cAAc,IAAI,OAAO,CAAC,GAAG,CAAC,CAAC;IAC/B,+BAA+B,IAAI,OAAO,CAAC,GAAG,CAAC,CAAC;IAChD,qBAAqB,IAAI,OAAO,CAAC,GAAG,CAAC,CAAC;IACtC,qBAAqB,CAAC,WAAW,EAAE,UAAU,EAAE,GAAG,IAAI,CAAC;CAC1D"}

package/interfaces/interpretador-interface.d.ts

@@ -15,7 +15,7 @@ export interface InterpretadorInterface extends VisitanteComumInterface {
     avaliar(expressao: Construto | Declaracao): any;
     executarBloco(declaracoes: Declaracao[], ambiente?: EspacoVariaveis): Promise<any>;
     paraTexto(objeto: any): any;
-    executar(declaracao: Declaracao, mostrarResultado: boolean): any;
+    executar(declaracao: Declaracao, mostrarResultado?: boolean): any;
     interpretar(declaracoes: Declaracao[], manterAmbiente?: boolean): Promise<RetornoInterpretador>;
 }
 //# sourceMappingURL=interpretador-interface.d.ts.map

package/interfaces/interpretador-interface.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"interpretador-interface.d.ts","sourceRoot":"","sources":["../../fontes/interfaces/interpretador-interface.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,EAAE,6BAA6B,EAAE,MAAM,oCAAoC,CAAC;AAEnF,OAAO,EAAE,oBAAoB,EAAE,MAAM,kCAAkC,CAAC;AACxE,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AAEtE,MAAM,WAAW,sBAAuB,SAAQ,uBAAuB;IACnE,KAAK,EAAE,iBAAiB,EAAE,CAAC;IAC3B,aAAa,EAAE,GAAG,CAAC;IACnB,eAAe,EAAE,QAAQ,CAAC;IAC1B,oBAAoB,EAAE,6BAA6B,CAAC;IACpD,qBAAqB,EAAE,GAAG,CAAC;IAE3B,WAAW,CAAC,MAAM,EAAE,GAAG,GAAG,OAAO,CAAC;IAClC,OAAO,CAAC,SAAS,EAAE,SAAS,GAAG,UAAU,GAAG,GAAG,CAAC;IAChD,aAAa,CAAC,WAAW,EAAE,UAAU,EAAE,EAAE,QAAQ,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IACnF,SAAS,CAAC,MAAM,EAAE,GAAG,GAAG,GAAG,CAAC;IAC5B,QAAQ,CAAC,UAAU,EAAE,UAAU,EAAE,gBAAgB,EAAE,OAAO,GAAG,GAAG,CAAC;IACjE,WAAW,CAAC,WAAW,EAAE,UAAU,EAAE,EAAE,cAAc,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAC;CACnG"}
+{"version":3,"file":"interpretador-interface.d.ts","sourceRoot":"","sources":["../../fontes/interfaces/interpretador-interface.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,EAAE,6BAA6B,EAAE,MAAM,oCAAoC,CAAC;AAEnF,OAAO,EAAE,oBAAoB,EAAE,MAAM,kCAAkC,CAAC;AACxE,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AAEtE,MAAM,WAAW,sBAAuB,SAAQ,uBAAuB;IACnE,KAAK,EAAE,iBAAiB,EAAE,CAAC;IAC3B,aAAa,EAAE,GAAG,CAAC;IACnB,eAAe,EAAE,QAAQ,CAAC;IAC1B,oBAAoB,EAAE,6BAA6B,CAAC;IACpD,qBAAqB,EAAE,GAAG,CAAC;IAE3B,WAAW,CAAC,MAAM,EAAE,GAAG,GAAG,OAAO,CAAC;IAClC,OAAO,CAAC,SAAS,EAAE,SAAS,GAAG,UAAU,GAAG,GAAG,CAAC;IAChD,aAAa,CAAC,WAAW,EAAE,UAAU,EAAE,EAAE,QAAQ,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IACnF,SAAS,CAAC,MAAM,EAAE,GAAG,GAAG,GAAG,CAAC;IAC5B,QAAQ,CAAC,UAAU,EAAE,UAAU,EAAE,gBAAgB,CAAC,EAAE,OAAO,GAAG,GAAG,CAAC;IAClE,WAAW,CAAC,WAAW,EAAE,UAAU,EAAE,EAAE,cAAc,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAC;CACnG"}

package/interpretador/depuracao/comum.d.ts

@@ -0,0 +1,88 @@
+import { Chamada, Construto } from "../../construtos";
+import { Declaracao, Enquanto, Escreva, Para, Retorna } from "../../declaracoes";
+import { InterpretadorComDepuracaoInterface } from "../../interfaces";
+import { RetornoQuebra } from "../../quebras";
+import { EspacoVariaveis } from '../../espaco-variaveis';
+import { TipoEscopoExecucao } from '../../interfaces/escopo-execucao';
+/**
+ * Quando um construto ou declaração possui id, significa que o interpretador
+ * deve resolver a avaliação e guardar seu valor até o final do escopo.
+ * Isso serve para quando a linguagem está em modo de depuração, e o contexto
+ * da execução deixa de existir com um ponto de parada, por exemplo.
+ * @param expressao A expressão a ser avaliada.
+ * @returns O resultado da avaliação.
+ */
+export declare function avaliar(interpretador: InterpretadorComDepuracaoInterface, expressao: Construto | Declaracao): Promise<any>;
+export declare function visitarExpressaoDeChamada(interpretador: InterpretadorComDepuracaoInterface, visitarExpressaoDeChamadaAncestral: (expressao: Chamada) => Promise<any>, expressao: Chamada): Promise<any>;
+export declare function visitarDeclaracaoEnquanto(interpretador: InterpretadorComDepuracaoInterface, declaracao: Enquanto): Promise<any>;
+/**
+ * Execução de uma escrita na saída configurada, que pode ser `console` (padrão) ou
+ * alguma função para escrever numa página Web.
+ * Se ponto de parada foi ativado durante a avaliação de argumentos, não escreve.
+ * @param declaracao A declaração.
+ * @returns Sempre nulo, por convenção de visita.
+ */
+export declare function visitarDeclaracaoEscreva(interpretador: InterpretadorComDepuracaoInterface, declaracao: Escreva): Promise<any>;
+export declare function visitarDeclaracaoPara(interpretador: InterpretadorComDepuracaoInterface, declaracao: Para): 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.
+ */
+export declare function visitarExpressaoRetornar(interpretador: InterpretadorComDepuracaoInterface, visitarExpressaoRetornarAncestral: (declaracao: Retorna) => Promise<any>, 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.
+ * Se bloco de execução ainda não foi instanciado, empilha declarações na pilha de escopos de execução,
+ * cria um novo ambiente e executa as declarações empilhadas.
+ * Se depurador comandou uma instrução 'adentrar-escopo', execução do bloco não ocorre, mas
+ * ponteiros de escopo e execução são atualizados.
+ * @param declaracoes Um vetor de declaracoes a ser executado.
+ * @param ambiente O ambiente de execução quando houver, como parâmetros, argumentos, etc.
+ */
+export declare function executarBloco(interpretador: InterpretadorComDepuracaoInterface, declaracoes: Declaracao[], ambiente?: EspacoVariaveis): Promise<any>;
+/**
+ * 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
+ * quando há 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 Um objeto de retorno, com erros encontrados se houverem.
+ */
+export declare function executarUltimoEscopoComandoContinuar(interpretador: InterpretadorComDepuracaoInterface, manterAmbiente?: boolean, naoVerificarPrimeiraExecucao?: boolean): Promise<any>;
+/**
+ * Continua a interpretação, conforme comando do depurador.
+ * Quando um ponto de parada é ativado, a pilha de execução do TypeScript é perdida.
+ * 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.
+ * Se entre escopos houver ponto de parada ativo, a execução é suspensa até o próximo comando
+ * do desenvolvedor.
+ * @see executarUltimoEscopo
+ */
+export declare function instrucaoContinuarInterpretacao(interpretador: InterpretadorComDepuracaoInterface, escopo?: number): 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.
+ */
+export declare function instrucaoPasso(interpretador: InterpretadorComDepuracaoInterface, escopo?: number): Promise<any>;
+export declare function abrirNovoBlocoEscopo(interpretador: InterpretadorComDepuracaoInterface, declaracoes: Declaracao[], ambiente?: EspacoVariaveis, tipoEscopo?: TipoEscopoExecucao): void;
+/**
+ * No interpretador com depuração, este método é dividido em dois outros métodos privados:
+ * - `executarUmPassoNoEscopo`, que executa apenas uma instrução e nada mais;
+ * - `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.
+ */
+export declare function executarUltimoEscopo(interpretador: InterpretadorComDepuracaoInterface, manterAmbiente?: boolean, naoVerificarPrimeiraExecucao?: boolean): Promise<any>;
+//# sourceMappingURL=comum.d.ts.map

package/interpretador/depuracao/comum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"comum.d.ts","sourceRoot":"","sources":["../../../fontes/interpretador/depuracao/comum.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,SAAS,EAAQ,MAAM,kBAAkB,CAAC;AAC5D,OAAO,EAAS,UAAU,EAAE,QAAQ,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AACxF,OAAO,EAAE,kCAAkC,EAAE,MAAM,kBAAkB,CAAC;AACtE,OAAO,EAAyC,aAAa,EAAE,MAAM,eAAe,CAAC;AACrF,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAEzD,OAAO,EAAkB,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AAyGtF;;;;;;;GAOG;AACH,wBAAsB,OAAO,CACzB,aAAa,EAAE,kCAAkC,EACjD,SAAS,EAAE,SAAS,GAAG,UAAU,GAClC,OAAO,CAAC,GAAG,CAAC,CAUd;AAED,wBAAsB,yBAAyB,CAC3C,aAAa,EAAE,kCAAkC,EACjD,kCAAkC,EAAE,CAAC,SAAS,EAAE,OAAO,KAAK,OAAO,CAAC,GAAG,CAAC,EACxE,SAAS,EAAE,OAAO,GACnB,OAAO,CAAC,GAAG,CAAC,CAYd;AAED,wBAAsB,yBAAyB,CAC3C,aAAa,EAAE,kCAAkC,EACjD,UAAU,EAAE,QAAQ,GACrB,OAAO,CAAC,GAAG,CAAC,CAoCd;AAED;;;;;;GAMG;AACH,wBAAsB,wBAAwB,CAC1C,aAAa,EAAE,kCAAkC,EACjD,UAAU,EAAE,OAAO,GACpB,OAAO,CAAC,GAAG,CAAC,CAgBd;AAED,wBAAsB,qBAAqB,CACvC,aAAa,EAAE,kCAAkC,EACjD,UAAU,EAAE,IAAI,GACjB,OAAO,CAAC,GAAG,CAAC,CA8Dd;AAED;;;;;GAKG;AACH,wBAAsB,wBAAwB,CAC1C,aAAa,EAAE,kCAAkC,EACjD,iCAAiC,EAAE,CAAC,UAAU,EAAE,OAAO,KAAK,OAAO,CAAC,GAAG,CAAC,EACxE,UAAU,EAAE,OAAO,GACpB,OAAO,CAAC,aAAa,CAAC,CAoBxB;AAED;;;;;;;;;GASG;AACH,wBAAsB,aAAa,CAC/B,aAAa,EAAE,kCAAkC,EACjD,WAAW,EAAE,UAAU,EAAE,EACzB,QAAQ,CAAC,EAAE,eAAe,GAC3B,OAAO,CAAC,GAAG,CAAC,CA0Dd;AA8ED;;;;;;;;;;GAUG;AACH,wBAAsB,oCAAoC,CACtD,aAAa,EAAE,kCAAkC,EACjD,cAAc,UAAQ,EACtB,4BAA4B,UAAQ,GACrC,OAAO,CAAC,GAAG,CAAC,CA+Dd;AAED;;;;;;;;GAQG;AACH,wBAAsB,+BAA+B,CACjD,aAAa,EAAE,kCAAkC,EACjD,MAAM,SAAI,GACX,OAAO,CAAC,GAAG,CAAC,CAWd;AAED;;;;;GAKG;AACH,wBAAsB,cAAc,CAChC,aAAa,EAAE,kCAAkC,EACjD,MAAM,SAAI,gBAqBb;AAWD,wBAAgB,oBAAoB,CAChC,aAAa,EAAE,kCAAkC,EACjD,WAAW,EAAE,UAAU,EAAE,EACzB,QAAQ,CAAC,EAAE,eAAe,EAC1B,UAAU,GAAE,kBAA4B,QAY3C;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,oBAAoB,CACtC,aAAa,EAAE,kCAAkC,EACjD,cAAc,UAAQ,EACtB,4BAA4B,UAAQ,GACrC,OAAO,CAAC,GAAG,CAAC,CAoBd"}

package/interpretador/depuracao/comum.js

@@ -0,0 +1,509 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.avaliar = avaliar;
+exports.visitarExpressaoDeChamada = visitarExpressaoDeChamada;
+exports.visitarDeclaracaoEnquanto = visitarDeclaracaoEnquanto;
+exports.visitarDeclaracaoEscreva = visitarDeclaracaoEscreva;
+exports.visitarDeclaracaoPara = visitarDeclaracaoPara;
+exports.visitarExpressaoRetornar = visitarExpressaoRetornar;
+exports.executarBloco = executarBloco;
+exports.executarUltimoEscopoComandoContinuar = executarUltimoEscopoComandoContinuar;
+exports.instrucaoContinuarInterpretacao = instrucaoContinuarInterpretacao;
+exports.instrucaoPasso = instrucaoPasso;
+exports.abrirNovoBlocoEscopo = abrirNovoBlocoEscopo;
+exports.executarUltimoEscopo = executarUltimoEscopo;
+const lodash_1 = __importDefault(require("lodash"));
+const construtos_1 = require("../../construtos");
+const quebras_1 = require("../../quebras");
+const espaco_variaveis_1 = require("../../espaco-variaveis");
+const inferenciador_1 = require("../../inferenciador");
+async function avaliarArgumentosEscreva(interpretador, argumentos) {
+    let formatoTexto = '';
+    for (const argumento of argumentos) {
+        const resultadoAvaliacao = await interpretador.avaliar(argumento);
+        let valor = (resultadoAvaliacao === null || resultadoAvaliacao === void 0 ? void 0 : resultadoAvaliacao.hasOwnProperty('valor'))
+            ? resultadoAvaliacao.valor
+            : resultadoAvaliacao;
+        formatoTexto += `${interpretador.paraTexto(valor)} `;
+    }
+    return formatoTexto.trimEnd();
+}
+/**
+ * Resolve problema de literais que tenham vírgulas, e confundem a resolução de chamadas.
+ * @param valor O valor do argumento, que pode ser um literal com virgulas.
+ * @returns Uma string com vírgulas escapadas.
+ */
+function escaparVirgulas(valor) {
+    return String(valor).replace(/,/i, ',');
+}
+/**
+ * Gera um identificador para resolução de chamadas.
+ * Usado para não chamar funções repetidamente quando usando instruções
+ * de passo, como "próximo" ou "adentrar-escopo".
+ * @param expressao A expressão de chamada.
+ * @returns Uma `Promise` que resolve como `string`.
+ */
+async function gerarIdResolucaoChamada(interpretador, expressao) {
+    const argumentosResolvidos = [];
+    if (expressao.argumentos && expressao.argumentos.length > 0) {
+        for (let argumento of expressao.argumentos) {
+            if (argumento instanceof construtos_1.Leia) {
+                argumentosResolvidos.push(`leia_${argumento.id}`);
+            }
+            else {
+                argumentosResolvidos.push(await interpretador.avaliar(argumento));
+            }
+        }
+    }
+    return argumentosResolvidos.reduce((acumulador, argumento) => (acumulador += `,${escaparVirgulas(argumento.hasOwnProperty('valor') ? argumento.valor : argumento)}`), expressao.id);
+}
+/**
+ * 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.
+ */
+function obterVariavel(interpretador, nome) {
+    const valorOuVariavel = interpretador.pilhaEscoposExecucao.obterValorVariavel({
+        lexema: nome,
+    });
+    return valorOuVariavel.hasOwnProperty('valor')
+        ? valorOuVariavel
+        : {
+            valor: valorOuVariavel,
+            tipo: (0, inferenciador_1.inferirTipoVariavel)(valorOuVariavel),
+        };
+}
+/**
+ * Para fins de depuração, verifica se há ponto de parada no mesmo pragma da declaração.
+ * @param declaracao A declaração a ser executada.
+ * @returns `true` quando execução deve parar. `false` caso contrário.
+ */
+function verificarPontoParada(interpretador, declaracao) {
+    const buscaPontoParada = interpretador.pontosParada.filter((p) => p.hashArquivo === declaracao.hashArquivo && p.linha === declaracao.linha);
+    if (buscaPontoParada.length > 0) {
+        console.log(`Ponto de parada encontrado. Linha: ${declaracao.linha}.`);
+        return true;
+    }
+    return false;
+}
+/**
+ * Quando um construto ou declaração possui id, significa que o interpretador
+ * deve resolver a avaliação e guardar seu valor até o final do escopo.
+ * Isso serve para quando a linguagem está em modo de depuração, e o contexto
+ * da execução deixa de existir com um ponto de parada, por exemplo.
+ * @param expressao A expressão a ser avaliada.
+ * @returns O resultado da avaliação.
+ */
+async function avaliar(interpretador, expressao) {
+    if (expressao.hasOwnProperty('id')) {
+        const escopoAtual = interpretador.pilhaEscoposExecucao.topoDaPilha();
+        const idChamadaComArgumentos = await gerarIdResolucaoChamada(interpretador, expressao);
+        if (escopoAtual.ambiente.resolucoesChamadas.hasOwnProperty(idChamadaComArgumentos)) {
+            return escopoAtual.ambiente.resolucoesChamadas[idChamadaComArgumentos];
+        }
+    }
+    return await expressao.aceitar(interpretador);
+}
+async function visitarExpressaoDeChamada(interpretador, visitarExpressaoDeChamadaAncestral, expressao) {
+    const _idChamadaComArgumentos = await gerarIdResolucaoChamada(interpretador, expressao);
+    // Usado na abertura do bloco de escopo da chamada.
+    interpretador.idChamadaAtual = _idChamadaComArgumentos;
+    interpretador.executandoChamada = true;
+    interpretador.proximoEscopo = 'funcao';
+    const retorno = await visitarExpressaoDeChamadaAncestral(expressao);
+    interpretador.executandoChamada = false;
+    const escopoAtual = interpretador.pilhaEscoposExecucao.topoDaPilha();
+    escopoAtual.ambiente.resolucoesChamadas[_idChamadaComArgumentos] = retorno;
+    return retorno;
+}
+async function visitarDeclaracaoEnquanto(interpretador, declaracao) {
+    const escopoAtual = interpretador.pilhaEscoposExecucao.topoDaPilha();
+    switch (interpretador.comando) {
+        case 'proximo':
+            if (interpretador.eVerdadeiro(await interpretador.avaliar(declaracao.condicao))) {
+                escopoAtual.emLacoRepeticao = true;
+                return interpretador.executarBloco(declaracao.corpo.declaracoes);
+            }
+            escopoAtual.emLacoRepeticao = false;
+            return null;
+        default:
+            let retornoExecucao;
+            while (!(retornoExecucao instanceof quebras_1.Quebra) &&
+                !interpretador.pontoDeParadaAtivo &&
+                interpretador.eVerdadeiro(await interpretador.avaliar(declaracao.condicao))) {
+                escopoAtual.emLacoRepeticao = true;
+                try {
+                    retornoExecucao = await interpretador.executar(declaracao.corpo);
+                    if (retornoExecucao instanceof quebras_1.SustarQuebra) {
+                        return null;
+                    }
+                    if (retornoExecucao instanceof quebras_1.ContinuarQuebra) {
+                        retornoExecucao = null;
+                    }
+                }
+                catch (erro) {
+                    return Promise.reject(erro);
+                }
+            }
+            escopoAtual.emLacoRepeticao = false;
+            return retornoExecucao;
+    }
+}
+/**
+ * Execução de uma escrita na saída configurada, que pode ser `console` (padrão) ou
+ * alguma função para escrever numa página Web.
+ * Se ponto de parada foi ativado durante a avaliação de argumentos, não escreve.
+ * @param declaracao A declaração.
+ * @returns Sempre nulo, por convenção de visita.
+ */
+async function visitarDeclaracaoEscreva(interpretador, declaracao) {
+    try {
+        const formatoTexto = await avaliarArgumentosEscreva(interpretador, declaracao.argumentos);
+        if (interpretador.pontoDeParadaAtivo) {
+            return null;
+        }
+        interpretador.funcaoDeRetorno(formatoTexto);
+        return null;
+    }
+    catch (erro) {
+        interpretador.erros.push({
+            erroInterno: erro,
+            linha: declaracao.linha,
+            hashArquivo: declaracao.hashArquivo,
+        });
+    }
+}
+async function visitarDeclaracaoPara(interpretador, declaracao) {
+    // Aqui precisamos clonar a declaração porque modificamos
+    // algumas propriedades que indicam o estado da execução dela.
+    // Por exemplo, se chamamos uma função que tem dentro dela um bloco Para,
+    // cada execução do bloco precisa de uma inicialização diferente.
+    const cloneDeclaracao = lodash_1.default.cloneDeep(declaracao);
+    const corpoExecucao = cloneDeclaracao.corpo;
+    const declaracaoInicializador = Array.isArray(cloneDeclaracao.inicializador)
+        ? declaracao.inicializador[0]
+        : declaracao.inicializador;
+    if (declaracaoInicializador !== null) {
+        await interpretador.avaliar(declaracaoInicializador);
+        // O incremento vai ao final do bloco de escopo.
+        if (cloneDeclaracao.incrementar !== null) {
+            corpoExecucao.declaracoes.push(cloneDeclaracao.incrementar);
+        }
+    }
+    cloneDeclaracao.inicializada = true;
+    const escopoAtual = interpretador.pilhaEscoposExecucao.topoDaPilha();
+    switch (interpretador.comando) {
+        case 'proximo':
+            if (cloneDeclaracao.condicao !== null &&
+                interpretador.eVerdadeiro(await interpretador.avaliar(cloneDeclaracao.condicao))) {
+                escopoAtual.emLacoRepeticao = true;
+                const resultadoBloco = interpretador.executarBloco(corpoExecucao.declaracoes);
+                return resultadoBloco;
+            }
+            escopoAtual.emLacoRepeticao = false;
+            return null;
+        default:
+            let retornoExecucao;
+            while (!(retornoExecucao instanceof quebras_1.Quebra) && !interpretador.pontoDeParadaAtivo) {
+                if (cloneDeclaracao.condicao !== null &&
+                    !interpretador.eVerdadeiro(await interpretador.avaliar(cloneDeclaracao.condicao))) {
+                    break;
+                }
+                try {
+                    retornoExecucao = await interpretador.executar(corpoExecucao);
+                    if (retornoExecucao instanceof quebras_1.SustarQuebra) {
+                        return null;
+                    }
+                    if (retornoExecucao instanceof quebras_1.ContinuarQuebra) {
+                        retornoExecucao = null;
+                    }
+                }
+                catch (erro) {
+                    return Promise.reject(erro);
+                }
+            }
+            // escopoAtual.emLacoRepeticao = false;
+            return retornoExecucao;
+    }
+}
+/**
+ * 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 function visitarExpressaoRetornar(interpretador, visitarExpressaoRetornarAncestral, declaracao) {
+    const retorno = await visitarExpressaoRetornarAncestral(declaracao);
+    // O escopo atual é marcado como finalizado, para notificar a
+    // instrução de que deve ser descartado.
+    const escopoAtual = interpretador.pilhaEscoposExecucao.topoDaPilha();
+    escopoAtual.finalizado = true;
+    // Acha o primeiro escopo de função.
+    const escopoFuncao = interpretador.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
+ * execução do código é retomada pelo depurador), retoma a execução do bloco do ponto em que havia parado.
+ * Se bloco de execução ainda não foi instanciado, empilha declarações na pilha de escopos de execução,
+ * cria um novo ambiente e executa as declarações empilhadas.
+ * Se depurador comandou uma instrução 'adentrar-escopo', execução do bloco não ocorre, mas
+ * ponteiros de escopo e execução são atualizados.
+ * @param declaracoes Um vetor de declaracoes a ser executado.
+ * @param ambiente O ambiente de execução quando houver, como parâmetros, argumentos, etc.
+ */
+async function executarBloco(interpretador, declaracoes, ambiente) {
+    // Se o escopo atual não é o último.
+    if (interpretador.escopoAtual < interpretador.pilhaEscoposExecucao.elementos() - 1) {
+        interpretador.escopoAtual++;
+        const proximoEscopo = interpretador.pilhaEscoposExecucao.naPosicao(interpretador.escopoAtual);
+        let retornoExecucao;
+        // Sempre executa a próxima instrução, mesmo que haja ponto de parada.
+        retornoExecucao = await interpretador.executar(proximoEscopo.declaracoes[proximoEscopo.declaracaoAtual]);
+        proximoEscopo.declaracaoAtual++;
+        for (; !(retornoExecucao instanceof quebras_1.Quebra) &&
+            proximoEscopo.declaracaoAtual < proximoEscopo.declaracoes.length; proximoEscopo.declaracaoAtual++) {
+            interpretador.pontoDeParadaAtivo = verificarPontoParada(interpretador, proximoEscopo.declaracoes[proximoEscopo.declaracaoAtual]);
+            if (interpretador.pontoDeParadaAtivo) {
+                interpretador.avisoPontoParadaAtivado();
+                break;
+            }
+            retornoExecucao = await interpretador.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
+            // `interpretador.declaracaoAtual` seja incrementado.
+            if (interpretador.pontoDeParadaAtivo) {
+                interpretador.avisoPontoParadaAtivado();
+                break;
+            }
+        }
+        interpretador.pilhaEscoposExecucao.removerUltimo();
+        interpretador.escopoAtual--;
+        return retornoExecucao;
+    }
+    else {
+        abrirNovoBlocoEscopo(interpretador, declaracoes, ambiente, interpretador.proximoEscopo || 'outro');
+        const ultimoEscopo = interpretador.pilhaEscoposExecucao.topoDaPilha();
+        if (interpretador.idChamadaAtual) {
+            ultimoEscopo.idChamada = interpretador.idChamadaAtual;
+            interpretador.idChamadaAtual = undefined;
+        }
+        interpretador.proximoEscopo = undefined;
+        if (interpretador.comando !== 'adentrarEscopo') {
+            return await executarUltimoEscopo(interpretador);
+        }
+    }
+}
+function descartarEscopoPorRetornoFuncao(interpretador) {
+    let ultimoEscopo = interpretador.pilhaEscoposExecucao.topoDaPilha();
+    while (ultimoEscopo.tipo !== 'funcao') {
+        interpretador.pilhaEscoposExecucao.removerUltimo();
+        const escopoAnterior = interpretador.pilhaEscoposExecucao.topoDaPilha();
+        escopoAnterior.ambiente.resolucoesChamadas = Object.assign(escopoAnterior.ambiente.resolucoesChamadas, ultimoEscopo.ambiente.resolucoesChamadas);
+        interpretador.escopoAtual--;
+        ultimoEscopo = interpretador.pilhaEscoposExecucao.topoDaPilha();
+    }
+    interpretador.pilhaEscoposExecucao.removerUltimo();
+    const escopoAnterior = interpretador.pilhaEscoposExecucao.topoDaPilha();
+    escopoAnterior.ambiente.resolucoesChamadas = Object.assign(escopoAnterior.ambiente.resolucoesChamadas, ultimoEscopo.ambiente.resolucoesChamadas);
+    interpretador.escopoAtual--;
+}
+function descartarTodosEscoposFinalizados(interpretador) {
+    let i = interpretador.pilhaEscoposExecucao.pilha.length - 1;
+    while (i > 0) {
+        let ultimoEscopo = interpretador.pilhaEscoposExecucao.topoDaPilha();
+        if (ultimoEscopo.declaracaoAtual >= ultimoEscopo.declaracoes.length ||
+            ultimoEscopo.finalizado) {
+            interpretador.pilhaEscoposExecucao.removerUltimo();
+            const escopoAnterior = interpretador.pilhaEscoposExecucao.topoDaPilha();
+            escopoAnterior.ambiente.resolucoesChamadas = Object.assign(escopoAnterior.ambiente.resolucoesChamadas, ultimoEscopo.ambiente.resolucoesChamadas);
+            interpretador.escopoAtual--;
+        }
+        else {
+            break;
+        }
+        i--;
+    }
+}
+async function executarUmPassoNoEscopo(interpretador) {
+    const ultimoEscopo = interpretador.pilhaEscoposExecucao.topoDaPilha();
+    let retornoExecucao;
+    if (interpretador.passos > 0) {
+        interpretador.passos--;
+        retornoExecucao = await interpretador.executar(ultimoEscopo.declaracoes[ultimoEscopo.declaracaoAtual]);
+        if (!interpretador.pontoDeParadaAtivo && !ultimoEscopo.emLacoRepeticao) {
+            ultimoEscopo.declaracaoAtual++;
+        }
+        if (ultimoEscopo.declaracaoAtual >= ultimoEscopo.declaracoes.length ||
+            ultimoEscopo.finalizado) {
+            if (retornoExecucao instanceof quebras_1.RetornoQuebra) {
+                descartarEscopoPorRetornoFuncao(interpretador);
+            }
+            else {
+                descartarTodosEscoposFinalizados(interpretador);
+            }
+        }
+        if (interpretador.pilhaEscoposExecucao.elementos() === 1) {
+            interpretador.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
+ * quando há 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 Um objeto de retorno, com erros encontrados se houverem.
+ */
+async function executarUltimoEscopoComandoContinuar(interpretador, manterAmbiente = false, naoVerificarPrimeiraExecucao = false) {
+    const ultimoEscopo = interpretador.pilhaEscoposExecucao.topoDaPilha();
+    let retornoExecucao;
+    try {
+        for (; !(retornoExecucao instanceof quebras_1.Quebra) &&
+            ultimoEscopo.declaracaoAtual < ultimoEscopo.declaracoes.length; ultimoEscopo.declaracaoAtual++) {
+            if (naoVerificarPrimeiraExecucao) {
+                naoVerificarPrimeiraExecucao = false;
+            }
+            else {
+                interpretador.pontoDeParadaAtivo = verificarPontoParada(interpretador, ultimoEscopo.declaracoes[ultimoEscopo.declaracaoAtual]);
+                if (interpretador.pontoDeParadaAtivo) {
+                    interpretador.avisoPontoParadaAtivado();
+                    break;
+                }
+            }
+            retornoExecucao = await interpretador.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
+            // `interpretador.declaracaoAtual` seja incrementado.
+            if (interpretador.pontoDeParadaAtivo) {
+                interpretador.avisoPontoParadaAtivado();
+                break;
+            }
+        }
+        return retornoExecucao;
+    }
+    catch (erro) {
+        interpretador.erros.push(erro);
+    }
+    finally {
+        if (!interpretador.pontoDeParadaAtivo && interpretador.comando !== 'adentrarEscopo') {
+            interpretador.pilhaEscoposExecucao.removerUltimo();
+            const escopoAnterior = interpretador.pilhaEscoposExecucao.topoDaPilha();
+            escopoAnterior.ambiente.resolucoesChamadas = Object.assign(escopoAnterior.ambiente.resolucoesChamadas, ultimoEscopo.ambiente.resolucoesChamadas);
+            if (manterAmbiente) {
+                escopoAnterior.ambiente.valores = Object.assign(escopoAnterior.ambiente.valores, ultimoEscopo.ambiente.valores);
+            }
+            interpretador.escopoAtual--;
+        }
+        if (interpretador.pilhaEscoposExecucao.elementos() === 1) {
+            interpretador.finalizacaoDaExecucao();
+        }
+    }
+}
+/**
+ * Continua a interpretação, conforme comando do depurador.
+ * Quando um ponto de parada é ativado, a pilha de execução do TypeScript é perdida.
+ * 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.
+ * Se entre escopos houver ponto de parada ativo, a execução é suspensa até o próximo comando
+ * do desenvolvedor.
+ * @see executarUltimoEscopo
+ */
+async function instrucaoContinuarInterpretacao(interpretador, escopo = 1) {
+    let retornoExecucao;
+    if (escopo < interpretador.escopoAtual) {
+        retornoExecucao = await instrucaoContinuarInterpretacao(interpretador, escopo + 1);
+    }
+    if (interpretador.pontoDeParadaAtivo) {
+        return;
+    }
+    await executarUltimoEscopoComandoContinuar(interpretador, false, true);
+}
+/**
+ * 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.
+ */
+async function instrucaoPasso(interpretador, escopo = 1) {
+    interpretador.passos = 1;
+    const escopoVisitado = interpretador.pilhaEscoposExecucao.naPosicao(escopo);
+    if (escopo < interpretador.escopoAtual) {
+        await instrucaoPasso(interpretador, escopo + 1);
+    }
+    else {
+        if (escopoVisitado.declaracaoAtual >= escopoVisitado.declaracoes.length ||
+            escopoVisitado.finalizado) {
+            interpretador.pilhaEscoposExecucao.removerUltimo();
+        }
+        if (interpretador.pilhaEscoposExecucao.elementos() === 1) {
+            return interpretador.finalizacaoDaExecucao();
+        }
+        await executarUmPassoNoEscopo(interpretador);
+    }
+}
+/**
+ * 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.
+ */
+async function instrucaoProximoESair(interpretador) {
+    executarUltimoEscopoComandoContinuar(interpretador, false, true);
+}
+function abrirNovoBlocoEscopo(interpretador, declaracoes, ambiente, tipoEscopo = 'outro') {
+    const escopoExecucao = {
+        declaracoes: declaracoes,
+        declaracaoAtual: 0,
+        ambiente: ambiente || new espaco_variaveis_1.EspacoVariaveis(),
+        finalizado: false,
+        tipo: tipoEscopo,
+        emLacoRepeticao: false,
+    };
+    interpretador.pilhaEscoposExecucao.empilhar(escopoExecucao);
+    interpretador.escopoAtual++;
+}
+/**
+ * No interpretador com depuração, este método é dividido em dois outros métodos privados:
+ * - `executarUmPassoNoEscopo`, que executa apenas uma instrução e nada mais;
+ * - `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 function executarUltimoEscopo(interpretador, manterAmbiente = false, naoVerificarPrimeiraExecucao = false) {
+    switch (interpretador.comando) {
+        case 'adentrarEscopo':
+        case 'proximo':
+            if (!interpretador.executandoChamada) {
+                return executarUmPassoNoEscopo(interpretador);
+            }
+            else {
+                return executarUltimoEscopoComandoContinuar(interpretador, manterAmbiente, naoVerificarPrimeiraExecucao);
+            }
+        default:
+            return executarUltimoEscopoComandoContinuar(interpretador, manterAmbiente, naoVerificarPrimeiraExecucao);
+    }
+}
+//# sourceMappingURL=comum.js.map