Merge branch 'master' of github.com:rust-analyzer/rust-analyzer

Author: bnjjj

Cargo.lock

@@ -19,18 +19,6 @@ miniz_oxide.opt-level = 3
 incremental = true
 debug = 0 # Set this to 1 or 2 to get more useful backtraces in debugger.
 
-# Ideally, we would use `build-override` here, but some crates are also
-# needed at run-time and we end up compiling them twice.
-[profile.release.package]
-chalk-derive.opt-level = 0
-proc-macro2.opt-level = 0
-quote.opt-level = 0
-salsa-macros.opt-level = 0
-serde_derive.opt-level = 0
-syn.opt-level = 0
-tracing-attributes.opt-level = 0
-xtask.opt-level = 0
-
 [patch.'crates-io']
 # rowan = { path = "../rowan" }
 

Cargo.toml

@@ -324,23 +324,21 @@ pub struct Foo { pub bar: () }
 
     #[test]
     fn fix_visibility_of_enum_variant_field() {
-        check_assist(
+        // Enum variants, as well as their fields, always get the enum's visibility. In fact, rustc
+        // rejects any visibility specifiers on them, so this assist should never fire on them.
+        check_assist_not_applicable(
             fix_visibility,
             r"mod foo { pub enum Foo { Bar { bar: () } } }
               fn main() { foo::Foo::Bar { <|>bar: () }; } ",
-            r"mod foo { pub enum Foo { Bar { $0pub(crate) bar: () } } }
-              fn main() { foo::Foo::Bar { bar: () }; } ",
         );
-        check_assist(
+        check_assist_not_applicable(
             fix_visibility,
             r"
 //- /lib.rs
 mod foo;
 fn main() { foo::Foo::Bar { <|>bar: () }; }
 //- /foo.rs
 pub enum Foo { Bar { bar: () } }
-",
-            r"pub enum Foo { Bar { $0pub(crate) bar: () } }
 ",
         );
         check_assist_not_applicable(

crates/assists/src/handlers/fix_visibility.rs

@@ -186,6 +186,16 @@ impl_from!(
     for ModuleDef
 );
 
+impl From<VariantDef> for ModuleDef {
+    fn from(var: VariantDef) -> Self {
+        match var {
+            VariantDef::Struct(t) => Adt::from(t).into(),
+            VariantDef::Union(t) => Adt::from(t).into(),
+            VariantDef::EnumVariant(t) => t.into(),
+        }
+    }
+}
+
 impl ModuleDef {
     pub fn module(self, db: &dyn HirDatabase) -> Option<Module> {
         match self {
@@ -752,6 +762,13 @@ impl Function {
     pub fn diagnostics(self, db: &dyn HirDatabase, sink: &mut DiagnosticSink) {
         hir_ty::diagnostics::validate_body(db, self.id.into(), sink)
     }
+
+    /// Whether this function declaration has a definition.
+    ///
+    /// This is false in the case of required (not provided) trait methods.
+    pub fn has_body(self, db: &dyn HirDatabase) -> bool {
+        db.function_data(self.id).has_body
+    }
 }
 
 // Note: logically, this belongs to `hir_ty`, but we are not using it there yet.

crates/hir/src/code_model.rs

@@ -189,6 +189,10 @@ impl SourceToDefCtx<'_, '_> {
                         let def = self.type_alias_to_def(container.with_value(it))?;
                         def.into()
                     },
+                    ast::Variant(it) => {
+                        let def = self.enum_variant_to_def(container.with_value(it))?;
+                        VariantId::from(def).into()
+                    },
                     _ => continue,
                 }
             };

crates/hir/src/semantics/source_to_def.rs

@@ -14,7 +14,7 @@ use tt::{Delimiter, DelimiterKind, Leaf, Subtree, TokenTree};
 use crate::{
     body::{CfgExpander, LowerCtx},
     db::DefDatabase,
-    item_tree::{AttrOwner, Field, Fields, ItemTree, ModItem},
+    item_tree::{AttrOwner, Field, Fields, ItemTree, ModItem, RawVisibilityId},
     src::HasChildSource,
     src::HasSource,
     trace::Trace,
@@ -91,7 +91,7 @@ impl StructData {
         let cfg_options = db.crate_graph()[loc.container.module(db).krate].cfg_options.clone();
 
         let strukt = &item_tree[loc.id.value];
-        let variant_data = lower_fields(&item_tree, &cfg_options, &strukt.fields);
+        let variant_data = lower_fields(&item_tree, &cfg_options, &strukt.fields, None);
         Arc::new(StructData {
             name: strukt.name.clone(),
             variant_data: Arc::new(variant_data),
@@ -105,7 +105,7 @@ impl StructData {
         let cfg_options = db.crate_graph()[loc.container.module(db).krate].cfg_options.clone();
 
         let union = &item_tree[loc.id.value];
-        let variant_data = lower_fields(&item_tree, &cfg_options, &union.fields);
+        let variant_data = lower_fields(&item_tree, &cfg_options, &union.fields, None);
 
         Arc::new(StructData {
             name: union.name.clone(),
@@ -126,7 +126,8 @@ impl EnumData {
         for var_id in enum_.variants.clone() {
             if item_tree.attrs(var_id.into()).is_cfg_enabled(&cfg_options) {
                 let var = &item_tree[var_id];
-                let var_data = lower_fields(&item_tree, &cfg_options, &var.fields);
+                let var_data =
+                    lower_fields(&item_tree, &cfg_options, &var.fields, Some(enum_.visibility));
 
                 variants.alloc(EnumVariantData {
                     name: var.name.clone(),
@@ -296,13 +297,18 @@ fn lower_struct(
     }
 }
 
-fn lower_fields(item_tree: &ItemTree, cfg_options: &CfgOptions, fields: &Fields) -> VariantData {
+fn lower_fields(
+    item_tree: &ItemTree,
+    cfg_options: &CfgOptions,
+    fields: &Fields,
+    override_visibility: Option<RawVisibilityId>,
+) -> VariantData {
     match fields {
         Fields::Record(flds) => {
             let mut arena = Arena::new();
             for field_id in flds.clone() {
                 if item_tree.attrs(field_id.into()).is_cfg_enabled(cfg_options) {
-                    arena.alloc(lower_field(item_tree, &item_tree[field_id]));
+                    arena.alloc(lower_field(item_tree, &item_tree[field_id], override_visibility));
                 }
             }
             VariantData::Record(arena)
@@ -311,7 +317,7 @@ fn lower_fields(item_tree: &ItemTree, cfg_options: &CfgOptions, fields: &Fields)
             let mut arena = Arena::new();
             for field_id in flds.clone() {
                 if item_tree.attrs(field_id.into()).is_cfg_enabled(cfg_options) {
-                    arena.alloc(lower_field(item_tree, &item_tree[field_id]));
+                    arena.alloc(lower_field(item_tree, &item_tree[field_id], override_visibility));
                 }
             }
             VariantData::Tuple(arena)
@@ -320,10 +326,14 @@ fn lower_fields(item_tree: &ItemTree, cfg_options: &CfgOptions, fields: &Fields)
     }
 }
 
-fn lower_field(item_tree: &ItemTree, field: &Field) -> FieldData {
+fn lower_field(
+    item_tree: &ItemTree,
+    field: &Field,
+    override_visibility: Option<RawVisibilityId>,
+) -> FieldData {
     FieldData {
         name: field.name.clone(),
         type_ref: field.type_ref.clone(),
-        visibility: item_tree[field.visibility].clone(),
+        visibility: item_tree[override_visibility.unwrap_or(field.visibility)].clone(),
     }
 }

crates/hir_def/src/adt.rs

@@ -25,6 +25,7 @@ pub struct FunctionData {
     /// True if the first param is `self`. This is relevant to decide whether this
     /// can be called as a method.
     pub has_self_param: bool,
+    pub has_body: bool,
     pub is_unsafe: bool,
     pub is_varargs: bool,
     pub visibility: RawVisibility,
@@ -42,6 +43,7 @@ impl FunctionData {
             ret_type: func.ret_type.clone(),
             attrs: item_tree.attrs(ModItem::from(loc.id.value).into()).clone(),
             has_self_param: func.has_self_param,
+            has_body: func.has_body,
             is_unsafe: func.is_unsafe,
             is_varargs: func.is_varargs,
             visibility: item_tree[func.visibility].clone(),

crates/hir_def/src/data.rs

@@ -505,6 +505,7 @@ pub struct Function {
     pub visibility: RawVisibilityId,
     pub generic_params: GenericParamsId,
     pub has_self_param: bool,
+    pub has_body: bool,
     pub is_unsafe: bool,
     pub params: Box<[TypeRef]>,
     pub is_varargs: bool,

crates/hir_def/src/item_tree.rs

@@ -330,12 +330,15 @@ impl Ctx {
             ret_type
         };
 
+        let has_body = func.body().is_some();
+
         let ast_id = self.source_ast_id_map.ast_id(func);
         let mut res = Function {
             name,
             visibility,
             generic_params: GenericParamsId::EMPTY,
             has_self_param,
+            has_body,
             is_unsafe: func.unsafe_token().is_some(),
             params: params.into_boxed_slice(),
             is_varargs,