2 files changed, 1147 insertions, 0 deletions

diff --git a/crates/ra_hir_def/src/item_tree/lower.rs b/crates/ra_hir_def/src/item_tree/lower.rs
new file mode 100644
index 000000000..f79b8fca3
--- /dev/null
+++ b/crates/ra_hir_def/src/item_tree/lower.rs
@@ -0,0 +1,708 @@
+//! AST -> `ItemTree` lowering code.
+
+use super::*;
+use crate::{
+    attr::Attrs,
+    generics::{GenericParams, TypeParamData, TypeParamProvenance},
+};
+use hir_expand::{ast_id_map::AstIdMap, hygiene::Hygiene, HirFileId};
+use ra_arena::map::ArenaMap;
+use ra_syntax::{
+    ast::{self, ModuleItemOwner},
+    SyntaxNode,
+};
+use smallvec::SmallVec;
+use std::{collections::hash_map::Entry, mem, sync::Arc};
+
+fn id<N: ItemTreeNode>(index: Idx<N>) -> FileItemTreeId<N> {
+    FileItemTreeId { index, _p: PhantomData }
+}
+
+struct ModItems(SmallVec<[ModItem; 1]>);
+
+impl<T> From<T> for ModItems
+where
+    T: Into<ModItem>,
+{
+    fn from(t: T) -> Self {
+        ModItems(SmallVec::from_buf([t.into(); 1]))
+    }
+}
+
+pub(super) struct Ctx {
+    tree: ItemTree,
+    hygiene: Hygiene,
+    file: HirFileId,
+    source_ast_id_map: Arc<AstIdMap>,
+    body_ctx: crate::body::LowerCtx,
+    inner_items: Vec<ModItem>,
+    forced_visibility: Option<RawVisibilityId>,
+}
+
+impl Ctx {
+    pub(super) fn new(db: &dyn DefDatabase, hygiene: Hygiene, file: HirFileId) -> Self {
+        Self {
+            tree: ItemTree::empty(),
+            hygiene,
+            file,
+            source_ast_id_map: db.ast_id_map(file),
+            body_ctx: crate::body::LowerCtx::new(db, file),
+            inner_items: Vec::new(),
+            forced_visibility: None,
+        }
+    }
+
+    pub(super) fn lower_module_items(mut self, item_owner: &dyn ModuleItemOwner) -> ItemTree {
+        self.tree.top_level = item_owner
+            .items()
+            .flat_map(|item| self.lower_mod_item(&item, false))
+            .flat_map(|items| items.0)
+            .collect();
+        self.tree
+    }
+
+    pub(super) fn lower_inner_items(mut self, within: &SyntaxNode) -> ItemTree {
+        self.collect_inner_items(within);
+        self.tree
+    }
+
+    fn data(&mut self) -> &mut ItemTreeData {
+        self.tree.data_mut()
+    }
+
+    fn lower_mod_item(&mut self, item: &ast::ModuleItem, inner: bool) -> Option<ModItems> {
+        assert!(inner || self.inner_items.is_empty());
+
+        // Collect inner items for 1-to-1-lowered items.
+        match item {
+            ast::ModuleItem::StructDef(_)
+            | ast::ModuleItem::UnionDef(_)
+            | ast::ModuleItem::EnumDef(_)
+            | ast::ModuleItem::FnDef(_)
+            | ast::ModuleItem::TypeAliasDef(_)
+            | ast::ModuleItem::ConstDef(_)
+            | ast::ModuleItem::StaticDef(_)
+            | ast::ModuleItem::MacroCall(_) => {
+                // Skip this if we're already collecting inner items. We'll descend into all nodes
+                // already.
+                if !inner {
+                    self.collect_inner_items(item.syntax());
+                }
+            }
+
+            // These are handled in their respective `lower_X` method (since we can't just blindly
+            // walk them).
+            ast::ModuleItem::TraitDef(_)
+            | ast::ModuleItem::ImplDef(_)
+            | ast::ModuleItem::ExternBlock(_) => {}
+
+            // These don't have inner items.
+            ast::ModuleItem::Module(_)
+            | ast::ModuleItem::ExternCrateItem(_)
+            | ast::ModuleItem::UseItem(_) => {}
+        };
+
+        let attrs = Attrs::new(item, &self.hygiene);
+        let items = match item {
+            ast::ModuleItem::StructDef(ast) => self.lower_struct(ast).map(Into::into),
+            ast::ModuleItem::UnionDef(ast) => self.lower_union(ast).map(Into::into),
+            ast::ModuleItem::EnumDef(ast) => self.lower_enum(ast).map(Into::into),
+            ast::ModuleItem::FnDef(ast) => self.lower_function(ast).map(Into::into),
+            ast::ModuleItem::TypeAliasDef(ast) => self.lower_type_alias(ast).map(Into::into),
+            ast::ModuleItem::StaticDef(ast) => self.lower_static(ast).map(Into::into),
+            ast::ModuleItem::ConstDef(ast) => Some(self.lower_const(ast).into()),
+            ast::ModuleItem::Module(ast) => self.lower_module(ast).map(Into::into),
+            ast::ModuleItem::TraitDef(ast) => self.lower_trait(ast).map(Into::into),
+            ast::ModuleItem::ImplDef(ast) => self.lower_impl(ast).map(Into::into),
+            ast::ModuleItem::UseItem(ast) => Some(ModItems(
+                self.lower_use(ast).into_iter().map(Into::into).collect::<SmallVec<_>>(),
+            )),
+            ast::ModuleItem::ExternCrateItem(ast) => self.lower_extern_crate(ast).map(Into::into),
+            ast::ModuleItem::MacroCall(ast) => self.lower_macro_call(ast).map(Into::into),
+            ast::ModuleItem::ExternBlock(ast) => {
+                Some(ModItems(self.lower_extern_block(ast).into_iter().collect::<SmallVec<_>>()))
+            }
+        };
+
+        if !attrs.is_empty() {
+            for item in items.iter().flat_map(|items| &items.0) {
+                self.add_attrs((*item).into(), attrs.clone());
+            }
+        }
+
+        items
+    }
+
+    fn add_attrs(&mut self, item: AttrOwner, attrs: Attrs) {
+        match self.tree.attrs.entry(item) {
+            Entry::Occupied(mut entry) => {
+                *entry.get_mut() = entry.get().merge(attrs);
+            }
+            Entry::Vacant(entry) => {
+                entry.insert(attrs);
+            }
+        }
+    }
+
+    fn collect_inner_items(&mut self, container: &SyntaxNode) {
+        let forced_vis = self.forced_visibility.take();
+        let mut inner_items = mem::take(&mut self.tree.inner_items);
+        inner_items.extend(
+            container.descendants().skip(1).filter_map(ast::ModuleItem::cast).filter_map(|item| {
+                let ast_id = self.source_ast_id_map.ast_id(&item);
+                Some((ast_id, self.lower_mod_item(&item, true)?.0))
+            }),
+        );
+        self.tree.inner_items = inner_items;
+        self.forced_visibility = forced_vis;
+    }
+
+    fn lower_assoc_item(&mut self, item: &ast::ModuleItem) -> Option<AssocItem> {
+        match item {
+            ast::ModuleItem::FnDef(ast) => self.lower_function(ast).map(Into::into),
+            ast::ModuleItem::TypeAliasDef(ast) => self.lower_type_alias(ast).map(Into::into),
+            ast::ModuleItem::ConstDef(ast) => Some(self.lower_const(ast).into()),
+            ast::ModuleItem::MacroCall(ast) => self.lower_macro_call(ast).map(Into::into),
+            _ => None,
+        }
+    }
+
+    fn lower_struct(&mut self, strukt: &ast::StructDef) -> Option<FileItemTreeId<Struct>> {
+        let visibility = self.lower_visibility(strukt);
+        let name = strukt.name()?.as_name();
+        let generic_params = self.lower_generic_params(GenericsOwner::Struct, strukt);
+        let fields = self.lower_fields(&strukt.kind());
+        let ast_id = self.source_ast_id_map.ast_id(strukt);
+        let kind = match strukt.kind() {
+            ast::StructKind::Record(_) => StructDefKind::Record,
+            ast::StructKind::Tuple(_) => StructDefKind::Tuple,
+            ast::StructKind::Unit => StructDefKind::Unit,
+        };
+        let res = Struct { name, visibility, generic_params, fields, ast_id, kind };
+        Some(id(self.data().structs.alloc(res)))
+    }
+
+    fn lower_fields(&mut self, strukt_kind: &ast::StructKind) -> Fields {
+        match strukt_kind {
+            ast::StructKind::Record(it) => {
+                let range = self.lower_record_fields(it);
+                Fields::Record(range)
+            }
+            ast::StructKind::Tuple(it) => {
+                let range = self.lower_tuple_fields(it);
+                Fields::Tuple(range)
+            }
+            ast::StructKind::Unit => Fields::Unit,
+        }
+    }
+
+    fn lower_record_fields(&mut self, fields: &ast::RecordFieldDefList) -> IdRange<Field> {
+        let start = self.next_field_idx();
+        for field in fields.fields() {
+            if let Some(data) = self.lower_record_field(&field) {
+                let idx = self.data().fields.alloc(data);
+                self.add_attrs(idx.into(), Attrs::new(&field, &self.hygiene));
+            }
+        }
+        let end = self.next_field_idx();
+        IdRange::new(start..end)
+    }
+
+    fn lower_record_field(&mut self, field: &ast::RecordFieldDef) -> Option<Field> {
+        let name = field.name()?.as_name();
+        let visibility = self.lower_visibility(field);
+        let type_ref = self.lower_type_ref_opt(field.ascribed_type());
+        let res = Field { name, type_ref, visibility };
+        Some(res)
+    }
+
+    fn lower_tuple_fields(&mut self, fields: &ast::TupleFieldDefList) -> IdRange<Field> {
+        let start = self.next_field_idx();
+        for (i, field) in fields.fields().enumerate() {
+            let data = self.lower_tuple_field(i, &field);
+            let idx = self.data().fields.alloc(data);
+            self.add_attrs(idx.into(), Attrs::new(&field, &self.hygiene));
+        }
+        let end = self.next_field_idx();
+        IdRange::new(start..end)
+    }
+
+    fn lower_tuple_field(&mut self, idx: usize, field: &ast::TupleFieldDef) -> Field {
+        let name = Name::new_tuple_field(idx);
+        let visibility = self.lower_visibility(field);
+        let type_ref = self.lower_type_ref_opt(field.type_ref());
+        let res = Field { name, type_ref, visibility };
+        res
+    }
+
+    fn lower_union(&mut self, union: &ast::UnionDef) -> Option<FileItemTreeId<Union>> {
+        let visibility = self.lower_visibility(union);
+        let name = union.name()?.as_name();
+        let generic_params = self.lower_generic_params(GenericsOwner::Union, union);
+        let fields = match union.record_field_def_list() {
+            Some(record_field_def_list) => {
+                self.lower_fields(&StructKind::Record(record_field_def_list))
+            }
+            None => Fields::Record(IdRange::new(self.next_field_idx()..self.next_field_idx())),
+        };
+        let ast_id = self.source_ast_id_map.ast_id(union);
+        let res = Union { name, visibility, generic_params, fields, ast_id };
+        Some(id(self.data().unions.alloc(res)))
+    }
+
+    fn lower_enum(&mut self, enum_: &ast::EnumDef) -> Option<FileItemTreeId<Enum>> {
+        let visibility = self.lower_visibility(enum_);
+        let name = enum_.name()?.as_name();
+        let generic_params = self.lower_generic_params(GenericsOwner::Enum, enum_);
+        let variants = match &enum_.variant_list() {
+            Some(variant_list) => self.lower_variants(variant_list),
+            None => IdRange::new(self.next_variant_idx()..self.next_variant_idx()),
+        };
+        let ast_id = self.source_ast_id_map.ast_id(enum_);
+        let res = Enum { name, visibility, generic_params, variants, ast_id };
+        Some(id(self.data().enums.alloc(res)))
+    }
+
+    fn lower_variants(&mut self, variants: &ast::EnumVariantList) -> IdRange<Variant> {
+        let start = self.next_variant_idx();
+        for variant in variants.variants() {
+            if let Some(data) = self.lower_variant(&variant) {
+                let idx = self.data().variants.alloc(data);
+                self.add_attrs(idx.into(), Attrs::new(&variant, &self.hygiene));
+            }
+        }
+        let end = self.next_variant_idx();
+        IdRange::new(start..end)
+    }
+
+    fn lower_variant(&mut self, variant: &ast::EnumVariant) -> Option<Variant> {
+        let name = variant.name()?.as_name();
+        let fields = self.lower_fields(&variant.kind());
+        let res = Variant { name, fields };
+        Some(res)
+    }
+
+    fn lower_function(&mut self, func: &ast::FnDef) -> Option<FileItemTreeId<Function>> {
+        let visibility = self.lower_visibility(func);
+        let name = func.name()?.as_name();
+
+        let mut params = Vec::new();
+        let mut has_self_param = false;
+        if let Some(param_list) = func.param_list() {
+            if let Some(self_param) = param_list.self_param() {
+                let self_type = match self_param.ascribed_type() {
+                    Some(type_ref) => TypeRef::from_ast(&self.body_ctx, type_ref),
+                    None => {
+                        let self_type = TypeRef::Path(name![Self].into());
+                        match self_param.kind() {
+                            ast::SelfParamKind::Owned => self_type,
+                            ast::SelfParamKind::Ref => {
+                                TypeRef::Reference(Box::new(self_type), Mutability::Shared)
+                            }
+                            ast::SelfParamKind::MutRef => {
+                                TypeRef::Reference(Box::new(self_type), Mutability::Mut)
+                            }
+                        }
+                    }
+                };
+                params.push(self_type);
+                has_self_param = true;
+            }
+            for param in param_list.params() {
+                let type_ref = TypeRef::from_ast_opt(&self.body_ctx, param.ascribed_type());
+                params.push(type_ref);
+            }
+        }
+
+        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 ret_type = match func.ret_type().and_then(|rt| rt.type_ref()) {
+            Some(type_ref) => TypeRef::from_ast(&self.body_ctx, type_ref),
+            _ => TypeRef::unit(),
+        };
+
+        let ret_type = if func.async_token().is_some() {
+            let future_impl = desugar_future_path(ret_type);
+            let ty_bound = TypeBound::Path(future_impl);
+            TypeRef::ImplTrait(vec![ty_bound])
+        } else {
+            ret_type
+        };
+
+        let ast_id = self.source_ast_id_map.ast_id(func);
+        let mut res = Function {
+            name,
+            visibility,
+            generic_params: GenericParamsId::EMPTY,
+            has_self_param,
+            is_unsafe: func.unsafe_token().is_some(),
+            params: params.into_boxed_slice(),
+            is_varargs,
+            ret_type,
+            ast_id,
+        };
+        res.generic_params = self.lower_generic_params(GenericsOwner::Function(&res), func);
+
+        Some(id(self.data().functions.alloc(res)))
+    }
+
+    fn lower_type_alias(
+        &mut self,
+        type_alias: &ast::TypeAliasDef,
+    ) -> Option<FileItemTreeId<TypeAlias>> {
+        let name = type_alias.name()?.as_name();
+        let type_ref = type_alias.type_ref().map(|it| self.lower_type_ref(&it));
+        let visibility = self.lower_visibility(type_alias);
+        let bounds = self.lower_type_bounds(type_alias);
+        let generic_params = self.lower_generic_params(GenericsOwner::TypeAlias, type_alias);
+        let ast_id = self.source_ast_id_map.ast_id(type_alias);
+        let res = TypeAlias {
+            name,
+            visibility,
+            bounds: bounds.into_boxed_slice(),
+            generic_params,
+            type_ref,
+            ast_id,
+        };
+        Some(id(self.data().type_aliases.alloc(res)))
+    }
+
+    fn lower_static(&mut self, static_: &ast::StaticDef) -> Option<FileItemTreeId<Static>> {
+        let name = static_.name()?.as_name();
+        let type_ref = self.lower_type_ref_opt(static_.ascribed_type());
+        let visibility = self.lower_visibility(static_);
+        let mutable = static_.mut_token().is_some();
+        let ast_id = self.source_ast_id_map.ast_id(static_);
+        let res = Static { name, visibility, mutable, type_ref, ast_id };
+        Some(id(self.data().statics.alloc(res)))
+    }
+
+    fn lower_const(&mut self, konst: &ast::ConstDef) -> FileItemTreeId<Const> {
+        let name = konst.name().map(|it| it.as_name());
+        let type_ref = self.lower_type_ref_opt(konst.ascribed_type());
+        let visibility = self.lower_visibility(konst);
+        let ast_id = self.source_ast_id_map.ast_id(konst);
+        let res = Const { name, visibility, type_ref, ast_id };
+        id(self.data().consts.alloc(res))
+    }
+
+    fn lower_module(&mut self, module: &ast::Module) -> Option<FileItemTreeId<Mod>> {
+        let name = module.name()?.as_name();
+        let visibility = self.lower_visibility(module);
+        let kind = if module.semicolon_token().is_some() {
+            ModKind::Outline {}
+        } else {
+            ModKind::Inline {
+                items: module
+                    .item_list()
+                    .map(|list| {
+                        list.items()
+                            .flat_map(|item| self.lower_mod_item(&item, false))
+                            .flat_map(|items| items.0)
+                            .collect()
+                    })
+                    .unwrap_or_else(|| {
+                        mark::hit!(name_res_works_for_broken_modules);
+                        Box::new([]) as Box<[_]>
+                    }),
+            }
+        };
+        let ast_id = self.source_ast_id_map.ast_id(module);
+        let res = Mod { name, visibility, kind, ast_id };
+        Some(id(self.data().mods.alloc(res)))
+    }
+
+    fn lower_trait(&mut self, trait_def: &ast::TraitDef) -> Option<FileItemTreeId<Trait>> {
+        let name = trait_def.name()?.as_name();
+        let visibility = self.lower_visibility(trait_def);
+        let generic_params =
+            self.lower_generic_params_and_inner_items(GenericsOwner::Trait(trait_def), trait_def);
+        let auto = trait_def.auto_token().is_some();
+        let items = trait_def.item_list().map(|list| {
+            self.with_inherited_visibility(visibility, |this| {
+                list.items()
+                    .filter_map(|item| {
+                        let attrs = Attrs::new(&item, &this.hygiene);
+                        this.collect_inner_items(item.syntax());
+                        this.lower_assoc_item(&item).map(|item| {
+                            this.add_attrs(ModItem::from(item).into(), attrs);
+                            item
+                        })
+                    })
+                    .collect()
+            })
+        });
+        let ast_id = self.source_ast_id_map.ast_id(trait_def);
+        let res = Trait {
+            name,
+            visibility,
+            generic_params,
+            auto,
+            items: items.unwrap_or_default(),
+            ast_id,
+        };
+        Some(id(self.data().traits.alloc(res)))
+    }
+
+    fn lower_impl(&mut self, impl_def: &ast::ImplDef) -> Option<FileItemTreeId<Impl>> {
+        let generic_params =
+            self.lower_generic_params_and_inner_items(GenericsOwner::Impl, impl_def);
+        let target_trait = impl_def.target_trait().map(|tr| self.lower_type_ref(&tr));
+        let target_type = self.lower_type_ref(&impl_def.target_type()?);
+        let is_negative = impl_def.excl_token().is_some();
+
+        // We cannot use `assoc_items()` here as that does not include macro calls.
+        let items = impl_def
+            .item_list()
+            .into_iter()
+            .flat_map(|it| it.items())
+            .filter_map(|item| {
+                self.collect_inner_items(item.syntax());
+                let assoc = self.lower_assoc_item(&item)?;
+                let attrs = Attrs::new(&item, &self.hygiene);
+                self.add_attrs(ModItem::from(assoc).into(), attrs);
+                Some(assoc)
+            })
+            .collect();
+        let ast_id = self.source_ast_id_map.ast_id(impl_def);
+        let res = Impl { generic_params, target_trait, target_type, is_negative, items, ast_id };
+        Some(id(self.data().impls.alloc(res)))
+    }
+
+    fn lower_use(&mut self, use_item: &ast::UseItem) -> Vec<FileItemTreeId<Import>> {
+        // FIXME: cfg_attr
+        let is_prelude = use_item.has_atom_attr("prelude_import");
+        let visibility = self.lower_visibility(use_item);
+        let ast_id = self.source_ast_id_map.ast_id(use_item);
+
+        // Every use item can expand to many `Import`s.
+        let mut imports = Vec::new();
+        let tree = self.tree.data_mut();
+        ModPath::expand_use_item(
+            InFile::new(self.file, use_item.clone()),
+            &self.hygiene,
+            |path, _tree, is_glob, alias| {
+                imports.push(id(tree.imports.alloc(Import {
+                    path,
+                    alias,
+                    visibility,
+                    is_glob,
+                    is_prelude,
+                    ast_id,
+                })));
+            },
+        );
+
+        imports
+    }
+
+    fn lower_extern_crate(
+        &mut self,
+        extern_crate: &ast::ExternCrateItem,
+    ) -> Option<FileItemTreeId<ExternCrate>> {
+        let path = ModPath::from_name_ref(&extern_crate.name_ref()?);
+        let alias = extern_crate.alias().map(|a| {
+            a.name().map(|it| it.as_name()).map_or(ImportAlias::Underscore, ImportAlias::Alias)
+        });
+        let visibility = self.lower_visibility(extern_crate);
+        let ast_id = self.source_ast_id_map.ast_id(extern_crate);
+        // FIXME: cfg_attr
+        let is_macro_use = extern_crate.has_atom_attr("macro_use");
+
+        let res = ExternCrate { path, alias, visibility, is_macro_use, ast_id };
+        Some(id(self.data().extern_crates.alloc(res)))
+    }
+
+    fn lower_macro_call(&mut self, m: &ast::MacroCall) -> Option<FileItemTreeId<MacroCall>> {
+        let name = m.name().map(|it| it.as_name());
+        let attrs = Attrs::new(m, &self.hygiene);
+        let path = ModPath::from_src(m.path()?, &self.hygiene)?;
+
+        let ast_id = self.source_ast_id_map.ast_id(m);
+
+        // FIXME: cfg_attr
+        let export_attr = attrs.by_key("macro_export");
+
+        let is_export = export_attr.exists();
+        let is_local_inner = if is_export {
+            export_attr.tt_values().map(|it| &it.token_trees).flatten().any(|it| match it {
+                tt::TokenTree::Leaf(tt::Leaf::Ident(ident)) => {
+                    ident.text.contains("local_inner_macros")
+                }
+                _ => false,
+            })
+        } else {
+            false
+        };
+
+        let is_builtin = attrs.by_key("rustc_builtin_macro").exists();
+        let res = MacroCall { name, path, is_export, is_builtin, is_local_inner, ast_id };
+        Some(id(self.data().macro_calls.alloc(res)))
+    }
+
+    fn lower_extern_block(&mut self, block: &ast::ExternBlock) -> Vec<ModItem> {
+        block.extern_item_list().map_or(Vec::new(), |list| {
+            list.extern_items()
+                .filter_map(|item| {
+                    self.collect_inner_items(item.syntax());
+                    let attrs = Attrs::new(&item, &self.hygiene);
+                    let id: ModItem = match item {
+                        ast::ExternItem::FnDef(ast) => {
+                            let func = self.lower_function(&ast)?;
+                            self.data().functions[func.index].is_unsafe = true;
+                            func.into()
+                        }
+                        ast::ExternItem::StaticDef(ast) => {
+                            let statik = self.lower_static(&ast)?;
+                            statik.into()
+                        }
+                    };
+                    self.add_attrs(id.into(), attrs);
+                    Some(id)
+                })
+                .collect()
+        })
+    }
+
+    /// Lowers generics defined on `node` and collects inner items defined within.
+    fn lower_generic_params_and_inner_items(
+        &mut self,
+        owner: GenericsOwner<'_>,
+        node: &impl ast::TypeParamsOwner,
+    ) -> GenericParamsId {
+        // Generics are part of item headers and may contain inner items we need to collect.
+        if let Some(params) = node.type_param_list() {
+            self.collect_inner_items(params.syntax());
+        }
+        if let Some(clause) = node.where_clause() {
+            self.collect_inner_items(clause.syntax());
+        }
+
+        self.lower_generic_params(owner, node)
+    }
+
+    fn lower_generic_params(
+        &mut self,
+        owner: GenericsOwner<'_>,
+        node: &impl ast::TypeParamsOwner,
+    ) -> GenericParamsId {
+        let mut sm = &mut ArenaMap::default();
+        let mut generics = GenericParams::default();
+        match owner {
+            GenericsOwner::Function(func) => {
+                generics.fill(&self.body_ctx, sm, node);
+                // lower `impl Trait` in arguments
+                for param in &*func.params {
+                    generics.fill_implicit_impl_trait_args(param);
+                }
+            }
+            GenericsOwner::Struct
+            | GenericsOwner::Enum
+            | GenericsOwner::Union
+            | GenericsOwner::TypeAlias => {
+                generics.fill(&self.body_ctx, sm, node);
+            }
+            GenericsOwner::Trait(trait_def) => {
+                // traits get the Self type as an implicit first type parameter
+                let self_param_id = generics.types.alloc(TypeParamData {
+                    name: Some(name![Self]),
+                    default: None,
+                    provenance: TypeParamProvenance::TraitSelf,
+                });
+                sm.insert(self_param_id, Either::Left(trait_def.clone()));
+                // add super traits as bounds on Self
+                // i.e., trait Foo: Bar is equivalent to trait Foo where Self: Bar
+                let self_param = TypeRef::Path(name![Self].into());
+                generics.fill_bounds(&self.body_ctx, trait_def, self_param);
+
+                generics.fill(&self.body_ctx, &mut sm, node);
+            }
+            GenericsOwner::Impl => {
+                // Note that we don't add `Self` here: in `impl`s, `Self` is not a
+                // type-parameter, but rather is a type-alias for impl's target
+                // type, so this is handled by the resolver.
+                generics.fill(&self.body_ctx, &mut sm, node);
+            }
+        }
+
+        self.data().generics.alloc(generics)
+    }
+
+    fn lower_type_bounds(&mut self, node: &impl ast::TypeBoundsOwner) -> Vec<TypeBound> {
+        match node.type_bound_list() {
+            Some(bound_list) => {
+                bound_list.bounds().map(|it| TypeBound::from_ast(&self.body_ctx, it)).collect()
+            }
+            None => Vec::new(),
+        }
+    }
+
+    fn lower_visibility(&mut self, item: &impl ast::VisibilityOwner) -> RawVisibilityId {
+        let vis = match self.forced_visibility {
+            Some(vis) => return vis,
+            None => RawVisibility::from_ast_with_hygiene(item.visibility(), &self.hygiene),
+        };
+
+        self.data().vis.alloc(vis)
+    }
+
+    fn lower_type_ref(&self, type_ref: &ast::TypeRef) -> TypeRef {
+        TypeRef::from_ast(&self.body_ctx, type_ref.clone())
+    }
+    fn lower_type_ref_opt(&self, type_ref: Option<ast::TypeRef>) -> TypeRef {
+        type_ref.map(|ty| self.lower_type_ref(&ty)).unwrap_or(TypeRef::Error)
+    }
+
+    /// Forces the visibility `vis` to be used for all items lowered during execution of `f`.
+    fn with_inherited_visibility<R>(
+        &mut self,
+        vis: RawVisibilityId,
+        f: impl FnOnce(&mut Self) -> R,
+    ) -> R {
+        let old = mem::replace(&mut self.forced_visibility, Some(vis));
+        let res = f(self);
+        self.forced_visibility = old;
+        res
+    }
+
+    fn next_field_idx(&self) -> Idx<Field> {
+        Idx::from_raw(RawId::from(
+            self.tree.data.as_ref().map_or(0, |data| data.fields.len() as u32),
+        ))
+    }
+    fn next_variant_idx(&self) -> Idx<Variant> {
+        Idx::from_raw(RawId::from(
+            self.tree.data.as_ref().map_or(0, |data| data.variants.len() as u32),
+        ))
+    }
+}
+
+fn desugar_future_path(orig: TypeRef) -> Path {
+    let path = path![core::future::Future];
+    let mut generic_args: Vec<_> = std::iter::repeat(None).take(path.segments.len() - 1).collect();
+    let mut last = GenericArgs::empty();
+    let binding =
+        AssociatedTypeBinding { name: name![Output], type_ref: Some(orig), bounds: Vec::new() };
+    last.bindings.push(binding);
+    generic_args.push(Some(Arc::new(last)));
+
+    Path::from_known_path(path, generic_args)
+}
+
+enum GenericsOwner<'a> {
+    /// We need access to the partially-lowered `Function` for lowering `impl Trait` in argument
+    /// position.
+    Function(&'a Function),
+    Struct,
+    Enum,
+    Union,
+    /// The `TraitDef` is needed to fill the source map for the implicit `Self` parameter.
+    Trait(&'a ast::TraitDef),
+    TypeAlias,
+    Impl,
+}
diff --git a/crates/ra_hir_def/src/item_tree/tests.rs b/crates/ra_hir_def/src/item_tree/tests.rs
new file mode 100644
index 000000000..f26982985
--- /dev/null
+++ b/crates/ra_hir_def/src/item_tree/tests.rs
@@ -0,0 +1,439 @@
+use expect::{expect, Expect};
+use hir_expand::{db::AstDatabase, HirFileId, InFile};
+use ra_db::fixture::WithFixture;
+use ra_syntax::{ast, AstNode};
+use rustc_hash::FxHashSet;
+use std::sync::Arc;
+use stdx::format_to;
+
+use crate::{db::DefDatabase, test_db::TestDB};
+
+use super::{ItemTree, ModItem, ModKind};
+
+fn test_inner_items(ra_fixture: &str) {
+    let (db, file_id) = TestDB::with_single_file(ra_fixture);
+    let file_id = HirFileId::from(file_id);
+    let tree = db.item_tree(file_id);
+    let root = db.parse_or_expand(file_id).unwrap();
+    let ast_id_map = db.ast_id_map(file_id);
+
+    // Traverse the item tree and collect all module/impl/trait-level items as AST nodes.
+    let mut outer_items = FxHashSet::default();
+    let mut worklist = tree.top_level_items().to_vec();
+    while let Some(item) = worklist.pop() {
+        let node: ast::ModuleItem = match item {
+            ModItem::Import(it) => tree.source(&db, InFile::new(file_id, it)).into(),
+            ModItem::ExternCrate(it) => tree.source(&db, InFile::new(file_id, it)).into(),
+            ModItem::Function(it) => tree.source(&db, InFile::new(file_id, it)).into(),
+            ModItem::Struct(it) => tree.source(&db, InFile::new(file_id, it)).into(),
+            ModItem::Union(it) => tree.source(&db, InFile::new(file_id, it)).into(),
+            ModItem::Enum(it) => tree.source(&db, InFile::new(file_id, it)).into(),
+            ModItem::Const(it) => tree.source(&db, InFile::new(file_id, it)).into(),
+            ModItem::Static(it) => tree.source(&db, InFile::new(file_id, it)).into(),
+            ModItem::TypeAlias(it) => tree.source(&db, InFile::new(file_id, it)).into(),
+            ModItem::Mod(it) => {
+                if let ModKind::Inline { items } = &tree[it].kind {
+                    worklist.extend(&**items);
+                }
+                tree.source(&db, InFile::new(file_id, it)).into()
+            }
+            ModItem::Trait(it) => {
+                worklist.extend(tree[it].items.iter().map(|item| ModItem::from(*item)));
+                tree.source(&db, InFile::new(file_id, it)).into()
+            }
+            ModItem::Impl(it) => {
+                worklist.extend(tree[it].items.iter().map(|item| ModItem::from(*item)));
+                tree.source(&db, InFile::new(file_id, it)).into()
+            }
+            ModItem::MacroCall(_) => continue,
+        };
+
+        outer_items.insert(node);
+    }
+
+    // Now descend the root node and check that all `ast::ModuleItem`s are either recorded above, or
+    // registered as inner items.
+    for item in root.descendants().skip(1).filter_map(ast::ModuleItem::cast) {
+        if outer_items.contains(&item) {
+            continue;
+        }
+
+        let ast_id = ast_id_map.ast_id(&item);
+        assert!(!tree.inner_items(ast_id).is_empty());
+    }
+}
+
+fn item_tree(ra_fixture: &str) -> Arc<ItemTree> {
+    let (db, file_id) = TestDB::with_single_file(ra_fixture);
+    db.item_tree(file_id.into())
+}
+
+fn print_item_tree(ra_fixture: &str) -> String {
+    let tree = item_tree(ra_fixture);
+    let mut out = String::new();
+
+    format_to!(out, "inner attrs: {:?}\n\n", tree.top_level_attrs());
+    format_to!(out, "top-level items:\n");
+    for item in tree.top_level_items() {
+        fmt_mod_item(&mut out, &tree, *item);
+        format_to!(out, "\n");
+    }
+
+    if !tree.inner_items.is_empty() {
+        format_to!(out, "\ninner items:\n\n");
+        for (ast_id, items) in &tree.inner_items {
+            format_to!(out, "for AST {:?}:\n", ast_id);
+            for inner in items {
+                fmt_mod_item(&mut out, &tree, *inner);
+                format_to!(out, "\n\n");
+            }
+        }
+    }
+
+    out
+}
+
+fn fmt_mod_item(out: &mut String, tree: &ItemTree, item: ModItem) {
+    let attrs = tree.attrs(item.into());
+    if !attrs.is_empty() {
+        format_to!(out, "#[{:?}]\n", attrs);
+    }
+
+    let mut children = String::new();
+    match item {
+        ModItem::ExternCrate(it) => {
+            format_to!(out, "{:?}", tree[it]);
+        }
+        ModItem::Import(it) => {
+            format_to!(out, "{:?}", tree[it]);
+        }
+        ModItem::Function(it) => {
+            format_to!(out, "{:?}", tree[it]);
+        }
+        ModItem::Struct(it) => {
+            format_to!(out, "{:?}", tree[it]);
+        }
+        ModItem::Union(it) => {
+            format_to!(out, "{:?}", tree[it]);
+        }
+        ModItem::Enum(it) => {
+            format_to!(out, "{:?}", tree[it]);
+        }
+        ModItem::Const(it) => {
+            format_to!(out, "{:?}", tree[it]);
+        }
+        ModItem::Static(it) => {
+            format_to!(out, "{:?}", tree[it]);
+        }
+        ModItem::Trait(it) => {
+            format_to!(out, "{:?}", tree[it]);
+            for item in &*tree[it].items {
+                fmt_mod_item(&mut children, tree, ModItem::from(*item));
+                format_to!(children, "\n");
+            }
+        }
+        ModItem::Impl(it) => {
+            format_to!(out, "{:?}", tree[it]);
+            for item in &*tree[it].items {
+                fmt_mod_item(&mut children, tree, ModItem::from(*item));
+                format_to!(children, "\n");
+            }
+        }
+        ModItem::TypeAlias(it) => {
+            format_to!(out, "{:?}", tree[it]);
+        }
+        ModItem::Mod(it) => {
+            format_to!(out, "{:?}", tree[it]);
+            match &tree[it].kind {
+                ModKind::Inline { items } => {
+                    for item in &**items {
+                        fmt_mod_item(&mut children, tree, *item);
+                        format_to!(children, "\n");
+                    }
+                }
+                ModKind::Outline {} => {}
+            }
+        }
+        ModItem::MacroCall(it) => {
+            format_to!(out, "{:?}", tree[it]);
+        }
+    }
+
+    for line in children.lines() {
+        format_to!(out, "\n> {}", line);
+    }
+}
+
+fn check(ra_fixture: &str, expect: Expect) {
+    let actual = print_item_tree(ra_fixture);
+    expect.assert_eq(&actual);
+}
+
+#[test]
+fn smoke() {
+    check(
+        r"
+        #![attr]
+
+        #[attr_on_use]
+        use {a, b::*};
+
+        #[ext_crate]
+        extern crate krate;
+
+        #[on_trait]
+        trait Tr<U> {
+            #[assoc_ty]
+            type AssocTy: Tr<()>;
+
+            #[assoc_const]
+            const CONST: u8;
+
+            #[assoc_method]
+            fn method(&self);
+
+            #[assoc_dfl_method]
+            fn dfl_method(&mut self) {}
+        }
+
+        #[struct0]
+        struct Struct0<T = ()>;
+
+        #[struct1]
+        struct Struct1<T>(#[struct1fld] u8);
+
+        #[struct2]
+        struct Struct2<T> {
+            #[struct2fld]
+            fld: (T, ),
+        }
+
+        #[en]
+        enum En {
+            #[enum_variant]
+            Variant {
+                #[enum_field]
+                field: u8,
+            },
+        }
+
+        #[un]
+        union Un {
+            #[union_fld]
+            fld: u16,
+        }
+    ",
+        expect![[r##"
+            inner attrs: Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("attr"))] }, input: None }]) }
+
+            top-level items:
+            #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("attr_on_use"))] }, input: None }]) }]
+            Import { path: ModPath { kind: Plain, segments: [Name(Text("a"))] }, alias: None, visibility: RawVisibilityId("pub(self)"), is_glob: false, is_prelude: false, ast_id: FileAstId::<ra_syntax::ast::generated::nodes::UseItem>(0) }
+            #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("attr_on_use"))] }, input: None }]) }]
+            Import { path: ModPath { kind: Plain, segments: [Name(Text("b"))] }, alias: None, visibility: RawVisibilityId("pub(self)"), is_glob: true, is_prelude: false, ast_id: FileAstId::<ra_syntax::ast::generated::nodes::UseItem>(0) }
+            #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("ext_crate"))] }, input: None }]) }]
+            ExternCrate { path: ModPath { kind: Plain, segments: [Name(Text("krate"))] }, alias: None, visibility: RawVisibilityId("pub(self)"), is_macro_use: false, ast_id: FileAstId::<ra_syntax::ast::generated::nodes::ExternCrateItem>(1) }
+            #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("on_trait"))] }, input: None }]) }]
+            Trait { name: Name(Text("Tr")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(0), auto: false, items: [TypeAlias(Idx::<TypeAlias>(0)), Const(Idx::<Const>(0)), Function(Idx::<Function>(0)), Function(Idx::<Function>(1))], ast_id: FileAstId::<ra_syntax::ast::generated::nodes::TraitDef>(2) }
+            > #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("assoc_ty"))] }, input: None }]) }]
+            > TypeAlias { name: Name(Text("AssocTy")), visibility: RawVisibilityId("pub(self)"), bounds: [Path(Path { type_anchor: None, mod_path: ModPath { kind: Plain, segments: [Name(Text("Tr"))] }, generic_args: [Some(GenericArgs { args: [Type(Tuple([]))], has_self_type: false, bindings: [] })] })], generic_params: GenericParamsId(4294967295), type_ref: None, ast_id: FileAstId::<ra_syntax::ast::generated::nodes::TypeAliasDef>(8) }
+            > #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("assoc_const"))] }, input: None }]) }]
+            > Const { name: Some(Name(Text("CONST"))), visibility: RawVisibilityId("pub(self)"), type_ref: Path(Path { type_anchor: None, mod_path: ModPath { kind: Plain, segments: [Name(Text("u8"))] }, generic_args: [None] }), ast_id: FileAstId::<ra_syntax::ast::generated::nodes::ConstDef>(9) }
+            > #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("assoc_method"))] }, input: None }]) }]
+            > Function { name: Name(Text("method")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(4294967295), has_self_param: true, is_unsafe: false, params: [Reference(Path(Path { type_anchor: None, mod_path: ModPath { kind: Plain, segments: [Name(Text("Self"))] }, generic_args: [None] }), Shared)], is_varargs: false, ret_type: Tuple([]), ast_id: FileAstId::<ra_syntax::ast::generated::nodes::FnDef>(10) }
+            > #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("assoc_dfl_method"))] }, input: None }]) }]
+            > Function { name: Name(Text("dfl_method")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(4294967295), has_self_param: true, is_unsafe: false, params: [Reference(Path(Path { type_anchor: None, mod_path: ModPath { kind: Plain, segments: [Name(Text("Self"))] }, generic_args: [None] }), Mut)], is_varargs: false, ret_type: Tuple([]), ast_id: FileAstId::<ra_syntax::ast::generated::nodes::FnDef>(11) }
+            #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("struct0"))] }, input: None }]) }]
+            Struct { name: Name(Text("Struct0")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(1), fields: Unit, ast_id: FileAstId::<ra_syntax::ast::generated::nodes::StructDef>(3), kind: Unit }
+            #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("struct1"))] }, input: None }]) }]
+            Struct { name: Name(Text("Struct1")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(2), fields: Tuple(IdRange::<ra_hir_def::item_tree::Field>(0..1)), ast_id: FileAstId::<ra_syntax::ast::generated::nodes::StructDef>(4), kind: Tuple }
+            #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("struct2"))] }, input: None }]) }]
+            Struct { name: Name(Text("Struct2")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(3), fields: Record(IdRange::<ra_hir_def::item_tree::Field>(1..2)), ast_id: FileAstId::<ra_syntax::ast::generated::nodes::StructDef>(5), kind: Record }
+            #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("en"))] }, input: None }]) }]
+            Enum { name: Name(Text("En")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(4294967295), variants: IdRange::<ra_hir_def::item_tree::Variant>(0..1), ast_id: FileAstId::<ra_syntax::ast::generated::nodes::EnumDef>(6) }
+            #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("un"))] }, input: None }]) }]
+            Union { name: Name(Text("Un")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(4294967295), fields: Record(IdRange::<ra_hir_def::item_tree::Field>(3..4)), ast_id: FileAstId::<ra_syntax::ast::generated::nodes::UnionDef>(7) }
+        "##]],
+    );
+}
+
+#[test]
+fn simple_inner_items() {
+    check(
+        r"
+        impl<T:A> D for Response<T> {
+            fn foo() {
+                end();
+                fn end<W: Write>() {
+                    let _x: T = loop {};
+                }
+            }
+        }
+    ",
+        expect![[r#"
+            inner attrs: Attrs { entries: None }
+
+            top-level items:
+            Impl { generic_params: GenericParamsId(0), target_trait: Some(Path(Path { type_anchor: None, mod_path: ModPath { kind: Plain, segments: [Name(Text("D"))] }, generic_args: [None] })), target_type: Path(Path { type_anchor: None, mod_path: ModPath { kind: Plain, segments: [Name(Text("Response"))] }, generic_args: [Some(GenericArgs { args: [Type(Path(Path { type_anchor: None, mod_path: ModPath { kind: Plain, segments: [Name(Text("T"))] }, generic_args: [None] }))], has_self_type: false, bindings: [] })] }), is_negative: false, items: [Function(Idx::<Function>(1))], ast_id: FileAstId::<ra_syntax::ast::generated::nodes::ImplDef>(0) }
+            > Function { name: Name(Text("foo")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(4294967295), has_self_param: false, is_unsafe: false, params: [], is_varargs: false, ret_type: Tuple([]), ast_id: FileAstId::<ra_syntax::ast::generated::nodes::FnDef>(1) }
+
+            inner items:
+
+            for AST FileAstId::<ra_syntax::ast::generated::nodes::ModuleItem>(2):
+            Function { name: Name(Text("end")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(1), has_self_param: false, is_unsafe: false, params: [], is_varargs: false, ret_type: Tuple([]), ast_id: FileAstId::<ra_syntax::ast::generated::nodes::FnDef>(2) }
+
+        "#]],
+    );
+}
+
+#[test]
+fn extern_attrs() {
+    check(
+        r#"
+        #[block_attr]
+        extern "C" {
+            #[attr_a]
+            fn a() {}
+            #[attr_b]
+            fn b() {}
+        }
+    "#,
+        expect![[r##"
+            inner attrs: Attrs { entries: None }
+
+            top-level items:
+            #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("attr_a"))] }, input: None }, Attr { path: ModPath { kind: Plain, segments: [Name(Text("block_attr"))] }, input: None }]) }]
+            Function { name: Name(Text("a")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(4294967295), has_self_param: false, is_unsafe: true, params: [], is_varargs: false, ret_type: Tuple([]), ast_id: FileAstId::<ra_syntax::ast::generated::nodes::FnDef>(1) }
+            #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("attr_b"))] }, input: None }, Attr { path: ModPath { kind: Plain, segments: [Name(Text("block_attr"))] }, input: None }]) }]
+            Function { name: Name(Text("b")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(4294967295), has_self_param: false, is_unsafe: true, params: [], is_varargs: false, ret_type: Tuple([]), ast_id: FileAstId::<ra_syntax::ast::generated::nodes::FnDef>(2) }
+        "##]],
+    );
+}
+
+#[test]
+fn trait_attrs() {
+    check(
+        r#"
+        #[trait_attr]
+        trait Tr {
+            #[attr_a]
+            fn a() {}
+            #[attr_b]
+            fn b() {}
+        }
+    "#,
+        expect![[r##"
+            inner attrs: Attrs { entries: None }
+
+            top-level items:
+            #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("trait_attr"))] }, input: None }]) }]
+            Trait { name: Name(Text("Tr")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(0), auto: false, items: [Function(Idx::<Function>(0)), Function(Idx::<Function>(1))], ast_id: FileAstId::<ra_syntax::ast::generated::nodes::TraitDef>(0) }
+            > #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("attr_a"))] }, input: None }]) }]
+            > Function { name: Name(Text("a")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(4294967295), has_self_param: false, is_unsafe: false, params: [], is_varargs: false, ret_type: Tuple([]), ast_id: FileAstId::<ra_syntax::ast::generated::nodes::FnDef>(1) }
+            > #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("attr_b"))] }, input: None }]) }]
+            > Function { name: Name(Text("b")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(4294967295), has_self_param: false, is_unsafe: false, params: [], is_varargs: false, ret_type: Tuple([]), ast_id: FileAstId::<ra_syntax::ast::generated::nodes::FnDef>(2) }
+        "##]],
+    );
+}
+
+#[test]
+fn impl_attrs() {
+    check(
+        r#"
+        #[impl_attr]
+        impl Ty {
+            #[attr_a]
+            fn a() {}
+            #[attr_b]
+            fn b() {}
+        }
+    "#,
+        expect![[r##"
+            inner attrs: Attrs { entries: None }
+
+            top-level items:
+            #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("impl_attr"))] }, input: None }]) }]
+            Impl { generic_params: GenericParamsId(4294967295), target_trait: None, target_type: Path(Path { type_anchor: None, mod_path: ModPath { kind: Plain, segments: [Name(Text("Ty"))] }, generic_args: [None] }), is_negative: false, items: [Function(Idx::<Function>(0)), Function(Idx::<Function>(1))], ast_id: FileAstId::<ra_syntax::ast::generated::nodes::ImplDef>(0) }
+            > #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("attr_a"))] }, input: None }]) }]
+            > Function { name: Name(Text("a")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(4294967295), has_self_param: false, is_unsafe: false, params: [], is_varargs: false, ret_type: Tuple([]), ast_id: FileAstId::<ra_syntax::ast::generated::nodes::FnDef>(1) }
+            > #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("attr_b"))] }, input: None }]) }]
+            > Function { name: Name(Text("b")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(4294967295), has_self_param: false, is_unsafe: false, params: [], is_varargs: false, ret_type: Tuple([]), ast_id: FileAstId::<ra_syntax::ast::generated::nodes::FnDef>(2) }
+        "##]],
+    );
+}
+
+#[test]
+fn cursed_inner_items() {
+    test_inner_items(
+        r"
+        struct S<T: Trait = [u8; { fn f() {} 0 }]>(T);
+
+        enum En {
+            Var1 {
+                t: [(); { trait Inner {} 0 }],
+            },
+
+            Var2([u16; { enum Inner {} 0 }]),
+        }
+
+        type Ty = [En; { struct Inner; 0 }];
+
+        impl En {
+            fn assoc() {
+                trait InnerTrait<T = [u8; { fn f() {} }]> {}
+                struct InnerStruct<T = [u8; { fn f() {} }]> {}
+                impl<T = [u8; { fn f() {} }]> InnerTrait for InnerStruct {}
+            }
+        }
+
+        trait Tr<T = [u8; { fn f() {} }]> {
+            type AssocTy = [u8; { fn f() {} }];
+
+            const AssocConst: [u8; { fn f() {} }];
+        }
+    ",
+    );
+}
+
+#[test]
+fn inner_item_attrs() {
+    check(
+        r"
+        fn foo() {
+            #[on_inner]
+            fn inner() {}
+        }
+    ",
+        expect![[r##"
+            inner attrs: Attrs { entries: None }
+
+            top-level items:
+            Function { name: Name(Text("foo")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(4294967295), has_self_param: false, is_unsafe: false, params: [], is_varargs: false, ret_type: Tuple([]), ast_id: FileAstId::<ra_syntax::ast::generated::nodes::FnDef>(0) }
+
+            inner items:
+
+            for AST FileAstId::<ra_syntax::ast::generated::nodes::ModuleItem>(1):
+            #[Attrs { entries: Some([Attr { path: ModPath { kind: Plain, segments: [Name(Text("on_inner"))] }, input: None }]) }]
+            Function { name: Name(Text("inner")), visibility: RawVisibilityId("pub(self)"), generic_params: GenericParamsId(4294967295), has_self_param: false, is_unsafe: false, params: [], is_varargs: false, ret_type: Tuple([]), ast_id: FileAstId::<ra_syntax::ast::generated::nodes::FnDef>(1) }
+
+        "##]],
+    );
+}
+
+#[test]
+fn assoc_item_macros() {
+    check(
+        r"
+        impl S {
+            items!();
+        }
+    ",
+        expect![[r#"
+            inner attrs: Attrs { entries: None }
+
+            top-level items:
+            Impl { generic_params: GenericParamsId(4294967295), target_trait: None, target_type: Path(Path { type_anchor: None, mod_path: ModPath { kind: Plain, segments: [Name(Text("S"))] }, generic_args: [None] }), is_negative: false, items: [MacroCall(Idx::<MacroCall>(0))], ast_id: FileAstId::<ra_syntax::ast::generated::nodes::ImplDef>(0) }
+            > MacroCall { name: None, path: ModPath { kind: Plain, segments: [Name(Text("items"))] }, is_export: false, is_local_inner: false, is_builtin: false, ast_id: FileAstId::<ra_syntax::ast::generated::nodes::MacroCall>(1) }
+        "#]],
+    );
+}