@abaplint/transpiler-cli 2.14.1 → 2.14.3

package/build/bundle.js

@@ -71,6 +71,7 @@ class TranspilerConfig {
             input_folder: "src",
             input_filter: [],
             output_folder: "output",
+            incremental_output: false,
             libs: [
                 { "url": "https://github.com/open-abap/open-abap-core" },
             ],
@@ -314,14 +315,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-const fs = __importStar(__webpack_require__(/*! fs */ "fs"));
-const path = __importStar(__webpack_require__(/*! path */ "path"));
 const progress_1 = __importDefault(__webpack_require__(/*! progress */ "./node_modules/progress/index.js"));
 const Transpiler = __importStar(__webpack_require__(/*! @abaplint/transpiler */ "./node_modules/@abaplint/transpiler/build/src/index.js"));
 const config_1 = __webpack_require__(/*! ./config */ "./build/config.js");
 const file_operations_1 = __webpack_require__(/*! ./file_operations */ "./build/file_operations.js");
 const libraries_1 = __webpack_require__(/*! ./libraries */ "./build/libraries.js");
 const write_objects_1 = __webpack_require__(/*! ./write_objects */ "./build/write_objects.js");
+const output_writer_1 = __webpack_require__(/*! ./output_writer */ "./build/output_writer.js");
 class Progress {
     bar;
     set(total, _text) {
@@ -351,23 +351,23 @@ async function run() {
     console.log("\nBuilding");
     const { output, sources } = await build(config, files);
     console.log("\nOutput");
-    const outputFolder = config.output_folder;
-    if (!fs.existsSync(outputFolder)) {
-        fs.mkdirSync(outputFolder, { recursive: true });
-    }
-    await (0, write_objects_1.writeObjects)(output.objects, config, sources);
-    console.log(output.objects.length + " objects written to disk");
+    const artifacts = (0, write_objects_1.collectObjectFiles)(output.objects, config, sources);
     if (config.write_unit_tests === true) {
-        // breaking change? rename this output file,
-        fs.writeFileSync(outputFolder + path.sep + "index.mjs", output.unitTestScript);
-        fs.writeFileSync(outputFolder + path.sep + "_unit_open.mjs", output.unitTestScriptOpen);
+        artifacts.push({ path: "index.mjs", contents: output.unitTestScript });
+        artifacts.push({ path: "_unit_open.mjs", contents: output.unitTestScriptOpen });
+    }
+    artifacts.push({ path: "init.mjs", contents: output.initializationScript });
+    artifacts.push({ path: "_init.mjs", contents: output.initializationScript2 });
+    artifacts.push({ path: "_top.mjs", contents: `import runtime from "@abaplint/runtime";
+globalThis.abap = new runtime.ABAP();` });
+    const written = await (0, output_writer_1.writeOutput)(config.output_folder, artifacts, config.incremental_output === true);
+    if (config.incremental_output === true) {
+        console.log("Output files: " + written.created + " created, " +
+            written.updated + " updated, " + written.unchanged + " unchanged, " + written.deleted + " deleted");
+    }
+    else {
+        console.log(`Output files: ${written.updated} written`);
     }
-    // breaking change? rename this output file,
-    fs.writeFileSync(outputFolder + path.sep + "init.mjs", output.initializationScript);
-    // new static referenced imports,
-    fs.writeFileSync(outputFolder + path.sep + "_init.mjs", output.initializationScript2);
-    fs.writeFileSync(outputFolder + path.sep + "_top.mjs", `import runtime from "@abaplint/runtime";
-globalThis.abap = new runtime.ABAP();`);
 }
 run().then(() => {
     process.exit();
@@ -491,6 +491,11 @@ const abaplint = __importStar(__webpack_require__(/*! @abaplint/core */ "./node_
 const file_operations_1 = __webpack_require__(/*! ./file_operations */ "./build/file_operations.js");
 const git_clone_1 = __webpack_require__(/*! ./git_clone */ "./build/git_clone.js");
 const lib_folder_1 = __webpack_require__(/*! ./lib_folder */ "./build/lib_folder.js");
+function logicalLibrarySource(library, directory, filename) {
+    const relative = path.relative(directory, filename).split(path.sep)
+        .map(segment => encodeURIComponent(segment)).join("/");
+    return "abaplint://" + encodeURIComponent(library) + "/" + relative;
+}
 function libraryNames(libs) {
     const used = new Set(["project"]);
     return libs.map(lib => {
@@ -514,6 +519,7 @@ async function loadLibraries(config) {
     const names = libraryNames(libs);
     const result = [];
     for (const [index, lib] of libs.entries()) {
+        const libraryName = names[index];
         let dir;
         let cleanupFolder = false;
         const folder = (0, lib_folder_1.resolveLibFolder)(lib.folder, process.cwd());
@@ -547,8 +553,15 @@ async function loadLibraries(config) {
                     filesToRead.add(filename);
                 }
             }
-            const files = await file_operations_1.FileOperations.readAllFiles([...filesToRead], config.output_folder);
-            result.push({ name: names[index], files });
+            const filenames = [...filesToRead];
+            const files = await file_operations_1.FileOperations.readAllFiles(filenames, config.output_folder);
+            if (cleanupFolder) {
+                for (const [index, file] of files.entries()) {
+                    file.sourceMapPath = logicalLibrarySource(libraryName, dir, filenames[index]);
+                    delete file.relative;
+                }
+            }
+            result.push({ name: libraryName, files });
             console.log("\t" + files.length + " files added from lib");
         }
         finally {
@@ -604,6 +617,347 @@ function libraryRegistry(files, libraries, skipDuplicateDependencies = false) {
 
 /***/ },
 
+/***/ "./build/output_writer.js"
+/*!********************************!*\
+  !*** ./build/output_writer.js ***!
+  \********************************/
+(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.writeOutput = writeOutput;
+const fsPromises = __importStar(__webpack_require__(/*! node:fs/promises */ "node:fs/promises"));
+const os = __importStar(__webpack_require__(/*! node:os */ "node:os"));
+const path = __importStar(__webpack_require__(/*! node:path */ "node:path"));
+const file_operations_1 = __webpack_require__(/*! ./file_operations */ "./build/file_operations.js");
+const MANIFEST = ".abap-transpile-manifest.json";
+function concurrency() {
+    return Math.max(1, Math.min(8, os.cpus().length));
+}
+async function forEachLimit(items, task, limit = concurrency()) {
+    let next = 0;
+    const workers = Array.from({ length: Math.min(limit, items.length) }, async () => {
+        while (next < items.length) {
+            const index = next++;
+            await task(items[index]);
+        }
+    });
+    const results = await Promise.allSettled(workers);
+    const failed = results.find(result => result.status === "rejected");
+    if (failed?.status === "rejected") {
+        throw failed.reason;
+    }
+}
+function normalizeRelative(filename, label) {
+    if (filename.length === 0 || filename.startsWith("/") || filename.includes("\\")
+        || /^[a-zA-Z]:/.test(filename)) {
+        throw new Error("Invalid " + label + " path: " + filename);
+    }
+    const segments = filename.split("/");
+    if (segments.some(segment => segment.length === 0 || segment === "." || segment === "..")) {
+        throw new Error("Invalid " + label + " path: " + filename);
+    }
+    return segments.join("/");
+}
+function validatePaths(filenames, label) {
+    const paths = new Map();
+    for (const filename of filenames) {
+        if (typeof filename !== "string") {
+            throw new Error("Invalid " + label + " path");
+        }
+        const relative = normalizeRelative(filename, label);
+        const key = relative.toLowerCase();
+        if (key === MANIFEST || key.startsWith(MANIFEST + "/")) {
+            throw new Error("Reserved " + label + " path: " + relative);
+        }
+        const existing = paths.get(key);
+        if (existing !== undefined) {
+            throw new Error("Conflicting " + label + " paths: " + existing + " and " + relative);
+        }
+        paths.set(key, relative);
+    }
+    for (const filename of paths.values()) {
+        const segments = filename.split("/");
+        for (let index = 1; index < segments.length; index++) {
+            if (paths.has(segments.slice(0, index).join("/").toLowerCase())) {
+                throw new Error("Conflicting " + label + " file and directory paths: " + filename);
+            }
+        }
+    }
+    return [...paths.values()];
+}
+function validateArtifactPaths(artifacts) {
+    const paths = validatePaths(artifacts.map(artifact => artifact.path.replace(/\\/g, "/")), "output");
+    return artifacts.map((artifact, index) => ({
+        ...artifact,
+        relative: paths[index],
+        byteLength: Buffer.byteLength(artifact.contents, file_operations_1.FileOperations.isBinaryFilename(paths[index]) ? "latin1" : "utf8"),
+        binary: file_operations_1.FileOperations.isBinaryFilename(paths[index]),
+    }));
+}
+function parseManifest(contents) {
+    let parsed;
+    try {
+        parsed = JSON.parse(contents);
+    }
+    catch (error) {
+        throw new Error("Invalid incremental output manifest JSON: " + String(error));
+    }
+    if (typeof parsed !== "object" || parsed === null || !("version" in parsed) || !("files" in parsed)
+        || parsed.version !== 1 || !Array.isArray(parsed.files)) {
+        throw new Error("Unsupported incremental output manifest");
+    }
+    return { version: 1, files: validatePaths(parsed.files, "incremental output manifest") };
+}
+function serializeManifest(files) {
+    return JSON.stringify({ version: 1, files: [...files].sort() }, null, 2) + "\n";
+}
+async function lstatOrMissing(filename) {
+    try {
+        return await fsPromises.lstat(filename);
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return undefined;
+        }
+        throw error;
+    }
+}
+function isBelowRoot(root, filename) {
+    const relative = path.relative(root, filename);
+    return relative !== "" && relative !== ".." && !relative.startsWith(".." + path.sep) && !path.isAbsolute(relative);
+}
+async function inspectPaths(root, relativePaths, rootStats, ioConcurrency) {
+    const metadata = new Map();
+    const nodes = new Map();
+    for (const filename of relativePaths) {
+        const segments = filename.split("/");
+        for (let index = 1; index <= segments.length; index++) {
+            const relative = segments.slice(0, index).join("/");
+            const isDirectory = index < segments.length;
+            nodes.set(relative, (nodes.get(relative) ?? false) || isDirectory);
+        }
+    }
+    if (rootStats !== undefined) {
+        const byDepth = new Map();
+        for (const relative of nodes.keys()) {
+            const depth = relative.split("/").length;
+            const group = byDepth.get(depth) ?? [];
+            group.push(relative);
+            byDepth.set(depth, group);
+        }
+        for (const depth of [...byDepth.keys()].sort((a, b) => a - b)) {
+            const candidates = byDepth.get(depth).filter(relative => {
+                const parent = path.posix.dirname(relative);
+                return depth === 1 || metadata.get(parent)?.isDirectory() === true;
+            });
+            await forEachLimit(candidates, async (relative) => {
+                const absolute = path.resolve(root, ...relative.split("/"));
+                const stat = await lstatOrMissing(absolute);
+                if (stat?.isSymbolicLink()) {
+                    throw new Error("Output path must not traverse a symlink: " + relative);
+                }
+                if (stat !== undefined && nodes.get(relative) === true && !stat.isDirectory()) {
+                    throw new Error("Output path parent is not a directory: " + relative);
+                }
+                if (stat !== undefined && nodes.get(relative) === false && !stat.isFile()) {
+                    throw new Error("Generated output path is not a regular file: " + relative);
+                }
+                metadata.set(relative, stat);
+            }, ioConcurrency);
+        }
+    }
+    else {
+        for (const relative of nodes.keys()) {
+            metadata.set(relative, undefined);
+        }
+    }
+    return metadata;
+}
+async function atomicWriteManifest(root, contents, current) {
+    if (current === contents) {
+        return;
+    }
+    await fsPromises.mkdir(root, { recursive: true });
+    const temporary = path.join(root, MANIFEST + ".tmp-" + process.pid + "-" + Math.random().toString(36).slice(2));
+    try {
+        await fsPromises.writeFile(temporary, contents, { flag: "wx", encoding: "utf8" });
+        await fsPromises.rename(temporary, path.join(root, MANIFEST));
+    }
+    catch (error) {
+        try {
+            await fsPromises.unlink(temporary);
+        }
+        catch {
+            // The temporary file can be absent when creation failed.
+        }
+        throw error;
+    }
+}
+async function writeOutput(rootFolder, artifacts, incremental, ioConcurrency = concurrency()) {
+    const root = path.resolve(rootFolder);
+    const prepared = validateArtifactPaths(artifacts);
+    const result = {
+        created: 0, updated: 0, unchanged: 0, deleted: 0,
+    };
+    if (!incremental) {
+        const files = prepared.map(file => ({ path: path.resolve(root, file.relative), contents: file.contents }));
+        await file_operations_1.FileOperations.writeFiles(files);
+        result.updated = files.length;
+        return result;
+    }
+    const manifestPath = path.join(root, MANIFEST);
+    const rootStats = await lstatOrMissing(root);
+    if (rootStats?.isSymbolicLink()) {
+        throw new Error("Output folder must not be a symlink: " + root);
+    }
+    if (rootStats !== undefined && !rootStats.isDirectory()) {
+        throw new Error("Output folder is not a directory: " + root);
+    }
+    let manifestContents;
+    let previous = [];
+    if (rootStats !== undefined) {
+        const manifestStat = await lstatOrMissing(manifestPath);
+        if (manifestStat?.isSymbolicLink() || (manifestStat !== undefined && !manifestStat.isFile())) {
+            throw new Error("Incremental output manifest must be a regular file");
+        }
+        if (manifestStat !== undefined) {
+            const contents = await fsPromises.readFile(manifestPath, "utf8");
+            manifestContents = contents;
+            previous = parseManifest(contents).files;
+        }
+    }
+    // A path can belong to both inventories; each inventory rejects its own duplicates.
+    validatePaths([...new Set([...prepared.map(file => file.relative), ...previous])], "incremental output");
+    const previousPaths = new Set(previous);
+    const current = new Set(prepared.map(file => file.relative));
+    const stale = previous.filter(filename => !current.has(filename));
+    const additions = prepared.some(file => !previousPaths.has(file.relative));
+    const pathsToInspect = [...new Set([...prepared.map(file => file.relative), ...stale])];
+    const metadata = await inspectPaths(root, pathsToInspect, rootStats, ioConcurrency);
+    await forEachLimit(prepared, async (file) => {
+        const stat = metadata.get(file.relative);
+        file.existed = stat !== undefined;
+        if (stat === undefined || stat.size !== file.byteLength) {
+            file.changed = true;
+            return;
+        }
+        let existing;
+        try {
+            existing = await fsPromises.readFile(path.resolve(root, ...file.relative.split("/")));
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                file.existed = false;
+                file.changed = true;
+                return;
+            }
+            throw error;
+        }
+        const generated = Buffer.from(file.contents, file.binary ? "latin1" : "utf8");
+        file.changed = !existing.equals(generated);
+    }, ioConcurrency);
+    if (additions) {
+        const union = serializeManifest(new Set([...previous, ...current]));
+        await atomicWriteManifest(root, union, manifestContents);
+        manifestContents = union;
+    }
+    const toWrite = prepared.filter(file => file.changed);
+    const directories = new Map();
+    for (const file of toWrite) {
+        const segments = file.relative.split("/");
+        for (let index = 1; index < segments.length; index++) {
+            const relative = segments.slice(0, index).join("/");
+            if (metadata.get(relative) === undefined) {
+                directories.set(relative, index);
+            }
+        }
+    }
+    const directoryDepths = [...new Set(directories.values())].sort((a, b) => a - b);
+    for (const depth of directoryDepths) {
+        const atDepth = [...directories.entries()].filter(([, candidateDepth]) => candidateDepth === depth)
+            .map(([relative]) => path.resolve(root, ...relative.split("/")));
+        await forEachLimit(atDepth, async (directory) => {
+            await fsPromises.mkdir(directory);
+        }, ioConcurrency);
+    }
+    await forEachLimit(toWrite, async (file) => {
+        await fsPromises.writeFile(path.resolve(root, ...file.relative.split("/")), file.contents, file.binary ? { encoding: "latin1" } : undefined);
+    }, ioConcurrency);
+    const staleFiles = stale.map(filename => path.resolve(root, ...filename.split("/")));
+    const removedDirectories = new Set();
+    for (const filename of staleFiles) {
+        try {
+            await fsPromises.unlink(filename);
+            result.deleted++;
+        }
+        catch (error) {
+            if (error.code !== "ENOENT") {
+                throw error;
+            }
+        }
+        let directory = path.dirname(filename);
+        while (isBelowRoot(root, directory)) {
+            removedDirectories.add(directory);
+            directory = path.dirname(directory);
+        }
+    }
+    await forEachLimit([...removedDirectories].sort((a, b) => b.length - a.length), async (directory) => {
+        try {
+            await fsPromises.rmdir(directory);
+        }
+        catch (error) {
+            const code = error.code;
+            if (code !== "ENOENT" && code !== "ENOTEMPTY" && code !== "EEXIST") {
+                throw error;
+            }
+        }
+    });
+    const finalManifest = serializeManifest(current);
+    await atomicWriteManifest(root, finalManifest, manifestContents);
+    result.created = prepared.filter(file => file.changed && !file.existed).length;
+    result.updated = prepared.filter(file => file.changed && file.existed).length;
+    result.unchanged = prepared.filter(file => !file.changed).length;
+    return result;
+}
+//# sourceMappingURL=output_writer.js.map
+
+/***/ },
+
 /***/ "./build/write_objects.js"
 /*!********************************!*\
   !*** ./build/write_objects.js ***!
@@ -646,28 +1000,16 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.writeObjects = writeObjects;
+exports.collectObjectFiles = collectObjectFiles;
 const path = __importStar(__webpack_require__(/*! path */ "path"));
 const url_1 = __webpack_require__(/*! url */ "url");
 const transpiler_1 = __webpack_require__(/*! @abaplint/transpiler */ "./node_modules/@abaplint/transpiler/build/src/index.js");
-const file_operations_1 = __webpack_require__(/*! ./file_operations */ "./build/file_operations.js");
-async function writeObjects(outputFiles, config, files) {
+function collectObjectFiles(outputFiles, config, files) {
     const root = path.resolve(config.output_folder);
     const filesToWrite = [];
-    const destinations = new Set();
     const sources = new Map(files.map(file => [file.filename.toLowerCase(), file]));
     const add = (filename, contents) => {
-        const target = path.resolve(root, filename);
-        const relative = path.relative(root, target);
-        if (relative === "" || relative.startsWith(".." + path.sep) || relative === ".." || path.isAbsolute(relative)) {
-            throw new Error("Output file escapes output_folder: " + filename);
-        }
-        const key = target.toLowerCase();
-        if (destinations.has(key)) {
-            throw new Error("Conflicting output file: " + filename);
-        }
-        destinations.add(key);
-        filesToWrite.push({ path: target, contents });
+        filesToWrite.push({ path: filename.replace(/\\/g, "/"), contents });
     };
     for (const output of outputFiles) {
         const type = output.object.type.toUpperCase();
@@ -688,21 +1030,24 @@ async function writeObjects(outputFiles, config, files) {
                 if (file === undefined) {
                     continue;
                 }
-                if (file.relative !== undefined) {
+                if (file.sourceMapPath !== undefined) {
+                    sourcePaths[filename] = file.sourceMapPath;
+                }
+                else if (file.relative !== undefined) {
                     const source = path.resolve(root, file.relative, file.filename);
                     const relative = path.relative(mapDirectory, source);
                     // Sources on another Windows drive cannot be expressed as relative paths.
                     sourcePaths[filename] = path.isAbsolute(relative) ? (0, url_1.pathToFileURL)(source).href
                         : relative.split(path.sep).map(segment => encodeURIComponent(segment)).join("/");
                 }
-                // Include sources for local and cloned libraries; clones are removed before emission.
+                // Embedding source text keeps maps useful after temporary checkouts are removed.
                 sourceContents[filename] = file.contents;
             }
             add(name, output.chunk.getMap(path.basename(output.filename), { generatedLineOffset, sourcePaths, sourceContents }));
         }
         add(output.filename, contents);
     }
-    await file_operations_1.FileOperations.writeFiles(filesToWrite);
+    return filesToWrite;
 }
 //# sourceMappingURL=write_objects.js.map
 
@@ -1060,7 +1405,7 @@ class Lexer {
             else if (this.m === ModeTemplate
                 && this.buffer.length() > 1
                 && (current === CH_PIPE || current === CH_LBRACE)
-                && (stream.prevChar() !== CH_BACKSLASH || (stream.prevPrevChar() === CH_BACKSLASH && stream.prevChar() === CH_BACKSLASH))) {
+                && stream.countPrevious(CH_BACKSLASH) % 2 === 0) {
                 // end of template
                 if (current === CH_LBRACE || AFTER_LITERAL.has(ahead)) {
                     this.add();
@@ -1214,6 +1559,14 @@ class LexerStream {
         }
         return this.raw.charCodeAt(o);
     }
+    /** number of consecutive occurrences of the character directly before the current one */
+    countPrevious(code) {
+        let count = 0;
+        for (let o = this.offset - 1; o >= 0 && this.raw.charCodeAt(o) === code; o--) {
+            count++;
+        }
+        return count;
+    }
     currentChar() {
         if (this.offset < 0) {
             return NL; // simulate newline at start of file to handle star(*) comments
@@ -21213,6 +21566,21 @@ exports.sta = sta;
 exports.sub = sub;
 const nodes_1 = __webpack_require__(/*! ../../nodes */ "./node_modules/@abaplint/core/build/src/abap/nodes/index.js");
 const _statement_1 = __webpack_require__(/*! ../../2_statements/statements/_statement */ "./node_modules/@abaplint/core/build/src/abap/2_statements/statements/_statement.js");
+function toMatch(statements, m) {
+    return {
+        matched: statements.slice(0, m.next),
+        unmatched: statements.slice(m.next),
+        error: m.error,
+        errorDescription: m.errorDescription,
+        errorMatched: m.errorMatched,
+    };
+}
+function success(next) {
+    return { next, error: false, errorDescription: "", errorMatched: 0 };
+}
+function failure(next, errorDescription, errorMatched) {
+    return { next, error: true, errorDescription, errorMatched };
+}
 class Sequence {
     constructor(list) {
         if (list.length < 2) {
@@ -21231,36 +21599,18 @@ class Sequence {
         return this.list[0].first();
     }
     run(statements, parent) {
-        let inn = statements;
-        let out = [];
+        return toMatch(statements, this.runAt(statements, 0, parent));
+    }
+    runAt(statements, index, parent) {
+        let next = index;
         for (const i of this.list) {
-            const match = i.run(inn, parent);
+            const match = i.runAt(statements, next, parent);
             if (match.error) {
-                return {
-                    matched: [],
-                    unmatched: statements,
-                    error: true,
-                    errorDescription: match.errorDescription,
-                    errorMatched: out.length,
-                };
-            }
-            if (match.matched.length < 100) {
-                out.push(...match.matched);
-            }
-            else {
-                // avoid using the spread operator, it might trigger "Maximum call stack size exceeded"
-                // when the number of matched elements is very large
-                out = out.concat(match.matched);
+                return failure(index, match.errorDescription, next - index);
             }
-            inn = match.unmatched;
+            next = match.next;
         }
-        return {
-            matched: out,
-            unmatched: inn,
-            error: false,
-            errorDescription: "",
-            errorMatched: 0,
-        };
+        return success(next);
     }
 }
 // Note that the Alternative does not nessesarily return the first in the alternative
@@ -21299,21 +21649,18 @@ class Alternative {
         return this.list.reduce((a, c) => { return a.concat(c.getUsing()); }, []);
     }
     run(statements, parent) {
+        return toMatch(statements, this.runAt(statements, 0, parent));
+    }
+    runAt(statements, index, parent) {
         this.setupMap();
         let count = 0;
         let countError = "";
-        if (statements.length === 0) {
-            return {
-                matched: [],
-                unmatched: statements,
-                error: true,
-                errorDescription: countError,
-                errorMatched: count,
-            };
+        if (index >= statements.length) {
+            return failure(index, countError, count);
         }
-        const token = statements[0].getFirstToken().getStr().toUpperCase();
+        const token = statements[index].getFirstToken().getStr().toUpperCase();
         for (const i of this.map[token] || []) {
-            const match = i.run(statements, parent);
+            const match = i.runAt(statements, index, parent);
             if (match.error === false) {
                 return match;
             }
@@ -21323,7 +21670,7 @@ class Alternative {
             }
         }
         for (const i of this.map[""] || []) {
-            const match = i.run(statements, parent);
+            const match = i.runAt(statements, index, parent);
             if (match.error === false) {
                 return match;
             }
@@ -21333,22 +21680,10 @@ class Alternative {
             }
         }
         if (count === 0) {
-            return {
-                matched: [],
-                unmatched: statements,
-                error: true,
-                errorDescription: "Unexpected code structure",
-                errorMatched: count,
-            };
+            return failure(index, "Unexpected code structure", count);
         }
         else {
-            return {
-                matched: [],
-                unmatched: statements,
-                error: true,
-                errorDescription: countError,
-                errorMatched: count,
-            };
+            return failure(index, countError, count);
         }
     }
 }
@@ -21363,7 +21698,10 @@ class Optional {
         return this.obj.getUsing();
     }
     run(statements, parent) {
-        const ret = this.obj.run(statements, parent);
+        return toMatch(statements, this.runAt(statements, 0, parent));
+    }
+    runAt(statements, index, parent) {
+        const ret = this.obj.runAt(statements, index, parent);
         ret.error = false;
         return ret;
     }
@@ -21382,48 +21720,24 @@ class Star {
         return this.obj.getUsing();
     }
     run(statements, parent) {
-        let inn = statements;
-        let out = [];
+        return toMatch(statements, this.runAt(statements, 0, parent));
+    }
+    runAt(statements, index, parent) {
+        let next = index;
         while (true) {
-            if (inn.length === 0) {
-                return {
-                    matched: out,
-                    unmatched: inn,
-                    error: false,
-                    errorDescription: "",
-                    errorMatched: 0,
-                };
+            if (next >= statements.length) {
+                return success(next);
             }
-            const match = this.obj.run(inn, parent);
+            const match = this.obj.runAt(statements, next, parent);
             if (match.error === true) {
                 if (match.errorMatched > 0) {
-                    return {
-                        matched: out,
-                        unmatched: inn,
-                        error: true,
-                        errorDescription: match.errorDescription,
-                        errorMatched: match.errorMatched,
-                    };
+                    return failure(next, match.errorDescription, match.errorMatched);
                 }
                 else {
-                    return {
-                        matched: out,
-                        unmatched: inn,
-                        error: false,
-                        errorDescription: "",
-                        errorMatched: 0,
-                    };
+                    return success(next);
                 }
             }
-            if (match.matched.length < 100) {
-                out.push(...match.matched);
-            }
-            else {
-                // avoid using the spread operator, it might trigger "Maximum call stack size exceeded"
-                // when the number of matched elements is very large
-                out = out.concat(match.matched);
-            }
-            inn = match.unmatched;
+            next = match.next;
         }
     }
     first() {
@@ -21452,10 +21766,13 @@ class SubStructure {
         }
     }
     run(statements, parent) {
+        return toMatch(statements, this.runAt(statements, 0, parent));
+    }
+    runAt(statements, index, parent) {
         const nparent = new nodes_1.StructureNode(this.s);
         this.setupMatcher();
-        const ret = this.matcher.run(statements, nparent);
-        if (ret.matched.length === 0) {
+        const ret = this.matcher.runAt(statements, index, nparent);
+        if (ret.next === index) {
             ret.error = true;
         }
         else {
@@ -21485,33 +21802,18 @@ class SubStatement {
         return this.obj.name;
     }
     run(statements, parent) {
-        if (statements.length === 0) {
-            return {
-                matched: [],
-                unmatched: [],
-                error: true,
-                errorDescription: "Expected " + this.className().toUpperCase(),
-                errorMatched: 0,
-            };
+        return toMatch(statements, this.runAt(statements, 0, parent));
+    }
+    runAt(statements, index, parent) {
+        if (index >= statements.length) {
+            return failure(statements.length, "Expected " + this.className().toUpperCase(), 0);
         }
-        else if (statements[0].get() instanceof this.obj) {
-            parent.addChild(statements[0]);
-            return {
-                matched: [statements[0]],
-                unmatched: statements.splice(1),
-                error: false,
-                errorDescription: "",
-                errorMatched: 0,
-            };
+        else if (statements[index].get() instanceof this.obj) {
+            parent.addChild(statements[index]);
+            return success(index + 1);
         }
         else {
-            return {
-                matched: [],
-                unmatched: statements,
-                error: true,
-                errorDescription: "Expected " + this.className().toUpperCase(),
-                errorMatched: 0,
-            };
+            return failure(index, "Expected " + this.className().toUpperCase(), 0);
         }
     }
 }
@@ -29257,7 +29559,7 @@ class BasicTypes {
         if (children.length === 0) {
             return new Types.UnknownType("Type error, could not resolve \"" + fullName + "\", resolveLikeName1");
         }
-        let type = undefined;
+        let type;
         if (children[1] && (children[1].getFirstToken().getStr() === "=>" || children[1].getFirstToken().getStr() === "->")) {
             type = field_chain_1.FieldChain.runSyntax(chain, this.input, _reference_1.ReferenceType.TypeReference);
         }
@@ -29520,7 +29822,7 @@ class BasicTypes {
             primaryKey: primaryKey,
             secondary: secondaryKeys,
         };
-        let found = undefined;
+        let found;
         if (text.startsWith("TYPE TABLE OF REF TO ")
             || text.startsWith("TYPE STANDARD TABLE OF REF TO ")
             || text.startsWith("TYPE SORTED TABLE OF REF TO ")
@@ -29658,7 +29960,7 @@ class BasicTypes {
                 name = typeName === null || typeName === void 0 ? void 0 : typeName.concatTokens();
             }
             const type = this.resolveLikeName(e, false);
-            let row = undefined;
+            let row;
             if (type === undefined) {
                 return new Types.UnknownType("Type error, could not resolve \"" + name + "\", parseType");
             }
@@ -29853,7 +30155,7 @@ class BasicTypes {
             rest = split[1];
         }
         const subs = rest.split("-");
-        let foundType = undefined;
+        let foundType;
         if (className && chainText.includes("=>")) {
             const split = chainText.split("=>");
             const className = split[0];
@@ -30276,6 +30578,143 @@ function checkDatabaseFields(fields, dbSources, input, token) {
 
 /***/ },
 
+/***/ "./node_modules/@abaplint/core/build/src/abap/5_syntax/expressions/_check_database_work_area.js"
+/*!******************************************************************************************************!*\
+  !*** ./node_modules/@abaplint/core/build/src/abap/5_syntax/expressions/_check_database_work_area.js ***!
+  \******************************************************************************************************/
+(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.checkDatabaseWorkArea = checkDatabaseWorkArea;
+const nodes_1 = __webpack_require__(/*! ../../nodes */ "./node_modules/@abaplint/core/build/src/abap/nodes/index.js");
+const Expressions = __importStar(__webpack_require__(/*! ../../2_statements/expressions */ "./node_modules/@abaplint/core/build/src/abap/2_statements/expressions/index.js"));
+const Basic = __importStar(__webpack_require__(/*! ../../types/basic */ "./node_modules/@abaplint/core/build/src/abap/types/basic/index.js"));
+const objects_1 = __webpack_require__(/*! ../../../objects */ "./node_modules/@abaplint/core/build/src/objects/index.js");
+const _syntax_input_1 = __webpack_require__(/*! ../_syntax_input */ "./node_modules/@abaplint/core/build/src/abap/5_syntax/_syntax_input.js");
+// byte length of a flat type in a unicode system, as a lower and an upper bound:
+// IntegerType also stands for INT1 and INT2, and padding is left out of the lower bound
+function bounds(type) {
+    if (type instanceof Basic.CharacterType || type instanceof Basic.NumericType) {
+        return { min: type.getLength() * 2, max: type.getLength() * 2, align: 2 };
+    }
+    else if (type instanceof Basic.DateType) {
+        return { min: 16, max: 16, align: 2 };
+    }
+    else if (type instanceof Basic.TimeType) {
+        return { min: 12, max: 12, align: 2 };
+    }
+    else if (type instanceof Basic.IntegerType) {
+        return { min: 1, max: 4, align: 4 };
+    }
+    else if (type instanceof Basic.Integer8Type || type instanceof Basic.FloatType
+        || type instanceof Basic.DecFloat16Type || type instanceof Basic.UTCLongType) {
+        return { min: 8, max: 8, align: 8 };
+    }
+    else if (type instanceof Basic.DecFloat34Type) {
+        return { min: 16, max: 16, align: 16 };
+    }
+    else if (type instanceof Basic.PackedType || type instanceof Basic.HexType) {
+        return { min: type.getLength(), max: type.getLength(), align: 1 };
+    }
+    else if (type instanceof Basic.StructureType) {
+        let min = 0;
+        let max = 0;
+        let align = 1;
+        for (const component of type.getComponents()) {
+            const sub = bounds(component.type);
+            if (sub === undefined) {
+                return undefined;
+            }
+            align = Math.max(align, sub.align);
+            max = Math.ceil(max / sub.align) * sub.align + sub.max;
+            min = min + sub.min;
+        }
+        max = Math.ceil(max / align) * align;
+        return { min, max, align };
+    }
+    // deep, generic, void or unknown
+    return undefined;
+}
+// INSERT/MODIFY/UPDATE dbtab FROM wa: the work area must be at least as long as the table line,
+// client field included, else the statement is a syntax error on the system
+function checkDatabaseWorkArea(node, dbSource, sourceTypes, input) {
+    var _a;
+    if (!(dbSource instanceof objects_1.Table)) {
+        return;
+    }
+    const children = node.getChildren();
+    let workArea = undefined;
+    for (let i = 0; i < children.length - 1; i++) {
+        const child = children[i];
+        if (child instanceof nodes_1.TokenNode && child.concatTokens().toUpperCase() === "FROM") {
+            const next = children[i + 1];
+            if (next instanceof nodes_1.ExpressionNode && next.get() instanceof Expressions.SQLSource) {
+                workArea = next;
+            }
+            break;
+        }
+    }
+    if (workArea === undefined) {
+        return;
+    }
+    const source = (_a = workArea.findFirstExpression(Expressions.SimpleSource3)) !== null && _a !== void 0 ? _a : workArea.findFirstExpression(Expressions.Source);
+    if (source === undefined) {
+        return;
+    }
+    const waType = sourceTypes.get(source);
+    if (!(waType instanceof Basic.StructureType)) {
+        return;
+    }
+    const tableType = dbSource.parseType(input.scope.getRegistry());
+    const waBounds = bounds(waType);
+    const tableBounds = bounds(tableType);
+    if (waBounds === undefined || tableBounds === undefined) {
+        return;
+    }
+    if (waBounds.max < tableBounds.min) {
+        const message = "The work area \"" + source.concatTokens() + "\" is not long enough for table " + dbSource.getName();
+        input.issues.push((0, _syntax_input_1.syntaxIssue)(input, source.getFirstToken(), message));
+    }
+}
+//# sourceMappingURL=_check_database_work_area.js.map
+
+/***/ },
+
 /***/ "./node_modules/@abaplint/core/build/src/abap/5_syntax/expressions/_check_offset_length.js"
 /*!*************************************************************************************************!*\
   !*** ./node_modules/@abaplint/core/build/src/abap/5_syntax/expressions/_check_offset_length.js ***!
@@ -30597,7 +31036,7 @@ class AttributeName {
             return context;
         }
         const helper = new _object_oriented_1.ObjectOriented(input.scope);
-        let ret = undefined;
+        let ret;
         if (context instanceof object_reference_type_1.ObjectReferenceType) {
             const def = input.scope.findObjectDefinition(context.getIdentifierName());
             if (def === undefined) {
@@ -31622,7 +32061,7 @@ const let_1 = __webpack_require__(/*! ./let */ "./node_modules/@abaplint/core/bu
 const _syntax_input_1 = __webpack_require__(/*! ../_syntax_input */ "./node_modules/@abaplint/core/build/src/abap/5_syntax/_syntax_input.js");
 const basic_1 = __webpack_require__(/*! ../../types/basic */ "./node_modules/@abaplint/core/build/src/abap/types/basic/index.js");
 class ConvBody {
-    static runSyntax(node, input) {
+    static runSyntax(node, input, targetType) {
         let scoped = false;
         const l = node.findDirectExpression(Expressions.Let);
         if (l) {
@@ -31634,7 +32073,7 @@ class ConvBody {
             input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
             return basic_1.VoidType.get(_syntax_input_1.CheckSyntaxKey);
         }
-        const sourceType = source_1.Source.runSyntax(s, input);
+        const sourceType = source_1.Source.runSyntax(s, input, targetType);
         if (scoped === true) {
             input.scope.pop(node.getLastToken().getEnd());
         }
@@ -32167,7 +32606,7 @@ class FieldChain {
                 return found.getType();
             }
         }
-        let context = undefined;
+        let context;
         const children = node.getChildren();
         context = this.findTop(children[0], input, refType);
         let prev = children[0].concatTokens();
@@ -32660,7 +33099,7 @@ class FormParam {
         if (node.findDirectTokenByText("STRUCTURE") && nameToken) {
             // STRUCTURES typing
             const typeName = (_a = node.findDirectExpression(expressions_1.SimpleFieldChain)) === null || _a === void 0 ? void 0 : _a.getFirstToken().getStr();
-            let type = undefined;
+            let type;
             if (typeName) {
                 type = (_b = input.scope.findType(typeName)) === null || _b === void 0 ? void 0 : _b.getType();
                 if (type === undefined) {
@@ -34233,7 +34672,7 @@ class MethodParameters {
     }
     checkImporting(node, input, method) {
         for (const item of this.parameterListT(node, input)) {
-            let parameterType = undefined;
+            let parameterType;
             if (method instanceof basic_1.VoidType) {
                 parameterType = method;
             }
@@ -34270,7 +34709,7 @@ class MethodParameters {
                 input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
                 return;
             }
-            let parameterType = undefined;
+            let parameterType;
             if (method instanceof basic_1.VoidType) {
                 parameterType = method;
             }
@@ -35587,9 +36026,8 @@ class Select {
     }
     static findFields(node, input) {
         var _a, _b;
-        let expr = undefined;
+        const expr = node.findFirstExpression(Expressions.SQLFieldList);
         const ret = [];
-        expr = node.findFirstExpression(Expressions.SQLFieldList);
         if (((_a = expr === null || expr === void 0 ? void 0 : expr.getFirstChild()) === null || _a === void 0 ? void 0 : _a.get()) instanceof Expressions.Dynamic) {
             dynamic_1.Dynamic.runSyntax(expr.getFirstChild(), input);
         }
@@ -35683,6 +36121,7 @@ const _typed_identifier_1 = __webpack_require__(/*! ../../types/_typed_identifie
 const _type_utils_1 = __webpack_require__(/*! ../_type_utils */ "./node_modules/@abaplint/core/build/src/abap/5_syntax/_type_utils.js");
 const _syntax_input_1 = __webpack_require__(/*! ../_syntax_input */ "./node_modules/@abaplint/core/build/src/abap/5_syntax/_syntax_input.js");
 const assert_error_1 = __webpack_require__(/*! ../assert_error */ "./node_modules/@abaplint/core/build/src/abap/5_syntax/assert_error.js");
+const version_1 = __webpack_require__(/*! ../../../version */ "./node_modules/@abaplint/core/build/src/version.js");
 /*
 * Type interference, valid scenarios:
 * typed = VALUE #( ... ).         right hand side must follow left hand type
@@ -35695,7 +36134,7 @@ const assert_error_1 = __webpack_require__(/*! ../assert_error */ "./node_module
 // TODO: refactor all these method parameters to objects, this is getting messy
 class Source {
     static runSyntax(node, input, targetType, writeReference = false, allowGenericDeference = false, readReference = true) {
-        var _a;
+        var _a, _b, _c, _d;
         if (node === undefined) {
             return undefined;
         }
@@ -35773,7 +36212,7 @@ class Source {
                 case "CONV":
                     {
                         const foundType = this.determineType(node, input, targetType);
-                        const bodyType = conv_body_1.ConvBody.runSyntax(node.findDirectExpression(Expressions.ConvBody), input);
+                        const bodyType = conv_body_1.ConvBody.runSyntax(node.findDirectExpression(Expressions.ConvBody), input, foundType);
                         const inferred = (_a = node.findDirectExpression(Expressions.TypeNameOrInfer)) === null || _a === void 0 ? void 0 : _a.concatTokens();
                         if (new _type_utils_1.TypeUtils(input.scope).isConvable(foundType, bodyType) === false) {
                             const message = `CONV: Types not compatible, ${foundType === null || foundType === void 0 ? void 0 : foundType.constructor.name}, ${bodyType === null || bodyType === void 0 ? void 0 : bodyType.constructor.name}`;
@@ -35790,7 +36229,13 @@ class Source {
                             this.traverseRemainingChildren(children, input);
                             return bodyType;
                         }
-                        this.addIfInferred(node, input, foundType);
+                        const bodySource = (_b = node.findDirectExpression(Expressions.ConvBody)) === null || _b === void 0 ? void 0 : _b.findDirectExpression(Expressions.Source);
+                        const nestedType = (_c = bodySource === null || bodySource === void 0 ? void 0 : bodySource.findDirectExpression(Expressions.TypeNameOrInfer)) === null || _c === void 0 ? void 0 : _c.concatTokens();
+                        // CONV # passes its target type into a nested inferred constructor, so
+                        // showing both inferred types would produce duplicate inlay hints.
+                        if (!(inferred === "#" && nestedType === "#")) {
+                            this.addIfInferred(node, input, foundType);
+                        }
                         this.traverseRemainingChildren(children, input);
                         return foundType;
                     }
@@ -35847,6 +36292,15 @@ class Source {
                 case "CORRESPONDING":
                     {
                         const foundType = this.determineType(node, input, targetType);
+                        if ((foundType === null || foundType === void 0 ? void 0 : foundType.isGeneric()) === true
+                            && ((_d = node.findDirectExpression(Expressions.TypeNameOrInfer)) === null || _d === void 0 ? void 0 : _d.concatTokens()) === "#"
+                            && !(0, version_1.releaseAtLeast)(input.scope.getRelease(), version_1.Release.v756)
+                            && input.scope.getLanguageVersion() !== version_1.LanguageVersion.Cloud
+                            && !input.scope.getOpenABAP()) {
+                            const message = "CORRESPONDING #, the type of the target is generic";
+                            input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                            return basic_1.VoidType.get(_syntax_input_1.CheckSyntaxKey);
+                        }
                         corresponding_body_1.CorrespondingBody.runSyntax(node.findDirectExpression(Expressions.CorrespondingBody), input, foundType);
                         this.addIfInferred(node, input, foundType);
                         return foundType;
@@ -38492,6 +38946,7 @@ const basic_1 = __webpack_require__(/*! ../../types/basic */ "./node_modules/@ab
 const dynamic_1 = __webpack_require__(/*! ../expressions/dynamic */ "./node_modules/@abaplint/core/build/src/abap/5_syntax/expressions/dynamic.js");
 const _type_utils_1 = __webpack_require__(/*! ../_type_utils */ "./node_modules/@abaplint/core/build/src/abap/5_syntax/_type_utils.js");
 const _syntax_input_1 = __webpack_require__(/*! ../_syntax_input */ "./node_modules/@abaplint/core/build/src/abap/5_syntax/_syntax_input.js");
+const version_1 = __webpack_require__(/*! ../../../version */ "./node_modules/@abaplint/core/build/src/version.js");
 class Assign {
     runSyntax(node, input) {
         var _a;
@@ -38499,7 +38954,7 @@ class Assign {
         const isComponent = ((_a = assignSource === null || assignSource === void 0 ? void 0 : assignSource.getFirstChild()) === null || _a === void 0 ? void 0 : _a.concatTokens().toUpperCase()) === "COMPONENT";
         const sources = (assignSource === null || assignSource === void 0 ? void 0 : assignSource.findDirectExpressionsMulti([Expressions.Source, Expressions.SimpleSource3])) || [];
         const theSource = sources[sources.length - 1];
-        let sourceType = undefined;
+        let sourceType;
         const firstAssign = assignSource === null || assignSource === void 0 ? void 0 : assignSource.getChildren()[0];
         const secondAssign = assignSource === null || assignSource === void 0 ? void 0 : assignSource.getChildren()[1];
         const thirdAssign = assignSource === null || assignSource === void 0 ? void 0 : assignSource.getChildren()[2];
@@ -38515,6 +38970,19 @@ class Assign {
         }
         else {
             sourceType = source_1.Source.runSyntax(theSource, input, undefined, false, isComponent === false);
+            if ((secondAssign === null || secondAssign === void 0 ? void 0 : secondAssign.concatTokens()) === "->"
+                && (thirdAssign === null || thirdAssign === void 0 ? void 0 : thirdAssign.get()) instanceof Expressions.Dynamic
+                && (sourceType === null || sourceType === void 0 ? void 0 : sourceType.isGeneric()) === true
+                && !(sourceType instanceof basic_1.DataReference)
+                && !(sourceType instanceof basic_1.ObjectReferenceType)
+                && !(sourceType instanceof basic_1.GenericObjectReferenceType)
+                && !(0, version_1.releaseAtLeast)(input.scope.getRelease(), version_1.Release.v756)
+                && input.scope.getLanguageVersion() !== version_1.LanguageVersion.Cloud
+                && !input.scope.getOpenABAP()) {
+                const message = `"${theSource.concatTokens()}" is not a reference variable`;
+                input.issues.push((0, _syntax_input_1.syntaxIssue)(input, node.getFirstToken(), message));
+                return;
+            }
         }
         if ((assignSource === null || assignSource === void 0 ? void 0 : assignSource.getChildren().length) === 5
             && isComponent) {
@@ -43241,20 +43709,23 @@ const Expressions = __importStar(__webpack_require__(/*! ../../2_statements/expr
 const source_1 = __webpack_require__(/*! ../expressions/source */ "./node_modules/@abaplint/core/build/src/abap/5_syntax/expressions/source.js");
 const dynamic_1 = __webpack_require__(/*! ../expressions/dynamic */ "./node_modules/@abaplint/core/build/src/abap/5_syntax/expressions/dynamic.js");
 const database_table_1 = __webpack_require__(/*! ../expressions/database_table */ "./node_modules/@abaplint/core/build/src/abap/5_syntax/expressions/database_table.js");
+const _check_database_work_area_1 = __webpack_require__(/*! ../expressions/_check_database_work_area */ "./node_modules/@abaplint/core/build/src/abap/5_syntax/expressions/_check_database_work_area.js");
 class InsertDatabase {
     runSyntax(node, input) {
+        const sourceTypes = new Map();
         for (const s of node.findAllExpressions(Expressions.Source)) {
-            source_1.Source.runSyntax(s, input);
+            sourceTypes.set(s, source_1.Source.runSyntax(s, input));
         }
         for (const s of node.findAllExpressions(Expressions.SimpleSource3)) {
-            source_1.Source.runSyntax(s, input);
+            sourceTypes.set(s, source_1.Source.runSyntax(s, input));
         }
         for (const d of node.findAllExpressions(Expressions.Dynamic)) {
             dynamic_1.Dynamic.runSyntax(d, input);
         }
         const dbtab = node.findFirstExpression(Expressions.DatabaseTable);
         if (dbtab !== undefined) {
-            database_table_1.DatabaseTable.runSyntax(dbtab, input);
+            const dbSource = database_table_1.DatabaseTable.runSyntax(dbtab, input);
+            (0, _check_database_work_area_1.checkDatabaseWorkArea)(node, dbSource, sourceTypes, input);
         }
     }
 }
@@ -43840,7 +44311,7 @@ class Loop {
             && topType instanceof basic_1.TableType) {
             // https://github.com/abap2xlsx/abap2xlsx/issues/1341
             const keyName = node.findExpressionAfterToken("KEY");
-            let key = undefined;
+            let key;
             const name = (keyName === null || keyName === void 0 ? void 0 : keyName.get()) instanceof Expressions.SimpleName ? keyName.getFirstToken().getStr().toUpperCase() : undefined;
             // it might be dynamic, in that case we cannot check anything; and
             // primary_key is the predefined name of the primary key every table has
@@ -44197,11 +44668,13 @@ const dynamic_1 = __webpack_require__(/*! ../expressions/dynamic */ "./node_modu
 const database_table_1 = __webpack_require__(/*! ../expressions/database_table */ "./node_modules/@abaplint/core/build/src/abap/5_syntax/expressions/database_table.js");
 const source_1 = __webpack_require__(/*! ../expressions/source */ "./node_modules/@abaplint/core/build/src/abap/5_syntax/expressions/source.js");
 const _reference_1 = __webpack_require__(/*! ../_reference */ "./node_modules/@abaplint/core/build/src/abap/5_syntax/_reference.js");
+const _check_database_work_area_1 = __webpack_require__(/*! ../expressions/_check_database_work_area */ "./node_modules/@abaplint/core/build/src/abap/5_syntax/expressions/_check_database_work_area.js");
 class ModifyDatabase {
     runSyntax(node, input) {
         for (const d of node.findAllExpressions(Expressions.Dynamic)) {
             dynamic_1.Dynamic.runSyntax(d, input);
         }
+        let dbSource = undefined;
         const dbtab = node.findFirstExpression(Expressions.DatabaseTable);
         if (dbtab !== undefined) {
             if (node.getChildren().length === 5) {
@@ -44210,19 +44683,21 @@ class ModifyDatabase {
                     input.scope.addReference(dbtab.getFirstToken(), found, _reference_1.ReferenceType.DataWriteReference, input.filename);
                 }
                 else {
-                    database_table_1.DatabaseTable.runSyntax(dbtab, input);
+                    dbSource = database_table_1.DatabaseTable.runSyntax(dbtab, input);
                 }
             }
             else {
-                database_table_1.DatabaseTable.runSyntax(dbtab, input);
+                dbSource = database_table_1.DatabaseTable.runSyntax(dbtab, input);
             }
         }
+        const sourceTypes = new Map();
         for (const s of node.findAllExpressions(Expressions.Source)) {
-            source_1.Source.runSyntax(s, input);
+            sourceTypes.set(s, source_1.Source.runSyntax(s, input));
         }
         for (const s of node.findAllExpressions(Expressions.SimpleSource3)) {
-            source_1.Source.runSyntax(s, input);
+            sourceTypes.set(s, source_1.Source.runSyntax(s, input));
         }
+        (0, _check_database_work_area_1.checkDatabaseWorkArea)(node, dbSource, sourceTypes, input);
     }
 }
 exports.ModifyDatabase = ModifyDatabase;
@@ -48122,11 +48597,13 @@ const identifier_1 = __webpack_require__(/*! ../../1_lexer/tokens/identifier */
 const database_table_1 = __webpack_require__(/*! ../expressions/database_table */ "./node_modules/@abaplint/core/build/src/abap/5_syntax/expressions/database_table.js");
 const dynamic_1 = __webpack_require__(/*! ../expressions/dynamic */ "./node_modules/@abaplint/core/build/src/abap/5_syntax/expressions/dynamic.js");
 const _check_database_fields_1 = __webpack_require__(/*! ../expressions/_check_database_fields */ "./node_modules/@abaplint/core/build/src/abap/5_syntax/expressions/_check_database_fields.js");
+const _check_database_work_area_1 = __webpack_require__(/*! ../expressions/_check_database_work_area */ "./node_modules/@abaplint/core/build/src/abap/5_syntax/expressions/_check_database_work_area.js");
 class UpdateDatabase {
     runSyntax(node, input) {
+        let dbSource = undefined;
         const dbtab = node.findFirstExpression(Expressions.DatabaseTable);
         if (dbtab !== undefined) {
-            const dbSource = database_table_1.DatabaseTable.runSyntax(dbtab, input);
+            dbSource = database_table_1.DatabaseTable.runSyntax(dbtab, input);
             const fields = node.findAllExpressions(Expressions.SQLFieldAndValue)
                 .flatMap(fieldAndValue => fieldAndValue.findDirectExpressions(Expressions.SQLFieldName))
                 .map(field => field.concatTokens().toUpperCase());
@@ -48149,15 +48626,17 @@ class UpdateDatabase {
                 }
             }
         }
+        const sourceTypes = new Map();
         for (const s of node.findAllExpressions(Expressions.Source)) {
-            source_1.Source.runSyntax(s, input);
+            sourceTypes.set(s, source_1.Source.runSyntax(s, input));
         }
         for (const s of node.findAllExpressions(Expressions.SimpleSource3)) {
-            source_1.Source.runSyntax(s, input);
+            sourceTypes.set(s, source_1.Source.runSyntax(s, input));
         }
         for (const d of node.findAllExpressions(Expressions.Dynamic)) {
             dynamic_1.Dynamic.runSyntax(d, input);
         }
+        (0, _check_database_work_area_1.checkDatabaseWorkArea)(node, dbSource, sourceTypes, input);
         if (input.scope.getType() === _scope_type_1.ScopeType.OpenSQL) {
             input.scope.pop(node.getLastToken().getEnd());
         }
@@ -48346,7 +48825,7 @@ class WhenType {
         if (nameToken === undefined) {
             return undefined;
         }
-        let type = undefined;
+        let type;
         const className = nameToken.getStr().toUpperCase();
         const found = input.scope.existsObject(className);
         if (found === null || found === void 0 ? void 0 : found.id) {
@@ -53470,7 +53949,7 @@ class Attributes {
         return false;
     }
     parseAttribute(node, visibility, input) {
-        let found = undefined;
+        let found;
         const s = node.get();
         if (s instanceof Statements.Data) {
             found = new data_1.Data().runSyntax(node, input);
@@ -55646,7 +56125,7 @@ class CDSLexer {
                     break;
                 case "@":
                     // @ starts a new annotation; flush current token and start building with @
-                    build = result.add(build, row, col, mode);
+                    result.add(build, row, col, mode);
                     build = "@";
                     break;
                 default:
@@ -60520,7 +60999,7 @@ class Help {
         return content;
     }
     static dumpABAP(file, reg, textDocument, position) {
-        let content = "";
+        let content;
         content = `
     <a href="#_tokens" rel="no-refresh">Tokens</a> |
     <a href="#_statements" rel="no-refresh">Statements</a> |
@@ -60553,7 +61032,7 @@ class Help {
         return `<h3 id="_info">Info Dump</h3><pre>` + text + "</pre>";
     }
     static cursorInformation(reg, textDocument, position, file) {
-        let ret = "";
+        let ret;
         const found = _lsp_utils_1.LSPUtils.findCursor(reg, { textDocument, position });
         if (found !== undefined) {
             ret = "Statement: " + this.linkToStatement(found.snode.get()) + "<br>\n" +
@@ -64311,7 +64790,7 @@ class DataElement extends _abstract_object_1.AbstractObject {
     }
     parseType(reg) {
         const references = [];
-        let lookup = undefined;
+        let lookup;
         this.parse();
         if (this.parsedXML === undefined) {
             lookup = { type: new Types.UnknownType("Data Element " + this.getName() + ", parser error") };
@@ -69762,6 +70241,7 @@ class Table extends _abstract_object_1.AbstractObject {
                 PRECFIELD: field.PRECFIELD,
                 LENG: field.LENG,
                 INTLEN: field.INTLEN,
+                INTTYPE: field.INTTYPE,
                 DATATYPE: field.DATATYPE,
                 DECIMALS: field.DECIMALS,
                 KEYFLAG: field.KEYFLAG,
@@ -71280,7 +71760,7 @@ class Registry {
     }
     static abaplintVersion() {
         // magic, see build script "version.js"
-        return "2.120.71";
+        return "2.120.72";
     }
     getDDICReferences() {
         return this.ddicReferences;
@@ -72628,7 +73108,7 @@ class AlignPseudoComments extends _abap_rule_1.ABAPRule {
             }
             const col = firstCommentToken.getStart().getCol();
             if (previousEnd.getCol() < expectedColumn && col !== expectedColumn) {
-                let fix = undefined;
+                let fix;
                 if (col < expectedColumn) {
                     fix = edit_helper_1.EditHelper.insertAt(file, firstCommentToken.getStart(), " ".repeat(expectedColumn - col));
                 }
@@ -72795,7 +73275,7 @@ ENDINTERFACE.`,
             if (f.after.getCol() === column) {
                 continue;
             }
-            let fix = undefined;
+            let fix;
             if (f.after.getCol() < column) {
                 fix = edit_helper_1.EditHelper.insertAt(file, f.after, " ".repeat(column - f.after.getCol()));
             }
@@ -75186,7 +75666,7 @@ ENDCASE.`,
         if (tuples.length === 1) {
             return false;
         }
-        let chain = "";
+        let chain;
         if (tuples[0].left === tuples[1].left) {
             chain = tuples[0].left;
         }
@@ -75475,7 +75955,7 @@ class CheckDDIC {
         this.conf = conf;
     }
     run(obj) {
-        let found = undefined;
+        let found;
         if (obj instanceof Objects.DataElement
             || obj instanceof Objects.Domain
             || obj instanceof Objects.Table
@@ -76199,7 +76679,6 @@ ENDCLASS.`,
         this.conf = conf;
     }
     runParsed(file, obj) {
-        let issues = [];
         if (this.conf.patternKind === undefined) {
             this.conf.patternKind = "required";
         }
@@ -76220,8 +76699,7 @@ ENDCLASS.`,
                 attributes = attributes.concat(intfDef.attributes);
             }
         }
-        issues = this.checkAttributes(attributes);
-        return issues;
+        return this.checkAttributes(attributes);
     }
     checkAttributes(attr) {
         if (attr === undefined) {
@@ -78891,7 +79369,7 @@ Make sure to test the downported code, it might not always be completely correct
         if (found) {
             return found;
         }
-        found = this.outlineGetReferenceSimple(high, lowFile);
+        found = this.outlineGetReferenceSimple(high, lowFile, highSyntax);
         if (found) {
             return found;
         }
@@ -79566,7 +80044,17 @@ ${indentation}CATCH ${className} INTO ${targetName}.`;
         const fix = edit_helper_1.EditHelper.replaceRange(lowFile, node.getStart(), node.getEnd(), code);
         return issue_1.Issue.atToken(lowFile, node.getFirstToken(), "Outline DATA", this.getMetadata().key, this.conf.severity, fix);
     }
-    outlineGetReferenceSimple(node, lowFile) {
+    /** the type of a reference to the source: LIKE REF TO it, or REF TO data when its type is generic,
+     *  as LIKE REF TO a generically typed field symbol or parameter does not activate */
+    refTypeOf(sourceName, node, lowFile, highSyntax) {
+        var _a;
+        const spag = highSyntax.spaghetti.lookupPosition(node.getFirstToken().getStart(), lowFile.getFilename());
+        if (((_a = spag === null || spag === void 0 ? void 0 : spag.findVariable(sourceName)) === null || _a === void 0 ? void 0 : _a.getType().isGeneric()) === true) {
+            return "TYPE REF TO data";
+        }
+        return "LIKE REF TO " + sourceName;
+    }
+    outlineGetReferenceSimple(node, lowFile, highSyntax) {
         var _a, _b, _c;
         if (!(node.get() instanceof Statements.GetReference)) {
             return undefined;
@@ -79583,7 +80071,8 @@ ${indentation}CATCH ${className} INTO ${targetName}.`;
         const indentation = " ".repeat(node.getFirstToken().getStart().getCol() - 1);
         const firstToken = target.getFirstToken();
         const lastToken = target.getLastToken();
-        const fix1 = edit_helper_1.EditHelper.insertAt(lowFile, node.getStart(), `DATA ${targetName} LIKE REF TO ${source.concatTokens()}.\n${indentation}`);
+        const refType = this.refTypeOf(source.concatTokens(), node, lowFile, highSyntax);
+        const fix1 = edit_helper_1.EditHelper.insertAt(lowFile, node.getStart(), `DATA ${targetName} ${refType}.\n${indentation}`);
         const fix2 = edit_helper_1.EditHelper.replaceRange(lowFile, firstToken.getStart(), lastToken.getEnd(), targetName);
         const fix = edit_helper_1.EditHelper.merge(fix2, fix1);
         return issue_1.Issue.atToken(lowFile, node.getFirstToken(), "Outline DATA", this.getMetadata().key, this.conf.severity, fix);
@@ -79600,7 +80089,7 @@ ${indentation}CATCH ${className} INTO ${targetName}.`;
         if (!(((_a = target === null || target === void 0 ? void 0 : target.getFirstChild()) === null || _a === void 0 ? void 0 : _a.get()) instanceof Expressions.InlineData)) {
             return undefined;
         }
-        let type = "";
+        let type;
         const source = node.findFirstExpression(Expressions.Source);
         if (source === undefined) {
             return undefined;
@@ -79690,8 +80179,8 @@ ${indentation}CATCH ${className} INTO ${targetName}.`;
         if (!(node.get() instanceof Statements.Raise)) {
             return undefined;
         }
-        let id = undefined;
-        let number = undefined;
+        let id;
+        let number;
         let startToken = node.findDirectTokenByText("ID");
         if (startToken) {
             const sources = node.findDirectExpressions(Expressions.Source);
@@ -79849,7 +80338,7 @@ ${indentation}${uniqueName2}->if_t100_message~t100key = ${uniqueName1}.\n`;
             || sourceRef.getChildren().length !== 1) {
             return undefined;
         }
-        let code = "";
+        let code;
         if (sourceRef.findFirstExpression(Expressions.TableExpression)) {
             const uniqueName = this.uniqueName(high.getFirstToken().getStart(), lowFile.getFilename(), highSyntax);
             code = `ASSIGN ${sourceRef.concatTokens()} TO FIELD-SYMBOL(<${uniqueName}>).
@@ -80041,7 +80530,7 @@ LOOP AT ${groupTargetName}tab ${groupTarget}.`;
             || !(tableExpression instanceof nodes_1.ExpressionNode)) {
             return undefined;
         }
-        let condition = "";
+        let condition;
         if (tableExpression.getChildren().length === 3) {
             const index = tableExpression.findDirectExpression(Expressions.Source);
             if (index === undefined) {
@@ -80225,7 +80714,7 @@ ${indentation}${uniqueName}`;
             return undefined;
         }
         const op = secondChild.getFirstToken();
-        let operator = "";
+        let operator;
         switch (op.getStr()) {
             case "+":
                 operator = " + ";
@@ -80267,7 +80756,7 @@ ${indentation}${uniqueName}`;
                 || (formatting === null || formatting === void 0 ? void 0 : formatting.startsWith("ALPHA = ")) === false) {
                 continue;
             }
-            let functionName = "";
+            let functionName;
             switch (formatting) {
                 case "ALPHA = IN":
                     functionName = "CONVERSION_EXIT_ALPHA_INPUT";
@@ -80563,13 +81052,12 @@ ${indentation}    output = ${uniqueName}.\n`;
             const uniqueName = this.uniqueName(firstToken.getStart(), lowFile.getFilename(), highSyntax);
             const indentation = " ".repeat(high.getFirstToken().getStart().getCol() - 1);
             let body = "";
-            let name = "";
             const switchBody = i.findDirectExpression(Expressions.SwitchBody);
             if (switchBody === undefined) {
                 continue;
             }
             for (const l of ((_c = switchBody === null || switchBody === void 0 ? void 0 : switchBody.findDirectExpression(Expressions.Let)) === null || _c === void 0 ? void 0 : _c.findDirectExpressions(Expressions.InlineFieldDefinition)) || []) {
-                name = l.getFirstToken().getStr();
+                const name = l.getFirstToken().getStr();
                 body += indentation + `DATA(${name}) = ${(_d = switchBody.findFirstExpression(Expressions.Source)) === null || _d === void 0 ? void 0 : _d.concatTokens()}.\n`;
             }
             body += `DATA ${uniqueName} ${type}.\n`;
@@ -80627,7 +81115,6 @@ ${indentation}    output = ${uniqueName}.\n`;
             const uniqueName = this.uniqueName(firstToken.getStart(), lowFile.getFilename(), highSyntax);
             const indentation = " ".repeat(high.getFirstToken().getStart().getCol() - 1);
             let body = "";
-            let name = "";
             const reduceBody = i.findDirectExpression(Expressions.ReduceBody);
             if (reduceBody === undefined) {
                 continue;
@@ -80638,7 +81125,7 @@ ${indentation}    output = ${uniqueName}.\n`;
             }
             let firstName = "";
             for (const init of reduceBody.findDirectExpressions(Expressions.InlineFieldDefinition)) {
-                name = init.getFirstToken().getStr();
+                const name = init.getFirstToken().getStr();
                 if (firstName === "") {
                     firstName = name;
                 }
@@ -80870,7 +81357,7 @@ ${indentation}    output = ${uniqueName}.\n`;
                         after += c.concatTokens();
                     }
                 }
-                let condition = "";
+                let condition;
                 if ((tableExpression === null || tableExpression === void 0 ? void 0 : tableExpression.getChildren().length) === 3) {
                     condition = "INDEX " + ((_d = tableExpression === null || tableExpression === void 0 ? void 0 : tableExpression.findDirectExpression(Expressions.Source)) === null || _d === void 0 ? void 0 : _d.concatTokens());
                 }
@@ -81021,7 +81508,7 @@ ${indentation}    output = ${uniqueName}.\n`;
                 continue;
             }
             const name = nameToken.getStr();
-            let type = "";
+            let type;
             if (high.concatTokens().toUpperCase().startsWith("APPEND INITIAL LINE TO ")) {
                 type = "LIKE LINE OF " + ((_b = high.findFirstExpression(Expressions.Target)) === null || _b === void 0 ? void 0 : _b.concatTokens());
             }
@@ -81387,7 +81874,7 @@ ${indentation}    output = ${uniqueName}.\n`;
         }
         return undefined;
     }
-    getReference(node, lowFile, _highSyntax) {
+    getReference(node, lowFile, highSyntax) {
         var _a, _b, _c;
         if (!(node.get() instanceof Statements.GetReference)) {
             return undefined;
@@ -81401,7 +81888,7 @@ ${indentation}    output = ${uniqueName}.\n`;
         if (targetName === undefined || sourceName === undefined) {
             return undefined;
         }
-        const code = `DATA ${targetName} LIKE REF TO ${sourceName}.\n`;
+        const code = `DATA ${targetName} ${this.refTypeOf(sourceName, node, lowFile, highSyntax)}.\n`;
         const fix1 = edit_helper_1.EditHelper.insertAt(lowFile, node.getFirstToken().getStart(), code);
         const fix2 = edit_helper_1.EditHelper.replaceRange(lowFile, inline.getFirstToken().getStart(), inline.getLastToken().getEnd(), targetName);
         const fix = edit_helper_1.EditHelper.merge(fix2, fix1);
@@ -81478,18 +81965,30 @@ ${indentation}    output = ${uniqueName}.\n`;
                 const uniqueName = this.uniqueName(node.getFirstToken().getStart(), lowFile.getFilename(), highSyntax);
                 const indentation = " ".repeat(node.getFirstToken().getStart().getCol() - 1);
                 const sy = func === "LINE_EXISTS" ? "sy-subrc" : "sy-tabix";
-                const code = `DATA ${uniqueName} LIKE sy-subrc.\n` +
-                    indentation + `READ TABLE ${tableName} ${condition}TRANSPORTING NO FIELDS.\n` +
-                    indentation + uniqueName + ` = ${sy}.\n` +
-                    indentation;
                 let insertAt = node.getFirstToken().getStart();
                 if (node.get() instanceof statements_1.ElseIf) {
-                    // assumption: no side effects in IF conditions
+                    // assumption: no side effects in IF conditions, except the READ itself, see below
                     insertAt = this.findStartOfIf(node, highFile);
                     if (insertAt === undefined) {
                         continue;
                     }
                 }
+                // the READ sets sy-subrc and sy-tabix, which the built-in function does not,
+                // keep the values for the code that reads them after the inserted READ
+                const keep = [];
+                const reads = this.readSyFields(insertAt, highFile);
+                for (const field of ["sy-subrc", "sy-tabix"]) {
+                    if (reads.has(field)) {
+                        keep.push({ field, name: this.uniqueName(node.getFirstToken().getStart(), lowFile.getFilename(), highSyntax) });
+                    }
+                }
+                const code = `DATA ${uniqueName} LIKE sy-subrc.\n` +
+                    keep.map(k => indentation + `DATA ${k.name} LIKE ${k.field}.\n`).join("") +
+                    keep.map(k => indentation + `${k.name} = ${k.field}.\n`).join("") +
+                    indentation + `READ TABLE ${tableName} ${condition}TRANSPORTING NO FIELDS.\n` +
+                    indentation + uniqueName + ` = ${sy}.\n` +
+                    keep.map(k => indentation + `${k.field} = ${k.name}.\n`).join("") +
+                    indentation;
                 const fix1 = edit_helper_1.EditHelper.insertAt(lowFile, insertAt, code);
                 const start = expression.getFirstToken().getStart();
                 const end = expression.getLastToken().getEnd();
@@ -81500,6 +81999,46 @@ ${indentation}    output = ${uniqueName}.\n`;
         }
         return undefined;
     }
+    /** sy-subrc and sy-tabix, when read from the position on, in the procedure around it or the file outside of one;
+     *  inside a loop from the start of the outermost loop, as the next pass reads what this one left */
+    readSyFields(position, highFile) {
+        const structure = highFile.getStructure();
+        const contains = (s) => !position.isBefore(s.getFirstToken().getStart())
+            && !position.isAfter(s.getLastToken().getStart());
+        let scope = undefined;
+        for (const s of [Structures.Method, Structures.Form, Structures.FunctionModule]) {
+            for (const p of (structure === null || structure === void 0 ? void 0 : structure.findAllStructuresRecursive(s)) || []) {
+                if (contains(p)) {
+                    scope = p;
+                }
+            }
+        }
+        scope = scope || structure;
+        let from = position;
+        for (const s of [Structures.Loop, Structures.Do, Structures.While, Structures.Select]) {
+            for (const l of (scope === null || scope === void 0 ? void 0 : scope.findAllStructuresRecursive(s)) || []) {
+                if (contains(l) && l.getFirstToken().getStart().isBefore(from)) {
+                    from = l.getFirstToken().getStart();
+                }
+            }
+        }
+        const ret = new Set();
+        for (const s of (scope === null || scope === void 0 ? void 0 : scope.findAllStatementNodes()) || []) {
+            if (s.getLastToken().getStart().isBefore(from)) {
+                continue;
+            }
+            const tokens = s.getTokens();
+            for (let i = 0; i < tokens.length - 2; i++) {
+                if (tokens[i].getStr().toUpperCase() === "SY" && tokens[i + 1].getStr() === "-") {
+                    const field = "sy-" + tokens[i + 2].getStr().toLowerCase();
+                    if (field === "sy-subrc" || field === "sy-tabix") {
+                        ret.add(field);
+                    }
+                }
+            }
+        }
+        return ret;
+    }
     findStartOfIf(node, highFile) {
         const structure = highFile.getStructure();
         for (const c of (structure === null || structure === void 0 ? void 0 : structure.findAllStructuresRecursive(Structures.If)) || []) {
@@ -81512,6 +82051,7 @@ ${indentation}    output = ${uniqueName}.\n`;
         return undefined;
     }
     newToCreateObject(low, high, lowFile, highSyntax) {
+        var _a;
         if (!(low.get() instanceof _statement_1.Unknown)) {
             return undefined;
         }
@@ -81527,7 +82067,7 @@ ${indentation}    output = ${uniqueName}.\n`;
                 && found
                 && source.concatTokens() === found.concatTokens()
                 && target.findDirectExpression(Expressions.InlineData) === undefined) {
-                const abap = this.newParameters(found, target.concatTokens(), highSyntax, lowFile);
+                const abap = (_a = this.newDataReference(high, target, found, lowFile, highSyntax)) !== null && _a !== void 0 ? _a : this.newParameters(found, target.concatTokens(), highSyntax, lowFile);
                 if (abap !== undefined) {
                     fix = edit_helper_1.EditHelper.replaceRange(lowFile, high.getFirstToken().getStart(), high.getLastToken().getEnd(), abap);
                 }
@@ -81566,6 +82106,42 @@ ${indentation}    output = ${uniqueName}.\n`;
             return undefined;
         }
     }
+    /** NEW into a data reference creates data, CREATE OBJECT cannot: "target = NEW #|type( [value] )"
+     *  with a variable typed REF TO a data type becomes CREATE DATA plus the assignment of the value */
+    newDataReference(high, target, found, lowFile, highSyntax) {
+        var _a, _b, _c;
+        if (target.getChildren().length !== 1 || !(((_a = target.getFirstChild()) === null || _a === void 0 ? void 0 : _a.get()) instanceof Expressions.TargetField)) {
+            return undefined;
+        }
+        const children = found.getChildren();
+        const value = found.findDirectExpression(Expressions.Source);
+        // NEW, the type, "(", optionally one value, ")"
+        if (children.length !== 4 + (value ? 1 : 0)) {
+            return undefined;
+        }
+        const name = target.concatTokens();
+        const spag = highSyntax.spaghetti.lookupPosition(high.getFirstToken().getStart(), lowFile.getFilename());
+        const type = (_b = spag === null || spag === void 0 ? void 0 : spag.findVariable(name)) === null || _b === void 0 ? void 0 : _b.getType();
+        if (!(type instanceof basic_1.DataReference)) {
+            return undefined;
+        }
+        const typeName = (_c = found.findDirectExpression(Expressions.TypeNameOrInfer)) === null || _c === void 0 ? void 0 : _c.concatTokens();
+        const indentation = " ".repeat(high.getFirstToken().getStart().getCol() - 1);
+        let abap = `CREATE DATA ${name}` + (typeName === "#" ? "" : ` TYPE ${typeName}`) + ".";
+        if (value === undefined) {
+            return abap;
+        }
+        else if (type.getType().isGeneric() === false) {
+            return abap + `\n${indentation}${name}->* = ${value.concatTokens()}.`;
+        }
+        // a generic reference cannot be dereferenced as a target below v756
+        const fs = this.uniqueName(high.getFirstToken().getStart(), lowFile.getFilename(), highSyntax, true);
+        abap = `FIELD-SYMBOLS ${fs} TYPE any.\n` +
+            indentation + abap + "\n" +
+            indentation + `ASSIGN ${name}->* TO ${fs}.\n` +
+            indentation + `${fs} = ${value.concatTokens()}.`;
+        return abap;
+    }
     newParameters(found, name, highSyntax, lowFile) {
         var _a, _b, _c;
         const typeToken = (_a = found.findDirectExpression(Expressions.TypeNameOrInfer)) === null || _a === void 0 ? void 0 : _a.getFirstToken();
@@ -82357,6 +82933,8 @@ class EmptyStructureConf extends _basic_rule_config_1.BasicRuleConfig {
         this.try = true;
         /** Checks for empty WHEN blocks */
         this.when = true;
+        /** Checks for empty CATCH blocks, unless the CATCH has pragma ##NO_HANDLER or pseudo comment "#EC NO_HANDLER */
+        this.catch = false;
         // todo, other category containing ELSE
     }
 }
@@ -82469,6 +83047,21 @@ result = xsdbool( sy-subrc = 0 ).`,
                 }
             }
         }
+        if (this.getConfig().catch === true) {
+            for (const c of stru.findAllStructuresRecursive(Structures.Catch)) {
+                // a comment in the block does not count, the extended check (SLIN) reports it too
+                if (c.findDirectStructure(Structures.Body) !== undefined) {
+                    continue;
+                }
+                const catchStatement = c.getFirstStatement();
+                if (catchStatement === undefined || this.isNoHandler(catchStatement, statements)) {
+                    continue;
+                }
+                const token = c.getFirstToken();
+                const issue = issue_1.Issue.atToken(file, token, this.getDescription(c.get().constructor.name), this.getMetadata().key, this.conf.severity);
+                issues.push(issue);
+            }
+        }
         if (this.getConfig().when === true) {
             const tries = stru.findAllStructuresRecursive(Structures.When);
             for (const t of tries) {
@@ -82482,6 +83075,15 @@ result = xsdbool( sy-subrc = 0 ).`,
         }
         return issues;
     }
+    isNoHandler(catchStatement, statements) {
+        if (catchStatement.getPragmas().some(p => p.getStr().toUpperCase() === "##NO_HANDLER")) {
+            return true;
+        }
+        const next = statements[statements.indexOf(catchStatement) + 1];
+        return (next === null || next === void 0 ? void 0 : next.get()) instanceof _statement_1.Comment
+            && next.getStart().getRow() === catchStatement.getEnd().getRow()
+            && next.concatTokens().toUpperCase().replace(/\s/g, "").includes("\"#ECNO_HANDLER");
+    }
 }
 exports.EmptyStructure = EmptyStructure;
 //# sourceMappingURL=empty_structure.js.map
@@ -83918,7 +84520,7 @@ cl_abap_typedescr=>describe_by_name(
         const methodSource = statNode.findDirectExpression(Expressions.MethodSource);
         let methodSourceStr = methodSource === null || methodSource === void 0 ? void 0 : methodSource.concatTokens();
         const methodBody = statNode.findDirectExpression(Expressions.MethodCallBody);
-        let methodBodyStr = "";
+        let methodBodyStr;
         if (methodBody) {
             const methodCallParam = methodBody.findDirectExpression(Expressions.MethodCallParam);
             if (methodCallParam && methodCallParam.getFirstToken().getStr() === "(") {
@@ -86812,7 +87414,7 @@ class KeywordCase extends _abap_rule_1.ABAPRule {
         const firstToken = tokens[0].token;
         const lastToken = tokens[tokens.length - 1].token;
         const firstTokenValue = firstToken.getStr();
-        let description = "";
+        let description;
         if (first.keyword === true) {
             description = `Keyword should be ${this.conf.style} case: "${firstTokenValue}"`;
         }
@@ -87337,7 +87939,7 @@ ENDCLASS.`,
                 continue;
             }
             const className = classDef.name;
-            let expected = "";
+            let expected;
             if (classDef.isForTesting) {
                 expected = this.conf.test;
             }
@@ -88003,7 +88605,7 @@ ENDIF.
             issues.push(...this.analyzeCondition(file, cond));
         }
         for (const sub of structure.findAllExpressionsMulti([Expressions.CondSub, Expressions.ComponentCondSub])) {
-            let cond = [];
+            let cond;
             if (sub.get() instanceof Expressions.CondSub) {
                 cond = sub.findDirectExpressions(Expressions.Cond);
             }
@@ -92041,13 +92643,9 @@ ENDIF.`,
         }
         else if (statement instanceof Statements.ClassDefinitionLoad ||
             statement instanceof Statements.InterfaceLoad) {
-            let token = undefined;
-            if (statement instanceof Statements.ClassDefinitionLoad) {
-                token = statementNode.getChildren()[3].getFirstToken();
-            }
-            else {
-                token = statementNode.getChildren()[2].getFirstToken();
-            }
+            const token = statement instanceof Statements.ClassDefinitionLoad
+                ? statementNode.getChildren()[3].getFirstToken()
+                : statementNode.getChildren()[2].getFirstToken();
             let startPosition = token.getStart();
             startPosition = new position_1.Position(startPosition.getRow(), startPosition.getCol() - 1);
             return edit_helper_1.EditHelper.deleteRange(file, startPosition, token.getEnd());
@@ -92844,7 +93442,6 @@ Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.ParserMissingSpace = exports.ParserMissingSpaceConf = void 0;
 const Expressions = __importStar(__webpack_require__(/*! ../abap/2_statements/expressions */ "./node_modules/@abaplint/core/build/src/abap/2_statements/expressions/index.js"));
 const issue_1 = __webpack_require__(/*! ../issue */ "./node_modules/@abaplint/core/build/src/issue.js");
-const position_1 = __webpack_require__(/*! ../position */ "./node_modules/@abaplint/core/build/src/position.js");
 const _abap_rule_1 = __webpack_require__(/*! ./_abap_rule */ "./node_modules/@abaplint/core/build/src/rules/_abap_rule.js");
 const nodes_1 = __webpack_require__(/*! ../abap/nodes */ "./node_modules/@abaplint/core/build/src/abap/nodes/index.js");
 const _basic_rule_config_1 = __webpack_require__(/*! ./_basic_rule_config */ "./node_modules/@abaplint/core/build/src/rules/_basic_rule_config.js");
@@ -92877,7 +93474,7 @@ This rule makes sure the spaces are consistently required across the language.`,
     }
     runParsed(file) {
         const issues = [];
-        let start = new position_1.Position(0, 0);
+        let start;
         for (const statement of file.getStatements()) {
             const missing = this.missingSpace(statement);
             if (missing) {
@@ -94438,14 +95035,8 @@ From 752 and up`,
     }
     getFix(file, statement, withExporting) {
         const children = statement.getChildren();
-        let contentFix = undefined;
-        if (withExporting) {
-            const fixText = "( " + children[5].concatTokens() + " ).";
-            contentFix = edit_helper_1.EditHelper.replaceRange(file, children[3].getLastToken().getEnd(), statement.getEnd(), fixText);
-        }
-        else {
-            contentFix = edit_helper_1.EditHelper.replaceRange(file, children[3].getLastToken().getEnd(), statement.getEnd(), "( ).");
-        }
+        const fixText = withExporting ? "( " + children[5].concatTokens() + " )." : "( ).";
+        const contentFix = edit_helper_1.EditHelper.replaceRange(file, children[3].getLastToken().getEnd(), statement.getEnd(), fixText);
         const replaceType = edit_helper_1.EditHelper.replaceToken(file, children[2].getFirstToken(), "NEW");
         return edit_helper_1.EditHelper.merge(contentFix, replaceType);
     }
@@ -102872,6 +103463,7 @@ class XMLConsistency {
 * Naming for CLAS and INTF objects
 * QUAN fields in TABL objects have reference table and field values
 * Transparent TABL objects have delivery class and size category set
+* TABL fields with a built-in type carry the INTTYPE abapGit serializes for it, for the confirmed pairs
 * Lock parameter names in ENQU objects are max 16 characters
 * Texts and translations do not exceed maximum allowed length.`,
             tags: [_irule_1.RuleTag.Naming, _irule_1.RuleTag.Syntax],
@@ -103138,6 +103730,12 @@ class XMLConsistency {
                 const message = `QUAN field ${field.FIELDNAME} must have REFTABLE and REFFIELD set`;
                 issues.push(issue_1.Issue.atRow(file, 1, message, this.getMetadata().key, this.conf.severity));
             }
+            const expected = field.DATATYPE ? XMLConsistency.intTypes[field.DATATYPE] : undefined;
+            if (expected !== undefined && field.INTTYPE !== undefined && field.INTTYPE !== expected) {
+                const message = `Field ${field.FIELDNAME}: INTTYPE "${field.INTTYPE}" does not match DATATYPE ${field.DATATYPE}, ` +
+                    `abapGit serializes "${expected}"`;
+                issues.push(issue_1.Issue.atRow(file, 1, message, this.getMetadata().key, this.conf.severity));
+            }
         }
         if (obj.getTableCategory() === Objects.TableCategory.Transparent) {
             // Confirmed reserved database field names, see issue #4331, DAY and HOUR reported by activation.
@@ -103161,6 +103759,15 @@ class XMLConsistency {
     }
 }
 exports.XMLConsistency = XMLConsistency;
+// INTTYPE that abapGit serializes for a built-in DATATYPE, confirmed by exported tables;
+// a different value activates, but shows as a diff on every pull
+XMLConsistency.intTypes = {
+    "CHAR": "C", "CLNT": "C", "CUKY": "C", "LANG": "C",
+    "DATS": "D", "TIMS": "T",
+    "INT4": "X", "RAW": "X",
+    "DEC": "P", "CURR": "P",
+    "STRG": "g", "SSTR": "g", "RSTR": "y",
+};
 //# sourceMappingURL=xml_consistency.js.map
 
 /***/ },
@@ -103783,7 +104390,7 @@ class FormLengthStats {
         return res;
     }
     static findName(stat) {
-        let name = "";
+        let name;
         const nameExpr = stat.findFirstExpression(expressions_1.FormName);
         if (nameExpr) {
             name = nameExpr.getFirstToken().getStr();
@@ -104194,7 +104801,7 @@ class MethodLengthStats {
         return res;
     }
     static findName(stat) {
-        let name = "";
+        let name;
         const nameExpr = stat.findFirstExpression(expressions_1.MethodName);
         if (nameExpr) {
             name = nameExpr.getFirstToken().getStr();
@@ -127051,13 +127658,20 @@ class Traversal {
         if (ref === undefined) {
             return undefined;
         }
-        // local
+        // local, also when the interface is declared in another include of the same object,
+        // eg. a local interface in the locals_imp of a class, used in its test classes
         if (ref.getFilename() === this.getFilename()) {
             const scope = this.findCurrentScopeByToken(ref.getToken());
             if (scope?.getIdentifier().stype === abaplint.ScopeType.Interface) {
                 return scope?.getIdentifier().sname;
             }
         }
+        else if (this.getCurrentObject().getABAPFileByName(ref.getFilename()) !== undefined) {
+            const scope = this.spaghetti.lookupPosition(ref.getStart(), ref.getFilename());
+            if (scope?.getIdentifier().stype === abaplint.ScopeType.Interface) {
+                return scope?.getIdentifier().sname;
+            }
+        }
         // global
         for (const obj of this.reg.getObjectsByType("INTF")) {
             if (obj.getFiles().some(f => f.getFilename() === ref.getFilename())) {
@@ -127422,8 +128036,33 @@ this.INTERNAL_ID = abap.internalIdCounter++;\n`;
         return `abap.Classes['${name}'] = ${Traversal.escapeNamespace(def.getName().toLowerCase())};`;
     }
     setValues(identifier, name) {
+        // an enumerated value of a class or interface, declared without STRUCTURE: number the
+        // values in the order they are declared, like the STRUCTURE components in setValues below
+        if (identifier.getValue() === "novalueClassAttributeEnum"
+            && !(identifier.getType() instanceof abaplint.BasicTypes.StructureType)) {
+            const index = this.findEnumValueIndex(identifier);
+            return index === undefined ? "" : Traversal.prefixVariable(name) + ".set(" + index + ");\n";
+        }
         return Traversal.setValues(identifier, name);
     }
+    /** position of an enumerated value in its TYPES BEGIN OF ENUM, counting from 0 */
+    findEnumValueIndex(identifier) {
+        // the enum can be declared in another object, eg. a global interface the class implements
+        const filename = identifier.getFilename();
+        const raw = this.reg.getFileByName(filename);
+        const obj = raw === undefined ? undefined : this.reg.findObjectForFile(raw);
+        const file = obj instanceof abaplint.ABAPObject ? obj.getABAPFileByName(filename) : undefined;
+        for (const enumeration of file?.getStructure()?.findAllStructures(abaplint.Structures.TypeEnum) || []) {
+            const values = enumeration.getChildren().filter(c => c instanceof abaplint.Nodes.StatementNode
+                && (c.get() instanceof abaplint.Statements.Type || c.get() instanceof abaplint.Statements.TypeEnum));
+            const index = values.findIndex(v => v
+                .findFirstExpression(abaplint.Expressions.NamespaceSimpleName)?.getFirstToken().getStart().equals(identifier.getStart()));
+            if (index >= 0) {
+                return index;
+            }
+        }
+        return undefined;
+    }
     static setValues(identifier, name) {
         const val = identifier.getValue();
         let ret = "";
@@ -127819,6 +128458,11 @@ run().then(() => {
                         }
                         methods.push(m.name);
                     }
+                    if (methods.length === 0) {
+                        // FOR TESTING helper class without test methods, nothing to run; it might also
+                        // live in locals_imp, which is not exported from the .testclasses module
+                        continue;
+                    }
                     tests.push({
                         obj,
                         filename: `${(0, output_layout_1.importPath)("index.mjs", this.layout.objectModule(obj, ".testclasses"))}`,