using declaration inside a member function for an inherited member field

Inside a function one can employ the using declaration to import a name in the current scope, like

namespace A {
   int y;
}
void f() { using A::y; }

A using declaration can be used in a class definition, to alter the accessibility of an inherited member, but also it is useful to explicitly bring a member inherited from a template class

template <bool activate>
struct A {
   int x;
};
template <bool activate>
struct B : public A<activate> {
   using A<activate>::x;
};

This is particularly useful, as it avoids the need to access to x via this->x or A<activate>::x. This can be used only inside the body of the definition, but not inside a member function.

template <bool activate>
struct A {
   int x;
};
template <bool activate>
struct B : public A<activate> {
   int f() const noexcept {
       // This gives: "error: using-declaration for member at non-class scope"
       // using A<activate>::x;
       return x;
   }
};

Is there a rationale for this restriction of the language, that is, for the fact that using A<activate>::x can only be placed inside the definition of the class?

Absent a direct statement on the subject in Design & Evolution of C++, it’s hard to reliably infer intent for something like this. That said, until recently, the standard described using-declarations as introducing declarations as synonyms for the named declarations. In that view, it would be more than a little strange to have a member declaration belong to a block scope. Now they are considered to be redirects that are replaced by their referents during name lookup, which would be more consistent with this notional usage.