Self type to be used in impls.
Allows macros which operate on methods to do more, more easily without having to rebuild the concrete self type. Macros could use the literal self type like programmers do, but that requires extra machinery in the macro expansion code and extra work by the macro author.
Allows easier copy and pasting of method signatures from trait declarations to implementations.
Is more succinct where the self type is complex.
Motivation for doing this now
I'm hitting the macro problem in a side project. I wrote and hope to land the compiler code to make it work, but it is ugly and this is a much nicer solution. It is also really easy to implement, and since it is just a desugaring, it should not add any additional complexity to the compiler. Obviously, this should not block 1.0.
When used inside an impl,
Self is desugared during syntactic expansion to the
concrete type being implemented.
Self can be used anywhere the desugared type
could be used.
There are some advantages to being explicit about the self type where it is possible - clarity and fewer type aliases.
We could just force authors to use the concrete type as we do currently. This
would require macro expansion code to make available the concrete type (or the
whole impl AST) to macros working on methods. The macro author would then
extract/construct the self type and use it instead of