44 files changed, 1038 insertions, 307 deletions
diff --git a/crates/ra_hir/src/adt.rs b/crates/ra_hir/src/adt.rs
index fbb4ff4d8..99d286215 100644
--- a/crates/ra_hir/src/adt.rs
+++ b/crates/ra_hir/src/adt.rs
@@ -133,7 +133,7 @@ impl VariantData {
                    .fields()
                    .enumerate()
                    .map(|(i, fd)| StructFieldData {
-                        name: Name::tuple_field_name(i),
+                        name: Name::new_tuple_field(i),
                        type_ref: TypeRef::from_ast_opt(fd.type_ref()),
                    })
                    .collect();
diff --git a/crates/ra_hir/src/attr.rs b/crates/ra_hir/src/attr.rs
new file mode 100644
index 000000000..f67e80bfd
--- /dev/null
+++ b/crates/ra_hir/src/attr.rs
@@ -0,0 +1,80 @@
+//! A higher level attributes based on TokenTree, with also some shortcuts.
+use std::sync::Arc;
+use mbe::ast_to_token_tree;
+use ra_cfg::CfgOptions;
+use ra_syntax::{
+    ast::{self, AstNode, AttrsOwner},
+    SmolStr,
+};
+use tt::Subtree;
+use crate::{db::AstDatabase, path::Path, HirFileId, Source};
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct Attr {
+    pub(crate) path: Path,
+    pub(crate) input: Option<AttrInput>,
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum AttrInput {
+    Literal(SmolStr),
+    TokenTree(Subtree),
+}
+impl Attr {
+    pub(crate) fn from_src(
+        Source { file_id, ast }: Source<ast::Attr>,
+        db: &impl AstDatabase,
+    ) -> Option<Attr> {
+        let path = Path::from_src(Source { file_id, ast: ast.path()? }, db)?;
+        let input = match ast.input() {
+            None => None,
+            Some(ast::AttrInput::Literal(lit)) => {
+                // FIXME: escape? raw string?
+                let value = lit.syntax().first_token()?.text().trim_matches('"').into();
+                Some(AttrInput::Literal(value))
+            }
+            Some(ast::AttrInput::TokenTree(tt)) => {
+                Some(AttrInput::TokenTree(ast_to_token_tree(&tt)?.0))
+            }
+        };
+        Some(Attr { path, input })
+    }
+    pub(crate) fn from_attrs_owner(
+        file_id: HirFileId,
+        owner: &dyn AttrsOwner,
+        db: &impl AstDatabase,
+    ) -> Option<Arc<[Attr]>> {
+        let mut attrs = owner.attrs().peekable();
+        if attrs.peek().is_none() {
+            // Avoid heap allocation
+            return None;
+        }
+        Some(attrs.flat_map(|ast| Attr::from_src(Source { file_id, ast }, db)).collect())
+    }
+    pub(crate) fn is_simple_atom(&self, name: &str) -> bool {
+        // FIXME: Avoid cloning
+        self.path.as_ident().map_or(false, |s| s.to_string() == name)
+    }
+    pub(crate) fn as_cfg(&self) -> Option<&Subtree> {
+        if self.is_simple_atom("cfg") {
+            match &self.input {
+                Some(AttrInput::TokenTree(subtree)) => Some(subtree),
+                _ => None,
+            }
+        } else {
+            None
+        }
+    }
+    pub(crate) fn is_cfg_enabled(&self, cfg_options: &CfgOptions) -> Option<bool> {
+        cfg_options.is_cfg_enabled(self.as_cfg()?)
+    }
+}
diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index 20413cb3d..e3a7e8e3c 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -1,3 +1,5 @@
+//! FIXME: write short doc here
 pub(crate) mod src;
 pub(crate) mod docs;
@@ -339,10 +341,14 @@ pub struct Struct {
 }
 impl Struct {
-    pub fn module(self, db: &impl HirDatabase) -> Module {
+    pub fn module(self, db: &impl DefDatabase) -> Module {
        self.id.module(db)
    }
+    pub fn krate(self, db: &impl DefDatabase) -> Option<Crate> {
+        self.module(db).krate(db)
+    }
    pub fn name(self, db: &impl DefDatabase) -> Option<Name> {
        db.struct_data(self).name.clone()
    }
@@ -423,10 +429,14 @@ pub struct Enum {
 }
 impl Enum {
-    pub fn module(self, db: &impl HirDatabase) -> Module {
+    pub fn module(self, db: &impl DefDatabase) -> Module {
        self.id.module(db)
    }
+    pub fn krate(self, db: &impl DefDatabase) -> Option<Crate> {
+        self.module(db).krate(db)
+    }
    pub fn name(self, db: &impl DefDatabase) -> Option<Name> {
        db.enum_data(self).name.clone()
    }
@@ -514,7 +524,7 @@ impl Adt {
        }
    }
-    pub(crate) fn krate(self, db: &impl HirDatabase) -> Option<Crate> {
+    pub fn krate(self, db: &impl HirDatabase) -> Option<Crate> {
        match self {
            Adt::Struct(s) => s.module(db),
            Adt::Union(s) => s.module(db),
diff --git a/crates/ra_hir/src/code_model/docs.rs b/crates/ra_hir/src/code_model/docs.rs
index 99edc5814..9675e397f 100644
--- a/crates/ra_hir/src/code_model/docs.rs
+++ b/crates/ra_hir/src/code_model/docs.rs
@@ -1,3 +1,5 @@
+//! FIXME: write short doc here
 use std::sync::Arc;
 use ra_syntax::ast;
diff --git a/crates/ra_hir/src/code_model/src.rs b/crates/ra_hir/src/code_model/src.rs
index c0cb27b47..fdae26906 100644
--- a/crates/ra_hir/src/code_model/src.rs
+++ b/crates/ra_hir/src/code_model/src.rs
@@ -1,3 +1,5 @@
+//! FIXME: write short doc here
 use ra_syntax::{
    ast::{self, AstNode},
    SyntaxNode,
@@ -119,7 +121,7 @@ impl HasSource for TypeAlias {
 impl HasSource for MacroDef {
    type Ast = ast::MacroCall;
    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<ast::MacroCall> {
-        Source { file_id: self.id.0.file_id(), ast: self.id.0.to_node(db) }
+        Source { file_id: self.id.ast_id.file_id(), ast: self.id.ast_id.to_node(db) }
    }
 }
diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs
index deed1c62f..73d7d6fb6 100644
--- a/crates/ra_hir/src/db.rs
+++ b/crates/ra_hir/src/db.rs
@@ -1,3 +1,5 @@
+//! FIXME: write short doc here
 use std::sync::Arc;
 use ra_db::{salsa, SourceDatabase};
diff --git a/crates/ra_hir/src/diagnostics.rs b/crates/ra_hir/src/diagnostics.rs
index 60da33695..9acdaf8ed 100644
--- a/crates/ra_hir/src/diagnostics.rs
+++ b/crates/ra_hir/src/diagnostics.rs
@@ -1,3 +1,5 @@
+//! FIXME: write short doc here
 use std::{any::Any, fmt};
 use ra_syntax::{ast, AstNode, AstPtr, SyntaxNode, SyntaxNodePtr, TextRange};
diff --git a/crates/ra_hir/src/either.rs b/crates/ra_hir/src/either.rs
index 439e6ec87..83583ef8b 100644
--- a/crates/ra_hir/src/either.rs
+++ b/crates/ra_hir/src/either.rs
@@ -1,3 +1,5 @@
+//! FIXME: write short doc here
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub enum Either<A, B> {
    A(A),
diff --git a/crates/ra_hir/src/expr.rs b/crates/ra_hir/src/expr.rs
index b1bec2a68..d238741ba 100644
--- a/crates/ra_hir/src/expr.rs
+++ b/crates/ra_hir/src/expr.rs
@@ -1,3 +1,5 @@
+//! FIXME: write short doc here
 pub(crate) mod lower;
 pub(crate) mod scope;
 pub(crate) mod validation;
diff --git a/crates/ra_hir/src/expr/lower.rs b/crates/ra_hir/src/expr/lower.rs
index 61535d24f..50ea429ea 100644
--- a/crates/ra_hir/src/expr/lower.rs
+++ b/crates/ra_hir/src/expr/lower.rs
@@ -1,3 +1,5 @@
+//! FIXME: write short doc here
 use ra_arena::Arena;
 use ra_syntax::{
    ast::{
@@ -272,8 +274,11 @@ where
                self.alloc_expr(Expr::Match { expr, arms }, syntax_ptr)
            }
            ast::Expr::PathExpr(e) => {
-                let path =
+                let path = e
-                    e.path().and_then(Path::from_ast).map(Expr::Path).unwrap_or(Expr::Missing);
+                    .path()
+                    .and_then(|path| self.parse_path(path))
+                    .map(Expr::Path)
+                    .unwrap_or(Expr::Missing);
                self.alloc_expr(path, syntax_ptr)
            }
            ast::Expr::ContinueExpr(_e) => {
@@ -295,7 +300,7 @@ where
                self.alloc_expr(Expr::Return { expr }, syntax_ptr)
            }
            ast::Expr::RecordLit(e) => {
-                let path = e.path().and_then(Path::from_ast);
+                let path = e.path().and_then(|path| self.parse_path(path));
                let mut field_ptrs = Vec::new();
                let record_lit = if let Some(nfl) = e.record_field_list() {
                    let fields = nfl
@@ -459,7 +464,7 @@ where
                    .ast_id(&e)
                    .with_file_id(self.current_file_id);
-                if let Some(path) = e.path().and_then(Path::from_ast) {
+                if let Some(path) = e.path().and_then(|path| self.parse_path(path)) {
                    if let Some(def) = self.resolver.resolve_path_as_macro(self.db, &path) {
                        let call_id = MacroCallLoc { def: def.id, ast_id }.id(self.db);
                        let file_id = call_id.as_file(MacroFileKind::Expr);
@@ -529,7 +534,7 @@ where
                Pat::Bind { name, mode: annotation, subpat }
            }
            ast::Pat::TupleStructPat(p) => {
-                let path = p.path().and_then(Path::from_ast);
+                let path = p.path().and_then(|path| self.parse_path(path));
                let args = p.args().map(|p| self.collect_pat(p)).collect();
                Pat::TupleStruct { path, args }
            }
@@ -539,7 +544,7 @@ where
                Pat::Ref { pat, mutability }
            }
            ast::Pat::PathPat(p) => {
-                let path = p.path().and_then(Path::from_ast);
+                let path = p.path().and_then(|path| self.parse_path(path));
                path.map(Pat::Path).unwrap_or(Pat::Missing)
            }
            ast::Pat::TuplePat(p) => {
@@ -548,7 +553,7 @@ where
            }
            ast::Pat::PlaceholderPat(_) => Pat::Wild,
            ast::Pat::RecordPat(p) => {
-                let path = p.path().and_then(Path::from_ast);
+                let path = p.path().and_then(|path| self.parse_path(path));
                let record_field_pat_list =
                    p.record_field_pat_list().expect("every struct should have a field list");
                let mut fields: Vec<_> = record_field_pat_list
@@ -589,6 +594,10 @@ where
            self.missing_pat()
        }
    }
+    fn parse_path(&mut self, path: ast::Path) -> Option<Path> {
+        Path::from_src(Source { ast: path, file_id: self.current_file_id }, self.db)
+    }
 }
 impl From<ast::BinOp> for BinaryOp {
diff --git a/crates/ra_hir/src/expr/scope.rs b/crates/ra_hir/src/expr/scope.rs
index de0983a7e..5496822e7 100644
--- a/crates/ra_hir/src/expr/scope.rs
+++ b/crates/ra_hir/src/expr/scope.rs
@@ -1,3 +1,5 @@
+//! FIXME: write short doc here
 use std::sync::Arc;
 use ra_arena::{impl_arena_id, Arena, RawId};
diff --git a/crates/ra_hir/src/expr/validation.rs b/crates/ra_hir/src/expr/validation.rs
index f06e5ec07..1aa853c3e 100644
--- a/crates/ra_hir/src/expr/validation.rs
+++ b/crates/ra_hir/src/expr/validation.rs
@@ -1,3 +1,5 @@
+//! FIXME: write short doc here
 use std::sync::Arc;
 use ra_syntax::ast;
diff --git a/crates/ra_hir/src/from_source.rs b/crates/ra_hir/src/from_source.rs
index 7b6d9b240..a012f33f7 100644
--- a/crates/ra_hir/src/from_source.rs
+++ b/crates/ra_hir/src/from_source.rs
@@ -1,3 +1,5 @@
+//! FIXME: write short doc here
 use ra_db::{FileId, FilePosition};
 use ra_syntax::{
    algo::find_node_at_offset,
diff --git a/crates/ra_hir/src/generics.rs b/crates/ra_hir/src/generics.rs
index 6865d34ba..4ce7551c3 100644
--- a/crates/ra_hir/src/generics.rs
+++ b/crates/ra_hir/src/generics.rs
@@ -132,6 +132,7 @@ impl GenericParams {
    fn fill_params(&mut self, params: ast::TypeParamList, start: u32) {
        for (idx, type_param) in params.type_params().enumerate() {
            let name = type_param.name().map_or_else(Name::missing, |it| it.as_name());
+            // FIXME: Use `Path::from_src`
            let default = type_param.default_type().and_then(|t| t.path()).and_then(Path::from_ast);
            let param = GenericParam { idx: idx as u32 + start, name: name.clone(), default };
diff --git a/crates/ra_hir/src/ids.rs b/crates/ra_hir/src/ids.rs
index 9ea4e695d..a3b65cc79 100644
--- a/crates/ra_hir/src/ids.rs
+++ b/crates/ra_hir/src/ids.rs
@@ -1,3 +1,5 @@
+//! FIXME: write short doc here
 use std::{
    hash::{Hash, Hasher},
    sync::Arc,
@@ -10,7 +12,7 @@ use ra_syntax::{ast, AstNode, Parse, SyntaxNode};
 use crate::{
    db::{AstDatabase, DefDatabase, InternDatabase},
-    AstId, FileAstId, Module, Source,
+    AstId, Crate, FileAstId, Module, Source,
 };
 /// hir makes heavy use of ids: integer (u32) handlers to various things. You
@@ -58,6 +60,17 @@ impl HirFileId {
        }
    }
+    /// Get the crate which the macro lives in, if it is a macro file.
+    pub(crate) fn macro_crate(self, db: &impl AstDatabase) -> Option<Crate> {
+        match self.0 {
+            HirFileIdRepr::File(_) => None,
+            HirFileIdRepr::Macro(macro_file) => {
+                let loc = macro_file.macro_call_id.loc(db);
+                Some(loc.def.krate)
+            }
+        }
+    }
    pub(crate) fn parse_or_expand_query(
        db: &impl AstDatabase,
        file_id: HirFileId,
@@ -121,10 +134,13 @@ impl From<FileId> for HirFileId {
 }
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct MacroDefId(pub(crate) AstId<ast::MacroCall>);
+pub struct MacroDefId {
+    pub(crate) ast_id: AstId<ast::MacroCall>,
+    pub(crate) krate: Crate,
+}
 pub(crate) fn macro_def_query(db: &impl AstDatabase, id: MacroDefId) -> Option<Arc<MacroRules>> {
-    let macro_call = id.0.to_node(db);
+    let macro_call = id.ast_id.to_node(db);
    let arg = macro_call.token_tree()?;
    let (tt, _) = mbe::ast_to_token_tree(&arg).or_else(|| {
        log::warn!("fail on macro_def to token tree: {:#?}", arg);
diff --git a/crates/ra_hir/src/impl_block.rs b/crates/ra_hir/src/impl_block.rs
index d830202bd..55dfc393b 100644
--- a/crates/ra_hir/src/impl_block.rs
+++ b/crates/ra_hir/src/impl_block.rs
@@ -1,13 +1,17 @@
+//! FIXME: write short doc here
 use rustc_hash::FxHashMap;
 use std::sync::Arc;
 use ra_arena::{impl_arena_id, map::ArenaMap, Arena, RawId};
+use ra_cfg::CfgOptions;
 use ra_syntax::{
    ast::{self, AstNode},
    AstPtr,
 };
 use crate::{
+    attr::Attr,
    code_model::{Module, ModuleSource},
    db::{AstDatabase, DefDatabase, HirDatabase},
    generics::HasGenericParams,
@@ -174,6 +178,7 @@ pub struct ModuleImplBlocks {
 impl ModuleImplBlocks {
    fn collect(
        db: &(impl DefDatabase + AstDatabase),
+        cfg_options: &CfgOptions,
        module: Module,
        source_map: &mut ImplSourceMap,
    ) -> Self {
@@ -186,11 +191,11 @@ impl ModuleImplBlocks {
        let src = m.module.definition_source(db);
        match &src.ast {
            ModuleSource::SourceFile(node) => {
-                m.collect_from_item_owner(db, source_map, node, src.file_id)
+                m.collect_from_item_owner(db, cfg_options, source_map, node, src.file_id)
            }
            ModuleSource::Module(node) => {
                let item_list = node.item_list().expect("inline module should have item list");
-                m.collect_from_item_owner(db, source_map, &item_list, src.file_id)
+                m.collect_from_item_owner(db, cfg_options, source_map, &item_list, src.file_id)
            }
        };
        m
@@ -199,6 +204,7 @@ impl ModuleImplBlocks {
    fn collect_from_item_owner(
        &mut self,
        db: &(impl DefDatabase + AstDatabase),
+        cfg_options: &CfgOptions,
        source_map: &mut ImplSourceMap,
        owner: &dyn ast::ModuleItemOwner,
        file_id: HirFileId,
@@ -206,6 +212,13 @@ impl ModuleImplBlocks {
        for item in owner.items_with_macros() {
            match item {
                ast::ItemOrMacro::Item(ast::ModuleItem::ImplBlock(impl_block_ast)) => {
+                    let attrs = Attr::from_attrs_owner(file_id, &impl_block_ast, db);
+                    if attrs.map_or(false, |attrs| {
+                        attrs.iter().any(|attr| attr.is_cfg_enabled(cfg_options) == Some(false))
+                    }) {
+                        continue;
+                    }
                    let impl_block = ImplData::from_ast(db, file_id, self.module, &impl_block_ast);
                    let id = self.impls.alloc(impl_block);
                    for &impl_item in &self.impls[id].items {
@@ -216,9 +229,19 @@ impl ModuleImplBlocks {
                }
                ast::ItemOrMacro::Item(_) => (),
                ast::ItemOrMacro::Macro(macro_call) => {
+                    let attrs = Attr::from_attrs_owner(file_id, &macro_call, db);
+                    if attrs.map_or(false, |attrs| {
+                        attrs.iter().any(|attr| attr.is_cfg_enabled(cfg_options) == Some(false))
+                    }) {
+                        continue;
+                    }
                    //FIXME: we should really cut down on the boilerplate required to process a macro
                    let ast_id = db.ast_id_map(file_id).ast_id(&macro_call).with_file_id(file_id);
-                    if let Some(path) = macro_call.path().and_then(Path::from_ast) {
+                    if let Some(path) = macro_call
+                        .path()
+                        .and_then(|path| Path::from_src(Source { ast: path, file_id }, db))
+                    {
                        if let Some(def) = self.module.resolver(db).resolve_path_as_macro(db, &path)
                        {
                            let call_id = MacroCallLoc { def: def.id, ast_id }.id(db);
@@ -226,7 +249,13 @@ impl ModuleImplBlocks {
                            if let Some(item_list) =
                                db.parse_or_expand(file_id).and_then(ast::MacroItems::cast)
                            {
-                                self.collect_from_item_owner(db, source_map, &item_list, file_id)
+                                self.collect_from_item_owner(
+                                    db,
+                                    cfg_options,
+                                    source_map,
+                                    &item_list,
+                                    file_id,
+                                )
                            }
                        }
                    }
@@ -241,8 +270,10 @@ pub(crate) fn impls_in_module_with_source_map_query(
    module: Module,
 ) -> (Arc<ModuleImplBlocks>, Arc<ImplSourceMap>) {
    let mut source_map = ImplSourceMap::default();
+    let crate_graph = db.crate_graph();
+    let cfg_options = crate_graph.cfg_options(module.krate.crate_id());
-    let result = ModuleImplBlocks::collect(db, module, &mut source_map);
+    let result = ModuleImplBlocks::collect(db, cfg_options, module, &mut source_map);
    (Arc::new(result), Arc::new(source_map))
 }
diff --git a/crates/ra_hir/src/lang_item.rs b/crates/ra_hir/src/lang_item.rs
index bcce314d8..6c4e8ffbd 100644
--- a/crates/ra_hir/src/lang_item.rs
+++ b/crates/ra_hir/src/lang_item.rs
@@ -1,3 +1,5 @@
+//! FIXME: write short doc here
 use rustc_hash::FxHashMap;
 use std::sync::Arc;
@@ -151,7 +153,7 @@ impl LangItems {
 fn lang_item_name<T: AttrsOwner>(node: &T) -> Option<SmolStr> {
    node.attrs()
-        .filter_map(|a| a.as_key_value())
+        .filter_map(|a| a.as_simple_key_value())
        .filter(|(key, _)| key == "lang")
        .map(|(_, val)| val)
        .nth(0)
diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs
index a9de9fb6b..4340e9d34 100644
--- a/crates/ra_hir/src/lib.rs
+++ b/crates/ra_hir/src/lib.rs
@@ -1,5 +1,3 @@
-#![recursion_limit = "512"]
 //! HIR (previously known as descriptors) provides a high-level object oriented
 //! access to Rust code.
 //!
@@ -7,6 +5,8 @@
 //! to a particular crate instance. That is, it has cfg flags and features
 //! applied. So, the relation between syntax and HIR is many-to-one.
+#![recursion_limit = "512"]
 macro_rules! impl_froms {
    ($e:ident: $($v:ident $(($($sv:ident),*))?),*) => {
        $(
@@ -44,6 +44,7 @@ mod traits;
 mod type_alias;
 mod type_ref;
 mod ty;
+mod attr;
 mod impl_block;
 mod expr;
 mod lang_item;
diff --git a/crates/ra_hir/src/marks.rs b/crates/ra_hir/src/marks.rs
index b2111be05..79af24b20 100644
--- a/crates/ra_hir/src/marks.rs
+++ b/crates/ra_hir/src/marks.rs
@@ -1,3 +1,5 @@
+//! See test_utils/src/marks.rs
 test_utils::marks!(
    bogus_paths
    name_res_works_for_broken_modules
@@ -9,9 +11,10 @@ test_utils::marks!(
    glob_across_crates
    std_prelude
    match_ergonomics_ref
-    trait_resolution_on_fn_type
    infer_while_let
    macro_rules_from_other_crates_are_visible_with_macro_use
    prelude_is_macro_use
    coerce_merge_fail_fallback
+    macro_dollar_crate_self
+    macro_dollar_crate_other
 );
diff --git a/crates/ra_hir/src/mock.rs b/crates/ra_hir/src/mock.rs
index cb405091e..f750986b8 100644
--- a/crates/ra_hir/src/mock.rs
+++ b/crates/ra_hir/src/mock.rs
@@ -1,6 +1,9 @@
+//! FIXME: write short doc here
 use std::{panic, sync::Arc};
 use parking_lot::Mutex;
+use ra_cfg::CfgOptions;
 use ra_db::{
    salsa, CrateGraph, CrateId, Edition, FileId, FilePosition, SourceDatabase, SourceRoot,
    SourceRootId,
@@ -72,13 +75,13 @@ impl MockDatabase {
    pub fn set_crate_graph_from_fixture(&mut self, graph: CrateGraphFixture) {
        let mut ids = FxHashMap::default();
        let mut crate_graph = CrateGraph::default();
-        for (crate_name, (crate_root, edition, _)) in graph.0.iter() {
+        for (crate_name, (crate_root, edition, cfg_options, _)) in graph.0.iter() {
            let crate_root = self.file_id_of(&crate_root);
-            let crate_id = crate_graph.add_crate_root(crate_root, *edition);
+            let crate_id = crate_graph.add_crate_root(crate_root, *edition, cfg_options.clone());
            Arc::make_mut(&mut self.crate_names).insert(crate_id, crate_name.clone());
            ids.insert(crate_name, crate_id);
        }
-        for (crate_name, (_, _, deps)) in graph.0.iter() {
+        for (crate_name, (_, _, _, deps)) in graph.0.iter() {
            let from = ids[crate_name];
            for dep in deps {
                let to = ids[dep];
@@ -182,7 +185,7 @@ impl MockDatabase {
        if is_crate_root {
            let mut crate_graph = CrateGraph::default();
-            crate_graph.add_crate_root(file_id, Edition::Edition2018);
+            crate_graph.add_crate_root(file_id, Edition::Edition2018, CfgOptions::default());
            self.set_crate_graph(Arc::new(crate_graph));
        }
        file_id
@@ -266,19 +269,27 @@ impl MockDatabase {
 }
 #[derive(Default)]
-pub struct CrateGraphFixture(pub Vec<(String, (String, Edition, Vec<String>))>);
+pub struct CrateGraphFixture(pub Vec<(String, (String, Edition, CfgOptions, Vec<String>))>);
 #[macro_export]
 macro_rules! crate_graph {
-    ($($crate_name:literal: ($crate_path:literal, $($edition:literal,)? [$($dep:literal),*]),)*) => {{
+    ($(
+        $crate_name:literal: (
+            $crate_path:literal,
+            $($edition:literal,)?
+            [$($dep:literal),*]
+            $(,$cfg:expr)?
+        ),
+    )*) => {{
        let mut res = $crate::mock::CrateGraphFixture::default();
        $(
            #[allow(unused_mut, unused_assignments)]
            let mut edition = ra_db::Edition::Edition2018;
            $(edition = ra_db::Edition::from_string($edition);)?
+            let cfg_options = { ::ra_cfg::CfgOptions::default() $(; $cfg)? };
            res.0.push((
                $crate_name.to_string(),
-                ($crate_path.to_string(), edition, vec![$($dep.to_string()),*])
+                ($crate_path.to_string(), edition, cfg_options, vec![$($dep.to_string()),*])
            ));
        )*
        res
diff --git a/crates/ra_hir/src/name.rs b/crates/ra_hir/src/name.rs
index 1bf993ffb..1e0b8c350 100644
--- a/crates/ra_hir/src/name.rs
+++ b/crates/ra_hir/src/name.rs
@@ -1,3 +1,5 @@
+//! FIXME: write short doc here
 use std::fmt;
 use ra_syntax::{ast, SmolStr};
@@ -5,20 +7,21 @@ use ra_syntax::{ast, SmolStr};
 /// `Name` is a wrapper around string, which is used in hir for both references
 /// and declarations. In theory, names should also carry hygiene info, but we are
 /// not there yet!
-#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub struct Name {
+pub struct Name(Repr);
-    text: SmolStr,
-}
-impl fmt::Display for Name {
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+enum Repr {
-        fmt::Display::fmt(&self.text, f)
+    Text(SmolStr),
-    }
+    TupleField(usize),
 }
-impl fmt::Debug for Name {
+impl fmt::Display for Name {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::Debug::fmt(&self.text, f)
+        match &self.0 {
+            Repr::Text(text) => fmt::Display::fmt(&text, f),
+            Repr::TupleField(idx) => fmt::Display::fmt(&idx, f),
+        }
    }
 }
@@ -26,29 +29,38 @@ impl Name {
    /// Note: this is private to make creating name from random string hard.
    /// Hopefully, this should allow us to integrate hygiene cleaner in the
    /// future, and to switch to interned representation of names.
-    const fn new(text: SmolStr) -> Name {
+    const fn new_text(text: SmolStr) -> Name {
-        Name { text }
+        Name(Repr::Text(text))
    }
-    pub(crate) fn missing() -> Name {
+    pub(crate) fn new_tuple_field(idx: usize) -> Name {
-        Name::new("[missing name]".into())
+        Name(Repr::TupleField(idx))
+    }
+    /// Shortcut to create inline plain text name
+    const fn new_inline_ascii(len: usize, text: &[u8]) -> Name {
+        Name::new_text(SmolStr::new_inline_from_ascii(len, text))
    }
-    pub(crate) fn tuple_field_name(idx: usize) -> Name {
+    /// Resolve a name from the text of token.
-        Name::new(idx.to_string().into())
+    fn resolve(raw_text: &SmolStr) -> Name {
+        let raw_start = "r#";
+        if raw_text.as_str().starts_with(raw_start) {
+            Name::new_text(SmolStr::new(&raw_text[raw_start.len()..]))
+        } else {
+            Name::new_text(raw_text.clone())
+        }
    }
-    // There's should be no way to extract a string out of `Name`: `Name` in the
+    pub(crate) fn missing() -> Name {
-    // future, `Name` will include hygiene information, and you can't encode
+        Name::new_text("[missing name]".into())
-    // hygiene into a String.
+    }
-    //
-    // If you need to compare something with `Name`, compare `Name`s directly.
+    pub(crate) fn as_tuple_index(&self) -> Option<usize> {
-    //
+        match self.0 {
-    // If you need to render `Name` for the user, use the `Display` impl, but be
+            Repr::TupleField(idx) => Some(idx),
-    // aware that it strips hygiene info.
+            _ => None,
-    #[deprecated(note = "use to_string instead")]
+        }
-    pub fn as_smolstr(&self) -> &SmolStr {
-        &self.text
    }
 }
@@ -58,15 +70,16 @@ pub(crate) trait AsName {
 impl AsName for ast::NameRef {
    fn as_name(&self) -> Name {
-        let name = resolve_name(self.text());
+        match self.as_tuple_field() {
-        Name::new(name)
+            Some(idx) => Name::new_tuple_field(idx),
+            None => Name::resolve(self.text()),
+        }
    }
 }
 impl AsName for ast::Name {
    fn as_name(&self) -> Name {
-        let name = resolve_name(self.text());
+        Name::resolve(self.text())
-        Name::new(name)
    }
 }
@@ -74,66 +87,56 @@ impl AsName for ast::FieldKind {
    fn as_name(&self) -> Name {
        match self {
            ast::FieldKind::Name(nr) => nr.as_name(),
-            ast::FieldKind::Index(idx) => Name::new(idx.text().clone()),
+            ast::FieldKind::Index(idx) => Name::new_tuple_field(idx.text().parse().unwrap()),
        }
    }
 }
 impl AsName for ra_db::Dependency {
    fn as_name(&self) -> Name {
-        Name::new(self.name.clone())
+        Name::new_text(self.name.clone())
    }
 }
 // Primitives
-pub(crate) const ISIZE: Name = Name::new(SmolStr::new_inline_from_ascii(5, b"isize"));
+pub(crate) const ISIZE: Name = Name::new_inline_ascii(5, b"isize");
-pub(crate) const I8: Name = Name::new(SmolStr::new_inline_from_ascii(2, b"i8"));
+pub(crate) const I8: Name = Name::new_inline_ascii(2, b"i8");
-pub(crate) const I16: Name = Name::new(SmolStr::new_inline_from_ascii(3, b"i16"));
+pub(crate) const I16: Name = Name::new_inline_ascii(3, b"i16");
-pub(crate) const I32: Name = Name::new(SmolStr::new_inline_from_ascii(3, b"i32"));
+pub(crate) const I32: Name = Name::new_inline_ascii(3, b"i32");
-pub(crate) const I64: Name = Name::new(SmolStr::new_inline_from_ascii(3, b"i64"));
+pub(crate) const I64: Name = Name::new_inline_ascii(3, b"i64");
-pub(crate) const I128: Name = Name::new(SmolStr::new_inline_from_ascii(4, b"i128"));
+pub(crate) const I128: Name = Name::new_inline_ascii(4, b"i128");
-pub(crate) const USIZE: Name = Name::new(SmolStr::new_inline_from_ascii(5, b"usize"));
+pub(crate) const USIZE: Name = Name::new_inline_ascii(5, b"usize");
-pub(crate) const U8: Name = Name::new(SmolStr::new_inline_from_ascii(2, b"u8"));
+pub(crate) const U8: Name = Name::new_inline_ascii(2, b"u8");
-pub(crate) const U16: Name = Name::new(SmolStr::new_inline_from_ascii(3, b"u16"));
+pub(crate) const U16: Name = Name::new_inline_ascii(3, b"u16");
-pub(crate) const U32: Name = Name::new(SmolStr::new_inline_from_ascii(3, b"u32"));
+pub(crate) const U32: Name = Name::new_inline_ascii(3, b"u32");
-pub(crate) const U64: Name = Name::new(SmolStr::new_inline_from_ascii(3, b"u64"));
+pub(crate) const U64: Name = Name::new_inline_ascii(3, b"u64");
-pub(crate) const U128: Name = Name::new(SmolStr::new_inline_from_ascii(4, b"u128"));
+pub(crate) const U128: Name = Name::new_inline_ascii(4, b"u128");
-pub(crate) const F32: Name = Name::new(SmolStr::new_inline_from_ascii(3, b"f32"));
+pub(crate) const F32: Name = Name::new_inline_ascii(3, b"f32");
-pub(crate) const F64: Name = Name::new(SmolStr::new_inline_from_ascii(3, b"f64"));
+pub(crate) const F64: Name = Name::new_inline_ascii(3, b"f64");
-pub(crate) const BOOL: Name = Name::new(SmolStr::new_inline_from_ascii(4, b"bool"));
+pub(crate) const BOOL: Name = Name::new_inline_ascii(4, b"bool");
-pub(crate) const CHAR: Name = Name::new(SmolStr::new_inline_from_ascii(4, b"char"));
+pub(crate) const CHAR: Name = Name::new_inline_ascii(4, b"char");
-pub(crate) const STR: Name = Name::new(SmolStr::new_inline_from_ascii(3, b"str"));
+pub(crate) const STR: Name = Name::new_inline_ascii(3, b"str");
 // Special names
-pub(crate) const SELF_PARAM: Name = Name::new(SmolStr::new_inline_from_ascii(4, b"self"));
+pub(crate) const SELF_PARAM: Name = Name::new_inline_ascii(4, b"self");
-pub(crate) const SELF_TYPE: Name = Name::new(SmolStr::new_inline_from_ascii(4, b"Self"));
+pub(crate) const SELF_TYPE: Name = Name::new_inline_ascii(4, b"Self");
-pub(crate) const MACRO_RULES: Name = Name::new(SmolStr::new_inline_from_ascii(11, b"macro_rules"));
+pub(crate) const MACRO_RULES: Name = Name::new_inline_ascii(11, b"macro_rules");
 // Components of known path (value or mod name)
-pub(crate) const STD: Name = Name::new(SmolStr::new_inline_from_ascii(3, b"std"));
+pub(crate) const STD: Name = Name::new_inline_ascii(3, b"std");
-pub(crate) const ITER: Name = Name::new(SmolStr::new_inline_from_ascii(4, b"iter"));
+pub(crate) const ITER: Name = Name::new_inline_ascii(4, b"iter");
-pub(crate) const OPS: Name = Name::new(SmolStr::new_inline_from_ascii(3, b"ops"));
+pub(crate) const OPS: Name = Name::new_inline_ascii(3, b"ops");
-pub(crate) const FUTURE: Name = Name::new(SmolStr::new_inline_from_ascii(6, b"future"));
+pub(crate) const FUTURE: Name = Name::new_inline_ascii(6, b"future");
-pub(crate) const RESULT: Name = Name::new(SmolStr::new_inline_from_ascii(6, b"result"));
+pub(crate) const RESULT: Name = Name::new_inline_ascii(6, b"result");
-pub(crate) const BOXED: Name = Name::new(SmolStr::new_inline_from_ascii(5, b"boxed"));
+pub(crate) const BOXED: Name = Name::new_inline_ascii(5, b"boxed");
 // Components of known path (type name)
-pub(crate) const INTO_ITERATOR_TYPE: Name =
+pub(crate) const INTO_ITERATOR_TYPE: Name = Name::new_inline_ascii(12, b"IntoIterator");
-    Name::new(SmolStr::new_inline_from_ascii(12, b"IntoIterator"));
+pub(crate) const ITEM_TYPE: Name = Name::new_inline_ascii(4, b"Item");
-pub(crate) const ITEM_TYPE: Name = Name::new(SmolStr::new_inline_from_ascii(4, b"Item"));
+pub(crate) const TRY_TYPE: Name = Name::new_inline_ascii(3, b"Try");
-pub(crate) const TRY_TYPE: Name = Name::new(SmolStr::new_inline_from_ascii(3, b"Try"));
+pub(crate) const OK_TYPE: Name = Name::new_inline_ascii(2, b"Ok");
-pub(crate) const OK_TYPE: Name = Name::new(SmolStr::new_inline_from_ascii(2, b"Ok"));
+pub(crate) const FUTURE_TYPE: Name = Name::new_inline_ascii(6, b"Future");
-pub(crate) const FUTURE_TYPE: Name = Name::new(SmolStr::new_inline_from_ascii(6, b"Future"));
+pub(crate) const RESULT_TYPE: Name = Name::new_inline_ascii(6, b"Result");
-pub(crate) const RESULT_TYPE: Name = Name::new(SmolStr::new_inline_from_ascii(6, b"Result"));
+pub(crate) const OUTPUT_TYPE: Name = Name::new_inline_ascii(6, b"Output");
-pub(crate) const OUTPUT_TYPE: Name = Name::new(SmolStr::new_inline_from_ascii(6, b"Output"));
+pub(crate) const TARGET_TYPE: Name = Name::new_inline_ascii(6, b"Target");
-pub(crate) const TARGET_TYPE: Name = Name::new(SmolStr::new_inline_from_ascii(6, b"Target"));
+pub(crate) const BOX_TYPE: Name = Name::new_inline_ascii(3, b"Box");
-pub(crate) const BOX_TYPE: Name = Name::new(SmolStr::new_inline_from_ascii(3, b"Box"));
-fn resolve_name(text: &SmolStr) -> SmolStr {
-    let raw_start = "r#";
-    if text.as_str().starts_with(raw_start) {
-        SmolStr::new(&text[raw_start.len()..])
-    } else {
-        text.clone()
-    }
-}
diff --git a/crates/ra_hir/src/nameres.rs b/crates/ra_hir/src/nameres.rs
index b808a0c36..67adcfa28 100644
--- a/crates/ra_hir/src/nameres.rs
+++ b/crates/ra_hir/src/nameres.rs
@@ -332,6 +332,20 @@ impl CrateDefMap {
    ) -> ResolvePathResult {
        let mut segments = path.segments.iter().enumerate();
        let mut curr_per_ns: PerNs = match path.kind {
+            PathKind::DollarCrate(krate) => {
+                if krate == self.krate {
+                    tested_by!(macro_dollar_crate_self);
+                    PerNs::types(Module { krate: self.krate, module_id: self.root }.into())
+                } else {
+                    match krate.root_module(db) {
+                        Some(module) => {
+                            tested_by!(macro_dollar_crate_other);
+                            PerNs::types(module.into())
+                        }
+                        None => return ResolvePathResult::empty(ReachedFixedPoint::Yes),
+                    }
+                }
+            }
            PathKind::Crate => {
                PerNs::types(Module { krate: self.krate, module_id: self.root }.into())
            }
diff --git a/crates/ra_hir/src/nameres/collector.rs b/crates/ra_hir/src/nameres/collector.rs
index ef7dc6ebe..cef2dc9d2 100644
--- a/crates/ra_hir/src/nameres/collector.rs
+++ b/crates/ra_hir/src/nameres/collector.rs
@@ -1,3 +1,6 @@
+//! FIXME: write short doc here
+use ra_cfg::CfgOptions;
 use ra_db::FileId;
 use ra_syntax::{ast, SmolStr};
 use rustc_hash::FxHashMap;
@@ -33,6 +36,9 @@ pub(super) fn collect_defs(db: &impl DefDatabase, mut def_map: CrateDefMap) -> C
        }
    }
+    let crate_graph = db.crate_graph();
+    let cfg_options = crate_graph.cfg_options(def_map.krate().crate_id());
    let mut collector = DefCollector {
        db,
        def_map,
@@ -40,6 +46,7 @@ pub(super) fn collect_defs(db: &impl DefDatabase, mut def_map: CrateDefMap) -> C
        unresolved_imports: Vec::new(),
        unexpanded_macros: Vec::new(),
        macro_stack_monitor: MacroStackMonitor::default(),
+        cfg_options,
    };
    collector.collect();
    collector.finish()
@@ -74,8 +81,8 @@ impl MacroStackMonitor {
 }
 /// Walks the tree of module recursively
-struct DefCollector<DB> {
+struct DefCollector<'a, DB> {
-    db: DB,
+    db: &'a DB,
    def_map: CrateDefMap,
    glob_imports: FxHashMap<CrateModuleId, Vec<(CrateModuleId, raw::ImportId)>>,
    unresolved_imports: Vec<(CrateModuleId, raw::ImportId, raw::ImportData)>,
@@ -84,9 +91,11 @@ struct DefCollector<DB> {
    /// Some macro use `$tt:tt which mean we have to handle the macro perfectly
    /// To prevent stack overflow, we add a deep counter here for prevent that.
    macro_stack_monitor: MacroStackMonitor,
+    cfg_options: &'a CfgOptions,
 }
-impl<'a, DB> DefCollector<&'a DB>
+impl<DB> DefCollector<'_, DB>
 where
    DB: DefDatabase,
 {
@@ -504,7 +513,7 @@ struct ModCollector<'a, D> {
    parent_module: Option<ParentModule<'a>>,
 }
-impl<DB> ModCollector<'_, &'_ mut DefCollector<&'_ DB>>
+impl<DB> ModCollector<'_, &'_ mut DefCollector<'_, DB>>
 where
    DB: DefDatabase,
 {
@@ -521,24 +530,27 @@ where
        // `#[macro_use] extern crate` is hoisted to imports macros before collecting
        // any other items.
        for item in items {
-            if let raw::RawItem::Import(import_id) = *item {
+            if self.is_cfg_enabled(&item.attrs) {
-                let import = self.raw_items[import_id].clone();
+                if let raw::RawItemKind::Import(import_id) = item.kind {
-                if import.is_extern_crate && import.is_macro_use {
+                    let import = self.raw_items[import_id].clone();
-                    self.def_collector.import_macros_from_extern_crate(self.module_id, &import);
+                    if import.is_extern_crate && import.is_macro_use {
+                        self.def_collector.import_macros_from_extern_crate(self.module_id, &import);
+                    }
                }
            }
        }
        for item in items {
-            match *item {
+            if self.is_cfg_enabled(&item.attrs) {
-                raw::RawItem::Module(m) => self.collect_module(&self.raw_items[m]),
+                match item.kind {
-                raw::RawItem::Import(import_id) => self.def_collector.unresolved_imports.push((
+                    raw::RawItemKind::Module(m) => self.collect_module(&self.raw_items[m]),
-                    self.module_id,
+                    raw::RawItemKind::Import(import_id) => self
-                    import_id,
+                        .def_collector
-                    self.raw_items[import_id].clone(),
+                        .unresolved_imports
-                )),
+                        .push((self.module_id, import_id, self.raw_items[import_id].clone())),
-                raw::RawItem::Def(def) => self.define_def(&self.raw_items[def]),
+                    raw::RawItemKind::Def(def) => self.define_def(&self.raw_items[def]),
-                raw::RawItem::Macro(mac) => self.collect_macro(&self.raw_items[mac]),
+                    raw::RawItemKind::Macro(mac) => self.collect_macro(&self.raw_items[mac]),
+                }
            }
        }
    }
@@ -662,7 +674,10 @@ where
        // Case 1: macro rules, define a macro in crate-global mutable scope
        if is_macro_rules(&mac.path) {
            if let Some(name) = &mac.name {
-                let macro_id = MacroDefId(mac.ast_id.with_file_id(self.file_id));
+                let macro_id = MacroDefId {
+                    ast_id: mac.ast_id.with_file_id(self.file_id),
+                    krate: self.def_collector.def_map.krate,
+                };
                let macro_ = MacroDef { id: macro_id };
                self.def_collector.define_macro(self.module_id, name.clone(), macro_, mac.export);
            }
@@ -698,6 +713,14 @@ where
            self.def_collector.define_legacy_macro(self.module_id, name.clone(), macro_);
        }
    }
+    fn is_cfg_enabled(&self, attrs: &raw::Attrs) -> bool {
+        attrs.as_ref().map_or(true, |attrs| {
+            attrs
+                .iter()
+                .all(|attr| attr.is_cfg_enabled(&self.def_collector.cfg_options) != Some(false))
+        })
+    }
 }
 fn is_macro_rules(path: &Path) -> bool {
@@ -725,6 +748,7 @@ mod tests {
            unresolved_imports: Vec::new(),
            unexpanded_macros: Vec::new(),
            macro_stack_monitor: monitor,
+            cfg_options: &CfgOptions::default(),
        };
        collector.collect();
        collector.finish()
diff --git a/crates/ra_hir/src/nameres/per_ns.rs b/crates/ra_hir/src/nameres/per_ns.rs
index 964da2794..0da6789de 100644
--- a/crates/ra_hir/src/nameres/per_ns.rs
+++ b/crates/ra_hir/src/nameres/per_ns.rs
@@ -1,3 +1,5 @@
+//! FIXME: write short doc here
 use crate::{MacroDef, ModuleDef};
 #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
diff --git a/crates/ra_hir/src/nameres/raw.rs b/crates/ra_hir/src/nameres/raw.rs
index 29aaddbf1..623b343c4 100644
--- a/crates/ra_hir/src/nameres/raw.rs
+++ b/crates/ra_hir/src/nameres/raw.rs
@@ -1,3 +1,5 @@
+//! FIXME: write short doc here
 use std::{ops::Index, sync::Arc};
 use ra_arena::{impl_arena_id, map::ArenaMap, Arena, RawId};
@@ -8,8 +10,9 @@ use ra_syntax::{
 use test_utils::tested_by;
 use crate::{
+    attr::Attr,
    db::{AstDatabase, DefDatabase},
-    AsName, AstIdMap, Either, FileAstId, HirFileId, ModuleSource, Name, Path,
+    AsName, AstIdMap, Either, FileAstId, HirFileId, ModuleSource, Name, Path, Source,
 };
 /// `RawItems` is a set of top-level items in a file (except for impls).
@@ -71,6 +74,8 @@ impl RawItems {
            raw_items: RawItems::default(),
            source_ast_id_map: db.ast_id_map(file_id),
            source_map: ImportSourceMap::default(),
+            file_id,
+            db,
        };
        if let Some(node) = db.parse_or_expand(file_id) {
            if let Some(source_file) = ast::SourceFile::cast(node.clone()) {
@@ -115,8 +120,17 @@ impl Index<Macro> for RawItems {
    }
 }
+// Avoid heap allocation on items without attributes.
+pub(super) type Attrs = Option<Arc<[Attr]>>;
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub(super) struct RawItem {
+    pub(super) attrs: Attrs,
+    pub(super) kind: RawItemKind,
+}
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
-pub(super) enum RawItem {
+pub(super) enum RawItemKind {
    Module(Module),
    Import(ImportId),
    Def(Def),
@@ -192,13 +206,15 @@ pub(super) struct MacroData {
    pub(super) export: bool,
 }
-struct RawItemsCollector {
+struct RawItemsCollector<DB> {
    raw_items: RawItems,
    source_ast_id_map: Arc<AstIdMap>,
    source_map: ImportSourceMap,
+    file_id: HirFileId,
+    db: DB,
 }
-impl RawItemsCollector {
+impl<DB: AstDatabase> RawItemsCollector<&DB> {
    fn process_module(&mut self, current_module: Option<Module>, body: impl ast::ModuleItemOwner) {
        for item_or_macro in body.items_with_macros() {
            match item_or_macro {
@@ -209,6 +225,7 @@ impl RawItemsCollector {
    }
    fn add_item(&mut self, current_module: Option<Module>, item: ast::ModuleItem) {
+        let attrs = self.parse_attrs(&item);
        let (kind, name) = match item {
            ast::ModuleItem::Module(module) => {
                self.add_module(current_module, module);
@@ -257,7 +274,7 @@ impl RawItemsCollector {
        if let Some(name) = name {
            let name = name.as_name();
            let def = self.raw_items.defs.alloc(DefData { name, kind });
-            self.push_item(current_module, RawItem::Def(def))
+            self.push_item(current_module, attrs, RawItemKind::Def(def));
        }
    }
@@ -266,8 +283,10 @@ impl RawItemsCollector {
            Some(it) => it.as_name(),
            None => return,
        };
+        let attrs = self.parse_attrs(&module);
        let ast_id = self.source_ast_id_map.ast_id(&module);
+        // FIXME: cfg_attr
        let is_macro_use = module.has_atom_attr("macro_use");
        if module.has_semi() {
            let attr_path = extract_mod_path_attribute(&module);
@@ -277,7 +296,7 @@ impl RawItemsCollector {
                attr_path,
                is_macro_use,
            });
-            self.push_item(current_module, RawItem::Module(item));
+            self.push_item(current_module, attrs, RawItemKind::Module(item));
            return;
        }
@@ -291,26 +310,37 @@ impl RawItemsCollector {
                is_macro_use,
            });
            self.process_module(Some(item), item_list);
-            self.push_item(current_module, RawItem::Module(item));
+            self.push_item(current_module, attrs, RawItemKind::Module(item));
            return;
        }
        tested_by!(name_res_works_for_broken_modules);
    }
    fn add_use_item(&mut self, current_module: Option<Module>, use_item: ast::UseItem) {
+        // FIXME: cfg_attr
        let is_prelude = use_item.has_atom_attr("prelude_import");
+        let attrs = self.parse_attrs(&use_item);
-        Path::expand_use_item(&use_item, |path, use_tree, is_glob, alias| {
-            let import_data = ImportData {
+        Path::expand_use_item(
-                path,
+            Source { ast: use_item, file_id: self.file_id },
-                alias,
+            self.db,
-                is_glob,
+            |path, use_tree, is_glob, alias| {
-                is_prelude,
+                let import_data = ImportData {
-                is_extern_crate: false,
+                    path,
-                is_macro_use: false,
+                    alias,
-            };
+                    is_glob,
-            self.push_import(current_module, import_data, Either::A(AstPtr::new(use_tree)));
+                    is_prelude,
-        })
+                    is_extern_crate: false,
+                    is_macro_use: false,
+                };
+                self.push_import(
+                    current_module,
+                    attrs.clone(),
+                    import_data,
+                    Either::A(AstPtr::new(use_tree)),
+                );
+            },
+        )
    }
    fn add_extern_crate_item(
@@ -321,6 +351,8 @@ impl RawItemsCollector {
        if let Some(name_ref) = extern_crate.name_ref() {
            let path = Path::from_name_ref(&name_ref);
            let alias = extern_crate.alias().and_then(|a| a.name()).map(|it| it.as_name());
+            let attrs = self.parse_attrs(&extern_crate);
+            // FIXME: cfg_attr
            let is_macro_use = extern_crate.has_atom_attr("macro_use");
            let import_data = ImportData {
                path,
@@ -330,37 +362,47 @@ impl RawItemsCollector {
                is_extern_crate: true,
                is_macro_use,
            };
-            self.push_import(current_module, import_data, Either::B(AstPtr::new(&extern_crate)));
+            self.push_import(
+                current_module,
+                attrs,
+                import_data,
+                Either::B(AstPtr::new(&extern_crate)),
+            );
        }
    }
    fn add_macro(&mut self, current_module: Option<Module>, m: ast::MacroCall) {
-        let path = match m.path().and_then(Path::from_ast) {
+        let attrs = self.parse_attrs(&m);
+        let path = match m
+            .path()
+            .and_then(|path| Path::from_src(Source { ast: path, file_id: self.file_id }, self.db))
+        {
            Some(it) => it,
            _ => return,
        };
        let name = m.name().map(|it| it.as_name());
        let ast_id = self.source_ast_id_map.ast_id(&m);
-        let export = m.has_atom_attr("macro_export")
+        // FIXME: cfg_attr
-            || m.attrs().filter_map(|x| x.as_call()).any(|(name, _)| name == "macro_export");
+        let export = m.attrs().filter_map(|x| x.simple_name()).any(|name| name == "macro_export");
        let m = self.raw_items.macros.alloc(MacroData { ast_id, path, name, export });
-        self.push_item(current_module, RawItem::Macro(m));
+        self.push_item(current_module, attrs, RawItemKind::Macro(m));
    }
    fn push_import(
        &mut self,
        current_module: Option<Module>,
+        attrs: Attrs,
        data: ImportData,
        source: ImportSourcePtr,
    ) {
        let import = self.raw_items.imports.alloc(data);
        self.source_map.insert(import, source);
-        self.push_item(current_module, RawItem::Import(import))
+        self.push_item(current_module, attrs, RawItemKind::Import(import))
    }
-    fn push_item(&mut self, current_module: Option<Module>, item: RawItem) {
+    fn push_item(&mut self, current_module: Option<Module>, attrs: Attrs, kind: RawItemKind) {
        match current_module {
            Some(module) => match &mut self.raw_items.modules[module] {
                ModuleData::Definition { items, .. } => items,
@@ -368,13 +410,17 @@ impl RawItemsCollector {
            },
            None => &mut self.raw_items.items,
        }
-        .push(item)
+        .push(RawItem { attrs, kind })
+    }
+    fn parse_attrs(&self, item: &impl ast::AttrsOwner) -> Attrs {
+        Attr::from_attrs_owner(self.file_id, item, self.db)
    }
 }
 fn extract_mod_path_attribute(module: &ast::Module) -> Option<SmolStr> {
    module.attrs().into_iter().find_map(|attr| {
-        attr.as_key_value().and_then(|(name, value)| {
+        attr.as_simple_key_value().and_then(|(name, value)| {
            let is_path = name == "path";
            if is_path {
                Some(value)
diff --git a/crates/ra_hir/src/nameres/tests.rs b/crates/ra_hir/src/nameres/tests.rs
index bc4b47b70..34dd79574 100644
--- a/crates/ra_hir/src/nameres/tests.rs
+++ b/crates/ra_hir/src/nameres/tests.rs
@@ -7,6 +7,7 @@ mod mod_resolution;
 use std::sync::Arc;
 use insta::assert_snapshot;
+use ra_cfg::CfgOptions;
 use ra_db::SourceDatabase;
 use test_utils::covers;
@@ -507,3 +508,72 @@ fn values_dont_shadow_extern_crates() {
        ⋮foo: v
    "###);
 }
+#[test]
+fn cfg_not_test() {
+    let map = def_map_with_crate_graph(
+        r#"
+        //- /main.rs
+        use {Foo, Bar, Baz};
+        //- /lib.rs
+        #[prelude_import]
+        pub use self::prelude::*;
+        mod prelude {
+            #[cfg(test)]
+            pub struct Foo;
+            #[cfg(not(test))]
+            pub struct Bar;
+            #[cfg(all(not(any()), feature = "foo", feature = "bar", opt = "42"))]
+            pub struct Baz;
+        }
+        "#,
+        crate_graph! {
+            "main": ("/main.rs", ["std"]),
+            "std": ("/lib.rs", []),
+        },
+    );
+    assert_snapshot!(map, @r###"
+        ⋮crate
+        ⋮Bar: t v
+        ⋮Baz: _
+        ⋮Foo: _
+    "###);
+}
+#[test]
+fn cfg_test() {
+    let map = def_map_with_crate_graph(
+        r#"
+        //- /main.rs
+        use {Foo, Bar, Baz};
+        //- /lib.rs
+        #[prelude_import]
+        pub use self::prelude::*;
+        mod prelude {
+            #[cfg(test)]
+            pub struct Foo;
+            #[cfg(not(test))]
+            pub struct Bar;
+            #[cfg(all(not(any()), feature = "foo", feature = "bar", opt = "42"))]
+            pub struct Baz;
+        }
+        "#,
+        crate_graph! {
+            "main": ("/main.rs", ["std"]),
+            "std": ("/lib.rs", [], CfgOptions::default()
+                .atom("test".into())
+                .key_value("feature".into(), "foo".into())
+                .key_value("feature".into(), "bar".into())
+                .key_value("opt".into(), "42".into())
+            ),
+        },
+    );
+    assert_snapshot!(map, @r###"
+        ⋮crate
+        ⋮Bar: _
+        ⋮Baz: t v
+        ⋮Foo: t v
+    "###);
+}
diff --git a/crates/ra_hir/src/nameres/tests/macros.rs b/crates/ra_hir/src/nameres/tests/macros.rs
index bd60f4258..e4b408394 100644
--- a/crates/ra_hir/src/nameres/tests/macros.rs
+++ b/crates/ra_hir/src/nameres/tests/macros.rs
@@ -515,3 +515,108 @@ fn path_qualified_macros() {
        ⋮not_found: _
    "###);
 }
+#[test]
+fn macro_dollar_crate_is_correct_in_item() {
+    covers!(macro_dollar_crate_self);
+    covers!(macro_dollar_crate_other);
+    let map = def_map_with_crate_graph(
+        "
+        //- /main.rs
+        #[macro_use]
+        extern crate foo;
+        #[macro_use]
+        mod m {
+            macro_rules! current {
+                () => {
+                    use $crate::Foo as FooSelf;
+                }
+            }
+        }
+        struct Foo;
+        current!();
+        not_current1!();
+        foo::not_current2!();
+        //- /lib.rs
+        mod m {
+            #[macro_export]
+            macro_rules! not_current1 {
+                () => {
+                    use $crate::Bar;
+                }
+            }
+        }
+        #[macro_export]
+        macro_rules! not_current2 {
+            () => {
+                use $crate::Baz;
+            }
+        }
+        struct Bar;
+        struct Baz;
+        ",
+        crate_graph! {
+            "main": ("/main.rs", ["foo"]),
+            "foo": ("/lib.rs", []),
+        },
+    );
+    assert_snapshot!(map, @r###"
+        ⋮crate
+        ⋮Bar: t v
+        ⋮Baz: t v
+        ⋮Foo: t v
+        ⋮FooSelf: t v
+        ⋮foo: t
+        ⋮m: t
+        ⋮
+        ⋮crate::m
+    "###);
+}
+#[test]
+fn macro_dollar_crate_is_correct_in_indirect_deps() {
+    covers!(macro_dollar_crate_other);
+    // From std
+    let map = def_map_with_crate_graph(
+        r#"
+        //- /main.rs
+        foo!();
+        //- /std.rs
+        #[prelude_import]
+        use self::prelude::*;
+        pub use core::foo;
+        mod prelude {}
+        #[macro_use]
+        mod std_macros;
+        //- /core.rs
+        #[macro_export]
+        macro_rules! foo {
+            () => {
+                use $crate::bar;
+            }
+        }
+        pub struct bar;
+        "#,
+        crate_graph! {
+            "main": ("/main.rs", ["std"]),
+            "std": ("/std.rs", ["core"]),
+            "core": ("/core.rs", []),
+        },
+    );
+    assert_snapshot!(map, @r###"
+        ⋮crate
+        ⋮bar: t v
+    "###);
+}
diff --git a/crates/ra_hir/src/path.rs b/crates/ra_hir/src/path.rs
index 39d1b7e46..394617e1a 100644
--- a/crates/ra_hir/src/path.rs
+++ b/crates/ra_hir/src/path.rs
@@ -1,3 +1,5 @@
+//! FIXME: write short doc here
 use std::{iter, sync::Arc};
 use ra_syntax::{
@@ -5,7 +7,7 @@ use ra_syntax::{
    AstNode,
 };
-use crate::{name, type_ref::TypeRef, AsName, Name};
+use crate::{db::AstDatabase, name, type_ref::TypeRef, AsName, Crate, Name, Source};
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Path {
@@ -52,16 +54,19 @@ pub enum PathKind {
    Abs,
    // Type based path like `<T>::foo`
    Type(Box<TypeRef>),
+    // `$crate` from macro expansion
+    DollarCrate(Crate),
 }
 impl Path {
    /// Calls `cb` with all paths, represented by this use item.
    pub fn expand_use_item(
-        item: &ast::UseItem,
+        item_src: Source<ast::UseItem>,
+        db: &impl AstDatabase,
        mut cb: impl FnMut(Path, &ast::UseTree, bool, Option<Name>),
    ) {
-        if let Some(tree) = item.use_tree() {
+        if let Some(tree) = item_src.ast.use_tree() {
-            expand_use_tree(None, tree, &mut cb);
+            expand_use_tree(None, tree, &|| item_src.file_id.macro_crate(db), &mut cb);
        }
    }
@@ -76,7 +81,19 @@ impl Path {
    }
    /// Converts an `ast::Path` to `Path`. Works with use trees.
-    pub fn from_ast(mut path: ast::Path) -> Option<Path> {
+    /// DEPRECATED: It does not handle `$crate` from macro call.
+    pub fn from_ast(path: ast::Path) -> Option<Path> {
+        Path::parse(path, &|| None)
+    }
+    /// Converts an `ast::Path` to `Path`. Works with use trees.
+    /// It correctly handles `$crate` based path from macro call.
+    pub fn from_src(source: Source<ast::Path>, db: &impl AstDatabase) -> Option<Path> {
+        let file_id = source.file_id;
+        Path::parse(source.ast, &|| file_id.macro_crate(db))
+    }
+    fn parse(mut path: ast::Path, macro_crate: &impl Fn() -> Option<Crate>) -> Option<Path> {
        let mut kind = PathKind::Plain;
        let mut segments = Vec::new();
        loop {
@@ -88,6 +105,13 @@ impl Path {
            match segment.kind()? {
                ast::PathSegmentKind::Name(name) => {
+                    if name.text() == "$crate" {
+                        if let Some(macro_crate) = macro_crate() {
+                            kind = PathKind::DollarCrate(macro_crate);
+                            break;
+                        }
+                    }
                    let args = segment
                        .type_arg_list()
                        .and_then(GenericArgs::from_ast)
@@ -113,7 +137,7 @@ impl Path {
                        }
                        // <T as Trait<A>>::Foo desugars to Trait<Self=T, A>::Foo
                        Some(trait_ref) => {
-                            let path = Path::from_ast(trait_ref.path()?)?;
+                            let path = Path::parse(trait_ref.path()?, macro_crate)?;
                            kind = path.kind;
                            let mut prefix_segments = path.segments;
                            prefix_segments.reverse();
@@ -264,6 +288,7 @@ impl From<Name> for Path {
 fn expand_use_tree(
    prefix: Option<Path>,
    tree: ast::UseTree,
+    macro_crate: &impl Fn() -> Option<Crate>,
    cb: &mut impl FnMut(Path, &ast::UseTree, bool, Option<Name>),
 ) {
    if let Some(use_tree_list) = tree.use_tree_list() {
@@ -272,13 +297,13 @@ fn expand_use_tree(
            None => prefix,
            // E.g. `use something::{inner}` (prefix is `None`, path is `something`)
            // or `use something::{path::{inner::{innerer}}}` (prefix is `something::path`, path is `inner`)
-            Some(path) => match convert_path(prefix, path) {
+            Some(path) => match convert_path(prefix, path, macro_crate) {
                Some(it) => Some(it),
                None => return, // FIXME: report errors somewhere
            },
        };
        for child_tree in use_tree_list.use_trees() {
-            expand_use_tree(prefix.clone(), child_tree, cb);
+            expand_use_tree(prefix.clone(), child_tree, macro_crate, cb);
        }
    } else {
        let alias = tree.alias().and_then(|a| a.name()).map(|a| a.as_name());
@@ -295,7 +320,7 @@ fn expand_use_tree(
                    }
                }
            }
-            if let Some(path) = convert_path(prefix, ast_path) {
+            if let Some(path) = convert_path(prefix, ast_path, macro_crate) {
                let is_glob = tree.has_star();
                cb(path, &tree, is_glob, alias)
            }
@@ -305,12 +330,29 @@ fn expand_use_tree(
    }
 }
-fn convert_path(prefix: Option<Path>, path: ast::Path) -> Option<Path> {
+fn convert_path(
-    let prefix =
+    prefix: Option<Path>,
-        if let Some(qual) = path.qualifier() { Some(convert_path(prefix, qual)?) } else { prefix };
+    path: ast::Path,
+    macro_crate: &impl Fn() -> Option<Crate>,
+) -> Option<Path> {
+    let prefix = if let Some(qual) = path.qualifier() {
+        Some(convert_path(prefix, qual, macro_crate)?)
+    } else {
+        prefix
+    };
    let segment = path.segment()?;
    let res = match segment.kind()? {
        ast::PathSegmentKind::Name(name) => {
+            if name.text() == "$crate" {
+                if let Some(krate) = macro_crate() {
+                    return Some(Path::from_simple_segments(
+                        PathKind::DollarCrate(krate),
+                        iter::empty(),
+                    ));
+                }
+            }
            // no type args in use
            let mut res = prefix
                .unwrap_or_else(|| Path { kind: PathKind::Plain, segments: Vec::with_capacity(1) });
diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs
index bd4be8430..088335e66 100644
--- a/crates/ra_hir/src/source_binder.rs
+++ b/crates/ra_hir/src/source_binder.rs
@@ -1,10 +1,10 @@
-/// Lookup hir elements using positions in the source code. This is a lossy
+//! Lookup hir elements using positions in the source code. This is a lossy
-/// transformation: in general, a single source might correspond to several
+//! transformation: in general, a single source might correspond to several
-/// modules, functions, etc, due to macros, cfgs and `#[path=]` attributes on
+//! modules, functions, etc, due to macros, cfgs and `#[path=]` attributes on
-/// modules.
+//! modules.
-///
+//!
-/// So, this modules should not be used during hir construction, it exists
+//! So, this modules should not be used during hir construction, it exists
-/// purely for "IDE needs".
+//! purely for "IDE needs".
 use std::sync::Arc;
 use ra_db::FileId;
@@ -203,6 +203,7 @@ impl SourceAnalyzer {
        db: &impl HirDatabase,
        macro_call: &ast::MacroCall,
    ) -> Option<MacroDef> {
+        // This must be a normal source file rather than macro file.
        let path = macro_call.path().and_then(Path::from_ast)?;
        self.resolver.resolve_path_as_macro(db, &path)
    }
@@ -261,6 +262,7 @@ impl SourceAnalyzer {
                return Some(PathResolution::AssocItem(assoc));
            }
        }
+        // This must be a normal source file rather than macro file.
        let hir_path = crate::Path::from_ast(path.clone())?;
        self.resolve_hir_path(db, &hir_path)
    }
diff --git a/crates/ra_hir/src/source_id.rs b/crates/ra_hir/src/source_id.rs
index 04574876d..a4dd99598 100644
--- a/crates/ra_hir/src/source_id.rs
+++ b/crates/ra_hir/src/source_id.rs
@@ -1,3 +1,5 @@
+//! FIXME: write short doc here
 use std::{
    hash::{Hash, Hasher},
    marker::PhantomData,
diff --git a/crates/ra_hir/src/ty.rs b/crates/ra_hir/src/ty.rs
index fae9c1e22..d161735e8 100644
--- a/crates/ra_hir/src/ty.rs
+++ b/crates/ra_hir/src/ty.rs
@@ -14,11 +14,11 @@ pub(crate) mod display;
 use std::ops::Deref;
 use std::sync::Arc;
-use std::{fmt, mem};
+use std::{fmt, iter, mem};
 use crate::{
-    db::HirDatabase, expr::ExprId, type_ref::Mutability, Adt, DefWithBody, GenericParams, Name,
+    db::HirDatabase, expr::ExprId, type_ref::Mutability, Adt, Crate, DefWithBody, GenericParams,
-    Trait, TypeAlias,
+    HasGenericParams, Name, Trait, TypeAlias,
 };
 use display::{HirDisplay, HirFormatter};
@@ -111,6 +111,81 @@ pub enum TypeCtor {
    Closure { def: DefWithBody, expr: ExprId },
 }
+impl TypeCtor {
+    pub fn num_ty_params(self, db: &impl HirDatabase) -> usize {
+        match self {
+            TypeCtor::Bool
+            | TypeCtor::Char
+            | TypeCtor::Int(_)
+            | TypeCtor::Float(_)
+            | TypeCtor::Str
+            | TypeCtor::Never => 0,
+            TypeCtor::Slice
+            | TypeCtor::Array
+            | TypeCtor::RawPtr(_)
+            | TypeCtor::Ref(_)
+            | TypeCtor::Closure { .. } // 1 param representing the signature of the closure
+            => 1,
+            TypeCtor::Adt(adt) => {
+                let generic_params = adt.generic_params(db);
+                generic_params.count_params_including_parent()
+            }
+            TypeCtor::FnDef(callable) => {
+                let generic_params = callable.generic_params(db);
+                generic_params.count_params_including_parent()
+            }
+            TypeCtor::AssociatedType(type_alias) => {
+                let generic_params = type_alias.generic_params(db);
+                generic_params.count_params_including_parent()
+            }
+            TypeCtor::FnPtr { num_args } => num_args as usize + 1,
+            TypeCtor::Tuple { cardinality } => cardinality as usize,
+        }
+    }
+    pub fn krate(self, db: &impl HirDatabase) -> Option<Crate> {
+        match self {
+            TypeCtor::Bool
+            | TypeCtor::Char
+            | TypeCtor::Int(_)
+            | TypeCtor::Float(_)
+            | TypeCtor::Str
+            | TypeCtor::Never
+            | TypeCtor::Slice
+            | TypeCtor::Array
+            | TypeCtor::RawPtr(_)
+            | TypeCtor::Ref(_)
+            | TypeCtor::FnPtr { .. }
+            | TypeCtor::Tuple { .. } => None,
+            TypeCtor::Closure { def, .. } => def.krate(db),
+            TypeCtor::Adt(adt) => adt.krate(db),
+            TypeCtor::FnDef(callable) => callable.krate(db),
+            TypeCtor::AssociatedType(type_alias) => type_alias.krate(db),
+        }
+    }
+    pub fn as_generic_def(self) -> Option<crate::generics::GenericDef> {
+        match self {
+            TypeCtor::Bool
+            | TypeCtor::Char
+            | TypeCtor::Int(_)
+            | TypeCtor::Float(_)
+            | TypeCtor::Str
+            | TypeCtor::Never
+            | TypeCtor::Slice
+            | TypeCtor::Array
+            | TypeCtor::RawPtr(_)
+            | TypeCtor::Ref(_)
+            | TypeCtor::FnPtr { .. }
+            | TypeCtor::Tuple { .. }
+            | TypeCtor::Closure { .. } => None,
+            TypeCtor::Adt(adt) => Some(adt.into()),
+            TypeCtor::FnDef(callable) => Some(callable.into()),
+            TypeCtor::AssociatedType(type_alias) => Some(type_alias.into()),
+        }
+    }
+}
 /// A nominal type with (maybe 0) type parameters. This might be a primitive
 /// type like `bool`, a struct, tuple, function pointer, reference or
 /// several other things.
@@ -271,11 +346,65 @@ impl Substs {
                .into(),
        )
    }
+    pub fn build_for_def(
+        db: &impl HirDatabase,
+        def: impl crate::HasGenericParams,
+    ) -> SubstsBuilder {
+        let params = def.generic_params(db);
+        let param_count = params.count_params_including_parent();
+        Substs::builder(param_count)
+    }
+    pub fn build_for_generics(generic_params: &GenericParams) -> SubstsBuilder {
+        Substs::builder(generic_params.count_params_including_parent())
+    }
+    pub fn build_for_type_ctor(db: &impl HirDatabase, type_ctor: TypeCtor) -> SubstsBuilder {
+        Substs::builder(type_ctor.num_ty_params(db))
+    }
+    fn builder(param_count: usize) -> SubstsBuilder {
+        SubstsBuilder { vec: Vec::with_capacity(param_count), param_count }
+    }
+}
+#[derive(Debug, Clone)]
+pub struct SubstsBuilder {
+    vec: Vec<Ty>,
+    param_count: usize,
 }
-impl From<Vec<Ty>> for Substs {
+impl SubstsBuilder {
-    fn from(v: Vec<Ty>) -> Self {
+    pub fn build(self) -> Substs {
-        Substs(v.into())
+        assert_eq!(self.vec.len(), self.param_count);
+        Substs(self.vec.into())
+    }
+    pub fn push(mut self, ty: Ty) -> Self {
+        self.vec.push(ty);
+        self
+    }
+    fn remaining(&self) -> usize {
+        self.param_count - self.vec.len()
+    }
+    pub fn fill_with_bound_vars(mut self, starting_from: u32) -> Self {
+        self.vec.extend((starting_from..starting_from + self.remaining() as u32).map(Ty::Bound));
+        self
+    }
+    pub fn fill_with_unknown(mut self) -> Self {
+        self.vec.extend(iter::repeat(Ty::Unknown).take(self.remaining()));
+        self
+    }
+    pub fn use_parent_substs(mut self, parent_substs: &Substs) -> Self {
+        assert!(self.vec.is_empty());
+        assert!(parent_substs.len() <= self.param_count);
+        self.vec.extend(parent_substs.iter().cloned());
+        self
    }
 }
diff --git a/crates/ra_hir/src/ty/autoderef.rs b/crates/ra_hir/src/ty/autoderef.rs
index 94f8ecdc9..02492ca14 100644
--- a/crates/ra_hir/src/ty/autoderef.rs
+++ b/crates/ra_hir/src/ty/autoderef.rs
@@ -7,7 +7,7 @@ use std::iter::successors;
 use log::{info, warn};
-use super::{traits::Solution, Canonical, Ty, TypeWalk};
+use super::{traits::Solution, Canonical, Substs, Ty, TypeWalk};
 use crate::{db::HirDatabase, name, HasGenericParams, Resolver};
 const AUTODEREF_RECURSION_LIMIT: usize = 10;
@@ -44,7 +44,8 @@ fn deref_by_trait(
    };
    let target = deref_trait.associated_type_by_name(db, &name::TARGET_TYPE)?;
-    if target.generic_params(db).count_params_including_parent() != 1 {
+    let generic_params = target.generic_params(db);
+    if generic_params.count_params_including_parent() != 1 {
        // the Target type + Deref trait should only have one generic parameter,
        // namely Deref's Self type
        return None;
@@ -54,12 +55,13 @@ fn deref_by_trait(
    let env = super::lower::trait_env(db, resolver);
+    let parameters = Substs::build_for_generics(&generic_params)
+        .push(ty.value.clone().shift_bound_vars(1))
+        .build();
    let projection = super::traits::ProjectionPredicate {
        ty: Ty::Bound(0),
-        projection_ty: super::ProjectionTy {
+        projection_ty: super::ProjectionTy { associated_ty: target, parameters },
-            associated_ty: target,
-            parameters: vec![ty.value.clone().shift_bound_vars(1)].into(),
-        },
    };
    let obligation = super::Obligation::Projection(projection);
diff --git a/crates/ra_hir/src/ty/display.rs b/crates/ra_hir/src/ty/display.rs
index 63ec9d7e1..7910429d7 100644
--- a/crates/ra_hir/src/ty/display.rs
+++ b/crates/ra_hir/src/ty/display.rs
@@ -1,3 +1,5 @@
+//! FIXME: write short doc here
 use std::fmt;
 use crate::db::HirDatabase;
diff --git a/crates/ra_hir/src/ty/infer.rs b/crates/ra_hir/src/ty/infer.rs
index db3377357..ca9aefc42 100644
--- a/crates/ra_hir/src/ty/infer.rs
+++ b/crates/ra_hir/src/ty/infer.rs
@@ -609,7 +609,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
        for (i, &subpat) in subpats.iter().enumerate() {
            let expected_ty = def
-                .and_then(|d| d.field(self.db, &Name::tuple_field_name(i)))
+                .and_then(|d| d.field(self.db, &Name::new_tuple_field(i)))
                .map_or(Ty::Unknown, |field| field.ty(self.db))
                .subst(&substs);
            let expected_ty = self.normalize_associated_types_in(expected_ty);
@@ -688,14 +688,13 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                };
                let expectations_iter = expectations.iter().chain(repeat(&Ty::Unknown));
-                let inner_tys: Substs = args
+                let inner_tys = args
                    .iter()
                    .zip(expectations_iter)
                    .map(|(&pat, ty)| self.infer_pat(pat, ty, default_bm))
-                    .collect::<Vec<_>>()
+                    .collect();
-                    .into();
-                Ty::apply(TypeCtor::Tuple { cardinality: inner_tys.len() as u16 }, inner_tys)
+                Ty::apply(TypeCtor::Tuple { cardinality: args.len() as u16 }, Substs(inner_tys))
            }
            Pat::Ref { pat, mutability } => {
                let expectation = match expected.as_reference() {
@@ -1229,7 +1228,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                            ty: pat_ty.clone(),
                            projection_ty: ProjectionTy {
                                associated_ty: into_iter_item_alias,
-                                parameters: vec![iterable_ty].into(),
+                                parameters: Substs::single(iterable_ty),
                            },
                        };
                        self.obligations.push(Obligation::Projection(projection));
@@ -1262,7 +1261,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                sig_tys.push(ret_ty.clone());
                let sig_ty = Ty::apply(
                    TypeCtor::FnPtr { num_args: sig_tys.len() as u16 - 1 },
-                    sig_tys.into(),
+                    Substs(sig_tys.into()),
                );
                let closure_ty = Ty::apply_one(
                    TypeCtor::Closure { def: self.body.owner(), expr: tgt_expr },
@@ -1375,10 +1374,9 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                )
                .find_map(|derefed_ty| match canonicalized.decanonicalize_ty(derefed_ty.value) {
                    Ty::Apply(a_ty) => match a_ty.ctor {
-                        TypeCtor::Tuple { .. } => {
+                        TypeCtor::Tuple { .. } => name
-                            let i = name.to_string().parse::<usize>().ok();
+                            .as_tuple_index()
-                            i.and_then(|i| a_ty.parameters.0.get(i).cloned())
+                            .and_then(|idx| a_ty.parameters.0.get(idx).cloned()),
-                        }
                        TypeCtor::Adt(Adt::Struct(s)) => s.field(self.db, name).map(|field| {
                            self.write_field_resolution(tgt_expr, field);
                            field.ty(self.db).subst(&a_ty.parameters)
@@ -1400,7 +1398,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                            ty: ty.clone(),
                            projection_ty: ProjectionTy {
                                associated_ty: future_future_output_alias,
-                                parameters: vec![inner_ty].into(),
+                                parameters: Substs::single(inner_ty),
                            },
                        };
                        self.obligations.push(Obligation::Projection(projection));
@@ -1419,7 +1417,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                            ty: ty.clone(),
                            projection_ty: ProjectionTy {
                                associated_ty: ops_try_ok_alias,
-                                parameters: vec![inner_ty].into(),
+                                parameters: Substs::single(inner_ty),
                            },
                        };
                        self.obligations.push(Obligation::Projection(projection));
@@ -1604,6 +1602,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
        tail: Option<ExprId>,
        expected: &Expectation,
    ) -> Ty {
+        let mut diverges = false;
        for stmt in statements {
            match stmt {
                Statement::Let { pat, type_ref, initializer } => {
@@ -1625,16 +1624,23 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                    self.infer_pat(*pat, &ty, BindingMode::default());
                }
                Statement::Expr(expr) => {
-                    self.infer_expr(*expr, &Expectation::none());
+                    if let ty_app!(TypeCtor::Never) = self.infer_expr(*expr, &Expectation::none()) {
+                        diverges = true;
+                    }
                }
            }
        }
-        if let Some(expr) = tail {
+        let ty = if let Some(expr) = tail {
            self.infer_expr_coerce(expr, expected)
        } else {
            self.coerce(&Ty::unit(), &expected.ty);
            Ty::unit()
+        };
+        if diverges {
+            Ty::simple(TypeCtor::Never)
+        } else {
+            ty
        }
    }
diff --git a/crates/ra_hir/src/ty/infer/path.rs b/crates/ra_hir/src/ty/infer/path.rs
index feb7481b2..db979353a 100644
--- a/crates/ra_hir/src/ty/infer/path.rs
+++ b/crates/ra_hir/src/ty/infer/path.rs
@@ -158,13 +158,13 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
            AssocItem::Const(c) => ValueNs::Const(c),
            AssocItem::TypeAlias(_) => unreachable!(),
        };
-        let generics = item.generic_params(self.db);
+        let substs = Substs::build_for_def(self.db, item)
-        let mut substs = Vec::with_capacity(generics.count_params_including_parent());
+            .use_parent_substs(&trait_ref.substs)
-        substs.extend(trait_ref.substs.iter().cloned());
+            .fill_with_unknown()
-        substs.extend(std::iter::repeat(Ty::Unknown).take(generics.params.len()));
+            .build();
        self.write_assoc_resolution(id, item);
-        Some((def, Some(substs.into())))
+        Some((def, Some(substs)))
    }
    fn resolve_ty_assoc_item(
diff --git a/crates/ra_hir/src/ty/infer/unify.rs b/crates/ra_hir/src/ty/infer/unify.rs
index b6ebee3b1..d161aa6b3 100644
--- a/crates/ra_hir/src/ty/infer/unify.rs
+++ b/crates/ra_hir/src/ty/infer/unify.rs
@@ -3,7 +3,8 @@
 use super::{InferenceContext, Obligation};
 use crate::db::HirDatabase;
 use crate::ty::{
-    Canonical, InEnvironment, InferTy, ProjectionPredicate, ProjectionTy, TraitRef, Ty, TypeWalk,
+    Canonical, InEnvironment, InferTy, ProjectionPredicate, ProjectionTy, Substs, TraitRef, Ty,
+    TypeWalk,
 };
 impl<'a, D: HirDatabase> InferenceContext<'a, D> {
@@ -74,12 +75,9 @@ where
    }
    fn do_canonicalize_trait_ref(&mut self, trait_ref: TraitRef) -> TraitRef {
-        let substs = trait_ref
+        let substs =
-            .substs
+            trait_ref.substs.iter().map(|ty| self.do_canonicalize_ty(ty.clone())).collect();
-            .iter()
+        TraitRef { trait_: trait_ref.trait_, substs: Substs(substs) }
-            .map(|ty| self.do_canonicalize_ty(ty.clone()))
-            .collect::<Vec<_>>();
-        TraitRef { trait_: trait_ref.trait_, substs: substs.into() }
    }
    fn into_canonicalized<T>(self, result: T) -> Canonicalized<T> {
@@ -90,12 +88,9 @@ where
    }
    fn do_canonicalize_projection_ty(&mut self, projection_ty: ProjectionTy) -> ProjectionTy {
-        let params = projection_ty
+        let params =
-            .parameters
+            projection_ty.parameters.iter().map(|ty| self.do_canonicalize_ty(ty.clone())).collect();
-            .iter()
+        ProjectionTy { associated_ty: projection_ty.associated_ty, parameters: Substs(params) }
-            .map(|ty| self.do_canonicalize_ty(ty.clone()))
-            .collect::<Vec<_>>();
-        ProjectionTy { associated_ty: projection_ty.associated_ty, parameters: params.into() }
    }
    fn do_canonicalize_projection_predicate(
@@ -153,8 +148,7 @@ impl<T> Canonicalized<T> {
        solution: Canonical<Vec<Ty>>,
    ) {
        // the solution may contain new variables, which we need to convert to new inference vars
-        let new_vars =
+        let new_vars = Substs((0..solution.num_vars).map(|_| ctx.new_type_var()).collect());
-            (0..solution.num_vars).map(|_| ctx.new_type_var()).collect::<Vec<_>>().into();
        for (i, ty) in solution.value.into_iter().enumerate() {
            let var = self.free_vars[i];
            ctx.unify(&Ty::Infer(var), &ty.subst_bound_vars(&new_vars));
diff --git a/crates/ra_hir/src/ty/lower.rs b/crates/ra_hir/src/ty/lower.rs
index dd503d771..4b67c82e7 100644
--- a/crates/ra_hir/src/ty/lower.rs
+++ b/crates/ra_hir/src/ty/lower.rs
@@ -239,14 +239,10 @@ impl Ty {
        let traits = traits_from_env.flat_map(|t| t.all_super_traits(db));
        for t in traits {
            if let Some(associated_ty) = t.associated_type_by_name(db, &segment.name) {
-                let generics = t.generic_params(db);
+                let substs =
-                let mut substs = Vec::new();
+                    Substs::build_for_def(db, t).push(self_ty.clone()).fill_with_unknown().build();
-                substs.push(self_ty.clone());
-                substs.extend(
-                    iter::repeat(Ty::Unknown).take(generics.count_params_including_parent() - 1),
-                );
                // FIXME handle type parameters on the segment
-                return Ty::Projection(ProjectionTy { associated_ty, parameters: substs.into() });
+                return Ty::Projection(ProjectionTy { associated_ty, parameters: substs });
            }
        }
        Ty::Unknown
@@ -766,6 +762,16 @@ pub enum CallableDef {
 }
 impl_froms!(CallableDef: Function, Struct, EnumVariant);
+impl CallableDef {
+    pub fn krate(self, db: &impl HirDatabase) -> Option<crate::Crate> {
+        match self {
+            CallableDef::Function(f) => f.krate(db),
+            CallableDef::Struct(s) => s.krate(db),
+            CallableDef::EnumVariant(e) => e.parent_enum(db).krate(db),
+        }
+    }
+}
 impl From<CallableDef> for GenericDef {
    fn from(def: CallableDef) -> GenericDef {
        match def {
diff --git a/crates/ra_hir/src/ty/method_resolution.rs b/crates/ra_hir/src/ty/method_resolution.rs
index 4b71b376f..ad2ab560d 100644
--- a/crates/ra_hir/src/ty/method_resolution.rs
+++ b/crates/ra_hir/src/ty/method_resolution.rs
@@ -10,7 +10,6 @@ use rustc_hash::FxHashMap;
 use super::{autoderef, lower, Canonical, InEnvironment, TraitEnvironment, TraitRef};
 use crate::{
    db::HirDatabase,
-    generics::HasGenericParams,
    impl_block::{ImplBlock, ImplId},
    nameres::CrateModuleId,
    resolve::Resolver,
@@ -331,20 +330,13 @@ fn generic_implements_goal(
    trait_: Trait,
    self_ty: Canonical<Ty>,
 ) -> Canonical<InEnvironment<super::Obligation>> {
-    let mut substs = Vec::new();
-    let generics = trait_.generic_params(db);
    let num_vars = self_ty.num_vars;
-    substs.push(self_ty.value);
+    let substs = super::Substs::build_for_def(db, trait_)
-    substs.extend(
+        .push(self_ty.value)
-        generics
+        .fill_with_bound_vars(num_vars as u32)
-            .params_including_parent()
+        .build();
-            .into_iter()
-            .skip(1)
-            .enumerate()
-            .map(|(i, _p)| Ty::Bound((i + num_vars) as u32)),
-    );
    let num_vars = substs.len() - 1 + self_ty.num_vars;
-    let trait_ref = TraitRef { trait_, substs: substs.into() };
+    let trait_ref = TraitRef { trait_, substs };
    let obligation = super::Obligation::Trait(trait_ref);
    Canonical { num_vars, value: InEnvironment::new(env, obligation) }
 }
diff --git a/crates/ra_hir/src/ty/op.rs b/crates/ra_hir/src/ty/op.rs
index 1b30a5b9b..bcfa3a6a2 100644
--- a/crates/ra_hir/src/ty/op.rs
+++ b/crates/ra_hir/src/ty/op.rs
@@ -1,3 +1,5 @@
+//! FIXME: write short doc here
 use super::{InferTy, Ty, TypeCtor};
 use crate::{
    expr::{BinaryOp, CmpOp},
diff --git a/crates/ra_hir/src/ty/primitive.rs b/crates/ra_hir/src/ty/primitive.rs
index 2c60fefd6..8966f9d1d 100644
--- a/crates/ra_hir/src/ty/primitive.rs
+++ b/crates/ra_hir/src/ty/primitive.rs
@@ -1,3 +1,5 @@
+//! FIXME: write short doc here
 use std::fmt;
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
diff --git a/crates/ra_hir/src/ty/tests.rs b/crates/ra_hir/src/ty/tests.rs
index 4362bb27a..25dad81eb 100644
--- a/crates/ra_hir/src/ty/tests.rs
+++ b/crates/ra_hir/src/ty/tests.rs
@@ -3,6 +3,7 @@ use std::sync::Arc;
 use insta::assert_snapshot;
+use ra_cfg::CfgOptions;
 use ra_db::{salsa::Database, FilePosition, SourceDatabase};
 use ra_syntax::{
    algo,
@@ -24,6 +25,50 @@ mod never_type;
 mod coercion;
 #[test]
+fn cfg_impl_block() {
+    let (mut db, pos) = MockDatabase::with_position(
+        r#"
+//- /main.rs
+use foo::S as T;
+struct S;
+#[cfg(test)]
+impl S {
+    fn foo1(&self) -> i32 { 0 }
+}
+#[cfg(not(test))]
+impl S {
+    fn foo2(&self) -> i32 { 0 }
+}
+fn test() {
+    let t = (S.foo1(), S.foo2(), T.foo3(), T.foo4());
+    t<|>;
+}
+//- /foo.rs
+struct S;
+#[cfg(not(test))]
+impl S {
+    fn foo3(&self) -> i32 { 0 }
+}
+#[cfg(test)]
+impl S {
+    fn foo4(&self) -> i32 { 0 }
+}
+"#,
+    );
+    db.set_crate_graph_from_fixture(crate_graph! {
+        "main": ("/main.rs", ["foo"], CfgOptions::default().atom("test".into())),
+        "foo": ("/foo.rs", []),
+    });
+    assert_eq!("(i32, {unknown}, i32, {unknown})", type_at_pos(&db, pos));
+}
+#[test]
 fn infer_await() {
    let (mut db, pos) = MockDatabase::with_position(
        r#"
@@ -218,7 +263,7 @@ fn test(a: u32, b: isize, c: !, d: &str) {
    [17; 18) 'b': isize
    [27; 28) 'c': !
    [33; 34) 'd': &str
-    [42; 121) '{     ...f32; }': ()
+    [42; 121) '{     ...f32; }': !
    [48; 49) 'a': u32
    [55; 56) 'b': isize
    [62; 63) 'c': !
@@ -981,6 +1026,67 @@ fn main(foo: Foo) {
 }
 #[test]
+fn infer_if_match_with_return() {
+    assert_snapshot!(
+        infer(r#"
+fn foo() {
+    let _x1 = if true {
+        1
+    } else {
+        return;
+    };
+    let _x2 = if true {
+        2
+    } else {
+        return
+    };
+    let _x3 = match true {
+        true => 3,
+        _ => {
+            return;
+        }
+    };
+    let _x4 = match true {
+        true => 4,
+        _ => return
+    };
+}"#),
+        @r###"
+    [10; 323) '{     ...  }; }': ()
+    [20; 23) '_x1': i32
+    [26; 80) 'if tru...     }': i32
+    [29; 33) 'true': bool
+    [34; 51) '{     ...     }': i32
+    [44; 45) '1': i32
+    [57; 80) '{     ...     }': !
+    [67; 73) 'return': !
+    [90; 93) '_x2': i32
+    [96; 149) 'if tru...     }': i32
+    [99; 103) 'true': bool
+    [104; 121) '{     ...     }': i32
+    [114; 115) '2': i32
+    [127; 149) '{     ...     }': !
+    [137; 143) 'return': !
+    [159; 162) '_x3': i32
+    [165; 247) 'match ...     }': i32
+    [171; 175) 'true': bool
+    [186; 190) 'true': bool
+    [194; 195) '3': i32
+    [205; 206) '_': bool
+    [210; 241) '{     ...     }': !
+    [224; 230) 'return': !
+    [257; 260) '_x4': i32
+    [263; 320) 'match ...     }': i32
+    [269; 273) 'true': bool
+    [284; 288) 'true': bool
+    [292; 293) '4': i32
+    [303; 304) '_': bool
+    [308; 314) 'return': !
+    "###
+    )
+}
+#[test]
 fn infer_inherent_method() {
    assert_snapshot!(
        infer(r#"
@@ -3130,6 +3236,39 @@ fn test() { S.foo()<|>; }
    assert_eq!(t, "u128");
 }
+#[test]
+fn infer_macro_with_dollar_crate_is_correct_in_expr() {
+    covers!(macro_dollar_crate_other);
+    let (mut db, pos) = MockDatabase::with_position(
+        r#"
+//- /main.rs
+fn test() {
+    let x = (foo::foo!(1), foo::foo!(2));
+    x<|>;
+}
+//- /lib.rs
+#[macro_export]
+macro_rules! foo {
+    (1) => { $crate::bar!() };
+    (2) => { 1 + $crate::baz() };
+}
+#[macro_export]
+macro_rules! bar {
+    () => { 42 }
+}
+pub fn baz() -> usize { 31usize }
+"#,
+    );
+    db.set_crate_graph_from_fixture(crate_graph! {
+        "main": ("/main.rs", ["foo"]),
+        "foo": ("/lib.rs", []),
+    });
+    assert_eq!("(i32, usize)", type_at_pos(&db, pos));
+}
 #[ignore]
 #[test]
 fn method_resolution_trait_before_autoref() {
@@ -3321,7 +3460,6 @@ fn test() { S2.into()<|>; }
 #[test]
 fn method_resolution_encountering_fn_type() {
-    covers!(trait_resolution_on_fn_type);
    type_at(
        r#"
 //- /main.rs
diff --git a/crates/ra_hir/src/ty/traits.rs b/crates/ra_hir/src/ty/traits.rs
index d11dab294..b0f67ae50 100644
--- a/crates/ra_hir/src/ty/traits.rs
+++ b/crates/ra_hir/src/ty/traits.rs
@@ -1,9 +1,8 @@
 //! Trait solving using Chalk.
-use std::sync::Arc;
+use std::sync::{Arc, Mutex};
 use chalk_ir::cast::Cast;
 use log::debug;
-use parking_lot::Mutex;
 use ra_db::salsa;
 use ra_prof::profile;
 use rustc_hash::FxHashSet;
@@ -38,7 +37,14 @@ impl TraitSolver {
    ) -> Option<chalk_solve::Solution> {
        let context = ChalkContext { db, krate: self.krate };
        debug!("solve goal: {:?}", goal);
-        let solution = self.inner.lock().solve(&context, goal);
+        let mut solver = match self.inner.lock() {
+            Ok(it) => it,
+            // Our cancellation works via unwinding, but, as chalk is not
+            // panic-safe, we need to make sure to propagate the cancellation.
+            // Ideally, we should also make chalk panic-safe.
+            Err(_) => ra_db::Canceled::throw(),
+        };
+        let solution = solver.solve(&context, goal);
        debug!("solve({:?}) => {:?}", goal, solution);
        solution
    }
diff --git a/crates/ra_hir/src/ty/traits/chalk.rs b/crates/ra_hir/src/ty/traits/chalk.rs
index 538b4d3ec..2642a54bf 100644
--- a/crates/ra_hir/src/ty/traits/chalk.rs
+++ b/crates/ra_hir/src/ty/traits/chalk.rs
@@ -10,17 +10,13 @@ use chalk_ir::{
 use chalk_rust_ir::{AssociatedTyDatum, ImplDatum, StructDatum, TraitDatum};
 use ra_db::salsa::{InternId, InternKey};
-use test_utils::tested_by;
 use super::{Canonical, ChalkContext, Impl, Obligation};
 use crate::{
    db::HirDatabase,
    generics::GenericDef,
    ty::display::HirDisplay,
-    ty::{
+    ty::{ApplicationTy, GenericPredicate, ProjectionTy, Substs, TraitRef, Ty, TypeCtor, TypeWalk},
-        ApplicationTy, CallableDef, GenericPredicate, ProjectionTy, Substs, TraitRef, Ty, TypeCtor,
-        TypeWalk,
-    },
    AssocItem, Crate, HasGenericParams, ImplBlock, Trait, TypeAlias,
 };
@@ -124,14 +120,15 @@ impl ToChalk for Substs {
    }
    fn from_chalk(db: &impl HirDatabase, parameters: Vec<chalk_ir::Parameter>) -> Substs {
-        parameters
+        let tys = parameters
            .into_iter()
            .map(|p| match p {
                chalk_ir::Parameter(chalk_ir::ParameterKind::Ty(ty)) => from_chalk(db, ty),
                chalk_ir::Parameter(chalk_ir::ParameterKind::Lifetime(_)) => unimplemented!(),
            })
            .collect::<Vec<_>>()
-            .into()
+            .into();
+        Substs(tys)
    }
 }
@@ -539,60 +536,18 @@ pub(crate) fn struct_datum_query(
    struct_id: chalk_ir::StructId,
 ) -> Arc<StructDatum> {
    debug!("struct_datum {:?}", struct_id);
-    let type_ctor = from_chalk(db, struct_id);
+    let type_ctor: TypeCtor = from_chalk(db, struct_id);
    debug!("struct {:?} = {:?}", struct_id, type_ctor);
-    // FIXME might be nicer if we can create a fake GenericParams for the TypeCtor
+    let num_params = type_ctor.num_ty_params(db);
-    // FIXME extract this to a method on Ty
+    let upstream = type_ctor.krate(db) != Some(krate);
-    let (num_params, where_clauses, upstream) = match type_ctor {
+    let where_clauses = type_ctor
-        TypeCtor::Bool
+        .as_generic_def()
-        | TypeCtor::Char
+        .map(|generic_def| {
-        | TypeCtor::Int(_)
-        | TypeCtor::Float(_)
-        | TypeCtor::Never
-        | TypeCtor::Str => (0, vec![], true),
-        TypeCtor::Slice | TypeCtor::Array | TypeCtor::RawPtr(_) | TypeCtor::Ref(_) => {
-            (1, vec![], true)
-        }
-        TypeCtor::FnPtr { num_args } => (num_args as usize + 1, vec![], true),
-        TypeCtor::Tuple { cardinality } => (cardinality as usize, vec![], true),
-        TypeCtor::FnDef(callable) => {
-            tested_by!(trait_resolution_on_fn_type);
-            let upstream = match callable {
-                CallableDef::Function(f) => f.module(db).krate(db),
-                CallableDef::Struct(s) => s.module(db).krate(db),
-                CallableDef::EnumVariant(v) => v.parent_enum(db).module(db).krate(db),
-            } != Some(krate);
-            let generic_def: GenericDef = callable.into();
            let generic_params = generic_def.generic_params(db);
            let bound_vars = Substs::bound_vars(&generic_params);
-            let where_clauses = convert_where_clauses(db, generic_def, &bound_vars);
+            convert_where_clauses(db, generic_def, &bound_vars)
-            (generic_params.count_params_including_parent(), where_clauses, upstream)
+        })
-        }
+        .unwrap_or_else(Vec::new);
-        TypeCtor::Adt(adt) => {
-            let generic_params = adt.generic_params(db);
-            let bound_vars = Substs::bound_vars(&generic_params);
-            let where_clauses = convert_where_clauses(db, adt.into(), &bound_vars);
-            (
-                generic_params.count_params_including_parent(),
-                where_clauses,
-                adt.krate(db) != Some(krate),
-            )
-        }
-        TypeCtor::AssociatedType(type_alias) => {
-            let generic_params = type_alias.generic_params(db);
-            let bound_vars = Substs::bound_vars(&generic_params);
-            let where_clauses = convert_where_clauses(db, type_alias.into(), &bound_vars);
-            (
-                generic_params.count_params_including_parent(),
-                where_clauses,
-                type_alias.krate(db) != Some(krate),
-            )
-        }
-        TypeCtor::Closure { def, .. } => {
-            let upstream = def.krate(db) != Some(krate);
-            (1, vec![], upstream)
-        }
-    };
    let flags = chalk_rust_ir::StructFlags {
        upstream,
        // FIXME set fundamental flag correctly
@@ -729,17 +684,20 @@ fn closure_fn_trait_impl_datum(
    let arg_ty = Ty::apply(
        TypeCtor::Tuple { cardinality: num_args },
-        (0..num_args).map(|i| Ty::Bound(i.into())).collect::<Vec<_>>().into(),
+        Substs::builder(num_args as usize).fill_with_bound_vars(0).build(),
    );
    let output_ty = Ty::Bound(num_args.into());
    let sig_ty = Ty::apply(
        TypeCtor::FnPtr { num_args },
-        (0..num_args + 1).map(|i| Ty::Bound(i.into())).collect::<Vec<_>>().into(),
+        Substs::builder(num_args as usize + 1).fill_with_bound_vars(0).build(),
    );
    let self_ty = Ty::apply_one(TypeCtor::Closure { def: data.def, expr: data.expr }, sig_ty);
-    let trait_ref = TraitRef { trait_, substs: vec![self_ty, arg_ty].into() };
+    let trait_ref = TraitRef {
+        trait_,
+        substs: Substs::build_for_def(db, trait_).push(self_ty).push(arg_ty).build(),
+    };
    let output_ty_id = fn_once_trait.associated_type_by_name(db, &crate::name::OUTPUT_TYPE)?;
diff --git a/crates/ra_hir/src/type_ref.rs b/crates/ra_hir/src/type_ref.rs
index bc8acc7ee..2cf06b250 100644
--- a/crates/ra_hir/src/type_ref.rs
+++ b/crates/ra_hir/src/type_ref.rs
@@ -72,6 +72,7 @@ impl TypeRef {
            }
            ast::TypeRef::NeverType(..) => TypeRef::Never,
            ast::TypeRef::PathType(inner) => {
+                // FIXME: Use `Path::from_src`
                inner.path().and_then(Path::from_ast).map(TypeRef::Path).unwrap_or(TypeRef::Error)
            }
            ast::TypeRef::PointerType(inner) => {
@@ -141,6 +142,7 @@ impl TypeBound {
                    Some(p) => p,
                    None => return TypeBound::Error,
                };
+                // FIXME: Use `Path::from_src`
                let path = match Path::from_ast(path) {
                    Some(p) => p,
                    None => return TypeBound::Error,