Why can't I init a new var from const var?

[Random D user via Digitalmars-d-learn]

I can init a variable from mutable source without defining any 
constructor or assignment operators, but not if the source is 
const. I would imagine the behavior to be the same with mutable 
and const source, since it's just reading the source and copying 
it.

Is there a reason for this? Or is this a bug?
I can workaround this by making copies or casting, that just 
creates ugly code everywhere.

Here's an example (with dmd 2.073):

struct Foo
{
    this( Foo source )
    {
        buf = source.buf.dup;
    }

    this( const Foo source )
    {
        buf = source.buf.dup;
    }

    this( const ref Foo source )
    {
        buf = source.buf.dup;
    }

    void opAssign( Foo source )
    {
        buf = source.buf.dup;
    }

    void opAssign( const Foo source )
    {
        buf = source.buf.dup;
    }

    void opAssign( const ref Foo source )
    {
        buf = source.buf.dup;
    }

    char[] buf;
}

Foo fun(const ref Foo foo, Foo foo2)
{
    Foo bar  = foo;                     // Error: cannot 
implicitly convert expression (foo) of type const(Foo) to Foo
    Foo baz  = foo2;                    // Ok, No need for 
constructors or opAssign
    Foo baz2 = cast(const Foo)foo2;     // Error: cannot 
implicitly convert expression (Foo(null).this(foo2)) of type 
const(Foo) to Foo
    Foo bar2;
    bar2     = foo;                     // uses opAssing( const 
Foo ) / opAssign( const ref Foo )
    Foo bar3;
    bar3     = foo2;                    // uses opAssign( const 
Foo ) / opAssign( Foo )
    Foo bar4;
    bar4     = cast(const Foo)foo2;     // uses opAssing( const 
Foo )

    //Foo bar = Foo(foo);     // This works provided there is 
non-const opAssign defined.
    //Foo bar = cast(Foo)foo; // This seems to work as well
    return bar;
}

Foo foo;
foo = fun(foo, foo);