17 files changed, 317 insertions, 133 deletions
diff --git a/crates/ra_cli/Cargo.toml b/crates/ra_cli/Cargo.toml
index bcd408421..53d4876f6 100644
--- a/crates/ra_cli/Cargo.toml
+++ b/crates/ra_cli/Cargo.toml
@@ -6,8 +6,10 @@ authors = ["rust-analyzer developers"]
 publish = false
 [dependencies]
+itertools = "0.8.0"
 pico-args = "0.3.0"
 env_logger = { version = "0.7.1", default-features = false }
+rand = { version = "0.7.0", features = ["small_rng"] }
 ra_syntax = { path = "../ra_syntax" }
 ra_ide = { path = "../ra_ide" }
diff --git a/crates/ra_cli/src/analysis_bench.rs b/crates/ra_cli/src/analysis_bench.rs
index 5485a38ff..4835a68ce 100644
--- a/crates/ra_cli/src/analysis_bench.rs
+++ b/crates/ra_cli/src/analysis_bench.rs
@@ -2,6 +2,7 @@
 use std::{
    path::{Path, PathBuf},
+    str::FromStr,
    sync::Arc,
    time::Instant,
 };
@@ -14,12 +15,35 @@ use ra_ide::{Analysis, AnalysisChange, AnalysisHost, FilePosition, LineCol};
 use crate::Result;
+pub(crate) struct Position {
+    path: PathBuf,
+    line: u32,
+    column: u32,
+}
+impl FromStr for Position {
+    type Err = Box<dyn std::error::Error + Send + Sync>;
+    fn from_str(s: &str) -> Result<Self> {
+        let (path_line, column) = rsplit_at_char(s, ':')?;
+        let (path, line) = rsplit_at_char(path_line, ':')?;
+        Ok(Position { path: path.into(), line: line.parse()?, column: column.parse()? })
+    }
+}
+fn rsplit_at_char(s: &str, c: char) -> Result<(&str, &str)> {
+    let idx = s.rfind(':').ok_or_else(|| format!("no `{}` in {}", c, s))?;
+    Ok((&s[..idx], &s[idx + 1..]))
+}
 pub(crate) enum Op {
    Highlight { path: PathBuf },
-    Complete { path: PathBuf, line: u32, column: u32 },
+    Complete(Position),
+    GotoDef(Position),
 }
 pub(crate) fn run(verbose: bool, path: &Path, op: Op) -> Result<()> {
+    ra_prof::init();
    let start = Instant::now();
    eprint!("loading: ");
    let (mut host, roots) = ra_batch::load_cargo(path)?;
@@ -29,7 +53,7 @@ pub(crate) fn run(verbose: bool, path: &Path, op: Op) -> Result<()> {
    let file_id = {
        let path = match &op {
            Op::Highlight { path } => path,
-            Op::Complete { path, .. } => path,
+            Op::Complete(pos) | Op::GotoDef(pos) => &pos.path,
        };
        let path = std::env::current_dir()?.join(path).canonicalize()?;
        roots
@@ -49,7 +73,7 @@ pub(crate) fn run(verbose: bool, path: &Path, op: Op) -> Result<()> {
            .ok_or_else(|| format!("Can't find {:?}", path))?
    };
-    match op {
+    match &op {
        Op::Highlight { .. } => {
            let res = do_work(&mut host, file_id, |analysis| {
                analysis.diagnostics(file_id).unwrap();
@@ -59,16 +83,30 @@ pub(crate) fn run(verbose: bool, path: &Path, op: Op) -> Result<()> {
                println!("\n{}", res);
            }
        }
-        Op::Complete { line, column, .. } => {
+        Op::Complete(pos) | Op::GotoDef(pos) => {
+            let is_completion = match op {
+                Op::Complete(..) => true,
+                _ => false,
+            };
            let offset = host
                .analysis()
                .file_line_index(file_id)?
-                .offset(LineCol { line, col_utf16: column });
+                .offset(LineCol { line: pos.line - 1, col_utf16: pos.column });
            let file_postion = FilePosition { file_id, offset };
-            let res = do_work(&mut host, file_id, |analysis| analysis.completions(file_postion));
+            if is_completion {
-            if verbose {
+                let res =
-                println!("\n{:#?}", res);
+                    do_work(&mut host, file_id, |analysis| analysis.completions(file_postion));
+                if verbose {
+                    println!("\n{:#?}", res);
+                }
+            } else {
+                let res =
+                    do_work(&mut host, file_id, |analysis| analysis.goto_definition(file_postion));
+                if verbose {
+                    println!("\n{:#?}", res);
+                }
            }
        }
    }
diff --git a/crates/ra_cli/src/analysis_stats.rs b/crates/ra_cli/src/analysis_stats.rs
index 833235bff..6d2dd34c6 100644
--- a/crates/ra_cli/src/analysis_stats.rs
+++ b/crates/ra_cli/src/analysis_stats.rs
@@ -2,6 +2,9 @@
 use std::{collections::HashSet, fmt::Write, path::Path, time::Instant};
+use itertools::Itertools;
+use rand::{seq::SliceRandom, thread_rng};
 use hir::{
    db::{DefDatabase, HirDatabase},
    AssocItem, Crate, HasSource, HirDisplay, ModuleDef,
@@ -19,6 +22,7 @@ pub fn run(
    path: &Path,
    only: Option<&str>,
    with_deps: bool,
+    randomize: bool,
 ) -> Result<()> {
    let db_load_time = Instant::now();
    let (mut host, roots) = ra_batch::load_cargo(path)?;
@@ -41,7 +45,11 @@ pub fn run(
            })
            .collect::<HashSet<_>>();
-    for krate in Crate::all(db) {
+    let mut krates = Crate::all(db);
+    if randomize {
+        krates.shuffle(&mut thread_rng());
+    }
+    for krate in krates {
        let module = krate.root_module(db).expect("crate without root module");
        let file_id = module.definition_source(db).file_id;
        if members.contains(&db.file_source_root(file_id.original_file(db))) {
@@ -50,6 +58,10 @@ pub fn run(
        }
    }
+    if randomize {
+        visit_queue.shuffle(&mut thread_rng());
+    }
    println!("Crates in this dir: {}", num_crates);
    let mut num_decls = 0;
    let mut funcs = Vec::new();
@@ -79,10 +91,14 @@ pub fn run(
    println!("Total functions: {}", funcs.len());
    println!("Item Collection: {:?}, {}", analysis_time.elapsed(), ra_prof::memory_usage());
+    if randomize {
+        funcs.shuffle(&mut thread_rng());
+    }
    let inference_time = Instant::now();
    let mut bar = match verbosity {
-        Verbosity::Verbose | Verbosity::Normal => ProgressReport::new(funcs.len() as u64),
+        Verbosity::Quiet | Verbosity::Spammy => ProgressReport::hidden(),
-        Verbosity::Quiet => ProgressReport::hidden(),
+        _ => ProgressReport::new(funcs.len() as u64),
    };
    bar.tick();
@@ -92,7 +108,20 @@ pub fn run(
    let mut num_type_mismatches = 0;
    for f in funcs {
        let name = f.name(db);
-        let mut msg = format!("processing: {}", name);
+        let full_name = f
+            .module(db)
+            .path_to_root(db)
+            .into_iter()
+            .rev()
+            .filter_map(|it| it.name(db))
+            .chain(Some(f.name(db)))
+            .join("::");
+        if let Some(only_name) = only {
+            if name.to_string() != only_name && full_name != only_name {
+                continue;
+            }
+        }
+        let mut msg = format!("processing: {}", full_name);
        if verbosity.is_verbose() {
            let src = f.source(db);
            let original_file = src.file_id.original_file(db);
@@ -100,15 +129,15 @@ pub fn run(
            let syntax_range = src.value.syntax().text_range();
            write!(msg, " ({:?} {})", path, syntax_range).unwrap();
        }
-        bar.set_message(&msg);
+        if verbosity.is_spammy() {
-        if let Some(only_name) = only {
+            bar.println(format!("{}", msg));
-            if name.to_string() != only_name {
-                continue;
-            }
        }
+        bar.set_message(&msg);
        let f_id = FunctionId::from(f);
        let body = db.body(f_id.into());
        let inference_result = db.infer(f_id.into());
+        let (previous_exprs, previous_unknown, previous_partially_unknown) =
+            (num_exprs, num_exprs_unknown, num_exprs_partially_unknown);
        for (expr_id, _) in body.exprs.iter() {
            let ty = &inference_result[expr_id];
            num_exprs += 1;
@@ -125,6 +154,33 @@ pub fn run(
                    num_exprs_partially_unknown += 1;
                }
            }
+            if only.is_some() && verbosity.is_spammy() {
+                // in super-verbose mode for just one function, we print every single expression
+                let (_, sm) = db.body_with_source_map(f_id.into());
+                let src = sm.expr_syntax(expr_id);
+                if let Some(src) = src {
+                    let original_file = src.file_id.original_file(db);
+                    let line_index = host.analysis().file_line_index(original_file).unwrap();
+                    let text_range = src.value.either(
+                        |it| it.syntax_node_ptr().range(),
+                        |it| it.syntax_node_ptr().range(),
+                    );
+                    let (start, end) = (
+                        line_index.line_col(text_range.start()),
+                        line_index.line_col(text_range.end()),
+                    );
+                    bar.println(format!(
+                        "{}:{}-{}:{}: {}",
+                        start.line + 1,
+                        start.col_utf16,
+                        end.line + 1,
+                        end.col_utf16,
+                        ty.display(db)
+                    ));
+                } else {
+                    bar.println(format!("unknown location: {}", ty.display(db)));
+                }
+            }
            if let Some(mismatch) = inference_result.type_mismatch_for_expr(expr_id) {
                num_type_mismatches += 1;
                if verbosity.is_verbose() {
@@ -164,6 +220,15 @@ pub fn run(
                }
            }
        }
+        if verbosity.is_spammy() {
+            bar.println(format!(
+                "In {}: {} exprs, {} unknown, {} partial",
+                full_name,
+                num_exprs - previous_exprs,
+                num_exprs_unknown - previous_unknown,
+                num_exprs_partially_unknown - previous_partially_unknown
+            ));
+        }
        bar.inc(1);
    }
    bar.finish_and_clear();
diff --git a/crates/ra_cli/src/main.rs b/crates/ra_cli/src/main.rs
index 806612c2c..750cbab86 100644
--- a/crates/ra_cli/src/main.rs
+++ b/crates/ra_cli/src/main.rs
@@ -16,6 +16,7 @@ type Result<T> = std::result::Result<T, Box<dyn Error + Send + Sync>>;
 #[derive(Clone, Copy)]
 pub enum Verbosity {
+    Spammy,
    Verbose,
    Normal,
    Quiet,
@@ -24,7 +25,13 @@ pub enum Verbosity {
 impl Verbosity {
    fn is_verbose(self) -> bool {
        match self {
-            Verbosity::Verbose => true,
+            Verbosity::Verbose | Verbosity::Spammy => true,
+            _ => false,
+        }
+    }
+    fn is_spammy(self) -> bool {
+        match self {
+            Verbosity::Spammy => true,
            _ => false,
        }
    }
@@ -86,14 +93,18 @@ fn main() -> Result<()> {
                return Ok(());
            }
            let verbosity = match (
+                matches.contains(["-vv", "--spammy"]),
                matches.contains(["-v", "--verbose"]),
                matches.contains(["-q", "--quiet"]),
            ) {
-                (false, false) => Verbosity::Normal,
+                (true, _, true) => Err("Invalid flags: -q conflicts with -vv")?,
-                (false, true) => Verbosity::Quiet,
+                (true, _, false) => Verbosity::Spammy,
-                (true, false) => Verbosity::Verbose,
+                (false, false, false) => Verbosity::Normal,
-                (true, true) => Err("Invalid flags: -q conflicts with -v")?,
+                (false, false, true) => Verbosity::Quiet,
+                (false, true, false) => Verbosity::Verbose,
+                (false, true, true) => Err("Invalid flags: -q conflicts with -v")?,
            };
+            let randomize = matches.contains("--randomize");
            let memory_usage = matches.contains("--memory-usage");
            let only: Option<String> = matches.opt_value_from_str(["-o", "--only"])?;
            let with_deps: bool = matches.contains("--with-deps");
@@ -111,6 +122,7 @@ fn main() -> Result<()> {
                path.as_ref(),
                only.as_ref().map(String::as_ref),
                with_deps,
+                randomize,
            )?;
        }
        "analysis-bench" => {
@@ -120,25 +132,16 @@ fn main() -> Result<()> {
            }
            let verbose = matches.contains(["-v", "--verbose"]);
            let path: String = matches.opt_value_from_str("--path")?.unwrap_or_default();
-            let highlight_path = matches.opt_value_from_str("--highlight")?;
+            let highlight_path: Option<String> = matches.opt_value_from_str("--highlight")?;
-            let complete_path = matches.opt_value_from_str("--complete")?;
+            let complete_path: Option<String> = matches.opt_value_from_str("--complete")?;
-            if highlight_path.is_some() && complete_path.is_some() {
+            let goto_def_path: Option<String> = matches.opt_value_from_str("--goto-def")?;
-                panic!("either --highlight or --complete must be set, not both")
+            let op = match (highlight_path, complete_path, goto_def_path) {
-            }
+                (Some(path), None, None) => analysis_bench::Op::Highlight { path: path.into() },
-            let op = if let Some(path) = highlight_path {
+                (None, Some(position), None) => analysis_bench::Op::Complete(position.parse()?),
-                let path: String = path;
+                (None, None, Some(position)) => analysis_bench::Op::GotoDef(position.parse()?),
-                analysis_bench::Op::Highlight { path: path.into() }
+                _ => panic!(
-            } else if let Some(path_line_col) = complete_path {
+                    "exactly one of  `--highlight`, `--complete` or `--goto-def` must be set"
-                let path_line_col: String = path_line_col;
+                ),
-                let (path_line, column) = rsplit_at_char(path_line_col.as_str(), ':')?;
-                let (path, line) = rsplit_at_char(path_line, ':')?;
-                analysis_bench::Op::Complete {
-                    path: path.into(),
-                    line: line.parse()?,
-                    column: column.parse()?,
-                }
-            } else {
-                panic!("either --highlight or --complete must be set")
            };
            matches.finish().or_else(handle_extra_flags)?;
            analysis_bench::run(verbose, path.as_ref(), op)?;
@@ -171,8 +174,3 @@ fn read_stdin() -> Result<String> {
    std::io::stdin().read_to_string(&mut buff)?;
    Ok(buff)
 }
-fn rsplit_at_char(s: &str, c: char) -> Result<(&str, &str)> {
-    let idx = s.rfind(':').ok_or_else(|| format!("no `{}` in {}", c, s))?;
-    Ok((&s[..idx], &s[idx + 1..]))
-}
diff --git a/crates/ra_hir/src/source_analyzer.rs b/crates/ra_hir/src/source_analyzer.rs
index bb9a35c5d..94d5b4cfd 100644
--- a/crates/ra_hir/src/source_analyzer.rs
+++ b/crates/ra_hir/src/source_analyzer.rs
@@ -15,11 +15,9 @@ use hir_def::{
    },
    expr::{ExprId, PatId},
    resolver::{self, resolver_for_scope, Resolver, TypeNs, ValueNs},
-    DefWithBodyId, TraitId,
+    AsMacroCall, DefWithBodyId, TraitId,
-};
-use hir_expand::{
-    hygiene::Hygiene, name::AsName, AstId, HirFileId, InFile, MacroCallId, MacroCallKind,
 };
+use hir_expand::{hygiene::Hygiene, name::AsName, HirFileId, InFile, MacroCallId};
 use hir_ty::{InEnvironment, InferenceResult, TraitEnvironment};
 use ra_syntax::{
    ast::{self, AstNode},
@@ -363,12 +361,10 @@ impl SourceAnalyzer {
        db: &impl HirDatabase,
        macro_call: InFile<&ast::MacroCall>,
    ) -> Option<Expansion> {
-        let def = self.resolve_macro_call(db, macro_call)?.id;
+        let macro_call_id = macro_call.as_call_id(db, |path| {
-        let ast_id = AstId::new(
+            self.resolver.resolve_path_as_macro(db, &path).map(|it| it.into())
-            macro_call.file_id,
+        })?;
-            db.ast_id_map(macro_call.file_id).ast_id(macro_call.value),
+        Some(Expansion { macro_call_id })
-        );
-        Some(Expansion { macro_call_id: def.as_call_id(db, MacroCallKind::FnLike(ast_id)) })
    }
 }
diff --git a/crates/ra_hir_def/src/body.rs b/crates/ra_hir_def/src/body.rs
index 142c52d35..010d35e55 100644
--- a/crates/ra_hir_def/src/body.rs
+++ b/crates/ra_hir_def/src/body.rs
@@ -7,9 +7,7 @@ use std::{mem, ops::Index, sync::Arc};
 use drop_bomb::DropBomb;
 use either::Either;
-use hir_expand::{
+use hir_expand::{ast_id_map::AstIdMap, hygiene::Hygiene, AstId, HirFileId, InFile, MacroDefId};
-    ast_id_map::AstIdMap, hygiene::Hygiene, AstId, HirFileId, InFile, MacroCallKind, MacroDefId,
-};
 use ra_arena::{map::ArenaMap, Arena};
 use ra_prof::profile;
 use ra_syntax::{ast, AstNode, AstPtr};
@@ -23,7 +21,7 @@ use crate::{
    nameres::CrateDefMap,
    path::{ModPath, Path},
    src::HasSource,
-    DefWithBodyId, HasModule, Lookup, ModuleId,
+    AsMacroCall, DefWithBodyId, HasModule, Lookup, ModuleId,
 };
 pub(crate) struct Expander {
@@ -51,30 +49,26 @@ impl Expander {
        db: &DB,
        macro_call: ast::MacroCall,
    ) -> Option<(Mark, T)> {
-        let ast_id = AstId::new(
+        let macro_call = InFile::new(self.current_file_id, &macro_call);
-            self.current_file_id,
-            db.ast_id_map(self.current_file_id).ast_id(&macro_call),
+        if let Some(call_id) =
-        );
+            macro_call.as_call_id(db, |path| self.resolve_path_as_macro(db, &path))
+        {
-        if let Some(path) = macro_call.path().and_then(|path| self.parse_mod_path(path)) {
+            let file_id = call_id.as_file();
-            if let Some(def) = self.resolve_path_as_macro(db, &path) {
+            if let Some(node) = db.parse_or_expand(file_id) {
-                let call_id = def.as_call_id(db, MacroCallKind::FnLike(ast_id));
+                if let Some(expr) = T::cast(node) {
-                let file_id = call_id.as_file();
+                    log::debug!("macro expansion {:#?}", expr.syntax());
-                if let Some(node) = db.parse_or_expand(file_id) {
-                    if let Some(expr) = T::cast(node) {
+                    let mark = Mark {
-                        log::debug!("macro expansion {:#?}", expr.syntax());
+                        file_id: self.current_file_id,
+                        ast_id_map: mem::take(&mut self.ast_id_map),
-                        let mark = Mark {
+                        bomb: DropBomb::new("expansion mark dropped"),
-                            file_id: self.current_file_id,
+                    };
-                            ast_id_map: mem::take(&mut self.ast_id_map),
+                    self.hygiene = Hygiene::new(db, file_id);
-                            bomb: DropBomb::new("expansion mark dropped"),
+                    self.current_file_id = file_id;
-                        };
+                    self.ast_id_map = db.ast_id_map(file_id);
-                        self.hygiene = Hygiene::new(db, file_id);
-                        self.current_file_id = file_id;
+                    return Some((mark, expr));
-                        self.ast_id_map = db.ast_id_map(file_id);
-                        return Some((mark, expr));
-                    }
                }
            }
        }
@@ -99,10 +93,6 @@ impl Expander {
        Path::from_src(path, &self.hygiene)
    }
-    fn parse_mod_path(&mut self, path: ast::Path) -> Option<ModPath> {
-        ModPath::from_src(path, &self.hygiene)
-    }
    fn resolve_path_as_macro(&self, db: &impl DefDatabase, path: &ModPath) -> Option<MacroDefId> {
        self.crate_def_map
            .resolve_path(db, self.module.local_id, path, BuiltinShadowMode::Other)
diff --git a/crates/ra_hir_def/src/lib.rs b/crates/ra_hir_def/src/lib.rs
index feb3a300d..aa0b558b8 100644
--- a/crates/ra_hir_def/src/lib.rs
+++ b/crates/ra_hir_def/src/lib.rs
@@ -46,7 +46,10 @@ mod marks;
 use std::hash::Hash;
-use hir_expand::{ast_id_map::FileAstId, AstId, HirFileId, InFile, MacroDefId};
+use hir_expand::{
+    ast_id_map::FileAstId, db::AstDatabase, hygiene::Hygiene, AstId, HirFileId, InFile,
+    MacroCallId, MacroCallKind, MacroDefId,
+};
 use ra_arena::{impl_arena_id, RawId};
 use ra_db::{impl_intern_key, salsa, CrateId};
 use ra_syntax::{ast, AstNode};
@@ -413,3 +416,61 @@ impl HasModule for StaticLoc {
        self.container.module(db)
    }
 }
+/// A helper trait for converting to MacroCallId
+pub trait AsMacroCall {
+    fn as_call_id(
+        &self,
+        db: &(impl db::DefDatabase + AstDatabase),
+        resolver: impl Fn(path::ModPath) -> Option<MacroDefId>,
+    ) -> Option<MacroCallId>;
+}
+impl AsMacroCall for InFile<&ast::MacroCall> {
+    fn as_call_id(
+        &self,
+        db: &(impl db::DefDatabase + AstDatabase),
+        resolver: impl Fn(path::ModPath) -> Option<MacroDefId>,
+    ) -> Option<MacroCallId> {
+        let ast_id = AstId::new(self.file_id, db.ast_id_map(self.file_id).ast_id(self.value));
+        let h = Hygiene::new(db, self.file_id);
+        let path = path::ModPath::from_src(self.value.path()?, &h)?;
+        AstIdWithPath::new(ast_id.file_id, ast_id.value, path).as_call_id(db, resolver)
+    }
+}
+/// Helper wrapper for `AstId` with `ModPath`
+#[derive(Clone, Debug, Eq, PartialEq)]
+struct AstIdWithPath<T: ast::AstNode> {
+    pub ast_id: AstId<T>,
+    pub path: path::ModPath,
+}
+impl<T: ast::AstNode> AstIdWithPath<T> {
+    pub fn new(file_id: HirFileId, ast_id: FileAstId<T>, path: path::ModPath) -> AstIdWithPath<T> {
+        AstIdWithPath { ast_id: AstId::new(file_id, ast_id), path }
+    }
+}
+impl AsMacroCall for AstIdWithPath<ast::MacroCall> {
+    fn as_call_id(
+        &self,
+        db: &impl AstDatabase,
+        resolver: impl Fn(path::ModPath) -> Option<MacroDefId>,
+    ) -> Option<MacroCallId> {
+        let def = resolver(self.path.clone())?;
+        Some(def.as_call_id(db, MacroCallKind::FnLike(self.ast_id.clone())))
+    }
+}
+impl AsMacroCall for AstIdWithPath<ast::ModuleItem> {
+    fn as_call_id(
+        &self,
+        db: &impl AstDatabase,
+        resolver: impl Fn(path::ModPath) -> Option<MacroDefId>,
+    ) -> Option<MacroCallId> {
+        let def = resolver(self.path.clone())?;
+        Some(def.as_call_id(db, MacroCallKind::Attr(self.ast_id.clone())))
+    }
+}
diff --git a/crates/ra_hir_def/src/nameres/collector.rs b/crates/ra_hir_def/src/nameres/collector.rs
index b1f3f525d..51c65a5d7 100644
--- a/crates/ra_hir_def/src/nameres/collector.rs
+++ b/crates/ra_hir_def/src/nameres/collector.rs
@@ -7,7 +7,7 @@ use hir_expand::{
    builtin_derive::find_builtin_derive,
    builtin_macro::find_builtin_macro,
    name::{name, AsName, Name},
-    HirFileId, MacroCallId, MacroCallKind, MacroDefId, MacroDefKind,
+    HirFileId, MacroCallId, MacroDefId, MacroDefKind,
 };
 use ra_cfg::CfgOptions;
 use ra_db::{CrateId, FileId};
@@ -25,8 +25,9 @@ use crate::{
    path::{ImportAlias, ModPath, PathKind},
    per_ns::PerNs,
    visibility::Visibility,
-    AdtId, AstId, ConstLoc, ContainerId, EnumLoc, EnumVariantId, FunctionLoc, ImplLoc, Intern,
+    AdtId, AsMacroCall, AstId, AstIdWithPath, ConstLoc, ContainerId, EnumLoc, EnumVariantId,
-    LocalModuleId, ModuleDefId, ModuleId, StaticLoc, StructLoc, TraitLoc, TypeAliasLoc, UnionLoc,
+    FunctionLoc, ImplLoc, Intern, LocalModuleId, ModuleDefId, ModuleId, StaticLoc, StructLoc,
+    TraitLoc, TypeAliasLoc, UnionLoc,
 };
 pub(super) fn collect_defs(db: &impl DefDatabase, mut def_map: CrateDefMap) -> CrateDefMap {
@@ -99,11 +100,16 @@ struct ImportDirective {
 #[derive(Clone, Debug, Eq, PartialEq)]
 struct MacroDirective {
    module_id: LocalModuleId,
-    ast_id: AstId<ast::MacroCall>,
+    ast_id: AstIdWithPath<ast::MacroCall>,
-    path: ModPath,
    legacy: Option<MacroCallId>,
 }
+#[derive(Clone, Debug, Eq, PartialEq)]
+struct DeriveDirective {
+    module_id: LocalModuleId,
+    ast_id: AstIdWithPath<ast::ModuleItem>,
+}
 /// Walks the tree of module recursively
 struct DefCollector<'a, DB> {
    db: &'a DB,
@@ -112,7 +118,7 @@ struct DefCollector<'a, DB> {
    unresolved_imports: Vec<ImportDirective>,
    resolved_imports: Vec<ImportDirective>,
    unexpanded_macros: Vec<MacroDirective>,
-    unexpanded_attribute_macros: Vec<(LocalModuleId, AstId<ast::ModuleItem>, ModPath)>,
+    unexpanded_attribute_macros: Vec<DeriveDirective>,
    mod_dirs: FxHashMap<LocalModuleId, ModDir>,
    cfg_options: &'a CfgOptions,
 }
@@ -515,16 +521,16 @@ where
                return false;
            }
-            let resolved_res = self.def_map.resolve_path_fp_with_macro(
+            if let Some(call_id) = directive.ast_id.as_call_id(self.db, |path| {
-                self.db,
+                let resolved_res = self.def_map.resolve_path_fp_with_macro(
-                ResolveMode::Other,
+                    self.db,
-                directive.module_id,
+                    ResolveMode::Other,
-                &directive.path,
+                    directive.module_id,
-                BuiltinShadowMode::Module,
+                    &path,
-            );
+                    BuiltinShadowMode::Module,
+                );
-            if let Some(def) = resolved_res.resolved_def.take_macros() {
+                resolved_res.resolved_def.take_macros()
-                let call_id = def.as_call_id(self.db, MacroCallKind::FnLike(directive.ast_id));
+            }) {
                resolved.push((directive.module_id, call_id));
                res = ReachedFixedPoint::No;
                return false;
@@ -532,12 +538,11 @@ where
            true
        });
-        attribute_macros.retain(|(module_id, ast_id, path)| {
+        attribute_macros.retain(|directive| {
-            let resolved_res = self.resolve_attribute_macro(path);
+            if let Some(call_id) =
+                directive.ast_id.as_call_id(self.db, |path| self.resolve_attribute_macro(&path))
-            if let Some(def) = resolved_res {
+            {
-                let call_id = def.as_call_id(self.db, MacroCallKind::Attr(*ast_id));
+                resolved.push((directive.module_id, call_id));
-                resolved.push((*module_id, call_id));
                res = ReachedFixedPoint::No;
                return false;
            }
@@ -833,20 +838,22 @@ where
                };
                let path = ModPath::from_tt_ident(ident);
-                let ast_id = AstId::new(self.file_id, def.kind.ast_id());
+                let ast_id = AstIdWithPath::new(self.file_id, def.kind.ast_id(), path);
-                self.def_collector.unexpanded_attribute_macros.push((self.module_id, ast_id, path));
+                self.def_collector
+                    .unexpanded_attribute_macros
+                    .push(DeriveDirective { module_id: self.module_id, ast_id });
            }
        }
    }
    fn collect_macro(&mut self, mac: &raw::MacroData) {
-        let ast_id = AstId::new(self.file_id, mac.ast_id);
+        let mut ast_id = AstIdWithPath::new(self.file_id, mac.ast_id, mac.path.clone());
        // Case 0: builtin macros
        if mac.builtin {
            if let Some(name) = &mac.name {
                let krate = self.def_collector.def_map.krate;
-                if let Some(macro_id) = find_builtin_macro(name, krate, ast_id) {
+                if let Some(macro_id) = find_builtin_macro(name, krate, ast_id.ast_id) {
                    self.def_collector.define_macro(
                        self.module_id,
                        name.clone(),
@@ -862,7 +869,7 @@ where
        if is_macro_rules(&mac.path) {
            if let Some(name) = &mac.name {
                let macro_id = MacroDefId {
-                    ast_id: Some(ast_id),
+                    ast_id: Some(ast_id.ast_id),
                    krate: Some(self.def_collector.def_map.krate),
                    kind: MacroDefKind::Declarative,
                };
@@ -872,15 +879,13 @@ where
        }
        // Case 2: try to resolve in legacy scope and expand macro_rules
-        if let Some(macro_def) = mac.path.as_ident().and_then(|name| {
+        if let Some(macro_call_id) = ast_id.as_call_id(self.def_collector.db, |path| {
-            self.def_collector.def_map[self.module_id].scope.get_legacy_macro(&name)
+            path.as_ident().and_then(|name| {
+                self.def_collector.def_map[self.module_id].scope.get_legacy_macro(&name)
+            })
        }) {
-            let macro_call_id =
-                macro_def.as_call_id(self.def_collector.db, MacroCallKind::FnLike(ast_id));
            self.def_collector.unexpanded_macros.push(MacroDirective {
                module_id: self.module_id,
-                path: mac.path.clone(),
                ast_id,
                legacy: Some(macro_call_id),
            });
@@ -890,14 +895,12 @@ where
        // Case 3: resolve in module scope, expand during name resolution.
        // We rewrite simple path `macro_name` to `self::macro_name` to force resolve in module scope only.
-        let mut path = mac.path.clone();
+        if ast_id.path.is_ident() {
-        if path.is_ident() {
+            ast_id.path.kind = PathKind::Super(0);
-            path.kind = PathKind::Super(0);
        }
        self.def_collector.unexpanded_macros.push(MacroDirective {
            module_id: self.module_id,
-            path,
            ast_id,
            legacy: None,
        });
diff --git a/crates/ra_hir_ty/src/infer/unify.rs b/crates/ra_hir_ty/src/infer/unify.rs
index fe05642ae..1dc842f40 100644
--- a/crates/ra_hir_ty/src/infer/unify.rs
+++ b/crates/ra_hir_ty/src/infer/unify.rs
@@ -249,6 +249,8 @@ impl InferenceTable {
        match (ty1, ty2) {
            (Ty::Unknown, _) | (_, Ty::Unknown) => true,
+            (Ty::Placeholder(p1), Ty::Placeholder(p2)) if *p1 == *p2 => true,
            (Ty::Infer(InferTy::TypeVar(tv1)), Ty::Infer(InferTy::TypeVar(tv2)))
            | (Ty::Infer(InferTy::IntVar(tv1)), Ty::Infer(InferTy::IntVar(tv2)))
            | (Ty::Infer(InferTy::FloatVar(tv1)), Ty::Infer(InferTy::FloatVar(tv2)))
diff --git a/crates/ra_hir_ty/src/tests/coercion.rs b/crates/ra_hir_ty/src/tests/coercion.rs
index fc5ef36a5..42330b269 100644
--- a/crates/ra_hir_ty/src/tests/coercion.rs
+++ b/crates/ra_hir_ty/src/tests/coercion.rs
@@ -526,3 +526,25 @@ fn test() {
    "###
    );
 }
+#[test]
+fn coerce_placeholder_ref() {
+    // placeholders should unify, even behind references
+    assert_snapshot!(
+        infer_with_mismatches(r#"
+struct S<T> { t: T }
+impl<TT> S<TT> {
+    fn get(&self) -> &TT {
+        &self.t
+    }
+}
+"#, true),
+        @r###"
+    [51; 55) 'self': &S<TT>
+    [64; 87) '{     ...     }': &TT
+    [74; 81) '&self.t': &TT
+    [75; 79) 'self': &S<TT>
+    [75; 81) 'self.t': TT
+    "###
+    );
+}
diff --git a/crates/ra_hir_ty/src/traits.rs b/crates/ra_hir_ty/src/traits.rs
index 88af61e87..ff8e75b48 100644
--- a/crates/ra_hir_ty/src/traits.rs
+++ b/crates/ra_hir_ty/src/traits.rs
@@ -60,6 +60,9 @@ impl TraitSolver {
                    context.0.db.check_canceled();
                    let remaining = fuel.get();
                    fuel.set(remaining - 1);
+                    if remaining == 0 {
+                        log::debug!("fuel exhausted");
+                    }
                    remaining > 0
                })
            }
diff --git a/crates/ra_ide/src/snapshots/highlighting.html b/crates/ra_ide/src/snapshots/highlighting.html
index 1cc55e78b..a02dbaf2f 100644
--- a/crates/ra_ide/src/snapshots/highlighting.html
+++ b/crates/ra_ide/src/snapshots/highlighting.html
@@ -16,6 +16,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .literal            { color: #BFEBBF; }
 .literal\.numeric  { color: #6A8759; }
 .macro              { color: #94BFF3; }
+.module             { color: #AFD8AF; }
 .variable           { color: #DCDCCC; }
 .variable\.mut     { color: #DCDCCC; text-decoration: underline; }
diff --git a/crates/ra_ide/src/snapshots/rainbow_highlighting.html b/crates/ra_ide/src/snapshots/rainbow_highlighting.html
index 918fd4b97..95f038f00 100644
--- a/crates/ra_ide/src/snapshots/rainbow_highlighting.html
+++ b/crates/ra_ide/src/snapshots/rainbow_highlighting.html
@@ -16,6 +16,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .literal            { color: #BFEBBF; }
 .literal\.numeric  { color: #6A8759; }
 .macro              { color: #94BFF3; }
+.module             { color: #AFD8AF; }
 .variable           { color: #DCDCCC; }
 .variable\.mut     { color: #DCDCCC; text-decoration: underline; }
diff --git a/crates/ra_ide/src/syntax_highlighting.rs b/crates/ra_ide/src/syntax_highlighting.rs
index 174e13595..20c414ca1 100644
--- a/crates/ra_ide/src/syntax_highlighting.rs
+++ b/crates/ra_ide/src/syntax_highlighting.rs
@@ -365,6 +365,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .literal            { color: #BFEBBF; }
 .literal\\.numeric  { color: #6A8759; }
 .macro              { color: #94BFF3; }
+.module             { color: #AFD8AF; }
 .variable           { color: #DCDCCC; }
 .variable\\.mut     { color: #DCDCCC; text-decoration: underline; }
diff --git a/crates/ra_ide_db/Cargo.toml b/crates/ra_ide_db/Cargo.toml
index 716e88bc1..495fffb5a 100644
--- a/crates/ra_ide_db/Cargo.toml
+++ b/crates/ra_ide_db/Cargo.toml
@@ -22,7 +22,6 @@ fst = { version = "0.3.1", default-features = false }
 rustc-hash = "1.0"
 unicase = "2.2.0"
 superslice = "1.0.0"
-rand = { version = "0.7.0", features = ["small_rng"] }
 once_cell = "1.2.0"
 ra_syntax = { path = "../ra_syntax" }
diff --git a/crates/ra_lsp_server/src/main.rs b/crates/ra_lsp_server/src/main.rs
index c8a017c5c..ed2eaabd4 100644
--- a/crates/ra_lsp_server/src/main.rs
+++ b/crates/ra_lsp_server/src/main.rs
@@ -15,13 +15,8 @@ fn main() -> Result<()> {
 fn setup_logging() -> Result<()> {
    std::env::set_var("RUST_BACKTRACE", "short");
    env_logger::try_init()?;
+    ra_prof::init();
-    ra_prof::set_filter(match std::env::var("RA_PROFILE") {
-        Ok(spec) => ra_prof::Filter::from_spec(&spec),
-        Err(_) => ra_prof::Filter::disabled(),
-    });
    Ok(())
 }
diff --git a/crates/ra_prof/src/lib.rs b/crates/ra_prof/src/lib.rs
index d38ff397e..c0bfbc2ee 100644
--- a/crates/ra_prof/src/lib.rs
+++ b/crates/ra_prof/src/lib.rs
@@ -26,6 +26,13 @@ pub use crate::memory_usage::{Bytes, MemoryUsage};
 #[global_allocator]
 static ALLOC: jemallocator::Jemalloc = jemallocator::Jemalloc;
+pub fn init() {
+    set_filter(match std::env::var("RA_PROFILE") {
+        Ok(spec) => Filter::from_spec(&spec),
+        Err(_) => Filter::disabled(),
+    });
+}
 /// Set profiling filter. It specifies descriptions allowed to profile.
 /// This is helpful when call stack has too many nested profiling scopes.
 /// Additionally filter can specify maximum depth of profiling scopes nesting.