rt.util.typeinfo: Use complex aliases instead of built-in complex types

Author: ibuclaw

src/core/stdc/config.d

@@ -31,7 +31,7 @@ version (StdDdoc)
             alias ddoc_long = int;
             alias ddoc_ulong = uint;
         }
-        struct ddoc_complex(T) {};
+        struct ddoc_complex(T) { T re; T im; };
     }
 
     /***

src/rt/util/typeinfo.d

@@ -7,6 +7,7 @@
  * Source: $(DRUNTIMESRC rt/util/_typeinfo.d)
  */
 module rt.util.typeinfo;
+import core.stdc.config;
 static import core.internal.hash;
 
 template Floating(T)
@@ -36,14 +37,15 @@ if (is(T == float) || is(T == double) || is(T == real))
 
     public alias hashOf = core.internal.hash.hashOf;
 }
+
 template Floating(T)
-if (is(T == cfloat) || is(T == cdouble) || is(T == creal))
+if (is(T == c_complex_float) || is(T == c_complex_double) || is(T == c_complex_real))
 {
   pure nothrow @safe:
 
     bool equals(T f1, T f2)
     {
-        return f1 == f2;
+        return f1.re == f2.re && f1.im == f2.im;
     }
 
     int compare(T f1, T f2)
@@ -63,12 +65,14 @@ if (is(T == cfloat) || is(T == cdouble) || is(T == creal))
         return result;
     }
 
-    public alias hashOf = core.internal.hash.hashOf;
+    size_t hashOf(scope const T val)
+    {
+        return core.internal.hash.hashOf(val.re, core.internal.hash.hashOf(val.im));
+    }
 }
 
 template Array(T)
-if (is(T ==  float) || is(T ==  double) || is(T ==  real) ||
-    is(T == cfloat) || is(T == cdouble) || is(T == creal))
+if (is(T ==  float) || is(T ==  double) || is(T ==  real))
 {
   pure nothrow @safe:
 
@@ -105,6 +109,52 @@ if (is(T ==  float) || is(T ==  double) || is(T ==  real) ||
     public alias hashOf = core.internal.hash.hashOf;
 }
 
+template Array(T)
+if (is(T == c_complex_float) || is(T == c_complex_double) || is(T == c_complex_real))
+{
+  pure nothrow @safe:
+
+    bool equals(T[] s1, T[] s2)
+    {
+        size_t len = s1.length;
+        if (len != s2.length)
+            return false;
+        for (size_t u = 0; u < len; u++)
+        {
+            if (!Floating!T.equals(s1[u], s2[u]))
+                return false;
+        }
+        return true;
+    }
+
+    int compare(T[] s1, T[] s2)
+    {
+        size_t len = s1.length;
+        if (s2.length < len)
+            len = s2.length;
+        for (size_t u = 0; u < len; u++)
+        {
+            if (int c = Floating!T.compare(s1[u], s2[u]))
+                return c;
+        }
+        if (s1.length < s2.length)
+            return -1;
+        else if (s1.length > s2.length)
+            return 1;
+        return 0;
+    }
+
+    size_t hashOf(scope const T[] val)
+    {
+        size_t hash = 0;
+        foreach (ref o; val)
+        {
+            hash = core.internal.hash.hashOf(Floating!T.hashOf(o), hash);
+        }
+        return hash;
+    }
+}
+
 version (CoreUnittest)
 {
     alias TypeTuple(T...) = T;
@@ -177,7 +227,7 @@ TypeInfo information for built-in types.
 
 A `Base` type may be specified, which must be a type with the same layout, alignment, hashing, and
 equality comparison as type `T`. This saves on code size because parts of `Base` will be reused. Example:
-`float` and `ifloat` or `char` and `ubyte`. The implementation assumes `Base` and `T` hash the same, swap
+`char` and `ubyte`. The implementation assumes `Base` and `T` hash the same, swap
 the same, have the same ABI flags, and compare the same for equality. For ordering comparisons, we detect
 during compilation whether they have different signedness and override appropriately. For initializer, we
 detect if we need to override. The overriding initializer should be nonzero.
@@ -194,7 +244,10 @@ if (T.sizeof == Base.sizeof && T.alignof == Base.alignof)
     static if (is(T == Base))
         override size_t getHash(scope const void* p)
         {
-            static if (__traits(isFloating, T))
+            static if (__traits(isFloating, T) ||
+                       is(T == c_complex_float) ||
+                       is(T == c_complex_double) ||
+                       is(T == c_complex_real))
                 return Floating!T.hashOf(*cast(T*)p);
             else
                 return hashOf(*cast(const T *)p);
@@ -204,7 +257,10 @@ if (T.sizeof == Base.sizeof && T.alignof == Base.alignof)
     static if (is(T == Base))
         override bool equals(in void* p1, in void* p2)
         {
-            static if (__traits(isFloating, T))
+            static if (__traits(isFloating, T) ||
+                       is(T == c_complex_float) ||
+                       is(T == c_complex_double) ||
+                       is(T == c_complex_real))
                 return Floating!T.equals(*cast(T*)p1, *cast(T*)p2);
             else
                 return *cast(T *)p1 == *cast(T *)p2;
@@ -214,7 +270,10 @@ if (T.sizeof == Base.sizeof && T.alignof == Base.alignof)
     static if (is(T == Base) || (__traits(isIntegral, T) && T.max != Base.max))
         override int compare(in void* p1, in void* p2)
         {
-            static if (__traits(isFloating, T))
+            static if (__traits(isFloating, T) ||
+                       is(T == c_complex_float) ||
+                       is(T == c_complex_double) ||
+                       is(T == c_complex_real))
             {
                 return Floating!T.compare(*cast(T*)p1, *cast(T*)p2);
             }
@@ -273,9 +332,12 @@ if (T.sizeof == Base.sizeof && T.alignof == Base.alignof)
         }
 
     static if (is(T == Base))
-        static if (__traits(isFloating, T) && T.mant_dig != 64)
+    {
+        static if ((__traits(isFloating, T) && T.mant_dig != 64) ||
+                   is(T == c_complex_float) || is(T == c_complex_double))
             // FP types except 80-bit X87 are passed in SIMD register.
             override @property uint flags() const { return 2; }
+    }
 }
 
 unittest
@@ -312,7 +374,7 @@ TypeInfo information for arrays of built-in types.
 
 A `Base` type may be specified, which must be a type with the same layout, alignment, hashing, and
 equality comparison as type `T`. This saves on code size because parts of `Base` will be reused. Example:
-`float` and `ifloat` or `char` and `ubyte`. The implementation assumes `Base` and `T` hash the same, swap
+`char` and `ubyte`. The implementation assumes `Base` and `T` hash the same, swap
 the same, have the same ABI flags, and compare the same for equality. For ordering comparisons, we detect
 during compilation whether they have different signedness and override appropriately. For initializer, we
 detect if we need to override. The overriding initializer should be nonzero.
@@ -327,7 +389,10 @@ private class TypeInfoArrayGeneric(T, Base = T) : Select!(is(T == Base), TypeInf
     static if (is(T == Base))
         override size_t getHash(scope const void* p) @trusted const
         {
-            static if (__traits(isFloating, T))
+            static if (__traits(isFloating, T) ||
+                       is(T == c_complex_float) ||
+                       is(T == c_complex_double) ||
+                       is(T == c_complex_real))
                 return Array!T.hashOf(*cast(T[]*)p);
             else
                 return hashOf(*cast(const T[]*) p);
@@ -336,7 +401,10 @@ private class TypeInfoArrayGeneric(T, Base = T) : Select!(is(T == Base), TypeInf
     static if (is(T == Base))
         override bool equals(in void* p1, in void* p2) const
         {
-            static if (__traits(isFloating, T))
+            static if (__traits(isFloating, T) ||
+                       is(T == c_complex_float) ||
+                       is(T == c_complex_double) ||
+                       is(T == c_complex_real))
             {
                 return Array!T.equals(*cast(T[]*)p1, *cast(T[]*)p2);
             }
@@ -353,7 +421,10 @@ private class TypeInfoArrayGeneric(T, Base = T) : Select!(is(T == Base), TypeInf
     static if (is(T == Base) || (__traits(isIntegral, T) && T.max != Base.max))
         override int compare(in void* p1, in void* p2) const
         {
-            static if (__traits(isFloating, T))
+            static if (__traits(isFloating, T) ||
+                       is(T == c_complex_float) ||
+                       is(T == c_complex_double) ||
+                       is(T == c_complex_real))
             {
                 return Array!T.compare(*cast(T[]*)p1, *cast(T[]*)p2);
             }
@@ -443,17 +514,36 @@ static if (is(ucent)) class TypeInfo_zk : TypeInfoGeneric!ucent {}
 
 // All simple floating-point types.
 class TypeInfo_f : TypeInfoGeneric!float {}
-class TypeInfo_o : TypeInfoGeneric!(ifloat, float) {}
 class TypeInfo_d : TypeInfoGeneric!double {}
-class TypeInfo_p : TypeInfoGeneric!(idouble, double) {}
 class TypeInfo_e : TypeInfoGeneric!real {}
-class TypeInfo_j : TypeInfoGeneric!(ireal, real) {}
+
+// All imaginary floating-point types.
+
+// ifloat @@@DEPRECATED_2.105@@@
+deprecated class TypeInfo_o : TypeInfoGeneric!float
+{
+    override string toString() const pure nothrow @safe { return "ifloat"; }
+}
+
+// idouble @@@DEPRECATED_2.105@@@
+deprecated class TypeInfo_p : TypeInfoGeneric!double
+{
+    override string toString() const pure nothrow @safe { return "idouble"; }
+}
+
+// ireal @@@DEPRECATED_2.105@@@
+deprecated class TypeInfo_j : TypeInfoGeneric!real
+{
+    override string toString() const pure nothrow @safe { return "ireal"; }
+}
 
 // All complex floating-point types.
 
-// cfloat
-class TypeInfo_q : TypeInfoGeneric!cfloat
+// cfloat @@@DEPRECATED_2.105@@@
+deprecated class TypeInfo_q : TypeInfoGeneric!c_complex_float
 {
+    override string toString() const pure nothrow @safe { return "cfloat"; }
+
     const: nothrow: pure: @trusted:
     static if (__traits(hasMember, TypeInfo, "argTypes"))
         override int argTypes(out TypeInfo arg1, out TypeInfo arg2)
@@ -463,9 +553,11 @@ class TypeInfo_q : TypeInfoGeneric!cfloat
         }
 }
 
-// cdouble
-class TypeInfo_r : TypeInfoGeneric!cdouble
+// cdouble @@@DEPRECATED_2.105@@@
+deprecated class TypeInfo_r : TypeInfoGeneric!c_complex_double
 {
+    override string toString() const pure nothrow @safe { return "cdouble"; }
+
     const: nothrow: pure: @trusted:
     static if (__traits(hasMember, TypeInfo, "argTypes"))
         override int argTypes(out TypeInfo arg1, out TypeInfo arg2)
@@ -476,9 +568,11 @@ class TypeInfo_r : TypeInfoGeneric!cdouble
         }
 }
 
-// creal
-class TypeInfo_c : TypeInfoGeneric!creal
+// creal @@@DEPRECATED_2.105@@@
+deprecated class TypeInfo_c : TypeInfoGeneric!c_complex_real
 {
+    override string toString() const pure nothrow @safe { return "creal"; }
+
     const: nothrow: pure: @trusted:
     static if (__traits(hasMember, TypeInfo, "argTypes"))
         override int argTypes(out TypeInfo arg1, out TypeInfo arg2)
@@ -548,16 +642,50 @@ unittest
     assert(!(a1 < b1 && b1 < a1)); // Original failing case
 }
 
-// Arrays of all floating point types.
+// Arrays of all simple floating-point types.
 class TypeInfo_Af : TypeInfoArrayGeneric!float {}
-class TypeInfo_Ao : TypeInfoArrayGeneric!(ifloat, float) {}
 class TypeInfo_Ad : TypeInfoArrayGeneric!double {}
-class TypeInfo_Ap : TypeInfoArrayGeneric!(idouble, double) {}
 class TypeInfo_Ae : TypeInfoArrayGeneric!real {}
-class TypeInfo_Aj : TypeInfoArrayGeneric!(ireal, real) {}
-class TypeInfo_Aq : TypeInfoArrayGeneric!cfloat {}
-class TypeInfo_Ar : TypeInfoArrayGeneric!cdouble {}
-class TypeInfo_Ac : TypeInfoArrayGeneric!creal {}
+
+// Arrays of all imaginary floating-point types.
+
+// ifloat @@@DEPRECATED_2.105@@@
+deprecated class TypeInfo_Ao : TypeInfoArrayGeneric!float
+{
+    override string toString() const pure nothrow @safe { return "ifloat[]"; }
+}
+
+// idouble @@@DEPRECATED_2.105@@@
+deprecated class TypeInfo_Ap : TypeInfoArrayGeneric!double
+{
+    override string toString() const pure nothrow @safe { return "idouble[]"; }
+}
+
+// ireal @@@DEPRECATED_2.105@@@
+deprecated class TypeInfo_Aj : TypeInfoArrayGeneric!real
+{
+    override string toString() const pure nothrow @safe { return "ireal[]"; }
+}
+
+// Arrays of all complex floating-point types.
+
+// cfloat @@@DEPRECATED_2.105@@@
+deprecated class TypeInfo_Aq : TypeInfoArrayGeneric!c_complex_float
+{
+    override string toString() const pure nothrow @safe { return "cfloat[]"; }
+}
+
+// cdouble @@@DEPRECATED_2.105@@@
+deprecated class TypeInfo_Ar : TypeInfoArrayGeneric!c_complex_double
+{
+    override string toString() const pure nothrow @safe { return "cdouble[]"; }
+}
+
+// creal @@@DEPRECATED_2.105@@@
+deprecated class TypeInfo_Ac : TypeInfoArrayGeneric!c_complex_real
+{
+    override string toString() const pure nothrow @safe { return "creal[]"; }
+}
 
 // void[] is a bit different, behaves like ubyte[] for comparison purposes.
 class TypeInfo_Av : TypeInfo_Ah