@abaplint/runtime 2.13.40 → 2.13.42

package/build/src/compare/eq.js

@@ -19,11 +19,104 @@ function compareTables(left, right) {
     }
     return true;
 }
+function compareStructures(left, right) {
+    const l = left.get();
+    const r = right.get();
+    const leftKeys = Object.keys(l);
+    const rightKeys = Object.keys(r);
+    if (leftKeys.length !== rightKeys.length) {
+        return false;
+    }
+    for (const k of leftKeys) {
+        const e = eq(l[k], r[k]);
+        if (e === false) {
+            return false;
+        }
+    }
+    return true;
+}
+// module locals instead of the imported bindings, as the CommonJS re-export
+// getters add overhead on every access in the hot path below
+const IntegerC = types_1.Integer;
+const StringC = types_1.String;
+const CharacterC = types_1.Character;
+const NumcC = types_1.Numc;
+const DateC = types_1.Date;
+const TimeC = types_1.Time;
+const PackedC = types_1.Packed;
+const FloatC = types_1.Float;
+const TableC = types_1.Table;
+const HashedTableC = types_1.HashedTable;
+const StructureC = types_1.Structure;
+const XStringC = types_1.XString;
+const HexC = types_1.Hex;
+const HexUInt8C = types_1.HexUInt8;
+const Integer8C = types_1.Integer8;
+const ABAPObjectC = types_1.ABAPObject;
+const DataReferenceC = types_1.DataReference;
 function eq(left, right) {
     /*
       console.dir(left);
       console.dir(right);
     */
+    // fast path: same concrete type covers the vast majority of comparisons,
+    // exact constructor identity, so subclasses and other types fall through
+    const leftConstructor = left?.constructor;
+    if (leftConstructor === right?.constructor) {
+        if (leftConstructor === IntegerC) {
+            return left.get() === right.get();
+        }
+        else if (leftConstructor === StringC) {
+            return left.get() === right.get();
+        }
+        else if (leftConstructor === CharacterC) {
+            if (left.getLength() === right.getLength()) {
+                return left.get() === right.get();
+            }
+            else {
+                return left.getTrimEnd() === right.getTrimEnd();
+            }
+        }
+        else if (leftConstructor === NumcC) {
+            return left.get() === right.get();
+        }
+        else if (leftConstructor === DateC) {
+            return left.get() === right.get();
+        }
+        else if (leftConstructor === TimeC) {
+            return left.get() === right.get();
+        }
+        else if (leftConstructor === PackedC) {
+            return left.get() === right.get();
+        }
+        else if (leftConstructor === FloatC) {
+            return left.getRaw() === right.getRaw();
+        }
+        else if (leftConstructor === TableC || leftConstructor === HashedTableC) {
+            return compareTables(left, right);
+        }
+        else if (leftConstructor === StructureC) {
+            return compareStructures(left, right);
+        }
+        else if (leftConstructor === XStringC) {
+            return left.get() === right.get();
+        }
+        else if (leftConstructor === HexC || leftConstructor === HexUInt8C) {
+            if (left.getLength() !== right.getLength()) {
+                return (0, initial_1.initial)(left) && (0, initial_1.initial)(right);
+            }
+            return left.get() === right.get();
+        }
+        else if (leftConstructor === Integer8C) {
+            return left.get() === right.get();
+        }
+        else if (leftConstructor === ABAPObjectC) {
+            return left.get() === right.get();
+        }
+        else if (leftConstructor === DataReferenceC) {
+            return left.getPointer() === right.getPointer();
+        }
+    }
     if (right instanceof types_1.FieldSymbol) {
         return eq(left, right.getPointer());
     }
@@ -186,20 +279,7 @@ function eq(left, right) {
         else if (!(left instanceof types_1.Structure)) {
             return eq(left, right.getCharacter());
         }
-        const l = left.get();
-        const r = right.get();
-        const leftKeys = Object.keys(l);
-        const rightKeys = Object.keys(r);
-        if (leftKeys.length !== rightKeys.length) {
-            return false;
-        }
-        for (const k of leftKeys) {
-            const e = eq(l[k], r[k]);
-            if (e === false) {
-                return false;
-            }
-        }
-        return true;
+        return compareStructures(left, right);
     }
     let l = undefined;
     if (left instanceof types_1.Character) {

package/build/src/types/structure.d.ts

@@ -12,7 +12,7 @@ export declare class Structure {
     private readonly asInclude;
     constructor(fields: {
         [key: string]: any;
-    }, qualifiedName?: string, ddicName?: string, suffix?: any, asInclude?: any);
+    }, qualifiedName?: string, ddicName?: string, suffix?: any, asInclude?: any, cloning?: boolean);
     private linkGroupFields;
     clone(): Structure;
     clear(): this;

package/build/src/types/structure.js

@@ -7,19 +7,39 @@ const _parse_1 = require("../operators/_parse");
 const character_1 = require("./character");
 const throw_error_1 = require("../throw_error");
 const abap_object_1 = require("./abap_object");
+// structures are typically instantiated repeatedly with the same literal names,
+// cache the uppercasing
+const upperCaseCache = new Map();
+function cachedUpperCase(name) {
+    let upper = upperCaseCache.get(name);
+    if (upper === undefined) {
+        upper = name.toUpperCase();
+        upperCaseCache.set(name, upper);
+    }
+    return upper;
+}
 class Structure {
     value;
     qualifiedName;
     ddicName;
     suffix;
     asInclude;
-    constructor(fields, qualifiedName, ddicName, suffix, asInclude) {
+    // "cloning = true" is only used from clone(), the names are then already uppercased
+    constructor(fields, qualifiedName, ddicName, suffix, asInclude, cloning = false) {
         this.value = fields;
-        this.qualifiedName = qualifiedName?.toUpperCase();
-        this.ddicName = ddicName?.toUpperCase();
+        if (cloning === true) {
+            this.qualifiedName = qualifiedName;
+            this.ddicName = ddicName;
+        }
+        else {
+            this.qualifiedName = qualifiedName === undefined ? undefined : cachedUpperCase(qualifiedName);
+            this.ddicName = ddicName === undefined ? undefined : cachedUpperCase(ddicName);
+        }
         this.suffix = suffix;
         this.asInclude = asInclude;
-        this.linkGroupFields();
+        if (asInclude !== undefined) {
+            this.linkGroupFields();
+        }
     }
     linkGroupFields() {
         for (const as of Object.keys(this.asInclude || {})) {
@@ -34,7 +54,9 @@ class Structure {
         for (const key in this.value) {
             newValues[key] = this.value[key].clone();
         }
-        const n = new Structure(newValues, this.qualifiedName, this.ddicName, this.suffix, this.asInclude);
+        // note: when includes are present, the constructor re-links the group
+        // fields so they alias the cloned include's fields
+        const n = new Structure(newValues, this.qualifiedName, this.ddicName, this.suffix, this.asInclude, true);
         return n;
     }
     clear() {
@@ -98,8 +120,15 @@ class Structure {
                 if (this.value[key2] === undefined) {
                     break;
                 }
-                // todo: can clone() be removed? might be needed for like Structure and Tables?
-                this.value[key2].set(obj[key1].clone());
+                const val = obj[key1];
+                if (val instanceof Structure || val instanceof table_1.Table || val instanceof table_1.HashedTable) {
+                    // deep types are cloned so the target never shares references with the source
+                    this.value[key2].set(val.clone());
+                }
+                else {
+                    // elementary types copy by value in set(), no clone needed
+                    this.value[key2].set(val);
+                }
             }
         }
         else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abaplint/runtime",
-  "version": "2.13.40",
+  "version": "2.13.42",
   "description": "Transpiler - Runtime",
   "main": "build/src/index.js",
   "typings": "build/src/index.d.ts",