@abaplint/transpiler 2.13.92 → 2.13.94

package/build/src/index.js

@@ -37,6 +37,7 @@ exports.Transpiler = exports.Chunk = exports.UnknownTypesEnum = exports.config =
 const abaplint = __importStar(require("@abaplint/core"));
 const validation_1 = require("./validation");
 Object.defineProperty(exports, "config", { enumerable: true, get: function () { return validation_1.config; } });
+const unique_identifier_1 = require("./unique_identifier");
 const unit_test_1 = require("./unit_test");
 const types_1 = require("./types");
 Object.defineProperty(exports, "UnknownTypesEnum", { enumerable: true, get: function () { return types_1.UnknownTypesEnum; } });
@@ -95,6 +96,12 @@ class Transpiler {
         progress?.set(reg.getObjectCount().total, "Building");
         for (const obj of reg.getObjects()) {
             await progress?.tick("Building, " + obj.getName());
+            // the temporary names ("unique1", ..., and the DO/WHILE sy-index backups
+            // "indexBackup1", ...) are local to the module an object becomes, so each
+            // object numbers its own: its output then depends on the registry alone,
+            // not on the objects built before it or on an earlier run in the same process
+            unique_identifier_1.UniqueIdentifier.reset();
+            unique_identifier_1.UniqueIdentifier.resetIndexBackup();
             if (obj instanceof abaplint.Objects.TypePool) {
                 output.objects.push(...new handle_type_pool_1.HandleTypePool().runObject(obj, reg));
             }

package/build/src/statements/delete_internal.js

@@ -51,10 +51,12 @@ class DeleteInternalTranspiler {
             extra.push("where: async " + traversal.traverse(componentCompare).getCode());
         }
         // todo, this is not completely correct, fields might have the name ADJACENT
-        // comparisons should be on table key unless other is specified, but we're unaware
         if (node.findDirectTokenByText("ADJACENT")) {
             extra.push("adjacent: true");
-            if (node.findDirectTokenByText("COMPARING") && !concat.includes("COMPARING ALL FIELDS")) {
+            if (concat.includes("COMPARING ALL FIELDS")) {
+                extra.push("allFields: true");
+            }
+            else if (node.findDirectTokenByText("COMPARING")) {
                 const comparing = node.findAllExpressions(abaplint.Expressions.SimpleFieldChain2);
                 if (comparing) {
                     const compareFields = comparing.map(i => "'" + i.getFirstToken().getStr() + "'").join(",");

package/build/src/statements/do.js

@@ -46,11 +46,14 @@ class DoTranspiler {
     transpile(node, traversal) {
         const found = node.findFirstExpression(abaplint.Expressions.Source);
         if (found) {
-            const source = new expressions_1.SourceTranspiler(true).transpile(found, traversal).getCode();
+            // the count is converted to i, like any numeric expression position: an
+            // f count read with get( ) gives its text 3,0000000000000000E+00, which
+            // no loop counter compares with, and a p count of 2.4 means 2 passes
+            const source = new expressions_1.SourceTranspiler(false).transpile(found, traversal).getCode();
             const idSource = unique_identifier_1.UniqueIdentifier.get();
             const id = unique_identifier_1.UniqueIdentifier.get();
             return new chunk_1.Chunk(`const ${this.syIndexBackup} = abap.builtin.sy.get().index.get();
-const ${idSource} = ${source};
+const ${idSource} = new abap.types.Integer().set(${source}).get();
 for (let ${id} = 0; ${id} < ${idSource}; ${id}++) {
 abap.builtin.sy.get().index.set(${id} + 1);`);
         }

package/build/src/statements/insert_database.js

@@ -61,6 +61,9 @@ class InsertDatabaseTranspiler {
             const tvalues = traversal.traverse(fromTable);
             options.push(`"table": ` + tvalues.getCode());
         }
+        if (node.findDirectTokenByText("ACCEPTING") !== undefined) {
+            options.push(`"acceptingDuplicateKeys": true`);
+        }
         const connection = node.findDirectExpression(abaplint.Expressions.DatabaseConnection);
         if (connection) {
             const con = findConnection(connection, traversal);

package/build/src/statements/select.js

@@ -185,7 +185,7 @@ class SelectTranspiler {
   }
   if (!(${target} instanceof abap.types.HashedTable) && ${target}.getOptions()?.primaryKey?.type !== "SORTED") {
     abap.statements.sort(${target}, {by: ${by}.map(k => { return {component: k}; })});
-    await abap.statements.deleteInternal(${target}, {adjacent: true, by: ${by}});
+    await abap.statements.deleteInternal(${target}, {adjacent: true, allFields: true});
   }
   abap.builtin.sy.get().dbcnt.set(${target}.getArrayLength());
 }`;

package/build/src/traversal.d.ts

@@ -1,6 +1,12 @@
 import * as abaplint from "@abaplint/core";
 import { Chunk } from "./chunk";
 import { ITranspilerOptions } from "./types";
+type IReference = ReturnType<abaplint.ISpaghettiScopeNode["getData"]>["references"][number];
+/** the references of a scope whose start equals the token's start, in the
+ *  scope's own order -- the same set and order the linear scan found:
+ *  Position.equals compares row and column, a VirtualPosition compares its
+ *  virtual row and column and only with another VirtualPosition */
+export declare function referencesAt(scope: abaplint.ISpaghettiScopeNode, token: abaplint.Token): IReference[];
 export declare class Traversal {
     private readonly spaghetti;
     private readonly file;
@@ -104,3 +110,4 @@ export declare class Traversal {
     protected traverseStatement(node: abaplint.Nodes.StatementNode): Chunk;
     protected traverseExpression(node: abaplint.Nodes.ExpressionNode): Chunk;
 }
+export {};

package/build/src/traversal.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Traversal = void 0;
+exports.referencesAt = referencesAt;
 const abaplint = __importStar(require("@abaplint/core"));
 const StatementTranspilers = __importStar(require("./statements"));
 const ExpressionTranspilers = __importStar(require("./expressions"));
@@ -42,6 +43,43 @@ const transpile_types_1 = require("./transpile_types");
 const chunk_1 = require("./chunk");
 const expressions_1 = require("./expressions");
 const keywords_1 = require("./keywords");
+/** the references of one scope, by where they start: built once per scope,
+ *  so finding the reference at a token no longer walks every reference of
+ *  the scope for every token, which made a long method quadratic */
+const REFERENCE_INDEX = new WeakMap();
+/** the references of a scope whose start equals the token's start, in the
+ *  scope's own order -- the same set and order the linear scan found:
+ *  Position.equals compares row and column, a VirtualPosition compares its
+ *  virtual row and column and only with another VirtualPosition */
+function referencesAt(scope, token) {
+    const references = scope.getData().references;
+    let index = REFERENCE_INDEX.get(references);
+    if (index === undefined) {
+        index = { plain: new Map(), virtual: new Map() };
+        references.forEach((r, n) => {
+            const start = r.position.getStart();
+            const key = start instanceof abaplint.VirtualPosition
+                ? start.vrow + ":" + start.vcol
+                : start.getRow() + ":" + start.getCol();
+            const map = start instanceof abaplint.VirtualPosition ? index.virtual : index.plain;
+            const list = map.get(key);
+            if (list === undefined) {
+                map.set(key, [n]);
+            }
+            else {
+                list.push(n);
+            }
+        });
+        REFERENCE_INDEX.set(references, index);
+    }
+    const start = token.getStart();
+    const found = [...(index.plain.get(start.getRow() + ":" + start.getCol()) ?? [])];
+    if (start instanceof abaplint.VirtualPosition) {
+        found.push(...(index.virtual.get(start.vrow + ":" + start.vcol) ?? []));
+        found.sort((a, b) => a - b);
+    }
+    return found.map(n => references[n]);
+}
 class Traversal {
     spaghetti;
     file;
@@ -395,9 +433,8 @@ class Traversal {
         if (scope === undefined) {
             return false;
         }
-        for (const r of scope.getData().references) {
-            if (r.referenceType === abaplint.ReferenceType.BuiltinMethodReference
-                && r.position.getStart().equals(token.getStart())) {
+        for (const r of referencesAt(scope, token)) {
+            if (r.referenceType === abaplint.ReferenceType.BuiltinMethodReference) {
                 return true;
             }
         }
@@ -417,9 +454,8 @@ class Traversal {
         if (scope === undefined) {
             return undefined;
         }
-        for (const r of scope.getData().references) {
+        for (const r of referencesAt(scope, token)) {
             if (r.referenceType === abaplint.ReferenceType.MethodReference
-                && r.position.getStart().equals(token.getStart())
                 && r.resolved instanceof abaplint.Types.MethodDefinition) {
                 let name = r.resolved.getName();
                 if (r.extra?.ooName && r.extra?.ooType === "INTF") {
@@ -433,8 +469,7 @@ class Traversal {
                 }
                 return candidate;
             }
-            else if (r.referenceType === abaplint.ReferenceType.BuiltinMethodReference
-                && r.position.getStart().equals(token.getStart())) {
+            else if (r.referenceType === abaplint.ReferenceType.BuiltinMethodReference) {
                 const def = r.resolved;
                 const name = def.getName();
                 return { def, name };
@@ -582,10 +617,9 @@ class Traversal {
         if (scope === undefined) {
             return undefined;
         }
-        for (const r of scope.getData().references) {
-            if ((r.referenceType === abaplint.ReferenceType.DataReadReference
-                || r.referenceType === abaplint.ReferenceType.DataWriteReference)
-                && r.position.getStart().equals(token.getStart())) {
+        for (const r of referencesAt(scope, token)) {
+            if (r.referenceType === abaplint.ReferenceType.DataReadReference
+                || r.referenceType === abaplint.ReferenceType.DataWriteReference) {
                 return r.resolved;
             }
         }
@@ -596,9 +630,8 @@ class Traversal {
         if (scope === undefined) {
             return undefined;
         }
-        for (const r of scope.getData().references) {
-            if (r.referenceType === abaplint.ReferenceType.InferredType
-                && r.position.getStart().equals(token.getStart())) {
+        for (const r of referencesAt(scope, token)) {
+            if (r.referenceType === abaplint.ReferenceType.InferredType) {
                 if (r.resolved instanceof abaplint.TypedIdentifier) {
                     return r.resolved.getType();
                 }
@@ -611,9 +644,8 @@ class Traversal {
         if (scope === undefined) {
             return undefined;
         }
-        for (const r of scope.getData().references) {
-            if (r.referenceType === abaplint.ReferenceType.TypeReference
-                && r.position.getStart().equals(token.getStart())) {
+        for (const r of referencesAt(scope, token)) {
+            if (r.referenceType === abaplint.ReferenceType.TypeReference) {
                 if (r.resolved instanceof abaplint.TypedIdentifier) {
                     return r.resolved.getType();
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abaplint/transpiler",
-  "version": "2.13.92",
+  "version": "2.13.94",
   "description": "Transpiler",
   "main": "build/src/index.js",
   "typings": "build/src/index.d.ts",
@@ -29,7 +29,7 @@
   "author": "abaplint",
   "license": "MIT",
   "dependencies": {
-    "@abaplint/core": "^2.120.59",
+    "@abaplint/core": "^2.120.61",
     "source-map": "^0.8.0"
   },
   "devDependencies": {