56 files changed, 2995 insertions, 2359 deletions
diff --git a/crates/hir/src/attrs.rs b/crates/hir/src/attrs.rs
index b9c695921..dab8da7bb 100644
--- a/crates/hir/src/attrs.rs
+++ b/crates/hir/src/attrs.rs
@@ -11,8 +11,8 @@ use hir_ty::db::HirDatabase;
 use syntax::ast;
 use crate::{
-    Adt, Const, ConstParam, Enum, Field, Function, GenericParam, LifetimeParam, MacroDef, Module,
+    Adt, Const, ConstParam, Enum, Field, Function, GenericParam, Impl, LifetimeParam, MacroDef,
-    ModuleDef, Static, Struct, Trait, TypeAlias, TypeParam, Union, Variant,
+    Module, ModuleDef, Static, Struct, Trait, TypeAlias, TypeParam, Union, Variant,
 };
 pub trait HasAttrs {
@@ -64,6 +64,7 @@ impl_has_attrs![
    (Adt, AdtId),
    (Module, ModuleId),
    (GenericParam, GenericParamId),
+    (Impl, ImplId),
 ];
 macro_rules! impl_has_attrs_enum {
diff --git a/crates/hir/src/db.rs b/crates/hir/src/db.rs
index d444f4bbb..1902a8d16 100644
--- a/crates/hir/src/db.rs
+++ b/crates/hir/src/db.rs
@@ -3,10 +3,10 @@
 pub use hir_def::db::{
    AttrsQuery, BlockDefMapQuery, BodyQuery, BodyWithSourceMapQuery, ConstDataQuery,
    CrateDefMapQueryQuery, CrateLangItemsQuery, DefDatabase, DefDatabaseStorage, EnumDataQuery,
-    ExprScopesQuery, FunctionDataQuery, GenericParamsQuery, ImplDataQuery, ImportMapQuery,
+    ExprScopesQuery, FileItemTreeQuery, FunctionDataQuery, GenericParamsQuery, ImplDataQuery,
-    InternConstQuery, InternDatabase, InternDatabaseStorage, InternEnumQuery, InternFunctionQuery,
+    ImportMapQuery, InternConstQuery, InternDatabase, InternDatabaseStorage, InternEnumQuery,
-    InternImplQuery, InternStaticQuery, InternStructQuery, InternTraitQuery, InternTypeAliasQuery,
+    InternFunctionQuery, InternImplQuery, InternStaticQuery, InternStructQuery, InternTraitQuery,
-    InternUnionQuery, ItemTreeQuery, LangItemQuery, StaticDataQuery, StructDataQuery,
+    InternTypeAliasQuery, InternUnionQuery, LangItemQuery, StaticDataQuery, StructDataQuery,
    TraitDataQuery, TypeAliasDataQuery, UnionDataQuery,
 };
 pub use hir_expand::db::{
diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index 861b7329e..b41a36a78 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs
@@ -89,7 +89,7 @@ pub use crate::{
 pub use {
    hir_def::{
        adt::StructKind,
-        attr::{Attrs, Documentation},
+        attr::{Attr, Attrs, Documentation},
        body::scope::ExprScopes,
        find_path::PrefixKind,
        import_map,
diff --git a/crates/hir/src/semantics.rs b/crates/hir/src/semantics.rs
index 00b076175..15651bb22 100644
--- a/crates/hir/src/semantics.rs
+++ b/crates/hir/src/semantics.rs
@@ -574,7 +574,7 @@ impl<'db> SemanticsImpl<'db> {
    }
    fn scope_for_def(&self, def: Trait) -> SemanticsScope<'db> {
-        let file_id = self.db.lookup_intern_trait(def.id).id.file_id;
+        let file_id = self.db.lookup_intern_trait(def.id).id.file_id();
        let resolver = def.id.resolver(self.db.upcast());
        SemanticsScope { db: self.db, file_id, resolver }
    }
@@ -752,6 +752,7 @@ macro_rules! to_def_impls {
 to_def_impls![
    (crate::Module, ast::Module, module_to_def),
+    (crate::Module, ast::SourceFile, source_file_to_def),
    (crate::Struct, ast::Struct, struct_to_def),
    (crate::Enum, ast::Enum, enum_to_def),
    (crate::Union, ast::Union, union_to_def),
diff --git a/crates/hir/src/semantics/source_to_def.rs b/crates/hir/src/semantics/source_to_def.rs
index e9d820140..c6ad5ecb5 100644
--- a/crates/hir/src/semantics/source_to_def.rs
+++ b/crates/hir/src/semantics/source_to_def.rs
@@ -71,6 +71,12 @@ impl SourceToDefCtx<'_, '_> {
        Some(def_map.module_id(child_id))
    }
+    pub(super) fn source_file_to_def(&mut self, src: InFile<ast::SourceFile>) -> Option<ModuleId> {
+        let _p = profile::span("source_file_to_def");
+        let file_id = src.file_id.original_file(self.db.upcast());
+        self.file_to_def(file_id).get(0).copied()
+    }
    pub(super) fn trait_to_def(&mut self, src: InFile<ast::Trait>) -> Option<TraitId> {
        self.to_def(src, keys::TRAIT)
    }
diff --git a/crates/hir_def/src/adt.rs b/crates/hir_def/src/adt.rs
index 1b9bb8235..58e35353b 100644
--- a/crates/hir_def/src/adt.rs
+++ b/crates/hir_def/src/adt.rs
@@ -94,7 +94,7 @@ impl StructData {
    pub(crate) fn struct_data_query(db: &dyn DefDatabase, id: StructId) -> Arc<StructData> {
        let loc = id.lookup(db);
        let krate = loc.container.krate;
-        let item_tree = db.item_tree(loc.id.file_id);
+        let item_tree = loc.id.item_tree(db);
        let repr = repr_from_value(db, krate, &item_tree, ModItem::from(loc.id.value).into());
        let cfg_options = db.crate_graph()[loc.container.krate].cfg_options.clone();
@@ -110,7 +110,7 @@ impl StructData {
    pub(crate) fn union_data_query(db: &dyn DefDatabase, id: UnionId) -> Arc<StructData> {
        let loc = id.lookup(db);
        let krate = loc.container.krate;
-        let item_tree = db.item_tree(loc.id.file_id);
+        let item_tree = loc.id.item_tree(db);
        let repr = repr_from_value(db, krate, &item_tree, ModItem::from(loc.id.value).into());
        let cfg_options = db.crate_graph()[loc.container.krate].cfg_options.clone();
@@ -130,7 +130,7 @@ impl EnumData {
    pub(crate) fn enum_data_query(db: &dyn DefDatabase, e: EnumId) -> Arc<EnumData> {
        let loc = e.lookup(db);
        let krate = loc.container.krate;
-        let item_tree = db.item_tree(loc.id.file_id);
+        let item_tree = loc.id.item_tree(db);
        let cfg_options = db.crate_graph()[krate].cfg_options.clone();
        let enum_ = &item_tree[loc.id.value];
diff --git a/crates/hir_def/src/attr.rs b/crates/hir_def/src/attr.rs
index b0b4b5052..e4c84afbf 100644
--- a/crates/hir_def/src/attr.rs
+++ b/crates/hir_def/src/attr.rs
@@ -76,37 +76,23 @@ impl ops::Deref for Attrs {
 impl RawAttrs {
    pub(crate) const EMPTY: Self = Self { entries: None };
-    pub(crate) fn new(owner: &dyn AttrsOwner, hygiene: &Hygiene) -> Self {
+    pub(crate) fn new(owner: &dyn ast::AttrsOwner, hygiene: &Hygiene) -> Self {
-        let attrs: Vec<_> = collect_attrs(owner).collect();
+        let entries = collect_attrs(owner)
-        let entries = if attrs.is_empty() {
+            .enumerate()
-            // Avoid heap allocation
+            .flat_map(|(i, attr)| match attr {
-            None
+                Either::Left(attr) => Attr::from_src(attr, hygiene, i as u32),
-        } else {
+                Either::Right(comment) => comment.doc_comment().map(|doc| Attr {
-            Some(
+                    index: i as u32,
-                attrs
+                    input: Some(AttrInput::Literal(SmolStr::new(doc))),
-                    .into_iter()
+                    path: ModPath::from(hir_expand::name!(doc)),
-                    .enumerate()
+                }),
-                    .flat_map(|(i, attr)| match attr {
+            })
-                        Either::Left(attr) => Attr::from_src(attr, hygiene).map(|attr| (i, attr)),
+            .collect::<Arc<_>>();
-                        Either::Right(comment) => comment.doc_comment().map(|doc| {
-                            (
+        Self { entries: if entries.is_empty() { None } else { Some(entries) } }
-                                i,
-                                Attr {
-                                    index: 0,
-                                    input: Some(AttrInput::Literal(SmolStr::new(doc))),
-                                    path: ModPath::from(hir_expand::name!(doc)),
-                                },
-                            )
-                        }),
-                    })
-                    .map(|(i, attr)| Attr { index: i as u32, ..attr })
-                    .collect(),
-            )
-        };
-        Self { entries }
    }
-    fn from_attrs_owner(db: &dyn DefDatabase, owner: InFile<&dyn AttrsOwner>) -> Self {
+    fn from_attrs_owner(db: &dyn DefDatabase, owner: InFile<&dyn ast::AttrsOwner>) -> Self {
        let hygiene = Hygiene::new(db.upcast(), owner.file_id);
        Self::new(owner.value, &hygiene)
    }
@@ -136,16 +122,15 @@ impl RawAttrs {
        let new_attrs = self
            .iter()
            .flat_map(|attr| -> SmallVec<[_; 1]> {
-                let attr = attr.clone();
                let is_cfg_attr =
                    attr.path.as_ident().map_or(false, |name| *name == hir_expand::name![cfg_attr]);
                if !is_cfg_attr {
-                    return smallvec![attr];
+                    return smallvec![attr.clone()];
                }
                let subtree = match &attr.input {
                    Some(AttrInput::TokenTree(it)) => it,
-                    _ => return smallvec![attr],
+                    _ => return smallvec![attr.clone()],
                };
                // Input subtree is: `(cfg, $(attr),+)`
@@ -157,11 +142,13 @@ impl RawAttrs {
                let cfg = parts.next().unwrap();
                let cfg = Subtree { delimiter: subtree.delimiter, token_trees: cfg.to_vec() };
                let cfg = CfgExpr::parse(&cfg);
+                let index = attr.index;
                let attrs = parts.filter(|a| !a.is_empty()).filter_map(|attr| {
                    let tree = Subtree { delimiter: None, token_trees: attr.to_vec() };
                    let attr = ast::Attr::parse(&format!("#[{}]", tree)).ok()?;
-                    let hygiene = Hygiene::new_unhygienic(); // FIXME
+                    // FIXME hygiene
-                    Attr::from_src(attr, &hygiene)
+                    let hygiene = Hygiene::new_unhygienic();
+                    Attr::from_src(attr, &hygiene, index)
                });
                let cfg_options = &crate_graph[krate].cfg_options;
@@ -191,7 +178,7 @@ impl Attrs {
                    Some(it) => {
                        let raw_attrs = RawAttrs::from_attrs_owner(
                            db,
-                            it.as_ref().map(|it| it as &dyn AttrsOwner),
+                            it.as_ref().map(|it| it as &dyn ast::AttrsOwner),
                        );
                        match mod_data.definition_source(db) {
                            InFile { file_id, value: ModuleSource::SourceFile(file) } => raw_attrs
@@ -202,9 +189,9 @@ impl Attrs {
                    None => RawAttrs::from_attrs_owner(
                        db,
                        mod_data.definition_source(db).as_ref().map(|src| match src {
-                            ModuleSource::SourceFile(file) => file as &dyn AttrsOwner,
+                            ModuleSource::SourceFile(file) => file as &dyn ast::AttrsOwner,
-                            ModuleSource::Module(module) => module as &dyn AttrsOwner,
+                            ModuleSource::Module(module) => module as &dyn ast::AttrsOwner,
-                            ModuleSource::BlockExpr(block) => block as &dyn AttrsOwner,
+                            ModuleSource::BlockExpr(block) => block as &dyn ast::AttrsOwner,
                        }),
                    ),
                }
@@ -262,7 +249,7 @@ impl Attrs {
        let mut res = ArenaMap::default();
        for (id, var) in src.value.iter() {
-            let attrs = RawAttrs::from_attrs_owner(db, src.with_value(var as &dyn AttrsOwner))
+            let attrs = RawAttrs::from_attrs_owner(db, src.with_value(var as &dyn ast::AttrsOwner))
                .filter(db, krate);
            res.insert(id, attrs)
@@ -293,6 +280,13 @@ impl Attrs {
        Arc::new(res)
    }
+    /// Constructs a map that maps the lowered `Attr`s in this `Attrs` back to its original syntax nodes.
+    ///
+    /// `owner` must be the original owner of the attributes.
+    pub fn source_map(&self, owner: &dyn ast::AttrsOwner) -> AttrSourceMap {
+        AttrSourceMap { attrs: collect_attrs(owner).collect() }
+    }
    pub fn by_key(&self, key: &'static str) -> AttrQuery<'_> {
        AttrQuery { attrs: self, key }
    }
@@ -317,15 +311,34 @@ impl Attrs {
            AttrInput::Literal(s) => Some(s),
            AttrInput::TokenTree(_) => None,
        });
-        // FIXME: Replace `Itertools::intersperse` with `Iterator::intersperse[_with]` until the
+        let indent = docs
-        // libstd api gets stabilized (https://github.com/rust-lang/rust/issues/79524).
+            .clone()
-        let docs = Itertools::intersperse(docs, &SmolStr::new_inline("\n"))
+            .flat_map(|s| s.lines())
-            .map(|it| it.as_str())
+            .filter(|line| !line.chars().all(|c| c.is_whitespace()))
-            .collect::<String>();
+            .map(|line| line.chars().take_while(|c| c.is_whitespace()).count())
-        if docs.is_empty() {
+            .min()
+            .unwrap_or(0);
+        let mut buf = String::new();
+        for doc in docs {
+            // str::lines doesn't yield anything for the empty string
+            if !doc.is_empty() {
+                buf.extend(Itertools::intersperse(
+                    doc.lines().map(|line| {
+                        line.char_indices()
+                            .nth(indent)
+                            .map_or(line, |(offset, _)| &line[offset..])
+                            .trim_end()
+                    }),
+                    "\n",
+                ));
+            }
+            buf.push('\n');
+        }
+        buf.pop();
+        if buf.is_empty() {
            None
        } else {
-            Some(Documentation(docs))
+            Some(Documentation(buf))
        }
    }
 }
@@ -365,6 +378,24 @@ fn inner_attributes(
    Some((attrs, docs))
 }
+pub struct AttrSourceMap {
+    attrs: Vec<Either<ast::Attr, ast::Comment>>,
+}
+impl AttrSourceMap {
+    /// Maps the lowered `Attr` back to its original syntax node.
+    ///
+    /// `attr` must come from the `owner` used for AttrSourceMap
+    ///
+    /// Note that the returned syntax node might be a `#[cfg_attr]`, or a doc comment, instead of
+    /// the attribute represented by `Attr`.
+    pub fn source_of(&self, attr: &Attr) -> &Either<ast::Attr, ast::Comment> {
+        self.attrs
+            .get(attr.index as usize)
+            .unwrap_or_else(|| panic!("cannot find `Attr` at index {}", attr.index))
+    }
+}
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Attr {
    index: u32,
@@ -381,7 +412,7 @@ pub enum AttrInput {
 }
 impl Attr {
-    fn from_src(ast: ast::Attr, hygiene: &Hygiene) -> Option<Attr> {
+    fn from_src(ast: ast::Attr, hygiene: &Hygiene, index: u32) -> Option<Attr> {
        let path = ModPath::from_src(ast.path()?, hygiene)?;
        let input = if let Some(lit) = ast.literal() {
            let value = match lit.kind() {
@@ -394,7 +425,7 @@ impl Attr {
        } else {
            None
        };
-        Some(Attr { index: 0, path, input })
+        Some(Attr { index, path, input })
    }
    /// Maps this lowered `Attr` back to its original syntax node.
@@ -403,7 +434,7 @@ impl Attr {
    ///
    /// Note that the returned syntax node might be a `#[cfg_attr]`, or a doc comment, instead of
    /// the attribute represented by `Attr`.
-    pub fn to_src(&self, owner: &dyn AttrsOwner) -> Either<ast::Attr, ast::Comment> {
+    pub fn to_src(&self, owner: &dyn ast::AttrsOwner) -> Either<ast::Attr, ast::Comment> {
        collect_attrs(owner).nth(self.index as usize).unwrap_or_else(|| {
            panic!("cannot find `Attr` at index {} in {}", self.index, owner.syntax())
        })
@@ -448,6 +479,13 @@ impl Attr {
            _ => None,
        }
    }
+    pub fn string_value(&self) -> Option<&SmolStr> {
+        match self.input.as_ref()? {
+            AttrInput::Literal(it) => Some(it),
+            _ => None,
+        }
+    }
 }
 #[derive(Debug, Clone, Copy)]
@@ -475,7 +513,7 @@ impl<'a> AttrQuery<'a> {
        self.attrs().next().is_some()
    }
-    pub(crate) fn attrs(self) -> impl Iterator<Item = &'a Attr> {
+    pub fn attrs(self) -> impl Iterator<Item = &'a Attr> + Clone {
        let key = self.key;
        self.attrs
            .iter()
@@ -488,16 +526,18 @@ where
    N: ast::AttrsOwner,
 {
    let src = InFile::new(src.file_id, src.to_node(db.upcast()));
-    RawAttrs::from_attrs_owner(db, src.as_ref().map(|it| it as &dyn AttrsOwner))
+    RawAttrs::from_attrs_owner(db, src.as_ref().map(|it| it as &dyn ast::AttrsOwner))
 }
 fn attrs_from_item_tree<N: ItemTreeNode>(id: ItemTreeId<N>, db: &dyn DefDatabase) -> RawAttrs {
-    let tree = db.item_tree(id.file_id);
+    let tree = id.item_tree(db);
    let mod_item = N::id_to_mod_item(id.value);
    tree.raw_attrs(mod_item.into()).clone()
 }
-fn collect_attrs(owner: &dyn AttrsOwner) -> impl Iterator<Item = Either<ast::Attr, ast::Comment>> {
+fn collect_attrs(
+    owner: &dyn ast::AttrsOwner,
+) -> impl Iterator<Item = Either<ast::Attr, ast::Comment>> {
    let (inner_attrs, inner_docs) = inner_attributes(owner.syntax())
        .map_or((None, None), |(attrs, docs)| ((Some(attrs), Some(docs))));
diff --git a/crates/hir_def/src/body/lower.rs b/crates/hir_def/src/body/lower.rs
index 60b25db56..19f5065d1 100644
--- a/crates/hir_def/src/body/lower.rs
+++ b/crates/hir_def/src/body/lower.rs
@@ -177,12 +177,15 @@ impl ExprCollector<'_> {
    }
    fn collect_expr(&mut self, expr: ast::Expr) -> ExprId {
+        self.maybe_collect_expr(expr).unwrap_or_else(|| self.missing_expr())
+    }
+    /// Returns `None` if the expression is `#[cfg]`d out.
+    fn maybe_collect_expr(&mut self, expr: ast::Expr) -> Option<ExprId> {
        let syntax_ptr = AstPtr::new(&expr);
-        if self.check_cfg(&expr).is_none() {
+        self.check_cfg(&expr)?;
-            return self.missing_expr();
-        }
-        match expr {
+        Some(match expr {
            ast::Expr::IfExpr(e) => {
                let then_branch = self.collect_block_opt(e.then_branch());
@@ -211,8 +214,9 @@ impl ExprCollector<'_> {
                                    guard: None,
                                },
                            ];
-                            return self
+                            return Some(
-                                .alloc_expr(Expr::Match { expr: match_expr, arms }, syntax_ptr);
+                                self.alloc_expr(Expr::Match { expr: match_expr, arms }, syntax_ptr),
+                            );
                        }
                    },
                };
@@ -283,8 +287,9 @@ impl ExprCollector<'_> {
                            ];
                            let match_expr =
                                self.alloc_expr_desugared(Expr::Match { expr: match_expr, arms });
-                            return self
+                            return Some(
-                                .alloc_expr(Expr::Loop { body: match_expr, label }, syntax_ptr);
+                                self.alloc_expr(Expr::Loop { body: match_expr, label }, syntax_ptr),
+                            );
                        }
                    },
                };
@@ -301,7 +306,7 @@ impl ExprCollector<'_> {
            ast::Expr::CallExpr(e) => {
                let callee = self.collect_expr_opt(e.expr());
                let args = if let Some(arg_list) = e.arg_list() {
-                    arg_list.args().map(|e| self.collect_expr(e)).collect()
+                    arg_list.args().filter_map(|e| self.maybe_collect_expr(e)).collect()
                } else {
                    Vec::new()
                };
@@ -310,7 +315,7 @@ impl ExprCollector<'_> {
            ast::Expr::MethodCallExpr(e) => {
                let receiver = self.collect_expr_opt(e.receiver());
                let args = if let Some(arg_list) = e.arg_list() {
-                    arg_list.args().map(|e| self.collect_expr(e)).collect()
+                    arg_list.args().filter_map(|e| self.maybe_collect_expr(e)).collect()
                } else {
                    Vec::new()
                };
@@ -538,7 +543,7 @@ impl ExprCollector<'_> {
                    self.alloc_expr(Expr::Missing, syntax_ptr)
                }
            }
-        }
+        })
    }
    fn collect_macro_call<F: FnMut(&mut Self, Option<T>), T: ast::AstNode>(
diff --git a/crates/hir_def/src/body/tests.rs b/crates/hir_def/src/body/tests.rs
index f8e6f70e8..faa133297 100644
--- a/crates/hir_def/src/body/tests.rs
+++ b/crates/hir_def/src/body/tests.rs
@@ -137,7 +137,7 @@ fn f() {
    include!(invalid);
  //^^^^^^^^^^^^^^^^^ could not convert tokens
    include!("does not exist");
-  //^^^^^^^^^^^^^^^^^^^^^^^^^^ could not convert tokens
+  //^^^^^^^^^^^^^^^^^^^^^^^^^^ failed to load file `does not exist`
    env!(invalid);
  //^^^^^^^^^^^^^ could not convert tokens
diff --git a/crates/hir_def/src/data.rs b/crates/hir_def/src/data.rs
index 1a27f7bf2..0be868ba2 100644
--- a/crates/hir_def/src/data.rs
+++ b/crates/hir_def/src/data.rs
@@ -9,7 +9,7 @@ use crate::{
    attr::Attrs,
    body::Expander,
    db::DefDatabase,
-    item_tree::{AssocItem, FunctionQualifier, ItemTreeId, ModItem},
+    item_tree::{AssocItem, FunctionQualifier, ItemTreeId, ModItem, Param},
    type_ref::{TypeBound, TypeRef},
    visibility::RawVisibility,
    AssocContainerId, AssocItemId, ConstId, ConstLoc, FunctionId, FunctionLoc, HasModule, ImplId,
@@ -36,19 +36,38 @@ impl FunctionData {
    pub(crate) fn fn_data_query(db: &dyn DefDatabase, func: FunctionId) -> Arc<FunctionData> {
        let loc = func.lookup(db);
        let krate = loc.container.module(db).krate;
-        let item_tree = db.item_tree(loc.id.file_id);
+        let crate_graph = db.crate_graph();
+        let cfg_options = &crate_graph[krate].cfg_options;
+        let item_tree = loc.id.item_tree(db);
        let func = &item_tree[loc.id.value];
+        let enabled_params = func
+            .params
+            .clone()
+            .filter(|&param| item_tree.attrs(db, krate, param.into()).is_cfg_enabled(cfg_options));
+        // If last cfg-enabled param is a `...` param, it's a varargs function.
+        let is_varargs = enabled_params
+            .clone()
+            .next_back()
+            .map_or(false, |param| matches!(item_tree[param], Param::Varargs));
        Arc::new(FunctionData {
            name: func.name.clone(),
-            params: func.params.iter().map(|id| item_tree[*id].clone()).collect(),
+            params: enabled_params
+                .clone()
+                .filter_map(|id| match &item_tree[id] {
+                    Param::Normal(ty) => Some(item_tree[*ty].clone()),
+                    Param::Varargs => None,
+                })
+                .collect(),
            ret_type: item_tree[func.ret_type].clone(),
            attrs: item_tree.attrs(db, krate, ModItem::from(loc.id.value).into()),
            has_self_param: func.has_self_param,
            has_body: func.has_body,
            qualifier: func.qualifier.clone(),
            is_in_extern_block: func.is_in_extern_block,
-            is_varargs: func.is_varargs,
+            is_varargs,
            visibility: item_tree[func.visibility].clone(),
        })
    }
@@ -70,7 +89,7 @@ impl TypeAliasData {
        typ: TypeAliasId,
    ) -> Arc<TypeAliasData> {
        let loc = typ.lookup(db);
-        let item_tree = db.item_tree(loc.id.file_id);
+        let item_tree = loc.id.item_tree(db);
        let typ = &item_tree[loc.id.value];
        Arc::new(TypeAliasData {
@@ -96,23 +115,23 @@ pub struct TraitData {
 impl TraitData {
    pub(crate) fn trait_data_query(db: &dyn DefDatabase, tr: TraitId) -> Arc<TraitData> {
        let tr_loc = tr.lookup(db);
-        let item_tree = db.item_tree(tr_loc.id.file_id);
+        let item_tree = tr_loc.id.item_tree(db);
        let tr_def = &item_tree[tr_loc.id.value];
        let name = tr_def.name.clone();
        let is_auto = tr_def.is_auto;
        let is_unsafe = tr_def.is_unsafe;
        let module_id = tr_loc.container;
        let container = AssocContainerId::TraitId(tr);
-        let mut expander = Expander::new(db, tr_loc.id.file_id, module_id);
        let visibility = item_tree[tr_def.visibility].clone();
        let bounds = tr_def.bounds.clone();
+        let mut expander = Expander::new(db, tr_loc.id.file_id(), module_id);
        let items = collect_items(
            db,
            module_id,
            &mut expander,
            tr_def.items.iter().copied(),
-            tr_loc.id.file_id,
+            tr_loc.id.file_id(),
            container,
            100,
        );
@@ -148,21 +167,21 @@ impl ImplData {
        let _p = profile::span("impl_data_query");
        let impl_loc = id.lookup(db);
-        let item_tree = db.item_tree(impl_loc.id.file_id);
+        let item_tree = impl_loc.id.item_tree(db);
        let impl_def = &item_tree[impl_loc.id.value];
        let target_trait = impl_def.target_trait.map(|id| item_tree[id].clone());
        let target_type = item_tree[impl_def.target_type].clone();
        let is_negative = impl_def.is_negative;
        let module_id = impl_loc.container;
        let container = AssocContainerId::ImplId(id);
-        let mut expander = Expander::new(db, impl_loc.id.file_id, module_id);
+        let mut expander = Expander::new(db, impl_loc.id.file_id(), module_id);
        let items = collect_items(
            db,
            module_id,
            &mut expander,
            impl_def.items.iter().copied(),
-            impl_loc.id.file_id,
+            impl_loc.id.file_id(),
            container,
            100,
        );
@@ -183,7 +202,7 @@ pub struct ConstData {
 impl ConstData {
    pub(crate) fn const_data_query(db: &dyn DefDatabase, konst: ConstId) -> Arc<ConstData> {
        let loc = konst.lookup(db);
-        let item_tree = db.item_tree(loc.id.file_id);
+        let item_tree = loc.id.item_tree(db);
        let konst = &item_tree[loc.id.value];
        Arc::new(ConstData {
@@ -206,7 +225,7 @@ pub struct StaticData {
 impl StaticData {
    pub(crate) fn static_data_query(db: &dyn DefDatabase, konst: StaticId) -> Arc<StaticData> {
        let node = konst.lookup(db);
-        let item_tree = db.item_tree(node.id.file_id);
+        let item_tree = node.id.item_tree(db);
        let statik = &item_tree[node.id.value];
        Arc::new(StaticData {
@@ -232,22 +251,23 @@ fn collect_items(
        return Vec::new();
    }
-    let item_tree = db.item_tree(file_id);
+    let item_tree = db.file_item_tree(file_id);
-    let cfg_options = db.crate_graph()[module.krate].cfg_options.clone();
+    let crate_graph = db.crate_graph();
+    let cfg_options = &crate_graph[module.krate].cfg_options;
    let mut items = Vec::new();
    for item in assoc_items {
+        let attrs = item_tree.attrs(db, module.krate, ModItem::from(item).into());
+        if !attrs.is_cfg_enabled(cfg_options) {
+            continue;
+        }
        match item {
            AssocItem::Function(id) => {
                let item = &item_tree[id];
-                let attrs = item_tree.attrs(db, module.krate, ModItem::from(id).into());
-                if !attrs.is_cfg_enabled(&cfg_options) {
-                    continue;
-                }
                let def = FunctionLoc { container, id: ItemTreeId::new(file_id, id) }.intern(db);
                items.push((item.name.clone(), def.into()));
            }
-            // FIXME: cfg?
            AssocItem::Const(id) => {
                let item = &item_tree[id];
                let name = match item.name.clone() {
@@ -272,7 +292,7 @@ fn collect_items(
                if let Ok(res) = res {
                    if let Some((mark, mac)) = res.value {
                        let src: InFile<ast::MacroItems> = expander.to_source(mac);
-                        let item_tree = db.item_tree(src.file_id);
+                        let item_tree = db.file_item_tree(src.file_id);
                        let iter =
                            item_tree.top_level_items().iter().filter_map(ModItem::as_assoc_item);
                        items.extend(collect_items(
diff --git a/crates/hir_def/src/db.rs b/crates/hir_def/src/db.rs
index cca5a086b..276caf5b3 100644
--- a/crates/hir_def/src/db.rs
+++ b/crates/hir_def/src/db.rs
@@ -48,8 +48,8 @@ pub trait InternDatabase: SourceDatabase {
 #[salsa::query_group(DefDatabaseStorage)]
 pub trait DefDatabase: InternDatabase + AstDatabase + Upcast<dyn AstDatabase> {
-    #[salsa::invoke(ItemTree::item_tree_query)]
+    #[salsa::invoke(ItemTree::file_item_tree_query)]
-    fn item_tree(&self, file_id: HirFileId) -> Arc<ItemTree>;
+    fn file_item_tree(&self, file_id: HirFileId) -> Arc<ItemTree>;
    #[salsa::invoke(crate_def_map_wait)]
    #[salsa::transparent]
diff --git a/crates/hir_def/src/generics.rs b/crates/hir_def/src/generics.rs
index a056ab797..7c6cbff11 100644
--- a/crates/hir_def/src/generics.rs
+++ b/crates/hir_def/src/generics.rs
@@ -97,43 +97,43 @@ impl GenericParams {
        let generics = match def {
            GenericDefId::FunctionId(id) => {
                let id = id.lookup(db).id;
-                let tree = db.item_tree(id.file_id);
+                let tree = id.item_tree(db);
                let item = &tree[id.value];
                tree[item.generic_params].clone()
            }
            GenericDefId::AdtId(AdtId::StructId(id)) => {
                let id = id.lookup(db).id;
-                let tree = db.item_tree(id.file_id);
+                let tree = id.item_tree(db);
                let item = &tree[id.value];
                tree[item.generic_params].clone()
            }
            GenericDefId::AdtId(AdtId::EnumId(id)) => {
                let id = id.lookup(db).id;
-                let tree = db.item_tree(id.file_id);
+                let tree = id.item_tree(db);
                let item = &tree[id.value];
                tree[item.generic_params].clone()
            }
            GenericDefId::AdtId(AdtId::UnionId(id)) => {
                let id = id.lookup(db).id;
-                let tree = db.item_tree(id.file_id);
+                let tree = id.item_tree(db);
                let item = &tree[id.value];
                tree[item.generic_params].clone()
            }
            GenericDefId::TraitId(id) => {
                let id = id.lookup(db).id;
-                let tree = db.item_tree(id.file_id);
+                let tree = id.item_tree(db);
                let item = &tree[id.value];
                tree[item.generic_params].clone()
            }
            GenericDefId::TypeAliasId(id) => {
                let id = id.lookup(db).id;
-                let tree = db.item_tree(id.file_id);
+                let tree = id.item_tree(db);
                let item = &tree[id.value];
                tree[item.generic_params].clone()
            }
            GenericDefId::ImplId(id) => {
                let id = id.lookup(db).id;
-                let tree = db.item_tree(id.file_id);
+                let tree = id.item_tree(db);
                let item = &tree[id.value];
                tree[item.generic_params].clone()
            }
diff --git a/crates/hir_def/src/item_tree.rs b/crates/hir_def/src/item_tree.rs
index 4477bdd36..ae2475b4e 100644
--- a/crates/hir_def/src/item_tree.rs
+++ b/crates/hir_def/src/item_tree.rs
@@ -76,7 +76,7 @@ pub struct ItemTree {
 }
 impl ItemTree {
-    pub(crate) fn item_tree_query(db: &dyn DefDatabase, file_id: HirFileId) -> Arc<ItemTree> {
+    pub(crate) fn file_item_tree_query(db: &dyn DefDatabase, file_id: HirFileId) -> Arc<ItemTree> {
        let _p = profile::span("item_tree_query").detail(|| format!("{:?}", file_id));
        let syntax = if let Some(node) = db.parse_or_expand(file_id) {
            if node.kind() == SyntaxKind::ERROR {
@@ -138,6 +138,7 @@ impl ItemTree {
                imports,
                extern_crates,
                functions,
+                params,
                structs,
                fields,
                unions,
@@ -161,6 +162,7 @@ impl ItemTree {
            imports.shrink_to_fit();
            extern_crates.shrink_to_fit();
            functions.shrink_to_fit();
+            params.shrink_to_fit();
            structs.shrink_to_fit();
            fields.shrink_to_fit();
            unions.shrink_to_fit();
@@ -307,6 +309,7 @@ struct ItemTreeData {
    imports: Arena<Import>,
    extern_crates: Arena<ExternCrate>,
    functions: Arena<Function>,
+    params: Arena<Param>,
    structs: Arena<Struct>,
    fields: Arena<Field>,
    unions: Arena<Union>,
@@ -338,6 +341,7 @@ pub enum AttrOwner {
    Variant(Idx<Variant>),
    Field(Idx<Field>),
+    Param(Idx<Param>),
 }
 macro_rules! from_attrs {
@@ -352,7 +356,7 @@ macro_rules! from_attrs {
    };
 }
-from_attrs!(ModItem(ModItem), Variant(Idx<Variant>), Field(Idx<Field>));
+from_attrs!(ModItem(ModItem), Variant(Idx<Variant>), Field(Idx<Field>), Param(Idx<Param>));
 /// Trait implemented by all item nodes in the item tree.
 pub trait ItemTreeNode: Clone {
@@ -401,7 +405,47 @@ impl<N: ItemTreeNode> fmt::Debug for FileItemTreeId<N> {
    }
 }
-pub type ItemTreeId<N> = InFile<FileItemTreeId<N>>;
+#[derive(Debug)]
+pub struct ItemTreeId<N: ItemTreeNode> {
+    file: HirFileId,
+    pub value: FileItemTreeId<N>,
+}
+impl<N: ItemTreeNode> ItemTreeId<N> {
+    pub fn new(file: HirFileId, idx: FileItemTreeId<N>) -> Self {
+        Self { file, value: idx }
+    }
+    pub fn file_id(self) -> HirFileId {
+        self.file
+    }
+    pub fn item_tree(self, db: &dyn DefDatabase) -> Arc<ItemTree> {
+        db.file_item_tree(self.file)
+    }
+}
+impl<N: ItemTreeNode> Copy for ItemTreeId<N> {}
+impl<N: ItemTreeNode> Clone for ItemTreeId<N> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+impl<N: ItemTreeNode> PartialEq for ItemTreeId<N> {
+    fn eq(&self, other: &Self) -> bool {
+        self.file == other.file && self.value == other.value
+    }
+}
+impl<N: ItemTreeNode> Eq for ItemTreeId<N> {}
+impl<N: ItemTreeNode> Hash for ItemTreeId<N> {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.file.hash(state);
+        self.value.hash(state);
+    }
+}
 macro_rules! mod_items {
    ( $( $typ:ident in $fld:ident -> $ast:ty ),+ $(,)? ) => {
@@ -488,7 +532,7 @@ macro_rules! impl_index {
    };
 }
-impl_index!(fields: Field, variants: Variant);
+impl_index!(fields: Field, variants: Variant, params: Param);
 impl Index<RawVisibilityId> for ItemTree {
    type Output = RawVisibility;
@@ -564,12 +608,17 @@ pub struct Function {
    /// Whether the function is located in an `extern` block (*not* whether it is an
    /// `extern "abi" fn`).
    pub is_in_extern_block: bool,
-    pub params: Box<[Idx<TypeRef>]>,
+    pub params: IdRange<Param>,
-    pub is_varargs: bool,
    pub ret_type: Idx<TypeRef>,
    pub ast_id: FileAstId<ast::Fn>,
 }
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub enum Param {
+    Normal(Idx<TypeRef>),
+    Varargs,
+}
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct FunctionQualifier {
    pub is_default: bool,
@@ -800,6 +849,7 @@ pub struct Variant {
    pub fields: Fields,
 }
+/// A range of densely allocated ItemTree IDs.
 pub struct IdRange<T> {
    range: Range<u32>,
    _p: PhantomData<T>,
@@ -818,6 +868,12 @@ impl<T> Iterator for IdRange<T> {
    }
 }
+impl<T> DoubleEndedIterator for IdRange<T> {
+    fn next_back(&mut self) -> Option<Self::Item> {
+        self.range.next_back().map(|raw| Idx::from_raw(raw.into()))
+    }
+}
 impl<T> fmt::Debug for IdRange<T> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_tuple(&format!("IdRange::<{}>", type_name::<T>())).field(&self.range).finish()
diff --git a/crates/hir_def/src/item_tree/lower.rs b/crates/hir_def/src/item_tree/lower.rs
index d684b89d0..d3fe1ce1e 100644
--- a/crates/hir_def/src/item_tree/lower.rs
+++ b/crates/hir_def/src/item_tree/lower.rs
@@ -341,8 +341,8 @@ impl Ctx {
        let visibility = self.lower_visibility(func);
        let name = func.name()?.as_name();
-        let mut params = Vec::new();
        let mut has_self_param = false;
+        let start_param = self.next_param_idx();
        if let Some(param_list) = func.param_list() {
            if let Some(self_param) = param_list.self_param() {
                let self_type = match self_param.ty() {
@@ -364,22 +364,25 @@ impl Ctx {
                        }
                    }
                };
-                params.push(self_type);
+                let ty = self.data().type_refs.intern(self_type);
+                let idx = self.data().params.alloc(Param::Normal(ty));
+                self.add_attrs(idx.into(), RawAttrs::new(&self_param, &self.hygiene));
                has_self_param = true;
            }
            for param in param_list.params() {
-                let type_ref = TypeRef::from_ast_opt(&self.body_ctx, param.ty());
+                let idx = match param.dotdotdot_token() {
-                params.push(type_ref);
+                    Some(_) => self.data().params.alloc(Param::Varargs),
-            }
+                    None => {
-        }
+                        let type_ref = TypeRef::from_ast_opt(&self.body_ctx, param.ty());
-        let params = params.into_iter().map(|param| self.data().type_refs.intern(param)).collect();
+                        let ty = self.data().type_refs.intern(type_ref);
+                        self.data().params.alloc(Param::Normal(ty))
-        let mut is_varargs = false;
+                    }
-        if let Some(params) = func.param_list() {
+                };
-            if let Some(last) = params.params().last() {
+                self.add_attrs(idx.into(), RawAttrs::new(&param, &self.hygiene));
-                is_varargs = last.dotdotdot_token().is_some();
            }
        }
+        let end_param = self.next_param_idx();
+        let params = IdRange::new(start_param..end_param);
        let ret_type = match func.ret_type().and_then(|rt| rt.ty()) {
            Some(type_ref) => TypeRef::from_ast(&self.body_ctx, type_ref),
@@ -427,7 +430,6 @@ impl Ctx {
            qualifier,
            is_in_extern_block: false,
            params,
-            is_varargs,
            ret_type,
            ast_id,
        };
@@ -690,9 +692,11 @@ impl Ctx {
            GenericsOwner::Function(func) => {
                generics.fill(&self.body_ctx, sm, node);
                // lower `impl Trait` in arguments
-                for param in &*func.params {
+                for id in func.params.clone() {
-                    let param = self.data().type_refs.lookup(*param);
+                    if let Param::Normal(ty) = self.data().params[id] {
-                    generics.fill_implicit_impl_trait_args(param);
+                        let ty = self.data().type_refs.lookup(ty);
+                        generics.fill_implicit_impl_trait_args(ty);
+                    }
                }
            }
            GenericsOwner::Struct
@@ -777,6 +781,11 @@ impl Ctx {
            self.tree.data.as_ref().map_or(0, |data| data.variants.len() as u32),
        ))
    }
+    fn next_param_idx(&self) -> Idx<Param> {
+        Idx::from_raw(RawIdx::from(
+            self.tree.data.as_ref().map_or(0, |data| data.params.len() as u32),
+        ))
+    }
 }
 fn desugar_future_path(orig: TypeRef) -> Path {
diff --git a/crates/hir_def/src/nameres.rs b/crates/hir_def/src/nameres.rs
index 003d668ca..c97be584e 100644
--- a/crates/hir_def/src/nameres.rs
+++ b/crates/hir_def/src/nameres.rs
@@ -213,7 +213,7 @@ impl DefMap {
    ) -> Option<Arc<DefMap>> {
        let block: BlockLoc = db.lookup_intern_block(block_id);
-        let item_tree = db.item_tree(block.ast_id.file_id);
+        let item_tree = db.file_item_tree(block.ast_id.file_id);
        if item_tree.inner_items_of_block(block.ast_id.value).is_empty() {
            return None;
        }
diff --git a/crates/hir_def/src/nameres/collector.rs b/crates/hir_def/src/nameres/collector.rs
index 81cf652b0..d0fefb5af 100644
--- a/crates/hir_def/src/nameres/collector.rs
+++ b/crates/hir_def/src/nameres/collector.rs
@@ -242,7 +242,7 @@ struct DefCollector<'a> {
 impl DefCollector<'_> {
    fn seed_with_top_level(&mut self) {
        let file_id = self.db.crate_graph()[self.def_map.krate].root_file_id;
-        let item_tree = self.db.item_tree(file_id.into());
+        let item_tree = self.db.file_item_tree(file_id.into());
        let module_id = self.def_map.root;
        self.def_map.modules[module_id].origin = ModuleOrigin::CrateRoot { definition: file_id };
        if item_tree
@@ -263,7 +263,7 @@ impl DefCollector<'_> {
    }
    fn seed_with_inner(&mut self, block: AstId<ast::BlockExpr>) {
-        let item_tree = self.db.item_tree(block.file_id);
+        let item_tree = self.db.file_item_tree(block.file_id);
        let module_id = self.def_map.root;
        self.def_map.modules[module_id].origin = ModuleOrigin::BlockExpr { block };
        if item_tree
@@ -656,26 +656,28 @@ impl DefCollector<'_> {
                }
            }
        } else {
-            match import.path.segments().last() {
+            let name = match &import.alias {
-                Some(last_segment) => {
+                Some(ImportAlias::Alias(name)) => Some(name.clone()),
-                    let name = match &import.alias {
+                Some(ImportAlias::Underscore) => None,
-                        Some(ImportAlias::Alias(name)) => Some(name.clone()),
+                None => match import.path.segments().last() {
-                        Some(ImportAlias::Underscore) => None,
+                    Some(last_segment) => Some(last_segment.clone()),
-                        None => Some(last_segment.clone()),
+                    None => {
-                    };
+                        cov_mark::hit!(bogus_paths);
-                    log::debug!("resolved import {:?} ({:?}) to {:?}", name, import, def);
+                        return;
-                    // extern crates in the crate root are special-cased to insert entries into the extern prelude: rust-lang/rust#54658
-                    if import.is_extern_crate && module_id == self.def_map.root {
-                        if let (Some(def), Some(name)) = (def.take_types(), name.as_ref()) {
-                            self.def_map.extern_prelude.insert(name.clone(), def);
-                        }
                    }
+                },
+            };
+            log::debug!("resolved import {:?} ({:?}) to {:?}", name, import, def);
-                    self.update(module_id, &[(name, def)], vis, ImportType::Named);
+            // extern crates in the crate root are special-cased to insert entries into the extern prelude: rust-lang/rust#54658
+            if import.is_extern_crate && module_id == self.def_map.root {
+                if let (Some(def), Some(name)) = (def.take_types(), name.as_ref()) {
+                    self.def_map.extern_prelude.insert(name.clone(), def);
                }
-                None => cov_mark::hit!(bogus_paths),
            }
+            self.update(module_id, &[(name, def)], vis, ImportType::Named);
        }
    }
@@ -893,7 +895,7 @@ impl DefCollector<'_> {
        }
        // Then, fetch and process the item tree. This will reuse the expansion result from above.
-        let item_tree = self.db.item_tree(file_id);
+        let item_tree = self.db.file_item_tree(file_id);
        let mod_dir = self.mod_dirs[&module_id].clone();
        ModCollector {
            def_collector: &mut *self,
@@ -949,21 +951,21 @@ impl DefCollector<'_> {
        let mut diagnosed_extern_crates = FxHashSet::default();
        for directive in &self.unresolved_imports {
            if let ImportSource::ExternCrate(krate) = directive.import.source {
-                let item_tree = self.db.item_tree(krate.file_id);
+                let item_tree = krate.item_tree(self.db);
                let extern_crate = &item_tree[krate.value];
                diagnosed_extern_crates.insert(extern_crate.name.clone());
                self.def_map.diagnostics.push(DefDiagnostic::unresolved_extern_crate(
                    directive.module_id,
-                    InFile::new(krate.file_id, extern_crate.ast_id),
+                    InFile::new(krate.file_id(), extern_crate.ast_id),
                ));
            }
        }
        for directive in &self.unresolved_imports {
            if let ImportSource::Import(import) = &directive.import.source {
-                let item_tree = self.db.item_tree(import.file_id);
+                let item_tree = import.item_tree(self.db);
                let import_data = &item_tree[import.value];
                match (import_data.path.segments().first(), &import_data.path.kind) {
@@ -977,7 +979,7 @@ impl DefCollector<'_> {
                self.def_map.diagnostics.push(DefDiagnostic::unresolved_import(
                    directive.module_id,
-                    InFile::new(import.file_id, import_data.ast_id),
+                    InFile::new(import.file_id(), import_data.ast_id),
                    import_data.index,
                ));
            }
@@ -1053,7 +1055,7 @@ impl ModCollector<'_, '_> {
                            self.def_collector.db,
                            krate,
                            &self.item_tree,
-                            InFile::new(self.file_id, import_id),
+                            ItemTreeId::new(self.file_id, import_id),
                        ),
                        status: PartialResolvedImport::Unresolved,
                    })
@@ -1065,7 +1067,7 @@ impl ModCollector<'_, '_> {
                            self.def_collector.db,
                            krate,
                            &self.item_tree,
-                            InFile::new(self.file_id, import_id),
+                            ItemTreeId::new(self.file_id, import_id),
                        ),
                        status: PartialResolvedImport::Unresolved,
                    })
@@ -1297,7 +1299,7 @@ impl ModCollector<'_, '_> {
                            Some((file_id, is_mod_rs)),
                            &self.item_tree[module.visibility],
                        );
-                        let item_tree = db.item_tree(file_id.into());
+                        let item_tree = db.file_item_tree(file_id.into());
                        ModCollector {
                            def_collector: &mut *self.def_collector,
                            macro_depth: self.macro_depth,
@@ -1469,7 +1471,9 @@ impl ModCollector<'_, '_> {
                    )
                })
            },
-            &mut |err| error = Some(err),
+            &mut |err| {
+                error.get_or_insert(err);
+            },
        ) {
            Ok(Ok(macro_call_id)) => {
                self.def_collector.unexpanded_macros.push(MacroDirective {
diff --git a/crates/hir_def/src/nameres/tests.rs b/crates/hir_def/src/nameres/tests.rs
index de3aa4f9a..4f2e7a2f9 100644
--- a/crates/hir_def/src/nameres/tests.rs
+++ b/crates/hir_def/src/nameres/tests.rs
@@ -713,3 +713,22 @@ pub fn f() {}
        "#]],
    );
 }
+#[test]
+fn use_crate_as() {
+    check(
+        r#"
+use crate as foo;
+use foo::bar as baz;
+fn bar() {}
+        "#,
+        expect![[r#"
+            crate
+            bar: v
+            baz: v
+            foo: t
+        "#]],
+    );
+}
diff --git a/crates/hir_def/src/nameres/tests/diagnostics.rs b/crates/hir_def/src/nameres/tests/diagnostics.rs
index c22ef46fd..a89061c2e 100644
--- a/crates/hir_def/src/nameres/tests/diagnostics.rs
+++ b/crates/hir_def/src/nameres/tests/diagnostics.rs
@@ -196,7 +196,24 @@ fn builtin_macro_fails_expansion() {
          macro_rules! include { () => {} }
          include!("doesntexist");
-        //^^^^^^^^^^^^^^^^^^^^^^^^ could not convert tokens
+        //^^^^^^^^^^^^^^^^^^^^^^^^ failed to load file `doesntexist`
+        "#,
+    );
+}
+#[test]
+fn good_out_dir_diagnostic() {
+    check_diagnostics(
+        r#"
+        #[rustc_builtin_macro]
+        macro_rules! include { () => {} }
+        #[rustc_builtin_macro]
+        macro_rules! env { () => {} }
+        #[rustc_builtin_macro]
+        macro_rules! concat { () => {} }
+        include!(concat!(env!("OUT_DIR"), "/out.rs"));
+      //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `OUT_DIR` not set, enable "load out dirs from check" to fix
        "#,
    );
 }
diff --git a/crates/hir_def/src/src.rs b/crates/hir_def/src/src.rs
index 751d4c052..24e57b469 100644
--- a/crates/hir_def/src/src.rs
+++ b/crates/hir_def/src/src.rs
@@ -14,12 +14,12 @@ impl<N: ItemTreeNode> HasSource for AssocItemLoc<N> {
    type Value = N::Source;
    fn source(&self, db: &dyn DefDatabase) -> InFile<N::Source> {
-        let tree = db.item_tree(self.id.file_id);
+        let tree = self.id.item_tree(db);
-        let ast_id_map = db.ast_id_map(self.id.file_id);
+        let ast_id_map = db.ast_id_map(self.id.file_id());
-        let root = db.parse_or_expand(self.id.file_id).unwrap();
+        let root = db.parse_or_expand(self.id.file_id()).unwrap();
        let node = &tree[self.id.value];
-        InFile::new(self.id.file_id, ast_id_map.get(node.ast_id()).to_node(&root))
+        InFile::new(self.id.file_id(), ast_id_map.get(node.ast_id()).to_node(&root))
    }
 }
@@ -27,12 +27,12 @@ impl<N: ItemTreeNode> HasSource for ItemLoc<N> {
    type Value = N::Source;
    fn source(&self, db: &dyn DefDatabase) -> InFile<N::Source> {
-        let tree = db.item_tree(self.id.file_id);
+        let tree = self.id.item_tree(db);
-        let ast_id_map = db.ast_id_map(self.id.file_id);
+        let ast_id_map = db.ast_id_map(self.id.file_id());
-        let root = db.parse_or_expand(self.id.file_id).unwrap();
+        let root = db.parse_or_expand(self.id.file_id()).unwrap();
        let node = &tree[self.id.value];
-        InFile::new(self.id.file_id, ast_id_map.get(node.ast_id()).to_node(&root))
+        InFile::new(self.id.file_id(), ast_id_map.get(node.ast_id()).to_node(&root))
    }
 }
diff --git a/crates/hir_expand/src/builtin_macro.rs b/crates/hir_expand/src/builtin_macro.rs
index 2a79c892b..fce09a9e7 100644
--- a/crates/hir_expand/src/builtin_macro.rs
+++ b/crates/hir_expand/src/builtin_macro.rs
@@ -333,17 +333,19 @@ fn concat_expand(
 fn relative_file(
    db: &dyn AstDatabase,
    call_id: MacroCallId,
-    path: &str,
+    path_str: &str,
    allow_recursion: bool,
-) -> Option<FileId> {
+) -> Result<FileId, mbe::ExpandError> {
    let call_site = call_id.as_file().original_file(db);
-    let path = AnchoredPath { anchor: call_site, path };
+    let path = AnchoredPath { anchor: call_site, path: path_str };
-    let res = db.resolve_path(path)?;
+    let res = db
+        .resolve_path(path)
+        .ok_or_else(|| mbe::ExpandError::Other(format!("failed to load file `{}`", path_str)))?;
    // Prevent include itself
    if res == call_site && !allow_recursion {
-        None
+        Err(mbe::ExpandError::Other(format!("recursive inclusion of `{}`", path_str)))
    } else {
-        Some(res)
+        Ok(res)
    }
 }
@@ -364,8 +366,7 @@ fn include_expand(
 ) -> ExpandResult<Option<(tt::Subtree, FragmentKind)>> {
    let res = (|| {
        let path = parse_string(tt)?;
-        let file_id = relative_file(db, arg_id.into(), &path, false)
+        let file_id = relative_file(db, arg_id.into(), &path, false)?;
-            .ok_or_else(|| mbe::ExpandError::ConversionError)?;
        Ok(parse_to_token_tree(&db.file_text(file_id))
            .ok_or_else(|| mbe::ExpandError::ConversionError)?
@@ -417,8 +418,8 @@ fn include_str_expand(
    // Ideally, we'd be able to offer a precise expansion if the user asks for macro
    // expansion.
    let file_id = match relative_file(db, arg_id.into(), &path, true) {
-        Some(file_id) => file_id,
+        Ok(file_id) => file_id,
-        None => {
+        Err(_) => {
            return ExpandResult::ok(Some((quote!(""), FragmentKind::Expr)));
        }
    };
diff --git a/crates/hir_ty/src/diagnostics/expr.rs b/crates/hir_ty/src/diagnostics/expr.rs
index 71b2cade0..3909ad354 100644
--- a/crates/hir_ty/src/diagnostics/expr.rs
+++ b/crates/hir_ty/src/diagnostics/expr.rs
@@ -690,4 +690,61 @@ fn main() {
 "#,
        )
    }
+    #[test]
+    fn cfgd_out_call_arguments() {
+        check_diagnostics(
+            r#"
+struct C(#[cfg(FALSE)] ());
+impl C {
+    fn new() -> Self {
+        Self(
+            #[cfg(FALSE)]
+            (),
+        )
+    }
+    fn method(&self) {}
+}
+fn main() {
+    C::new().method(#[cfg(FALSE)] 0);
+}
+            "#,
+        );
+    }
+    #[test]
+    fn cfgd_out_fn_params() {
+        check_diagnostics(
+            r#"
+fn foo(#[cfg(NEVER)] x: ()) {}
+struct S;
+impl S {
+    fn method(#[cfg(NEVER)] self) {}
+    fn method2(#[cfg(NEVER)] self, arg: u8) {}
+    fn method3(self, #[cfg(NEVER)] arg: u8) {}
+}
+extern "C" {
+    fn fixed(fixed: u8, #[cfg(NEVER)] ...);
+    fn varargs(#[cfg(not(NEVER))] ...);
+}
+fn main() {
+    foo();
+    S::method();
+    S::method2(0);
+    S::method3(S);
+    S.method3();
+    unsafe {
+        fixed(0);
+        varargs(1, 2, 3);
+    }
+}
+            "#,
+        )
+    }
 }
diff --git a/crates/hir_ty/src/tests/simple.rs b/crates/hir_ty/src/tests/simple.rs
index f5069eba5..bcc43ed70 100644
--- a/crates/hir_ty/src/tests/simple.rs
+++ b/crates/hir_ty/src/tests/simple.rs
@@ -2545,3 +2545,22 @@ fn test() {
        "#]],
    )
 }
+#[test]
+fn cfgd_out_assoc_items() {
+    check_types(
+        r#"
+struct S;
+impl S {
+    #[cfg(FALSE)]
+    const C: S = S;
+}
+fn f() {
+    S::C;
+  //^^^^ {unknown}
+}
+    "#,
+    )
+}
diff --git a/crates/hir_ty/src/tests/traits.rs b/crates/hir_ty/src/tests/traits.rs
index 93d3ad020..8270fa219 100644
--- a/crates/hir_ty/src/tests/traits.rs
+++ b/crates/hir_ty/src/tests/traits.rs
@@ -3253,3 +3253,24 @@ fn f() {
        "#,
    );
 }
+#[test]
+fn nested_inner_function_calling_self() {
+    check_infer(
+        r#"
+struct S;
+fn f() {
+    fn inner() -> S {
+        let s = inner();
+    }
+}
+        "#,
+        expect![[r#"
+            17..73 '{     ...   } }': ()
+            39..71 '{     ...     }': ()
+            53..54 's': S
+            57..62 'inner': fn inner() -> S
+            57..64 'inner()': S
+        "#]],
+    )
+}
diff --git a/crates/ide/src/doc_links.rs b/crates/ide/src/doc_links.rs
index 5ea9fc4fb..c7c1f4fee 100644
--- a/crates/ide/src/doc_links.rs
+++ b/crates/ide/src/doc_links.rs
@@ -65,6 +65,8 @@ pub(crate) fn extract_definitions_from_markdown(
 ) -> Vec<(String, Option<hir::Namespace>, Range<usize>)> {
    let mut res = vec![];
    let mut cb = |link: BrokenLink| {
+        // These allocations are actually unnecessary but the lifetimes on BrokenLinkCallback are wrong
+        // this is fixed in the repo but not on the crates.io release yet
        Some((
            /*url*/ link.reference.to_owned().into(),
            /*title*/ link.reference.to_owned().into(),
@@ -72,13 +74,10 @@ pub(crate) fn extract_definitions_from_markdown(
    };
    let doc = Parser::new_with_broken_link_callback(markdown, Options::empty(), Some(&mut cb));
    for (event, range) in doc.into_offset_iter() {
-        match event {
+        if let Event::Start(Tag::Link(_, target, title)) = event {
-            Event::Start(Tag::Link(_link_type, ref target, ref title)) => {
+            let link = if target.is_empty() { title } else { target };
-                let link = if target.is_empty() { title } else { target };
+            let (link, ns) = parse_link(&link);
-                let (link, ns) = parse_link(link);
+            res.push((link.to_string(), ns, range));
-                res.push((link.to_string(), ns, range));
-            }
-            _ => {}
        }
    }
    res
diff --git a/crates/ide/src/goto_definition.rs b/crates/ide/src/goto_definition.rs
index b71f4917c..598b47e41 100644
--- a/crates/ide/src/goto_definition.rs
+++ b/crates/ide/src/goto_definition.rs
@@ -1,3 +1,5 @@
+use std::ops::Range;
 use either::Either;
 use hir::{HasAttrs, ModuleDef, Semantics};
 use ide_db::{
@@ -5,7 +7,8 @@ use ide_db::{
    RootDatabase,
 };
 use syntax::{
-    ast, match_ast, AstNode, AstToken, SyntaxKind::*, SyntaxToken, TextSize, TokenAtOffset, T,
+    ast, match_ast, AstNode, AstToken, SyntaxKind::*, SyntaxToken, TextRange, TextSize,
+    TokenAtOffset, T,
 };
 use crate::{
@@ -92,17 +95,18 @@ fn extract_positioned_link_from_comment(
    position: FilePosition,
    comment: &ast::Comment,
 ) -> Option<(String, Option<hir::Namespace>)> {
-    let comment_range = comment.syntax().text_range();
    let doc_comment = comment.doc_comment()?;
+    let comment_start =
+        comment.syntax().text_range().start() + TextSize::from(comment.prefix().len() as u32);
    let def_links = extract_definitions_from_markdown(doc_comment);
-    let (def_link, ns, _) = def_links.iter().min_by_key(|(_, _, def_link_range)| {
+    let (def_link, ns, _) = def_links.into_iter().find(|&(_, _, Range { start, end })| {
-        let matched_position = comment_range.start() + TextSize::from(def_link_range.start as u32);
+        TextRange::at(
-        match position.offset.checked_sub(matched_position) {
+            comment_start + TextSize::from(start as u32),
-            Some(distance) => distance,
+            TextSize::from((end - start) as u32),
-            None => comment_range.end(),
+        )
-        }
+        .contains(position.offset)
    })?;
-    Some((def_link.to_string(), *ns))
+    Some((def_link, ns))
 }
 fn pick_best(tokens: TokenAtOffset<SyntaxToken>) -> Option<SyntaxToken> {
@@ -1136,7 +1140,7 @@ fn foo<'foo>(_: &'foo ()) {
    fn goto_def_for_intra_doc_link_same_file() {
        check(
            r#"
-/// Blah, [`bar`](bar) .. [`foo`](foo)$0 has [`bar`](bar)
+/// Blah, [`bar`](bar) .. [`foo`](foo$0) has [`bar`](bar)
 pub fn bar() { }
 /// You might want to see [`std::fs::read()`] too.
diff --git a/crates/ide/src/hover.rs b/crates/ide/src/hover.rs
index 325014622..15d309d7d 100644
--- a/crates/ide/src/hover.rs
+++ b/crates/ide/src/hover.rs
@@ -1533,12 +1533,21 @@ fn my() {}
    fn test_hover_struct_doc_comment() {
        check(
            r#"
-/// bar docs
+/// This is an example
+/// multiline doc
+///
+/// # Example
+///
+/// ```
+/// let five = 5;
+///
+/// assert_eq!(6, my_crate::add_one(5));
+/// ```
 struct Bar;
 fn foo() { let bar = Ba$0r; }
 "#,
-            expect![[r#"
+            expect![[r##"
                *Bar*
                ```rust
@@ -1551,8 +1560,17 @@ fn foo() { let bar = Ba$0r; }
                ---
-                bar docs
+                This is an example
-            "#]],
+                multiline doc
+                # Example
+                ```
+                let five = 5;
+                assert_eq!(6, my_crate::add_one(5));
+                ```
+            "##]],
        );
    }
@@ -3424,6 +3442,40 @@ mod Foo$0 {
    }
    #[test]
+    fn hover_doc_block_style_indentend() {
+        check(
+            r#"
+/**
+    foo
+    ```rust
+    let x = 3;
+    ```
+*/
+fn foo$0() {}
+"#,
+            expect![[r#"
+                *foo*
+                ```rust
+                test
+                ```
+                ```rust
+                fn foo()
+                ```
+                ---
+                foo
+                ```rust
+                let x = 3;
+                ```
+            "#]],
+        );
+    }
+    #[test]
    fn hover_comments_dont_highlight_parent() {
        check_hover_no_result(
            r#"
diff --git a/crates/ide/src/runnables.rs b/crates/ide/src/runnables.rs
index 397e2126b..bea020b06 100644
--- a/crates/ide/src/runnables.rs
+++ b/crates/ide/src/runnables.rs
@@ -576,6 +576,20 @@ fn should_have_runnable_1() {}
 /// ```
 fn should_have_runnable_2() {}
+/**
+```rust
+let z = 55;
+```
+*/
+fn should_have_no_runnable_3() {}
+/**
+    ```rust
+    let z = 55;
+    ```
+*/
+fn should_have_no_runnable_4() {}
 /// ```no_run
 /// let z = 55;
 /// ```
@@ -616,7 +630,7 @@ fn should_have_no_runnable_6() {}
 struct StructWithRunnable(String);
 "#,
-            &[&BIN, &DOCTEST, &DOCTEST, &DOCTEST, &DOCTEST],
+            &[&BIN, &DOCTEST, &DOCTEST, &DOCTEST, &DOCTEST, &DOCTEST, &DOCTEST],
            expect![[r#"
                [
                    Runnable {
@@ -682,7 +696,37 @@ struct StructWithRunnable(String);
                            file_id: FileId(
                                0,
                            ),
-                            full_range: 756..821,
+                            full_range: 256..320,
+                            name: "should_have_no_runnable_3",
+                        },
+                        kind: DocTest {
+                            test_id: Path(
+                                "should_have_no_runnable_3",
+                            ),
+                        },
+                        cfg: None,
+                    },
+                    Runnable {
+                        nav: NavigationTarget {
+                            file_id: FileId(
+                                0,
+                            ),
+                            full_range: 322..398,
+                            name: "should_have_no_runnable_4",
+                        },
+                        kind: DocTest {
+                            test_id: Path(
+                                "should_have_no_runnable_4",
+                            ),
+                        },
+                        cfg: None,
+                    },
+                    Runnable {
+                        nav: NavigationTarget {
+                            file_id: FileId(
+                                0,
+                            ),
+                            full_range: 900..965,
                            name: "StructWithRunnable",
                        },
                        kind: DocTest {
diff --git a/crates/ide/src/syntax_highlighting.rs b/crates/ide/src/syntax_highlighting.rs
index 870146d24..ba3447b3a 100644
--- a/crates/ide/src/syntax_highlighting.rs
+++ b/crates/ide/src/syntax_highlighting.rs
@@ -150,7 +150,7 @@ fn traverse(
            WalkEvent::Enter(it) => it,
            WalkEvent::Leave(it) => {
                if let Some(node) = it.as_node() {
-                    inject::doc_comment(hl, node);
+                    inject::doc_comment(hl, sema, node);
                }
                continue;
            }
diff --git a/crates/ide/src/syntax_highlighting/html.rs b/crates/ide/src/syntax_highlighting/html.rs
index 0ee7bc96e..1d34731ab 100644
--- a/crates/ide/src/syntax_highlighting/html.rs
+++ b/crates/ide/src/syntax_highlighting/html.rs
@@ -59,6 +59,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .label              { color: #DFAF8F; font-style: italic; }
 .comment            { color: #7F9F7F; }
 .documentation      { color: #629755; }
+.intra_doc_link     { color: #A9C577; }
 .injected           { opacity: 0.65 ; }
 .struct, .enum      { color: #7CB8BB; }
 .enum_variant       { color: #BDE0F3; }
diff --git a/crates/ide/src/syntax_highlighting/inject.rs b/crates/ide/src/syntax_highlighting/inject.rs
index 4f825523c..947cc974c 100644
--- a/crates/ide/src/syntax_highlighting/inject.rs
+++ b/crates/ide/src/syntax_highlighting/inject.rs
@@ -1,10 +1,18 @@
 //! "Recursive" Syntax highlighting for code in doctests and fixtures.
-use hir::Semantics;
+use std::{mem, ops::Range};
-use ide_db::call_info::ActiveParameter;
-use syntax::{ast, AstToken, SyntaxNode, SyntaxToken, TextRange, TextSize};
-use crate::{Analysis, HlMod, HlRange, HlTag, RootDatabase};
+use either::Either;
+use hir::{HasAttrs, Semantics};
+use ide_db::{call_info::ActiveParameter, defs::Definition};
+use syntax::{
+    ast::{self, AstNode, AttrsOwner, DocCommentsOwner},
+    match_ast, AstToken, NodeOrToken, SyntaxNode, SyntaxToken, TextRange, TextSize,
+};
+use crate::{
+    doc_links::extract_definitions_from_markdown, Analysis, HlMod, HlRange, HlTag, RootDatabase,
+};
 use super::{highlights::Highlights, injector::Injector};
@@ -81,70 +89,181 @@ const RUSTDOC_FENCE_TOKENS: &[&'static str] = &[
    "edition2021",
 ];
-/// Injection of syntax highlighting of doctests.
+// Basically an owned dyn AttrsOwner without extra Boxing
-pub(super) fn doc_comment(hl: &mut Highlights, node: &SyntaxNode) {
+struct AttrsOwnerNode {
-    let doc_comments = node
+    node: SyntaxNode,
-        .children_with_tokens()
+}
-        .filter_map(|it| it.into_token().and_then(ast::Comment::cast))
-        .filter(|it| it.kind().doc.is_some());
+impl AttrsOwnerNode {
+    fn new<N: DocCommentsOwner>(node: N) -> Self {
+        AttrsOwnerNode { node: node.syntax().clone() }
+    }
+}
+impl AttrsOwner for AttrsOwnerNode {}
+impl AstNode for AttrsOwnerNode {
+    fn can_cast(_: syntax::SyntaxKind) -> bool
+    where
+        Self: Sized,
+    {
+        false
+    }
+    fn cast(_: SyntaxNode) -> Option<Self>
+    where
+        Self: Sized,
+    {
+        None
+    }
+    fn syntax(&self) -> &SyntaxNode {
+        &self.node
+    }
+}
-    if !doc_comments.clone().any(|it| it.text().contains(RUSTDOC_FENCE)) {
+fn doc_attributes<'node>(
-        return;
+    sema: &Semantics<RootDatabase>,
+    node: &'node SyntaxNode,
+) -> Option<(AttrsOwnerNode, hir::Attrs, Definition)> {
+    match_ast! {
+        match node {
+            ast::SourceFile(it)  => sema.to_def(&it).map(|def| (AttrsOwnerNode::new(it), def.attrs(sema.db), Definition::ModuleDef(hir::ModuleDef::Module(def)))),
+            ast::Module(it)      => sema.to_def(&it).map(|def| (AttrsOwnerNode::new(it), def.attrs(sema.db), Definition::ModuleDef(hir::ModuleDef::Module(def)))),
+            ast::Fn(it)          => sema.to_def(&it).map(|def| (AttrsOwnerNode::new(it), def.attrs(sema.db), Definition::ModuleDef(hir::ModuleDef::Function(def)))),
+            ast::Struct(it)      => sema.to_def(&it).map(|def| (AttrsOwnerNode::new(it), def.attrs(sema.db), Definition::ModuleDef(hir::ModuleDef::Adt(hir::Adt::Struct(def))))),
+            ast::Union(it)       => sema.to_def(&it).map(|def| (AttrsOwnerNode::new(it), def.attrs(sema.db), Definition::ModuleDef(hir::ModuleDef::Adt(hir::Adt::Union(def))))),
+            ast::Enum(it)        => sema.to_def(&it).map(|def| (AttrsOwnerNode::new(it), def.attrs(sema.db), Definition::ModuleDef(hir::ModuleDef::Adt(hir::Adt::Enum(def))))),
+            ast::Variant(it)     => sema.to_def(&it).map(|def| (AttrsOwnerNode::new(it), def.attrs(sema.db), Definition::ModuleDef(hir::ModuleDef::Variant(def)))),
+            ast::Trait(it)       => sema.to_def(&it).map(|def| (AttrsOwnerNode::new(it), def.attrs(sema.db), Definition::ModuleDef(hir::ModuleDef::Trait(def)))),
+            ast::Static(it)      => sema.to_def(&it).map(|def| (AttrsOwnerNode::new(it), def.attrs(sema.db), Definition::ModuleDef(hir::ModuleDef::Static(def)))),
+            ast::Const(it)       => sema.to_def(&it).map(|def| (AttrsOwnerNode::new(it), def.attrs(sema.db), Definition::ModuleDef(hir::ModuleDef::Const(def)))),
+            ast::TypeAlias(it)   => sema.to_def(&it).map(|def| (AttrsOwnerNode::new(it), def.attrs(sema.db), Definition::ModuleDef(hir::ModuleDef::TypeAlias(def)))),
+            ast::Impl(it)        => sema.to_def(&it).map(|def| (AttrsOwnerNode::new(it), def.attrs(sema.db), Definition::SelfType(def))),
+            ast::RecordField(it) => sema.to_def(&it).map(|def| (AttrsOwnerNode::new(it), def.attrs(sema.db), Definition::Field(def))),
+            ast::TupleField(it)  => sema.to_def(&it).map(|def| (AttrsOwnerNode::new(it), def.attrs(sema.db), Definition::Field(def))),
+            ast::MacroRules(it)  => sema.to_def(&it).map(|def| (AttrsOwnerNode::new(it), def.attrs(sema.db), Definition::Macro(def))),
+            // ast::MacroDef(it) => sema.to_def(&it).map(|def| (Box::new(it) as _, def.attrs(sema.db))),
+            // ast::Use(it) => sema.to_def(&it).map(|def| (Box::new(it) as _, def.attrs(sema.db))),
+            _ => return None
+        }
    }
+}
+/// Injection of syntax highlighting of doctests.
+pub(super) fn doc_comment(hl: &mut Highlights, sema: &Semantics<RootDatabase>, node: &SyntaxNode) {
+    let (owner, attributes, def) = match doc_attributes(sema, node) {
+        Some(it) => it,
+        None => return,
+    };
    let mut inj = Injector::default();
    inj.add_unmapped("fn doctest() {\n");
+    let attrs_source_map = attributes.source_map(&owner);
    let mut is_codeblock = false;
    let mut is_doctest = false;
    // Replace the original, line-spanning comment ranges by new, only comment-prefix
    // spanning comment ranges.
    let mut new_comments = Vec::new();
-    for comment in doc_comments {
+    let mut intra_doc_links = Vec::new();
-        match comment.text().find(RUSTDOC_FENCE) {
+    let mut string;
-            Some(idx) => {
+    for attr in attributes.by_key("doc").attrs() {
-                is_codeblock = !is_codeblock;
+        let src = attrs_source_map.source_of(&attr);
-                // Check whether code is rust by inspecting fence guards
+        let (line, range, prefix) = match &src {
-                let guards = &comment.text()[idx + RUSTDOC_FENCE.len()..];
+            Either::Left(it) => {
-                let is_rust =
+                string = match find_doc_string_in_attr(attr, it) {
-                    guards.split(',').all(|sub| RUSTDOC_FENCE_TOKENS.contains(&sub.trim()));
+                    Some(it) => it,
-                is_doctest = is_codeblock && is_rust;
+                    None => continue,
-                continue;
+                };
+                let text_range = string.syntax().text_range();
+                let text_range = TextRange::new(
+                    text_range.start() + TextSize::from(1),
+                    text_range.end() - TextSize::from(1),
+                );
+                let text = string.text();
+                (&text[1..text.len() - 1], text_range, "")
            }
-            None if !is_doctest => continue,
+            Either::Right(comment) => {
-            None => (),
+                (comment.text(), comment.syntax().text_range(), comment.prefix())
-        }
+            }
+        };
-        let line: &str = comment.text();
+        let mut pos = TextSize::from(prefix.len() as u32);
-        let range = comment.syntax().text_range();
+        let mut range_start = range.start();
+        for line in line.split('\n') {
+            let line_len = TextSize::from(line.len() as u32);
+            let prev_range_start = {
+                let next_range_start = range_start + line_len + TextSize::from(1);
+                mem::replace(&mut range_start, next_range_start)
+            };
+            // only first line has the prefix so take it away for future iterations
+            let mut pos = mem::take(&mut pos);
-        let mut pos = TextSize::of(comment.prefix());
+            match line.find(RUSTDOC_FENCE) {
-        // whitespace after comment is ignored
+                Some(idx) => {
-        if let Some(ws) = line[pos.into()..].chars().next().filter(|c| c.is_whitespace()) {
+                    is_codeblock = !is_codeblock;
-            pos += TextSize::of(ws);
+                    // Check whether code is rust by inspecting fence guards
-        }
+                    let guards = &line[idx + RUSTDOC_FENCE.len()..];
-        // lines marked with `#` should be ignored in output, we skip the `#` char
+                    let is_rust =
-        if let Some(ws) = line[pos.into()..].chars().next().filter(|&c| c == '#') {
+                        guards.split(',').all(|sub| RUSTDOC_FENCE_TOKENS.contains(&sub.trim()));
-            pos += TextSize::of(ws);
+                    is_doctest = is_codeblock && is_rust;
+                    continue;
+                }
+                None if !is_doctest => {
+                    intra_doc_links.extend(
+                        extract_definitions_from_markdown(line)
+                            .into_iter()
+                            .filter(|(link, ns, _)| {
+                                validate_intra_doc_link(sema.db, &def, link, *ns)
+                            })
+                            .map(|(.., Range { start, end })| {
+                                TextRange::at(
+                                    prev_range_start + TextSize::from(start as u32),
+                                    TextSize::from((end - start) as u32),
+                                )
+                            }),
+                    );
+                    continue;
+                }
+                None => (),
+            }
+            // whitespace after comment is ignored
+            if let Some(ws) = line[pos.into()..].chars().next().filter(|c| c.is_whitespace()) {
+                pos += TextSize::of(ws);
+            }
+            // lines marked with `#` should be ignored in output, we skip the `#` char
+            if line[pos.into()..].starts_with('#') {
+                pos += TextSize::of('#');
+            }
+            new_comments.push(TextRange::at(prev_range_start, pos));
+            inj.add(&line[pos.into()..], TextRange::new(pos, line_len) + prev_range_start);
+            inj.add_unmapped("\n");
        }
+    }
-        new_comments.push(TextRange::at(range.start(), pos));
+    for range in intra_doc_links {
+        hl.add(HlRange {
+            range,
+            highlight: HlTag::IntraDocLink | HlMod::Documentation,
+            binding_hash: None,
+        });
+    }
-        inj.add(&line[pos.into()..], TextRange::new(range.start() + pos, range.end()));
+    if new_comments.is_empty() {
-        inj.add_unmapped("\n");
+        return; // no need to run an analysis on an empty file
    }
    inj.add_unmapped("\n}");
    let (analysis, tmp_file_id) = Analysis::from_single_file(inj.text().to_string());
-    for h in analysis.with_db(|db| super::highlight(db, tmp_file_id, None, true)).unwrap() {
+    for HlRange { range, highlight, binding_hash } in
-        for r in inj.map_range_up(h.range) {
+        analysis.with_db(|db| super::highlight(db, tmp_file_id, None, true)).unwrap()
-            hl.add(HlRange {
+    {
-                range: r,
+        for range in inj.map_range_up(range) {
-                highlight: h.highlight | HlMod::Injected,
+            hl.add(HlRange { range, highlight: highlight | HlMod::Injected, binding_hash });
-                binding_hash: h.binding_hash,
-            });
        }
    }
@@ -156,3 +275,55 @@ pub(super) fn doc_comment(hl: &mut Highlights, node: &SyntaxNode) {
        });
    }
 }
+fn find_doc_string_in_attr(attr: &hir::Attr, it: &ast::Attr) -> Option<ast::String> {
+    match it.literal() {
+        // #[doc = lit]
+        Some(lit) => match lit.kind() {
+            ast::LiteralKind::String(it) => Some(it),
+            _ => None,
+        },
+        // #[cfg_attr(..., doc = "", ...)]
+        None => {
+            // We gotta hunt the string token manually here
+            let text = attr.string_value()?;
+            // FIXME: We just pick the first string literal that has the same text as the doc attribute
+            // This means technically we might highlight the wrong one
+            it.syntax()
+                .descendants_with_tokens()
+                .filter_map(NodeOrToken::into_token)
+                .filter_map(ast::String::cast)
+                .find(|string| {
+                    string.text().get(1..string.text().len() - 1).map_or(false, |it| it == text)
+                })
+        }
+    }
+}
+fn validate_intra_doc_link(
+    db: &RootDatabase,
+    def: &Definition,
+    link: &str,
+    ns: Option<hir::Namespace>,
+) -> bool {
+    match def {
+        Definition::ModuleDef(def) => match def {
+            hir::ModuleDef::Module(it) => it.resolve_doc_path(db, &link, ns),
+            hir::ModuleDef::Function(it) => it.resolve_doc_path(db, &link, ns),
+            hir::ModuleDef::Adt(it) => it.resolve_doc_path(db, &link, ns),
+            hir::ModuleDef::Variant(it) => it.resolve_doc_path(db, &link, ns),
+            hir::ModuleDef::Const(it) => it.resolve_doc_path(db, &link, ns),
+            hir::ModuleDef::Static(it) => it.resolve_doc_path(db, &link, ns),
+            hir::ModuleDef::Trait(it) => it.resolve_doc_path(db, &link, ns),
+            hir::ModuleDef::TypeAlias(it) => it.resolve_doc_path(db, &link, ns),
+            hir::ModuleDef::BuiltinType(_) => None,
+        },
+        Definition::Macro(it) => it.resolve_doc_path(db, &link, ns),
+        Definition::Field(it) => it.resolve_doc_path(db, &link, ns),
+        Definition::SelfType(_)
+        | Definition::Local(_)
+        | Definition::GenericParam(_)
+        | Definition::Label(_) => None,
+    }
+    .is_some()
+}
diff --git a/crates/ide/src/syntax_highlighting/tags.rs b/crates/ide/src/syntax_highlighting/tags.rs
index 3c02fdb11..ce46e5127 100644
--- a/crates/ide/src/syntax_highlighting/tags.rs
+++ b/crates/ide/src/syntax_highlighting/tags.rs
@@ -18,19 +18,20 @@ pub struct HlMods(u32);
 pub enum HlTag {
    Symbol(SymbolKind),
+    Attribute,
    BoolLiteral,
    BuiltinType,
    ByteLiteral,
    CharLiteral,
-    NumericLiteral,
-    StringLiteral,
-    Attribute,
    Comment,
    EscapeSequence,
    FormatSpecifier,
+    IntraDocLink,
    Keyword,
-    Punctuation(HlPunct),
+    NumericLiteral,
    Operator,
+    Punctuation(HlPunct),
+    StringLiteral,
    UnresolvedReference,
    // For things which don't have a specific highlight.
@@ -116,6 +117,7 @@ impl HlTag {
            HlTag::Comment => "comment",
            HlTag::EscapeSequence => "escape_sequence",
            HlTag::FormatSpecifier => "format_specifier",
+            HlTag::IntraDocLink => "intra_doc_link",
            HlTag::Keyword => "keyword",
            HlTag::Punctuation(punct) => match punct {
                HlPunct::Bracket => "bracket",
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlight_assoc_functions.html b/crates/ide/src/syntax_highlighting/test_data/highlight_assoc_functions.html
index d421a7803..60c7518af 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlight_assoc_functions.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlight_assoc_functions.html
@@ -7,6 +7,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .label              { color: #DFAF8F; font-style: italic; }
 .comment            { color: #7F9F7F; }
 .documentation      { color: #629755; }
+.intra_doc_link     { color: #A9C577; }
 .injected           { opacity: 0.65 ; }
 .struct, .enum      { color: #7CB8BB; }
 .enum_variant       { color: #BDE0F3; }
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html b/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html
index 5e877df88..5d802a647 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html
@@ -7,6 +7,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .label              { color: #DFAF8F; font-style: italic; }
 .comment            { color: #7F9F7F; }
 .documentation      { color: #629755; }
+.intra_doc_link     { color: #A9C577; }
 .injected           { opacity: 0.65 ; }
 .struct, .enum      { color: #7CB8BB; }
 .enum_variant       { color: #BDE0F3; }
@@ -81,7 +82,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
    <span class="comment documentation">/// </span><span class="comment injected">       comment */</span>
    <span class="comment documentation">///</span>
    <span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="none injected"> </span><span class="variable declaration injected">multi_line_string</span><span class="none injected"> </span><span class="operator injected">=</span><span class="none injected"> </span><span class="string_literal injected">"Foo</span>
-    <span class="comment documentation">/// </span><span class="string_literal injected">  bar</span>
+    <span class="comment documentation">/// </span><span class="string_literal injected">  bar</span><span class="escape_sequence injected">\n</span>
    <span class="comment documentation">/// </span><span class="string_literal injected">         "</span><span class="semicolon injected">;</span>
    <span class="comment documentation">///</span>
    <span class="comment documentation">/// ```</span>
@@ -98,6 +99,11 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
    <span class="brace">}</span>
 <span class="brace">}</span>
+<span class="comment documentation">/// </span><span class="intra_doc_link documentation">[`Foo`](Foo)</span><span class="comment documentation"> is a struct</span>
+<span class="comment documentation">/// </span><span class="intra_doc_link documentation">[`all_the_links`](all_the_links)</span><span class="comment documentation"> is this function</span>
+<span class="comment documentation">/// [`noop`](noop) is a macro below</span>
+<span class="keyword">pub</span> <span class="keyword">fn</span> <span class="function declaration">all_the_links</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>
 <span class="comment documentation">/// ```</span>
 <span class="comment documentation">/// </span><span class="macro injected">noop!</span><span class="parenthesis injected">(</span><span class="numeric_literal injected">1</span><span class="parenthesis injected">)</span><span class="semicolon injected">;</span>
 <span class="comment documentation">/// ```</span>
@@ -105,4 +111,36 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
    <span class="parenthesis">(</span><span class="punctuation">$</span>expr<span class="colon">:</span>expr<span class="parenthesis">)</span> <span class="operator">=</span><span class="angle">&gt;</span> <span class="brace">{</span>
        <span class="punctuation">$</span>expr
    <span class="brace">}</span>
-<span class="brace">}</span></code></pre>
-\ No newline at end of file
+<span class="brace">}</span>
+<span class="comment documentation">/// ```rust</span>
+<span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="none injected"> </span><span class="punctuation injected">_</span><span class="none injected"> </span><span class="operator injected">=</span><span class="none injected"> </span><span class="function injected">example</span><span class="parenthesis injected">(</span><span class="operator injected">&</span><span class="bracket injected">[</span><span class="numeric_literal injected">1</span><span class="comma injected">,</span><span class="none injected"> </span><span class="numeric_literal injected">2</span><span class="comma injected">,</span><span class="none injected"> </span><span class="numeric_literal injected">3</span><span class="bracket injected">]</span><span class="parenthesis injected">)</span><span class="semicolon injected">;</span>
+<span class="comment documentation">/// ```</span>
+<span class="comment documentation">///</span>
+<span class="comment documentation">/// ```</span>
+<span class="comment documentation">/// </span><span class="keyword control injected">loop</span><span class="none injected"> </span><span class="brace injected">{</span><span class="brace injected">}</span>
+<span class="attribute attribute">#</span><span class="attribute attribute">[</span><span class="function attribute">cfg_attr</span><span class="parenthesis attribute">(</span><span class="attribute attribute">not</span><span class="parenthesis attribute">(</span><span class="attribute attribute">feature </span><span class="operator attribute">=</span><span class="attribute attribute"> </span><span class="string_literal attribute">"false"</span><span class="parenthesis attribute">)</span><span class="comma attribute">,</span><span class="attribute attribute"> doc </span><span class="operator attribute">=</span><span class="attribute attribute"> </span><span class="string_literal attribute">"</span><span class="keyword control injected">loop</span><span class="none injected"> </span><span class="brace injected">{</span><span class="brace injected">}</span><span class="string_literal attribute">"</span><span class="parenthesis attribute">)</span><span class="attribute attribute">]</span>
+<span class="attribute attribute">#</span><span class="attribute attribute">[</span><span class="function attribute">doc</span><span class="attribute attribute"> </span><span class="operator attribute">=</span><span class="attribute attribute"> </span><span class="string_literal attribute">"</span><span class="keyword control injected">loop</span><span class="none injected"> </span><span class="brace injected">{</span><span class="brace injected">}</span><span class="string_literal attribute">"</span><span class="attribute attribute">]</span>
+<span class="comment documentation">/// ```</span>
+<span class="comment documentation">///</span>
+<span class="attribute attribute">#</span><span class="attribute attribute">[</span><span class="function attribute">cfg_attr</span><span class="parenthesis attribute">(</span><span class="attribute attribute">feature </span><span class="operator attribute">=</span><span class="attribute attribute"> </span><span class="string_literal attribute">"alloc"</span><span class="comma attribute">,</span><span class="attribute attribute"> doc </span><span class="operator attribute">=</span><span class="attribute attribute"> </span><span class="string_literal attribute">"```rust"</span><span class="parenthesis attribute">)</span><span class="attribute attribute">]</span>
+<span class="attribute attribute">#</span><span class="attribute attribute">[</span><span class="function attribute">cfg_attr</span><span class="parenthesis attribute">(</span><span class="attribute attribute">not</span><span class="parenthesis attribute">(</span><span class="attribute attribute">feature </span><span class="operator attribute">=</span><span class="attribute attribute"> </span><span class="string_literal attribute">"alloc"</span><span class="parenthesis attribute">)</span><span class="comma attribute">,</span><span class="attribute attribute"> doc </span><span class="operator attribute">=</span><span class="attribute attribute"> </span><span class="string_literal attribute">"```ignore"</span><span class="parenthesis attribute">)</span><span class="attribute attribute">]</span>
+<span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="none injected"> </span><span class="punctuation injected">_</span><span class="none injected"> </span><span class="operator injected">=</span><span class="none injected"> </span><span class="function injected">example</span><span class="parenthesis injected">(</span><span class="operator injected">&</span><span class="none injected">alloc::</span><span class="macro injected">vec!</span><span class="bracket injected">[</span><span class="numeric_literal injected">1</span><span class="comma injected">,</span><span class="none injected"> </span><span class="numeric_literal injected">2</span><span class="comma injected">,</span><span class="none injected"> </span><span class="numeric_literal injected">3</span><span class="bracket injected">]</span><span class="parenthesis injected">)</span><span class="semicolon injected">;</span>
+<span class="comment documentation">/// ```</span>
+<span class="keyword">pub</span> <span class="keyword">fn</span> <span class="function declaration">mix_and_match</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>
+<span class="comment documentation">/**
+It is beyond me why you'd use these when you got ///
+```rust
+</span><span class="keyword injected">let</span><span class="none injected"> </span><span class="punctuation injected">_</span><span class="none injected"> </span><span class="operator injected">=</span><span class="none injected"> </span><span class="function injected">example</span><span class="parenthesis injected">(</span><span class="operator injected">&</span><span class="bracket injected">[</span><span class="numeric_literal injected">1</span><span class="comma injected">,</span><span class="none injected"> </span><span class="numeric_literal injected">2</span><span class="comma injected">,</span><span class="none injected"> </span><span class="numeric_literal injected">3</span><span class="bracket injected">]</span><span class="parenthesis injected">)</span><span class="semicolon injected">;</span><span class="comment documentation">
+```
+ */</span>
+<span class="keyword">pub</span> <span class="keyword">fn</span> <span class="function declaration">block_comments</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>
+<span class="comment documentation">/**
+    Really, I don't get it
+    ```rust
+</span><span class="comment documentation"> </span><span class="none injected">   </span><span class="keyword injected">let</span><span class="none injected"> </span><span class="punctuation injected">_</span><span class="none injected"> </span><span class="operator injected">=</span><span class="none injected"> </span><span class="function injected">example</span><span class="parenthesis injected">(</span><span class="operator injected">&</span><span class="bracket injected">[</span><span class="numeric_literal injected">1</span><span class="comma injected">,</span><span class="none injected"> </span><span class="numeric_literal injected">2</span><span class="comma injected">,</span><span class="none injected"> </span><span class="numeric_literal injected">3</span><span class="bracket injected">]</span><span class="parenthesis injected">)</span><span class="semicolon injected">;</span><span class="comment documentation">
+    ```
+*/</span>
+<span class="keyword">pub</span> <span class="keyword">fn</span> <span class="function declaration">block_comments2</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span></code></pre>
+\ No newline at end of file
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlight_extern_crate.html b/crates/ide/src/syntax_highlighting/test_data/highlight_extern_crate.html
index 6f7a7ffff..4e312765c 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlight_extern_crate.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlight_extern_crate.html
@@ -7,6 +7,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .label              { color: #DFAF8F; font-style: italic; }
 .comment            { color: #7F9F7F; }
 .documentation      { color: #629755; }
+.intra_doc_link     { color: #A9C577; }
 .injected           { opacity: 0.65 ; }
 .struct, .enum      { color: #7CB8BB; }
 .enum_variant       { color: #BDE0F3; }
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlight_injection.html b/crates/ide/src/syntax_highlighting/test_data/highlight_injection.html
index 753b535b5..57dfe7509 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlight_injection.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlight_injection.html
@@ -7,6 +7,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .label              { color: #DFAF8F; font-style: italic; }
 .comment            { color: #7F9F7F; }
 .documentation      { color: #629755; }
+.intra_doc_link     { color: #A9C577; }
 .injected           { opacity: 0.65 ; }
 .struct, .enum      { color: #7CB8BB; }
 .enum_variant       { color: #BDE0F3; }
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlight_strings.html b/crates/ide/src/syntax_highlighting/test_data/highlight_strings.html
index 66d80c4b6..75dbd0f14 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlight_strings.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlight_strings.html
@@ -7,6 +7,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .label              { color: #DFAF8F; font-style: italic; }
 .comment            { color: #7F9F7F; }
 .documentation      { color: #629755; }
+.intra_doc_link     { color: #A9C577; }
 .injected           { opacity: 0.65 ; }
 .struct, .enum      { color: #7CB8BB; }
 .enum_variant       { color: #BDE0F3; }
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlight_unsafe.html b/crates/ide/src/syntax_highlighting/test_data/highlight_unsafe.html
index 036cb6c11..423256a20 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlight_unsafe.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlight_unsafe.html
@@ -7,6 +7,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .label              { color: #DFAF8F; font-style: italic; }
 .comment            { color: #7F9F7F; }
 .documentation      { color: #629755; }
+.intra_doc_link     { color: #A9C577; }
 .injected           { opacity: 0.65 ; }
 .struct, .enum      { color: #7CB8BB; }
 .enum_variant       { color: #BDE0F3; }
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlighting.html b/crates/ide/src/syntax_highlighting/test_data/highlighting.html
index 2f983c0b8..fffe8c0f5 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlighting.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlighting.html
@@ -7,6 +7,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .label              { color: #DFAF8F; font-style: italic; }
 .comment            { color: #7F9F7F; }
 .documentation      { color: #629755; }
+.intra_doc_link     { color: #A9C577; }
 .injected           { opacity: 0.65 ; }
 .struct, .enum      { color: #7CB8BB; }
 .enum_variant       { color: #BDE0F3; }
diff --git a/crates/ide/src/syntax_highlighting/test_data/injection.html b/crates/ide/src/syntax_highlighting/test_data/injection.html
index 78dfec951..34d8deb68 100644
--- a/crates/ide/src/syntax_highlighting/test_data/injection.html
+++ b/crates/ide/src/syntax_highlighting/test_data/injection.html
@@ -7,6 +7,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .label              { color: #DFAF8F; font-style: italic; }
 .comment            { color: #7F9F7F; }
 .documentation      { color: #629755; }
+.intra_doc_link     { color: #A9C577; }
 .injected           { opacity: 0.65 ; }
 .struct, .enum      { color: #7CB8BB; }
 .enum_variant       { color: #BDE0F3; }
diff --git a/crates/ide/src/syntax_highlighting/test_data/rainbow_highlighting.html b/crates/ide/src/syntax_highlighting/test_data/rainbow_highlighting.html
index e64f2e5e9..d9ca3a4c4 100644
--- a/crates/ide/src/syntax_highlighting/test_data/rainbow_highlighting.html
+++ b/crates/ide/src/syntax_highlighting/test_data/rainbow_highlighting.html
@@ -7,6 +7,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .label              { color: #DFAF8F; font-style: italic; }
 .comment            { color: #7F9F7F; }
 .documentation      { color: #629755; }
+.intra_doc_link     { color: #A9C577; }
 .injected           { opacity: 0.65 ; }
 .struct, .enum      { color: #7CB8BB; }
 .enum_variant       { color: #BDE0F3; }
diff --git a/crates/ide/src/syntax_highlighting/tests.rs b/crates/ide/src/syntax_highlighting/tests.rs
index 9d0cd1af5..7b2922b0d 100644
--- a/crates/ide/src/syntax_highlighting/tests.rs
+++ b/crates/ide/src/syntax_highlighting/tests.rs
@@ -468,7 +468,7 @@ fn main() {
 }
 #[test]
-fn test_highlight_doctest() {
+fn test_highlight_doc_comment() {
    check_highlighting(
        r#"
 /// ```
@@ -516,7 +516,7 @@ impl Foo {
    ///        comment */
    ///
    /// let multi_line_string = "Foo
-    ///   bar
+    ///   bar\n
    ///          ";
    ///
    /// ```
@@ -533,6 +533,11 @@ impl Foo {
    }
 }
+/// [`Foo`](Foo) is a struct
+/// [`all_the_links`](all_the_links) is this function
+/// [`noop`](noop) is a macro below
+pub fn all_the_links() {}
 /// ```
 /// noop!(1);
 /// ```
@@ -541,6 +546,38 @@ macro_rules! noop {
        $expr
    }
 }
+/// ```rust
+/// let _ = example(&[1, 2, 3]);
+/// ```
+///
+/// ```
+/// loop {}
+#[cfg_attr(not(feature = "false"), doc = "loop {}")]
+#[doc = "loop {}"]
+/// ```
+///
+#[cfg_attr(feature = "alloc", doc = "```rust")]
+#[cfg_attr(not(feature = "alloc"), doc = "```ignore")]
+/// let _ = example(&alloc::vec![1, 2, 3]);
+/// ```
+pub fn mix_and_match() {}
+/**
+It is beyond me why you'd use these when you got ///
+```rust
+let _ = example(&[1, 2, 3]);
+```
+ */
+pub fn block_comments() {}
+/**
+    Really, I don't get it
+    ```rust
+    let _ = example(&[1, 2, 3]);
+    ```
+*/
+pub fn block_comments2() {}
 "#
        .trim(),
        expect_file!["./test_data/highlight_doctest.html"],
diff --git a/crates/ide_completion/src/lib.rs b/crates/ide_completion/src/lib.rs
index 5b7ad38d5..d9ea7b7ea 100644
--- a/crates/ide_completion/src/lib.rs
+++ b/crates/ide_completion/src/lib.rs
@@ -255,7 +255,7 @@ fn foo() {
    bar.fo$0;
 }
 "#,
-            DetailAndDocumentation { detail: "fn(&self)", documentation: " Do the foo" },
+            DetailAndDocumentation { detail: "fn(&self)", documentation: "Do the foo" },
        );
    }
diff --git a/crates/ide_db/src/apply_change.rs b/crates/ide_db/src/apply_change.rs
index 104ee113f..9b590d919 100644
--- a/crates/ide_db/src/apply_change.rs
+++ b/crates/ide_db/src/apply_change.rs
@@ -148,7 +148,7 @@ impl RootDatabase {
            hir::db::HygieneFrameQuery
            // DefDatabase
-            hir::db::ItemTreeQuery
+            hir::db::FileItemTreeQuery
            hir::db::BlockDefMapQuery
            hir::db::CrateDefMapQueryQuery
            hir::db::StructDataQuery
diff --git a/crates/ide_db/src/call_info.rs b/crates/ide_db/src/call_info.rs
index d4016973c..7e26c3ccf 100644
--- a/crates/ide_db/src/call_info.rs
+++ b/crates/ide_db/src/call_info.rs
@@ -53,15 +53,15 @@ pub fn call_info(db: &RootDatabase, position: FilePosition) -> Option<CallInfo>
    match callable.kind() {
        hir::CallableKind::Function(func) => {
-            res.doc = func.docs(db).map(|it| it.as_str().to_string());
+            res.doc = func.docs(db).map(|it| it.into());
            format_to!(res.signature, "fn {}", func.name(db));
        }
        hir::CallableKind::TupleStruct(strukt) => {
-            res.doc = strukt.docs(db).map(|it| it.as_str().to_string());
+            res.doc = strukt.docs(db).map(|it| it.into());
            format_to!(res.signature, "struct {}", strukt.name(db));
        }
        hir::CallableKind::TupleEnumVariant(variant) => {
-            res.doc = variant.docs(db).map(|it| it.as_str().to_string());
+            res.doc = variant.docs(db).map(|it| it.into());
            format_to!(
                res.signature,
                "enum {}::{}",
diff --git a/crates/ide_db/src/call_info/tests.rs b/crates/ide_db/src/call_info/tests.rs
index 9f84c253c..75ab3eb6e 100644
--- a/crates/ide_db/src/call_info/tests.rs
+++ b/crates/ide_db/src/call_info/tests.rs
@@ -220,11 +220,11 @@ fn bar() {
 }
 "#,
        expect![[r#"
-                test
+            test
-                ------
+            ------
-                fn foo(j: u32) -> u32
+            fn foo(j: u32) -> u32
-                (<j: u32>)
+            (<j: u32>)
-            "#]],
+        "#]],
    );
 }
@@ -249,19 +249,19 @@ pub fn do() {
    add_one($0
 }"#,
        expect![[r##"
-                Adds one to the number given.
+            Adds one to the number given.
-                # Examples
+            # Examples
-                ```
+            ```
-                let five = 5;
+            let five = 5;
-                assert_eq!(6, my_crate::add_one(5));
+            assert_eq!(6, my_crate::add_one(5));
-                ```
+            ```
-                ------
+            ------
-                fn add_one(x: i32) -> i32
+            fn add_one(x: i32) -> i32
-                (<x: i32>)
+            (<x: i32>)
-            "##]],
+        "##]],
    );
 }
@@ -291,19 +291,19 @@ pub fn do_it() {
 }
 "#,
        expect![[r##"
-                Adds one to the number given.
+            Adds one to the number given.
-                # Examples
+            # Examples
-                ```
+            ```
-                let five = 5;
+            let five = 5;
-                assert_eq!(6, my_crate::add_one(5));
+            assert_eq!(6, my_crate::add_one(5));
-                ```
+            ```
-                ------
+            ------
-                fn add_one(x: i32) -> i32
+            fn add_one(x: i32) -> i32
-                (<x: i32>)
+            (<x: i32>)
-            "##]],
+        "##]],
    );
 }
@@ -335,13 +335,13 @@ pub fn foo(mut r: WriteHandler<()>) {
 }
 "#,
        expect![[r#"
-                Method is called when writer finishes.
+            Method is called when writer finishes.
-                By default this method stops actor's `Context`.
+            By default this method stops actor's `Context`.
-                ------
+            ------
-                fn finished(&mut self, ctx: &mut {unknown})
+            fn finished(&mut self, ctx: &mut {unknown})
-                (<ctx: &mut {unknown}>)
+            (<ctx: &mut {unknown}>)
-            "#]],
+        "#]],
    );
 }
@@ -389,11 +389,11 @@ fn main() {
 }
 "#,
        expect![[r#"
-                A cool tuple struct
+            A cool tuple struct
-                ------
+            ------
-                struct S(u32, i32)
+            struct S(u32, i32)
-                (u32, <i32>)
+            (u32, <i32>)
-            "#]],
+        "#]],
    );
 }
@@ -431,11 +431,11 @@ fn main() {
 }
 "#,
        expect![[r#"
-                A Variant
+            A Variant
-                ------
+            ------
-                enum E::A(i32)
+            enum E::A(i32)
-                (<i32>)
+            (<i32>)
-            "#]],
+        "#]],
    );
 }
diff --git a/crates/mbe/src/tests.rs b/crates/mbe/src/tests.rs
index 25c374b9b..6da18ecf4 100644
--- a/crates/mbe/src/tests.rs
+++ b/crates/mbe/src/tests.rs
@@ -1,1775 +1,14 @@
+mod expand;
+mod rule;
 use std::fmt::Write;
 use ::parser::FragmentKind;
-use syntax::{
+use syntax::{ast, AstNode, NodeOrToken, SyntaxNode, WalkEvent};
-    ast, AstNode, NodeOrToken,
-    SyntaxKind::{ERROR, IDENT},
-    SyntaxNode, WalkEvent, T,
-};
 use test_utils::assert_eq_text;
 use super::*;
-mod rule_parsing {
-    use syntax::{ast, AstNode};
-    use crate::ast_to_token_tree;
-    use super::*;
-    #[test]
-    fn test_valid_arms() {
-        fn check(macro_body: &str) {
-            let m = parse_macro_arm(macro_body);
-            m.unwrap();
-        }
-        check("($i:ident) => ()");
-        check("($($i:ident)*) => ($_)");
-        check("($($true:ident)*) => ($true)");
-        check("($($false:ident)*) => ($false)");
-        check("($) => ($)");
-    }
-    #[test]
-    fn test_invalid_arms() {
-        fn check(macro_body: &str, err: ParseError) {
-            let m = parse_macro_arm(macro_body);
-            assert_eq!(m, Err(err));
-        }
-        check("invalid", ParseError::Expected("expected subtree".into()));
-        check("$i:ident => ()", ParseError::Expected("expected subtree".into()));
-        check("($i:ident) ()", ParseError::Expected("expected `=`".into()));
-        check("($($i:ident)_) => ()", ParseError::InvalidRepeat);
-        check("($i) => ($i)", ParseError::UnexpectedToken("bad fragment specifier 1".into()));
-        check("($i:) => ($i)", ParseError::UnexpectedToken("bad fragment specifier 1".into()));
-    }
-    fn parse_macro_arm(arm_definition: &str) -> Result<crate::MacroRules, ParseError> {
-        let macro_definition = format!(" macro_rules! m {{ {} }} ", arm_definition);
-        let source_file = ast::SourceFile::parse(&macro_definition).ok().unwrap();
-        let macro_definition =
-            source_file.syntax().descendants().find_map(ast::MacroRules::cast).unwrap();
-        let (definition_tt, _) =
-            ast_to_token_tree(&macro_definition.token_tree().unwrap()).unwrap();
-        crate::MacroRules::parse(&definition_tt)
-    }
-}
-// Good first issue (although a slightly challenging one):
-//
-// * Pick a random test from here
-//   https://github.com/intellij-rust/intellij-rust/blob/c4e9feee4ad46e7953b1948c112533360b6087bb/src/test/kotlin/org/rust/lang/core/macros/RsMacroExpansionTest.kt
-// * Port the test to rust and add it to this module
-// * Make it pass :-)
-#[test]
-fn test_token_id_shift() {
-    let expansion = parse_macro(
-        r#"
-macro_rules! foobar {
-    ($e:ident) => { foo bar $e }
-}
-"#,
-    )
-    .expand_tt("foobar!(baz);");
-    fn get_id(t: &tt::TokenTree) -> Option<u32> {
-        if let tt::TokenTree::Leaf(tt::Leaf::Ident(ident)) = t {
-            return Some(ident.id.0);
-        }
-        None
-    }
-    assert_eq!(expansion.token_trees.len(), 3);
-    // {($e:ident) => { foo bar $e }}
-    // 012345      67 8 9   T   12
-    assert_eq!(get_id(&expansion.token_trees[0]), Some(9));
-    assert_eq!(get_id(&expansion.token_trees[1]), Some(10));
-    // The input args of macro call include parentheses:
-    // (baz)
-    // So baz should be 12+1+1
-    assert_eq!(get_id(&expansion.token_trees[2]), Some(14));
-}
-#[test]
-fn test_token_map() {
-    let expanded = parse_macro(
-        r#"
-macro_rules! foobar {
-    ($e:ident) => { fn $e() {} }
-}
-"#,
-    )
-    .expand_tt("foobar!(baz);");
-    let (node, token_map) = token_tree_to_syntax_node(&expanded, FragmentKind::Items).unwrap();
-    let content = node.syntax_node().to_string();
-    let get_text = |id, kind| -> String {
-        content[token_map.range_by_token(id).unwrap().by_kind(kind).unwrap()].to_string()
-    };
-    assert_eq!(expanded.token_trees.len(), 4);
-    // {($e:ident) => { fn $e() {} }}
-    // 012345      67 8 9  T12  3
-    assert_eq!(get_text(tt::TokenId(9), IDENT), "fn");
-    assert_eq!(get_text(tt::TokenId(12), T!['(']), "(");
-    assert_eq!(get_text(tt::TokenId(13), T!['{']), "{");
-}
-#[test]
-fn test_convert_tt() {
-    parse_macro(r#"
-macro_rules! impl_froms {
-    ($e:ident: $($v:ident),*) => {
-        $(
-            impl From<$v> for $e {
-                fn from(it: $v) -> $e {
-                    $e::$v(it)
-                }
-            }
-        )*
-    }
-}
-"#)
-        .assert_expand_tt(
-            "impl_froms!(TokenTree: Leaf, Subtree);",
-            "impl From <Leaf > for TokenTree {fn from (it : Leaf) -> TokenTree {TokenTree ::Leaf (it)}} \
-             impl From <Subtree > for TokenTree {fn from (it : Subtree) -> TokenTree {TokenTree ::Subtree (it)}}"
-        );
-}
-#[test]
-fn test_convert_tt2() {
-    parse_macro(
-        r#"
-macro_rules! impl_froms {
-    ($e:ident: $($v:ident),*) => {
-        $(
-            impl From<$v> for $e {
-                fn from(it: $v) -> $e {
-                    $e::$v(it)
-                }
-            }
-        )*
-    }
-}
-"#,
-    )
-    .assert_expand(
-        "impl_froms!(TokenTree: Leaf, Subtree);",
-        r#"
-SUBTREE $
-  IDENT   impl 20
-  IDENT   From 21
-  PUNCH   < [joint] 22
-  IDENT   Leaf 53
-  PUNCH   > [alone] 25
-  IDENT   for 26
-  IDENT   TokenTree 51
-  SUBTREE {} 29
-    IDENT   fn 30
-    IDENT   from 31
-    SUBTREE () 32
-      IDENT   it 33
-      PUNCH   : [alone] 34
-      IDENT   Leaf 53
-    PUNCH   - [joint] 37
-    PUNCH   > [alone] 38
-    IDENT   TokenTree 51
-    SUBTREE {} 41
-      IDENT   TokenTree 51
-      PUNCH   : [joint] 44
-      PUNCH   : [joint] 45
-      IDENT   Leaf 53
-      SUBTREE () 48
-        IDENT   it 49
-  IDENT   impl 20
-  IDENT   From 21
-  PUNCH   < [joint] 22
-  IDENT   Subtree 55
-  PUNCH   > [alone] 25
-  IDENT   for 26
-  IDENT   TokenTree 51
-  SUBTREE {} 29
-    IDENT   fn 30
-    IDENT   from 31
-    SUBTREE () 32
-      IDENT   it 33
-      PUNCH   : [alone] 34
-      IDENT   Subtree 55
-    PUNCH   - [joint] 37
-    PUNCH   > [alone] 38
-    IDENT   TokenTree 51
-    SUBTREE {} 41
-      IDENT   TokenTree 51
-      PUNCH   : [joint] 44
-      PUNCH   : [joint] 45
-      IDENT   Subtree 55
-      SUBTREE () 48
-        IDENT   it 49
-"#,
-    );
-}
-#[test]
-fn test_lifetime_split() {
-    parse_macro(
-        r#"
-macro_rules! foo {
-    ($($t:tt)*) => { $($t)*}
-}
-"#,
-    )
-    .assert_expand(
-        r#"foo!(static bar: &'static str = "hello";);"#,
-        r#"
-SUBTREE $
-  IDENT   static 17
-  IDENT   bar 18
-  PUNCH   : [alone] 19
-  PUNCH   & [alone] 20
-  PUNCH   ' [joint] 21
-  IDENT   static 22
-  IDENT   str 23
-  PUNCH   = [alone] 24
-  LITERAL "hello" 25
-  PUNCH   ; [joint] 26
-"#,
-    );
-}
-#[test]
-fn test_expr_order() {
-    let expanded = parse_macro(
-        r#"
-        macro_rules! foo {
-            ($ i:expr) => {
-                 fn bar() { $ i * 2; }
-            }
-        }
-"#,
-    )
-    .expand_items("foo! { 1 + 1}");
-    let dump = format!("{:#?}", expanded);
-    assert_eq_text!(
-        r#"[email protected]
-  [email protected]
-    [email protected] "fn"
-    [email protected]
-      [email protected] "bar"
-    [email protected]
-      [email protected] "("
-      [email protected] ")"
-    [email protected]
-      [email protected] "{"
-      [email protected]
-        [email protected]
-          [email protected]
-            [email protected]
-              [email protected] "1"
-            [email protected] "+"
-            [email protected]
-              [email protected] "1"
-          [email protected] "*"
-          [email protected]
-            [email protected] "2"
-        [email protected] ";"
-      [email protected] "}""#,
-        dump.trim()
-    );
-}
-#[test]
-fn test_fail_match_pattern_by_first_token() {
-    parse_macro(
-        r#"
-        macro_rules! foo {
-            ($ i:ident) => (
-                mod $ i {}
-            );
-            (= $ i:ident) => (
-                fn $ i() {}
-            );
-            (+ $ i:ident) => (
-                struct $ i;
-            )
-        }
-"#,
-    )
-    .assert_expand_items("foo! { foo }", "mod foo {}")
-    .assert_expand_items("foo! { = bar }", "fn bar () {}")
-    .assert_expand_items("foo! { + Baz }", "struct Baz ;");
-}
-#[test]
-fn test_fail_match_pattern_by_last_token() {
-    parse_macro(
-        r#"
-        macro_rules! foo {
-            ($ i:ident) => (
-                mod $ i {}
-            );
-            ($ i:ident =) => (
-                fn $ i() {}
-            );
-            ($ i:ident +) => (
-                struct $ i;
-            )
-        }
-"#,
-    )
-    .assert_expand_items("foo! { foo }", "mod foo {}")
-    .assert_expand_items("foo! { bar = }", "fn bar () {}")
-    .assert_expand_items("foo! { Baz + }", "struct Baz ;");
-}
-#[test]
-fn test_fail_match_pattern_by_word_token() {
-    parse_macro(
-        r#"
-        macro_rules! foo {
-            ($ i:ident) => (
-                mod $ i {}
-            );
-            (spam $ i:ident) => (
-                fn $ i() {}
-            );
-            (eggs $ i:ident) => (
-                struct $ i;
-            )
-        }
-"#,
-    )
-    .assert_expand_items("foo! { foo }", "mod foo {}")
-    .assert_expand_items("foo! { spam bar }", "fn bar () {}")
-    .assert_expand_items("foo! { eggs Baz }", "struct Baz ;");
-}
-#[test]
-fn test_match_group_pattern_by_separator_token() {
-    parse_macro(
-        r#"
-        macro_rules! foo {
-            ($ ($ i:ident),*) => ($ (
-                mod $ i {}
-            )*);
-            ($ ($ i:ident)#*) => ($ (
-                fn $ i() {}
-            )*);
-            ($ i:ident ,# $ j:ident) => (
-                struct $ i;
-                struct $ j;
-            )
-        }
-"#,
-    )
-    .assert_expand_items("foo! { foo, bar }", "mod foo {} mod bar {}")
-    .assert_expand_items("foo! { foo# bar }", "fn foo () {} fn bar () {}")
-    .assert_expand_items("foo! { Foo,# Bar }", "struct Foo ; struct Bar ;");
-}
-#[test]
-fn test_match_group_pattern_with_multiple_defs() {
-    parse_macro(
-        r#"
-        macro_rules! foo {
-            ($ ($ i:ident),*) => ( struct Bar { $ (
-                fn $ i {}
-            )*} );
-        }
-"#,
-    )
-    .assert_expand_items("foo! { foo, bar }", "struct Bar {fn foo {} fn bar {}}");
-}
-#[test]
-fn test_match_group_pattern_with_multiple_statement() {
-    parse_macro(
-        r#"
-        macro_rules! foo {
-            ($ ($ i:ident),*) => ( fn baz { $ (
-                $ i ();
-            )*} );
-        }
-"#,
-    )
-    .assert_expand_items("foo! { foo, bar }", "fn baz {foo () ; bar () ;}");
-}
-#[test]
-fn test_match_group_pattern_with_multiple_statement_without_semi() {
-    parse_macro(
-        r#"
-        macro_rules! foo {
-            ($ ($ i:ident),*) => ( fn baz { $ (
-                $i()
-            );*} );
-        }
-"#,
-    )
-    .assert_expand_items("foo! { foo, bar }", "fn baz {foo () ;bar ()}");
-}
-#[test]
-fn test_match_group_empty_fixed_token() {
-    parse_macro(
-        r#"
-        macro_rules! foo {
-            ($ ($ i:ident)* #abc) => ( fn baz { $ (
-                $ i ();
-            )*} );
-        }
-"#,
-    )
-    .assert_expand_items("foo! {#abc}", "fn baz {}");
-}
-#[test]
-fn test_match_group_in_subtree() {
-    parse_macro(
-        r#"
-        macro_rules! foo {
-            (fn $name:ident {$($i:ident)*} ) => ( fn $name() { $ (
-                $ i ();
-            )*} );
-        }"#,
-    )
-    .assert_expand_items("foo! {fn baz {a b} }", "fn baz () {a () ; b () ;}");
-}
-#[test]
-fn test_match_group_with_multichar_sep() {
-    parse_macro(
-        r#"
-        macro_rules! foo {
-            (fn $name:ident {$($i:literal)*} ) => ( fn $name() -> bool { $($i)&&*} );
-        }"#,
-    )
-    .assert_expand_items("foo! (fn baz {true true} );", "fn baz () -> bool {true &&true}");
-}
-#[test]
-fn test_match_group_with_multichar_sep2() {
-    parse_macro(
-        r#"
-        macro_rules! foo {
-            (fn $name:ident {$($i:literal)&&*} ) => ( fn $name() -> bool { $($i)&&*} );
-        }"#,
-    )
-    .assert_expand_items("foo! (fn baz {true && true} );", "fn baz () -> bool {true &&true}");
-}
-#[test]
-fn test_match_group_zero_match() {
-    parse_macro(
-        r#"
-        macro_rules! foo {
-            ( $($i:ident)* ) => ();
-        }"#,
-    )
-    .assert_expand_items("foo! ();", "");
-}
-#[test]
-fn test_match_group_in_group() {
-    parse_macro(
-        r#"
-        macro_rules! foo {
-            { $( ( $($i:ident)* ) )* } => ( $( ( $($i)* ) )* );
-        }"#,
-    )
-    .assert_expand_items("foo! ( (a b) );", "(a b)");
-}
-#[test]
-fn test_expand_to_item_list() {
-    let tree = parse_macro(
-        "
-            macro_rules! structs {
-                ($($i:ident),*) => {
-                    $(struct $i { field: u32 } )*
-                }
-            }
-            ",
-    )
-    .expand_items("structs!(Foo, Bar);");
-    assert_eq!(
-        format!("{:#?}", tree).trim(),
-        r#"
-[email protected]
-  [email protected]
-    [email protected] "struct"
-    [email protected]
-      [email protected] "Foo"
-    [email protected]
-      [email protected] "{"
-      [email protected]
-        [email protected]
-          [email protected] "field"
-        [email protected] ":"
-        [email protected]
-          [email protected]
-            [email protected]
-              [email protected]
-                [email protected] "u32"
-      [email protected] "}"
-  [email protected]
-    [email protected] "struct"
-    [email protected]
-      [email protected] "Bar"
-    [email protected]
-      [email protected] "{"
-      [email protected]
-        [email protected]
-          [email protected] "field"
-        [email protected] ":"
-        [email protected]
-          [email protected]
-            [email protected]
-              [email protected]
-                [email protected] "u32"
-      [email protected] "}""#
-            .trim()
-    );
-}
-fn to_subtree(tt: &tt::TokenTree) -> &tt::Subtree {
-    if let tt::TokenTree::Subtree(subtree) = tt {
-        return &subtree;
-    }
-    unreachable!("It is not a subtree");
-}
-fn to_literal(tt: &tt::TokenTree) -> &tt::Literal {
-    if let tt::TokenTree::Leaf(tt::Leaf::Literal(lit)) = tt {
-        return lit;
-    }
-    unreachable!("It is not a literal");
-}
-fn to_punct(tt: &tt::TokenTree) -> &tt::Punct {
-    if let tt::TokenTree::Leaf(tt::Leaf::Punct(lit)) = tt {
-        return lit;
-    }
-    unreachable!("It is not a Punct");
-}
-#[test]
-fn test_expand_literals_to_token_tree() {
-    let expansion = parse_macro(
-        r#"
-            macro_rules! literals {
-                ($i:ident) => {
-                    {
-                        let a = 'c';
-                        let c = 1000;
-                        let f = 12E+99_f64;
-                        let s = "rust1";
-                    }
-                }
-            }
-            "#,
-    )
-    .expand_tt("literals!(foo);");
-    let stm_tokens = &to_subtree(&expansion.token_trees[0]).token_trees;
-    // [let] [a] [=] ['c'] [;]
-    assert_eq!(to_literal(&stm_tokens[3]).text, "'c'");
-    // [let] [c] [=] [1000] [;]
-    assert_eq!(to_literal(&stm_tokens[5 + 3]).text, "1000");
-    // [let] [f] [=] [12E+99_f64] [;]
-    assert_eq!(to_literal(&stm_tokens[10 + 3]).text, "12E+99_f64");
-    // [let] [s] [=] ["rust1"] [;]
-    assert_eq!(to_literal(&stm_tokens[15 + 3]).text, "\"rust1\"");
-}
-#[test]
-fn test_attr_to_token_tree() {
-    let expansion = parse_to_token_tree_by_syntax(
-        r#"
-            #[derive(Copy)]
-            struct Foo;
-            "#,
-    );
-    assert_eq!(to_punct(&expansion.token_trees[0]).char, '#');
-    assert_eq!(
-        to_subtree(&expansion.token_trees[1]).delimiter_kind(),
-        Some(tt::DelimiterKind::Bracket)
-    );
-}
-#[test]
-fn test_two_idents() {
-    parse_macro(
-        r#"
-        macro_rules! foo {
-            ($ i:ident, $ j:ident) => {
-                fn foo() { let a = $ i; let b = $j; }
-            }
-        }
-"#,
-    )
-    .assert_expand_items("foo! { foo, bar }", "fn foo () {let a = foo ; let b = bar ;}");
-}
-#[test]
-fn test_tt_to_stmts() {
-    let stmts = parse_macro(
-        r#"
-        macro_rules! foo {
-            () => {
-                 let a = 0;
-                 a = 10 + 1;
-                 a
-            }
-        }
-"#,
-    )
-    .expand_statements("foo!{}");
-    assert_eq!(
-        format!("{:#?}", stmts).trim(),
-        r#"[email protected]
-  [email protected]
-    [email protected] "let"
-    [email protected]
-      [email protected]
-        [email protected] "a"
-    [email protected] "="
-    [email protected]
-      [email protected] "0"
-    [email protected] ";"
-  [email protected]
-    [email protected]
-      [email protected]
-        [email protected]
-          [email protected]
-            [email protected]
-              [email protected] "a"
-      [email protected] "="
-      [email protected]