@abaplint/transpiler 2.11.1 → 2.11.3

package/build/src/statements/set_handler.js

@@ -7,23 +7,21 @@ const expressions_1 = require("../expressions");
 class SetHandlerTranspiler {
     transpile(node, traversal) {
         const methods = [];
-        let className = undefined;
+        let eventClass = undefined;
         let eventName = undefined;
         for (const m of node.findDirectExpressions(abaplint.Expressions.MethodSource)) {
             methods.push(new expressions_1.MethodSourceTranspiler().transpile(m, traversal).getCode().replace("await ", ""));
-            if (className === undefined) {
+            if (eventClass === undefined) {
                 const nameToken = m.getFirstToken();
                 const scope = traversal.findCurrentScopeByToken(nameToken);
                 const method = traversal.findMethodReference(nameToken, scope);
                 if (method?.def.isEventHandler() !== true) {
                     throw new Error(`SetHandlerTranspiler: Method "${nameToken.getStr()}" is not an event handler`);
                 }
-                const def = traversal.findClassDefinition(method.def.getClassName(), scope);
-                if (def === undefined) {
-                    throw new Error(`SetHandlerTranspiler: Class "${method.def.getClassName()}" not found`);
-                }
                 eventName = method.def.getEventName();
-                className = this.findEventClass(def, eventName, traversal, scope);
+                eventClass = this.findEventClass(method.def, traversal, scope);
+                // className = method.def.getEventClass();
+                // this.findEventClass(def, eventName, traversal, scope);
             }
         }
         let f = undefined;
@@ -39,30 +37,24 @@ class SetHandlerTranspiler {
         if (activationExpression) {
             activation = ", " + new expressions_1.SourceTranspiler().transpile(activationExpression, traversal).getCode();
         }
-        return new chunk_1.Chunk().append(`abap.statements.setHandler({EVENT_NAME: "${eventName}", EVENT_CLASS: "${className}"}, [${methods.join(",")}], ${f}${activation});`, node, traversal);
+        return new chunk_1.Chunk().append(`abap.statements.setHandler({EVENT_NAME: "${eventName}", EVENT_CLASS: "${eventClass}"}, [${methods.join(",")}], ${f}${activation});`, node, traversal);
     }
-    findEventClass(def, eventName, traversal, scope) {
-        let current = def;
-        while (current !== undefined) {
-            for (const event of current.getEvents()) {
-                if (event.getName().toUpperCase() === eventName?.toUpperCase()) {
-                    return traversal.buildInternalName(current.getName(), current);
-                }
-            }
-            for (const implementing of current.getImplementing()) {
-                const idef = traversal.findInterfaceDefinition(implementing.name, scope);
-                if (idef === undefined) {
-                    continue;
-                }
-                for (const event of idef.getEvents()) {
-                    if (event.getName().toUpperCase() === eventName?.toUpperCase()) {
-                        return traversal.buildInternalName(idef.getName(), idef);
-                    }
-                }
+    findEventClass(mdef, traversal, scope) {
+        let def = traversal.findClassDefinition(mdef.getEventClass(), scope);
+        if (def === undefined) {
+            def = traversal.findInterfaceDefinition(mdef.getEventClass(), scope);
+        }
+        // look through super classes
+        while (def?.getSuperClass() !== undefined) {
+            if (def.getEvents().find(e => e.getName().toUpperCase() === mdef.getEventName()?.toUpperCase())) {
+                break;
             }
-            current = traversal.findClassDefinition(current.getSuperClass(), scope);
+            def = traversal.findClassDefinition(def.getSuperClass(), scope);
+        }
+        if (def === undefined) {
+            throw new Error(`SetHandlerTranspiler: findEventClass, class or interface "${mdef.getEventClass()}" not found`);
         }
-        throw new Error(`Transpiler: Event "${eventName}" not found in class "${def.getName()}"`);
+        return traversal.buildInternalName(def.getName(), def);
     }
 }
 exports.SetHandlerTranspiler = SetHandlerTranspiler;

package/build/src/structures/class_implementation.js

@@ -118,6 +118,14 @@ class ClassImplementationTranspiler {
             }
             ret += traversal_1.Traversal.escapeNamespace(clasName) + "." + alias.getName().toLowerCase() + " = " + traversal_1.Traversal.escapeNamespace(clasName) + "." + traversal_1.Traversal.escapeNamespace(alias.getComponent().replace("~", "$")) + ";\n";
         }
+        for (const e of cdef.getEvents()) {
+            if (e.isStatic() === false) {
+                continue;
+            }
+            const fname = traversal_1.Traversal.escapeNamespace(e.getName().toLowerCase());
+            const name = traversal.buildInternalName(clasName, cdef);
+            ret += traversal_1.Traversal.escapeNamespace(clasName) + "." + fname + " = {\"EVENT_NAME\": \"" + e.getName().toUpperCase() + "\", \"EVENT_CLASS\": \"" + name + "\"};\n";
+        }
         // this is not correct, ABAP does not invocate the class constructor at require time,
         // but this will probably work
         if (traversal.getCurrentObject().getType() === "CLAS") {

package/package.json

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