Merge commit '76633199f4316b9c659d4ec0c102774d693cd940' into sync-from-rust

Author: lnicola

crates/hir-def/src/import_map.rs

@@ -111,7 +111,11 @@ fn collect_import_map(db: &dyn DefDatabase, krate: CrateId) -> FxIndexMap<ItemIn
 
         let visible_items = mod_data.scope.entries().filter_map(|(name, per_ns)| {
             let per_ns = per_ns.filter_visibility(|vis| vis == Visibility::Public);
-            if per_ns.is_none() { None } else { Some((name, per_ns)) }
+            if per_ns.is_none() {
+                None
+            } else {
+                Some((name, per_ns))
+            }
         });
 
         for (name, per_ns) in visible_items {

crates/hir-ty/src/chalk_ext.rs

@@ -28,6 +28,7 @@ pub trait TyExt {
     fn is_unknown(&self) -> bool;
     fn contains_unknown(&self) -> bool;
     fn is_ty_var(&self) -> bool;
+    fn is_union(&self) -> bool;
 
     fn as_adt(&self) -> Option<(hir_def::AdtId, &Substitution)>;
     fn as_builtin(&self) -> Option<BuiltinType>;
@@ -96,6 +97,10 @@ impl TyExt for Ty {
         matches!(self.kind(Interner), TyKind::InferenceVar(_, _))
     }
 
+    fn is_union(&self) -> bool {
+        matches!(self.adt_id(Interner), Some(AdtId(hir_def::AdtId::UnionId(_))))
+    }
+
     fn as_adt(&self) -> Option<(hir_def::AdtId, &Substitution)> {
         match self.kind(Interner) {
             TyKind::Adt(AdtId(adt), parameters) => Some((*adt, parameters)),

crates/hir-ty/src/infer/closure.rs

@@ -735,6 +735,32 @@ impl InferenceContext<'_> {
         self.walk_expr(expr);
     }
 
+    fn restrict_precision_for_unsafe(&mut self) {
+        for capture in &mut self.current_captures {
+            let mut ty = self.table.resolve_completely(self.result[capture.place.local].clone());
+            if ty.as_raw_ptr().is_some() || ty.is_union() {
+                capture.kind = CaptureKind::ByRef(BorrowKind::Shared);
+                capture.place.projections.truncate(0);
+                continue;
+            }
+            for (i, p) in capture.place.projections.iter().enumerate() {
+                ty = p.projected_ty(
+                    ty,
+                    self.db,
+                    |_, _, _| {
+                        unreachable!("Closure field only happens in MIR");
+                    },
+                    self.owner.module(self.db.upcast()).krate(),
+                );
+                if ty.as_raw_ptr().is_some() || ty.is_union() {
+                    capture.kind = CaptureKind::ByRef(BorrowKind::Shared);
+                    capture.place.projections.truncate(i + 1);
+                    break;
+                }
+            }
+        }
+    }
+
     fn adjust_for_move_closure(&mut self) {
         for capture in &mut self.current_captures {
             if let Some(first_deref) =
@@ -924,6 +950,7 @@ impl InferenceContext<'_> {
                 self.result.mutated_bindings_in_closure.insert(item.place.local);
             }
         }
+        self.restrict_precision_for_unsafe();
         // closure_kind should be done before adjust_for_move_closure
         let closure_kind = self.closure_kind();
         match capture_by {

crates/hir/src/display.rs

@@ -1,6 +1,6 @@
 //! HirDisplay implementations for various hir types.
 use hir_def::{
-    data::adt::VariantData,
+    data::adt::{StructKind, VariantData},
     generics::{
         TypeOrConstParamData, TypeParamProvenance, WherePredicate, WherePredicateTypeTarget,
     },
@@ -163,7 +163,40 @@ impl HirDisplay for Struct {
         write!(f, "{}", self.name(f.db).display(f.db.upcast()))?;
         let def_id = GenericDefId::AdtId(AdtId::StructId(self.id));
         write_generic_params(def_id, f)?;
+
+        let variant_data = self.variant_data(f.db);
+        if let StructKind::Tuple = variant_data.kind() {
+            f.write_char('(')?;
+            let mut it = variant_data.fields().iter().peekable();
+
+            while let Some((id, _)) = it.next() {
+                let field = Field { parent: (*self).into(), id };
+                field.ty(f.db).hir_fmt(f)?;
+                if it.peek().is_some() {
+                    f.write_str(", ")?;
+                }
+            }
+
+            f.write_str(");")?;
+        }
+
         write_where_clause(def_id, f)?;
+
+        if let StructKind::Record = variant_data.kind() {
+            let fields = self.fields(f.db);
+            if fields.is_empty() {
+                f.write_str(" {}")?;
+            } else {
+                f.write_str(" {\n")?;
+                for field in self.fields(f.db) {
+                    f.write_str("    ")?;
+                    field.hir_fmt(f)?;
+                    f.write_str(",\n")?;
+                }
+                f.write_str("}")?;
+            }
+        }
+
         Ok(())
     }
 }
@@ -176,6 +209,18 @@ impl HirDisplay for Enum {
         let def_id = GenericDefId::AdtId(AdtId::EnumId(self.id));
         write_generic_params(def_id, f)?;
         write_where_clause(def_id, f)?;
+
+        let variants = self.variants(f.db);
+        if !variants.is_empty() {
+            f.write_str(" {\n")?;
+            for variant in variants {
+                f.write_str("    ")?;
+                variant.hir_fmt(f)?;
+                f.write_str(",\n")?;
+            }
+            f.write_str("}")?;
+        }
+
         Ok(())
     }
 }
@@ -188,6 +233,18 @@ impl HirDisplay for Union {
         let def_id = GenericDefId::AdtId(AdtId::UnionId(self.id));
         write_generic_params(def_id, f)?;
         write_where_clause(def_id, f)?;
+
+        let fields = self.fields(f.db);
+        if !fields.is_empty() {
+            f.write_str(" {\n")?;
+            for field in self.fields(f.db) {
+                f.write_str("    ")?;
+                field.hir_fmt(f)?;
+                f.write_str(",\n")?;
+            }
+            f.write_str("}")?;
+        }
+
         Ok(())
     }
 }

crates/ide-diagnostics/src/handlers/mutability_errors.rs

@@ -1225,6 +1225,22 @@ fn foo(mut foo: Foo) {
     };
     call_me();
 }
+"#,
+        );
+    }
+
+    #[test]
+    fn regression_15670() {
+        check_diagnostics(
+            r#"
+//- minicore: fn
+
+pub struct A {}
+pub unsafe fn foo(a: *mut A) {
+    let mut b = || -> *mut A { &mut *a };
+      //^^^^^ 💡 warn: variable does not need to be mutable
+    let _ = b();
+}
 "#,
         );
     }