2.13.47: bugfix, whitespace

package.json

@@ -42,7 +42,7 @@
     },
     "homepage": "https://github.com/abaplint/transpiler_poc#readme",
     "devDependencies": {
-        "@abaplint/core": "^2.120.5",
+        "@abaplint/core": "^2.120.6",
         "@eslint/compat": "^2.1.0",
         "@eslint/eslintrc": "^3.3.5",
         "@eslint/js": "^9.39.4",

packages/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abaplint/transpiler-cli",
-  "version": "2.13.46",
+  "version": "2.13.47",
   "description": "Transpiler - Command Line Interface",
   "funding": "https://github.com/sponsors/larshp",
   "bin": {
@@ -27,8 +27,8 @@
   "author": "abaplint",
   "license": "MIT",
   "devDependencies": {
-    "@abaplint/core": "^2.120.5",
-    "@abaplint/transpiler": "^2.13.46",
+    "@abaplint/core": "^2.120.6",
+    "@abaplint/transpiler": "^2.13.47",
     "@types/glob": "^8.1.0",
     "@types/node": "^24.12.2",
     "@types/progress": "^2.0.7",

packages/extras/package.json

@@ -28,12 +28,12 @@
   "author": "Heliconia Labs ApS",
   "license": "PolyForm-Noncommercial-1.0.0",
   "peerDependencies": {
-    "@abaplint/core": "^2.120.5",
-    "@abaplint/transpiler": "^2.13.46"
+    "@abaplint/core": "^2.120.6",
+    "@abaplint/transpiler": "^2.13.47"
   },
   "devDependencies": {
-    "@abaplint/core": "^2.120.5",
-    "@abaplint/transpiler": "^2.13.46",
+    "@abaplint/core": "^2.120.6",
+    "@abaplint/transpiler": "^2.13.47",
     "@types/chai": "^4.3.20",
     "@types/mocha": "^10.0.10",
     "@types/node": "^24.13.2",

packages/runtime/package.json

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

packages/runtime/src/builtin/abs.ts

@@ -10,7 +10,7 @@ export function abs(input: {val: number | string | ICharacter | INumeric}) {
   } else if (typeof input.val === "string") {
     num_in = parseFloat(input.val);
   } else if (input.val instanceof Float) {
-    num_in = input.val.getRaw();
+    num_in = input.val.getCalculationValue();
   } else {
     num_in = parseFloat(input.val.get().toString());
   }

packages/runtime/src/builtin/ceil.ts

@@ -10,7 +10,7 @@ export function ceil(input: {val: number | string | ICharacter | INumeric}) {
   } else if ( typeof input.val === "string") {
     num_in = parseFloat(input.val);
   } else if (input.val instanceof Float) {
-    num_in = input.val.getRaw();
+    num_in = input.val.getCalculationValue();
   } else {
     num_in = parseFloat(input.val.get().toString());
   }

packages/runtime/src/builtin/floor.ts

@@ -10,7 +10,7 @@ export function floor(input: {val: number | string | ICharacter | INumeric}) {
   } else if (typeof input.val === "string") {
     num_in = parseFloat(input.val);
   } else if (input.val instanceof Float) {
-    num_in = input.val.getRaw();
+    num_in = input.val.getCalculationValue();
   } else {
     num_in = parseFloat(input.val.get().toString());
   }

packages/runtime/src/builtin/frac.ts

@@ -11,8 +11,9 @@ export function frac(input: {val: number | string | ICharacter | INumeric}) {
     num_in = input.val;
   } else if (typeof input.val === "string") {
     num_in = parseFloat(input.val);
-  } else if (input.val instanceof DecFloat34
-      || input.val instanceof Float) {
+  } else if (input.val instanceof Float) {
+    num_in = input.val.getCalculationValue();
+  } else if (input.val instanceof DecFloat34) {
     num_in = input.val.getRaw();
   } else {
     num_in = parseFloat(input.val.get().toString());

packages/runtime/src/builtin/trunc.ts

@@ -9,7 +9,7 @@ export function trunc(input: {val: number | string | ICharacter | INumeric}) {
   } else if (typeof input.val === "string") {
     num_in = parseFloat(input.val);
   } else if (input.val instanceof Float) {
-    num_in = input.val.getRaw();
+    num_in = input.val.getCalculationValue();
   } else {
     num_in = parseFloat(input.val.get().toString());
   }

packages/runtime/src/operators/add.ts

@@ -23,14 +23,14 @@ export function add(left: INumeric | ICharacter | string | number | Float | Inte
     return new Integer().set(left.get() + right);
 
   } else if ((left instanceof String || left instanceof Character) && isIntegerCharacter(left) && right instanceof Integer) {
-    return new Integer().set(Number.parseInt(left.get(), 10) + right.get());
+    return new Integer().set(Number.parseInt(left.get(), 10) + right.get()).clearIntegerCalculationType();
   } else if ((right instanceof String || right instanceof Character) && isIntegerCharacter(right) && left instanceof Integer) {
-    return new Integer().set(left.get() + Number.parseInt(right.get(), 10));
+    return new Integer().set(left.get() + Number.parseInt(right.get(), 10)).clearIntegerCalculationType();
   } else if ((left instanceof String || left instanceof Character)
       && (right instanceof String || right instanceof Character)
       && isIntegerCharacter(left)
       && isIntegerCharacter(right)) {
-    return new Integer().set(Number.parseInt(left.get(), 10) + Number.parseInt(right.get(), 10));
+    return new Integer().set(Number.parseInt(left.get(), 10) + Number.parseInt(right.get(), 10)).clearIntegerCalculationType();
   } else if (left instanceof Integer8) {
     if (right instanceof Integer8) {
       return new Integer8().set(left.get() + right.get());

packages/runtime/src/operators/divide.ts

@@ -32,5 +32,16 @@ export function divide(left: INumeric | ICharacter | Integer8 | string | number,
   }
   const val = l / r;
 
-  return new Float().set(val);
-}
+  const ret = new Float().set(val);
+  if (isIntegerOperand(left) && isIntegerOperand(right)) {
+    ret.setIntegerCalculationType();
+  }
+  return ret;
+}
+
+function isIntegerOperand(val: INumeric | ICharacter | Integer8 | string | number): boolean {
+  if (val instanceof Integer) {
+    return val.isIntegerCalculationType();
+  }
+  return val instanceof Integer8;
+}

packages/runtime/src/operators/minus.ts

@@ -38,9 +38,9 @@ export function minus(left: INumeric | ICharacter | string | Integer8 | number |
     return new Integer().set(left.get() - right);
 
   } else if ((left instanceof String || left instanceof Character) && Number.isInteger(Number(left.get())) && right instanceof Integer) {
-    return new Integer().set(Number.parseInt(left.get(), 10) - right.get());
+    return new Integer().set(Number.parseInt(left.get(), 10) - right.get()).clearIntegerCalculationType();
   } else if ((right instanceof String || right instanceof Character) && Number.isInteger(Number(right)) && left instanceof Integer) {
-    return new Integer().set(left.get() - Number.parseInt(right.get(), 10));
+    return new Integer().set(left.get() - Number.parseInt(right.get(), 10)).clearIntegerCalculationType();
   }
 
   return new Float().set(parse(left) - parse(right));

packages/runtime/src/operators/multiply.ts

@@ -25,10 +25,10 @@ export function multiply(left: INumeric | ICharacter | string | Integer8 | numbe
     return new Integer().set(val);
   } else if ((left instanceof String || left instanceof Character) && Number.isInteger(Number(left.get())) && right instanceof Integer) {
     const val = Number.parseInt(left.get(), 10) * right.get();
-    return new Integer().set(val);
+    return new Integer().set(val).clearIntegerCalculationType();
   } else if ((right instanceof String || right instanceof Character) && Number.isInteger(Number(right)) && left instanceof Integer) {
     const val = left.get() * Number.parseInt(right.get(), 10);
-    return new Integer().set(val);
+    return new Integer().set(val).clearIntegerCalculationType();
   }
 
   return new Float().set(parse(left) * parse(right));

packages/runtime/src/types/float.ts

@@ -22,6 +22,7 @@ function getNumberParts(x: number) {
 
 export class Float {
   private value: number;
+  private integerCalculationType = false;
   private readonly qualifiedName: string | undefined;
 
   public constructor(input?: {qualifiedName?: string}) {
@@ -35,6 +36,23 @@ export class Float {
     return n;
   }
 
+  /** ABAP calculates in type i if all operands are integers, ie. "3 / 2" is 2. The exact value is
+   * kept here, so assigning to a float or packed target, which raises the calculation type, still
+   * gives the exact result. Consumers without a target type must use getCalculationValue() */
+  public setIntegerCalculationType(): Float {
+    this.integerCalculationType = true;
+    return this;
+  }
+
+  /** value as seen by the calculation type, ie. rounded if the calculation type is integer */
+  public getCalculationValue(): number {
+    if (this.integerCalculationType === true) {
+      // ABAP rounds half away from zero
+      return this.value < 0 ? -Math.round(-this.value) : Math.round(this.value);
+    }
+    return this.value;
+  }
+
   public getQualifiedName() {
     return this.qualifiedName;
   }

packages/runtime/src/types/integer.ts

@@ -34,13 +34,25 @@ export function toInteger(value: string, exception = true): number {
 export class Integer implements INumeric {
   private value: number;
   private constant: boolean = false;
+  private integerCalculationType = true;
   private readonly qualifiedName: string | undefined;
 
   public constructor(input?: {qualifiedName?: string}) {
     this.value = 0;
     this.qualifiedName = input?.qualifiedName;
   }
 
+  /** ABAP determines the calculation type from the operand types, character-like operands raise it
+   * above type i even if the intermediate result is integer, ie. "'1.0' * 18 / 16" is not rounded */
+  public clearIntegerCalculationType(): Integer {
+    this.integerCalculationType = false;
+    return this;
+  }
+
+  public isIntegerCalculationType(): boolean {
+    return this.integerCalculationType;
+  }
+
   public getQualifiedName() {
     return this.qualifiedName;
   }