fix #20339 Constant folding differs between Windows and linux builds

Author: WalterBright

compiler/src/dmd/constfold.d

@@ -29,6 +29,7 @@ import dmd.expressionsem;
 import dmd.globals;
 import dmd.location;
 import dmd.mtype;
+import dmd.printast;
 import dmd.root.complex;
 import dmd.root.ctfloat;
 import dmd.root.port;
@@ -223,6 +224,9 @@ UnionExp Min(Loc loc, Type type, Expression e1, Expression e2)
 
 UnionExp Mul(Loc loc, Type type, Expression e1, Expression e2)
 {
+    //printf("Mul() type: %s\n", type.toChars());
+    //printAST(e1);
+    //printAST(e2);
     UnionExp ue = void;
     if (type.isFloating())
     {

compiler/src/dmd/expressionsem.d

@@ -138,15 +138,44 @@ real_t toImaginary(Expression _this)
 {
     if (auto ie = _this.isIntegerExp())
         return CTFloat.zero;
-    else if (auto re = _this.isRealExp)
-        return re.type.isReal() ? CTFloat.zero : re.value;
+    else if (auto rexp = _this.isRealExp)
+    {
+        real_t result = rexp.value;
+
+        if (!rexp.type.isReal()) // the ! is the only difference from toReal()
+        {
+            const sz = size(rexp.type);
+            if (sz == 4)
+            {
+                float f = cast(float)result;    // force round to float with x87 instructions
+                result = f;
+            }
+            else if (sz == 8)
+            {
+                double d = cast(double)result;
+                result = d;
+            }
+            rexp.value = result;        // in case of further casting
+        }
+        else
+            result = CTFloat.zero;
+        return result;
+    }
     else if (auto ce = _this.isComplexExp())
         return cimagl(ce.value);
 
     error(_this.loc, "floating point constant expression expected instead of `%s`", _this.toChars());
     return CTFloat.zero;
 }
 
+/***********************************
+ * Interpret the value from IntegerExp, RealExp, or ComplexExp
+ * as a correctly typed floating point number.
+ * Params:
+ *      _this = Expression
+ * Returns:
+ *      floating point value, zero on error
+ */
 real_t toReal(Expression _this)
 {
     if (auto iexp = _this.isIntegerExp())
@@ -161,7 +190,29 @@ real_t toReal(Expression _this)
     }
     else if (auto rexp = _this.isRealExp())
     {
-        return rexp.type.isReal() ? rexp.value : CTFloat.zero;
+        /* Conversions are handled here instead of in RealExp's constructor
+         * because the type sent to the constructor is not semantically known yet
+         */
+        real_t result = rexp.value;
+
+        if (rexp.type.isReal())
+        {
+            const sz = size(rexp.type);
+            if (sz == 4)
+            {
+                float f = cast(float)result;    // force round to float with x87 instructions
+                result = f;
+            }
+            else if (sz == 8)
+            {
+                double d = cast(double)result;
+                result = d;
+            }
+            rexp.value = result;        // in case of further casting
+        }
+        else
+            result = CTFloat.zero;
+        return result;
     }
     else if (auto cexp = _this.isComplexExp())
     {

compiler/test/compilable/interpret3.d

@@ -4494,11 +4494,11 @@ auto classtest1(int n)
     d = new TheBase;
     SomeInterface fc = c;
     SomeOtherInterface ot = c;
-    assert(fc.bar('x') == 2.6);
+    assert(fc.bar('x') == 2.6f);
     assert(ot.xxx() == 762);
     fc = d;
     ot = d;
-    assert(fc.bar('x') == 3.6);
+    assert(fc.bar('x') == 3.6f);
     assert(ot.xxx() == 762);
 
     Unrelated u2 = new Unrelated(7);

compiler/test/runnable/ctorpowtests.d

@@ -159,7 +159,7 @@ enum B = StructWithCtor(7, 2.3);
 static assert(A.n == 1);
 static assert(A.x == 5.0);
 static assert(B.n == 7);
-static assert(B.x == 2.3);
+static assert(B.x == 2.3f);
 
 int bazra(int x)
 {

compiler/test/runnable/test34.d

@@ -576,7 +576,9 @@ ulong foo32()
 
 void test32()
 {
-        assert(foo32()==1176576510);
+        assert(/*foo32()==1176576510 ||*/  // previous version held floats internally at higher precision
+               foo32()==1176576512);  // newer version has float precision
+                                      // https://github.com/dlang/dmd/pull/22270
 }
 
 /************************************************/