@abaplint/transpiler 2.10.28 → 2.10.29

package/build/src/expressions/method_call.js

@@ -5,6 +5,7 @@ const core_1 = require("@abaplint/core");
 const traversal_1 = require("../traversal");
 const method_call_param_1 = require("./method_call_param");
 const chunk_1 = require("../chunk");
+const feature_flags_1 = require("../feature_flags");
 class MethodCallTranspiler {
     transpile(node, traversal) {
         const nameToken = node.findDirectExpression(core_1.Expressions.MethodName)?.getFirstToken();
@@ -22,6 +23,10 @@ class MethodCallTranspiler {
         if (m?.name && traversal.isBuiltinMethod(nameToken) === false) {
             name = m.name.toLowerCase() + "(";
         }
+        if (feature_flags_1.FEATURE_FLAGS.private === true
+            && m?.def.getVisibility() === core_1.Visibility.Private) {
+            name = "#" + name;
+        }
         const step = node.findDirectExpression(core_1.Expressions.MethodCallParam);
         if (step === undefined) {
             throw new Error("MethodCallTranspiler, unexpected node");

package/build/src/feature_flags.d.ts

@@ -0,0 +1,3 @@
+export declare const FEATURE_FLAGS: {
+    private: boolean;
+};

package/build/src/feature_flags.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FEATURE_FLAGS = void 0;
+exports.FEATURE_FLAGS = {
+    private: true,
+};
+//# sourceMappingURL=feature_flags.js.map

package/build/src/statements/class_implementation.js

@@ -23,6 +23,7 @@ static INTERNAL_TYPE = 'CLAS';
 static INTERNAL_NAME = '${traversal.buildInternalName(token.getStr(), def)}';
 static IMPLEMENTED_INTERFACES = [${this.findImplementedByClass(traversal, def, scope).map(e => `"` + e.toUpperCase() + `"`).join(",")}];
 static ATTRIBUTES = {${traversal.buildAttributes(def, scope).join(",\n")}};
+static FRIENDS_ACCESS_STATIC = {}; // todo
 static METHODS = {${traversal.buildMethods(def, scope).join(",\n")}};`, node, traversal);
     }
     findImplementedInterface(traversal, def, scope) {

package/build/src/statements/method_implementation.js

@@ -8,6 +8,7 @@ const traversal_1 = require("../traversal");
 const expressions_1 = require("../expressions");
 const chunk_1 = require("../chunk");
 const unique_identifier_1 = require("../unique_identifier");
+const feature_flags_1 = require("../feature_flags");
 class MethodImplementationTranspiler {
     transpile(node, traversal) {
         const token = node.findFirstExpression(abaplint.Expressions.MethodName).getFirstToken();
@@ -116,15 +117,21 @@ class MethodImplementationTranspiler {
                 methodName = a.getComponent().replace("~", "$").toLowerCase();
             }
         }
+        // https://github.com/tc39/proposal-class-fields
+        let isPrivate = "";
+        if (feature_flags_1.FEATURE_FLAGS.private === true
+            && method?.getVisibility() === abaplint.Visibility.Private) {
+            isPrivate = "#";
+        }
         if (method && method.isStatic()) {
             // in ABAP static methods can be called with instance arrows, "->"
             const className = scope.getParent()?.getIdentifier().sname?.toLowerCase();
-            staticMethod = "async " + traversal_1.Traversal.escapeNamespace(methodName) + "(" + unique + ") {\n" +
+            staticMethod = "async " + isPrivate + traversal_1.Traversal.escapeNamespace(methodName) + "(" + unique + ") {\n" +
                 "return " + traversal_1.Traversal.escapeNamespace(className) + "." + traversal_1.Traversal.escapeNamespace(methodName) + "(" + unique + ");\n" +
                 "}\n" + "static ";
         }
         unique_identifier_1.UniqueIdentifier.resetIndexBackup();
-        const str = staticMethod + "async " + traversal_1.Traversal.escapeNamespace(methodName) + "(" + unique + ") {" + after;
+        const str = staticMethod + "async " + isPrivate + traversal_1.Traversal.escapeNamespace(methodName) + "(" + unique + ") {" + after;
         return new chunk_1.Chunk().append(str, node, traversal);
     }
     /////////////////////////////

package/build/src/structures/class_definition.js

@@ -25,6 +25,7 @@ class ${className?.toLowerCase()} {
   static IMPLEMENTED_INTERFACES = [];
   static INTERNAL_NAME = 'ABSTRACT_CLASS_INTERNAL_NAME';
   static ATTRIBUTES = {};
+  static FRIENDS_ACCESS_STATIC = {};
   async constructor_() {
     this.me = new abap.types.ABAPObject();
     this.me.set(this);

package/build/src/traversal.d.ts

@@ -39,6 +39,8 @@ export declare class Traversal {
     isTypePool(token: abaplint.Token): string | undefined;
     isInterfaceAttribute(token: abaplint.Token): string | undefined;
     private findReadOrWriteReference;
+    private buildThisAttributes;
+    private buildFriendsAccess;
     buildConstructorContents(scope: abaplint.ISpaghettiScopeNode | undefined, def: abaplint.IClassDefinition): string;
     findInterfaceDefinition(name: string, scope: abaplint.ISpaghettiScopeNode | undefined): abaplint.IInterfaceDefinition | undefined;
     findTable(name: string): abaplint.Objects.Table | undefined;

package/build/src/traversal.js

@@ -9,6 +9,7 @@ const transpile_types_1 = require("./transpile_types");
 const chunk_1 = require("./chunk");
 const expressions_1 = require("./expressions");
 const keywords_1 = require("./keywords");
+const feature_flags_1 = require("./feature_flags");
 class Traversal {
     constructor(spaghetti, file, obj, reg, options) {
         this.scopeCache = undefined;
@@ -376,15 +377,8 @@ class Traversal {
         }
         return undefined;
     }
-    buildConstructorContents(scope, def) {
+    buildThisAttributes(def, cName) {
         let ret = "";
-        if (def.getSuperClass() !== undefined || def.getName().toUpperCase() === "CX_ROOT") {
-            ret += "super();\n";
-        }
-        const cName = Traversal.escapeNamespace(def.getName().toLowerCase());
-        ret += `this.me = new abap.types.ABAPObject();
-this.me.set(this);
-this.INTERNAL_ID = abap.internalIdCounter++;\n`;
         for (const a of def.getAttributes()?.getAll() || []) {
             const escaped = Traversal.escapeNamespace(a.getName().toLowerCase());
             if (a.getMeta().includes("static" /* abaplint.IdentifierMeta.Static */) === true) {
@@ -395,6 +389,39 @@ this.INTERNAL_ID = abap.internalIdCounter++;\n`;
             ret += name + " = " + new transpile_types_1.TranspileTypes().toType(a.getType()) + ";\n";
             ret += this.setValues(a, name);
         }
+        return ret;
+    }
+    buildFriendsAccess(def, hasSuperClass) {
+        let ret = "this.FRIENDS_ACCESS_INSTANCE = {\n";
+        if (hasSuperClass === true) {
+            ret += `"SUPER": sup.FRIENDS_ACCESS_INSTANCE,\n`;
+        }
+        for (const a of def.getMethodDefinitions()?.getAll() || []) {
+            const name = a.getName().toLowerCase();
+            if (name === "constructor" || a.isStatic() === true) {
+                continue;
+            }
+            let privateHash = "";
+            if (feature_flags_1.FEATURE_FLAGS.private === true && a.getVisibility() === abaplint.Visibility.Private) {
+                privateHash = "#";
+            }
+            const methodName = privateHash + Traversal.escapeNamespace(name.replace("~", "$"));
+            ret += `"${name.replace("~", "$")}": this.${methodName}.bind(this),\n`;
+        }
+        ret += "};\n";
+        return ret;
+    }
+    buildConstructorContents(scope, def) {
+        let ret = "";
+        if (def.getSuperClass() !== undefined || def.getName().toUpperCase() === "CX_ROOT") {
+            ret += "const sup = super();\n";
+        }
+        const cName = Traversal.escapeNamespace(def.getName().toLowerCase());
+        ret += `this.me = new abap.types.ABAPObject();
+this.me.set(this);
+this.INTERNAL_ID = abap.internalIdCounter++;\n`;
+        ret += this.buildFriendsAccess(def, def.getSuperClass() !== undefined);
+        ret += this.buildThisAttributes(def, cName);
         // attributes from directly implemented interfaces(not interfaces implemented in super classes)
         for (const i of def.getImplementing()) {
             ret += this.dataFromInterfaces(i.name, scope, cName);

package/build/src/unit_test.js

@@ -225,10 +225,13 @@ async function run() {
                     continue;
                 }
                 ret += `      {\n        const test = await (new ${lc}()).constructor_();\n`;
+                // todo, some refactoring here,
                 ret += `        if (test.setup) await test.setup();\n`;
+                ret += `        if (test.FRIENDS_ACCESS_INSTANCE.setup) await test.FRIENDS_ACCESS_INSTANCE.setup();\n`;
+                ret += `        if (test.FRIENDS_ACCESS_INSTANCE.SUPER && test.FRIENDS_ACCESS_INSTANCE.SUPER.setup) await test.FRIENDS_ACCESS_INSTANCE.SUPER.setup();\n`;
                 ret += `        console.log("${st.obj.getName()}: running ${lc}->${m}");\n`;
                 ret += `        meth = locl.addMethod("${m}");\n`;
-                ret += `        await test.${m}();\n`;
+                ret += `        await test.FRIENDS_ACCESS_INSTANCE.${m}();\n`;
                 ret += `        meth.pass();\n`;
                 ret += `        if (test.teardown) await test.teardown();\n`;
                 ret += `      }\n`;
@@ -236,59 +239,6 @@ async function run() {
             ret += `      if (${lc}.class_teardown) await ${lc}.class_teardown();\n`;
             ret += `    }\n`;
         }
-        /*
-            for (const obj of reg.getObjects()) {
-              if (reg.isDependency(obj) || !(obj instanceof abaplint.Objects.Class)) {
-                continue;
-              }
-              ret += `// --------------------------------------------\n`;
-              ret += `    clas = unit.addObject("${obj.getName()}");\n`;
-              for (const file of obj.getABAPFiles()) {
-                for (const def of file.getInfo().listClassDefinitions()) {
-                  if (def.isForTesting === false
-                      || def.isGlobal === true
-                      || def.methods.length === 0
-                      || def.isAbstract === true) {
-                    // todo, fix, there might be global test methods
-                    continue;
-                  }
-                  const hasTestFile = obj.getFiles().some(f => { return f.getFilename().includes(".testclasses."); });
-                  if (hasTestFile === false) {
-                    break;
-                  }
-                  ret += `    {
-              const {${def.name}} = await import("./${this.escapeNamespace(obj.getName().toLowerCase())}.${obj.getType().toLowerCase()}.testclasses.mjs");
-              locl = clas.addTestClass("${def.name}");
-              if (${def.name}.class_setup) await ${def.name}.class_setup();\n`;
-        
-                  for (const m of def.methods) {
-                    if (m.isForTesting === false) {
-                      continue;
-                    }
-                    const skipThis = (skip || []).some(a => a.object === obj.getName() && a.class === def.name && a.method === m.name);
-                    if (skipThis) {
-                      ret += `  console.log('${obj.getName()}: running ${def.name}->${m.name}, skipped');\n`;
-                      ret += `  meth = locl.addMethod("${m.name}");\n`;
-                      ret += `  meth.skip();\n`;
-                      continue;
-                    }
-        
-                    ret += `      {\n        const test = await (new ${def.name}()).constructor_();\n`;
-                    ret += `        if (test.setup) await test.setup();\n`;
-                    ret += `        console.log("${obj.getName()}: running ${def.name}->${m.name}");\n`;
-                    ret += `        meth = locl.addMethod("${m.name}");\n`;
-                    ret += `        await test.${m.name}();\n`;
-                    ret += `        meth.pass();\n`;
-                    ret += `        if (test.teardown) await test.teardown();\n`;
-                    ret += `      }\n`;
-                  }
-        
-                  ret += `      if (${def.name}.class_teardown) await ${def.name}.class_teardown();\n`;
-                  ret += `    }\n`;
-                }
-              }
-            }
-            */
         ret += `// -------------------END-------------------
     fs.writeFileSync(__dirname + path.sep + "_output.xml", unit.xUnitXML());
   } catch (e) {

package/package.json

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