Merge #5594 #5604 #5605

5594: Update sysroot crates r=jonas-schievink a=lnicola



5604: Rename EnumVariant -> Variant r=matklad a=matklad



bors r+
🤖

5605: fmt r=matklad a=matklad



bors r+
🤖

Co-authored-by: Laurențiu Nicola <[email protected]>
Co-authored-by: Aleksey Kladov <[email protected]>

Author: 3 people

crates/ra_assists/src/handlers/add_missing_impl_members.rs

@@ -120,7 +120,7 @@ fn add_missing_impl_members_inner(
         match item {
             ast::AssocItem::Fn(def) => def.name(),
             ast::AssocItem::TypeAlias(def) => def.name(),
-            ast::AssocItem::ConstDef(def) => def.name(),
+            ast::AssocItem::Const(def) => def.name(),
             ast::AssocItem::MacroCall(_) => None,
         }
         .map(|it| it.text().clone())
@@ -131,7 +131,7 @@ fn add_missing_impl_members_inner(
         .map(|i| match i {
             hir::AssocItem::Function(i) => ast::AssocItem::Fn(i.source(ctx.db()).value),
             hir::AssocItem::TypeAlias(i) => ast::AssocItem::TypeAlias(i.source(ctx.db()).value),
-            hir::AssocItem::Const(i) => ast::AssocItem::ConstDef(i.source(ctx.db()).value),
+            hir::AssocItem::Const(i) => ast::AssocItem::Const(i.source(ctx.db()).value),
         })
         .filter(|t| def_name(&t).is_some())
         .filter(|t| match t {

crates/ra_assists/src/handlers/change_visibility.rs

@@ -1,7 +1,7 @@
 use ra_syntax::{
     ast::{self, NameOwner, VisibilityOwner},
     AstNode,
-    SyntaxKind::{CONST_DEF, ENUM, FN, MODULE, STATIC_DEF, STRUCT, TRAIT_DEF, VISIBILITY},
+    SyntaxKind::{CONST, ENUM, FN, MODULE, STATIC, STRUCT, TRAIT_DEF, VISIBILITY},
     T,
 };
 use test_utils::mark;
@@ -36,7 +36,7 @@ fn add_vis(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
 
     let (offset, target) = if let Some(keyword) = item_keyword {
         let parent = keyword.parent();
-        let def_kws = vec![CONST_DEF, STATIC_DEF, FN, MODULE, STRUCT, ENUM, TRAIT_DEF];
+        let def_kws = vec![CONST, STATIC, FN, MODULE, STRUCT, ENUM, TRAIT_DEF];
         // Parent is not a definition, can't add visibility
         if !def_kws.iter().any(|&def_kw| def_kw == parent.kind()) {
             return None;

crates/ra_assists/src/handlers/extract_struct_from_enum_variant.rs

@@ -31,7 +31,7 @@ pub(crate) fn extract_struct_from_enum_variant(
     acc: &mut Assists,
     ctx: &AssistContext,
 ) -> Option<()> {
-    let variant = ctx.find_node_at_offset::<ast::EnumVariant>()?;
+    let variant = ctx.find_node_at_offset::<ast::Variant>()?;
     let field_list = match variant.kind() {
         ast::StructKind::Tuple(field_list) => field_list,
         _ => return None,

crates/ra_assists/src/handlers/generate_from_impl_for_enum.rs

@@ -22,7 +22,7 @@ use crate::{utils::FamousDefs, AssistContext, AssistId, AssistKind, Assists};
 // }
 // ```
 pub(crate) fn generate_from_impl_for_enum(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
-    let variant = ctx.find_node_at_offset::<ast::EnumVariant>()?;
+    let variant = ctx.find_node_at_offset::<ast::Variant>()?;
     let variant_name = variant.name()?;
     let enum_name = variant.parent_enum().name()?;
     let field_list = match variant.kind() {
@@ -69,7 +69,7 @@ impl From<{0}> for {1} {{
 
 fn existing_from_impl(
     sema: &'_ hir::Semantics<'_, RootDatabase>,
-    variant: &ast::EnumVariant,
+    variant: &ast::Variant,
 ) -> Option<()> {
     let variant = sema.to_def(variant)?;
     let enum_ = variant.parent_enum(sema.db);

crates/ra_assists/src/utils.rs

@@ -78,7 +78,7 @@ pub fn get_missing_assoc_items(
                     }
                 }
 
-                ast::AssocItem::ConstDef(c) => {
+                ast::AssocItem::Const(c) => {
                     if let Some(n) = c.name() {
                         impl_fns_consts.insert(n.syntax().to_string());
                     }

crates/ra_hir/src/has_source.rs

@@ -75,8 +75,8 @@ impl HasSource for Enum {
     }
 }
 impl HasSource for EnumVariant {
-    type Ast = ast::EnumVariant;
-    fn source(self, db: &dyn HirDatabase) -> InFile<ast::EnumVariant> {
+    type Ast = ast::Variant;
+    fn source(self, db: &dyn HirDatabase) -> InFile<ast::Variant> {
         self.parent.id.child_source(db.upcast()).map(|map| map[self.id].clone())
     }
 }
@@ -87,14 +87,14 @@ impl HasSource for Function {
     }
 }
 impl HasSource for Const {
-    type Ast = ast::ConstDef;
-    fn source(self, db: &dyn HirDatabase) -> InFile<ast::ConstDef> {
+    type Ast = ast::Const;
+    fn source(self, db: &dyn HirDatabase) -> InFile<ast::Const> {
         self.id.lookup(db.upcast()).source(db.upcast())
     }
 }
 impl HasSource for Static {
-    type Ast = ast::StaticDef;
-    fn source(self, db: &dyn HirDatabase) -> InFile<ast::StaticDef> {
+    type Ast = ast::Static;
+    fn source(self, db: &dyn HirDatabase) -> InFile<ast::Static> {
         self.id.lookup(db.upcast()).source(db.upcast())
     }
 }

crates/ra_hir/src/semantics.rs

@@ -586,12 +586,12 @@ to_def_impls![
     (crate::Trait, ast::TraitDef, trait_to_def),
     (crate::ImplDef, ast::ImplDef, impl_to_def),
     (crate::TypeAlias, ast::TypeAlias, type_alias_to_def),
-    (crate::Const, ast::ConstDef, const_to_def),
-    (crate::Static, ast::StaticDef, static_to_def),
+    (crate::Const, ast::Const, const_to_def),
+    (crate::Static, ast::Static, static_to_def),
     (crate::Function, ast::Fn, fn_to_def),
     (crate::Field, ast::RecordField, record_field_to_def),
     (crate::Field, ast::TupleField, tuple_field_to_def),
-    (crate::EnumVariant, ast::EnumVariant, enum_variant_to_def),
+    (crate::EnumVariant, ast::Variant, enum_variant_to_def),
     (crate::TypeParam, ast::TypeParam, type_param_to_def),
     (crate::MacroDef, ast::MacroCall, macro_call_to_def), // this one is dubious, not all calls are macros
     (crate::Local, ast::BindPat, bind_pat_to_def),

crates/ra_hir/src/semantics/source_to_def.rs

@@ -83,10 +83,10 @@ impl SourceToDefCtx<'_, '_> {
     pub(super) fn union_to_def(&mut self, src: InFile<ast::Union>) -> Option<UnionId> {
         self.to_def(src, keys::UNION)
     }
-    pub(super) fn static_to_def(&mut self, src: InFile<ast::StaticDef>) -> Option<StaticId> {
+    pub(super) fn static_to_def(&mut self, src: InFile<ast::Static>) -> Option<StaticId> {
         self.to_def(src, keys::STATIC)
     }
-    pub(super) fn const_to_def(&mut self, src: InFile<ast::ConstDef>) -> Option<ConstId> {
+    pub(super) fn const_to_def(&mut self, src: InFile<ast::Const>) -> Option<ConstId> {
         self.to_def(src, keys::CONST)
     }
     pub(super) fn type_alias_to_def(&mut self, src: InFile<ast::TypeAlias>) -> Option<TypeAliasId> {
@@ -100,9 +100,9 @@ impl SourceToDefCtx<'_, '_> {
     }
     pub(super) fn enum_variant_to_def(
         &mut self,
-        src: InFile<ast::EnumVariant>,
+        src: InFile<ast::Variant>,
     ) -> Option<EnumVariantId> {
-        self.to_def(src, keys::ENUM_VARIANT)
+        self.to_def(src, keys::VARIANT)
     }
     pub(super) fn bind_pat_to_def(
         &mut self,
@@ -178,11 +178,11 @@ impl SourceToDefCtx<'_, '_> {
                         let def = self.union_to_def(container.with_value(it))?;
                         VariantId::from(def).into()
                     },
-                    ast::StaticDef(it) => {
+                    ast::Static(it) => {
                         let def = self.static_to_def(container.with_value(it))?;
                         DefWithBodyId::from(def).into()
                     },
-                    ast::ConstDef(it) => {
+                    ast::Const(it) => {
                         let def = self.const_to_def(container.with_value(it))?;
                         DefWithBodyId::from(def).into()
                     },
@@ -222,8 +222,8 @@ impl SourceToDefCtx<'_, '_> {
         for container in src.cloned().ancestors_with_macros(self.db.upcast()).skip(1) {
             let res: DefWithBodyId = match_ast! {
                 match (container.value) {
-                    ast::ConstDef(it) => self.const_to_def(container.with_value(it))?.into(),
-                    ast::StaticDef(it) => self.static_to_def(container.with_value(it))?.into(),
+                    ast::Const(it) => self.const_to_def(container.with_value(it))?.into(),
+                    ast::Static(it) => self.static_to_def(container.with_value(it))?.into(),
                     ast::Fn(it) => self.fn_to_def(container.with_value(it))?.into(),
                     _ => continue,
                 }

crates/ra_hir_def/src/adt.rs

@@ -112,7 +112,7 @@ impl EnumData {
 
 impl HasChildSource for EnumId {
     type ChildId = LocalEnumVariantId;
-    type Value = ast::EnumVariant;
+    type Value = ast::Variant;
     fn child_source(&self, db: &dyn DefDatabase) -> InFile<ArenaMap<Self::ChildId, Self::Value>> {
         let src = self.lookup(db).source(db);
         let mut trace = Trace::new_for_map();
@@ -123,7 +123,7 @@ impl HasChildSource for EnumId {
 
 fn lower_enum(
     db: &dyn DefDatabase,
-    trace: &mut Trace<EnumVariantData, ast::EnumVariant>,
+    trace: &mut Trace<EnumVariantData, ast::Variant>,
     ast: &InFile<ast::Enum>,
     module_id: ModuleId,
 ) {

crates/ra_hir_def/src/body/lower.rs

@@ -641,14 +641,14 @@ impl ExprCollector<'_> {
                             def.name(),
                         )
                     }
-                    ast::Item::ConstDef(def) => {
+                    ast::Item::Const(def) => {
                         let id = self.find_inner_item(&def)?;
                         (
                             ConstLoc { container: container.into(), id }.intern(self.db).into(),
                             def.name(),
                         )
                     }
-                    ast::Item::StaticDef(def) => {
+                    ast::Item::Static(def) => {
                         let id = self.find_inner_item(&def)?;
                         (StaticLoc { container, id }.intern(self.db).into(), def.name())
                     }