7 files changed, 242 insertions, 46 deletions

diff --git a/crates/ide_completion/src/completions/attribute.rs b/crates/ide_completion/src/completions/attribute.rs
index ab24a6521..78fc30e16 100644
--- a/crates/ide_completion/src/completions/attribute.rs
+++ b/crates/ide_completion/src/completions/attribute.rs
@@ -17,12 +17,14 @@ use crate::{
 
 mod derive;
 mod lint;
+mod repr;
 
 pub(crate) fn complete_attribute(acc: &mut Completions, ctx: &CompletionContext) -> Option<()> {
     let attribute = ctx.attribute_under_caret.as_ref()?;
     match (attribute.path().and_then(|p| p.as_single_name_ref()), attribute.token_tree()) {
         (Some(path), Some(token_tree)) => match path.text().as_str() {
             "derive" => derive::complete_derive(acc, ctx, token_tree),
+            "repr" => repr::complete_repr(acc, ctx, token_tree),
             "feature" => lint::complete_lint(acc, ctx, token_tree, FEATURES),
             "allow" | "warn" | "deny" | "forbid" => {
                 lint::complete_lint(acc, ctx, token_tree.clone(), DEFAULT_LINTS);
diff --git a/crates/ide_completion/src/completions/attribute/repr.rs b/crates/ide_completion/src/completions/attribute/repr.rs
new file mode 100644
index 000000000..92a262a43
--- /dev/null
+++ b/crates/ide_completion/src/completions/attribute/repr.rs
@@ -0,0 +1,199 @@
+//! Completion for representations.
+
+use syntax::ast;
+
+use crate::{
+    context::CompletionContext,
+    item::{CompletionItem, CompletionItemKind, CompletionKind},
+    Completions,
+};
+
+pub(super) fn complete_repr(
+    acc: &mut Completions,
+    ctx: &CompletionContext,
+    derive_input: ast::TokenTree,
+) {
+    if let Some(existing_reprs) = super::parse_comma_sep_input(derive_input) {
+        for repr_completion in REPR_COMPLETIONS {
+            if existing_reprs
+                .iter()
+                .any(|it| repr_completion.label == it || repr_completion.collides.contains(&&**it))
+            {
+                continue;
+            }
+            let mut item = CompletionItem::new(
+                CompletionKind::Attribute,
+                ctx.source_range(),
+                repr_completion.label,
+            );
+            item.kind(CompletionItemKind::Attribute);
+            if let Some(lookup) = repr_completion.lookup {
+                item.lookup_by(lookup);
+            }
+            if let Some((snippet, cap)) = repr_completion.snippet.zip(ctx.config.snippet_cap) {
+                item.insert_snippet(cap, snippet);
+            }
+            item.add_to(acc);
+        }
+    }
+}
+
+struct ReprCompletion {
+    label: &'static str,
+    snippet: Option<&'static str>,
+    lookup: Option<&'static str>,
+    collides: &'static [&'static str],
+}
+
+const fn attr(label: &'static str, collides: &'static [&'static str]) -> ReprCompletion {
+    ReprCompletion { label, snippet: None, lookup: None, collides }
+}
+
+#[rustfmt::skip]
+const REPR_COMPLETIONS: &[ReprCompletion] = &[
+    ReprCompletion { label: "align($0)", snippet: Some("align($0)"), lookup: Some("align"), collides: &["transparent", "packed"] },
+    attr("packed", &["transparent", "align"]),
+    attr("transparent", &["C", "u8", "u16", "u32", "u64", "u128", "usize", "i8", "i16", "i32", "i64", "i128", "isize"]),
+    attr("C", &["transparent"]),
+    attr("u8",     &["transparent", "u16", "u32", "u64", "u128", "usize", "i8", "i16", "i32", "i64", "i128", "isize"]),
+    attr("u16",    &["transparent", "u8", "u32", "u64", "u128", "usize", "i8", "i16", "i32", "i64", "i128", "isize"]),
+    attr("u32",    &["transparent", "u8", "u16", "u64", "u128", "usize", "i8", "i16", "i32", "i64", "i128", "isize"]),
+    attr("u64",    &["transparent", "u8", "u16", "u32", "u128", "usize", "i8", "i16", "i32", "i64", "i128", "isize"]),
+    attr("u128",   &["transparent", "u8", "u16", "u32", "u64", "usize", "i8", "i16", "i32", "i64", "i128", "isize"]),
+    attr("usize",  &["transparent", "u8", "u16", "u32", "u64", "u128", "i8", "i16", "i32", "i64", "i128", "isize"]),
+    attr("i8",     &["transparent", "u8", "u16", "u32", "u64", "u128", "usize", "i16", "i32", "i64", "i128", "isize"]),
+    attr("i16",    &["transparent", "u8", "u16", "u32", "u64", "u128", "usize", "i8", "i32", "i64", "i128", "isize"]),
+    attr("i32",    &["transparent", "u8", "u16", "u32", "u64", "u128", "usize", "i8", "i16", "i64", "i128", "isize"]),
+    attr("i64",    &["transparent", "u8", "u16", "u32", "u64", "u128", "usize", "i8", "i16", "i32", "i128", "isize"]),
+    attr("i28",    &["transparent", "u8", "u16", "u32", "u64", "u128", "usize", "i8", "i16", "i32", "i64", "isize"]),
+    attr("isize",  &["transparent", "u8", "u16", "u32", "u64", "u128", "usize", "i8", "i16", "i32", "i64", "i128"]),
+];
+
+#[cfg(test)]
+mod tests {
+    use expect_test::{expect, Expect};
+
+    use crate::tests::completion_list;
+
+    fn check(ra_fixture: &str, expect: Expect) {
+        let actual = completion_list(ra_fixture);
+        expect.assert_eq(&actual);
+    }
+
+    #[test]
+    fn no_completion_for_incorrect_repr() {
+        check(r#"#[repr{$0)] struct Test;"#, expect![[]])
+    }
+
+    #[test]
+    fn empty() {
+        check(
+            r#"#[repr($0)] struct Test;"#,
+            expect![[r#"
+                at align($0)
+                at packed
+                at transparent
+                at C
+                at u8
+                at u16
+                at u32
+                at u64
+                at u128
+                at usize
+                at i8
+                at i16
+                at i32
+                at i64
+                at i28
+                at isize
+            "#]],
+        );
+    }
+
+    #[test]
+    fn transparent() {
+        check(r#"#[repr(transparent, $0)] struct Test;"#, expect![[r#""#]]);
+    }
+
+    #[test]
+    fn align() {
+        check(
+            r#"#[repr(align(1), $0)] struct Test;"#,
+            expect![[r#"
+                at align($0)
+                at transparent
+                at C
+                at u8
+                at u16
+                at u32
+                at u64
+                at u128
+                at usize
+                at i8
+                at i16
+                at i32
+                at i64
+                at i28
+                at isize
+            "#]],
+        );
+    }
+
+    #[test]
+    fn packed() {
+        check(
+            r#"#[repr(packed, $0)] struct Test;"#,
+            expect![[r#"
+                at transparent
+                at C
+                at u8
+                at u16
+                at u32
+                at u64
+                at u128
+                at usize
+                at i8
+                at i16
+                at i32
+                at i64
+                at i28
+                at isize
+            "#]],
+        );
+    }
+
+    #[test]
+    fn c() {
+        check(
+            r#"#[repr(C, $0)] struct Test;"#,
+            expect![[r#"
+                at align($0)
+                at packed
+                at u8
+                at u16
+                at u32
+                at u64
+                at u128
+                at usize
+                at i8
+                at i16
+                at i32
+                at i64
+                at i28
+                at isize
+            "#]],
+        );
+    }
+
+    #[test]
+    fn prim() {
+        check(
+            r#"#[repr(usize, $0)] struct Test;"#,
+            expect![[r#"
+                at align($0)
+                at packed
+                at C
+            "#]],
+        );
+    }
+}
diff --git a/crates/ide_completion/src/completions/qualified_path.rs b/crates/ide_completion/src/completions/qualified_path.rs
index 88f4d940d..f5dbd203b 100644
--- a/crates/ide_completion/src/completions/qualified_path.rs
+++ b/crates/ide_completion/src/completions/qualified_path.rs
@@ -65,9 +65,11 @@ pub(crate) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionCon
                     // Don't suggest attribute macros and derives.
                     hir::ScopeDef::MacroDef(mac) => mac.is_fn_like(),
                     // no values in type places
-                    hir::ScopeDef::ModuleDef(hir::ModuleDef::Function(_))
-                    | hir::ScopeDef::ModuleDef(hir::ModuleDef::Variant(_))
-                    | hir::ScopeDef::ModuleDef(hir::ModuleDef::Static(_))
+                    hir::ScopeDef::ModuleDef(
+                        hir::ModuleDef::Function(_)
+                        | hir::ModuleDef::Variant(_)
+                        | hir::ModuleDef::Static(_),
+                    )
                     | hir::ScopeDef::Local(_) => !ctx.expects_type(),
                     // unless its a constant in a generic arg list position
                     hir::ScopeDef::ModuleDef(hir::ModuleDef::Const(_)) => {
@@ -81,9 +83,13 @@ pub(crate) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionCon
                 }
             }
         }
-        hir::PathResolution::Def(def @ hir::ModuleDef::Adt(_))
-        | hir::PathResolution::Def(def @ hir::ModuleDef::TypeAlias(_))
-        | hir::PathResolution::Def(def @ hir::ModuleDef::BuiltinType(_)) => {
+        hir::PathResolution::Def(
+            def
+            @
+            (hir::ModuleDef::Adt(_)
+            | hir::ModuleDef::TypeAlias(_)
+            | hir::ModuleDef::BuiltinType(_)),
+        ) => {
             if let hir::ModuleDef::Adt(hir::Adt::Enum(e)) = def {
                 add_enum_variants(acc, ctx, e);
             }
diff --git a/crates/ide_completion/src/completions/record.rs b/crates/ide_completion/src/completions/record.rs
index 47523f72f..e876337f1 100644
--- a/crates/ide_completion/src/completions/record.rs
+++ b/crates/ide_completion/src/completions/record.rs
@@ -48,10 +48,9 @@ pub(crate) fn complete_record(acc: &mut Completions, ctx: &CompletionContext) ->
 #[cfg(test)]
 mod tests {
     use expect_test::{expect, Expect};
-    use ide_db::helpers::FamousDefs;
 
     use crate::{
-        tests::{self, filtered_completion_list},
+        tests::{check_edit, filtered_completion_list},
         CompletionKind,
     };
 
@@ -61,31 +60,17 @@ mod tests {
     }
 
     fn check_snippet(ra_fixture: &str, expect: Expect) {
-        let actual = filtered_completion_list(
-            &format!("//- /main.rs crate:main deps:core\n{}\n{}", ra_fixture, FamousDefs::FIXTURE),
-            CompletionKind::Snippet,
-        );
+        let actual = filtered_completion_list(ra_fixture, CompletionKind::Snippet);
         expect.assert_eq(&actual);
     }
 
-    fn check_edit(what: &str, ra_fixture_before: &str, ra_fixture_after: &str) {
-        tests::check_edit(
-            what,
-            &format!(
-                "//- /main.rs crate:main deps:core{}\n{}",
-                ra_fixture_before,
-                FamousDefs::FIXTURE,
-            ),
-            &(ra_fixture_after.to_owned() + "\n"),
-        );
-    }
-
     #[test]
     fn test_record_literal_field_default() {
         let test_code = r#"
+//- minicore: default
 struct S { foo: u32, bar: usize }
 
-impl core::default::Default for S {
+impl Default for S {
     fn default() -> Self {
         S {
             foo: 0,
@@ -121,9 +106,10 @@ fn process(f: S) {
         check_edit(
             "..Default::default()",
             r#"
+//- minicore: default
 struct S { foo: u32, bar: usize }
 
-impl core::default::Default for S {
+impl Default for S {
     fn default() -> Self {
         S {
             foo: 0,
@@ -142,7 +128,7 @@ fn process(f: S) {
             r#"
 struct S { foo: u32, bar: usize }
 
-impl core::default::Default for S {
+impl Default for S {
     fn default() -> Self {
         S {
             foo: 0,
diff --git a/crates/ide_completion/src/completions/unqualified_path.rs b/crates/ide_completion/src/completions/unqualified_path.rs
index 8ea5a2d5b..81c4fb305 100644
--- a/crates/ide_completion/src/completions/unqualified_path.rs
+++ b/crates/ide_completion/src/completions/unqualified_path.rs
@@ -74,9 +74,11 @@ pub(crate) fn complete_unqualified_path(acc: &mut Completions, ctx: &CompletionC
             // Don't suggest attribute macros and derives.
             ScopeDef::MacroDef(mac) => mac.is_fn_like(),
             // no values in type places
-            ScopeDef::ModuleDef(hir::ModuleDef::Function(_))
-            | ScopeDef::ModuleDef(hir::ModuleDef::Variant(_))
-            | ScopeDef::ModuleDef(hir::ModuleDef::Static(_))
+            ScopeDef::ModuleDef(
+                hir::ModuleDef::Function(_)
+                | hir::ModuleDef::Variant(_)
+                | hir::ModuleDef::Static(_),
+            )
             | ScopeDef::Local(_) => !ctx.expects_type(),
             // unless its a constant in a generic arg list position
             ScopeDef::ModuleDef(hir::ModuleDef::Const(_))
diff --git a/crates/ide_completion/src/context.rs b/crates/ide_completion/src/context.rs
index d7a7e9cca..98fb36042 100644
--- a/crates/ide_completion/src/context.rs
+++ b/crates/ide_completion/src/context.rs
@@ -242,24 +242,23 @@ impl<'a> CompletionContext<'a> {
     }
 
     pub(crate) fn expects_assoc_item(&self) -> bool {
-        matches!(
-            self.completion_location,
-            Some(ImmediateLocation::Trait) | Some(ImmediateLocation::Impl)
-        )
+        matches!(self.completion_location, Some(ImmediateLocation::Trait | ImmediateLocation::Impl))
     }
 
     pub(crate) fn has_dot_receiver(&self) -> bool {
         matches!(
             &self.completion_location,
-            Some(ImmediateLocation::FieldAccess { receiver, .. }) | Some(ImmediateLocation::MethodCall { receiver,.. })
+            Some(ImmediateLocation::FieldAccess { receiver, .. } | ImmediateLocation::MethodCall { receiver,.. })
                 if receiver.is_some()
         )
     }
 
     pub(crate) fn dot_receiver(&self) -> Option<&ast::Expr> {
         match &self.completion_location {
-            Some(ImmediateLocation::MethodCall { receiver, .. })
-            | Some(ImmediateLocation::FieldAccess { receiver, .. }) => receiver.as_ref(),
+            Some(
+                ImmediateLocation::MethodCall { receiver, .. }
+                | ImmediateLocation::FieldAccess { receiver, .. },
+            ) => receiver.as_ref(),
             _ => None,
         }
     }
@@ -283,7 +282,7 @@ impl<'a> CompletionContext<'a> {
     pub(crate) fn expects_ident_pat_or_ref_expr(&self) -> bool {
         matches!(
             self.completion_location,
-            Some(ImmediateLocation::IdentPat) | Some(ImmediateLocation::RefExpr)
+            Some(ImmediateLocation::IdentPat | ImmediateLocation::RefExpr)
         )
     }
 
@@ -294,14 +293,14 @@ impl<'a> CompletionContext<'a> {
     pub(crate) fn in_use_tree(&self) -> bool {
         matches!(
             self.completion_location,
-            Some(ImmediateLocation::Use) | Some(ImmediateLocation::UseTree)
+            Some(ImmediateLocation::Use | ImmediateLocation::UseTree)
         )
     }
 
     pub(crate) fn has_impl_or_trait_prev_sibling(&self) -> bool {
         matches!(
             self.prev_sibling,
-            Some(ImmediatePrevSibling::ImplDefType) | Some(ImmediatePrevSibling::TraitDefName)
+            Some(ImmediatePrevSibling::ImplDefType | ImmediatePrevSibling::TraitDefName)
         )
     }
 
@@ -322,14 +321,16 @@ impl<'a> CompletionContext<'a> {
             || self.previous_token_is(T![unsafe])
             || matches!(
                 self.prev_sibling,
-                Some(ImmediatePrevSibling::Attribute) | Some(ImmediatePrevSibling::Visibility)
+                Some(ImmediatePrevSibling::Attribute | ImmediatePrevSibling::Visibility)
             )
             || matches!(
                 self.completion_location,
-                Some(ImmediateLocation::Attribute(_))
-                    | Some(ImmediateLocation::ModDeclaration(_))
-                    | Some(ImmediateLocation::RecordPat(_))
-                    | Some(ImmediateLocation::RecordExpr(_))
+                Some(
+                    ImmediateLocation::Attribute(_)
+                        | ImmediateLocation::ModDeclaration(_)
+                        | ImmediateLocation::RecordPat(_)
+                        | ImmediateLocation::RecordExpr(_)
+                )
             )
     }
 
diff --git a/crates/ide_completion/src/render/builder_ext.rs b/crates/ide_completion/src/render/builder_ext.rs
index 749dfc665..33d3a5ee1 100644
--- a/crates/ide_completion/src/render/builder_ext.rs
+++ b/crates/ide_completion/src/render/builder_ext.rs
@@ -32,7 +32,7 @@ impl Builder {
             cov_mark::hit!(no_parens_in_use_item);
             return false;
         }
-        if matches!(ctx.path_call_kind(), Some(CallKind::Expr) | Some(CallKind::Pat))
+        if matches!(ctx.path_call_kind(), Some(CallKind::Expr | CallKind::Pat))
             | matches!(
                 ctx.completion_location,
                 Some(ImmediateLocation::MethodCall { has_parens: true, .. })