Rename ast::ImplBlock -> ast::ImplDef

Author: matklad

crates/ra_assists/src/ast_transform.rs

@@ -40,9 +40,9 @@ impl<'a> SubstituteTypeParams<'a> {
         db: &'a RootDatabase,
         // FIXME: there's implicit invariant that `trait_` and  `source_scope` match...
         trait_: hir::Trait,
-        impl_block: ast::ImplBlock,
+        impl_def: ast::ImplDef,
     ) -> SubstituteTypeParams<'a> {
-        let substs = get_syntactic_substs(impl_block).unwrap_or_default();
+        let substs = get_syntactic_substs(impl_def).unwrap_or_default();
         let generic_def: hir::GenericDef = trait_.into();
         let substs_by_param: FxHashMap<_, _> = generic_def
             .params(db)
@@ -59,8 +59,8 @@ 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_block: ast::ImplBlock) -> Option<Vec<ast::TypeRef>> {
-            let target_trait = impl_block.target_trait()?;
+        fn get_syntactic_substs(impl_def: ast::ImplDef) -> Option<Vec<ast::TypeRef>> {
+            let target_trait = impl_def.target_trait()?;
             let path_type = match target_trait {
                 ast::TypeRef::PathType(path) => path,
                 _ => return None,

crates/ra_assists/src/handlers/add_missing_impl_members.rs

@@ -101,7 +101,7 @@ fn add_missing_impl_members_inner(
     label: &'static str,
 ) -> Option<Assist> {
     let _p = ra_prof::profile("add_missing_impl_members_inner");
-    let impl_node = ctx.find_node_at_offset::<ast::ImplBlock>()?;
+    let impl_node = ctx.find_node_at_offset::<ast::ImplDef>()?;
     let impl_item_list = impl_node.item_list()?;
 
     let trait_ = resolve_target_trait(&ctx.sema, &impl_node)?;
@@ -257,7 +257,7 @@ impl Foo for S {
     }
 
     #[test]
-    fn test_empty_impl_block() {
+    fn test_empty_impl_def() {
         check_assist(
             add_missing_impl_members,
             "
@@ -308,7 +308,7 @@ impl<U> Foo<U> for S {
     }
 
     #[test]
-    fn test_cursor_after_empty_impl_block() {
+    fn test_cursor_after_empty_impl_def() {
         check_assist(
             add_missing_impl_members,
             "

crates/ra_assists/src/handlers/add_new.rs

@@ -41,14 +41,14 @@ pub(crate) fn add_new(ctx: AssistCtx) -> Option<Assist> {
     };
 
     // Return early if we've found an existing new fn
-    let impl_block = find_struct_impl(&ctx, &strukt)?;
+    let impl_def = find_struct_impl(&ctx, &strukt)?;
 
     ctx.add_assist(AssistId("add_new"), "Add default constructor", |edit| {
         edit.target(strukt.syntax().text_range());
 
         let mut buf = String::with_capacity(512);
 
-        if impl_block.is_some() {
+        if impl_def.is_some() {
             buf.push('\n');
         }
 
@@ -71,10 +71,10 @@ pub(crate) fn add_new(ctx: AssistCtx) -> Option<Assist> {
 
         buf.push_str("} }");
 
-        let (start_offset, end_offset) = impl_block
-            .and_then(|impl_block| {
+        let (start_offset, end_offset) = impl_def
+            .and_then(|impl_def| {
                 buf.push('\n');
-                let start = impl_block
+                let start = impl_def
                     .syntax()
                     .descendants_with_tokens()
                     .find(|t| t.kind() == T!['{'])?
@@ -128,15 +128,15 @@ fn generate_impl_text(strukt: &ast::StructDef, code: &str) -> String {
 //
 // FIXME: change the new fn checking to a more semantic approach when that's more
 // viable (e.g. we process proc macros, etc)
-fn find_struct_impl(ctx: &AssistCtx, strukt: &ast::StructDef) -> Option<Option<ast::ImplBlock>> {
+fn find_struct_impl(ctx: &AssistCtx, strukt: &ast::StructDef) -> Option<Option<ast::ImplDef>> {
     let db = ctx.db;
     let module = strukt.syntax().ancestors().find(|node| {
         ast::Module::can_cast(node.kind()) || ast::SourceFile::can_cast(node.kind())
     })?;
 
     let struct_def = ctx.sema.to_def(strukt)?;
 
-    let block = module.descendants().filter_map(ast::ImplBlock::cast).find_map(|impl_blk| {
+    let block = module.descendants().filter_map(ast::ImplDef::cast).find_map(|impl_blk| {
         let blk = ctx.sema.to_def(&impl_blk)?;
 
         // FIXME: handle e.g. `struct S<T>; impl<U> S<U> {}`
@@ -164,7 +164,7 @@ fn find_struct_impl(ctx: &AssistCtx, strukt: &ast::StructDef) -> Option<Option<a
     Some(block)
 }
 
-fn has_new_fn(imp: &ast::ImplBlock) -> bool {
+fn has_new_fn(imp: &ast::ImplDef) -> bool {
     if let Some(il) = imp.item_list() {
         for item in il.impl_items() {
             if let ast::ImplItem::FnDef(f) = item {

crates/ra_assists/src/handlers/move_bounds.rs

@@ -37,7 +37,7 @@ pub(crate) fn move_bounds_to_where_clause(ctx: AssistCtx) -> Option<Assist> {
     let anchor: SyntaxElement = match parent.kind() {
         FN_DEF => ast::FnDef::cast(parent)?.body()?.syntax().clone().into(),
         TRAIT_DEF => ast::TraitDef::cast(parent)?.item_list()?.syntax().clone().into(),
-        IMPL_BLOCK => ast::ImplBlock::cast(parent)?.item_list()?.syntax().clone().into(),
+        IMPL_DEF => ast::ImplDef::cast(parent)?.item_list()?.syntax().clone().into(),
         ENUM_DEF => ast::EnumDef::cast(parent)?.variant_list()?.syntax().clone().into(),
         STRUCT_DEF => parent
             .children_with_tokens()

crates/ra_assists/src/utils.rs

@@ -13,14 +13,14 @@ pub use insert_use::insert_use_statement;
 
 pub fn get_missing_impl_items(
     sema: &Semantics<RootDatabase>,
-    impl_block: &ast::ImplBlock,
+    impl_def: &ast::ImplDef,
 ) -> Vec<hir::AssocItem> {
     // Names must be unique between constants and functions. However, type aliases
     // may share the same name as a function or constant.
     let mut impl_fns_consts = FxHashSet::default();
     let mut impl_type = FxHashSet::default();
 
-    if let Some(item_list) = impl_block.item_list() {
+    if let Some(item_list) = impl_def.item_list() {
         for item in item_list.impl_items() {
             match item {
                 ast::ImplItem::FnDef(f) => {
@@ -44,7 +44,7 @@ pub fn get_missing_impl_items(
         }
     }
 
-    resolve_target_trait(sema, impl_block).map_or(vec![], |target_trait| {
+    resolve_target_trait(sema, impl_def).map_or(vec![], |target_trait| {
         target_trait
             .items(sema.db)
             .iter()
@@ -65,9 +65,9 @@ pub fn get_missing_impl_items(
 
 pub(crate) fn resolve_target_trait(
     sema: &Semantics<RootDatabase>,
-    impl_block: &ast::ImplBlock,
+    impl_def: &ast::ImplDef,
 ) -> Option<hir::Trait> {
-    let ast_path = impl_block
+    let ast_path = impl_def
         .target_trait()
         .map(|it| it.syntax().clone())
         .and_then(ast::PathType::cast)?

crates/ra_hir/src/code_model.rs

@@ -229,8 +229,8 @@ impl Module {
             }
         }
 
-        for impl_block in self.impl_blocks(db) {
-            for item in impl_block.items(db) {
+        for impl_def in self.impl_defs(db) {
+            for item in impl_def.items(db) {
                 if let AssocItem::Function(f) = item {
                     f.diagnostics(db, sink);
                 }
@@ -243,9 +243,9 @@ impl Module {
         def_map[self.id.local_id].scope.declarations().map(ModuleDef::from).collect()
     }
 
-    pub fn impl_blocks(self, db: &impl DefDatabase) -> Vec<ImplBlock> {
+    pub fn impl_defs(self, db: &impl DefDatabase) -> Vec<ImplDef> {
         let def_map = db.crate_def_map(self.id.krate);
-        def_map[self.id.local_id].scope.impls().map(ImplBlock::from).collect()
+        def_map[self.id.local_id].scope.impls().map(ImplDef::from).collect()
     }
 
     pub(crate) fn with_module_id(self, module_id: LocalModuleId) -> Module {
@@ -686,7 +686,7 @@ pub enum AssocItem {
 }
 pub enum AssocItemContainer {
     Trait(Trait),
-    ImplBlock(ImplBlock),
+    ImplDef(ImplDef),
 }
 pub trait AsAssocItem {
     fn as_assoc_item(self, db: &impl DefDatabase) -> Option<AssocItem>;
@@ -736,7 +736,7 @@ impl AssocItem {
         };
         match container {
             AssocContainerId::TraitId(id) => AssocItemContainer::Trait(id.into()),
-            AssocContainerId::ImplId(id) => AssocItemContainer::ImplBlock(id.into()),
+            AssocContainerId::ImplId(id) => AssocItemContainer::ImplDef(id.into()),
             AssocContainerId::ContainerId(_) => panic!("invalid AssocItem"),
         }
     }
@@ -748,7 +748,7 @@ pub enum GenericDef {
     Adt(Adt),
     Trait(Trait),
     TypeAlias(TypeAlias),
-    ImplBlock(ImplBlock),
+    ImplDef(ImplDef),
     // enum variants cannot have generics themselves, but their parent enums
     // can, and this makes some code easier to write
     EnumVariant(EnumVariant),
@@ -760,7 +760,7 @@ impl_froms!(
     Adt(Struct, Enum, Union),
     Trait,
     TypeAlias,
-    ImplBlock,
+    ImplDef,
     EnumVariant,
     Const
 );
@@ -850,20 +850,20 @@ impl TypeParam {
     }
 }
 
-// FIXME: rename from `ImplBlock` to `Impl`
+// FIXME: rename from `ImplDef` to `Impl`
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct ImplBlock {
+pub struct ImplDef {
     pub(crate) id: ImplId,
 }
 
-impl ImplBlock {
-    pub fn all_in_crate(db: &impl HirDatabase, krate: Crate) -> Vec<ImplBlock> {
+impl ImplDef {
+    pub fn all_in_crate(db: &impl HirDatabase, krate: Crate) -> Vec<ImplDef> {
         let impls = db.impls_in_crate(krate.id);
         impls.all_impls().map(Self::from).collect()
     }
-    pub fn for_trait(db: &impl HirDatabase, krate: Crate, trait_: Trait) -> Vec<ImplBlock> {
+    pub fn for_trait(db: &impl HirDatabase, krate: Crate, trait_: Trait) -> Vec<ImplDef> {
         let impls = db.impls_in_crate(krate.id);
-        impls.lookup_impl_blocks_for_trait(trait_.id).map(Self::from).collect()
+        impls.lookup_impl_defs_for_trait(trait_.id).map(Self::from).collect()
     }
 
     pub fn target_trait(&self, db: &impl DefDatabase) -> Option<TypeRef> {
@@ -1077,7 +1077,7 @@ impl Type {
     }
 
     // This would be nicer if it just returned an iterator, but that runs into
-    // lifetime problems, because we need to borrow temp `CrateImplBlocks`.
+    // lifetime problems, because we need to borrow temp `CrateImplDefs`.
     pub fn iterate_impl_items<T>(
         self,
         db: &impl HirDatabase,
@@ -1087,8 +1087,8 @@ impl Type {
         for krate in self.ty.value.def_crates(db, krate.id)? {
             let impls = db.impls_in_crate(krate);
 
-            for impl_block in impls.lookup_impl_blocks(&self.ty.value) {
-                for &item in db.impl_data(impl_block).items.iter() {
+            for impl_def in impls.lookup_impl_defs(&self.ty.value) {
+                for &item in db.impl_data(impl_def).items.iter() {
                     if let Some(result) = callback(item.into()) {
                         return Some(result);
                     }
@@ -1196,7 +1196,7 @@ pub enum ScopeDef {
     ModuleDef(ModuleDef),
     MacroDef(MacroDef),
     GenericParam(TypeParam),
-    ImplSelfType(ImplBlock),
+    ImplSelfType(ImplDef),
     AdtSelfType(Adt),
     Local(Local),
     Unknown,

crates/ra_hir/src/from_id.rs

@@ -39,7 +39,7 @@ from_id![
     (hir_def::StaticId, crate::Static),
     (hir_def::ConstId, crate::Const),
     (hir_def::FunctionId, crate::Function),
-    (hir_def::ImplId, crate::ImplBlock),
+    (hir_def::ImplId, crate::ImplDef),
     (hir_def::TypeParamId, crate::TypeParam),
     (hir_expand::MacroDefId, crate::MacroDef)
 ];
@@ -145,7 +145,7 @@ impl From<GenericDef> for GenericDefId {
             GenericDef::Adt(it) => GenericDefId::AdtId(it.into()),
             GenericDef::Trait(it) => GenericDefId::TraitId(it.id),
             GenericDef::TypeAlias(it) => GenericDefId::TypeAliasId(it.id),
-            GenericDef::ImplBlock(it) => GenericDefId::ImplId(it.id),
+            GenericDef::ImplDef(it) => GenericDefId::ImplId(it.id),
             GenericDef::EnumVariant(it) => {
                 GenericDefId::EnumVariantId(EnumVariantId { parent: it.parent.id, local_id: it.id })
             }

crates/ra_hir/src/has_source.rs

@@ -9,7 +9,7 @@ use hir_def::{
 use ra_syntax::ast;
 
 use crate::{
-    db::DefDatabase, Const, Enum, EnumVariant, FieldSource, Function, ImplBlock, MacroDef, Module,
+    db::DefDatabase, Const, Enum, EnumVariant, FieldSource, Function, ImplDef, MacroDef, Module,
     Static, Struct, StructField, Trait, TypeAlias, TypeParam, Union,
 };
 
@@ -111,9 +111,9 @@ impl HasSource for MacroDef {
         }
     }
 }
-impl HasSource for ImplBlock {
-    type Ast = ast::ImplBlock;
-    fn source(self, db: &impl DefDatabase) -> InFile<ast::ImplBlock> {
+impl HasSource for ImplDef {
+    type Ast = ast::ImplDef;
+    fn source(self, db: &impl DefDatabase) -> InFile<ast::ImplDef> {
         self.id.lookup(db).source(db)
     }
 }

crates/ra_hir/src/lib.rs

@@ -41,7 +41,7 @@ pub use crate::{
     code_model::{
         Adt, AsAssocItem, AssocItem, AssocItemContainer, AttrDef, Const, Crate, CrateDependency,
         DefWithBody, Docs, Enum, EnumVariant, FieldSource, Function, GenericDef, HasAttrs,
-        HasVisibility, ImplBlock, Local, MacroDef, Module, ModuleDef, ScopeDef, Static, Struct,
+        HasVisibility, ImplDef, Local, MacroDef, Module, ModuleDef, ScopeDef, Static, Struct,
         StructField, Trait, Type, TypeAlias, TypeParam, Union, VariantDef,
     },
     has_source::HasSource,

crates/ra_hir/src/semantics.rs

@@ -262,7 +262,7 @@ to_def_impls![
     (crate::Enum, ast::EnumDef, enum_to_def),
     (crate::Union, ast::UnionDef, union_to_def),
     (crate::Trait, ast::TraitDef, trait_to_def),
-    (crate::ImplBlock, ast::ImplBlock, impl_to_def),
+    (crate::ImplDef, ast::ImplDef, impl_to_def),
     (crate::TypeAlias, ast::TypeAliasDef, type_alias_to_def),
     (crate::Const, ast::ConstDef, const_to_def),
     (crate::Static, ast::StaticDef, static_to_def),