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?