[Moved to DR at the April, 2013 meeting.]

Proposed resolution (February, 2012):

Move 12.2.4.3 [over.ics.rank] paragraph 3, first bullet, third sub-bullet, after the current fifth sub-bullet, as follows:

Two implicit conversion sequences of the same form are indistinguishable conversion sequences unless one of the following rules applies:

• Standard conversion sequence S1 is a better conversion sequence...

• S1 is a proper subsequence of S2...

• the rank of S1 is better...

• S1 and S2 differ only in their qualification conversion... —end example] or if not that,

• S1 and S2 are reference bindings (9.4.4 [dcl.init.ref]) and neither refers... or if not that,

• S1 and S2 are reference bindings (9.4.4 [dcl.init.ref]) and S1 binds... —end example] or if not that,

• S1 and S2 differ only in their qualification conversion... —end example] or if not that,

• S1 and S2 are reference bindings (9.4.4 [dcl.init.ref]), and the types to which the references refer...

• User-defined conversion sequence U1...

Notes from the February, 2012 meeting:

The CWG agreed that bullets 3 and 4 should be reversed, to check the reference binding first and then for qualification conversion.

The rule in 12.2.4.3 [over.ics.rank] paragraph 3 for ranking based on a difference in qualification conversion applies only if they "differ only in their qualification conversion".

It is unclear as to whether the property of being a reference binding is a factor in determining if there is a difference between conversion sequences. Notice that 12.2.4.2.5 [over.ics.ref] maps reference bindings to other forms of implicit conversion sequences, but does not state that the property of being a reference binding is preserved; however, 12.2.4.3 [over.ics.rank] has cases which depend on whether certain standard conversion sequences are reference bindings or not and on the specifics of the bindings.

In the following, picking T2 && would bind an rvalue to an rvalue reference. Picking T1 & would bind an rvalue to an lvalue reference, but the qualification conversion to T1 is "better". Which is better?

    typedef int *      *      *const *const T1;
    typedef int *const *const *const *const T2;
    void foo(T1 &);
    void foo(T2 &&) { }

    int main() {
       foo((int ****)0);
       return 0;
    }