It looks like #146972 (comment) suggests to support trailing self in all paths, not just import paths. We can start with import paths if that's more convenient though.

However, if we are doing it, then I think it's time to abandon the whole "self rewriting" hack, and just properly resolve self inside modules.

It looks like #146972 (comment) suggests to support trailing self in all paths, not just import paths.

Semantics of trailing self in import paths, like use foo::self;, is explicit and same to use foo::{self};, and this will require foo is in type namespace. So I think trailing self in import paths is usefull to replace use foo::{self}; when we want to import only items in type namespace.

But what will trailing self in non-import paths be? Do we need things like Foo::self? 🤔

@rustbot review

@rustbot author

@rustbot ready

This PR was rebased onto a different main commit. Here's a range-diff highlighting what actually changed.

Rebasing is a normal part of keeping PRs up to date, so no action is needed—this note is just to help reviewers.

This code currently compiles in stable rust:

struct Thing;
use Thing::{self as Alias};

If this code will stop compiling with this PR, then this PR needs a crater run.

Yes, we'll certainly run crater.

Let's perhaps split this into 2 steps.

• Replacing self overwriting with proper resolution.
• Relaxing the rules to allow trailing self in more contexts.

The first part may require a new deprecation lint for the use Struct::{self} cases, we'll see after running crater.
(All the test additions may go into the first part as usual.)
@rustbot author

@rustbot review

Could you limit this PR to just the first step from #152996 (comment)?
Remove the overwriting, add the ident.name == kw::SelfLower case to resolve_ident_in_module, and then do just the bare minimum to keep old code compiling while preventing any new code from compiling.
@rustbot author