@abaplint/transpiler 2.13.56 → 2.13.58

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

@@ -1,7 +1,15 @@
-import { Nodes } from "@abaplint/core";
+import { Nodes, Types } from "@abaplint/core";
 import { IExpressionTranspiler } from "./_expression_transpiler";
 import { Traversal } from "../traversal";
 import { Chunk } from "../chunk";
 export declare class MethodCallTranspiler implements IExpressionTranspiler {
+    private readonly postName;
+    private readonly method;
+    /** @param postName inserted between the method name and the parameters, eg. ".bind(this)"
+     *  @param method   the already resolved method reference, saves looking it up again */
+    constructor(postName?: string, method?: {
+        def: Types.MethodDefinition;
+        name: string;
+    });
     transpile(node: Nodes.ExpressionNode, traversal: Traversal): Chunk;
 }

package/build/src/expressions/method_call.js

@@ -6,6 +6,14 @@ const traversal_1 = require("../traversal");
 const method_call_param_1 = require("./method_call_param");
 const chunk_1 = require("../chunk");
 class MethodCallTranspiler {
+    postName;
+    method;
+    /** @param postName inserted between the method name and the parameters, eg. ".bind(this)"
+     *  @param method   the already resolved method reference, saves looking it up again */
+    constructor(postName = "", method) {
+        this.postName = postName;
+        this.method = method;
+    }
     transpile(node, traversal) {
         let post = "";
         const nameToken = node.findDirectExpression(core_1.Expressions.MethodName)?.getFirstToken();
@@ -13,7 +21,7 @@ class MethodCallTranspiler {
             throw new Error("MethodCallTranspiler, name not found");
         }
         const scope = traversal.findCurrentScopeByToken(nameToken);
-        const m = traversal.findMethodReference(nameToken, scope);
+        const m = this.method ?? traversal.findMethodReference(nameToken, scope);
         let name = nameToken.getStr().toLowerCase();
         if (traversal.isBuiltinMethod(nameToken)) {
             // todo: this is not correct, the method name might be shadowed
@@ -38,12 +46,12 @@ class MethodCallTranspiler {
                     name = `FRIENDS_ACCESS_INSTANCE["${name}"]`;
                 }
             }
-            name = name + "(";
+            name = name + this.postName + "(";
         }
         else {
             // todo: this should never happen?
             name = traversal_1.Traversal.escapeNamespace(name.replace("~", "$"));
-            name = name + "(";
+            name = name + this.postName + "(";
         }
         const step = node.findDirectExpression(core_1.Expressions.MethodCallParam);
         if (step === undefined) {

package/build/src/expressions/method_call_chain.js

@@ -4,22 +4,46 @@ exports.MethodCallChainTranspiler = void 0;
 const core_1 = require("@abaplint/core");
 const traversal_1 = require("../traversal");
 const chunk_1 = require("../chunk");
+const method_call_1 = require("./method_call");
 class MethodCallChainTranspiler {
     transpile(node, traversal) {
         let ret = new chunk_1.Chunk();
-        for (const c of node.getChildren()) {
+        const children = node.getChildren();
+        for (const c of children) {
             if (c instanceof core_1.Nodes.ExpressionNode && c.get() instanceof core_1.Expressions.MethodCall) {
-                const sub = traversal.traverse(c);
+                const isFirst = c === node.getFirstChild();
+                // "me->name( )" has the same semantics as the unqualified "name( )",
+                // only the first call in the chain is on "me", the rest is dispatched dynamically
+                const viaMe = c === children[2] && traversal_1.Traversal.isMe(children[0]);
+                let prefix = undefined;
+                let method = undefined;
+                const nameToken = isFirst || viaMe
+                    ? c.findDirectExpression(core_1.Expressions.MethodName)?.getFirstToken()
+                    : undefined;
+                // resolving the method reference is a linear scan of the scope, only do it when it can matter
+                const enclosingClass = nameToken ? traversal.enclosingConstructorClass(nameToken) : undefined;
+                if (nameToken && enclosingClass !== undefined) {
+                    method = traversal.findMethodReference(nameToken, traversal.findCurrentScopeByToken(nameToken));
+                    prefix = traversal.constructorPrototypePrefix(nameToken, method?.def, enclosingClass);
+                }
+                const sub = prefix === undefined
+                    ? traversal.traverse(c)
+                    : new method_call_1.MethodCallTranspiler(".bind(this)", method).transpile(c, traversal);
                 if (sub.getCode().startsWith("abap.builtin.")
                     || sub.getCode().startsWith("await abap.builtin.")) {
                     ret.appendChunk(sub);
                 }
                 else {
-                    const t = c === node.getFirstChild() ? "this." : "";
+                    let receiver = ret;
+                    let t = isFirst ? "this." : "";
+                    if (prefix !== undefined) {
+                        t = prefix;
+                        receiver = new chunk_1.Chunk(); // discard the "this.me.get()." built for the viaMe case
+                    }
                     ret = new chunk_1.Chunk()
                         .appendString("(await ")
                         .append(t, node, traversal)
-                        .appendChunk(ret)
+                        .appendChunk(receiver)
                         .appendChunk(sub)
                         .appendString(")");
                 }

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

@@ -5,6 +5,9 @@ import { Chunk } from "../chunk";
 export declare class MethodSourceTranspiler implements IExpressionTranspiler {
     private prepend;
     private readonly privatePrefix;
-    constructor(prepend?: string, privatePrefix?: boolean);
+    private readonly staticConstructorCall;
+    /** @param staticConstructorCall set to false when building a reference to the method instead of calling it,
+     *                               eg. SET HANDLER, where the dynamic method is the one to be registered */
+    constructor(prepend?: string, privatePrefix?: boolean, staticConstructorCall?: boolean);
     transpile(node: Nodes.ExpressionNode, traversal: Traversal): Chunk;
 }

package/build/src/expressions/method_source.js

@@ -9,14 +9,19 @@ const _1 = require(".");
 class MethodSourceTranspiler {
     prepend;
     privatePrefix;
-    constructor(prepend, privatePrefix = false) {
+    staticConstructorCall;
+    /** @param staticConstructorCall set to false when building a reference to the method instead of calling it,
+     *                               eg. SET HANDLER, where the dynamic method is the one to be registered */
+    constructor(prepend, privatePrefix = false, staticConstructorCall = true) {
         this.prepend = (prepend || "") + "await ";
         this.privatePrefix = privatePrefix;
+        this.staticConstructorCall = staticConstructorCall;
     }
     transpile(node, traversal) {
         const ret = new chunk_1.Chunk();
         const children = node.getChildren();
         let call = "";
+        let bindConstructorCall = false;
         for (let i = 0; i < children.length; i++) {
             const child = children[i];
             const nextChild = children[i + 1];
@@ -78,11 +83,25 @@ class MethodSourceTranspiler {
             }
             else if (child.get() instanceof core_1.Expressions.MethodName
                 || child.get() instanceof core_1.Expressions.AttributeName) {
-                if (i === 0) {
+                const nameToken = child.getFirstToken();
+                const scope = traversal.findCurrentScopeByToken(nameToken);
+                const m = traversal.findMethodReference(nameToken, scope);
+                // "me->name( )" has the same semantics as the unqualified "name( )"
+                const viaMe = i === 2 && children.length === 3 && traversal_1.Traversal.isMe(children[0]);
+                if (this.staticConstructorCall && (i === 0 || viaMe)) {
+                    const prefix = traversal.constructorPrototypePrefix(nameToken, m?.def);
+                    if (prefix !== undefined) {
+                        this.prepend += prefix;
+                        call = ""; // discard the "this.me.get()." built for the viaMe case
+                        bindConstructorCall = true;
+                    }
+                    else if (i === 0) {
+                        this.prepend += "this.";
+                    }
+                }
+                else if (i === 0) {
                     this.prepend += "this.";
                 }
-                const nameToken = child.getFirstToken();
-                const m = traversal.findMethodReference(nameToken, traversal.findCurrentScopeByToken(nameToken));
                 if (m) {
                     call += traversal_1.Traversal.escapeNamespace(m.name.toLowerCase().replace("~", "$"));
                 }
@@ -105,9 +124,19 @@ class MethodSourceTranspiler {
             else if (child.get() instanceof core_1.Expressions.FieldChain
                 || child.get() instanceof core_1.Expressions.SourceField) {
                 const nameToken = child.getFirstToken();
-                const m = traversal.findMethodReference(nameToken, traversal.findCurrentScopeByToken(nameToken));
+                const scope = traversal.findCurrentScopeByToken(nameToken);
+                const m = traversal.findMethodReference(nameToken, scope);
                 if (i === 0 && m) {
-                    this.prepend += "this.";
+                    const prefix = this.staticConstructorCall
+                        ? traversal.constructorPrototypePrefix(nameToken, m.def)
+                        : undefined;
+                    if (prefix !== undefined) {
+                        this.prepend += prefix;
+                        bindConstructorCall = true;
+                    }
+                    else {
+                        this.prepend += "this.";
+                    }
                     if (this.privatePrefix && m.def.getVisibility() === core_1.Visibility.Private
                         && m.def.isStatic() === false) { // todo: this is probably wrong?
                         this.prepend += "#";
@@ -128,6 +157,9 @@ class MethodSourceTranspiler {
                 ret.appendString("MethodSourceTranspiler-" + child.get().constructor.name + "-todo");
             }
         }
+        if (bindConstructorCall) {
+            call += ".bind(this)";
+        }
         ret.appendString(this.prepend);
         ret.appendString(call);
         return ret;

package/build/src/statements/method_implementation.js

@@ -143,11 +143,15 @@ class MethodImplementationTranspiler {
             // it messes up promises when "this" is returned
             throw new Error(`Method name "then" not allowed`);
         }
-        const superDef = traversal.findClassDefinition(classDef?.getSuperClass(), scope);
-        for (const a of superDef?.getAliases() || []) {
-            if (a.getName().toLowerCase() === methodName) {
-                methodName = a.getComponent().replace("~", "$").toLowerCase();
+        let superClassName = classDef?.getSuperClass();
+        while (superClassName !== undefined) {
+            const superDef = traversal.findClassDefinition(superClassName, scope);
+            const alias = superDef?.getAliases().find(a => a.getName().toLowerCase() === methodName);
+            if (alias !== undefined) {
+                methodName = alias.getComponent().replace("~", "$").toLowerCase();
+                break;
             }
+            superClassName = superDef?.getSuperClass();
         }
         // https://github.com/tc39/proposal-class-fields
         let isPrivate = "";

package/build/src/statements/set_handler.js

@@ -43,7 +43,9 @@ class SetHandlerTranspiler {
         let eventClass = undefined;
         let eventName = undefined;
         for (const m of node.findDirectExpressions(abaplint.Expressions.MethodSource)) {
-            const msource = new expressions_1.MethodSourceTranspiler("", true).transpile(m, traversal).getCode().replace("await ", "");
+            // the handler method is registered as a reference, it is dispatched dynamically when the event is raised,
+            // so no static binding even if the SET HANDLER is inside a constructor
+            const msource = new expressions_1.MethodSourceTranspiler("", true, false).transpile(m, traversal).getCode().replace("await ", "");
             const lastDot = msource.lastIndexOf(".");
             const receiver = lastDot === -1 ? "this" : msource.substring(0, lastDot);
             methods.push(`{method: ${msource}, receiver: ${receiver}}`);

package/build/src/traversal.d.ts

@@ -11,6 +11,8 @@ 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;
+    /** the self reference "me", it is a FieldChain in eg. MethodCallChain and a SourceField in eg. MethodSource */
+    static isMe(node: abaplint.Nodes.ExpressionNode | abaplint.Nodes.TokenNode | abaplint.Nodes.StructureNode): boolean;
     static prefixVariable(name: string | undefined): string;
     getCurrentObject(): abaplint.ABAPObject;
     traverse(node: abaplint.INode | undefined): Chunk;
@@ -39,6 +41,27 @@ export declare class Traversal {
         def: abaplint.Types.MethodDefinition;
         name: string;
     };
+    /** Returns the name of the class implementing the instance constructor the token is located in,
+     * or undefined if the token is not inside an instance constructor.
+     *
+     * Only the constructor body itself counts, including nested scopes like FOR and LET. A method
+     * called from the constructor is a scope of its own, and is not considered part of the constructor.
+     *
+     * This is cheap compared to resolving a method reference, so use it to bail out early. */
+    enclosingConstructorClass(token: abaplint.Token): string | undefined;
+    /** Methods called in an instance constructor are bound statically in ABAP, ie. a redefinition
+     * in a sub class is not called. Returns the "{class}.prototype." prefix to call the method with,
+     * or undefined if the normal dynamic dispatch via "this." is to be used.
+     *
+     * Note that the prefix is the class implementing the constructor, which is not necessarily the class
+     * being constructed, nor the class defining the method. Eg. constructing a sub class runs the constructor
+     * of the super class, and calls in there are bound to the super class. The JS prototype chain then finds
+     * the implementation as seen from that class, and interface methods as they are implemented in the class.
+     *
+     * Only calls written directly in the constructor body are bound statically, see enclosingConstructorClass
+     *
+     * @param enclosingClass the result of enclosingConstructorClass(token), pass it if already resolved */
+    constructorPrototypePrefix(token: abaplint.Token, def: abaplint.Types.MethodDefinition | undefined, enclosingClass?: string): string | undefined;
     private isBuiltinVariable;
     isTypePool(token: abaplint.Token): string | undefined;
     isInterfaceAttribute(token: abaplint.Token): string | undefined;

package/build/src/traversal.js

@@ -60,6 +60,12 @@ class Traversal {
     static escapeNamespace(name) {
         return name?.replace(/\//g, "$");
     }
+    /** the self reference "me", it is a FieldChain in eg. MethodCallChain and a SourceField in eg. MethodSource */
+    static isMe(node) {
+        return (node.get() instanceof abaplint.Expressions.FieldChain
+            || node.get() instanceof abaplint.Expressions.SourceField)
+            && node.concatTokens().toLowerCase() === "me";
+    }
     static prefixVariable(name) {
         if (name && keywords_1.DEFAULT_KEYWORDS.has(name)) {
             return "$" + name;
@@ -391,6 +397,57 @@ class Traversal {
         }
         return candidate;
     }
+    /** Returns the name of the class implementing the instance constructor the token is located in,
+     * or undefined if the token is not inside an instance constructor.
+     *
+     * Only the constructor body itself counts, including nested scopes like FOR and LET. A method
+     * called from the constructor is a scope of its own, and is not considered part of the constructor.
+     *
+     * This is cheap compared to resolving a method reference, so use it to bail out early. */
+    enclosingConstructorClass(token) {
+        let scope = this.findCurrentScopeByToken(token);
+        // the token might be in a scope nested inside the method, eg. FOR or LET
+        while (scope !== undefined && scope.getIdentifier().stype !== abaplint.ScopeType.Method) {
+            if (scope.getIdentifier().stype === abaplint.ScopeType.ClassImplementation) {
+                return undefined;
+            }
+            scope = scope.getParent();
+        }
+        if (scope === undefined || scope.getIdentifier().sname.toUpperCase() !== "CONSTRUCTOR") {
+            return undefined;
+        }
+        while (scope !== undefined && scope.getIdentifier().stype !== abaplint.ScopeType.ClassImplementation) {
+            scope = scope.getParent();
+        }
+        return scope?.getIdentifier().sname;
+    }
+    /** Methods called in an instance constructor are bound statically in ABAP, ie. a redefinition
+     * in a sub class is not called. Returns the "{class}.prototype." prefix to call the method with,
+     * or undefined if the normal dynamic dispatch via "this." is to be used.
+     *
+     * Note that the prefix is the class implementing the constructor, which is not necessarily the class
+     * being constructed, nor the class defining the method. Eg. constructing a sub class runs the constructor
+     * of the super class, and calls in there are bound to the super class. The JS prototype chain then finds
+     * the implementation as seen from that class, and interface methods as they are implemented in the class.
+     *
+     * Only calls written directly in the constructor body are bound statically, see enclosingConstructorClass
+     *
+     * @param enclosingClass the result of enclosingConstructorClass(token), pass it if already resolved */
+    constructorPrototypePrefix(token, def, enclosingClass) {
+        if (def === undefined
+            || def.isStatic() === true
+            || def.getVisibility() === abaplint.Visibility.Private
+            || def.isAbstract() === true) {
+            // static methods are not dispatched via the instance, and private methods cannot be redefined,
+            // abstract methods have no implementation to bind to, so keep the dynamic dispatch
+            return undefined;
+        }
+        const className = enclosingClass ?? this.enclosingConstructorClass(token);
+        if (className === undefined) {
+            return undefined;
+        }
+        return this.lookupClassOrInterface(className, token) + ".prototype.";
+    }
     isBuiltinVariable(token) {
         const scope = this.findCurrentScopeByToken(token);
         if (scope === undefined) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abaplint/transpiler",
-  "version": "2.13.56",
+  "version": "2.13.58",
   "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.20",
+    "@abaplint/core": "^2.120.22",
     "source-map": "^0.7.6"
   },
   "devDependencies": {