14 files changed, 327 insertions, 157 deletions

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 {
-        let attrs: Vec<_> = collect_attrs(owner).collect();
-        let entries = if attrs.is_empty() {
-            // Avoid heap allocation
-            None
-        } else {
-            Some(
-                attrs
-                    .into_iter()
-                    .enumerate()
-                    .flat_map(|(i, attr)| match attr {
-                        Either::Left(attr) => Attr::from_src(attr, hygiene).map(|attr| (i, attr)),
-                        Either::Right(comment) => comment.doc_comment().map(|doc| {
-                            (
-                                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 }
+    pub(crate) fn new(owner: &dyn ast::AttrsOwner, hygiene: &Hygiene) -> Self {
+        let entries = collect_attrs(owner)
+            .enumerate()
+            .flat_map(|(i, attr)| match attr {
+                Either::Left(attr) => Attr::from_src(attr, hygiene, i as u32),
+                Either::Right(comment) => comment.doc_comment().map(|doc| Attr {
+                    index: i as u32,
+                    input: Some(AttrInput::Literal(SmolStr::new(doc))),
+                    path: ModPath::from(hir_expand::name!(doc)),
+                }),
+            })
+            .collect::<Arc<_>>();
+
+        Self { entries: if entries.is_empty() { None } else { Some(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
-                    Attr::from_src(attr, &hygiene)
+                    // FIXME 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::Module(module) => module as &dyn AttrsOwner,
-                            ModuleSource::BlockExpr(block) => block as &dyn AttrsOwner,
+                            ModuleSource::SourceFile(file) => file as &dyn ast::AttrsOwner,
+                            ModuleSource::Module(module) => module as &dyn ast::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
-        // libstd api gets stabilized (https://github.com/rust-lang/rust/issues/79524).
-        let docs = Itertools::intersperse(docs, &SmolStr::new_inline("\n"))
-            .map(|it| it.as_str())
-            .collect::<String>();
-        if docs.is_empty() {
+        let indent = docs
+            .clone()
+            .flat_map(|s| s.lines())
+            .filter(|line| !line.chars().all(|c| c.is_whitespace()))
+            .map(|line| line.chars().take_while(|c| c.is_whitespace()).count())
+            .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() {
-            return self.missing_expr();
-        }
+        self.check_cfg(&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
-                                .alloc_expr(Expr::Match { expr: match_expr, arms }, syntax_ptr);
+                            return Some(
+                                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
-                                .alloc_expr(Expr::Loop { body: match_expr, label }, syntax_ptr);
+                            return Some(
+                                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 cfg_options = db.crate_graph()[module.krate].cfg_options.clone();
+    let item_tree = db.file_item_tree(file_id);
+    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)]
-    fn item_tree(&self, file_id: HirFileId) -> Arc<ItemTree>;
+    #[salsa::invoke(ItemTree::file_item_tree_query)]
+    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 7bb22c4c4..5f5b7151a 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 {
@@ -134,6 +134,7 @@ impl ItemTree {
                 imports,
                 extern_crates,
                 functions,
+                params,
                 structs,
                 fields,
                 unions,
@@ -157,6 +158,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();
@@ -303,6 +305,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>,
@@ -334,6 +337,7 @@ pub enum AttrOwner {
 
     Variant(Idx<Variant>),
     Field(Idx<Field>),
+    Param(Idx<Param>),
 }
 
 macro_rules! from_attrs {
@@ -348,7 +352,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 {
@@ -397,7 +401,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 ),+ $(,)? ) => {
@@ -484,7 +528,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;
@@ -560,12 +604,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 is_varargs: bool,
+    pub params: IdRange<Param>,
     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,
@@ -796,6 +845,7 @@ pub struct Variant {
     pub fields: Fields,
 }
 
+/// A range of densely allocated ItemTree IDs.
 pub struct IdRange<T> {
     range: Range<u32>,
     _p: PhantomData<T>,
@@ -814,6 +864,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 7e91b991d..3f558edd8 100644
--- a/crates/hir_def/src/item_tree/lower.rs
+++ b/crates/hir_def/src/item_tree/lower.rs
@@ -333,8 +333,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() {
@@ -356,22 +356,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());
-                params.push(type_ref);
-            }
-        }
-        let params = params.into_iter().map(|param| self.data().type_refs.intern(param)).collect();
-
-        let mut is_varargs = false;
-        if let Some(params) = func.param_list() {
-            if let Some(last) = params.params().last() {
-                is_varargs = last.dotdotdot_token().is_some();
+                let idx = match param.dotdotdot_token() {
+                    Some(_) => self.data().params.alloc(Param::Varargs),
+                    None => {
+                        let type_ref = TypeRef::from_ast_opt(&self.body_ctx, param.ty());
+                        let ty = self.data().type_refs.intern(type_ref);
+                        self.data().params.alloc(Param::Normal(ty))
+                    }
+                };
+                self.add_attrs(idx.into(), RawAttrs::new(&param, &self.hygiene));
             }
         }
+        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),
@@ -419,7 +422,6 @@ impl Ctx {
             qualifier,
             is_in_extern_block: false,
             params,
-            is_varargs,
             ret_type,
             ast_id,
         };
@@ -682,9 +684,11 @@ impl Ctx {
             GenericsOwner::Function(func) => {
                 generics.fill(&self.body_ctx, sm, node);
                 // lower `impl Trait` in arguments
-                for param in &*func.params {
-                    let param = self.data().type_refs.lookup(*param);
-                    generics.fill_implicit_impl_trait_args(param);
+                for id in func.params.clone() {
+                    if let Param::Normal(ty) = self.data().params[id] {
+                        let ty = self.data().type_refs.lookup(ty);
+                        generics.fill_implicit_impl_trait_args(ty);
+                    }
                 }
             }
             GenericsOwner::Struct
@@ -769,6 +773,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() {
-                Some(last_segment) => {
-                    let name = match &import.alias {
-                        Some(ImportAlias::Alias(name)) => Some(name.clone()),
-                        Some(ImportAlias::Underscore) => None,
-                        None => Some(last_segment.clone()),
-                    };
-                    log::debug!("resolved import {:?} ({:?}) to {:?}", name, import, def);
-
-                    // 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);
-                        }
+            let name = match &import.alias {
+                Some(ImportAlias::Alias(name)) => Some(name.clone()),
+                Some(ImportAlias::Underscore) => None,
+                None => match import.path.segments().last() {
+                    Some(last_segment) => Some(last_segment.clone()),
+                    None => {
+                        cov_mark::hit!(bogus_paths);
+                        return;
                     }
+                },
+            };
+
+            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 ast_id_map = db.ast_id_map(self.id.file_id);
-        let root = db.parse_or_expand(self.id.file_id).unwrap();
+        let tree = self.id.item_tree(db);
+        let ast_id_map = db.ast_id_map(self.id.file_id());
+        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 ast_id_map = db.ast_id_map(self.id.file_id);
-        let root = db.parse_or_expand(self.id.file_id).unwrap();
+        let tree = self.id.item_tree(db);
+        let ast_id_map = db.ast_id_map(self.id.file_id());
+        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))
     }
 }