miss a method to access all `PathType` in `PathSegment`

[Young-Flash]

There are only pub fn path_type(&self) -> Option<PathType> for PathSegment, which only return the first PathType, but there maybe more than one PathType in a PathSegment, take <i32 as std::ops::Add> for example, the AST of it is as the following:

PATH_SEGMENT@48..70
  L_ANGLE@48..49 "<"
  PATH_TYPE@49..52
    ... // i32
  WHITESPACE@52..53 " "
  AS_KW@53..55 "as"
  WHITESPACE@55..56 " "
  PATH_TYPE@56..69
    ... // std::ops::Add
  R_ANGLE@69..70 ">"

So I think there can make a pub fn path_types(&self) -> Vec<PathType> { support::children(&self.syntax).collect() } for PathSegment to access all PathType.

[Veykril]

Interesting, our grammar is also wrong here

rust-analyzer/crates/syntax/rust.ungram

Line 39 in d6afb4f

| '<' PathType ('as' PathType)? '>'

That should be

| '<' Type ('as' PathType)? '>'

and then we should implement the path type accessor manually given the potential overlap, somewhat similar to

rust-analyzer/crates/syntax/src/ast/node_ext.rs

Lines 332 to 362 in d6afb4f

	impl ast::Impl {
	pub fn self_ty(&self) -> Option<ast::Type> {
	match self.target() {
	(Some(t), None) | (_, Some(t)) => Some(t),
	_ => None,
	}
	}
	pub fn trait_(&self) -> Option<ast::Type> {
	match self.target() {
	(Some(t), Some(_)) => Some(t),
	_ => None,
	}
	}
	fn target(&self) -> (Option<ast::Type>, Option<ast::Type>) {
	let mut types = support::children(self.syntax());
	let first = types.next();
	let second = types.next();
	(first, second)
	}
	pub fn for_trait_name_ref(name_ref: &ast::NameRef) -> Option<ast::Impl> {
	let this = name_ref.syntax().ancestors().find_map(ast::Impl::cast)?;
	if this.trait_()?.syntax().text_range().start() == name_ref.syntax().text_range().start() {
	Some(this)
	} else {
	None
	}
	}
	}

[Young-Flash]

Should we modify the syntax tree structure of PathSegment (seems a breaking change)? search the codebase but can't figure out where parse the i32 of <i32 as std::ops::Add> into a PathType, any suggestion?

According to PathSegment = ... | '<' Type ('as' PathType)? '>', there should be only one PathType within a PathSegment, right?
If so, can we just simplely make PathType accessor as (this is what I do here basically):

pub fn path_type(&self) -> Option<PathType> { 
    support::children(&self.syntax).last()
}

fn path_type has no usage in the codebase currently, so it will not raise breaking change.

[Veykril]

The parser already parses a Type instead of a PathType, so it's just that the grammar is wrong which we need to fix up. The reason why we can't just make a path_type accessor like you say is that the Type in in the grammar rule could be a PathType as well, in which case the path_type accessor will yield the wrong one. That's why that special handling is required.

[Young-Flash]

@rustbot claim