Method grammar incomplete/wrong

[gomain]

The section on methods states this grammar:

Method :
   [FunctionQualifiers] fn [IDENTIFIER] [Generics]^?
      ( SelfParam (, [FunctionParam])^* ,^? )
      [FunctionReturnType]^? [WhereClause]^?
      [BlockExpression]

SelfParam :
   [OuterAttribute]^* ( ShorthandSelf | TypedSelf )

ShorthandSelf :
   (& | & [Lifetime])^? mut^? self

TypedSelf :
   mut^? self : [Type]

and then elaborates that [Type] is limited to the following..

P = &'lt S | &'lt mut S | Box<S> | Rc<S> | Arc<S> | Pin<P>
S = Self | P

My thoughts... Why use, the nonterminal, Type in the rule of TypedSelf? It is clear that only a small subset of Type is allowed here. Suggestion...

TypedSelf :
   mut^? self : [SelfType]
SelfType :
   (& | & [Lifetime])^? mut^? [Self] | Box<[Self]> | Rc<[Self]> | Arc<[Self]> | Pin<[SelfType]>
Self :
   Self | [SelfType]

then in the example there is this

impl Example {
    fn via_projection(self: <Example as Trait>::Output) {}
}

which was not mentioned in the grammar nor is accepted syntax. Should be removed?

[ehuss]

The grammar describes the syntax of the language, which corresponds to how it is parsed into an AST. This is significant because macros work with the AST. Semantic validation is done later, such as validating the self type. In this example, a macro could accept any type in that position, and that would be valid Rust, such as:

#[cfg(FALSE)]
fn foo(self: ArbitraryThing) {}

[ehuss]

I'm going to close this, as the grammar is defined as intended. The reference could definitely make this a little clearer, and I opened #916 to track that.