@abaplint/transpiler 2.13.98 → 2.13.100

package/build/src/statements/select.d.ts

@@ -7,5 +7,6 @@ export declare class SelectTranspiler implements IStatementTranspiler {
     private findTable;
     private dynamicSelectList;
     private dynamicSQLClause;
+    private dynamicHavingClause;
     private isWhereExpression;
 }

package/build/src/statements/select.js

@@ -105,8 +105,18 @@ class SelectTranspiler {
         const having = node.findDirectExpression(abaplint.Expressions.Select)
             ?.findDirectExpression(abaplint.Expressions.SQLHaving);
         const havingCond = having?.findFirstExpression(abaplint.Expressions.SQLCond);
+        let dynamicHaving;
         if (havingCond) {
-            select += "HAVING " + new expressions_1.SQLCondTranspiler().transpile(havingCond, traversal, table).getCode() + " ";
+            const dynamic = havingCond.findFirstExpression(abaplint.Expressions.Dynamic);
+            const chain = dynamic?.findFirstExpression(abaplint.Expressions.FieldChain);
+            if (chain && havingCond.concatTokens() === dynamic?.concatTokens()) {
+                dynamicHaving = dynamic;
+                const code = new expressions_1.FieldChainTranspiler(false).transpile(chain, traversal).getCode();
+                select += `" + ${this.dynamicHavingClause(code)} + " `;
+            }
+            else {
+                select += "HAVING " + new expressions_1.SQLCondTranspiler().transpile(havingCond, traversal, table).getCode() + " ";
+            }
         }
         const upTo = node.findFirstExpression(abaplint.Expressions.SQLUpTo);
         if (upTo) {
@@ -126,6 +136,9 @@ class SelectTranspiler {
         const groupByDynamics = new Set(groupBy?.findAllExpressionsRecursive(abaplint.Expressions.Dynamic) || []);
         const orderByDynamics = new Set(orderBy?.findAllExpressionsRecursive(abaplint.Expressions.Dynamic) || []);
         for (const d of node.findAllExpressionsRecursive(abaplint.Expressions.Dynamic)) {
+            if (d === dynamicHaving) {
+                continue;
+            }
             const chain = d.findFirstExpression(abaplint.Expressions.FieldChain);
             if (chain) {
                 const search = d.concatTokens();
@@ -282,6 +295,13 @@ abap.builtin.sy.get().dbcnt.set(${target}.getArrayLength());
             + ` ? (${code}.array().length === 0 ? "" : "${keyword} " + ${code}.array().map(row => row.get()).join(", "))`
             + ` : (("" + ${code}.get()).trim() === "" ? "" : "${keyword} " + ${code}.get()))`;
     }
+    dynamicHavingClause(code) {
+        return `((value) => {
+const condition = value instanceof abap.types.Table || value instanceof abap.types.HashedTable
+  ? value.array().map(row => row.get()).join(" ") : value.get();
+return condition.trim() === "" ? "" : "HAVING " + abap.expandDynamic(condition, (name) => {try { return eval(name);} catch {}});
+})(${code})`;
+    }
     isWhereExpression(node, expression) {
         // check if previous token before sqlCond is "WHERE". It could also be "ON" in case of join condition
         let prevToken;

package/build/src/traversal.d.ts

@@ -15,6 +15,10 @@ export declare class Traversal {
     private readonly doOrWhileIndexBackups;
     private readonly statementsInsideLoop;
     private readonly enclosingDoOrWhile;
+    /** DATA, CONSTANTS and FIELD-SYMBOLS nested in blocks, already declared in front of the block */
+    private readonly declaredEarly;
+    private emittingEarly;
+    private blockDepth;
     readonly reg: abaplint.IRegistry;
     readonly options: ITranspilerOptions | undefined;
     constructor(spaghetti: abaplint.ISpaghettiScope, file: abaplint.ABAPFile, obj: abaplint.ABAPObject, reg: abaplint.IRegistry, options?: ITranspilerOptions);
@@ -106,6 +110,15 @@ export declare class Traversal {
     buildInternalName(name: string, def: abaplint.IClassDefinition | abaplint.IInterfaceDefinition | undefined): string;
     lookupClassOrInterface(name: string | undefined, token: abaplint.Token | undefined, directGlobal?: boolean): string;
     buildPrefix(): string;
+    /** In ABAP, DATA, CONSTANTS and FIELD-SYMBOLS are visible in the whole method/form/program, but a
+     * javascript "let" inside the block of an IF, LOOP, TRY etc. is not. So before each block on
+     * method/form/program level the declarations nested in it are output, in source order, and
+     * skipped inside the block. They then exist after the block even if the branch did not run,
+     * and are initialized once, also when the block is a loop */
+    private traverseProcedureLevel;
+    private declareNestedEarly;
+    private static isDeclaration;
+    private static findNestedDeclarations;
     protected traverseStructure(node: abaplint.Nodes.StructureNode): Chunk;
     protected traverseStatement(node: abaplint.Nodes.StatementNode): Chunk;
     protected traverseExpression(node: abaplint.Nodes.ExpressionNode): Chunk;

package/build/src/traversal.js

@@ -88,6 +88,10 @@ class Traversal {
     doOrWhileIndexBackups = new Map();
     statementsInsideLoop = new WeakSet();
     enclosingDoOrWhile = new WeakMap();
+    /** DATA, CONSTANTS and FIELD-SYMBOLS nested in blocks, already declared in front of the block */
+    declaredEarly = new WeakSet();
+    emittingEarly = false;
+    blockDepth = 0;
     reg;
     options;
     constructor(spaghetti, file, obj, reg, options) {
@@ -926,17 +930,15 @@ this.INTERNAL_ID = abap.internalIdCounter++;\n`;
             }
             else if (c.get() instanceof abaplint.Expressions.AttributeName
                 && context instanceof abaplint.BasicTypes.ObjectReferenceType) {
-                const id = context.getIdentifier();
-                if (id instanceof abaplint.Types.ClassDefinition || id instanceof abaplint.Types.InterfaceDefinition) {
-                    const concat = c.concatTokens();
-                    if (concat.includes("~")) {
-                        const [iname, aname] = concat.split("~");
-                        const intf = this.findInterfaceDefinition(iname, scope);
-                        context = intf?.getAttributes().findByName(aname)?.getType();
-                    }
-                    else {
-                        context = id.getAttributes().findByName(concat)?.getType();
-                    }
+                const concat = c.concatTokens();
+                if (concat.includes("~")) {
+                    const [iname, aname] = concat.split("~");
+                    const intf = this.findInterfaceDefinition(iname, scope);
+                    context = intf?.getAttributes().findByName(aname)?.getType();
+                }
+                else {
+                    // Global references can carry an identifier rather than a class definition.
+                    context = this.narrowContextAttribute(context, concat, scope);
                 }
             }
             else if (c.get() instanceof abaplint.Expressions.AttributeName
@@ -950,7 +952,7 @@ this.INTERNAL_ID = abap.internalIdCounter++;\n`;
         return context;
     }
     isInsideLoop(node) {
-        return this.statementsInsideLoop.has(node);
+        return this.statementsInsideLoop.has(node) && !this.declaredEarly.has(node);
     }
     isInsideDoOrWhile(node) {
         return this.findCurrentDoOrWhileIndexBackup(node) !== undefined;
@@ -1045,7 +1047,87 @@ this.INTERNAL_ID = abap.internalIdCounter++;\n`;
         return this.obj.getType() + "-" + this.obj.getName() + "-";
     }
     ////////////////////////////
+    /** In ABAP, DATA, CONSTANTS and FIELD-SYMBOLS are visible in the whole method/form/program, but a
+     * javascript "let" inside the block of an IF, LOOP, TRY etc. is not. So before each block on
+     * method/form/program level the declarations nested in it are output, in source order, and
+     * skipped inside the block. They then exist after the block even if the branch did not run,
+     * and are initialized once, also when the block is a loop */
+    traverseProcedureLevel(node) {
+        const ret = new chunk_1.Chunk();
+        for (const c of node.getChildren()) {
+            if (c instanceof abaplint.Nodes.StructureNode && Traversal.isDeclaration(c) === false) {
+                ret.appendChunk(this.declareNestedEarly(c));
+                this.blockDepth++;
+                try {
+                    ret.appendChunk(this.traverseStructure(c));
+                }
+                finally {
+                    this.blockDepth--;
+                }
+            }
+            else {
+                ret.appendChunk(this.traverse(c));
+            }
+        }
+        return ret;
+    }
+    declareNestedEarly(block) {
+        const found = [];
+        Traversal.findNestedDeclarations(block, found);
+        for (const node of found) {
+            this.declaredEarly.add(node);
+            if (node instanceof abaplint.Nodes.StructureNode) {
+                for (const statement of node.findAllStatementNodes()) {
+                    this.declaredEarly.add(statement);
+                }
+            }
+        }
+        const ret = new chunk_1.Chunk();
+        this.emittingEarly = true;
+        try {
+            for (const node of found) {
+                ret.appendChunk(this.traverse(node));
+            }
+        }
+        finally {
+            this.emittingEarly = false;
+        }
+        return ret;
+    }
+    static isDeclaration(node) {
+        const get = node.get();
+        return get instanceof abaplint.Structures.Data
+            || get instanceof abaplint.Structures.Constants
+            || get instanceof abaplint.Structures.Types;
+    }
+    static findNestedDeclarations(node, found) {
+        for (const c of node.getChildren()) {
+            if (c instanceof abaplint.Nodes.StatementNode) {
+                const get = c.get();
+                if (get instanceof abaplint.Statements.Data
+                    || get instanceof abaplint.Statements.Constant
+                    || get instanceof abaplint.Statements.FieldSymbol) {
+                    found.push(c);
+                }
+            }
+            else if (c instanceof abaplint.Nodes.StructureNode) {
+                const get = c.get();
+                if (get instanceof abaplint.Structures.Data || get instanceof abaplint.Structures.Constants) {
+                    found.push(c);
+                }
+                else {
+                    Traversal.findNestedDeclarations(c, found);
+                }
+            }
+        }
+    }
     traverseStructure(node) {
+        if (this.declaredEarly.has(node) && this.emittingEarly === false) {
+            return new chunk_1.Chunk();
+        }
+        else if (this.blockDepth === 0 && node.get() instanceof abaplint.Structures.Normal) {
+            return this.traverseProcedureLevel(node);
+        }
         const list = StructureTranspilers;
         const ret = new chunk_1.Chunk();
         const search = node.get().constructor.name + "Transpiler";
@@ -1068,6 +1150,9 @@ this.INTERNAL_ID = abap.internalIdCounter++;\n`;
         return ret;
     }
     traverseStatement(node) {
+        if (this.declaredEarly.has(node) && this.emittingEarly === false) {
+            return new chunk_1.Chunk();
+        }
         const list = StatementTranspilers;
         const search = node.get().constructor.name + "Transpiler";
         if (list[search]) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abaplint/transpiler",
-  "version": "2.13.98",
+  "version": "2.13.100",
   "description": "Transpiler",
   "main": "build/src/index.js",
   "typings": "build/src/index.d.ts",
@@ -29,7 +29,7 @@
   "author": "abaplint",
   "license": "MIT",
   "dependencies": {
-    "@abaplint/core": "^2.120.66",
+    "@abaplint/core": "^2.120.69",
     "source-map": "^0.8.0"
   },
   "devDependencies": {