@abaplint/transpiler 2.10.11 → 2.10.12

package/build/src/expressions/field_chain.js

@@ -18,7 +18,7 @@ class FieldChainTranspiler {
             if (c.get() instanceof core_1.Expressions.SourceField
                 || c.get() instanceof core_1.Expressions.Field) {
                 const name = traversal.prefixAndName(c.getFirstToken(), filename).replace("~", "$");
-                ret.append(traversal_1.Traversal.escapeNamespace(name), c, traversal);
+                ret.append(traversal_1.Traversal.prefixVariable(traversal_1.Traversal.escapeNamespace(name)), c, traversal);
             }
             else if (c instanceof core_1.Nodes.ExpressionNode && c.get() instanceof core_1.Expressions.SourceFieldSymbol) {
                 ret.appendChunk(new field_symbol_1.FieldSymbolTranspiler().transpile(c, traversal));

package/build/src/expressions/target.js

@@ -15,7 +15,7 @@ class TargetTranspiler {
             const next = children[i + 1];
             if (c.get() instanceof core_1.Expressions.TargetField) {
                 const prefix = traversal.prefixAndName(c.getFirstToken()).replace("~", "$");
-                ret.append(traversal_1.Traversal.escapeNamespace(prefix), c, traversal);
+                ret.append(traversal_1.Traversal.prefixVariable(traversal_1.Traversal.escapeNamespace(prefix)), c, traversal);
             }
             else if (c.get() instanceof core_1.Expressions.ClassName) {
                 const name = traversal.lookupClassOrInterface(c.getFirstToken().getStr(), c.getFirstToken());

package/build/src/keywords.d.ts

@@ -1,5 +1,5 @@
 import * as abaplint from "@abaplint/core";
-export declare const defaultKeywords: string[];
+export declare const DEFAULT_KEYWORDS: string[];
 /** Replaces javascript keywords in ABAP source code, in-memory only */
 export declare class Keywords {
     private readonly keywords;

package/build/src/keywords.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Keywords = exports.defaultKeywords = void 0;
+exports.Keywords = exports.DEFAULT_KEYWORDS = void 0;
 const abaplint = require("@abaplint/core");
 // https://www.w3schools.com/js/js_reserved.asp
-exports.defaultKeywords = [
+exports.DEFAULT_KEYWORDS = [
     "abstract", "arguments", "await",
     "break", "byte", "catch",
     "char", "class", "const", "continue",
@@ -31,10 +31,13 @@ class Keywords {
             this.keywords = keywords;
         }
         else {
-            this.keywords = exports.defaultKeywords;
+            this.keywords = exports.DEFAULT_KEYWORDS;
         }
     }
     handle(reg) {
+        if (this.keywords.length === 0) {
+            return;
+        }
         reg.parse();
         for (const o of reg.getObjects()) {
             if (!(o instanceof abaplint.ABAPObject)) {

package/build/src/statements/data.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DataTranspiler = void 0;
 const abaplint = require("@abaplint/core");
 const transpile_types_1 = require("../transpile_types");
+const traversal_1 = require("../traversal");
 const constant_1 = require("../expressions/constant");
 const expressions_1 = require("../expressions");
 const chunk_1 = require("../chunk");
@@ -29,7 +30,7 @@ class DataTranspiler {
         }
         const ret = new chunk_1.Chunk()
             .appendString("let ")
-            .append(found.getName().toLowerCase(), token, traversal)
+            .append(traversal_1.Traversal.prefixVariable(traversal_1.Traversal.escapeNamespace(found.getName().toLowerCase())), token, traversal)
             .appendString(" = " + new transpile_types_1.TranspileTypes().toType(found.getType()))
             .append(";", node.getLastToken(), traversal)
             .append(value, node.getLastToken(), traversal);

package/build/src/statements/form.js

@@ -4,6 +4,7 @@ exports.FormTranspiler = void 0;
 const abaplint = require("@abaplint/core");
 const chunk_1 = require("../chunk");
 const unique_identifier_1 = require("../unique_identifier");
+const traversal_1 = require("../traversal");
 class FormTranspiler {
     transpile(node, traversal) {
         unique_identifier_1.UniqueIdentifier.resetIndexBackup();
@@ -13,13 +14,13 @@ class FormTranspiler {
         const ret = new chunk_1.Chunk("async function " + name + "(INPUT) {");
         const params = [];
         for (const p of def?.getChangingParameters() || []) {
-            params.push(`let ${p.getName()} = INPUT.${p.getName()};`);
+            params.push(`let ${traversal_1.Traversal.prefixVariable(p.getName())} = INPUT.${p.getName()};`);
         }
         for (const p of def?.getTablesParameters() || []) {
-            params.push(`let ${p.getName()} = INPUT.${p.getName()};`);
+            params.push(`let ${traversal_1.Traversal.prefixVariable(p.getName())} = INPUT.${p.getName()};`);
         }
         for (const p of def?.getUsingParameters() || []) {
-            params.push(`let ${p.getName()} = INPUT.${p.getName()};`);
+            params.push(`let ${traversal_1.Traversal.prefixVariable(p.getName())} = INPUT.${p.getName()};`);
         }
         if (params.length > 0) {
             ret.appendString("\n" + params.join("\n"));

package/build/src/statements/method_implementation.js

@@ -33,6 +33,7 @@ class MethodImplementationTranspiler {
         for (const n in vars) {
             const identifier = vars[n];
             const varName = n.toLowerCase();
+            const varPrefixed = traversal_1.Traversal.prefixVariable(varName);
             if (identifier.getMeta().includes("importing" /* abaplint.IdentifierMeta.MethodImporting */)
                 || identifier.getMeta().includes("changing" /* abaplint.IdentifierMeta.MethodChanging */)
                 || identifier.getMeta().includes("event_parameter" /* abaplint.IdentifierMeta.EventParameter */)
@@ -45,31 +46,31 @@ class MethodImplementationTranspiler {
                 const passByValue = identifier.getMeta().includes("pass_by_value" /* abaplint.IdentifierMeta.PassByValue */);
                 const type = identifier.getType();
                 if (identifier.getMeta().includes("exporting" /* abaplint.IdentifierMeta.MethodExporting */)) {
-                    after += `let ${varName} = ${unique}?.${varName} || ${new transpile_types_1.TranspileTypes().toType(identifier.getType())};\n`;
+                    after += `let ${varPrefixed} = ${unique}?.${varName} || ${new transpile_types_1.TranspileTypes().toType(identifier.getType())};\n`;
                 }
                 else if (identifier.getMeta().includes("importing" /* abaplint.IdentifierMeta.MethodImporting */)
                     && parameterDefault === undefined
                     && passByValue === false
                     && isOptional === false
                     && type.isGeneric() === false) {
-                    after += `let ${varName} = ${unique}?.${varName};\n`;
+                    after += `let ${varPrefixed} = ${unique}?.${varName};\n`;
                     if (identifier.getType().getQualifiedName() !== undefined && identifier.getType().getQualifiedName() !== "") {
-                        after += `if (${varName}?.getQualifiedName === undefined || ${varName}.getQualifiedName() !== "${identifier.getType().getQualifiedName()?.toUpperCase()}") { ${varName} = undefined; }\n`;
+                        after += `if (${varPrefixed}?.getQualifiedName === undefined || ${varPrefixed}.getQualifiedName() !== "${identifier.getType().getQualifiedName()?.toUpperCase()}") { ${varPrefixed} = undefined; }\n`;
                     }
-                    after += `if (${varName} === undefined) { ${varName} = ${new transpile_types_1.TranspileTypes().toType(identifier.getType())}.set(${unique}.${varName}); }\n`;
+                    after += `if (${varPrefixed} === undefined) { ${varPrefixed} = ${new transpile_types_1.TranspileTypes().toType(identifier.getType())}.set(${unique}.${varName}); }\n`;
                 }
                 else if (identifier.getMeta().includes("importing" /* abaplint.IdentifierMeta.MethodImporting */)
                     && type.isGeneric() === true) {
                     if (isOptional === true) {
-                        after += `let ${varName} = ${unique}?.${varName} || ${new transpile_types_1.TranspileTypes().toType(identifier.getType())};\n`;
+                        after += `let ${varPrefixed} = ${unique}?.${varName} || ${new transpile_types_1.TranspileTypes().toType(identifier.getType())};\n`;
                     }
                     else {
-                        after += `let ${varName} = ${unique}?.${varName};\n`;
+                        after += `let ${varPrefixed} = ${unique}?.${varName};\n`;
                     }
                     if (type instanceof abaplint.BasicTypes.NumericGenericType) {
-                        after += `if (${varName}.constructor.name === "Character") {
-  ${varName} = ${new transpile_types_1.TranspileTypes().toType(identifier.getType())};
-  ${varName}.set(${unique}?.${varName});
+                        after += `if (${varPrefixed}.constructor.name === "Character") {
+  ${varPrefixed} = ${new transpile_types_1.TranspileTypes().toType(identifier.getType())};
+  ${varPrefixed}.set(${unique}?.${varName});
 }\n`;
                     }
                 }
@@ -77,19 +78,19 @@ class MethodImplementationTranspiler {
                     && type.isGeneric() === false) {
                     after += new transpile_types_1.TranspileTypes().declare(identifier) + "\n";
                     // note: it might be nessesary to do a type conversion, eg char is passed to xstring parameter
-                    after += "if (" + unique + " && " + unique + "." + varName + ") {" + varName + ".set(" + unique + "." + varName + ");}\n";
+                    after += "if (" + unique + " && " + unique + "." + varName + ") {" + varPrefixed + ".set(" + unique + "." + varName + ");}\n";
                 }
                 else {
                     after += new transpile_types_1.TranspileTypes().declare(identifier) + "\n";
-                    after += "if (" + unique + " && " + unique + "." + varName + ") {" + varName + " = " + unique + "." + varName + ";}\n";
+                    after += "if (" + unique + " && " + unique + "." + varName + ") {" + varPrefixed + " = " + unique + "." + varName + ";}\n";
                 }
                 if (parameterDefault) {
                     const val = this.buildDefault(parameterDefault, traversal, methodDef?.getFilename());
                     if (passByValue === true || identifier.getMeta().includes("changing" /* abaplint.IdentifierMeta.MethodChanging */)) {
-                        after += "if (" + unique + " === undefined || " + unique + "." + varName + " === undefined) {" + varName + ".set(" + val + ");}\n";
+                        after += "if (" + unique + " === undefined || " + unique + "." + varName + " === undefined) {" + varPrefixed + ".set(" + val + ");}\n";
                     }
                     else {
-                        after += "if (" + unique + " === undefined || " + unique + "." + varName + " === undefined) {" + varName + " = " + val + ";}\n";
+                        after += "if (" + unique + " === undefined || " + unique + "." + varName + " === undefined) {" + varPrefixed + " = " + val + ";}\n";
                     }
                 }
             }

package/build/src/traversal.d.ts

@@ -10,6 +10,7 @@ export declare class Traversal {
     readonly options: ITranspilerOptions | undefined;
     constructor(spaghetti: abaplint.ISpaghettiScope, file: abaplint.ABAPFile, obj: abaplint.ABAPObject, reg: abaplint.IRegistry, options?: ITranspilerOptions);
     static escapeNamespace(name: string | undefined): string | undefined;
+    static prefixVariable(name: string | undefined): string;
     getCurrentObject(): abaplint.ABAPObject;
     traverse(node: abaplint.INode | undefined): Chunk;
     getFilename(): string;

package/build/src/traversal.js

@@ -8,6 +8,7 @@ const StructureTranspilers = require("./structures");
 const transpile_types_1 = require("./transpile_types");
 const chunk_1 = require("./chunk");
 const expressions_1 = require("./expressions");
+const keywords_1 = require("./keywords");
 class Traversal {
     constructor(spaghetti, file, obj, reg, options) {
         this.scopeCache = undefined;
@@ -20,6 +21,13 @@ class Traversal {
     static escapeNamespace(name) {
         return name?.replace(/\//g, "$");
     }
+    static prefixVariable(name) {
+        // TODO: performace, make this a hash lookup?,
+        if (keywords_1.DEFAULT_KEYWORDS.some(k => k === name)) {
+            return "$" + name;
+        }
+        return name + "";
+    }
     getCurrentObject() {
         return this.obj;
     }

package/build/src/validation.js

@@ -120,7 +120,7 @@ class Validation {
         }
         exports.config.rules["forbidden_identifier"]["check"] = ["^unique\\d+$"];
         if (this.options?.keywords === undefined) {
-            for (const d of keywords_1.defaultKeywords) {
+            for (const d of keywords_1.DEFAULT_KEYWORDS) {
                 const add = "^" + d + "$";
                 exports.config.rules["forbidden_identifier"]["check"].push(add);
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abaplint/transpiler",
-  "version": "2.10.11",
+  "version": "2.10.12",
   "description": "Transpiler",
   "main": "build/src/index.js",
   "typings": "build/src/index.d.ts",