@abaplint/transpiler-cli 2.10.58 → 2.10.60

package/build/bundle.js

@@ -71,6 +71,9 @@ exports.FileOperations = void 0;
 const fs = __webpack_require__(/*! fs */ "fs");
 const path = __webpack_require__(/*! path */ "path");
 const glob = __webpack_require__(/*! glob */ "./node_modules/glob/glob.js");
+const pLimit = __webpack_require__(/*! p-limit */ "./node_modules/p-limit/index.js");
+const os = __webpack_require__(/*! node:os */ "node:os");
+const fsPromises = __webpack_require__(/*! node:fs/promises */ "node:fs/promises");
 class FileOperations {
     static deleteFolderRecursive(p) {
         if (fs.existsSync(p) === false) {
@@ -78,26 +81,46 @@ class FileOperations {
         }
         fs.rmSync(p, { recursive: true });
     }
-    static loadFiles(config) {
-        const files = [];
+    static setupPLimit() {
+        let concurrency = os.cpus().length;
+        if (concurrency > 8) {
+            concurrency = 8;
+        }
+        else if (concurrency < 1) {
+            concurrency = 1;
+        }
+        return pLimit(concurrency);
+    }
+    static async readAllFiles(filesToRead, outputFolder) {
+        const limit = this.setupPLimit();
+        const promises = filesToRead.map((filename) => {
+            return limit(async () => {
+                return {
+                    filename: path.basename(filename),
+                    relative: path.relative(outputFolder, path.dirname(filename)),
+                    contents: await fsPromises.readFile(filename, "utf8"),
+                };
+            });
+        });
+        return Promise.all(promises);
+    }
+    static async loadFiles(config) {
         const filter = (config.input_filter ?? []).map(pattern => new RegExp(pattern, "i"));
         let skipped = 0;
         let added = 0;
         const folders = Array.isArray(config.input_folder) ? config.input_folder : [config.input_folder];
+        const filesToRead = [];
         for (const folder of folders) {
             for (const filename of glob.sync(folder + "/**", { nosort: true, nodir: true })) {
                 if (filter.length > 0 && filter.some(a => a.test(filename)) === false) {
                     skipped++;
                     continue;
                 }
-                files.push({
-                    filename: path.basename(filename),
-                    relative: path.relative(config.output_folder, path.dirname(filename)),
-                    contents: fs.readFileSync(filename, "utf8"),
-                });
+                filesToRead.push(filename);
                 added++;
             }
         }
+        const files = await this.readAllFiles(filesToRead, config.output_folder);
         console.log(added + " files added from source");
         console.log(skipped + " files skipped in source");
         return files;
@@ -21361,6 +21384,19 @@ class CurrentScope {
         }
         return false;
     }
+    isAnyOO() {
+        let curr = this.current;
+        while (curr !== undefined) {
+            const stype = curr.getIdentifier().stype;
+            if (stype === _scope_type_1.ScopeType.ClassDefinition
+                || stype === _scope_type_1.ScopeType.ClassImplementation
+                || stype === _scope_type_1.ScopeType.Interface) {
+                return true;
+            }
+            curr = curr.getParent();
+        }
+        return false;
+    }
     isGlobalOO() {
         return this.parentObj.getType() === "INTF" || this.parentObj.getType() === "CLAS";
     }
@@ -22779,7 +22815,7 @@ class BasicTypes {
             if (type === undefined) {
                 type = (_a = this.input.scope.getDDIC().lookupNoVoid(name)) === null || _a === void 0 ? void 0 : _a.type;
             }
-            if (type === undefined && this.input.scope.isOO() === false && this.input.scope.getDDIC().inErrorNamespace(name) === false) {
+            if (type === undefined && this.input.scope.isAnyOO() === false && this.input.scope.getDDIC().inErrorNamespace(name) === false) {
                 this.input.scope.addReference(chain.getChildren()[0].getFirstToken(), undefined, _reference_1.ReferenceType.VoidType, this.input.filename);
                 return new Types.VoidType(name);
             }
@@ -24350,7 +24386,6 @@ class DataDefinition {
             }
         }
         if (name) {
-            console.dir("undef");
             return new _typed_identifier_1.TypedIdentifier(name.getFirstToken(), input.filename, new basic_1.UnknownType("DataDefinition, fallback"));
         }
         return undefined;
@@ -53116,7 +53151,7 @@ class Registry {
     }
     static abaplintVersion() {
         // magic, see build script "version.sh"
-        return "2.113.125";
+        return "2.113.126";
     }
     getDDICReferences() {
         return this.ddicReferences;
@@ -75838,7 +75873,7 @@ class XMLConsistency {
                 issues.push(issue_1.Issue.atRow(file, 1, "Class matching XML name not found in ABAP file", this.getMetadata().key, this.conf.severity));
             }
         }
-        if (obj instanceof Objects.Interface) {
+        else if (obj instanceof Objects.Interface) {
             const name = obj.getNameFromXML();
             if (name === undefined) {
                 issues.push(issue_1.Issue.atRow(file, 1, "Name undefined in XML", this.getMetadata().key, this.conf.severity));
@@ -81050,8 +81085,8 @@ class Transpiler {
             objects: [],
             unitTestScript: new unit_test_1.UnitTest().unitTestScript(reg, this.options?.skip),
             unitTestScriptOpen: new unit_test_1.UnitTest().unitTestScriptOpen(reg, this.options?.skip),
-            initializationScript: new initialization_1.Initialization().script(reg, dbSetup, this.options?.extraSetup),
-            initializationScript2: new initialization_1.Initialization().script(reg, dbSetup, this.options?.extraSetup, true),
+            initializationScript: new initialization_1.Initialization().script(reg, dbSetup, this.options),
+            initializationScript2: new initialization_1.Initialization().script(reg, dbSetup, this.options, true),
             databaseSetup: dbSetup,
             reg: reg,
         };
@@ -81132,7 +81167,7 @@ function escapeNamespaceFilename(filename) {
     return filename.replace(/\//g, "%23");
 }
 class Initialization {
-    script(reg, dbSetup, extraSetup, useImport) {
+    script(reg, dbSetup, options, useImport) {
         let ret = "";
         if (useImport === true) {
             ret = `/* eslint-disable import/newline-after-import */
@@ -81143,7 +81178,7 @@ import "./_top.mjs";\n`;
 import runtime from "@abaplint/runtime";
 globalThis.abap = new runtime.ABAP();\n`;
         }
-        ret += `${this.buildImports(reg, useImport)}
+        ret += `${this.buildImports(reg, useImport, options)}
 
 export async function initializeABAP() {\n`;
         ret += `  const sqlite = [];\n`;
@@ -81166,17 +81201,17 @@ export async function initializeABAP() {\n`;
             ret += `  insert.push(\`${i}\`);\n`;
         }
         ret += `\n`;
-        if (extraSetup === undefined || extraSetup === "") {
+        if (options?.extraSetup === undefined || options?.extraSetup === "") {
             ret += `// no setup logic specified in config\n`;
         }
         else {
-            ret += `  const {setup} = await import("${extraSetup}");\n` +
+            ret += `  const {setup} = await import("${options?.extraSetup}");\n` +
                 `  await setup(globalThis.abap, schemas, insert);\n`;
         }
         ret += `}`;
         return ret;
     }
-    buildImports(reg, useImport) {
+    buildImports(reg, useImport, options) {
         // note: ES modules are hoised, so use the dynamic import(), due to setting of globalThis.abap
         // some sorting required: eg. a class constructor using constant from interface
         const list = [];
@@ -81215,7 +81250,7 @@ export async function initializeABAP() {\n`;
             }
             else if (obj instanceof abaplint.Objects.Interface
                 || obj instanceof abaplint.Objects.FunctionGroup
-                // hmm          || obj instanceof abaplint.Objects.Program
+                || (options?.importProg === true && obj instanceof abaplint.Objects.Program)
                 || obj instanceof abaplint.Objects.Class) {
                 list.push(name);
             }
@@ -82941,10 +82976,10 @@ class DataTranspiler {
         }
         const ret = new chunk_1.Chunk()
             .appendString("let ")
-            .append(traversal_1.Traversal.prefixVariable(traversal_1.Traversal.escapeNamespace(found.getName().toLowerCase())), token, traversal)
+            .appendString(traversal_1.Traversal.prefixVariable(traversal_1.Traversal.escapeNamespace(found.getName().toLowerCase())))
             .appendString(" = " + new transpile_types_1.TranspileTypes().toType(found.getType()))
-            .append(";", node.getLastToken(), traversal)
-            .append(value, node.getLastToken(), traversal);
+            .appendString(";")
+            .appendString(value);
         return ret;
     }
     static buildValue(node, name, traversal) {
@@ -83787,9 +83822,9 @@ class FieldSymbolTranspiler {
         }
         if (name) {
             return new chunk_1.Chunk()
-                .append("let ", node, traversal)
-                .appendChunk(new field_symbol_1.FieldSymbolTranspiler().transpile(name, traversal))
-                .append(" = new abap.types.FieldSymbol(" + new transpile_types_1.TranspileTypes().toType(found.getType()) + ");", node.getLastToken(), traversal);
+                .appendString("let ")
+                .appendString(new field_symbol_1.FieldSymbolTranspiler().transpile(name, traversal).getCode())
+                .appendString(" = new abap.types.FieldSymbol(" + new transpile_types_1.TranspileTypes().toType(found.getType()) + ");");
         }
         throw new Error("FieldSymbolTranspiler, name not found");
     }
@@ -94670,6 +94705,88 @@ function onceStrict (fn) {
 }
 
 
+/***/ }),
+
+/***/ "./node_modules/p-limit/index.js":
+/*!***************************************!*\
+  !*** ./node_modules/p-limit/index.js ***!
+  \***************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+const Queue = __webpack_require__(/*! yocto-queue */ "./node_modules/yocto-queue/index.js");
+
+const pLimit = concurrency => {
+	if (!((Number.isInteger(concurrency) || concurrency === Infinity) && concurrency > 0)) {
+		throw new TypeError('Expected `concurrency` to be a number from 1 and up');
+	}
+
+	const queue = new Queue();
+	let activeCount = 0;
+
+	const next = () => {
+		activeCount--;
+
+		if (queue.size > 0) {
+			queue.dequeue()();
+		}
+	};
+
+	const run = async (fn, resolve, ...args) => {
+		activeCount++;
+
+		const result = (async () => fn(...args))();
+
+		resolve(result);
+
+		try {
+			await result;
+		} catch {}
+
+		next();
+	};
+
+	const enqueue = (fn, resolve, ...args) => {
+		queue.enqueue(run.bind(null, fn, resolve, ...args));
+
+		(async () => {
+			// This function needs to wait until the next microtask before comparing
+			// `activeCount` to `concurrency`, because `activeCount` is updated asynchronously
+			// when the run function is dequeued and called. The comparison in the if-statement
+			// needs to happen asynchronously as well to get an up-to-date value for `activeCount`.
+			await Promise.resolve();
+
+			if (activeCount < concurrency && queue.size > 0) {
+				queue.dequeue()();
+			}
+		})();
+	};
+
+	const generator = (fn, ...args) => new Promise(resolve => {
+		enqueue(fn, resolve, ...args);
+	});
+
+	Object.defineProperties(generator, {
+		activeCount: {
+			get: () => activeCount
+		},
+		pendingCount: {
+			get: () => queue.size
+		},
+		clearQueue: {
+			value: () => {
+				queue.clear();
+			}
+		}
+	});
+
+	return generator;
+};
+
+module.exports = pLimit;
+
+
 /***/ }),
 
 /***/ "./node_modules/path-is-absolute/index.js":
@@ -100604,6 +100721,84 @@ function wrappy (fn, cb) {
 }
 
 
+/***/ }),
+
+/***/ "./node_modules/yocto-queue/index.js":
+/*!*******************************************!*\
+  !*** ./node_modules/yocto-queue/index.js ***!
+  \*******************************************/
+/***/ ((module) => {
+
+class Node {
+	/// value;
+	/// next;
+
+	constructor(value) {
+		this.value = value;
+
+		// TODO: Remove this when targeting Node.js 12.
+		this.next = undefined;
+	}
+}
+
+class Queue {
+	// TODO: Use private class fields when targeting Node.js 12.
+	// #_head;
+	// #_tail;
+	// #_size;
+
+	constructor() {
+		this.clear();
+	}
+
+	enqueue(value) {
+		const node = new Node(value);
+
+		if (this._head) {
+			this._tail.next = node;
+			this._tail = node;
+		} else {
+			this._head = node;
+			this._tail = node;
+		}
+
+		this._size++;
+	}
+
+	dequeue() {
+		const current = this._head;
+		if (!current) {
+			return;
+		}
+
+		this._head = this._head.next;
+		this._size--;
+		return current.value;
+	}
+
+	clear() {
+		this._head = undefined;
+		this._tail = undefined;
+		this._size = 0;
+	}
+
+	get size() {
+		return this._size;
+	}
+
+	* [Symbol.iterator]() {
+		let current = this._head;
+
+		while (current) {
+			yield current.value;
+			current = current.next;
+		}
+	}
+}
+
+module.exports = Queue;
+
+
 /***/ }),
 
 /***/ "assert":
@@ -100661,6 +100856,28 @@ module.exports = require("fs");
 
 /***/ }),
 
+/***/ "node:fs/promises":
+/*!***********************************!*\
+  !*** external "node:fs/promises" ***!
+  \***********************************/
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("node:fs/promises");
+
+/***/ }),
+
+/***/ "node:os":
+/*!**************************!*\
+  !*** external "node:os" ***!
+  \**************************/
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("node:os");
+
+/***/ }),
+
 /***/ "os":
 /*!*********************!*\
   !*** external "os" ***!
@@ -100861,7 +101078,7 @@ async function run() {
     console.log("Transpiler CLI");
     const config = config_1.TranspilerConfig.find(process.argv[2]);
     const libFiles = loadLib(config);
-    const files = file_operations_1.FileOperations.loadFiles(config);
+    const files = await file_operations_1.FileOperations.loadFiles(config);
     console.log("\nBuilding");
     const t = new Transpiler.Transpiler(config.options);
     const reg = new abaplint.Registry();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abaplint/transpiler-cli",
-  "version": "2.10.58",
+  "version": "2.10.60",
   "description": "Transpiler - Command Line Interface",
   "funding": "https://github.com/sponsors/larshp",
   "bin": {
@@ -27,15 +27,16 @@
   "author": "abaplint",
   "license": "MIT",
   "devDependencies": {
-    "@abaplint/core": "^2.113.125",
-    "@abaplint/transpiler": "^2.10.58",
+    "@abaplint/core": "^2.113.126",
+    "@abaplint/transpiler": "^2.10.60",
     "@types/glob": "^8.1.0",
-    "@types/node": "^22.15.29",
+    "@types/node": "^22.15.30",
     "@types/progress": "^2.0.7",
     "glob": "=7.2.0",
     "progress": "^2.0.3",
     "ts-json-schema-generator": "^2.4.0",
     "typescript": "^5.8.3",
+    "p-limit": "^3.1.0",
     "webpack-cli": "^6.0.1",
     "webpack": "^5.99.9"
   }