74 files changed, 1871 insertions, 639 deletions
diff --git a/crates/ra_arena/src/lib.rs b/crates/ra_arena/src/lib.rs
index 3b7cb77b1..3ec8d3b60 100644
--- a/crates/ra_arena/src/lib.rs
+++ b/crates/ra_arena/src/lib.rs
@@ -79,7 +79,7 @@ impl<ID: ArenaId, T> Arena<ID, T> {
        self.data.push(value);
        ID::from_raw(id)
    }
-    pub fn iter(&self) -> impl Iterator<Item = (ID, &T)> {
+    pub fn iter(&self) -> impl Iterator<Item = (ID, &T)> + ExactSizeIterator {
        self.data.iter().enumerate().map(|(idx, value)| (ID::from_raw(RawId(idx as u32)), value))
    }
 }
diff --git a/crates/ra_assists/src/auto_import.rs b/crates/ra_assists/src/auto_import.rs
index a32e2f9b6..1158adbbc 100644
--- a/crates/ra_assists/src/auto_import.rs
+++ b/crates/ra_assists/src/auto_import.rs
@@ -71,6 +71,7 @@ fn compare_path_segment(a: &SmolStr, b: &ast::PathSegment) -> bool {
            ast::PathSegmentKind::SelfKw => a == "self",
            ast::PathSegmentKind::SuperKw => a == "super",
            ast::PathSegmentKind::CrateKw => a == "crate",
+            ast::PathSegmentKind::Type { .. } => false, // not allowed in imports
        }
    } else {
        false
diff --git a/crates/ra_batch/Cargo.toml b/crates/ra_batch/Cargo.toml
index 0ee94c445..8e23826a4 100644
--- a/crates/ra_batch/Cargo.toml
+++ b/crates/ra_batch/Cargo.toml
@@ -9,6 +9,7 @@ log = "0.4.5"
 rustc-hash = "1.0"
 ra_vfs = "0.2.0"
+ra_vfs_glob = { path = "../ra_vfs_glob" }
 ra_db = { path = "../ra_db" }
 ra_ide_api = { path = "../ra_ide_api" }
 ra_hir = { path = "../ra_hir" }
diff --git a/crates/ra_batch/src/lib.rs b/crates/ra_batch/src/lib.rs
index c25737aaa..0db751465 100644
--- a/crates/ra_batch/src/lib.rs
+++ b/crates/ra_batch/src/lib.rs
@@ -1,14 +1,12 @@
-mod vfs_filter;
 use std::{collections::HashSet, error::Error, path::Path};
 use rustc_hash::FxHashMap;
 use ra_db::{CrateGraph, FileId, SourceRootId};
 use ra_ide_api::{AnalysisChange, AnalysisHost};
-use ra_project_model::{ProjectRoot, ProjectWorkspace};
+use ra_project_model::{PackageRoot, ProjectWorkspace};
-use ra_vfs::{Vfs, VfsChange};
+use ra_vfs::{RootEntry, Vfs, VfsChange};
-use vfs_filter::IncludeRustFiles;
+use ra_vfs_glob::RustPackageFilterBuilder;
 type Result<T> = std::result::Result<T, Box<dyn Error + Send + Sync>>;
@@ -19,11 +17,23 @@ fn vfs_root_to_id(r: ra_vfs::VfsRoot) -> SourceRootId {
    SourceRootId(r.0)
 }
-pub fn load_cargo(root: &Path) -> Result<(AnalysisHost, FxHashMap<SourceRootId, ProjectRoot>)> {
+pub fn load_cargo(root: &Path) -> Result<(AnalysisHost, FxHashMap<SourceRootId, PackageRoot>)> {
    let root = std::env::current_dir()?.join(root);
    let ws = ProjectWorkspace::discover(root.as_ref())?;
    let project_roots = ws.to_roots();
-    let (mut vfs, roots) = Vfs::new(IncludeRustFiles::from_roots(project_roots.clone()).collect());
+    let (mut vfs, roots) = Vfs::new(
+        project_roots
+            .iter()
+            .map(|pkg_root| {
+                RootEntry::new(
+                    pkg_root.path().clone(),
+                    RustPackageFilterBuilder::default()
+                        .set_member(pkg_root.is_member())
+                        .into_vfs_filter(),
+                )
+            })
+            .collect(),
+    );
    let crate_graph = ws.to_crate_graph(&mut |path: &Path| {
        let vfs_file = vfs.load(path);
        log::debug!("vfs file {:?} -> {:?}", path, vfs_file);
@@ -48,7 +58,7 @@ pub fn load_cargo(root: &Path) -> Result<(AnalysisHost, FxHashMap<SourceRootId,
 }
 pub fn load(
-    source_roots: &FxHashMap<SourceRootId, ProjectRoot>,
+    source_roots: &FxHashMap<SourceRootId, PackageRoot>,
    crate_graph: CrateGraph,
    vfs: &mut Vfs,
 ) -> AnalysisHost {
diff --git a/crates/ra_batch/src/vfs_filter.rs b/crates/ra_batch/src/vfs_filter.rs
deleted file mode 100644
index 2f0d8cb8b..000000000
--- a/crates/ra_batch/src/vfs_filter.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-use ra_project_model::ProjectRoot;
-use ra_vfs::{Filter, RelativePath, RootEntry};
-use std::path::PathBuf;
-/// `IncludeRustFiles` is used to convert
-/// from `ProjectRoot` to `RootEntry` for VFS
-pub struct IncludeRustFiles {
-    root: ProjectRoot,
-}
-impl IncludeRustFiles {
-    pub fn from_roots<R>(roots: R) -> impl Iterator<Item = RootEntry>
-    where
-        R: IntoIterator<Item = ProjectRoot>,
-    {
-        roots.into_iter().map(IncludeRustFiles::from_root)
-    }
-    pub fn from_root(root: ProjectRoot) -> RootEntry {
-        IncludeRustFiles::from(root).into()
-    }
-    #[allow(unused)]
-    pub fn external(path: PathBuf) -> RootEntry {
-        IncludeRustFiles::from_root(ProjectRoot::new(path, false))
-    }
-    pub fn member(path: PathBuf) -> RootEntry {
-        IncludeRustFiles::from_root(ProjectRoot::new(path, true))
-    }
-}
-impl Filter for IncludeRustFiles {
-    fn include_dir(&self, dir_path: &RelativePath) -> bool {
-        self.root.include_dir(dir_path)
-    }
-    fn include_file(&self, file_path: &RelativePath) -> bool {
-        self.root.include_file(file_path)
-    }
-}
-impl From<ProjectRoot> for IncludeRustFiles {
-    fn from(v: ProjectRoot) -> IncludeRustFiles {
-        IncludeRustFiles { root: v }
-    }
-}
-impl From<IncludeRustFiles> for RootEntry {
-    fn from(v: IncludeRustFiles) -> RootEntry {
-        let path = v.root.path().clone();
-        RootEntry::new(path, Box::new(v))
-    }
-}
diff --git a/crates/ra_cli/src/analysis_stats.rs b/crates/ra_cli/src/analysis_stats.rs
index 403aab352..7e7e6c073 100644
--- a/crates/ra_cli/src/analysis_stats.rs
+++ b/crates/ra_cli/src/analysis_stats.rs
@@ -52,6 +52,9 @@ pub fn run(verbose: bool, memory_usage: bool, path: &Path, only: Option<&str>) -
    println!("Total modules found: {}", visited_modules.len());
    println!("Total declarations: {}", num_decls);
    println!("Total functions: {}", funcs.len());
+    println!("Item Collection: {:?}, {}", analysis_time.elapsed(), ra_prof::memory_usage());
+    let inference_time = Instant::now();
    let bar = indicatif::ProgressBar::with_draw_target(
        funcs.len() as u64,
        indicatif::ProgressDrawTarget::stderr_nohz(),
@@ -112,7 +115,8 @@ pub fn run(verbose: bool, memory_usage: bool, path: &Path, only: Option<&str>) -
        num_exprs_partially_unknown,
        (num_exprs_partially_unknown * 100 / num_exprs)
    );
-    println!("Analysis: {:?}, {}", analysis_time.elapsed(), ra_prof::memory_usage());
+    println!("Inference: {:?}, {}", inference_time.elapsed(), ra_prof::memory_usage());
+    println!("Total: {:?}, {}", analysis_time.elapsed(), ra_prof::memory_usage());
    if memory_usage {
        drop(db);
diff --git a/crates/ra_hir/Cargo.toml b/crates/ra_hir/Cargo.toml
index 285b3c63a..1a2f1b47c 100644
--- a/crates/ra_hir/Cargo.toml
+++ b/crates/ra_hir/Cargo.toml
@@ -27,4 +27,4 @@ chalk-ir = { git = "https://github.com/rust-lang/chalk.git" }
 lalrpop-intern = "0.15.1"
 [dev-dependencies]
-insta = "0.9.0"
+insta = "0.10.0"
diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index 779764590..89fc1d1a1 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -838,6 +838,10 @@ impl TypeAlias {
        self.id.module(db)
    }
+    pub fn krate(self, db: &impl DefDatabase) -> Option<Crate> {
+        self.module(db).krate(db)
+    }
    /// The containing impl block, if this is a method.
    pub fn impl_block(self, db: &impl DefDatabase) -> Option<ImplBlock> {
        let module_impls = db.impls_in_module(self.module(db));
diff --git a/crates/ra_hir/src/diagnostics.rs b/crates/ra_hir/src/diagnostics.rs
index 0290483b3..f6240830f 100644
--- a/crates/ra_hir/src/diagnostics.rs
+++ b/crates/ra_hir/src/diagnostics.rs
@@ -3,7 +3,7 @@ use std::{any::Any, fmt};
 use ra_syntax::{ast, AstNode, AstPtr, SyntaxNode, SyntaxNodePtr, TextRange};
 use relative_path::RelativePathBuf;
-use crate::{HirDatabase, HirFileId, Name};
+use crate::{HirDatabase, HirFileId, Name, Source};
 /// Diagnostic defines hir API for errors and warnings.
 ///
@@ -19,10 +19,9 @@ use crate::{HirDatabase, HirFileId, Name};
 /// instance of `Diagnostic` on demand.
 pub trait Diagnostic: Any + Send + Sync + fmt::Debug + 'static {
    fn message(&self) -> String;
-    fn file(&self) -> HirFileId;
+    fn source(&self) -> Source<SyntaxNodePtr>;
-    fn syntax_node_ptr(&self) -> SyntaxNodePtr;
    fn highlight_range(&self) -> TextRange {
-        self.syntax_node_ptr().range()
+        self.source().ast.range()
    }
    fn as_any(&self) -> &(dyn Any + Send + 'static);
 }
@@ -34,8 +33,8 @@ pub trait AstDiagnostic {
 impl dyn Diagnostic {
    pub fn syntax_node(&self, db: &impl HirDatabase) -> SyntaxNode {
-        let node = db.parse_or_expand(self.file()).unwrap();
+        let node = db.parse_or_expand(self.source().file_id).unwrap();
-        self.syntax_node_ptr().to_node(&node)
+        self.source().ast.to_node(&node)
    }
    pub fn downcast_ref<D: Diagnostic>(&self) -> Option<&D> {
@@ -87,12 +86,11 @@ impl Diagnostic for NoSuchField {
    fn message(&self) -> String {
        "no such field".to_string()
    }
-    fn file(&self) -> HirFileId {
-        self.file
+    fn source(&self) -> Source<SyntaxNodePtr> {
-    }
+        Source { file_id: self.file, ast: self.field.into() }
-    fn syntax_node_ptr(&self) -> SyntaxNodePtr {
-        self.field.into()
    }
    fn as_any(&self) -> &(dyn Any + Send + 'static) {
        self
    }
@@ -109,11 +107,8 @@ impl Diagnostic for UnresolvedModule {
    fn message(&self) -> String {
        "unresolved module".to_string()
    }
-    fn file(&self) -> HirFileId {
+    fn source(&self) -> Source<SyntaxNodePtr> {
-        self.file
+        Source { file_id: self.file, ast: self.decl.into() }
-    }
-    fn syntax_node_ptr(&self) -> SyntaxNodePtr {
-        self.decl.into()
    }
    fn as_any(&self) -> &(dyn Any + Send + 'static) {
        self
@@ -131,11 +126,8 @@ impl Diagnostic for MissingFields {
    fn message(&self) -> String {
        "fill structure fields".to_string()
    }
-    fn file(&self) -> HirFileId {
+    fn source(&self) -> Source<SyntaxNodePtr> {
-        self.file
+        Source { file_id: self.file, ast: self.field_list.into() }
-    }
-    fn syntax_node_ptr(&self) -> SyntaxNodePtr {
-        self.field_list.into()
    }
    fn as_any(&self) -> &(dyn Any + Send + 'static) {
        self
@@ -146,8 +138,8 @@ impl AstDiagnostic for MissingFields {
    type AST = ast::NamedFieldList;
    fn ast(&self, db: &impl HirDatabase) -> Self::AST {
-        let root = db.parse_or_expand(self.file()).unwrap();
+        let root = db.parse_or_expand(self.source().file_id).unwrap();
-        let node = self.syntax_node_ptr().to_node(&root);
+        let node = self.source().ast.to_node(&root);
        ast::NamedFieldList::cast(node).unwrap()
    }
 }
diff --git a/crates/ra_hir/src/expr.rs b/crates/ra_hir/src/expr.rs
index 4dcea19a9..f33676655 100644
--- a/crates/ra_hir/src/expr.rs
+++ b/crates/ra_hir/src/expr.rs
@@ -11,17 +11,16 @@ use ra_syntax::{
    },
    AstNode, AstPtr, SyntaxNodePtr,
 };
+use test_utils::tested_by;
 use crate::{
    name::{AsName, SELF_PARAM},
+    path::GenericArgs,
+    ty::primitive::{FloatTy, IntTy, UncertainFloatTy, UncertainIntTy},
    type_ref::{Mutability, TypeRef},
    DefWithBody, Either, HasSource, HirDatabase, HirFileId, MacroCallLoc, MacroFileKind, Name,
    Path, Resolver,
 };
-use crate::{
-    path::GenericArgs,
-    ty::primitive::{FloatTy, IntTy, UncertainFloatTy, UncertainIntTy},
-};
 pub use self::scope::ExprScopes;
@@ -558,37 +557,40 @@ where
        let syntax_ptr = SyntaxNodePtr::new(expr.syntax());
        match expr.kind() {
            ast::ExprKind::IfExpr(e) => {
-                if let Some(pat) = e.condition().and_then(|c| c.pat()) {
+                let then_branch = self.collect_block_opt(e.then_branch());
-                    // if let -- desugar to match
-                    let pat = self.collect_pat(pat);
+                let else_branch = e.else_branch().map(|b| match b {
-                    let match_expr =
+                    ast::ElseBranch::Block(it) => self.collect_block(it),
-                        self.collect_expr_opt(e.condition().expect("checked above").expr());
+                    ast::ElseBranch::IfExpr(elif) => {
-                    let then_branch = self.collect_block_opt(e.then_branch());
+                        let expr: ast::Expr = ast::Expr::cast(elif.syntax().clone()).unwrap();
-                    let else_branch = e
+                        self.collect_expr(expr)
-                        .else_branch()
+                    }
-                        .map(|b| match b {
+                });
-                            ast::ElseBranch::Block(it) => self.collect_block(it),
-                            ast::ElseBranch::IfExpr(elif) => self.collect_expr(elif.into()),
+                let condition = match e.condition() {
-                        })
+                    None => self.exprs.alloc(Expr::Missing),
-                        .unwrap_or_else(|| self.empty_block());
+                    Some(condition) => match condition.pat() {
-                    let placeholder_pat = self.pats.alloc(Pat::Missing);
+                        None => self.collect_expr_opt(condition.expr()),
-                    let arms = vec![
+                        // if let -- desugar to match
-                        MatchArm { pats: vec![pat], expr: then_branch, guard: None },
+                        Some(pat) => {
-                        MatchArm { pats: vec![placeholder_pat], expr: else_branch, guard: None },
+                            let pat = self.collect_pat(pat);
-                    ];
+                            let match_expr = self.collect_expr_opt(condition.expr());
-                    self.alloc_expr(Expr::Match { expr: match_expr, arms }, syntax_ptr)
+                            let placeholder_pat = self.pats.alloc(Pat::Missing);
-                } else {
+                            let arms = vec![
-                    let condition = self.collect_expr_opt(e.condition().and_then(|c| c.expr()));
+                                MatchArm { pats: vec![pat], expr: then_branch, guard: None },
-                    let then_branch = self.collect_block_opt(e.then_branch());
+                                MatchArm {
-                    let else_branch = e.else_branch().map(|b| match b {
+                                    pats: vec![placeholder_pat],
-                        ast::ElseBranch::Block(it) => self.collect_block(it),
+                                    expr: else_branch.unwrap_or_else(|| self.empty_block()),
-                        ast::ElseBranch::IfExpr(elif) => {
+                                    guard: None,
-                            let expr: ast::Expr = ast::Expr::cast(elif.syntax().clone()).unwrap();
+                                },
-                            self.collect_expr(expr)
+                            ];
+                            return self
+                                .alloc_expr(Expr::Match { expr: match_expr, arms }, syntax_ptr);
                        }
-                    });
+                    },
-                    self.alloc_expr(Expr::If { condition, then_branch, else_branch }, syntax_ptr)
+                };
-                }
+                self.alloc_expr(Expr::If { condition, then_branch, else_branch }, syntax_ptr)
            }
            ast::ExprKind::TryBlockExpr(e) => {
                let body = self.collect_block_opt(e.try_body());
@@ -600,17 +602,30 @@ where
                self.alloc_expr(Expr::Loop { body }, syntax_ptr)
            }
            ast::ExprKind::WhileExpr(e) => {
-                let condition = if let Some(condition) = e.condition() {
-                    if condition.pat().is_none() {
-                        self.collect_expr_opt(condition.expr())
-                    } else {
-                        // FIXME handle while let
-                        return self.alloc_expr(Expr::Missing, syntax_ptr);
-                    }
-                } else {
-                    self.exprs.alloc(Expr::Missing)
-                };
                let body = self.collect_block_opt(e.loop_body());
+                let condition = match e.condition() {
+                    None => self.exprs.alloc(Expr::Missing),
+                    Some(condition) => match condition.pat() {
+                        None => self.collect_expr_opt(condition.expr()),
+                        // if let -- desugar to match
+                        Some(pat) => {
+                            tested_by!(infer_while_let);
+                            let pat = self.collect_pat(pat);
+                            let match_expr = self.collect_expr_opt(condition.expr());
+                            let placeholder_pat = self.pats.alloc(Pat::Missing);
+                            let break_ = self.exprs.alloc(Expr::Break { expr: None });
+                            let arms = vec![
+                                MatchArm { pats: vec![pat], expr: body, guard: None },
+                                MatchArm { pats: vec![placeholder_pat], expr: break_, guard: None },
+                            ];
+                            let match_expr =
+                                self.exprs.alloc(Expr::Match { expr: match_expr, arms });
+                            return self.alloc_expr(Expr::Loop { body: match_expr }, syntax_ptr);
+                        }
+                    },
+                };
                self.alloc_expr(Expr::While { condition, body }, syntax_ptr)
            }
            ast::ExprKind::ForExpr(e) => {
diff --git a/crates/ra_hir/src/marks.rs b/crates/ra_hir/src/marks.rs
index 2d831f0d8..5b15eee90 100644
--- a/crates/ra_hir/src/marks.rs
+++ b/crates/ra_hir/src/marks.rs
@@ -10,4 +10,5 @@ test_utils::marks!(
    std_prelude
    match_ergonomics_ref
    trait_resolution_on_fn_type
+    infer_while_let
 );
diff --git a/crates/ra_hir/src/nameres/collector.rs b/crates/ra_hir/src/nameres/collector.rs
index 06b732215..7da2dcdff 100644
--- a/crates/ra_hir/src/nameres/collector.rs
+++ b/crates/ra_hir/src/nameres/collector.rs
@@ -483,7 +483,7 @@ struct ModCollector<'a, D> {
    module_id: CrateModuleId,
    file_id: HirFileId,
    raw_items: &'a raw::RawItems,
-    parent_module: Option<&'a Name>,
+    parent_module: Option<ParentModule<'a>>,
 }
 impl<DB> ModCollector<'_, &'_ mut DefCollector<&'_ DB>>
@@ -508,15 +508,16 @@ where
    fn collect_module(&mut self, module: &raw::ModuleData) {
        match module {
            // inline module, just recurse
-            raw::ModuleData::Definition { name, items, ast_id } => {
+            raw::ModuleData::Definition { name, items, ast_id, attr_path } => {
                let module_id =
                    self.push_child_module(name.clone(), ast_id.with_file_id(self.file_id), None);
+                let parent_module = ParentModule { name, attr_path: attr_path.as_ref() };
                ModCollector {
                    def_collector: &mut *self.def_collector,
                    module_id,
                    file_id: self.file_id,
                    raw_items: self.raw_items,
-                    parent_module: Some(name),
+                    parent_module: Some(parent_module),
                }
                .collect(&*items);
            }
@@ -530,7 +531,7 @@ where
                    name,
                    is_root,
                    attr_path.as_ref(),
-                    self.parent_module,
+                    self.parent_module.as_ref(),
                ) {
                    Ok(file_id) => {
                        let module_id = self.push_child_module(name.clone(), ast_id, Some(file_id));
@@ -647,7 +648,7 @@ fn resolve_submodule(
    name: &Name,
    is_root: bool,
    attr_path: Option<&SmolStr>,
-    parent_module: Option<&Name>,
+    parent_module: Option<&ParentModule>,
 ) -> Result<FileId, RelativePathBuf> {
    let file_id = file_id.original_file(db);
    let source_root_id = db.file_source_root(file_id);
@@ -657,20 +658,49 @@ fn resolve_submodule(
    let mod_name = path.file_stem().unwrap_or("unknown");
    let resolve_mode = match (attr_path.filter(|p| !p.is_empty()), parent_module) {
-        (Some(file_path), Some(parent_name)) => {
+        (Some(file_path), Some(parent_module)) => {
            let file_path = normalize_attribute_path(file_path);
-            let path = dir_path.join(format!("{}/{}", parent_name, file_path)).normalize();
+            match parent_module.attribute_path() {
-            ResolutionMode::InsideInlineModule(InsideInlineModuleMode::WithAttributePath(path))
+                Some(parent_module_attr_path) => {
+                    let path = dir_path
+                        .join(format!(
+                            "{}/{}",
+                            normalize_attribute_path(parent_module_attr_path),
+                            file_path
+                        ))
+                        .normalize();
+                    ResolutionMode::InlineModuleWithAttributePath(
+                        InsideInlineModuleMode::WithAttributePath(path),
+                    )
+                }
+                None => {
+                    let path =
+                        dir_path.join(format!("{}/{}", parent_module.name, file_path)).normalize();
+                    ResolutionMode::InsideInlineModule(InsideInlineModuleMode::WithAttributePath(
+                        path,
+                    ))
+                }
+            }
        }
+        (None, Some(parent_module)) => match parent_module.attribute_path() {
+            Some(parent_module_attr_path) => {
+                let path = dir_path.join(format!(
+                    "{}/{}.rs",
+                    normalize_attribute_path(parent_module_attr_path),
+                    name
+                ));
+                ResolutionMode::InlineModuleWithAttributePath(InsideInlineModuleMode::File(path))
+            }
+            None => {
+                let path = dir_path.join(format!("{}/{}.rs", parent_module.name, name));
+                ResolutionMode::InsideInlineModule(InsideInlineModuleMode::File(path))
+            }
+        },
        (Some(file_path), None) => {
            let file_path = normalize_attribute_path(file_path);
            let path = dir_path.join(file_path.as_ref()).normalize();
            ResolutionMode::OutOfLine(OutOfLineMode::WithAttributePath(path))
        }
-        (None, Some(parent_name)) => {
-            let path = dir_path.join(format!("{}/{}.rs", parent_name, name));
-            ResolutionMode::InsideInlineModule(InsideInlineModuleMode::File(path))
-        }
        _ => {
            let is_dir_owner = is_root || mod_name == "mod";
            if is_dir_owner {
@@ -743,6 +773,7 @@ impl InsideInlineModuleMode {
 enum ResolutionMode {
    OutOfLine(OutOfLineMode),
    InsideInlineModule(InsideInlineModuleMode),
+    InlineModuleWithAttributePath(InsideInlineModuleMode),
 }
 impl ResolutionMode {
@@ -752,6 +783,7 @@ impl ResolutionMode {
        match self {
            OutOfLine(mode) => mode.resolve(source_root),
            InsideInlineModule(mode) => mode.resolve(source_root),
+            InlineModuleWithAttributePath(mode) => mode.resolve(source_root),
        }
    }
 }
@@ -773,6 +805,17 @@ fn resolve_find_result(
    }
 }
+struct ParentModule<'a> {
+    name: &'a Name,
+    attr_path: Option<&'a SmolStr>,
+}
+impl<'a> ParentModule<'a> {
+    pub fn attribute_path(&self) -> Option<&SmolStr> {
+        self.attr_path.filter(|p| !p.is_empty())
+    }
+}
 #[cfg(test)]
 mod tests {
    use ra_db::SourceDatabase;
diff --git a/crates/ra_hir/src/nameres/raw.rs b/crates/ra_hir/src/nameres/raw.rs
index 8517f3c43..584e15e29 100644
--- a/crates/ra_hir/src/nameres/raw.rs
+++ b/crates/ra_hir/src/nameres/raw.rs
@@ -130,8 +130,17 @@ impl_arena_id!(Module);
 #[derive(Debug, PartialEq, Eq)]
 pub(super) enum ModuleData {
-    Declaration { name: Name, ast_id: FileAstId<ast::Module>, attr_path: Option<SmolStr> },
+    Declaration {
-    Definition { name: Name, ast_id: FileAstId<ast::Module>, items: Vec<RawItem> },
+        name: Name,
+        ast_id: FileAstId<ast::Module>,
+        attr_path: Option<SmolStr>,
+    },
+    Definition {
+        name: Name,
+        ast_id: FileAstId<ast::Module>,
+        items: Vec<RawItem>,
+        attr_path: Option<SmolStr>,
+    },
 }
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -256,9 +265,9 @@ impl RawItemsCollector {
            None => return,
        };
-        let attr_path = extract_mod_path_attribute(&module);
        let ast_id = self.source_ast_id_map.ast_id(&module);
        if module.has_semi() {
+            let attr_path = extract_mod_path_attribute(&module);
            let item =
                self.raw_items.modules.alloc(ModuleData::Declaration { name, ast_id, attr_path });
            self.push_item(current_module, RawItem::Module(item));
@@ -266,10 +275,12 @@ impl RawItemsCollector {
        }
        if let Some(item_list) = module.item_list() {
+            let attr_path = extract_mod_path_attribute(&module);
            let item = self.raw_items.modules.alloc(ModuleData::Definition {
                name,
                ast_id,
                items: Vec::new(),
+                attr_path,
            });
            self.process_module(Some(item), item_list);
            self.push_item(current_module, RawItem::Module(item));
diff --git a/crates/ra_hir/src/nameres/tests/mods.rs b/crates/ra_hir/src/nameres/tests/mods.rs
index 382728149..6dd18df1a 100644
--- a/crates/ra_hir/src/nameres/tests/mods.rs
+++ b/crates/ra_hir/src/nameres/tests/mods.rs
@@ -336,9 +336,7 @@ fn module_resolution_explicit_path_mod_rs_with_win_separator() {
    "###);
 }
-// FIXME: issue #1529. not support out-of-line modules inside inline.
 #[test]
-#[ignore]
 fn module_resolution_decl_inside_inline_module_with_path_attribute() {
    let map = def_map_with_crate_graph(
        r###"
@@ -397,9 +395,7 @@ fn module_resolution_decl_inside_inline_module() {
    "###);
 }
-// FIXME: issue #1529. not support out-of-line modules inside inline.
 #[test]
-#[ignore]
 fn module_resolution_decl_inside_inline_module_2_with_path_attribute() {
    let map = def_map_with_crate_graph(
        r###"
@@ -429,9 +425,7 @@ fn module_resolution_decl_inside_inline_module_2_with_path_attribute() {
    "###);
 }
-// FIXME: issue #1529. not support out-of-line modules inside inline.
 #[test]
-#[ignore]
 fn module_resolution_decl_inside_inline_module_3() {
    let map = def_map_with_crate_graph(
        r###"
@@ -462,9 +456,7 @@ fn module_resolution_decl_inside_inline_module_3() {
    "###);
 }
-// FIXME: issue #1529. not support out-of-line modules inside inline.
 #[test]
-#[ignore]
 fn module_resolution_decl_inside_inline_module_empty_path() {
    let map = def_map_with_crate_graph(
        r###"
@@ -475,7 +467,7 @@ fn module_resolution_decl_inside_inline_module_empty_path() {
            mod bar;
        }
-        //- /users.rs
+        //- /foo/users.rs
        pub struct Baz;
        "###,
        crate_graph! {
@@ -520,9 +512,7 @@ fn module_resolution_decl_empty_path() {
    "###);
 }
-// FIXME: issue #1529. not support out-of-line modules inside inline.
 #[test]
-#[ignore]
 fn module_resolution_decl_inside_inline_module_relative_path() {
    let map = def_map_with_crate_graph(
        r###"
@@ -660,9 +650,7 @@ fn module_resolution_decl_inside_inline_module_in_non_crate_root() {
    "###);
 }
-// FIXME: issue #1529. not support out-of-line modules inside inline.
 #[test]
-#[ignore]
 fn module_resolution_decl_inside_inline_module_in_non_crate_root_2() {
    let map = def_map_with_crate_graph(
        r###"
diff --git a/crates/ra_hir/src/path.rs b/crates/ra_hir/src/path.rs
index 882db7681..5ee71e421 100644
--- a/crates/ra_hir/src/path.rs
+++ b/crates/ra_hir/src/path.rs
@@ -25,6 +25,12 @@ pub struct PathSegment {
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct GenericArgs {
    pub args: Vec<GenericArg>,
+    /// This specifies whether the args contain a Self type as the first
+    /// element. This is the case for path segments like `<T as Trait>`, where
+    /// `T` is actually a type parameter for the path `Trait` specifying the
+    /// Self type. Otherwise, when we have a path `Trait<X, Y>`, the Self type
+    /// is left out.
+    pub has_self_type: bool,
    // someday also bindings
 }
@@ -74,6 +80,28 @@ impl Path {
                    let segment = PathSegment { name: name.as_name(), args_and_bindings: args };
                    segments.push(segment);
                }
+                ast::PathSegmentKind::Type { type_ref, trait_ref } => {
+                    assert!(path.qualifier().is_none()); // this can only occur at the first segment
+                    // FIXME: handle <T> syntax (type segments without trait)
+                    // <T as Trait<A>>::Foo desugars to Trait<Self=T, A>::Foo
+                    let path = Path::from_ast(trait_ref?.path()?)?;
+                    kind = path.kind;
+                    let mut prefix_segments = path.segments;
+                    prefix_segments.reverse();
+                    segments.extend(prefix_segments);
+                    // Insert the type reference (T in the above example) as Self parameter for the trait
+                    let self_type = TypeRef::from_ast(type_ref?);
+                    let mut last_segment = segments.last_mut()?;
+                    if last_segment.args_and_bindings.is_none() {
+                        last_segment.args_and_bindings = Some(Arc::new(GenericArgs::empty()));
+                    };
+                    let args = last_segment.args_and_bindings.as_mut().unwrap();
+                    let mut args_inner = Arc::make_mut(args);
+                    args_inner.has_self_type = true;
+                    args_inner.args.insert(0, GenericArg::Type(self_type));
+                }
                ast::PathSegmentKind::CrateKw => {
                    kind = PathKind::Crate;
                    break;
@@ -144,11 +172,15 @@ impl GenericArgs {
        }
        // lifetimes and assoc type args ignored for now
        if !args.is_empty() {
-            Some(GenericArgs { args })
+            Some(GenericArgs { args, has_self_type: false })
        } else {
            None
        }
    }
+    pub(crate) fn empty() -> GenericArgs {
+        GenericArgs { args: Vec::new(), has_self_type: false }
+    }
 }
 impl From<Name> for Path {
@@ -236,6 +268,10 @@ fn convert_path(prefix: Option<Path>, path: ast::Path) -> Option<Path> {
            }
            Path { kind: PathKind::Super, segments: Vec::new() }
        }
+        ast::PathSegmentKind::Type { .. } => {
+            // not allowed in imports
+            return None;
+        }
    };
    Some(res)
 }
diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs
index c2c6921cb..e86716d74 100644
--- a/crates/ra_hir/src/source_binder.rs
+++ b/crates/ra_hir/src/source_binder.rs
@@ -18,14 +18,18 @@ use ra_syntax::{
 use rustc_hash::{FxHashMap, FxHashSet};
 use crate::{
-    expr,
    expr::{
+        self,
        scope::{ExprScopes, ScopeId},
        BodySourceMap,
    },
    ids::LocationCtx,
+    name,
+    path::{PathKind, PathSegment},
+    ty::method_resolution::implements_trait,
    AsName, AstId, Const, Crate, DefWithBody, Either, Enum, Function, HirDatabase, HirFileId,
-    MacroDef, Module, Name, Path, PerNs, Resolver, Static, Struct, Trait, Ty,
+    MacroDef, Module, ModuleDef, Name, Path, PerNs, Resolution, Resolver, Static, Struct, Trait,
+    Ty,
 };
 /// Locates the module by `FileId`. Picks topmost module in the file.
@@ -409,6 +413,33 @@ impl SourceAnalyzer {
        crate::ty::autoderef(db, &self.resolver, canonical).map(|canonical| canonical.value)
    }
+    /// Checks that particular type `ty` implements `std::future::Future`.
+    /// This function is used in `.await` syntax completion.
+    pub fn impls_future(&self, db: &impl HirDatabase, ty: Ty) -> bool {
+        let std_future_path = Path {
+            kind: PathKind::Abs,
+            segments: vec![
+                PathSegment { name: name::STD, args_and_bindings: None },
+                PathSegment { name: name::FUTURE_MOD, args_and_bindings: None },
+                PathSegment { name: name::FUTURE_TYPE, args_and_bindings: None },
+            ],
+        };
+        let std_future_trait =
+            match self.resolver.resolve_path_segments(db, &std_future_path).into_fully_resolved() {
+                PerNs { types: Some(Resolution::Def(ModuleDef::Trait(trait_))), .. } => trait_,
+                _ => return false,
+            };
+        let krate = match self.resolver.krate() {
+            Some(krate) => krate,
+            _ => return false,
+        };
+        let canonical_ty = crate::ty::Canonical { value: ty, num_vars: 0 };
+        implements_trait(&canonical_ty, db, &self.resolver, krate, std_future_trait)
+    }
    #[cfg(test)]
    pub(crate) fn body_source_map(&self) -> Arc<BodySourceMap> {
        self.body_source_map.clone().unwrap()
diff --git a/crates/ra_hir/src/ty.rs b/crates/ra_hir/src/ty.rs
index 82589e504..642dd02cb 100644
--- a/crates/ra_hir/src/ty.rs
+++ b/crates/ra_hir/src/ty.rs
@@ -94,6 +94,12 @@ pub enum TypeCtor {
    /// A tuple type.  For example, `(i32, bool)`.
    Tuple { cardinality: u16 },
+    /// Represents an associated item like `Iterator::Item`.  This is used
+    /// when we have tried to normalize a projection like `T::Item` but
+    /// couldn't find a better representation.  In that case, we generate
+    /// an **application type** like `(Iterator::Item)<T>`.
+    AssociatedType(TypeAlias),
 }
 /// A nominal type with (maybe 0) type parameters. This might be a primitive
@@ -114,6 +120,12 @@ pub struct ProjectionTy {
    pub parameters: Substs,
 }
+#[derive(Clone, PartialEq, Eq, Debug, Hash)]
+pub struct UnselectedProjectionTy {
+    pub type_name: Name,
+    pub parameters: Substs,
+}
 /// A type.
 ///
 /// See also the `TyKind` enum in rustc (librustc/ty/sty.rs), which represents
@@ -127,6 +139,18 @@ pub enum Ty {
    /// several other things.
    Apply(ApplicationTy),
+    /// A "projection" type corresponds to an (unnormalized)
+    /// projection like `<P0 as Trait<P1..Pn>>::Foo`. Note that the
+    /// trait and all its parameters are fully known.
+    Projection(ProjectionTy),
+    /// This is a variant of a projection in which the trait is
+    /// **not** known.  It corresponds to a case where people write
+    /// `T::Item` without specifying the trait. We would then try to
+    /// figure out the trait by looking at all the traits that are in
+    /// scope.
+    UnselectedProjection(UnselectedProjectionTy),
    /// A type parameter; for example, `T` in `fn f<T>(x: T) {}
    Param {
        /// The index of the parameter (starting with parameters from the
@@ -352,6 +376,16 @@ impl Ty {
                    t.walk(f);
                }
            }
+            Ty::Projection(p_ty) => {
+                for t in p_ty.parameters.iter() {
+                    t.walk(f);
+                }
+            }
+            Ty::UnselectedProjection(p_ty) => {
+                for t in p_ty.parameters.iter() {
+                    t.walk(f);
+                }
+            }
            Ty::Param { .. } | Ty::Bound(_) | Ty::Infer(_) | Ty::Unknown => {}
        }
        f(self);
@@ -362,6 +396,12 @@ impl Ty {
            Ty::Apply(a_ty) => {
                a_ty.parameters.walk_mut(f);
            }
+            Ty::Projection(p_ty) => {
+                p_ty.parameters.walk_mut(f);
+            }
+            Ty::UnselectedProjection(p_ty) => {
+                p_ty.parameters.walk_mut(f);
+            }
            Ty::Param { .. } | Ty::Bound(_) | Ty::Infer(_) | Ty::Unknown => {}
        }
        f(self);
@@ -572,15 +612,61 @@ impl HirDisplay for ApplicationTy {
                    write!(f, ">")?;
                }
            }
+            TypeCtor::AssociatedType(type_alias) => {
+                let trait_name = type_alias
+                    .parent_trait(f.db)
+                    .and_then(|t| t.name(f.db))
+                    .unwrap_or_else(Name::missing);
+                let name = type_alias.name(f.db);
+                write!(f, "{}::{}", trait_name, name)?;
+                if self.parameters.len() > 0 {
+                    write!(f, "<")?;
+                    f.write_joined(&*self.parameters.0, ", ")?;
+                    write!(f, ">")?;
+                }
+            }
        }
        Ok(())
    }
 }
+impl HirDisplay for ProjectionTy {
+    fn hir_fmt(&self, f: &mut HirFormatter<impl HirDatabase>) -> fmt::Result {
+        let trait_name = self
+            .associated_ty
+            .parent_trait(f.db)
+            .and_then(|t| t.name(f.db))
+            .unwrap_or_else(Name::missing);
+        write!(f, "<{} as {}", self.parameters[0].display(f.db), trait_name,)?;
+        if self.parameters.len() > 1 {
+            write!(f, "<")?;
+            f.write_joined(&self.parameters[1..], ", ")?;
+            write!(f, ">")?;
+        }
+        write!(f, ">::{}", self.associated_ty.name(f.db))?;
+        Ok(())
+    }
+}
+impl HirDisplay for UnselectedProjectionTy {
+    fn hir_fmt(&self, f: &mut HirFormatter<impl HirDatabase>) -> fmt::Result {
+        write!(f, "{}", self.parameters[0].display(f.db))?;
+        if self.parameters.len() > 1 {
+            write!(f, "<")?;
+            f.write_joined(&self.parameters[1..], ", ")?;
+            write!(f, ">")?;
+        }
+        write!(f, "::{}", self.type_name)?;
+        Ok(())
+    }
+}
 impl HirDisplay for Ty {
    fn hir_fmt(&self, f: &mut HirFormatter<impl HirDatabase>) -> fmt::Result {
        match self {
            Ty::Apply(a_ty) => a_ty.hir_fmt(f)?,
+            Ty::Projection(p_ty) => p_ty.hir_fmt(f)?,
+            Ty::UnselectedProjection(p_ty) => p_ty.hir_fmt(f)?,
            Ty::Param { name, .. } => write!(f, "{}", name)?,
            Ty::Bound(idx) => write!(f, "?{}", idx)?,
            Ty::Unknown => write!(f, "{{unknown}}")?,
@@ -606,3 +692,17 @@ impl HirDisplay for TraitRef {
        Ok(())
    }
 }
+impl HirDisplay for Obligation {
+    fn hir_fmt(&self, f: &mut HirFormatter<impl HirDatabase>) -> fmt::Result {
+        match self {
+            Obligation::Trait(tr) => write!(f, "Implements({})", tr.display(f.db)),
+            Obligation::Projection(proj) => write!(
+                f,
+                "Normalize({} => {})",
+                proj.projection_ty.display(f.db),
+                proj.ty.display(f.db)
+            ),
+        }
+    }
+}
diff --git a/crates/ra_hir/src/ty/infer.rs b/crates/ra_hir/src/ty/infer.rs
index 594c5bc79..675df4a22 100644
--- a/crates/ra_hir/src/ty/infer.rs
+++ b/crates/ra_hir/src/ty/infer.rs
@@ -245,7 +245,8 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
            &self.resolver,
            type_ref,
        );
-        self.insert_type_vars(ty)
+        let ty = self.insert_type_vars(ty);
+        self.normalize_associated_types_in(ty)
    }
    fn unify_substs(&mut self, substs1: &Substs, substs2: &Substs, depth: usize) -> bool {
@@ -411,6 +412,32 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
        ty
    }
+    /// Recurses through the given type, normalizing associated types mentioned
+    /// in it by replacing them by type variables and registering obligations to
+    /// resolve later. This should be done once for every type we get from some
+    /// type annotation (e.g. from a let type annotation, field type or function
+    /// call). `make_ty` handles this already, but e.g. for field types we need
+    /// to do it as well.
+    fn normalize_associated_types_in(&mut self, ty: Ty) -> Ty {
+        let ty = self.resolve_ty_as_possible(&mut vec![], ty);
+        ty.fold(&mut |ty| match ty {
+            Ty::Projection(proj_ty) => self.normalize_projection_ty(proj_ty),
+            Ty::UnselectedProjection(proj_ty) => {
+                // FIXME use Chalk's unselected projection support
+                Ty::UnselectedProjection(proj_ty)
+            }
+            _ => ty,
+        })
+    }
+    fn normalize_projection_ty(&mut self, proj_ty: ProjectionTy) -> Ty {
+        let var = self.new_type_var();
+        let predicate = ProjectionPredicate { projection_ty: proj_ty.clone(), ty: var.clone() };
+        let obligation = Obligation::Projection(predicate);
+        self.obligations.push(obligation);
+        var
+    }
    /// Resolves the type completely; type variables without known type are
    /// replaced by Ty::Unknown.
    fn resolve_ty_completely(&mut self, tv_stack: &mut Vec<TypeVarId>, ty: Ty) -> Ty {
@@ -549,6 +576,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                let substs = Ty::substs_from_path(self.db, &self.resolver, path, typable);
                let ty = ty.subst(&substs);
                let ty = self.insert_type_vars(ty);
+                let ty = self.normalize_associated_types_in(ty);
                Some(ty)
            }
            Resolution::LocalBinding(pat) => {
@@ -670,6 +698,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                .and_then(|d| d.field(self.db, &Name::tuple_field_name(i)))
                .map_or(Ty::Unknown, |field| field.ty(self.db))
                .subst(&substs);
+            let expected_ty = self.normalize_associated_types_in(expected_ty);
            self.infer_pat(subpat, &expected_ty, default_bm);
        }
@@ -697,6 +726,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
            let matching_field = def.and_then(|it| it.field(self.db, &subpat.name));
            let expected_ty =
                matching_field.map_or(Ty::Unknown, |field| field.ty(self.db)).subst(&substs);
+            let expected_ty = self.normalize_associated_types_in(expected_ty);
            self.infer_pat(subpat.pat, &expected_ty, default_bm);
        }
@@ -927,9 +957,11 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
        self.unify(&expected_receiver_ty, &actual_receiver_ty);
        let param_iter = param_tys.into_iter().chain(repeat(Ty::Unknown));
-        for (arg, param) in args.iter().zip(param_iter) {
+        for (arg, param_ty) in args.iter().zip(param_iter) {
-            self.infer_expr(*arg, &Expectation::has_type(param));
+            let param_ty = self.normalize_associated_types_in(param_ty);
+            self.infer_expr(*arg, &Expectation::has_type(param_ty));
        }
+        let ret_ty = self.normalize_associated_types_in(ret_ty);
        ret_ty
    }
@@ -1020,9 +1052,11 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                };
                self.register_obligations_for_call(&callee_ty);
                let param_iter = param_tys.into_iter().chain(repeat(Ty::Unknown));
-                for (arg, param) in args.iter().zip(param_iter) {
+                for (arg, param_ty) in args.iter().zip(param_iter) {
-                    self.infer_expr(*arg, &Expectation::has_type(param));
+                    let param_ty = self.normalize_associated_types_in(param_ty);
+                    self.infer_expr(*arg, &Expectation::has_type(param_ty));
                }
+                let ret_ty = self.normalize_associated_types_in(ret_ty);
                ret_ty
            }
            Expr::MethodCall { receiver, args, method_name, generic_args } => self
@@ -1120,7 +1154,8 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                    _ => None,
                })
                .unwrap_or(Ty::Unknown);
-                self.insert_type_vars(ty)
+                let ty = self.insert_type_vars(ty);
+                self.normalize_associated_types_in(ty)
            }
            Expr::Await { expr } => {
                let inner_ty = self.infer_expr(*expr, &Expectation::none());
diff --git a/crates/ra_hir/src/ty/lower.rs b/crates/ra_hir/src/ty/lower.rs
index 894ba0695..debedcbb8 100644
--- a/crates/ra_hir/src/ty/lower.rs
+++ b/crates/ra_hir/src/ty/lower.rs
@@ -8,7 +8,7 @@
 use std::iter;
 use std::sync::Arc;
-use super::{FnSig, GenericPredicate, Substs, TraitRef, Ty, TypeCtor};
+use super::{FnSig, GenericPredicate, ProjectionTy, Substs, TraitRef, Ty, TypeCtor};
 use crate::{
    adt::VariantDef,
    generics::HasGenericParams,
@@ -64,7 +64,8 @@ impl Ty {
    pub(crate) fn from_hir_path(db: &impl HirDatabase, resolver: &Resolver, path: &Path) -> Self {
        // Resolve the path (in type namespace)
-        let resolution = resolver.resolve_path_without_assoc_items(db, path).take_types();
+        let (resolution, remaining_index) = resolver.resolve_path_segments(db, path).into_inner();
+        let resolution = resolution.take_types();
        let def = match resolution {
            Some(Resolution::Def(def)) => def,
@@ -73,6 +74,10 @@ impl Ty {
                panic!("path resolved to local binding in type ns");
            }
            Some(Resolution::GenericParam(idx)) => {
+                if remaining_index.is_some() {
+                    // e.g. T::Item
+                    return Ty::Unknown;
+                }
                return Ty::Param {
                    idx,
                    // FIXME: maybe return name in resolution?
@@ -83,18 +88,54 @@ impl Ty {
                };
            }
            Some(Resolution::SelfType(impl_block)) => {
+                if remaining_index.is_some() {
+                    // e.g. Self::Item
+                    return Ty::Unknown;
+                }
                return impl_block.target_ty(db);
            }
-            None => return Ty::Unknown,
+            None => {
+                // path did not resolve
+                return Ty::Unknown;
+            }
        };
-        let typable: TypableDef = match def.into() {
+        if let ModuleDef::Trait(trait_) = def {
-            None => return Ty::Unknown,
+            let segment = match remaining_index {
-            Some(it) => it,
+                None => path.segments.last().expect("resolved path has at least one element"),
-        };
+                Some(i) => &path.segments[i - 1],
-        let ty = db.type_for_def(typable, Namespace::Types);
+            };
-        let substs = Ty::substs_from_path(db, resolver, path, typable);
+            let trait_ref = TraitRef::from_resolved_path(db, resolver, trait_, segment, None);
-        ty.subst(&substs)
+            if let Some(remaining_index) = remaining_index {
+                if remaining_index == path.segments.len() - 1 {
+                    let segment = &path.segments[remaining_index];
+                    let associated_ty =
+                        match trait_ref.trait_.associated_type_by_name(db, segment.name.clone()) {
+                            Some(t) => t,
+                            None => {
+                                // associated type not found
+                                return Ty::Unknown;
+                            }
+                        };
+                    // FIXME handle type parameters on the segment
+                    Ty::Projection(ProjectionTy { associated_ty, parameters: trait_ref.substs })
+                } else {
+                    // FIXME more than one segment remaining, is this possible?
+                    Ty::Unknown
+                }
+            } else {
+                // FIXME dyn Trait without the dyn
+                Ty::Unknown
+            }
+        } else {
+            let typable: TypableDef = match def.into() {
+                None => return Ty::Unknown,
+                Some(it) => it,
+            };
+            let ty = db.type_for_def(typable, Namespace::Types);
+            let substs = Ty::substs_from_path(db, resolver, path, typable);
+            ty.subst(&substs)
+        }
    }
    pub(super) fn substs_from_path_segment(
@@ -219,14 +260,25 @@ impl TraitRef {
            Resolution::Def(ModuleDef::Trait(tr)) => tr,
            _ => return None,
        };
-        let mut substs = Self::substs_from_path(db, resolver, path, resolved);
+        let segment = path.segments.last().expect("path should have at least one segment");
+        Some(TraitRef::from_resolved_path(db, resolver, resolved, segment, explicit_self_ty))
+    }
+    fn from_resolved_path(
+        db: &impl HirDatabase,
+        resolver: &Resolver,
+        resolved: Trait,
+        segment: &PathSegment,
+        explicit_self_ty: Option<Ty>,
+    ) -> Self {
+        let mut substs = TraitRef::substs_from_path(db, resolver, segment, resolved);
        if let Some(self_ty) = explicit_self_ty {
            // FIXME this could be nicer
            let mut substs_vec = substs.0.to_vec();
            substs_vec[0] = self_ty;
            substs.0 = substs_vec.into();
        }
-        Some(TraitRef { trait_: resolved, substs })
+        TraitRef { trait_: resolved, substs }
    }
    pub(crate) fn from_hir(
@@ -245,11 +297,12 @@ impl TraitRef {
    fn substs_from_path(
        db: &impl HirDatabase,
        resolver: &Resolver,
-        path: &Path,
+        segment: &PathSegment,
        resolved: Trait,
    ) -> Substs {
-        let segment = path.segments.last().expect("path should have at least one segment");
+        let has_self_param =
-        substs_from_path_segment(db, resolver, segment, Some(resolved.into()), true)
+            segment.args_and_bindings.as_ref().map(|a| a.has_self_type).unwrap_or(false);
+        substs_from_path_segment(db, resolver, segment, Some(resolved.into()), !has_self_param)
    }
    pub(crate) fn for_trait(db: &impl HirDatabase, trait_: Trait) -> TraitRef {
diff --git a/crates/ra_hir/src/ty/method_resolution.rs b/crates/ra_hir/src/ty/method_resolution.rs
index d421bf9ef..88d012a74 100644
--- a/crates/ra_hir/src/ty/method_resolution.rs
+++ b/crates/ra_hir/src/ty/method_resolution.rs
@@ -255,6 +255,20 @@ fn iterate_inherent_methods<T>(
    None
 }
+pub(crate) fn implements_trait(
+    ty: &Canonical<Ty>,
+    db: &impl HirDatabase,
+    resolver: &Resolver,
+    krate: Crate,
+    trait_: Trait,
+) -> bool {
+    let env = lower::trait_env(db, resolver);
+    let goal = generic_implements_goal(db, env.clone(), trait_, ty.clone());
+    let solution = db.trait_solve(krate, goal);
+    solution.is_some()
+}
 impl Ty {
    // This would be nicer if it just returned an iterator, but that runs into
    // lifetime problems, because we need to borrow temp `CrateImplBlocks`.
diff --git a/crates/ra_hir/src/ty/tests.rs b/crates/ra_hir/src/ty/tests.rs
index 36dea17a3..28727bb18 100644
--- a/crates/ra_hir/src/ty/tests.rs
+++ b/crates/ra_hir/src/ty/tests.rs
@@ -145,6 +145,26 @@ mod collections {
 }
 #[test]
+fn infer_while_let() {
+    covers!(infer_while_let);
+    let (db, pos) = MockDatabase::with_position(
+        r#"
+//- /main.rs
+enum Option<T> { Some(T), None }
+fn test() {
+    let foo: Option<f32> = None;
+    while let Option::Some(x) = foo {
+        <|>x
+    }
+}
+"#,
+    );
+    assert_eq!("f32", type_at_pos(&db, pos));
+}
+#[test]
 fn infer_basics() {
    assert_snapshot_matches!(
        infer(r#"
@@ -2488,15 +2508,55 @@ struct S;
 impl Iterable for S { type Item = u32; }
 fn test<T: Iterable>() {
    let x: <S as Iterable>::Item = 1;
-    let y: T::Item = no_matter;
+    let y: <T as Iterable>::Item = no_matter;
+    let z: T::Item = no_matter;
+}
+"#),
+        @r###"
+   ⋮
+   ⋮[108; 227) '{     ...ter; }': ()
+   ⋮[118; 119) 'x': u32
+   ⋮[145; 146) '1': u32
+   ⋮[156; 157) 'y': {unknown}
+   ⋮[183; 192) 'no_matter': {unknown}
+   ⋮[202; 203) 'z': {unknown}
+   ⋮[215; 224) 'no_matter': {unknown}
+    "###
+    );
+}
+#[test]
+fn infer_return_associated_type() {
+    assert_snapshot_matches!(
+        infer(r#"
+trait Iterable {
+   type Item;
+}
+struct S;
+impl Iterable for S { type Item = u32; }
+fn foo1<T: Iterable>(t: T) -> T::Item {}
+fn foo2<T: Iterable>(t: T) -> <T as Iterable>::Item {}
+fn test() {
+    let x = foo1(S);
+    let y = foo2(S);
 }
 "#),
        @r###"
-[108; 181) '{     ...ter; }': ()
+   ⋮
-[118; 119) 'x': i32
+   ⋮[106; 107) 't': T
-[145; 146) '1': i32
+   ⋮[123; 125) '{}': ()
-[156; 157) 'y': {unknown}
+   ⋮[147; 148) 't': T
-[169; 178) 'no_matter': {unknown}"###
+   ⋮[178; 180) '{}': ()
+   ⋮[191; 236) '{     ...(S); }': ()
+   ⋮[201; 202) 'x': {unknown}
+   ⋮[205; 209) 'foo1': fn foo1<S>(T) -> {unknown}
+   ⋮[205; 212) 'foo1(S)': {unknown}
+   ⋮[210; 211) 'S': S
+   ⋮[222; 223) 'y': u32
+   ⋮[226; 230) 'foo2': fn foo2<S>(T) -> <T as Iterable>::Item
+   ⋮[226; 233) 'foo2(S)': u32
+   ⋮[231; 232) 'S': S
+    "###
    );
 }
@@ -3121,6 +3181,55 @@ fn test<T: Trait>(t: T) { (*t)<|>; }
    assert_eq!(t, "i128");
 }
+#[test]
+fn associated_type_placeholder() {
+    let t = type_at(
+        r#"
+//- /main.rs
+pub trait ApplyL {
+    type Out;
+}
+pub struct RefMutL<T>;
+impl<T> ApplyL for RefMutL<T> {
+    type Out = <T as ApplyL>::Out;
+}
+fn test<T: ApplyL>() {
+    let y: <RefMutL<T> as ApplyL>::Out = no_matter;
+    y<|>;
+}
+"#,
+    );
+    // inside the generic function, the associated type gets normalized to a placeholder `ApplL::Out<T>` [https://rust-lang.github.io/rustc-guide/traits/associated-types.html#placeholder-associated-types].
+    // FIXME: fix type parameter names going missing when going through Chalk
+    assert_eq!(t, "ApplyL::Out<[missing name]>");
+}
+#[test]
+fn associated_type_placeholder_2() {
+    let t = type_at(
+        r#"
+//- /main.rs
+pub trait ApplyL {
+    type Out;
+}
+fn foo<T: ApplyL>(t: T) -> <T as ApplyL>::Out;
+fn test<T: ApplyL>(t: T) {
+    let y = foo(t);
+    y<|>;
+}
+"#,
+    );
+    // FIXME here Chalk doesn't normalize the type to a placeholder. I think we
+    // need to add a rule like Normalize(<T as ApplyL>::Out -> ApplyL::Out<T>)
+    // to the trait env ourselves here; probably Chalk can't do this by itself.
+    // assert_eq!(t, "ApplyL::Out<[missing name]>");
+    assert_eq!(t, "{unknown}");
+}
 fn type_at_pos(db: &MockDatabase, pos: FilePosition) -> String {
    let file = db.parse(pos.file_id).ok().unwrap();
    let expr = algo::find_node_at_offset::<ast::Expr>(file.syntax(), pos.offset).unwrap();
diff --git a/crates/ra_hir/src/ty/traits.rs b/crates/ra_hir/src/ty/traits.rs
index 0769e6e17..fde5d8a47 100644
--- a/crates/ra_hir/src/ty/traits.rs
+++ b/crates/ra_hir/src/ty/traits.rs
@@ -7,7 +7,7 @@ use parking_lot::Mutex;
 use ra_prof::profile;
 use rustc_hash::FxHashSet;
-use super::{Canonical, GenericPredicate, ProjectionTy, TraitRef, Ty};
+use super::{Canonical, GenericPredicate, HirDisplay, ProjectionTy, TraitRef, Ty};
 use crate::{db::HirDatabase, Crate, ImplBlock, Trait};
 use self::chalk::{from_chalk, ToChalk};
@@ -61,7 +61,6 @@ fn solve(
 ) -> Option<chalk_solve::Solution> {
    let context = ChalkContext { db, krate };
    let solver = db.trait_solver(krate);
-    debug!("solve goal: {:?}", goal);
    let solution = solver.lock().solve(&context, goal);
    debug!("solve({:?}) => {:?}", goal, solution);
    solution
@@ -120,10 +119,11 @@ pub struct ProjectionPredicate {
 pub(crate) fn trait_solve_query(
    db: &impl HirDatabase,
    krate: Crate,
-    trait_ref: Canonical<InEnvironment<Obligation>>,
+    goal: Canonical<InEnvironment<Obligation>>,
 ) -> Option<Solution> {
    let _p = profile("trait_solve_query");
-    let canonical = trait_ref.to_chalk(db).cast();
+    debug!("trait_solve_query({})", goal.value.value.display(db));
+    let canonical = goal.to_chalk(db).cast();
    // We currently don't deal with universes (I think / hope they're not yet
    // relevant for our use cases?)
    let u_canonical = chalk_ir::UCanonical { canonical, universes: 1 };
diff --git a/crates/ra_hir/src/ty/traits/chalk.rs b/crates/ra_hir/src/ty/traits/chalk.rs
index 9e7ae0724..6df7094c5 100644
--- a/crates/ra_hir/src/ty/traits/chalk.rs
+++ b/crates/ra_hir/src/ty/traits/chalk.rs
@@ -45,11 +45,33 @@ impl ToChalk for Ty {
    fn to_chalk(self, db: &impl HirDatabase) -> chalk_ir::Ty {
        match self {
            Ty::Apply(apply_ty) => {
-                let struct_id = apply_ty.ctor.to_chalk(db);
+                let name = match apply_ty.ctor {
-                let name = TypeName::TypeKindId(struct_id.into());
+                    TypeCtor::AssociatedType(type_alias) => {
+                        let type_id = type_alias.to_chalk(db);
+                        TypeName::AssociatedType(type_id)
+                    }
+                    _ => {
+                        // other TypeCtors get interned and turned into a chalk StructId
+                        let struct_id = apply_ty.ctor.to_chalk(db);
+                        TypeName::TypeKindId(struct_id.into())
+                    }
+                };
                let parameters = apply_ty.parameters.to_chalk(db);
                chalk_ir::ApplicationTy { name, parameters }.cast()
            }
+            Ty::Projection(proj_ty) => {
+                let associated_ty_id = proj_ty.associated_ty.to_chalk(db);
+                let parameters = proj_ty.parameters.to_chalk(db);
+                chalk_ir::ProjectionTy { associated_ty_id, parameters }.cast()
+            }
+            Ty::UnselectedProjection(proj_ty) => {
+                let type_name = lalrpop_intern::intern(&proj_ty.type_name.to_string());
+                let parameters = proj_ty.parameters.to_chalk(db);
+                chalk_ir::Ty::UnselectedProjection(chalk_ir::UnselectedProjectionTy {
+                    type_name,
+                    parameters,
+                })
+            }
            Ty::Param { idx, .. } => {
                PlaceholderIndex { ui: UniverseIndex::ROOT, idx: idx as usize }.to_ty()
            }
@@ -66,15 +88,21 @@ impl ToChalk for Ty {
    fn from_chalk(db: &impl HirDatabase, chalk: chalk_ir::Ty) -> Self {
        match chalk {
            chalk_ir::Ty::Apply(apply_ty) => {
+                // FIXME this is kind of hacky due to the fact that
+                // TypeName::Placeholder is a Ty::Param on our side
                match apply_ty.name {
                    TypeName::TypeKindId(TypeKindId::StructId(struct_id)) => {
                        let ctor = from_chalk(db, struct_id);
                        let parameters = from_chalk(db, apply_ty.parameters);
                        Ty::Apply(ApplicationTy { ctor, parameters })
                    }
+                    TypeName::AssociatedType(type_id) => {
+                        let ctor = TypeCtor::AssociatedType(from_chalk(db, type_id));
+                        let parameters = from_chalk(db, apply_ty.parameters);
+                        Ty::Apply(ApplicationTy { ctor, parameters })
+                    }
                    // FIXME handle TypeKindId::Trait/Type here
                    TypeName::TypeKindId(_) => unimplemented!(),
-                    TypeName::AssociatedType(_) => unimplemented!(),
                    TypeName::Placeholder(idx) => {
                        assert_eq!(idx.ui, UniverseIndex::ROOT);
                        Ty::Param { idx: idx.idx as u32, name: crate::Name::missing() }
@@ -389,11 +417,12 @@ where
        &self,
        projection: &'p chalk_ir::ProjectionTy,
    ) -> (Arc<AssociatedTyDatum>, &'p [Parameter], &'p [Parameter]) {
-        debug!("split_projection {:?}", projection);
+        let proj_ty: ProjectionTy = from_chalk(self.db, projection.clone());
-        unimplemented!()
+        debug!("split_projection {:?} = {}", projection, proj_ty.display(self.db));
+        // we don't support GATs, so I think this should always be correct currently
+        (self.db.associated_ty_data(projection.associated_ty_id), &projection.parameters, &[])
    }
    fn custom_clauses(&self) -> Vec<chalk_ir::ProgramClause> {
-        debug!("custom_clauses");
        vec![]
    }
    fn all_structs(&self) -> Vec<chalk_ir::StructId> {
@@ -529,6 +558,16 @@ pub(crate) fn struct_datum_query(
                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),
+            )
+        }
    };
    let flags = chalk_rust_ir::StructFlags {
        upstream,
diff --git a/crates/ra_ide_api/Cargo.toml b/crates/ra_ide_api/Cargo.toml
index dd11ec0f6..a7dc0b63a 100644
--- a/crates/ra_ide_api/Cargo.toml
+++ b/crates/ra_ide_api/Cargo.toml
@@ -27,7 +27,7 @@ test_utils = { path = "../test_utils" }
 ra_assists = { path = "../ra_assists" }
 [dev-dependencies]
-insta = "0.9.0"
+insta = "0.10.0"
 [dev-dependencies.proptest]
 version = "0.9.0"
diff --git a/crates/ra_ide_api/src/completion/complete_dot.rs b/crates/ra_ide_api/src/completion/complete_dot.rs
index 536ba36df..d43ff2eec 100644
--- a/crates/ra_ide_api/src/completion/complete_dot.rs
+++ b/crates/ra_ide_api/src/completion/complete_dot.rs
@@ -1,19 +1,36 @@
 use hir::{AdtDef, Ty, TypeCtor};
-use crate::completion::{CompletionContext, Completions};
+use crate::completion::completion_item::CompletionKind;
+use crate::{
+    completion::{completion_context::CompletionContext, completion_item::Completions},
+    CompletionItem,
+};
 use rustc_hash::FxHashSet;
-/// Complete dot accesses, i.e. fields or methods (currently only fields).
+/// Complete dot accesses, i.e. fields or methods (and .await syntax).
 pub(super) fn complete_dot(acc: &mut Completions, ctx: &CompletionContext) {
-    let receiver_ty =
+    let dot_receiver = match &ctx.dot_receiver {
-        match ctx.dot_receiver.as_ref().and_then(|it| ctx.analyzer.type_of(ctx.db, it)) {
+        Some(expr) => expr,
-            Some(it) => it,
+        _ => return,
-            None => return,
+    };
-        };
+    let receiver_ty = match ctx.analyzer.type_of(ctx.db, &dot_receiver) {
+        Some(ty) => ty,
+        _ => return,
+    };
    if !ctx.is_call {
        complete_fields(acc, ctx, receiver_ty.clone());
    }
-    complete_methods(acc, ctx, receiver_ty);
+    complete_methods(acc, ctx, receiver_ty.clone());
+    // Suggest .await syntax for types that implement Future trait
+    if ctx.analyzer.impls_future(ctx.db, receiver_ty) {
+        CompletionItem::new(CompletionKind::Keyword, ctx.source_range(), "await")
+            .detail("expr.await")
+            .insert_text("await")
+            .add_to(acc);
+    }
 }
 fn complete_fields(acc: &mut Completions, ctx: &CompletionContext, receiver: Ty) {
@@ -406,4 +423,36 @@ mod tests {
        "###
        );
    }
+    #[test]
+    fn test_completion_await_impls_future() {
+        assert_debug_snapshot_matches!(
+        do_completion(
+            r###"
+            //- /main.rs
+            use std::future::*;
+            struct A {}
+            impl Future for A {}
+            fn foo(a: A) {
+                a.<|>
+            }
+            //- /std/lib.rs
+            pub mod future {
+                pub trait Future {}
+            }
+            "###, CompletionKind::Keyword),
+        @r###"
+       ⋮[
+       ⋮    CompletionItem {
+       ⋮        label: "await",
+       ⋮        source_range: [74; 74),
+       ⋮        delete: [74; 74),
+       ⋮        insert: "await",
+       ⋮        detail: "expr.await",
+       ⋮    },
+       ⋮]
+        "###
+        )
+    }
 }
diff --git a/crates/ra_ide_api/src/diagnostics.rs b/crates/ra_ide_api/src/diagnostics.rs
index 028dc3d4f..98b840b26 100644
--- a/crates/ra_ide_api/src/diagnostics.rs
+++ b/crates/ra_ide_api/src/diagnostics.rs
@@ -48,7 +48,7 @@ pub(crate) fn diagnostics(db: &RootDatabase, file_id: FileId) -> Vec<Diagnostic>
        })
    })
    .on::<hir::diagnostics::UnresolvedModule, _>(|d| {
-        let source_root = db.file_source_root(d.file().original_file(db));
+        let source_root = db.file_source_root(d.source().file_id.original_file(db));
        let create_file = FileSystemEdit::CreateFile { source_root, path: d.candidate.clone() };
        let fix = SourceChange::file_system_edit("create module", create_file);
        res.borrow_mut().push(Diagnostic {
diff --git a/crates/ra_ide_api/src/inlay_hints.rs b/crates/ra_ide_api/src/inlay_hints.rs
index a524e014f..0b3c96d26 100644
--- a/crates/ra_ide_api/src/inlay_hints.rs
+++ b/crates/ra_ide_api/src/inlay_hints.rs
@@ -9,14 +9,9 @@ use ra_syntax::{
    SmolStr, SyntaxKind, SyntaxNode, TextRange,
 };
-#[derive(Debug, PartialEq, Eq, Clone)]
+#[derive(Debug, PartialEq, Eq)]
 pub enum InlayKind {
-    LetBindingType,
+    TypeHint,
-    ClosureParameterType,
-    ForExpressionBindingType,
-    IfExpressionType,
-    WhileLetExpressionType,
-    MatchArmType,
 }
 #[derive(Debug)]
@@ -46,7 +41,7 @@ fn get_inlay_hints(
            }
            let pat = let_statement.pat()?;
            let analyzer = SourceAnalyzer::new(db, file_id, let_statement.syntax(), None);
-            Some(get_pat_hints(db, &analyzer, pat, InlayKind::LetBindingType, false))
+            Some(get_pat_type_hints(db, &analyzer, pat, false))
        })
        .visit(|closure_parameter: LambdaExpr| {
            let analyzer = SourceAnalyzer::new(db, file_id, closure_parameter.syntax(), None);
@@ -55,15 +50,7 @@ fn get_inlay_hints(
                    .params()
                    .filter(|closure_param| closure_param.ascribed_type().is_none())
                    .filter_map(|closure_param| closure_param.pat())
-                    .map(|root_pat| {
+                    .map(|root_pat| get_pat_type_hints(db, &analyzer, root_pat, false))
-                        get_pat_hints(
-                            db,
-                            &analyzer,
-                            root_pat,
-                            InlayKind::ClosureParameterType,
-                            false,
-                        )
-                    })
                    .flatten()
                    .collect()
            })
@@ -71,17 +58,17 @@ fn get_inlay_hints(
        .visit(|for_expression: ForExpr| {
            let pat = for_expression.pat()?;
            let analyzer = SourceAnalyzer::new(db, file_id, for_expression.syntax(), None);
-            Some(get_pat_hints(db, &analyzer, pat, InlayKind::ForExpressionBindingType, false))
+            Some(get_pat_type_hints(db, &analyzer, pat, false))
        })
        .visit(|if_expr: IfExpr| {
            let pat = if_expr.condition()?.pat()?;
            let analyzer = SourceAnalyzer::new(db, file_id, if_expr.syntax(), None);
-            Some(get_pat_hints(db, &analyzer, pat, InlayKind::IfExpressionType, true))
+            Some(get_pat_type_hints(db, &analyzer, pat, true))
        })
        .visit(|while_expr: WhileExpr| {
            let pat = while_expr.condition()?.pat()?;
            let analyzer = SourceAnalyzer::new(db, file_id, while_expr.syntax(), None);
-            Some(get_pat_hints(db, &analyzer, pat, InlayKind::WhileLetExpressionType, true))
+            Some(get_pat_type_hints(db, &analyzer, pat, true))
        })
        .visit(|match_arm_list: MatchArmList| {
            let analyzer = SourceAnalyzer::new(db, file_id, match_arm_list.syntax(), None);
@@ -90,9 +77,7 @@ fn get_inlay_hints(
                    .arms()
                    .map(|match_arm| match_arm.pats())
                    .flatten()
-                    .map(|root_pat| {
+                    .map(|root_pat| get_pat_type_hints(db, &analyzer, root_pat, true))
-                        get_pat_hints(db, &analyzer, root_pat, InlayKind::MatchArmType, true)
-                    })
                    .flatten()
                    .collect(),
            )
@@ -100,11 +85,10 @@ fn get_inlay_hints(
        .accept(&node)?
 }
-fn get_pat_hints(
+fn get_pat_type_hints(
    db: &RootDatabase,
    analyzer: &SourceAnalyzer,
    root_pat: Pat,
-    kind: InlayKind,
    skip_root_pat_hint: bool,
 ) -> Vec<InlayHint> {
    let original_pat = &root_pat.clone();
@@ -118,7 +102,7 @@ fn get_pat_hints(
        })
        .map(|(range, pat_type)| InlayHint {
            range,
-            kind: kind.clone(),
+            kind: InlayKind::TypeHint,
            label: pat_type.display(db).to_string().into(),
        })
        .collect()
@@ -232,52 +216,52 @@ fn main() {
        assert_debug_snapshot_matches!(analysis.inlay_hints(file_id).unwrap(), @r#"[
    InlayHint {
        range: [193; 197),
-        kind: LetBindingType,
+        kind: TypeHint,
        label: "i32",
    },
    InlayHint {
        range: [236; 244),
-        kind: LetBindingType,
+        kind: TypeHint,
        label: "i32",
    },
    InlayHint {
        range: [275; 279),
-        kind: LetBindingType,
+        kind: TypeHint,
        label: "&str",
    },
    InlayHint {
        range: [539; 543),
-        kind: LetBindingType,
+        kind: TypeHint,
        label: "(i32, char)",
    },
    InlayHint {
        range: [566; 567),
-        kind: LetBindingType,
+        kind: TypeHint,
        label: "i32",
    },
    InlayHint {
        range: [570; 571),
-        kind: LetBindingType,
+        kind: TypeHint,
        label: "i32",
    },
    InlayHint {
        range: [573; 574),
-        kind: LetBindingType,
+        kind: TypeHint,
        label: "i32",
    },
    InlayHint {
        range: [584; 585),
-        kind: LetBindingType,
+        kind: TypeHint,
        label: "i32",
    },
    InlayHint {
        range: [577; 578),
-        kind: LetBindingType,
+        kind: TypeHint,
        label: "f64",
    },
    InlayHint {
        range: [580; 581),
-        kind: LetBindingType,
+        kind: TypeHint,
        label: "f64",
    },
 ]"#
@@ -299,12 +283,12 @@ fn main() {
        assert_debug_snapshot_matches!(analysis.inlay_hints(file_id).unwrap(), @r#"[
    InlayHint {
        range: [21; 30),
-        kind: LetBindingType,
+        kind: TypeHint,
        label: "i32",
    },
    InlayHint {
        range: [57; 66),
-        kind: ClosureParameterType,
+        kind: TypeHint,
        label: "i32",
    },
 ]"#
@@ -326,12 +310,12 @@ fn main() {
        assert_debug_snapshot_matches!(analysis.inlay_hints(file_id).unwrap(), @r#"[
    InlayHint {
        range: [21; 30),
-        kind: LetBindingType,
+        kind: TypeHint,
        label: "i32",
    },
    InlayHint {
        range: [44; 53),
-        kind: ForExpressionBindingType,
+        kind: TypeHint,
        label: "i32",
    },
 ]"#
@@ -364,7 +348,7 @@ fn main() {
    if let CustomOption::Some(Test { a: CustomOption::Some(x), b: y }) = &test {};
    if let CustomOption::Some(Test { a: CustomOption::None, b: y }) = &test {};
    if let CustomOption::Some(Test { b: y, .. }) = &test {};
-    
    if test == CustomOption::None {}
 }"#,
        );
@@ -372,27 +356,27 @@ fn main() {
        assert_debug_snapshot_matches!(analysis.inlay_hints(file_id).unwrap(), @r#"[
    InlayHint {
        range: [166; 170),
-        kind: LetBindingType,
+        kind: TypeHint,
        label: "CustomOption<Test>",
    },
    InlayHint {
        range: [334; 338),
-        kind: IfExpressionType,
+        kind: TypeHint,
        label: "&Test",
    },
    InlayHint {
        range: [389; 390),
-        kind: IfExpressionType,
+        kind: TypeHint,
        label: "&CustomOption<u32>",
    },
    InlayHint {
        range: [392; 393),
-        kind: IfExpressionType,
+        kind: TypeHint,
        label: "&u8",
    },
    InlayHint {
        range: [531; 532),
-        kind: IfExpressionType,
+        kind: TypeHint,
        label: "&u32",
    },
 ]"#
@@ -425,18 +409,40 @@ fn main() {
    while let CustomOption::Some(Test { a: CustomOption::Some(x), b: y }) = &test {};
    while let CustomOption::Some(Test { a: CustomOption::None, b: y }) = &test {};
    while let CustomOption::Some(Test { b: y, .. }) = &test {};
-    
    while test == CustomOption::None {}
 }"#,
        );
-        assert_debug_snapshot_matches!(analysis.inlay_hints(file_id).unwrap(), @r#"[
+        assert_debug_snapshot_matches!(analysis.inlay_hints(file_id).unwrap(), @r###"
-    InlayHint {
+       ⋮[
-        range: [166; 170),
+       ⋮    InlayHint {
-        kind: LetBindingType,
+       ⋮        range: [166; 170),
-        label: "CustomOption<Test>",
+       ⋮        kind: TypeHint,
-    },
+       ⋮        label: "CustomOption<Test>",
-]"#
+       ⋮    },
+       ⋮    InlayHint {
+       ⋮        range: [343; 347),
+       ⋮        kind: TypeHint,
+       ⋮        label: "&Test",
+       ⋮    },
+       ⋮    InlayHint {
+       ⋮        range: [401; 402),
+       ⋮        kind: TypeHint,
+       ⋮        label: "&CustomOption<u32>",
+       ⋮    },
+       ⋮    InlayHint {
+       ⋮        range: [404; 405),
+       ⋮        kind: TypeHint,
+       ⋮        label: "&u8",
+       ⋮    },
+       ⋮    InlayHint {
+       ⋮        range: [549; 550),
+       ⋮        kind: TypeHint,
+       ⋮        label: "&u32",
+       ⋮    },
+       ⋮]
+        "###
        );
    }
@@ -445,7 +451,7 @@ fn main() {
        let (analysis, file_id) = single_file(
            r#"
 #[derive(PartialEq)]
-enum CustomOption<T> { 
+enum CustomOption<T> {
    None,
    Some(T),
 }
@@ -473,23 +479,23 @@ fn main() {
        assert_debug_snapshot_matches!(analysis.inlay_hints(file_id).unwrap(), @r#"[
    InlayHint {
-        range: [312; 316),
+        range: [311; 315),
-        kind: MatchArmType,
+        kind: TypeHint,
        label: "Test",
    },
    InlayHint {
-        range: [359; 360),
+        range: [358; 359),
-        kind: MatchArmType,
+        kind: TypeHint,
        label: "CustomOption<u32>",
    },
    InlayHint {
-        range: [362; 363),
+        range: [361; 362),
-        kind: MatchArmType,
+        kind: TypeHint,
        label: "u8",
    },
    InlayHint {
-        range: [485; 486),
+        range: [484; 485),
-        kind: MatchArmType,
+        kind: TypeHint,
        label: "u32",
    },
 ]"#
diff --git a/crates/ra_lsp_server/Cargo.toml b/crates/ra_lsp_server/Cargo.toml
index cec360667..c282d6db8 100644
--- a/crates/ra_lsp_server/Cargo.toml
+++ b/crates/ra_lsp_server/Cargo.toml
@@ -25,6 +25,7 @@ ra_ide_api = { path = "../ra_ide_api" }
 gen_lsp_server = { path = "../gen_lsp_server" }
 ra_project_model = { path = "../ra_project_model" }
 ra_prof = { path = "../ra_prof" }
+ra_vfs_glob = { path = "../ra_vfs_glob" }
 [dev-dependencies]
 tempfile = "3"
diff --git a/crates/ra_lsp_server/src/init.rs b/crates/ra_lsp_server/src/config.rs
index b894b449d..6dcdc695a 100644
--- a/crates/ra_lsp_server/src/init.rs
+++ b/crates/ra_lsp_server/src/config.rs
@@ -1,9 +1,9 @@
 use serde::{Deserialize, Deserializer};
 /// Client provided initialization options
-#[derive(Deserialize, Clone, Copy, Debug, PartialEq, Eq)]
+#[derive(Deserialize, Clone, Debug, PartialEq, Eq)]
 #[serde(rename_all = "camelCase", default)]
-pub struct InitializationOptions {
+pub struct ServerConfig {
    /// Whether the client supports our custom highlighting publishing decorations.
    /// This is different to the highlightingOn setting, which is whether the user
    /// wants our custom highlighting to be used.
@@ -18,14 +18,17 @@ pub struct InitializationOptions {
    #[serde(deserialize_with = "nullable_bool_true")]
    pub show_workspace_loaded: bool,
+    pub exclude_globs: Vec<String>,
    pub lru_capacity: Option<usize>,
 }
-impl Default for InitializationOptions {
+impl Default for ServerConfig {
-    fn default() -> InitializationOptions {
+    fn default() -> ServerConfig {
-        InitializationOptions {
+        ServerConfig {
            publish_decorations: false,
            show_workspace_loaded: true,
+            exclude_globs: Vec::new(),
            lru_capacity: None,
        }
    }
@@ -56,7 +59,7 @@ mod test {
    #[test]
    fn deserialize_init_options_defaults() {
        // check that null == default for both fields
-        let default = InitializationOptions::default();
+        let default = ServerConfig::default();
        assert_eq!(default, serde_json::from_str(r#"{}"#).unwrap());
        assert_eq!(
            default,
diff --git a/crates/ra_lsp_server/src/conv.rs b/crates/ra_lsp_server/src/conv.rs
index 59c5e1582..df8ea6e0d 100644
--- a/crates/ra_lsp_server/src/conv.rs
+++ b/crates/ra_lsp_server/src/conv.rs
@@ -1,13 +1,13 @@
 use lsp_types::{
-    self, CreateFile, DocumentChangeOperation, DocumentChanges, Documentation, Location,
+    self, CreateFile, DiagnosticSeverity, DocumentChangeOperation, DocumentChanges, Documentation,
-    LocationLink, MarkupContent, MarkupKind, Position, Range, RenameFile, ResourceOp, SymbolKind,
+    Location, LocationLink, MarkupContent, MarkupKind, Position, Range, RenameFile, ResourceOp,
-    TextDocumentEdit, TextDocumentIdentifier, TextDocumentItem, TextDocumentPositionParams, Url,
+    SymbolKind, TextDocumentEdit, TextDocumentIdentifier, TextDocumentItem,
-    VersionedTextDocumentIdentifier, WorkspaceEdit,
+    TextDocumentPositionParams, Url, VersionedTextDocumentIdentifier, WorkspaceEdit,
 };
 use ra_ide_api::{
    translate_offset_with_edit, CompletionItem, CompletionItemKind, FileId, FilePosition,
    FileRange, FileSystemEdit, InsertTextFormat, LineCol, LineIndex, NavigationTarget, RangeInfo,
-    SourceChange, SourceFileEdit,
+    Severity, SourceChange, SourceFileEdit,
 };
 use ra_syntax::{SyntaxKind, TextRange, TextUnit};
 use ra_text_edit::{AtomTextEdit, TextEdit};
@@ -79,6 +79,16 @@ impl Conv for CompletionItemKind {
    }
 }
+impl Conv for Severity {
+    type Output = DiagnosticSeverity;
+    fn conv(self) -> DiagnosticSeverity {
+        match self {
+            Severity::Error => DiagnosticSeverity::Error,
+            Severity::WeakWarning => DiagnosticSeverity::Hint,
+        }
+    }
+}
 impl ConvWith for CompletionItem {
    type Ctx = LineIndex;
    type Output = ::lsp_types::CompletionItem;
diff --git a/crates/ra_lsp_server/src/lib.rs b/crates/ra_lsp_server/src/lib.rs
index 56a263aa5..795f86383 100644
--- a/crates/ra_lsp_server/src/lib.rs
+++ b/crates/ra_lsp_server/src/lib.rs
@@ -4,13 +4,11 @@ mod conv;
 mod main_loop;
 mod markdown;
 mod project_model;
-mod vfs_filter;
 pub mod req;
-pub mod init;
+pub mod config;
 mod world;
 pub type Result<T> = std::result::Result<T, Box<dyn std::error::Error + Send + Sync>>;
 pub use crate::{
-    caps::server_capabilities, init::InitializationOptions, main_loop::main_loop,
+    caps::server_capabilities, config::ServerConfig, main_loop::main_loop, main_loop::LspError,
-    main_loop::LspError,
 };
diff --git a/crates/ra_lsp_server/src/main.rs b/crates/ra_lsp_server/src/main.rs
index c1f8243be..1a2ab1bc2 100644
--- a/crates/ra_lsp_server/src/main.rs
+++ b/crates/ra_lsp_server/src/main.rs
@@ -2,7 +2,7 @@ use flexi_logger::{Duplicate, Logger};
 use gen_lsp_server::{run_server, stdio_transport};
 use serde::Deserialize;
-use ra_lsp_server::{InitializationOptions, Result};
+use ra_lsp_server::{Result, ServerConfig};
 use ra_prof;
 fn main() -> Result<()> {
@@ -48,7 +48,7 @@ fn main_inner() -> Result<()> {
        let opts = params
            .initialization_options
-            .and_then(|v| InitializationOptions::deserialize(v).ok())
+            .and_then(|v| ServerConfig::deserialize(v).ok())
            .unwrap_or_default();
        ra_lsp_server::main_loop(workspace_roots, params.capabilities, opts, r, s)
diff --git a/crates/ra_lsp_server/src/main_loop.rs b/crates/ra_lsp_server/src/main_loop.rs
index 8e830c8b8..b9c99a223 100644
--- a/crates/ra_lsp_server/src/main_loop.rs
+++ b/crates/ra_lsp_server/src/main_loop.rs
@@ -23,7 +23,7 @@ use crate::{
    project_model::workspace_loader,
    req,
    world::{Options, WorldSnapshot, WorldState},
-    InitializationOptions, Result,
+    Result, ServerConfig,
 };
 const THREADPOOL_SIZE: usize = 8;
@@ -52,10 +52,11 @@ impl Error for LspError {}
 pub fn main_loop(
    ws_roots: Vec<PathBuf>,
    client_caps: ClientCapabilities,
-    options: InitializationOptions,
+    config: ServerConfig,
    msg_receiver: &Receiver<RawMessage>,
    msg_sender: &Sender<RawMessage>,
 ) -> Result<()> {
+    log::debug!("server_config: {:?}", config);
    // FIXME: support dynamic workspace loading.
    let workspaces = {
        let ws_worker = workspace_loader();
@@ -77,14 +78,19 @@ pub fn main_loop(
        }
        loaded_workspaces
    };
+    let globs = config
+        .exclude_globs
+        .iter()
+        .map(|glob| ra_vfs_glob::Glob::new(glob))
+        .collect::<std::result::Result<Vec<_>, _>>()?;
    let mut state = WorldState::new(
        ws_roots,
        workspaces,
-        options.lru_capacity,
+        config.lru_capacity,
+        &globs,
        Options {
-            publish_decorations: options.publish_decorations,
+            publish_decorations: config.publish_decorations,
-            show_workspace_loaded: options.show_workspace_loaded,
+            show_workspace_loaded: config.show_workspace_loaded,
            supports_location_link: client_caps
                .text_document
                .and_then(|it| it.definition)
@@ -269,7 +275,7 @@ fn main_loop_inner(
            && pending_libraries.is_empty()
            && in_flight_libraries == 0
        {
-            let n_packages: usize = state.workspaces.iter().map(|it| it.count()).sum();
+            let n_packages: usize = state.workspaces.iter().map(|it| it.n_packages()).sum();
            if state.options.show_workspace_loaded {
                let msg = format!("workspace loaded, {} rust packages", n_packages);
                show_message(req::MessageType::Info, msg, msg_sender);
@@ -340,7 +346,6 @@ fn on_request(
        })?
        .on::<req::AnalyzerStatus>(handlers::handle_analyzer_status)?
        .on::<req::SyntaxTree>(handlers::handle_syntax_tree)?
-        .on::<req::ExtendSelection>(handlers::handle_extend_selection)?
        .on::<req::OnTypeFormatting>(handlers::handle_on_type_formatting)?
        .on::<req::DocumentSymbolRequest>(handlers::handle_document_symbol)?
        .on::<req::WorkspaceSymbol>(handlers::handle_workspace_symbol)?
diff --git a/crates/ra_lsp_server/src/main_loop/handlers.rs b/crates/ra_lsp_server/src/main_loop/handlers.rs
index c2a44ffa0..a3d3f167c 100644
--- a/crates/ra_lsp_server/src/main_loop/handlers.rs
+++ b/crates/ra_lsp_server/src/main_loop/handlers.rs
@@ -3,13 +3,13 @@ use std::{fmt::Write as _, io::Write as _};
 use gen_lsp_server::ErrorCode;
 use lsp_types::{
    CodeAction, CodeActionResponse, CodeLens, Command, CompletionItem, Diagnostic,
-    DiagnosticSeverity, DocumentFormattingParams, DocumentHighlight, DocumentSymbol, FoldingRange,
+    DocumentFormattingParams, DocumentHighlight, DocumentSymbol, FoldingRange, FoldingRangeKind,
-    FoldingRangeKind, FoldingRangeParams, Hover, HoverContents, Location, MarkupContent,
+    FoldingRangeParams, Hover, HoverContents, Location, MarkupContent, MarkupKind, Position,
-    MarkupKind, Position, PrepareRenameResponse, Range, RenameParams, SymbolInformation,
+    PrepareRenameResponse, Range, RenameParams, SymbolInformation, TextDocumentIdentifier,
-    TextDocumentIdentifier, TextEdit, WorkspaceEdit,
+    TextEdit, WorkspaceEdit,
 };
 use ra_ide_api::{
-    AssistId, Cancelable, FileId, FilePosition, FileRange, FoldKind, Query, RunnableKind, Severity,
+    AssistId, FileId, FilePosition, FileRange, FoldKind, Query, Runnable, RunnableKind,
 };
 use ra_prof::profile;
 use ra_syntax::{AstNode, SyntaxKind, TextRange, TextUnit};
@@ -45,27 +45,6 @@ pub fn handle_syntax_tree(world: WorldSnapshot, params: req::SyntaxTreeParams) -
    Ok(res)
 }
-// FIXME: drop this API
-pub fn handle_extend_selection(
-    world: WorldSnapshot,
-    params: req::ExtendSelectionParams,
-) -> Result<req::ExtendSelectionResult> {
-    log::error!(
-        "extend selection is deprecated and will be removed soon,
-         use the new selection range API in LSP",
-    );
-    let file_id = params.text_document.try_conv_with(&world)?;
-    let line_index = world.analysis().file_line_index(file_id)?;
-    let selections = params
-        .selections
-        .into_iter()
-        .map_conv_with(&line_index)
-        .map(|range| FileRange { file_id, range })
-        .map(|frange| world.analysis().extend_selection(frange).map(|it| it.conv_with(&line_index)))
-        .collect::<Cancelable<Vec<_>>>()?;
-    Ok(req::ExtendSelectionResult { selections })
-}
 pub fn handle_selection_range(
    world: WorldSnapshot,
    params: req::SelectionRangeParams,
@@ -325,27 +304,7 @@ pub fn handle_runnables(
                continue;
            }
        }
+        res.push(to_lsp_runnable(&world, file_id, runnable)?);
-        let args = runnable_args(&world, file_id, &runnable.kind)?;
-        let r = req::Runnable {
-            range: runnable.range.conv_with(&line_index),
-            label: match &runnable.kind {
-                RunnableKind::Test { name } => format!("test {}", name),
-                RunnableKind::TestMod { path } => format!("test-mod {}", path),
-                RunnableKind::Bench { name } => format!("bench {}", name),
-                RunnableKind::Bin => "run binary".to_string(),
-            },
-            bin: "cargo".to_string(),
-            args,
-            env: {
-                let mut m = FxHashMap::default();
-                m.insert("RUST_BACKTRACE".to_string(), "short".to_string());
-                m
-            },
-            cwd: workspace_root.map(|root| root.to_string_lossy().to_string()),
-        };
-        res.push(r);
    }
    let mut check_args = vec!["check".to_string()];
    let label;
@@ -693,42 +652,27 @@ pub fn handle_code_lens(
    let line_index = world.analysis().file_line_index(file_id)?;
    let mut lenses: Vec<CodeLens> = Default::default();
-    let workspace_root = world.workspace_root_for(file_id);
    // Gather runnables
    for runnable in world.analysis().runnables(file_id)? {
        let title = match &runnable.kind {
-            RunnableKind::Test { .. } | RunnableKind::TestMod { .. } => Some("▶️Run Test"),
+            RunnableKind::Test { .. } | RunnableKind::TestMod { .. } => "▶️Run Test",
-            RunnableKind::Bench { .. } => Some("Run Bench"),
+            RunnableKind::Bench { .. } => "Run Bench",
-            RunnableKind::Bin => Some("️Run"),
+            RunnableKind::Bin => "Run",
+        }
+        .to_string();
+        let r = to_lsp_runnable(&world, file_id, runnable)?;
+        let lens = CodeLens {
+            range: r.range,
+            command: Some(Command {
+                title,
+                command: "rust-analyzer.runSingle".into(),
+                arguments: Some(vec![to_value(r).unwrap()]),
+            }),
+            data: None,
        };
-        if let Some(title) = title {
+        lenses.push(lens);
-            let args = runnable_args(&world, file_id, &runnable.kind)?;
-            let range = runnable.range.conv_with(&line_index);
-            // This represents the actual command that will be run.
-            let r: req::Runnable = req::Runnable {
-                range,
-                label: Default::default(),
-                bin: "cargo".into(),
-                args,
-                env: Default::default(),
-                cwd: workspace_root.map(|root| root.to_string_lossy().to_string()),
-            };
-            let lens = CodeLens {
-                range,
-                command: Some(Command {
-                    title: title.into(),
-                    command: "rust-analyzer.runSingle".into(),
-                    arguments: Some(vec![to_value(r).unwrap()]),
-                }),
-                data: None,
-            };
-            lenses.push(lens);
-        }
    }
    // Handle impls
@@ -838,7 +782,7 @@ pub fn publish_diagnostics(
        .into_iter()
        .map(|d| Diagnostic {
            range: d.range.conv_with(&line_index),
-            severity: Some(to_diagnostic_severity(d.severity)),
+            severity: Some(d.severity.conv()),
            code: None,
            source: Some("rust-analyzer".to_string()),
            message: d.message,
@@ -856,6 +800,32 @@ pub fn publish_decorations(
    Ok(req::PublishDecorationsParams { uri, decorations: highlight(&world, file_id)? })
 }
+fn to_lsp_runnable(
+    world: &WorldSnapshot,
+    file_id: FileId,
+    runnable: Runnable,
+) -> Result<req::Runnable> {
+    let args = runnable_args(world, file_id, &runnable.kind)?;
+    let line_index = world.analysis().file_line_index(file_id)?;
+    let label = match &runnable.kind {
+        RunnableKind::Test { name } => format!("test {}", name),
+        RunnableKind::TestMod { path } => format!("test-mod {}", path),
+        RunnableKind::Bench { name } => format!("bench {}", name),
+        RunnableKind::Bin => "run binary".to_string(),
+    };
+    Ok(req::Runnable {
+        range: runnable.range.conv_with(&line_index),
+        label,
+        bin: "cargo".to_string(),
+        args,
+        env: {
+            let mut m = FxHashMap::default();
+            m.insert("RUST_BACKTRACE".to_string(), "short".to_string());
+            m
+        },
+        cwd: world.workspace_root_for(file_id).map(|root| root.to_string_lossy().to_string()),
+    })
+}
 fn highlight(world: &WorldSnapshot, file_id: FileId) -> Result<Vec<Decoration>> {
    let line_index = world.analysis().file_line_index(file_id)?;
    let res = world
@@ -871,15 +841,6 @@ fn highlight(world: &WorldSnapshot, file_id: FileId) -> Result<Vec<Decoration>>
    Ok(res)
 }
-fn to_diagnostic_severity(severity: Severity) -> DiagnosticSeverity {
-    use ra_ide_api::Severity::*;
-    match severity {
-        Error => DiagnosticSeverity::Error,
-        WeakWarning => DiagnosticSeverity::Hint,
-    }
-}
 pub fn handle_inlay_hints(
    world: WorldSnapshot,
    params: InlayHintsParams,
@@ -894,14 +855,7 @@ pub fn handle_inlay_hints(
            label: api_type.label.to_string(),
            range: api_type.range.conv_with(&line_index),
            kind: match api_type.kind {
-                ra_ide_api::InlayKind::LetBindingType => InlayKind::LetBindingType,
+                ra_ide_api::InlayKind::TypeHint => InlayKind::TypeHint,
-                ra_ide_api::InlayKind::ClosureParameterType => InlayKind::ClosureParameterType,
-                ra_ide_api::InlayKind::ForExpressionBindingType => {
-                    InlayKind::ForExpressionBindingType
-                }
-                ra_ide_api::InlayKind::IfExpressionType => InlayKind::IfExpressionType,
-                ra_ide_api::InlayKind::WhileLetExpressionType => InlayKind::WhileLetExpressionType,
-                ra_ide_api::InlayKind::MatchArmType => InlayKind::MatchArmType,
            },
        })
        .collect())
diff --git a/crates/ra_lsp_server/src/markdown.rs b/crates/ra_lsp_server/src/markdown.rs
index 947ef77cd..c1eb0236a 100644
--- a/crates/ra_lsp_server/src/markdown.rs
+++ b/crates/ra_lsp_server/src/markdown.rs
@@ -54,4 +54,21 @@ mod tests {
        let comment = "this\nis\nultiline";
        assert_eq!(format_docs(comment), comment);
    }
+    #[test]
+    fn test_code_blocks_in_comments_marked_as_rust() {
+        let comment = r#"```rust
+fn main(){}
+```
+Some comment.
+```
+let a = 1;
+```"#;
+        assert_eq!(
+            format_docs(comment),
+            "```rust\nfn main(){}\n```\nSome comment.\n```rust\nlet a = 1;\n```"
+        );
+    }
 }
diff --git a/crates/ra_lsp_server/src/req.rs b/crates/ra_lsp_server/src/req.rs
index 570438643..b2f3c509d 100644
--- a/crates/ra_lsp_server/src/req.rs
+++ b/crates/ra_lsp_server/src/req.rs
@@ -43,27 +43,6 @@ pub struct SyntaxTreeParams {
    pub range: Option<Range>,
 }
-pub enum ExtendSelection {}
-impl Request for ExtendSelection {
-    type Params = ExtendSelectionParams;
-    type Result = ExtendSelectionResult;
-    const METHOD: &'static str = "rust-analyzer/extendSelection";
-}
-#[derive(Deserialize, Debug)]
-#[serde(rename_all = "camelCase")]
-pub struct ExtendSelectionParams {
-    pub text_document: TextDocumentIdentifier,
-    pub selections: Vec<Range>,
-}
-#[derive(Serialize, Debug)]
-#[serde(rename_all = "camelCase")]
-pub struct ExtendSelectionResult {
-    pub selections: Vec<Range>,
-}
 pub enum SelectionRangeRequest {}
 impl Request for SelectionRangeRequest {
@@ -213,12 +192,7 @@ pub struct InlayHintsParams {
 #[derive(Debug, PartialEq, Eq, Deserialize, Serialize)]
 pub enum InlayKind {
-    LetBindingType,
+    TypeHint,
-    ClosureParameterType,
-    ForExpressionBindingType,
-    IfExpressionType,
-    WhileLetExpressionType,
-    MatchArmType,
 }
 #[derive(Debug, Deserialize, Serialize)]
diff --git a/crates/ra_lsp_server/src/vfs_filter.rs b/crates/ra_lsp_server/src/vfs_filter.rs
deleted file mode 100644
index e16a57da5..000000000
--- a/crates/ra_lsp_server/src/vfs_filter.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-use ra_project_model::ProjectRoot;
-use ra_vfs::{Filter, RelativePath, RootEntry};
-use std::path::PathBuf;
-/// `IncludeRustFiles` is used to convert
-/// from `ProjectRoot` to `RootEntry` for VFS
-pub struct IncludeRustFiles {
-    root: ProjectRoot,
-}
-impl IncludeRustFiles {
-    pub fn from_roots<R>(roots: R) -> impl Iterator<Item = RootEntry>
-    where
-        R: IntoIterator<Item = ProjectRoot>,
-    {
-        roots.into_iter().map(IncludeRustFiles::from_root)
-    }
-    pub fn from_root(root: ProjectRoot) -> RootEntry {
-        IncludeRustFiles::from(root).into()
-    }
-    #[allow(unused)]
-    pub fn external(path: PathBuf) -> RootEntry {
-        IncludeRustFiles::from_root(ProjectRoot::new(path, false))
-    }
-    pub fn member(path: PathBuf) -> RootEntry {
-        IncludeRustFiles::from_root(ProjectRoot::new(path, true))
-    }
-}
-impl Filter for IncludeRustFiles {
-    fn include_dir(&self, dir_path: &RelativePath) -> bool {
-        self.root.include_dir(dir_path)
-    }
-    fn include_file(&self, file_path: &RelativePath) -> bool {
-        self.root.include_file(file_path)
-    }
-}
-impl std::convert::From<ProjectRoot> for IncludeRustFiles {
-    fn from(v: ProjectRoot) -> IncludeRustFiles {
-        IncludeRustFiles { root: v }
-    }
-}
-impl std::convert::From<IncludeRustFiles> for RootEntry {
-    fn from(v: IncludeRustFiles) -> RootEntry {
-        let path = v.root.path().clone();
-        RootEntry::new(path, Box::new(v))
-    }
-}
diff --git a/crates/ra_lsp_server/src/world.rs b/crates/ra_lsp_server/src/world.rs
index 1d7755910..9990ef62e 100644
--- a/crates/ra_lsp_server/src/world.rs
+++ b/crates/ra_lsp_server/src/world.rs
@@ -9,13 +9,13 @@ use parking_lot::RwLock;
 use ra_ide_api::{
    Analysis, AnalysisChange, AnalysisHost, CrateGraph, FileId, LibraryData, SourceRootId,
 };
-use ra_vfs::{Vfs, VfsChange, VfsFile, VfsRoot};
+use ra_vfs::{RootEntry, Vfs, VfsChange, VfsFile, VfsRoot};
+use ra_vfs_glob::{Glob, RustPackageFilterBuilder};
 use relative_path::RelativePathBuf;
 use crate::{
    main_loop::pending_requests::{CompletedRequest, LatestRequests},
    project_model::ProjectWorkspace,
-    vfs_filter::IncludeRustFiles,
    LspError, Result,
 };
@@ -56,14 +56,28 @@ impl WorldState {
        folder_roots: Vec<PathBuf>,
        workspaces: Vec<ProjectWorkspace>,
        lru_capacity: Option<usize>,
+        exclude_globs: &[Glob],
        options: Options,
    ) -> WorldState {
        let mut change = AnalysisChange::new();
        let mut roots = Vec::new();
-        roots.extend(folder_roots.iter().cloned().map(IncludeRustFiles::member));
+        roots.extend(folder_roots.iter().map(|path| {
+            let mut filter = RustPackageFilterBuilder::default().set_member(true);
+            for glob in exclude_globs.iter() {
+                filter = filter.exclude(glob.clone());
+            }
+            RootEntry::new(path.clone(), filter.into_vfs_filter())
+        }));
        for ws in workspaces.iter() {
-            roots.extend(IncludeRustFiles::from_roots(ws.to_roots()));
+            roots.extend(ws.to_roots().into_iter().map(|pkg_root| {
+                let mut filter =
+                    RustPackageFilterBuilder::default().set_member(pkg_root.is_member());
+                for glob in exclude_globs.iter() {
+                    filter = filter.exclude(glob.clone());
+                }
+                RootEntry::new(pkg_root.path().clone(), filter.into_vfs_filter())
+            }));
        }
        let (mut vfs, vfs_roots) = Vfs::new(roots);
@@ -211,7 +225,7 @@ impl WorldSnapshot {
        } else {
            res.push_str("workspaces:\n");
            for w in self.workspaces.iter() {
-                res += &format!("{} packages loaded\n", w.count());
+                res += &format!("{} packages loaded\n", w.n_packages());
            }
        }
        res.push_str("\nanalysis:\n");
diff --git a/crates/ra_lsp_server/tests/heavy_tests/support.rs b/crates/ra_lsp_server/tests/heavy_tests/support.rs
index 5dddbbe17..ba8ee8b06 100644
--- a/crates/ra_lsp_server/tests/heavy_tests/support.rs
+++ b/crates/ra_lsp_server/tests/heavy_tests/support.rs
@@ -22,7 +22,7 @@ use tempfile::TempDir;
 use test_utils::{find_mismatch, parse_fixture};
 use thread_worker::Worker;
-use ra_lsp_server::{main_loop, req, InitializationOptions};
+use ra_lsp_server::{main_loop, req, ServerConfig};
 pub struct Project<'a> {
    fixture: &'a str,
@@ -107,7 +107,7 @@ impl Server {
                        window: None,
                        experimental: None,
                    },
-                    InitializationOptions::default(),
+                    ServerConfig::default(),
                    &msg_receiver,
                    &msg_sender,
                )
diff --git a/crates/ra_mbe/src/subtree_source.rs b/crates/ra_mbe/src/subtree_source.rs
index 6603ff34d..9d6d0133f 100644
--- a/crates/ra_mbe/src/subtree_source.rs
+++ b/crates/ra_mbe/src/subtree_source.rs
@@ -1,6 +1,6 @@
 use ra_parser::{Token, TokenSource};
 use ra_syntax::{classify_literal, SmolStr, SyntaxKind, SyntaxKind::*, T};
-use std::cell::{Cell, RefCell};
+use std::cell::{Cell, Ref, RefCell};
 use tt::buffer::{Cursor, TokenBuffer};
 #[derive(Debug, Clone, Eq, PartialEq)]
@@ -20,8 +20,8 @@ impl<'a> SubtreeTokenSource<'a> {
    // Helper function used in test
    #[cfg(test)]
    pub fn text(&self) -> SmolStr {
-        match self.get(self.curr.1) {
+        match *self.get(self.curr.1) {
-            Some(tt) => tt.text,
+            Some(ref tt) => tt.text.clone(),
            _ => SmolStr::new(""),
        }
    }
@@ -41,44 +41,46 @@ impl<'a> SubtreeTokenSource<'a> {
    }
    fn mk_token(&self, pos: usize) -> Token {
-        match self.get(pos) {
+        match *self.get(pos) {
-            Some(tt) => Token { kind: tt.kind, is_jointed_to_next: tt.is_joint_to_next },
+            Some(ref tt) => Token { kind: tt.kind, is_jointed_to_next: tt.is_joint_to_next },
            None => Token { kind: EOF, is_jointed_to_next: false },
        }
    }
-    fn get(&self, pos: usize) -> Option<TtToken> {
+    fn get(&self, pos: usize) -> Ref<Option<TtToken>> {
-        let mut cached = self.cached.borrow_mut();
+        if pos < self.cached.borrow().len() {
-        if pos < cached.len() {
+            return Ref::map(self.cached.borrow(), |c| &c[pos]);
-            return cached[pos].clone();
        }
-        while pos >= cached.len() {
+        {
-            let cursor = self.cached_cursor.get();
+            let mut cached = self.cached.borrow_mut();
-            if cursor.eof() {
+            while pos >= cached.len() {
-                cached.push(None);
+                let cursor = self.cached_cursor.get();
-                continue;
+                if cursor.eof() {
-            }
+                    cached.push(None);
+                    continue;
-            match cursor.token_tree() {
-                Some(tt::TokenTree::Leaf(leaf)) => {
-                    cached.push(Some(convert_leaf(&leaf)));
-                    self.cached_cursor.set(cursor.bump());
-                }
-                Some(tt::TokenTree::Subtree(subtree)) => {
-                    self.cached_cursor.set(cursor.subtree().unwrap());
-                    cached.push(Some(convert_delim(subtree.delimiter, false)));
                }
-                None => {
-                    if let Some(subtree) = cursor.end() {
+                match cursor.token_tree() {
-                        cached.push(Some(convert_delim(subtree.delimiter, true)));
+                    Some(tt::TokenTree::Leaf(leaf)) => {
+                        cached.push(Some(convert_leaf(&leaf)));
                        self.cached_cursor.set(cursor.bump());
                    }
+                    Some(tt::TokenTree::Subtree(subtree)) => {
+                        self.cached_cursor.set(cursor.subtree().unwrap());
+                        cached.push(Some(convert_delim(subtree.delimiter, false)));
+                    }
+                    None => {
+                        if let Some(subtree) = cursor.end() {
+                            cached.push(Some(convert_delim(subtree.delimiter, true)));
+                            self.cached_cursor.set(cursor.bump());
+                        }
+                    }
                }
            }
        }
-        cached[pos].clone()
+        Ref::map(self.cached.borrow(), |c| &c[pos])
    }
 }
@@ -103,8 +105,8 @@ impl<'a> TokenSource for SubtreeTokenSource<'a> {
    /// Is the current token a specified keyword?
    fn is_keyword(&self, kw: &str) -> bool {
-        match self.get(self.curr.1) {
+        match *self.get(self.curr.1) {
-            Some(t) => t.text == *kw,
+            Some(ref t) => t.text == *kw,
            _ => false,
        }
    }
diff --git a/crates/ra_parser/src/grammar.rs b/crates/ra_parser/src/grammar.rs
index 658034097..beedac457 100644
--- a/crates/ra_parser/src/grammar.rs
+++ b/crates/ra_parser/src/grammar.rs
@@ -287,6 +287,16 @@ fn name_ref(p: &mut Parser) {
    }
 }
+fn name_ref_or_index(p: &mut Parser) {
+    if p.at(IDENT) || p.at(INT_NUMBER) {
+        let m = p.start();
+        p.bump();
+        m.complete(p, NAME_REF);
+    } else {
+        p.err_and_bump("expected identifier");
+    }
+}
 fn error_block(p: &mut Parser, message: &str) {
    assert!(p.at(T!['{']));
    let m = p.start();
diff --git a/crates/ra_parser/src/grammar/expressions.rs b/crates/ra_parser/src/grammar/expressions.rs
index b60a2f68c..742076c1a 100644
--- a/crates/ra_parser/src/grammar/expressions.rs
+++ b/crates/ra_parser/src/grammar/expressions.rs
@@ -489,10 +489,8 @@ fn field_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
    assert!(p.at(T![.]));
    let m = lhs.precede(p);
    p.bump();
-    if p.at(IDENT) {
+    if p.at(IDENT) || p.at(INT_NUMBER) {
-        name_ref(p)
+        name_ref_or_index(p)
-    } else if p.at(INT_NUMBER) {
-        p.bump();
    } else if p.at(FLOAT_NUMBER) {
        // FIXME: How to recover and instead parse INT + T![.]?
        p.bump();
@@ -577,6 +575,7 @@ fn path_expr(p: &mut Parser, r: Restrictions) -> (CompletedMarker, BlockLike) {
 //     S {};
 //     S { x, y: 32, };
 //     S { x, y: 32, ..Default::default() };
+//     TupleStruct { 0: 1 };
 // }
 pub(crate) fn named_field_list(p: &mut Parser) {
    assert!(p.at(T!['{']));
@@ -588,10 +587,10 @@ pub(crate) fn named_field_list(p: &mut Parser) {
            // fn main() {
            //     S { #[cfg(test)] field: 1 }
            // }
-            IDENT | T![#] => {
+            IDENT | INT_NUMBER | T![#] => {
                let m = p.start();
                attributes::outer_attributes(p);
-                name_ref(p);
+                name_ref_or_index(p);
                if p.eat(T![:]) {
                    expr(p);
                }
diff --git a/crates/ra_parser/src/grammar/params.rs b/crates/ra_parser/src/grammar/params.rs
index 723b56343..0b09f1874 100644
--- a/crates/ra_parser/src/grammar/params.rs
+++ b/crates/ra_parser/src/grammar/params.rs
@@ -41,9 +41,20 @@ fn list_(p: &mut Parser, flavor: Flavor) {
    let m = p.start();
    p.bump();
    if flavor.type_required() {
+        // test self_param_outer_attr
+        // fn f(#[must_use] self) {}
+        attributes::outer_attributes(p);
        opt_self_param(p);
    }
-    while !p.at(EOF) && !p.at(ket) && !(flavor.type_required() && p.at(T![...])) {
+    while !p.at(EOF) && !p.at(ket) {
+        // test param_outer_arg
+        // fn f(#[attr1] pat: Type) {}
+        attributes::outer_attributes(p);
+        if flavor.type_required() && p.at(T![...]) {
+            break;
+        }
        if !p.at_ts(VALUE_PARAMETER_FIRST) {
            p.error("expected value parameter");
            break;
diff --git a/crates/ra_parser/src/grammar/type_args.rs b/crates/ra_parser/src/grammar/type_args.rs
index f391b63db..3db08b280 100644
--- a/crates/ra_parser/src/grammar/type_args.rs
+++ b/crates/ra_parser/src/grammar/type_args.rs
@@ -35,6 +35,13 @@ fn type_arg(p: &mut Parser) {
            p.bump();
            m.complete(p, LIFETIME_ARG);
        }
+        // test associated_type_bounds
+        // fn print_all<T: Iterator<Item: Display>>(printables: T) {}
+        IDENT if p.nth(1) == T![:] => {
+            name_ref(p);
+            type_params::bounds(p);
+            m.complete(p, ASSOC_TYPE_ARG);
+        }
        IDENT if p.nth(1) == T![=] => {
            name_ref(p);
            p.bump();
diff --git a/crates/ra_parser/src/parser.rs b/crates/ra_parser/src/parser.rs
index 159ed50df..393586561 100644
--- a/crates/ra_parser/src/parser.rs
+++ b/crates/ra_parser/src/parser.rs
@@ -6,7 +6,7 @@ use crate::{
    event::Event,
    ParseError,
    SyntaxKind::{self, EOF, ERROR, TOMBSTONE},
-    TokenSet, TokenSource, T,
+    Token, TokenSet, TokenSource, T,
 };
 /// `Parser` struct provides the low-level API for
@@ -87,8 +87,9 @@ impl<'t> Parser<'t> {
        let mut i = 0;
        loop {
-            let mut kind = self.token_source.lookahead_nth(i).kind;
+            let token = self.token_source.lookahead_nth(i);
-            if let Some((composited, step)) = self.is_composite(kind, i) {
+            let mut kind = token.kind;
+            if let Some((composited, step)) = self.is_composite(token, i) {
                kind = composited;
                i += step;
            } else {
@@ -250,32 +251,47 @@ impl<'t> Parser<'t> {
    }
    /// helper function for check if it is composite.
-    fn is_composite(&self, kind: SyntaxKind, n: usize) -> Option<(SyntaxKind, usize)> {
+    fn is_composite(&self, first: Token, n: usize) -> Option<(SyntaxKind, usize)> {
        // We assume the dollars will not occuried between
        // mult-byte tokens
-        let first = self.token_source.lookahead_nth(n);
+        let jn1 = first.is_jointed_to_next;
+        if !jn1 && first.kind != T![-] {
+            return None;
+        }
        let second = self.token_source.lookahead_nth(n + 1);
+        if first.kind == T![-] && second.kind == T![>] {
+            return Some((T![->], 2));
+        }
+        if !jn1 {
+            return None;
+        }
+        match (first.kind, second.kind) {
+            (T![:], T![:]) => return Some((T![::], 2)),
+            (T![=], T![=]) => return Some((T![==], 2)),
+            (T![=], T![>]) => return Some((T![=>], 2)),
+            (T![!], T![=]) => return Some((T![!=], 2)),
+            _ => {}
+        }
+        if first.kind != T![.] || second.kind != T![.] {
+            return None;
+        }
        let third = self.token_source.lookahead_nth(n + 2);
-        let jn1 = first.is_jointed_to_next;
-        let la2 = second.kind;
        let jn2 = second.is_jointed_to_next;
        let la3 = third.kind;
-        match kind {
+        if jn2 && la3 == T![.] {
-            T![.] if jn1 && la2 == T![.] && jn2 && la3 == T![.] => Some((T![...], 3)),
+            return Some((T![...], 3));
-            T![.] if jn1 && la2 == T![.] && la3 == T![=] => Some((T![..=], 3)),
+        }
-            T![.] if jn1 && la2 == T![.] => Some((T![..], 2)),
+        if la3 == T![=] {
+            return Some((T![..=], 3));
-            T![:] if jn1 && la2 == T![:] => Some((T![::], 2)),
-            T![=] if jn1 && la2 == T![=] => Some((T![==], 2)),
-            T![=] if jn1 && la2 == T![>] => Some((T![=>], 2)),
-            T![!] if jn1 && la2 == T![=] => Some((T![!=], 2)),
-            T![-] if la2 == T![>] => Some((T![->], 2)),
-            _ => None,
        }
+        return Some((T![..], 2));
    }
    fn eat_dollars(&mut self) {
diff --git a/crates/ra_project_model/Cargo.toml b/crates/ra_project_model/Cargo.toml
index 3545d23c9..4fd6c75ef 100644
--- a/crates/ra_project_model/Cargo.toml
+++ b/crates/ra_project_model/Cargo.toml
@@ -7,7 +7,6 @@ authors = ["rust-analyzer developers"]
 [dependencies]
 log = "0.4.5"
 rustc-hash = "1.0"
-relative-path = "0.4.0"
 cargo_metadata = "0.8.0"
diff --git a/crates/ra_project_model/src/cargo_workspace.rs b/crates/ra_project_model/src/cargo_workspace.rs
index 2b06e9e37..712d8818f 100644
--- a/crates/ra_project_model/src/cargo_workspace.rs
+++ b/crates/ra_project_model/src/cargo_workspace.rs
@@ -167,7 +167,7 @@ impl CargoWorkspace {
        Ok(CargoWorkspace { packages, targets, workspace_root: meta.workspace_root })
    }
-    pub fn packages<'a>(&'a self) -> impl Iterator<Item = Package> + 'a {
+    pub fn packages<'a>(&'a self) -> impl Iterator<Item = Package> + ExactSizeIterator + 'a {
        self.packages.iter().map(|(id, _pkg)| id)
    }
diff --git a/crates/ra_project_model/src/lib.rs b/crates/ra_project_model/src/lib.rs
index 08e5c1c32..55b94b911 100644
--- a/crates/ra_project_model/src/lib.rs
+++ b/crates/ra_project_model/src/lib.rs
@@ -9,14 +9,10 @@ use std::{
    path::{Path, PathBuf},
 };
-use rustc_hash::FxHashMap;
 use ra_db::{CrateGraph, Edition, FileId};
+use rustc_hash::FxHashMap;
 use serde_json::from_reader;
-use relative_path::RelativePath;
 pub use crate::{
    cargo_workspace::{CargoWorkspace, Package, Target, TargetKind},
    json_project::JsonProject,
@@ -34,20 +30,20 @@ pub enum ProjectWorkspace {
    Json { project: JsonProject },
 }
-/// `ProjectRoot` describes a workspace root folder.
+/// `PackageRoot` describes a package root folder.
 /// Which may be an external dependency, or a member of
 /// the current workspace.
 #[derive(Clone)]
-pub struct ProjectRoot {
+pub struct PackageRoot {
    /// Path to the root folder
    path: PathBuf,
    /// Is a member of the current workspace
    is_member: bool,
 }
-impl ProjectRoot {
+impl PackageRoot {
-    pub fn new(path: PathBuf, is_member: bool) -> ProjectRoot {
+    pub fn new(path: PathBuf, is_member: bool) -> PackageRoot {
-        ProjectRoot { path, is_member }
+        PackageRoot { path, is_member }
    }
    pub fn path(&self) -> &PathBuf {
@@ -57,28 +53,6 @@ impl ProjectRoot {
    pub fn is_member(&self) -> bool {
        self.is_member
    }
-    pub fn include_dir(&self, dir_path: &RelativePath) -> bool {
-        const COMMON_IGNORED_DIRS: &[&str] = &["node_modules", "target", ".git"];
-        const EXTERNAL_IGNORED_DIRS: &[&str] = &["examples", "tests", "benches"];
-        let is_ignored = if self.is_member {
-            dir_path.components().any(|c| COMMON_IGNORED_DIRS.contains(&c.as_str()))
-        } else {
-            dir_path.components().any(|c| {
-                let path = c.as_str();
-                COMMON_IGNORED_DIRS.contains(&path) || EXTERNAL_IGNORED_DIRS.contains(&path)
-            })
-        };
-        let hidden = dir_path.components().any(|c| c.as_str().starts_with('.'));
-        !is_ignored && !hidden
-    }
-    pub fn include_file(&self, file_path: &RelativePath) -> bool {
-        file_path.extension() == Some("rs")
-    }
 }
 impl ProjectWorkspace {
@@ -99,38 +73,39 @@ impl ProjectWorkspace {
        }
    }
-    /// Returns the roots for the current ProjectWorkspace
+    /// Returns the roots for the current `ProjectWorkspace`
    /// The return type contains the path and whether or not
    /// the root is a member of the current workspace
-    pub fn to_roots(&self) -> Vec<ProjectRoot> {
+    pub fn to_roots(&self) -> Vec<PackageRoot> {
        match self {
            ProjectWorkspace::Json { project } => {
                let mut roots = Vec::with_capacity(project.roots.len());
                for root in &project.roots {
-                    roots.push(ProjectRoot::new(root.path.clone(), true));
+                    roots.push(PackageRoot::new(root.path.clone(), true));
                }
                roots
            }
            ProjectWorkspace::Cargo { cargo, sysroot } => {
-                let mut roots =
+                let mut roots = Vec::with_capacity(cargo.packages().len() + sysroot.crates().len());
-                    Vec::with_capacity(cargo.packages().count() + sysroot.crates().count());
                for pkg in cargo.packages() {
                    let root = pkg.root(&cargo).to_path_buf();
                    let member = pkg.is_member(&cargo);
-                    roots.push(ProjectRoot::new(root, member));
+                    roots.push(PackageRoot::new(root, member));
                }
                for krate in sysroot.crates() {
-                    roots.push(ProjectRoot::new(krate.root_dir(&sysroot).to_path_buf(), false))
+                    roots.push(PackageRoot::new(krate.root_dir(&sysroot).to_path_buf(), false))
                }
                roots
            }
        }
    }
-    pub fn count(&self) -> usize {
+    pub fn n_packages(&self) -> usize {
        match self {
            ProjectWorkspace::Json { project } => project.crates.len(),
-            ProjectWorkspace::Cargo { cargo, .. } => cargo.packages().count(),
+            ProjectWorkspace::Cargo { cargo, sysroot } => {
+                cargo.packages().len() + sysroot.crates().len()
+            }
        }
    }
diff --git a/crates/ra_project_model/src/sysroot.rs b/crates/ra_project_model/src/sysroot.rs
index 4f6e880dd..3f34d51cc 100644
--- a/crates/ra_project_model/src/sysroot.rs
+++ b/crates/ra_project_model/src/sysroot.rs
@@ -28,7 +28,7 @@ impl Sysroot {
        self.by_name("std")
    }
-    pub fn crates<'a>(&'a self) -> impl Iterator<Item = SysrootCrate> + 'a {
+    pub fn crates<'a>(&'a self) -> impl Iterator<Item = SysrootCrate> + ExactSizeIterator + 'a {
        self.crates.iter().map(|(id, _data)| id)
    }
diff --git a/crates/ra_syntax/Cargo.toml b/crates/ra_syntax/Cargo.toml
index bc1c88070..5f8585878 100644
--- a/crates/ra_syntax/Cargo.toml
+++ b/crates/ra_syntax/Cargo.toml
@@ -8,7 +8,6 @@ description = "Comment and whitespace preserving parser for the Rust langauge"
 repository = "https://github.com/rust-analyzer/rust-analyzer"
 [dependencies]
-unicode-xid = "0.1.0"
 itertools = "0.8.0"
 rowan = "0.6.1"
 ra_rustc_lexer = { version = "0.1.0-pre.2" }
diff --git a/crates/ra_syntax/src/ast.rs b/crates/ra_syntax/src/ast.rs
index c5746d98d..6f0489617 100644
--- a/crates/ra_syntax/src/ast.rs
+++ b/crates/ra_syntax/src/ast.rs
@@ -139,6 +139,52 @@ fn test_doc_comment_preserves_newlines() {
 }
 #[test]
+fn test_doc_comment_single_line_block_strips_suffix() {
+    let file = SourceFile::parse(
+        r#"
+        /** this is mod foo*/
+        mod foo {}
+        "#,
+    )
+    .ok()
+    .unwrap();
+    let module = file.syntax().descendants().find_map(Module::cast).unwrap();
+    assert_eq!("this is mod foo", module.doc_comment_text().unwrap());
+}
+#[test]
+fn test_doc_comment_single_line_block_strips_suffix_whitespace() {
+    let file = SourceFile::parse(
+        r#"
+        /** this is mod foo */
+        mod foo {}
+        "#,
+    )
+    .ok()
+    .unwrap();
+    let module = file.syntax().descendants().find_map(Module::cast).unwrap();
+    assert_eq!("this is mod foo", module.doc_comment_text().unwrap());
+}
+#[test]
+fn test_doc_comment_multi_line_block_strips_suffix() {
+    let file = SourceFile::parse(
+        r#"
+        /**
+        this
+        is
+        mod foo
+        */
+        mod foo {}
+        "#,
+    )
+    .ok()
+    .unwrap();
+    let module = file.syntax().descendants().find_map(Module::cast).unwrap();
+    assert_eq!("        this\n        is\n        mod foo", module.doc_comment_text().unwrap());
+}
+#[test]
 fn test_where_predicates() {
    fn assert_bound(text: &str, bound: Option<TypeBound>) {
        assert_eq!(text, bound.unwrap().syntax().text().to_string());
diff --git a/crates/ra_syntax/src/ast/extensions.rs b/crates/ra_syntax/src/ast/extensions.rs
index d4873b39a..2a59cf653 100644
--- a/crates/ra_syntax/src/ast/extensions.rs
+++ b/crates/ra_syntax/src/ast/extensions.rs
@@ -91,6 +91,7 @@ impl ast::Attr {
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum PathSegmentKind {
    Name(ast::NameRef),
+    Type { type_ref: Option<ast::TypeRef>, trait_ref: Option<ast::PathType> },
    SelfKw,
    SuperKw,
    CrateKw,
@@ -112,6 +113,15 @@ impl ast::PathSegment {
                T![self] => PathSegmentKind::SelfKw,
                T![super] => PathSegmentKind::SuperKw,
                T![crate] => PathSegmentKind::CrateKw,
+                T![<] => {
+                    // <T> or <T as Trait>
+                    // T is any TypeRef, Trait has to be a PathType
+                    let mut type_refs =
+                        self.syntax().children().filter(|node| ast::TypeRef::can_cast(node.kind()));
+                    let type_ref = type_refs.next().and_then(ast::TypeRef::cast);
+                    let trait_ref = type_refs.next().and_then(ast::PathType::cast);
+                    PathSegmentKind::Type { type_ref, trait_ref }
+                }
                _ => return None,
            }
        };
diff --git a/crates/ra_syntax/src/ast/generated.rs b/crates/ra_syntax/src/ast/generated.rs
index da8cf4ae8..f322e1d84 100644
--- a/crates/ra_syntax/src/ast/generated.rs
+++ b/crates/ra_syntax/src/ast/generated.rs
@@ -2013,6 +2013,7 @@ impl AstNode for Param {
 impl ast::TypeAscriptionOwner for Param {}
+impl ast::AttrsOwner for Param {}
 impl Param {
    pub fn pat(&self) -> Option<Pat> {
        super::child_opt(self)
@@ -2667,6 +2668,7 @@ impl AstNode for SelfParam {
 impl ast::TypeAscriptionOwner for SelfParam {}
+impl ast::AttrsOwner for SelfParam {}
 impl SelfParam {}
 // SlicePat
diff --git a/crates/ra_syntax/src/ast/traits.rs b/crates/ra_syntax/src/ast/traits.rs
index 6ed1b5213..1b9a2b20c 100644
--- a/crates/ra_syntax/src/ast/traits.rs
+++ b/crates/ra_syntax/src/ast/traits.rs
@@ -115,8 +115,8 @@ pub trait DocCommentsOwner: AstNode {
    }
    /// Returns the textual content of a doc comment block as a single string.
-    /// That is, strips leading `///` (+ optional 1 character of whitespace)
+    /// That is, strips leading `///` (+ optional 1 character of whitespace),
-    /// and joins lines.
+    /// trailing `*/`, trailing whitespace and then joins the lines.
    fn doc_comment_text(&self) -> Option<String> {
        let mut has_comments = false;
        let docs = self
@@ -136,7 +136,13 @@ pub trait DocCommentsOwner: AstNode {
                        prefix_len
                    };
-                line[pos..].to_owned()
+                let end = if comment.kind().shape.is_block() && line.ends_with("*/") {
+                    line.len() - 2
+                } else {
+                    line.len()
+                };
+                line[pos..end].trim_end().to_owned()
            })
            .join("\n");
diff --git a/crates/ra_syntax/src/grammar.ron b/crates/ra_syntax/src/grammar.ron
index 817dedfbf..f2c20573e 100644
--- a/crates/ra_syntax/src/grammar.ron
+++ b/crates/ra_syntax/src/grammar.ron
@@ -642,12 +642,14 @@ Grammar(
        "SelfParam": (
            traits: [
                "TypeAscriptionOwner",
+                                "AttrsOwner",
            ]
        ),
        "Param": (
            options: [ "Pat" ],
            traits: [
                "TypeAscriptionOwner",
+                                "AttrsOwner",
            ]
        ),
        "UseItem": (
diff --git a/crates/ra_syntax/src/parsing/lexer.rs b/crates/ra_syntax/src/parsing/lexer.rs
index 2a4343b0a..06822ea91 100644
--- a/crates/ra_syntax/src/parsing/lexer.rs
+++ b/crates/ra_syntax/src/parsing/lexer.rs
@@ -12,6 +12,19 @@ pub struct Token {
    pub len: TextUnit,
 }
+fn match_literal_kind(kind: ra_rustc_lexer::LiteralKind) -> SyntaxKind {
+    match kind {
+        ra_rustc_lexer::LiteralKind::Int { .. } => INT_NUMBER,
+        ra_rustc_lexer::LiteralKind::Float { .. } => FLOAT_NUMBER,
+        ra_rustc_lexer::LiteralKind::Char { .. } => CHAR,
+        ra_rustc_lexer::LiteralKind::Byte { .. } => BYTE,
+        ra_rustc_lexer::LiteralKind::Str { .. } => STRING,
+        ra_rustc_lexer::LiteralKind::ByteStr { .. } => BYTE_STRING,
+        ra_rustc_lexer::LiteralKind::RawStr { .. } => RAW_STRING,
+        ra_rustc_lexer::LiteralKind::RawByteStr { .. } => RAW_BYTE_STRING,
+    }
+}
 /// Break a string up into its component tokens
 pub fn tokenize(text: &str) -> Vec<Token> {
    if text.is_empty() {
@@ -53,16 +66,7 @@ pub fn tokenize(text: &str) -> Vec<Token> {
                }
            }
            ra_rustc_lexer::TokenKind::RawIdent => IDENT,
-            ra_rustc_lexer::TokenKind::Literal { kind, .. } => match kind {
+            ra_rustc_lexer::TokenKind::Literal { kind, .. } => match_literal_kind(kind),
-                ra_rustc_lexer::LiteralKind::Int { .. } => INT_NUMBER,
-                ra_rustc_lexer::LiteralKind::Float { .. } => FLOAT_NUMBER,
-                ra_rustc_lexer::LiteralKind::Char { .. } => CHAR,
-                ra_rustc_lexer::LiteralKind::Byte { .. } => BYTE,
-                ra_rustc_lexer::LiteralKind::Str { .. } => STRING,
-                ra_rustc_lexer::LiteralKind::ByteStr { .. } => BYTE_STRING,
-                ra_rustc_lexer::LiteralKind::RawStr { .. } => RAW_STRING,
-                ra_rustc_lexer::LiteralKind::RawByteStr { .. } => RAW_BYTE_STRING,
-            },
            ra_rustc_lexer::TokenKind::Lifetime { .. } => LIFETIME,
            ra_rustc_lexer::TokenKind::Semi => SEMI,
            ra_rustc_lexer::TokenKind::Comma => COMMA,
@@ -131,16 +135,7 @@ pub fn classify_literal(text: &str) -> Option<Token> {
        return None;
    }
    let kind = match t.kind {
-        ra_rustc_lexer::TokenKind::Literal { kind, .. } => match kind {
+        ra_rustc_lexer::TokenKind::Literal { kind, .. } => match_literal_kind(kind),
-            ra_rustc_lexer::LiteralKind::Int { .. } => INT_NUMBER,
-            ra_rustc_lexer::LiteralKind::Float { .. } => FLOAT_NUMBER,
-            ra_rustc_lexer::LiteralKind::Char { .. } => CHAR,
-            ra_rustc_lexer::LiteralKind::Byte { .. } => BYTE,
-            ra_rustc_lexer::LiteralKind::Str { .. } => STRING,
-            ra_rustc_lexer::LiteralKind::ByteStr { .. } => BYTE_STRING,
-            ra_rustc_lexer::LiteralKind::RawStr { .. } => RAW_STRING,
-            ra_rustc_lexer::LiteralKind::RawByteStr { .. } => RAW_BYTE_STRING,
-        },
        _ => return None,
    };
    Some(Token { kind, len: TextUnit::from_usize(t.len) })
diff --git a/crates/ra_syntax/src/validation.rs b/crates/ra_syntax/src/validation.rs
index 1f904434e..2bb3c0a03 100644
--- a/crates/ra_syntax/src/validation.rs
+++ b/crates/ra_syntax/src/validation.rs
@@ -1,13 +1,12 @@
 mod block;
-mod field_expr;
 use ra_rustc_lexer::unescape;
 use crate::{
    algo::visit::{visitor_ctx, VisitorCtx},
-    ast, SyntaxError, SyntaxErrorKind,
+    ast, AstNode, SyntaxError, SyntaxErrorKind,
-    SyntaxKind::{BYTE, BYTE_STRING, CHAR, STRING},
+    SyntaxKind::{BYTE, BYTE_STRING, CHAR, INT_NUMBER, STRING},
-    SyntaxNode, TextUnit, T,
+    SyntaxNode, SyntaxToken, TextUnit, T,
 };
 #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
@@ -101,7 +100,8 @@ pub(crate) fn validate(root: &SyntaxNode) -> Vec<SyntaxError> {
        let _ = visitor_ctx(&mut errors)
            .visit::<ast::Literal, _>(validate_literal)
            .visit::<ast::Block, _>(block::validate_block_node)
-            .visit::<ast::FieldExpr, _>(field_expr::validate_field_expr_node)
+            .visit::<ast::FieldExpr, _>(|it, errors| validate_numeric_name(it.name_ref(), errors))
+            .visit::<ast::NamedField, _>(|it, errors| validate_numeric_name(it.name_ref(), errors))
            .accept(&node);
    }
    errors
@@ -189,3 +189,18 @@ pub(crate) fn validate_block_structure(root: &SyntaxNode) {
        }
    }
 }
+fn validate_numeric_name(name_ref: Option<ast::NameRef>, errors: &mut Vec<SyntaxError>) {
+    if let Some(int_token) = int_token(name_ref) {
+        if int_token.text().chars().any(|c| !c.is_digit(10)) {
+            errors.push(SyntaxError::new(
+                SyntaxErrorKind::InvalidTupleIndexFormat,
+                int_token.text_range(),
+            ));
+        }
+    }
+    fn int_token(name_ref: Option<ast::NameRef>) -> Option<SyntaxToken> {
+        name_ref?.syntax().first_child_or_token()?.into_token().filter(|it| it.kind() == INT_NUMBER)
+    }
+}
diff --git a/crates/ra_syntax/src/validation/field_expr.rs b/crates/ra_syntax/src/validation/field_expr.rs
deleted file mode 100644
index 004f199fd..000000000
--- a/crates/ra_syntax/src/validation/field_expr.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-use crate::{
-    ast::{self, FieldKind},
-    SyntaxError,
-    SyntaxErrorKind::*,
-};
-pub(crate) fn validate_field_expr_node(node: ast::FieldExpr, errors: &mut Vec<SyntaxError>) {
-    if let Some(FieldKind::Index(idx)) = node.field_access() {
-        if idx.text().chars().any(|c| c < '0' || c > '9') {
-            errors.push(SyntaxError::new(InvalidTupleIndexFormat, idx.text_range()));
-        }
-    }
-}
diff --git a/crates/ra_syntax/test_data/parser/inline/err/0010_bad_tuple_index_expr.txt b/crates/ra_syntax/test_data/parser/inline/err/0010_bad_tuple_index_expr.txt
index a21b29c80..465e79e7b 100644
--- a/crates/ra_syntax/test_data/parser/inline/err/0010_bad_tuple_index_expr.txt
+++ b/crates/ra_syntax/test_data/parser/inline/err/0010_bad_tuple_index_expr.txt
@@ -30,7 +30,8 @@ SOURCE_FILE@[0; 47)
                NAME_REF@[25; 26)
                  IDENT@[25; 26) "x"
          DOT@[26; 27) "."
-          INT_NUMBER@[27; 31) "1i32"
+          NAME_REF@[27; 31)
+            INT_NUMBER@[27; 31) "1i32"
        SEMI@[31; 32) ";"
      WHITESPACE@[32; 37) "\n    "
      EXPR_STMT@[37; 44)
@@ -41,11 +42,11 @@ SOURCE_FILE@[0; 47)
                NAME_REF@[37; 38)
                  IDENT@[37; 38) "x"
          DOT@[38; 39) "."
-          INT_NUMBER@[39; 43) "0x01"
+          NAME_REF@[39; 43)
+            INT_NUMBER@[39; 43) "0x01"
        SEMI@[43; 44) ";"
      WHITESPACE@[44; 45) "\n"
      R_CURLY@[45; 46) "}"
  WHITESPACE@[46; 47) "\n"
-error [17; 19): Tuple (struct) field access is only allowed through decimal integers with no underscores or suffix
 error [27; 31): Tuple (struct) field access is only allowed through decimal integers with no underscores or suffix
 error [39; 43): Tuple (struct) field access is only allowed through decimal integers with no underscores or suffix
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0011_field_expr.txt b/crates/ra_syntax/test_data/parser/inline/ok/0011_field_expr.txt
index 78054ec5a..1d2cf2761 100644
--- a/crates/ra_syntax/test_data/parser/inline/ok/0011_field_expr.txt
+++ b/crates/ra_syntax/test_data/parser/inline/ok/0011_field_expr.txt
@@ -32,7 +32,8 @@ SOURCE_FILE@[0; 48)
                  NAME_REF@[26; 27)
                    IDENT@[26; 27) "x"
            DOT@[27; 28) "."
-            INT_NUMBER@[28; 29) "0"
+            NAME_REF@[28; 29)
+              INT_NUMBER@[28; 29) "0"
          DOT@[29; 30) "."
          NAME_REF@[30; 33)
            IDENT@[30; 33) "bar"
@@ -47,7 +48,8 @@ SOURCE_FILE@[0; 48)
                  NAME_REF@[39; 40)
                    IDENT@[39; 40) "x"
            DOT@[40; 41) "."
-            INT_NUMBER@[41; 42) "0"
+            NAME_REF@[41; 42)
+              INT_NUMBER@[41; 42) "0"
          ARG_LIST@[42; 44)
            L_PAREN@[42; 43) "("
            R_PAREN@[43; 44) ")"
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0061_struct_lit.rs b/crates/ra_syntax/test_data/parser/inline/ok/0061_struct_lit.rs
index eb711f68a..6285e5549 100644
--- a/crates/ra_syntax/test_data/parser/inline/ok/0061_struct_lit.rs
+++ b/crates/ra_syntax/test_data/parser/inline/ok/0061_struct_lit.rs
@@ -2,4 +2,5 @@ fn foo() {
    S {};
    S { x, y: 32, };
    S { x, y: 32, ..Default::default() };
+    TupleStruct { 0: 1 };
 }
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0061_struct_lit.txt b/crates/ra_syntax/test_data/parser/inline/ok/0061_struct_lit.txt
index 94d1bfe2e..d06594cae 100644
--- a/crates/ra_syntax/test_data/parser/inline/ok/0061_struct_lit.txt
+++ b/crates/ra_syntax/test_data/parser/inline/ok/0061_struct_lit.txt
@@ -1,5 +1,5 @@
-SOURCE_FILE@[0; 86)
+SOURCE_FILE@[0; 112)
-  FN_DEF@[0; 85)
+  FN_DEF@[0; 111)
    FN_KW@[0; 2) "fn"
    WHITESPACE@[2; 3) " "
    NAME@[3; 6)
@@ -8,7 +8,7 @@ SOURCE_FILE@[0; 86)
      L_PAREN@[6; 7) "("
      R_PAREN@[7; 8) ")"
    WHITESPACE@[8; 9) " "
-    BLOCK@[9; 85)
+    BLOCK@[9; 111)
      L_CURLY@[9; 10) "{"
      WHITESPACE@[10; 15) "\n    "
      EXPR_STMT@[15; 20)
@@ -92,6 +92,27 @@ SOURCE_FILE@[0; 86)
            WHITESPACE@[80; 81) " "
            R_CURLY@[81; 82) "}"
        SEMI@[82; 83) ";"
-      WHITESPACE@[83; 84) "\n"
+      WHITESPACE@[83; 88) "\n    "
-      R_CURLY@[84; 85) "}"
+      EXPR_STMT@[88; 109)
-  WHITESPACE@[85; 86) "\n"
+        STRUCT_LIT@[88; 108)
+          PATH@[88; 99)
+            PATH_SEGMENT@[88; 99)
+              NAME_REF@[88; 99)
+                IDENT@[88; 99) "TupleStruct"
+          WHITESPACE@[99; 100) " "
+          NAMED_FIELD_LIST@[100; 108)
+            L_CURLY@[100; 101) "{"
+            WHITESPACE@[101; 102) " "
+            NAMED_FIELD@[102; 106)
+              NAME_REF@[102; 103)
+                INT_NUMBER@[102; 103) "0"
+              COLON@[103; 104) ":"
+              WHITESPACE@[104; 105) " "
+              LITERAL@[105; 106)
+                INT_NUMBER@[105; 106) "1"
+            WHITESPACE@[106; 107) " "
+            R_CURLY@[107; 108) "}"
+        SEMI@[108; 109) ";"
+      WHITESPACE@[109; 110) "\n"
+      R_CURLY@[110; 111) "}"
+  WHITESPACE@[111; 112) "\n"
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0137_await_expr.txt b/crates/ra_syntax/test_data/parser/inline/ok/0137_await_expr.txt
index 99bd76ace..7adb662de 100644
--- a/crates/ra_syntax/test_data/parser/inline/ok/0137_await_expr.txt
+++ b/crates/ra_syntax/test_data/parser/inline/ok/0137_await_expr.txt
@@ -31,7 +31,8 @@ SOURCE_FILE@[0; 67)
                  NAME_REF@[28; 29)
                    IDENT@[28; 29) "x"
            DOT@[29; 30) "."
-            INT_NUMBER@[30; 31) "0"
+            NAME_REF@[30; 31)
+              INT_NUMBER@[30; 31) "0"
          DOT@[31; 32) "."
          AWAIT_KW@[32; 37) "await"
        SEMI@[37; 38) ";"
@@ -48,7 +49,8 @@ SOURCE_FILE@[0; 67)
                        NAME_REF@[43; 44)
                          IDENT@[43; 44) "x"
                  DOT@[44; 45) "."
-                  INT_NUMBER@[45; 46) "0"
+                  NAME_REF@[45; 46)
+                    INT_NUMBER@[45; 46) "0"
                ARG_LIST@[46; 48)
                  L_PAREN@[46; 47) "("
                  R_PAREN@[47; 48) ")"
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0138_associated_type_bounds.rs b/crates/ra_syntax/test_data/parser/inline/ok/0138_associated_type_bounds.rs
new file mode 100644
index 000000000..eb21a657b
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/inline/ok/0138_associated_type_bounds.rs
@@ -0,0 +1 @@
+fn print_all<T: Iterator<Item: Display>>(printables: T) {}
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0138_associated_type_bounds.txt b/crates/ra_syntax/test_data/parser/inline/ok/0138_associated_type_bounds.txt
new file mode 100644
index 000000000..33e75510d
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/inline/ok/0138_associated_type_bounds.txt
@@ -0,0 +1,55 @@
+SOURCE_FILE@[0; 59)
+  FN_DEF@[0; 58)
+    FN_KW@[0; 2) "fn"
+    WHITESPACE@[2; 3) " "
+    NAME@[3; 12)
+      IDENT@[3; 12) "print_all"
+    TYPE_PARAM_LIST@[12; 40)
+      L_ANGLE@[12; 13) "<"
+      TYPE_PARAM@[13; 39)
+        NAME@[13; 14)
+          IDENT@[13; 14) "T"
+        COLON@[14; 15) ":"
+        WHITESPACE@[15; 16) " "
+        TYPE_BOUND_LIST@[16; 39)
+          TYPE_BOUND@[16; 39)
+            PATH_TYPE@[16; 39)
+              PATH@[16; 39)
+                PATH_SEGMENT@[16; 39)
+                  NAME_REF@[16; 24)
+                    IDENT@[16; 24) "Iterator"
+                  TYPE_ARG_LIST@[24; 39)
+                    L_ANGLE@[24; 25) "<"
+                    ASSOC_TYPE_ARG@[25; 38)
+                      NAME_REF@[25; 29)
+                        IDENT@[25; 29) "Item"
+                      COLON@[29; 30) ":"
+                      WHITESPACE@[30; 31) " "
+                      TYPE_BOUND_LIST@[31; 38)
+                        TYPE_BOUND@[31; 38)
+                          PATH_TYPE@[31; 38)
+                            PATH@[31; 38)
+                              PATH_SEGMENT@[31; 38)
+                                NAME_REF@[31; 38)
+                                  IDENT@[31; 38) "Display"
+                    R_ANGLE@[38; 39) ">"
+      R_ANGLE@[39; 40) ">"
+    PARAM_LIST@[40; 55)
+      L_PAREN@[40; 41) "("
+      PARAM@[41; 54)
+        BIND_PAT@[41; 51)
+          NAME@[41; 51)
+            IDENT@[41; 51) "printables"
+        COLON@[51; 52) ":"
+        WHITESPACE@[52; 53) " "
+        PATH_TYPE@[53; 54)
+          PATH@[53; 54)
+            PATH_SEGMENT@[53; 54)
+              NAME_REF@[53; 54)
+                IDENT@[53; 54) "T"
+      R_PAREN@[54; 55) ")"
+    WHITESPACE@[55; 56) " "
+    BLOCK@[56; 58)
+      L_CURLY@[56; 57) "{"
+      R_CURLY@[57; 58) "}"
+  WHITESPACE@[58; 59) "\n"
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0138_self_param_outer_attr.rs b/crates/ra_syntax/test_data/parser/inline/ok/0138_self_param_outer_attr.rs
new file mode 100644
index 000000000..35155057a
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/inline/ok/0138_self_param_outer_attr.rs
@@ -0,0 +1 @@
+fn f(#[must_use] self) {}
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0138_self_param_outer_attr.txt b/crates/ra_syntax/test_data/parser/inline/ok/0138_self_param_outer_attr.txt
new file mode 100644
index 000000000..49b14e632
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/inline/ok/0138_self_param_outer_attr.txt
@@ -0,0 +1,23 @@
+SOURCE_FILE@[0; 26)
+  FN_DEF@[0; 25)
+    FN_KW@[0; 2) "fn"
+    WHITESPACE@[2; 3) " "
+    NAME@[3; 4)
+      IDENT@[3; 4) "f"
+    PARAM_LIST@[4; 22)
+      L_PAREN@[4; 5) "("
+      ATTR@[5; 16)
+        POUND@[5; 6) "#"
+        TOKEN_TREE@[6; 16)
+          L_BRACK@[6; 7) "["
+          IDENT@[7; 15) "must_use"
+          R_BRACK@[15; 16) "]"
+      WHITESPACE@[16; 17) " "
+      SELF_PARAM@[17; 21)
+        SELF_KW@[17; 21) "self"
+      R_PAREN@[21; 22) ")"
+    WHITESPACE@[22; 23) " "
+    BLOCK@[23; 25)
+      L_CURLY@[23; 24) "{"
+      R_CURLY@[24; 25) "}"
+  WHITESPACE@[25; 26) "\n"
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0139_param_outer_arg.rs b/crates/ra_syntax/test_data/parser/inline/ok/0139_param_outer_arg.rs
new file mode 100644
index 000000000..c238be791
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/inline/ok/0139_param_outer_arg.rs
@@ -0,0 +1 @@
+fn f(#[attr1] pat: Type) {}
diff --git a/crates/ra_syntax/test_data/parser/inline/ok/0139_param_outer_arg.txt b/crates/ra_syntax/test_data/parser/inline/ok/0139_param_outer_arg.txt
new file mode 100644
index 000000000..91c5e5f9a
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/inline/ok/0139_param_outer_arg.txt
@@ -0,0 +1,32 @@
+SOURCE_FILE@[0; 28)
+  FN_DEF@[0; 27)
+    FN_KW@[0; 2) "fn"
+    WHITESPACE@[2; 3) " "
+    NAME@[3; 4)
+      IDENT@[3; 4) "f"
+    PARAM_LIST@[4; 24)
+      L_PAREN@[4; 5) "("
+      ATTR@[5; 13)
+        POUND@[5; 6) "#"
+        TOKEN_TREE@[6; 13)
+          L_BRACK@[6; 7) "["
+          IDENT@[7; 12) "attr1"
+          R_BRACK@[12; 13) "]"
+      WHITESPACE@[13; 14) " "
+      PARAM@[14; 23)
+        BIND_PAT@[14; 17)
+          NAME@[14; 17)
+            IDENT@[14; 17) "pat"
+        COLON@[17; 18) ":"
+        WHITESPACE@[18; 19) " "
+        PATH_TYPE@[19; 23)
+          PATH@[19; 23)
+            PATH_SEGMENT@[19; 23)
+              NAME_REF@[19; 23)
+                IDENT@[19; 23) "Type"
+      R_PAREN@[23; 24) ")"
+    WHITESPACE@[24; 25) " "
+    BLOCK@[25; 27)
+      L_CURLY@[25; 26) "{"
+      R_CURLY@[26; 27) "}"
+  WHITESPACE@[27; 28) "\n"
diff --git a/crates/ra_syntax/test_data/parser/ok/0051_parameter_attrs.rs b/crates/ra_syntax/test_data/parser/ok/0051_parameter_attrs.rs
new file mode 100644
index 000000000..de350d858
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/ok/0051_parameter_attrs.rs
@@ -0,0 +1,21 @@
+fn g1(#[attr1] #[attr2] pat: Type) {}
+fn g2(#[attr1] x: u8) {}
+extern "C" { fn printf(format: *const i8, #[attr] ...) -> i32; }
+fn foo<F: FnMut(#[attr] &mut Foo<'a>)>(){}
+trait Foo {
+    fn bar(#[attr] _: u64, # [attr] mut x: i32);
+}
+impl S {
+     fn f(#[must_use] self) {}
+     fn g1(#[attr] self) {}
+     fn g2(#[attr] &self) {}
+     fn g3<'a>(#[attr] &mut self) {}
+     fn g4<'a>(#[attr] &'a self) {}
+     fn g5<'a>(#[attr] &'a mut self) {}
+     fn c(#[attr] self: Self) {}
+     fn d(#[attr] self: Rc<Self>) {}
+}
+\ No newline at end of file
diff --git a/crates/ra_syntax/test_data/parser/ok/0051_parameter_attrs.txt b/crates/ra_syntax/test_data/parser/ok/0051_parameter_attrs.txt
new file mode 100644
index 000000000..b360f29f4
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/ok/0051_parameter_attrs.txt
@@ -0,0 +1,477 @@
+SOURCE_FILE@[0; 519)
+  FN_DEF@[0; 37)
+    FN_KW@[0; 2) "fn"
+    WHITESPACE@[2; 3) " "
+    NAME@[3; 5)
+      IDENT@[3; 5) "g1"
+    PARAM_LIST@[5; 34)
+      L_PAREN@[5; 6) "("
+      ATTR@[6; 14)
+        POUND@[6; 7) "#"
+        TOKEN_TREE@[7; 14)
+          L_BRACK@[7; 8) "["
+          IDENT@[8; 13) "attr1"
+          R_BRACK@[13; 14) "]"
+      WHITESPACE@[14; 15) " "
+      ATTR@[15; 23)
+        POUND@[15; 16) "#"
+        TOKEN_TREE@[16; 23)
+          L_BRACK@[16; 17) "["
+          IDENT@[17; 22) "attr2"
+          R_BRACK@[22; 23) "]"
+      WHITESPACE@[23; 24) " "
+      PARAM@[24; 33)
+        BIND_PAT@[24; 27)
+          NAME@[24; 27)
+            IDENT@[24; 27) "pat"
+        COLON@[27; 28) ":"
+        WHITESPACE@[28; 29) " "
+        PATH_TYPE@[29; 33)
+          PATH@[29; 33)
+            PATH_SEGMENT@[29; 33)
+              NAME_REF@[29; 33)
+                IDENT@[29; 33) "Type"
+      R_PAREN@[33; 34) ")"
+    WHITESPACE@[34; 35) " "
+    BLOCK@[35; 37)
+      L_CURLY@[35; 36) "{"
+      R_CURLY@[36; 37) "}"
+  WHITESPACE@[37; 38) "\n"
+  FN_DEF@[38; 62)
+    FN_KW@[38; 40) "fn"
+    WHITESPACE@[40; 41) " "
+    NAME@[41; 43)
+      IDENT@[41; 43) "g2"
+    PARAM_LIST@[43; 59)
+      L_PAREN@[43; 44) "("
+      ATTR@[44; 52)
+        POUND@[44; 45) "#"
+        TOKEN_TREE@[45; 52)
+          L_BRACK@[45; 46) "["
+          IDENT@[46; 51) "attr1"
+          R_BRACK@[51; 52) "]"
+      WHITESPACE@[52; 53) " "
+      PARAM@[53; 58)
+        BIND_PAT@[53; 54)
+          NAME@[53; 54)
+            IDENT@[53; 54) "x"
+        COLON@[54; 55) ":"
+        WHITESPACE@[55; 56) " "
+        PATH_TYPE@[56; 58)
+          PATH@[56; 58)
+            PATH_SEGMENT@[56; 58)
+              NAME_REF@[56; 58)
+                IDENT@[56; 58) "u8"
+      R_PAREN@[58; 59) ")"
+    WHITESPACE@[59; 60) " "
+    BLOCK@[60; 62)
+      L_CURLY@[60; 61) "{"
+      R_CURLY@[61; 62) "}"
+  WHITESPACE@[62; 64) "\n\n"
+  EXTERN_BLOCK@[64; 128)
+    ABI@[64; 74)
+      EXTERN_KW@[64; 70) "extern"
+      WHITESPACE@[70; 71) " "
+      STRING@[71; 74) "\"C\""
+    WHITESPACE@[74; 75) " "
+    EXTERN_ITEM_LIST@[75; 128)
+      L_CURLY@[75; 76) "{"
+      WHITESPACE@[76; 77) " "
+      FN_DEF@[77; 126)
+        FN_KW@[77; 79) "fn"
+        WHITESPACE@[79; 80) " "
+        NAME@[80; 86)
+          IDENT@[80; 86) "printf"
+        PARAM_LIST@[86; 118)
+          L_PAREN@[86; 87) "("
+          PARAM@[87; 104)
+            BIND_PAT@[87; 93)
+              NAME@[87; 93)
+                IDENT@[87; 93) "format"
+            COLON@[93; 94) ":"
+            WHITESPACE@[94; 95) " "
+            POINTER_TYPE@[95; 104)
+              STAR@[95; 96) "*"
+              CONST_KW@[96; 101) "const"
+              WHITESPACE@[101; 102) " "
+              PATH_TYPE@[102; 104)
+                PATH@[102; 104)
+                  PATH_SEGMENT@[102; 104)
+                    NAME_REF@[102; 104)
+                      IDENT@[102; 104) "i8"
+          COMMA@[104; 105) ","
+          WHITESPACE@[105; 106) " "
+          ATTR@[106; 113)
+            POUND@[106; 107) "#"
+            TOKEN_TREE@[107; 113)
+              L_BRACK@[107; 108) "["
+              IDENT@[108; 112) "attr"
+              R_BRACK@[112; 113) "]"
+          WHITESPACE@[113; 114) " "
+          DOTDOTDOT@[114; 117) "..."
+          R_PAREN@[117; 118) ")"
+        WHITESPACE@[118; 119) " "
+        RET_TYPE@[119; 125)
+          THIN_ARROW@[119; 121) "->"
+          WHITESPACE@[121; 122) " "
+          PATH_TYPE@[122; 125)
+            PATH@[122; 125)
+              PATH_SEGMENT@[122; 125)
+                NAME_REF@[122; 125)
+                  IDENT@[122; 125) "i32"
+        SEMI@[125; 126) ";"
+      WHITESPACE@[126; 127) " "
+      R_CURLY@[127; 128) "}"
+  WHITESPACE@[128; 130) "\n\n"
+  FN_DEF@[130; 172)
+    FN_KW@[130; 132) "fn"
+    WHITESPACE@[132; 133) " "
+    NAME@[133; 136)
+      IDENT@[133; 136) "foo"
+    TYPE_PARAM_LIST@[136; 168)
+      L_ANGLE@[136; 137) "<"
+      TYPE_PARAM@[137; 167)
+        NAME@[137; 138)
+          IDENT@[137; 138) "F"
+        COLON@[138; 139) ":"
+        WHITESPACE@[139; 140) " "
+        TYPE_BOUND_LIST@[140; 167)
+          TYPE_BOUND@[140; 167)
+            PATH_TYPE@[140; 167)
+              PATH@[140; 167)
+                PATH_SEGMENT@[140; 167)
+                  NAME_REF@[140; 145)
+                    IDENT@[140; 145) "FnMut"
+                  PARAM_LIST@[145; 167)
+                    L_PAREN@[145; 146) "("
+                    ATTR@[146; 153)
+                      POUND@[146; 147) "#"
+                      TOKEN_TREE@[147; 153)
+                        L_BRACK@[147; 148) "["
+                        IDENT@[148; 152) "attr"
+                        R_BRACK@[152; 153) "]"
+                    WHITESPACE@[153; 154) " "
+                    PARAM@[154; 166)
+                      REFERENCE_TYPE@[154; 166)
+                        AMP@[154; 155) "&"
+                        MUT_KW@[155; 158) "mut"
+                        WHITESPACE@[158; 159) " "
+                        PATH_TYPE@[159; 166)
+                          PATH@[159; 166)
+                            PATH_SEGMENT@[159; 166)
+                              NAME_REF@[159; 162)
+                                IDENT@[159; 162) "Foo"
+                              TYPE_ARG_LIST@[162; 166)
+                                L_ANGLE@[162; 163) "<"
+                                LIFETIME_ARG@[163; 165)
+                                  LIFETIME@[163; 165) "\'a"
+                                R_ANGLE@[165; 166) ">"
+                    R_PAREN@[166; 167) ")"
+      R_ANGLE@[167; 168) ">"
+    PARAM_LIST@[168; 170)
+      L_PAREN@[168; 169) "("
+      R_PAREN@[169; 170) ")"
+    BLOCK@[170; 172)
+      L_CURLY@[170; 171) "{"
+      R_CURLY@[171; 172) "}"
+  WHITESPACE@[172; 174) "\n\n"
+  TRAIT_DEF@[174; 236)
+    TRAIT_KW@[174; 179) "trait"
+    WHITESPACE@[179; 180) " "
+    NAME@[180; 183)
+      IDENT@[180; 183) "Foo"
+    WHITESPACE@[183; 184) " "
+    ITEM_LIST@[184; 236)
+      L_CURLY@[184; 185) "{"
+      WHITESPACE@[185; 190) "\n    "
+      FN_DEF@[190; 234)
+        FN_KW@[190; 192) "fn"
+        WHITESPACE@[192; 193) " "
+        NAME@[193; 196)
+          IDENT@[193; 196) "bar"
+        PARAM_LIST@[196; 233)
+          L_PAREN@[196; 197) "("
+          ATTR@[197; 204)
+            POUND@[197; 198) "#"
+            TOKEN_TREE@[198; 204)
+              L_BRACK@[198; 199) "["
+              IDENT@[199; 203) "attr"
+              R_BRACK@[203; 204) "]"
+          WHITESPACE@[204; 205) " "
+          PARAM@[205; 211)
+            PLACEHOLDER_PAT@[205; 206)
+              UNDERSCORE@[205; 206) "_"
+            COLON@[206; 207) ":"
+            WHITESPACE@[207; 208) " "
+            PATH_TYPE@[208; 211)
+              PATH@[208; 211)
+                PATH_SEGMENT@[208; 211)
+                  NAME_REF@[208; 211)
+                    IDENT@[208; 211) "u64"
+          COMMA@[211; 212) ","
+          WHITESPACE@[212; 213) " "
+          ATTR@[213; 221)
+            POUND@[213; 214) "#"
+            WHITESPACE@[214; 215) " "
+            TOKEN_TREE@[215; 221)
+              L_BRACK@[215; 216) "["
+              IDENT@[216; 220) "attr"
+              R_BRACK@[220; 221) "]"
+          WHITESPACE@[221; 222) " "
+          PARAM@[222; 232)
+            BIND_PAT@[222; 227)
+              MUT_KW@[222; 225) "mut"
+              WHITESPACE@[225; 226) " "
+              NAME@[226; 227)
+                IDENT@[226; 227) "x"
+            COLON@[227; 228) ":"
+            WHITESPACE@[228; 229) " "
+            PATH_TYPE@[229; 232)
+              PATH@[229; 232)
+                PATH_SEGMENT@[229; 232)
+                  NAME_REF@[229; 232)
+                    IDENT@[229; 232) "i32"
+          R_PAREN@[232; 233) ")"
+        SEMI@[233; 234) ";"
+      WHITESPACE@[234; 235) "\n"
+      R_CURLY@[235; 236) "}"
+  WHITESPACE@[236; 238) "\n\n"
+  IMPL_BLOCK@[238; 519)
+    IMPL_KW@[238; 242) "impl"
+    WHITESPACE@[242; 243) " "
+    PATH_TYPE@[243; 244)
+      PATH@[243; 244)
+        PATH_SEGMENT@[243; 244)
+          NAME_REF@[243; 244)
+            IDENT@[243; 244) "S"
+    WHITESPACE@[244; 245) " "
+    ITEM_LIST@[245; 519)
+      L_CURLY@[245; 246) "{"
+      WHITESPACE@[246; 252) "\n     "
+      FN_DEF@[252; 277)
+        FN_KW@[252; 254) "fn"
+        WHITESPACE@[254; 255) " "
+        NAME@[255; 256)
+          IDENT@[255; 256) "f"
+        PARAM_LIST@[256; 274)
+          L_PAREN@[256; 257) "("
+          ATTR@[257; 268)
+            POUND@[257; 258) "#"
+            TOKEN_TREE@[258; 268)
+              L_BRACK@[258; 259) "["
+              IDENT@[259; 267) "must_use"
+              R_BRACK@[267; 268) "]"
+          WHITESPACE@[268; 269) " "
+          SELF_PARAM@[269; 273)
+            SELF_KW@[269; 273) "self"
+          R_PAREN@[273; 274) ")"
+        WHITESPACE@[274; 275) " "
+        BLOCK@[275; 277)
+          L_CURLY@[275; 276) "{"
+          R_CURLY@[276; 277) "}"
+      WHITESPACE@[277; 283) "\n     "
+      FN_DEF@[283; 305)
+        FN_KW@[283; 285) "fn"
+        WHITESPACE@[285; 286) " "
+        NAME@[286; 288)
+          IDENT@[286; 288) "g1"
+        PARAM_LIST@[288; 302)
+          L_PAREN@[288; 289) "("
+          ATTR@[289; 296)
+            POUND@[289; 290) "#"
+            TOKEN_TREE@[290; 296)
+              L_BRACK@[290; 291) "["
+              IDENT@[291; 295) "attr"
+              R_BRACK@[295; 296) "]"
+          WHITESPACE@[296; 297) " "
+          SELF_PARAM@[297; 301)
+            SELF_KW@[297; 301) "self"
+          R_PAREN@[301; 302) ")"
+        WHITESPACE@[302; 303) " "
+        BLOCK@[303; 305)
+          L_CURLY@[303; 304) "{"
+          R_CURLY@[304; 305) "}"
+      WHITESPACE@[305; 311) "\n     "
+      FN_DEF@[311; 334)
+        FN_KW@[311; 313) "fn"
+        WHITESPACE@[313; 314) " "
+        NAME@[314; 316)
+          IDENT@[314; 316) "g2"
+        PARAM_LIST@[316; 331)
+          L_PAREN@[316; 317) "("
+          ATTR@[317; 324)
+            POUND@[317; 318) "#"
+            TOKEN_TREE@[318; 324)
+              L_BRACK@[318; 319) "["
+              IDENT@[319; 323) "attr"
+              R_BRACK@[323; 324) "]"
+          WHITESPACE@[324; 325) " "
+          SELF_PARAM@[325; 330)
+            AMP@[325; 326) "&"
+            SELF_KW@[326; 330) "self"
+          R_PAREN@[330; 331) ")"
+        WHITESPACE@[331; 332) " "
+        BLOCK@[332; 334)
+          L_CURLY@[332; 333) "{"
+          R_CURLY@[333; 334) "}"
+      WHITESPACE@[334; 340) "\n     "
+      FN_DEF@[340; 371)
+        FN_KW@[340; 342) "fn"
+        WHITESPACE@[342; 343) " "
+        NAME@[343; 345)
+          IDENT@[343; 345) "g3"
+        TYPE_PARAM_LIST@[345; 349)
+          L_ANGLE@[345; 346) "<"
+          LIFETIME_PARAM@[346; 348)
+            LIFETIME@[346; 348) "\'a"
+          R_ANGLE@[348; 349) ">"
+        PARAM_LIST@[349; 368)
+          L_PAREN@[349; 350) "("
+          ATTR@[350; 357)
+            POUND@[350; 351) "#"
+            TOKEN_TREE@[351; 357)
+              L_BRACK@[351; 352) "["
+              IDENT@[352; 356) "attr"
+              R_BRACK@[356; 357) "]"
+          WHITESPACE@[357; 358) " "
+          SELF_PARAM@[358; 367)
+            AMP@[358; 359) "&"
+            MUT_KW@[359; 362) "mut"
+            WHITESPACE@[362; 363) " "
+            SELF_KW@[363; 367) "self"
+          R_PAREN@[367; 368) ")"
+        WHITESPACE@[368; 369) " "
+        BLOCK@[369; 371)
+          L_CURLY@[369; 370) "{"
+          R_CURLY@[370; 371) "}"
+      WHITESPACE@[371; 377) "\n     "
+      FN_DEF@[377; 407)
+        FN_KW@[377; 379) "fn"
+        WHITESPACE@[379; 380) " "
+        NAME@[380; 382)
+          IDENT@[380; 382) "g4"
+        TYPE_PARAM_LIST@[382; 386)
+          L_ANGLE@[382; 383) "<"
+          LIFETIME_PARAM@[383; 385)
+            LIFETIME@[383; 385) "\'a"
+          R_ANGLE@[385; 386) ">"
+        PARAM_LIST@[386; 404)
+          L_PAREN@[386; 387) "("
+          ATTR@[387; 394)
+            POUND@[387; 388) "#"
+            TOKEN_TREE@[388; 394)
+              L_BRACK@[388; 389) "["
+              IDENT@[389; 393) "attr"
+              R_BRACK@[393; 394) "]"
+          WHITESPACE@[394; 395) " "
+          SELF_PARAM@[395; 403)
+            AMP@[395; 396) "&"
+            LIFETIME@[396; 398) "\'a"
+            WHITESPACE@[398; 399) " "
+            SELF_KW@[399; 403) "self"
+          R_PAREN@[403; 404) ")"
+        WHITESPACE@[404; 405) " "
+        BLOCK@[405; 407)
+          L_CURLY@[405; 406) "{"
+          R_CURLY@[406; 407) "}"
+      WHITESPACE@[407; 413) "\n     "
+      FN_DEF@[413; 447)
+        FN_KW@[413; 415) "fn"
+        WHITESPACE@[415; 416) " "
+        NAME@[416; 418)
+          IDENT@[416; 418) "g5"
+        TYPE_PARAM_LIST@[418; 422)
+          L_ANGLE@[418; 419) "<"
+          LIFETIME_PARAM@[419; 421)
+            LIFETIME@[419; 421) "\'a"
+          R_ANGLE@[421; 422) ">"
+        PARAM_LIST@[422; 444)
+          L_PAREN@[422; 423) "("
+          ATTR@[423; 430)
+            POUND@[423; 424) "#"
+            TOKEN_TREE@[424; 430)
+              L_BRACK@[424; 425) "["
+              IDENT@[425; 429) "attr"
+              R_BRACK@[429; 430) "]"
+          WHITESPACE@[430; 431) " "
+          SELF_PARAM@[431; 443)
+            AMP@[431; 432) "&"
+            LIFETIME@[432; 434) "\'a"
+            WHITESPACE@[434; 435) " "
+            MUT_KW@[435; 438) "mut"
+            WHITESPACE@[438; 439) " "
+            SELF_KW@[439; 443) "self"
+          R_PAREN@[443; 444) ")"
+        WHITESPACE@[444; 445) " "
+        BLOCK@[445; 447)
+          L_CURLY@[445; 446) "{"
+          R_CURLY@[446; 447) "}"
+      WHITESPACE@[447; 453) "\n     "
+      FN_DEF@[453; 480)
+        FN_KW@[453; 455) "fn"
+        WHITESPACE@[455; 456) " "
+        NAME@[456; 457)
+          IDENT@[456; 457) "c"
+        PARAM_LIST@[457; 477)
+          L_PAREN@[457; 458) "("
+          ATTR@[458; 465)
+            POUND@[458; 459) "#"
+            TOKEN_TREE@[459; 465)
+              L_BRACK@[459; 460) "["
+              IDENT@[460; 464) "attr"
+              R_BRACK@[464; 465) "]"
+          WHITESPACE@[465; 466) " "
+          SELF_PARAM@[466; 476)
+            SELF_KW@[466; 470) "self"
+            COLON@[470; 471) ":"
+            WHITESPACE@[471; 472) " "
+            PATH_TYPE@[472; 476)
+              PATH@[472; 476)
+                PATH_SEGMENT@[472; 476)
+                  NAME_REF@[472; 476)
+                    IDENT@[472; 476) "Self"
+          R_PAREN@[476; 477) ")"
+        WHITESPACE@[477; 478) " "
+        BLOCK@[478; 480)
+          L_CURLY@[478; 479) "{"
+          R_CURLY@[479; 480) "}"
+      WHITESPACE@[480; 486) "\n     "
+      FN_DEF@[486; 517)
+        FN_KW@[486; 488) "fn"
+        WHITESPACE@[488; 489) " "
+        NAME@[489; 490)
+          IDENT@[489; 490) "d"
+        PARAM_LIST@[490; 514)
+          L_PAREN@[490; 491) "("
+          ATTR@[491; 498)
+            POUND@[491; 492) "#"
+            TOKEN_TREE@[492; 498)
+              L_BRACK@[492; 493) "["
+              IDENT@[493; 497) "attr"
+              R_BRACK@[497; 498) "]"
+          WHITESPACE@[498; 499) " "
+          SELF_PARAM@[499; 513)
+            SELF_KW@[499; 503) "self"
+            COLON@[503; 504) ":"
+            WHITESPACE@[504; 505) " "
+            PATH_TYPE@[505; 513)
+              PATH@[505; 513)
+                PATH_SEGMENT@[505; 513)
+                  NAME_REF@[505; 507)
+                    IDENT@[505; 507) "Rc"
+                  TYPE_ARG_LIST@[507; 513)
+                    L_ANGLE@[507; 508) "<"
+                    TYPE_ARG@[508; 512)
+                      PATH_TYPE@[508; 512)
+                        PATH@[508; 512)
+                          PATH_SEGMENT@[508; 512)
+                            NAME_REF@[508; 512)
+                              IDENT@[508; 512) "Self"
+                    R_ANGLE@[512; 513) ">"
+          R_PAREN@[513; 514) ")"
+        WHITESPACE@[514; 515) " "
+        BLOCK@[515; 517)
+          L_CURLY@[515; 516) "{"
+          R_CURLY@[516; 517) "}"
+      WHITESPACE@[517; 518) "\n"
+      R_CURLY@[518; 519) "}"
diff --git a/crates/ra_tools/src/main.rs b/crates/ra_tools/src/main.rs
index 4fcb2adeb..54d96e446 100644
--- a/crates/ra_tools/src/main.rs
+++ b/crates/ra_tools/src/main.rs
@@ -63,12 +63,12 @@ fn install(opts: InstallOpt) -> Result<()> {
    if cfg!(target_os = "macos") {
        fix_path_for_mac()?
    }
-    if let Some(client) = opts.client {
-        install_client(client)?;
-    }
    if let Some(server) = opts.server {
        install_server(server)?;
    }
+    if let Some(client) = opts.client {
+        install_client(client)?;
+    }
    Ok(())
 }
diff --git a/crates/ra_vfs_glob/Cargo.toml b/crates/ra_vfs_glob/Cargo.toml
new file mode 100644
index 000000000..0390d7da1
--- /dev/null
+++ b/crates/ra_vfs_glob/Cargo.toml
@@ -0,0 +1,9 @@
+[package]
+edition = "2018"
+name = "ra_vfs_glob"
+version = "0.1.0"
+authors = ["rust-analyzer developers"]
+[dependencies]
+ra_vfs = "0.2.0"
+globset = "0.4.4"
diff --git a/crates/ra_vfs_glob/src/lib.rs b/crates/ra_vfs_glob/src/lib.rs
new file mode 100644
index 000000000..12401d75a
--- /dev/null
+++ b/crates/ra_vfs_glob/src/lib.rs
@@ -0,0 +1,94 @@
+//! `ra_vfs_glob` crate implements exclusion rules for vfs.
+//!
+//! By default, we include only `.rs` files, and skip some know offenders like
+//! `/target` or `/node_modules` altogether.
+//!
+//! It's also possible to add custom exclusion globs.
+use globset::{GlobSet, GlobSetBuilder};
+use ra_vfs::{Filter, RelativePath};
+pub use globset::{Glob, GlobBuilder};
+const ALWAYS_IGNORED: &[&str] = &["target/**", "**/node_modules/**", "**/.git/**"];
+const IGNORED_FOR_NON_MEMBERS: &[&str] = &["examples/**", "tests/**", "benches/**"];
+pub struct RustPackageFilterBuilder {
+    is_member: bool,
+    exclude: GlobSetBuilder,
+}
+impl Default for RustPackageFilterBuilder {
+    fn default() -> RustPackageFilterBuilder {
+        RustPackageFilterBuilder { is_member: false, exclude: GlobSetBuilder::new() }
+    }
+}
+impl RustPackageFilterBuilder {
+    pub fn set_member(mut self, is_member: bool) -> RustPackageFilterBuilder {
+        self.is_member = is_member;
+        self
+    }
+    pub fn exclude(mut self, glob: Glob) -> RustPackageFilterBuilder {
+        self.exclude.add(glob);
+        self
+    }
+    pub fn into_vfs_filter(self) -> Box<dyn Filter> {
+        let RustPackageFilterBuilder { is_member, mut exclude } = self;
+        for &glob in ALWAYS_IGNORED {
+            exclude.add(Glob::new(glob).unwrap());
+        }
+        if !is_member {
+            for &glob in IGNORED_FOR_NON_MEMBERS {
+                exclude.add(Glob::new(glob).unwrap());
+            }
+        }
+        Box::new(RustPackageFilter { exclude: exclude.build().unwrap() })
+    }
+}
+struct RustPackageFilter {
+    exclude: GlobSet,
+}
+impl Filter for RustPackageFilter {
+    fn include_dir(&self, dir_path: &RelativePath) -> bool {
+        !self.exclude.is_match(dir_path.as_str())
+    }
+    fn include_file(&self, file_path: &RelativePath) -> bool {
+        file_path.extension() == Some("rs")
+    }
+}
+#[test]
+fn test_globs() {
+    let filter = RustPackageFilterBuilder::default().set_member(true).into_vfs_filter();
+    assert!(filter.include_dir(RelativePath::new("src/tests")));
+    assert!(filter.include_dir(RelativePath::new("src/target")));
+    assert!(filter.include_dir(RelativePath::new("tests")));
+    assert!(filter.include_dir(RelativePath::new("benches")));
+    assert!(!filter.include_dir(RelativePath::new("target")));
+    assert!(!filter.include_dir(RelativePath::new("src/foo/.git")));
+    assert!(!filter.include_dir(RelativePath::new("foo/node_modules")));
+    let filter = RustPackageFilterBuilder::default().set_member(false).into_vfs_filter();
+    assert!(filter.include_dir(RelativePath::new("src/tests")));
+    assert!(filter.include_dir(RelativePath::new("src/target")));
+    assert!(!filter.include_dir(RelativePath::new("target")));
+    assert!(!filter.include_dir(RelativePath::new("src/foo/.git")));
+    assert!(!filter.include_dir(RelativePath::new("foo/node_modules")));
+    assert!(!filter.include_dir(RelativePath::new("tests")));
+    assert!(!filter.include_dir(RelativePath::new("benches")));
+    let filter = RustPackageFilterBuilder::default()
+        .set_member(true)
+        .exclude(Glob::new("src/llvm-project/**").unwrap())
+        .into_vfs_filter();
+    assert!(!filter.include_dir(RelativePath::new("src/llvm-project/clang")));
+}