7 files changed, 197 insertions, 11 deletions

diff --git a/crates/assists/src/handlers/generate_impl.rs b/crates/assists/src/handlers/generate_impl.rs
index 9989109b5..114974465 100644
--- a/crates/assists/src/handlers/generate_impl.rs
+++ b/crates/assists/src/handlers/generate_impl.rs
@@ -1,6 +1,6 @@
 use itertools::Itertools;
 use stdx::format_to;
-use syntax::ast::{self, AstNode, GenericParamsOwner, NameOwner};
+use syntax::ast::{self, AstNode, AttrsOwner, GenericParamsOwner, NameOwner};
 
 use crate::{AssistContext, AssistId, AssistKind, Assists};
 
@@ -27,6 +27,7 @@ pub(crate) fn generate_impl(acc: &mut Assists, ctx: &AssistContext) -> Option<()
     let nominal = ctx.find_node_at_offset::<ast::AdtDef>()?;
     let name = nominal.name()?;
     let target = nominal.syntax().text_range();
+
     acc.add(
         AssistId("generate_impl", AssistKind::Generate),
         format!("Generate impl for `{}`", name),
@@ -35,7 +36,15 @@ pub(crate) fn generate_impl(acc: &mut Assists, ctx: &AssistContext) -> Option<()
             let type_params = nominal.generic_param_list();
             let start_offset = nominal.syntax().text_range().end();
             let mut buf = String::new();
-            buf.push_str("\n\nimpl");
+            buf.push_str("\n\n");
+            nominal
+                .attrs()
+                .filter(|attr| {
+                    attr.as_simple_call().map(|(name, _arg)| name == "cfg").unwrap_or(false)
+                })
+                .for_each(|attr| buf.push_str(format!("{}\n", attr.to_string()).as_str()));
+
+            buf.push_str("impl");
             if let Some(type_params) = &type_params {
                 format_to!(buf, "{}", type_params.syntax());
             }
@@ -91,6 +100,35 @@ mod tests {
             "struct Foo<'a, T: Foo<'a>> {<|>}",
             "struct Foo<'a, T: Foo<'a>> {}\n\nimpl<'a, T: Foo<'a>> Foo<'a, T> {\n    $0\n}",
         );
+        check_assist(
+            generate_impl,
+            r#"
+            #[cfg(feature = "foo")]
+            struct Foo<'a, T: Foo<'a>> {<|>}"#,
+            r#"
+            #[cfg(feature = "foo")]
+            struct Foo<'a, T: Foo<'a>> {}
+
+            #[cfg(feature = "foo")]
+            impl<'a, T: Foo<'a>> Foo<'a, T> {
+                $0
+            }"#,
+        );
+
+        check_assist(
+            generate_impl,
+            r#"
+            #[cfg(not(feature = "foo"))]
+            struct Foo<'a, T: Foo<'a>> {<|>}"#,
+            r#"
+            #[cfg(not(feature = "foo"))]
+            struct Foo<'a, T: Foo<'a>> {}
+
+            #[cfg(not(feature = "foo"))]
+            impl<'a, T: Foo<'a>> Foo<'a, T> {
+                $0
+            }"#,
+        );
     }
 
     #[test]
diff --git a/crates/hir_def/src/item_tree/lower.rs b/crates/hir_def/src/item_tree/lower.rs
index 3328639cf..ca7fb4a43 100644
--- a/crates/hir_def/src/item_tree/lower.rs
+++ b/crates/hir_def/src/item_tree/lower.rs
@@ -3,7 +3,7 @@
 use std::{collections::hash_map::Entry, mem, sync::Arc};
 
 use arena::map::ArenaMap;
-use hir_expand::{ast_id_map::AstIdMap, hygiene::Hygiene, HirFileId};
+use hir_expand::{ast_id_map::AstIdMap, hygiene::Hygiene, name::known, HirFileId};
 use smallvec::SmallVec;
 use syntax::{
     ast::{self, ModuleItemOwner},
@@ -555,7 +555,8 @@ impl Ctx {
                     let id: ModItem = match item {
                         ast::ExternItem::Fn(ast) => {
                             let func = self.lower_function(&ast)?;
-                            self.data().functions[func.index].is_unsafe = true;
+                            self.data().functions[func.index].is_unsafe =
+                                is_intrinsic_fn_unsafe(&self.data().functions[func.index].name);
                             func.into()
                         }
                         ast::ExternItem::Static(ast) => {
@@ -713,3 +714,45 @@ enum GenericsOwner<'a> {
     TypeAlias,
     Impl,
 }
+
+/// Returns `true` if the given intrinsic is unsafe to call, or false otherwise.
+fn is_intrinsic_fn_unsafe(name: &Name) -> bool {
+    // Should be kept in sync with https://github.com/rust-lang/rust/blob/c6e4db620a7d2f569f11dcab627430921ea8aacf/compiler/rustc_typeck/src/check/intrinsic.rs#L68
+    ![
+        known::abort,
+        known::min_align_of,
+        known::needs_drop,
+        known::caller_location,
+        known::size_of_val,
+        known::min_align_of_val,
+        known::add_with_overflow,
+        known::sub_with_overflow,
+        known::mul_with_overflow,
+        known::wrapping_add,
+        known::wrapping_sub,
+        known::wrapping_mul,
+        known::saturating_add,
+        known::saturating_sub,
+        known::rotate_left,
+        known::rotate_right,
+        known::ctpop,
+        known::ctlz,
+        known::cttz,
+        known::bswap,
+        known::bitreverse,
+        known::discriminant_value,
+        known::type_id,
+        known::likely,
+        known::unlikely,
+        known::ptr_guaranteed_eq,
+        known::ptr_guaranteed_ne,
+        known::minnumf32,
+        known::minnumf64,
+        known::maxnumf32,
+        known::rustc_peek,
+        known::maxnumf64,
+        known::type_name,
+        known::variant_count,
+    ]
+    .contains(&name)
+}
diff --git a/crates/hir_expand/src/name.rs b/crates/hir_expand/src/name.rs
index 63f828707..b26ffa1ef 100644
--- a/crates/hir_expand/src/name.rs
+++ b/crates/hir_expand/src/name.rs
@@ -208,6 +208,42 @@ pub mod known {
         PartialOrd,
         Eq,
         PartialEq,
+        // Safe intrinsics
+        abort,
+        size_of,
+        min_align_of,
+        needs_drop,
+        caller_location,
+        size_of_val,
+        min_align_of_val,
+        add_with_overflow,
+        sub_with_overflow,
+        mul_with_overflow,
+        wrapping_add,
+        wrapping_sub,
+        wrapping_mul,
+        saturating_add,
+        saturating_sub,
+        rotate_left,
+        rotate_right,
+        ctpop,
+        ctlz,
+        cttz,
+        bswap,
+        bitreverse,
+        discriminant_value,
+        type_id,
+        likely,
+        unlikely,
+        ptr_guaranteed_eq,
+        ptr_guaranteed_ne,
+        minnumf32,
+        minnumf64,
+        maxnumf32,
+        rustc_peek,
+        maxnumf64,
+        type_name,
+        variant_count,
     );
 
     // self/Self cannot be used as an identifier
diff --git a/crates/hir_ty/src/diagnostics/decl_check.rs b/crates/hir_ty/src/diagnostics/decl_check.rs
index f987636fe..f179c62b7 100644
--- a/crates/hir_ty/src/diagnostics/decl_check.rs
+++ b/crates/hir_ty/src/diagnostics/decl_check.rs
@@ -708,11 +708,23 @@ fn foo() {
     }
 
     #[test]
-    fn incorrect_struct_name() {
+    fn incorrect_struct_names() {
         check_diagnostics(
             r#"
 struct non_camel_case_name {}
     // ^^^^^^^^^^^^^^^^^^^ Structure `non_camel_case_name` should have CamelCase name, e.g. `NonCamelCaseName`
+
+struct SCREAMING_CASE {}
+    // ^^^^^^^^^^^^^^ Structure `SCREAMING_CASE` should have CamelCase name, e.g. `ScreamingCase`
+"#,
+        );
+    }
+
+    #[test]
+    fn no_diagnostic_for_camel_cased_acronyms_in_struct_name() {
+        check_diagnostics(
+            r#"
+struct AABB {}
 "#,
         );
     }
@@ -728,11 +740,23 @@ struct SomeStruct { SomeField: u8 }
     }
 
     #[test]
-    fn incorrect_enum_name() {
+    fn incorrect_enum_names() {
         check_diagnostics(
             r#"
 enum some_enum { Val(u8) }
   // ^^^^^^^^^ Enum `some_enum` should have CamelCase name, e.g. `SomeEnum`
+
+enum SOME_ENUM
+  // ^^^^^^^^^ Enum `SOME_ENUM` should have CamelCase name, e.g. `SomeEnum`
+"#,
+        );
+    }
+
+    #[test]
+    fn no_diagnostic_for_camel_cased_acronyms_in_enum_name() {
+        check_diagnostics(
+            r#"
+enum AABB {}
 "#,
         );
     }
diff --git a/crates/hir_ty/src/diagnostics/decl_check/case_conv.rs b/crates/hir_ty/src/diagnostics/decl_check/case_conv.rs
index 3800f2a6b..324d60765 100644
--- a/crates/hir_ty/src/diagnostics/decl_check/case_conv.rs
+++ b/crates/hir_ty/src/diagnostics/decl_check/case_conv.rs
@@ -29,7 +29,13 @@ fn detect_case(ident: &str) -> DetectedCase {
 
     if has_uppercase {
         if !has_lowercase {
-            DetectedCase::UpperSnakeCase
+            if has_underscore {
+                DetectedCase::UpperSnakeCase
+            } else {
+                // It has uppercase only and no underscores. Ex: "AABB"
+                // This is a camel cased acronym.
+                DetectedCase::UpperCamelCase
+            }
         } else if !has_underscore {
             if first_lowercase {
                 DetectedCase::LowerCamelCase
@@ -180,6 +186,7 @@ mod tests {
         check(to_camel_case, "Weird_Case", expect![["WeirdCase"]]);
         check(to_camel_case, "name", expect![["Name"]]);
         check(to_camel_case, "A", expect![[""]]);
+        check(to_camel_case, "AABB", expect![[""]]);
     }
 
     #[test]
diff --git a/crates/hir_ty/src/diagnostics/unsafe_check.rs b/crates/hir_ty/src/diagnostics/unsafe_check.rs
index 21a121aad..2da9688ca 100644
--- a/crates/hir_ty/src/diagnostics/unsafe_check.rs
+++ b/crates/hir_ty/src/diagnostics/unsafe_check.rs
@@ -202,4 +202,22 @@ fn main() {
 "#,
         );
     }
+
+    #[test]
+    fn no_missing_unsafe_diagnostic_with_safe_intrinsic() {
+        check_diagnostics(
+            r#"
+extern "rust-intrinsic" {
+    pub fn bitreverse(x: u32) -> u32; // Safe intrinsic
+    pub fn floorf32(x: f32) -> f32; // Unsafe intrinsic
+}
+
+fn main() {
+    let _ = bitreverse(12);
+    let _ = floorf32(12.0);
+          //^^^^^^^^^^^^^^ This operation is unsafe and requires an unsafe function or block
+}
+"#,
+        );
+    }
 }
diff --git a/crates/ide/src/doc_links.rs b/crates/ide/src/doc_links.rs
index b9d8b8a2b..250f10f9f 100644
--- a/crates/ide/src/doc_links.rs
+++ b/crates/ide/src/doc_links.rs
@@ -132,7 +132,8 @@ fn get_doc_link(db: &RootDatabase, definition: Definition) -> Option<String> {
     let import_map = db.import_map(krate.into());
     let base = once(krate.display_name(db)?.to_string())
         .chain(import_map.path_of(ns)?.segments.iter().map(|name| name.to_string()))
-        .join("/");
+        .join("/")
+        + "/";
 
     let filename = get_symbol_filename(db, &target_def);
     let fragment = match definition {
@@ -152,9 +153,16 @@ fn get_doc_link(db: &RootDatabase, definition: Definition) -> Option<String> {
         _ => None,
     };
 
-    get_doc_url(db, &krate)
-        .and_then(|url| url.join(&base).ok())
-        .and_then(|url| filename.as_deref().and_then(|f| url.join(f).ok()))
+    get_doc_url(db, &krate)?
+        .join(&base)
+        .ok()
+        .and_then(|mut url| {
+            if !matches!(definition, Definition::ModuleDef(ModuleDef::Module(..))) {
+                url.path_segments_mut().ok()?.pop();
+            };
+            Some(url)
+        })
+        .and_then(|url| url.join(filename.as_deref()?).ok())
         .and_then(
             |url| if let Some(fragment) = fragment { url.join(&fragment).ok() } else { Some(url) },
         )
@@ -522,6 +530,18 @@ pub struct Foo {
         );
     }
 
+    #[test]
+    fn test_module() {
+        check(
+            r#"
+pub mod foo {
+    pub mod ba<|>r {}
+}
+        "#,
+            expect![[r#"https://docs.rs/test/*/test/foo/bar/index.html"#]],
+        )
+    }
+
     // FIXME: ImportMap will return re-export paths instead of public module
     // paths. The correct path to documentation will never be a re-export.
     // This problem stops us from resolving stdlib items included in the prelude