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,38 @@ 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)
+                result = cast(float)result;
+            else if (sz == 8)
+                result = cast(double)result;
+            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 +184,23 @@ 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)
+                result = cast(float)result;
+            else if (sz == 8)
+                result = cast(double)result;
+            rexp.value = result;        // in case of further casting
+        }
+        else
+            result = CTFloat.zero;
+        return result;
     }
     else if (auto cexp = _this.isComplexExp())
     {