54 files changed, 746 insertions, 371 deletions
diff --git a/crates/hir/src/has_source.rs b/crates/hir/src/has_source.rs
index 262002671..d57fad9ed 100644
--- a/crates/hir/src/has_source.rs
+++ b/crates/hir/src/has_source.rs
@@ -6,7 +6,7 @@ use hir_def::{
    src::{HasChildSource, HasSource as _},
    Lookup, VariantId,
 };
-use hir_expand::InFile;
+use hir_expand::{InFile, MacroDefKind};
 use syntax::ast;
 use crate::{
@@ -111,10 +111,17 @@ 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(match &self.id.kind {
-        Some(InFile { file_id: ast_id.file_id, value: ast_id.to_node(db.upcast()) })
+            MacroDefKind::Declarative(id)
+            | MacroDefKind::BuiltIn(_, id)
+            | MacroDefKind::BuiltInDerive(_, id)
+            | MacroDefKind::BuiltInEager(_, id) => {
+                id.with_value(Either::Left(id.to_node(db.upcast())))
+            }
+            MacroDefKind::ProcMacro(_, id) => id.map(|_| 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..5ebd0a3b8 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, DebruijnIndex,
-    InEnvironment, Interner, Obligation, ProjectionPredicate, ProjectionTy, Scalar, Substitution,
+    GenericPredicate, InEnvironment, Interner, Obligation, ProjectionTy, Scalar, Substitution, Ty,
-    Ty, TyDefId, TyKind, TyVariableKind,
+    TyDefId, TyKind, TyVariableKind,
 };
 use itertools::Itertools;
 use rustc_hash::FxHashSet;
@@ -1144,17 +1144,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(..))
    }
 }
@@ -1458,7 +1462,7 @@ impl TypeParam {
            .into_iter()
            .filter_map(|pred| match &pred.value {
                hir_ty::GenericPredicate::Implemented(trait_ref) => {
-                    Some(Trait::from(trait_ref.trait_))
+                    Some(Trait::from(trait_ref.hir_trait_id()))
                }
                _ => None,
            })
@@ -1753,8 +1757,8 @@ 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())
                .fill(args.iter().map(|t| t.ty.value.clone()))
                .build(),
@@ -1782,17 +1786,17 @@ impl Type {
            .push(self.ty.value.clone())
            .fill(args.iter().map(|t| t.ty.value.clone()))
            .build();
-        let predicate = ProjectionPredicate {
-            projection_ty: ProjectionTy {
-                associated_ty_id: to_assoc_type_id(alias.id),
-                substitution: subst,
-            },
-            ty: TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0)).intern(&Interner),
-        };
        let goal = Canonical {
            value: InEnvironment::new(
                self.ty.environment.clone(),
-                Obligation::Projection(predicate),
+                Obligation::AliasEq(AliasEq {
+                    alias: AliasTy::Projection(ProjectionTy {
+                        associated_ty_id: to_assoc_type_id(alias.id),
+                        substitution: subst,
+                    }),
+                    ty: TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0))
+                        .intern(&Interner),
+                }),
            ),
            kinds: Arc::new([TyVariableKind::General]),
        };
@@ -2019,7 +2023,7 @@ impl Type {
            it.into_iter()
                .filter_map(|pred| match pred {
                    hir_ty::GenericPredicate::Implemented(trait_ref) => {
-                        Some(Trait::from(trait_ref.trait_))
+                        Some(Trait::from(trait_ref.hir_trait_id()))
                    }
                    _ => None,
                })
@@ -2063,7 +2067,7 @@ impl Type {
                match pred {
                    GenericPredicate::Implemented(trait_ref) => {
                        cb(type_.clone());
-                        walk_substs(db, type_, &trait_ref.substs, cb);
+                        walk_substs(db, type_, &trait_ref.substitution, cb);
                    }
                    _ => (),
                }
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 85d01ac3e..0360fb627 100644
--- a/crates/hir_def/src/attr.rs
+++ b/crates/hir_def/src/attr.rs
@@ -209,7 +209,7 @@ impl Attrs {
            },
            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))
+                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),
@@ -283,8 +283,51 @@ impl Attrs {
    /// 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 {
+    // FIXME: figure out a better api that doesnt require the for_module hack
-        AttrSourceMap { attrs: collect_attrs(owner).collect() }
+    pub fn source_map(&self, owner: InFile<&dyn ast::AttrsOwner>) -> AttrSourceMap {
+        // FIXME: This doesn't work correctly for modules, as the attributes there can have up to
+        // two different owners
+        AttrSourceMap {
+            attrs: collect_attrs(owner.value)
+                .map(|attr| InFile::new(owner.file_id, attr))
+                .collect(),
+        }
+    }
+    pub fn source_map_for_module(
+        &self,
+        db: &dyn DefDatabase,
+        module: crate::ModuleId,
+    ) -> AttrSourceMap {
+        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()
+            }
+        };
+        AttrSourceMap { attrs }
    }
    pub fn by_key(&self, key: &'static str) -> AttrQuery<'_> {
@@ -379,7 +422,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 +432,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()
    }
 }
@@ -428,18 +472,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.
    ///
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/lib.rs b/crates/hir_def/src/lib.rs
index 6758411a0..50e730444 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);
diff --git a/crates/hir_def/src/nameres.rs b/crates/hir_def/src/nameres.rs
index c97be584e..1ac326f97 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,
diff --git a/crates/hir_def/src/nameres/collector.rs b/crates/hir_def/src/nameres/collector.rs
index d0fefb5af..dcedf7766 100644
--- a/crates/hir_def/src/nameres/collector.rs
+++ b/crates/hir_def/src/nameres/collector.rs
@@ -18,7 +18,6 @@ use hir_expand::{
 use hir_expand::{InFile, MacroCallLoc};
 use rustc_hash::{FxHashMap, FxHashSet};
 use syntax::ast;
-use tt::{Leaf, TokenTree};
 use crate::{
    attr::Attrs,
@@ -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`.
@@ -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 {
@@ -1385,28 +1386,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 +1429,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);
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..d59d3c0db 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() {
@@ -790,3 +791,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_expand/src/builtin_derive.rs b/crates/hir_expand/src/builtin_derive.rs
index a8d267c30..60fd2ebdd 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,
    })
 }
@@ -314,8 +313,7 @@ $0
        let loc = MacroCallLoc {
            def: MacroDefId {
                krate: CrateId(0),
-                ast_id: Some(macro_ast_id),
+                kind: MacroDefKind::BuiltInDerive(expander, macro_ast_id),
-                kind: MacroDefKind::BuiltInDerive(expander),
                local_inner: false,
            },
            krate: CrateId(0),
diff --git a/crates/hir_expand/src/builtin_macro.rs b/crates/hir_expand/src/builtin_macro.rs
index fce09a9e7..8529b43b6 100644
--- a/crates/hir_expand/src/builtin_macro.rs
+++ b/crates/hir_expand/src/builtin_macro.rs
@@ -71,14 +71,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,
        }),
    }
@@ -512,6 +510,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 +518,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 +538,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,
                };
diff --git a/crates/hir_expand/src/db.rs b/crates/hir_expand/src/db.rs
index a3070f1f9..2748e25cf 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())))
        }
    }
@@ -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..04f374a29 100644
--- a/crates/hir_expand/src/eager.rs
+++ b/crates/hir_expand/src/eager.rs
@@ -140,7 +140,7 @@ 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)?;
@@ -193,7 +193,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 +206,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..20cda1683 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().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..0a379651f 100644
--- a/crates/hir_expand/src/lib.rs
+++ b/crates/hir_expand/src/lib.rs
@@ -143,7 +143,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().and_then(|id| {
                    let def_tt = match id.to_node(db) {
                        ast::Macro::MacroRules(mac) => mac.token_tree()?,
                        ast::Macro::MacroDef(_) => return None,
@@ -180,7 +180,7 @@ 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())?))
@@ -224,7 +224,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 +238,27 @@ impl MacroDefId {
    ) -> LazyMacroId {
        db.intern_macro(MacroCallLoc { def: self, krate, kind })
    }
+    pub fn ast_id(&self) -> Option<AstId<ast::Macro>> {
+        let id = match &self.kind {
+            MacroDefKind::Declarative(id) => id,
+            MacroDefKind::BuiltIn(_, id) => id,
+            MacroDefKind::BuiltInDerive(_, id) => id,
+            MacroDefKind::BuiltInEager(_, id) => id,
+            MacroDefKind::ProcMacro(..) => return None,
+        };
+        Some(*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)]
diff --git a/crates/hir_ty/src/autoderef.rs b/crates/hir_ty/src/autoderef.rs
index bd2ff5d38..33b966026 100644
--- a/crates/hir_ty/src/autoderef.rs
+++ b/crates/hir_ty/src/autoderef.rs
@@ -12,10 +12,11 @@ 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, DebruijnIndex, Interner, Obligation, ProjectionTy,
+    Substitution, TraitRef, Ty, TyKind,
 };
 const AUTODEREF_RECURSION_LIMIT: usize = 10;
@@ -68,7 +69,8 @@ fn deref_by_trait(
        Substitution::build_for_generics(&generic_params).push(ty.value.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(),
        value: InEnvironment {
@@ -81,16 +83,16 @@ 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.value.kinds.len()))
+            .intern(&Interner),
    };
-    let obligation = super::Obligation::Projection(projection);
+    let obligation = super::Obligation::AliasEq(projection);
    let in_env = InEnvironment { value: obligation, environment: ty.environment };
diff --git a/crates/hir_ty/src/diagnostics/decl_check.rs b/crates/hir_ty/src/diagnostics/decl_check.rs
index bfe239793..33a0f4d7d 100644
--- a/crates/hir_ty/src/diagnostics/decl_check.rs
+++ b/crates/hir_ty/src/diagnostics/decl_check.rs
@@ -102,7 +102,7 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
        let db = self.db;
        for block_def_map in body.block_scopes.iter().filter_map(|block| db.block_def_map(*block)) {
            for (_, module) in block_def_map.modules() {
-                for (def_id, _) in module.scope.values() {
+                for def_id in module.scope.declarations() {
                    let mut validator = DeclValidator::new(self.db, self.krate, self.sink);
                    validator.validate_item(def_id);
                }
@@ -902,4 +902,17 @@ extern {
            "#,
        );
    }
+    #[test]
+    fn infinite_loop_inner_items() {
+        check_diagnostics(
+            r#"
+fn qualify() {
+    mod foo {
+        use super::*;
+    }
+}
+            "#,
+        )
+    }
 }
diff --git a/crates/hir_ty/src/display.rs b/crates/hir_ty/src/display.rs
index 7ce0f864c..59a1bd9b0 100644
--- a/crates/hir_ty/src/display.rs
+++ b/crates/hir_ty/src/display.rs
@@ -18,9 +18,9 @@ use hir_expand::name::Name;
 use crate::{
    db::HirDatabase, from_assoc_type_id, from_foreign_def_id, from_placeholder_idx, primitive,
-    to_assoc_type_id, traits::chalk::from_chalk, utils::generics, AdtId, AliasTy, CallableDefId,
+    to_assoc_type_id, traits::chalk::from_chalk, utils::generics, AdtId, AliasEq, AliasTy,
-    CallableSig, GenericPredicate, ImplTraitId, Interner, Lifetime, Obligation, OpaqueTy,
+    CallableDefId, CallableSig, GenericPredicate, ImplTraitId, Interner, Lifetime, Obligation,
-    ProjectionTy, Scalar, Substitution, TraitRef, Ty, TyKind,
+    OpaqueTy, ProjectionTy, Scalar, Substitution, TraitRef, Ty, TyKind,
 };
 pub struct HirFormatter<'a> {
@@ -268,6 +268,16 @@ impl HirDisplay for ProjectionTy {
    }
 }
+impl HirDisplay for OpaqueTy {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
+        if f.should_truncate() {
+            return write!(f, "{}", TYPE_HINT_TRUNCATION);
+        }
+        self.substitution[0].hir_fmt(f)
+    }
+}
 impl HirDisplay for Ty {
    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
        if f.should_truncate() {
@@ -344,7 +354,7 @@ impl HirDisplay for Ty {
                };
                if let [GenericPredicate::Implemented(trait_ref), _] = predicates.as_ref() {
-                    let trait_ = trait_ref.trait_;
+                    let trait_ = trait_ref.hir_trait_id();
                    if fn_traits(f.db.upcast(), trait_).any(|it| it == trait_) {
                        return write!(f, "{}", ty_display);
                    }
@@ -670,7 +680,7 @@ fn write_bounds_like_dyn_trait(
    for p in predicates.iter() {
        match p {
            GenericPredicate::Implemented(trait_ref) => {
-                let trait_ = trait_ref.trait_;
+                let trait_ = trait_ref.hir_trait_id();
                if !is_fn_trait {
                    is_fn_trait = fn_traits(f.db.upcast(), trait_).any(|it| it == trait_);
                }
@@ -685,7 +695,7 @@ fn write_bounds_like_dyn_trait(
                // existential) here, which is the only thing that's
                // possible in actual Rust, and hence don't print it
                write!(f, "{}", f.db.trait_data(trait_).name)?;
-                if let [_, params @ ..] = &*trait_ref.substs.0 {
+                if let [_, params @ ..] = &*trait_ref.substitution.0 {
                    if is_fn_trait {
                        if let Some(args) = params.first().and_then(|it| it.as_tuple()) {
                            write!(f, "(")?;
@@ -700,12 +710,12 @@ fn write_bounds_like_dyn_trait(
                    }
                }
            }
-            GenericPredicate::Projection(projection_pred) if is_fn_trait => {
+            GenericPredicate::AliasEq(alias_eq) if is_fn_trait => {
                is_fn_trait = false;
                write!(f, " -> ")?;
-                projection_pred.ty.hir_fmt(f)?;
+                alias_eq.ty.hir_fmt(f)?;
            }
-            GenericPredicate::Projection(projection_pred) => {
+            GenericPredicate::AliasEq(AliasEq { ty, alias }) => {
                // in types in actual Rust, these will always come
                // after the corresponding Implemented predicate
                if angle_open {
@@ -714,11 +724,12 @@ fn write_bounds_like_dyn_trait(
                    write!(f, "<")?;
                    angle_open = true;
                }
-                let type_alias = f.db.type_alias_data(from_assoc_type_id(
+                if let AliasTy::Projection(proj) = alias {
-                    projection_pred.projection_ty.associated_ty_id,
+                    let type_alias =
-                ));
+                        f.db.type_alias_data(from_assoc_type_id(proj.associated_ty_id));
-                write!(f, "{} = ", type_alias.name)?;
+                    write!(f, "{} = ", type_alias.name)?;
-                projection_pred.ty.hir_fmt(f)?;
+                }
+                ty.hir_fmt(f)?;
            }
            GenericPredicate::Error => {
                if angle_open {
@@ -745,16 +756,16 @@ impl TraitRef {
            return write!(f, "{}", TYPE_HINT_TRUNCATION);
        }
-        self.substs[0].hir_fmt(f)?;
+        self.substitution[0].hir_fmt(f)?;
        if use_as {
            write!(f, " as ")?;
        } else {
            write!(f, ": ")?;
        }
-        write!(f, "{}", f.db.trait_data(self.trait_).name)?;
+        write!(f, "{}", f.db.trait_data(self.hir_trait_id()).name)?;
-        if self.substs.len() > 1 {
+        if self.substitution.len() > 1 {
            write!(f, "<")?;
-            f.write_joined(&self.substs[1..], ", ")?;
+            f.write_joined(&self.substitution[1..], ", ")?;
            write!(f, ">")?;
        }
        Ok(())
@@ -775,20 +786,20 @@ impl HirDisplay for GenericPredicate {
        match self {
            GenericPredicate::Implemented(trait_ref) => trait_ref.hir_fmt(f)?,
-            GenericPredicate::Projection(projection_pred) => {
+            GenericPredicate::AliasEq(AliasEq {
+                alias: AliasTy::Projection(projection_ty),
+                ty,
+            }) => {
                write!(f, "<")?;
-                projection_pred.projection_ty.trait_ref(f.db).hir_fmt_ext(f, true)?;
+                projection_ty.trait_ref(f.db).hir_fmt_ext(f, true)?;
                write!(
                    f,
                    ">::{} = ",
-                    f.db.type_alias_data(from_assoc_type_id(
+                    f.db.type_alias_data(from_assoc_type_id(projection_ty.associated_ty_id)).name,
-                        projection_pred.projection_ty.associated_ty_id
-                    ))
-                    .name,
                )?;
-                projection_pred.ty.hir_fmt(f)?;
+                ty.hir_fmt(f)?;
            }
-            GenericPredicate::Error => write!(f, "{{error}}")?,
+            GenericPredicate::AliasEq(_) | GenericPredicate::Error => write!(f, "{{error}}")?,
        }
        Ok(())
    }
@@ -815,11 +826,14 @@ impl HirDisplay for Obligation {
                tr.hir_fmt(f)?;
                write!(f, ")")
            }
-            Obligation::Projection(proj) => {
+            Obligation::AliasEq(AliasEq { alias, ty }) => {
                write!(f, "Normalize(")?;
-                proj.projection_ty.hir_fmt(f)?;
+                match alias {
+                    AliasTy::Projection(projection_ty) => projection_ty.hir_fmt(f)?,
+                    AliasTy::Opaque(opaque) => opaque.hir_fmt(f)?,
+                }
                write!(f, " => ")?;
-                proj.ty.hir_fmt(f)?;
+                ty.hir_fmt(f)?;
                write!(f, ")")
            }
        }
diff --git a/crates/hir_ty/src/infer.rs b/crates/hir_ty/src/infer.rs
index 2610c9279..82186979a 100644
--- a/crates/hir_ty/src/infer.rs
+++ b/crates/hir_ty/src/infer.rs
@@ -37,12 +37,12 @@ use stdx::impl_from;
 use syntax::SmolStr;
 use super::{
-    traits::{Guidance, Obligation, ProjectionPredicate, Solution},
+    traits::{Guidance, Obligation, Solution},
    InEnvironment, ProjectionTy, Substitution, TraitEnvironment, TraitRef, Ty, TypeWalk,
 };
 use crate::{
    db::HirDatabase, infer::diagnostics::InferenceDiagnostic, lower::ImplTraitLoweringMode,
-    to_assoc_type_id, AliasTy, Interner, TyKind,
+    to_assoc_type_id, to_chalk_trait_id, AliasEq, AliasTy, Interner, TyKind,
 };
 pub(crate) use unify::unify;
@@ -394,16 +394,17 @@ impl<'a> InferenceContext<'a> {
                    .push(inner_ty)
                    .fill(params.iter().cloned())
                    .build();
-                let trait_ref = TraitRef { trait_, substs: substs.clone() };
+                let trait_ref =
-                let projection = ProjectionPredicate {
+                    TraitRef { trait_id: to_chalk_trait_id(trait_), substitution: substs.clone() };
-                    ty: ty.clone(),
+                let alias_eq = AliasEq {
-                    projection_ty: ProjectionTy {
+                    alias: AliasTy::Projection(ProjectionTy {
                        associated_ty_id: to_assoc_type_id(res_assoc_ty),
                        substitution: substs,
-                    },
+                    }),
+                    ty: ty.clone(),
                };
                self.obligations.push(Obligation::Trait(trait_ref));
-                self.obligations.push(Obligation::Projection(projection));
+                self.obligations.push(Obligation::AliasEq(alias_eq));
                self.resolve_ty_as_possible(ty)
            }
            None => self.err_ty(),
@@ -428,8 +429,8 @@ impl<'a> InferenceContext<'a> {
    fn normalize_projection_ty(&mut self, proj_ty: ProjectionTy) -> Ty {
        let var = self.table.new_type_var();
-        let predicate = ProjectionPredicate { projection_ty: proj_ty, ty: var.clone() };
+        let alias_eq = AliasEq { alias: AliasTy::Projection(proj_ty), ty: var.clone() };
-        let obligation = Obligation::Projection(predicate);
+        let obligation = Obligation::AliasEq(alias_eq);
        self.obligations.push(obligation);
        var
    }
diff --git a/crates/hir_ty/src/infer/coerce.rs b/crates/hir_ty/src/infer/coerce.rs
index b1f98c507..b86474ed4 100644
--- a/crates/hir_ty/src/infer/coerce.rs
+++ b/crates/hir_ty/src/infer/coerce.rs
@@ -8,7 +8,8 @@ use chalk_ir::{Mutability, TyVariableKind};
 use hir_def::lang_item::LangItemTarget;
 use crate::{
-    autoderef, traits::Solution, Interner, Obligation, Substitution, TraitRef, Ty, TyKind,
+    autoderef, to_chalk_trait_id, traits::Solution, Interner, Obligation, Substitution, TraitRef,
+    Ty, TyKind,
 };
 use super::{InEnvironment, InferenceContext};
@@ -140,7 +141,8 @@ impl<'a> InferenceContext<'a> {
            .push(from_ty.clone())
            .push(to_ty.clone())
            .build();
-        let trait_ref = TraitRef { trait_: coerce_unsized_trait, substs };
+        let trait_ref =
+            TraitRef { trait_id: to_chalk_trait_id(coerce_unsized_trait), substitution: substs };
        let goal = InEnvironment::new(self.trait_env.clone(), Obligation::Trait(trait_ref));
        let canonicalizer = self.canonicalizer();
diff --git a/crates/hir_ty/src/infer/expr.rs b/crates/hir_ty/src/infer/expr.rs
index 0be8c5a90..93548b6c0 100644
--- a/crates/hir_ty/src/infer/expr.rs
+++ b/crates/hir_ty/src/infer/expr.rs
@@ -18,7 +18,7 @@ use crate::{
    lower::lower_to_chalk_mutability,
    method_resolution, op,
    primitive::{self, UintTy},
-    to_assoc_type_id,
+    to_assoc_type_id, to_chalk_trait_id,
    traits::{chalk::from_chalk, FnTrait, InEnvironment},
    utils::{generics, variant_data, Generics},
    AdtId, Binders, CallableDefId, FnPointer, FnSig, Interner, Obligation, Rawness, Scalar,
@@ -90,8 +90,10 @@ impl<'a> InferenceContext<'a> {
            Substitution::build_for_generics(&generic_params).push(ty.clone()).push(arg_ty).build();
        let trait_env = Arc::clone(&self.trait_env);
-        let implements_fn_trait =
+        let implements_fn_trait = Obligation::Trait(TraitRef {
-            Obligation::Trait(TraitRef { trait_: fn_once_trait, substs: substs.clone() });
+            trait_id: to_chalk_trait_id(fn_once_trait),
+            substitution: substs.clone(),
+        });
        let goal = self.canonicalizer().canonicalize_obligation(InEnvironment {
            value: implements_fn_trait.clone(),
            environment: trait_env,
@@ -948,7 +950,10 @@ impl<'a> InferenceContext<'a> {
                        // construct a TraitDef
                        let substs =
                            parameters.prefix(generics(self.db.upcast(), trait_.into()).len());
-                        self.obligations.push(Obligation::Trait(TraitRef { trait_, substs }));
+                        self.obligations.push(Obligation::Trait(TraitRef {
+                            trait_id: to_chalk_trait_id(trait_),
+                            substitution: substs,
+                        }));
                    }
                }
                CallableDefId::StructId(_) | CallableDefId::EnumVariantId(_) => {}
diff --git a/crates/hir_ty/src/infer/path.rs b/crates/hir_ty/src/infer/path.rs
index ea01d6238..e15135fc1 100644
--- a/crates/hir_ty/src/infer/path.rs
+++ b/crates/hir_ty/src/infer/path.rs
@@ -9,7 +9,9 @@ use hir_def::{
 };
 use hir_expand::name::Name;
-use crate::{method_resolution, Interner, Substitution, Ty, TyKind, ValueTyDefId};
+use crate::{
+    method_resolution, to_chalk_trait_id, Interner, Substitution, Ty, TyKind, ValueTyDefId,
+};
 use super::{ExprOrPatId, InferenceContext, TraitRef};
@@ -165,7 +167,7 @@ impl<'a> InferenceContext<'a> {
        segment: PathSegment<'_>,
        id: ExprOrPatId,
    ) -> Option<(ValueNs, Option<Substitution>)> {
-        let trait_ = trait_ref.trait_;
+        let trait_ = trait_ref.hir_trait_id();
        let item =
            self.db.trait_data(trait_).items.iter().map(|(_name, id)| (*id)).find_map(|item| {
                match item {
@@ -200,7 +202,7 @@ impl<'a> InferenceContext<'a> {
        };
        self.write_assoc_resolution(id, item);
-        Some((def, Some(trait_ref.substs)))
+        Some((def, Some(trait_ref.substitution)))
    }
    fn resolve_ty_assoc_item(
@@ -255,8 +257,8 @@ impl<'a> InferenceContext<'a> {
                            .fill(std::iter::repeat_with(|| self.table.new_type_var()))
                            .build();
                        self.obligations.push(super::Obligation::Trait(TraitRef {
-                            trait_,
+                            trait_id: to_chalk_trait_id(trait_),
-                            substs: trait_substs.clone(),
+                            substitution: trait_substs.clone(),
                        }));
                        Some(trait_substs)
                    }
diff --git a/crates/hir_ty/src/infer/unify.rs b/crates/hir_ty/src/infer/unify.rs
index b2d4f67b3..4738ec08a 100644
--- a/crates/hir_ty/src/infer/unify.rs
+++ b/crates/hir_ty/src/infer/unify.rs
@@ -7,8 +7,8 @@ use ena::unify::{InPlaceUnificationTable, NoError, UnifyKey, UnifyValue};
 use super::{InferenceContext, Obligation};
 use crate::{
-    BoundVar, Canonical, DebruijnIndex, FnPointer, GenericPredicate, InEnvironment, InferenceVar,
+    AliasEq, AliasTy, BoundVar, Canonical, DebruijnIndex, FnPointer, GenericPredicate,
-    Interner, Scalar, Substitution, Ty, TyKind, TypeWalk,
+    InEnvironment, InferenceVar, Interner, Scalar, Substitution, Ty, TyKind, TypeWalk,
 };
 impl<'a> InferenceContext<'a> {
@@ -93,8 +93,8 @@ impl<'a, 'b> Canonicalizer<'a, 'b> {
            Obligation::Trait(tr) => {
                Obligation::Trait(self.do_canonicalize(tr, DebruijnIndex::INNERMOST))
            }
-            Obligation::Projection(pr) => {
+            Obligation::AliasEq(alias_eq) => {
-                Obligation::Projection(self.do_canonicalize(pr, DebruijnIndex::INNERMOST))
+                Obligation::AliasEq(self.do_canonicalize(alias_eq, DebruijnIndex::INNERMOST))
            }
        };
        self.into_canonicalized(InEnvironment {
@@ -390,18 +390,29 @@ impl InferenceTable {
    ) -> bool {
        match (pred1, pred2) {
            (GenericPredicate::Implemented(tr1), GenericPredicate::Implemented(tr2))
-                if tr1.trait_ == tr2.trait_ =>
+                if tr1.trait_id == tr2.trait_id =>
            {
-                self.unify_substs(&tr1.substs, &tr2.substs, depth + 1)
+                self.unify_substs(&tr1.substitution, &tr2.substitution, depth + 1)
            }
-            (GenericPredicate::Projection(proj1), GenericPredicate::Projection(proj2))
+            (
-                if proj1.projection_ty.associated_ty_id == proj2.projection_ty.associated_ty_id =>
+                GenericPredicate::AliasEq(AliasEq { alias: alias1, ty: ty1 }),
-            {
+                GenericPredicate::AliasEq(AliasEq { alias: alias2, ty: ty2 }),
-                self.unify_substs(
+            ) => {
-                    &proj1.projection_ty.substitution,
+                let (substitution1, substitution2) = match (alias1, alias2) {
-                    &proj2.projection_ty.substitution,
+                    (AliasTy::Projection(projection_ty1), AliasTy::Projection(projection_ty2))
-                    depth + 1,
+                        if projection_ty1.associated_ty_id == projection_ty2.associated_ty_id =>
-                ) && self.unify_inner(&proj1.ty, &proj2.ty, depth + 1)
+                    {
+                        (&projection_ty1.substitution, &projection_ty2.substitution)
+                    }
+                    (AliasTy::Opaque(opaque1), AliasTy::Opaque(opaque2))
+                        if opaque1.opaque_ty_id == opaque2.opaque_ty_id =>
+                    {
+                        (&opaque1.substitution, &opaque2.substitution)
+                    }
+                    _ => return false,
+                };
+                self.unify_substs(&substitution1, &substitution2, depth + 1)
+                    && self.unify_inner(&ty1, &ty2, depth + 1)
            }
            _ => false,
        }
diff --git a/crates/hir_ty/src/lib.rs b/crates/hir_ty/src/lib.rs
index 52b498ff7..2afcb5413 100644
--- a/crates/hir_ty/src/lib.rs
+++ b/crates/hir_ty/src/lib.rs
@@ -45,7 +45,7 @@ pub use lower::{
    associated_type_shorthand_candidates, callable_item_sig, CallableDefId, ImplTraitLoweringMode,
    TyDefId, TyLoweringContext, ValueTyDefId,
 };
-pub use traits::{InEnvironment, Obligation, ProjectionPredicate, TraitEnvironment};
+pub use traits::{AliasEq, InEnvironment, Obligation, TraitEnvironment};
 pub use chalk_ir::{AdtId, BoundVar, DebruijnIndex, Mutability, Safety, Scalar, TyVariableKind};
@@ -58,6 +58,8 @@ pub type ClosureId = chalk_ir::ClosureId<Interner>;
 pub type OpaqueTyId = chalk_ir::OpaqueTyId<Interner>;
 pub type PlaceholderIndex = chalk_ir::PlaceholderIndex;
+pub type ChalkTraitId = chalk_ir::TraitId<Interner>;
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub enum Lifetime {
    Parameter(LifetimeParamId),
@@ -70,6 +72,20 @@ pub struct OpaqueTy {
    pub substitution: Substitution,
 }
+impl TypeWalk for OpaqueTy {
+    fn walk(&self, f: &mut impl FnMut(&Ty)) {
+        self.substitution.walk(f);
+    }
+    fn walk_mut_binders(
+        &mut self,
+        f: &mut impl FnMut(&mut Ty, DebruijnIndex),
+        binders: DebruijnIndex,
+    ) {
+        self.substitution.walk_mut_binders(f, binders);
+    }
+}
 /// A "projection" type corresponds to an (unnormalized)
 /// projection like `<P0 as Trait<P1..Pn>>::Foo`. Note that the
 /// trait and all its parameters are fully known.
@@ -81,7 +97,10 @@ pub struct ProjectionTy {
 impl ProjectionTy {
    pub fn trait_ref(&self, db: &dyn HirDatabase) -> TraitRef {
-        TraitRef { trait_: self.trait_(db), substs: self.substitution.clone() }
+        TraitRef {
+            trait_id: to_chalk_trait_id(self.trait_(db)),
+            substitution: self.substitution.clone(),
+        }
    }
    fn trait_(&self, db: &dyn HirDatabase) -> TraitId {
@@ -128,6 +147,25 @@ pub enum AliasTy {
    Opaque(OpaqueTy),
 }
+impl TypeWalk for AliasTy {
+    fn walk(&self, f: &mut impl FnMut(&Ty)) {
+        match self {
+            AliasTy::Projection(it) => it.walk(f),
+            AliasTy::Opaque(it) => it.walk(f),
+        }
+    }
+    fn walk_mut_binders(
+        &mut self,
+        f: &mut impl FnMut(&mut Ty, DebruijnIndex),
+        binders: DebruijnIndex,
+    ) {
+        match self {
+            AliasTy::Projection(it) => it.walk_mut_binders(f, binders),
+            AliasTy::Opaque(it) => it.walk_mut_binders(f, binders),
+        }
+    }
+}
 /// A type.
 ///
 /// See also the `TyKind` enum in rustc (librustc/ty/sty.rs), which represents
@@ -493,23 +531,25 @@ impl<T: TypeWalk> TypeWalk for Binders<T> {
 }
 /// A trait with type parameters. This includes the `Self`, so this represents a concrete type implementing the trait.
-/// Name to be bikeshedded: TraitBound? TraitImplements?
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub struct TraitRef {
-    /// FIXME name?
+    pub trait_id: ChalkTraitId,
-    pub trait_: TraitId,
+    pub substitution: Substitution,
-    pub substs: Substitution,
 }
 impl TraitRef {
-    pub fn self_ty(&self) -> &Ty {
+    pub fn self_type_parameter(&self) -> &Ty {
-        &self.substs[0]
+        &self.substitution[0]
+    }
+    pub fn hir_trait_id(&self) -> TraitId {
+        from_chalk_trait_id(self.trait_id)
    }
 }
 impl TypeWalk for TraitRef {
    fn walk(&self, f: &mut impl FnMut(&Ty)) {
-        self.substs.walk(f);
+        self.substitution.walk(f);
    }
    fn walk_mut_binders(
@@ -517,7 +557,7 @@ impl TypeWalk for TraitRef {
        f: &mut impl FnMut(&mut Ty, DebruijnIndex),
        binders: DebruijnIndex,
    ) {
-        self.substs.walk_mut_binders(f, binders);
+        self.substitution.walk_mut_binders(f, binders);
    }
 }
@@ -528,7 +568,7 @@ pub enum GenericPredicate {
    /// The given trait needs to be implemented for its type parameters.
    Implemented(TraitRef),
    /// An associated type bindings like in `Iterator<Item = T>`.
-    Projection(ProjectionPredicate),
+    AliasEq(AliasEq),
    /// We couldn't resolve the trait reference. (If some type parameters can't
    /// be resolved, they will just be Unknown).
    Error,
@@ -546,8 +586,10 @@ impl GenericPredicate {
    pub fn trait_ref(&self, db: &dyn HirDatabase) -> Option<TraitRef> {
        match self {
            GenericPredicate::Implemented(tr) => Some(tr.clone()),
-            GenericPredicate::Projection(proj) => Some(proj.projection_ty.trait_ref(db)),
+            GenericPredicate::AliasEq(AliasEq { alias: AliasTy::Projection(proj), .. }) => {
-            GenericPredicate::Error => None,
+                Some(proj.trait_ref(db))
+            }
+            GenericPredicate::AliasEq(_) | GenericPredicate::Error => None,
        }
    }
 }
@@ -556,7 +598,7 @@ impl TypeWalk for GenericPredicate {
    fn walk(&self, f: &mut impl FnMut(&Ty)) {
        match self {
            GenericPredicate::Implemented(trait_ref) => trait_ref.walk(f),
-            GenericPredicate::Projection(projection_pred) => projection_pred.walk(f),
+            GenericPredicate::AliasEq(alias_eq) => alias_eq.walk(f),
            GenericPredicate::Error => {}
        }
    }
@@ -568,9 +610,7 @@ impl TypeWalk for GenericPredicate {
    ) {
        match self {
            GenericPredicate::Implemented(trait_ref) => trait_ref.walk_mut_binders(f, binders),
-            GenericPredicate::Projection(projection_pred) => {
+            GenericPredicate::AliasEq(alias_eq) => alias_eq.walk_mut_binders(f, binders),
-                projection_pred.walk_mut_binders(f, binders)
-            }
            GenericPredicate::Error => {}
        }
    }
@@ -784,7 +824,7 @@ impl Ty {
    /// If this is a `dyn Trait`, returns that trait.
    pub fn dyn_trait(&self) -> Option<TraitId> {
-        self.dyn_trait_ref().map(|it| it.trait_)
+        self.dyn_trait_ref().map(|it| it.trait_id).map(from_chalk_trait_id)
    }
    fn builtin_deref(&self) -> Option<Ty> {
@@ -868,8 +908,8 @@ impl Ty {
                            // Parameters will be walked outside, and projection predicate is not used.
                            // So just provide the Future trait.
                            let impl_bound = GenericPredicate::Implemented(TraitRef {
-                                trait_: future_trait,
+                                trait_id: to_chalk_trait_id(future_trait),
-                                substs: Substitution::empty(),
+                                substitution: Substitution::empty(),
                            });
                            Some(vec![impl_bound])
                        } else {
@@ -1158,3 +1198,11 @@ pub fn to_placeholder_idx(db: &dyn HirDatabase, id: TypeParamId) -> PlaceholderI
        idx: salsa::InternKey::as_intern_id(&interned_id).as_usize(),
    }
 }
+pub fn to_chalk_trait_id(id: TraitId) -> ChalkTraitId {
+    chalk_ir::TraitId(salsa::InternKey::as_intern_id(&id))
+}
+pub fn from_chalk_trait_id(id: ChalkTraitId) -> TraitId {
+    salsa::InternKey::from_intern_id(id.0)
+}
diff --git a/crates/hir_ty/src/lower.rs b/crates/hir_ty/src/lower.rs
index 462882b2b..7d22c3df5 100644
--- a/crates/hir_ty/src/lower.rs
+++ b/crates/hir_ty/src/lower.rs
@@ -27,14 +27,14 @@ use stdx::impl_from;
 use crate::{
    db::HirDatabase,
-    to_assoc_type_id, to_placeholder_idx,
+    to_assoc_type_id, to_chalk_trait_id, to_placeholder_idx,
    traits::chalk::{Interner, ToChalk},
    utils::{
        all_super_trait_refs, associated_type_by_name_including_super_traits, generics,
        variant_data,
    },
-    AliasTy, Binders, BoundVar, CallableSig, DebruijnIndex, FnPointer, FnSig, GenericPredicate,
+    AliasEq, AliasTy, Binders, BoundVar, CallableSig, DebruijnIndex, FnPointer, FnSig,
-    ImplTraitId, OpaqueTy, PolyFnSig, ProjectionPredicate, ProjectionTy, ReturnTypeImplTrait,
+    GenericPredicate, ImplTraitId, OpaqueTy, PolyFnSig, ProjectionTy, ReturnTypeImplTrait,
    ReturnTypeImplTraits, Substitution, TraitEnvironment, TraitRef, Ty, TyKind, TypeWalk,
 };
@@ -360,7 +360,7 @@ impl<'a> TyLoweringContext<'a> {
                            // FIXME handle type parameters on the segment
                            TyKind::Alias(AliasTy::Projection(ProjectionTy {
                                associated_ty_id: to_assoc_type_id(associated_ty),
-                                substitution: super_trait_ref.substs,
+                                substitution: super_trait_ref.substitution,
                            }))
                            .intern(&Interner)
                        }
@@ -470,9 +470,9 @@ impl<'a> TyLoweringContext<'a> {
                                        "there should be generics if there's a generic param",
                                    ),
                                );
-                                t.substs.clone().subst_bound_vars(&s)
+                                t.substitution.clone().subst_bound_vars(&s)
                            }
-                            TypeParamLoweringMode::Variable => t.substs.clone(),
+                            TypeParamLoweringMode::Variable => t.substitution.clone(),
                        };
                        // We need to shift in the bound vars, since
                        // associated_type_shorthand_candidates does not do that
@@ -641,7 +641,7 @@ impl<'a> TyLoweringContext<'a> {
        if let Some(self_ty) = explicit_self_ty {
            substs.0[0] = self_ty;
        }
-        TraitRef { trait_: resolved, substs }
+        TraitRef { trait_id: to_chalk_trait_id(resolved), substitution: substs }
    }
    fn lower_trait_ref(
@@ -743,16 +743,16 @@ impl<'a> TyLoweringContext<'a> {
                };
                let projection_ty = ProjectionTy {
                    associated_ty_id: to_assoc_type_id(associated_ty),
-                    substitution: super_trait_ref.substs,
+                    substitution: super_trait_ref.substitution,
                };
                let mut preds = SmallVec::with_capacity(
                    binding.type_ref.as_ref().map_or(0, |_| 1) + binding.bounds.len(),
                );
                if let Some(type_ref) = &binding.type_ref {
                    let ty = self.lower_ty(type_ref);
-                    let projection_predicate =
+                    let alias_eq =
-                        ProjectionPredicate { projection_ty: projection_ty.clone(), ty };
+                        AliasEq { alias: AliasTy::Projection(projection_ty.clone()), ty };
-                    preds.push(GenericPredicate::Projection(projection_predicate));
+                    preds.push(GenericPredicate::AliasEq(alias_eq));
                }
                for bound in &binding.bounds {
                    preds.extend(self.lower_type_bound(
@@ -820,8 +820,8 @@ pub fn associated_type_shorthand_candidates<R>(
                    == TypeParamProvenance::TraitSelf
                {
                    let trait_ref = TraitRef {
-                        trait_: trait_id,
+                        trait_id: to_chalk_trait_id(trait_id),
-                        substs: Substitution::bound_vars(&generics, DebruijnIndex::INNERMOST),
+                        substitution: Substitution::bound_vars(&generics, DebruijnIndex::INNERMOST),
                    };
                    traits_.push(trait_ref);
                }
@@ -832,7 +832,7 @@ pub fn associated_type_shorthand_candidates<R>(
    };
    for t in traits_from_env.into_iter().flat_map(move |t| all_super_trait_refs(db, t)) {
-        let data = db.trait_data(t.trait_);
+        let data = db.trait_data(t.hir_trait_id());
        for (name, assoc_id) in &data.items {
            match assoc_id {
@@ -926,7 +926,7 @@ pub(crate) fn trait_environment_query(
                continue;
            }
            if let GenericPredicate::Implemented(tr) = &pred {
-                traits_in_scope.push((tr.self_ty().clone(), tr.trait_));
+                traits_in_scope.push((tr.self_type_parameter().clone(), tr.hir_trait_id()));
            }
            let program_clause: chalk_ir::ProgramClause<Interner> =
                pred.clone().to_chalk(db).cast(&Interner);
@@ -950,7 +950,7 @@ pub(crate) fn trait_environment_query(
        // inside consts or type aliases)
        cov_mark::hit!(trait_self_implements_self);
        let substs = Substitution::type_params(db, trait_id);
-        let trait_ref = TraitRef { trait_: trait_id, substs };
+        let trait_ref = TraitRef { trait_id: to_chalk_trait_id(trait_id), substitution: substs };
        let pred = GenericPredicate::Implemented(trait_ref);
        let program_clause: chalk_ir::ProgramClause<Interner> =
            pred.clone().to_chalk(db).cast(&Interner);
diff --git a/crates/hir_ty/src/method_resolution.rs b/crates/hir_ty/src/method_resolution.rs
index 943d3339b..01b78fb44 100644
--- a/crates/hir_ty/src/method_resolution.rs
+++ b/crates/hir_ty/src/method_resolution.rs
@@ -19,6 +19,7 @@ use crate::{
    db::HirDatabase,
    from_foreign_def_id,
    primitive::{self, FloatTy, IntTy, UintTy},
+    to_chalk_trait_id,
    utils::all_super_traits,
    AdtId, Canonical, DebruijnIndex, FnPointer, FnSig, ForeignDefId, InEnvironment, Interner,
    Scalar, Substitution, TraitEnvironment, TraitRef, Ty, TyKind, TypeWalk,
@@ -101,7 +102,7 @@ impl TraitImpls {
        for (_module_id, module_data) in crate_def_map.modules() {
            for impl_id in module_data.scope.impls() {
                let target_trait = match db.impl_trait(impl_id) {
-                    Some(tr) => tr.value.trait_,
+                    Some(tr) => tr.value.hir_trait_id(),
                    None => continue,
                };
                let self_ty = db.impl_self_ty(impl_id);
@@ -773,7 +774,7 @@ fn generic_implements_goal(
        .fill_with_bound_vars(DebruijnIndex::INNERMOST, kinds.len())
        .build();
    kinds.extend(iter::repeat(chalk_ir::TyVariableKind::General).take(substs.len() - 1));
-    let trait_ref = TraitRef { trait_, substs };
+    let trait_ref = TraitRef { trait_id: to_chalk_trait_id(trait_), substitution: substs };
    let obligation = super::Obligation::Trait(trait_ref);
    Canonical { kinds: kinds.into(), value: InEnvironment::new(env, obligation) }
 }
diff --git a/crates/hir_ty/src/traits.rs b/crates/hir_ty/src/traits.rs
index 40eb1034e..ac7de7605 100644
--- a/crates/hir_ty/src/traits.rs
+++ b/crates/hir_ty/src/traits.rs
@@ -8,10 +8,9 @@ use chalk_solve::{logging_db::LoggingRustIrDatabase, Solver};
 use hir_def::{lang_item::LangItemTarget, TraitId};
 use stdx::panic_context;
-use crate::{db::HirDatabase, DebruijnIndex, Substitution};
+use crate::{
+    db::HirDatabase, AliasTy, Canonical, DebruijnIndex, GenericPredicate, HirDisplay, Substitution,
-use super::{
+    TraitRef, Ty, TyKind, TypeWalk,
-    Canonical, GenericPredicate, HirDisplay, ProjectionTy, TraitRef, Ty, TyKind, TypeWalk,
 };
 use self::chalk::{from_chalk, Interner, ToChalk};
@@ -93,31 +92,32 @@ pub enum Obligation {
    /// Prove that a certain type implements a trait (the type is the `Self` type
    /// parameter to the `TraitRef`).
    Trait(TraitRef),
-    Projection(ProjectionPredicate),
+    AliasEq(AliasEq),
 }
 impl Obligation {
    pub fn from_predicate(predicate: GenericPredicate) -> Option<Obligation> {
        match predicate {
            GenericPredicate::Implemented(trait_ref) => Some(Obligation::Trait(trait_ref)),
-            GenericPredicate::Projection(projection_pred) => {
+            GenericPredicate::AliasEq(alias_eq) => Some(Obligation::AliasEq(alias_eq)),
-                Some(Obligation::Projection(projection_pred))
-            }
            GenericPredicate::Error => None,
        }
    }
 }
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
-pub struct ProjectionPredicate {
+pub struct AliasEq {
-    pub projection_ty: ProjectionTy,
+    pub alias: AliasTy,
    pub ty: Ty,
 }
-impl TypeWalk for ProjectionPredicate {
+impl TypeWalk for AliasEq {
    fn walk(&self, f: &mut impl FnMut(&Ty)) {
-        self.projection_ty.walk(f);
        self.ty.walk(f);
+        match &self.alias {
+            AliasTy::Projection(projection_ty) => projection_ty.walk(f),
+            AliasTy::Opaque(opaque) => opaque.walk(f),
+        }
    }
    fn walk_mut_binders(
@@ -125,8 +125,11 @@ impl TypeWalk for ProjectionPredicate {
        f: &mut impl FnMut(&mut Ty, DebruijnIndex),
        binders: DebruijnIndex,
    ) {
-        self.projection_ty.walk_mut_binders(f, binders);
        self.ty.walk_mut_binders(f, binders);
+        match &mut self.alias {
+            AliasTy::Projection(projection_ty) => projection_ty.walk_mut_binders(f, binders),
+            AliasTy::Opaque(opaque) => opaque.walk_mut_binders(f, binders),
+        }
    }
 }
@@ -137,13 +140,15 @@ pub(crate) fn trait_solve_query(
    goal: Canonical<InEnvironment<Obligation>>,
 ) -> Option<Solution> {
    let _p = profile::span("trait_solve_query").detail(|| match &goal.value.value {
-        Obligation::Trait(it) => db.trait_data(it.trait_).name.to_string(),
+        Obligation::Trait(it) => db.trait_data(it.hir_trait_id()).name.to_string(),
-        Obligation::Projection(_) => "projection".to_string(),
+        Obligation::AliasEq(_) => "alias_eq".to_string(),
    });
    log::info!("trait_solve_query({})", goal.value.value.display(db));
-    if let Obligation::Projection(pred) = &goal.value.value {
+    if let Obligation::AliasEq(AliasEq { alias: AliasTy::Projection(projection_ty), .. }) =
-        if let TyKind::BoundVar(_) = &pred.projection_ty.substitution[0].interned(&Interner) {
+        &goal.value.value
+    {
+        if let TyKind::BoundVar(_) = &projection_ty.substitution[0].interned(&Interner) {
            // Hack: don't ask Chalk to normalize with an unknown self type, it'll say that's impossible
            return Some(Solution::Ambig(Guidance::Unknown));
        }
diff --git a/crates/hir_ty/src/traits/chalk.rs b/crates/hir_ty/src/traits/chalk.rs
index bef6e7e9c..080764e76 100644
--- a/crates/hir_ty/src/traits/chalk.rs
+++ b/crates/hir_ty/src/traits/chalk.rs
@@ -19,10 +19,10 @@ use crate::{
    display::HirDisplay,
    from_assoc_type_id,
    method_resolution::{TyFingerprint, ALL_FLOAT_FPS, ALL_INT_FPS},
-    to_assoc_type_id,
+    to_assoc_type_id, to_chalk_trait_id,
    utils::generics,
-    BoundVar, CallableDefId, CallableSig, DebruijnIndex, FnDefId, GenericPredicate,
+    AliasEq, AliasTy, BoundVar, CallableDefId, CallableSig, DebruijnIndex, FnDefId,
-    ProjectionPredicate, ProjectionTy, Substitution, TraitRef, Ty, TyKind,
+    GenericPredicate, ProjectionTy, Substitution, TraitRef, Ty, TyKind,
 };
 use mapping::{
    convert_where_clauses, generic_predicate_to_inline_bound, make_binders, TypeAliasAsValue,
@@ -219,9 +219,9 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
                    // for<T> <Self> [Future<Self>, Future::Output<Self> = T]
                    //     ^1  ^0            ^0                    ^0      ^1
                    let impl_bound = GenericPredicate::Implemented(TraitRef {
-                        trait_: future_trait,
+                        trait_id: to_chalk_trait_id(future_trait),
                        // Self type as the first parameter.
-                        substs: Substitution::single(
+                        substitution: Substitution::single(
                            TyKind::BoundVar(BoundVar {
                                debruijn: DebruijnIndex::INNERMOST,
                                index: 0,
@@ -229,18 +229,18 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
                            .intern(&Interner),
                        ),
                    });
-                    let proj_bound = GenericPredicate::Projection(ProjectionPredicate {
+                    let proj_bound = GenericPredicate::AliasEq(AliasEq {
-                        // The parameter of the opaque type.
+                        alias: AliasTy::Projection(ProjectionTy {
-                        ty: TyKind::BoundVar(BoundVar { debruijn: DebruijnIndex::ONE, index: 0 })
-                            .intern(&Interner),
-                        projection_ty: ProjectionTy {
                            associated_ty_id: to_assoc_type_id(future_output),
                            // Self type as the first parameter.
                            substitution: Substitution::single(
                                TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0))
                                    .intern(&Interner),
                            ),
-                        },
+                        }),
+                        // The parameter of the opaque type.
+                        ty: TyKind::BoundVar(BoundVar { debruijn: DebruijnIndex::ONE, index: 0 })
+                            .intern(&Interner),
                    });
                    let bound = OpaqueTyDatumBound {
                        bounds: make_binders(
@@ -546,7 +546,7 @@ fn impl_def_datum(
    let generic_params = generics(db.upcast(), impl_id.into());
    let bound_vars = Substitution::bound_vars(&generic_params, DebruijnIndex::INNERMOST);
-    let trait_ = trait_ref.trait_;
+    let trait_ = trait_ref.hir_trait_id();
    let impl_type = if impl_id.lookup(db.upcast()).container.krate() == krate {
        rust_ir::ImplType::Local
    } else {
@@ -614,7 +614,7 @@ fn type_alias_associated_ty_value(
    let trait_ref = db.impl_trait(impl_id).expect("assoc ty value should not exist").value; // we don't return any assoc ty values if the impl'd trait can't be resolved
    let assoc_ty = db
-        .trait_data(trait_ref.trait_)
+        .trait_data(trait_ref.hir_trait_id())
        .associated_type_by_name(&type_alias_data.name)
        .expect("assoc ty value should not exist"); // validated when building the impl data as well
    let ty = db.ty(type_alias.into());
diff --git a/crates/hir_ty/src/traits/chalk/mapping.rs b/crates/hir_ty/src/traits/chalk/mapping.rs
index d969527dc..62b779008 100644
--- a/crates/hir_ty/src/traits/chalk/mapping.rs
+++ b/crates/hir_ty/src/traits/chalk/mapping.rs
@@ -14,8 +14,8 @@ use crate::{
    from_assoc_type_id,
    primitive::UintTy,
    traits::{Canonical, Obligation},
-    AliasTy, CallableDefId, FnPointer, GenericPredicate, InEnvironment, OpaqueTy,
+    AliasTy, CallableDefId, FnPointer, GenericPredicate, InEnvironment, OpaqueTy, ProjectionTy,
-    ProjectionPredicate, ProjectionTy, Scalar, Substitution, TraitRef, Ty,
+    Scalar, Substitution, TraitRef, Ty,
 };
 use super::interner::*;
@@ -239,15 +239,15 @@ impl ToChalk for TraitRef {
    type Chalk = chalk_ir::TraitRef<Interner>;
    fn to_chalk(self: TraitRef, db: &dyn HirDatabase) -> chalk_ir::TraitRef<Interner> {
-        let trait_id = self.trait_.to_chalk(db);
+        let trait_id = self.trait_id;
-        let substitution = self.substs.to_chalk(db);
+        let substitution = self.substitution.to_chalk(db);
        chalk_ir::TraitRef { trait_id, substitution }
    }
    fn from_chalk(db: &dyn HirDatabase, trait_ref: chalk_ir::TraitRef<Interner>) -> Self {
-        let trait_ = from_chalk(db, trait_ref.trait_id);
+        let trait_id = trait_ref.trait_id;
        let substs = from_chalk(db, trait_ref.substitution);
-        TraitRef { trait_, substs }
+        TraitRef { trait_id, substitution: substs }
    }
 }
@@ -314,12 +314,10 @@ impl ToChalk for GenericPredicate {
                let chalk_trait_ref = chalk_trait_ref.shifted_in(&Interner);
                make_binders(chalk_ir::WhereClause::Implemented(chalk_trait_ref), 0)
            }
-            GenericPredicate::Projection(projection_pred) => {
+            GenericPredicate::AliasEq(alias_eq) => make_binders(
-                let ty = projection_pred.ty.to_chalk(db).shifted_in(&Interner);
+                chalk_ir::WhereClause::AliasEq(alias_eq.to_chalk(db).shifted_in(&Interner)),
-                let projection = projection_pred.projection_ty.to_chalk(db).shifted_in(&Interner);
+                0,
-                let alias = chalk_ir::AliasTy::Projection(projection);
+            ),
-                make_binders(chalk_ir::WhereClause::AliasEq(chalk_ir::AliasEq { alias, ty }), 0)
-            }
            GenericPredicate::Error => panic!("tried passing GenericPredicate::Error to Chalk"),
        }
    }
@@ -338,16 +336,8 @@ impl ToChalk for GenericPredicate {
            chalk_ir::WhereClause::Implemented(tr) => {
                GenericPredicate::Implemented(from_chalk(db, tr))
            }
-            chalk_ir::WhereClause::AliasEq(projection_eq) => {
+            chalk_ir::WhereClause::AliasEq(alias_eq) => {
-                let projection_ty = from_chalk(
+                GenericPredicate::AliasEq(from_chalk(db, alias_eq))
-                    db,
-                    match projection_eq.alias {
-                        chalk_ir::AliasTy::Projection(p) => p,
-                        _ => unimplemented!(),
-                    },
-                );
-                let ty = from_chalk(db, projection_eq.ty);
-                GenericPredicate::Projection(ProjectionPredicate { projection_ty, ty })
            }
            chalk_ir::WhereClause::LifetimeOutlives(_) => {
@@ -383,19 +373,55 @@ impl ToChalk for ProjectionTy {
        }
    }
 }
+impl ToChalk for OpaqueTy {
+    type Chalk = chalk_ir::OpaqueTy<Interner>;
+    fn to_chalk(self, db: &dyn HirDatabase) -> Self::Chalk {
+        chalk_ir::OpaqueTy {
+            opaque_ty_id: self.opaque_ty_id,
+            substitution: self.substitution.to_chalk(db),
+        }
+    }
+    fn from_chalk(db: &dyn HirDatabase, chalk: Self::Chalk) -> Self {
+        OpaqueTy {
+            opaque_ty_id: chalk.opaque_ty_id,
+            substitution: from_chalk(db, chalk.substitution),
+        }
+    }
+}
+impl ToChalk for AliasTy {
+    type Chalk = chalk_ir::AliasTy<Interner>;
+    fn to_chalk(self, db: &dyn HirDatabase) -> Self::Chalk {
+        match self {
+            AliasTy::Projection(projection_ty) => {
+                chalk_ir::AliasTy::Projection(projection_ty.to_chalk(db))
+            }
+            AliasTy::Opaque(opaque_ty) => chalk_ir::AliasTy::Opaque(opaque_ty.to_chalk(db)),
+        }
+    }
+    fn from_chalk(db: &dyn HirDatabase, chalk: Self::Chalk) -> Self {
+        match chalk {
+            chalk_ir::AliasTy::Projection(projection_ty) => {
+                AliasTy::Projection(from_chalk(db, projection_ty))
+            }
+            chalk_ir::AliasTy::Opaque(opaque_ty) => AliasTy::Opaque(from_chalk(db, opaque_ty)),
+        }
+    }
+}
-impl ToChalk for ProjectionPredicate {
+impl ToChalk for AliasEq {
    type Chalk = chalk_ir::AliasEq<Interner>;
    fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::AliasEq<Interner> {
-        chalk_ir::AliasEq {
+        chalk_ir::AliasEq { alias: self.alias.to_chalk(db), ty: self.ty.to_chalk(db) }
-            alias: chalk_ir::AliasTy::Projection(self.projection_ty.to_chalk(db)),
-            ty: self.ty.to_chalk(db),
-        }
    }
-    fn from_chalk(_db: &dyn HirDatabase, _normalize: chalk_ir::AliasEq<Interner>) -> Self {
+    fn from_chalk(db: &dyn HirDatabase, alias_eq: chalk_ir::AliasEq<Interner>) -> Self {
-        unimplemented!()
+        AliasEq { alias: from_chalk(db, alias_eq.alias), ty: from_chalk(db, alias_eq.ty) }
    }
 }
@@ -405,7 +431,7 @@ impl ToChalk for Obligation {
    fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::DomainGoal<Interner> {
        match self {
            Obligation::Trait(tr) => tr.to_chalk(db).cast(&Interner),
-            Obligation::Projection(pr) => pr.to_chalk(db).cast(&Interner),
+            Obligation::AliasEq(alias_eq) => alias_eq.to_chalk(db).cast(&Interner),
        }
    }
@@ -515,42 +541,41 @@ pub(super) fn generic_predicate_to_inline_bound(
    // We don't have a special type for this, but Chalk does.
    match pred {
        GenericPredicate::Implemented(trait_ref) => {
-            if &trait_ref.substs[0] != self_ty {
+            if &trait_ref.substitution[0] != self_ty {
                // we can only convert predicates back to type bounds if they
                // have the expected self type
                return None;
            }
-            let args_no_self = trait_ref.substs[1..]
+            let args_no_self = trait_ref.substitution[1..]
                .iter()
                .map(|ty| ty.clone().to_chalk(db).cast(&Interner))
                .collect();
-            let trait_bound =
+            let trait_bound = rust_ir::TraitBound { trait_id: trait_ref.trait_id, args_no_self };
-                rust_ir::TraitBound { trait_id: trait_ref.trait_.to_chalk(db), args_no_self };
            Some(rust_ir::InlineBound::TraitBound(trait_bound))
        }
-        GenericPredicate::Projection(proj) => {
+        GenericPredicate::AliasEq(AliasEq { alias: AliasTy::Projection(projection_ty), ty }) => {
-            if &proj.projection_ty.substitution[0] != self_ty {
+            if &projection_ty.substitution[0] != self_ty {
                return None;
            }
-            let trait_ = match from_assoc_type_id(proj.projection_ty.associated_ty_id)
+            let trait_ = match from_assoc_type_id(projection_ty.associated_ty_id)
                .lookup(db.upcast())
                .container
            {
                AssocContainerId::TraitId(t) => t,
                _ => panic!("associated type not in trait"),
            };
-            let args_no_self = proj.projection_ty.substitution[1..]
+            let args_no_self = projection_ty.substitution[1..]
                .iter()
                .map(|ty| ty.clone().to_chalk(db).cast(&Interner))
                .collect();
            let alias_eq_bound = rust_ir::AliasEqBound {
-                value: proj.ty.clone().to_chalk(db),
+                value: ty.clone().to_chalk(db),
                trait_bound: rust_ir::TraitBound { trait_id: trait_.to_chalk(db), args_no_self },
-                associated_ty_id: proj.projection_ty.associated_ty_id,
+                associated_ty_id: projection_ty.associated_ty_id,
                parameters: Vec::new(), // FIXME we don't support generic associated types yet
            };
            Some(rust_ir::InlineBound::AliasEqBound(alias_eq_bound))
        }
-        GenericPredicate::Error => None,
+        _ => None,
    }
 }
diff --git a/crates/hir_ty/src/utils.rs b/crates/hir_ty/src/utils.rs
index 7351e4e54..b66243d48 100644
--- a/crates/hir_ty/src/utils.rs
+++ b/crates/hir_ty/src/utils.rs
@@ -55,9 +55,9 @@ fn direct_super_trait_refs(db: &dyn HirDatabase, trait_ref: &TraitRef) -> Vec<Tr
    // lifetime problems, but since there usually shouldn't be more than a
    // few direct traits this should be fine (we could even use some kind of
    // SmallVec if performance is a concern)
-    let generic_params = db.generic_params(trait_ref.trait_.into());
+    let generic_params = db.generic_params(trait_ref.hir_trait_id().into());
    let trait_self = match generic_params.find_trait_self_param() {
-        Some(p) => TypeParamId { parent: trait_ref.trait_.into(), local_id: p },
+        Some(p) => TypeParamId { parent: trait_ref.hir_trait_id().into(), local_id: p },
        None => return Vec::new(),
    };
    db.generic_predicates_for_param(trait_self)
@@ -68,7 +68,7 @@ fn direct_super_trait_refs(db: &dyn HirDatabase, trait_ref: &TraitRef) -> Vec<Tr
                _ => None,
            })
        })
-        .map(|pred| pred.subst(&trait_ref.substs))
+        .map(|pred| pred.subst(&trait_ref.substitution))
        .collect()
 }
@@ -108,7 +108,7 @@ pub(super) fn all_super_trait_refs(db: &dyn HirDatabase, trait_ref: TraitRef) ->
        // yeah this is quadratic, but trait hierarchies should be flat
        // enough that this doesn't matter
        for tt in direct_super_trait_refs(db, t) {
-            if !result.iter().any(|tr| tr.trait_ == tt.trait_) {
+            if !result.iter().any(|tr| tr.trait_id == tt.trait_id) {
                result.push(tt);
            }
        }
@@ -123,7 +123,7 @@ pub(super) fn associated_type_by_name_including_super_traits(
    name: &Name,
 ) -> Option<(TraitRef, TypeAliasId)> {
    all_super_trait_refs(db, trait_ref).into_iter().find_map(|t| {
-        let assoc_type = db.trait_data(t.trait_).associated_type_by_name(name)?;
+        let assoc_type = db.trait_data(t.hir_trait_id()).associated_type_by_name(name)?;
        Some((t, assoc_type))
    })
 }
diff --git a/crates/ide/src/display/navigation_target.rs b/crates/ide/src/display/navigation_target.rs
index c086de163..364be260c 100644
--- a/crates/ide/src/display/navigation_target.rs
+++ b/crates/ide/src/display/navigation_target.rs
@@ -339,10 +339,14 @@ impl TryToNav for hir::Field {
 impl TryToNav for hir::MacroDef {
    fn try_to_nav(&self, db: &RootDatabase) -> Option<NavigationTarget> {
        let src = self.source(db)?;
-        log::debug!("nav target {:#?}", src.value.syntax());
+        let name_owner: &dyn ast::NameOwner = match &src.value {
+            Either::Left(it) => it,
+            Either::Right(it) => it,
+        };
+        log::debug!("nav target {:#?}", name_owner.syntax());
        let mut res = NavigationTarget::from_named(
            db,
-            src.as_ref().map(|it| it as &dyn ast::NameOwner),
+            src.as_ref().with_value(name_owner),
            SymbolKind::Macro,
        );
        res.docs = self.docs(db);
diff --git a/crates/ide/src/goto_definition.rs b/crates/ide/src/goto_definition.rs
index 598b47e41..473d48c2f 100644
--- a/crates/ide/src/goto_definition.rs
+++ b/crates/ide/src/goto_definition.rs
@@ -1176,4 +1176,21 @@ fn foo() { A { a$0: }; }
 "#,
        )
    }
+    #[test]
+    fn goto_proc_macro() {
+        check(
+            r#"
+//- /main.rs crate:main deps:mac
+use mac::fn_macro;
+fn_macro$0!();
+//- /mac.rs crate:mac
+#[proc_macro]
+fn fn_macro() {}
+ //^^^^^^^^
+            "#,
+        )
+    }
 }
diff --git a/crates/ide/src/hover.rs b/crates/ide/src/hover.rs
index 15d309d7d..a3fb17c0a 100644
--- a/crates/ide/src/hover.rs
+++ b/crates/ide/src/hover.rs
@@ -331,10 +331,16 @@ fn hover_for_definition(
 ) -> Option<Markup> {
    let mod_path = definition_mod_path(db, &def);
    return match def {
-        Definition::Macro(it) => {
+        Definition::Macro(it) => match &it.source(db)?.value {
-            let label = macro_label(&it.source(db)?.value);
+            Either::Left(mac) => {
-            from_def_source_labeled(db, it, Some(label), mod_path)
+                let label = macro_label(&mac);
-        }
+                from_def_source_labeled(db, it, Some(label), mod_path)
+            }
+            Either::Right(_) => {
+                // FIXME
+                None
+            }
+        },
        Definition::Field(def) => from_hir_fmt(db, def, mod_path),
        Definition::ModuleDef(it) => match it {
            ModuleDef::Module(it) => from_hir_fmt(db, it, mod_path),
diff --git a/crates/ide/src/syntax_highlighting.rs b/crates/ide/src/syntax_highlighting.rs
index ba3447b3a..e25b698e0 100644
--- a/crates/ide/src/syntax_highlighting.rs
+++ b/crates/ide/src/syntax_highlighting.rs
@@ -12,7 +12,7 @@ mod html;
 #[cfg(test)]
 mod tests;
-use hir::{Name, Semantics};
+use hir::{InFile, Name, Semantics};
 use ide_db::{RootDatabase, SymbolKind};
 use rustc_hash::FxHashMap;
 use syntax::{
@@ -73,14 +73,20 @@ pub(crate) fn highlight(
    };
    let mut hl = highlights::Highlights::new(root.text_range());
-    traverse(&mut hl, &sema, &root, range_to_highlight, syntactic_name_ref_highlighting);
+    traverse(
+        &mut hl,
+        &sema,
+        InFile::new(file_id.into(), &root),
+        range_to_highlight,
+        syntactic_name_ref_highlighting,
+    );
    hl.to_vec()
 }
 fn traverse(
    hl: &mut Highlights,
    sema: &Semantics<RootDatabase>,
-    root: &SyntaxNode,
+    root: InFile<&SyntaxNode>,
    range_to_highlight: TextRange,
    syntactic_name_ref_highlighting: bool,
 ) {
@@ -93,7 +99,7 @@ fn traverse(
    // Walk all nodes, keeping track of whether we are inside a macro or not.
    // If in macro, expand it first and highlight the expanded code.
-    for event in root.preorder_with_tokens() {
+    for event in root.value.preorder_with_tokens() {
        let event_range = match &event {
            WalkEvent::Enter(it) | WalkEvent::Leave(it) => it.text_range(),
        };
@@ -150,7 +156,7 @@ fn traverse(
            WalkEvent::Enter(it) => it,
            WalkEvent::Leave(it) => {
                if let Some(node) = it.as_node() {
-                    inject::doc_comment(hl, sema, node);
+                    inject::doc_comment(hl, sema, root.with_value(node));
                }
                continue;
            }
diff --git a/crates/ide/src/syntax_highlighting/html.rs b/crates/ide/src/syntax_highlighting/html.rs
index 1d34731ab..5327af845 100644
--- a/crates/ide/src/syntax_highlighting/html.rs
+++ b/crates/ide/src/syntax_highlighting/html.rs
@@ -59,7 +59,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .label              { color: #DFAF8F; font-style: italic; }
 .comment            { color: #7F9F7F; }
 .documentation      { color: #629755; }
-.intra_doc_link     { color: #A9C577; }
+.intra_doc_link     { font-style: italic; }
 .injected           { opacity: 0.65 ; }
 .struct, .enum      { color: #7CB8BB; }
 .enum_variant       { color: #BDE0F3; }
diff --git a/crates/ide/src/syntax_highlighting/inject.rs b/crates/ide/src/syntax_highlighting/inject.rs
index 90feb6c18..5722dea3a 100644
--- a/crates/ide/src/syntax_highlighting/inject.rs
+++ b/crates/ide/src/syntax_highlighting/inject.rs
@@ -3,8 +3,8 @@
 use std::{mem, ops::Range};
 use either::Either;
-use hir::{HasAttrs, Semantics};
+use hir::{HasAttrs, InFile, Semantics};
-use ide_db::{call_info::ActiveParameter, defs::Definition};
+use ide_db::{call_info::ActiveParameter, defs::Definition, SymbolKind};
 use syntax::{
    ast::{self, AstNode, AttrsOwner, DocCommentsOwner},
    match_ast, AstToken, NodeOrToken, SyntaxNode, SyntaxToken, TextRange, TextSize,
@@ -148,8 +148,12 @@ fn doc_attributes<'node>(
 }
 /// Injection of syntax highlighting of doctests.
-pub(super) fn doc_comment(hl: &mut Highlights, sema: &Semantics<RootDatabase>, node: &SyntaxNode) {
+pub(super) fn doc_comment(
-    let (owner, attributes, def) = match doc_attributes(sema, node) {
+    hl: &mut Highlights,
+    sema: &Semantics<RootDatabase>,
+    node: InFile<&SyntaxNode>,
+) {
+    let (owner, attributes, def) = match doc_attributes(sema, node.value) {
        Some(it) => it,
        None => return,
    };
@@ -157,7 +161,12 @@ pub(super) fn doc_comment(hl: &mut Highlights, sema: &Semantics<RootDatabase>, n
    let mut inj = Injector::default();
    inj.add_unmapped("fn doctest() {\n");
-    let attrs_source_map = attributes.source_map(&owner);
+    let attrs_source_map = match def {
+        Definition::ModuleDef(hir::ModuleDef::Module(module)) => {
+            attributes.source_map_for_module(sema.db, module.into())
+        }
+        _ => attributes.source_map(node.with_value(&owner)),
+    };
    let mut is_codeblock = false;
    let mut is_doctest = false;
@@ -168,7 +177,10 @@ pub(super) fn doc_comment(hl: &mut Highlights, sema: &Semantics<RootDatabase>, n
    let mut intra_doc_links = Vec::new();
    let mut string;
    for attr in attributes.by_key("doc").attrs() {
-        let src = attrs_source_map.source_of(&attr);
+        let InFile { file_id, value: src } = attrs_source_map.source_of(&attr);
+        if file_id != node.file_id {
+            continue;
+        }
        let (line, range, prefix) = match &src {
            Either::Left(it) => {
                string = match find_doc_string_in_attr(attr, it) {
@@ -213,13 +225,16 @@ pub(super) fn doc_comment(hl: &mut Highlights, sema: &Semantics<RootDatabase>, n
                    intra_doc_links.extend(
                        extract_definitions_from_markdown(line)
                            .into_iter()
-                            .filter(|(link, ns, _)| {
+                            .filter_map(|(link, ns, range)| {
-                                validate_intra_doc_link(sema.db, &def, link, *ns)
+                                validate_intra_doc_link(sema.db, &def, &link, ns).zip(Some(range))
                            })
-                            .map(|(.., Range { start, end })| {
+                            .map(|(def, Range { start, end })| {
-                                TextRange::at(
+                                (
-                                    prev_range_start + TextSize::from(start as u32),
+                                    def,
-                                    TextSize::from((end - start) as u32),
+                                    TextRange::at(
+                                        prev_range_start + TextSize::from(start as u32),
+                                        TextSize::from((end - start) as u32),
+                                    ),
                                )
                            }),
                    );
@@ -243,10 +258,13 @@ pub(super) fn doc_comment(hl: &mut Highlights, sema: &Semantics<RootDatabase>, n
        }
    }
-    for range in intra_doc_links {
+    for (def, range) in intra_doc_links {
        hl.add(HlRange {
            range,
-            highlight: HlTag::IntraDocLink | HlMod::Documentation,
+            highlight: module_def_to_hl_tag(def)
+                | HlMod::Documentation
+                | HlMod::Injected
+                | HlMod::IntraDocLink,
            binding_hash: None,
        });
    }
@@ -306,7 +324,7 @@ fn validate_intra_doc_link(
    def: &Definition,
    link: &str,
    ns: Option<hir::Namespace>,
-) -> bool {
+) -> Option<hir::ModuleDef> {
    match def {
        Definition::ModuleDef(def) => match def {
            hir::ModuleDef::Module(it) => it.resolve_doc_path(db, &link, ns),
@@ -326,5 +344,21 @@ fn validate_intra_doc_link(
        | Definition::GenericParam(_)
        | Definition::Label(_) => None,
    }
-    .is_some()
+}
+fn module_def_to_hl_tag(def: hir::ModuleDef) -> HlTag {
+    let symbol = match def {
+        hir::ModuleDef::Module(_) => SymbolKind::Module,
+        hir::ModuleDef::Function(_) => SymbolKind::Function,
+        hir::ModuleDef::Adt(hir::Adt::Struct(_)) => SymbolKind::Struct,
+        hir::ModuleDef::Adt(hir::Adt::Enum(_)) => SymbolKind::Enum,
+        hir::ModuleDef::Adt(hir::Adt::Union(_)) => SymbolKind::Union,
+        hir::ModuleDef::Variant(_) => SymbolKind::Variant,
+        hir::ModuleDef::Const(_) => SymbolKind::Const,
+        hir::ModuleDef::Static(_) => SymbolKind::Static,
+        hir::ModuleDef::Trait(_) => SymbolKind::Trait,
+        hir::ModuleDef::TypeAlias(_) => SymbolKind::TypeAlias,
+        hir::ModuleDef::BuiltinType(_) => return HlTag::BuiltinType,
+    };
+    HlTag::Symbol(symbol)
 }
diff --git a/crates/ide/src/syntax_highlighting/tags.rs b/crates/ide/src/syntax_highlighting/tags.rs
index ce46e5127..93db79b89 100644
--- a/crates/ide/src/syntax_highlighting/tags.rs
+++ b/crates/ide/src/syntax_highlighting/tags.rs
@@ -26,7 +26,6 @@ pub enum HlTag {
    Comment,
    EscapeSequence,
    FormatSpecifier,
-    IntraDocLink,
    Keyword,
    NumericLiteral,
    Operator,
@@ -57,6 +56,8 @@ pub enum HlMod {
    Static,
    /// Used for items in impls&traits.
    Associated,
+    /// Used for intra doc links in doc injection.
+    IntraDocLink,
    /// Keep this last!
    Unsafe,
@@ -117,7 +118,6 @@ impl HlTag {
            HlTag::Comment => "comment",
            HlTag::EscapeSequence => "escape_sequence",
            HlTag::FormatSpecifier => "format_specifier",
-            HlTag::IntraDocLink => "intra_doc_link",
            HlTag::Keyword => "keyword",
            HlTag::Punctuation(punct) => match punct {
                HlPunct::Bracket => "bracket",
@@ -151,6 +151,7 @@ impl HlMod {
        HlMod::ControlFlow,
        HlMod::Definition,
        HlMod::Documentation,
+        HlMod::IntraDocLink,
        HlMod::Injected,
        HlMod::Mutable,
        HlMod::Consuming,
@@ -162,17 +163,18 @@ impl HlMod {
    fn as_str(self) -> &'static str {
        match self {
+            HlMod::Associated => "associated",
            HlMod::Attribute => "attribute",
+            HlMod::Callable => "callable",
+            HlMod::Consuming => "consuming",
            HlMod::ControlFlow => "control",
            HlMod::Definition => "declaration",
            HlMod::Documentation => "documentation",
            HlMod::Injected => "injected",
+            HlMod::IntraDocLink => "intra_doc_link",
            HlMod::Mutable => "mutable",
-            HlMod::Consuming => "consuming",
-            HlMod::Unsafe => "unsafe",
-            HlMod::Callable => "callable",
            HlMod::Static => "static",
-            HlMod::Associated => "associated",
+            HlMod::Unsafe => "unsafe",
        }
    }
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlight_assoc_functions.html b/crates/ide/src/syntax_highlighting/test_data/highlight_assoc_functions.html
index 60c7518af..4635ea927 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlight_assoc_functions.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlight_assoc_functions.html
@@ -7,7 +7,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .label              { color: #DFAF8F; font-style: italic; }
 .comment            { color: #7F9F7F; }
 .documentation      { color: #629755; }
-.intra_doc_link     { color: #A9C577; }
+.intra_doc_link     { font-style: italic; }
 .injected           { opacity: 0.65 ; }
 .struct, .enum      { color: #7CB8BB; }
 .enum_variant       { color: #BDE0F3; }
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html b/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html
index 5d802a647..045162eb8 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html
@@ -7,7 +7,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .label              { color: #DFAF8F; font-style: italic; }
 .comment            { color: #7F9F7F; }
 .documentation      { color: #629755; }
-.intra_doc_link     { color: #A9C577; }
+.intra_doc_link     { font-style: italic; }
 .injected           { opacity: 0.65 ; }
 .struct, .enum      { color: #7CB8BB; }
 .enum_variant       { color: #BDE0F3; }
@@ -99,8 +99,8 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
    <span class="brace">}</span>
 <span class="brace">}</span>
-<span class="comment documentation">/// </span><span class="intra_doc_link documentation">[`Foo`](Foo)</span><span class="comment documentation"> is a struct</span>
+<span class="comment documentation">/// </span><span class="struct documentation intra_doc_link injected">[`Foo`](Foo)</span><span class="comment documentation"> is a struct</span>
-<span class="comment documentation">/// </span><span class="intra_doc_link documentation">[`all_the_links`](all_the_links)</span><span class="comment documentation"> is this function</span>
+<span class="comment documentation">/// </span><span class="function documentation intra_doc_link injected">[`all_the_links`](all_the_links)</span><span class="comment documentation"> is this function</span>
 <span class="comment documentation">/// [`noop`](noop) is a macro below</span>
 <span class="keyword">pub</span> <span class="keyword">fn</span> <span class="function declaration">all_the_links</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlight_extern_crate.html b/crates/ide/src/syntax_highlighting/test_data/highlight_extern_crate.html
index 4e312765c..ca9bb1e7d 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlight_extern_crate.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlight_extern_crate.html
@@ -7,7 +7,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .label              { color: #DFAF8F; font-style: italic; }
 .comment            { color: #7F9F7F; }
 .documentation      { color: #629755; }
-.intra_doc_link     { color: #A9C577; }
+.intra_doc_link     { font-style: italic; }
 .injected           { opacity: 0.65 ; }
 .struct, .enum      { color: #7CB8BB; }
 .enum_variant       { color: #BDE0F3; }
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlight_injection.html b/crates/ide/src/syntax_highlighting/test_data/highlight_injection.html
index 57dfe7509..9215ddd9e 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlight_injection.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlight_injection.html
@@ -7,7 +7,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .label              { color: #DFAF8F; font-style: italic; }
 .comment            { color: #7F9F7F; }
 .documentation      { color: #629755; }
-.intra_doc_link     { color: #A9C577; }
+.intra_doc_link     { font-style: italic; }
 .injected           { opacity: 0.65 ; }
 .struct, .enum      { color: #7CB8BB; }
 .enum_variant       { color: #BDE0F3; }
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlight_strings.html b/crates/ide/src/syntax_highlighting/test_data/highlight_strings.html
index 75dbd0f14..e860d713e 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlight_strings.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlight_strings.html
@@ -7,7 +7,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .label              { color: #DFAF8F; font-style: italic; }
 .comment            { color: #7F9F7F; }
 .documentation      { color: #629755; }
-.intra_doc_link     { color: #A9C577; }
+.intra_doc_link     { font-style: italic; }
 .injected           { opacity: 0.65 ; }
 .struct, .enum      { color: #7CB8BB; }
 .enum_variant       { color: #BDE0F3; }
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlight_unsafe.html b/crates/ide/src/syntax_highlighting/test_data/highlight_unsafe.html
index 423256a20..6a6555208 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlight_unsafe.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlight_unsafe.html
@@ -7,7 +7,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .label              { color: #DFAF8F; font-style: italic; }
 .comment            { color: #7F9F7F; }
 .documentation      { color: #629755; }
-.intra_doc_link     { color: #A9C577; }
+.intra_doc_link     { font-style: italic; }
 .injected           { opacity: 0.65 ; }
 .struct, .enum      { color: #7CB8BB; }
 .enum_variant       { color: #BDE0F3; }
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlighting.html b/crates/ide/src/syntax_highlighting/test_data/highlighting.html
index fffe8c0f5..8b2dd3b70 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlighting.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlighting.html
@@ -7,7 +7,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .label              { color: #DFAF8F; font-style: italic; }
 .comment            { color: #7F9F7F; }
 .documentation      { color: #629755; }
-.intra_doc_link     { color: #A9C577; }
+.intra_doc_link     { font-style: italic; }
 .injected           { opacity: 0.65 ; }
 .struct, .enum      { color: #7CB8BB; }
 .enum_variant       { color: #BDE0F3; }
diff --git a/crates/ide/src/syntax_highlighting/test_data/injection.html b/crates/ide/src/syntax_highlighting/test_data/injection.html
index 34d8deb68..9ab46d05c 100644
--- a/crates/ide/src/syntax_highlighting/test_data/injection.html
+++ b/crates/ide/src/syntax_highlighting/test_data/injection.html
@@ -7,7 +7,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .label              { color: #DFAF8F; font-style: italic; }
 .comment            { color: #7F9F7F; }
 .documentation      { color: #629755; }
-.intra_doc_link     { color: #A9C577; }
+.intra_doc_link     { font-style: italic; }
 .injected           { opacity: 0.65 ; }
 .struct, .enum      { color: #7CB8BB; }
 .enum_variant       { color: #BDE0F3; }
diff --git a/crates/ide/src/syntax_highlighting/test_data/rainbow_highlighting.html b/crates/ide/src/syntax_highlighting/test_data/rainbow_highlighting.html
index d9ca3a4c4..666b0b228 100644
--- a/crates/ide/src/syntax_highlighting/test_data/rainbow_highlighting.html
+++ b/crates/ide/src/syntax_highlighting/test_data/rainbow_highlighting.html
@@ -7,7 +7,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .label              { color: #DFAF8F; font-style: italic; }
 .comment            { color: #7F9F7F; }
 .documentation      { color: #629755; }
-.intra_doc_link     { color: #A9C577; }
+.intra_doc_link     { font-style: italic; }
 .injected           { opacity: 0.65 ; }
 .struct, .enum      { color: #7CB8BB; }
 .enum_variant       { color: #BDE0F3; }
diff --git a/crates/ide_assists/src/handlers/qualify_path.rs b/crates/ide_assists/src/handlers/qualify_path.rs
index 30b23da6c..40571e52b 100644
--- a/crates/ide_assists/src/handlers/qualify_path.rs
+++ b/crates/ide_assists/src/handlers/qualify_path.rs
@@ -208,8 +208,10 @@ fn label(candidate: &ImportCandidate, import: &LocatedImport) -> String {
                format!("Qualify as `{}`", import.import_path)
            }
        }
-        ImportCandidate::TraitAssocItem(_) => format!("Qualify `{}`", import.import_path),
+        ImportCandidate::TraitAssocItem(_) => {
-        ImportCandidate::TraitMethod(_) => format!("Qualify with cast as `{}`", import.import_path),
+            format!("Qualify with `{}`", import.import_path)
+        }
+        ImportCandidate::TraitMethod(_) => format!("Qualify with `{}`", import.import_path),
    }
 }
@@ -544,6 +546,37 @@ fn main() {
    }
    #[test]
+    fn associated_struct_const_unqualified() {
+        check_assist(
+            qualify_path,
+            r"
+            mod test_mod {
+                pub struct TestStruct {}
+                impl TestStruct {
+                    const TEST_CONST: u8 = 42;
+                }
+            }
+            fn main() {
+                TEST_CONST$0
+            }
+            ",
+            r"
+            mod test_mod {
+                pub struct TestStruct {}
+                impl TestStruct {
+                    const TEST_CONST: u8 = 42;
+                }
+            }
+            fn main() {
+                test_mod::TestStruct::TEST_CONST
+            }
+            ",
+        );
+    }
+    #[test]
    fn associated_trait_function() {
        check_assist(
            qualify_path,
diff --git a/crates/ide_completion/src/render/macro_.rs b/crates/ide_completion/src/render/macro_.rs
index 3fa21ba7c..7578ad50b 100644
--- a/crates/ide_completion/src/render/macro_.rs
+++ b/crates/ide_completion/src/render/macro_.rs
@@ -91,7 +91,7 @@ impl<'a> MacroRender<'a> {
    }
    fn detail(&self) -> Option<String> {
-        let ast_node = self.macro_.source(self.ctx.db())?.value;
+        let ast_node = self.macro_.source(self.ctx.db())?.value.left()?;
        Some(macro_label(&ast_node))
    }
 }
diff --git a/crates/ide_db/src/helpers/import_assets.rs b/crates/ide_db/src/helpers/import_assets.rs
index e03ccd351..7c8844e95 100644
--- a/crates/ide_db/src/helpers/import_assets.rs
+++ b/crates/ide_db/src/helpers/import_assets.rs
@@ -304,7 +304,11 @@ fn path_applicable_imports(
            return items_with_candidate_name
                .into_iter()
                .filter_map(|item| {
-                    Some(LocatedImport::new(mod_path(item)?, item, item, mod_path(item)))
+                    let mut mod_path = mod_path(item)?;
+                    if let Some(assoc_item) = item_as_assoc(db, item) {
+                        mod_path.push_segment(assoc_item.name(db)?);
+                    }
+                    Some(LocatedImport::new(mod_path.clone(), item, item, Some(mod_path)))
                })
                .collect();
        }
diff --git a/crates/rust-analyzer/src/semantic_tokens.rs b/crates/rust-analyzer/src/semantic_tokens.rs
index 0cb7d12a7..a3c5e9ccf 100644
--- a/crates/rust-analyzer/src/semantic_tokens.rs
+++ b/crates/rust-analyzer/src/semantic_tokens.rs
@@ -52,7 +52,6 @@ define_semantic_token_types![
    (ESCAPE_SEQUENCE, "escapeSequence"),
    (FORMAT_SPECIFIER, "formatSpecifier"),
    (GENERIC, "generic"),
-    (INTRA_DOC_LINK, "intraDocLink"),
    (LABEL, "label"),
    (LIFETIME, "lifetime"),
    (PARENTHESIS, "parenthesis"),
@@ -90,6 +89,7 @@ define_semantic_token_modifiers![
    (UNSAFE, "unsafe"),
    (ATTRIBUTE_MODIFIER, "attribute"),
    (CALLABLE, "callable"),
+    (INTRA_DOC_LINK, "intraDocLink"),
 ];
 #[derive(Default)]
diff --git a/crates/rust-analyzer/src/to_proto.rs b/crates/rust-analyzer/src/to_proto.rs
index 70501618e..1ddea9278 100644
--- a/crates/rust-analyzer/src/to_proto.rs
+++ b/crates/rust-analyzer/src/to_proto.rs
@@ -443,7 +443,6 @@ fn semantic_token_type_and_modifiers(
        HlTag::Comment => lsp_types::SemanticTokenType::COMMENT,
        HlTag::EscapeSequence => semantic_tokens::ESCAPE_SEQUENCE,
        HlTag::FormatSpecifier => semantic_tokens::FORMAT_SPECIFIER,
-        HlTag::IntraDocLink => semantic_tokens::INTRA_DOC_LINK,
        HlTag::Keyword => lsp_types::SemanticTokenType::KEYWORD,
        HlTag::None => semantic_tokens::GENERIC,
        HlTag::Operator => lsp_types::SemanticTokenType::OPERATOR,
@@ -474,6 +473,7 @@ fn semantic_token_type_and_modifiers(
            HlMod::Unsafe => semantic_tokens::UNSAFE,
            HlMod::Callable => semantic_tokens::CALLABLE,
            HlMod::Static => lsp_types::SemanticTokenModifier::STATIC,
+            HlMod::IntraDocLink => semantic_tokens::INTRA_DOC_LINK,
            HlMod::Associated => continue,
        };
        mods |= modifier;
diff --git a/docs/user/manual.adoc b/docs/user/manual.adoc
index f4c37353c..dba2197de 100644
--- a/docs/user/manual.adoc
+++ b/docs/user/manual.adoc
@@ -384,11 +384,9 @@ If the LSP binary is not available, GNOME Builder can install it when opening a
 === Eclipse IDE
-Prerequisites: You have installed the <<rust-analyzer-language-server-binary,`rust-analyzer` binary>>.
 Support for Rust development in the Eclipse IDE is provided by link:https://github.com/eclipse/corrosion[Eclipse Corrosion].
-While it currently uses RLS as default, you can successfully configure it so the IDE will use `rust-analyzer` instead.
+If available in PATH or in some standard location, `rust-analyzer` is detected and powers editing of Rust files without further configuration.
-To do so, with an Eclipse IDE where Corrosion is installed, just go to __Window > Preferences > Rust__ and edit the __Path to Rust Language Server__ entry to reference the path to `rust-analyzer`.
+If `rust-analyzer` is not detected, Corrosion will prompt you for configuration of your Rust toolchain and language server with a link to the __Window > Preferences > Rust__ preference page; from here a button allows to download and configure `rust-analyzer`, but you can also reference another installation.
 You'll need to close and reopen all .rs and Cargo files, or to restart the IDE, for this change to take effect.
 == Configuration