@designliquido/delegua 1.17.1 → 1.17.2

package/interpretador/dialetos/egua-classico/interpretador-egua-classico.d.ts

@@ -54,7 +54,7 @@ export declare class InterpretadorEguaClassico implements InterpretadorInterface
     visitarExpressaoFormatacaoEscrita(declaracao: FormatacaoEscrita): never;
     visitarDeclaracaoEscrevaMesmaLinha(declaracao: EscrevaMesmaLinha): never;
     visitarExpressaoLeia(expressao: Leia): Promise<any>;
-    visitarExpressaoLiteral(expressao: Literal): Promise<import("../../../construtos").ValorLiteral>;
+    visitarExpressaoLiteral(expressao: Literal): Promise<import("../../..").ValorLiteral>;
     avaliar(expressao: Construto | Declaracao): VariavelInterface | any;
     visitarExpressaoAgrupamento(expressao: any): any;
     eVerdadeiro(objeto: any): boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@designliquido/delegua",
-    "version": "1.17.1",
+    "version": "1.17.2",
     "description": "Linguagem de programação simples e moderna usando português estruturado.",
     "main": "index.js",
     "types": "index.d.ts",
@@ -107,7 +107,7 @@
         "ts-jest": "^29.3.0",
         "ts-node": "^10.9.2",
         "typedoc": "^0.28.1",
-        "typescript": "^5.8.2"
+        "typescript": "^6.0.2"
     },
     "dependencies": {
         "antlr4ts": "^0.5.0-alpha.4",

package/umd/delegua.js

@@ -641,10 +641,16 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
     }
     visitarChamadaPorVariavel(entidadeChamadaVariavel, argumentos) {
         const variavel = entidadeChamadaVariavel;
-        const funcaoChamada = this.gerenciadorEscopos.buscar(variavel.simbolo.lexema) ||
-            this.funcoes[variavel.simbolo.lexema];
+        const nomeFuncao = variavel.simbolo.lexema;
+        const funcoesNativas = ['inteiro', 'real', 'numero', 'número', 'texto', 'leia', 'escreva', 'tipo'];
+        const pareceSerClasse = nomeFuncao[0] === nomeFuncao[0].toUpperCase();
+        if (funcoesNativas.includes(nomeFuncao) || pareceSerClasse) {
+            return Promise.resolve();
+        }
+        const funcaoChamada = this.gerenciadorEscopos.buscar(nomeFuncao) ||
+            this.funcoes[nomeFuncao];
         if (!funcaoChamada) {
-            this.erro(entidadeChamadaVariavel.simbolo, `Chamada da função '${entidadeChamadaVariavel.simbolo.lexema}' não existe.`);
+            this.erro(entidadeChamadaVariavel.simbolo, `Chamada da função '${nomeFuncao}' não existe.`);
             return Promise.resolve();
         }
         const funcao = funcaoChamada.valor;
@@ -3386,6 +3392,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         const caminhoFazer = await this.declaracaoBloco();
         this.consumir(delegua_2.default.ENQUANTO, "Esperado declaração do 'enquanto' após o escopo do 'fazer'.");
         const condicaoEnquanto = await this.expressao();
+        this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA);
         return {
             caminhoFazer,
             condicaoEnquanto,
@@ -6188,6 +6195,37 @@ class AvaliadorSintaticoPitugues {
         }
         return false;
     }
+    /**
+     * Transforma uma string com interpolações (f-string) em código equivalente usando o método formatar.
+     * Exemplo: f"Olá {nome}, você tem {idade} anos" -> "Olá " + nome + " você tem " + idade + " anos"
+     * Com formatadores: f"{valor:.2f}" -> "" + "{:.2f}".formatar(valor) + ""
+     * Com depuração: f"{usuario=}" -> "" + "{usuario=}".formatar(usuario) + ""
+     */
+    transformarInterpolacaoEmFormatacao(conteudoOriginal) {
+        const ehDepuracao = (mioloLimpo) => {
+            return mioloLimpo.endsWith('=') && !/^(?:[!=<>]=|[<>])$/.test(mioloLimpo.slice(-2));
+        };
+        const processarParte = (_, miolo) => {
+            const mioloLimpo = miolo.trimEnd();
+            // Modo depuração: {expressao=}
+            if (ehDepuracao(mioloLimpo)) {
+                const expressao = mioloLimpo.slice(0, -1).trim();
+                return `" + "{${miolo}}".formatar(${expressao}) + "`;
+            }
+            // Modo formatação: {expressao:formato}
+            if (mioloLimpo.includes(':')) {
+                const [variavel, formato] = mioloLimpo
+                    .split(':')
+                    .map(s => s.trim());
+                if (variavel) {
+                    return `" + "{:${formato}}".formatar(${variavel}) + "`;
+                }
+            }
+            // Interpolação simples: {expressao}
+            return `" + (${miolo}) + "`;
+        };
+        return '"' + conteudoOriginal.replace(/\{(.*?)\}/g, processarParte) + '"';
+    }
     async primario() {
         const simboloAtual = this.simbolos[this.atual];
         switch (simboloAtual.tipo) {
@@ -6302,19 +6340,8 @@ class AvaliadorSintaticoPitugues {
             case pitugues_2.default.INTERPOLACAO:
                 const simboloInterpolacao = this.avancarEDevolverAnterior();
                 const conteudoOriginal = simboloInterpolacao.literal;
-                const codigoTransformado = '"' +
-                    conteudoOriginal.replace(/\{(.*?)\}/g, (_, miolo) => {
-                        // 'miolo' é o texto que estava dentro das chaves. Ex: "valor" ou "valor:.2f"
-                        if (miolo.includes(':')) {
-                            const [variavel, formato] = miolo.split(':').map((s) => s.trim());
-                            if (variavel !== '') {
-                                // Transforma {valor:.2f} em "{:.2f}".formatar(valor)
-                                return '" + "{:' + formato + '}".formatar(' + variavel + ') + "';
-                            }
-                        }
-                        return '" + (' + miolo.trim() + ') + "';
-                    }) +
-                    '"';
+                const codigoTransformado = this
+                    .transformarInterpolacaoEmFormatacao(conteudoOriginal);
                 const microLexador = new micro_lexador_pitugues_1.MicroLexadorPitugues();
                 const retornoMicroLexador = microLexador.mapear(codigoTransformado);
                 const microAvaliadorSintatico = new micro_avaliador_sintatico_pitugues_1.MicroAvaliadorSintaticoPitugues();