62 files changed, 2267 insertions, 1151 deletions

diff --git a/crates/base_db/src/fixture.rs b/crates/base_db/src/fixture.rs
index 0132565e4..69ceba735 100644
--- a/crates/base_db/src/fixture.rs
+++ b/crates/base_db/src/fixture.rs
@@ -34,19 +34,13 @@ pub trait WithFixture: Default + SourceDatabaseExt + 'static {
 
     fn with_position(ra_fixture: &str) -> (Self, FilePosition) {
         let (db, file_id, range_or_offset) = Self::with_range_or_offset(ra_fixture);
-        let offset = match range_or_offset {
-            RangeOrOffset::Range(_) => panic!("Expected a cursor position, got a range instead"),
-            RangeOrOffset::Offset(it) => it,
-        };
+        let offset = range_or_offset.expect_offset();
         (db, FilePosition { file_id, offset })
     }
 
     fn with_range(ra_fixture: &str) -> (Self, FileRange) {
         let (db, file_id, range_or_offset) = Self::with_range_or_offset(ra_fixture);
-        let range = match range_or_offset {
-            RangeOrOffset::Range(it) => it,
-            RangeOrOffset::Offset(_) => panic!("Expected a cursor range, got a position instead"),
-        };
+        let range = range_or_offset.expect_range();
         (db, FileRange { file_id, range })
     }
 
diff --git a/crates/base_db/src/input.rs b/crates/base_db/src/input.rs
index 64ccd11ee..23cb0c839 100644
--- a/crates/base_db/src/input.rs
+++ b/crates/base_db/src/input.rs
@@ -147,7 +147,7 @@ impl CrateDisplayName {
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub struct ProcMacroId(pub u32);
 
-#[derive(Copy, Clone, Eq, PartialEq, Debug)]
+#[derive(Copy, Clone, Eq, PartialEq, Debug, Hash)]
 pub enum ProcMacroKind {
     CustomDerive,
     FuncLike,
diff --git a/crates/hir/src/diagnostics.rs b/crates/hir/src/diagnostics.rs
index 22ec7c6ac..2cdbd172a 100644
--- a/crates/hir/src/diagnostics.rs
+++ b/crates/hir/src/diagnostics.rs
@@ -227,3 +227,27 @@ impl Diagnostic for MacroError {
         true
     }
 }
+
+#[derive(Debug)]
+pub struct UnimplementedBuiltinMacro {
+    pub file: HirFileId,
+    pub node: SyntaxNodePtr,
+}
+
+impl Diagnostic for UnimplementedBuiltinMacro {
+    fn code(&self) -> DiagnosticCode {
+        DiagnosticCode("unimplemented-builtin-macro")
+    }
+
+    fn message(&self) -> String {
+        "unimplemented built-in macro".to_string()
+    }
+
+    fn display_source(&self) -> InFile<SyntaxNodePtr> {
+        InFile::new(self.file, self.node.clone())
+    }
+
+    fn as_any(&self) -> &(dyn Any + Send + 'static) {
+        self
+    }
+}
diff --git a/crates/hir/src/display.rs b/crates/hir/src/display.rs
index c5cf803fd..72f0d9b5f 100644
--- a/crates/hir/src/display.rs
+++ b/crates/hir/src/display.rs
@@ -427,10 +427,6 @@ impl HirDisplay for Trait {
         write!(f, "trait {}", data.name)?;
         let def_id = GenericDefId::TraitId(self.id);
         write_generic_params(def_id, f)?;
-        if !data.bounds.is_empty() {
-            write!(f, ": ")?;
-            f.write_joined(&*data.bounds, " + ")?;
-        }
         write_where_clause(def_id, f)?;
         Ok(())
     }
diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index 01b2de515..d3ef29db4 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs
@@ -36,8 +36,8 @@ use std::{iter, sync::Arc};
 use arrayvec::ArrayVec;
 use base_db::{CrateDisplayName, CrateId, Edition, FileId};
 use diagnostics::{
-    InactiveCode, MacroError, UnresolvedExternCrate, UnresolvedImport, UnresolvedMacroCall,
-    UnresolvedModule, UnresolvedProcMacro,
+    InactiveCode, MacroError, UnimplementedBuiltinMacro, UnresolvedExternCrate, UnresolvedImport,
+    UnresolvedMacroCall, UnresolvedModule, UnresolvedProcMacro,
 };
 use either::Either;
 use hir_def::{
@@ -565,6 +565,14 @@ impl Module {
                     };
                     sink.push(MacroError { file, node: ast, message: message.clone() });
                 }
+
+                DefDiagnosticKind::UnimplementedBuiltinMacro { ast } => {
+                    let node = ast.to_node(db.upcast());
+                    // Must have a name, otherwise we wouldn't emit it.
+                    let name = node.name().expect("unimplemented builtin macro with no name");
+                    let ptr = SyntaxNodePtr::from(AstPtr::new(&name));
+                    sink.push(UnimplementedBuiltinMacro { file: ast.file_id, node: ptr });
+                }
             }
         }
         for decl in self.declarations(db) {
@@ -1282,10 +1290,16 @@ impl BuiltinType {
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum MacroKind {
+    /// `macro_rules!` or Macros 2.0 macro.
     Declarative,
-    ProcMacro,
+    /// A built-in or custom derive.
     Derive,
+    /// A built-in function-like macro.
     BuiltIn,
+    /// A procedural attribute macro.
+    Attr,
+    /// A function-like procedural macro.
+    ProcMacro,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -1315,11 +1329,13 @@ impl MacroDef {
     pub fn kind(&self) -> MacroKind {
         match self.id.kind {
             MacroDefKind::Declarative(_) => MacroKind::Declarative,
-            MacroDefKind::BuiltIn(_, _) => MacroKind::BuiltIn,
+            MacroDefKind::BuiltIn(_, _) | MacroDefKind::BuiltInEager(_, _) => MacroKind::BuiltIn,
             MacroDefKind::BuiltInDerive(_, _) => MacroKind::Derive,
-            MacroDefKind::BuiltInEager(_, _) => MacroKind::BuiltIn,
-            // FIXME might be a derive
-            MacroDefKind::ProcMacro(_, _) => MacroKind::ProcMacro,
+            MacroDefKind::ProcMacro(_, base_db::ProcMacroKind::CustomDerive, _) => {
+                MacroKind::Derive
+            }
+            MacroDefKind::ProcMacro(_, base_db::ProcMacroKind::Attr, _) => MacroKind::Attr,
+            MacroDefKind::ProcMacro(_, base_db::ProcMacroKind::FuncLike, _) => MacroKind::ProcMacro,
         }
     }
 }
diff --git a/crates/hir_def/src/data.rs b/crates/hir_def/src/data.rs
index 8bcac60ef..d2bb381be 100644
--- a/crates/hir_def/src/data.rs
+++ b/crates/hir_def/src/data.rs
@@ -22,6 +22,7 @@ pub struct FunctionData {
     pub name: Name,
     pub params: Vec<Interned<TypeRef>>,
     pub ret_type: Interned<TypeRef>,
+    pub async_ret_type: Option<Interned<TypeRef>>,
     pub attrs: Attrs,
     pub visibility: RawVisibility,
     pub abi: Option<Interned<str>>,
@@ -63,6 +64,7 @@ impl FunctionData {
                 })
                 .collect(),
             ret_type: func.ret_type.clone(),
+            async_ret_type: func.async_ret_type.clone(),
             attrs: item_tree.attrs(db, krate, ModItem::from(loc.id.value).into()),
             visibility: item_tree[func.visibility].clone(),
             abi: func.abi.clone(),
@@ -141,7 +143,6 @@ pub struct TraitData {
     pub is_auto: bool,
     pub is_unsafe: bool,
     pub visibility: RawVisibility,
-    pub bounds: Box<[Interned<TypeBound>]>,
 }
 
 impl TraitData {
@@ -155,7 +156,6 @@ impl TraitData {
         let module_id = tr_loc.container;
         let container = AssocContainerId::TraitId(tr);
         let visibility = item_tree[tr_def.visibility].clone();
-        let bounds = tr_def.bounds.clone();
         let mut expander = Expander::new(db, tr_loc.id.file_id(), module_id);
 
         let items = collect_items(
@@ -168,7 +168,7 @@ impl TraitData {
             100,
         );
 
-        Arc::new(TraitData { name, items, is_auto, is_unsafe, visibility, bounds })
+        Arc::new(TraitData { name, items, is_auto, is_unsafe, visibility })
     }
 
     pub fn associated_types(&self) -> impl Iterator<Item = TypeAliasId> + '_ {
diff --git a/crates/hir_def/src/item_tree.rs b/crates/hir_def/src/item_tree.rs
index f84c4cf2b..227337a8d 100644
--- a/crates/hir_def/src/item_tree.rs
+++ b/crates/hir_def/src/item_tree.rs
@@ -580,6 +580,7 @@ pub struct Function {
     pub abi: Option<Interned<str>>,
     pub params: IdRange<Param>,
     pub ret_type: Interned<TypeRef>,
+    pub async_ret_type: Option<Interned<TypeRef>>,
     pub ast_id: FileAstId<ast::Fn>,
     pub(crate) flags: FnFlags,
 }
@@ -661,7 +662,6 @@ pub struct Trait {
     pub generic_params: Interned<GenericParams>,
     pub is_auto: bool,
     pub is_unsafe: bool,
-    pub bounds: Box<[Interned<TypeBound>]>,
     pub items: Box<[AssocItem]>,
     pub ast_id: FileAstId<ast::Trait>,
 }
diff --git a/crates/hir_def/src/item_tree/lower.rs b/crates/hir_def/src/item_tree/lower.rs
index 40f3428b7..6208facd5 100644
--- a/crates/hir_def/src/item_tree/lower.rs
+++ b/crates/hir_def/src/item_tree/lower.rs
@@ -356,12 +356,13 @@ impl<'a> Ctx<'a> {
             _ => TypeRef::unit(),
         };
 
-        let ret_type = if func.async_token().is_some() {
+        let (ret_type, async_ret_type) = if func.async_token().is_some() {
+            let async_ret_type = ret_type.clone();
             let future_impl = desugar_future_path(ret_type);
             let ty_bound = Interned::new(TypeBound::Path(future_impl));
-            TypeRef::ImplTrait(vec![ty_bound])
+            (TypeRef::ImplTrait(vec![ty_bound]), Some(async_ret_type))
         } else {
-            ret_type
+            (ret_type, None)
         };
 
         let abi = func.abi().map(lower_abi);
@@ -395,6 +396,7 @@ impl<'a> Ctx<'a> {
             abi,
             params,
             ret_type: Interned::new(ret_type),
+            async_ret_type: async_ret_type.map(Interned::new),
             ast_id,
             flags,
         };
@@ -474,7 +476,6 @@ impl<'a> Ctx<'a> {
             self.lower_generic_params_and_inner_items(GenericsOwner::Trait(trait_def), trait_def);
         let is_auto = trait_def.auto_token().is_some();
         let is_unsafe = trait_def.unsafe_token().is_some();
-        let bounds = self.lower_type_bounds(trait_def);
         let items = trait_def.assoc_item_list().map(|list| {
             let db = self.db;
             self.with_inherited_visibility(visibility, |this| {
@@ -497,7 +498,6 @@ impl<'a> Ctx<'a> {
             generic_params,
             is_auto,
             is_unsafe,
-            bounds: bounds.into(),
             items: items.unwrap_or_default(),
             ast_id,
         };
diff --git a/crates/hir_def/src/item_tree/pretty.rs b/crates/hir_def/src/item_tree/pretty.rs
index 53631ab19..cc9944a22 100644
--- a/crates/hir_def/src/item_tree/pretty.rs
+++ b/crates/hir_def/src/item_tree/pretty.rs
@@ -235,6 +235,7 @@ impl<'a> Printer<'a> {
                     abi,
                     params,
                     ret_type,
+                    async_ret_type: _,
                     ast_id: _,
                     flags,
                 } = &self.tree[it];
@@ -345,7 +346,6 @@ impl<'a> Printer<'a> {
                     visibility,
                     is_auto,
                     is_unsafe,
-                    bounds,
                     items,
                     generic_params,
                     ast_id: _,
@@ -359,10 +359,6 @@ impl<'a> Printer<'a> {
                 }
                 w!(self, "trait {}", name);
                 self.print_generic_params(generic_params);
-                if !bounds.is_empty() {
-                    w!(self, ": ");
-                    self.print_type_bounds(bounds);
-                }
                 self.print_where_clause_and_opening_brace(generic_params);
                 self.indented(|this| {
                     for item in &**items {
diff --git a/crates/hir_def/src/item_tree/tests.rs b/crates/hir_def/src/item_tree/tests.rs
index 20773aa69..b362add5c 100644
--- a/crates/hir_def/src/item_tree/tests.rs
+++ b/crates/hir_def/src/item_tree/tests.rs
@@ -180,7 +180,7 @@ trait Tr: SuperTrait + 'lifetime {
                 _: (),
             ) -> ();
 
-            pub(self) trait Tr<Self>: SuperTrait + 'lifetime
+            pub(self) trait Tr<Self>
             where
                 Self: SuperTrait,
                 Self: 'lifetime
@@ -350,7 +350,7 @@ trait Tr<'a, T: 'a>: Super {}
             pub(self) union Union<'a, T, const U: u8> {
             }
 
-            pub(self) trait Tr<'a, Self, T>: Super
+            pub(self) trait Tr<'a, Self, T>
             where
                 Self: Super,
                 T: 'a
diff --git a/crates/hir_def/src/nameres/collector.rs b/crates/hir_def/src/nameres/collector.rs
index 716dcf1f7..7f9fdb379 100644
--- a/crates/hir_def/src/nameres/collector.rs
+++ b/crates/hir_def/src/nameres/collector.rs
@@ -477,16 +477,21 @@ impl DefCollector<'_> {
     /// going out of sync with what the build system sees (since we resolve using VFS state, but
     /// Cargo builds only on-disk files). We could and probably should add diagnostics for that.
     fn export_proc_macro(&mut self, def: ProcMacroDef, ast_id: AstId<ast::Fn>) {
+        let kind = def.kind.to_basedb_kind();
         self.exports_proc_macros = true;
         let macro_def = match self.proc_macros.iter().find(|(n, _)| n == &def.name) {
             Some((_, expander)) => MacroDefId {
                 krate: self.def_map.krate,
-                kind: MacroDefKind::ProcMacro(*expander, ast_id),
+                kind: MacroDefKind::ProcMacro(*expander, kind, ast_id),
                 local_inner: false,
             },
             None => MacroDefId {
                 krate: self.def_map.krate,
-                kind: MacroDefKind::ProcMacro(ProcMacroExpander::dummy(self.def_map.krate), ast_id),
+                kind: MacroDefKind::ProcMacro(
+                    ProcMacroExpander::dummy(self.def_map.krate),
+                    kind,
+                    ast_id,
+                ),
                 local_inner: false,
             },
         };
@@ -1674,14 +1679,22 @@ impl ModCollector<'_, '_> {
                 None => &mac.name,
             };
             let krate = self.def_collector.def_map.krate;
-            if let Some(macro_id) = find_builtin_macro(name, krate, ast_id) {
-                self.def_collector.define_macro_rules(
-                    self.module_id,
-                    mac.name.clone(),
-                    macro_id,
-                    is_export,
-                );
-                return;
+            match find_builtin_macro(name, krate, ast_id) {
+                Some(macro_id) => {
+                    self.def_collector.define_macro_rules(
+                        self.module_id,
+                        mac.name.clone(),
+                        macro_id,
+                        is_export,
+                    );
+                    return;
+                }
+                None => {
+                    self.def_collector
+                        .def_map
+                        .diagnostics
+                        .push(DefDiagnostic::unimplemented_builtin_macro(self.module_id, ast_id));
+                }
             }
         }
 
@@ -1710,15 +1723,23 @@ impl ModCollector<'_, '_> {
             let macro_id = find_builtin_macro(&mac.name, krate, ast_id)
                 .or_else(|| find_builtin_derive(&mac.name, krate, ast_id));
 
-            if let Some(macro_id) = macro_id {
-                self.def_collector.define_macro_def(
-                    self.module_id,
-                    mac.name.clone(),
-                    macro_id,
-                    &self.item_tree[mac.visibility],
-                );
+            match macro_id {
+                Some(macro_id) => {
+                    self.def_collector.define_macro_def(
+                        self.module_id,
+                        mac.name.clone(),
+                        macro_id,
+                        &self.item_tree[mac.visibility],
+                    );
+                    return;
+                }
+                None => {
+                    self.def_collector
+                        .def_map
+                        .diagnostics
+                        .push(DefDiagnostic::unimplemented_builtin_macro(self.module_id, ast_id));
+                }
             }
-            return;
         }
 
         // Case 2: normal `macro`
diff --git a/crates/hir_def/src/nameres/diagnostics.rs b/crates/hir_def/src/nameres/diagnostics.rs
index 57c36c3c6..95061f601 100644
--- a/crates/hir_def/src/nameres/diagnostics.rs
+++ b/crates/hir_def/src/nameres/diagnostics.rs
@@ -27,6 +27,8 @@ pub enum DefDiagnosticKind {
     UnresolvedMacroCall { ast: AstId<ast::MacroCall>, path: ModPath },
 
     MacroError { ast: MacroCallKind, message: String },
+
+    UnimplementedBuiltinMacro { ast: AstId<ast::Macro> },
 }
 
 #[derive(Debug, PartialEq, Eq)]
@@ -93,4 +95,11 @@ impl DefDiagnostic {
     ) -> Self {
         Self { in_module: container, kind: DefDiagnosticKind::UnresolvedMacroCall { ast, path } }
     }
+
+    pub(super) fn unimplemented_builtin_macro(
+        container: LocalModuleId,
+        ast: AstId<ast::Macro>,
+    ) -> Self {
+        Self { in_module: container, kind: DefDiagnosticKind::UnimplementedBuiltinMacro { ast } }
+    }
 }
diff --git a/crates/hir_def/src/nameres/proc_macro.rs b/crates/hir_def/src/nameres/proc_macro.rs
index 156598f19..3f095d623 100644
--- a/crates/hir_def/src/nameres/proc_macro.rs
+++ b/crates/hir_def/src/nameres/proc_macro.rs
@@ -18,6 +18,16 @@ pub(super) enum ProcMacroKind {
     Attr,
 }
 
+impl ProcMacroKind {
+    pub(super) fn to_basedb_kind(&self) -> base_db::ProcMacroKind {
+        match self {
+            ProcMacroKind::CustomDerive { .. } => base_db::ProcMacroKind::CustomDerive,
+            ProcMacroKind::FnLike => base_db::ProcMacroKind::FuncLike,
+            ProcMacroKind::Attr => base_db::ProcMacroKind::Attr,
+        }
+    }
+}
+
 impl Attrs {
     #[rustfmt::skip]
     pub(super) fn parse_proc_macro_decl(&self, func_name: &Name) -> Option<ProcMacroDef> {
diff --git a/crates/hir_def/src/nameres/tests/incremental.rs b/crates/hir_def/src/nameres/tests/incremental.rs
index d884a6eb4..7bf152e26 100644
--- a/crates/hir_def/src/nameres/tests/incremental.rs
+++ b/crates/hir_def/src/nameres/tests/incremental.rs
@@ -1,6 +1,8 @@
 use std::sync::Arc;
 
-use base_db::SourceDatabaseExt;
+use base_db::{salsa::SweepStrategy, SourceDatabaseExt};
+
+use crate::{AdtId, ModuleDefId};
 
 use super::*;
 
@@ -163,3 +165,73 @@ m!(Z);
         assert_eq!(n_reparsed_macros, 0);
     }
 }
+
+#[test]
+fn item_tree_prevents_reparsing() {
+    // The `ItemTree` is used by both name resolution and the various queries in `adt.rs` and
+    // `data.rs`. After computing the `ItemTree` and deleting the parse tree, we should be able to
+    // run those other queries without triggering a reparse.
+
+    let (db, pos) = TestDB::with_position(
+        r#"
+pub struct S;
+pub union U {}
+pub enum E {
+    Variant,
+}
+pub fn f(_: S) { $0 }
+pub trait Tr {}
+impl Tr for () {}
+pub const C: u8 = 0;
+pub static ST: u8 = 0;
+pub type Ty = ();
+"#,
+    );
+    let krate = db.test_crate();
+    {
+        let events = db.log_executed(|| {
+            db.file_item_tree(pos.file_id.into());
+        });
+        let n_calculated_item_trees = events.iter().filter(|it| it.contains("item_tree")).count();
+        assert_eq!(n_calculated_item_trees, 1);
+        let n_parsed_files = events.iter().filter(|it| it.contains("parse(")).count();
+        assert_eq!(n_parsed_files, 1);
+    }
+
+    // Delete the parse tree.
+    let sweep = SweepStrategy::default().discard_values().sweep_all_revisions();
+    base_db::ParseQuery.in_db(&db).sweep(sweep);
+
+    {
+        let events = db.log_executed(|| {
+            let crate_def_map = db.crate_def_map(krate);
+            let (_, module_data) = crate_def_map.modules.iter().last().unwrap();
+            assert_eq!(module_data.scope.resolutions().count(), 8);
+            assert_eq!(module_data.scope.impls().count(), 1);
+
+            for imp in module_data.scope.impls() {
+                db.impl_data(imp);
+            }
+
+            for (_, res) in module_data.scope.resolutions() {
+                match res.values.or(res.types).unwrap().0 {
+                    ModuleDefId::FunctionId(f) => drop(db.function_data(f)),
+                    ModuleDefId::AdtId(adt) => match adt {
+                        AdtId::StructId(it) => drop(db.struct_data(it)),
+                        AdtId::UnionId(it) => drop(db.union_data(it)),
+                        AdtId::EnumId(it) => drop(db.enum_data(it)),
+                    },
+                    ModuleDefId::ConstId(it) => drop(db.const_data(it)),
+                    ModuleDefId::StaticId(it) => drop(db.static_data(it)),
+                    ModuleDefId::TraitId(it) => drop(db.trait_data(it)),
+                    ModuleDefId::TypeAliasId(it) => drop(db.type_alias_data(it)),
+                    ModuleDefId::EnumVariantId(_)
+                    | ModuleDefId::ModuleId(_)
+                    | ModuleDefId::BuiltinType(_) => unreachable!(),
+                }
+            }
+        });
+        let n_reparsed_files = events.iter().filter(|it| it.contains("parse(")).count();
+        assert_eq!(n_reparsed_files, 0);
+    }
+}
diff --git a/crates/hir_def/src/test_db.rs b/crates/hir_def/src/test_db.rs
index a9c1e13e2..e840fe5e8 100644
--- a/crates/hir_def/src/test_db.rs
+++ b/crates/hir_def/src/test_db.rs
@@ -298,6 +298,13 @@ impl TestDB {
                     DefDiagnosticKind::MacroError { ast, message } => {
                         (ast.to_node(self.upcast()), message.as_str())
                     }
+                    DefDiagnosticKind::UnimplementedBuiltinMacro { ast } => {
+                        let node = ast.to_node(self.upcast());
+                        (
+                            InFile::new(ast.file_id, node.syntax().clone()),
+                            "UnimplementedBuiltinMacro",
+                        )
+                    }
                 };
 
                 let frange = node.as_ref().original_file_range(self);
diff --git a/crates/hir_expand/src/builtin_macro.rs b/crates/hir_expand/src/builtin_macro.rs
index 94d7aecb6..0b310ba2f 100644
--- a/crates/hir_expand/src/builtin_macro.rs
+++ b/crates/hir_expand/src/builtin_macro.rs
@@ -8,7 +8,6 @@ use base_db::{AnchoredPath, Edition, FileId};
 use cfg::CfgExpr;
 use either::Either;
 use mbe::{parse_exprs_with_sep, parse_to_token_tree, ExpandResult};
-use parser::FragmentKind;
 use syntax::ast::{self, AstToken};
 
 macro_rules! register_builtin {
@@ -47,7 +46,7 @@ macro_rules! register_builtin {
                 let expander = match *self {
                     $( EagerExpander::$e_kind => $e_expand, )*
                 };
-                expander(db,arg_id,tt)
+                expander(db, arg_id, tt)
             }
         }
 
@@ -64,14 +63,13 @@ macro_rules! register_builtin {
 #[derive(Debug)]
 pub struct ExpandedEager {
     pub(crate) subtree: tt::Subtree,
-    pub(crate) fragment: FragmentKind,
     /// The included file ID of the include macro.
     pub(crate) included_file: Option<FileId>,
 }
 
 impl ExpandedEager {
-    fn new(subtree: tt::Subtree, fragment: FragmentKind) -> Self {
-        ExpandedEager { subtree, fragment, included_file: None }
+    fn new(subtree: tt::Subtree) -> Self {
+        ExpandedEager { subtree, included_file: None }
     }
 }
 
@@ -340,7 +338,7 @@ fn compile_error_expand(
         _ => mbe::ExpandError::BindingError("`compile_error!` argument must be a string".into()),
     };
 
-    ExpandResult { value: Some(ExpandedEager::new(quote! {}, FragmentKind::Items)), err: Some(err) }
+    ExpandResult { value: Some(ExpandedEager::new(quote! {})), err: Some(err) }
 }
 
 fn concat_expand(
@@ -371,7 +369,7 @@ fn concat_expand(
             }
         }
     }
-    ExpandResult { value: Some(ExpandedEager::new(quote!(#text), FragmentKind::Expr)), err }
+    ExpandResult { value: Some(ExpandedEager::new(quote!(#text))), err }
 }
 
 fn concat_idents_expand(
@@ -393,7 +391,7 @@ fn concat_idents_expand(
         }
     }
     let ident = tt::Ident { text: ident.into(), id: tt::TokenId::unspecified() };
-    ExpandResult { value: Some(ExpandedEager::new(quote!(#ident), FragmentKind::Expr)), err }
+    ExpandResult { value: Some(ExpandedEager::new(quote!(#ident))), err }
 }
 
 fn relative_file(
@@ -442,14 +440,7 @@ fn include_expand(
 
     match res {
         Ok((subtree, file_id)) => {
-            // FIXME:
-            // Handle include as expression
-
-            ExpandResult::ok(Some(ExpandedEager {
-                subtree,
-                fragment: FragmentKind::Items,
-                included_file: Some(file_id),
-            }))
+            ExpandResult::ok(Some(ExpandedEager { subtree, included_file: Some(file_id) }))
         }
         Err(e) => ExpandResult::only_err(e),
     }
@@ -472,7 +463,7 @@ fn include_bytes_expand(
             id: tt::TokenId::unspecified(),
         }))],
     };
-    ExpandResult::ok(Some(ExpandedEager::new(res, FragmentKind::Expr)))
+    ExpandResult::ok(Some(ExpandedEager::new(res)))
 }
 
 fn include_str_expand(
@@ -492,14 +483,14 @@ fn include_str_expand(
     let file_id = match relative_file(db, arg_id.into(), &path, true) {
         Ok(file_id) => file_id,
         Err(_) => {
-            return ExpandResult::ok(Some(ExpandedEager::new(quote!(""), FragmentKind::Expr)));
+            return ExpandResult::ok(Some(ExpandedEager::new(quote!(""))));
         }
     };
 
     let text = db.file_text(file_id);
     let text = &*text;
 
-    ExpandResult::ok(Some(ExpandedEager::new(quote!(#text), FragmentKind::Expr)))
+    ExpandResult::ok(Some(ExpandedEager::new(quote!(#text))))
 }
 
 fn get_env_inner(db: &dyn AstDatabase, arg_id: MacroCallId, key: &str) -> Option<String> {
@@ -535,7 +526,7 @@ fn env_expand(
     });
     let expanded = quote! { #s };
 
-    ExpandResult { value: Some(ExpandedEager::new(expanded, FragmentKind::Expr)), err }
+    ExpandResult { value: Some(ExpandedEager::new(expanded)), err }
 }
 
 fn option_env_expand(
@@ -553,7 +544,7 @@ fn option_env_expand(
         Some(s) => quote! { std::option::Some(#s) },
     };
 
-    ExpandResult::ok(Some(ExpandedEager::new(expanded, FragmentKind::Expr)))
+    ExpandResult::ok(Some(ExpandedEager::new(expanded)))
 }
 
 #[cfg(test)]
@@ -565,6 +556,7 @@ mod tests {
     };
     use base_db::{fixture::WithFixture, SourceDatabase};
     use expect_test::{expect, Expect};
+    use parser::FragmentKind;
     use std::sync::Arc;
     use syntax::ast::NameOwner;
 
@@ -617,6 +609,7 @@ mod tests {
                     local_inner: false,
                 };
 
+                let fragment = crate::to_fragment_kind(&macro_call);
                 let args = macro_call.token_tree().unwrap();
                 let parsed_args = mbe::ast_to_token_tree(&args).0;
                 let call_id = AstId::new(file_id.into(), ast_id_map.ast_id(&macro_call));
@@ -639,7 +632,7 @@ mod tests {
                         arg_or_expansion: Arc::new(expanded.subtree),
                         included_file: expanded.included_file,
                     }),
-                    kind: MacroCallKind::FnLike { ast_id: call_id, fragment: expanded.fragment },
+                    kind: MacroCallKind::FnLike { ast_id: call_id, fragment },
                 };
 
                 let id: MacroCallId = db.intern_macro(loc).into();
diff --git a/crates/hir_expand/src/eager.rs b/crates/hir_expand/src/eager.rs
index 1464320ba..14af628a1 100644
--- a/crates/hir_expand/src/eager.rs
+++ b/crates/hir_expand/src/eager.rs
@@ -113,6 +113,7 @@ pub fn expand_eager_macro(
 
     let ast_map = db.ast_id_map(macro_call.file_id);
     let call_id = InFile::new(macro_call.file_id, ast_map.ast_id(&macro_call.value));
+    let fragment = crate::to_fragment_kind(&macro_call.value);
 
     // Note:
     // When `lazy_expand` is called, its *parent* file must be already exists.
@@ -152,7 +153,7 @@ pub fn expand_eager_macro(
                 arg_or_expansion: Arc::new(expanded.subtree),
                 included_file: expanded.included_file,
             }),
-            kind: MacroCallKind::FnLike { ast_id: call_id, fragment: expanded.fragment },
+            kind: MacroCallKind::FnLike { ast_id: call_id, fragment },
         };
 
         Ok(db.intern_macro(loc))
diff --git a/crates/hir_expand/src/lib.rs b/crates/hir_expand/src/lib.rs
index 10d37234e..90d8ae240 100644
--- a/crates/hir_expand/src/lib.rs
+++ b/crates/hir_expand/src/lib.rs
@@ -15,6 +15,7 @@ pub mod quote;
 pub mod eager;
 mod input;
 
+use base_db::ProcMacroKind;
 use either::Either;
 
 pub use mbe::{ExpandError, ExpandResult};
@@ -207,7 +208,7 @@ impl MacroDefId {
             MacroDefKind::BuiltIn(_, id) => id,
             MacroDefKind::BuiltInDerive(_, id) => id,
             MacroDefKind::BuiltInEager(_, id) => id,
-            MacroDefKind::ProcMacro(_, id) => return Either::Right(*id),
+            MacroDefKind::ProcMacro(.., id) => return Either::Right(*id),
         };
         Either::Left(*id)
     }
@@ -224,7 +225,7 @@ pub enum MacroDefKind {
     // FIXME: maybe just Builtin and rename BuiltinFnLikeExpander to BuiltinExpander
     BuiltInDerive(BuiltinDeriveExpander, AstId<ast::Macro>),
     BuiltInEager(EagerExpander, AstId<ast::Macro>),
-    ProcMacro(ProcMacroExpander, AstId<ast::Fn>),
+    ProcMacro(ProcMacroExpander, ProcMacroKind, AstId<ast::Fn>),
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
diff --git a/crates/hir_ty/Cargo.toml b/crates/hir_ty/Cargo.toml
index a9994082a..c3d02424d 100644
--- a/crates/hir_ty/Cargo.toml
+++ b/crates/hir_ty/Cargo.toml
@@ -18,9 +18,9 @@ ena = "0.14.0"
 log = "0.4.8"
 rustc-hash = "1.1.0"
 scoped-tls = "1"
-chalk-solve = { version = "0.67", default-features = false }
-chalk-ir = "0.67"
-chalk-recursive = "0.67"
+chalk-solve = { version = "0.68", default-features = false }
+chalk-ir = "0.68"
+chalk-recursive = "0.68"
 la-arena = { version = "0.2.0", path = "../../lib/arena" }
 
 stdx = { path = "../stdx", version = "0.0.0" }
diff --git a/crates/hir_ty/src/chalk_db.rs b/crates/hir_ty/src/chalk_db.rs
index b108fd559..4e042bf42 100644
--- a/crates/hir_ty/src/chalk_db.rs
+++ b/crates/hir_ty/src/chalk_db.rs
@@ -383,7 +383,7 @@ pub(crate) fn associated_ty_data_query(
     // Lower bounds -- we could/should maybe move this to a separate query in `lower`
     let type_alias_data = db.type_alias_data(type_alias);
     let generic_params = generics(db.upcast(), type_alias.into());
-    let bound_vars = generic_params.bound_vars_subst(DebruijnIndex::INNERMOST);
+    // let bound_vars = generic_params.bound_vars_subst(DebruijnIndex::INNERMOST);
     let resolver = hir_def::resolver::HasResolver::resolver(type_alias, db.upcast());
     let ctx = crate::TyLoweringContext::new(db, &resolver)
         .with_type_param_mode(crate::lower::TypeParamLoweringMode::Variable);
@@ -396,8 +396,10 @@ pub(crate) fn associated_ty_data_query(
         .filter_map(|pred| generic_predicate_to_inline_bound(db, &pred, &self_ty))
         .collect();
 
-    let where_clauses = convert_where_clauses(db, type_alias.into(), &bound_vars);
-    let bound_data = rust_ir::AssociatedTyDatumBound { bounds, where_clauses };
+    // FIXME: Re-enable where clauses on associated types when an upstream chalk bug is fixed.
+    //        (rust-analyzer#9052)
+    // let where_clauses = convert_where_clauses(db, type_alias.into(), &bound_vars);
+    let bound_data = rust_ir::AssociatedTyDatumBound { bounds, where_clauses: vec![] };
     let datum = AssociatedTyDatum {
         trait_id: to_chalk_trait_id(trait_),
         id,
diff --git a/crates/hir_ty/src/infer.rs b/crates/hir_ty/src/infer.rs
index 8cefd80f3..7a4268819 100644
--- a/crates/hir_ty/src/infer.rs
+++ b/crates/hir_ty/src/infer.rs
@@ -558,7 +558,13 @@ impl<'a> InferenceContext<'a> {
 
             self.infer_pat(*pat, &ty, BindingMode::default());
         }
-        let return_ty = self.make_ty_with_mode(&data.ret_type, ImplTraitLoweringMode::Disallowed); // FIXME implement RPIT
+        let error_ty = &TypeRef::Error;
+        let return_ty = if data.is_async() {
+            data.async_ret_type.as_deref().unwrap_or(error_ty)
+        } else {
+            &*data.ret_type
+        };
+        let return_ty = self.make_ty_with_mode(return_ty, ImplTraitLoweringMode::Disallowed); // FIXME implement RPIT
         self.return_ty = return_ty;
     }
 
diff --git a/crates/hir_ty/src/tests.rs b/crates/hir_ty/src/tests.rs
index cc819373c..9d726b024 100644
--- a/crates/hir_ty/src/tests.rs
+++ b/crates/hir_ty/src/tests.rs
@@ -7,6 +7,7 @@ mod traits;
 mod method_resolution;
 mod macros;
 mod display_source_code;
+mod incremental;
 
 use std::{env, sync::Arc};
 
@@ -317,50 +318,6 @@ fn ellipsize(mut text: String, max_len: usize) -> String {
     text
 }
 
-#[test]
-fn typing_whitespace_inside_a_function_should_not_invalidate_types() {
-    let (mut db, pos) = TestDB::with_position(
-        "
-        //- /lib.rs
-        fn foo() -> i32 {
-            $01 + 1
-        }
-    ",
-    );
-    {
-        let events = db.log_executed(|| {
-            let module = db.module_for_file(pos.file_id);
-            let crate_def_map = module.def_map(&db);
-            visit_module(&db, &crate_def_map, module.local_id, &mut |def| {
-                db.infer(def);
-            });
-        });
-        assert!(format!("{:?}", events).contains("infer"))
-    }
-
-    let new_text = "
-        fn foo() -> i32 {
-            1
-            +
-            1
-        }
-    "
-    .to_string();
-
-    db.set_file_text(pos.file_id, Arc::new(new_text));
-
-    {
-        let events = db.log_executed(|| {
-            let module = db.module_for_file(pos.file_id);
-            let crate_def_map = module.def_map(&db);
-            visit_module(&db, &crate_def_map, module.local_id, &mut |def| {
-                db.infer(def);
-            });
-        });
-        assert!(!format!("{:?}", events).contains("infer"), "{:#?}", events)
-    }
-}
-
 fn check_infer(ra_fixture: &str, expect: Expect) {
     let mut actual = infer(ra_fixture);
     actual.push('\n');
diff --git a/crates/hir_ty/src/tests/incremental.rs b/crates/hir_ty/src/tests/incremental.rs
new file mode 100644
index 000000000..3e08e83e8
--- /dev/null
+++ b/crates/hir_ty/src/tests/incremental.rs
@@ -0,0 +1,51 @@
+use std::sync::Arc;
+
+use base_db::{fixture::WithFixture, SourceDatabaseExt};
+
+use crate::{db::HirDatabase, test_db::TestDB};
+
+use super::visit_module;
+
+#[test]
+fn typing_whitespace_inside_a_function_should_not_invalidate_types() {
+    let (mut db, pos) = TestDB::with_position(
+        "
+        //- /lib.rs
+        fn foo() -> i32 {
+            $01 + 1
+        }
+    ",
+    );
+    {
+        let events = db.log_executed(|| {
+            let module = db.module_for_file(pos.file_id);
+            let crate_def_map = module.def_map(&db);
+            visit_module(&db, &crate_def_map, module.local_id, &mut |def| {
+                db.infer(def);
+            });
+        });
+        assert!(format!("{:?}", events).contains("infer"))
+    }
+
+    let new_text = "
+        fn foo() -> i32 {
+            1
+            +
+            1
+        }
+    "
+    .to_string();
+
+    db.set_file_text(pos.file_id, Arc::new(new_text));
+
+    {
+        let events = db.log_executed(|| {
+            let module = db.module_for_file(pos.file_id);
+            let crate_def_map = module.def_map(&db);
+            visit_module(&db, &crate_def_map, module.local_id, &mut |def| {
+                db.infer(def);
+            });
+        });
+        assert!(!format!("{:?}", events).contains("infer"), "{:#?}", events)
+    }
+}
diff --git a/crates/hir_ty/src/tests/macros.rs b/crates/hir_ty/src/tests/macros.rs
index 6588aa46c..7647bb08b 100644
--- a/crates/hir_ty/src/tests/macros.rs
+++ b/crates/hir_ty/src/tests/macros.rs
@@ -752,6 +752,24 @@ fn bar() -> u32 {0}
 }
 
 #[test]
+fn infer_builtin_macros_include_expression() {
+    check_types(
+        r#"
+//- /main.rs
+#[rustc_builtin_macro]
+macro_rules! include {() => {}}
+fn main() {
+    let i = include!("bla.rs");
+    i;
+  //^ i32
+}
+//- /bla.rs
+0
+        "#,
+    )
+}
+
+#[test]
 fn infer_builtin_macros_include_child_mod() {
     check_types(
         r#"
diff --git a/crates/hir_ty/src/tests/traits.rs b/crates/hir_ty/src/tests/traits.rs
index 6ad96bfe3..49add4ab9 100644
--- a/crates/hir_ty/src/tests/traits.rs
+++ b/crates/hir_ty/src/tests/traits.rs
@@ -161,7 +161,7 @@ mod result {
 }
 
 #[test]
-fn infer_tryv2() {
+fn infer_try_trait_v2() {
     check_types(
         r#"
 //- /main.rs crate:main deps:core
@@ -172,26 +172,41 @@ fn test() {
 } //^ i32
 
 //- /core.rs crate:core
-#[prelude_import] use ops::*;
 mod ops {
-    trait Try {
-        type Output;
-        type Residual;
+    mod try_trait {
+        pub trait Try: FromResidual {
+            type Output;
+            type Residual;
+        }
+        pub trait FromResidual<R = <Self as Try>::Residual> {}
     }
+
+    pub use self::try_trait::FromResidual;
+    pub use self::try_trait::Try;
+}
+
+mov convert {
+    pub trait From<T> {}
+    impl<T> From<T> for T {}
 }
 
 #[prelude_import] use result::*;
 mod result {
-    enum Infallible {}
-    enum Result<O, E> {
+    use crate::convert::From;
+    use crate::ops::{Try, FromResidual};
+
+    pub enum Infallible {}
+    pub enum Result<O, E> {
         Ok(O),
         Err(E)
     }
 
-    impl<O, E> crate::ops::Try for Result<O, E> {
+    impl<O, E> Try for Result<O, E> {
         type Output = O;
         type Error = Result<Infallible, E>;
     }
+
+    impl<T, E, F: From<E>> FromResidual<Result<Infallible, E>> for Result<T, F> {}
 }
 "#,
     );
@@ -3660,3 +3675,52 @@ impl foo::Foo for u32 {
         "#]],
     );
 }
+
+#[test]
+fn infer_async_ret_type() {
+    check_types(
+        r#"
+//- /main.rs crate:main deps:core
+
+enum Result<T, E> {
+    Ok(T),
+    Err(E),
+}
+
+use Result::*;
+
+
+struct Fooey;
+
+impl Fooey {
+    fn collect<B: Convert>(self) -> B {
+        B::new()
+    }
+}
+
+trait Convert {
+    fn new() -> Self;
+}
+impl Convert for u32 {
+    fn new() -> Self {
+        0
+    }
+}
+
+async fn get_accounts() -> Result<u32, ()> {
+    let ret = Fooey.collect();
+    //                      ^ u32
+    Ok(ret)
+}
+
+//- /core.rs crate:core
+#[prelude_import] use future::*;
+mod future {
+    #[lang = "future_trait"]
+    trait Future {
+        type Output;
+    }
+}
+"#,
+    );
+}
diff --git a/crates/ide/src/annotations.rs b/crates/ide/src/annotations.rs
index b0c4ed60a..8d68dce05 100644
--- a/crates/ide/src/annotations.rs
+++ b/crates/ide/src/annotations.rs
@@ -58,7 +58,7 @@ pub(crate) fn annotations(
             }
 
             let action = runnable.action();
-            let range = runnable.nav.full_range;
+            let range = runnable.nav.focus_or_full_range();
 
             if config.run {
                 annotations.push(Annotation {
@@ -224,7 +224,7 @@ fn main() {
             expect![[r#"
                 [
                     Annotation {
-                        range: 50..85,
+                        range: 53..57,
                         kind: Runnable {
                             debug: false,
                             runnable: Runnable {
@@ -243,7 +243,7 @@ fn main() {
                         },
                     },
                     Annotation {
-                        range: 50..85,
+                        range: 53..57,
                         kind: Runnable {
                             debug: true,
                             runnable: Runnable {
@@ -328,7 +328,7 @@ fn main() {
             expect![[r#"
                 [
                     Annotation {
-                        range: 14..48,
+                        range: 17..21,
                         kind: Runnable {
                             debug: false,
                             runnable: Runnable {
@@ -347,7 +347,7 @@ fn main() {
                         },
                     },
                     Annotation {
-                        range: 14..48,
+                        range: 17..21,
                         kind: Runnable {
                             debug: true,
                             runnable: Runnable {
@@ -436,7 +436,7 @@ fn main() {
             expect![[r#"
                 [
                     Annotation {
-                        range: 66..100,
+                        range: 69..73,
                         kind: Runnable {
                             debug: false,
                             runnable: Runnable {
@@ -455,7 +455,7 @@ fn main() {
                         },
                     },
                     Annotation {
-                        range: 66..100,
+                        range: 69..73,
                         kind: Runnable {
                             debug: true,
                             runnable: Runnable {
@@ -597,7 +597,7 @@ fn main() {}
             expect![[r#"
                 [
                     Annotation {
-                        range: 0..12,
+                        range: 3..7,
                         kind: Runnable {
                             debug: false,
                             runnable: Runnable {
@@ -616,7 +616,7 @@ fn main() {}
                         },
                     },
                     Annotation {
-                        range: 0..12,
+                        range: 3..7,
                         kind: Runnable {
                             debug: true,
                             runnable: Runnable {
@@ -670,7 +670,7 @@ fn main() {
             expect![[r#"
                 [
                     Annotation {
-                        range: 58..95,
+                        range: 61..65,
                         kind: Runnable {
                             debug: false,
                             runnable: Runnable {
@@ -689,7 +689,7 @@ fn main() {
                         },
                     },
                     Annotation {
-                        range: 58..95,
+                        range: 61..65,
                         kind: Runnable {
                             debug: true,
                             runnable: Runnable {
@@ -812,7 +812,7 @@ mod tests {
             expect![[r#"
                 [
                     Annotation {
-                        range: 0..12,
+                        range: 3..7,
                         kind: Runnable {
                             debug: false,
                             runnable: Runnable {
@@ -831,7 +831,7 @@ mod tests {
                         },
                     },
                     Annotation {
-                        range: 0..12,
+                        range: 3..7,
                         kind: Runnable {
                             debug: true,
                             runnable: Runnable {
@@ -850,7 +850,7 @@ mod tests {
                         },
                     },
                     Annotation {
-                        range: 14..64,
+                        range: 18..23,
                         kind: Runnable {
                             debug: false,
                             runnable: Runnable {
@@ -871,7 +871,7 @@ mod tests {
                         },
                     },
                     Annotation {
-                        range: 14..64,
+                        range: 18..23,
                         kind: Runnable {
                             debug: true,
                             runnable: Runnable {
@@ -892,7 +892,7 @@ mod tests {
                         },
                     },
                     Annotation {
-                        range: 30..62,
+                        range: 45..57,
                         kind: Runnable {
                             debug: false,
                             runnable: Runnable {
@@ -918,7 +918,7 @@ mod tests {
                         },
                     },
                     Annotation {
-                        range: 30..62,
+                        range: 45..57,
                         kind: Runnable {
                             debug: true,
                             runnable: Runnable {
diff --git a/crates/ide/src/diagnostics.rs b/crates/ide/src/diagnostics.rs
index 6cf5810fa..d5c954b8b 100644
--- a/crates/ide/src/diagnostics.rs
+++ b/crates/ide/src/diagnostics.rs
@@ -182,6 +182,11 @@ pub(crate) fn diagnostics(
             res.borrow_mut()
                 .push(Diagnostic::error(display_range, d.message()).with_code(Some(d.code())));
         })
+        .on::<hir::diagnostics::UnimplementedBuiltinMacro, _>(|d| {
+            let display_range = sema.diagnostics_display_range(d.display_source()).range;
+            res.borrow_mut()
+                .push(Diagnostic::hint(display_range, d.message()).with_code(Some(d.code())));
+        })
         // Only collect experimental diagnostics when they're enabled.
         .filter(|diag| !(diag.is_experimental() && config.disable_experimental))
         .filter(|diag| !config.disabled.contains(diag.code().as_str()));
diff --git a/crates/ide/src/fixture.rs b/crates/ide/src/fixture.rs
index cc6641ba1..6780af617 100644
--- a/crates/ide/src/fixture.rs
+++ b/crates/ide/src/fixture.rs
@@ -1,7 +1,7 @@
 //! Utilities for creating `Analysis` instances for tests.
 use ide_db::base_db::fixture::ChangeFixture;
 use syntax::{TextRange, TextSize};
-use test_utils::{extract_annotations, RangeOrOffset};
+use test_utils::extract_annotations;
 
 use crate::{Analysis, AnalysisHost, FileId, FilePosition, FileRange};
 
@@ -27,10 +27,7 @@ pub(crate) fn position(ra_fixture: &str) -> (Analysis, FilePosition) {
     let change_fixture = ChangeFixture::parse(ra_fixture);
     host.db.apply_change(change_fixture.change);
     let (file_id, range_or_offset) = change_fixture.file_position.expect("expected a marker ($0)");
-    let offset = match range_or_offset {
-        RangeOrOffset::Range(_) => panic!(),
-        RangeOrOffset::Offset(it) => it,
-    };
+    let offset = range_or_offset.expect_offset();
     (host.analysis(), FilePosition { file_id, offset })
 }
 
@@ -40,10 +37,7 @@ pub(crate) fn range(ra_fixture: &str) -> (Analysis, FileRange) {
     let change_fixture = ChangeFixture::parse(ra_fixture);
     host.db.apply_change(change_fixture.change);
     let (file_id, range_or_offset) = change_fixture.file_position.expect("expected a marker ($0)");
-    let range = match range_or_offset {
-        RangeOrOffset::Range(it) => it,
-        RangeOrOffset::Offset(_) => panic!(),
-    };
+    let range = range_or_offset.expect_range();
     (host.analysis(), FileRange { file_id, range })
 }
 
@@ -53,10 +47,7 @@ pub(crate) fn annotations(ra_fixture: &str) -> (Analysis, FilePosition, Vec<(Fil
     let change_fixture = ChangeFixture::parse(ra_fixture);
     host.db.apply_change(change_fixture.change);
     let (file_id, range_or_offset) = change_fixture.file_position.expect("expected a marker ($0)");
-    let offset = match range_or_offset {
-        RangeOrOffset::Range(_) => panic!(),
-        RangeOrOffset::Offset(it) => it,
-    };
+    let offset = range_or_offset.expect_offset();
 
     let annotations = change_fixture
         .files
diff --git a/crates/ide/src/folding_ranges.rs b/crates/ide/src/folding_ranges.rs
index b893c1c54..c5015a345 100755
--- a/crates/ide/src/folding_ranges.rs
+++ b/crates/ide/src/folding_ranges.rs
@@ -19,6 +19,7 @@ pub enum FoldKind {
     Statics,
     Array,
     WhereClause,
+    ReturnType,
 }
 
 #[derive(Debug)]
@@ -131,6 +132,7 @@ fn fold_kind(kind: SyntaxKind) -> Option<FoldKind> {
         COMMENT => Some(FoldKind::Comment),
         ARG_LIST | PARAM_LIST => Some(FoldKind::ArgList),
         ARRAY_EXPR => Some(FoldKind::Array),
+        RET_TYPE => Some(FoldKind::ReturnType),
         ASSOC_ITEM_LIST
         | RECORD_FIELD_LIST
         | RECORD_PAT_FIELD_LIST
@@ -300,6 +302,7 @@ mod tests {
                 FoldKind::Statics => "statics",
                 FoldKind::Array => "array",
                 FoldKind::WhereClause => "whereclause",
+                FoldKind::ReturnType => "returntype",
             };
             assert_eq!(kind, &attr.unwrap());
         }
@@ -560,4 +563,18 @@ where
 "#,
         )
     }
+
+    #[test]
+    fn fold_return_type() {
+        check(
+            r#"
+fn foo()<fold returntype>-> (
+    bool,
+    bool,
+)</fold> { (true, true) }
+
+fn bar() -> (bool, bool) { (true, true) }
+            "#,
+        )
+    }
 }
diff --git a/crates/ide_completion/Cargo.toml b/crates/ide_completion/Cargo.toml
index 6bd8a5500..ba81c9e04 100644
--- a/crates/ide_completion/Cargo.toml
+++ b/crates/ide_completion/Cargo.toml
@@ -15,6 +15,7 @@ itertools = "0.10.0"
 log = "0.4.8"
 rustc-hash = "1.1.0"
 either = "1.6.1"
+once_cell = "1.7"
 
 stdx = { path = "../stdx", version = "0.0.0" }
 syntax = { path = "../syntax", version = "0.0.0" }
diff --git a/crates/ide_completion/src/completions.rs b/crates/ide_completion/src/completions.rs
index 78154bf3e..151bf3783 100644
--- a/crates/ide_completion/src/completions.rs
+++ b/crates/ide_completion/src/completions.rs
@@ -18,7 +18,7 @@ pub(crate) mod unqualified_path;
 
 use std::iter;
 
-use hir::{known, ModPath, ScopeDef, Type};
+use hir::known;
 use ide_db::SymbolKind;
 
 use crate::{
@@ -69,12 +69,17 @@ impl Completions {
         items.into_iter().for_each(|item| self.add(item.into()))
     }
 
-    pub(crate) fn add_field(&mut self, ctx: &CompletionContext, field: hir::Field, ty: &Type) {
+    pub(crate) fn add_field(&mut self, ctx: &CompletionContext, field: hir::Field, ty: &hir::Type) {
         let item = render_field(RenderContext::new(ctx), field, ty);
         self.add(item);
     }
 
-    pub(crate) fn add_tuple_field(&mut self, ctx: &CompletionContext, field: usize, ty: &Type) {
+    pub(crate) fn add_tuple_field(
+        &mut self,
+        ctx: &CompletionContext,
+        field: usize,
+        ty: &hir::Type,
+    ) {
         let item = render_tuple_field(RenderContext::new(ctx), field, ty);
         self.add(item);
     }
@@ -89,8 +94,8 @@ impl Completions {
     pub(crate) fn add_resolution(
         &mut self,
         ctx: &CompletionContext,
-        local_name: String,
-        resolution: &ScopeDef,
+        local_name: hir::Name,
+        resolution: &hir::ScopeDef,
     ) {
         if let Some(item) = render_resolution(RenderContext::new(ctx), local_name, resolution) {
             self.add(item);
@@ -100,7 +105,7 @@ impl Completions {
     pub(crate) fn add_macro(
         &mut self,
         ctx: &CompletionContext,
-        name: Option<String>,
+        name: Option<hir::Name>,
         macro_: hir::MacroDef,
     ) {
         let name = match name {
@@ -116,7 +121,7 @@ impl Completions {
         &mut self,
         ctx: &CompletionContext,
         func: hir::Function,
-        local_name: Option<String>,
+        local_name: Option<hir::Name>,
     ) {
         if let Some(item) = render_fn(RenderContext::new(ctx), None, local_name, func) {
             self.add(item)
@@ -127,7 +132,7 @@ impl Completions {
         &mut self,
         ctx: &CompletionContext,
         func: hir::Function,
-        local_name: Option<String>,
+        local_name: Option<hir::Name>,
     ) {
         if let Some(item) = render_method(RenderContext::new(ctx), None, local_name, func) {
             self.add(item)
@@ -149,7 +154,7 @@ impl Completions {
         &mut self,
         ctx: &CompletionContext,
         variant: hir::Variant,
-        path: ModPath,
+        path: hir::ModPath,
     ) {
         if let Some(item) = render_variant_pat(RenderContext::new(ctx), variant, None, Some(path)) {
             self.add(item);
@@ -183,7 +188,7 @@ impl Completions {
         &mut self,
         ctx: &CompletionContext,
         variant: hir::Variant,
-        path: ModPath,
+        path: hir::ModPath,
     ) {
         let item = render_variant(RenderContext::new(ctx), None, None, variant, Some(path));
         self.add(item);
@@ -193,7 +198,7 @@ impl Completions {
         &mut self,
         ctx: &CompletionContext,
         variant: hir::Variant,
-        local_name: Option<String>,
+        local_name: Option<hir::Name>,
     ) {
         let item = render_variant(RenderContext::new(ctx), None, local_name, variant, None);
         self.add(item);
diff --git a/crates/ide_completion/src/completions/attribute.rs b/crates/ide_completion/src/completions/attribute.rs
index b1505c74b..76d926157 100644
--- a/crates/ide_completion/src/completions/attribute.rs
+++ b/crates/ide_completion/src/completions/attribute.rs
@@ -3,9 +3,9 @@
 //! This module uses a bit of static metadata to provide completions
 //! for built-in attributes.
 
-use itertools::Itertools;
-use rustc_hash::FxHashSet;
-use syntax::{ast, AstNode, T};
+use once_cell::sync::Lazy;
+use rustc_hash::{FxHashMap, FxHashSet};
+use syntax::{ast, AstNode, NodeOrToken, SyntaxKind, T};
 
 use crate::{
     context::CompletionContext,
@@ -14,33 +14,40 @@ use crate::{
     Completions,
 };
 
-pub(crate) fn complete_attribute(acc: &mut Completions, ctx: &CompletionContext) -> Option<()> {
-    if ctx.mod_declaration_under_caret.is_some() {
-        return None;
-    }
+mod derive;
+mod lint;
+pub(crate) use self::lint::LintCompletion;
 
+pub(crate) fn complete_attribute(acc: &mut Completions, ctx: &CompletionContext) -> Option<()> {
     let attribute = ctx.attribute_under_caret.as_ref()?;
-    match (attribute.path(), attribute.token_tree()) {
-        (Some(path), Some(token_tree)) => {
-            let path = path.syntax().text();
-            if path == "derive" {
-                complete_derive(acc, ctx, token_tree)
-            } else if path == "feature" {
-                complete_lint(acc, ctx, token_tree, FEATURES)
-            } else if path == "allow" || path == "warn" || path == "deny" || path == "forbid" {
-                complete_lint(acc, ctx, token_tree.clone(), DEFAULT_LINT_COMPLETIONS);
-                complete_lint(acc, ctx, token_tree, CLIPPY_LINTS);
+    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),
+            "feature" => lint::complete_lint(acc, ctx, token_tree, FEATURES),
+            "allow" | "warn" | "deny" | "forbid" => {
+                lint::complete_lint(acc, ctx, token_tree.clone(), lint::DEFAULT_LINT_COMPLETIONS);
+                lint::complete_lint(acc, ctx, token_tree, CLIPPY_LINTS);
             }
-        }
-        (_, Some(_token_tree)) => {}
-        _ => complete_attribute_start(acc, ctx, attribute),
+            _ => (),
+        },
+        (None, Some(_)) => (),
+        _ => complete_new_attribute(acc, ctx, attribute),
     }
     Some(())
 }
 
-fn complete_attribute_start(acc: &mut Completions, ctx: &CompletionContext, attribute: &ast::Attr) {
+fn complete_new_attribute(acc: &mut Completions, ctx: &CompletionContext, attribute: &ast::Attr) {
+    let attribute_annotated_item_kind = attribute.syntax().parent().map(|it| it.kind());
+    let attributes = attribute_annotated_item_kind.and_then(|kind| {
+        if ast::Expr::can_cast(kind) {
+            Some(EXPR_ATTRIBUTES)
+        } else {
+            KIND_TO_ATTRIBUTES.get(&kind).copied()
+        }
+    });
     let is_inner = attribute.kind() == ast::AttrKind::Inner;
-    for attr_completion in ATTRIBUTES.iter().filter(|compl| is_inner || !compl.prefer_inner) {
+
+    let add_completion = |attr_completion: &AttrCompletion| {
         let mut item = CompletionItem::new(
             CompletionKind::Attribute,
             ctx.source_range(),
@@ -56,9 +63,19 @@ fn complete_attribute_start(acc: &mut Completions, ctx: &CompletionContext, attr
             item.insert_snippet(cap, snippet);
         }
 
-        if attribute.kind() == ast::AttrKind::Inner || !attr_completion.prefer_inner {
+        if is_inner || !attr_completion.prefer_inner {
             acc.add(item.build());
         }
+    };
+
+    match attributes {
+        Some(applicable) => applicable
+            .iter()
+            .flat_map(|name| ATTRIBUTES.binary_search_by(|attr| attr.key().cmp(name)).ok())
+            .flat_map(|idx| ATTRIBUTES.get(idx))
+            .for_each(add_completion),
+        None if is_inner => ATTRIBUTES.iter().for_each(add_completion),
+        None => ATTRIBUTES.iter().filter(|compl| !compl.prefer_inner).for_each(add_completion),
     }
 }
 
@@ -70,6 +87,10 @@ struct AttrCompletion {
 }
 
 impl AttrCompletion {
+    fn key(&self) -> &'static str {
+        self.lookup.unwrap_or(self.label)
+    }
+
     const fn prefer_inner(self) -> AttrCompletion {
         AttrCompletion { prefer_inner: true, ..self }
     }
@@ -83,30 +104,122 @@ const fn attr(
     AttrCompletion { label, lookup, snippet, prefer_inner: false }
 }
 
+macro_rules! attrs {
+    // attributes applicable to all items
+    [@ { item $($tt:tt)* } {$($acc:tt)*}] => {
+        attrs!(@ { $($tt)* } { $($acc)*, "deprecated", "doc", "dochidden", "docalias", "must_use", "no_mangle" })
+    };
+    // attributes applicable to all adts
+    [@ { adt $($tt:tt)* } {$($acc:tt)*}] => {
+        attrs!(@ { $($tt)* } { $($acc)*, "derive", "repr" })
+    };
+    // attributes applicable to all linkable things aka functions/statics
+    [@ { linkable $($tt:tt)* } {$($acc:tt)*}] => {
+        attrs!(@ { $($tt)* } { $($acc)*, "export_name", "link_name", "link_section" })
+    };
+    // error fallback for nicer error message
+    [@ { $ty:ident $($tt:tt)* } {$($acc:tt)*}] => {
+        compile_error!(concat!("unknown attr subtype ", stringify!($ty)))
+    };
+    // general push down accumulation
+    [@ { $lit:literal $($tt:tt)*} {$($acc:tt)*}] => {
+        attrs!(@ { $($tt)* } { $($acc)*, $lit })
+    };
+    [@ {$($tt:tt)+} {$($tt2:tt)*}] => {
+        compile_error!(concat!("Unexpected input ", stringify!($($tt)+)))
+    };
+    // final output construction
+    [@ {} {$($tt:tt)*}] => { &[$($tt)*] as _ };
+    // starting matcher
+    [$($tt:tt),*] => {
+        attrs!(@ { $($tt)* } { "allow", "cfg", "cfg_attr", "deny", "forbid", "warn" })
+    };
+}
+
+#[rustfmt::skip]
+static KIND_TO_ATTRIBUTES: Lazy<FxHashMap<SyntaxKind, &[&str]>> = Lazy::new(|| {
+    use SyntaxKind::*;
+    std::array::IntoIter::new([
+        (
+            SOURCE_FILE,
+            attrs!(
+                item,
+                "crate_name", "feature", "no_implicit_prelude", "no_main", "no_std",
+                "recursion_limit", "type_length_limit", "windows_subsystem"
+            ),
+        ),
+        (MODULE, attrs!(item, "no_implicit_prelude", "path")),
+        (ITEM_LIST, attrs!(item, "no_implicit_prelude")),
+        (MACRO_RULES, attrs!(item, "macro_export", "macro_use")),
+        (MACRO_DEF, attrs!(item)),
+        (EXTERN_CRATE, attrs!(item, "macro_use", "no_link")),
+        (USE, attrs!(item)),
+        (TYPE_ALIAS, attrs!(item)),
+        (STRUCT, attrs!(item, adt, "non_exhaustive")),
+        (ENUM, attrs!(item, adt, "non_exhaustive")),
+        (UNION, attrs!(item, adt)),
+        (CONST, attrs!(item)),
+        (
+            FN,
+            attrs!(
+                item, linkable,
+                "cold", "ignore", "inline", "must_use", "panic_handler", "proc_macro",
+                "proc_macro_derive", "proc_macro_attribute", "should_panic", "target_feature",
+                "test", "track_caller"
+            ),
+        ),
+        (STATIC, attrs!(item, linkable, "global_allocator", "used")),
+        (TRAIT, attrs!(item, "must_use")),
+        (IMPL, attrs!(item, "automatically_derived")),
+        (ASSOC_ITEM_LIST, attrs!(item)),
+        (EXTERN_BLOCK, attrs!(item, "link")),
+        (EXTERN_ITEM_LIST, attrs!(item, "link")),
+        (MACRO_CALL, attrs!()),
+        (SELF_PARAM, attrs!()),
+        (PARAM, attrs!()),
+        (RECORD_FIELD, attrs!()),
+        (VARIANT, attrs!("non_exhaustive")),
+        (TYPE_PARAM, attrs!()),
+        (CONST_PARAM, attrs!()),
+        (LIFETIME_PARAM, attrs!()),
+        (LET_STMT, attrs!()),
+        (EXPR_STMT, attrs!()),
+        (LITERAL, attrs!()),
+        (RECORD_EXPR_FIELD_LIST, attrs!()),
+        (RECORD_EXPR_FIELD, attrs!()),
+        (MATCH_ARM_LIST, attrs!()),
+        (MATCH_ARM, attrs!()),
+        (IDENT_PAT, attrs!()),
+        (RECORD_PAT_FIELD, attrs!()),
+    ])
+    .collect()
+});
+const EXPR_ATTRIBUTES: &[&str] = attrs!();
+
 /// https://doc.rust-lang.org/reference/attributes.html#built-in-attributes-index
+// Keep these sorted for the binary search!
 const ATTRIBUTES: &[AttrCompletion] = &[
     attr("allow(…)", Some("allow"), Some("allow(${0:lint})")),
     attr("automatically_derived", None, None),
-    attr("cfg_attr(…)", Some("cfg_attr"), Some("cfg_attr(${1:predicate}, ${0:attr})")),
     attr("cfg(…)", Some("cfg"), Some("cfg(${0:predicate})")),
+    attr("cfg_attr(…)", Some("cfg_attr"), Some("cfg_attr(${1:predicate}, ${0:attr})")),
     attr("cold", None, None),
     attr(r#"crate_name = """#, Some("crate_name"), Some(r#"crate_name = "${0:crate_name}""#))
         .prefer_inner(),
     attr("deny(…)", Some("deny"), Some("deny(${0:lint})")),
     attr(r#"deprecated"#, Some("deprecated"), Some(r#"deprecated"#)),
     attr("derive(…)", Some("derive"), Some(r#"derive(${0:Debug})"#)),
+    attr(r#"doc = "…""#, Some("doc"), Some(r#"doc = "${0:docs}""#)),
+    attr(r#"doc(alias = "…")"#, Some("docalias"), Some(r#"doc(alias = "${0:docs}")"#)),
+    attr(r#"doc(hidden)"#, Some("dochidden"), Some(r#"doc(hidden)"#)),
     attr(
         r#"export_name = "…""#,
         Some("export_name"),
         Some(r#"export_name = "${0:exported_symbol_name}""#),
     ),
-    attr(r#"doc(alias = "…")"#, Some("docalias"), Some(r#"doc(alias = "${0:docs}")"#)),
-    attr(r#"doc = "…""#, Some("doc"), Some(r#"doc = "${0:docs}""#)),
-    attr(r#"doc(hidden)"#, Some("dochidden"), Some(r#"doc(hidden)"#)),
     attr("feature(…)", Some("feature"), Some("feature(${0:flag})")).prefer_inner(),
     attr("forbid(…)", Some("forbid"), Some("forbid(${0:lint})")),
-    // FIXME: resolve through macro resolution?
-    attr("global_allocator", None, None).prefer_inner(),
+    attr("global_allocator", None, None),
     attr(r#"ignore = "…""#, Some("ignore"), Some(r#"ignore = "${0:reason}""#)),
     attr("inline", Some("inline"), Some("inline")),
     attr("link", None, None),
@@ -119,13 +232,13 @@ const ATTRIBUTES: &[AttrCompletion] = &[
     attr("macro_export", None, None),
     attr("macro_use", None, None),
     attr(r#"must_use"#, Some("must_use"), Some(r#"must_use"#)),
-    attr("no_link", None, None).prefer_inner(),
     attr("no_implicit_prelude", None, None).prefer_inner(),
+    attr("no_link", None, None).prefer_inner(),
     attr("no_main", None, None).prefer_inner(),
     attr("no_mangle", None, None),
     attr("no_std", None, None).prefer_inner(),
     attr("non_exhaustive", None, None),
-    attr("panic_handler", None, None).prefer_inner(),
+    attr("panic_handler", None, None),
     attr(r#"path = "…""#, Some("path"), Some(r#"path ="${0:path}""#)),
     attr("proc_macro", None, None),
     attr("proc_macro_attribute", None, None),
@@ -153,412 +266,518 @@ const ATTRIBUTES: &[AttrCompletion] = &[
     .prefer_inner(),
 ];
 
-fn complete_derive(acc: &mut Completions, ctx: &CompletionContext, derive_input: ast::TokenTree) {
-    if let Ok(existing_derives) = parse_comma_sep_input(derive_input) {
-        for derive_completion in DEFAULT_DERIVE_COMPLETIONS
-            .iter()
-            .filter(|completion| !existing_derives.contains(completion.label))
-        {
-            let mut components = vec![derive_completion.label];
-            components.extend(
-                derive_completion
-                    .dependencies
-                    .iter()
-                    .filter(|&&dependency| !existing_derives.contains(dependency)),
-            );
-            let lookup = components.join(", ");
-            let label = components.iter().rev().join(", ");
-            let mut item =
-                CompletionItem::new(CompletionKind::Attribute, ctx.source_range(), label);
-            item.lookup_by(lookup).kind(CompletionItemKind::Attribute);
-            item.add_to(acc);
-        }
-
-        for custom_derive_name in get_derive_names_in_scope(ctx).difference(&existing_derives) {
-            let mut item = CompletionItem::new(
-                CompletionKind::Attribute,
-                ctx.source_range(),
-                custom_derive_name,
-            );
-            item.kind(CompletionItemKind::Attribute);
-            item.add_to(acc);
+fn parse_comma_sep_input(derive_input: ast::TokenTree) -> Option<FxHashSet<String>> {
+    let (l_paren, r_paren) = derive_input.l_paren_token().zip(derive_input.r_paren_token())?;
+    let mut input_derives = FxHashSet::default();
+    let mut tokens = derive_input
+        .syntax()
+        .children_with_tokens()
+        .filter_map(NodeOrToken::into_token)
+        .skip_while(|token| token != &l_paren)
+        .skip(1)
+        .take_while(|token| token != &r_paren)
+        .peekable();
+    let mut input = String::new();
+    while tokens.peek().is_some() {
+        for token in tokens.by_ref().take_while(|t| t.kind() != T![,]) {
+            input.push_str(token.text());
         }
-    }
-}
 
-fn complete_lint(
-    acc: &mut Completions,
-    ctx: &CompletionContext,
-    derive_input: ast::TokenTree,
-    lints_completions: &[LintCompletion],
-) {
-    if let Ok(existing_lints) = parse_comma_sep_input(derive_input) {
-        for lint_completion in lints_completions
-            .into_iter()
-            .filter(|completion| !existing_lints.contains(completion.label))
-        {
-            let mut item = CompletionItem::new(
-                CompletionKind::Attribute,
-                ctx.source_range(),
-                lint_completion.label,
-            );
-            item.kind(CompletionItemKind::Attribute).detail(lint_completion.description);
-            item.add_to(acc)
+        if !input.is_empty() {
+            input_derives.insert(input.trim().to_owned());
         }
-    }
-}
 
-fn parse_comma_sep_input(derive_input: ast::TokenTree) -> Result<FxHashSet<String>, ()> {
-    match (derive_input.left_delimiter_token(), derive_input.right_delimiter_token()) {
-        (Some(left_paren), Some(right_paren))
-            if left_paren.kind() == T!['('] && right_paren.kind() == T![')'] =>
-        {
-            let mut input_derives = FxHashSet::default();
-            let mut current_derive = String::new();
-            for token in derive_input
-                .syntax()
-                .children_with_tokens()
-                .filter_map(|token| token.into_token())
-                .skip_while(|token| token != &left_paren)
-                .skip(1)
-                .take_while(|token| token != &right_paren)
-            {
-                if T![,] == token.kind() {
-                    if !current_derive.is_empty() {
-                        input_derives.insert(current_derive);
-                        current_derive = String::new();
-                    }
-                } else {
-                    current_derive.push_str(token.text().trim());
-                }
-            }
-
-            if !current_derive.is_empty() {
-                input_derives.insert(current_derive);
-            }
-            Ok(input_derives)
-        }
-        _ => Err(()),
+        input.clear();
     }
-}
-
-fn get_derive_names_in_scope(ctx: &CompletionContext) -> FxHashSet<String> {
-    let mut result = FxHashSet::default();
-    ctx.scope.process_all_names(&mut |name, scope_def| {
-        if let hir::ScopeDef::MacroDef(mac) = scope_def {
-            // FIXME kind() doesn't check whether proc-macro is a derive
-            if mac.kind() == hir::MacroKind::Derive || mac.kind() == hir::MacroKind::ProcMacro {
-                result.insert(name.to_string());
-            }
-        }
-    });
-    result
-}
-
-struct DeriveCompletion {
-    label: &'static str,
-    dependencies: &'static [&'static str],
-}
-
-/// Standard Rust derives and the information about their dependencies
-/// (the dependencies are needed so that the main derive don't break the compilation when added)
-const DEFAULT_DERIVE_COMPLETIONS: &[DeriveCompletion] = &[
-    DeriveCompletion { label: "Clone", dependencies: &[] },
-    DeriveCompletion { label: "Copy", dependencies: &["Clone"] },
-    DeriveCompletion { label: "Debug", dependencies: &[] },
-    DeriveCompletion { label: "Default", dependencies: &[] },
-    DeriveCompletion { label: "Hash", dependencies: &[] },
-    DeriveCompletion { label: "PartialEq", dependencies: &[] },
-    DeriveCompletion { label: "Eq", dependencies: &["PartialEq"] },
-    DeriveCompletion { label: "PartialOrd", dependencies: &["PartialEq"] },
-    DeriveCompletion { label: "Ord", dependencies: &["PartialOrd", "Eq", "PartialEq"] },
-];
 
-pub(crate) struct LintCompletion {
-    pub(crate) label: &'static str,
-    pub(crate) description: &'static str,
+    Some(input_derives)
 }
 
-#[rustfmt::skip]
-const DEFAULT_LINT_COMPLETIONS: &[LintCompletion] = &[
-    LintCompletion { label: "absolute_paths_not_starting_with_crate", description: r#"fully qualified paths that start with a module name instead of `crate`, `self`, or an extern crate name"# },
-    LintCompletion { label: "anonymous_parameters", description: r#"detects anonymous parameters"# },
-    LintCompletion { label: "box_pointers", description: r#"use of owned (Box type) heap memory"# },
-    LintCompletion { label: "deprecated_in_future", description: r#"detects use of items that will be deprecated in a future version"# },
-    LintCompletion { label: "elided_lifetimes_in_paths", description: r#"hidden lifetime parameters in types are deprecated"# },
-    LintCompletion { label: "explicit_outlives_requirements", description: r#"outlives requirements can be inferred"# },
-    LintCompletion { label: "indirect_structural_match", description: r#"pattern with const indirectly referencing non-structural-match type"# },
-    LintCompletion { label: "keyword_idents", description: r#"detects edition keywords being used as an identifier"# },
-    LintCompletion { label: "macro_use_extern_crate", description: r#"the `#[macro_use]` attribute is now deprecated in favor of using macros via the module system"# },
-    LintCompletion { label: "meta_variable_misuse", description: r#"possible meta-variable misuse at macro definition"# },
-    LintCompletion { label: "missing_copy_implementations", description: r#"detects potentially-forgotten implementations of `Copy`"# },
-    LintCompletion { label: "missing_crate_level_docs", description: r#"detects crates with no crate-level documentation"# },
-    LintCompletion { label: "missing_debug_implementations", description: r#"detects missing implementations of Debug"# },
-    LintCompletion { label: "missing_docs", description: r#"detects missing documentation for public members"# },
-    LintCompletion { label: "missing_doc_code_examples", description: r#"detects publicly-exported items without code samples in their documentation"# },
-    LintCompletion { label: "non_ascii_idents", description: r#"detects non-ASCII identifiers"# },
-    LintCompletion { label: "private_doc_tests", description: r#"detects code samples in docs of private items not documented by rustdoc"# },
-    LintCompletion { label: "single_use_lifetimes", description: r#"detects lifetime parameters that are only used once"# },
-    LintCompletion { label: "trivial_casts", description: r#"detects trivial casts which could be removed"# },
-    LintCompletion { label: "trivial_numeric_casts", description: r#"detects trivial casts of numeric types which could be removed"# },
-    LintCompletion { label: "unaligned_references", description: r#"detects unaligned references to fields of packed structs"# },
-    LintCompletion { label: "unreachable_pub", description: r#"`pub` items not reachable from crate root"# },
-    LintCompletion { label: "unsafe_code", description: r#"usage of `unsafe` code"# },
-    LintCompletion { label: "unsafe_op_in_unsafe_fn", description: r#"unsafe operations in unsafe functions without an explicit unsafe block are deprecated"# },
-    LintCompletion { label: "unstable_features", description: r#"enabling unstable features (deprecated. do not use)"# },
-    LintCompletion { label: "unused_crate_dependencies", description: r#"crate dependencies that are never used"# },
-    LintCompletion { label: "unused_extern_crates", description: r#"extern crates that are never used"# },
-    LintCompletion { label: "unused_import_braces", description: r#"unnecessary braces around an imported item"# },
-    LintCompletion { label: "unused_lifetimes", description: r#"detects lifetime parameters that are never used"# },
-    LintCompletion { label: "unused_qualifications", description: r#"detects unnecessarily qualified names"# },
-    LintCompletion { label: "unused_results", description: r#"unused result of an expression in a statement"# },
-    LintCompletion { label: "variant_size_differences", description: r#"detects enums with widely varying variant sizes"# },
-    LintCompletion { label: "array_into_iter", description: r#"detects calling `into_iter` on arrays"# },
-    LintCompletion { label: "asm_sub_register", description: r#"using only a subset of a register for inline asm inputs"# },
-    LintCompletion { label: "bare_trait_objects", description: r#"suggest using `dyn Trait` for trait objects"# },
-    LintCompletion { label: "bindings_with_variant_name", description: r#"detects pattern bindings with the same name as one of the matched variants"# },
-    LintCompletion { label: "cenum_impl_drop_cast", description: r#"a C-like enum implementing Drop is cast"# },
-    LintCompletion { label: "clashing_extern_declarations", description: r#"detects when an extern fn has been declared with the same name but different types"# },
-    LintCompletion { label: "coherence_leak_check", description: r#"distinct impls distinguished only by the leak-check code"# },
-    LintCompletion { label: "confusable_idents", description: r#"detects visually confusable pairs between identifiers"# },
-    LintCompletion { label: "dead_code", description: r#"detect unused, unexported items"# },
-    LintCompletion { label: "deprecated", description: r#"detects use of deprecated items"# },
-    LintCompletion { label: "ellipsis_inclusive_range_patterns", description: r#"`...` range patterns are deprecated"# },
-    LintCompletion { label: "exported_private_dependencies", description: r#"public interface leaks type from a private dependency"# },
-    LintCompletion { label: "illegal_floating_point_literal_pattern", description: r#"floating-point literals cannot be used in patterns"# },
-    LintCompletion { label: "improper_ctypes", description: r#"proper use of libc types in foreign modules"# },
-    LintCompletion { label: "improper_ctypes_definitions", description: r#"proper use of libc types in foreign item definitions"# },
-    LintCompletion { label: "incomplete_features", description: r#"incomplete features that may function improperly in some or all cases"# },
-    LintCompletion { label: "inline_no_sanitize", description: r#"detects incompatible use of `#[inline(always)]` and `#[no_sanitize(...)]`"# },
-    LintCompletion { label: "intra_doc_link_resolution_failure", description: r#"failures in resolving intra-doc link targets"# },
-    LintCompletion { label: "invalid_codeblock_attributes", description: r#"codeblock attribute looks a lot like a known one"# },
-    LintCompletion { label: "invalid_value", description: r#"an invalid value is being created (such as a NULL reference)"# },
-    LintCompletion { label: "irrefutable_let_patterns", description: r#"detects irrefutable patterns in if-let and while-let statements"# },
-    LintCompletion { label: "late_bound_lifetime_arguments", description: r#"detects generic lifetime arguments in path segments with late bound lifetime parameters"# },
-    LintCompletion { label: "mixed_script_confusables", description: r#"detects Unicode scripts whose mixed script confusables codepoints are solely used"# },
-    LintCompletion { label: "mutable_borrow_reservation_conflict", description: r#"reservation of a two-phased borrow conflicts with other shared borrows"# },
-    LintCompletion { label: "non_camel_case_types", description: r#"types, variants, traits and type parameters should have camel case names"# },
-    LintCompletion { label: "non_shorthand_field_patterns", description: r#"using `Struct { x: x }` instead of `Struct { x }` in a pattern"# },
-    LintCompletion { label: "non_snake_case", description: r#"variables, methods, functions, lifetime parameters and modules should have snake case names"# },
-    LintCompletion { label: "non_upper_case_globals", description: r#"static constants should have uppercase identifiers"# },
-    LintCompletion { label: "no_mangle_generic_items", description: r#"generic items must be mangled"# },
-    LintCompletion { label: "overlapping_patterns", description: r#"detects overlapping patterns"# },
-    LintCompletion { label: "path_statements", description: r#"path statements with no effect"# },
-    LintCompletion { label: "private_in_public", description: r#"detect private items in public interfaces not caught by the old implementation"# },
-    LintCompletion { label: "proc_macro_derive_resolution_fallback", description: r#"detects proc macro derives using inaccessible names from parent modules"# },
-    LintCompletion { label: "redundant_semicolons", description: r#"detects unnecessary trailing semicolons"# },
-    LintCompletion { label: "renamed_and_removed_lints", description: r#"lints that have been renamed or removed"# },
-    LintCompletion { label: "safe_packed_borrows", description: r#"safe borrows of fields of packed structs were erroneously allowed"# },
-    LintCompletion { label: "stable_features", description: r#"stable features found in `#[feature]` directive"# },
-    LintCompletion { label: "trivial_bounds", description: r#"these bounds don't depend on an type parameters"# },
-    LintCompletion { label: "type_alias_bounds", description: r#"bounds in type aliases are not enforced"# },
-    LintCompletion { label: "tyvar_behind_raw_pointer", description: r#"raw pointer to an inference variable"# },
-    LintCompletion { label: "uncommon_codepoints", description: r#"detects uncommon Unicode codepoints in identifiers"# },
-    LintCompletion { label: "unconditional_recursion", description: r#"functions that cannot return without calling themselves"# },
-    LintCompletion { label: "unknown_lints", description: r#"unrecognized lint attribute"# },
-    LintCompletion { label: "unnameable_test_items", description: r#"detects an item that cannot be named being marked as `#[test_case]`"# },
-    LintCompletion { label: "unreachable_code", description: r#"detects unreachable code paths"# },
-    LintCompletion { label: "unreachable_patterns", description: r#"detects unreachable patterns"# },
-    LintCompletion { label: "unstable_name_collisions", description: r#"detects name collision with an existing but unstable method"# },
-    LintCompletion { label: "unused_allocation", description: r#"detects unnecessary allocations that can be eliminated"# },
-    LintCompletion { label: "unused_assignments", description: r#"detect assignments that will never be read"# },
-    LintCompletion { label: "unused_attributes", description: r#"detects attributes that were not used by the compiler"# },
-    LintCompletion { label: "unused_braces", description: r#"unnecessary braces around an expression"# },
-    LintCompletion { label: "unused_comparisons", description: r#"comparisons made useless by limits of the types involved"# },
-    LintCompletion { label: "unused_doc_comments", description: r#"detects doc comments that aren't used by rustdoc"# },
-    LintCompletion { label: "unused_features", description: r#"unused features found in crate-level `#[feature]` directives"# },
-    LintCompletion { label: "unused_imports", description: r#"imports that are never used"# },
-    LintCompletion { label: "unused_labels", description: r#"detects labels that are never used"# },
-    LintCompletion { label: "unused_macros", description: r#"detects macros that were not used"# },
-    LintCompletion { label: "unused_must_use", description: r#"unused result of a type flagged as `#[must_use]`"# },
-    LintCompletion { label: "unused_mut", description: r#"detect mut variables which don't need to be mutable"# },
-    LintCompletion { label: "unused_parens", description: r#"`if`, `match`, `while` and `return` do not need parentheses"# },
-    LintCompletion { label: "unused_unsafe", description: r#"unnecessary use of an `unsafe` block"# },
-    LintCompletion { label: "unused_variables", description: r#"detect variables which are not used in any way"# },
-    LintCompletion { label: "warnings", description: r#"mass-change the level for lints which produce warnings"# },
-    LintCompletion { label: "where_clauses_object_safety", description: r#"checks the object safety of where clauses"# },
-    LintCompletion { label: "while_true", description: r#"suggest using `loop { }` instead of `while true { }`"# },
-    LintCompletion { label: "ambiguous_associated_items", description: r#"ambiguous associated items"# },
-    LintCompletion { label: "arithmetic_overflow", description: r#"arithmetic operation overflows"# },
-    LintCompletion { label: "conflicting_repr_hints", description: r#"conflicts between `#[repr(..)]` hints that were previously accepted and used in practice"# },
-    LintCompletion { label: "const_err", description: r#"constant evaluation detected erroneous expression"# },
-    LintCompletion { label: "ill_formed_attribute_input", description: r#"ill-formed attribute inputs that were previously accepted and used in practice"# },
-    LintCompletion { label: "incomplete_include", description: r#"trailing content in included file"# },
-    LintCompletion { label: "invalid_type_param_default", description: r#"type parameter default erroneously allowed in invalid location"# },
-    LintCompletion { label: "macro_expanded_macro_exports_accessed_by_absolute_paths", description: r#"macro-expanded `macro_export` macros from the current crate cannot be referred to by absolute paths"# },
-    LintCompletion { label: "missing_fragment_specifier", description: r#"detects missing fragment specifiers in unused `macro_rules!` patterns"# },
-    LintCompletion { label: "mutable_transmutes", description: r#"mutating transmuted &mut T from &T may cause undefined behavior"# },
-    LintCompletion { label: "no_mangle_const_items", description: r#"const items will not have their symbols exported"# },
-    LintCompletion { label: "order_dependent_trait_objects", description: r#"trait-object types were treated as different depending on marker-trait order"# },
-    LintCompletion { label: "overflowing_literals", description: r#"literal out of range for its type"# },
-    LintCompletion { label: "patterns_in_fns_without_body", description: r#"patterns in functions without body were erroneously allowed"# },
-    LintCompletion { label: "pub_use_of_private_extern_crate", description: r#"detect public re-exports of private extern crates"# },
-    LintCompletion { label: "soft_unstable", description: r#"a feature gate that doesn't break dependent crates"# },
-    LintCompletion { label: "unconditional_panic", description: r#"operation will cause a panic at runtime"# },
-    LintCompletion { label: "unknown_crate_types", description: r#"unknown crate type found in `#[crate_type]` directive"# },
-];
-
 #[cfg(test)]
 mod tests {
+    use super::*;
+
     use expect_test::{expect, Expect};
 
     use crate::{test_utils::completion_list, CompletionKind};
 
+    #[test]
+    fn attributes_are_sorted() {
+        let mut attrs = ATTRIBUTES.iter().map(|attr| attr.key());
+        let mut prev = attrs.next().unwrap();
+
+        attrs.for_each(|next| {
+            assert!(
+                prev < next,
+                r#"ATTRIBUTES array is not sorted, "{}" should come after "{}""#,
+                prev,
+                next
+            );
+            prev = next;
+        });
+    }
+
     fn check(ra_fixture: &str, expect: Expect) {
         let actual = completion_list(ra_fixture, CompletionKind::Attribute);
         expect.assert_eq(&actual);
     }
 
     #[test]
-    fn empty_derive_completion() {
+    fn test_attribute_completion_inside_nested_attr() {
+        check(r#"#[cfg($0)]"#, expect![[]])
+    }
+
+    #[test]
+    fn test_attribute_completion_with_existing_attr() {
         check(
-            r#"
-#[derive($0)]
-struct Test {}
-        "#,
+            r#"#[no_mangle] #[$0] mcall!();"#,
             expect![[r#"
-                at Clone
-                at Clone, Copy
-                at Debug
-                at Default
-                at Hash
-                at PartialEq
-                at PartialEq, Eq
-                at PartialEq, PartialOrd
-                at PartialEq, Eq, PartialOrd, Ord
+                at allow(…)
+                at cfg(…)
+                at cfg_attr(…)
+                at deny(…)
+                at forbid(…)
+                at warn(…)
+            "#]],
+        )
+    }
+
+    #[test]
+    fn complete_attribute_on_source_file() {
+        check(
+            r#"#![$0]"#,
+            expect![[r#"
+                at allow(…)
+                at cfg(…)
+                at cfg_attr(…)
+                at deny(…)
+                at forbid(…)
+                at warn(…)
+                at deprecated
+                at doc = "…"
+                at doc(hidden)
+                at doc(alias = "…")
+                at must_use
+                at no_mangle
+                at crate_name = ""
+                at feature(…)
+                at no_implicit_prelude
+                at no_main
+                at no_std
+                at recursion_limit = …
+                at type_length_limit = …
+                at windows_subsystem = "…"
             "#]],
         );
     }
 
     #[test]
-    fn no_completion_for_incorrect_derive() {
+    fn complete_attribute_on_module() {
         check(
-            r#"
-#[derive{$0)]
-struct Test {}
-"#,
-            expect![[r#""#]],
-        )
+            r#"#[$0] mod foo;"#,
+            expect![[r#"
+            at allow(…)
+            at cfg(…)
+            at cfg_attr(…)
+            at deny(…)
+            at forbid(…)
+            at warn(…)
+            at deprecated
+            at doc = "…"
+            at doc(hidden)
+            at doc(alias = "…")
+            at must_use
+            at no_mangle
+            at path = "…"
+        "#]],
+        );
+        check(
+            r#"mod foo {#![$0]}"#,
+            expect![[r#"
+                at allow(…)
+                at cfg(…)
+                at cfg_attr(…)
+                at deny(…)
+                at forbid(…)
+                at warn(…)
+                at deprecated
+                at doc = "…"
+                at doc(hidden)
+                at doc(alias = "…")
+                at must_use
+                at no_mangle
+                at no_implicit_prelude
+            "#]],
+        );
     }
 
     #[test]
-    fn derive_with_input_completion() {
+    fn complete_attribute_on_macro_rules() {
         check(
-            r#"
-#[derive(serde::Serialize, PartialEq, $0)]
-struct Test {}
-"#,
+            r#"#[$0] macro_rules! foo {}"#,
             expect![[r#"
-                at Clone
-                at Clone, Copy
-                at Debug
-                at Default
-                at Hash
-                at Eq
-                at PartialOrd
-                at Eq, PartialOrd, Ord
+                at allow(…)
+                at cfg(…)
+                at cfg_attr(…)
+                at deny(…)
+                at forbid(…)
+                at warn(…)
+                at deprecated
+                at doc = "…"
+                at doc(hidden)
+                at doc(alias = "…")
+                at must_use
+                at no_mangle
+                at macro_export
+                at macro_use
             "#]],
-        )
+        );
     }
 
     #[test]
-    fn test_attribute_completion() {
+    fn complete_attribute_on_macro_def() {
         check(
-            r#"#[$0]"#,
+            r#"#[$0] macro foo {}"#,
             expect![[r#"
                 at allow(…)
-                at automatically_derived
+                at cfg(…)
                 at cfg_attr(…)
+                at deny(…)
+                at forbid(…)
+                at warn(…)
+                at deprecated
+                at doc = "…"
+                at doc(hidden)
+                at doc(alias = "…")
+                at must_use
+                at no_mangle
+            "#]],
+        );
+    }
+
+    #[test]
+    fn complete_attribute_on_extern_crate() {
+        check(
+            r#"#[$0] extern crate foo;"#,
+            expect![[r#"
+                at allow(…)
                 at cfg(…)
-                at cold
+                at cfg_attr(…)
                 at deny(…)
+                at forbid(…)
+                at warn(…)
                 at deprecated
-                at derive(…)
-                at export_name = "…"
+                at doc = "…"
+                at doc(hidden)
                 at doc(alias = "…")
+                at must_use
+                at no_mangle
+                at macro_use
+            "#]],
+        );
+    }
+
+    #[test]
+    fn complete_attribute_on_use() {
+        check(
+            r#"#[$0] use foo;"#,
+            expect![[r#"
+                at allow(…)
+                at cfg(…)
+                at cfg_attr(…)
+                at deny(…)
+                at forbid(…)
+                at warn(…)
+                at deprecated
                 at doc = "…"
                 at doc(hidden)
+                at doc(alias = "…")
+                at must_use
+                at no_mangle
+            "#]],
+        );
+    }
+
+    #[test]
+    fn complete_attribute_on_type_alias() {
+        check(
+            r#"#[$0] type foo = ();"#,
+            expect![[r#"
+                at allow(…)
+                at cfg(…)
+                at cfg_attr(…)
+                at deny(…)
                 at forbid(…)
-                at ignore = "…"
-                at inline
-                at link
-                at link_name = "…"
-                at link_section = "…"
-                at macro_export
-                at macro_use
+                at warn(…)
+                at deprecated
+                at doc = "…"
+                at doc(hidden)
+                at doc(alias = "…")
+                at must_use
+                at no_mangle
+            "#]],
+        );
+    }
+
+    #[test]
+    fn complete_attribute_on_struct() {
+        check(
+            r#"#[$0] struct Foo;"#,
+            expect![[r#"
+                at allow(…)
+                at cfg(…)
+                at cfg_attr(…)
+                at deny(…)
+                at forbid(…)
+                at warn(…)
+                at deprecated
+                at doc = "…"
+                at doc(hidden)
+                at doc(alias = "…")
                 at must_use
                 at no_mangle
+                at derive(…)
+                at repr(…)
                 at non_exhaustive
-                at path = "…"
-                at proc_macro
-                at proc_macro_attribute
-                at proc_macro_derive(…)
+            "#]],
+        );
+    }
+
+    #[test]
+    fn complete_attribute_on_enum() {
+        check(
+            r#"#[$0] enum Foo {}"#,
+            expect![[r#"
+                at allow(…)
+                at cfg(…)
+                at cfg_attr(…)
+                at deny(…)
+                at forbid(…)
+                at warn(…)
+                at deprecated
+                at doc = "…"
+                at doc(hidden)
+                at doc(alias = "…")
+                at must_use
+                at no_mangle
+                at derive(…)
                 at repr(…)
-                at should_panic
-                at target_feature = "…"
-                at test
-                at track_caller
-                at used
+                at non_exhaustive
+            "#]],
+        );
+    }
+
+    #[test]
+    fn complete_attribute_on_const() {
+        check(
+            r#"#[$0] const FOO: () = ();"#,
+            expect![[r#"
+                at allow(…)
+                at cfg(…)
+                at cfg_attr(…)
+                at deny(…)
+                at forbid(…)
                 at warn(…)
+                at deprecated
+                at doc = "…"
+                at doc(hidden)
+                at doc(alias = "…")
+                at must_use
+                at no_mangle
             "#]],
-        )
+        );
     }
 
     #[test]
-    fn test_attribute_completion_inside_nested_attr() {
-        check(r#"#[cfg($0)]"#, expect![[]])
+    fn complete_attribute_on_static() {
+        check(
+            r#"#[$0] static FOO: () = ()"#,
+            expect![[r#"
+                at allow(…)
+                at cfg(…)
+                at cfg_attr(…)
+                at deny(…)
+                at forbid(…)
+                at warn(…)
+                at deprecated
+                at doc = "…"
+                at doc(hidden)
+                at doc(alias = "…")
+                at must_use
+                at no_mangle
+                at export_name = "…"
+                at link_name = "…"
+                at link_section = "…"
+                at global_allocator
+                at used
+            "#]],
+        );
     }
 
     #[test]
-    fn test_inner_attribute_completion() {
+    fn complete_attribute_on_trait() {
         check(
-            r"#![$0]",
+            r#"#[$0] trait Foo {}"#,
             expect![[r#"
                 at allow(…)
-                at automatically_derived
+                at cfg(…)
                 at cfg_attr(…)
+                at deny(…)
+                at forbid(…)
+                at warn(…)
+                at deprecated
+                at doc = "…"
+                at doc(hidden)
+                at doc(alias = "…")
+                at must_use
+                at no_mangle
+                at must_use
+            "#]],
+        );
+    }
+
+    #[test]
+    fn complete_attribute_on_impl() {
+        check(
+            r#"#[$0] impl () {}"#,
+            expect![[r#"
+                at allow(…)
                 at cfg(…)
-                at cold
-                at crate_name = ""
+                at cfg_attr(…)
                 at deny(…)
+                at forbid(…)
+                at warn(…)
                 at deprecated
-                at derive(…)
-                at export_name = "…"
+                at doc = "…"
+                at doc(hidden)
+                at doc(alias = "…")
+                at must_use
+                at no_mangle
+                at automatically_derived
+            "#]],
+        );
+        check(
+            r#"impl () {#![$0]}"#,
+            expect![[r#"
+                at allow(…)
+                at cfg(…)
+                at cfg_attr(…)
+                at deny(…)
+                at forbid(…)
+                at warn(…)
+                at deprecated
+                at doc = "…"
+                at doc(hidden)
                 at doc(alias = "…")
+                at must_use
+                at no_mangle
+            "#]],
+        );
+    }
+
+    #[test]
+    fn complete_attribute_on_extern_block() {
+        check(
+            r#"#[$0] extern {}"#,
+            expect![[r#"
+                at allow(…)
+                at cfg(…)
+                at cfg_attr(…)
+                at deny(…)
+                at forbid(…)
+                at warn(…)
+                at deprecated
                 at doc = "…"
                 at doc(hidden)
-                at feature(…)
+                at doc(alias = "…")
+                at must_use
+                at no_mangle
+                at link
+            "#]],
+        );
+        check(
+            r#"extern {#![$0]}"#,
+            expect![[r#"
+                at allow(…)
+                at cfg(…)
+                at cfg_attr(…)
+                at deny(…)
                 at forbid(…)
-                at global_allocator
-                at ignore = "…"
-                at inline
+                at warn(…)
+                at deprecated
+                at doc = "…"
+                at doc(hidden)
+                at doc(alias = "…")
+                at must_use
+                at no_mangle
                 at link
+            "#]],
+        );
+    }
+
+    #[test]
+    fn complete_attribute_on_variant() {
+        check(
+            r#"enum Foo { #[$0] Bar }"#,
+            expect![[r#"
+                at allow(…)
+                at cfg(…)
+                at cfg_attr(…)
+                at deny(…)
+                at forbid(…)
+                at warn(…)
+                at non_exhaustive
+            "#]],
+        );
+    }
+
+    #[test]
+    fn complete_attribute_on_fn() {
+        check(
+            r#"#[$0] fn main() {}"#,
+            expect![[r#"
+                at allow(…)
+                at cfg(…)
+                at cfg_attr(…)
+                at deny(…)
+                at forbid(…)
+                at warn(…)
+                at deprecated
+                at doc = "…"
+                at doc(hidden)
+                at doc(alias = "…")
+                at must_use
+                at no_mangle
+                at export_name = "…"
                 at link_name = "…"
                 at link_section = "…"
-                at macro_export
-                at macro_use
+                at cold
+                at ignore = "…"
+                at inline
                 at must_use
-                at no_link
-                at no_implicit_prelude
-                at no_main
-                at no_mangle
-                at no_std
-                at non_exhaustive
                 at panic_handler
-                at path = "…"
                 at proc_macro
-                at proc_macro_attribute
                 at proc_macro_derive(…)
-                at recursion_limit = …
-                at repr(…)
+                at proc_macro_attribute
                 at should_panic
                 at target_feature = "…"
                 at test
                 at track_caller
-                at type_length_limit = …
-                at used
+            "#]],
+        );
+    }
+
+    #[test]
+    fn complete_attribute_on_expr() {
+        check(
+            r#"fn main() { #[$0] foo() }"#,
+            expect![[r#"
+                at allow(…)
+                at cfg(…)
+                at cfg_attr(…)
+                at deny(…)
+                at forbid(…)
                 at warn(…)
-                at windows_subsystem = "…"
             "#]],
         );
     }
diff --git a/crates/ide_completion/src/completions/attribute/derive.rs b/crates/ide_completion/src/completions/attribute/derive.rs
new file mode 100644
index 000000000..0bc3eab98
--- /dev/null
+++ b/crates/ide_completion/src/completions/attribute/derive.rs
@@ -0,0 +1,147 @@
+//! Completion for derives
+use itertools::Itertools;
+use rustc_hash::FxHashSet;
+use syntax::ast;
+
+use crate::{
+    context::CompletionContext,
+    item::{CompletionItem, CompletionItemKind, CompletionKind},
+    Completions,
+};
+
+pub(super) fn complete_derive(
+    acc: &mut Completions,
+    ctx: &CompletionContext,
+    derive_input: ast::TokenTree,
+) {
+    if let Some(existing_derives) = super::parse_comma_sep_input(derive_input) {
+        for derive_completion in DEFAULT_DERIVE_COMPLETIONS
+            .iter()
+            .filter(|completion| !existing_derives.contains(completion.label))
+        {
+            let mut components = vec![derive_completion.label];
+            components.extend(
+                derive_completion
+                    .dependencies
+                    .iter()
+                    .filter(|&&dependency| !existing_derives.contains(dependency)),
+            );
+            let lookup = components.join(", ");
+            let label = components.iter().rev().join(", ");
+            let mut item =
+                CompletionItem::new(CompletionKind::Attribute, ctx.source_range(), label);
+            item.lookup_by(lookup).kind(CompletionItemKind::Attribute);
+            item.add_to(acc);
+        }
+
+        for custom_derive_name in get_derive_names_in_scope(ctx).difference(&existing_derives) {
+            let mut item = CompletionItem::new(
+                CompletionKind::Attribute,
+                ctx.source_range(),
+                custom_derive_name,
+            );
+            item.kind(CompletionItemKind::Attribute);
+            item.add_to(acc);
+        }
+    }
+}
+
+fn get_derive_names_in_scope(ctx: &CompletionContext) -> FxHashSet<String> {
+    let mut result = FxHashSet::default();
+    ctx.scope.process_all_names(&mut |name, scope_def| {
+        if let hir::ScopeDef::MacroDef(mac) = scope_def {
+            if mac.kind() == hir::MacroKind::Derive {
+                result.insert(name.to_string());
+            }
+        }
+    });
+    result
+}
+
+struct DeriveCompletion {
+    label: &'static str,
+    dependencies: &'static [&'static str],
+}
+
+/// Standard Rust derives and the information about their dependencies
+/// (the dependencies are needed so that the main derive don't break the compilation when added)
+const DEFAULT_DERIVE_COMPLETIONS: &[DeriveCompletion] = &[
+    DeriveCompletion { label: "Clone", dependencies: &[] },
+    DeriveCompletion { label: "Copy", dependencies: &["Clone"] },
+    DeriveCompletion { label: "Debug", dependencies: &[] },
+    DeriveCompletion { label: "Default", dependencies: &[] },
+    DeriveCompletion { label: "Hash", dependencies: &[] },
+    DeriveCompletion { label: "PartialEq", dependencies: &[] },
+    DeriveCompletion { label: "Eq", dependencies: &["PartialEq"] },
+    DeriveCompletion { label: "PartialOrd", dependencies: &["PartialEq"] },
+    DeriveCompletion { label: "Ord", dependencies: &["PartialOrd", "Eq", "PartialEq"] },
+];
+
+#[cfg(test)]
+mod tests {
+    use expect_test::{expect, Expect};
+
+    use crate::{test_utils::completion_list, CompletionKind};
+
+    fn check(ra_fixture: &str, expect: Expect) {
+        let actual = completion_list(ra_fixture, CompletionKind::Attribute);
+        expect.assert_eq(&actual);
+    }
+
+    #[test]
+    fn no_completion_for_incorrect_derive() {
+        check(r#"#[derive{$0)] struct Test;"#, expect![[]])
+    }
+
+    #[test]
+    fn empty_derive() {
+        check(
+            r#"#[derive($0)] struct Test;"#,
+            expect![[r#"
+                at Clone
+                at Clone, Copy
+                at Debug
+                at Default
+                at Hash
+                at PartialEq
+                at PartialEq, Eq
+                at PartialEq, PartialOrd
+                at PartialEq, Eq, PartialOrd, Ord
+            "#]],
+        );
+    }
+
+    #[test]
+    fn derive_with_input() {
+        check(
+            r#"#[derive(serde::Serialize, PartialEq, $0)] struct Test;"#,
+            expect![[r#"
+                at Clone
+                at Clone, Copy
+                at Debug
+                at Default
+                at Hash
+                at Eq
+                at PartialOrd
+                at Eq, PartialOrd, Ord
+            "#]],
+        )
+    }
+
+    #[test]
+    fn derive_with_input2() {
+        check(
+            r#"#[derive($0 serde::Serialize, PartialEq)] struct Test;"#,
+            expect![[r#"
+                at Clone
+                at Clone, Copy
+                at Debug
+                at Default
+                at Hash
+                at Eq
+                at PartialOrd
+                at Eq, PartialOrd, Ord
+            "#]],
+        )
+    }
+}
diff --git a/crates/ide_completion/src/completions/attribute/lint.rs b/crates/ide_completion/src/completions/attribute/lint.rs
new file mode 100644
index 000000000..403630dce
--- /dev/null
+++ b/crates/ide_completion/src/completions/attribute/lint.rs
@@ -0,0 +1,187 @@
+//! Completion for lints
+use syntax::ast;
+
+use crate::{
+    context::CompletionContext,
+    item::{CompletionItem, CompletionItemKind, CompletionKind},
+    Completions,
+};
+
+pub(super) fn complete_lint(
+    acc: &mut Completions,
+    ctx: &CompletionContext,
+    derive_input: ast::TokenTree,
+    lints_completions: &[LintCompletion],
+) {
+    if let Some(existing_lints) = super::parse_comma_sep_input(derive_input) {
+        for lint_completion in lints_completions
+            .into_iter()
+            .filter(|completion| !existing_lints.contains(completion.label))
+        {
+            let mut item = CompletionItem::new(
+                CompletionKind::Attribute,
+                ctx.source_range(),
+                lint_completion.label,
+            );
+            item.kind(CompletionItemKind::Attribute).detail(lint_completion.description);
+            item.add_to(acc)
+        }
+    }
+}
+
+pub(crate) struct LintCompletion {
+    pub(crate) label: &'static str,
+    pub(crate) description: &'static str,
+}
+
+#[rustfmt::skip]
+pub(super) const DEFAULT_LINT_COMPLETIONS: &[LintCompletion] = &[
+    LintCompletion { label: "absolute_paths_not_starting_with_crate", description: r#"fully qualified paths that start with a module name instead of `crate`, `self`, or an extern crate name"# },
+    LintCompletion { label: "anonymous_parameters", description: r#"detects anonymous parameters"# },
+    LintCompletion { label: "box_pointers", description: r#"use of owned (Box type) heap memory"# },
+    LintCompletion { label: "deprecated_in_future", description: r#"detects use of items that will be deprecated in a future version"# },
+    LintCompletion { label: "elided_lifetimes_in_paths", description: r#"hidden lifetime parameters in types are deprecated"# },
+    LintCompletion { label: "explicit_outlives_requirements", description: r#"outlives requirements can be inferred"# },
+    LintCompletion { label: "indirect_structural_match", description: r#"pattern with const indirectly referencing non-structural-match type"# },
+    LintCompletion { label: "keyword_idents", description: r#"detects edition keywords being used as an identifier"# },
+    LintCompletion { label: "macro_use_extern_crate", description: r#"the `#[macro_use]` attribute is now deprecated in favor of using macros via the module system"# },
+    LintCompletion { label: "meta_variable_misuse", description: r#"possible meta-variable misuse at macro definition"# },
+    LintCompletion { label: "missing_copy_implementations", description: r#"detects potentially-forgotten implementations of `Copy`"# },
+    LintCompletion { label: "missing_crate_level_docs", description: r#"detects crates with no crate-level documentation"# },
+    LintCompletion { label: "missing_debug_implementations", description: r#"detects missing implementations of Debug"# },
+    LintCompletion { label: "missing_docs", description: r#"detects missing documentation for public members"# },
+    LintCompletion { label: "missing_doc_code_examples", description: r#"detects publicly-exported items without code samples in their documentation"# },
+    LintCompletion { label: "non_ascii_idents", description: r#"detects non-ASCII identifiers"# },
+    LintCompletion { label: "private_doc_tests", description: r#"detects code samples in docs of private items not documented by rustdoc"# },
+    LintCompletion { label: "single_use_lifetimes", description: r#"detects lifetime parameters that are only used once"# },
+    LintCompletion { label: "trivial_casts", description: r#"detects trivial casts which could be removed"# },
+    LintCompletion { label: "trivial_numeric_casts", description: r#"detects trivial casts of numeric types which could be removed"# },
+    LintCompletion { label: "unaligned_references", description: r#"detects unaligned references to fields of packed structs"# },
+    LintCompletion { label: "unreachable_pub", description: r#"`pub` items not reachable from crate root"# },
+    LintCompletion { label: "unsafe_code", description: r#"usage of `unsafe` code"# },
+    LintCompletion { label: "unsafe_op_in_unsafe_fn", description: r#"unsafe operations in unsafe functions without an explicit unsafe block are deprecated"# },
+    LintCompletion { label: "unstable_features", description: r#"enabling unstable features (deprecated. do not use)"# },
+    LintCompletion { label: "unused_crate_dependencies", description: r#"crate dependencies that are never used"# },
+    LintCompletion { label: "unused_extern_crates", description: r#"extern crates that are never used"# },
+    LintCompletion { label: "unused_import_braces", description: r#"unnecessary braces around an imported item"# },
+    LintCompletion { label: "unused_lifetimes", description: r#"detects lifetime parameters that are never used"# },
+    LintCompletion { label: "unused_qualifications", description: r#"detects unnecessarily qualified names"# },
+    LintCompletion { label: "unused_results", description: r#"unused result of an expression in a statement"# },
+    LintCompletion { label: "variant_size_differences", description: r#"detects enums with widely varying variant sizes"# },
+    LintCompletion { label: "array_into_iter", description: r#"detects calling `into_iter` on arrays"# },
+    LintCompletion { label: "asm_sub_register", description: r#"using only a subset of a register for inline asm inputs"# },
+    LintCompletion { label: "bare_trait_objects", description: r#"suggest using `dyn Trait` for trait objects"# },
+    LintCompletion { label: "bindings_with_variant_name", description: r#"detects pattern bindings with the same name as one of the matched variants"# },
+    LintCompletion { label: "cenum_impl_drop_cast", description: r#"a C-like enum implementing Drop is cast"# },
+    LintCompletion { label: "clashing_extern_declarations", description: r#"detects when an extern fn has been declared with the same name but different types"# },
+    LintCompletion { label: "coherence_leak_check", description: r#"distinct impls distinguished only by the leak-check code"# },
+    LintCompletion { label: "confusable_idents", description: r#"detects visually confusable pairs between identifiers"# },
+    LintCompletion { label: "dead_code", description: r#"detect unused, unexported items"# },
+    LintCompletion { label: "deprecated", description: r#"detects use of deprecated items"# },
+    LintCompletion { label: "ellipsis_inclusive_range_patterns", description: r#"`...` range patterns are deprecated"# },
+    LintCompletion { label: "exported_private_dependencies", description: r#"public interface leaks type from a private dependency"# },
+    LintCompletion { label: "illegal_floating_point_literal_pattern", description: r#"floating-point literals cannot be used in patterns"# },
+    LintCompletion { label: "improper_ctypes", description: r#"proper use of libc types in foreign modules"# },
+    LintCompletion { label: "improper_ctypes_definitions", description: r#"proper use of libc types in foreign item definitions"# },
+    LintCompletion { label: "incomplete_features", description: r#"incomplete features that may function improperly in some or all cases"# },
+    LintCompletion { label: "inline_no_sanitize", description: r#"detects incompatible use of `#[inline(always)]` and `#[no_sanitize(...)]`"# },
+    LintCompletion { label: "intra_doc_link_resolution_failure", description: r#"failures in resolving intra-doc link targets"# },
+    LintCompletion { label: "invalid_codeblock_attributes", description: r#"codeblock attribute looks a lot like a known one"# },
+    LintCompletion { label: "invalid_value", description: r#"an invalid value is being created (such as a NULL reference)"# },
+    LintCompletion { label: "irrefutable_let_patterns", description: r#"detects irrefutable patterns in if-let and while-let statements"# },
+    LintCompletion { label: "late_bound_lifetime_arguments", description: r#"detects generic lifetime arguments in path segments with late bound lifetime parameters"# },
+    LintCompletion { label: "mixed_script_confusables", description: r#"detects Unicode scripts whose mixed script confusables codepoints are solely used"# },
+    LintCompletion { label: "mutable_borrow_reservation_conflict", description: r#"reservation of a two-phased borrow conflicts with other shared borrows"# },
+    LintCompletion { label: "non_camel_case_types", description: r#"types, variants, traits and type parameters should have camel case names"# },
+    LintCompletion { label: "non_shorthand_field_patterns", description: r#"using `Struct { x: x }` instead of `Struct { x }` in a pattern"# },
+    LintCompletion { label: "non_snake_case", description: r#"variables, methods, functions, lifetime parameters and modules should have snake case names"# },
+    LintCompletion { label: "non_upper_case_globals", description: r#"static constants should have uppercase identifiers"# },
+    LintCompletion { label: "no_mangle_generic_items", description: r#"generic items must be mangled"# },
+    LintCompletion { label: "overlapping_patterns", description: r#"detects overlapping patterns"# },
+    LintCompletion { label: "path_statements", description: r#"path statements with no effect"# },
+    LintCompletion { label: "private_in_public", description: r#"detect private items in public interfaces not caught by the old implementation"# },
+    LintCompletion { label: "proc_macro_derive_resolution_fallback", description: r#"detects proc macro derives using inaccessible names from parent modules"# },
+    LintCompletion { label: "redundant_semicolons", description: r#"detects unnecessary trailing semicolons"# },
+    LintCompletion { label: "renamed_and_removed_lints", description: r#"lints that have been renamed or removed"# },
+    LintCompletion { label: "safe_packed_borrows", description: r#"safe borrows of fields of packed structs were erroneously allowed"# },
+    LintCompletion { label: "stable_features", description: r#"stable features found in `#[feature]` directive"# },
+    LintCompletion { label: "trivial_bounds", description: r#"these bounds don't depend on an type parameters"# },
+    LintCompletion { label: "type_alias_bounds", description: r#"bounds in type aliases are not enforced"# },
+    LintCompletion { label: "tyvar_behind_raw_pointer", description: r#"raw pointer to an inference variable"# },
+    LintCompletion { label: "uncommon_codepoints", description: r#"detects uncommon Unicode codepoints in identifiers"# },
+    LintCompletion { label: "unconditional_recursion", description: r#"functions that cannot return without calling themselves"# },
+    LintCompletion { label: "unknown_lints", description: r#"unrecognized lint attribute"# },
+    LintCompletion { label: "unnameable_test_items", description: r#"detects an item that cannot be named being marked as `#[test_case]`"# },
+    LintCompletion { label: "unreachable_code", description: r#"detects unreachable code paths"# },
+    LintCompletion { label: "unreachable_patterns", description: r#"detects unreachable patterns"# },
+    LintCompletion { label: "unstable_name_collisions", description: r#"detects name collision with an existing but unstable method"# },
+    LintCompletion { label: "unused_allocation", description: r#"detects unnecessary allocations that can be eliminated"# },
+    LintCompletion { label: "unused_assignments", description: r#"detect assignments that will never be read"# },
+    LintCompletion { label: "unused_attributes", description: r#"detects attributes that were not used by the compiler"# },
+    LintCompletion { label: "unused_braces", description: r#"unnecessary braces around an expression"# },
+    LintCompletion { label: "unused_comparisons", description: r#"comparisons made useless by limits of the types involved"# },
+    LintCompletion { label: "unused_doc_comments", description: r#"detects doc comments that aren't used by rustdoc"# },
+    LintCompletion { label: "unused_features", description: r#"unused features found in crate-level `#[feature]` directives"# },
+    LintCompletion { label: "unused_imports", description: r#"imports that are never used"# },
+    LintCompletion { label: "unused_labels", description: r#"detects labels that are never used"# },
+    LintCompletion { label: "unused_macros", description: r#"detects macros that were not used"# },
+    LintCompletion { label: "unused_must_use", description: r#"unused result of a type flagged as `#[must_use]`"# },
+    LintCompletion { label: "unused_mut", description: r#"detect mut variables which don't need to be mutable"# },
+    LintCompletion { label: "unused_parens", description: r#"`if`, `match`, `while` and `return` do not need parentheses"# },
+    LintCompletion { label: "unused_unsafe", description: r#"unnecessary use of an `unsafe` block"# },
+    LintCompletion { label: "unused_variables", description: r#"detect variables which are not used in any way"# },
+    LintCompletion { label: "warnings", description: r#"mass-change the level for lints which produce warnings"# },
+    LintCompletion { label: "where_clauses_object_safety", description: r#"checks the object safety of where clauses"# },
+    LintCompletion { label: "while_true", description: r#"suggest using `loop { }` instead of `while true { }`"# },
+    LintCompletion { label: "ambiguous_associated_items", description: r#"ambiguous associated items"# },
+    LintCompletion { label: "arithmetic_overflow", description: r#"arithmetic operation overflows"# },
+    LintCompletion { label: "conflicting_repr_hints", description: r#"conflicts between `#[repr(..)]` hints that were previously accepted and used in practice"# },
+    LintCompletion { label: "const_err", description: r#"constant evaluation detected erroneous expression"# },
+    LintCompletion { label: "ill_formed_attribute_input", description: r#"ill-formed attribute inputs that were previously accepted and used in practice"# },
+    LintCompletion { label: "incomplete_include", description: r#"trailing content in included file"# },
+    LintCompletion { label: "invalid_type_param_default", description: r#"type parameter default erroneously allowed in invalid location"# },
+    LintCompletion { label: "macro_expanded_macro_exports_accessed_by_absolute_paths", description: r#"macro-expanded `macro_export` macros from the current crate cannot be referred to by absolute paths"# },
+    LintCompletion { label: "missing_fragment_specifier", description: r#"detects missing fragment specifiers in unused `macro_rules!` patterns"# },
+    LintCompletion { label: "mutable_transmutes", description: r#"mutating transmuted &mut T from &T may cause undefined behavior"# },
+    LintCompletion { label: "no_mangle_const_items", description: r#"const items will not have their symbols exported"# },
+    LintCompletion { label: "order_dependent_trait_objects", description: r#"trait-object types were treated as different depending on marker-trait order"# },
+    LintCompletion { label: "overflowing_literals", description: r#"literal out of range for its type"# },
+    LintCompletion { label: "patterns_in_fns_without_body", description: r#"patterns in functions without body were erroneously allowed"# },
+    LintCompletion { label: "pub_use_of_private_extern_crate", description: r#"detect public re-exports of private extern crates"# },
+    LintCompletion { label: "soft_unstable", description: r#"a feature gate that doesn't break dependent crates"# },
+    LintCompletion { label: "unconditional_panic", description: r#"operation will cause a panic at runtime"# },
+    LintCompletion { label: "unknown_crate_types", description: r#"unknown crate type found in `#[crate_type]` directive"# },
+];
+
+#[cfg(test)]
+mod tests {
+
+    use crate::test_utils::check_edit;
+
+    #[test]
+    fn check_empty() {
+        check_edit(
+            "deprecated",
+            r#"#[allow($0)] struct Test;"#,
+            r#"#[allow(deprecated)] struct Test;"#,
+        )
+    }
+
+    #[test]
+    fn check_with_existing() {
+        check_edit(
+            "deprecated",
+            r#"#[allow(keyword_idents, $0)] struct Test;"#,
+            r#"#[allow(keyword_idents, deprecated)] struct Test;"#,
+        )
+    }
+
+    #[test]
+    fn check_qualified() {
+        check_edit(
+            "deprecated",
+            r#"#[allow(keyword_idents, $0)] struct Test;"#,
+            r#"#[allow(keyword_idents, deprecated)] struct Test;"#,
+        )
+    }
+}
diff --git a/crates/ide_completion/src/completions/flyimport.rs b/crates/ide_completion/src/completions/flyimport.rs
index be9cfbded..df27e7a84 100644
--- a/crates/ide_completion/src/completions/flyimport.rs
+++ b/crates/ide_completion/src/completions/flyimport.rs
@@ -110,7 +110,11 @@ pub(crate) fn import_on_the_fly(acc: &mut Completions, ctx: &CompletionContext)
     if !ctx.config.enable_imports_on_the_fly {
         return None;
     }
-    if ctx.use_item_syntax.is_some() || ctx.is_path_disallowed() {
+    if ctx.use_item_syntax.is_some()
+        || ctx.is_path_disallowed()
+        || ctx.expects_item()
+        || ctx.expects_assoc_item()
+    {
         return None;
     }
     let potential_import_name = {
diff --git a/crates/ide_completion/src/completions/fn_param.rs b/crates/ide_completion/src/completions/fn_param.rs
index 0ea558489..cb90e8a3e 100644
--- a/crates/ide_completion/src/completions/fn_param.rs
+++ b/crates/ide_completion/src/completions/fn_param.rs
@@ -128,4 +128,19 @@ fn outer(text: String) {
             "#]],
         )
     }
+