@abaplint/transpiler 2.11.0 → 2.11.1

package/build/src/statements/raise_event.js

@@ -1,11 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RaiseEventTranspiler = void 0;
+const abaplint = require("@abaplint/core");
+const traversal_1 = require("../traversal");
 const chunk_1 = require("../chunk");
+const expressions_1 = require("../expressions");
 class RaiseEventTranspiler {
     transpile(node, traversal) {
-        // todo
-        return new chunk_1.Chunk().append(`abap.statements.raiseEvent();`, node, traversal);
+        const eventName = traversal_1.Traversal.escapeNamespace(node.findFirstExpression(abaplint.Expressions.EventName)?.concatTokens())?.toLowerCase().replace("~", "$");
+        const parameters = node.findFirstExpression(abaplint.Expressions.ParameterListS);
+        let extra = "";
+        if (parameters) {
+            extra = "," + new expressions_1.ParameterListSTranspiler().transpile(parameters, traversal).getCode();
+        }
+        return new chunk_1.Chunk().append(`await abap.statements.raiseEvent(this.${eventName}, this.me${extra});`, node, traversal);
     }
 }
 exports.RaiseEventTranspiler = RaiseEventTranspiler;

package/build/src/statements/set_handler.d.ts

@@ -4,4 +4,5 @@ import { Traversal } from "../traversal";
 import { Chunk } from "../chunk";
 export declare class SetHandlerTranspiler implements IStatementTranspiler {
     transpile(node: abaplint.Nodes.StatementNode, traversal: Traversal): Chunk;
+    private findEventClass;
 }

package/build/src/statements/set_handler.js

@@ -7,20 +7,62 @@ const expressions_1 = require("../expressions");
 class SetHandlerTranspiler {
     transpile(node, traversal) {
         const methods = [];
+        let className = undefined;
+        let eventName = undefined;
         for (const m of node.findDirectExpressions(abaplint.Expressions.MethodSource)) {
-            methods.push(new expressions_1.MethodSourceTranspiler().transpile(m, traversal).getCode());
+            methods.push(new expressions_1.MethodSourceTranspiler().transpile(m, traversal).getCode().replace("await ", ""));
+            if (className === 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);
+            }
         }
         let f = undefined;
         const forExpression = node.findExpressionAfterToken("FOR");
-        if (forExpression) {
+        if (forExpression instanceof abaplint.Expressions.Source) {
             f = new expressions_1.SourceTranspiler().transpile(forExpression, traversal).getCode();
         }
-        let activation = undefined;
+        else {
+            f = `"ALL"`;
+        }
+        let activation = "";
         const activationExpression = node.findExpressionAfterToken("ACTIVATION");
         if (activationExpression) {
-            activation = new expressions_1.SourceTranspiler().transpile(activationExpression, traversal).getCode();
+            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);
+    }
+    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);
+                    }
+                }
+            }
+            current = traversal.findClassDefinition(current.getSuperClass(), scope);
         }
-        return new chunk_1.Chunk().append(`abap.statements.setHandler([${methods.join(",")}], ${f}, ${activation});`, node, traversal);
+        throw new Error(`Transpiler: Event "${eventName}" not found in class "${def.getName()}"`);
     }
 }
 exports.SetHandlerTranspiler = SetHandlerTranspiler;

package/build/src/traversal.d.ts

@@ -42,6 +42,7 @@ export declare class Traversal {
     private buildThisAttributes;
     private buildFriendsAccess;
     buildConstructorContents(scope: abaplint.ISpaghettiScopeNode | undefined, def: abaplint.IClassDefinition): string;
+    private eventsFromInterfaces;
     findInterfaceDefinition(name: string, scope: abaplint.ISpaghettiScopeNode | undefined): abaplint.IInterfaceDefinition | undefined;
     findTable(name: string): abaplint.Objects.Table | undefined;
     findClassDefinition(name: string | undefined, scope: abaplint.ISpaghettiScopeNode | undefined): abaplint.IClassDefinition | undefined;

package/build/src/traversal.js

@@ -477,6 +477,7 @@ this.INTERNAL_ID = abap.internalIdCounter++;\n`;
         for (const i of def.getImplementing()) {
             ret += this.dataFromInterfaces(i.name, scope, cName);
             ret += this.aliasesFromInterfaces(i.name, scope, cName);
+            ret += this.eventsFromInterfaces(i.name, scope);
         }
         // handle aliases after initialization of carrier variables
         for (const a of def.getAliases() || []) {
@@ -486,6 +487,27 @@ this.INTERNAL_ID = abap.internalIdCounter++;\n`;
         for (const c of def.getAttributes()?.getConstants() || []) {
             ret += "this." + Traversal.escapeNamespace(c.getName().toLowerCase()) + " = " + cName + "." + Traversal.escapeNamespace(c.getName().toLowerCase()) + ";\n";
         }
+        for (const e of def.getEvents() || []) {
+            const name = this.buildInternalName(def.getName(), def);
+            ret += "this." + Traversal.escapeNamespace(e.getName().toLowerCase()) + " = {\"EVENT_NAME\": \"" + e.getName().toUpperCase() + "\", \"EVENT_CLASS\": \"" + name + "\"};\n";
+        }
+        return ret;
+    }
+    eventsFromInterfaces(name, scope) {
+        let ret = "";
+        const intf = this.findInterfaceDefinition(name, scope);
+        if (intf === undefined) {
+            return ret;
+        }
+        for (const e of intf.getEvents() || []) {
+            const fname = Traversal.escapeNamespace(e.getName().toLowerCase());
+            const iname = Traversal.escapeNamespace(intf?.getName().toLowerCase());
+            const name = this.buildInternalName(intf.getName(), intf);
+            ret += "this." + iname + "$" + fname + " = {\"EVENT_NAME\": \"" + e.getName().toUpperCase() + "\", \"EVENT_CLASS\": \"" + name + "\"};\n";
+        }
+        for (const i of intf.getImplementing() || []) {
+            ret += this.eventsFromInterfaces(i.name, scope);
+        }
         return ret;
     }
     findInterfaceDefinition(name, scope) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abaplint/transpiler",
-  "version": "2.11.0",
+  "version": "2.11.1",
   "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.113.150",
+    "@abaplint/core": "^2.113.151",
     "source-map": "^0.7.6"
   },
   "devDependencies": {