40 files changed, 1545 insertions, 294 deletions
diff --git a/crates/assists/src/handlers/generate_impl.rs b/crates/assists/src/handlers/generate_impl.rs
index 9989109b5..114974465 100644
--- a/crates/assists/src/handlers/generate_impl.rs
+++ b/crates/assists/src/handlers/generate_impl.rs
@@ -1,6 +1,6 @@
 use itertools::Itertools;
 use stdx::format_to;
-use syntax::ast::{self, AstNode, GenericParamsOwner, NameOwner};
+use syntax::ast::{self, AstNode, AttrsOwner, GenericParamsOwner, NameOwner};
 use crate::{AssistContext, AssistId, AssistKind, Assists};
@@ -27,6 +27,7 @@ pub(crate) fn generate_impl(acc: &mut Assists, ctx: &AssistContext) -> Option<()
    let nominal = ctx.find_node_at_offset::<ast::AdtDef>()?;
    let name = nominal.name()?;
    let target = nominal.syntax().text_range();
    acc.add(
        AssistId("generate_impl", AssistKind::Generate),
        format!("Generate impl for `{}`", name),
@@ -35,7 +36,15 @@ pub(crate) fn generate_impl(acc: &mut Assists, ctx: &AssistContext) -> Option<()
            let type_params = nominal.generic_param_list();
            let start_offset = nominal.syntax().text_range().end();
            let mut buf = String::new();
-            buf.push_str("\n\nimpl");
+            buf.push_str("\n\n");
+            nominal
+                .attrs()
+                .filter(|attr| {
+                    attr.as_simple_call().map(|(name, _arg)| name == "cfg").unwrap_or(false)
+                })
+                .for_each(|attr| buf.push_str(format!("{}\n", attr.to_string()).as_str()));
+            buf.push_str("impl");
            if let Some(type_params) = &type_params {
                format_to!(buf, "{}", type_params.syntax());
            }
@@ -91,6 +100,35 @@ mod tests {
            "struct Foo<'a, T: Foo<'a>> {<|>}",
            "struct Foo<'a, T: Foo<'a>> {}\n\nimpl<'a, T: Foo<'a>> Foo<'a, T> {\n    $0\n}",
        );
+        check_assist(
+            generate_impl,
+            r#"
+            #[cfg(feature = "foo")]
+            struct Foo<'a, T: Foo<'a>> {<|>}"#,
+            r#"
+            #[cfg(feature = "foo")]
+            struct Foo<'a, T: Foo<'a>> {}
+            #[cfg(feature = "foo")]
+            impl<'a, T: Foo<'a>> Foo<'a, T> {
+                $0
+            }"#,
+        );
+        check_assist(
+            generate_impl,
+            r#"
+            #[cfg(not(feature = "foo"))]
+            struct Foo<'a, T: Foo<'a>> {<|>}"#,
+            r#"
+            #[cfg(not(feature = "foo"))]
+            struct Foo<'a, T: Foo<'a>> {}
+            #[cfg(not(feature = "foo"))]
+            impl<'a, T: Foo<'a>> Foo<'a, T> {
+                $0
+            }"#,
+        );
    }
    #[test]
diff --git a/crates/cfg/Cargo.toml b/crates/cfg/Cargo.toml
index a6785ee8e..c68e391c1 100644
--- a/crates/cfg/Cargo.toml
+++ b/crates/cfg/Cargo.toml
@@ -17,3 +17,4 @@ tt = { path = "../tt", version = "0.0.0" }
 [dev-dependencies]
 mbe = { path = "../mbe" }
 syntax = { path = "../syntax" }
+expect-test = "1.0"
diff --git a/crates/cfg/src/cfg_expr.rs b/crates/cfg/src/cfg_expr.rs
index 336fe25bc..42327f1e1 100644
--- a/crates/cfg/src/cfg_expr.rs
+++ b/crates/cfg/src/cfg_expr.rs
@@ -2,30 +2,77 @@
 //!
 //! See: https://doc.rust-lang.org/reference/conditional-compilation.html#conditional-compilation
-use std::slice::Iter as SliceIter;
+use std::{fmt, slice::Iter as SliceIter};
 use tt::SmolStr;
+/// A simple configuration value passed in from the outside.
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Ord, PartialOrd)]
+pub enum CfgAtom {
+    /// eg. `#[cfg(test)]`
+    Flag(SmolStr),
+    /// eg. `#[cfg(target_os = "linux")]`
+    ///
+    /// Note that a key can have multiple values that are all considered "active" at the same time.
+    /// For example, `#[cfg(target_feature = "sse")]` and `#[cfg(target_feature = "sse2")]`.
+    KeyValue { key: SmolStr, value: SmolStr },
+}
+impl CfgAtom {
+    /// Returns `true` when the atom comes from the target specification.
+    ///
+    /// If this returns `true`, then changing this atom requires changing the compilation target. If
+    /// it returns `false`, the atom might come from a build script or the build system.
+    pub fn is_target_defined(&self) -> bool {
+        match self {
+            CfgAtom::Flag(flag) => matches!(&**flag, "unix" | "windows"),
+            CfgAtom::KeyValue { key, value: _ } => matches!(
+                &**key,
+                "target_arch"
+                    | "target_os"
+                    | "target_env"
+                    | "target_family"
+                    | "target_endian"
+                    | "target_pointer_width"
+                    | "target_vendor" // NOTE: `target_feature` is left out since it can be configured via `-Ctarget-feature`
+            ),
+        }
+    }
+}
+impl fmt::Display for CfgAtom {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            CfgAtom::Flag(name) => write!(f, "{}", name),
+            CfgAtom::KeyValue { key, value } => write!(f, "{} = {:?}", key, value),
+        }
+    }
+}
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum CfgExpr {
    Invalid,
-    Atom(SmolStr),
+    Atom(CfgAtom),
-    KeyValue { key: SmolStr, value: SmolStr },
    All(Vec<CfgExpr>),
    Any(Vec<CfgExpr>),
    Not(Box<CfgExpr>),
 }
+impl From<CfgAtom> for CfgExpr {
+    fn from(atom: CfgAtom) -> Self {
+        CfgExpr::Atom(atom)
+    }
+}
 impl CfgExpr {
    pub fn parse(tt: &tt::Subtree) -> CfgExpr {
        next_cfg_expr(&mut tt.token_trees.iter()).unwrap_or(CfgExpr::Invalid)
    }
    /// Fold the cfg by querying all basic `Atom` and `KeyValue` predicates.
-    pub fn fold(&self, query: &dyn Fn(&SmolStr, Option<&SmolStr>) -> bool) -> Option<bool> {
+    pub fn fold(&self, query: &dyn Fn(&CfgAtom) -> bool) -> Option<bool> {
        match self {
            CfgExpr::Invalid => None,
-            CfgExpr::Atom(name) => Some(query(name, None)),
+            CfgExpr::Atom(atom) => Some(query(atom)),
-            CfgExpr::KeyValue { key, value } => Some(query(key, Some(value))),
            CfgExpr::All(preds) => {
                preds.iter().try_fold(true, |s, pred| Some(s && pred.fold(query)?))
            }
@@ -54,7 +101,7 @@ fn next_cfg_expr(it: &mut SliceIter<tt::TokenTree>) -> Option<CfgExpr> {
                    // FIXME: escape? raw string?
                    let value =
                        SmolStr::new(literal.text.trim_start_matches('"').trim_end_matches('"'));
-                    CfgExpr::KeyValue { key: name, value }
+                    CfgAtom::KeyValue { key: name, value }.into()
                }
                _ => return Some(CfgExpr::Invalid),
            }
@@ -70,7 +117,7 @@ fn next_cfg_expr(it: &mut SliceIter<tt::TokenTree>) -> Option<CfgExpr> {
                _ => CfgExpr::Invalid,
            }
        }
-        _ => CfgExpr::Atom(name),
+        _ => CfgAtom::Flag(name).into(),
    };
    // Eat comma separator
@@ -81,53 +128,3 @@ fn next_cfg_expr(it: &mut SliceIter<tt::TokenTree>) -> Option<CfgExpr> {
    }
    Some(ret)
 }
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use mbe::ast_to_token_tree;
-    use syntax::ast::{self, AstNode};
-    fn assert_parse_result(input: &str, expected: CfgExpr) {
-        let (tt, _) = {
-            let source_file = ast::SourceFile::parse(input).ok().unwrap();
-            let tt = source_file.syntax().descendants().find_map(ast::TokenTree::cast).unwrap();
-            ast_to_token_tree(&tt).unwrap()
-        };
-        let cfg = CfgExpr::parse(&tt);
-        assert_eq!(cfg, expected);
-    }
-    #[test]
-    fn test_cfg_expr_parser() {
-        assert_parse_result("#![cfg(foo)]", CfgExpr::Atom("foo".into()));
-        assert_parse_result("#![cfg(foo,)]", CfgExpr::Atom("foo".into()));
-        assert_parse_result(
-            "#![cfg(not(foo))]",
-            CfgExpr::Not(Box::new(CfgExpr::Atom("foo".into()))),
-        );
-        assert_parse_result("#![cfg(foo(bar))]", CfgExpr::Invalid);
-        // Only take the first
-        assert_parse_result(r#"#![cfg(foo, bar = "baz")]"#, CfgExpr::Atom("foo".into()));
-        assert_parse_result(
-            r#"#![cfg(all(foo, bar = "baz"))]"#,
-            CfgExpr::All(vec![
-                CfgExpr::Atom("foo".into()),
-                CfgExpr::KeyValue { key: "bar".into(), value: "baz".into() },
-            ]),
-        );
-        assert_parse_result(
-            r#"#![cfg(any(not(), all(), , bar = "baz",))]"#,
-            CfgExpr::Any(vec![
-                CfgExpr::Not(Box::new(CfgExpr::Invalid)),
-                CfgExpr::All(vec![]),
-                CfgExpr::Invalid,
-                CfgExpr::KeyValue { key: "bar".into(), value: "baz".into() },
-            ]),
-        );
-    }
-}
diff --git a/crates/cfg/src/dnf.rs b/crates/cfg/src/dnf.rs
new file mode 100644
index 000000000..580c9a9a2
--- /dev/null
+++ b/crates/cfg/src/dnf.rs
@@ -0,0 +1,320 @@
+//! Disjunctive Normal Form construction.
+//!
+//! Algorithm from <https://www.cs.drexel.edu/~jjohnson/2015-16/fall/CS270/Lectures/3/dnf.pdf>,
+//! which would have been much easier to read if it used pattern matching. It's also missing the
+//! entire "distribute ANDs over ORs" part, which is not trivial. Oh well.
+//!
+//! This is currently both messy and inefficient. Feel free to improve, there are unit tests.
+use std::fmt;
+use rustc_hash::FxHashSet;
+use crate::{CfgAtom, CfgDiff, CfgExpr, CfgOptions, InactiveReason};
+/// A `#[cfg]` directive in Disjunctive Normal Form (DNF).
+pub struct DnfExpr {
+    conjunctions: Vec<Conjunction>,
+}
+struct Conjunction {
+    literals: Vec<Literal>,
+}
+struct Literal {
+    negate: bool,
+    var: Option<CfgAtom>, // None = Invalid
+}
+impl DnfExpr {
+    pub fn new(expr: CfgExpr) -> Self {
+        let builder = Builder { expr: DnfExpr { conjunctions: Vec::new() } };
+        builder.lower(expr.clone())
+    }
+    /// Computes a list of present or absent atoms in `opts` that cause this expression to evaluate
+    /// to `false`.
+    ///
+    /// Note that flipping a subset of these atoms might be sufficient to make the whole expression
+    /// evaluate to `true`. For that, see `compute_enable_hints`.
+    ///
+    /// Returns `None` when `self` is already true, or contains errors.
+    pub fn why_inactive(&self, opts: &CfgOptions) -> Option<InactiveReason> {
+        let mut res = InactiveReason { enabled: Vec::new(), disabled: Vec::new() };
+        for conj in &self.conjunctions {
+            let mut conj_is_true = true;
+            for lit in &conj.literals {
+                let atom = lit.var.as_ref()?;
+                let enabled = opts.enabled.contains(atom);
+                if lit.negate == enabled {
+                    // Literal is false, but needs to be true for this conjunction.
+                    conj_is_true = false;
+                    if enabled {
+                        res.enabled.push(atom.clone());
+                    } else {
+                        res.disabled.push(atom.clone());
+                    }
+                }
+            }
+            if conj_is_true {
+                // This expression is not actually inactive.
+                return None;
+            }
+        }
+        res.enabled.sort_unstable();
+        res.enabled.dedup();
+        res.disabled.sort_unstable();
+        res.disabled.dedup();
+        Some(res)
+    }
+    /// Returns `CfgDiff` objects that would enable this directive if applied to `opts`.
+    pub fn compute_enable_hints<'a>(
+        &'a self,
+        opts: &'a CfgOptions,
+    ) -> impl Iterator<Item = CfgDiff> + 'a {
+        // A cfg is enabled if any of `self.conjunctions` evaluate to `true`.
+        self.conjunctions.iter().filter_map(move |conj| {
+            let mut enable = FxHashSet::default();
+            let mut disable = FxHashSet::default();
+            for lit in &conj.literals {
+                let atom = lit.var.as_ref()?;
+                let enabled = opts.enabled.contains(atom);
+                if lit.negate && enabled {
+                    disable.insert(atom.clone());
+                }
+                if !lit.negate && !enabled {
+                    enable.insert(atom.clone());
+                }
+            }
+            // Check that this actually makes `conj` true.
+            for lit in &conj.literals {
+                let atom = lit.var.as_ref()?;
+                let enabled = enable.contains(atom)
+                    || (opts.enabled.contains(atom) && !disable.contains(atom));
+                if enabled == lit.negate {
+                    return None;
+                }
+            }
+            if enable.is_empty() && disable.is_empty() {
+                return None;
+            }
+            let mut diff = CfgDiff {
+                enable: enable.into_iter().collect(),
+                disable: disable.into_iter().collect(),
+            };
+            // Undo the FxHashMap randomization for consistent output.
+            diff.enable.sort_unstable();
+            diff.disable.sort_unstable();
+            Some(diff)
+        })
+    }
+}
+impl fmt::Display for DnfExpr {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if self.conjunctions.len() != 1 {
+            write!(f, "any(")?;
+        }
+        for (i, conj) in self.conjunctions.iter().enumerate() {
+            if i != 0 {
+                f.write_str(", ")?;
+            }
+            write!(f, "{}", conj)?;
+        }
+        if self.conjunctions.len() != 1 {
+            write!(f, ")")?;
+        }
+        Ok(())
+    }
+}
+impl Conjunction {
+    fn new(parts: Vec<CfgExpr>) -> Self {
+        let mut literals = Vec::new();
+        for part in parts {
+            match part {
+                CfgExpr::Invalid | CfgExpr::Atom(_) | CfgExpr::Not(_) => {
+                    literals.push(Literal::new(part));
+                }
+                CfgExpr::All(conj) => {
+                    // Flatten.
+                    literals.extend(Conjunction::new(conj).literals);
+                }
+                CfgExpr::Any(_) => unreachable!("disjunction in conjunction"),
+            }
+        }
+        Self { literals }
+    }
+}
+impl fmt::Display for Conjunction {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if self.literals.len() != 1 {
+            write!(f, "all(")?;
+        }
+        for (i, lit) in self.literals.iter().enumerate() {
+            if i != 0 {
+                f.write_str(", ")?;
+            }
+            write!(f, "{}", lit)?;
+        }
+        if self.literals.len() != 1 {
+            write!(f, ")")?;
+        }
+        Ok(())
+    }
+}
+impl Literal {
+    fn new(expr: CfgExpr) -> Self {
+        match expr {
+            CfgExpr::Invalid => Self { negate: false, var: None },
+            CfgExpr::Atom(atom) => Self { negate: false, var: Some(atom) },
+            CfgExpr::Not(expr) => match *expr {
+                CfgExpr::Invalid => Self { negate: true, var: None },
+                CfgExpr::Atom(atom) => Self { negate: true, var: Some(atom) },
+                _ => unreachable!("non-atom {:?}", expr),
+            },
+            CfgExpr::Any(_) | CfgExpr::All(_) => unreachable!("non-literal {:?}", expr),
+        }
+    }
+}
+impl fmt::Display for Literal {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if self.negate {
+            write!(f, "not(")?;
+        }
+        match &self.var {
+            Some(var) => write!(f, "{}", var)?,
+            None => f.write_str("<invalid>")?,
+        }
+        if self.negate {
+            write!(f, ")")?;
+        }
+        Ok(())
+    }
+}
+struct Builder {
+    expr: DnfExpr,
+}
+impl Builder {
+    fn lower(mut self, expr: CfgExpr) -> DnfExpr {
+        let expr = make_nnf(expr);
+        let expr = make_dnf(expr);
+        match expr {
+            CfgExpr::Invalid | CfgExpr::Atom(_) | CfgExpr::Not(_) => {
+                self.expr.conjunctions.push(Conjunction::new(vec![expr]));
+            }
+            CfgExpr::All(conj) => {
+                self.expr.conjunctions.push(Conjunction::new(conj));
+            }
+            CfgExpr::Any(mut disj) => {
+                disj.reverse();
+                while let Some(conj) = disj.pop() {
+                    match conj {
+                        CfgExpr::Invalid | CfgExpr::Atom(_) | CfgExpr::All(_) | CfgExpr::Not(_) => {
+                            self.expr.conjunctions.push(Conjunction::new(vec![conj]));
+                        }
+                        CfgExpr::Any(inner_disj) => {
+                            // Flatten.
+                            disj.extend(inner_disj.into_iter().rev());
+                        }
+                    }
+                }
+            }
+        }
+        self.expr
+    }
+}
+fn make_dnf(expr: CfgExpr) -> CfgExpr {
+    match expr {
+        CfgExpr::Invalid | CfgExpr::Atom(_) | CfgExpr::Not(_) => expr,
+        CfgExpr::Any(e) => CfgExpr::Any(e.into_iter().map(|expr| make_dnf(expr)).collect()),
+        CfgExpr::All(e) => {
+            let e = e.into_iter().map(|expr| make_nnf(expr)).collect::<Vec<_>>();
+            CfgExpr::Any(distribute_conj(&e))
+        }
+    }
+}
+/// Turns a conjunction of expressions into a disjunction of expressions.
+fn distribute_conj(conj: &[CfgExpr]) -> Vec<CfgExpr> {
+    fn go(out: &mut Vec<CfgExpr>, with: &mut Vec<CfgExpr>, rest: &[CfgExpr]) {
+        match rest {
+            [head, tail @ ..] => match head {
+                CfgExpr::Any(disj) => {
+                    for part in disj {
+                        with.push(part.clone());
+                        go(out, with, tail);
+                        with.pop();
+                    }
+                }
+                _ => {
+                    with.push(head.clone());
+                    go(out, with, tail);
+                    with.pop();
+                }
+            },
+            _ => {
+                // Turn accumulated parts into a new conjunction.
+                out.push(CfgExpr::All(with.clone()));
+            }
+        }
+    }
+    let mut out = Vec::new();
+    let mut with = Vec::new();
+    go(&mut out, &mut with, conj);
+    out
+}
+fn make_nnf(expr: CfgExpr) -> CfgExpr {
+    match expr {
+        CfgExpr::Invalid | CfgExpr::Atom(_) => expr,
+        CfgExpr::Any(expr) => CfgExpr::Any(expr.into_iter().map(|expr| make_nnf(expr)).collect()),
+        CfgExpr::All(expr) => CfgExpr::All(expr.into_iter().map(|expr| make_nnf(expr)).collect()),
+        CfgExpr::Not(operand) => match *operand {
+            CfgExpr::Invalid | CfgExpr::Atom(_) => CfgExpr::Not(operand.clone()), // Original negated expr
+            CfgExpr::Not(expr) => {
+                // Remove double negation.
+                make_nnf(*expr)
+            }
+            // Convert negated conjunction/disjunction using DeMorgan's Law.
+            CfgExpr::Any(inner) => CfgExpr::All(
+                inner.into_iter().map(|expr| make_nnf(CfgExpr::Not(Box::new(expr)))).collect(),
+            ),
+            CfgExpr::All(inner) => CfgExpr::Any(
+                inner.into_iter().map(|expr| make_nnf(CfgExpr::Not(Box::new(expr)))).collect(),
+            ),
+        },
+    }
+}
diff --git a/crates/cfg/src/lib.rs b/crates/cfg/src/lib.rs
index a9d50e698..d0e08cf5f 100644
--- a/crates/cfg/src/lib.rs
+++ b/crates/cfg/src/lib.rs
@@ -1,11 +1,17 @@
 //! cfg defines conditional compiling options, `cfg` attibute parser and evaluator
 mod cfg_expr;
+mod dnf;
+#[cfg(test)]
+mod tests;
+use std::fmt;
 use rustc_hash::FxHashSet;
 use tt::SmolStr;
-pub use cfg_expr::CfgExpr;
+pub use cfg_expr::{CfgAtom, CfgExpr};
+pub use dnf::DnfExpr;
 /// Configuration options used for conditional compilition on items with `cfg` attributes.
 /// We have two kind of options in different namespaces: atomic options like `unix`, and
@@ -19,33 +25,131 @@ pub use cfg_expr::CfgExpr;
 /// See: https://doc.rust-lang.org/reference/conditional-compilation.html#set-configuration-options
 #[derive(Debug, Clone, PartialEq, Eq, Default)]
 pub struct CfgOptions {
-    atoms: FxHashSet<SmolStr>,
+    enabled: FxHashSet<CfgAtom>,
-    key_values: FxHashSet<(SmolStr, SmolStr)>,
 }
 impl CfgOptions {
    pub fn check(&self, cfg: &CfgExpr) -> Option<bool> {
-        cfg.fold(&|key, value| match value {
+        cfg.fold(&|atom| self.enabled.contains(atom))
-            None => self.atoms.contains(key),
-            Some(value) => self.key_values.contains(&(key.clone(), value.clone())),
-        })
    }
    pub fn insert_atom(&mut self, key: SmolStr) {
-        self.atoms.insert(key);
+        self.enabled.insert(CfgAtom::Flag(key));
    }
    pub fn insert_key_value(&mut self, key: SmolStr, value: SmolStr) {
-        self.key_values.insert((key, value));
+        self.enabled.insert(CfgAtom::KeyValue { key, value });
    }
    pub fn append(&mut self, other: &CfgOptions) {
-        for atom in &other.atoms {
+        for atom in &other.enabled {
-            self.atoms.insert(atom.clone());
+            self.enabled.insert(atom.clone());
+        }
+    }
+    pub fn apply_diff(&mut self, diff: CfgDiff) {
+        for atom in diff.enable {
+            self.enabled.insert(atom);
        }
-        for (key, value) in &other.key_values {
+        for atom in diff.disable {
-            self.key_values.insert((key.clone(), value.clone()));
+            self.enabled.remove(&atom);
+        }
+    }
+}
+pub struct CfgDiff {
+    // Invariants: No duplicates, no atom that's both in `enable` and `disable`.
+    enable: Vec<CfgAtom>,
+    disable: Vec<CfgAtom>,
+}
+impl CfgDiff {
+    /// Returns the total number of atoms changed by this diff.
+    pub fn len(&self) -> usize {
+        self.enable.len() + self.disable.len()
+    }
+}
+impl fmt::Display for CfgDiff {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if !self.enable.is_empty() {
+            f.write_str("enable ")?;
+            for (i, atom) in self.enable.iter().enumerate() {
+                let sep = match i {
+                    0 => "",
+                    _ if i == self.enable.len() - 1 => " and ",
+                    _ => ", ",
+                };
+                f.write_str(sep)?;
+                write!(f, "{}", atom)?;
+            }
+            if !self.disable.is_empty() {
+                f.write_str("; ")?;
+            }
        }
+        if !self.disable.is_empty() {
+            f.write_str("disable ")?;
+            for (i, atom) in self.disable.iter().enumerate() {
+                let sep = match i {
+                    0 => "",
+                    _ if i == self.enable.len() - 1 => " and ",
+                    _ => ", ",
+                };
+                f.write_str(sep)?;
+                write!(f, "{}", atom)?;
+            }
+        }
+        Ok(())
+    }
+}
+pub struct InactiveReason {
+    enabled: Vec<CfgAtom>,
+    disabled: Vec<CfgAtom>,
+}
+impl fmt::Display for InactiveReason {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if !self.enabled.is_empty() {
+            for (i, atom) in self.enabled.iter().enumerate() {
+                let sep = match i {
+                    0 => "",
+                    _ if i == self.enabled.len() - 1 => " and ",
+                    _ => ", ",
+                };
+                f.write_str(sep)?;
+                write!(f, "{}", atom)?;
+            }
+            let is_are = if self.enabled.len() == 1 { "is" } else { "are" };
+            write!(f, " {} enabled", is_are)?;
+            if !self.disabled.is_empty() {
+                f.write_str(" and ")?;
+            }
+        }
+        if !self.disabled.is_empty() {
+            for (i, atom) in self.disabled.iter().enumerate() {
+                let sep = match i {
+                    0 => "",
+                    _ if i == self.disabled.len() - 1 => " and ",
+                    _ => ", ",
+                };
+                f.write_str(sep)?;
+                write!(f, "{}", atom)?;
+            }
+            let is_are = if self.disabled.len() == 1 { "is" } else { "are" };
+            write!(f, " {} disabled", is_are)?;
+        }
+        Ok(())
    }
 }
diff --git a/crates/cfg/src/tests.rs b/crates/cfg/src/tests.rs
new file mode 100644
index 000000000..bd0f9ec48
--- /dev/null
+++ b/crates/cfg/src/tests.rs
@@ -0,0 +1,193 @@
+use expect_test::{expect, Expect};
+use mbe::ast_to_token_tree;
+use syntax::{ast, AstNode};
+use crate::{CfgAtom, CfgExpr, CfgOptions, DnfExpr};
+fn assert_parse_result(input: &str, expected: CfgExpr) {
+    let (tt, _) = {
+        let source_file = ast::SourceFile::parse(input).ok().unwrap();
+        let tt = source_file.syntax().descendants().find_map(ast::TokenTree::cast).unwrap();
+        ast_to_token_tree(&tt).unwrap()
+    };
+    let cfg = CfgExpr::parse(&tt);
+    assert_eq!(cfg, expected);
+}
+fn check_dnf(input: &str, expect: Expect) {
+    let (tt, _) = {
+        let source_file = ast::SourceFile::parse(input).ok().unwrap();
+        let tt = source_file.syntax().descendants().find_map(ast::TokenTree::cast).unwrap();
+        ast_to_token_tree(&tt).unwrap()
+    };
+    let cfg = CfgExpr::parse(&tt);
+    let actual = format!("#![cfg({})]", DnfExpr::new(cfg));
+    expect.assert_eq(&actual);
+}
+fn check_why_inactive(input: &str, opts: &CfgOptions, expect: Expect) {
+    let (tt, _) = {
+        let source_file = ast::SourceFile::parse(input).ok().unwrap();
+        let tt = source_file.syntax().descendants().find_map(ast::TokenTree::cast).unwrap();
+        ast_to_token_tree(&tt).unwrap()
+    };
+    let cfg = CfgExpr::parse(&tt);
+    let dnf = DnfExpr::new(cfg);
+    let why_inactive = dnf.why_inactive(opts).unwrap().to_string();
+    expect.assert_eq(&why_inactive);
+}
+#[track_caller]
+fn check_enable_hints(input: &str, opts: &CfgOptions, expected_hints: &[&str]) {
+    let (tt, _) = {
+        let source_file = ast::SourceFile::parse(input).ok().unwrap();
+        let tt = source_file.syntax().descendants().find_map(ast::TokenTree::cast).unwrap();
+        ast_to_token_tree(&tt).unwrap()
+    };
+    let cfg = CfgExpr::parse(&tt);
+    let dnf = DnfExpr::new(cfg);
+    let hints = dnf.compute_enable_hints(opts).map(|diff| diff.to_string()).collect::<Vec<_>>();
+    assert_eq!(hints, expected_hints);
+}
+#[test]
+fn test_cfg_expr_parser() {
+    assert_parse_result("#![cfg(foo)]", CfgAtom::Flag("foo".into()).into());
+    assert_parse_result("#![cfg(foo,)]", CfgAtom::Flag("foo".into()).into());
+    assert_parse_result(
+        "#![cfg(not(foo))]",
+        CfgExpr::Not(Box::new(CfgAtom::Flag("foo".into()).into())),
+    );
+    assert_parse_result("#![cfg(foo(bar))]", CfgExpr::Invalid);
+    // Only take the first
+    assert_parse_result(r#"#![cfg(foo, bar = "baz")]"#, CfgAtom::Flag("foo".into()).into());
+    assert_parse_result(
+        r#"#![cfg(all(foo, bar = "baz"))]"#,
+        CfgExpr::All(vec![
+            CfgAtom::Flag("foo".into()).into(),
+            CfgAtom::KeyValue { key: "bar".into(), value: "baz".into() }.into(),
+        ]),
+    );
+    assert_parse_result(
+        r#"#![cfg(any(not(), all(), , bar = "baz",))]"#,
+        CfgExpr::Any(vec![
+            CfgExpr::Not(Box::new(CfgExpr::Invalid)),
+            CfgExpr::All(vec![]),
+            CfgExpr::Invalid,
+            CfgAtom::KeyValue { key: "bar".into(), value: "baz".into() }.into(),
+        ]),
+    );
+}
+#[test]
+fn smoke() {
+    check_dnf("#![cfg(test)]", expect![[r#"#![cfg(test)]"#]]);
+    check_dnf("#![cfg(not(test))]", expect![[r#"#![cfg(not(test))]"#]]);
+    check_dnf("#![cfg(not(not(test)))]", expect![[r#"#![cfg(test)]"#]]);
+    check_dnf("#![cfg(all(a, b))]", expect![[r#"#![cfg(all(a, b))]"#]]);
+    check_dnf("#![cfg(any(a, b))]", expect![[r#"#![cfg(any(a, b))]"#]]);
+    check_dnf("#![cfg(not(a))]", expect![[r#"#![cfg(not(a))]"#]]);
+}
+#[test]
+fn distribute() {
+    check_dnf("#![cfg(all(any(a, b), c))]", expect![[r#"#![cfg(any(all(a, c), all(b, c)))]"#]]);
+    check_dnf("#![cfg(all(c, any(a, b)))]", expect![[r#"#![cfg(any(all(c, a), all(c, b)))]"#]]);
+    check_dnf(
+        "#![cfg(all(any(a, b), any(c, d)))]",
+        expect![[r#"#![cfg(any(all(a, c), all(a, d), all(b, c), all(b, d)))]"#]],
+    );
+    check_dnf(
+        "#![cfg(all(any(a, b, c), any(d, e, f), g))]",
+        expect![[
+            r#"#![cfg(any(all(a, d, g), all(a, e, g), all(a, f, g), all(b, d, g), all(b, e, g), all(b, f, g), all(c, d, g), all(c, e, g), all(c, f, g)))]"#
+        ]],
+    );
+}
+#[test]
+fn demorgan() {
+    check_dnf("#![cfg(not(all(a, b)))]", expect![[r#"#![cfg(any(not(a), not(b)))]"#]]);
+    check_dnf("#![cfg(not(any(a, b)))]", expect![[r#"#![cfg(all(not(a), not(b)))]"#]]);
+    check_dnf("#![cfg(not(all(not(a), b)))]", expect![[r#"#![cfg(any(a, not(b)))]"#]]);
+    check_dnf("#![cfg(not(any(a, not(b))))]", expect![[r#"#![cfg(all(not(a), b))]"#]]);
+}
+#[test]
+fn nested() {
+    check_dnf("#![cfg(all(any(a), not(all(any(b)))))]", expect![[r#"#![cfg(all(a, not(b)))]"#]]);
+    check_dnf("#![cfg(any(any(a, b)))]", expect![[r#"#![cfg(any(a, b))]"#]]);
+    check_dnf("#![cfg(not(any(any(a, b))))]", expect![[r#"#![cfg(all(not(a), not(b)))]"#]]);
+    check_dnf("#![cfg(all(all(a, b)))]", expect![[r#"#![cfg(all(a, b))]"#]]);
+    check_dnf("#![cfg(not(all(all(a, b))))]", expect![[r#"#![cfg(any(not(a), not(b)))]"#]]);
+}
+#[test]
+fn hints() {
+    let mut opts = CfgOptions::default();
+    check_enable_hints("#![cfg(test)]", &opts, &["enable test"]);
+    check_enable_hints("#![cfg(not(test))]", &opts, &[]);
+    check_enable_hints("#![cfg(any(a, b))]", &opts, &["enable a", "enable b"]);
+    check_enable_hints("#![cfg(any(b, a))]", &opts, &["enable b", "enable a"]);
+    check_enable_hints("#![cfg(all(a, b))]", &opts, &["enable a and b"]);
+    opts.insert_atom("test".into());
+    check_enable_hints("#![cfg(test)]", &opts, &[]);
+    check_enable_hints("#![cfg(not(test))]", &opts, &["disable test"]);
+}
+/// Tests that we don't suggest hints for cfgs that express an inconsistent formula.
+#[test]
+fn hints_impossible() {
+    let mut opts = CfgOptions::default();
+    check_enable_hints("#![cfg(all(test, not(test)))]", &opts, &[]);
+    opts.insert_atom("test".into());
+    check_enable_hints("#![cfg(all(test, not(test)))]", &opts, &[]);
+}
+#[test]
+fn why_inactive() {
+    let mut opts = CfgOptions::default();
+    opts.insert_atom("test".into());
+    opts.insert_atom("test2".into());
+    check_why_inactive("#![cfg(a)]", &opts, expect![["a is disabled"]]);
+    check_why_inactive("#![cfg(not(test))]", &opts, expect![["test is enabled"]]);
+    check_why_inactive(
+        "#![cfg(all(not(test), not(test2)))]",
+        &opts,
+        expect![["test and test2 are enabled"]],
+    );
+    check_why_inactive("#![cfg(all(a, b))]", &opts, expect![["a and b are disabled"]]);
+    check_why_inactive(
+        "#![cfg(all(not(test), a))]",
+        &opts,
+        expect![["test is enabled and a is disabled"]],
+    );
+    check_why_inactive(
+        "#![cfg(all(not(test), test2, a))]",
+        &opts,
+        expect![["test is enabled and a is disabled"]],
+    );
+    check_why_inactive(
+        "#![cfg(all(not(test), not(test2), a))]",
+        &opts,
+        expect![["test and test2 are enabled and a is disabled"]],
+    );
+}
diff --git a/crates/completion/src/completion_context.rs b/crates/completion/src/completion_context.rs
index dc4e136c6..e4f86d0e0 100644
--- a/crates/completion/src/completion_context.rs
+++ b/crates/completion/src/completion_context.rs
@@ -246,6 +246,19 @@ impl<'a> CompletionContext<'a> {
        }
    }
+    pub(crate) fn active_name_and_type(&self) -> Option<(String, Type)> {
+        if let Some(record_field) = &self.record_field_syntax {
+            mark::hit!(record_field_type_match);
+            let (struct_field, _local) = self.sema.resolve_record_field(record_field)?;
+            Some((struct_field.name(self.db).to_string(), struct_field.signature_ty(self.db)))
+        } else if let Some(active_parameter) = &self.active_parameter {
+            mark::hit!(active_param_type_match);
+            Some((active_parameter.name.clone(), active_parameter.ty.clone()))
+        } else {
+            None
+        }
+    }
    fn fill_keyword_patterns(&mut self, file_with_fake_ident: &SyntaxNode, offset: TextSize) {
        let fake_ident_token = file_with_fake_ident.token_at_offset(offset).right_biased().unwrap();
        let syntax_element = NodeOrToken::Token(fake_ident_token);
diff --git a/crates/completion/src/completion_item.rs b/crates/completion/src/completion_item.rs
index f8be0ad2b..2e1ca0e59 100644
--- a/crates/completion/src/completion_item.rs
+++ b/crates/completion/src/completion_item.rs
@@ -2,7 +2,7 @@
 use std::fmt;
-use hir::Documentation;
+use hir::{Documentation, Mutability};
 use syntax::TextRange;
 use text_edit::TextEdit;
@@ -56,6 +56,10 @@ pub struct CompletionItem {
    /// Score is useful to pre select or display in better order completion items
    score: Option<CompletionScore>,
+    /// Indicates that a reference or mutable reference to this variable is a
+    /// possible match.
+    ref_match: Option<(Mutability, CompletionScore)>,
 }
 // We use custom debug for CompletionItem to make snapshot tests more readable.
@@ -194,6 +198,7 @@ impl CompletionItem {
            deprecated: None,
            trigger_call_info: None,
            score: None,
+            ref_match: None,
        }
    }
    /// What user sees in pop-up in the UI.
@@ -240,10 +245,15 @@ impl CompletionItem {
    pub fn trigger_call_info(&self) -> bool {
        self.trigger_call_info
    }
+    pub fn ref_match(&self) -> Option<(Mutability, CompletionScore)> {
+        self.ref_match
+    }
 }
 /// A helper to make `CompletionItem`s.
 #[must_use]
+#[derive(Clone)]
 pub(crate) struct Builder {
    source_range: TextRange,
    completion_kind: CompletionKind,
@@ -258,6 +268,7 @@ pub(crate) struct Builder {
    deprecated: Option<bool>,
    trigger_call_info: Option<bool>,
    score: Option<CompletionScore>,
+    ref_match: Option<(Mutability, CompletionScore)>,
 }
 impl Builder {
@@ -288,6 +299,7 @@ impl Builder {
            deprecated: self.deprecated.unwrap_or(false),
            trigger_call_info: self.trigger_call_info.unwrap_or(false),
            score: self.score,
+            ref_match: self.ref_match,
        }
    }
    pub(crate) fn lookup_by(mut self, lookup: impl Into<String>) -> Builder {
@@ -350,6 +362,13 @@ impl Builder {
        self.trigger_call_info = Some(true);
        self
    }
+    pub(crate) fn set_ref_match(
+        mut self,
+        ref_match: Option<(Mutability, CompletionScore)>,
+    ) -> Builder {
+        self.ref_match = ref_match;
+        self
+    }
 }
 impl<'a> Into<CompletionItem> for Builder {
diff --git a/crates/completion/src/presentation.rs b/crates/completion/src/presentation.rs
index 0a0dc1ce5..0a6f5a1ea 100644
--- a/crates/completion/src/presentation.rs
+++ b/crates/completion/src/presentation.rs
@@ -1,7 +1,7 @@
 //! This modules takes care of rendering various definitions as completion items.
 //! It also handles scoring (sorting) completions.
-use hir::{HasAttrs, HasSource, HirDisplay, ModPath, ScopeDef, StructKind, Type};
+use hir::{HasAttrs, HasSource, HirDisplay, ModPath, Mutability, ScopeDef, StructKind, Type};
 use itertools::Itertools;
 use syntax::{ast::NameOwner, display::*};
 use test_utils::mark;
@@ -107,9 +107,16 @@ impl Completions {
            }
        };
+        let mut ref_match = None;
        if let ScopeDef::Local(local) = resolution {
-            if let Some(score) = compute_score(ctx, &local.ty(ctx.db), &local_name) {
+            if let Some((active_name, active_type)) = ctx.active_name_and_type() {
-                completion_item = completion_item.set_score(score);
+                let ty = local.ty(ctx.db);
+                if let Some(score) =
+                    compute_score_from_active(&active_type, &active_name, &ty, &local_name)
+                {
+                    completion_item = completion_item.set_score(score);
+                }
+                ref_match = refed_type_matches(&active_type, &active_name, &ty, &local_name);
            }
        }
@@ -131,7 +138,7 @@ impl Completions {
            }
        }
-        completion_item.kind(kind).set_documentation(docs).add_to(self)
+        completion_item.kind(kind).set_documentation(docs).set_ref_match(ref_match).add_to(self)
    }
    pub(crate) fn add_macro(
@@ -297,9 +304,14 @@ impl Completions {
    ) {
        let is_deprecated = is_deprecated(variant, ctx.db);
        let name = local_name.unwrap_or_else(|| variant.name(ctx.db).to_string());
-        let qualified_name = match &path {
+        let (qualified_name, short_qualified_name) = match &path {
-            Some(it) => it.to_string(),
+            Some(path) => {
-            None => name.to_string(),
+                let full = path.to_string();
+                let short =
+                    path.segments[path.segments.len().saturating_sub(2)..].iter().join("::");
+                (full, short)
+            }
+            None => (name.to_string(), name.to_string()),
        };
        let detail_types = variant
            .fields(ctx.db)
@@ -328,39 +340,27 @@ impl Completions {
        .set_deprecated(is_deprecated)
        .detail(detail);
-        if path.is_some() {
-            res = res.lookup_by(name);
-        }
        if variant_kind == StructKind::Tuple {
            mark::hit!(inserts_parens_for_tuple_enums);
            let params = Params::Anonymous(variant.fields(ctx.db).len());
-            res = res.add_call_parens(ctx, qualified_name, params)
+            res = res.add_call_parens(ctx, short_qualified_name, params)
+        } else if path.is_some() {
+            res = res.lookup_by(short_qualified_name);
        }
        res.add_to(self);
    }
 }
-pub(crate) fn compute_score(
+fn compute_score_from_active(
-    ctx: &CompletionContext,
+    active_type: &Type,
+    active_name: &str,
    ty: &Type,
    name: &str,
 ) -> Option<CompletionScore> {
-    let (active_name, active_type) = if let Some(record_field) = &ctx.record_field_syntax {
-        mark::hit!(record_field_type_match);
-        let (struct_field, _local) = ctx.sema.resolve_record_field(record_field)?;
-        (struct_field.name(ctx.db).to_string(), struct_field.signature_ty(ctx.db))
-    } else if let Some(active_parameter) = &ctx.active_parameter {
-        mark::hit!(active_param_type_match);
-        (active_parameter.name.clone(), active_parameter.ty.clone())
-    } else {
-        return None;
-    };
    // Compute score
    // For the same type
-    if &active_type != ty {
+    if active_type != ty {
        return None;
    }
@@ -373,6 +373,24 @@ pub(crate) fn compute_score(
    Some(res)
 }
+fn refed_type_matches(
+    active_type: &Type,
+    active_name: &str,
+    ty: &Type,
+    name: &str,
+) -> Option<(Mutability, CompletionScore)> {
+    let derefed_active = active_type.remove_ref()?;
+    let score = compute_score_from_active(&derefed_active, &active_name, &ty, &name)?;
+    Some((
+        if active_type.is_mutable_reference() { Mutability::Mut } else { Mutability::Shared },
+        score,
+    ))
+}
+fn compute_score(ctx: &CompletionContext, ty: &Type, name: &str) -> Option<CompletionScore> {
+    let (active_name, active_type) = ctx.active_name_and_type()?;
+    compute_score_from_active(&active_type, &active_name, ty, name)
+}
 enum Params {
    Named(Vec<String>),
@@ -592,6 +610,57 @@ fn main() { Foo::Fo<|> }
    }
    #[test]
+    fn lookup_enums_by_two_qualifiers() {
+        check(
+            r#"
+mod m {
+    pub enum Spam { Foo, Bar(i32) }
+}
+fn main() { let _: m::Spam = S<|> }
+"#,
+            expect![[r#"
+                [
+                    CompletionItem {
+                        label: "Spam::Bar(…)",
+                        source_range: 75..76,
+                        delete: 75..76,
+                        insert: "Spam::Bar($0)",
+                        kind: EnumVariant,
+                        lookup: "Spam::Bar",
+                        detail: "(i32)",
+                        trigger_call_info: true,
+                    },
+                    CompletionItem {
+                        label: "m",
+                        source_range: 75..76,
+                        delete: 75..76,
+                        insert: "m",
+                        kind: Module,
+                    },
+                    CompletionItem {
+                        label: "m::Spam::Foo",
+                        source_range: 75..76,
+                        delete: 75..76,
+                        insert: "m::Spam::Foo",
+                        kind: EnumVariant,
+                        lookup: "Spam::Foo",
+                        detail: "()",
+                    },
+                    CompletionItem {
+                        label: "main()",
+                        source_range: 75..76,
+                        delete: 75..76,
+                        insert: "main()$0",
+                        kind: Function,
+                        lookup: "main",
+                        detail: "fn main()",
+                    },
+                ]
+            "#]],
+        )
+    }
+    #[test]
    fn sets_deprecated_flag_in_completion_items() {
        check(
            r#"
diff --git a/crates/hir/src/code_model.rs b/crates/hir/src/code_model.rs
index 7f169ccd2..63c1a8ebf 100644
--- a/crates/hir/src/code_model.rs
+++ b/crates/hir/src/code_model.rs
@@ -31,8 +31,7 @@ use hir_ty::{
    autoderef,
    display::{HirDisplayError, HirFormatter},
    method_resolution,
-    traits::Solution,
+    traits::{FnTrait, Solution, SolutionVariables},
-    traits::SolutionVariables,
    ApplicationTy, BoundVar, CallableDefId, Canonical, DebruijnIndex, FnSig, GenericPredicate,
    InEnvironment, Obligation, ProjectionPredicate, ProjectionTy, Substs, TraitEnvironment, Ty,
    TyDefId, TyKind, TypeCtor,
@@ -781,6 +780,7 @@ impl Function {
    }
    pub fn diagnostics(self, db: &dyn HirDatabase, sink: &mut DiagnosticSink) {
+        hir_def::diagnostics::validate_body(db.upcast(), self.id.into(), sink);
        hir_ty::diagnostics::validate_module_item(db, self.id.into(), sink);
        hir_ty::diagnostics::validate_body(db, self.id.into(), sink);
    }
@@ -1385,6 +1385,28 @@ impl Type {
        )
    }
+    /// Checks that particular type `ty` implements `std::ops::FnOnce`.
+    ///
+    /// This function can be used to check if a particular type is callable, since FnOnce is a
+    /// supertrait of Fn and FnMut, so all callable types implements at least FnOnce.
+    pub fn impls_fnonce(&self, db: &dyn HirDatabase) -> bool {
+        let krate = self.krate;
+        let fnonce_trait = match FnTrait::FnOnce.get_id(db, krate) {
+            Some(it) => it,
+            None => return false,
+        };
+        let canonical_ty = Canonical { value: self.ty.value.clone(), kinds: Arc::new([]) };
+        method_resolution::implements_trait(
+            &canonical_ty,
+            db,
+            self.ty.environment.clone(),
+            krate,
+            fnonce_trait,
+        )
+    }
    pub fn impls_trait(&self, db: &dyn HirDatabase, trait_: Trait, args: &[Type]) -> bool {
        let trait_ref = hir_ty::TraitRef {
            trait_: trait_.id,
diff --git a/crates/hir_def/src/attr.rs b/crates/hir_def/src/attr.rs
index dea552a60..b2ce7ca3c 100644
--- a/crates/hir_def/src/attr.rs
+++ b/crates/hir_def/src/attr.rs
@@ -125,12 +125,20 @@ impl Attrs {
        AttrQuery { attrs: self, key }
    }
-    pub fn cfg(&self) -> impl Iterator<Item = CfgExpr> + '_ {
+    pub fn cfg(&self) -> Option<CfgExpr> {
        // FIXME: handle cfg_attr :-)
-        self.by_key("cfg").tt_values().map(CfgExpr::parse)
+        let mut cfgs = self.by_key("cfg").tt_values().map(CfgExpr::parse).collect::<Vec<_>>();
+        match cfgs.len() {
+            0 => None,
+            1 => Some(cfgs.pop().unwrap()),
+            _ => Some(CfgExpr::All(cfgs)),
+        }
    }
    pub(crate) fn is_cfg_enabled(&self, cfg_options: &CfgOptions) -> bool {
-        self.cfg().all(|cfg| cfg_options.check(&cfg) != Some(false))
+        match self.cfg() {
+            None => true,
+            Some(cfg) => cfg_options.check(&cfg) != Some(false),
+        }
    }
 }
diff --git a/crates/hir_def/src/body.rs b/crates/hir_def/src/body.rs
index d51036e4f..d10b1af01 100644
--- a/crates/hir_def/src/body.rs
+++ b/crates/hir_def/src/body.rs
@@ -1,6 +1,9 @@
 //! Defines `Body`: a lowered representation of bodies of functions, statics and
 //! consts.
 mod lower;
+mod diagnostics;
+#[cfg(test)]
+mod tests;
 pub mod scope;
 use std::{mem, ops::Index, sync::Arc};
@@ -10,7 +13,10 @@ use base_db::CrateId;
 use cfg::CfgOptions;
 use drop_bomb::DropBomb;
 use either::Either;
-use hir_expand::{ast_id_map::AstIdMap, hygiene::Hygiene, AstId, HirFileId, InFile, MacroDefId};
+use hir_expand::{
+    ast_id_map::AstIdMap, diagnostics::DiagnosticSink, hygiene::Hygiene, AstId, HirFileId, InFile,
+    MacroDefId,
+};
 use rustc_hash::FxHashMap;
 use syntax::{ast, AstNode, AstPtr};
 use test_utils::mark;
@@ -150,8 +156,12 @@ impl Expander {
        InFile { file_id: self.current_file_id, value }
    }
-    pub(crate) fn is_cfg_enabled(&self, owner: &dyn ast::AttrsOwner) -> bool {
+    pub(crate) fn parse_attrs(&self, owner: &dyn ast::AttrsOwner) -> Attrs {
-        self.cfg_expander.is_cfg_enabled(owner)
+        self.cfg_expander.parse_attrs(owner)
+    }
+    pub(crate) fn cfg_options(&self) -> &CfgOptions {
+        &self.cfg_expander.cfg_options
    }
    fn parse_path(&mut self, path: ast::Path) -> Option<Path> {
@@ -219,6 +229,10 @@ pub struct BodySourceMap {
    pat_map_back: ArenaMap<PatId, Result<PatSource, SyntheticSyntax>>,
    field_map: FxHashMap<(ExprId, usize), InFile<AstPtr<ast::RecordExprField>>>,
    expansions: FxHashMap<InFile<AstPtr<ast::MacroCall>>, HirFileId>,
+    /// Diagnostics accumulated during body lowering. These contain `AstPtr`s and so are stored in
+    /// the source map (since they're just as volatile).
+    diagnostics: Vec<diagnostics::BodyDiagnostic>,
 }
 #[derive(Default, Debug, Eq, PartialEq, Clone, Copy)]
@@ -318,45 +332,10 @@ impl BodySourceMap {
    pub fn field_syntax(&self, expr: ExprId, field: usize) -> InFile<AstPtr<ast::RecordExprField>> {
        self.field_map[&(expr, field)].clone()
    }
-}
-#[cfg(test)]
-mod tests {
-    use base_db::{fixture::WithFixture, SourceDatabase};
-    use test_utils::mark;
-    use crate::ModuleDefId;
+    pub(crate) fn add_diagnostics(&self, _db: &dyn DefDatabase, sink: &mut DiagnosticSink<'_>) {
+        for diag in &self.diagnostics {
-    use super::*;
+            diag.add_to(sink);
+        }
-    fn lower(ra_fixture: &str) -> Arc<Body> {
-        let (db, file_id) = crate::test_db::TestDB::with_single_file(ra_fixture);
-        let krate = db.crate_graph().iter().next().unwrap();
-        let def_map = db.crate_def_map(krate);
-        let module = def_map.modules_for_file(file_id).next().unwrap();
-        let module = &def_map[module];
-        let fn_def = match module.scope.declarations().next().unwrap() {
-            ModuleDefId::FunctionId(it) => it,
-            _ => panic!(),
-        };
-        db.body(fn_def.into())
-    }
-    #[test]
-    fn your_stack_belongs_to_me() {
-        mark::check!(your_stack_belongs_to_me);
-        lower(
-            "
-macro_rules! n_nuple {
-    ($e:tt) => ();
-    ($($rest:tt)*) => {{
-        (n_nuple!($($rest)*)None,)
-    }};
-}
-fn main() { n_nuple!(1,2,3); }
-",
-        );
    }
 }
diff --git a/crates/hir_def/src/body/diagnostics.rs b/crates/hir_def/src/body/diagnostics.rs
new file mode 100644
index 000000000..cfa47d189
--- /dev/null
+++ b/crates/hir_def/src/body/diagnostics.rs
@@ -0,0 +1,20 @@
+//! Diagnostics emitted during body lowering.
+use hir_expand::diagnostics::DiagnosticSink;
+use crate::diagnostics::InactiveCode;
+#[derive(Debug, Eq, PartialEq)]
+pub enum BodyDiagnostic {
+    InactiveCode(InactiveCode),
+}
+impl BodyDiagnostic {
+    pub fn add_to(&self, sink: &mut DiagnosticSink<'_>) {
+        match self {
+            BodyDiagnostic::InactiveCode(diag) => {
+                sink.push(diag.clone());
+            }
+        }
+    }
+}
diff --git a/crates/hir_def/src/body/lower.rs b/crates/hir_def/src/body/lower.rs
index 01e72690a..ddc267b83 100644
--- a/crates/hir_def/src/body/lower.rs
+++ b/crates/hir_def/src/body/lower.rs
@@ -16,7 +16,7 @@ use syntax::{
        self, ArgListOwner, ArrayExprKind, AstChildren, LiteralKind, LoopBodyOwner, NameOwner,
        SlicePatComponents,
    },
-    AstNode, AstPtr,
+    AstNode, AstPtr, SyntaxNodePtr,
 };
 use test_utils::mark;
@@ -25,6 +25,7 @@ use crate::{
    body::{Body, BodySourceMap, Expander, PatPtr, SyntheticSyntax},
    builtin_type::{BuiltinFloat, BuiltinInt},
    db::DefDatabase,
+    diagnostics::InactiveCode,
    expr::{
        dummy_expr_id, ArithOp, Array, BinaryOp, BindingAnnotation, CmpOp, Expr, ExprId, Literal,
        LogicOp, MatchArm, Ordering, Pat, PatId, RecordFieldPat, RecordLitField, Statement,
@@ -37,7 +38,7 @@ use crate::{
    StaticLoc, StructLoc, TraitLoc, TypeAliasLoc, UnionLoc,
 };
-use super::{ExprSource, PatSource};
+use super::{diagnostics::BodyDiagnostic, ExprSource, PatSource};
 pub(crate) struct LowerCtx {
    hygiene: Hygiene,
@@ -176,7 +177,7 @@ impl ExprCollector<'_> {
    fn collect_expr(&mut self, expr: ast::Expr) -> ExprId {
        let syntax_ptr = AstPtr::new(&expr);
-        if !self.expander.is_cfg_enabled(&expr) {
+        if self.check_cfg(&expr).is_none() {
            return self.missing_expr();
        }
@@ -354,13 +355,15 @@ impl ExprCollector<'_> {
                let arms = if let Some(match_arm_list) = e.match_arm_list() {
                    match_arm_list
                        .arms()
-                        .map(|arm| MatchArm {
+                        .filter_map(|arm| {
-                            pat: self.collect_pat_opt(arm.pat()),
+                            self.check_cfg(&arm).map(|()| MatchArm {
-                            expr: self.collect_expr_opt(arm.expr()),
+                                pat: self.collect_pat_opt(arm.pat()),
-                            guard: arm
+                                expr: self.collect_expr_opt(arm.expr()),
-                                .guard()
+                                guard: arm
-                                .and_then(|guard| guard.expr())
+                                    .guard()
-                                .map(|e| self.collect_expr(e)),
+                                    .and_then(|guard| guard.expr())
+                                    .map(|e| self.collect_expr(e)),
+                            })
                        })
                        .collect()
                } else {
@@ -406,9 +409,8 @@ impl ExprCollector<'_> {
                        .fields()
                        .inspect(|field| field_ptrs.push(AstPtr::new(field)))
                        .filter_map(|field| {
-                            if !self.expander.is_cfg_enabled(&field) {
+                            self.check_cfg(&field)?;
-                                return None;
-                            }
                            let name = field.field_name()?.as_name();
                            Some(RecordLitField {
@@ -620,15 +622,23 @@ impl ExprCollector<'_> {
            .filter_map(|s| {
                let stmt = match s {
                    ast::Stmt::LetStmt(stmt) => {
+                        self.check_cfg(&stmt)?;
                        let pat = self.collect_pat_opt(stmt.pat());
                        let type_ref = stmt.ty().map(|it| TypeRef::from_ast(&self.ctx(), it));
                        let initializer = stmt.initializer().map(|e| self.collect_expr(e));
                        Statement::Let { pat, type_ref, initializer }
                    }
                    ast::Stmt::ExprStmt(stmt) => {
+                        self.check_cfg(&stmt)?;
                        Statement::Expr(self.collect_expr_opt(stmt.expr()))
                    }
-                    ast::Stmt::Item(_) => return None,
+                    ast::Stmt::Item(item) => {
+                        self.check_cfg(&item)?;
+                        return None;
+                    }
                };
                Some(stmt)
            })
@@ -872,6 +882,28 @@ impl ExprCollector<'_> {
        (args, ellipsis)
    }
+    /// Returns `None` (and emits diagnostics) when `owner` if `#[cfg]`d out, and `Some(())` when
+    /// not.
+    fn check_cfg(&mut self, owner: &dyn ast::AttrsOwner) -> Option<()> {
+        match self.expander.parse_attrs(owner).cfg() {
+            Some(cfg) => {
+                if self.expander.cfg_options().check(&cfg) != Some(false) {
+                    return Some(());
+                }
+                self.source_map.diagnostics.push(BodyDiagnostic::InactiveCode(InactiveCode {
+                    file: self.expander.current_file_id,
+                    node: SyntaxNodePtr::new(owner.syntax()),
+                    cfg,
+                    opts: self.expander.cfg_options().clone(),
+                }));
+                None
+            }
+            None => Some(()),
+        }
+    }
 }
 impl From<ast::BinOp> for BinaryOp {
diff --git a/crates/hir_def/src/body/tests.rs b/crates/hir_def/src/body/tests.rs
new file mode 100644
index 000000000..f07df5cee
--- /dev/null
+++ b/crates/hir_def/src/body/tests.rs
@@ -0,0 +1,75 @@
+use base_db::{fixture::WithFixture, SourceDatabase};
+use test_utils::mark;
+use crate::{test_db::TestDB, ModuleDefId};
+use super::*;
+fn lower(ra_fixture: &str) -> Arc<Body> {
+    let (db, file_id) = crate::test_db::TestDB::with_single_file(ra_fixture);
+    let krate = db.crate_graph().iter().next().unwrap();
+    let def_map = db.crate_def_map(krate);
+    let module = def_map.modules_for_file(file_id).next().unwrap();
+    let module = &def_map[module];
+    let fn_def = match module.scope.declarations().next().unwrap() {
+        ModuleDefId::FunctionId(it) => it,
+        _ => panic!(),
+    };
+    db.body(fn_def.into())
+}
+fn check_diagnostics(ra_fixture: &str) {
+    let db: TestDB = TestDB::with_files(ra_fixture);
+    db.check_diagnostics();
+}
+#[test]
+fn your_stack_belongs_to_me() {
+    mark::check!(your_stack_belongs_to_me);
+    lower(
+        "
+macro_rules! n_nuple {
+    ($e:tt) => ();
+    ($($rest:tt)*) => {{
+        (n_nuple!($($rest)*)None,)
+    }};
+}
+fn main() { n_nuple!(1,2,3); }
+",
+    );
+}
+#[test]
+fn cfg_diagnostics() {
+    check_diagnostics(
+        r"
+fn f() {
+    // The three g̶e̶n̶d̶e̶r̶s̶ statements:
+    #[cfg(a)] fn f() {}  // Item statement
+  //^^^^^^^^^^^^^^^^^^^ code is inactive due to #[cfg] directives: a is disabled
+    #[cfg(a)] {}         // Expression statement
+  //^^^^^^^^^^^^ code is inactive due to #[cfg] directives: a is disabled
+    #[cfg(a)] let x = 0; // let statement
+  //^^^^^^^^^^^^^^^^^^^^ code is inactive due to #[cfg] directives: a is disabled
+    abc(#[cfg(a)] 0);
+      //^^^^^^^^^^^ code is inactive due to #[cfg] directives: a is disabled
+    let x = Struct {
+        #[cfg(a)] f: 0,
+      //^^^^^^^^^^^^^^ code is inactive due to #[cfg] directives: a is disabled
+    };
+    match () {
+        () => (),
+        #[cfg(a)] () => (),
+      //^^^^^^^^^^^^^^^^^^ code is inactive due to #[cfg] directives: a is disabled
+    }
+    #[cfg(a)] 0          // Trailing expression of block
+  //^^^^^^^^^^^ code is inactive due to #[cfg] directives: a is disabled
+}
+    ",
+    );
+}
diff --git a/crates/hir_def/src/diagnostics.rs b/crates/hir_def/src/diagnostics.rs
index c9c08b01f..b221b290c 100644
--- a/crates/hir_def/src/diagnostics.rs
+++ b/crates/hir_def/src/diagnostics.rs
@@ -1,11 +1,19 @@
 //! Diagnostics produced by `hir_def`.
 use std::any::Any;
+use stdx::format_to;
-use hir_expand::diagnostics::{Diagnostic, DiagnosticCode};
+use cfg::{CfgExpr, CfgOptions, DnfExpr};
+use hir_expand::diagnostics::{Diagnostic, DiagnosticCode, DiagnosticSink};
+use hir_expand::{HirFileId, InFile};
 use syntax::{ast, AstPtr, SyntaxNodePtr};
-use hir_expand::{HirFileId, InFile};
+use crate::{db::DefDatabase, DefWithBodyId};
+pub fn validate_body(db: &dyn DefDatabase, owner: DefWithBodyId, sink: &mut DiagnosticSink<'_>) {
+    let source_map = db.body_with_source_map(owner).1;
+    source_map.add_diagnostics(db, sink);
+}
 // Diagnostic: unresolved-module
 //
@@ -87,13 +95,15 @@ impl Diagnostic for UnresolvedImport {
    }
 }
-// Diagnostic: unconfigured-code
+// Diagnostic: inactive-code
 //
 // This diagnostic is shown for code with inactive `#[cfg]` attributes.
-#[derive(Debug)]
+#[derive(Debug, Clone, Eq, PartialEq)]
 pub struct InactiveCode {
    pub file: HirFileId,
    pub node: SyntaxNodePtr,
+    pub cfg: CfgExpr,
+    pub opts: CfgOptions,
 }
 impl Diagnostic for InactiveCode {
@@ -101,8 +111,14 @@ impl Diagnostic for InactiveCode {
        DiagnosticCode("inactive-code")
    }
    fn message(&self) -> String {
-        // FIXME: say *why* it is configured out
+        let inactive = DnfExpr::new(self.cfg.clone()).why_inactive(&self.opts);
-        "code is inactive due to #[cfg] directives".to_string()
+        let mut buf = "code is inactive due to #[cfg] directives".to_string();
+        if let Some(inactive) = inactive {
+            format_to!(buf, ": {}", inactive);
+        }
+        buf
    }
    fn display_source(&self) -> InFile<SyntaxNodePtr> {
        InFile::new(self.file, self.node.clone())
diff --git a/crates/hir_def/src/item_tree/lower.rs b/crates/hir_def/src/item_tree/lower.rs
index 3328639cf..ca7fb4a43 100644
--- a/crates/hir_def/src/item_tree/lower.rs
+++ b/crates/hir_def/src/item_tree/lower.rs
@@ -3,7 +3,7 @@
 use std::{collections::hash_map::Entry, mem, sync::Arc};
 use arena::map::ArenaMap;
-use hir_expand::{ast_id_map::AstIdMap, hygiene::Hygiene, HirFileId};
+use hir_expand::{ast_id_map::AstIdMap, hygiene::Hygiene, name::known, HirFileId};
 use smallvec::SmallVec;
 use syntax::{
    ast::{self, ModuleItemOwner},
@@ -555,7 +555,8 @@ impl Ctx {
                    let id: ModItem = match item {
                        ast::ExternItem::Fn(ast) => {
                            let func = self.lower_function(&ast)?;
-                            self.data().functions[func.index].is_unsafe = true;
+                            self.data().functions[func.index].is_unsafe =
+                                is_intrinsic_fn_unsafe(&self.data().functions[func.index].name);
                            func.into()
                        }
                        ast::ExternItem::Static(ast) => {
@@ -713,3 +714,45 @@ enum GenericsOwner<'a> {
    TypeAlias,
    Impl,
 }
+/// Returns `true` if the given intrinsic is unsafe to call, or false otherwise.
+fn is_intrinsic_fn_unsafe(name: &Name) -> bool {
+    // Should be kept in sync with https://github.com/rust-lang/rust/blob/c6e4db620a7d2f569f11dcab627430921ea8aacf/compiler/rustc_typeck/src/check/intrinsic.rs#L68
+    ![
+        known::abort,
+        known::min_align_of,
+        known::needs_drop,
+        known::caller_location,
+        known::size_of_val,
+        known::min_align_of_val,
+        known::add_with_overflow,
+        known::sub_with_overflow,
+        known::mul_with_overflow,
+        known::wrapping_add,
+        known::wrapping_sub,
+        known::wrapping_mul,
+        known::saturating_add,
+        known::saturating_sub,
+        known::rotate_left,
+        known::rotate_right,
+        known::ctpop,
+        known::ctlz,
+        known::cttz,
+        known::bswap,
+        known::bitreverse,
+        known::discriminant_value,
+        known::type_id,
+        known::likely,
+        known::unlikely,
+        known::ptr_guaranteed_eq,
+        known::ptr_guaranteed_ne,
+        known::minnumf32,
+        known::minnumf64,
+        known::maxnumf32,
+        known::rustc_peek,
+        known::maxnumf64,
+        known::type_name,
+        known::variant_count,
+    ]
+    .contains(&name)
+}
diff --git a/crates/hir_def/src/nameres.rs b/crates/hir_def/src/nameres.rs
index 01a28aeeb..eb41d324e 100644
--- a/crates/hir_def/src/nameres.rs
+++ b/crates/hir_def/src/nameres.rs
@@ -283,6 +283,7 @@ pub enum ModuleSource {
 }
 mod diagnostics {
+    use cfg::{CfgExpr, CfgOptions};
    use hir_expand::diagnostics::DiagnosticSink;
    use hir_expand::hygiene::Hygiene;
    use hir_expand::InFile;
@@ -299,7 +300,7 @@ mod diagnostics {
        UnresolvedImport { ast: AstId<ast::Use>, index: usize },
-        UnconfiguredCode { ast: InFile<SyntaxNodePtr> },
+        UnconfiguredCode { ast: InFile<SyntaxNodePtr>, cfg: CfgExpr, opts: CfgOptions },
    }
    #[derive(Debug, PartialEq, Eq)]
@@ -341,8 +342,10 @@ mod diagnostics {
        pub(super) fn unconfigured_code(
            container: LocalModuleId,
            ast: InFile<SyntaxNodePtr>,
+            cfg: CfgExpr,
+            opts: CfgOptions,
        ) -> Self {
-            Self { in_module: container, kind: DiagnosticKind::UnconfiguredCode { ast } }
+            Self { in_module: container, kind: DiagnosticKind::UnconfiguredCode { ast, cfg, opts } }
        }
        pub(super) fn add_to(
@@ -395,8 +398,13 @@ mod diagnostics {
                    }
                }
-                DiagnosticKind::UnconfiguredCode { ast } => {
+                DiagnosticKind::UnconfiguredCode { ast, cfg, opts } => {
-                    sink.push(InactiveCode { file: ast.file_id, node: ast.value.clone() });
+                    sink.push(InactiveCode {
+                        file: ast.file_id,
+                        node: ast.value.clone(),
+                        cfg: cfg.clone(),
+                        opts: opts.clone(),
+                    });
                }
            }
        }
diff --git a/crates/hir_def/src/nameres/collector.rs b/crates/hir_def/src/nameres/collector.rs
index bff8edb62..f30172d90 100644
--- a/crates/hir_def/src/nameres/collector.rs
+++ b/crates/hir_def/src/nameres/collector.rs
@@ -6,7 +6,7 @@
 use std::iter;
 use base_db::{CrateId, FileId, ProcMacroId};
-use cfg::CfgOptions;
+use cfg::{CfgExpr, CfgOptions};
 use hir_expand::InFile;
 use hir_expand::{
    ast_id_map::FileAstId,
@@ -900,7 +900,8 @@ impl ModCollector<'_, '_> {
        // `#[macro_use] extern crate` is hoisted to imports macros before collecting
        // any other items.
        for item in items {
-            if self.is_cfg_enabled(self.item_tree.attrs((*item).into())) {
+            let attrs = self.item_tree.attrs((*item).into());
+            if attrs.cfg().map_or(true, |cfg| self.is_cfg_enabled(&cfg)) {
                if let ModItem::ExternCrate(id) = item {
                    let import = self.item_tree[*id].clone();
                    if import.is_macro_use {
@@ -912,9 +913,11 @@ impl ModCollector<'_, '_> {
        for &item in items {
            let attrs = self.item_tree.attrs(item.into());
-            if !self.is_cfg_enabled(attrs) {
+            if let Some(cfg) = attrs.cfg() {
-                self.emit_unconfigured_diagnostic(item);
+                if !self.is_cfg_enabled(&cfg) {
-                continue;
+                    self.emit_unconfigured_diagnostic(item, &cfg);
+                    continue;
+                }
            }
            let module =
                ModuleId { krate: self.def_collector.def_map.krate, local_id: self.module_id };
@@ -1321,20 +1324,22 @@ impl ModCollector<'_, '_> {
        }
    }
-    fn is_cfg_enabled(&self, attrs: &Attrs) -> bool {
+    fn is_cfg_enabled(&self, cfg: &CfgExpr) -> bool {
-        attrs.is_cfg_enabled(self.def_collector.cfg_options)
+        self.def_collector.cfg_options.check(cfg) != Some(false)
    }
-    fn emit_unconfigured_diagnostic(&mut self, item: ModItem) {
+    fn emit_unconfigured_diagnostic(&mut self, item: ModItem, cfg: &CfgExpr) {
        let ast_id = item.ast_id(self.item_tree);
        let id_map = self.def_collector.db.ast_id_map(self.file_id);
        let syntax_ptr = id_map.get(ast_id).syntax_node_ptr();
        let ast_node = InFile::new(self.file_id, syntax_ptr);
-        self.def_collector
+        self.def_collector.def_map.diagnostics.push(DefDiagnostic::unconfigured_code(
-            .def_map
+            self.module_id,
-            .diagnostics
+            ast_node,
-            .push(DefDiagnostic::unconfigured_code(self.module_id, ast_node));
+            cfg.clone(),
+            self.def_collector.cfg_options.clone(),
+        ));
    }
 }
diff --git a/crates/hir_def/src/nameres/tests/diagnostics.rs b/crates/hir_def/src/nameres/tests/diagnostics.rs
index 576b813d2..1a7b98831 100644
--- a/crates/hir_def/src/nameres/tests/diagnostics.rs
+++ b/crates/hir_def/src/nameres/tests/diagnostics.rs
@@ -1,42 +1,10 @@
 use base_db::fixture::WithFixture;
-use base_db::FileId;
-use base_db::SourceDatabaseExt;
-use hir_expand::db::AstDatabase;
-use rustc_hash::FxHashMap;
-use syntax::TextRange;
-use syntax::TextSize;
 use crate::test_db::TestDB;
 fn check_diagnostics(ra_fixture: &str) {
    let db: TestDB = TestDB::with_files(ra_fixture);
-    let annotations = db.extract_annotations();
+    db.check_diagnostics();
-    assert!(!annotations.is_empty());
-    let mut actual: FxHashMap<FileId, Vec<(TextRange, String)>> = FxHashMap::default();
-    db.diagnostics(|d| {
-        let src = d.display_source();
-        let root = db.parse_or_expand(src.file_id).unwrap();
-        // FIXME: macros...
-        let file_id = src.file_id.original_file(&db);
-        let range = src.value.to_node(&root).text_range();
-        let message = d.message().to_owned();
-        actual.entry(file_id).or_default().push((range, message));
-    });
-    for (file_id, diags) in actual.iter_mut() {
-        diags.sort_by_key(|it| it.0.start());
-        let text = db.file_text(*file_id);
-        // For multiline spans, place them on line start
-        for (range, content) in diags {
-            if text[*range].contains('\n') {
-                *range = TextRange::new(range.start(), range.start() + TextSize::from(1));
-                *content = format!("... {}", content);
-            }
-        }
-    }
-    assert_eq!(annotations, actual);
 }
 #[test]
@@ -129,3 +97,25 @@ fn unresolved_module() {
        ",
    );
 }
+#[test]
+fn inactive_item() {
+    // Additional tests in `cfg` crate. This only tests disabled cfgs.
+    check_diagnostics(
+        r#"
+        //- /lib.rs
+          #[cfg(no)] pub fn f() {}
+        //^^^^^^^^^^^^^^^^^^^^^^^^ code is inactive due to #[cfg] directives: no is disabled
+          #[cfg(no)] #[cfg(no2)] mod m;
+        //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ code is inactive due to #[cfg] directives: no and no2 are disabled
+          #[cfg(all(not(a), b))] enum E {}
+        //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ code is inactive due to #[cfg] directives: b is disabled
+          #[cfg(feature = "std")] use std;
+        //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ code is inactive due to #[cfg] directives: feature = "std" is disabled
+        "#,
+    );
+}
diff --git a/crates/hir_def/src/test_db.rs b/crates/hir_def/src/test_db.rs
index fb1d3c974..2b36c824a 100644
--- a/crates/hir_def/src/test_db.rs
+++ b/crates/hir_def/src/test_db.rs
@@ -12,10 +12,10 @@ use hir_expand::diagnostics::Diagnostic;
 use hir_expand::diagnostics::DiagnosticSinkBuilder;
 use rustc_hash::FxHashMap;
 use rustc_hash::FxHashSet;
-use syntax::TextRange;
+use syntax::{TextRange, TextSize};
 use test_utils::extract_annotations;
-use crate::db::DefDatabase;
+use crate::{db::DefDatabase, ModuleDefId};
 #[salsa::database(
    base_db::SourceDatabaseExtStorage,
@@ -135,9 +135,47 @@ impl TestDB {
            let crate_def_map = self.crate_def_map(krate);
            let mut sink = DiagnosticSinkBuilder::new().build(&mut cb);
-            for (module_id, _) in crate_def_map.modules.iter() {
+            for (module_id, module) in crate_def_map.modules.iter() {
                crate_def_map.add_diagnostics(self, module_id, &mut sink);
+                for decl in module.scope.declarations() {
+                    if let ModuleDefId::FunctionId(it) = decl {
+                        let source_map = self.body_with_source_map(it.into()).1;
+                        source_map.add_diagnostics(self, &mut sink);
+                    }
+                }
            }
        }
    }
+    pub fn check_diagnostics(&self) {
+        let db: &TestDB = self;
+        let annotations = db.extract_annotations();
+        assert!(!annotations.is_empty());
+        let mut actual: FxHashMap<FileId, Vec<(TextRange, String)>> = FxHashMap::default();
+        db.diagnostics(|d| {
+            let src = d.display_source();
+            let root = db.parse_or_expand(src.file_id).unwrap();
+            // FIXME: macros...
+            let file_id = src.file_id.original_file(db);
+            let range = src.value.to_node(&root).text_range();
+            let message = d.message().to_owned();
+            actual.entry(file_id).or_default().push((range, message));
+        });
+        for (file_id, diags) in actual.iter_mut() {
+            diags.sort_by_key(|it| it.0.start());
+            let text = db.file_text(*file_id);
+            // For multiline spans, place them on line start
+            for (range, content) in diags {
+                if text[*range].contains('\n') {
+                    *range = TextRange::new(range.start(), range.start() + TextSize::from(1));
+                    *content = format!("... {}", content);
+                }
+            }
+        }
+        assert_eq!(annotations, actual);
+    }
 }
diff --git a/crates/hir_expand/src/name.rs b/crates/hir_expand/src/name.rs
index 63f828707..b26ffa1ef 100644
--- a/crates/hir_expand/src/name.rs
+++ b/crates/hir_expand/src/name.rs
@@ -208,6 +208,42 @@ pub mod known {
        PartialOrd,
        Eq,
        PartialEq,
+        // Safe intrinsics
+        abort,
+        size_of,
+        min_align_of,
+        needs_drop,
+        caller_location,
+        size_of_val,
+        min_align_of_val,
+        add_with_overflow,
+        sub_with_overflow,
+        mul_with_overflow,
+        wrapping_add,
+        wrapping_sub,
+        wrapping_mul,
+        saturating_add,
+        saturating_sub,
+        rotate_left,
+        rotate_right,
+        ctpop,
+        ctlz,
+        cttz,
+        bswap,
+        bitreverse,
+        discriminant_value,
+        type_id,
+        likely,
+        unlikely,
+        ptr_guaranteed_eq,
+        ptr_guaranteed_ne,
+        minnumf32,
+        minnumf64,
+        maxnumf32,
+        rustc_peek,
+        maxnumf64,
+        type_name,
+        variant_count,
    );
    // self/Self cannot be used as an identifier
diff --git a/crates/hir_ty/src/diagnostics/decl_check.rs b/crates/hir_ty/src/diagnostics/decl_check.rs
index f987636fe..f179c62b7 100644
--- a/crates/hir_ty/src/diagnostics/decl_check.rs
+++ b/crates/hir_ty/src/diagnostics/decl_check.rs
@@ -708,11 +708,23 @@ fn foo() {
    }
    #[test]
-    fn incorrect_struct_name() {
+    fn incorrect_struct_names() {
        check_diagnostics(
            r#"
 struct non_camel_case_name {}
    // ^^^^^^^^^^^^^^^^^^^ Structure `non_camel_case_name` should have CamelCase name, e.g. `NonCamelCaseName`
+struct SCREAMING_CASE {}
+    // ^^^^^^^^^^^^^^ Structure `SCREAMING_CASE` should have CamelCase name, e.g. `ScreamingCase`
+"#,
+        );
+    }
+    #[test]
+    fn no_diagnostic_for_camel_cased_acronyms_in_struct_name() {
+        check_diagnostics(
+            r#"
+struct AABB {}
 "#,
        );
    }
@@ -728,11 +740,23 @@ struct SomeStruct { SomeField: u8 }
    }
    #[test]
-    fn incorrect_enum_name() {
+    fn incorrect_enum_names() {
        check_diagnostics(
            r#"
 enum some_enum { Val(u8) }
  // ^^^^^^^^^ Enum `some_enum` should have CamelCase name, e.g. `SomeEnum`
+enum SOME_ENUM
+  // ^^^^^^^^^ Enum `SOME_ENUM` should have CamelCase name, e.g. `SomeEnum`
+"#,
+        );
+    }
+    #[test]
+    fn no_diagnostic_for_camel_cased_acronyms_in_enum_name() {
+        check_diagnostics(
+            r#"
+enum AABB {}
 "#,
        );
    }
diff --git a/crates/hir_ty/src/diagnostics/decl_check/case_conv.rs b/crates/hir_ty/src/diagnostics/decl_check/case_conv.rs
index 3800f2a6b..324d60765 100644
--- a/crates/hir_ty/src/diagnostics/decl_check/case_conv.rs
+++ b/crates/hir_ty/src/diagnostics/decl_check/case_conv.rs
@@ -29,7 +29,13 @@ fn detect_case(ident: &str) -> DetectedCase {
    if has_uppercase {
        if !has_lowercase {
-            DetectedCase::UpperSnakeCase
+            if has_underscore {
+                DetectedCase::UpperSnakeCase
+            } else {
+                // It has uppercase only and no underscores. Ex: "AABB"
+                // This is a camel cased acronym.
+                DetectedCase::UpperCamelCase
+            }
        } else if !has_underscore {
            if first_lowercase {
                DetectedCase::LowerCamelCase
@@ -180,6 +186,7 @@ mod tests {
        check(to_camel_case, "Weird_Case", expect![["WeirdCase"]]);
        check(to_camel_case, "name", expect![["Name"]]);
        check(to_camel_case, "A", expect![[""]]);
+        check(to_camel_case, "AABB", expect![[""]]);
    }
    #[test]
diff --git a/crates/hir_ty/src/diagnostics/unsafe_check.rs b/crates/hir_ty/src/diagnostics/unsafe_check.rs
index 21a121aad..2da9688ca 100644
--- a/crates/hir_ty/src/diagnostics/unsafe_check.rs
+++ b/crates/hir_ty/src/diagnostics/unsafe_check.rs
@@ -202,4 +202,22 @@ fn main() {
 "#,
        );
    }
+    #[test]
+    fn no_missing_unsafe_diagnostic_with_safe_intrinsic() {
+        check_diagnostics(
+            r#"
+extern "rust-intrinsic" {
+    pub fn bitreverse(x: u32) -> u32; // Safe intrinsic
+    pub fn floorf32(x: f32) -> f32; // Unsafe intrinsic
+}
+fn main() {
+    let _ = bitreverse(12);
+    let _ = floorf32(12.0);
+          //^^^^^^^^^^^^^^ This operation is unsafe and requires an unsafe function or block
+}
+"#,
+        );
+    }
 }
diff --git a/crates/hir_ty/src/traits.rs b/crates/hir_ty/src/traits.rs
index 14cd3a2b4..ce1174cbe 100644
--- a/crates/hir_ty/src/traits.rs
+++ b/crates/hir_ty/src/traits.rs
@@ -5,6 +5,7 @@ use base_db::CrateId;
 use chalk_ir::cast::Cast;
 use chalk_solve::{logging_db::LoggingRustIrDatabase, Solver};
 use hir_def::{lang_item::LangItemTarget, TraitId};
+use stdx::panic_context;
 use crate::{db::HirDatabase, DebruijnIndex, Substs};
@@ -168,14 +169,23 @@ fn solve(
    };
    let mut solve = || {
-        if is_chalk_print() {
+        let _ctx = if is_chalk_debug() || is_chalk_print() {
-            let logging_db = LoggingRustIrDatabase::new(context);
+            Some(panic_context::enter(format!("solving {:?}", goal)))
-            let solution = solver.solve_limited(&logging_db, goal, &should_continue);
+        } else {
-            log::debug!("chalk program:\n{}", logging_db);
+            None
+        };
+        let solution = if is_chalk_print() {
+            let logging_db =
+                LoggingRustIrDatabaseLoggingOnDrop(LoggingRustIrDatabase::new(context));
+            let solution = solver.solve_limited(&logging_db.0, goal, &should_continue);
            solution
        } else {
            solver.solve_limited(&context, goal, &should_continue)
-        }
+        };
+        log::debug!("solve({:?}) => {:?}", goal, solution);
+        solution
    };
    // don't set the TLS for Chalk unless Chalk debugging is active, to make
@@ -183,11 +193,17 @@ fn solve(
    let solution =
        if is_chalk_debug() { chalk::tls::set_current_program(db, solve) } else { solve() };
-    log::debug!("solve({:?}) => {:?}", goal, solution);
    solution
 }
+struct LoggingRustIrDatabaseLoggingOnDrop<'a>(LoggingRustIrDatabase<Interner, ChalkContext<'a>>);
+impl<'a> Drop for LoggingRustIrDatabaseLoggingOnDrop<'a> {
+    fn drop(&mut self) {
+        eprintln!("chalk program:\n{}", self.0);
+    }
+}
 fn is_chalk_debug() -> bool {
    std::env::var("CHALK_DEBUG").is_ok()
 }
diff --git a/crates/ide/src/doc_links.rs b/crates/ide/src/doc_links.rs
index b9d8b8a2b..250f10f9f 100644
--- a/crates/ide/src/doc_links.rs
+++ b/crates/ide/src/doc_links.rs
@@ -132,7 +132,8 @@ fn get_doc_link(db: &RootDatabase, definition: Definition) -> Option<String> {
    let import_map = db.import_map(krate.into());
    let base = once(krate.display_name(db)?.to_string())
        .chain(import_map.path_of(ns)?.segments.iter().map(|name| name.to_string()))
-        .join("/");
+        .join("/")
+        + "/";
    let filename = get_symbol_filename(db, &target_def);
    let fragment = match definition {
@@ -152,9 +153,16 @@ fn get_doc_link(db: &RootDatabase, definition: Definition) -> Option<String> {
        _ => None,
    };
-    get_doc_url(db, &krate)
+    get_doc_url(db, &krate)?
-        .and_then(|url| url.join(&base).ok())
+        .join(&base)
-        .and_then(|url| filename.as_deref().and_then(|f| url.join(f).ok()))
+        .ok()
+        .and_then(|mut url| {
+            if !matches!(definition, Definition::ModuleDef(ModuleDef::Module(..))) {
+                url.path_segments_mut().ok()?.pop();
+            };
+            Some(url)
+        })
+        .and_then(|url| url.join(filename.as_deref()?).ok())
        .and_then(
            |url| if let Some(fragment) = fragment { url.join(&fragment).ok() } else { Some(url) },
        )
@@ -522,6 +530,18 @@ pub struct Foo {
        );
    }
+    #[test]
+    fn test_module() {
+        check(
+            r#"
+pub mod foo {
+    pub mod ba<|>r {}
+}
+        "#,
+            expect![[r#"https://docs.rs/test/*/test/foo/bar/index.html"#]],
+        )
+    }
    // FIXME: ImportMap will return re-export paths instead of public module
    // paths. The correct path to documentation will never be a re-export.
    // This problem stops us from resolving stdlib items included in the prelude
diff --git a/crates/ide/src/hover.rs b/crates/ide/src/hover.rs
index 6466422c5..0332c7be0 100644
--- a/crates/ide/src/hover.rs
+++ b/crates/ide/src/hover.rs
@@ -2128,7 +2128,7 @@ fn foo_<|>test() {}
                                    ignore: false,
                                },
                            },
-                            cfg_exprs: [],
+                            cfg: None,
                        },
                    ),
                ]
@@ -2166,7 +2166,7 @@ mod tests<|> {
                            kind: TestMod {
                                path: "tests",
                            },
-                            cfg_exprs: [],
+                            cfg: None,
                        },
                    ),
                ]
diff --git a/crates/ide/src/inlay_hints.rs b/crates/ide/src/inlay_hints.rs
index cccea129a..49d8e4ae1 100644
--- a/crates/ide/src/inlay_hints.rs
+++ b/crates/ide/src/inlay_hints.rs
@@ -378,7 +378,11 @@ fn is_enum_name_similar_to_param_name(
 fn get_string_representation(expr: &ast::Expr) -> Option<String> {
    match expr {
        ast::Expr::MethodCallExpr(method_call_expr) => {
-            Some(method_call_expr.name_ref()?.to_string())
+            let name_ref = method_call_expr.name_ref()?;
+            match name_ref.text().as_str() {
+                "clone" => method_call_expr.receiver().map(|rec| rec.to_string()),
+                name_ref => Some(name_ref.to_owned()),
+            }
        }
        ast::Expr::RefExpr(ref_expr) => get_string_representation(&ref_expr.expr()?),
        _ => Some(expr.to_string()),
@@ -1208,4 +1212,27 @@ fn main() {
 "#,
        );
    }
+    #[test]
+    fn hide_param_hints_for_clones() {
+        check_with_config(
+            InlayHintsConfig {
+                parameter_hints: true,
+                type_hints: false,
+                chaining_hints: false,
+                max_length: None,
+            },
+            r#"
+fn foo(bar: i32, baz: String, qux: f32) {}
+fn main() {
+    let bar = 3;
+    let baz = &"baz";
+    let fez = 1.0;
+    foo(bar.clone(), baz.clone(), fez.clone());
+                                //^^^^^^^^^^^ qux
+}
+"#,
+        );
+    }
 }
diff --git a/crates/ide/src/runnables.rs b/crates/ide/src/runnables.rs
index 752ef2f21..eb82456ad 100644
--- a/crates/ide/src/runnables.rs
+++ b/crates/ide/src/runnables.rs
@@ -15,7 +15,7 @@ use crate::{display::ToNav, FileId, NavigationTarget};
 pub struct Runnable {
    pub nav: NavigationTarget,
    pub kind: RunnableKind,
-    pub cfg_exprs: Vec<CfgExpr>,
+    pub cfg: Option<CfgExpr>,
 }
 #[derive(Debug, Clone)]
@@ -168,7 +168,7 @@ fn runnable_fn(
    };
    let attrs = Attrs::from_attrs_owner(sema.db, InFile::new(HirFileId::from(file_id), &fn_def));
-    let cfg_exprs = attrs.cfg().collect();
+    let cfg = attrs.cfg();
    let nav = if let RunnableKind::DocTest { .. } = kind {
        NavigationTarget::from_doc_commented(
@@ -179,7 +179,7 @@ fn runnable_fn(
    } else {
        NavigationTarget::from_named(sema.db, InFile::new(file_id.into(), &fn_def))
    };
-    Some(Runnable { nav, kind, cfg_exprs })
+    Some(Runnable { nav, kind, cfg })
 }
 #[derive(Debug, Copy, Clone)]
@@ -255,9 +255,9 @@ fn runnable_mod(
        .join("::");
    let attrs = Attrs::from_attrs_owner(sema.db, InFile::new(HirFileId::from(file_id), &module));
-    let cfg_exprs = attrs.cfg().collect();
+    let cfg = attrs.cfg();
    let nav = module_def.to_nav(sema.db);
-    Some(Runnable { nav, kind: RunnableKind::TestMod { path }, cfg_exprs })
+    Some(Runnable { nav, kind: RunnableKind::TestMod { path }, cfg })
 }
 // We could create runnables for modules with number_of_test_submodules > 0,
@@ -348,7 +348,7 @@ fn bench() {}
                            docs: None,
                        },
                        kind: Bin,
-                        cfg_exprs: [],
+                        cfg: None,
                    },
                    Runnable {
                        nav: NavigationTarget {
@@ -373,7 +373,7 @@ fn bench() {}
                                ignore: false,
                            },
                        },
-                        cfg_exprs: [],
+                        cfg: None,
                    },
                    Runnable {
                        nav: NavigationTarget {
@@ -398,7 +398,7 @@ fn bench() {}
                                ignore: true,
                            },
                        },
-                        cfg_exprs: [],
+                        cfg: None,
                    },
                    Runnable {
                        nav: NavigationTarget {
@@ -420,7 +420,7 @@ fn bench() {}
                                "bench",
                            ),
                        },
-                        cfg_exprs: [],
+                        cfg: None,
                    },
                ]
            "#]],
@@ -507,7 +507,7 @@ fn should_have_no_runnable_6() {}
                            docs: None,
                        },
                        kind: Bin,
-                        cfg_exprs: [],
+                        cfg: None,
                    },
                    Runnable {
                        nav: NavigationTarget {
@@ -527,7 +527,7 @@ fn should_have_no_runnable_6() {}
                                "should_have_runnable",
                            ),
                        },
-                        cfg_exprs: [],
+                        cfg: None,
                    },
                    Runnable {
                        nav: NavigationTarget {
@@ -547,7 +547,7 @@ fn should_have_no_runnable_6() {}
                                "should_have_runnable_1",
                            ),
                        },
-                        cfg_exprs: [],
+                        cfg: None,
                    },
                    Runnable {
                        nav: NavigationTarget {
@@ -567,7 +567,7 @@ fn should_have_no_runnable_6() {}
                                "should_have_runnable_2",
                            ),
                        },
-                        cfg_exprs: [],
+                        cfg: None,
                    },
                ]
            "#]],
@@ -609,7 +609,7 @@ impl Data {
                            docs: None,
                        },
                        kind: Bin,
-                        cfg_exprs: [],
+                        cfg: None,
                    },
                    Runnable {
                        nav: NavigationTarget {
@@ -629,7 +629,7 @@ impl Data {
                                "Data::foo",
                            ),
                        },
-                        cfg_exprs: [],
+                        cfg: None,
                    },
                ]
            "#]],
@@ -668,7 +668,7 @@ mod test_mod {
                        kind: TestMod {
                            path: "test_mod",
                        },
-                        cfg_exprs: [],
+                        cfg: None,
                    },
                    Runnable {
                        nav: NavigationTarget {
@@ -693,7 +693,7 @@ mod test_mod {
                                ignore: false,
                            },
                        },
-                        cfg_exprs: [],
+                        cfg: None,
                    },
                ]
            "#]],
@@ -748,7 +748,7 @@ mod root_tests {
                        kind: TestMod {
                            path: "root_tests::nested_tests_0",
                        },
-                        cfg_exprs: [],
+                        cfg: None,
                    },
                    Runnable {
                        nav: NavigationTarget {
@@ -768,7 +768,7 @@ mod root_tests {
                        kind: TestMod {
                            path: "root_tests::nested_tests_0::nested_tests_1",
                        },
-                        cfg_exprs: [],
+                        cfg: None,
                    },
                    Runnable {
                        nav: NavigationTarget {
@@ -793,7 +793,7 @@ mod root_tests {
                                ignore: false,
                            },
                        },
-                        cfg_exprs: [],
+                        cfg: None,
                    },
                    Runnable {
                        nav: NavigationTarget {
@@ -818,7 +818,7 @@ mod root_tests {
                                ignore: false,
                            },
                        },
-                        cfg_exprs: [],
+                        cfg: None,
                    },
                    Runnable {
                        nav: NavigationTarget {
@@ -838,7 +838,7 @@ mod root_tests {
                        kind: TestMod {
                            path: "root_tests::nested_tests_0::nested_tests_2",
                        },
-                        cfg_exprs: [],
+                        cfg: None,
                    },
                    Runnable {
                        nav: NavigationTarget {
@@ -863,7 +863,7 @@ mod root_tests {
                                ignore: false,
                            },
                        },
-                        cfg_exprs: [],
+                        cfg: None,
                    },
                ]
            "#]],
@@ -906,12 +906,14 @@ fn test_foo1() {}
                                ignore: false,
                            },
                        },
-                        cfg_exprs: [
+                        cfg: Some(
-                            KeyValue {
+                            Atom(
-                                key: "feature",
+                                KeyValue {
-                                value: "foo",
+                                    key: "feature",
-                            },
+                                    value: "foo",
-                        ],
+                                },
+                            ),
+                        ),
                    },
                ]
            "#]],
@@ -954,20 +956,24 @@ fn test_foo1() {}
                                ignore: false,
                            },
                        },
-                        cfg_exprs: [
+                        cfg: Some(
                            All(
                                [
-                                    KeyValue {
+                                    Atom(
-                                        key: "feature",
+                                        KeyValue {
-                                        value: "foo",
+                                            key: "feature",
-                                    },
+                                            value: "foo",
-                                    KeyValue {
+                                        },
-                                        key: "feature",
+                                    ),
-                                        value: "bar",
+                                    Atom(
-                                    },
+                                        KeyValue {
+                                            key: "feature",
+                                            value: "bar",
+                                        },
+                                    ),
                                ],
                            ),
-                        ],
+                        ),
                    },
                ]
            "#]],
diff --git a/crates/ide/src/syntax_highlighting.rs b/crates/ide/src/syntax_highlighting.rs
index b35c03162..750848467 100644
--- a/crates/ide/src/syntax_highlighting.rs
+++ b/crates/ide/src/syntax_highlighting.rs
@@ -763,6 +763,9 @@ fn highlight_def(db: &RootDatabase, def: Definition) -> Highlight {
            if local.is_mut(db) || local.ty(db).is_mutable_reference() {
                h |= HighlightModifier::Mutable;
            }
+            if local.ty(db).as_callable(db).is_some() || local.ty(db).impls_fnonce(db) {
+                h |= HighlightModifier::Callable;
+            }
            return h;
        }
    }
diff --git a/crates/ide/src/syntax_highlighting/tags.rs b/crates/ide/src/syntax_highlighting/tags.rs
index c1b817f06..e8f78ad52 100644
--- a/crates/ide/src/syntax_highlighting/tags.rs
+++ b/crates/ide/src/syntax_highlighting/tags.rs
@@ -64,6 +64,7 @@ pub enum HighlightModifier {
    Mutable,
    Consuming,
    Unsafe,
+    Callable,
 }
 impl HighlightTag {
@@ -122,6 +123,7 @@ impl HighlightModifier {
        HighlightModifier::Mutable,
        HighlightModifier::Consuming,
        HighlightModifier::Unsafe,
+        HighlightModifier::Callable,
    ];
    fn as_str(self) -> &'static str {
@@ -134,6 +136,7 @@ impl HighlightModifier {
            HighlightModifier::Mutable => "mutable",
            HighlightModifier::Consuming => "consuming",
            HighlightModifier::Unsafe => "unsafe",
+            HighlightModifier::Callable => "callable",
        }
    }
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlighting.html b/crates/ide/src/syntax_highlighting/test_data/highlighting.html
index 0bb0928e4..0cb84866d 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlighting.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlighting.html
@@ -44,6 +44,17 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
    <span class="keyword">pub</span> <span class="keyword">trait</span> <span class="trait declaration">Copy</span> <span class="punctuation">{</span><span class="punctuation">}</span>
 <span class="punctuation">}</span>
+<span class="keyword">pub</span> <span class="keyword">mod</span> <span class="module declaration">ops</span> <span class="punctuation">{</span>
+    <span class="attribute">#</span><span class="attribute">[</span><span class="function attribute">lang</span><span class="attribute"> </span><span class="operator">=</span><span class="attribute"> </span><span class="string_literal">"fn_once"</span><span class="attribute">]</span>
+    <span class="keyword">pub</span> <span class="keyword">trait</span> <span class="trait declaration">FnOnce</span><span class="punctuation">&lt;</span><span class="type_param declaration">Args</span><span class="punctuation">&gt;</span> <span class="punctuation">{</span><span class="punctuation">}</span>
+    <span class="attribute">#</span><span class="attribute">[</span><span class="function attribute">lang</span><span class="attribute"> </span><span class="operator">=</span><span class="attribute"> </span><span class="string_literal">"fn_mut"</span><span class="attribute">]</span>
+    <span class="keyword">pub</span> <span class="keyword">trait</span> <span class="trait declaration">FnMut</span><span class="punctuation">&lt;</span><span class="type_param declaration">Args</span><span class="punctuation">&gt;</span><span class="punctuation">:</span> <span class="trait">FnOnce</span><span class="punctuation">&lt;</span><span class="type_param">Args</span><span class="punctuation">&gt;</span> <span class="punctuation">{</span><span class="punctuation">}</span>
+    <span class="attribute">#</span><span class="attribute">[</span><span class="function attribute">lang</span><span class="attribute"> </span><span class="operator">=</span><span class="attribute"> </span><span class="string_literal">"fn"</span><span class="attribute">]</span>
+    <span class="keyword">pub</span> <span class="keyword">trait</span> <span class="trait declaration">Fn</span><span class="punctuation">&lt;</span><span class="type_param declaration">Args</span><span class="punctuation">&gt;</span><span class="punctuation">:</span> <span class="trait">FnMut</span><span class="punctuation">&lt;</span><span class="type_param">Args</span><span class="punctuation">&gt;</span> <span class="punctuation">{</span><span class="punctuation">}</span>
+<span class="punctuation">}</span>
 <span class="keyword">struct</span> <span class="struct declaration">Foo</span> <span class="punctuation">{</span>
    <span class="keyword">pub</span> <span class="field declaration">x</span><span class="punctuation">:</span> <span class="builtin_type">i32</span><span class="punctuation">,</span>
@@ -99,6 +110,11 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
    <span class="function">foo</span><span class="operator">::</span><span class="punctuation">&lt;</span><span class="lifetime">'a</span><span class="punctuation">,</span> <span class="builtin_type">i32</span><span class="punctuation">&gt;</span><span class="punctuation">(</span><span class="punctuation">)</span>
 <span class="punctuation">}</span>
+<span class="keyword">use</span> <span class="module">ops</span><span class="operator">::</span><span class="trait">Fn</span><span class="punctuation">;</span>
+<span class="keyword">fn</span> <span class="function declaration">baz</span><span class="punctuation">&lt;</span><span class="type_param declaration">F</span><span class="punctuation">:</span> <span class="trait">Fn</span><span class="punctuation">(</span><span class="punctuation">)</span> <span class="operator">-&gt;</span> <span class="punctuation">(</span><span class="punctuation">)</span><span class="punctuation">&gt;</span><span class="punctuation">(</span><span class="value_param declaration callable">f</span><span class="punctuation">:</span> <span class="type_param">F</span><span class="punctuation">)</span> <span class="punctuation">{</span>
+    <span class="value_param callable">f</span><span class="punctuation">(</span><span class="punctuation">)</span>
+<span class="punctuation">}</span>
 <span class="macro">macro_rules!</span> <span class="macro declaration">def_fn</span> <span class="punctuation">{</span>
    <span class="punctuation">(</span><span class="punctuation">$</span><span class="punctuation">(</span><span class="punctuation">$</span>tt<span class="punctuation">:</span>tt<span class="punctuation">)</span><span class="punctuation">*</span><span class="punctuation">)</span> <span class="operator">=</span><span class="punctuation">&gt;</span> <span class="punctuation">{</span><span class="punctuation">$</span><span class="punctuation">(</span><span class="punctuation">$</span>tt<span class="punctuation">)</span><span class="punctuation">*</span><span class="punctuation">}</span>
 <span class="punctuation">}</span>
@@ -157,6 +173,9 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
    <span class="variable mutable">copy</span><span class="punctuation">.</span><span class="function">quop</span><span class="punctuation">(</span><span class="punctuation">)</span><span class="punctuation">;</span>
    <span class="variable mutable">copy</span><span class="punctuation">.</span><span class="function mutable">qux</span><span class="punctuation">(</span><span class="punctuation">)</span><span class="punctuation">;</span>
    <span class="variable mutable">copy</span><span class="punctuation">.</span><span class="function">baz</span><span class="punctuation">(</span><span class="variable mutable">copy</span><span class="punctuation">)</span><span class="punctuation">;</span>
+    <span class="keyword">let</span> <span class="variable declaration callable">a</span> <span class="operator">=</span> <span class="punctuation">|</span><span class="value_param declaration">x</span><span class="punctuation">|</span> <span class="value_param">x</span><span class="punctuation">;</span>
+    <span class="keyword">let</span> <span class="variable declaration callable">bar</span> <span class="operator">=</span> <span class="struct">Foo</span><span class="operator">::</span><span class="function">baz</span><span class="punctuation">;</span>
 <span class="punctuation">}</span>
 <span class="keyword">enum</span> <span class="enum declaration">Option</span><span class="punctuation">&lt;</span><span class="type_param declaration">T</span><span class="punctuation">&gt;</span> <span class="punctuation">{</span>
diff --git a/crates/ide/src/syntax_highlighting/tests.rs b/crates/ide/src/syntax_highlighting/tests.rs
index 126363b8b..da20c300e 100644
--- a/crates/ide/src/syntax_highlighting/tests.rs
+++ b/crates/ide/src/syntax_highlighting/tests.rs
@@ -18,6 +18,17 @@ pub mod marker {
    pub trait Copy {}
 }
+pub mod ops {
+    #[lang = "fn_once"]
+    pub trait FnOnce<Args> {}
+    #[lang = "fn_mut"]
+    pub trait FnMut<Args>: FnOnce<Args> {}
+    #[lang = "fn"]
+    pub trait Fn<Args>: FnMut<Args> {}
+}
 struct Foo {
    pub x: i32,
@@ -73,6 +84,11 @@ fn foo<'a, T>() -> T {
    foo::<'a, i32>()
 }
+use ops::Fn;
+fn baz<F: Fn() -> ()>(f: F) {
+    f()
+}
 macro_rules! def_fn {
    ($($tt:tt)*) => {$($tt)*}
 }
@@ -131,6 +147,9 @@ fn main() {
    copy.quop();
    copy.qux();
    copy.baz(copy);
+    let a = |x| x;
+    let bar = Foo::baz;
 }
 enum Option<T> {
diff --git a/crates/rust-analyzer/src/cargo_target_spec.rs b/crates/rust-analyzer/src/cargo_target_spec.rs
index ddc028148..1ab72bd91 100644
--- a/crates/rust-analyzer/src/cargo_target_spec.rs
+++ b/crates/rust-analyzer/src/cargo_target_spec.rs
@@ -1,6 +1,6 @@
 //! See `CargoTargetSpec`
-use cfg::CfgExpr;
+use cfg::{CfgAtom, CfgExpr};
 use ide::{FileId, RunnableKind, TestId};
 use project_model::{self, TargetKind};
 use vfs::AbsPathBuf;
@@ -24,7 +24,7 @@ impl CargoTargetSpec {
        snap: &GlobalStateSnapshot,
        spec: Option<CargoTargetSpec>,
        kind: &RunnableKind,
-        cfgs: &[CfgExpr],
+        cfg: &Option<CfgExpr>,
    ) -> Result<(Vec<String>, Vec<String>)> {
        let mut args = Vec::new();
        let mut extra_args = Vec::new();
@@ -87,7 +87,7 @@ impl CargoTargetSpec {
            args.push("--all-features".to_string());
        } else {
            let mut features = Vec::new();
-            for cfg in cfgs {
+            if let Some(cfg) = cfg.as_ref() {
                required_features(cfg, &mut features);
            }
            for feature in &snap.config.cargo.features {
@@ -160,7 +160,9 @@ impl CargoTargetSpec {
 /// Fill minimal features needed
 fn required_features(cfg_expr: &CfgExpr, features: &mut Vec<String>) {
    match cfg_expr {
-        CfgExpr::KeyValue { key, value } if key == "feature" => features.push(value.to_string()),
+        CfgExpr::Atom(CfgAtom::KeyValue { key, value }) if key == "feature" => {
+            features.push(value.to_string())
+        }
        CfgExpr::All(preds) => {
            preds.iter().for_each(|cfg| required_features(cfg, features));
        }
diff --git a/crates/rust-analyzer/src/dispatch.rs b/crates/rust-analyzer/src/dispatch.rs
index 9c8815e29..7a87515e9 100644
--- a/crates/rust-analyzer/src/dispatch.rs
+++ b/crates/rust-analyzer/src/dispatch.rs
@@ -34,7 +34,7 @@ impl<'a> RequestDispatcher<'a> {
        };
        let world = panic::AssertUnwindSafe(&mut *self.global_state);
        let response = panic::catch_unwind(move || {
-            stdx::panic_context::enter(format!("request: {} {:#?}", R::METHOD, params));
+            let _pctx = stdx::panic_context::enter(format!("request: {} {:#?}", R::METHOD, params));
            let result = f(world.0, params);
            result_to_response::<R>(id, result)
        })
@@ -64,7 +64,7 @@ impl<'a> RequestDispatcher<'a> {
            let world = self.global_state.snapshot();
            move || {
-                let _ctx =
+                let _pctx =
                    stdx::panic_context::enter(format!("request: {} {:#?}", R::METHOD, params));
                let result = f(world, params);
                Task::Response(result_to_response::<R>(id, result))
@@ -160,7 +160,7 @@ impl<'a> NotificationDispatcher<'a> {
                return Ok(self);
            }
        };
-        stdx::panic_context::enter(format!("notification: {}", N::METHOD));
+        let _pctx = stdx::panic_context::enter(format!("notification: {}", N::METHOD));
        f(self.global_state, params)?;
        Ok(self)
    }
diff --git a/crates/rust-analyzer/src/handlers.rs b/crates/rust-analyzer/src/handlers.rs
index f2d57f986..2680e5f08 100644
--- a/crates/rust-analyzer/src/handlers.rs
+++ b/crates/rust-analyzer/src/handlers.rs
@@ -570,7 +570,7 @@ pub(crate) fn handle_completion(
    let line_endings = snap.file_line_endings(position.file_id);
    let items: Vec<CompletionItem> = items
        .into_iter()
-        .map(|item| to_proto::completion_item(&line_index, line_endings, item))
+        .flat_map(|item| to_proto::completion_item(&line_index, line_endings, item))
        .collect();
    Ok(Some(items.into()))
diff --git a/crates/rust-analyzer/src/semantic_tokens.rs b/crates/rust-analyzer/src/semantic_tokens.rs
index a6c4d6099..7df28c9dd 100644
--- a/crates/rust-analyzer/src/semantic_tokens.rs
+++ b/crates/rust-analyzer/src/semantic_tokens.rs
@@ -77,6 +77,7 @@ define_semantic_token_modifiers![
    (CONSUMING, "consuming"),
    (UNSAFE, "unsafe"),
    (ATTRIBUTE_MODIFIER, "attribute"),
+    (CALLABLE, "callable"),
 ];
 #[derive(Default)]
diff --git a/crates/rust-analyzer/src/to_proto.rs b/crates/rust-analyzer/src/to_proto.rs
index aeacde0f7..0d34970bc 100644
--- a/crates/rust-analyzer/src/to_proto.rs
+++ b/crates/rust-analyzer/src/to_proto.rs
@@ -160,7 +160,13 @@ pub(crate) fn completion_item(
    line_index: &LineIndex,
    line_endings: LineEndings,
    completion_item: CompletionItem,
-) -> lsp_types::CompletionItem {
+) -> Vec<lsp_types::CompletionItem> {
+    fn set_score(res: &mut lsp_types::CompletionItem, label: &str) {
+        res.preselect = Some(true);
+        // HACK: sort preselect items first
+        res.sort_text = Some(format!(" {}", label));
+    }
    let mut additional_text_edits = Vec::new();
    let mut text_edit = None;
    // LSP does not allow arbitrary edits in completion, so we have to do a
@@ -200,9 +206,7 @@ pub(crate) fn completion_item(
    };
    if completion_item.score().is_some() {
-        res.preselect = Some(true);
+        set_score(&mut res, completion_item.label());
-        // HACK: sort preselect items first
-        res.sort_text = Some(format!(" {}", completion_item.label()));
    }
    if completion_item.deprecated() {
@@ -217,9 +221,22 @@ pub(crate) fn completion_item(
        });
    }
-    res.insert_text_format = Some(insert_text_format(completion_item.insert_text_format()));
+    let mut all_results = match completion_item.ref_match() {
+        Some(ref_match) => {
+            let mut refed = res.clone();
+            let (mutability, _score) = ref_match;
+            let label = format!("&{}{}", mutability.as_keyword_for_ref(), refed.label);
+            set_score(&mut refed, &label);
+            refed.label = label;
+            vec![res, refed]
+        }
+        None => vec![res],
+    };
-    res
+    for mut r in all_results.iter_mut() {
+        r.insert_text_format = Some(insert_text_format(completion_item.insert_text_format()));
+    }
+    all_results
 }
 pub(crate) fn signature_help(
@@ -408,6 +425,7 @@ fn semantic_token_type_and_modifiers(
            HighlightModifier::Mutable => semantic_tokens::MUTABLE,
            HighlightModifier::Consuming => semantic_tokens::CONSUMING,
            HighlightModifier::Unsafe => semantic_tokens::UNSAFE,
+            HighlightModifier::Callable => semantic_tokens::CALLABLE,
        };
        mods |= modifier;
    }
@@ -745,7 +763,7 @@ pub(crate) fn runnable(
    let workspace_root = spec.as_ref().map(|it| it.workspace_root.clone());
    let target = spec.as_ref().map(|s| s.target.clone());
    let (cargo_args, executable_args) =
-        CargoTargetSpec::runnable_args(snap, spec, &runnable.kind, &runnable.cfg_exprs)?;
+        CargoTargetSpec::runnable_args(snap, spec, &runnable.kind, &runnable.cfg)?;
    let label = runnable.label(target);
    let location = location_link(snap, None, runnable.nav)?;
@@ -776,6 +794,48 @@ mod tests {
    use super::*;
    #[test]
+    fn test_completion_with_ref() {
+        let fixture = r#"
+        struct Foo;
+        fn foo(arg: &Foo) {}
+        fn main() {
+            let arg = Foo;
+            foo(<|>)
+        }"#;
+        let (offset, text) = test_utils::extract_offset(fixture);
+        let line_index = LineIndex::new(&text);
+        let (analysis, file_id) = Analysis::from_single_file(text);
+        let completions: Vec<(String, Option<String>)> = analysis
+            .completions(
+                &ide::CompletionConfig::default(),
+                base_db::FilePosition { file_id, offset },
+            )
+            .unwrap()
+            .unwrap()
+            .into_iter()
+            .filter(|c| c.label().ends_with("arg"))
+            .map(|c| completion_item(&line_index, LineEndings::Unix, c))
+            .flat_map(|comps| comps.into_iter().map(|c| (c.label, c.sort_text)))
+            .collect();
+        expect_test::expect![[r#"
+            [
+                (
+                    "arg",
+                    None,
+                ),
+                (
+                    "&arg",
+                    Some(
+                        " &arg",
+                    ),
+                ),
+            ]
+        "#]]
+        .assert_debug_eq(&completions);
+    }
+    #[test]
    fn conv_fold_line_folding_only_fixup() {
        let text = r#"mod a;
 mod b;
diff --git a/crates/stdx/src/panic_context.rs b/crates/stdx/src/panic_context.rs
index fd232e0cc..8d51e20d3 100644
--- a/crates/stdx/src/panic_context.rs
+++ b/crates/stdx/src/panic_context.rs
@@ -4,7 +4,7 @@
 use std::{cell::RefCell, panic, sync::Once};
-pub fn enter(context: String) -> impl Drop {
+pub fn enter(context: String) -> PanicContext {
    static ONCE: Once = Once::new();
    ONCE.call_once(PanicContext::init);
@@ -13,7 +13,7 @@ pub fn enter(context: String) -> impl Drop {
 }
 #[must_use]
-struct PanicContext {
+pub struct PanicContext {
    _priv: (),
 }