No, copy-initialization subsumes the conversion.

Do you mean the copy-initialization that occurred in the return statement subsumes the conversion of 0 to type A? If it is, the direct initialization of the reference will comprise the user-defined conversion that occurs in the temporary materialization conversion, specifically, the user-defined conversion occurs in the return statement where the operand is used to initialize the result object. IMHO, it contradicts with that

For this direct-initialization, user-defined conversions are not considered.

To make this thought more clear, the B const& rf = a; is equivalent to

B const& rf(a.operator B());
// where the materialization conversion is equivalent to
B temporary_object = a.operator B();
// where the return statement in `A::operator B` has the effect, which is like
B temporary_object = 0;
// In the above copy-initialization, user-defined conversion(B::B(int)) is considered
// which is considered in direct-initialization of the reference rf

@jensmaurer Is any thought here?

I'm not seeing a problem. We copy-initialize the temporary (conversion function is fine). This completes the evaluation of the conversion function and any talk about operands of "return". As a distinct step, we then direct-initialize the reference with the temporary (no conversion functions involved).

The temporary direct-initialize the reference is not specifying by [dcl.init.ref#5.4.1]. It just say

The result of the call to the conversion function, as described for the non-reference copy-initialization, is then used to direct-initialize the reference.

Where the call to the conversion function is a prvalue, bind it to a reference will trigger the materialization, which means a temporary object will copy-initialized from the operand, which requires the user-defined conversion, Occurs in direct-initializ the reference from a prvalue.

The relevant wording in C++11 standard was saying that the reference is bound to the temporary

Otherwise, a temporary of type “ cv1 T1” is created and initialized from the initializer expression using the rules for a non-reference copy-initialization ([dcl.init]). The reference is then bound to the temporary.

However, the concern in CWG1571, make the wording be changed, which claims that the conversion function call is direct-initialized the reference. In my example, this rule means we should continue to fall into [dcl.init.ref] p5 for it. What I'm concerning here is what's the extent of the application of the restriction that the user-defined conversions are not considered in this direct-initialization. Since we fall into [dcl.init.ref#5.3] for this direct-initialization, materialization conversion would apply to the conversion function call(prvalue), as discussed in the above comment, the copy-initialization of the temporary object does consider the user-defined conversion.

Maybe clarified by cplusplus/CWG#186