@abaplint/transpiler-cli 2.13.56 → 2.13.57

package/build/bundle.js

@@ -17217,11 +17217,12 @@ class ModifyEntities {
         const reported = (0, combi_1.seq)("REPORTED", expressions_1.Target);
         const end = (0, combi_1.optPrio)((0, combi_1.per)(failed, result, mapped, reported));
         const entities = (0, combi_1.seq)((0, combi_1.optPrio)("AUGMENTING"), "ENTITIES OF", expressions_1.NamespaceSimpleName, (0, combi_1.opt)("IN LOCAL MODE"), (0, combi_1.plusPrio)((0, combi_1.seq)("ENTITY", expressions_1.NamespaceSimpleName, (0, combi_1.plus)(operation))));
+        const dynamic = (0, combi_1.seq)("ENTITIES", (0, combi_1.optPrio)((0, combi_1.altPrio)("IN LOCAL MODE", (0, combi_1.seq)((0, combi_1.opt)("FORWARDING"), "PRIVILEGED"))), "OPERATIONS", expressions_1.Source);
         const create2 = (0, combi_1.seq)("CREATE", fieldsWith, (0, combi_1.opt)((0, combi_1.seq)("CREATE BY", expressions_1.EMLEntityPath, fieldsWith)));
         const create3 = (0, combi_1.seq)("CREATE BY", expressions_1.EMLEntityPath, fieldsWith);
         const create4 = (0, combi_1.seq)("CREATE FROM", expressions_1.Source, (0, combi_1.plus)((0, combi_1.seq)("CREATE BY", expressions_1.EMLEntityPath, "FROM", expressions_1.Source)));
         const entity = (0, combi_1.seq)("ENTITY", (0, combi_1.opt)("IN LOCAL MODE"), (0, combi_1.alt)(expressions_1.NamespaceSimpleName, expressions_1.EntityAssociation), (0, combi_1.alt)(execute, create, updateFields, deleteFrom, updateSetFields, updateFrom, create2, create3, create4));
-        return (0, combi_1.ver)(version_1.Release.v754, (0, combi_1.seq)("MODIFY", (0, combi_1.alt)(entities, entity), end), { also: combi_1.AlsoIn.OpenABAP });
+        return (0, combi_1.ver)(version_1.Release.v754, (0, combi_1.seq)("MODIFY", (0, combi_1.alt)(entities, dynamic, entity), end), { also: combi_1.AlsoIn.OpenABAP });
     }
 }
 exports.ModifyEntities = ModifyEntities;
@@ -39500,7 +39501,7 @@ class CreateObject {
         this.validateParameters(cdef, node, input);
     }
     static checkInstantiationAllowed(cdef, input) {
-        var _a, _b, _c, _d;
+        var _a, _b, _c;
         const createVis = cdef.getCreateVisibility();
         if (createVis === visibility_1.Visibility.Public) {
             return undefined;
@@ -39517,23 +39518,30 @@ class CreateObject {
             input.scope.isLocalFriend(cdef.getName(), enclosingClass)) {
             return undefined;
         }
+        const enclosingDefinition = input.scope.findClassDefinition(enclosingClass);
+        if (enclosingDefinition !== undefined) {
+            const implementedInterfaces = new _object_oriented_1.ObjectOriented(input.scope).findInterfaces(enclosingDefinition);
+            if (cdef.getFriends().some(friend => implementedInterfaces.some(implemented => implemented.name.toUpperCase() === friend.toUpperCase()))) {
+                return undefined;
+            }
+        }
         // subclasses of friends also have friendship
-        let enclosingSup = (_a = input.scope.findClassDefinition(enclosingClass)) === null || _a === void 0 ? void 0 : _a.getSuperClass();
+        let enclosingSup = enclosingDefinition === null || enclosingDefinition === void 0 ? void 0 : enclosingDefinition.getSuperClass();
         while (enclosingSup !== undefined) {
             if (cdef.getFriends().some(f => f.toUpperCase() === enclosingSup.toUpperCase()) ||
                 input.scope.isLocalFriend(cdef.getName(), enclosingSup)) {
                 return undefined;
             }
-            enclosingSup = (_b = input.scope.findClassDefinition(enclosingSup)) === null || _b === void 0 ? void 0 : _b.getSuperClass();
+            enclosingSup = (_a = input.scope.findClassDefinition(enclosingSup)) === null || _a === void 0 ? void 0 : _a.getSuperClass();
         }
         if (createVis === visibility_1.Visibility.Protected) {
             // subclasses are also allowed
-            let sup = (_c = input.scope.findClassDefinition(enclosingClass)) === null || _c === void 0 ? void 0 : _c.getSuperClass();
+            let sup = (_b = input.scope.findClassDefinition(enclosingClass)) === null || _b === void 0 ? void 0 : _b.getSuperClass();
             while (sup !== undefined) {
                 if (sup.toUpperCase() === cdef.getName().toUpperCase()) {
                     return undefined;
                 }
-                sup = (_d = input.scope.findClassDefinition(sup)) === null || _d === void 0 ? void 0 : _d.getSuperClass();
+                sup = (_c = input.scope.findClassDefinition(sup)) === null || _c === void 0 ? void 0 : _c.getSuperClass();
             }
         }
         return cdef.getName() + " cannot be instantiated, class is defined as " +
@@ -52159,6 +52167,7 @@ class ClassDefinition extends _identifier_1.Identifier {
         this.checkInterfaceVisibility(input, node);
         this.checkMethodsFromSuperClasses(input);
         this.checkMethodNameConflicts(input);
+        this.checkEventNameConflicts(input);
         this.checkClassNameLength(input);
         this.checkMethodNameLength(input);
         this.checkClassConstructorStatic(input);
@@ -52298,6 +52307,15 @@ class ClassDefinition extends _identifier_1.Identifier {
             }
         }
     }
+    checkEventNameConflicts(input) {
+        for (const e of this.events) {
+            if (this.attributes.findByName(e.getName()) !== undefined
+                || this.types.getByName(e.getName()) !== undefined
+                || this.methodDefs.getByName(e.getName()) !== undefined) {
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, e.getToken(), `"${e.getName()}" already defined`));
+            }
+        }
+    }
     findFriends(def, input) {
         var _a;
         const result = [];
@@ -70098,7 +70116,7 @@ class Registry {
     }
     static abaplintVersion() {
         // magic, see build script "version.js"
-        return "2.120.20";
+        return "2.120.22";
     }
     getDDICReferences() {
         return this.ddicReferences;
@@ -104041,6 +104059,14 @@ const traversal_1 = __webpack_require__(/*! ../traversal */ "./node_modules/@aba
 const method_call_param_1 = __webpack_require__(/*! ./method_call_param */ "./node_modules/@abaplint/transpiler/build/src/expressions/method_call_param.js");
 const chunk_1 = __webpack_require__(/*! ../chunk */ "./node_modules/@abaplint/transpiler/build/src/chunk.js");
 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();
@@ -104048,7 +104074,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
@@ -104073,12 +104099,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) {
@@ -104197,22 +104223,46 @@ exports.MethodCallChainTranspiler = void 0;
 const core_1 = __webpack_require__(/*! @abaplint/core */ "./node_modules/@abaplint/core/build/src/index.js");
 const traversal_1 = __webpack_require__(/*! ../traversal */ "./node_modules/@abaplint/transpiler/build/src/traversal.js");
 const chunk_1 = __webpack_require__(/*! ../chunk */ "./node_modules/@abaplint/transpiler/build/src/chunk.js");
+const method_call_1 = __webpack_require__(/*! ./method_call */ "./node_modules/@abaplint/transpiler/build/src/expressions/method_call.js");
 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(")");
                 }
@@ -104391,14 +104441,19 @@ const _1 = __webpack_require__(/*! . */ "./node_modules/@abaplint/transpiler/bui
 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];
@@ -104460,11 +104515,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("~", "$"));
                 }
@@ -104487,9 +104556,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 += "#";
@@ -104510,6 +104589,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;
@@ -116810,7 +116892,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}}`);
@@ -120585,6 +120669,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;
@@ -120916,6 +121006,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-cli",
-  "version": "2.13.56",
+  "version": "2.13.57",
   "description": "Transpiler - Command Line Interface",
   "funding": "https://github.com/sponsors/larshp",
   "bin": {
@@ -27,8 +27,8 @@
   "author": "abaplint",
   "license": "MIT",
   "devDependencies": {
-    "@abaplint/core": "^2.120.20",
-    "@abaplint/transpiler": "^2.13.56",
+    "@abaplint/core": "^2.120.22",
+    "@abaplint/transpiler": "^2.13.57",
     "@types/glob": "^8.1.0",
     "@types/node": "^24.13.3",
     "@types/progress": "^2.0.7",