Still gotta digest most of this, but I just want to quickly clear up some
possible confusions here.

I don't think my proposal is not saying that using N::f would NOT opt in
the namespace N. The opt-in is done only via the attribute-like syntax.

For example:

namespace ABC {

enum class Color
{
    Black,
    White,
    Red,
    Green,
    Blue,
    ...
};

enum class Shape
{
    Sphere,
    Cube,
    Pyramid,
    ...
};

[[context(using enum Color)]]
template <Color T_color, Shape T_shape>
class Rock { ... };

}


This would allow for this usage:

auto rock = ABC::Rock<Green, ABC::Shape::Sphere>{};


It would NOT allow for this usage:

auto rock = ABC::Rock<Green, Sphere>{};


Because the shape enum does not have a corresponding using statement.
We could also look at this example:

[[context(using namespace ABC)]]
template <Color T_color, Shape T_shape>
class Rock { ... };


Which would allow for this:

auto rock = ABC::Rock<Color::Green, Shape::Sphere>{};

It's as though there was a "using namespace ABC;" before that line, but
that only affects the parameter list.
Similarly with the previous example, it's as if we had "using enum
ABC::Color;" before that line, but it's scoped specifically to the param
list for ABC::Rock.

So the expression itself is in no way opting itself into a namespace. Some
other statement somewhere else is explicitly opting in to it, just with a
narrower scope. I think that's an important distinction.

>