@abaplint/transpiler 2.13.45 → 2.13.47

package/build/src/expressions/constant.d.ts

@@ -8,5 +8,6 @@ export declare class ConstantTranspiler implements IExpressionTranspiler {
     private handleInteger;
     transpile(node: Nodes.ExpressionNode, traversal: Traversal): Chunk;
     private handleCharacter;
+    static trimTextFieldLiteral(str: string): string;
     static escape(str: string): string;
 }

package/build/src/expressions/constant.js

@@ -44,7 +44,7 @@ class ConstantTranspiler {
             str = node.findDirectExpression(core_1.Expressions.TextElementString);
         }
         if (str) {
-            let res = str.getFirstToken().getStr();
+            const res = str.getFirstToken().getStr();
             if (res.startsWith("'") && this.addGet === false) {
                 const code = this.handleCharacter(res);
                 return new chunk_1.Chunk().append(code, node, traversal);
@@ -54,10 +54,7 @@ class ConstantTranspiler {
                 return new chunk_1.Chunk().append(code, node, traversal);
             }
             else {
-                if (res.startsWith("'")) {
-                    res = "'" + res.substring(1, res.length - 1).trimEnd() + "'";
-                }
-                const code = ConstantTranspiler.escape(res);
+                const code = ConstantTranspiler.escape(ConstantTranspiler.trimTextFieldLiteral(res));
                 return new chunk_1.Chunk().append(code, node, traversal);
             }
         }
@@ -98,6 +95,13 @@ class ConstantTranspiler {
         //    const code = "new abap.types.Character(" + length + ").set(" + ConstantTranspiler.escape(res) + ")";
         return code;
     }
+    // text field literals are of type c, trailing blanks are not part of the value
+    static trimTextFieldLiteral(str) {
+        if (str.startsWith("'") && str.endsWith("'") && str.length >= 2) {
+            return "'" + str.substring(1, str.length - 1).trimEnd() + "'";
+        }
+        return str;
+    }
     static escape(str) {
         str = str.replace(/\\/g, "\\\\");
         if (str.startsWith("'")) {

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

@@ -3,6 +3,21 @@ import { IStatementTranspiler } from "./_statement_transpiler";
 import { Traversal } from "../traversal";
 import { Chunk } from "../chunk";
 export declare class DataTranspiler implements IStatementTranspiler {
+    private readonly skipLoopScoping;
+    private variableName;
+    private loopScoped;
+    constructor(options?: {
+        skipLoopScoping?: boolean;
+    });
+    /** name of the declared javascript variable, set by transpile() */
+    getVariableName(): string;
+    /** set by transpile(), true if the declaration is inside a loop */
+    isLoopScoped(): boolean;
+    /** DATA is scoped to the enclosing method/form/program, but when the statement is inside a
+     * loop the generated declaration ends up inside the javascript block of the loop. Declaring
+     * with "var" hoists it out of the block, and the guard makes sure its constructed only on the
+     * first pass, ie. contents are kept across iterations, matching ABAP */
+    static wrapLoopScoped(name: string, chunk: Chunk): Chunk;
     transpile(node: abaplint.Nodes.StatementNode, traversal: Traversal): Chunk;
     static findEnumDefault(scope: abaplint.ISpaghettiScopeNode, _enumType: abaplint.AbstractType): string | undefined;
     static buildValue(node: abaplint.Nodes.StatementNode, name: string, traversal: Traversal): string;

package/build/src/statements/data.js

@@ -41,6 +41,30 @@ const constant_1 = require("../expressions/constant");
 const expressions_1 = require("../expressions");
 const chunk_1 = require("../chunk");
 class DataTranspiler {
+    skipLoopScoping;
+    variableName = "";
+    loopScoped = false;
+    constructor(options) {
+        this.skipLoopScoping = options?.skipLoopScoping === true;
+    }
+    /** name of the declared javascript variable, set by transpile() */
+    getVariableName() {
+        return this.variableName;
+    }
+    /** set by transpile(), true if the declaration is inside a loop */
+    isLoopScoped() {
+        return this.loopScoped;
+    }
+    /** DATA is scoped to the enclosing method/form/program, but when the statement is inside a
+     * loop the generated declaration ends up inside the javascript block of the loop. Declaring
+     * with "var" hoists it out of the block, and the guard makes sure its constructed only on the
+     * first pass, ie. contents are kept across iterations, matching ABAP */
+    static wrapLoopScoped(name, chunk) {
+        return new chunk_1.Chunk()
+            .appendString(`if (${name} === undefined) {\n`)
+            .appendChunk(chunk)
+            .appendString("\n}");
+    }
     transpile(node, traversal) {
         const token = node.findFirstExpression(abaplint.Expressions.DefinitionName)?.getFirstToken();
         if (token === undefined) {
@@ -68,12 +92,17 @@ class DataTranspiler {
                 value = "\n" + traversal_1.Traversal.prefixVariable(found.getName().toLowerCase()) + ".set(\"" + enumDefault + "\");";
             }
         }
+        this.variableName = traversal_1.Traversal.prefixVariable(traversal_1.Traversal.escapeNamespace(found.getName().toLowerCase()));
+        this.loopScoped = traversal.isInsideLoop(node);
         const ret = new chunk_1.Chunk()
-            .appendString("let ")
-            .appendString(traversal_1.Traversal.prefixVariable(traversal_1.Traversal.escapeNamespace(found.getName().toLowerCase())))
+            .appendString(this.loopScoped === true ? "var " : "let ")
+            .appendString(this.variableName)
             .appendString(" = " + transpile_types_1.TranspileTypes.toType(found.getType()))
             .appendString(";")
             .appendString(value);
+        if (this.loopScoped === true && this.skipLoopScoping === false) {
+            return DataTranspiler.wrapLoopScoped(this.variableName, ret);
+        }
         return ret;
     }
     static findEnumDefault(scope, _enumType) {
@@ -105,7 +134,7 @@ class DataTranspiler {
                 int = val.findFirstExpression(abaplint.Expressions.ConstantString);
             }
             if (int) {
-                const escaped = constant_1.ConstantTranspiler.escape(int.concatTokens());
+                const escaped = constant_1.ConstantTranspiler.escape(constant_1.ConstantTranspiler.trimTextFieldLiteral(int.concatTokens()));
                 value = "\n" + name + ".set(" + escaped + ");";
             }
             else if (val.getChildren()[1].get() instanceof abaplint.Expressions.SimpleFieldChain) {

package/build/src/structures/data.js

@@ -44,13 +44,18 @@ class DataTranspiler {
             return new chunk_1.Chunk("");
         }
         const topName = begin.findDirectExpression(abaplint.Expressions.DefinitionName)?.concatTokens().toLowerCase();
-        const chunk = new statements_1.DataTranspiler().transpile(begin, traversal).ensureStartMapping(begin, traversal);
+        // the component values are part of the declaration, so they must stay inside the loop guard
+        const statement = new statements_1.DataTranspiler({ skipLoopScoping: true });
+        let chunk = statement.transpile(begin, traversal).ensureStartMapping(begin, traversal);
         for (const d of node.findDirectStatements(abaplint.Statements.Data)) {
             const subName = d.findFirstExpression(abaplint.Expressions.DefinitionName)?.concatTokens().toLowerCase();
             if (subName && topName) {
                 chunk.appendString(statements_1.DataTranspiler.buildValue(d, topName + ".get()." + subName, traversal));
             }
         }
+        if (statement.isLoopScoped() === true) {
+            chunk = statements_1.DataTranspiler.wrapLoopScoped(statement.getVariableName(), chunk);
+        }
         chunk.appendString("\n");
         return chunk;
     }

package/build/src/traversal.js

@@ -482,10 +482,15 @@ class Traversal {
     }
     buildThisAttributes(def, cName) {
         let ret = "";
+        const constants = def.getAttributes()?.getConstants() || [];
         for (const a of def.getAttributes()?.getAll() || []) {
             let escaped = Traversal.escapeNamespace(a.getName().toLowerCase());
             if (a.getMeta().includes("static" /* abaplint.IdentifierMeta.Static */) === true) {
                 ret += "this." + escaped + " = " + cName + "." + escaped + ";\n";
+                const isConstant = constants.some(c => c.getName().toUpperCase() === a.getName().toUpperCase());
+                if (a.getVisibility() === abaplint.Visibility.Private && isConstant === false) {
+                    ret += `this.FRIENDS_ACCESS_INSTANCE["${escaped}"] = this.${escaped};\n`;
+                }
             }
             else {
                 if (a.getVisibility() === abaplint.Visibility.Private) {
@@ -837,7 +842,7 @@ this.INTERNAL_ID = abap.internalIdCounter++;\n`;
         }
         const handle = (val, name) => {
             if (typeof val === "string") {
-                const e = expressions_1.ConstantTranspiler.escape(val);
+                const e = expressions_1.ConstantTranspiler.escape(expressions_1.ConstantTranspiler.trimTextFieldLiteral(val));
                 ret += name + ".set(" + e + ");\n";
             }
             else if (typeof val === "object") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abaplint/transpiler",
-  "version": "2.13.45",
+  "version": "2.13.47",
   "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.5",
+    "@abaplint/core": "^2.120.6",
     "source-map": "^0.7.6"
   },
   "devDependencies": {