@open-rap/compiler 0.0.0-stage → 0.1.1

package/dist/gen/abap/rewrite.js

@@ -0,0 +1,957 @@
+/**
+ * The ABAP rewrite pass (decision D2): turns the behavior pools into standard ABAP that abaplint
+ * types completely and the transpiler accepts, without changing their meaning.
+ *
+ * - `FOR BEHAVIOR OF` is removed from the global class;
+ * - the RAP handler definitions (`METHODS x FOR VALIDATE ON SAVE …`) become plain methods whose
+ *   parameters are typed with the derived types of the BDEF;
+ * - `TYPE TABLE|STRUCTURE|RESPONSE FOR …` become references to the derived types interface;
+ * - every EML statement becomes a sequence of calls to the kernel class ZRAP_EML, with the `#`
+ *   of its operands made explicit and its inline declarations (`RESULT DATA(x)`) hoisted.
+ *
+ * Every replacement keeps the line count of the text it replaces, so that diagnostics on the
+ * rewritten sources point to the original lines.
+ */
+import { derivedType, derivedTypesInterfaceName, findEntity, same, } from "@open-rap/model";
+import { classifyMethodDefinition } from "../../ir/handlers.js";
+import { bdefAssociations } from "./derived-types.js";
+import { EmlSyntaxError, inferredTypeToken, inlineDeclaration, isEmlStatement, parseEml, } from "./eml.js";
+import { KERNEL_CLASS } from "./framework.js";
+import { adjacent, joinTokens, SourceEdits, toks } from "./tokens.js";
+export class BdefCatalog {
+    model;
+    bdefs = [];
+    constructor(model) {
+        this.model = model;
+        for (const behavior of model.behaviors.filter((b) => b.implementationType === "managed")) {
+            const info = { behavior, iface: derivedTypesInterfaceName(behavior.name).toLowerCase(), entities: [] };
+            behavior.entities.forEach((entity, i) => {
+                const cds = findEntity(model, entity.entity);
+                if (cds !== undefined) {
+                    info.entities.push({ bdef: info, behavior: entity, cds, index: i + 1 });
+                }
+            });
+            this.bdefs.push(info);
+        }
+    }
+    bdef(name) {
+        return this.bdefs.find((b) => same(b.behavior.name, name));
+    }
+    isProjection(name) {
+        return this.model.behaviors.some((b) => b.implementationType === "projection" && same(b.name, name));
+    }
+    entityOf(bdef, name) {
+        return bdef.entities.find((e) => same(e.behavior.alias, name) || same(e.behavior.entity, name));
+    }
+    /** An entity by its CDS name, in any managed BDEF. */
+    entityByName(name) {
+        for (const bdef of this.bdefs) {
+            const found = bdef.entities.find((e) => same(e.behavior.entity, name));
+            if (found !== undefined) {
+                return found;
+            }
+        }
+        return undefined;
+    }
+    associations(entity) {
+        const result = [];
+        for (const a of bdefAssociations(this.model, entity.bdef.behavior, entity.behavior)) {
+            const target = entity.bdef.entities.find((e) => e.index === a.targetIndex);
+            if (target !== undefined) {
+                result.push({ name: a.name, index: a.index, target });
+            }
+        }
+        return result;
+    }
+    association(entity, name) {
+        return this.associations(entity).find((a) => same(a.name, name.replace(/^\\/, "")));
+    }
+    action(entity, name) {
+        const index = entity.behavior.actions.findIndex((a) => same(a.name, name));
+        const action = entity.behavior.actions[index];
+        return action === undefined ? undefined : { action, index: index + 1 };
+    }
+}
+// ---------------------------------------------------------------------------------------------
+// Errors
+class RewriteError extends Error {
+    code;
+    token;
+    constructor(code, message, token) {
+        super(message);
+        this.code = code;
+        this.token = token;
+    }
+}
+function resolvePath(catalog, token, pool) {
+    const text = token.str;
+    const m = /^([^\\~]+)(?:\\\\([^\\~]+))?(?:\\([^\\~]+))?(?:~(.+))?$/.exec(text);
+    if (m === null) {
+        throw new RewriteError("ABP006", `cannot read the entity path ${text}`, token);
+    }
+    const [, head = "", alias, association, action] = m;
+    let entity;
+    if (alias !== undefined) {
+        const bdef = catalog.bdef(head);
+        if (bdef === undefined) {
+            throw unknownBdef(catalog, head, token);
+        }
+        entity = catalog.entityOf(bdef, alias);
+        if (entity === undefined) {
+            throw new RewriteError("ABP006", `${bdef.behavior.name} has no entity ${alias}`, token);
+        }
+    }
+    else {
+        entity = (pool === undefined ? undefined : catalog.entityOf(pool, head)) ?? catalog.entityByName(head);
+        if (entity === undefined) {
+            const bdef = catalog.bdef(head);
+            entity = bdef?.entities.find((e) => e.behavior.root) ?? bdef?.entities[0];
+        }
+        if (entity === undefined) {
+            throw unknownBdef(catalog, head, token);
+        }
+    }
+    const result = { entity };
+    if (association !== undefined) {
+        const found = catalog.association(entity, association);
+        if (found === undefined) {
+            throw new RewriteError("ABP006", `${entity.behavior.alias} has no association ${association} to an entity of ${entity.bdef.behavior.name}`, token);
+        }
+        result.association = found;
+    }
+    if (action !== undefined) {
+        const found = catalog.action(entity, action);
+        if (found === undefined) {
+            throw new RewriteError("ABP006", `${entity.behavior.alias} has no action or function ${action}`, token);
+        }
+        result.action = found;
+    }
+    return result;
+}
+function unknownBdef(catalog, name, token) {
+    if (catalog.isProjection(name)) {
+        return new RewriteError("ABP007", `EML and derived types of the projection ${name.toUpperCase()} are not supported: use the base behavior definition`, token);
+    }
+    return new RewriteError("ABP006", `unknown behavior definition or entity ${name} (it must be a managed BDEF of the service)`, token);
+}
+// ---------------------------------------------------------------------------------------------
+// TYPE TABLE|STRUCTURE|RESPONSE|REQUEST FOR …
+const TYPE_KINDS = new Set(["TABLE", "STRUCTURE", "RESPONSE", "REQUEST"]);
+/** Derived type of `TYPE <shape> FOR <words> <path>`, as `iface=>name`. */
+function derivedTypeName(catalog, shape, words, pathToken, pool) {
+    const key = words.join(" ");
+    const fail = () => {
+        throw new RewriteError("ABP007", `TYPE ${shape} FOR ${key} is not supported`, pathToken);
+    };
+    if (shape === "REQUEST") {
+        if (key !== "CHANGE" && key !== "DELETE") {
+            return fail();
+        }
+        const path = resolvePath(catalog, pathToken, pool);
+        return `${path.entity.bdef.iface}=>${key === "CHANGE" ? derivedType.requestChange : derivedType.requestDelete}`;
+    }
+    if (shape === "RESPONSE") {
+        const m = /^(FAILED|REPORTED|MAPPED)(?: (EARLY|LATE))?$/.exec(key);
+        if (m === null) {
+            return fail();
+        }
+        const path = resolvePath(catalog, pathToken, pool);
+        const late = m[2] === "LATE";
+        const name = { FAILED: late ? derivedType.failedLate : derivedType.failedEarly, REPORTED: late ? derivedType.reportedLate : derivedType.reportedEarly, MAPPED: late ? derivedType.mappedLate : derivedType.mappedEarly }[m[1]];
+        return `${path.entity.bdef.iface}=>${name}`;
+    }
+    const table = shape === "TABLE";
+    const path = resolvePath(catalog, pathToken, pool);
+    const e = path.entity.index;
+    const b = path.association?.index;
+    const a = path.action?.index;
+    const needAssociation = () => b ?? fail();
+    const needAction = () => a ?? fail();
+    const response = key.replace(/ (EARLY|LATE)$/, "");
+    let name;
+    switch (response) {
+        case "CHANGE":
+            name = table ? derivedType.change(e) : derivedType.changeRow(e);
+            break;
+        case "CREATE":
+            name = b === undefined ? (table ? derivedType.create(e) : derivedType.createRow(e)) : table ? derivedType.assocCreate(e, b) : `ts_e${e}_b${b}_cre`;
+            break;
+        case "UPDATE":
+            name = table ? derivedType.update(e) : derivedType.updateRow(e);
+            break;
+        case "DELETE":
+            name = table ? derivedType.delete(e) : `ts_e${e}_del`;
+            break;
+        case "LOCK":
+            name = table ? derivedType.lock(e) : `ts_e${e}_lock`;
+            break;
+        case "READ IMPORT":
+            name = b === undefined ? (table ? derivedType.readImport(e) : `ts_e${e}_rimp`) : table ? derivedType.assocReadImport(e, b) : `ts_e${e}_b${b}_rimp`;
+            break;
+        case "READ RESULT":
+            name =
+                b === undefined
+                    ? table
+                        ? derivedType.readResult(e)
+                        : derivedType.readResultRow(e)
+                    : table
+                        ? derivedType.assocReadResult(e, b)
+                        : derivedType.readResultRow(path.association.target.index);
+            break;
+        case "READ LINK":
+            name = table ? derivedType.assocLink(e, needAssociation()) : `ts_e${e}_b${needAssociation()}_link`;
+            break;
+        case "ACTION IMPORT":
+        case "FUNCTION IMPORT":
+            name = table ? derivedType.actionImport(e, needAction()) : `ts_e${e}_a${needAction()}_imp`;
+            break;
+        case "ACTION RESULT":
+        case "FUNCTION RESULT":
+            name = table ? derivedType.actionResult(e, needAction()) : `ts_e${e}_a${needAction()}_res`;
+            break;
+        case "FAILED":
+            name = table ? derivedType.failedRows(e) : `ts_e${e}_failr`;
+            break;
+        case "REPORTED":
+            name = table ? derivedType.reportedRows(e) : `ts_e${e}_repr`;
+            break;
+        case "MAPPED":
+            name = table ? derivedType.mappedRows(e) : `ts_e${e}_mapr`;
+            break;
+        case "DETERMINATION":
+        case "VALIDATION":
+        case "KEY OF":
+        case "AUTHORIZATION KEY":
+        case "INSTANCE AUTHORIZATION KEY":
+        case "INSTANCE FEATURES KEY":
+            name = table ? derivedType.keys(e) : `ts_e${e}_keys`;
+            break;
+        case "AUTHORIZATION REQUEST":
+        case "INSTANCE AUTHORIZATION REQUEST":
+            name = table ? fail() : derivedType.instanceAuthRequest(e);
+            break;
+        case "AUTHORIZATION RESULT":
+        case "INSTANCE AUTHORIZATION RESULT":
+            name = table ? derivedType.instanceAuthResult(e) : `ts_e${e}_iauth_r`;
+            break;
+        case "GLOBAL AUTHORIZATION REQUEST":
+            name = table ? fail() : derivedType.globalAuthRequest(e);
+            break;
+        case "GLOBAL AUTHORIZATION RESULT":
+            name = table ? fail() : derivedType.globalAuthResult(e);
+            break;
+        case "INSTANCE FEATURES REQUEST":
+            name = table ? fail() : derivedType.instanceFeaturesRequest(e);
+            break;
+        case "INSTANCE FEATURES RESULT":
+            name = table ? derivedType.instanceFeaturesResult(e) : `ts_e${e}_ifeat_r`;
+            break;
+        case "GLOBAL FEATURES REQUEST":
+            name = table ? fail() : derivedType.globalFeaturesRequest(e);
+            break;
+        case "GLOBAL FEATURES RESULT":
+            name = table ? fail() : derivedType.globalFeaturesResult(e);
+            break;
+        default:
+            return fail();
+    }
+    return `${path.entity.bdef.iface}=>${name}`;
+}
+const TYPE_WORDS = new Set([
+    "CREATE",
+    "UPDATE",
+    "DELETE",
+    "LOCK",
+    "READ",
+    "IMPORT",
+    "RESULT",
+    "LINK",
+    "ACTION",
+    "FUNCTION",
+    "FAILED",
+    "REPORTED",
+    "MAPPED",
+    "EARLY",
+    "LATE",
+    "DETERMINATION",
+    "VALIDATION",
+    "KEY",
+    "OF",
+    "INSTANCE",
+    "GLOBAL",
+    "AUTHORIZATION",
+    "FEATURES",
+    "REQUEST",
+    "CHANGE",
+    "PERMISSIONS",
+    "HIERARCHY",
+    "EVENT",
+    "ONLY",
+    "ENTITY",
+]);
+/** Glues a path token with the tokens written against it (`zr_travel`, `\`, `\travel`). */
+function gluePath(tokens, start) {
+    const first = tokens[start];
+    let last = first;
+    let text = first.str;
+    let i = start + 1;
+    for (; i < tokens.length; i++) {
+        const t = tokens[i];
+        if (!(last.endRow === t.row && last.endCol === t.col) || t.str === "." || t.str === ",") {
+            break;
+        }
+        text += t.str;
+        last = t;
+    }
+    return { token: { ...first, str: text, upper: text.toUpperCase(), endRow: last.endRow, endCol: last.endCol }, next: i };
+}
+/**
+ * Consumption model classes generated by a service consumption model (SCM2): `INHERITING FROM
+ * /iwbep/cl_v4_abs_pm_model_prov`. Their model definition uses the /iwbep/if_v4_pm_* interfaces of
+ * the SAP Gateway; the client proxy of the application reads the $metadata of the remote service
+ * instead, so the rewrite keeps the types and constants of these classes only (D31).
+ */
+export function findModelProviders(files) {
+    const providers = new Set();
+    for (const file of files) {
+        for (const statement of file.getStatements()) {
+            if (statement.get().constructor.name !== "ClassDefinition") {
+                continue;
+            }
+            const m = /^CLASS (\S+) DEFINITION .*INHERITING FROM \/IWBEP\/CL_V4_ABS_PM_MODEL_PROV\b/i.exec(statement.concatTokens().replace(/\s+/g, " "));
+            if (m !== null) {
+                providers.add((m[1] ?? "").toUpperCase());
+            }
+        }
+    }
+    return providers;
+}
+/** Statements of the definition of a consumption model class that stay: its types and constants. */
+const MODEL_PROVIDER_KEPT = new Set(["ClassDefinition", "Public", "Protected", "Private", "Type", "TypeBegin", "TypeEnd", "TypeEnumBegin", "TypeEnumEnd", "Constant", "ConstantBegin", "ConstantEnd", "EndClass", "ClassImplementation"]);
+/** Local saver classes of an object: `INHERITING FROM cl_abap_behavior_saver[_failed]`. */
+export function findSaverClasses(files) {
+    const savers = new Map();
+    for (const file of files) {
+        for (const statement of file.getStatements()) {
+            if (statement.get().constructor.name !== "ClassDefinition") {
+                continue;
+            }
+            const text = statement.concatTokens().replace(/\s+/g, " ");
+            const m = /^CLASS (\S+) DEFINITION .*INHERITING FROM (CL_ABAP_BEHAVIOR_SAVER(?:_FAILED)?)\b/i.exec(text);
+            if (m !== null) {
+                savers.set((m[1] ?? "").toUpperCase(), (m[2] ?? "").toUpperCase().endsWith("_FAILED"));
+            }
+        }
+    }
+    return savers;
+}
+const KERNEL = KERNEL_CLASS.toLowerCase();
+const literal = (s) => `\`${s.toUpperCase()}\``;
+/** Rewrites one ABAP file of a class or interface; returns the new source. */
+export function rewriteAbapFile(file, context) {
+    const edits = new SourceEdits(file.getRaw());
+    let methodStart;
+    for (const statement of file.getStatements()) {
+        const tokens = toks(statement.getTokens());
+        if (tokens.length === 0) {
+            continue;
+        }
+        const kind = statement.get().constructor.name;
+        if (kind === "ClassDefinition" || kind === "ClassImplementation") {
+            context.current = { name: (tokens[1]?.str ?? "").toUpperCase(), part: kind === "ClassDefinition" ? "definition" : "implementation" };
+        }
+        else if (kind === "EndClass") {
+            context.current = undefined;
+        }
+        if (context.current !== undefined && context.modelProviders?.has(context.current.name) === true) {
+            // a consumption model class: its types and constants only
+            if (kind === "MethodImplementation") {
+                methodStart = tokens[0];
+            }
+            else if (kind === "EndMethod" && methodStart !== undefined) {
+                edits.replace(methodStart, tokens[tokens.length - 1], "");
+                methodStart = undefined;
+            }
+            else if (methodStart === undefined && !MODEL_PROVIDER_KEPT.has(kind) && kind !== "Comment" && kind !== "Empty") {
+                edits.replace(tokens[0], tokens[tokens.length - 1], "");
+            }
+            continue;
+        }
+        try {
+            rewriteStatement(kind, tokens, edits, context);
+        }
+        catch (error) {
+            if (error instanceof RewriteError) {
+                const at = error.token ?? tokens[0];
+                context.diagnostics.error(error.code, error.message, { file: context.file, line: at?.row ?? 1, column: at?.col ?? 1 });
+            }
+            else if (error instanceof EmlSyntaxError) {
+                const at = error.token ?? tokens[tokens.length - 1];
+                context.diagnostics.error("ABP005", `EML: ${error.message}`, { file: context.file, line: at?.row ?? 1, column: at?.col ?? 1 });
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    return edits.size === 0 ? file.getRaw() : edits.apply();
+}
+/**
+ * abaplint statements of ABAP SQL that a behavior pool cannot use (decision D26): the writes (a
+ * managed business object is written by the RAP runtime, the code changes it with EML) and the
+ * common table expressions, which the transpiler does not translate. SELECT and the cursors read
+ * the tables and CDS entities of the application.
+ */
+const SQL_WRITES = new Set(["InsertDatabase", "UpdateDatabase", "ModifyDatabase", "DeleteDatabase"]);
+const SQL_CTE = new Set(["WithLoop", "With"]);
+function rewriteStatement(kind, tokens, edits, context) {
+    const last = tokens[tokens.length - 1];
+    if (isEmlStatement(tokens)) {
+        if (last.str !== ".") {
+            throw new RewriteError("ABP005", "EML statements cannot be chained", tokens[0]);
+        }
+        const statement = parseEml(tokens.slice(0, -1));
+        edits.replace(tokens[0], last, emlCode(statement, context));
+        return;
+    }
+    const inSaver = context.current !== undefined && context.saverClasses?.has(context.current.name) === true;
+    if (SQL_WRITES.has(kind)) {
+        if (!inSaver || context.current?.part !== "implementation") {
+            throw new RewriteError("ABP007", `${tokens[0]?.upper ?? ""} on a database table is only possible in the saver class (save_modified, with additional or unmanaged save): the RAP runtime writes the business object, change it with EML (MODIFY ENTITIES)`, tokens[0]);
+        }
+        const mapping = tokens.some((t, n) => t.upper === "MAPPING" && tokens[n + 1]?.upper === "FROM" && tokens[n + 2]?.upper === "ENTITY");
+        if (kind === "DeleteDatabase" && !mapping && tokens[2]?.upper === "FROM" && tokens[3]?.str === "@") {
+            // the transpiler drops the work area of DELETE dbtab FROM @wa: the statement would delete every row
+            throw new RewriteError("ABP007", "DELETE dbtab FROM @wa is not supported by the transpiler (it would delete every row): use DELETE FROM dbtab WHERE …, DELETE dbtab FROM TABLE @itab or MAPPING FROM ENTITY", tokens[0]);
+        }
+        lowerEntityMapping(tokens, edits);
+        return;
+    }
+    if (kind === "MethodDef" && inSaver && context.current?.part === "definition" && rewriteSaverMethod(tokens, edits, context)) {
+        return;
+    }
+    if (SQL_CTE.has(kind)) {
+        throw new RewriteError("ABP007", "common table expressions (WITH) are not supported by the transpiler", tokens[0]);
+    }
+    if (kind === "SelectLoop" && !selectsAllFields(tokens)) {
+        throw new RewriteError("ABP007", "SELECT … ENDSELECT with a field list is not supported by the transpiler (the loop reads whole rows into the target): use SELECT *, or INTO TABLE and LOOP AT", tokens[0]);
+    }
+    if (kind === "Select" || kind === "SelectLoop") {
+        hostComponentsAsExpressions(tokens, edits);
+        if (kind === "Select") {
+            declareSelectTarget(tokens, edits);
+        }
+        return;
+    }
+    const head = `${tokens[0]?.upper ?? ""} ${tokens[1]?.upper ?? ""}`;
+    if (head === "GET PERMISSIONS" || head === "SET LOCKS" || (head === "RAISE ENTITY" && tokens[2]?.upper === "EVENT")) {
+        throw new RewriteError("ABP007", `${head} is not supported`, tokens[0]);
+    }
+    if (kind === "ClassDefinition") {
+        const i = tokens.findIndex((t, n) => t.upper === "FOR" && tokens[n + 1]?.upper === "BEHAVIOR" && tokens[n + 2]?.upper === "OF");
+        if (i >= 0 && tokens[i + 3] !== undefined) {
+            edits.replace(tokens[i], tokens[i + 3], "");
+        }
+        return;
+    }
+    if (kind === "MethodDef" && rewriteHandlerDefinition(tokens, edits, context)) {
+        return;
+    }
+    rewriteDerivedTypes(tokens, edits, context);
+}
+/** Host variables that are targets or the table of FOR ALL ENTRIES, not operands. */
+const HOST_TARGETS = new Set(["INTO", "APPENDING", "TABLE", "OF", "IN", "TO", "OFFSET"]);
+/**
+ * In a SELECT with alias fields (`t~col`), @abaplint/transpiler reads a host variable with a
+ * component (`@ls-comp`) as a subtraction (`ls - comp`). The rewrite writes it as the equivalent
+ * host expression `@( ls-comp )`, which it translates right. Targets of INTO and the table of
+ * FOR ALL ENTRIES are left as they are.
+ */
+function hostComponentsAsExpressions(tokens, edits) {
+    if (!tokens.some((t) => t.str.includes("~"))) {
+        return;
+    }
+    const entries = tokens.findIndex((t, n) => t.upper === "ENTRIES" && tokens[n - 1]?.upper === "ALL" && tokens[n + 1]?.upper === "IN");
+    const driver = entries < 0 ? undefined : tokens[entries + 3]?.upper;
+    for (let i = 0; i < tokens.length; i++) {
+        const at = tokens[i];
+        const name = tokens[i + 1];
+        if (at.str !== "@" || name === undefined || !adjacent(at, name) || !/^[A-Za-z_%/]/.test(name.str) || HOST_TARGETS.has(tokens[i - 1]?.upper ?? "") || name.upper === driver) {
+            continue;
+        }
+        let last = i + 1;
+        while (tokens[last + 1]?.str === "-" && adjacent(tokens[last], tokens[last + 1]) && tokens[last + 2] !== undefined && adjacent(tokens[last + 1], tokens[last + 2])) {
+            last += 2;
+        }
+        if (last > i + 1) {
+            edits.replace(at, tokens[last], `@( ${joinTokens(tokens.slice(i + 1, last + 1))} )`);
+        }
+        i = last;
+    }
+}
+/**
+ * The saver methods of a managed BO with additional or unmanaged save, declared by redefinition:
+ * save_modified gets its parameters typed with the derived types of the BDEF (REQUEST FOR CHANGE,
+ * REQUEST FOR DELETE, RESPONSE FOR REPORTED/FAILED LATE), the others become plain methods.
+ */
+function rewriteSaverMethod(tokens, edits, context) {
+    const name = tokens[1];
+    const redefinition = tokens[2];
+    if (name === undefined || redefinition?.upper !== "REDEFINITION") {
+        return false;
+    }
+    const method = name.upper;
+    if (method === "ADJUST_NUMBERS") {
+        throw new RewriteError("ABP007", "adjust_numbers (late numbering) is not supported", name);
+    }
+    if (method !== "SAVE_MODIFIED") {
+        edits.replace(redefinition, redefinition, "");
+        return true;
+    }
+    const pool = context.pool;
+    if (pool === undefined) {
+        throw new RewriteError("ABP007", "save_modified outside of the behavior pool of a BDEF", name);
+    }
+    const t = (type) => `${pool.iface}=>${type}`;
+    const failed = context.saverClasses?.get(context.current?.name ?? "") === true ? ` failed TYPE ${t(derivedType.failedLate)}` : "";
+    edits.replace(redefinition, redefinition, `IMPORTING create TYPE ${t(derivedType.requestChange)} update TYPE ${t(derivedType.requestChange)} delete TYPE ${t(derivedType.requestDelete)} CHANGING reported TYPE ${t(derivedType.reportedLate)}${failed}`);
+    return true;
+}
+/**
+ * `INSERT|UPDATE|MODIFY|DELETE dbtab FROM [TABLE] @src [INDICATORS SET STRUCTURE %control]
+ * MAPPING FROM ENTITY`: the BDEF mapping of the entity to the table is applied by the kernel, which
+ * writes the rows (the transpiler does not know these RAP additions). Other writes are left to the
+ * transpiler.
+ */
+function lowerEntityMapping(tokens, edits) {
+    const mapping = tokens.findIndex((t, n) => t.upper === "MAPPING" && tokens[n + 1]?.upper === "FROM" && tokens[n + 2]?.upper === "ENTITY");
+    if (mapping < 0) {
+        return;
+    }
+    const operation = tokens[0]?.upper ?? "";
+    const table = tokens[1];
+    const from = tokens[2];
+    if (table === undefined || from?.upper !== "FROM") {
+        throw new RewriteError("ABP007", `${operation} … MAPPING FROM ENTITY: only the form ${operation} dbtab FROM [TABLE] @source is supported`, tokens[0]);
+    }
+    const isTable = tokens[3]?.upper === "TABLE";
+    const sourceStart = isTable ? 4 : 3;
+    const indicators = tokens.findIndex((t, n) => t.upper === "INDICATORS" && n > sourceStart);
+    const sourceEnd = indicators >= 0 ? indicators : mapping;
+    const source = tokens.slice(sourceStart, sourceEnd);
+    if (source[0]?.str !== "@" || source.length < 2) {
+        throw new RewriteError("ABP007", `${operation} … MAPPING FROM ENTITY: the source must be a host variable (@source)`, tokens[sourceStart]);
+    }
+    let operand = joinTokens(source.slice(1));
+    if (source[1]?.str === "(" && source[source.length - 1]?.str === ")") {
+        operand = joinTokens(source.slice(2, -1));
+    }
+    const last = tokens[tokens.length - 1];
+    const end = last.str === "." ? tokens[tokens.length - 2] : last;
+    const flags = indicators >= 0 ? " indicators = abap_true" : "";
+    edits.replace(tokens[0], end, `${KERNEL}=>sql_write( operation = ${literal(operation)} table = ${literal(table.str)} ${isTable ? "rows" : "row"} = ${operand}${flags} )`);
+}
+/** `SELECT *` or `SELECT FROM … FIELDS *`. */
+function selectsAllFields(tokens) {
+    let i = 1;
+    while (tokens[i]?.upper === "SINGLE" || tokens[i]?.upper === "DISTINCT") {
+        i++;
+    }
+    if (tokens[i]?.upper !== "FROM") {
+        return tokens[i]?.str === "*";
+    }
+    const fields = tokens.findIndex((t) => t.upper === "FIELDS");
+    return fields >= 0 && tokens[fields + 1]?.str === "*";
+}
+const SELECT_CLAUSES = new Set(["WHERE", "GROUP", "HAVING", "ORDER", "INTO", "APPENDING", "UP", "FOR", "BYPASSING", "CLIENT", "USING", "%_HINTS"]);
+/**
+ * The result of a SELECT that abaplint does not type, in its two most common forms (decision
+ * D26): the literal of an existence check (`SELECT SINGLE @abap_true … INTO @DATA(exists)`) and a
+ * single MAX or MIN of one table or entity (`SELECT SINGLE FROM t FIELDS MAX( id ) INTO
+ * @DATA(max_id)`). The inline declaration becomes a declaration in front of the statement, on the
+ * same line, with the type ABAP gives the result: abap_boolean, the column's type. Other untyped
+ * results are reported by the check (ABP009).
+ */
+function declareSelectTarget(tokens, edits) {
+    const into = tokens.findIndex((t, n) => t.upper === "INTO" && tokens[n + 1]?.str === "@" && (tokens[n + 2]?.upper === "DATA" || tokens[n + 2]?.upper === "FINAL") && tokens[n + 3]?.str === "(" && tokens[n + 5]?.str === ")");
+    const from = tokens.findIndex((t) => t.upper === "FROM");
+    const name = tokens[into + 4];
+    const source = tokens[from + 1];
+    if (into < 0 || from < 0 || name === undefined || source === undefined || tokens.some((t) => t.upper === "JOIN")) {
+        return;
+    }
+    const alias = tokens[from + 2]?.upper === "AS" ? tokens[from + 3]?.upper : undefined;
+    const fields = tokens.findIndex((t) => t.upper === "FIELDS");
+    let list;
+    if (fields >= 0) {
+        const end = tokens.findIndex((t, n) => n > fields && SELECT_CLAUSES.has(t.upper));
+        list = tokens.slice(fields + 1, end < 0 ? tokens.length - 1 : end);
+    }
+    else {
+        list = tokens.slice(tokens[1]?.upper === "SINGLE" ? 2 : 1, from);
+    }
+    if (list.length === 4 || list.length === 2) {
+        // an alias of the result does not change its type
+    }
+    else if (list.length === 6 && list[4]?.upper === "AS") {
+        list = list.slice(0, 4);
+    }
+    else {
+        return;
+    }
+    let type;
+    const [first, second, column, close] = list;
+    if (list.length === 2 && first?.str === "@" && (second?.upper === "ABAP_TRUE" || second?.upper === "ABAP_FALSE")) {
+        type = "abap_boolean";
+    }
+    else if ((first?.upper === "MAX" || first?.upper === "MIN") && second?.str === "(" && close?.str === ")" && column !== undefined) {
+        const [prefix, field] = column.str.includes("~") ? column.str.split("~") : [undefined, column.str];
+        if (prefix === undefined || prefix.toUpperCase() === alias || prefix.toUpperCase() === source.upper) {
+            type = `${source.str}-${field}`;
+        }
+    }
+    if (type === undefined) {
+        return;
+    }
+    edits.replace(tokens[into + 1], tokens[into + 5], `@${name.str}`);
+    edits.replace(tokens[0], tokens[0], `DATA ${name.str} TYPE ${type}. ${tokens[0]?.str ?? "SELECT"}`);
+}
+/** `TYPE TABLE FOR UPDATE zr_travel\\travel` → `TYPE zrap_dt_zr_travel=>tt_e1_upd`. */
+function rewriteDerivedTypes(tokens, edits, context) {
+    for (let i = 0; i + 3 < tokens.length; i++) {
+        const type = tokens[i];
+        const shape = tokens[i + 1];
+        if (type.upper !== "TYPE" || !TYPE_KINDS.has(shape.upper) || tokens[i + 2]?.upper !== "FOR") {
+            continue;
+        }
+        const words = [];
+        let j = i + 3;
+        while (j < tokens.length && TYPE_WORDS.has(tokens[j].upper) && j + 1 < tokens.length && tokens[j + 1]?.str !== "." && tokens[j + 1]?.str !== ",") {
+            words.push(tokens[j].upper);
+            j++;
+        }
+        if (j >= tokens.length) {
+            throw new RewriteError("ABP007", `TYPE ${shape.upper} FOR ${words.join(" ")}: entity missing`, shape);
+        }
+        const { token: path, next } = gluePath(tokens, j);
+        const name = derivedTypeName(context.catalog, shape.upper, words, path, context.pool);
+        edits.replace(type, tokens[next - 1], `TYPE ${name}`);
+        i = next - 1;
+    }
+}
+// ---------------------------------------------------------------------------------------------
+// Handler definitions
+function rewriteHandlerDefinition(tokens, edits, context) {
+    const classified = classifyMethodDefinition(joinTokens(tokens));
+    if (classified === undefined) {
+        return false;
+    }
+    const { kind, params } = classified;
+    if (kind.kind === "other") {
+        if (/^(EVENT|TESTING)\b/i.test(kind.text)) {
+            return false;
+        }
+        throw new RewriteError("ABP007", `handler method FOR ${kind.text.split(" ").slice(0, 3).join(" ")} is not supported in a managed behavior pool`, tokens[2]);
+    }
+    const forIndex = tokens.findIndex((t, n) => n >= 2 && t.upper === "FOR");
+    const last = tokens[tokens.length - 1];
+    const end = last.str === "." || last.str === "," ? tokens[tokens.length - 2] : last;
+    if (forIndex < 0 || end === undefined) {
+        return false;
+    }
+    const aliasText = kind.alias.split("\\")[0] ?? kind.alias;
+    const entity = resolveHandlerEntity(context, aliasText, tokens[forIndex]);
+    const t = (name) => `${entity.bdef.iface}=>${name}`;
+    const e = entity.index;
+    const importing = [];
+    const changing = [];
+    const param = (role, fallback) => params[role] ?? fallback;
+    const responses = (late, mapped) => {
+        if (mapped) {
+            changing.push(["mapped", t(late ? derivedType.mappedLate : derivedType.mappedEarly)]);
+        }
+        changing.push(["failed", t(late ? derivedType.failedLate : derivedType.failedEarly)]);
+        changing.push(["reported", t(late ? derivedType.reportedLate : derivedType.reportedEarly)]);
+    };
+    const actionOf = (name) => {
+        const found = context.catalog.action(entity, name);
+        if (found === undefined) {
+            throw new RewriteError("ABP006", `${entity.behavior.alias} has no action or function ${name}`, tokens[forIndex]);
+        }
+        return found;
+    };
+    switch (kind.kind) {
+        case "validation":
+            importing.push([param("keys", "keys"), t(derivedType.keys(e))]);
+            responses(true, false);
+            break;
+        case "determination": {
+            const determination = entity.behavior.determinations.find((d) => same(d.name, kind.name));
+            importing.push([param("keys", "keys"), t(derivedType.keys(e))]);
+            responses(determination?.on === "save", false);
+            break;
+        }
+        case "action":
+        case "function": {
+            const { index: a } = actionOf(kind.name);
+            importing.push([param("keys", "keys"), t(derivedType.actionImport(e, a))]);
+            if (params.result !== undefined) {
+                changing.push([params.result, t(derivedType.actionResult(e, a))]);
+            }
+            responses(false, kind.kind === "action");
+            break;
+        }
+        case "globalAuthorization":
+            importing.push([param("requested", "requested_authorizations"), t(derivedType.globalAuthRequest(e))]);
+            changing.push([param("result", "result"), t(derivedType.globalAuthResult(e))]);
+            responses(false, false);
+            break;
+        case "instanceAuthorization":
+            importing.push([param("keys", "keys"), t(derivedType.keys(e))]);
+            importing.push([param("requested", "requested_authorizations"), t(derivedType.instanceAuthRequest(e))]);
+            changing.push([param("result", "result"), t(derivedType.instanceAuthResult(e))]);
+            responses(false, false);
+            break;
+        case "globalFeatures":
+            importing.push([param("requested", "requested_features"), t(derivedType.globalFeaturesRequest(e))]);
+            changing.push([param("result", "result"), t(derivedType.globalFeaturesResult(e))]);
+            responses(false, false);
+            break;
+        case "instanceFeatures":
+            importing.push([param("keys", "keys"), t(derivedType.keys(e))]);
+            importing.push([param("requested", "requested_features"), t(derivedType.instanceFeaturesRequest(e))]);
+            changing.push([param("result", "result"), t(derivedType.instanceFeaturesResult(e))]);
+            responses(false, false);
+            break;
+        case "numbering": {
+            const association = kind.alias.includes("\\") ? kind.alias.slice(kind.alias.indexOf("\\") + 1) : undefined;
+            const found = association === undefined ? undefined : context.catalog.association(entity, association);
+            if (association !== undefined && found === undefined) {
+                throw new RewriteError("ABP006", `${entity.behavior.alias} has no association ${association}`, tokens[forIndex]);
+            }
+            importing.push([param("entities", "entities"), t(found === undefined ? derivedType.create(e) : derivedType.assocCreate(e, found.index))]);
+            responses(false, true);
+            break;
+        }
+        case "precheck": {
+            const [operation = "", detail] = kind.operation.split(":");
+            let type;
+            if (operation === "action") {
+                type = derivedType.actionImport(e, actionOf(detail ?? "").index);
+            }
+            else if (operation === "create" && detail !== undefined) {
+                const found = context.catalog.association(entity, detail);
+                if (found === undefined) {
+                    throw new RewriteError("ABP006", `${entity.behavior.alias} has no association ${detail}`, tokens[forIndex]);
+                }
+                type = derivedType.assocCreate(e, found.index);
+            }
+            else if (operation === "create") {
+                type = derivedType.create(e);
+            }
+            else if (operation === "update") {
+                type = derivedType.update(e);
+            }
+            else {
+                type = derivedType.delete(e);
+            }
+            importing.push([param("entities", "entities"), t(type)]);
+            responses(false, false);
+            break;
+        }
+    }
+    const signature = [
+        importing.length === 0 ? "" : `IMPORTING ${importing.map(([n, ty]) => `${n} TYPE ${ty}`).join(" ")}`,
+        changing.length === 0 ? "" : `CHANGING ${changing.map(([n, ty]) => `${n} TYPE ${ty}`).join(" ")}`,
+    ]
+        .filter((s) => s !== "")
+        .join(" ");
+    edits.replace(tokens[forIndex], end, signature);
+    return true;
+}
+function resolveHandlerEntity(context, alias, at) {
+    const { catalog, pool } = context;
+    const entity = (pool === undefined ? undefined : catalog.entityOf(pool, alias)) ??
+        catalog.entityByName(alias) ??
+        catalog.bdefs.map((b) => catalog.entityOf(b, alias)).find((e) => e !== undefined);
+    if (entity === undefined) {
+        throw new RewriteError("ABP006", `handler for ${alias}: no entity with this alias in the managed behavior definitions`, at);
+    }
+    return entity;
+}
+// ---------------------------------------------------------------------------------------------
+// EML
+function emlCode(statement, context) {
+    const { catalog } = context;
+    const declarations = [];
+    const calls = [];
+    const source = (operand, iface, type) => {
+        const hash = inferredTypeToken(operand);
+        return joinTokens(operand.tokens, hash === undefined ? undefined : new Map([[hash, `${iface}=>${type}`]]));
+    };
+    const target = (operand, iface, type) => {
+        const name = inlineDeclaration(operand);
+        if (name !== undefined) {
+            declarations.push(`DATA ${name} TYPE ${iface}=>${type}.`);
+            return name;
+        }
+        return joinTokens(operand.tokens);
+    };
+    const changingPart = (pairs) => {
+        const given = pairs.filter((p) => p[1] !== undefined);
+        return given.length === 0 ? "" : ` CHANGING ${given.map(([n, v]) => `${n} = ${v}`).join(" ")}`;
+    };
+    /** `name( a = 1 b = 2 )`, or `name( EXPORTING a = 1 CHANGING c = x )` when there are changing parameters. */
+    const call = (method, exporting, changing) => `${KERNEL}=>${method}(${changing === "" ? exporting : `${exporting === "" ? "" : ` EXPORTING${exporting}`}${changing}`} ).`;
+    if (statement.kind === "rollback") {
+        return `${KERNEL}=>rollback( ).`;
+    }
+    if (statement.kind === "commit") {
+        calls.push(`${KERNEL}=>commit(${statement.simulation ? " simulation = abap_true " : " "}).`);
+        for (const response of statement.responses) {
+            const bdef = catalog.bdef(response.bdef.str);
+            if (bdef === undefined) {
+                throw unknownBdef(catalog, response.bdef.str, response.bdef);
+            }
+            const failed = response.failed === undefined ? undefined : target(response.failed, bdef.iface, derivedType.failedLate);
+            const reported = response.reported === undefined ? undefined : target(response.reported, bdef.iface, derivedType.reportedLate);
+            calls.push(call("commit_response", ` bdef = ${literal(bdef.behavior.name)}`, changingPart([["failed", failed], ["reported", reported]])));
+        }
+        return [...declarations, ...calls].join(" ");
+    }
+    // the BDEF of the statement and the entities of its groups
+    let bdef;
+    const groupEntity = [];
+    if (statement.bdef !== undefined) {
+        bdef = catalog.bdef(statement.bdef.str);
+        if (bdef === undefined) {
+            throw unknownBdef(catalog, statement.bdef.str, statement.bdef);
+        }
+        for (const group of statement.groups) {
+            const entity = catalog.entityOf(bdef, group.entity.str);
+            if (entity === undefined) {
+                throw new RewriteError("ABP006", `${bdef.behavior.name} has no entity ${group.entity.str}`, group.entity);
+            }
+            groupEntity.push(entity);
+        }
+    }
+    else {
+        const group = statement.groups[0];
+        if (group === undefined) {
+            throw new RewriteError("ABP005", "EML statement without entity");
+        }
+        const resolved = resolvePath(catalog, group.entity, undefined);
+        if (resolved.association !== undefined || resolved.action !== undefined) {
+            throw new RewriteError("ABP005", `the entity of a short EML form is written without association or action: ${group.entity.str}`, group.entity);
+        }
+        bdef = resolved.entity.bdef;
+        groupEntity.push(resolved.entity);
+    }
+    const iface = bdef.iface;
+    const B = literal(bdef.behavior.name);
+    const fieldArgs = (spec, entity, operation) => {
+        switch (spec.kind) {
+            case "all":
+                return " fields = `*`";
+            case "set":
+                if (operation === "read") {
+                    throw new RewriteError("ABP005", "SET FIELDS WITH is not allowed in READ ENTITIES");
+                }
+                return " set_fields = abap_true";
+            case "from":
+                return "";
+            case "list": {
+                for (const field of spec.fields) {
+                    if (!entity.cds.fields.some((f) => same(f.name, field.str))) {
+                        throw new RewriteError("ABP006", `${entity.behavior.alias} has no field ${field.str}`, field);
+                    }
+                }
+                return ` fields = ${literal(spec.fields.map((f) => f.str).join(" "))}`;
+            }
+        }
+    };
+    statement.groups.forEach((group, g) => {
+        const entity = groupEntity[g];
+        const e = entity.index;
+        const E = literal(entity.behavior.entity);
+        const head = ` bdef = ${B} entity = ${E}`;
+        for (const operation of group.operations) {
+            switch (operation.kind) {
+                case "read": {
+                    const result = operation.result === undefined ? undefined : target(operation.result, iface, derivedType.readResult(e));
+                    calls.push(call("read", `${head}${fieldArgs(operation.fields, entity, "read")} keys = ${source(operation.source, iface, derivedType.readImport(e))}`, changingPart([["result", result]])));
+                    break;
+                }
+                case "readBy": {
+                    const association = catalog.association(entity, operation.association.str);
+                    if (association === undefined) {
+                        throw new RewriteError("ABP006", `${entity.behavior.alias} has no association ${operation.association.str.replace(/^\\/, "")} to an entity of ${bdef?.behavior.name ?? ""}`, operation.association);
+                    }
+                    const b = association.index;
+                    const result = operation.result === undefined ? undefined : target(operation.result, iface, derivedType.assocReadResult(e, b));
+                    const link = operation.link === undefined ? undefined : target(operation.link, iface, derivedType.assocLink(e, b));
+                    calls.push(call("read_by_association", `${head} association = ${literal(association.name)}${fieldArgs(operation.fields, association.target, "read")} keys = ${source(operation.source, iface, derivedType.assocReadImport(e, b))}`, changingPart([["result", result], ["link", link]])));
+                    break;
+                }
+                case "function":
+                case "execute": {
+                    const found = catalog.action(entity, operation.name.str);
+                    const expected = operation.kind === "function" ? "function" : "action";
+                    if (found === undefined || found.action.kind !== expected) {
+                        throw new RewriteError("ABP006", `${entity.behavior.alias} has no ${expected} ${operation.name.str}`, operation.name);
+                    }
+                    const a = found.index;
+                    const result = operation.result === undefined ? undefined : target(operation.result, iface, derivedType.actionResult(e, a));
+                    const autoFill = operation.kind === "execute" && operation.autoFillCid ? " auto_fill_cid = abap_true" : "";
+                    calls.push(call("execute", `${head} action = ${literal(found.action.name)}${autoFill} rows = ${source(operation.source, iface, derivedType.actionImport(e, a))}`, changingPart([["result", result]])));
+                    break;
+                }
+                case "create": {
+                    const autoFill = operation.autoFillCid ? " auto_fill_cid = abap_true" : "";
+                    calls.push(call("modify", `${head} operation = \`CREATE\`${fieldArgs(operation.fields, entity, "modify")}${autoFill} rows = ${source(operation.source, iface, derivedType.create(e))}`, ""));
+                    break;
+                }
+                case "createBy": {
+                    const association = catalog.association(entity, operation.association.str);
+                    if (association === undefined) {
+                        throw new RewriteError("ABP006", `${entity.behavior.alias} has no association ${operation.association.str.replace(/^\\/, "")} to an entity of ${bdef?.behavior.name ?? ""}`, operation.association);
+                    }
+                    const autoFill = operation.autoFillCid ? " auto_fill_cid = abap_true" : "";
+                    calls.push(call("create_by_association", `${head} association = ${literal(association.name)}${fieldArgs(operation.fields, association.target, "modify")}${autoFill} rows = ${source(operation.source, iface, derivedType.assocCreate(e, association.index))}`, ""));
+                    break;
+                }
+                case "update":
+                    calls.push(call("modify", `${head} operation = \`UPDATE\`${fieldArgs(operation.fields, entity, "modify")} rows = ${source(operation.source, iface, derivedType.update(e))}`, ""));
+                    break;
+                case "delete":
+                    calls.push(call("modify", `${head} operation = \`DELETE\` rows = ${source(operation.source, iface, derivedType.delete(e))}`, ""));
+                    break;
+            }
+        }
+    });
+    const mapped = statement.kind === "modify" && statement.mapped !== undefined ? target(statement.mapped, iface, derivedType.mappedEarly) : undefined;
+    const failed = statement.failed === undefined ? undefined : target(statement.failed, iface, derivedType.failedEarly);
+    const reported = statement.reported === undefined ? undefined : target(statement.reported, iface, derivedType.reportedEarly);
+    const mode = statement.mode === "local" ? " local = abap_true" : statement.mode === "privileged" ? " privileged = abap_true" : "";
+    return [
+        ...declarations,
+        call("begin", ` bdef = ${B}${mode}`, ""),
+        ...calls,
+        call("end", "", changingPart([["mapped", mapped], ["failed", failed], ["reported", reported]])),
+    ].join(" ");
+}
+/** The BDEF a class implements: `FOR BEHAVIOR OF x` in its definition, or the model. */
+export function poolBdefOf(catalog, className, mainFile) {
+    for (const statement of mainFile?.getStatements() ?? []) {
+        const tokens = toks(statement.getTokens());
+        const i = tokens.findIndex((t, n) => t.upper === "FOR" && tokens[n + 1]?.upper === "BEHAVIOR" && tokens[n + 2]?.upper === "OF");
+        if (i >= 0 && tokens[i + 3] !== undefined) {
+            const found = catalog.bdef(tokens[i + 3].str);
+            if (found !== undefined) {
+                return found;
+            }
+        }
+    }
+    return catalog.bdefs.find((b) => same(b.behavior.implementationClass ?? "", className) || b.behavior.entities.some((e) => same(e.implementationClass ?? "", className)));
+}
+//# sourceMappingURL=rewrite.js.map