Merge #5618

5618: Rename TypeRef -> Type r=matklad a=matklad

The TypeRef name comes from IntelliJ days, where you often have both
type *syntax* as well as *semantical* representation of types in
scope. And naming both Type is confusing.

In rust-analyzer however, we use ast types as `ast::Type`, and have
many more semantic counterparts to ast types, so avoiding name clash
here is just confusing.



bors r+
🤖

Co-authored-by: Aleksey Kladov <aleksey.kladov@gmail.com>

Author: bors[bot]

crates/ra_assists/src/ast_transform.rs

@@ -32,7 +32,7 @@ impl<'a> AstTransform<'a> for NullTransformer {
 
 pub struct SubstituteTypeParams<'a> {
     source_scope: &'a SemanticsScope<'a>,
-    substs: FxHashMap<hir::TypeParam, ast::TypeRef>,
+    substs: FxHashMap<hir::TypeParam, ast::Type>,
     previous: Box<dyn AstTransform<'a> + 'a>,
 }
 
@@ -80,17 +80,17 @@ impl<'a> SubstituteTypeParams<'a> {
 
         // FIXME: It would probably be nicer if we could get this via HIR (i.e. get the
         // trait ref, and then go from the types in the substs back to the syntax)
-        fn get_syntactic_substs(impl_def: ast::Impl) -> Option<Vec<ast::TypeRef>> {
+        fn get_syntactic_substs(impl_def: ast::Impl) -> Option<Vec<ast::Type>> {
             let target_trait = impl_def.target_trait()?;
             let path_type = match target_trait {
-                ast::TypeRef::PathType(path) => path,
+                ast::Type::PathType(path) => path,
                 _ => return None,
             };
             let type_arg_list = path_type.path()?.segment()?.type_arg_list()?;
             let mut result = Vec::new();
             for type_arg in type_arg_list.type_args() {
                 let type_arg: ast::TypeArg = type_arg;
-                result.push(type_arg.type_ref()?);
+                result.push(type_arg.ty()?);
             }
             Some(result)
         }
@@ -99,9 +99,9 @@ impl<'a> SubstituteTypeParams<'a> {
         &self,
         node: &ra_syntax::SyntaxNode,
     ) -> Option<ra_syntax::SyntaxNode> {
-        let type_ref = ast::TypeRef::cast(node.clone())?;
+        let type_ref = ast::Type::cast(node.clone())?;
         let path = match &type_ref {
-            ast::TypeRef::PathType(path_type) => path_type.path()?,
+            ast::Type::PathType(path_type) => path_type.path()?,
             _ => return None,
         };
         // FIXME: use `hir::Path::from_src` instead.

crates/ra_assists/src/handlers/generate_from_impl_for_enum.rs

@@ -34,7 +34,7 @@ pub(crate) fn generate_from_impl_for_enum(acc: &mut Assists, ctx: &AssistContext
     }
     let field_type = field_list.fields().next()?.ty()?;
     let path = match field_type {
-        ast::TypeRef::PathType(it) => it,
+        ast::Type::PathType(it) => it,
         _ => return None,
     };
 

crates/ra_assists/src/handlers/introduce_named_lifetime.rs

@@ -68,7 +68,7 @@ fn generate_fn_def_assist(
         let fn_params_without_lifetime: Vec<_> = param_list
             .params()
             .filter_map(|param| match param.ty() {
-                Some(ast::TypeRef::ReferenceType(ascribed_type))
+                Some(ast::Type::ReferenceType(ascribed_type))
                     if ascribed_type.lifetime_token() == None =>
                 {
                     Some(ascribed_type.amp_token()?.text_range().end())

crates/ra_hir_def/src/generics.rs

@@ -253,7 +253,7 @@ impl GenericParams {
 
     fn fill_where_predicates(&mut self, lower_ctx: &LowerCtx, where_clause: ast::WhereClause) {
         for pred in where_clause.predicates() {
-            let type_ref = match pred.type_ref() {
+            let type_ref = match pred.ty() {
                 Some(type_ref) => type_ref,
                 None => continue,
             };

crates/ra_hir_def/src/item_tree/lower.rs

@@ -648,10 +648,10 @@ impl Ctx {
         self.data().vis.alloc(vis)
     }
 
-    fn lower_type_ref(&self, type_ref: &ast::TypeRef) -> TypeRef {
+    fn lower_type_ref(&self, type_ref: &ast::Type) -> TypeRef {
         TypeRef::from_ast(&self.body_ctx, type_ref.clone())
     }
-    fn lower_type_ref_opt(&self, type_ref: Option<ast::TypeRef>) -> TypeRef {
+    fn lower_type_ref_opt(&self, type_ref: Option<ast::Type>) -> TypeRef {
         type_ref.map(|ty| self.lower_type_ref(&ty)).unwrap_or(TypeRef::Error)
     }
 

crates/ra_hir_def/src/path/lower.rs

@@ -152,7 +152,7 @@ pub(super) fn lower_generic_args(
 ) -> Option<GenericArgs> {
     let mut args = Vec::new();
     for type_arg in node.type_args() {
-        let type_ref = TypeRef::from_ast_opt(lower_ctx, type_arg.type_ref());
+        let type_ref = TypeRef::from_ast_opt(lower_ctx, type_arg.ty());
         args.push(GenericArg::Type(type_ref));
     }
     // lifetimes ignored for now
@@ -161,7 +161,7 @@ pub(super) fn lower_generic_args(
         let assoc_type_arg: ast::AssocTypeArg = assoc_type_arg;
         if let Some(name_ref) = assoc_type_arg.name_ref() {
             let name = name_ref.as_name();
-            let type_ref = assoc_type_arg.type_ref().map(|it| TypeRef::from_ast(lower_ctx, it));
+            let type_ref = assoc_type_arg.ty().map(|it| TypeRef::from_ast(lower_ctx, it));
             let bounds = if let Some(l) = assoc_type_arg.type_bound_list() {
                 l.bounds().map(|it| TypeBound::from_ast(lower_ctx, it)).collect()
             } else {

crates/ra_hir_def/src/type_ref.rs

@@ -80,39 +80,39 @@ pub enum TypeBound {
 
 impl TypeRef {
     /// Converts an `ast::TypeRef` to a `hir::TypeRef`.
-    pub(crate) fn from_ast(ctx: &LowerCtx, node: ast::TypeRef) -> Self {
+    pub(crate) fn from_ast(ctx: &LowerCtx, node: ast::Type) -> Self {
         match node {
-            ast::TypeRef::ParenType(inner) => TypeRef::from_ast_opt(&ctx, inner.ty()),
-            ast::TypeRef::TupleType(inner) => {
+            ast::Type::ParenType(inner) => TypeRef::from_ast_opt(&ctx, inner.ty()),
+            ast::Type::TupleType(inner) => {
                 TypeRef::Tuple(inner.fields().map(|it| TypeRef::from_ast(ctx, it)).collect())
             }
-            ast::TypeRef::NeverType(..) => TypeRef::Never,
-            ast::TypeRef::PathType(inner) => {
+            ast::Type::NeverType(..) => TypeRef::Never,
+            ast::Type::PathType(inner) => {
                 // FIXME: Use `Path::from_src`
                 inner
                     .path()
                     .and_then(|it| ctx.lower_path(it))
                     .map(TypeRef::Path)
                     .unwrap_or(TypeRef::Error)
             }
-            ast::TypeRef::PointerType(inner) => {
+            ast::Type::PointerType(inner) => {
                 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) => {
+            ast::Type::ArrayType(inner) => {
                 TypeRef::Array(Box::new(TypeRef::from_ast_opt(&ctx, inner.ty())))
             }
-            ast::TypeRef::SliceType(inner) => {
+            ast::Type::SliceType(inner) => {
                 TypeRef::Slice(Box::new(TypeRef::from_ast_opt(&ctx, inner.ty())))
             }
-            ast::TypeRef::ReferenceType(inner) => {
+            ast::Type::ReferenceType(inner) => {
                 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)
             }
-            ast::TypeRef::PlaceholderType(_inner) => TypeRef::Placeholder,
-            ast::TypeRef::FnPointerType(inner) => {
+            ast::Type::PlaceholderType(_inner) => TypeRef::Placeholder,
+            ast::Type::FnPointerType(inner) => {
                 let ret_ty = inner
                     .ret_type()
                     .and_then(|rt| rt.ty())
@@ -132,17 +132,17 @@ 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.ty()),
-            ast::TypeRef::ImplTraitType(inner) => {
+            ast::Type::ForType(inner) => TypeRef::from_ast_opt(&ctx, inner.ty()),
+            ast::Type::ImplTraitType(inner) => {
                 TypeRef::ImplTrait(type_bounds_from_ast(ctx, inner.type_bound_list()))
             }
-            ast::TypeRef::DynTraitType(inner) => {
+            ast::Type::DynTraitType(inner) => {
                 TypeRef::DynTrait(type_bounds_from_ast(ctx, inner.type_bound_list()))
             }
         }
     }
 
-    pub(crate) fn from_ast_opt(ctx: &LowerCtx, node: Option<ast::TypeRef>) -> Self {
+    pub(crate) fn from_ast_opt(ctx: &LowerCtx, node: Option<ast::Type>) -> Self {
         if let Some(node) = node {
             TypeRef::from_ast(ctx, node)
         } else {

crates/ra_ide/src/display/short_label.rs

@@ -77,7 +77,7 @@ impl ShortLabel for ast::Variant {
     }
 }
 
-fn short_label_from_ty<T>(node: &T, ty: Option<ast::TypeRef>, prefix: &str) -> Option<String>
+fn short_label_from_ty<T>(node: &T, ty: Option<ast::Type>, prefix: &str) -> Option<String>
 where
     T: NameOwner + VisibilityOwner,
 {

crates/ra_ide/src/file_structure.rs

@@ -57,7 +57,7 @@ fn structure_node(node: &SyntaxNode) -> Option<StructureNode> {
 
     fn decl_with_type_ref<N: NameOwner + AttrsOwner>(
         node: &N,
-        type_ref: Option<ast::TypeRef>,
+        type_ref: Option<ast::Type>,
     ) -> Option<StructureNode> {
         let detail = type_ref.map(|type_ref| {
             let mut detail = String::new();

crates/ra_ide/src/references/rename.rs

@@ -157,7 +157,7 @@ fn rename_to_self(
     }
     let first_param = params.params().next()?;
     let mutable = match first_param.ty() {
-        Some(ast::TypeRef::ReferenceType(rt)) => rt.mut_token().is_some(),
+        Some(ast::Type::ReferenceType(rt)) => rt.mut_token().is_some(),
         _ => return None, // not renaming other types
     };
 
@@ -194,7 +194,7 @@ fn text_edit_from_self_param(
     new_name: &str,
 ) -> Option<TextEdit> {
     fn target_type_name(impl_def: &ast::Impl) -> Option<String> {
-        if let Some(ast::TypeRef::PathType(p)) = impl_def.target_type() {
+        if let Some(ast::Type::PathType(p)) = impl_def.target_type() {
             return Some(p.path()?.segment()?.name_ref()?.text().to_string());
         }
         None