My code (as seen below) is failing due to a single line.

That line is:

```
this.ival += (this.val * rhs.ival);
```

I kid you not, this is the reason why running unittests results in a program that just hangs. And no, replacing unittest with void main() doesn't fix the problem.

```
module dutils.math.number;
version(DLL)
{
export:
}
version(Standard)
{
public:
}
public import dutils.math.core;
public import std.bigint;
class Number : Mtype!NumberContainer
{
this(NumberContainer num)
{
this.contained = val;
}
override dstring toDstring() const @property pure @safe
{
return this.contained.toDstring;
}
override void fromDstring(dstring from) pure @safe
{
this.contained.fromDstring(from);
}
bool applyOp(W)(dstring op, Mtype!W rhs) pure @safe
in
{
assert(is(W == NumberContainer));
assert((op == "+"d) ^ (op == "-"d) ^ (op == "*"d) ^ (op == "/"d) ^ (op == "^^"d));
}
do
{
mixin("this.contained " ~ op ~ "= rhs.contained;");
return true; //We assume that the contract hasn't been violated.
}
}
struct NumberContainer
{
this(BigInt val, BigInt ival = 0, long pow10 = 0, ulong precision = 18) pure @safe nothrow @nogc
{
this.val = val;
this.pow10 = pow10;
this.ival = ival;
this.precision = precision;
}
dstring toDstring() const @property pure @safe
{
return ""d; //Placeholder
}
void fromDstring(dstring from) pure @safe
{
//Placeholder
}
void opOpAssign(string op)(NumberContainer rhs) pure @safe
{
import std.algorithm : max;
if(op == "/") //This section is where the line that hangs leads us to.
{
//Because BigInt is strictly an integer type, it is easier to code A/B as A*1/B, because the * operator is a piece of cake, and 1 over a BigInt is easier than an arbitrary BigInt
//over another arbitrary BigInt
immutable BigInt den = rhs.val ^^ 2 + rhs.ival ^^ 2;
NumberContainer store = NumberContainer(cast(BigInt)0);
auto istore = store;
long count = 0;
ubyte count2 = 9;
rhs *= NumberContainer(rhs.val, -rhs.ival, rhs.pow10, rhs.precision); //This line leads directly to the cause of hang.
for(ulong i = 0; i < precision; ++i) //Real part
{
if(rhs.val == BigInt(0))
break;
//Play around with the multiplier so the denominator actually fits in the numerator.
while(den > (BigInt(10) ^^ count) * rhs.val)
{
++count;
}
//Remove excess.
while(den < (BigInt(10) ^^ (count - 1L) * rhs.val))
{
--count;
}
for(; count2 * den > (BigInt(10) ^^ count) * rhs.val; --count2)
{
if(count2 < -9) //Remember, negative numbers exist too!
throw new Exception("ERROR: Division by 0");
}
rhs.val *= (BigInt(10) ^^ count); //`rhs` is a copy, so this isn't an issue.
rhs.val -= count2 * den; //Continue performing long division.
store.val *= 10;
store.val += count2;
store.pow10 -= count;
count = 0;
count2 = 9;
}
this.val *= store.val;
this.pow10 = store.pow10;
for(ulong i = 0; i < precision; ++i) //Imaginary part.
{
if(rhs.ival == BigInt(0))
break;
while(den > (BigInt(10) ^^ count) * rhs.ival)
{
++count;
}
//Remove excess.
while(den < (BigInt(10) ^^ (count - 1L) * rhs.ival))
{
--count;
}
for(; count2 * den > (BigInt(10) ^^ count) * rhs.ival; --count2)
{
if(count2 < -9) //Remember, negative numbers exist too!
throw new Exception("ERROR: Division by 0");
}
rhs.ival *= (BigInt(10) ^^ count); //`rhs` is a copy, so this isn't an issue.
rhs.ival -= count2 * den; //Continue performing long division.
istore.ival *= 10;
istore.ival += count2;
istore.pow10 -= count;
count = 0;
count2 = 9;
}
import std.algorithm : min, max;
this.ival *= istore.ival;
this.pow10 = min(store.pow10, istore.pow10);
if(store.pow10 > istore.pow10)
this.val *= BigInt(10) ^^ (store.pow10 - istore.pow10);
else
this.ival *= BigInt(10) ^^ (max(store.pow10, istore.pow10) - store.pow10);
}
else if(op == "^^")
{
//Oy Vey
}
else if(op == "*")
{
this.val *= rhs.val;
this.val -= (this.ival + rhs.ival);
this.ival = (this.ival * rhs.val);
this.pow10 += rhs.pow10;
this.ival += (this.val * rhs.ival); //This line solely causes the hang. I kid you not.
}
else
{
if(this.pow10 > rhs.pow10)
{
this.val *= BigInt(10) ^^ (this.pow10 - rhs.pow10);
this.ival *= BigInt(10) ^^ (this.pow10 - rhs.pow10);
}
else if(rhs.pow10 > this.pow10)
{
rhs.val *= BigInt(10) ^^ (rhs.pow10 - this.pow10);
rhs.ival *= BigInt(10) ^^ (rhs.pow10 - this.pow10);
}
this.pow10 = rhs.pow10;
this.val += rhs.val;
this.ival += rhs.ival;
}
}
NumberContainer opBinary(string op)(NumberContainer rhs) pure @safe
{
NumberContainer ret = this;
mixin("ret " ~ op ~ " rhs;");
return ret;
}
package:
BigInt val;
BigInt ival;
long pow10;
ulong precision;
}
unittest {
BigInt a = 1;
BigInt b = 1;
long c = 0;
NumberContainer e = NumberContainer(a,b,c);
a = 2;
NumberContainer f = NumberContainer(a,b,c);
e /= f; //This is the line that causes the hang.
import std.format;
assert((e).val == 6 && (e).pow10 == -1, format("%d", e.val).dup ~ format("%d", e.ival));
}
```

Funnily enough, if you simplify the module down to the following:

```
import std.bigint;
unittest ()
{
import std.conv : to;
S a = S(BigInt(1),BigInt(2),3);
a *= S(a.val, -a.ival, a.pow10);
assert(a == S(BigInt(1), BigInt(0), 6L), to!string(a.val.toLong).idup);
}
struct S
{
private BigInt val;
private BigInt ival;
private long pow10;
ulong precision;
void opOpAssign(string op)(S rhs)
{
this.val *= rhs.val;
this.val -= (this.ival + rhs.ival);
this.ival = (this.ival * rhs.val);
this.pow10 += rhs.pow10;
this.ival += (this.val * rhs.ival);
}
}
```

It works and doesn't hang.

Anyone have ANY idea of what I'm doing wrong here? Or is the compiler just bugging out?