What is the rule that allows `this->` to access members of dependent base classes?

Question

As we know, the code below is ill-formed because the member x is in a dependent base class. However, changing x to this->x on the indicated line would fix the error.

template <typename T>
struct B {
    int x;
};
template <typename T>
struct C : B<T> {
    void f() {
        int y = x; // Error!
    }
};
int main() {
    C<int> c;
    c.f();
}

I would like an explanation of how this behaviour is specified in the standard. According to [temp.dep]/3:

In the definition of a class or class template, if a base class depends on a template-parameter, the base class scope is not examined during unqualified name lookup either at the point of definition of the class template or member or during an instantiation of the class template or member.

This seems to explain why using x alone fails. The name x is looked up at the point of definition, and the base class scope is not examined. However, what if we use this->x? Now the name x is dependent and its lookup is postponed until instantiation. But the quoted paragraph seems to imply that x should not be found even at instantiation time, since the lookup of x in this->x is still unqualified lookup.

Obviously implementations don't behave this way, and it's widely understood that the base class scope is searched once the template is instantiated.

1. Have I misinterpreted the quoted paragraph?
2. Is there a paragraph that specifies the "correct" behaviour?

Earthwork

This is not unqualified lookup (3.4.1 [basic.lookup.unqual]), this is class member access expression lookup (3.4.5 [basic.lookup.classref]). – Kidderminster

@n.m. Thanks, I didn't realize class member name lookup was a distinct type of name lookup. You should make that an answer. – Earthwork

What exactly is a 'dependent base class'? As opposed to say an independent base class? Is there such a thing? – Selfpreservation

@EJP In template <typename T> struct C : B { ... }, B is a not a dependent base class. – Sandra

Answer 1

Class member access expressions (5.2.5. [expr.ref]) don't use unqualified lookup rules, they use class member access lookup rules (3.4.5 [basic.lookup.classref]).

(2) If the id-expression in a class member access (5.2.5) is an unqualified-id, and the type of the object expression is of a class type C, the unqualified-id is looked up in the scope of class C.

Kidderminster

That doesn’t really say why the answer differs from that for an unqualified name (which obviously considers the scope of any containing class). – Lucienlucienne