C++0x confusion with using declarations

Question

What should happen for this case:

struct A {
  void f();
};

struct B : virtual A {
  using A::f;
};

struct C : virtual A {
  using A::f;
};

struct D : B, C { 
  void g() {
    f();
  }
};

The line of interest is f(). Clearly the lookup of f according to 10.2 of the FDIS succeeds and finds A::f. However, what candidates will overload resolution consider? The spec says at 13.3.1p4:

For non-conversion functions introduced by a using-declaration into a derived class, the function is considered to be a member of the derived class for the purpose of defining the type of the implicit object parameter.

The intent of this is that for a single class, if such a class contains both own member functions and a using declaration bringing names of base class functions into scope, that during overload resolution all the function candidates have the same class type in their implicit object parameter. But what does this mean for the above example? Will the candidates be the following?

void F1(B&)
void F2(C&)
// call arguments: (lvalue D)

This appears to be wrong, because we only have one declaration in the lookup result set according to 10.2p7. How shall we interpret this??

Answer 1

I think that since the lookup set resulting from 10.2/7 results in only one declaration, there's no function overloading present at all. 13.3.1/4 would only apply when/if the lookup set resulting from 10.2/7 contained two or more declarations.

Edit: Perhaps I wasn't as clear as I'd hoped. Even if f is overloaded in A, I think most of the same reasoning applies. Perhaps it's best to take things step by step. (Note, that in this case, I'm using the same S(f, X) notation as the standard, but since your most derived class is D, your S(f, D) corresponds to their S(f, C), and your S(f, B) ans S(f, C) correspond to its S(f, B₁) and S(f, B₂).

First s(f, D) is empty, because we have no declaration of f directly contained in D. Based on that, we get to 10.2/5.

In 10.2/6, we start by merging s(f, B) into S(f, D). Since s(f, D) is currently empty, we follow the second condition under the first bullet point, and S(f, D) becomes a copy of S(f, B).

Then we have to merge S(f, C) into S(f, D). In this case, each of the subobject members of S(f, C) is a subobject member of S(f, D). This satisfies the first condition of the first bullet point, so we leave S(f, D) unchanged, and the merge is complete.

At that point, there are no more base classes B_i to consider, so our S(f, D) = S(f, B). None of the declarations from S(f, C) is present in the final overload set at all.

Then, if S(f, B) contained two or more functions, we proceed to 13.3.1, and resolve the overload set -- but since the entire set came via B, the situation posited in the question simply doesn't exist.

Answer 2

_{Only speculation, totally not sure. :)}

[ Example:
struct A { int x; }; // S(x,A) = { { A::x }, { A } }
struct B { float x; }; // S(x,B) = { { B::x }, { B } }
struct C: public A, public B { }; // S(x,C) = { invalid, { A in C, B in C } }
struct D: public virtual C { }; // S(x,D) = S(x,C)
struct E: public virtual C { char x; }; // S(x,E) = { { E::x }, { E } }
struct F: public D, public E { }; // S(x,F) = S(x,E)
int main() {
F f;
f.x = 0; // OK, lookup finds E::x
}
S(x, F) is unambiguous because the A and B base subobjects of D are also base subobjects of E, so S(x,D)
is discarded in the first merge step. —end example ]

Is the example from 10.2p7, where S(f,C) denotes the lookup set. The sentence provided at the end is essential: Since both D and E have the same C base class, and E::x hides the x from that C, making the final use of F::x unambigiuous.
Now, in your example, nothing hides the f of the base classes of D, so the use of D::f is still ambigiuous and I can't see how 10.2p7 applies to your case. Like said at the top, totally not sure. ;)

Answer 3

Instead of addressing the question directly, I'm going to try to argue that pretending there exist f functions in each of the derived classes doesn't work:

There's only one candidate function, and it has type

void A::(void)

Although you can form a pointer-to-member to that function with

void (A::*F0)(void) = &A::f;
void (B::*F1)(void) = F0;
void (C::*F2)(void) = F0;

This is because the pointer-to-member contains additional information necessary to calculate the parameter of the function. The pointer-to-member call site finds an A subobject of the actual target instance, to provide the this pointer of f. There's no logic inside the function to find A's members from a this pointer of derived type. So one can't talk about void F1(B* this) and void F2(C* this) as your question suggests.

If the functions are considered members of the derived class, it is as

void B::A::f(void);
void C::A::f(void);

But as B::A and C::A are the same base class, ultimately there is only one function in the candidate list, although it is in the list twice. Then virtual inheritance provides that both candidates are calling the same function on the same object, there is no ambiguity.

Answer 4

I think the key is in 10.2p5, where the standard refers to checking each "direct base class subobject".

Because A is inherited virtually, it is a "direct base class subobject" of D (10.1p4).

Then three subobjects of D are considered: A, B, and C. By 10.2p6 B and C are eliminated (A is a base of these), and only A::f is a candidate.