11 files changed, 39 insertions, 41 deletions

diff --git a/crates/ra_assists/src/handlers/change_return_type_to_result.rs b/crates/ra_assists/src/handlers/change_return_type_to_result.rs
index 12018fc6a..167e162d8 100644
--- a/crates/ra_assists/src/handlers/change_return_type_to_result.rs
+++ b/crates/ra_assists/src/handlers/change_return_type_to_result.rs
@@ -22,7 +22,7 @@ pub(crate) fn change_return_type_to_result(acc: &mut Assists, ctx: &AssistContex
     // FIXME: extend to lambdas as well
     let fn_def = ret_type.syntax().parent().and_then(ast::Fn::cast)?;
 
-    let type_ref = &ret_type.type_ref()?;
+    let type_ref = &ret_type.ty()?;
     let ret_type_str = type_ref.syntax().text().to_string();
     let first_part_ret_type = ret_type_str.splitn(2, '<').next();
     if let Some(ret_type_first_part) = first_part_ret_type {
diff --git a/crates/ra_assists/src/handlers/generate_from_impl_for_enum.rs b/crates/ra_assists/src/handlers/generate_from_impl_for_enum.rs
index 5b282a30a..9da23640a 100644
--- a/crates/ra_assists/src/handlers/generate_from_impl_for_enum.rs
+++ b/crates/ra_assists/src/handlers/generate_from_impl_for_enum.rs
@@ -32,7 +32,7 @@ pub(crate) fn generate_from_impl_for_enum(acc: &mut Assists, ctx: &AssistContext
     if field_list.fields().count() != 1 {
         return None;
     }
-    let field_type = field_list.fields().next()?.type_ref()?;
+    let field_type = field_list.fields().next()?.ty()?;
     let path = match field_type {
         ast::TypeRef::PathType(it) => it,
         _ => return None,
diff --git a/crates/ra_hir_def/src/adt.rs b/crates/ra_hir_def/src/adt.rs
index f8523d03f..6cb56a1cd 100644
--- a/crates/ra_hir_def/src/adt.rs
+++ b/crates/ra_hir_def/src/adt.rs
@@ -234,7 +234,7 @@ fn lower_struct(
                     || Either::Left(fd.clone()),
                     || FieldData {
                         name: Name::new_tuple_field(i),
-                        type_ref: TypeRef::from_ast_opt(&ctx, fd.type_ref()),
+                        type_ref: TypeRef::from_ast_opt(&ctx, fd.ty()),
                         visibility: RawVisibility::from_ast(db, ast.with_value(fd.visibility())),
                     },
                 );
diff --git a/crates/ra_hir_def/src/body/lower.rs b/crates/ra_hir_def/src/body/lower.rs
index 288ca76c3..827ced4ad 100644
--- a/crates/ra_hir_def/src/body/lower.rs
+++ b/crates/ra_hir_def/src/body/lower.rs
@@ -432,7 +432,7 @@ impl ExprCollector<'_> {
             }
             ast::Expr::CastExpr(e) => {
                 let expr = self.collect_expr_opt(e.expr());
-                let type_ref = TypeRef::from_ast_opt(&self.ctx(), e.type_ref());
+                let type_ref = TypeRef::from_ast_opt(&self.ctx(), e.ty());
                 self.alloc_expr(Expr::Cast { expr, type_ref }, syntax_ptr)
             }
             ast::Expr::RefExpr(e) => {
@@ -471,10 +471,8 @@ impl ExprCollector<'_> {
                         arg_types.push(type_ref);
                     }
                 }
-                let ret_type = e
-                    .ret_type()
-                    .and_then(|r| r.type_ref())
-                    .map(|it| TypeRef::from_ast(&self.ctx(), it));
+                let ret_type =
+                    e.ret_type().and_then(|r| r.ty()).map(|it| TypeRef::from_ast(&self.ctx(), it));
                 let body = self.collect_expr_opt(e.body());
                 self.alloc_expr(Expr::Lambda { args, arg_types, ret_type, body }, syntax_ptr)
             }
diff --git a/crates/ra_hir_def/src/item_tree/lower.rs b/crates/ra_hir_def/src/item_tree/lower.rs
index f0ced1f79..feb31579e 100644
--- a/crates/ra_hir_def/src/item_tree/lower.rs
+++ b/crates/ra_hir_def/src/item_tree/lower.rs
@@ -228,7 +228,7 @@ impl Ctx {
     fn lower_tuple_field(&mut self, idx: usize, field: &ast::TupleField) -> Field {
         let name = Name::new_tuple_field(idx);
         let visibility = self.lower_visibility(field);
-        let type_ref = self.lower_type_ref_opt(field.type_ref());
+        let type_ref = self.lower_type_ref_opt(field.ty());
         let res = Field { name, type_ref, visibility };
         res
     }
@@ -317,7 +317,7 @@ impl Ctx {
             }
         }
 
-        let ret_type = match func.ret_type().and_then(|rt| rt.type_ref()) {
+        let ret_type = match func.ret_type().and_then(|rt| rt.ty()) {
             Some(type_ref) => TypeRef::from_ast(&self.body_ctx, type_ref),
             _ => TypeRef::unit(),
         };
@@ -352,7 +352,7 @@ impl Ctx {
         type_alias: &ast::TypeAlias,
     ) -> Option<FileItemTreeId<TypeAlias>> {
         let name = type_alias.name()?.as_name();
-        let type_ref = type_alias.type_ref().map(|it| self.lower_type_ref(&it));
+        let type_ref = type_alias.ty().map(|it| self.lower_type_ref(&it));
         let visibility = self.lower_visibility(type_alias);
         let bounds = self.lower_type_bounds(type_alias);
         let generic_params = self.lower_generic_params(GenericsOwner::TypeAlias, type_alias);
diff --git a/crates/ra_hir_def/src/path/lower.rs b/crates/ra_hir_def/src/path/lower.rs
index dfab15948..07d17916a 100644
--- a/crates/ra_hir_def/src/path/lower.rs
+++ b/crates/ra_hir_def/src/path/lower.rs
@@ -196,7 +196,7 @@ fn lower_generic_args_from_fn_path(
         args.push(arg);
     }
     if let Some(ret_type) = ret_type {
-        let type_ref = TypeRef::from_ast_opt(&ctx, ret_type.type_ref());
+        let type_ref = TypeRef::from_ast_opt(&ctx, ret_type.ty());
         bindings.push(AssociatedTypeBinding {
             name: name![Output],
             type_ref: Some(type_ref),
diff --git a/crates/ra_hir_def/src/type_ref.rs b/crates/ra_hir_def/src/type_ref.rs
index 4059302df..a5dc10eac 100644
--- a/crates/ra_hir_def/src/type_ref.rs
+++ b/crates/ra_hir_def/src/type_ref.rs
@@ -82,7 +82,7 @@ impl TypeRef {
     /// Converts an `ast::TypeRef` to a `hir::TypeRef`.
     pub(crate) fn from_ast(ctx: &LowerCtx, node: ast::TypeRef) -> Self {
         match node {
-            ast::TypeRef::ParenType(inner) => TypeRef::from_ast_opt(&ctx, inner.type_ref()),
+            ast::TypeRef::ParenType(inner) => TypeRef::from_ast_opt(&ctx, inner.ty()),
             ast::TypeRef::TupleType(inner) => {
                 TypeRef::Tuple(inner.fields().map(|it| TypeRef::from_ast(ctx, it)).collect())
             }
@@ -96,18 +96,18 @@ impl TypeRef {
                     .unwrap_or(TypeRef::Error)
             }
             ast::TypeRef::PointerType(inner) => {
-                let inner_ty = TypeRef::from_ast_opt(&ctx, inner.type_ref());
+                let inner_ty = TypeRef::from_ast_opt(&ctx, inner.ty());
                 let mutability = Mutability::from_mutable(inner.mut_token().is_some());
                 TypeRef::RawPtr(Box::new(inner_ty), mutability)
             }
             ast::TypeRef::ArrayType(inner) => {
-                TypeRef::Array(Box::new(TypeRef::from_ast_opt(&ctx, inner.type_ref())))
+                TypeRef::Array(Box::new(TypeRef::from_ast_opt(&ctx, inner.ty())))
             }
             ast::TypeRef::SliceType(inner) => {
-                TypeRef::Slice(Box::new(TypeRef::from_ast_opt(&ctx, inner.type_ref())))
+                TypeRef::Slice(Box::new(TypeRef::from_ast_opt(&ctx, inner.ty())))
             }
             ast::TypeRef::ReferenceType(inner) => {
-                let inner_ty = TypeRef::from_ast_opt(&ctx, inner.type_ref());
+                let inner_ty = TypeRef::from_ast_opt(&ctx, inner.ty());
                 let mutability = Mutability::from_mutable(inner.mut_token().is_some());
                 TypeRef::Reference(Box::new(inner_ty), mutability)
             }
@@ -115,7 +115,7 @@ impl TypeRef {
             ast::TypeRef::FnPointerType(inner) => {
                 let ret_ty = inner
                     .ret_type()
-                    .and_then(|rt| rt.type_ref())
+                    .and_then(|rt| rt.ty())
                     .map(|it| TypeRef::from_ast(ctx, it))
                     .unwrap_or_else(|| TypeRef::Tuple(Vec::new()));
                 let mut is_varargs = false;
@@ -132,7 +132,7 @@ impl TypeRef {
                 TypeRef::Fn(params, is_varargs)
             }
             // for types are close enough for our purposes to the inner type for now...
-            ast::TypeRef::ForType(inner) => TypeRef::from_ast_opt(&ctx, inner.type_ref()),
+            ast::TypeRef::ForType(inner) => TypeRef::from_ast_opt(&ctx, inner.ty()),
             ast::TypeRef::ImplTraitType(inner) => {
                 TypeRef::ImplTrait(type_bounds_from_ast(ctx, inner.type_bound_list()))
             }
diff --git a/crates/ra_ide/src/display.rs b/crates/ra_ide/src/display.rs
index 3efca0649..fd42aa435 100644
--- a/crates/ra_ide/src/display.rs
+++ b/crates/ra_ide/src/display.rs
@@ -44,7 +44,7 @@ pub(crate) fn function_declaration(node: &ast::Fn) -> String {
         format_to!(buf, "{}", param_list);
     }
     if let Some(ret_type) = node.ret_type() {
-        if ret_type.type_ref().is_some() {
+        if ret_type.ty().is_some() {
             format_to!(buf, " {}", ret_type);
         }
     }
diff --git a/crates/ra_ide/src/file_structure.rs b/crates/ra_ide/src/file_structure.rs
index 22cf8637a..91765140a 100644
--- a/crates/ra_ide/src/file_structure.rs
+++ b/crates/ra_ide/src/file_structure.rs
@@ -125,7 +125,7 @@ fn structure_node(node: &SyntaxNode) -> Option<StructureNode> {
             ast::Variant(it) => decl(it),
             ast::Trait(it) => decl(it),
             ast::Module(it) => decl(it),
-            ast::TypeAlias(it) => decl_with_type_ref(&it, it.type_ref()),
+            ast::TypeAlias(it) => decl_with_type_ref(&it, it.ty()),
             ast::RecordField(it) => decl_with_type_ref(&it, it.ty()),
             ast::Const(it) => decl_with_type_ref(&it, it.ty()),
             ast::Static(it) => decl_with_type_ref(&it, it.ty()),
diff --git a/crates/ra_syntax/src/ast/generated/nodes.rs b/crates/ra_syntax/src/ast/generated/nodes.rs
index 207826979..4306efe13 100644
--- a/crates/ra_syntax/src/ast/generated/nodes.rs
+++ b/crates/ra_syntax/src/ast/generated/nodes.rs
@@ -198,7 +198,7 @@ impl TypeAlias {
     pub fn default_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![default]) }
     pub fn type_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![type]) }
     pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
-    pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
+    pub fn ty(&self) -> Option<TypeRef> { support::child(&self.syntax) }
     pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -333,7 +333,7 @@ pub struct RetType {
 }
 impl RetType {
     pub fn thin_arrow_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![->]) }
-    pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
+    pub fn ty(&self) -> Option<TypeRef> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct WhereClause {
@@ -425,7 +425,7 @@ pub struct TupleField {
 impl ast::AttrsOwner for TupleField {}
 impl ast::VisibilityOwner for TupleField {}
 impl TupleField {
-    pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
+    pub fn ty(&self) -> Option<TypeRef> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct VariantList {
@@ -525,7 +525,7 @@ pub struct ParenType {
 }
 impl ParenType {
     pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
-    pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
+    pub fn ty(&self) -> Option<TypeRef> { support::child(&self.syntax) }
     pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -559,7 +559,7 @@ impl PointerType {
     pub fn star_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![*]) }
     pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
     pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
-    pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
+    pub fn ty(&self) -> Option<TypeRef> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ArrayType {
@@ -567,7 +567,7 @@ pub struct ArrayType {
 }
 impl ArrayType {
     pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
-    pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
+    pub fn ty(&self) -> Option<TypeRef> { support::child(&self.syntax) }
     pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
     pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
@@ -578,7 +578,7 @@ pub struct SliceType {
 }
 impl SliceType {
     pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
-    pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
+    pub fn ty(&self) -> Option<TypeRef> { support::child(&self.syntax) }
     pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -591,7 +591,7 @@ impl ReferenceType {
         support::token(&self.syntax, T![lifetime])
     }
     pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
-    pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
+    pub fn ty(&self) -> Option<TypeRef> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct PlaceholderType {
@@ -618,7 +618,7 @@ pub struct ForType {
 impl ForType {
     pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) }
     pub fn generic_param_list(&self) -> Option<GenericParamList> { support::child(&self.syntax) }
-    pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
+    pub fn ty(&self) -> Option<TypeRef> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ImplTraitType {
@@ -882,7 +882,7 @@ impl ast::AttrsOwner for CastExpr {}
 impl CastExpr {
     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
     pub fn as_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![as]) }
-    pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
+    pub fn ty(&self) -> Option<TypeRef> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct RefExpr {
diff --git a/xtask/src/codegen/rust.ungram b/xtask/src/codegen/rust.ungram
index e09bc875a..375df301f 100644
--- a/xtask/src/codegen/rust.ungram
+++ b/xtask/src/codegen/rust.ungram
@@ -72,11 +72,11 @@ Param =
   )
 
 RetType =
-  '->' TypeRef
+  '->' ty:TypeRef
 
 TypeAlias =
   Attr* Visibility? 'default'? 'type' Name GenericParamList? (':' TypeBoundList?)? WhereClause?
-  '=' TypeRef ';'
+  '=' ty:TypeRef ';'
 
 Struct =
   Attr* Visibility? 'struct' Name GenericParamList? (
@@ -94,7 +94,7 @@ TupleFieldList =
   '(' fields:(TupleField (',' TupleField)* ','?)? ')'
 
 TupleField =
-  Attr* Visibility? TypeRef
+  Attr* Visibility? ty:TypeRef
 
 FieldList =
   RecordFieldList
@@ -184,7 +184,7 @@ Attr =
   '#' '!'? '[' Path ('=' Literal | TokenTree)? ']'
 
 ParenType =
-  '(' TypeRef ')'
+  '(' ty:TypeRef ')'
 
 TupleType =
   '(' fields:TypeRef* ')'
@@ -196,16 +196,16 @@ PathType =
   Path
 
 PointerType =
-  '*' ('const' | 'mut') TypeRef
+  '*' ('const' | 'mut') ty:TypeRef
 
 ArrayType =
-  '[' TypeRef ';' Expr ']'
+  '[' ty:TypeRef ';' Expr ']'
 
 SliceType =
-  '[' TypeRef ']'
+  '[' ty:TypeRef ']'
 
 ReferenceType =
-  '&' 'lifetime'? 'mut'? TypeRef
+  '&' 'lifetime'? 'mut'? ty:TypeRef
 
 PlaceholderType =
    '_'
@@ -214,7 +214,7 @@ FnPointerType =
    Abi 'unsafe'? 'fn' ParamList RetType?
 
 ForType =
-   'for' GenericParamList TypeRef
+   'for' GenericParamList ty:TypeRef
 
 ImplTraitType =
   'impl' TypeBoundList
@@ -302,7 +302,7 @@ TryExpr =
   Attr* Expr '?'
 
 CastExpr =
-  Attr* Expr 'as' TypeRef
+  Attr* Expr 'as' ty:TypeRef
 
 RefExpr =
   Attr* '&' ('raw' | 'mut' | 'const') Expr