137 files changed, 4983 insertions, 3530 deletions
diff --git a/Cargo.lock b/Cargo.lock
index b99c243a4..9f013c275 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1809,9 +1809,9 @@ checksum = "56dee185309b50d1f11bfedef0fe6d036842e3fb77413abef29f8f8d1c5d4c1c"
 [[package]]
 name = "ungrammar"
-version = "1.12.2"
+version = "1.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df6586a7c530704efe803d49a0b4132dcbdb4063163df39110548e6b5f2373ba"
+checksum = "76760314176cc2b94047af2f921b92c39f11a34dc05c43a3c2b0fc91cb22959f"
 [[package]]
 name = "unicase"
diff --git a/crates/base_db/src/input.rs b/crates/base_db/src/input.rs
index d0def2181..e9e8dfc2e 100644
--- a/crates/base_db/src/input.rs
+++ b/crates/base_db/src/input.rs
@@ -410,7 +410,7 @@ impl CrateId {
 impl CrateData {
    fn add_dep(&mut self, name: CrateName, crate_id: CrateId) {
-        self.dependencies.push(Dependency { name, crate_id })
+        self.dependencies.push(Dependency { crate_id, name })
    }
 }
diff --git a/crates/cfg/src/dnf.rs b/crates/cfg/src/dnf.rs
index 30f4bcdf7..75ded9aa1 100644
--- a/crates/cfg/src/dnf.rs
+++ b/crates/cfg/src/dnf.rs
@@ -255,9 +255,9 @@ impl Builder {
 fn make_dnf(expr: CfgExpr) -> CfgExpr {
    match expr {
        CfgExpr::Invalid | CfgExpr::Atom(_) | CfgExpr::Not(_) => expr,
-        CfgExpr::Any(e) => CfgExpr::Any(e.into_iter().map(|expr| make_dnf(expr)).collect()),
+        CfgExpr::Any(e) => CfgExpr::Any(e.into_iter().map(make_dnf).collect()),
        CfgExpr::All(e) => {
-            let e = e.into_iter().map(|expr| make_nnf(expr)).collect::<Vec<_>>();
+            let e = e.into_iter().map(make_nnf).collect::<Vec<_>>();
            CfgExpr::Any(distribute_conj(&e))
        }
@@ -300,8 +300,8 @@ fn distribute_conj(conj: &[CfgExpr]) -> Vec<CfgExpr> {
 fn make_nnf(expr: CfgExpr) -> CfgExpr {
    match expr {
        CfgExpr::Invalid | CfgExpr::Atom(_) => expr,
-        CfgExpr::Any(expr) => CfgExpr::Any(expr.into_iter().map(|expr| make_nnf(expr)).collect()),
+        CfgExpr::Any(expr) => CfgExpr::Any(expr.into_iter().map(make_nnf).collect()),
-        CfgExpr::All(expr) => CfgExpr::All(expr.into_iter().map(|expr| make_nnf(expr)).collect()),
+        CfgExpr::All(expr) => CfgExpr::All(expr.into_iter().map(make_nnf).collect()),
        CfgExpr::Not(operand) => match *operand {
            CfgExpr::Invalid | CfgExpr::Atom(_) => CfgExpr::Not(operand.clone()), // Original negated expr
            CfgExpr::Not(expr) => {
diff --git a/crates/hir/src/attrs.rs b/crates/hir/src/attrs.rs
index dab8da7bb..4a11622fc 100644
--- a/crates/hir/src/attrs.rs
+++ b/crates/hir/src/attrs.rs
@@ -1,6 +1,6 @@
 //! Attributes & documentation for hir types.
 use hir_def::{
-    attr::{Attrs, Documentation},
+    attr::{AttrsWithOwner, Documentation},
    path::ModPath,
    per_ns::PerNs,
    resolver::HasResolver,
@@ -16,7 +16,7 @@ use crate::{
 };
 pub trait HasAttrs {
-    fn attrs(self, db: &dyn HirDatabase) -> Attrs;
+    fn attrs(self, db: &dyn HirDatabase) -> AttrsWithOwner;
    fn docs(self, db: &dyn HirDatabase) -> Option<Documentation>;
    fn resolve_doc_path(
        self,
@@ -36,7 +36,7 @@ pub enum Namespace {
 macro_rules! impl_has_attrs {
    ($(($def:ident, $def_id:ident),)*) => {$(
        impl HasAttrs for $def {
-            fn attrs(self, db: &dyn HirDatabase) -> Attrs {
+            fn attrs(self, db: &dyn HirDatabase) -> AttrsWithOwner {
                let def = AttrDefId::$def_id(self.into());
                db.attrs(def)
            }
@@ -70,7 +70,7 @@ impl_has_attrs![
 macro_rules! impl_has_attrs_enum {
    ($($variant:ident),* for $enum:ident) => {$(
        impl HasAttrs for $variant {
-            fn attrs(self, db: &dyn HirDatabase) -> Attrs {
+            fn attrs(self, db: &dyn HirDatabase) -> AttrsWithOwner {
                $enum::$variant(self).attrs(db)
            }
            fn docs(self, db: &dyn HirDatabase) -> Option<Documentation> {
diff --git a/crates/hir/src/display.rs b/crates/hir/src/display.rs
index 9f6d7be48..97a78ca25 100644
--- a/crates/hir/src/display.rs
+++ b/crates/hir/src/display.rs
@@ -217,7 +217,7 @@ impl HirDisplay for Variant {
 impl HirDisplay for Type {
    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
-        self.ty.value.hir_fmt(f)
+        self.ty.hir_fmt(f)
    }
 }
diff --git a/crates/hir/src/has_source.rs b/crates/hir/src/has_source.rs
index 262002671..dc10a4d0f 100644
--- a/crates/hir/src/has_source.rs
+++ b/crates/hir/src/has_source.rs
@@ -111,10 +111,12 @@ impl HasSource for TypeAlias {
    }
 }
 impl HasSource for MacroDef {
-    type Ast = ast::Macro;
+    type Ast = Either<ast::Macro, ast::Fn>;
    fn source(self, db: &dyn HirDatabase) -> Option<InFile<Self::Ast>> {
-        let ast_id = self.id.ast_id?;
+        Some(self.id.ast_id().either(
-        Some(InFile { file_id: ast_id.file_id, value: ast_id.to_node(db.upcast()) })
+            |id| id.with_value(Either::Left(id.to_node(db.upcast()))),
+            |id| id.with_value(Either::Right(id.to_node(db.upcast()))),
+        ))
    }
 }
 impl HasSource for Impl {
diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index b41a36a78..30b96d7e2 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs
@@ -56,9 +56,9 @@ use hir_ty::{
    primitive::UintTy,
    to_assoc_type_id,
    traits::{FnTrait, Solution, SolutionVariables},
-    AliasTy, BoundVar, CallableDefId, CallableSig, Canonical, DebruijnIndex, GenericPredicate,
+    AliasEq, AliasTy, BoundVar, CallableDefId, CallableSig, Canonical, CanonicalVarKinds, Cast,
-    InEnvironment, Interner, Obligation, ProjectionPredicate, ProjectionTy, Scalar, Substitution,
+    DebruijnIndex, InEnvironment, Interner, ProjectionTy, QuantifiedWhereClause, Scalar,
-    Ty, TyDefId, TyKind, TyVariableKind,
+    Substitution, TraitEnvironment, Ty, TyDefId, TyKind, TyVariableKind, WhereClause,
 };
 use itertools::Itertools;
 use rustc_hash::FxHashSet;
@@ -89,7 +89,7 @@ pub use crate::{
 pub use {
    hir_def::{
        adt::StructKind,
-        attr::{Attr, Attrs, Documentation},
+        attr::{Attr, Attrs, AttrsWithOwner, Documentation},
        body::scope::ExprScopes,
        find_path::PrefixKind,
        import_map,
@@ -213,7 +213,7 @@ impl Crate {
                Some(TokenTree::Leaf(Leaf::Literal(Literal{ref text, ..}))) => Some(text),
                _ => None
            }
-        }).flat_map(|t| t).next();
+        }).flatten().next();
        doc_url.map(|s| s.trim_matches('"').trim_end_matches('/').to_owned() + "/")
    }
@@ -851,13 +851,7 @@ impl Function {
            .iter()
            .enumerate()
            .map(|(idx, type_ref)| {
-                let ty = Type {
+                let ty = Type { krate, env: environment.clone(), ty: ctx.lower_ty(type_ref) };
-                    krate,
-                    ty: InEnvironment {
-                        value: ctx.lower_ty(type_ref),
-                        environment: environment.clone(),
-                    },
-                };
                Param { func: self, ty, idx }
            })
            .collect()
@@ -1144,17 +1138,21 @@ impl MacroDef {
    /// XXX: this parses the file
    pub fn name(self, db: &dyn HirDatabase) -> Option<Name> {
-        self.source(db)?.value.name().map(|it| it.as_name())
+        match self.source(db)?.value {
+            Either::Left(it) => it.name().map(|it| it.as_name()),
+            Either::Right(it) => it.name().map(|it| it.as_name()),
+        }
    }
    /// Indicate it is a proc-macro
    pub fn is_proc_macro(&self) -> bool {
-        matches!(self.id.kind, MacroDefKind::ProcMacro(_))
+        matches!(self.id.kind, MacroDefKind::ProcMacro(..))
    }
    /// Indicate it is a derive macro
    pub fn is_derive_macro(&self) -> bool {
-        matches!(self.id.kind, MacroDefKind::ProcMacro(_) | MacroDefKind::BuiltInDerive(_))
+        // FIXME: wrong for `ProcMacro`
+        matches!(self.id.kind, MacroDefKind::ProcMacro(..) | MacroDefKind::BuiltInDerive(..))
    }
 }
@@ -1456,9 +1454,9 @@ impl TypeParam {
    pub fn trait_bounds(self, db: &dyn HirDatabase) -> Vec<Trait> {
        db.generic_predicates_for_param(self.id)
            .into_iter()
-            .filter_map(|pred| match &pred.value {
+            .filter_map(|pred| match &pred.skip_binders().skip_binders() {
-                hir_ty::GenericPredicate::Implemented(trait_ref) => {
+                hir_ty::WhereClause::Implemented(trait_ref) => {
-                    Some(Trait::from(trait_ref.trait_))
+                    Some(Trait::from(trait_ref.hir_trait_id()))
                }
                _ => None,
            })
@@ -1536,8 +1534,8 @@ impl Impl {
        inherent.all_impls().chain(trait_.all_impls()).map(Self::from).collect()
    }
-    pub fn all_for_type(db: &dyn HirDatabase, Type { krate, ty }: Type) -> Vec<Impl> {
+    pub fn all_for_type(db: &dyn HirDatabase, Type { krate, ty, .. }: Type) -> Vec<Impl> {
-        let def_crates = match ty.value.def_crates(db, krate) {
+        let def_crates = match ty.def_crates(db, krate) {
            Some(def_crates) => def_crates,
            None => return Vec::new(),
        };
@@ -1545,14 +1543,14 @@ impl Impl {
        let filter = |impl_def: &Impl| {
            let target_ty = impl_def.target_ty(db);
            let rref = target_ty.remove_ref();
-            ty.value.equals_ctor(rref.as_ref().map_or(&target_ty.ty.value, |it| &it.ty.value))
+            ty.equals_ctor(rref.as_ref().map_or(&target_ty.ty, |it| &it.ty))
        };
        let mut all = Vec::new();
        def_crates.iter().for_each(|&id| {
            all.extend(db.inherent_impls_in_crate(id).all_impls().map(Self::from).filter(filter))
        });
-        let fp = TyFingerprint::for_impl(&ty.value);
+        let fp = TyFingerprint::for_impl(&ty);
        for id in def_crates
            .iter()
            .flat_map(|&id| Crate { id }.transitive_reverse_dependencies(db))
@@ -1639,7 +1637,8 @@ impl Impl {
 #[derive(Clone, PartialEq, Eq, Debug)]
 pub struct Type {
    krate: CrateId,
-    ty: InEnvironment<Ty>,
+    env: Arc<TraitEnvironment>,
+    ty: Ty,
 }
 impl Type {
@@ -1659,14 +1658,14 @@ impl Type {
    ) -> Type {
        let environment =
            resolver.generic_def().map_or_else(Default::default, |d| db.trait_environment(d));
-        Type { krate, ty: InEnvironment { value: ty, environment } }
+        Type { krate, env: environment, ty }
    }
    fn new(db: &dyn HirDatabase, krate: CrateId, lexical_env: impl HasResolver, ty: Ty) -> Type {
        let resolver = lexical_env.resolver(db.upcast());
        let environment =
            resolver.generic_def().map_or_else(Default::default, |d| db.trait_environment(d));
-        Type { krate, ty: InEnvironment { value: ty, environment } }
+        Type { krate, env: environment, ty }
    }
    fn from_def(
@@ -1680,29 +1679,29 @@ impl Type {
    }
    pub fn is_unit(&self) -> bool {
-        matches!(self.ty.value.interned(&Interner), TyKind::Tuple(0, ..))
+        matches!(self.ty.interned(&Interner), TyKind::Tuple(0, ..))
    }
    pub fn is_bool(&self) -> bool {
-        matches!(self.ty.value.interned(&Interner), TyKind::Scalar(Scalar::Bool))
+        matches!(self.ty.interned(&Interner), TyKind::Scalar(Scalar::Bool))
    }
    pub fn is_mutable_reference(&self) -> bool {
-        matches!(self.ty.value.interned(&Interner), TyKind::Ref(hir_ty::Mutability::Mut, ..))
+        matches!(self.ty.interned(&Interner), TyKind::Ref(hir_ty::Mutability::Mut, ..))
    }
    pub fn is_usize(&self) -> bool {
-        matches!(self.ty.value.interned(&Interner), TyKind::Scalar(Scalar::Uint(UintTy::Usize)))
+        matches!(self.ty.interned(&Interner), TyKind::Scalar(Scalar::Uint(UintTy::Usize)))
    }
    pub fn remove_ref(&self) -> Option<Type> {
-        match &self.ty.value.interned(&Interner) {
+        match &self.ty.interned(&Interner) {
            TyKind::Ref(.., ty) => Some(self.derived(ty.clone())),
            _ => None,
        }
    }
    pub fn is_unknown(&self) -> bool {
-        self.ty.value.is_unknown()
+        self.ty.is_unknown()
    }
    /// Checks that particular type `ty` implements `std::future::Future`.
@@ -1719,11 +1718,12 @@ impl Type {
            None => return false,
        };
-        let canonical_ty = Canonical { value: self.ty.value.clone(), kinds: Arc::new([]) };
+        let canonical_ty =
+            Canonical { value: self.ty.clone(), binders: CanonicalVarKinds::empty(&Interner) };
        method_resolution::implements_trait(
            &canonical_ty,
            db,
-            self.ty.environment.clone(),
+            self.env.clone(),
            krate,
            std_future_trait,
        )
@@ -1741,11 +1741,12 @@ impl Type {
            None => return false,
        };
-        let canonical_ty = Canonical { value: self.ty.value.clone(), kinds: Arc::new([]) };
+        let canonical_ty =
+            Canonical { value: self.ty.clone(), binders: CanonicalVarKinds::empty(&Interner) };
        method_resolution::implements_trait_unique(
            &canonical_ty,
            db,
-            self.ty.environment.clone(),
+            self.env.clone(),
            krate,
            fnonce_trait,
        )
@@ -1753,19 +1754,16 @@ impl Type {
    pub fn impls_trait(&self, db: &dyn HirDatabase, trait_: Trait, args: &[Type]) -> bool {
        let trait_ref = hir_ty::TraitRef {
-            trait_: trait_.id,
+            trait_id: hir_ty::to_chalk_trait_id(trait_.id),
-            substs: Substitution::build_for_def(db, trait_.id)
+            substitution: Substitution::build_for_def(db, trait_.id)
-                .push(self.ty.value.clone())
+                .push(self.ty.clone())
-                .fill(args.iter().map(|t| t.ty.value.clone()))
+                .fill(args.iter().map(|t| t.ty.clone()))
                .build(),
        };
        let goal = Canonical {
-            value: hir_ty::InEnvironment::new(
+            value: hir_ty::InEnvironment::new(self.env.env.clone(), trait_ref.cast(&Interner)),
-                self.ty.environment.clone(),
+            binders: CanonicalVarKinds::empty(&Interner),
-                hir_ty::Obligation::Trait(trait_ref),
-            ),
-            kinds: Arc::new([]),
        };
        db.trait_solve(self.krate, goal).is_some()
@@ -1779,23 +1777,24 @@ impl Type {
        alias: TypeAlias,
    ) -> Option<Type> {
        let subst = Substitution::build_for_def(db, trait_.id)
-            .push(self.ty.value.clone())
+            .push(self.ty.clone())
-            .fill(args.iter().map(|t| t.ty.value.clone()))
+            .fill(args.iter().map(|t| t.ty.clone()))
            .build();
-        let predicate = ProjectionPredicate {
+        let goal = Canonical::new(
-            projection_ty: ProjectionTy {
+            InEnvironment::new(
-                associated_ty_id: to_assoc_type_id(alias.id),
+                self.env.env.clone(),
-                substitution: subst,
+                AliasEq {
-            },
+                    alias: AliasTy::Projection(ProjectionTy {
-            ty: TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0)).intern(&Interner),
+                        associated_ty_id: to_assoc_type_id(alias.id),
-        };
+                        substitution: subst,
-        let goal = Canonical {
+                    }),
-            value: InEnvironment::new(
+                    ty: TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0))
-                self.ty.environment.clone(),
+                        .intern(&Interner),
-                Obligation::Projection(predicate),
+                }
+                .cast(&Interner),
            ),
-            kinds: Arc::new([TyVariableKind::General]),
+            [TyVariableKind::General].iter().copied(),
-        };
+        );
        match db.trait_solve(self.krate, goal)? {
            Solution::Unique(SolutionVariables(subst)) => {
@@ -1815,22 +1814,22 @@ impl Type {
    }
    pub fn as_callable(&self, db: &dyn HirDatabase) -> Option<Callable> {
-        let def = self.ty.value.callable_def(db);
+        let def = self.ty.callable_def(db);
-        let sig = self.ty.value.callable_sig(db)?;
+        let sig = self.ty.callable_sig(db)?;
        Some(Callable { ty: self.clone(), sig, def, is_bound_method: false })
    }
    pub fn is_closure(&self) -> bool {
-        matches!(&self.ty.value.interned(&Interner), TyKind::Closure { .. })
+        matches!(&self.ty.interned(&Interner), TyKind::Closure { .. })
    }
    pub fn is_fn(&self) -> bool {
-        matches!(&self.ty.value.interned(&Interner), TyKind::FnDef(..) | TyKind::Function { .. })
+        matches!(&self.ty.interned(&Interner), TyKind::FnDef(..) | TyKind::Function { .. })
    }
    pub fn is_packed(&self, db: &dyn HirDatabase) -> bool {
-        let adt_id = match self.ty.value.interned(&Interner) {
+        let adt_id = match self.ty.interned(&Interner) {
            &TyKind::Adt(hir_ty::AdtId(adt_id), ..) => adt_id,
            _ => return false,
        };
@@ -1843,11 +1842,11 @@ impl Type {
    }
    pub fn is_raw_ptr(&self) -> bool {
-        matches!(&self.ty.value.interned(&Interner), TyKind::Raw(..))
+        matches!(&self.ty.interned(&Interner), TyKind::Raw(..))
    }
    pub fn contains_unknown(&self) -> bool {
-        return go(&self.ty.value);
+        return go(&self.ty);
        fn go(ty: &Ty) -> bool {
            match ty.interned(&Interner) {
@@ -1879,7 +1878,7 @@ impl Type {
    }
    pub fn fields(&self, db: &dyn HirDatabase) -> Vec<(Field, Type)> {
-        let (variant_id, substs) = match self.ty.value.interned(&Interner) {
+        let (variant_id, substs) = match self.ty.interned(&Interner) {
            &TyKind::Adt(hir_ty::AdtId(AdtId::StructId(s)), ref substs) => (s.into(), substs),
            &TyKind::Adt(hir_ty::AdtId(AdtId::UnionId(u)), ref substs) => (u.into(), substs),
            _ => return Vec::new(),
@@ -1896,7 +1895,7 @@ impl Type {
    }
    pub fn tuple_fields(&self, _db: &dyn HirDatabase) -> Vec<Type> {
-        if let TyKind::Tuple(_, substs) = &self.ty.value.interned(&Interner) {
+        if let TyKind::Tuple(_, substs) = &self.ty.interned(&Interner) {
            substs.iter().map(|ty| self.derived(ty.clone())).collect()
        } else {
            Vec::new()
@@ -1906,9 +1905,10 @@ impl Type {
    pub fn autoderef<'a>(&'a self, db: &'a dyn HirDatabase) -> impl Iterator<Item = Type> + 'a {
        // There should be no inference vars in types passed here
        // FIXME check that?
-        let canonical = Canonical { value: self.ty.value.clone(), kinds: Arc::new([]) };
+        let canonical =
-        let environment = self.ty.environment.clone();
+            Canonical { value: self.ty.clone(), binders: CanonicalVarKinds::empty(&Interner) };
-        let ty = InEnvironment { value: canonical, environment };
+        let environment = self.env.env.clone();
+        let ty = InEnvironment { goal: canonical, environment };
        autoderef(db, Some(self.krate), ty)
            .map(|canonical| canonical.value)
            .map(move |ty| self.derived(ty))
@@ -1922,10 +1922,10 @@ impl Type {
        krate: Crate,
        mut callback: impl FnMut(AssocItem) -> Option<T>,
    ) -> Option<T> {
-        for krate in self.ty.value.def_crates(db, krate.id)? {
+        for krate in self.ty.def_crates(db, krate.id)? {
            let impls = db.inherent_impls_in_crate(krate);
-            for impl_def in impls.for_self_ty(&self.ty.value) {
+            for impl_def in impls.for_self_ty(&self.ty) {
                for &item in db.impl_data(*impl_def).items.iter() {
                    if let Some(result) = callback(item.into()) {
                        return Some(result);
@@ -1938,7 +1938,6 @@ impl Type {
    pub fn type_parameters(&self) -> impl Iterator<Item = Type> + '_ {
        self.ty
-            .value
            .strip_references()
            .substs()
            .into_iter()
@@ -1957,9 +1956,10 @@ impl Type {
        // There should be no inference vars in types passed here
        // FIXME check that?
        // FIXME replace Unknown by bound vars here
-        let canonical = Canonical { value: self.ty.value.clone(), kinds: Arc::new([]) };
+        let canonical =
+            Canonical { value: self.ty.clone(), binders: CanonicalVarKinds::empty(&Interner) };
-        let env = self.ty.environment.clone();
+        let env = self.env.clone();
        let krate = krate.id;
        method_resolution::iterate_method_candidates(
@@ -1988,9 +1988,10 @@ impl Type {
        // There should be no inference vars in types passed here
        // FIXME check that?
        // FIXME replace Unknown by bound vars here
-        let canonical = Canonical { value: self.ty.value.clone(), kinds: Arc::new([]) };
+        let canonical =
+            Canonical { value: self.ty.clone(), binders: CanonicalVarKinds::empty(&Interner) };
-        let env = self.ty.environment.clone();
+        let env = self.env.clone();
        let krate = krate.id;
        method_resolution::iterate_method_candidates(
@@ -2006,20 +2007,20 @@ impl Type {
    }
    pub fn as_adt(&self) -> Option<Adt> {
-        let (adt, _subst) = self.ty.value.as_adt()?;
+        let (adt, _subst) = self.ty.as_adt()?;
        Some(adt.into())
    }
    pub fn as_dyn_trait(&self) -> Option<Trait> {
-        self.ty.value.dyn_trait().map(Into::into)
+        self.ty.dyn_trait().map(Into::into)
    }
    pub fn as_impl_traits(&self, db: &dyn HirDatabase) -> Option<Vec<Trait>> {
-        self.ty.value.impl_trait_bounds(db).map(|it| {
+        self.ty.impl_trait_bounds(db).map(|it| {
            it.into_iter()
-                .filter_map(|pred| match pred {
+                .filter_map(|pred| match pred.skip_binders() {
-                    hir_ty::GenericPredicate::Implemented(trait_ref) => {
+                    hir_ty::WhereClause::Implemented(trait_ref) => {
-                        Some(Trait::from(trait_ref.trait_))
+                        Some(Trait::from(trait_ref.hir_trait_id()))
                    }
                    _ => None,
                })
@@ -2028,14 +2029,11 @@ impl Type {
    }
    pub fn as_associated_type_parent_trait(&self, db: &dyn HirDatabase) -> Option<Trait> {
-        self.ty.value.associated_type_parent_trait(db).map(Into::into)
+        self.ty.associated_type_parent_trait(db).map(Into::into)
    }
    fn derived(&self, ty: Ty) -> Type {
-        Type {
+        Type { krate: self.krate, env: self.env.clone(), ty }
-            krate: self.krate,
-            ty: InEnvironment { value: ty, environment: self.ty.environment.clone() },
-        }
    }
    pub fn walk(&self, db: &dyn HirDatabase, mut cb: impl FnMut(Type)) {
@@ -2056,14 +2054,17 @@ impl Type {
        fn walk_bounds(
            db: &dyn HirDatabase,
            type_: &Type,
-            bounds: &[GenericPredicate],
+            bounds: &[QuantifiedWhereClause],
            cb: &mut impl FnMut(Type),
        ) {
            for pred in bounds {
-                match pred {
+                match pred.skip_binders() {
-                    GenericPredicate::Implemented(trait_ref) => {
+                    WhereClause::Implemented(trait_ref) => {
                        cb(type_.clone());
-                        walk_substs(db, type_, &trait_ref.substs, cb);
+                        // skip the self type. it's likely the type we just got the bounds from
+                        for ty in trait_ref.substitution.iter().skip(1) {
+                            walk_type(db, &type_.derived(ty.clone()), cb);
+                        }
                    }
                    _ => (),
                }
@@ -2071,7 +2072,7 @@ impl Type {
        }
        fn walk_type(db: &dyn HirDatabase, type_: &Type, cb: &mut impl FnMut(Type)) {
-            let ty = type_.ty.value.strip_references();
+            let ty = type_.ty.strip_references();
            match ty.interned(&Interner) {
                TyKind::Adt(..) => {
                    cb(type_.derived(ty.clone()));
@@ -2099,7 +2100,12 @@ impl Type {
                    }
                }
                TyKind::Dyn(bounds) => {
-                    walk_bounds(db, &type_.derived(ty.clone()), bounds.as_ref(), cb);
+                    walk_bounds(
+                        db,
+                        &type_.derived(ty.clone()),
+                        bounds.bounds.skip_binders().interned(),
+                        cb,
+                    );
                }
                TyKind::Ref(_, ty) | TyKind::Raw(_, ty) | TyKind::Array(ty) | TyKind::Slice(ty) => {
@@ -2194,6 +2200,7 @@ pub enum ScopeDef {
    ImplSelfType(Impl),
    AdtSelfType(Adt),
    Local(Local),
+    Label(Label),
    Unknown,
 }
diff --git a/crates/hir/src/semantics.rs b/crates/hir/src/semantics.rs
index 15651bb22..1198e3f0b 100644
--- a/crates/hir/src/semantics.rs
+++ b/crates/hir/src/semantics.rs
@@ -839,6 +839,10 @@ impl<'a> SemanticsScope<'a> {
                    let parent = resolver.body_owner().unwrap();
                    ScopeDef::Local(Local { parent, pat_id })
                }
+                resolver::ScopeDef::Label(label_id) => {
+                    let parent = resolver.body_owner().unwrap();
+                    ScopeDef::Label(Label { parent, label_id })
+                }
            };
            f(name, def)
        })
diff --git a/crates/hir/src/semantics/source_to_def.rs b/crates/hir/src/semantics/source_to_def.rs
index c6ad5ecb5..762809fcd 100644
--- a/crates/hir/src/semantics/source_to_def.rs
+++ b/crates/hir/src/semantics/source_to_def.rs
@@ -195,12 +195,12 @@ impl SourceToDefCtx<'_, '_> {
        &mut self,
        src: InFile<ast::MacroRules>,
    ) -> Option<MacroDefId> {
-        let kind = MacroDefKind::Declarative;
+        let file_ast_id = self.db.ast_id_map(src.file_id).ast_id(&src.value);
+        let ast_id = AstId::new(src.file_id, file_ast_id.upcast());
+        let kind = MacroDefKind::Declarative(ast_id);
        let file_id = src.file_id.original_file(self.db.upcast());
        let krate = self.file_to_def(file_id).get(0).copied()?.krate();
-        let file_ast_id = self.db.ast_id_map(src.file_id).ast_id(&src.value);
+        Some(MacroDefId { krate, kind, local_inner: false })
-        let ast_id = Some(AstId::new(src.file_id, file_ast_id.upcast()));
-        Some(MacroDefId { krate, ast_id, kind, local_inner: false })
    }
    pub(super) fn find_container(&mut self, src: InFile<&SyntaxNode>) -> Option<ChildContainer> {
diff --git a/crates/hir_def/src/attr.rs b/crates/hir_def/src/attr.rs
index e4c84afbf..52a2bce9b 100644
--- a/crates/hir_def/src/attr.rs
+++ b/crates/hir_def/src/attr.rs
@@ -21,7 +21,7 @@ use crate::{
    item_tree::{ItemTreeId, ItemTreeNode},
    nameres::ModuleSource,
    path::{ModPath, PathKind},
-    src::HasChildSource,
+    src::{HasChildSource, HasSource},
    AdtId, AttrDefId, EnumId, GenericParamId, HasModule, LocalEnumVariantId, LocalFieldId, Lookup,
    VariantId,
 };
@@ -51,6 +51,12 @@ pub(crate) struct RawAttrs {
 #[derive(Default, Debug, Clone, PartialEq, Eq)]
 pub struct Attrs(RawAttrs);
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct AttrsWithOwner {
+    attrs: Attrs,
+    owner: AttrDefId,
+}
 impl ops::Deref for RawAttrs {
    type Target = [Attr];
@@ -73,6 +79,14 @@ impl ops::Deref for Attrs {
    }
 }
+impl ops::Deref for AttrsWithOwner {
+    type Target = Attrs;
+    fn deref(&self) -> &Attrs {
+        &self.attrs
+    }
+}
 impl RawAttrs {
    pub(crate) const EMPTY: Self = Self { entries: None };
@@ -169,77 +183,6 @@ impl RawAttrs {
 impl Attrs {
    pub const EMPTY: Self = Self(RawAttrs::EMPTY);
-    pub(crate) fn attrs_query(db: &dyn DefDatabase, def: AttrDefId) -> Attrs {
-        let raw_attrs = match def {
-            AttrDefId::ModuleId(module) => {
-                let def_map = module.def_map(db);
-                let mod_data = &def_map[module.local_id];
-                match mod_data.declaration_source(db) {
-                    Some(it) => {
-                        let raw_attrs = RawAttrs::from_attrs_owner(
-                            db,
-                            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
-                                .merge(RawAttrs::from_attrs_owner(db, InFile::new(file_id, &file))),
-                            _ => raw_attrs,
-                        }
-                    }
-                    None => RawAttrs::from_attrs_owner(
-                        db,
-                        mod_data.definition_source(db).as_ref().map(|src| match src {
-                            ModuleSource::SourceFile(file) => file as &dyn ast::AttrsOwner,
-                            ModuleSource::Module(module) => module as &dyn ast::AttrsOwner,
-                            ModuleSource::BlockExpr(block) => block as &dyn ast::AttrsOwner,
-                        }),
-                    ),
-                }
-            }
-            AttrDefId::FieldId(it) => {
-                return db.fields_attrs(it.parent)[it.local_id].clone();
-            }
-            AttrDefId::EnumVariantId(it) => {
-                return db.variants_attrs(it.parent)[it.local_id].clone();
-            }
-            AttrDefId::AdtId(it) => match it {
-                AdtId::StructId(it) => attrs_from_item_tree(it.lookup(db).id, db),
-                AdtId::EnumId(it) => attrs_from_item_tree(it.lookup(db).id, db),
-                AdtId::UnionId(it) => attrs_from_item_tree(it.lookup(db).id, db),
-            },
-            AttrDefId::TraitId(it) => attrs_from_item_tree(it.lookup(db).id, db),
-            AttrDefId::MacroDefId(it) => {
-                it.ast_id.map_or_else(Default::default, |ast_id| attrs_from_ast(ast_id, db))
-            }
-            AttrDefId::ImplId(it) => attrs_from_item_tree(it.lookup(db).id, db),
-            AttrDefId::ConstId(it) => attrs_from_item_tree(it.lookup(db).id, db),
-            AttrDefId::StaticId(it) => attrs_from_item_tree(it.lookup(db).id, db),
-            AttrDefId::FunctionId(it) => attrs_from_item_tree(it.lookup(db).id, db),
-            AttrDefId::TypeAliasId(it) => attrs_from_item_tree(it.lookup(db).id, db),
-            AttrDefId::GenericParamId(it) => match it {
-                GenericParamId::TypeParamId(it) => {
-                    let src = it.parent.child_source(db);
-                    RawAttrs::from_attrs_owner(
-                        db,
-                        src.with_value(
-                            src.value[it.local_id].as_ref().either(|it| it as _, |it| it as _),
-                        ),
-                    )
-                }
-                GenericParamId::LifetimeParamId(it) => {
-                    let src = it.parent.child_source(db);
-                    RawAttrs::from_attrs_owner(db, src.with_value(&src.value[it.local_id]))
-                }
-                GenericParamId::ConstParamId(it) => {
-                    let src = it.parent.child_source(db);
-                    RawAttrs::from_attrs_owner(db, src.with_value(&src.value[it.local_id]))
-                }
-            },
-        };
-        raw_attrs.filter(db, def.krate(db))
-    }
    pub(crate) fn variants_attrs_query(
        db: &dyn DefDatabase,
        e: EnumId,
@@ -280,13 +223,6 @@ 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 }
    }
@@ -343,6 +279,180 @@ impl Attrs {
    }
 }
+impl AttrsWithOwner {
+    pub(crate) fn attrs_query(db: &dyn DefDatabase, def: AttrDefId) -> Self {
+        // FIXME: this should use `Trace` to avoid duplication in `source_map` below
+        let raw_attrs = match def {
+            AttrDefId::ModuleId(module) => {
+                let def_map = module.def_map(db);
+                let mod_data = &def_map[module.local_id];
+                match mod_data.declaration_source(db) {
+                    Some(it) => {
+                        let raw_attrs = RawAttrs::from_attrs_owner(
+                            db,
+                            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
+                                .merge(RawAttrs::from_attrs_owner(db, InFile::new(file_id, &file))),
+                            _ => raw_attrs,
+                        }
+                    }
+                    None => RawAttrs::from_attrs_owner(
+                        db,
+                        mod_data.definition_source(db).as_ref().map(|src| match src {
+                            ModuleSource::SourceFile(file) => file as &dyn ast::AttrsOwner,
+                            ModuleSource::Module(module) => module as &dyn ast::AttrsOwner,
+                            ModuleSource::BlockExpr(block) => block as &dyn ast::AttrsOwner,
+                        }),
+                    ),
+                }
+            }
+            AttrDefId::FieldId(it) => {
+                return Self { attrs: db.fields_attrs(it.parent)[it.local_id].clone(), owner: def };
+            }
+            AttrDefId::EnumVariantId(it) => {
+                return Self {
+                    attrs: db.variants_attrs(it.parent)[it.local_id].clone(),
+                    owner: def,
+                };
+            }
+            AttrDefId::AdtId(it) => match it {
+                AdtId::StructId(it) => attrs_from_item_tree(it.lookup(db).id, db),
+                AdtId::EnumId(it) => attrs_from_item_tree(it.lookup(db).id, db),
+                AdtId::UnionId(it) => attrs_from_item_tree(it.lookup(db).id, db),
+            },
+            AttrDefId::TraitId(it) => attrs_from_item_tree(it.lookup(db).id, db),
+            AttrDefId::MacroDefId(it) => it
+                .ast_id()
+                .left()
+                .map_or_else(Default::default, |ast_id| attrs_from_ast(ast_id, db)),
+            AttrDefId::ImplId(it) => attrs_from_item_tree(it.lookup(db).id, db),
+            AttrDefId::ConstId(it) => attrs_from_item_tree(it.lookup(db).id, db),
+            AttrDefId::StaticId(it) => attrs_from_item_tree(it.lookup(db).id, db),
+            AttrDefId::FunctionId(it) => attrs_from_item_tree(it.lookup(db).id, db),
+            AttrDefId::TypeAliasId(it) => attrs_from_item_tree(it.lookup(db).id, db),
+            AttrDefId::GenericParamId(it) => match it {
+                GenericParamId::TypeParamId(it) => {
+                    let src = it.parent.child_source(db);
+                    RawAttrs::from_attrs_owner(
+                        db,
+                        src.with_value(
+                            src.value[it.local_id].as_ref().either(|it| it as _, |it| it as _),
+                        ),
+                    )
+                }
+                GenericParamId::LifetimeParamId(it) => {
+                    let src = it.parent.child_source(db);
+                    RawAttrs::from_attrs_owner(db, src.with_value(&src.value[it.local_id]))
+                }
+                GenericParamId::ConstParamId(it) => {
+                    let src = it.parent.child_source(db);
+                    RawAttrs::from_attrs_owner(db, src.with_value(&src.value[it.local_id]))
+                }
+            },
+        };
+        let attrs = raw_attrs.filter(db, def.krate(db));
+        Self { attrs, owner: def }
+    }
+    pub fn source_map(&self, db: &dyn DefDatabase) -> AttrSourceMap {
+        let owner = match self.owner {
+            AttrDefId::ModuleId(module) => {
+                // Modules can have 2 attribute owners (the `mod x;` item, and the module file itself).
+                let def_map = module.def_map(db);
+                let mod_data = &def_map[module.local_id];
+                let attrs = match mod_data.declaration_source(db) {
+                    Some(it) => {
+                        let mut attrs: Vec<_> = collect_attrs(&it.value as &dyn ast::AttrsOwner)
+                            .map(|attr| InFile::new(it.file_id, attr))
+                            .collect();
+                        if let InFile { file_id, value: ModuleSource::SourceFile(file) } =
+                            mod_data.definition_source(db)
+                        {
+                            attrs.extend(
+                                collect_attrs(&file as &dyn ast::AttrsOwner)
+                                    .map(|attr| InFile::new(file_id, attr)),
+                            )
+                        }
+                        attrs
+                    }
+                    None => {
+                        let InFile { file_id, value } = mod_data.definition_source(db);
+                        match &value {
+                            ModuleSource::SourceFile(file) => {
+                                collect_attrs(file as &dyn ast::AttrsOwner)
+                            }
+                            ModuleSource::Module(module) => {
+                                collect_attrs(module as &dyn ast::AttrsOwner)
+                            }
+                            ModuleSource::BlockExpr(block) => {
+                                collect_attrs(block as &dyn ast::AttrsOwner)
+                            }
+                        }
+                        .map(|attr| InFile::new(file_id, attr))
+                        .collect()
+                    }
+                };
+                return AttrSourceMap { attrs };
+            }
+            AttrDefId::FieldId(id) => {
+                id.parent.child_source(db).map(|source| match &source[id.local_id] {
+                    Either::Left(field) => ast::AttrsOwnerNode::new(field.clone()),
+                    Either::Right(field) => ast::AttrsOwnerNode::new(field.clone()),
+                })
+            }
+            AttrDefId::AdtId(adt) => match adt {
+                AdtId::StructId(id) => id.lookup(db).source(db).map(ast::AttrsOwnerNode::new),
+                AdtId::UnionId(id) => id.lookup(db).source(db).map(ast::AttrsOwnerNode::new),
+                AdtId::EnumId(id) => id.lookup(db).source(db).map(ast::AttrsOwnerNode::new),
+            },
+            AttrDefId::FunctionId(id) => id.lookup(db).source(db).map(ast::AttrsOwnerNode::new),
+            AttrDefId::EnumVariantId(id) => id
+                .parent
+                .child_source(db)
+                .map(|source| ast::AttrsOwnerNode::new(source[id.local_id].clone())),
+            AttrDefId::StaticId(id) => id.lookup(db).source(db).map(ast::AttrsOwnerNode::new),
+            AttrDefId::ConstId(id) => id.lookup(db).source(db).map(ast::AttrsOwnerNode::new),
+            AttrDefId::TraitId(id) => id.lookup(db).source(db).map(ast::AttrsOwnerNode::new),
+            AttrDefId::TypeAliasId(id) => id.lookup(db).source(db).map(ast::AttrsOwnerNode::new),
+            AttrDefId::MacroDefId(id) => match id.ast_id() {
+                Either::Left(it) => {
+                    it.with_value(ast::AttrsOwnerNode::new(it.to_node(db.upcast())))
+                }
+                Either::Right(it) => {
+                    it.with_value(ast::AttrsOwnerNode::new(it.to_node(db.upcast())))
+                }
+            },
+            AttrDefId::ImplId(id) => id.lookup(db).source(db).map(ast::AttrsOwnerNode::new),
+            AttrDefId::GenericParamId(id) => match id {
+                GenericParamId::TypeParamId(id) => {
+                    id.parent.child_source(db).map(|source| match &source[id.local_id] {
+                        Either::Left(id) => ast::AttrsOwnerNode::new(id.clone()),
+                        Either::Right(id) => ast::AttrsOwnerNode::new(id.clone()),
+                    })
+                }
+                GenericParamId::LifetimeParamId(id) => id
+                    .parent
+                    .child_source(db)
+                    .map(|source| ast::AttrsOwnerNode::new(source[id.local_id].clone())),
+                GenericParamId::ConstParamId(id) => id
+                    .parent
+                    .child_source(db)
+                    .map(|source| ast::AttrsOwnerNode::new(source[id.local_id].clone())),
+            },
+        };
+        AttrSourceMap {
+            attrs: collect_attrs(&owner.value)
+                .map(|attr| InFile::new(owner.file_id, attr))
+                .collect(),
+        }
+    }
+}
 fn inner_attributes(
    syntax: &SyntaxNode,
 ) -> Option<(impl Iterator<Item = ast::Attr>, impl Iterator<Item = ast::Comment>)> {
@@ -379,7 +489,7 @@ fn inner_attributes(
 }
 pub struct AttrSourceMap {
-    attrs: Vec<Either<ast::Attr, ast::Comment>>,
+    attrs: Vec<InFile<Either<ast::Attr, ast::Comment>>>,
 }
 impl AttrSourceMap {
@@ -389,10 +499,11 @@ impl 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> {
+    pub fn source_of(&self, attr: &Attr) -> InFile<&Either<ast::Attr, ast::Comment>> {
        self.attrs
            .get(attr.index as usize)
            .unwrap_or_else(|| panic!("cannot find `Attr` at index {}", attr.index))
+            .as_ref()
    }
 }
@@ -414,7 +525,7 @@ pub enum AttrInput {
 impl 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 input = if let Some(ast::Expr::Literal(lit)) = ast.expr() {
            let value = match lit.kind() {
                ast::LiteralKind::String(string) => string.value()?.into(),
                _ => lit.syntax().first_token()?.text().trim_matches('"').into(),
@@ -428,18 +539,6 @@ impl Attr {
        Some(Attr { index, path, input })
    }
-    /// Maps this lowered `Attr` back to its original syntax node.
-    ///
-    /// `owner` must be the original owner of the attribute.
-    ///
-    /// 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 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())
-        })
-    }
    /// Parses this attribute as a `#[derive]`, returns an iterator that yields all contained paths
    /// to derive macros.
    ///
@@ -539,7 +638,7 @@ 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))));
+        .map_or((None, None), |(attrs, docs)| (Some(attrs), Some(docs)));
    let outer_attrs = owner.attrs().filter(|attr| attr.excl_token().is_none());
    let attrs = outer_attrs
diff --git a/crates/hir_def/src/body/scope.rs b/crates/hir_def/src/body/scope.rs
index 1bbb54fc6..bd7005ca6 100644
--- a/crates/hir_def/src/body/scope.rs
+++ b/crates/hir_def/src/body/scope.rs
@@ -8,7 +8,7 @@ use rustc_hash::FxHashMap;
 use crate::{
    body::Body,
    db::DefDatabase,
-    expr::{Expr, ExprId, Pat, PatId, Statement},
+    expr::{Expr, ExprId, LabelId, Pat, PatId, Statement},
    BlockId, DefWithBodyId,
 };
@@ -40,6 +40,7 @@ impl ScopeEntry {
 pub struct ScopeData {
    parent: Option<ScopeId>,
    block: Option<BlockId>,
+    label: Option<(LabelId, Name)>,
    entries: Vec<ScopeEntry>,
 }
@@ -67,6 +68,11 @@ impl ExprScopes {
        self.scopes[scope].block
    }
+    /// If `scope` refers to a labeled expression scope, returns the corresponding `Label`.
+    pub fn label(&self, scope: ScopeId) -> Option<(LabelId, Name)> {
+        self.scopes[scope].label.clone()
+    }
    pub fn scope_chain(&self, scope: Option<ScopeId>) -> impl Iterator<Item = ScopeId> + '_ {
        std::iter::successors(scope, move |&scope| self.scopes[scope].parent)
    }
@@ -85,15 +91,34 @@ impl ExprScopes {
    }
    fn root_scope(&mut self) -> ScopeId {
-        self.scopes.alloc(ScopeData { parent: None, block: None, entries: vec![] })
+        self.scopes.alloc(ScopeData { parent: None, block: None, label: None, entries: vec![] })
    }
    fn new_scope(&mut self, parent: ScopeId) -> ScopeId {
-        self.scopes.alloc(ScopeData { parent: Some(parent), block: None, entries: vec![] })
+        self.scopes.alloc(ScopeData {
+            parent: Some(parent),
+            block: None,
+            label: None,
+            entries: vec![],
+        })
    }
-    fn new_block_scope(&mut self, parent: ScopeId, block: BlockId) -> ScopeId {
+    fn new_labeled_scope(&mut self, parent: ScopeId, label: Option<(LabelId, Name)>) -> ScopeId {
-        self.scopes.alloc(ScopeData { parent: Some(parent), block: Some(block), entries: vec![] })
+        self.scopes.alloc(ScopeData { parent: Some(parent), block: None, label, entries: vec![] })
+    }
+    fn new_block_scope(
+        &mut self,
+        parent: ScopeId,
+        block: BlockId,
+        label: Option<(LabelId, Name)>,
+    ) -> ScopeId {
+        self.scopes.alloc(ScopeData {
+            parent: Some(parent),
+            block: Some(block),
+            label,
+            entries: vec![],
+        })
    }
    fn add_bindings(&mut self, body: &Body, scope: ScopeId, pat: PatId) {
@@ -144,21 +169,33 @@ fn compute_block_scopes(
 }
 fn compute_expr_scopes(expr: ExprId, body: &Body, scopes: &mut ExprScopes, scope: ScopeId) {
+    let make_label =
+        |label: &Option<_>| label.map(|label| (label, body.labels[label].name.clone()));
    scopes.set_scope(expr, scope);
    match &body[expr] {
-        Expr::Block { statements, tail, id, .. } => {
+        Expr::Block { statements, tail, id, label } => {
-            let scope = scopes.new_block_scope(scope, *id);
+            let scope = scopes.new_block_scope(scope, *id, make_label(label));
            // Overwrite the old scope for the block expr, so that every block scope can be found
            // via the block itself (important for blocks that only contain items, no expressions).
            scopes.set_scope(expr, scope);
-            compute_block_scopes(&statements, *tail, body, scopes, scope);
+            compute_block_scopes(statements, *tail, body, scopes, scope);
        }
-        Expr::For { iterable, pat, body: body_expr, .. } => {
+        Expr::For { iterable, pat, body: body_expr, label } => {
            compute_expr_scopes(*iterable, body, scopes, scope);
-            let scope = scopes.new_scope(scope);
+            let scope = scopes.new_labeled_scope(scope, make_label(label));
            scopes.add_bindings(body, scope, *pat);
            compute_expr_scopes(*body_expr, body, scopes, scope);
        }
+        Expr::While { condition, body: body_expr, label } => {
+            let scope = scopes.new_labeled_scope(scope, make_label(label));
+            compute_expr_scopes(*condition, body, scopes, scope);
+            compute_expr_scopes(*body_expr, body, scopes, scope);
+        }
+        Expr::Loop { body: body_expr, label } => {
+            let scope = scopes.new_labeled_scope(scope, make_label(label));
+            compute_expr_scopes(*body_expr, body, scopes, scope);
+        }
        Expr::Lambda { args, body: body_expr, .. } => {
            let scope = scopes.new_scope(scope);
            scopes.add_params_bindings(body, scope, &args);
diff --git a/crates/hir_def/src/builtin_attr.rs b/crates/hir_def/src/builtin_attr.rs
index 2e989c504..d5d7f0f47 100644
--- a/crates/hir_def/src/builtin_attr.rs
+++ b/crates/hir_def/src/builtin_attr.rs
@@ -34,9 +34,12 @@ macro_rules! rustc_attr {
    };
 }
-/// Attributes that have a special meaning to rustc or rustdoc.
+/// Built-in macro-like attributes.
+pub const EXTRA_ATTRIBUTES: &[BuiltinAttribute] = &["test", "bench"];
+/// "Inert" built-in attributes that have a special meaning to rustc or rustdoc.
 #[rustfmt::skip]
-pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
+pub const INERT_ATTRIBUTES: &[BuiltinAttribute] = &[
    // ==========================================================================
    // Stable attributes:
    // ==========================================================================
diff --git a/crates/hir_def/src/db.rs b/crates/hir_def/src/db.rs
index 276caf5b3..53df85089 100644
--- a/crates/hir_def/src/db.rs
+++ b/crates/hir_def/src/db.rs
@@ -8,7 +8,7 @@ use syntax::SmolStr;
 use crate::{
    adt::{EnumData, StructData},
-    attr::Attrs,
+    attr::{Attrs, AttrsWithOwner},
    body::{scope::ExprScopes, Body, BodySourceMap},
    data::{ConstData, FunctionData, ImplData, StaticData, TraitData, TypeAliasData},
    generics::GenericParams,
@@ -120,8 +120,8 @@ pub trait DefDatabase: InternDatabase + AstDatabase + Upcast<dyn AstDatabase> {
    #[salsa::invoke(Attrs::fields_attrs_query)]
    fn fields_attrs(&self, def: VariantId) -> Arc<ArenaMap<LocalFieldId, Attrs>>;
-    #[salsa::invoke(Attrs::attrs_query)]
+    #[salsa::invoke(AttrsWithOwner::attrs_query)]
-    fn attrs(&self, def: AttrDefId) -> Attrs;
+    fn attrs(&self, def: AttrDefId) -> AttrsWithOwner;
    #[salsa::invoke(LangItems::crate_lang_items_query)]
    fn crate_lang_items(&self, krate: CrateId) -> Arc<LangItems>;
diff --git a/crates/hir_def/src/import_map.rs b/crates/hir_def/src/import_map.rs
index 369bc3350..960cabb5f 100644
--- a/crates/hir_def/src/import_map.rs
+++ b/crates/hir_def/src/import_map.rs
@@ -912,10 +912,10 @@ mod tests {
                dep::fmt (t)
                dep::format (f)
                dep::Fmt (v)
-                dep::fmt::Display (t)
+                dep::Fmt (m)
                dep::Fmt (t)
                dep::fmt::Display::fmt (a)
-                dep::Fmt (m)
+                dep::fmt::Display (t)
            "#]],
        );
@@ -926,9 +926,9 @@ mod tests {
            expect![[r#"
                dep::fmt (t)
                dep::Fmt (v)
+                dep::Fmt (m)
                dep::Fmt (t)
                dep::fmt::Display::fmt (a)
-                dep::Fmt (m)
            "#]],
        );
@@ -939,10 +939,10 @@ mod tests {
            expect![[r#"
                dep::fmt (t)
                dep::Fmt (v)
-                dep::fmt::Display (t)
+                dep::Fmt (m)
                dep::Fmt (t)
                dep::fmt::Display::fmt (a)
-                dep::Fmt (m)
+                dep::fmt::Display (t)
            "#]],
        );
    }
@@ -980,10 +980,10 @@ mod tests {
            expect![[r#"
                dep::fmt (t)
                dep::Fmt (v)
-                dep::fmt::Display (t)
+                dep::Fmt (m)
                dep::Fmt (t)
                dep::fmt::Display::fmt (a)
-                dep::Fmt (m)
+                dep::fmt::Display (t)
            "#]],
        );
@@ -994,9 +994,9 @@ mod tests {
            expect![[r#"
                dep::fmt (t)
                dep::Fmt (v)
+                dep::Fmt (m)
                dep::Fmt (t)
                dep::fmt::Display::fmt (a)
-                dep::Fmt (m)
            "#]],
        );
    }
@@ -1058,8 +1058,8 @@ mod tests {
            Query::new("".to_string()).limit(2),
            expect![[r#"
                dep::fmt (t)
-                dep::Fmt (t)
                dep::Fmt (m)
+                dep::Fmt (t)
                dep::Fmt (v)
            "#]],
        );
diff --git a/crates/hir_def/src/item_scope.rs b/crates/hir_def/src/item_scope.rs
index aafd73b60..f3ebe7c72 100644
--- a/crates/hir_def/src/item_scope.rs
+++ b/crates/hir_def/src/item_scope.rs
@@ -252,7 +252,7 @@ impl ItemScope {
            .for_each(|vis| *vis = Visibility::Module(this_module));
        for (mac, vis) in self.macros.values_mut() {
-            if let MacroDefKind::ProcMacro(_) = mac.kind {
+            if let MacroDefKind::ProcMacro(..) = mac.kind {
                // FIXME: Technically this is insufficient since reexports of proc macros are also
                // forbidden. Practically nobody does that.
                continue;
diff --git a/crates/hir_def/src/item_tree.rs b/crates/hir_def/src/item_tree.rs
index 5f5b7151a..ae2475b4e 100644
--- a/crates/hir_def/src/item_tree.rs
+++ b/crates/hir_def/src/item_tree.rs
@@ -115,6 +115,10 @@ impl ItemTree {
                    // still need to collect inner items.
                    ctx.lower_inner_items(stmt.syntax())
                },
+                ast::Item(item) => {
+                    // Macros can expand to stmt and other item, and we add it as top level item
+                    ctx.lower_single_item(item)
+                },
                _ => {
                    panic!("cannot create item tree from {:?} {}", syntax, syntax);
                },
diff --git a/crates/hir_def/src/item_tree/lower.rs b/crates/hir_def/src/item_tree/lower.rs
index 3f558edd8..d3fe1ce1e 100644
--- a/crates/hir_def/src/item_tree/lower.rs
+++ b/crates/hir_def/src/item_tree/lower.rs
@@ -87,6 +87,14 @@ impl Ctx {
        self.tree
    }
+    pub(super) fn lower_single_item(mut self, item: ast::Item) -> ItemTree {
+        self.tree.top_level = self
+            .lower_mod_item(&item, false)
+            .map(|item| item.0)
+            .unwrap_or_else(|| Default::default());
+        self.tree
+    }
    pub(super) fn lower_inner_items(mut self, within: &SyntaxNode) -> ItemTree {
        self.collect_inner_items(within);
        self.tree
diff --git a/crates/hir_def/src/lib.rs b/crates/hir_def/src/lib.rs
index 6758411a0..c9e07de86 100644
--- a/crates/hir_def/src/lib.rs
+++ b/crates/hir_def/src/lib.rs
@@ -76,7 +76,11 @@ use stdx::impl_from;
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct ModuleId {
    krate: CrateId,
+    /// If this `ModuleId` was derived from a `DefMap` for a block expression, this stores the
+    /// `BlockId` of that block expression. If `None`, this module is part of the crate-level
+    /// `DefMap` of `krate`.
    block: Option<BlockId>,
+    /// The module's ID in its originating `DefMap`.
    pub local_id: LocalModuleId,
 }
@@ -87,7 +91,7 @@ impl ModuleId {
                db.block_def_map(block).unwrap_or_else(|| {
                    // NOTE: This should be unreachable - all `ModuleId`s come from their `DefMap`s,
                    // so the `DefMap` here must exist.
-                    panic!("no `block_def_map` for `ModuleId` {:?}", self);
+                    unreachable!("no `block_def_map` for `ModuleId` {:?}", self);
                })
            }
            None => db.crate_def_map(self.krate),
@@ -650,7 +654,7 @@ fn macro_call_as_call_id(
 ) -> Result<Result<MacroCallId, ErrorEmitted>, UnresolvedMacro> {
    let def: MacroDefId = resolver(call.path.clone()).ok_or(UnresolvedMacro)?;
-    let res = if let MacroDefKind::BuiltInEager(_) = def.kind {
+    let res = if let MacroDefKind::BuiltInEager(..) = def.kind {
        let macro_call = InFile::new(call.ast_id.file_id, call.ast_id.to_node(db.upcast()));
        let hygiene = Hygiene::new(db.upcast(), call.ast_id.file_id);
@@ -669,7 +673,7 @@ fn macro_call_as_call_id(
    Ok(res)
 }
-fn item_attr_as_call_id(
+fn derive_macro_as_call_id(
    item_attr: &AstIdWithPath<ast::Item>,
    db: &dyn db::DefDatabase,
    krate: CrateId,
@@ -681,7 +685,7 @@ fn item_attr_as_call_id(
        .as_lazy_macro(
            db.upcast(),
            krate,
-            MacroCallKind::Attr(item_attr.ast_id, last_segment.to_string()),
+            MacroCallKind::Derive(item_attr.ast_id, last_segment.to_string()),
        )
        .into();
    Ok(res)
diff --git a/crates/hir_def/src/nameres.rs b/crates/hir_def/src/nameres.rs
index c97be584e..0d3a0b54f 100644
--- a/crates/hir_def/src/nameres.rs
+++ b/crates/hir_def/src/nameres.rs
@@ -53,11 +53,12 @@ mod path_resolution;
 #[cfg(test)]
 mod tests;
+mod proc_macro;
 use std::sync::Arc;
 use base_db::{CrateId, Edition, FileId};
-use hir_expand::{diagnostics::DiagnosticSink, name::Name, InFile};
+use hir_expand::{diagnostics::DiagnosticSink, name::Name, InFile, MacroDefId};
 use la_arena::Arena;
 use profile::Count;
 use rustc_hash::FxHashMap;
@@ -73,6 +74,8 @@ use crate::{
    AstId, BlockId, BlockLoc, LocalModuleId, ModuleDefId, ModuleId,
 };
+use self::proc_macro::ProcMacroDef;
 /// Contains the results of (early) name resolution.
 ///
 /// A `DefMap` stores the module tree and the definitions that are in scope in every module after
@@ -95,6 +98,12 @@ pub struct DefMap {
    prelude: Option<ModuleId>,
    extern_prelude: FxHashMap<Name, ModuleDefId>,
+    /// Side table with additional proc. macro info, for use by name resolution in downstream
+    /// crates.
+    ///
+    /// (the primary purpose is to resolve derive helpers)
+    exported_proc_macros: FxHashMap<MacroDefId, ProcMacroDef>,
    edition: Edition,
    diagnostics: Vec<DefDiagnostic>,
 }
@@ -237,6 +246,7 @@ impl DefMap {
            krate,
            edition,
            extern_prelude: FxHashMap::default(),
+            exported_proc_macros: FxHashMap::default(),
            prelude: None,
            root,
            modules,
@@ -565,7 +575,7 @@ mod diagnostics {
                            let node = ast.to_node(db.upcast());
                            (ast.file_id, SyntaxNodePtr::from(AstPtr::new(&node)), None)
                        }
-                        MacroCallKind::Attr(ast, name) => {
+                        MacroCallKind::Derive(ast, name) => {
                            let node = ast.to_node(db.upcast());
                            // Compute the precise location of the macro name's token in the derive
@@ -621,7 +631,7 @@ mod diagnostics {
                            let node = ast.to_node(db.upcast());
                            (ast.file_id, SyntaxNodePtr::from(AstPtr::new(&node)))
                        }
-                        MacroCallKind::Attr(ast, _) => {
+                        MacroCallKind::Derive(ast, _) => {
                            let node = ast.to_node(db.upcast());
                            (ast.file_id, SyntaxNodePtr::from(AstPtr::new(&node)))
                        }
diff --git a/crates/hir_def/src/nameres/collector.rs b/crates/hir_def/src/nameres/collector.rs
index d0fefb5af..28b73c3a1 100644
--- a/crates/hir_def/src/nameres/collector.rs
+++ b/crates/hir_def/src/nameres/collector.rs
@@ -18,12 +18,11 @@ use hir_expand::{
 use hir_expand::{InFile, MacroCallLoc};
 use rustc_hash::{FxHashMap, FxHashSet};
 use syntax::ast;
-use tt::{Leaf, TokenTree};
 use crate::{
    attr::Attrs,
    db::DefDatabase,
-    item_attr_as_call_id,
+    derive_macro_as_call_id,
    item_scope::{ImportType, PerNsGlobImports},
    item_tree::{
        self, FileItemTreeId, ItemTree, ItemTreeId, MacroCall, MacroRules, Mod, ModItem, ModKind,
@@ -42,6 +41,8 @@ use crate::{
    UnresolvedMacro,
 };
+use super::proc_macro::ProcMacroDef;
 const GLOB_RECURSION_LIMIT: usize = 100;
 const EXPANSION_DEPTH_LIMIT: usize = 128;
 const FIXED_POINT_LIMIT: usize = 8192;
@@ -353,24 +354,23 @@ impl DefCollector<'_> {
    /// use a dummy expander that always errors. This comes with the drawback of macros potentially
    /// going out of sync with what the build system sees (since we resolve using VFS state, but
    /// Cargo builds only on-disk files). We could and probably should add diagnostics for that.
-    fn resolve_proc_macro(&mut self, name: &Name) {
+    fn export_proc_macro(&mut self, def: ProcMacroDef, ast_id: AstId<ast::Fn>) {
        self.exports_proc_macros = true;
-        let macro_def = match self.proc_macros.iter().find(|(n, _)| n == name) {
+        let macro_def = match self.proc_macros.iter().find(|(n, _)| n == &def.name) {
            Some((_, expander)) => MacroDefId {
-                ast_id: None,
                krate: self.def_map.krate,
-                kind: MacroDefKind::ProcMacro(*expander),
+                kind: MacroDefKind::ProcMacro(*expander, ast_id),
                local_inner: false,
            },
            None => MacroDefId {
-                ast_id: None,
                krate: self.def_map.krate,
-                kind: MacroDefKind::ProcMacro(ProcMacroExpander::dummy(self.def_map.krate)),
+                kind: MacroDefKind::ProcMacro(ProcMacroExpander::dummy(self.def_map.krate), ast_id),
                local_inner: false,
            },
        };
-        self.define_proc_macro(name.clone(), macro_def);
+        self.define_proc_macro(def.name.clone(), macro_def);
+        self.def_map.exported_proc_macros.insert(macro_def, def);
    }
    /// Define a macro with `macro_rules`.
@@ -820,8 +820,8 @@ impl DefCollector<'_> {
            true
        });
        attribute_macros.retain(|directive| {
-            match item_attr_as_call_id(&directive.ast_id, self.db, self.def_map.krate, |path| {
+            match derive_macro_as_call_id(&directive.ast_id, self.db, self.def_map.krate, |path| {
-                self.resolve_attribute_macro(&directive, &path)
+                self.resolve_derive_macro(&directive, &path)
            }) {
                Ok(call_id) => {
                    resolved.push((directive.module_id, call_id, 0));
@@ -844,7 +844,7 @@ impl DefCollector<'_> {
        res
    }
-    fn resolve_attribute_macro(
+    fn resolve_derive_macro(
        &self,
        directive: &DeriveDirective,
        path: &ModPath,
@@ -1118,7 +1118,8 @@ impl ModCollector<'_, '_> {
                ModItem::Function(id) => {
                    let func = &self.item_tree[id];
-                    self.collect_proc_macro_def(&func.name, &attrs);
+                    let ast_id = InFile::new(self.file_id, func.ast_id);
+                    self.collect_proc_macro_def(&func.name, ast_id, &attrs);
                    def = Some(DefData {
                        id: FunctionLoc {
@@ -1293,29 +1294,37 @@ impl ModCollector<'_, '_> {
                let db = self.def_collector.db;
                match self.mod_dir.resolve_declaration(db, self.file_id, &module.name, path_attr) {
                    Ok((file_id, is_mod_rs, mod_dir)) => {
-                        let module_id = self.push_child_module(
-                            module.name.clone(),
-                            ast_id,
-                            Some((file_id, is_mod_rs)),
-                            &self.item_tree[module.visibility],
-                        );
                        let item_tree = db.file_item_tree(file_id.into());
-                        ModCollector {
+                        if item_tree
-                            def_collector: &mut *self.def_collector,
+                            .top_level_attrs(db, self.def_collector.def_map.krate)
-                            macro_depth: self.macro_depth,
+                            .cfg()
-                            module_id,
+                            .map_or(true, |cfg| {
-                            file_id: file_id.into(),
+                                self.def_collector.cfg_options.check(&cfg) != Some(false)
-                            item_tree: &item_tree,
+                            })
-                            mod_dir,
-                        }
-                        .collect(item_tree.top_level_items());
-                        if is_macro_use
-                            || item_tree
-                                .top_level_attrs(db, self.def_collector.def_map.krate)
-                                .by_key("macro_use")
-                                .exists()
                        {
-                            self.import_all_legacy_macros(module_id);
+                            let module_id = self.push_child_module(
+                                module.name.clone(),
+                                ast_id,
+                                Some((file_id, is_mod_rs)),
+                                &self.item_tree[module.visibility],
+                            );
+                            ModCollector {
+                                def_collector: &mut *self.def_collector,
+                                macro_depth: self.macro_depth,
+                                module_id,
+                                file_id: file_id.into(),
+                                item_tree: &item_tree,
+                                mod_dir,
+                            }
+                            .collect(item_tree.top_level_items());
+                            if is_macro_use
+                                || item_tree
+                                    .top_level_attrs(db, self.def_collector.def_map.krate)
+                                    .by_key("macro_use")
+                                    .exists()
+                            {
+                                self.import_all_legacy_macros(module_id);
+                            }
                        }
                    }
                    Err(candidate) => {
@@ -1385,28 +1394,11 @@ impl ModCollector<'_, '_> {
    }
    /// If `attrs` registers a procedural macro, collects its definition.
-    fn collect_proc_macro_def(&mut self, func_name: &Name, attrs: &Attrs) {
+    fn collect_proc_macro_def(&mut self, func_name: &Name, ast_id: AstId<ast::Fn>, attrs: &Attrs) {
        // FIXME: this should only be done in the root module of `proc-macro` crates, not everywhere
-        // FIXME: distinguish the type of macro
+        if let Some(proc_macro) = attrs.parse_proc_macro_decl(func_name) {
-        let macro_name = if attrs.by_key("proc_macro").exists()
+            self.def_collector.export_proc_macro(proc_macro, ast_id);
-            || attrs.by_key("proc_macro_attribute").exists()
+        }
-        {
-            func_name.clone()
-        } else {
-            let derive = attrs.by_key("proc_macro_derive");
-            if let Some(arg) = derive.tt_values().next() {
-                if let [TokenTree::Leaf(Leaf::Ident(trait_name)), ..] = &*arg.token_trees {
-                    trait_name.as_name()
-                } else {
-                    log::trace!("malformed `#[proc_macro_derive]`: {}", arg);
-                    return;
-                }
-            } else {
-                return;
-            }
-        };
-        self.def_collector.resolve_proc_macro(&macro_name);
    }
    fn collect_macro_rules(&mut self, id: FileItemTreeId<MacroRules>) {
@@ -1445,9 +1437,8 @@ impl ModCollector<'_, '_> {
        // Case 2: normal `macro_rules!` macro
        let macro_id = MacroDefId {
-            ast_id: Some(ast_id),
            krate: self.def_collector.def_map.krate,
-            kind: MacroDefKind::Declarative,
+            kind: MacroDefKind::Declarative(ast_id),
            local_inner: is_local_inner,
        };
        self.def_collector.define_macro(self.module_id, mac.name.clone(), macro_id, is_export);
@@ -1476,12 +1467,13 @@ impl ModCollector<'_, '_> {
            },
        ) {
            Ok(Ok(macro_call_id)) => {
-                self.def_collector.unexpanded_macros.push(MacroDirective {
+                // Legacy macros need to be expanded immediately, so that any macros they produce
-                    module_id: self.module_id,
+                // are in scope.
-                    ast_id,
+                self.def_collector.collect_macro_expansion(
-                    legacy: Some(macro_call_id),
+                    self.module_id,
-                    depth: self.macro_depth + 1,
+                    macro_call_id,
-                });
+                    self.macro_depth + 1,
+                );
                return;
            }
diff --git a/crates/hir_def/src/nameres/mod_resolution.rs b/crates/hir_def/src/nameres/mod_resolution.rs
index d5de9899c..d9cec0e27 100644
--- a/crates/hir_def/src/nameres/mod_resolution.rs
+++ b/crates/hir_def/src/nameres/mod_resolution.rs
@@ -62,7 +62,7 @@ impl ModDir {
        name: &Name,
        attr_path: Option<&SmolStr>,
    ) -> Result<(FileId, bool, ModDir), String> {
-        let file_id = file_id.original_file(db.upcast());
+        let orig_file_id = file_id.original_file(db.upcast());
        let mut candidate_files = Vec::new();
        match attr_path {
@@ -70,13 +70,18 @@ impl ModDir {
                candidate_files.push(self.dir_path.join_attr(attr_path, self.root_non_dir_owner))
            }
            None => {
-                candidate_files.push(format!("{}{}.rs", self.dir_path.0, name));
+                if file_id.is_include_macro(db.upcast()) {
-                candidate_files.push(format!("{}{}/mod.rs", self.dir_path.0, name));
+                    candidate_files.push(format!("{}.rs", name));
+                    candidate_files.push(format!("{}/mod.rs", name));
+                } else {
+                    candidate_files.push(format!("{}{}.rs", self.dir_path.0, name));
+                    candidate_files.push(format!("{}{}/mod.rs", self.dir_path.0, name));
+                }
            }
        };
        for candidate in candidate_files.iter() {
-            let path = AnchoredPath { anchor: file_id, path: candidate.as_str() };
+            let path = AnchoredPath { anchor: orig_file_id, path: candidate.as_str() };
            if let Some(file_id) = db.resolve_path(path) {
                let is_mod_rs = candidate.ends_with("/mod.rs");
diff --git a/crates/hir_def/src/nameres/proc_macro.rs b/crates/hir_def/src/nameres/proc_macro.rs
new file mode 100644
index 000000000..156598f19
--- /dev/null
+++ b/crates/hir_def/src/nameres/proc_macro.rs
@@ -0,0 +1,71 @@
+//! Nameres-specific procedural macro data and helpers.
+use hir_expand::name::{AsName, Name};
+use tt::{Leaf, TokenTree};
+use crate::attr::Attrs;
+#[derive(Debug, PartialEq, Eq)]
+pub(super) struct ProcMacroDef {
+    pub(super) name: Name,
+    pub(super) kind: ProcMacroKind,
+}
+#[derive(Debug, PartialEq, Eq)]
+pub(super) enum ProcMacroKind {
+    CustomDerive { helpers: Box<[Name]> },
+    FnLike,
+    Attr,
+}
+impl Attrs {
+    #[rustfmt::skip]
+    pub(super) fn parse_proc_macro_decl(&self, func_name: &Name) -> Option<ProcMacroDef> {
+        if self.by_key("proc_macro").exists() {
+            Some(ProcMacroDef { name: func_name.clone(), kind: ProcMacroKind::FnLike })
+        } else if self.by_key("proc_macro_attribute").exists() {
+            Some(ProcMacroDef { name: func_name.clone(), kind: ProcMacroKind::Attr })
+        } else if self.by_key("proc_macro_derive").exists() {
+            let derive = self.by_key("proc_macro_derive").tt_values().next().unwrap();
+            match &*derive.token_trees {
+                // `#[proc_macro_derive(Trait)]`
+                [TokenTree::Leaf(Leaf::Ident(trait_name))] => Some(ProcMacroDef {
+                    name: trait_name.as_name(),
+                    kind: ProcMacroKind::CustomDerive { helpers: Box::new([]) },
+                }),
+                // `#[proc_macro_derive(Trait, attibutes(helper1, helper2, ...))]`
+                [
+                    TokenTree::Leaf(Leaf::Ident(trait_name)),
+                    TokenTree::Leaf(Leaf::Punct(comma)),
+                    TokenTree::Leaf(Leaf::Ident(attributes)),
+                    TokenTree::Subtree(helpers)
+                ] if comma.char == ',' && attributes.text == "attributes" =>
+                {
+                    let helpers = helpers.token_trees.iter()
+                        .filter(|tt| !matches!(tt, TokenTree::Leaf(Leaf::Punct(comma)) if comma.char == ','))
+                        .map(|tt| {
+                            match tt {
+                                TokenTree::Leaf(Leaf::Ident(helper)) => Some(helper.as_name()),
+                                _ => None
+                            }
+                        })
+                        .collect::<Option<Box<[_]>>>()?;
+                    Some(ProcMacroDef {
+                        name: trait_name.as_name(),
+                        kind: ProcMacroKind::CustomDerive { helpers },
+                    })
+                }
+                _ => {
+                    log::trace!("malformed `#[proc_macro_derive]`: {}", derive);
+                    None
+                }
+            }
+        } else {
+            None
+        }
+    }
+}
diff --git a/crates/hir_def/src/nameres/tests/macros.rs b/crates/hir_def/src/nameres/tests/macros.rs
index f65a655bf..6d3cb8d7a 100644
--- a/crates/hir_def/src/nameres/tests/macros.rs
+++ b/crates/hir_def/src/nameres/tests/macros.rs
@@ -1,4 +1,5 @@
 use super::*;
+use crate::nameres::proc_macro::{ProcMacroDef, ProcMacroKind};
 #[test]
 fn macro_rules_are_globally_visible() {
@@ -712,6 +713,27 @@ b! { static = #[] ();}
 }
 #[test]
+fn macros_defining_macros() {
+    check(
+        r#"
+macro_rules! item {
+    ($item:item) => { $item }
+}
+item! {
+    macro_rules! indirect_macro { () => { struct S {} } }
+}
+indirect_macro!();
+    "#,
+        expect![[r#"
+            crate
+            S: t
+        "#]],
+    );
+}
+#[test]
 fn resolves_proc_macros() {
    check(
        r"
@@ -790,3 +812,28 @@ fn proc_macro_censoring() {
        "#]],
    );
 }
+#[test]
+fn collects_derive_helpers() {
+    let def_map = compute_crate_def_map(
+        r"
+        struct TokenStream;
+        #[proc_macro_derive(AnotherTrait, attributes(helper_attr))]
+        pub fn derive_macro_2(_item: TokenStream) -> TokenStream {
+            TokenStream
+        }
+        ",
+    );
+    assert_eq!(def_map.exported_proc_macros.len(), 1);
+    match def_map.exported_proc_macros.values().next() {
+        Some(ProcMacroDef { kind: ProcMacroKind::CustomDerive { helpers }, .. }) => {
+            match &**helpers {
+                [attr] => assert_eq!(attr.to_string(), "helper_attr"),
+                _ => unreachable!(),
+            }
+        }
+        _ => unreachable!(),
+    }
+}
diff --git a/crates/hir_def/src/nameres/tests/mod_resolution.rs b/crates/hir_def/src/nameres/tests/mod_resolution.rs
index dfbbad1f9..16a2cd27a 100644
--- a/crates/hir_def/src/nameres/tests/mod_resolution.rs
+++ b/crates/hir_def/src/nameres/tests/mod_resolution.rs
@@ -819,3 +819,22 @@ pub mod hash { pub trait Hash {} }
        "#]],
    );
 }
+#[test]
+fn cfg_in_module_file() {
+    // Inner `#![cfg]` in a module file makes the whole module disappear.
+    check(
+        r#"
+//- /main.rs
+mod module;
+//- /module.rs
+#![cfg(NEVER)]
+struct AlsoShoulntAppear;
+        "#,
+        expect![[r#"
+            crate
+        "#]],
+    )
+}
diff --git a/crates/hir_def/src/resolver.rs b/crates/hir_def/src/resolver.rs
index 42736171e..04ea9c5d7 100644
--- a/crates/hir_def/src/resolver.rs
+++ b/crates/hir_def/src/resolver.rs
@@ -12,7 +12,7 @@ use crate::{
    body::scope::{ExprScopes, ScopeId},
    builtin_type::BuiltinType,
    db::DefDatabase,
-    expr::{ExprId, PatId},
+    expr::{ExprId, LabelId, PatId},
    generics::GenericParams,
    item_scope::{BuiltinShadowMode, BUILTIN_SCOPE},
    nameres::DefMap,
@@ -409,6 +409,7 @@ pub enum ScopeDef {
    AdtSelfType(AdtId),
    GenericParam(GenericParamId),
    Local(PatId),
+    Label(LabelId),
 }
 impl Scope {
@@ -470,6 +471,9 @@ impl Scope {
                f(name![Self], ScopeDef::AdtSelfType(*i));
            }
            Scope::ExprScope(scope) => {
+                if let Some((label, name)) = scope.expr_scopes.label(scope.scope_id) {
+                    f(name, ScopeDef::Label(label))
+                }
                scope.expr_scopes.entries(scope.scope_id).iter().for_each(|e| {
                    f(e.name().clone(), ScopeDef::Local(e.pat()));
                });
diff --git a/crates/hir_expand/src/builtin_derive.rs b/crates/hir_expand/src/builtin_derive.rs
index 5e908b223..6ece4b289 100644
--- a/crates/hir_expand/src/builtin_derive.rs
+++ b/crates/hir_expand/src/builtin_derive.rs
@@ -61,8 +61,7 @@ pub fn find_builtin_derive(
    let expander = BuiltinDeriveExpander::find_by_name(ident)?;
    Some(MacroDefId {
        krate,
-        ast_id: Some(ast_id),
+        kind: MacroDefKind::BuiltInDerive(expander, ast_id),
-        kind: MacroDefKind::BuiltInDerive(expander),
        local_inner: false,
    })
 }
@@ -268,14 +267,13 @@ fn partial_ord_expand(
 mod tests {
    use base_db::{fixture::WithFixture, CrateId, SourceDatabase};
    use expect_test::{expect, Expect};
-    use name::{known, Name};
+    use name::AsName;
    use crate::{test_db::TestDB, AstId, MacroCallId, MacroCallKind, MacroCallLoc};
    use super::*;
-    fn expand_builtin_derive(ra_fixture: &str, name: Name) -> String {
+    fn expand_builtin_derive(ra_fixture: &str) -> String {
-        let expander = BuiltinDeriveExpander::find_by_name(&name).unwrap();
        let fixture = format!(
            r#"//- /main.rs crate:main deps:core
 $0
@@ -288,23 +286,38 @@ $0
        let (db, file_pos) = TestDB::with_position(&fixture);
        let file_id = file_pos.file_id;
+        let ast_id_map = db.ast_id_map(file_id.into());
        let parsed = db.parse(file_id);
-        let items: Vec<_> =
+        let macros: Vec<_> =
-            parsed.syntax_node().descendants().filter_map(ast::Item::cast).collect();
+            parsed.syntax_node().descendants().filter_map(ast::Macro::cast).collect();
+        let items: Vec<_> = parsed
+            .syntax_node()
+            .descendants()
+            .filter(|node| !ast::Macro::can_cast(node.kind()))
+            .filter_map(ast::Item::cast)
+            .collect();
+        assert_eq!(macros.len(), 1, "test must contain exactly 1 macro definition");
+        assert_eq!(items.len(), 1, "test must contain exactly 1 item");
+        let macro_ast_id = AstId::new(file_id.into(), ast_id_map.ast_id(&macros[0]));
+        let name = match &macros[0] {
+            ast::Macro::MacroRules(rules) => rules.name().unwrap().as_name(),
+            ast::Macro::MacroDef(def) => def.name().unwrap().as_name(),
+        };
-        let ast_id_map = db.ast_id_map(file_id.into());
+        let expander = BuiltinDeriveExpander::find_by_name(&name).unwrap();
        let attr_id = AstId::new(file_id.into(), ast_id_map.ast_id(&items[0]));
        let loc = MacroCallLoc {
            def: MacroDefId {
                krate: CrateId(0),
-                ast_id: None,
+                kind: MacroDefKind::BuiltInDerive(expander, macro_ast_id),
-                kind: MacroDefKind::BuiltInDerive(expander),
                local_inner: false,
            },
            krate: CrateId(0),
-            kind: MacroCallKind::Attr(attr_id, name.to_string()),
+            kind: MacroCallKind::Derive(attr_id, name.to_string()),
        };
        let id: MacroCallId = db.intern_macro(loc).into();
@@ -315,8 +328,8 @@ $0
        parsed.text().to_string()
    }
-    fn check_derive(ra_fixture: &str, name: Name, expected: Expect) {
+    fn check_derive(ra_fixture: &str, expected: Expect) {
-        let expanded = expand_builtin_derive(ra_fixture, name);
+        let expanded = expand_builtin_derive(ra_fixture);
        expected.assert_eq(&expanded);
    }
@@ -324,10 +337,10 @@ $0
    fn test_copy_expand_simple() {
        check_derive(
            r#"
+            macro Copy {}
            #[derive(Copy)]
            struct Foo;
            "#,
-            known::Copy,
            expect![["impl< >core::marker::CopyforFoo< >{}"]],
        );
    }
@@ -336,10 +349,10 @@ $0
    fn test_copy_expand_with_type_params() {
        check_derive(
            r#"
+            macro Copy {}
            #[derive(Copy)]
            struct Foo<A, B>;
            "#,
-            known::Copy,
            expect![["impl<T0:core::marker::Copy,T1:core::marker::Copy>core::marker::CopyforFoo<T0,T1>{}"]],
        );
    }
@@ -348,10 +361,10 @@ $0
    fn test_copy_expand_with_lifetimes() {
        check_derive(
            r#"
+            macro Copy {}
            #[derive(Copy)]
            struct Foo<A, B, 'a, 'b>;
            "#,
-            known::Copy,
            // We currently just ignore lifetimes
            expect![["impl<T0:core::marker::Copy,T1:core::marker::Copy>core::marker::CopyforFoo<T0,T1>{}"]],
        );
@@ -361,10 +374,10 @@ $0
    fn test_clone_expand() {
        check_derive(
            r#"
+            macro Clone {}
            #[derive(Clone)]
            struct Foo<A, B>;
            "#,
-            known::Clone,
            expect![["impl<T0:core::clone::Clone,T1:core::clone::Clone>core::clone::CloneforFoo<T0,T1>{}"]],
        );
    }
diff --git a/crates/hir_expand/src/builtin_macro.rs b/crates/hir_expand/src/builtin_macro.rs
index fce09a9e7..4d52904b9 100644
--- a/crates/hir_expand/src/builtin_macro.rs
+++ b/crates/hir_expand/src/builtin_macro.rs
@@ -43,7 +43,7 @@ macro_rules! register_builtin {
                db: &dyn AstDatabase,
                arg_id: EagerMacroId,
                tt: &tt::Subtree,
-            ) -> ExpandResult<Option<(tt::Subtree, FragmentKind)>> {
+            ) -> ExpandResult<Option<ExpandedEager>> {
                let expander = match *self {
                    $( EagerExpander::$e_kind => $e_expand, )*
                };
@@ -61,6 +61,20 @@ macro_rules! register_builtin {
    };
 }
+#[derive(Debug)]
+pub struct ExpandedEager {
+    pub(crate) subtree: tt::Subtree,
+    pub(crate) fragment: FragmentKind,
+    /// The included file ID of the include macro.
+    pub(crate) included_file: Option<FileId>,
+}
+impl ExpandedEager {
+    fn new(subtree: tt::Subtree, fragment: FragmentKind) -> Self {
+        ExpandedEager { subtree, fragment, included_file: None }
+    }
+}
 pub fn find_builtin_macro(
    ident: &name::Name,
    krate: CrateId,
@@ -71,14 +85,12 @@ pub fn find_builtin_macro(
    match kind {
        Either::Left(kind) => Some(MacroDefId {
            krate,
-            ast_id: Some(ast_id),
+            kind: MacroDefKind::BuiltIn(kind, ast_id),
-            kind: MacroDefKind::BuiltIn(kind),
            local_inner: false,
        }),
        Either::Right(kind) => Some(MacroDefId {
            krate,
-            ast_id: Some(ast_id),
+            kind: MacroDefKind::BuiltInEager(kind, ast_id),
-            kind: MacroDefKind::BuiltInEager(kind),
            local_inner: false,
        }),
    }
@@ -282,7 +294,7 @@ fn compile_error_expand(
    _db: &dyn AstDatabase,
    _id: EagerMacroId,
    tt: &tt::Subtree,
-) -> ExpandResult<Option<(tt::Subtree, FragmentKind)>> {
+) -> ExpandResult<Option<ExpandedEager>> {
    let err = match &*tt.token_trees {
        [tt::TokenTree::Leaf(tt::Leaf::Literal(it))] => {
            let text = it.text.as_str();
@@ -296,14 +308,14 @@ fn compile_error_expand(
        _ => mbe::ExpandError::BindingError("`compile_error!` argument must be a string".into()),
    };
-    ExpandResult { value: Some((quote! {}, FragmentKind::Items)), err: Some(err) }
+    ExpandResult { value: Some(ExpandedEager::new(quote! {}, FragmentKind::Items)), err: Some(err) }
 }
 fn concat_expand(
    _db: &dyn AstDatabase,
    _arg_id: EagerMacroId,
    tt: &tt::Subtree,
-) -> ExpandResult<Option<(tt::Subtree, FragmentKind)>> {
+) -> ExpandResult<Option<ExpandedEager>> {
    let mut err = None;
    let mut text = String::new();
    for (i, t) in tt.token_trees.iter().enumerate() {
@@ -327,7 +339,7 @@ fn concat_expand(
            }
        }
    }
-    ExpandResult { value: Some((quote!(#text), FragmentKind::Expr)), err }
+    ExpandResult { value: Some(ExpandedEager::new(quote!(#text), FragmentKind::Expr)), err }
 }
 fn relative_file(
@@ -363,21 +375,27 @@ fn include_expand(
    db: &dyn AstDatabase,
    arg_id: EagerMacroId,
    tt: &tt::Subtree,
-) -> ExpandResult<Option<(tt::Subtree, FragmentKind)>> {
+) -> ExpandResult<Option<ExpandedEager>> {
    let res = (|| {
        let path = parse_string(tt)?;
        let file_id = relative_file(db, arg_id.into(), &path, false)?;
-        Ok(parse_to_token_tree(&db.file_text(file_id))
+        let subtree = parse_to_token_tree(&db.file_text(file_id))
            .ok_or_else(|| mbe::ExpandError::ConversionError)?
-            .0)
+            .0;
+        Ok((subtree, file_id))
    })();
    match res {
-        Ok(res) => {
+        Ok((subtree, file_id)) => {
            // FIXME:
            // Handle include as expression
-            ExpandResult::ok(Some((res, FragmentKind::Items)))
+            ExpandResult::ok(Some(ExpandedEager {
+                subtree,
+                fragment: FragmentKind::Items,
+                included_file: Some(file_id),
+            }))
        }
        Err(e) => ExpandResult::only_err(e),
    }
@@ -387,7 +405,7 @@ fn include_bytes_expand(
    _db: &dyn AstDatabase,
    _arg_id: EagerMacroId,
    tt: &tt::Subtree,
-) -> ExpandResult<Option<(tt::Subtree, FragmentKind)>> {
+) -> ExpandResult<Option<ExpandedEager>> {
    if let Err(e) = parse_string(tt) {
        return ExpandResult::only_err(e);
    }
@@ -400,14 +418,14 @@ fn include_bytes_expand(
            id: tt::TokenId::unspecified(),
        }))],
    };
-    ExpandResult::ok(Some((res, FragmentKind::Expr)))
+    ExpandResult::ok(Some(ExpandedEager::new(res, FragmentKind::Expr)))
 }
 fn include_str_expand(
    db: &dyn AstDatabase,
    arg_id: EagerMacroId,
    tt: &tt::Subtree,
-) -> ExpandResult<Option<(tt::Subtree, FragmentKind)>> {
+) -> ExpandResult<Option<ExpandedEager>> {
    let path = match parse_string(tt) {
        Ok(it) => it,
        Err(e) => return ExpandResult::only_err(e),
@@ -420,14 +438,14 @@ fn include_str_expand(
    let file_id = match relative_file(db, arg_id.into(), &path, true) {
        Ok(file_id) => file_id,
        Err(_) => {
-            return ExpandResult::ok(Some((quote!(""), FragmentKind::Expr)));
+            return ExpandResult::ok(Some(ExpandedEager::new(quote!(""), FragmentKind::Expr)));
        }
    };
    let text = db.file_text(file_id);
    let text = &*text;
-    ExpandResult::ok(Some((quote!(#text), FragmentKind::Expr)))
+    ExpandResult::ok(Some(ExpandedEager::new(quote!(#text), FragmentKind::Expr)))
 }
 fn get_env_inner(db: &dyn AstDatabase, arg_id: EagerMacroId, key: &str) -> Option<String> {
@@ -439,7 +457,7 @@ fn env_expand(
    db: &dyn AstDatabase,
    arg_id: EagerMacroId,
    tt: &tt::Subtree,
-) -> ExpandResult<Option<(tt::Subtree, FragmentKind)>> {
+) -> ExpandResult<Option<ExpandedEager>> {
    let key = match parse_string(tt) {
        Ok(it) => it,
        Err(e) => return ExpandResult::only_err(e),
@@ -463,14 +481,14 @@ fn env_expand(
    });
    let expanded = quote! { #s };
-    ExpandResult { value: Some((expanded, FragmentKind::Expr)), err }
+    ExpandResult { value: Some(ExpandedEager::new(expanded, FragmentKind::Expr)), err }
 }
 fn option_env_expand(
    db: &dyn AstDatabase,
    arg_id: EagerMacroId,
    tt: &tt::Subtree,
-) -> ExpandResult<Option<(tt::Subtree, FragmentKind)>> {
+) -> ExpandResult<Option<ExpandedEager>> {
    let key = match parse_string(tt) {
        Ok(it) => it,
        Err(e) => return ExpandResult::only_err(e),
@@ -481,7 +499,7 @@ fn option_env_expand(
        Some(s) => quote! { std::option::Some(#s) },
    };
-    ExpandResult::ok(Some((expanded, FragmentKind::Expr)))
+    ExpandResult::ok(Some(ExpandedEager::new(expanded, FragmentKind::Expr)))
 }
 #[cfg(test)]
@@ -512,6 +530,7 @@ mod tests {
        let macro_call = macro_calls.pop().unwrap();
        let expander = find_by_name(&macro_rules.name().unwrap().as_name()).unwrap();
+        let ast_id = AstId::new(file_id.into(), ast_id_map.ast_id(&macro_rules));
        let krate = CrateId(0);
        let file_id = match expander {
@@ -519,8 +538,7 @@ mod tests {
                // the first one should be a macro_rules
                let def = MacroDefId {
                    krate: CrateId(0),
-                    ast_id: Some(AstId::new(file_id.into(), ast_id_map.ast_id(&macro_rules))),
+                    kind: MacroDefKind::BuiltIn(expander, ast_id),
-                    kind: MacroDefKind::BuiltIn(expander),
                    local_inner: false,
                };
@@ -540,8 +558,7 @@ mod tests {
                // the first one should be a macro_rules
                let def = MacroDefId {
                    krate,
-                    ast_id: Some(AstId::new(file_id.into(), ast_id_map.ast_id(&macro_rules))),
+                    kind: MacroDefKind::BuiltInEager(expander, ast_id),
-                    kind: MacroDefKind::BuiltInEager(expander),
                    local_inner: false,
                };
@@ -556,16 +573,18 @@ mod tests {
                        subtree: Arc::new(parsed_args.clone()),
                        krate,
                        call: call_id,
+                        included_file: None,
                    }
                });
-                let (subtree, fragment) = expander.expand(&db, arg_id, &parsed_args).value.unwrap();
+                let expanded = expander.expand(&db, arg_id, &parsed_args).value.unwrap();
                let eager = EagerCallLoc {
                    def,
-                    fragment,
+                    fragment: expanded.fragment,
-                    subtree: Arc::new(subtree),
+                    subtree: Arc::new(expanded.subtree),
                    krate,
                    call: call_id,
+                    included_file: expanded.included_file,
                };
                let id: MacroCallId = db.intern_eager_expansion(eager).into();
diff --git a/crates/hir_expand/src/db.rs b/crates/hir_expand/src/db.rs
index a3070f1f9..fc73e435b 100644
--- a/crates/hir_expand/src/db.rs
+++ b/crates/hir_expand/src/db.rs
@@ -130,8 +130,8 @@ fn ast_id_map(db: &dyn AstDatabase, file_id: HirFileId) -> Arc<AstIdMap> {
 fn macro_def(db: &dyn AstDatabase, id: MacroDefId) -> Option<Arc<(TokenExpander, mbe::TokenMap)>> {
    match id.kind {
-        MacroDefKind::Declarative => {
+        MacroDefKind::Declarative(ast_id) => {
-            let macro_rules = match id.ast_id?.to_node(db) {
+            let macro_rules = match ast_id.to_node(db) {
                syntax::ast::Macro::MacroRules(mac) => mac,
                syntax::ast::Macro::MacroDef(_) => return None,
            };
@@ -150,14 +150,14 @@ fn macro_def(db: &dyn AstDatabase, id: MacroDefId) -> Option<Arc<(TokenExpander,
            };
            Some(Arc::new((TokenExpander::MacroRules(rules), tmap)))
        }
-        MacroDefKind::BuiltIn(expander) => {
+        MacroDefKind::BuiltIn(expander, _) => {
            Some(Arc::new((TokenExpander::Builtin(expander), mbe::TokenMap::default())))
        }
-        MacroDefKind::BuiltInDerive(expander) => {
+        MacroDefKind::BuiltInDerive(expander, _) => {
            Some(Arc::new((TokenExpander::BuiltinDerive(expander), mbe::TokenMap::default())))
        }
-        MacroDefKind::BuiltInEager(_) => None,
+        MacroDefKind::BuiltInEager(..) => None,
-        MacroDefKind::ProcMacro(expander) => {
+        MacroDefKind::ProcMacro(expander, ..) => {
            Some(Arc::new((TokenExpander::ProcMacro(expander), mbe::TokenMap::default())))
        }
    }
@@ -173,7 +173,7 @@ fn macro_arg_text(db: &dyn AstDatabase, id: MacroCallId) -> Option<GreenNode> {
    };
    let loc = db.lookup_intern_macro(id);
    let arg = loc.kind.arg(db)?;
-    Some(arg.green().to_owned())
+    Some(arg.green())
 }
 fn macro_arg(db: &dyn AstDatabase, id: MacroCallId) -> Option<Arc<(tt::Subtree, mbe::TokenMap)>> {
@@ -269,7 +269,7 @@ fn expand_proc_macro(
    };
    let expander = match loc.def.kind {
-        MacroDefKind::ProcMacro(expander) => expander,
+        MacroDefKind::ProcMacro(expander, ..) => expander,
        _ => unreachable!(),
    };
diff --git a/crates/hir_expand/src/eager.rs b/crates/hir_expand/src/eager.rs
index dc618a9ee..9eedc8461 100644
--- a/crates/hir_expand/src/eager.rs
+++ b/crates/hir_expand/src/eager.rs
@@ -124,6 +124,7 @@ pub fn expand_eager_macro(
            subtree: Arc::new(parsed_args.clone()),
            krate,
            call: call_id,
+            included_file: None,
        }
    });
    let arg_file_id: MacroCallId = arg_id.into();
@@ -140,12 +141,18 @@ pub fn expand_eager_macro(
    let subtree =
        diagnostic_sink.option(to_subtree(&result), || err("failed to parse macro result"))?;
-    if let MacroDefKind::BuiltInEager(eager) = def.kind {
+    if let MacroDefKind::BuiltInEager(eager, _) = def.kind {
        let res = eager.expand(db, arg_id, &subtree);
-        let (subtree, fragment) = diagnostic_sink.expand_result_option(res)?;
+        let expanded = diagnostic_sink.expand_result_option(res)?;
-        let eager =
+        let eager = EagerCallLoc {
-            EagerCallLoc { def, fragment, subtree: Arc::new(subtree), krate, call: call_id };
+            def,
+            fragment: expanded.fragment,
+            subtree: Arc::new(expanded.subtree),
+            krate,
+            call: call_id,
+            included_file: expanded.included_file,
+        };
        Ok(db.intern_eager_expansion(eager))
    } else {
@@ -193,7 +200,7 @@ fn eager_macro_recur(
        let def = diagnostic_sink
            .option_with(|| macro_resolver(child.path()?), || err("failed to resolve macro"))?;
        let insert = match def.kind {
-            MacroDefKind::BuiltInEager(_) => {
+            MacroDefKind::BuiltInEager(..) => {
                let id: MacroCallId = expand_eager_macro(
                    db,
                    krate,
@@ -206,10 +213,10 @@ fn eager_macro_recur(
                db.parse_or_expand(id.as_file())
                    .expect("successful macro expansion should be parseable")
            }
-            MacroDefKind::Declarative
+            MacroDefKind::Declarative(_)
-            | MacroDefKind::BuiltIn(_)
+            | MacroDefKind::BuiltIn(..)
-            | MacroDefKind::BuiltInDerive(_)
+            | MacroDefKind::BuiltInDerive(..)
-            | MacroDefKind::ProcMacro(_) => {
+            | MacroDefKind::ProcMacro(..) => {
                let res = lazy_expand(db, &def, curr.with_value(child.clone()), krate);
                let val = diagnostic_sink.expand_result_option(res)?;
diff --git a/crates/hir_expand/src/hygiene.rs b/crates/hir_expand/src/hygiene.rs
index 87cad326d..0e0f7214a 100644
--- a/crates/hir_expand/src/hygiene.rs
+++ b/crates/hir_expand/src/hygiene.rs
@@ -145,7 +145,7 @@ fn make_hygiene_info(
 ) -> Option<HygieneInfo> {
    let arg_tt = loc.kind.arg(db)?;
-    let def_offset = loc.def.ast_id.and_then(|id| {
+    let def_offset = loc.def.ast_id().left().and_then(|id| {
        let def_tt = match id.to_node(db) {
            ast::Macro::MacroRules(mac) => mac.token_tree()?.syntax().text_range().start(),
            ast::Macro::MacroDef(_) => return None,
@@ -176,13 +176,13 @@ impl HygieneFrame {
                    let loc = db.lookup_intern_macro(id);
                    let info = make_hygiene_info(db, macro_file, &loc);
                    match loc.def.kind {
-                        MacroDefKind::Declarative => {
+                        MacroDefKind::Declarative(_) => {
                            (info, Some(loc.def.krate), loc.def.local_inner)
                        }
-                        MacroDefKind::BuiltIn(_) => (info, Some(loc.def.krate), false),
+                        MacroDefKind::BuiltIn(..) => (info, Some(loc.def.krate), false),
-                        MacroDefKind::BuiltInDerive(_) => (info, None, false),
+                        MacroDefKind::BuiltInDerive(..) => (info, None, false),
-                        MacroDefKind::BuiltInEager(_) => (info, None, false),
+                        MacroDefKind::BuiltInEager(..) => (info, None, false),
-                        MacroDefKind::ProcMacro(_) => (info, None, false),
+                        MacroDefKind::ProcMacro(..) => (info, None, false),
                    }
                }
            },
diff --git a/crates/hir_expand/src/lib.rs b/crates/hir_expand/src/lib.rs
index 7532d00b8..b8045fda9 100644
--- a/crates/hir_expand/src/lib.rs
+++ b/crates/hir_expand/src/lib.rs
@@ -15,6 +15,7 @@ pub mod proc_macro;
 pub mod quote;
 pub mod eager;
+use either::Either;
 pub use mbe::{ExpandError, ExpandResult};
 use std::hash::Hash;
@@ -83,7 +84,11 @@ impl HirFileId {
                    }
                    MacroCallId::EagerMacro(id) => {
                        let loc = db.lookup_intern_eager_expansion(id);
-                        loc.call.file_id
+                        if let Some(included_file) = loc.included_file {
+                            return included_file;
+                        } else {
+                            loc.call.file_id
+                        }
                    }
                };
                file_id.original_file(db)
@@ -143,7 +148,7 @@ impl HirFileId {
                let arg_tt = loc.kind.arg(db)?;
-                let def = loc.def.ast_id.and_then(|id| {
+                let def = loc.def.ast_id().left().and_then(|id| {
                    let def_tt = match id.to_node(db) {
                        ast::Macro::MacroRules(mac) => mac.token_tree()?,
                        ast::Macro::MacroDef(_) => return None,
@@ -180,13 +185,28 @@ impl HirFileId {
                };
                let loc: MacroCallLoc = db.lookup_intern_macro(lazy_id);
                let item = match loc.def.kind {
-                    MacroDefKind::BuiltInDerive(_) => loc.kind.node(db),
+                    MacroDefKind::BuiltInDerive(..) => loc.kind.node(db),
                    _ => return None,
                };
                Some(item.with_value(ast::Item::cast(item.value.clone())?))
            }
        }
    }
+    /// Return whether this file is an include macro
+    pub fn is_include_macro(&self, db: &dyn db::AstDatabase) -> bool {
+        match self.0 {
+            HirFileIdRepr::MacroFile(macro_file) => match macro_file.macro_call_id {
+                MacroCallId::EagerMacro(id) => {
+                    let loc = db.lookup_intern_eager_expansion(id);
+                    return loc.included_file.is_some();
+                }
+                _ => {}
+            },
+            _ => {}
+        }
+        false
+    }
 }
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -224,7 +244,6 @@ impl From<EagerMacroId> for MacroCallId {
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct MacroDefId {
    pub krate: CrateId,
-    pub ast_id: Option<AstId<ast::Macro>>,
    pub kind: MacroDefKind,
    pub local_inner: bool,
@@ -239,16 +258,27 @@ impl MacroDefId {
    ) -> LazyMacroId {
        db.intern_macro(MacroCallLoc { def: self, krate, kind })
    }
+    pub fn ast_id(&self) -> Either<AstId<ast::Macro>, AstId<ast::Fn>> {
+        let id = match &self.kind {
+            MacroDefKind::Declarative(id) => id,
+            MacroDefKind::BuiltIn(_, id) => id,
+            MacroDefKind::BuiltInDerive(_, id) => id,
+            MacroDefKind::BuiltInEager(_, id) => id,
+            MacroDefKind::ProcMacro(_, id) => return Either::Right(*id),
+        };
+        Either::Left(*id)
+    }
 }
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum MacroDefKind {
-    Declarative,
+    Declarative(AstId<ast::Macro>),
-    BuiltIn(BuiltinFnLikeExpander),
+    BuiltIn(BuiltinFnLikeExpander, AstId<ast::Macro>),
    // FIXME: maybe just Builtin and rename BuiltinFnLikeExpander to BuiltinExpander
-    BuiltInDerive(BuiltinDeriveExpander),
+    BuiltInDerive(BuiltinDeriveExpander, AstId<ast::Macro>),
-    BuiltInEager(EagerExpander),
+    BuiltInEager(EagerExpander, AstId<ast::Macro>),
-    ProcMacro(ProcMacroExpander),
+    ProcMacro(ProcMacroExpander, AstId<ast::Fn>),
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -261,21 +291,21 @@ pub struct MacroCallLoc {
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum MacroCallKind {
    FnLike(AstId<ast::MacroCall>),
-    Attr(AstId<ast::Item>, String),
+    Derive(AstId<ast::Item>, String),
 }
 impl MacroCallKind {
    fn file_id(&self) -> HirFileId {
        match self {
            MacroCallKind::FnLike(ast_id) => ast_id.file_id,
-            MacroCallKind::Attr(ast_id, _) => ast_id.file_id,
+            MacroCallKind::Derive(ast_id, _) => ast_id.file_id,
        }
    }
    fn node(&self, db: &dyn db::AstDatabase) -> InFile<SyntaxNode> {
        match self {
            MacroCallKind::FnLike(ast_id) => ast_id.with_value(ast_id.to_node(db).syntax().clone()),
-            MacroCallKind::Attr(ast_id, _) => {
+            MacroCallKind::Derive(ast_id, _) => {
                ast_id.with_value(ast_id.to_node(db).syntax().clone())
            }
        }
@@ -286,7 +316,7 @@ impl MacroCallKind {
            MacroCallKind::FnLike(ast_id) => {
                Some(ast_id.to_node(db).token_tree()?.syntax().clone())
            }
-            MacroCallKind::Attr(ast_id, _) => Some(ast_id.to_node(db).syntax().clone()),
+            MacroCallKind::Derive(ast_id, _) => Some(ast_id.to_node(db).syntax().clone()),
        }
    }
 }
@@ -304,6 +334,8 @@ pub struct EagerCallLoc {
    pub(crate) subtree: Arc<tt::Subtree>,
    pub(crate) krate: CrateId,
    pub(crate) call: AstId<ast::MacroCall>,
+    // The included file ID of the include macro.
+    pub(crate) included_file: Option<FileId>,
 }
 /// ExpansionInfo mainly describes how to map text range between src and expanded macro
diff --git a/crates/hir_expand/src/name.rs b/crates/hir_expand/src/name.rs
index 43de9edd6..0aeea48d5 100644
--- a/crates/hir_expand/src/name.rs
+++ b/crates/hir_expand/src/name.rs
@@ -48,9 +48,8 @@ impl Name {
    /// Resolve a name from the text of token.
    fn resolve(raw_text: &str) -> Name {
-        let raw_start = "r#";
+        if let Some(text) = raw_text.strip_prefix("r#") {
-        if raw_text.starts_with(raw_start) {
+            Name::new_text(SmolStr::new(text))
-            Name::new_text(SmolStr::new(&raw_text[raw_start.len()..]))
        } else {
            Name::new_text(raw_text.into())
        }
diff --git a/crates/hir_ty/src/autoderef.rs b/crates/hir_ty/src/autoderef.rs
index bd2ff5d38..dc5fc759a 100644
--- a/crates/hir_ty/src/autoderef.rs
+++ b/crates/hir_ty/src/autoderef.rs
@@ -6,16 +6,18 @@
 use std::iter::successors;
 use base_db::CrateId;
+use chalk_ir::cast::Cast;
 use hir_def::lang_item::LangItemTarget;
 use hir_expand::name::name;
 use log::{info, warn};
 use crate::{
    db::HirDatabase,
-    to_assoc_type_id,
+    to_assoc_type_id, to_chalk_trait_id,
    traits::{InEnvironment, Solution},
    utils::generics,
-    BoundVar, Canonical, DebruijnIndex, Interner, Obligation, Substitution, TraitRef, Ty, TyKind,
+    AliasEq, AliasTy, BoundVar, Canonical, CanonicalVarKinds, DebruijnIndex, Interner,
+    ProjectionTy, Substitution, TraitRef, Ty, TyKind,
 };
 const AUTODEREF_RECURSION_LIMIT: usize = 10;
@@ -25,9 +27,9 @@ pub fn autoderef<'a>(
    krate: Option<CrateId>,
    ty: InEnvironment<Canonical<Ty>>,
 ) -> impl Iterator<Item = Canonical<Ty>> + 'a {
-    let InEnvironment { value: ty, environment } = ty;
+    let InEnvironment { goal: ty, environment } = ty;
    successors(Some(ty), move |ty| {
-        deref(db, krate?, InEnvironment { value: ty, environment: environment.clone() })
+        deref(db, krate?, InEnvironment { goal: ty, environment: environment.clone() })
    })
    .take(AUTODEREF_RECURSION_LIMIT)
 }
@@ -37,8 +39,8 @@ pub(crate) fn deref(
    krate: CrateId,
    ty: InEnvironment<&Canonical<Ty>>,
 ) -> Option<Canonical<Ty>> {
-    if let Some(derefed) = ty.value.value.builtin_deref() {
+    if let Some(derefed) = ty.goal.value.builtin_deref() {
-        Some(Canonical { value: derefed, kinds: ty.value.kinds.clone() })
+        Some(Canonical { value: derefed, binders: ty.goal.binders.clone() })
    } else {
        deref_by_trait(db, krate, ty)
    }
@@ -65,14 +67,15 @@ fn deref_by_trait(
    // FIXME make the Canonical / bound var handling nicer
    let parameters =
-        Substitution::build_for_generics(&generic_params).push(ty.value.value.clone()).build();
+        Substitution::build_for_generics(&generic_params).push(ty.goal.value.clone()).build();
    // Check that the type implements Deref at all
-    let trait_ref = TraitRef { trait_: deref_trait, substs: parameters.clone() };
+    let trait_ref =
+        TraitRef { trait_id: to_chalk_trait_id(deref_trait), substitution: parameters.clone() };
    let implements_goal = Canonical {
-        kinds: ty.value.kinds.clone(),
+        binders: ty.goal.binders.clone(),
        value: InEnvironment {
-            value: Obligation::Trait(trait_ref),
+            goal: trait_ref.cast(&Interner),
            environment: ty.environment.clone(),
        },
    };
@@ -81,23 +84,32 @@ fn deref_by_trait(
    }
    // Now do the assoc type projection
-    let projection = super::traits::ProjectionPredicate {
+    let projection = AliasEq {
-        ty: TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, ty.value.kinds.len()))
+        alias: AliasTy::Projection(ProjectionTy {
-            .intern(&Interner),
-        projection_ty: super::ProjectionTy {
            associated_ty_id: to_assoc_type_id(target),
            substitution: parameters,
-        },
+        }),
+        ty: TyKind::BoundVar(BoundVar::new(
+            DebruijnIndex::INNERMOST,
+            ty.goal.binders.len(&Interner),
+        ))
+        .intern(&Interner),
    };
-    let obligation = super::Obligation::Projection(projection);
+    let obligation = projection.cast(&Interner);
-    let in_env = InEnvironment { value: obligation, environment: ty.environment };
+    let in_env = InEnvironment { goal: obligation, environment: ty.environment };
-    let canonical = Canonical::new(
+    let canonical = Canonical {
-        in_env,
+        value: in_env,
-        ty.value.kinds.iter().copied().chain(Some(chalk_ir::TyVariableKind::General)),
+        binders: CanonicalVarKinds::from_iter(
-    );
+            &Interner,
+            ty.goal.binders.iter(&Interner).cloned().chain(Some(chalk_ir::WithKind::new(
+                chalk_ir::VariableKind::Ty(chalk_ir::TyVariableKind::General),
+                chalk_ir::UniverseIndex::ROOT,
+            ))),
+        ),
+    };
    let solution = db.trait_solve(krate, canonical)?;
@@ -118,21 +130,21 @@ fn deref_by_trait(
            // assumptions will be broken. We would need to properly introduce
            // new variables in that case
-            for i in 1..vars.0.kinds.len() {
+            for i in 1..vars.0.binders.len(&Interner) {
                if vars.0.value[i - 1].interned(&Interner)
                    != &TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, i - 1))
                {
-                    warn!("complex solution for derefing {:?}: {:?}, ignoring", ty.value, solution);
+                    warn!("complex solution for derefing {:?}: {:?}, ignoring", ty.goal, solution);
                    return None;
                }