remove void initilization, make code more safe

9il · 9il · commit 40e49a32f92d · 2017-05-06T21:38:02.000+07:00
diff --git a/source/mir/math/sum.d b/source/mir/math/sum.d
@@ -51,7 +51,7 @@ unittest
         Quaternion opBinary(string op)(auto ref const Quaternion rhs) const
             if (op == "+" || op == "-")
         {
-            Quaternion ret = void;
+            Quaternion ret ;
             foreach (i, ref e; ret.rijk)
                 mixin("e = rijk[i] "~op~" rhs.rijk[i];");
             return ret;
@@ -446,7 +446,7 @@ struct Summator(T, Summation summation)
         static import std.math;
     private:
         enum F M = (cast(F)(2)) ^^ (T.max_exp - 1);
-        F[16] scopeBufferArray = void;
+        F[16] scopeBufferArray = 0;
         ScopeBuffer!F partials;
         //sum for NaN and infinity.
         F s;
@@ -472,7 +472,7 @@ struct Summator(T, Summation summation)
         }
         body
         {
-            bool _break = void;
+            bool _break;
             foreach_reverse (i, y; partials)
             {
                 s = partialsReducePred(s, y, i ? partials[i-1] : 0, _break);
@@ -554,23 +554,23 @@ struct Summator(T, Summation summation)
     else
     static if (summation == Summation.kb2)
     {
-        F s = void;
-        F cs = void;
-        F ccs = void;
+        F s = 0;
+        F cs = 0;
+        F ccs = 0;
     }
     else
     static if (summation == Summation.kbn)
     {
-        F s = void;
-        F c = void;
+        F s = 0;
+        F c = 0;
     }
     else
     static if (summation == Summation.kahan)
     {
-        F s = void;
-        F c = void;
-        F y = void; // do not declare in the loop/put (algo can be used for matrixes and etc)
-        F t = void; // ditto
+        F s = F.init;
+        F c = F.init;
+        F y = F.init; // do not declare in the loop/put (algo can be used for matrixes and etc)
+        F t = F.init; // ditto
     }
     else
     static if (summation == Summation.pairwise)
@@ -580,22 +580,22 @@ struct Summator(T, Summation summation)
         static if (fastPairwise)
         {
             enum registersCount= 16;
-            F[size_t.sizeof * 8] partials = void;
+            F[size_t.sizeof * 8] partials = F.init;
         }
         else
         {
-            F[size_t.sizeof * 8] partials = void;
+            F[size_t.sizeof * 8] partials = F.init;
         }
     }
     else
     static if (summation == Summation.naive)
     {
-        F s = void;
+        F s = F.init;
     }
     else
     static if (summation == Summation.fast)
     {
-        F s = void;
+        F s = F.init;
     }
     else
     static assert(0, "Unsupported summation type for std.numeric.Summator.");
@@ -759,7 +759,7 @@ public:
             static if (isFloatingPoint!F)
             {
                 F t = s + x;
-                F c = void;
+                F c = 0;
                 if (fabs(s) >= fabs(x))
                 {
                     F d = s - t;
@@ -911,7 +911,7 @@ public:
     {
         static if (summation == Summation.pairwise && fastPairwise && isDynamicArray!Range)
         {
-            F[registersCount] v = void;
+            F[registersCount] v;
             foreach (i, n; chainSeq!registersCount)
             {
                 if (r.length >= n * 2) do
@@ -1180,7 +1180,7 @@ public:
         else
         static if (summation == Summation.precise)
         {
-            typeof(return) ret = void;
+            auto ret = typeof(return).init;
             ret.s = s;
             ret.o = o;
             ret.partials = scopeBuffer(ret.scopeBufferArray);
@@ -1204,7 +1204,7 @@ public:
         else
         static if (summation == Summation.kb2)
         {
-            typeof(return) ret = void;
+            auto ret = typeof(return).init;
             ret.s = s;
             ret.cs = cs;
             ret.ccs = ccs;
@@ -1213,23 +1213,23 @@ public:
         else
         static if (summation == Summation.kbn)
         {
-            typeof(return) ret = void;
+            auto ret = typeof(return).init;
             ret.s = s;
             ret.c = c;
             return ret;
         }
         else
         static if (summation == Summation.kahan)
         {
-            typeof(return) ret = void;
+            auto ret = typeof(return).init;
             ret.s = s;
             ret.c = c;
             return ret;
         }
         else
         static if (summation == Summation.pairwise)
         {
-            typeof(return) ret = void;
+            auto ret = typeof(return).init;
             ret.counter = counter;
             ret.index = index;
             foreach (i; 0 .. index)
@@ -1239,14 +1239,14 @@ public:
         else
         static if (summation == Summation.naive)
         {
-            typeof(return) ret = void;
+            auto ret = typeof(return).init;
             ret.s = s;
             return ret;
         }
         else
         static if (summation == Summation.fast)
         {
-            typeof(return) ret = void;
+            auto ret = typeof(return).init;
             ret.s = s;
             return ret;
         }
diff --git a/source/mir/ndslice/allocation.d b/source/mir/ndslice/allocation.d
@@ -391,7 +391,7 @@ auto shape(T)(T[] array, ref int err)
     }
     else
     {
-        size_t[1] ret = void;
+        size_t[1] ret;
         ret[0] = array.length;
     }
     err = 0;
diff --git a/source/mir/ndslice/concatenation.d b/source/mir/ndslice/concatenation.d
@@ -201,7 +201,7 @@ struct Concatenation(size_t dim, Slices...)
     /// Shape of the concatenation.
     size_t[N] shape()() const @property
     {
-        typeof(return) ret = void;
+        typeof(return) ret;
         foreach(i; Iota!N)
             ret[i] = length!i;
         return ret;
@@ -394,7 +394,7 @@ template pad(size_t[] dimensions, string[] directions)
         enum q = directions[$ - 1];
         enum N = typeof(S.shape).length;
 
-        size_t[N] len = void;
+        size_t[N] len;
         auto _len = s.shape;
         foreach(i; Iota!(len.length))
             static if (i != d)
diff --git a/source/mir/ndslice/field.d b/source/mir/ndslice/field.d
@@ -264,7 +264,7 @@ struct ndIotaField(size_t N)
 
     size_t[N] opIndex()(size_t index) const
     {
-        size_t[N] indexes = void;
+        size_t[N] indexes;
         foreach_reverse (i; Iota!(N - 1))
         {
             indexes[i + 1] = index % _lengths[i];
@@ -309,7 +309,7 @@ struct LinspaceField(T)
 
     size_t[1] shape()() @property
     {
-        size_t[1] ret = void;
+        size_t[1] ret;
         ret[0] = _length;
         return ret;
     }
diff --git a/source/mir/ndslice/internal.d b/source/mir/ndslice/internal.d
@@ -111,7 +111,7 @@ mixin template _DefineRet_()
     static if (hasElaborateAssign!(typeof(Ret._iterator)))
         Ret ret;
     else
-        Ret ret = void;
+        Ret ret = Ret.init;
 }
 
 
@@ -277,4 +277,4 @@ pure nothrow unittest
     assert(lengthsProduct([3, 4, 5]) == 60);
 }
 
-struct _Slice() { size_t i = void, j = void; }
+struct _Slice() { size_t i, j; }
diff --git a/source/mir/ndslice/ndfield.d b/source/mir/ndslice/ndfield.d
@@ -74,7 +74,7 @@ struct Cartesian(NdFields...)
     ///
     size_t[N] shape()() @property
     {
-        typeof(return) ret = void;
+        typeof(return) ret;
         foreach(f, ref field; _fields)
         {
             static if (hasShape!(NdFields[f]))
@@ -163,7 +163,7 @@ struct Kronecker(alias fun, NdFields...)
         }
         else
         {
-            size_t[1] ret = void;
+            size_t[1] ret;
             ret[0] = _fields[0].length;
             foreach(ref field; _fields[1 .. $])
                 ret[0] *= field.length;
@@ -184,9 +184,9 @@ struct Kronecker(alias fun, NdFields...)
     auto ref opIndex()(size_t[N] indexes...)
     {   
         static if (N > 1)
-            size_t[N][NdFields.length] ind = void;
+            size_t[N][NdFields.length] ind;
         else
-            size_t[NdFields.length] ind = void;
+            size_t[NdFields.length] ind;
         foreach_reverse (f, ref field; _fields)
         {
             static if (f)
@@ -197,7 +197,7 @@ struct Kronecker(alias fun, NdFields...)
                 }
                 else
                 {
-                    size_t[1] s = void;
+                    size_t[1] s;
                     s[0] = field.length;
                 }
                 static if (N > 1)
diff --git a/source/mir/ndslice/topology.d b/source/mir/ndslice/topology.d
@@ -1712,7 +1712,7 @@ See_also: $(LREF)
 auto linspace(T, size_t N)(size_t[N] lengths, T[2][N] intervals...)
     if (N && (isFloatingPoint!T || isComplex!T))
 {
-    Repeat!(N, LinspaceField!T) fields = void;
+    Repeat!(N, LinspaceField!T) fields;
     foreach(i; Iota!N)
     {
         assert(lengths[i] > 1, "linspace: all lengths must be greater then 1.");

Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,7 @@ unittest`
`51`	`51`	`Quaternion opBinary(string op)(auto ref const Quaternion rhs) const`
`52`	`52`	`if (op == "+" \|\| op == "-")`
`53`	`53`	`{`
`54`		`- Quaternion ret = void;`
	`54`	`+ Quaternion ret ;`
`55`	`55`	`foreach (i, ref e; ret.rijk)`
`56`	`56`	`mixin("e = rijk[i] "~op~" rhs.rijk[i];");`
`57`	`57`	`return ret;`
`@@ -446,7 +446,7 @@ struct Summator(T, Summation summation)`
`446`	`446`	`static import std.math;`
`447`	`447`	`private:`
`448`	`448`	`enum F M = (cast(F)(2)) ^^ (T.max_exp - 1);`
`449`		`- F[16] scopeBufferArray = void;`
	`449`	`+ F[16] scopeBufferArray = 0;`
`450`	`450`	`ScopeBuffer!F partials;`
`451`	`451`	`//sum for NaN and infinity.`
`452`	`452`	`F s;`
`@@ -472,7 +472,7 @@ struct Summator(T, Summation summation)`
`472`	`472`	`}`
`473`	`473`	`body`
`474`	`474`	`{`
`475`		`- bool _break = void;`
	`475`	`+ bool _break;`
`476`	`476`	`foreach_reverse (i, y; partials)`
`477`	`477`	`{`
`478`	`478`	`s = partialsReducePred(s, y, i ? partials[i-1] : 0, _break);`
`@@ -554,23 +554,23 @@ struct Summator(T, Summation summation)`
`554`	`554`	`else`
`555`	`555`	`static if (summation == Summation.kb2)`
`556`	`556`	`{`
`557`		`- F s = void;`
`558`		`- F cs = void;`
`559`		`- F ccs = void;`
	`557`	`+ F s = 0;`
	`558`	`+ F cs = 0;`
	`559`	`+ F ccs = 0;`
`560`	`560`	`}`
`561`	`561`	`else`
`562`	`562`	`static if (summation == Summation.kbn)`
`563`	`563`	`{`
`564`		`- F s = void;`
`565`		`- F c = void;`
	`564`	`+ F s = 0;`
	`565`	`+ F c = 0;`
`566`	`566`	`}`
`567`	`567`	`else`
`568`	`568`	`static if (summation == Summation.kahan)`
`569`	`569`	`{`
`570`		`- F s = void;`
`571`		`- F c = void;`
`572`		`- F y = void; // do not declare in the loop/put (algo can be used for matrixes and etc)`
`573`		`- F t = void; // ditto`
	`570`	`+ F s = F.init;`
	`571`	`+ F c = F.init;`
	`572`	`+ F y = F.init; // do not declare in the loop/put (algo can be used for matrixes and etc)`
	`573`	`+ F t = F.init; // ditto`
`574`	`574`	`}`
`575`	`575`	`else`
`576`	`576`	`static if (summation == Summation.pairwise)`
`@@ -580,22 +580,22 @@ struct Summator(T, Summation summation)`
`580`	`580`	`static if (fastPairwise)`
`581`	`581`	`{`
`582`	`582`	`enum registersCount= 16;`
`583`		`- F[size_t.sizeof * 8] partials = void;`
	`583`	`+ F[size_t.sizeof * 8] partials = F.init;`
`584`	`584`	`}`
`585`	`585`	`else`
`586`	`586`	`{`
`587`		`- F[size_t.sizeof * 8] partials = void;`
	`587`	`+ F[size_t.sizeof * 8] partials = F.init;`
`588`	`588`	`}`
`589`	`589`	`}`
`590`	`590`	`else`
`591`	`591`	`static if (summation == Summation.naive)`
`592`	`592`	`{`
`593`		`- F s = void;`
	`593`	`+ F s = F.init;`
`594`	`594`	`}`
`595`	`595`	`else`
`596`	`596`	`static if (summation == Summation.fast)`
`597`	`597`	`{`
`598`		`- F s = void;`
	`598`	`+ F s = F.init;`
`599`	`599`	`}`
`600`	`600`	`else`
`601`	`601`	`static assert(0, "Unsupported summation type for std.numeric.Summator.");`
`@@ -759,7 +759,7 @@ public:`
`759`	`759`	`static if (isFloatingPoint!F)`
`760`	`760`	`{`
`761`	`761`	`F t = s + x;`
`762`		`- F c = void;`
	`762`	`+ F c = 0;`
`763`	`763`	`if (fabs(s) >= fabs(x))`
`764`	`764`	`{`
`765`	`765`	`F d = s - t;`
`@@ -911,7 +911,7 @@ public:`
`911`	`911`	`{`
`912`	`912`	`static if (summation == Summation.pairwise && fastPairwise && isDynamicArray!Range)`
`913`	`913`	`{`
`914`		`- F[registersCount] v = void;`
	`914`	`+ F[registersCount] v;`
`915`	`915`	`foreach (i, n; chainSeq!registersCount)`
`916`	`916`	`{`
`917`	`917`	`if (r.length >= n * 2) do`
`@@ -1180,7 +1180,7 @@ public:`
`1180`	`1180`	`else`
`1181`	`1181`	`static if (summation == Summation.precise)`
`1182`	`1182`	`{`
`1183`		`- typeof(return) ret = void;`
	`1183`	`+ auto ret = typeof(return).init;`
`1184`	`1184`	`ret.s = s;`
`1185`	`1185`	`ret.o = o;`
`1186`	`1186`	`ret.partials = scopeBuffer(ret.scopeBufferArray);`
`@@ -1204,7 +1204,7 @@ public:`
`1204`	`1204`	`else`
`1205`	`1205`	`static if (summation == Summation.kb2)`
`1206`	`1206`	`{`
`1207`		`- typeof(return) ret = void;`
	`1207`	`+ auto ret = typeof(return).init;`
`1208`	`1208`	`ret.s = s;`
`1209`	`1209`	`ret.cs = cs;`
`1210`	`1210`	`ret.ccs = ccs;`
`@@ -1213,23 +1213,23 @@ public:`
`1213`	`1213`	`else`
`1214`	`1214`	`static if (summation == Summation.kbn)`
`1215`	`1215`	`{`
`1216`		`- typeof(return) ret = void;`
	`1216`	`+ auto ret = typeof(return).init;`
`1217`	`1217`	`ret.s = s;`
`1218`	`1218`	`ret.c = c;`
`1219`	`1219`	`return ret;`
`1220`	`1220`	`}`
`1221`	`1221`	`else`
`1222`	`1222`	`static if (summation == Summation.kahan)`
`1223`	`1223`	`{`
`1224`		`- typeof(return) ret = void;`
	`1224`	`+ auto ret = typeof(return).init;`
`1225`	`1225`	`ret.s = s;`
`1226`	`1226`	`ret.c = c;`
`1227`	`1227`	`return ret;`
`1228`	`1228`	`}`
`1229`	`1229`	`else`
`1230`	`1230`	`static if (summation == Summation.pairwise)`
`1231`	`1231`	`{`
`1232`		`- typeof(return) ret = void;`
	`1232`	`+ auto ret = typeof(return).init;`
`1233`	`1233`	`ret.counter = counter;`
`1234`	`1234`	`ret.index = index;`
`1235`	`1235`	`foreach (i; 0 .. index)`
`@@ -1239,14 +1239,14 @@ public:`
`1239`	`1239`	`else`
`1240`	`1240`	`static if (summation == Summation.naive)`
`1241`	`1241`	`{`
`1242`		`- typeof(return) ret = void;`
	`1242`	`+ auto ret = typeof(return).init;`
`1243`	`1243`	`ret.s = s;`
`1244`	`1244`	`return ret;`
`1245`	`1245`	`}`
`1246`	`1246`	`else`
`1247`	`1247`	`static if (summation == Summation.fast)`
`1248`	`1248`	`{`
`1249`		`- typeof(return) ret = void;`
	`1249`	`+ auto ret = typeof(return).init;`
`1250`	`1250`	`ret.s = s;`
`1251`	`1251`	`return ret;`
`1252`	`1252`	`}`
Original file line number	Diff line number	Diff line change
`@@ -391,7 +391,7 @@ auto shape(T)(T[] array, ref int err)`
`391`	`391`	`}`
`392`	`392`	`else`
`393`	`393`	`{`
`394`		`- size_t[1] ret = void;`
	`394`	`+ size_t[1] ret;`
`395`	`395`	`ret[0] = array.length;`
`396`	`396`	`}`
`397`	`397`	`err = 0;`
Original file line number	Diff line number	Diff line change
`@@ -264,7 +264,7 @@ struct ndIotaField(size_t N)`
`264`	`264`
`265`	`265`	`size_t[N] opIndex()(size_t index) const`
`266`	`266`	`{`
`267`		`- size_t[N] indexes = void;`
	`267`	`+ size_t[N] indexes;`
`268`	`268`	`foreach_reverse (i; Iota!(N - 1))`
`269`	`269`	`{`
`270`	`270`	`indexes[i + 1] = index % _lengths[i];`
`@@ -309,7 +309,7 @@ struct LinspaceField(T)`
`309`	`309`
`310`	`310`	`size_t[1] shape()() @property`
`311`	`311`	`{`
`312`		`- size_t[1] ret = void;`
	`312`	`+ size_t[1] ret;`
`313`	`313`	`ret[0] = _length;`
`314`	`314`	`return ret;`
`315`	`315`	`}`
Original file line number	Diff line number	Diff line change
`@@ -111,7 +111,7 @@ mixin template _DefineRet_()`
`111`	`111`	`static if (hasElaborateAssign!(typeof(Ret._iterator)))`
`112`	`112`	`Ret ret;`
`113`	`113`	`else`
`114`		`- Ret ret = void;`
	`114`	`+ Ret ret = Ret.init;`
`115`	`115`	`}`
`116`	`116`
`117`	`117`
`@@ -277,4 +277,4 @@ pure nothrow unittest`
`277`	`277`	`assert(lengthsProduct([3, 4, 5]) == 60);`
`278`	`278`	`}`
`279`	`279`
`280`		`-struct _Slice() { size_t i = void, j = void; }`
	`280`	`+struct _Slice() { size_t i, j; }`
Original file line number	Diff line number	Diff line change
`@@ -74,7 +74,7 @@ struct Cartesian(NdFields...)`
`74`	`74`	`///`
`75`	`75`	`size_t[N] shape()() @property`
`76`	`76`	`{`
`77`		`- typeof(return) ret = void;`
	`77`	`+ typeof(return) ret;`
`78`	`78`	`foreach(f, ref field; _fields)`
`79`	`79`	`{`
`80`	`80`	`static if (hasShape!(NdFields[f]))`
`@@ -163,7 +163,7 @@ struct Kronecker(alias fun, NdFields...)`
`163`	`163`	`}`
`164`	`164`	`else`
`165`	`165`	`{`
`166`		`- size_t[1] ret = void;`
	`166`	`+ size_t[1] ret;`
`167`	`167`	`ret[0] = _fields[0].length;`
`168`	`168`	`foreach(ref field; _fields[1 .. $])`
`169`	`169`	`ret[0] *= field.length;`
`@@ -184,9 +184,9 @@ struct Kronecker(alias fun, NdFields...)`
`184`	`184`	`auto ref opIndex()(size_t[N] indexes...)`
`185`	`185`	`{`
`186`	`186`	`static if (N > 1)`
`187`		`- size_t[N][NdFields.length] ind = void;`
	`187`	`+ size_t[N][NdFields.length] ind;`
`188`	`188`	`else`
`189`		`- size_t[NdFields.length] ind = void;`
	`189`	`+ size_t[NdFields.length] ind;`
`190`	`190`	`foreach_reverse (f, ref field; _fields)`
`191`	`191`	`{`
`192`	`192`	`static if (f)`
`@@ -197,7 +197,7 @@ struct Kronecker(alias fun, NdFields...)`
`197`	`197`	`}`
`198`	`198`	`else`
`199`	`199`	`{`
`200`		`- size_t[1] s = void;`
	`200`	`+ size_t[1] s;`
`201`	`201`	`s[0] = field.length;`
`202`	`202`	`}`
`203`	`203`	`static if (N > 1)`
Original file line number	Diff line number	Diff line change
`@@ -1712,7 +1712,7 @@ See_also: $(LREF)`
`1712`	`1712`	`auto linspace(T, size_t N)(size_t[N] lengths, T[2][N] intervals...)`
`1713`	`1713`	`if (N && (isFloatingPoint!T \|\| isComplex!T))`
`1714`	`1714`	`{`
`1715`		`- Repeat!(N, LinspaceField!T) fields = void;`
	`1715`	`+ Repeat!(N, LinspaceField!T) fields;`
`1716`	`1716`	`foreach(i; Iota!N)`
`1717`	`1717`	`{`
`1718`	`1718`	`assert(lengths[i] > 1, "linspace: all lengths must be greater then 1.");`