common types + type modifiers

[Ellery Newcomer]

trying to wrap my head around shared,const,immutable (not inout yet, 
though someday I'll need to figure out what it's supposed to do)

Currently, dmd doesn't exhibit a lot of consistency wrt the above, so 
bear with me as I question every ____ing thing it does.

my [erroneous?] understanding of the modifiers:
shared - many threads can see
lack of shared - one thread can see plus some difference or other in 
physical layout (of which I am mostly ignorant)
immutable - nobody can mutate
lack of immutable - anybody can mutate
const - either immutable or mutable - you can't mutate because you don't 
know which, but you also can't rely on it not mutating

shared(immutable(T)) == immutable(T) because who care who can see it if 
nobody can mutate it

otherwise, shared(T) != T where T is not shared or immutable because T 
might be mutable and then it matters who can see it and when


What is the common type of two types with the same base T but different 
modifiers?

My [erroneous?] [generic] reasoning:
(notation - i under T1 means T1 == immutable(T), etc)
        T1       :    T2  ->   ResultT
        i              c          c        follows from my defs above
        i              m          c        ditto
        c              m          c        ditto

I think this is what dmd does. seems obvious. what about shared?

        shared(U) : U -> ??     where U is not shared or immutable

the result is some sort of a 'maybe shared' - it definitely can't be U. 
Can it be shared(U) ? I'm not sure about the semantics of tls, but it 
seems like that would violate U's contract that only one thread can see 
[and mutate] it.  So it seems to me that there is no common type of 
shared(U) and U.

unless it's acceptable to just make the mutability const. which would give:

        cs            m           cs
        cs            c           cs
        ms            m           cs
        ms            c           cs

otherwise, its a shared/shared or immutable/shared pair, so the result 
type is shared, and the mutability is the same as for unshared/unshared. 
which, come to think of it, will always be const. So the result type 
will be const shared(T)

So that's my generic reasoning, which doesn't take the semantics of 
subtypes, ease of use, etc, into account. here are some cases which I 
suspect are wrong:

const(int)  :  int  ->  int
const(int)  :  shared(int)  ->  int

and

shared(const(int*))  :  const(int*)  ->  const(int)*

1) why can we do away with the constness of the pointer?
2) I think we should not do away with the sharedness of the pointer, let 
alone of the element (shared is transitive too, isn't it?  it has to be..)

there's probably more, but..


confirmations? refutations?