43 files changed, 1129 insertions, 635 deletions
diff --git a/crates/ra_assists/src/assists/add_import.rs b/crates/ra_assists/src/assists/add_import.rs
index 363ade016..f81b4184a 100644
--- a/crates/ra_assists/src/assists/add_import.rs
+++ b/crates/ra_assists/src/assists/add_import.rs
@@ -578,7 +578,7 @@ fn apply_auto_import(
 fn collect_hir_path_segments(path: &hir::Path) -> Option<Vec<SmolStr>> {
    let mut ps = Vec::<SmolStr>::with_capacity(10);
-    match path.kind {
+    match path.kind() {
        hir::PathKind::Abs => ps.push("".into()),
        hir::PathKind::Crate => ps.push("crate".into()),
        hir::PathKind::Plain => {}
@@ -586,9 +586,7 @@ fn collect_hir_path_segments(path: &hir::Path) -> Option<Vec<SmolStr>> {
        hir::PathKind::Super => ps.push("super".into()),
        hir::PathKind::Type(_) | hir::PathKind::DollarCrate(_) => return None,
    }
-    for s in path.segments.iter() {
+    ps.extend(path.segments().iter().map(|it| it.name.to_string().into()));
-        ps.push(s.name.to_string().into());
-    }
    Some(ps)
 }
diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index c705d1630..7850ea9a7 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -17,7 +17,7 @@ use hir_def::{
 };
 use hir_expand::{
    diagnostics::DiagnosticSink,
-    name::{self, AsName},
+    name::{name, AsName},
    MacroDefId,
 };
 use hir_ty::{
@@ -723,7 +723,7 @@ impl Local {
    }
    pub fn is_self(self, db: &impl HirDatabase) -> bool {
-        self.name(db) == Some(name::SELF_PARAM)
+        self.name(db) == Some(name![self])
    }
    pub fn is_mut(self, db: &impl HirDatabase) -> bool {
diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs
index 8b9562722..2e52a1f5c 100644
--- a/crates/ra_hir/src/lib.rs
+++ b/crates/ra_hir/src/lib.rs
@@ -54,7 +54,7 @@ pub use hir_def::{
    builtin_type::BuiltinType,
    docs::Documentation,
    nameres::ModuleSource,
-    path::{Path, PathKind},
+    path::{ModPath, Path, PathKind},
    type_ref::Mutability,
 };
 pub use hir_expand::{
diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs
index d3cc5c423..d326169b3 100644
--- a/crates/ra_hir/src/source_binder.rs
+++ b/crates/ra_hir/src/source_binder.rs
@@ -15,7 +15,7 @@ use hir_def::{
    },
    expr::{ExprId, PatId},
    nameres::ModuleSource,
-    path::known,
+    path::path,
    resolver::{self, resolver_for_scope, HasResolver, Resolver, TypeNs, ValueNs},
    AssocItemId, DefWithBodyId,
 };
@@ -258,7 +258,7 @@ impl SourceAnalyzer {
    ) -> Option<MacroDef> {
        let hygiene = Hygiene::new(db, macro_call.file_id);
        let path = macro_call.value.path().and_then(|ast| Path::from_src(ast, &hygiene))?;
-        self.resolver.resolve_path_as_macro(db, &path).map(|it| it.into())
+        self.resolver.resolve_path_as_macro(db, path.mod_path()).map(|it| it.into())
    }
    pub fn resolve_hir_path(
@@ -266,40 +266,42 @@ impl SourceAnalyzer {
        db: &impl HirDatabase,
        path: &crate::Path,
    ) -> Option<PathResolution> {
-        let types = self.resolver.resolve_path_in_type_ns_fully(db, &path).map(|ty| match ty {
+        let types =
-            TypeNs::SelfType(it) => PathResolution::SelfType(it.into()),
+            self.resolver.resolve_path_in_type_ns_fully(db, path.mod_path()).map(|ty| match ty {
-            TypeNs::GenericParam(id) => PathResolution::TypeParam(TypeParam { id }),
+                TypeNs::SelfType(it) => PathResolution::SelfType(it.into()),
-            TypeNs::AdtSelfType(it) | TypeNs::AdtId(it) => {
+                TypeNs::GenericParam(id) => PathResolution::TypeParam(TypeParam { id }),
-                PathResolution::Def(Adt::from(it).into())
+                TypeNs::AdtSelfType(it) | TypeNs::AdtId(it) => {
-            }
+                    PathResolution::Def(Adt::from(it).into())
-            TypeNs::EnumVariantId(it) => PathResolution::Def(EnumVariant::from(it).into()),
-            TypeNs::TypeAliasId(it) => PathResolution::Def(TypeAlias::from(it).into()),
-            TypeNs::BuiltinType(it) => PathResolution::Def(it.into()),
-            TypeNs::TraitId(it) => PathResolution::Def(Trait::from(it).into()),
-        });
-        let values = self.resolver.resolve_path_in_value_ns_fully(db, &path).and_then(|val| {
-            let res = match val {
-                ValueNs::LocalBinding(pat_id) => {
-                    let var = Local { parent: self.body_owner?, pat_id };
-                    PathResolution::Local(var)
                }
-                ValueNs::FunctionId(it) => PathResolution::Def(Function::from(it).into()),
+                TypeNs::EnumVariantId(it) => PathResolution::Def(EnumVariant::from(it).into()),
-                ValueNs::ConstId(it) => PathResolution::Def(Const::from(it).into()),
+                TypeNs::TypeAliasId(it) => PathResolution::Def(TypeAlias::from(it).into()),
-                ValueNs::StaticId(it) => PathResolution::Def(Static::from(it).into()),
+                TypeNs::BuiltinType(it) => PathResolution::Def(it.into()),
-                ValueNs::StructId(it) => PathResolution::Def(Struct::from(it).into()),
+                TypeNs::TraitId(it) => PathResolution::Def(Trait::from(it).into()),
-                ValueNs::EnumVariantId(it) => PathResolution::Def(EnumVariant::from(it).into()),
+            });
-            };
+        let values =
-            Some(res)
+            self.resolver.resolve_path_in_value_ns_fully(db, path.mod_path()).and_then(|val| {
-        });
+                let res = match val {
+                    ValueNs::LocalBinding(pat_id) => {
+                        let var = Local { parent: self.body_owner?, pat_id };
+                        PathResolution::Local(var)
+                    }
+                    ValueNs::FunctionId(it) => PathResolution::Def(Function::from(it).into()),
+                    ValueNs::ConstId(it) => PathResolution::Def(Const::from(it).into()),
+                    ValueNs::StaticId(it) => PathResolution::Def(Static::from(it).into()),
+                    ValueNs::StructId(it) => PathResolution::Def(Struct::from(it).into()),
+                    ValueNs::EnumVariantId(it) => PathResolution::Def(EnumVariant::from(it).into()),
+                };
+                Some(res)
+            });
        let items = self
            .resolver
-            .resolve_module_path_in_items(db, &path)
+            .resolve_module_path_in_items(db, path.mod_path())
            .take_types()
            .map(|it| PathResolution::Def(it.into()));
        types.or(values).or(items).or_else(|| {
            self.resolver
-                .resolve_path_as_macro(db, &path)
+                .resolve_path_as_macro(db, path.mod_path())
                .map(|def| PathResolution::Macro(def.into()))
        })
    }
@@ -418,7 +420,7 @@ impl SourceAnalyzer {
    /// 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: Type) -> bool {
-        let std_future_path = known::std_future_future();
+        let std_future_path = path![std::future::Future];
        let std_future_trait = match self.resolver.resolve_known_trait(db, &std_future_path) {
            Some(it) => it.into(),
diff --git a/crates/ra_hir_def/src/attr.rs b/crates/ra_hir_def/src/attr.rs
index 5bf82e191..9efa4970c 100644
--- a/crates/ra_hir_def/src/attr.rs
+++ b/crates/ra_hir_def/src/attr.rs
@@ -12,7 +12,7 @@ use ra_syntax::{
 use tt::Subtree;
 use crate::{
-    db::DefDatabase, path::Path, src::HasChildSource, src::HasSource, AdtId, AttrDefId, Lookup,
+    db::DefDatabase, path::ModPath, src::HasChildSource, src::HasSource, AdtId, AttrDefId, Lookup,
 };
 #[derive(Default, Debug, Clone, PartialEq, Eq)]
@@ -94,7 +94,7 @@ impl Attrs {
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Attr {
-    pub(crate) path: Path,
+    pub(crate) path: ModPath,
    pub(crate) input: Option<AttrInput>,
 }
@@ -106,7 +106,7 @@ pub enum AttrInput {
 impl Attr {
    fn from_src(ast: ast::Attr, hygiene: &Hygiene) -> Option<Attr> {
-        let path = Path::from_src(ast.path()?, hygiene)?;
+        let path = ModPath::from_src(ast.path()?, hygiene)?;
        let input = match ast.input() {
            None => None,
            Some(ast::AttrInput::Literal(lit)) => {
diff --git a/crates/ra_hir_def/src/body.rs b/crates/ra_hir_def/src/body.rs
index b3bc336cf..7787cb87f 100644
--- a/crates/ra_hir_def/src/body.rs
+++ b/crates/ra_hir_def/src/body.rs
@@ -83,7 +83,7 @@ impl Expander {
    fn resolve_path_as_macro(&self, db: &impl DefDatabase, path: &Path) -> Option<MacroDefId> {
        self.crate_def_map
-            .resolve_path(db, self.module.local_id, path, BuiltinShadowMode::Other)
+            .resolve_path(db, self.module.local_id, path.mod_path(), BuiltinShadowMode::Other)
            .0
            .take_macros()
    }
diff --git a/crates/ra_hir_def/src/body/lower.rs b/crates/ra_hir_def/src/body/lower.rs
index cc068ff94..61193b4d8 100644
--- a/crates/ra_hir_def/src/body/lower.rs
+++ b/crates/ra_hir_def/src/body/lower.rs
@@ -2,7 +2,7 @@
 //! representation.
 use either::Either;
-use hir_expand::name::{self, AsName, Name};
+use hir_expand::name::{name, AsName, Name};
 use ra_arena::Arena;
 use ra_syntax::{
    ast::{
@@ -68,7 +68,7 @@ where
                let ptr = AstPtr::new(&self_param);
                let param_pat = self.alloc_pat(
                    Pat::Bind {
-                        name: name::SELF_PARAM,
+                        name: name![self],
                        mode: BindingAnnotation::Unannotated,
                        subpat: None,
                    },
diff --git a/crates/ra_hir_def/src/builtin_type.rs b/crates/ra_hir_def/src/builtin_type.rs
index 5e8157144..d14901a9b 100644
--- a/crates/ra_hir_def/src/builtin_type.rs
+++ b/crates/ra_hir_def/src/builtin_type.rs
@@ -5,7 +5,7 @@
 use std::fmt;
-use hir_expand::name::{self, Name};
+use hir_expand::name::{name, Name};
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
 pub enum Signedness {
@@ -52,26 +52,26 @@ pub enum BuiltinType {
 impl BuiltinType {
    #[rustfmt::skip]
    pub const ALL: &'static [(Name, BuiltinType)] = &[
-        (name::CHAR, BuiltinType::Char),
+        (name![char], BuiltinType::Char),
-        (name::BOOL, BuiltinType::Bool),
+        (name![bool], BuiltinType::Bool),
-        (name::STR,  BuiltinType::Str ),
+        (name![str],  BuiltinType::Str),
-        (name::ISIZE, BuiltinType::Int(BuiltinInt::ISIZE)),
+        (name![isize], BuiltinType::Int(BuiltinInt::ISIZE)),
-        (name::I8,    BuiltinType::Int(BuiltinInt::I8)),
+        (name![i8],    BuiltinType::Int(BuiltinInt::I8)),
-        (name::I16,   BuiltinType::Int(BuiltinInt::I16)),
+        (name![i16],   BuiltinType::Int(BuiltinInt::I16)),
-        (name::I32,   BuiltinType::Int(BuiltinInt::I32)),
+        (name![i32],   BuiltinType::Int(BuiltinInt::I32)),
-        (name::I64,   BuiltinType::Int(BuiltinInt::I64)),
+        (name![i64],   BuiltinType::Int(BuiltinInt::I64)),
-        (name::I128,  BuiltinType::Int(BuiltinInt::I128)),
+        (name![i128],  BuiltinType::Int(BuiltinInt::I128)),
-        (name::USIZE, BuiltinType::Int(BuiltinInt::USIZE)),
+        (name![usize], BuiltinType::Int(BuiltinInt::USIZE)),
-        (name::U8,    BuiltinType::Int(BuiltinInt::U8)),
+        (name![u8],    BuiltinType::Int(BuiltinInt::U8)),
-        (name::U16,   BuiltinType::Int(BuiltinInt::U16)),
+        (name![u16],   BuiltinType::Int(BuiltinInt::U16)),
-        (name::U32,   BuiltinType::Int(BuiltinInt::U32)),
+        (name![u32],   BuiltinType::Int(BuiltinInt::U32)),
-        (name::U64,   BuiltinType::Int(BuiltinInt::U64)),
+        (name![u64],   BuiltinType::Int(BuiltinInt::U64)),
-        (name::U128,  BuiltinType::Int(BuiltinInt::U128)),
+        (name![u128],  BuiltinType::Int(BuiltinInt::U128)),
-        (name::F32, BuiltinType::Float(BuiltinFloat::F32)),
+        (name![f32], BuiltinType::Float(BuiltinFloat::F32)),
-        (name::F64, BuiltinType::Float(BuiltinFloat::F64)),
+        (name![f64], BuiltinType::Float(BuiltinFloat::F64)),
    ];
 }
diff --git a/crates/ra_hir_def/src/data.rs b/crates/ra_hir_def/src/data.rs
index b2dac183e..4f4ef57cc 100644
--- a/crates/ra_hir_def/src/data.rs
+++ b/crates/ra_hir_def/src/data.rs
@@ -3,7 +3,7 @@
 use std::sync::Arc;
 use hir_expand::{
-    name::{self, AsName, Name},
+    name::{name, AsName, Name},
    AstId,
 };
 use ra_syntax::ast::{self, NameOwner, TypeAscriptionOwner};
@@ -37,7 +37,7 @@ impl FunctionData {
                let self_type = if let Some(type_ref) = self_param.ascribed_type() {
                    TypeRef::from_ast(type_ref)
                } else {
-                    let self_type = TypeRef::Path(name::SELF_TYPE.into());
+                    let self_type = TypeRef::Path(name![Self].into());
                    match self_param.kind() {
                        ast::SelfParamKind::Owned => self_type,
                        ast::SelfParamKind::Ref => {
diff --git a/crates/ra_hir_def/src/generics.rs b/crates/ra_hir_def/src/generics.rs
index e502dd798..e9c28c730 100644
--- a/crates/ra_hir_def/src/generics.rs
+++ b/crates/ra_hir_def/src/generics.rs
@@ -6,7 +6,7 @@ use std::sync::Arc;
 use either::Either;
 use hir_expand::{
-    name::{self, AsName, Name},
+    name::{name, AsName, Name},
    InFile,
 };
 use ra_arena::{map::ArenaMap, Arena};
@@ -90,11 +90,11 @@ impl GenericParams {
                // traits get the Self type as an implicit first type parameter
                let self_param_id =
-                    generics.types.alloc(TypeParamData { name: name::SELF_TYPE, default: None });
+                    generics.types.alloc(TypeParamData { name: name![Self], default: None });
                sm.insert(self_param_id, Either::Left(src.value.clone()));
                // add super traits as bounds on Self
                // i.e., trait Foo: Bar is equivalent to trait Foo where Self: Bar
-                let self_param = TypeRef::Path(name::SELF_TYPE.into());
+                let self_param = TypeRef::Path(name![Self].into());
                generics.fill_bounds(&src.value, self_param);
                generics.fill(&mut sm, &src.value);
diff --git a/crates/ra_hir_def/src/nameres.rs b/crates/ra_hir_def/src/nameres.rs
index bd237a7b3..9aae7e48e 100644
--- a/crates/ra_hir_def/src/nameres.rs
+++ b/crates/ra_hir_def/src/nameres.rs
@@ -74,7 +74,7 @@ use crate::{
    builtin_type::BuiltinType,
    db::DefDatabase,
    nameres::{diagnostics::DefDiagnostic, path_resolution::ResolveMode},
-    path::Path,
+    path::ModPath,
    per_ns::PerNs,
    AstId, FunctionId, ImplId, LocalImportId, LocalModuleId, ModuleDefId, ModuleId, TraitId,
 };
@@ -329,7 +329,7 @@ impl CrateDefMap {
        &self,
        db: &impl DefDatabase,
        original_module: LocalModuleId,
-        path: &Path,
+        path: &ModPath,
        shadow: BuiltinShadowMode,
    ) -> (PerNs, Option<usize>) {
        let res =
diff --git a/crates/ra_hir_def/src/nameres/collector.rs b/crates/ra_hir_def/src/nameres/collector.rs
index 04aadead1..912a073ea 100644
--- a/crates/ra_hir_def/src/nameres/collector.rs
+++ b/crates/ra_hir_def/src/nameres/collector.rs
@@ -6,7 +6,7 @@
 use hir_expand::{
    builtin_derive::find_builtin_derive,
    builtin_macro::find_builtin_macro,
-    name::{self, AsName, Name},
+    name::{name, AsName, Name},
    HirFileId, MacroCallId, MacroCallKind, MacroDefId, MacroDefKind,
 };
 use ra_cfg::CfgOptions;
@@ -22,7 +22,7 @@ use crate::{
        diagnostics::DefDiagnostic, mod_resolution::ModDir, path_resolution::ReachedFixedPoint,
        raw, BuiltinShadowMode, CrateDefMap, ModuleData, ModuleOrigin, Resolution, ResolveMode,
    },
-    path::{Path, PathKind},
+    path::{ModPath, PathKind},
    per_ns::PerNs,
    AdtId, AstId, ConstLoc, ContainerId, EnumLoc, EnumVariantId, FunctionLoc, ImplLoc, Intern,
    LocalImportId, LocalModuleId, ModuleDefId, ModuleId, StaticLoc, StructLoc, TraitLoc,
@@ -101,7 +101,7 @@ struct ImportDirective {
 struct MacroDirective {
    module_id: LocalModuleId,
    ast_id: AstId<ast::MacroCall>,
-    path: Path,
+    path: ModPath,
    legacy: Option<MacroCallId>,
 }
@@ -113,7 +113,7 @@ struct DefCollector<'a, DB> {
    unresolved_imports: Vec<ImportDirective>,
    resolved_imports: Vec<ImportDirective>,
    unexpanded_macros: Vec<MacroDirective>,
-    unexpanded_attribute_macros: Vec<(LocalModuleId, AstId<ast::ModuleItem>, Path)>,
+    unexpanded_attribute_macros: Vec<(LocalModuleId, AstId<ast::ModuleItem>, ModPath)>,
    mod_dirs: FxHashMap<LocalModuleId, ModDir>,
    cfg_options: &'a CfgOptions,
 }
@@ -428,7 +428,7 @@ where
        } else {
            match import.path.segments.last() {
                Some(last_segment) => {
-                    let name = import.alias.clone().unwrap_or_else(|| last_segment.name.clone());
+                    let name = import.alias.clone().unwrap_or_else(|| last_segment.clone());
                    log::debug!("resolved import {:?} ({:?}) to {:?}", name, import, def);
                    // extern crates in the crate root are special-cased to insert entries into the extern prelude: rust-lang/rust#54658
@@ -565,7 +565,7 @@ where
        res
    }
-    fn resolve_attribute_macro(&self, path: &Path) -> Option<MacroDefId> {
+    fn resolve_attribute_macro(&self, path: &ModPath) -> Option<MacroDefId> {
        // FIXME this is currently super hacky, just enough to support the
        // built-in derives
        if let Some(name) = path.as_ident() {
@@ -829,7 +829,7 @@ where
                    tt::TokenTree::Leaf(tt::Leaf::Punct(_)) => continue, // , is ok
                    _ => continue, // anything else would be an error (which we currently ignore)
                };
-                let path = Path::from_tt_ident(ident);
+                let path = ModPath::from_tt_ident(ident);
                let ast_id = AstId::new(self.file_id, def.kind.ast_id());
                self.def_collector.unexpanded_attribute_macros.push((self.module_id, ast_id, path));
@@ -917,8 +917,8 @@ where
    }
 }
-fn is_macro_rules(path: &Path) -> bool {
+fn is_macro_rules(path: &ModPath) -> bool {
-    path.as_ident() == Some(&name::MACRO_RULES)
+    path.as_ident() == Some(&name![macro_rules])
 }
 #[cfg(test)]
diff --git a/crates/ra_hir_def/src/nameres/path_resolution.rs b/crates/ra_hir_def/src/nameres/path_resolution.rs
index aab4b1dd9..4a249e7e7 100644
--- a/crates/ra_hir_def/src/nameres/path_resolution.rs
+++ b/crates/ra_hir_def/src/nameres/path_resolution.rs
@@ -17,7 +17,7 @@ use test_utils::tested_by;
 use crate::{
    db::DefDatabase,
    nameres::{BuiltinShadowMode, CrateDefMap},
-    path::{Path, PathKind},
+    path::{ModPath, PathKind},
    per_ns::PerNs,
    AdtId, CrateId, EnumVariantId, LocalModuleId, ModuleDefId, ModuleId,
 };
@@ -69,7 +69,7 @@ impl CrateDefMap {
        db: &impl DefDatabase,
        mode: ResolveMode,
        original_module: LocalModuleId,
-        path: &Path,
+        path: &ModPath,
        shadow: BuiltinShadowMode,
    ) -> ResolvePathResult {
        // if it is not the last segment, we prefer the module to the builtin
@@ -113,7 +113,7 @@ impl CrateDefMap {
                    None => return ResolvePathResult::empty(ReachedFixedPoint::Yes),
                };
                log::debug!("resolving {:?} in crate root (+ extern prelude)", segment);
-                self.resolve_name_in_crate_root_or_extern_prelude(&segment.name, prefer_module(idx))
+                self.resolve_name_in_crate_root_or_extern_prelude(&segment, prefer_module(idx))
            }
            PathKind::Plain => {
                let (idx, segment) = match segments.next() {
@@ -121,7 +121,7 @@ impl CrateDefMap {
                    None => return ResolvePathResult::empty(ReachedFixedPoint::Yes),
                };
                log::debug!("resolving {:?} in module", segment);
-                self.resolve_name_in_module(db, original_module, &segment.name, prefer_module(idx))
+                self.resolve_name_in_module(db, original_module, &segment, prefer_module(idx))
            }
            PathKind::Super => {
                if let Some(p) = self.modules[original_module].parent {
@@ -137,7 +137,7 @@ impl CrateDefMap {
                    Some((_, segment)) => segment,
                    None => return ResolvePathResult::empty(ReachedFixedPoint::Yes),
                };
-                if let Some(def) = self.extern_prelude.get(&segment.name) {
+                if let Some(def) = self.extern_prelude.get(&segment) {
                    log::debug!("absolute path {:?} resolved to crate {:?}", path, def);
                    PerNs::types(*def)
                } else {
@@ -168,8 +168,10 @@ impl CrateDefMap {
            curr_per_ns = match curr {
                ModuleDefId::ModuleId(module) => {
                    if module.krate != self.krate {
-                        let path =
+                        let path = ModPath {
-                            Path { segments: path.segments[i..].to_vec(), kind: PathKind::Self_ };
+                            segments: path.segments[i..].to_vec(),
+                            kind: PathKind::Self_,
+                        };
                        log::debug!("resolving {:?} in other crate", path);
                        let defp_map = db.crate_def_map(module.krate);
                        let (def, s) = defp_map.resolve_path(db, module.local_id, &path, shadow);
@@ -182,10 +184,10 @@ impl CrateDefMap {
                    }
                    // Since it is a qualified path here, it should not contains legacy macros
-                    match self[module.local_id].scope.get(&segment.name, prefer_module(i)) {
+                    match self[module.local_id].scope.get(&segment, prefer_module(i)) {
                        Some(res) => res.def,
                        _ => {
-                            log::debug!("path segment {:?} not found", segment.name);
+                            log::debug!("path segment {:?} not found", segment);
                            return ResolvePathResult::empty(ReachedFixedPoint::No);
                        }
                    }
@@ -194,7 +196,7 @@ impl CrateDefMap {
                    // enum variant
                    tested_by!(can_import_enum_variant);
                    let enum_data = db.enum_data(e);
-                    match enum_data.variant(&segment.name) {
+                    match enum_data.variant(&segment) {
                        Some(local_id) => {
                            let variant = EnumVariantId { parent: e, local_id };
                            PerNs::both(variant.into(), variant.into())
@@ -214,7 +216,7 @@ impl CrateDefMap {
                    // (`Struct::method`), or some other kind of associated item
                    log::debug!(
                        "path segment {:?} resolved to non-module {:?}, but is not last",
-                        segment.name,
+                        segment,
                        curr,
                    );
diff --git a/crates/ra_hir_def/src/nameres/raw.rs b/crates/ra_hir_def/src/nameres/raw.rs
index a2821e1c3..ecb4d7c03 100644
--- a/crates/ra_hir_def/src/nameres/raw.rs
+++ b/crates/ra_hir_def/src/nameres/raw.rs
@@ -22,7 +22,7 @@ use ra_syntax::{
 use test_utils::tested_by;
 use crate::{
-    attr::Attrs, db::DefDatabase, path::Path, trace::Trace, FileAstId, HirFileId, InFile,
+    attr::Attrs, db::DefDatabase, path::ModPath, trace::Trace, FileAstId, HirFileId, InFile,
    LocalImportId,
 };
@@ -154,7 +154,7 @@ pub(super) enum ModuleData {
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct ImportData {
-    pub(super) path: Path,
+    pub(super) path: ModPath,
    pub(super) alias: Option<Name>,
    pub(super) is_glob: bool,
    pub(super) is_prelude: bool,
@@ -206,7 +206,7 @@ impl_arena_id!(Macro);
 #[derive(Debug, PartialEq, Eq)]
 pub(super) struct MacroData {
    pub(super) ast_id: FileAstId<ast::MacroCall>,
-    pub(super) path: Path,
+    pub(super) path: ModPath,
    pub(super) name: Option<Name>,
    pub(super) export: bool,
    pub(super) builtin: bool,
@@ -327,7 +327,7 @@ impl RawItemsCollector {
        let attrs = self.parse_attrs(&use_item);
        let mut buf = Vec::new();
-        Path::expand_use_item(
+        ModPath::expand_use_item(
            InFile { value: use_item, file_id: self.file_id },
            &self.hygiene,
            |path, use_tree, is_glob, alias| {
@@ -353,7 +353,7 @@ impl RawItemsCollector {
        extern_crate: ast::ExternCrateItem,
    ) {
        if let Some(name_ref) = extern_crate.name_ref() {
-            let path = Path::from_name_ref(&name_ref);
+            let path = ModPath::from_name_ref(&name_ref);
            let alias = extern_crate.alias().and_then(|a| a.name()).map(|it| it.as_name());
            let attrs = self.parse_attrs(&extern_crate);
            // FIXME: cfg_attr
@@ -377,7 +377,7 @@ impl RawItemsCollector {
    fn add_macro(&mut self, current_module: Option<Module>, m: ast::MacroCall) {
        let attrs = self.parse_attrs(&m);
-        let path = match m.path().and_then(|path| Path::from_src(path, &self.hygiene)) {
+        let path = match m.path().and_then(|path| ModPath::from_src(path, &self.hygiene)) {
            Some(it) => it,
            _ => return,
        };
diff --git a/crates/ra_hir_def/src/path.rs b/crates/ra_hir_def/src/path.rs
index 50f0cad94..20d6d98ea 100644
--- a/crates/ra_hir_def/src/path.rs
+++ b/crates/ra_hir_def/src/path.rs
@@ -1,31 +1,78 @@
 //! A desugared representation of paths like `crate::foo` or `<Type as Trait>::bar`.
-mod lower_use;
+mod lower;
 use std::{iter, sync::Arc};
-use either::Either;
 use hir_expand::{
    hygiene::Hygiene,
-    name::{self, AsName, Name},
+    name::{AsName, Name},
 };
 use ra_db::CrateId;
-use ra_syntax::{
+use ra_syntax::ast;
-    ast::{self, TypeAscriptionOwner},
-    AstNode,
-};
 use crate::{type_ref::TypeRef, InFile};
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Path {
+pub struct ModPath {
    pub kind: PathKind,
-    pub segments: Vec<PathSegment>,
+    pub segments: Vec<Name>,
+}
+impl ModPath {
+    pub fn from_src(path: ast::Path, hygiene: &Hygiene) -> Option<ModPath> {
+        lower::lower_path(path, hygiene).map(|it| it.mod_path)
+    }
+    pub fn from_simple_segments(
+        kind: PathKind,
+        segments: impl IntoIterator<Item = Name>,
+    ) -> ModPath {
+        let segments = segments.into_iter().collect::<Vec<_>>();
+        ModPath { kind, segments }
+    }
+    pub(crate) fn from_name_ref(name_ref: &ast::NameRef) -> ModPath {
+        name_ref.as_name().into()
+    }
+    /// Converts an `tt::Ident` into a single-identifier `Path`.
+    pub(crate) fn from_tt_ident(ident: &tt::Ident) -> ModPath {
+        ident.as_name().into()
+    }
+    /// Calls `cb` with all paths, represented by this use item.
+    pub(crate) fn expand_use_item(
+        item_src: InFile<ast::UseItem>,
+        hygiene: &Hygiene,
+        mut cb: impl FnMut(ModPath, &ast::UseTree, /* is_glob */ bool, Option<Name>),
+    ) {
+        if let Some(tree) = item_src.value.use_tree() {
+            lower::lower_use_tree(None, tree, hygiene, &mut cb);
+        }
+    }
+    pub fn is_ident(&self) -> bool {
+        self.kind == PathKind::Plain && self.segments.len() == 1
+    }
+    pub fn is_self(&self) -> bool {
+        self.kind == PathKind::Self_ && self.segments.is_empty()
+    }
+    /// If this path is a single identifier, like `foo`, return its name.
+    pub fn as_ident(&self) -> Option<&Name> {
+        if self.kind != PathKind::Plain || self.segments.len() > 1 {
+            return None;
+        }
+        self.segments.first()
+    }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct PathSegment {
+pub struct Path {
-    pub name: Name,
+    mod_path: ModPath,
-    pub args_and_bindings: Option<Arc<GenericArgs>>,
+    /// Invariant: the same len as self.path.segments
+    generic_args: Vec<Option<Arc<GenericArgs>>>,
 }
 /// Generic arguments to a path segment (e.g. the `i32` in `Option<i32>`). This
@@ -65,300 +112,162 @@ pub enum PathKind {
 }
 impl Path {
-    /// Calls `cb` with all paths, represented by this use item.
-    pub(crate) fn expand_use_item(
-        item_src: InFile<ast::UseItem>,
-        hygiene: &Hygiene,
-        mut cb: impl FnMut(Path, &ast::UseTree, bool, Option<Name>),
-    ) {
-        if let Some(tree) = item_src.value.use_tree() {
-            lower_use::lower_use_tree(None, tree, hygiene, &mut cb);
-        }
-    }
-    pub(crate) fn from_simple_segments(
-        kind: PathKind,
-        segments: impl IntoIterator<Item = Name>,
-    ) -> Path {
-        Path {
-            kind,
-            segments: segments
-                .into_iter()
-                .map(|name| PathSegment { name, args_and_bindings: None })
-                .collect(),
-        }
-    }
    /// Converts an `ast::Path` to `Path`. Works with use trees.
    /// DEPRECATED: It does not handle `$crate` from macro call.
    pub fn from_ast(path: ast::Path) -> Option<Path> {
-        Path::from_src(path, &Hygiene::new_unhygienic())
+        lower::lower_path(path, &Hygiene::new_unhygienic())
    }
    /// Converts an `ast::Path` to `Path`. Works with use trees.
    /// It correctly handles `$crate` based path from macro call.
-    pub fn from_src(mut path: ast::Path, hygiene: &Hygiene) -> Option<Path> {
+    pub fn from_src(path: ast::Path, hygiene: &Hygiene) -> Option<Path> {
-        let mut kind = PathKind::Plain;
+        lower::lower_path(path, hygiene)
-        let mut segments = Vec::new();
-        loop {
-            let segment = path.segment()?;
-            if segment.has_colon_colon() {
-                kind = PathKind::Abs;
-            }
-            match segment.kind()? {
-                ast::PathSegmentKind::Name(name_ref) => {
-                    // FIXME: this should just return name
-                    match hygiene.name_ref_to_name(name_ref) {
-                        Either::Left(name) => {
-                            let args = segment
-                                .type_arg_list()
-                                .and_then(GenericArgs::from_ast)
-                                .or_else(|| {
-                                    GenericArgs::from_fn_like_path_ast(
-                                        segment.param_list(),
-                                        segment.ret_type(),
-                                    )
-                                })
-                                .map(Arc::new);
-                            let segment = PathSegment { name, args_and_bindings: args };
-                            segments.push(segment);
-                        }
-                        Either::Right(crate_id) => {
-                            kind = PathKind::DollarCrate(crate_id);
-                            break;
-                        }
-                    }
-                }
-                ast::PathSegmentKind::Type { type_ref, trait_ref } => {
-                    assert!(path.qualifier().is_none()); // this can only occur at the first segment
-                    let self_type = TypeRef::from_ast(type_ref?);
-                    match trait_ref {
-                        // <T>::foo
-                        None => {
-                            kind = PathKind::Type(Box::new(self_type));
-                        }
-                        // <T as Trait<A>>::Foo desugars to Trait<Self=T, A>::Foo
-                        Some(trait_ref) => {
-                            let path = Path::from_src(trait_ref.path()?, hygiene)?;
-                            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 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;
-                }
-                ast::PathSegmentKind::SelfKw => {
-                    kind = PathKind::Self_;
-                    break;
-                }
-                ast::PathSegmentKind::SuperKw => {
-                    kind = PathKind::Super;
-                    break;
-                }
-            }
-            path = match qualifier(&path) {
-                Some(it) => it,
-                None => break,
-            };
-        }
-        segments.reverse();
-        return Some(Path { kind, segments });
-        fn qualifier(path: &ast::Path) -> Option<ast::Path> {
-            if let Some(q) = path.qualifier() {
-                return Some(q);
-            }
-            // FIXME: this bottom up traversal is not too precise.
-            // Should we handle do a top-down analysis, recording results?
-            let use_tree_list = path.syntax().ancestors().find_map(ast::UseTreeList::cast)?;
-            let use_tree = use_tree_list.parent_use_tree();
-            use_tree.path()
-        }
    }
    /// Converts an `ast::NameRef` into a single-identifier `Path`.
    pub(crate) fn from_name_ref(name_ref: &ast::NameRef) -> Path {
-        name_ref.as_name().into()
+        Path { mod_path: name_ref.as_name().into(), generic_args: vec![None] }
-    }
-    /// Converts an `tt::Ident` into a single-identifier `Path`.
-    pub(crate) fn from_tt_ident(ident: &tt::Ident) -> Path {
-        ident.as_name().into()
-    }
-    /// `true` is this path is a single identifier, like `foo`
-    pub fn is_ident(&self) -> bool {
-        self.kind == PathKind::Plain && self.segments.len() == 1
    }
    /// `true` if this path is just a standalone `self`
    pub fn is_self(&self) -> bool {
-        self.kind == PathKind::Self_ && self.segments.is_empty()
+        self.mod_path.is_self()
    }
-    /// If this path is a single identifier, like `foo`, return its name.
+    pub fn kind(&self) -> &PathKind {
-    pub fn as_ident(&self) -> Option<&Name> {
+        &self.mod_path.kind
-        if self.kind != PathKind::Plain || self.segments.len() > 1 {
-            return None;
-        }
-        self.segments.first().map(|s| &s.name)
    }
-    pub fn expand_macro_expr(&self) -> Option<Name> {
+    pub fn segments(&self) -> PathSegments<'_> {
-        self.as_ident().and_then(|name| Some(name.clone()))
+        PathSegments {
-    }
+            segments: self.mod_path.segments.as_slice(),
+            generic_args: self.generic_args.as_slice(),
-    pub fn is_type_relative(&self) -> bool {
-        match self.kind {
-            PathKind::Type(_) => true,
-            _ => false,
        }
    }
-}
-impl GenericArgs {
+    pub fn mod_path(&self) -> &ModPath {
-    pub(crate) fn from_ast(node: ast::TypeArgList) -> Option<GenericArgs> {
+        &self.mod_path
-        let mut args = Vec::new();
-        for type_arg in node.type_args() {
-            let type_ref = TypeRef::from_ast_opt(type_arg.type_ref());
-            args.push(GenericArg::Type(type_ref));
-        }
-        // lifetimes ignored for now
-        let mut bindings = Vec::new();
-        for assoc_type_arg in node.assoc_type_args() {
-            if let Some(name_ref) = assoc_type_arg.name_ref() {
-                let name = name_ref.as_name();
-                let type_ref = TypeRef::from_ast_opt(assoc_type_arg.type_ref());
-                bindings.push((name, type_ref));
-            }
-        }
-        if args.is_empty() && bindings.is_empty() {
-            None
-        } else {
-            Some(GenericArgs { args, has_self_type: false, bindings })
-        }
    }
-    /// Collect `GenericArgs` from the parts of a fn-like path, i.e. `Fn(X, Y)
+    pub fn qualifier(&self) -> Option<Path> {
-    /// -> Z` (which desugars to `Fn<(X, Y), Output=Z>`).
+        if self.mod_path.is_ident() {
-    pub(crate) fn from_fn_like_path_ast(
+            return None;
-        params: Option<ast::ParamList>,
-        ret_type: Option<ast::RetType>,
-    ) -> Option<GenericArgs> {
-        let mut args = Vec::new();
-        let mut bindings = Vec::new();
-        if let Some(params) = params {
-            let mut param_types = Vec::new();
-            for param in params.params() {
-                let type_ref = TypeRef::from_ast_opt(param.ascribed_type());
-                param_types.push(type_ref);
-            }
-            let arg = GenericArg::Type(TypeRef::Tuple(param_types));
-            args.push(arg);
-        }
-        if let Some(ret_type) = ret_type {
-            let type_ref = TypeRef::from_ast_opt(ret_type.type_ref());
-            bindings.push((name::OUTPUT_TYPE, type_ref))
-        }
-        if args.is_empty() && bindings.is_empty() {
-            None
-        } else {
-            Some(GenericArgs { args, has_self_type: false, bindings })
        }
-    }
+        let res = Path {
+            mod_path: ModPath {
-    pub(crate) fn empty() -> GenericArgs {
+                kind: self.mod_path.kind.clone(),
-        GenericArgs { args: Vec::new(), has_self_type: false, bindings: Vec::new() }
+                segments: self.mod_path.segments[..self.mod_path.segments.len() - 1].to_vec(),
+            },
+            generic_args: self.generic_args[..self.generic_args.len() - 1].to_vec(),
+        };
+        Some(res)
    }
 }
-impl From<Name> for Path {
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-    fn from(name: Name) -> Path {
+pub struct PathSegment<'a> {
-        Path::from_simple_segments(PathKind::Plain, iter::once(name))
+    pub name: &'a Name,
-    }
+    pub args_and_bindings: Option<&'a GenericArgs>,
 }
-pub mod known {
+pub struct PathSegments<'a> {
-    use hir_expand::name;
+    segments: &'a [Name],
+    generic_args: &'a [Option<Arc<GenericArgs>>],
-    use super::{Path, PathKind};
+}
-    pub fn std_iter_into_iterator() -> Path {
+impl<'a> PathSegments<'a> {
-        Path::from_simple_segments(
+    pub const EMPTY: PathSegments<'static> = PathSegments { segments: &[], generic_args: &[] };
-            PathKind::Abs,
+    pub fn is_empty(&self) -> bool {
-            vec![name::STD, name::ITER, name::INTO_ITERATOR_TYPE],
+        self.len() == 0
-        )
    }
+    pub fn len(&self) -> usize {
-    pub fn std_ops_try() -> Path {
+        self.segments.len()
-        Path::from_simple_segments(PathKind::Abs, vec![name::STD, name::OPS, name::TRY_TYPE])
    }
+    pub fn first(&self) -> Option<PathSegment<'a>> {
-    pub fn std_ops_range() -> Path {
+        self.get(0)
-        Path::from_simple_segments(PathKind::Abs, vec![name::STD, name::OPS, name::RANGE_TYPE])
    }
+    pub fn last(&self) -> Option<PathSegment<'a>> {
-    pub fn std_ops_range_from() -> Path {
+        self.get(self.len().checked_sub(1)?)
-        Path::from_simple_segments(PathKind::Abs, vec![name::STD, name::OPS, name::RANGE_FROM_TYPE])
    }
+    pub fn get(&self, idx: usize) -> Option<PathSegment<'a>> {
-    pub fn std_ops_range_full() -> Path {
+        assert_eq!(self.segments.len(), self.generic_args.len());
-        Path::from_simple_segments(PathKind::Abs, vec![name::STD, name::OPS, name::RANGE_FULL_TYPE])
+        let res = PathSegment {
+            name: self.segments.get(idx)?,
+            args_and_bindings: self.generic_args.get(idx).unwrap().as_ref().map(|it| &**it),
+        };
+        Some(res)
    }
+    pub fn skip(&self, len: usize) -> PathSegments<'a> {
-    pub fn std_ops_range_inclusive() -> Path {
+        assert_eq!(self.segments.len(), self.generic_args.len());
-        Path::from_simple_segments(
+        PathSegments { segments: &self.segments[len..], generic_args: &self.generic_args[len..] }
-            PathKind::Abs,
-            vec![name::STD, name::OPS, name::RANGE_INCLUSIVE_TYPE],
-        )
    }
+    pub fn take(&self, len: usize) -> PathSegments<'a> {
-    pub fn std_ops_range_to() -> Path {
+        assert_eq!(self.segments.len(), self.generic_args.len());
-        Path::from_simple_segments(PathKind::Abs, vec![name::STD, name::OPS, name::RANGE_TO_TYPE])
+        PathSegments { segments: &self.segments[..len], generic_args: &self.generic_args[..len] }
    }
+    pub fn iter(&self) -> impl Iterator<Item = PathSegment<'a>> {
-    pub fn std_ops_range_to_inclusive() -> Path {
+        self.segments.iter().zip(self.generic_args.iter()).map(|(name, args)| PathSegment {
-        Path::from_simple_segments(
+            name,
-            PathKind::Abs,
+            args_and_bindings: args.as_ref().map(|it| &**it),
-            vec![name::STD, name::OPS, name::RANGE_TO_INCLUSIVE_TYPE],
+        })
-        )
    }
+}
-    pub fn std_ops_neg() -> Path {
+impl GenericArgs {
-        Path::from_simple_segments(PathKind::Abs, vec![name::STD, name::OPS, name::NEG_TYPE])
+    pub(crate) fn from_ast(node: ast::TypeArgList) -> Option<GenericArgs> {
+        lower::lower_generic_args(node)
    }
-    pub fn std_ops_not() -> Path {
+    pub(crate) fn empty() -> GenericArgs {
-        Path::from_simple_segments(PathKind::Abs, vec![name::STD, name::OPS, name::NOT_TYPE])
+        GenericArgs { args: Vec::new(), has_self_type: false, bindings: Vec::new() }
    }
+}
-    pub fn std_result_result() -> Path {
+impl From<Name> for Path {
-        Path::from_simple_segments(PathKind::Abs, vec![name::STD, name::RESULT, name::RESULT_TYPE])
+    fn from(name: Name) -> Path {
+        Path {
+            mod_path: ModPath::from_simple_segments(PathKind::Plain, iter::once(name)),
+            generic_args: vec![None],
+        }
    }
+}
-    pub fn std_future_future() -> Path {
+impl From<Name> for ModPath {
-        Path::from_simple_segments(PathKind::Abs, vec![name::STD, name::FUTURE, name::FUTURE_TYPE])
+    fn from(name: Name) -> ModPath {
+        ModPath::from_simple_segments(PathKind::Plain, iter::once(name))
    }
+}
-    pub fn std_boxed_box() -> Path {
+pub use hir_expand::name as __name;
-        Path::from_simple_segments(PathKind::Abs, vec![name::STD, name::BOXED, name::BOX_TYPE])
-    }
+#[macro_export]
+macro_rules! __known_path {
+    (std::iter::IntoIterator) => {};
+    (std::result::Result) => {};
+    (std::ops::Range) => {};
+    (std::ops::RangeFrom) => {};
+    (std::ops::RangeFull) => {};
+    (std::ops::RangeTo) => {};
+    (std::ops::RangeToInclusive) => {};
+    (std::ops::RangeInclusive) => {};
+    (std::boxed::Box) => {};
+    (std::future::Future) => {};
+    (std::ops::Try) => {};
+    (std::ops::Neg) => {};
+    (std::ops::Not) => {};
+    ($path:path) => {
+        compile_error!("Please register your known path in the path module")
+    };
 }
+#[macro_export]
+macro_rules! __path {
+    ($start:ident $(:: $seg:ident)*) => ({
+        $crate::__known_path!($start $(:: $seg)*);
+        $crate::path::ModPath::from_simple_segments($crate::path::PathKind::Abs, vec![
+            $crate::path::__name![$start], $($crate::path::__name![$seg],)*
+        ])
+    });
+}
+pub use crate::__path as path;
diff --git a/crates/ra_hir_def/src/path/lower.rs b/crates/ra_hir_def/src/path/lower.rs
new file mode 100644
index 000000000..a2e995198
--- /dev/null
+++ b/crates/ra_hir_def/src/path/lower.rs
@@ -0,0 +1,176 @@
+//! Transforms syntax into `Path` objects, ideally with accounting for hygiene
+mod lower_use;
+use std::sync::Arc;
+use either::Either;
+use hir_expand::{
+    hygiene::Hygiene,
+    name::{name, AsName},
+};
+use ra_syntax::ast::{self, AstNode, TypeAscriptionOwner};
+use crate::{
+    path::{GenericArg, GenericArgs, ModPath, Path, PathKind},
+    type_ref::TypeRef,
+};
+pub(super) use lower_use::lower_use_tree;
+/// Converts an `ast::Path` to `Path`. Works with use trees.
+/// It correctly handles `$crate` based path from macro call.
+pub(super) fn lower_path(mut path: ast::Path, hygiene: &Hygiene) -> Option<Path> {
+    let mut kind = PathKind::Plain;
+    let mut segments = Vec::new();
+    let mut generic_args = Vec::new();
+    loop {
+        let segment = path.segment()?;
+        if segment.has_colon_colon() {
+            kind = PathKind::Abs;
+        }
+        match segment.kind()? {
+            ast::PathSegmentKind::Name(name_ref) => {
+                // FIXME: this should just return name
+                match hygiene.name_ref_to_name(name_ref) {
+                    Either::Left(name) => {
+                        let args = segment
+                            .type_arg_list()
+                            .and_then(lower_generic_args)
+                            .or_else(|| {
+                                lower_generic_args_from_fn_path(
+                                    segment.param_list(),
+                                    segment.ret_type(),
+                                )
+                            })
+                            .map(Arc::new);
+                        segments.push(name);
+                        generic_args.push(args)
+                    }
+                    Either::Right(crate_id) => {
+                        kind = PathKind::DollarCrate(crate_id);
+                        break;
+                    }
+                }
+            }
+            ast::PathSegmentKind::Type { type_ref, trait_ref } => {
+                assert!(path.qualifier().is_none()); // this can only occur at the first segment
+                let self_type = TypeRef::from_ast(type_ref?);
+                match trait_ref {
+                    // <T>::foo
+                    None => {
+                        kind = PathKind::Type(Box::new(self_type));
+                    }
+                    // <T as Trait<A>>::Foo desugars to Trait<Self=T, A>::Foo
+                    Some(trait_ref) => {
+                        let path = Path::from_src(trait_ref.path()?, hygiene)?;
+                        kind = path.mod_path.kind;
+                        let mut prefix_segments = path.mod_path.segments;
+                        prefix_segments.reverse();
+                        segments.extend(prefix_segments);
+                        let mut prefix_args = path.generic_args;
+                        prefix_args.reverse();
+                        generic_args.extend(prefix_args);
+                        // Insert the type reference (T in the above example) as Self parameter for the trait
+                        let last_segment = generic_args.last_mut()?;
+                        if last_segment.is_none() {
+                            *last_segment = Some(Arc::new(GenericArgs::empty()));
+                        };
+                        let args = last_segment.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;
+            }
+            ast::PathSegmentKind::SelfKw => {
+                kind = PathKind::Self_;
+                break;
+            }
+            ast::PathSegmentKind::SuperKw => {
+                kind = PathKind::Super;
+                break;
+            }
+        }
+        path = match qualifier(&path) {
+            Some(it) => it,
+            None => break,
+        };
+    }
+    segments.reverse();
+    generic_args.reverse();
+    let mod_path = ModPath { kind, segments };
+    return Some(Path { mod_path, generic_args });
+    fn qualifier(path: &ast::Path) -> Option<ast::Path> {
+        if let Some(q) = path.qualifier() {
+            return Some(q);
+        }
+        // FIXME: this bottom up traversal is not too precise.
+        // Should we handle do a top-down analysis, recording results?
+        let use_tree_list = path.syntax().ancestors().find_map(ast::UseTreeList::cast)?;
+        let use_tree = use_tree_list.parent_use_tree();
+        use_tree.path()
+    }
+}
+pub(super) fn lower_generic_args(node: ast::TypeArgList) -> Option<GenericArgs> {
+    let mut args = Vec::new();
+    for type_arg in node.type_args() {
+        let type_ref = TypeRef::from_ast_opt(type_arg.type_ref());
+        args.push(GenericArg::Type(type_ref));
+    }
+    // lifetimes ignored for now
+    let mut bindings = Vec::new();
+    for assoc_type_arg in node.assoc_type_args() {
+        if let Some(name_ref) = assoc_type_arg.name_ref() {
+            let name = name_ref.as_name();
+            let type_ref = TypeRef::from_ast_opt(assoc_type_arg.type_ref());
+            bindings.push((name, type_ref));
+        }
+    }
+    if args.is_empty() && bindings.is_empty() {
+        None
+    } else {
+        Some(GenericArgs { args, has_self_type: false, bindings })
+    }
+}
+/// Collect `GenericArgs` from the parts of a fn-like path, i.e. `Fn(X, Y)
+/// -> Z` (which desugars to `Fn<(X, Y), Output=Z>`).
+fn lower_generic_args_from_fn_path(
+    params: Option<ast::ParamList>,
+    ret_type: Option<ast::RetType>,
+) -> Option<GenericArgs> {
+    let mut args = Vec::new();
+    let mut bindings = Vec::new();
+    if let Some(params) = params {
+        let mut param_types = Vec::new();
+        for param in params.params() {
+            let type_ref = TypeRef::from_ast_opt(param.ascribed_type());
+            param_types.push(type_ref);
+        }
+        let arg = GenericArg::Type(TypeRef::Tuple(param_types));
+        args.push(arg);
+    }
+    if let Some(ret_type) = ret_type {
+        let type_ref = TypeRef::from_ast_opt(ret_type.type_ref());
+        bindings.push((name![Output], type_ref))
+    }
+    if args.is_empty() && bindings.is_empty() {
+        None
+    } else {
+        Some(GenericArgs { args, has_self_type: false, bindings })
+    }
+}
diff --git a/crates/ra_hir_def/src/path/lower_use.rs b/crates/ra_hir_def/src/path/lower/lower_use.rs
index e2e1f716d..ea3fdb56c 100644
--- a/crates/ra_hir_def/src/path/lower_use.rs
+++ b/crates/ra_hir_def/src/path/lower/lower_use.rs
@@ -10,13 +10,13 @@ use hir_expand::{
 };
 use ra_syntax::ast::{self, NameOwner};
-use crate::path::{Path, PathKind, PathSegment};
+use crate::path::{ModPath, PathKind};
 pub(crate) fn lower_use_tree(
-    prefix: Option<Path>,
+    prefix: Option<ModPath>,
    tree: ast::UseTree,
    hygiene: &Hygiene,
-    cb: &mut dyn FnMut(Path, &ast::UseTree, bool, Option<Name>),
+    cb: &mut dyn FnMut(ModPath, &ast::UseTree, bool, Option<Name>),
 ) {
    if let Some(use_tree_list) = tree.use_tree_list() {
        let prefix = match tree.path() {
@@ -57,7 +57,7 @@ pub(crate) fn lower_use_tree(
    }
 }
-fn convert_path(prefix: Option<Path>, path: ast::Path, hygiene: &Hygiene) -> Option<Path> {
+fn convert_path(prefix: Option<ModPath>, path: ast::Path, hygiene: &Hygiene) -> Option<ModPath> {
    let prefix = if let Some(qual) = path.qualifier() {
        Some(convert_path(prefix, qual, hygiene)?)
    } else {
@@ -70,18 +70,15 @@ fn convert_path(prefix: Option<Path>, path: ast::Path, hygiene: &Hygiene) -> Opt
            match hygiene.name_ref_to_name(name_ref) {
                Either::Left(name) => {
                    // no type args in use
-                    let mut res = prefix.unwrap_or_else(|| Path {
+                    let mut res = prefix.unwrap_or_else(|| ModPath {
                        kind: PathKind::Plain,
                        segments: Vec::with_capacity(1),
                    });
-                    res.segments.push(PathSegment {
+                    res.segments.push(name);
-                        name,
-                        args_and_bindings: None, // no type args in use
-                    });
                    res
                }
                Either::Right(crate_id) => {
-                    return Some(Path::from_simple_segments(
+                    return Some(ModPath::from_simple_segments(
                        PathKind::DollarCrate(crate_id),
                        iter::empty(),
                    ))
@@ -92,19 +89,19 @@ fn convert_path(prefix: Option<Path>, path: ast::Path, hygiene: &Hygiene) -> Opt
            if prefix.is_some() {
                return None;
            }
-            Path::from_simple_segments(PathKind::Crate, iter::empty())
+            ModPath::from_simple_segments(PathKind::Crate, iter::empty())
        }
        ast::PathSegmentKind::SelfKw => {
            if prefix.is_some() {
                return None;
            }
-            Path::from_simple_segments(PathKind::Self_, iter::empty())
+            ModPath::from_simple_segments(PathKind::Self_, iter::empty())
        }
        ast::PathSegmentKind::SuperKw => {
            if prefix.is_some() {
                return None;
            }
-            Path::from_simple_segments(PathKind::Super, iter::empty())
+            ModPath::from_simple_segments(PathKind::Super, iter::empty())
        }
        ast::PathSegmentKind::Type { .. } => {
            // not allowed in imports
diff --git a/crates/ra_hir_def/src/resolver.rs b/crates/ra_hir_def/src/resolver.rs
index 17b2169d2..2694c0438 100644
--- a/crates/ra_hir_def/src/resolver.rs
+++ b/crates/ra_hir_def/src/resolver.rs
@@ -2,7 +2,7 @@
 use std::sync::Arc;
 use hir_expand::{
-    name::{self, Name},
+    name::{name, Name},
    MacroDefId,
 };
 use ra_db::CrateId;
@@ -15,7 +15,7 @@ use crate::{
    expr::{ExprId, PatId},
    generics::GenericParams,
    nameres::{BuiltinShadowMode, CrateDefMap},
-    path::{Path, PathKind},
+    path::{ModPath, PathKind},
    per_ns::PerNs,
    AdtId, ConstId, ContainerId, DefWithBodyId, EnumId, EnumVariantId, FunctionId, GenericDefId,
    HasModule, ImplId, LocalModuleId, Lookup, ModuleDefId, ModuleId, StaticId, StructId, TraitId,
@@ -91,7 +91,7 @@ pub enum ValueNs {
 impl Resolver {
    /// Resolve known trait from std, like `std::futures::Future`
-    pub fn resolve_known_trait(&self, db: &impl DefDatabase, path: &Path) -> Option<TraitId> {
+    pub fn resolve_known_trait(&self, db: &impl DefDatabase, path: &ModPath) -> Option<TraitId> {
        let res = self.resolve_module_path(db, path, BuiltinShadowMode::Other).take_types()?;
        match res {
            ModuleDefId::TraitId(it) => Some(it),
@@ -100,7 +100,7 @@ impl Resolver {
    }
    /// Resolve known struct from std, like `std::boxed::Box`
-    pub fn resolve_known_struct(&self, db: &impl DefDatabase, path: &Path) -> Option<StructId> {
+    pub fn resolve_known_struct(&self, db: &impl DefDatabase, path: &ModPath) -> Option<StructId> {
        let res = self.resolve_module_path(db, path, BuiltinShadowMode::Other).take_types()?;
        match res {
            ModuleDefId::AdtId(AdtId::StructId(it)) => Some(it),
@@ -109,7 +109,7 @@ impl Resolver {
    }
    /// Resolve known enum from std, like `std::result::Result`
-    pub fn resolve_known_enum(&self, db: &impl DefDatabase, path: &Path) -> Option<EnumId> {
+    pub fn resolve_known_enum(&self, db: &impl DefDatabase, path: &ModPath) -> Option<EnumId> {
        let res = self.resolve_module_path(db, path, BuiltinShadowMode::Other).take_types()?;
        match res {
            ModuleDefId::AdtId(AdtId::EnumId(it)) => Some(it),
@@ -120,33 +120,30 @@ impl Resolver {
    fn resolve_module_path(
        &self,
        db: &impl DefDatabase,
-        path: &Path,
+        path: &ModPath,
        shadow: BuiltinShadowMode,
    ) -> PerNs {
        let (item_map, module) = match self.module() {
            Some(it) => it,
            None => return PerNs::none(),
        };
-        let (module_res, segment_index) = item_map.resolve_path(db, module, path, shadow);
+        let (module_res, segment_index) = item_map.resolve_path(db, module, &path, shadow);
        if segment_index.is_some() {
            return PerNs::none();
        }
        module_res
    }
-    pub fn resolve_module_path_in_items(&self, db: &impl DefDatabase, path: &Path) -> PerNs {
+    pub fn resolve_module_path_in_items(&self, db: &impl DefDatabase, path: &ModPath) -> PerNs {
        self.resolve_module_path(db, path, BuiltinShadowMode::Module)
    }
    pub fn resolve_path_in_type_ns(
        &self,
        db: &impl DefDatabase,
-        path: &Path,
+        path: &ModPath,
    ) -> Option<(TypeNs, Option<usize>)> {
-        if path.is_type_relative() {
+        let first_name = path.segments.first()?;
-            return None;
-        }
-        let first_name = &path.segments.first()?.name;
        let skip_to_mod = path.kind != PathKind::Plain;
        for scope in self.scopes.iter().rev() {
            match scope {
@@ -163,13 +160,13 @@ impl Resolver {
                    }
                }
                Scope::ImplBlockScope(impl_) => {
-                    if first_name == &name::SELF_TYPE {
+                    if first_name == &name![Self] {
                        let idx = if path.segments.len() == 1 { None } else { Some(1) };
                        return Some((TypeNs::SelfType(*impl_), idx));
                    }
                }
                Scope::AdtScope(adt) => {
-                    if first_name == &name::SELF_TYPE {
+                    if first_name == &name![Self] {
                        let idx = if path.segments.len() == 1 { None } else { Some(1) };
                        return Some((TypeNs::AdtSelfType(*adt), idx));
                    }
@@ -178,7 +175,7 @@ impl Resolver {
                    let (module_def, idx) = m.crate_def_map.resolve_path(
                        db,
                        m.module_id,
-                        path,
+                        &path,
                        BuiltinShadowMode::Other,
                    );
                    let res = match module_def.take_types()? {
@@ -205,7 +202,7 @@ impl Resolver {
    pub fn resolve_path_in_type_ns_fully(
        &self,
        db: &impl DefDatabase,
-        path: &Path,
+        path: &ModPath,
    ) -> Option<TypeNs> {
        let (res, unresolved) = self.resolve_path_in_type_ns(db, path)?;
        if unresolved.is_some() {
@@ -214,17 +211,14 @@ impl Resolver {
        Some(res)
    }
-    pub fn resolve_path_in_value_ns<'p>(
+    pub fn resolve_path_in_value_ns(
        &self,
        db: &impl DefDatabase,
-        path: &'p Path,
+        path: &ModPath,
    ) -> Option<ResolveValueResult> {
-        if path.is_type_relative() {
-            return None;
-        }
        let n_segments = path.segments.len();
-        let tmp = name::SELF_PARAM;
+        let tmp = name![self];
-        let first_name = if path.is_self() { &tmp } else { &path.segments.first()?.name };
+        let first_name = if path.is_self() { &tmp } else { &path.segments.first()? };
        let skip_to_mod = path.kind != PathKind::Plain && !path.is_self();
        for scope in self.scopes.iter().rev() {
            match scope {
@@ -259,13 +253,13 @@ impl Resolver {
                Scope::GenericParams { .. } => continue,
                Scope::ImplBlockScope(impl_) if n_segments > 1 => {
-                    if first_name == &name::SELF_TYPE {
+                    if first_name == &name![Self] {
                        let ty = TypeNs::SelfType(*impl_);
                        return Some(ResolveValueResult::Partial(ty, 1));
                    }
                }
                Scope::AdtScope(adt) if n_segments > 1 => {
-                    if first_name == &name::SELF_TYPE {
+                    if first_name == &name![Self] {
                        let ty = TypeNs::AdtSelfType(*adt);
                        return Some(ResolveValueResult::Partial(ty, 1));
                    }
@@ -276,7 +270,7 @@ impl Resolver {
                    let (module_def, idx) = m.crate_def_map.resolve_path(
                        db,
                        m.module_id,
-                        path,
+                        &path,
                        BuiltinShadowMode::Other,
                    );
                    return match idx {
@@ -322,7 +316,7 @@ impl Resolver {
    pub fn resolve_path_in_value_ns_fully(
        &self,
        db: &impl DefDatabase,
-        path: &Path,
+        path: &ModPath,
    ) -> Option<ValueNs> {
        match self.resolve_path_in_value_ns(db, path)? {
            ResolveValueResult::ValueNs(it) => Some(it),
@@ -330,9 +324,13 @@ impl Resolver {
        }
    }
-    pub fn resolve_path_as_macro(&self, db: &impl DefDatabase, path: &Path) -> Option<MacroDefId> {
+    pub fn resolve_path_as_macro(
+        &self,
+        db: &impl DefDatabase,
+        path: &ModPath,
+    ) -> Option<MacroDefId> {
        let (item_map, module) = self.module()?;
-        item_map.resolve_path(db, module, path, BuiltinShadowMode::Other).0.take_macros()
+        item_map.resolve_path(db, module, &path, BuiltinShadowMode::Other).0.take_macros()
    }
    pub fn process_all_names(&self, db: &impl DefDatabase, f: &mut dyn FnMut(Name, ScopeDef)) {
@@ -439,10 +437,10 @@ impl Scope {
                }
            }
            Scope::ImplBlockScope(i) => {
-                f(name::SELF_TYPE, ScopeDef::ImplSelfType((*i).into()));
+                f(name![Self], ScopeDef::ImplSelfType((*i).into()));
            }
            Scope::AdtScope(i) => {
-                f(name::SELF_TYPE, ScopeDef::AdtSelfType((*i).into()));
+                f(name![Self], ScopeDef::AdtSelfType((*i).into()));
            }
            Scope::ExprScope(scope) => {
                scope.expr_scopes.entries(scope.scope_id).iter().for_each(|e| {
diff --git a/crates/ra_hir_expand/src/builtin_derive.rs b/crates/ra_hir_expand/src/builtin_derive.rs
index 574637602..b26441253 100644
--- a/crates/ra_hir_expand/src/builtin_derive.rs
+++ b/crates/ra_hir_expand/src/builtin_derive.rs
@@ -12,10 +12,10 @@ use crate::db::AstDatabase;
 use crate::{name, quote, MacroCallId, MacroDefId, MacroDefKind};
 macro_rules! register_builtin {
-    ( $(($name:ident, $kind: ident) => $expand:ident),* ) => {
+    ( $($trait:ident => $expand:ident),* ) => {
        #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
        pub enum BuiltinDeriveExpander {
-            $($kind),*
+            $($trait),*
        }
        impl BuiltinDeriveExpander {
@@ -26,7 +26,7 @@ macro_rules! register_builtin {
                tt: &tt::Subtree,
            ) -> Result<tt::Subtree, mbe::ExpandError> {
                let expander = match *self {
-                    $( BuiltinDeriveExpander::$kind => $expand, )*
+                    $( BuiltinDeriveExpander::$trait => $expand, )*
                };
                expander(db, id, tt)
            }
@@ -34,7 +34,7 @@ macro_rules! register_builtin {
        pub fn find_builtin_derive(ident: &name::Name) -> Option<MacroDefId> {
            let kind = match ident {
-                 $( id if id == &name::$name => BuiltinDeriveExpander::$kind, )*
+                $( id if id == &name::name![$trait] => BuiltinDeriveExpander::$trait, )*
                 _ => return None,
            };
@@ -44,15 +44,15 @@ macro_rules! register_builtin {
 }
 register_builtin! {
-    (COPY_TRAIT, Copy) => copy_expand,
+    Copy => copy_expand,
-    (CLONE_TRAIT, Clone) => clone_expand,
+    Clone => clone_expand,
-    (DEFAULT_TRAIT, Default) => default_expand,
+    Default => default_expand,
-    (DEBUG_TRAIT, Debug) => debug_expand,
+    Debug => debug_expand,
-    (HASH_TRAIT, Hash) => hash_expand,
+    Hash => hash_expand,
-    (ORD_TRAIT, Ord) => ord_expand,
+    Ord => ord_expand,
-    (PARTIAL_ORD_TRAIT, PartialOrd) => partial_ord_expand,
+    PartialOrd => partial_ord_expand,
-    (EQ_TRAIT, Eq) => eq_expand,
+    Eq => eq_expand,
-    (PARTIAL_EQ_TRAIT, PartialEq) => partial_eq_expand
+    PartialEq => partial_eq_expand
 }
 struct BasicAdtInfo {
diff --git a/crates/ra_hir_expand/src/builtin_macro.rs b/crates/ra_hir_expand/src/builtin_macro.rs
index be5f3cbe3..d2b3d769e 100644
--- a/crates/ra_hir_expand/src/builtin_macro.rs
+++ b/crates/ra_hir_expand/src/builtin_macro.rs
@@ -34,7 +34,7 @@ macro_rules! register_builtin {
            ast_id: AstId<ast::MacroCall>,
        ) -> Option<MacroDefId> {
            let kind = match ident {
-                 $( id if id == &name::$name => BuiltinFnLikeExpander::$kind, )*
+                 $( id if id == &name::name![$name] => BuiltinFnLikeExpander::$kind, )*
                 _ => return None,
            };
@@ -44,15 +44,15 @@ macro_rules! register_builtin {
 }
 register_builtin! {
-    (COLUMN_MACRO, Column) => column_expand,
+    (column, Column) => column_expand,
-    (COMPILE_ERROR_MACRO, CompileError) => compile_error_expand,
+    (compile_error, CompileError) => compile_error_expand,
-    (FILE_MACRO, File) => file_expand,
+    (file, File) => file_expand,
-    (LINE_MACRO, Line) => line_expand,
+    (line, Line) => line_expand,
-    (STRINGIFY_MACRO, Stringify) => stringify_expand,
+    (stringify, Stringify) => stringify_expand,
-    (FORMAT_ARGS_MACRO, FormatArgs) => format_args_expand,
+    (format_args, FormatArgs) => format_args_expand,
    // format_args_nl only differs in that it adds a newline in the end,
    // so we use the same stub expansion for now
-    (FORMAT_ARGS_NL_MACRO, FormatArgsNl) => format_args_expand
+    (format_args_nl, FormatArgsNl) => format_args_expand
 }
 fn to_line_number(db: &dyn AstDatabase, file: HirFileId, pos: TextUnit) -> usize {
diff --git a/crates/ra_hir_expand/src/name.rs b/crates/ra_hir_expand/src/name.rs
index 9e68dd98d..59d8214fd 100644
--- a/crates/ra_hir_expand/src/name.rs
+++ b/crates/ra_hir_expand/src/name.rs
@@ -104,73 +104,99 @@ impl AsName for ra_db::Dependency {
    }
 }
-// Primitives
+pub mod known {
-pub const ISIZE: Name = Name::new_inline_ascii(b"isize");
+    macro_rules! known_names {
-pub const I8: Name = Name::new_inline_ascii(b"i8");
+        ($($ident:ident),* $(,)?) => {
-pub const I16: Name = Name::new_inline_ascii(b"i16");
+            $(
-pub const I32: Name = Name::new_inline_ascii(b"i32");
+                #[allow(bad_style)]
-pub const I64: Name = Name::new_inline_ascii(b"i64");
+                pub const $ident: super::Name =
-pub const I128: Name = Name::new_inline_ascii(b"i128");
+                    super::Name::new_inline_ascii(stringify!($ident).as_bytes());
-pub const USIZE: Name = Name::new_inline_ascii(b"usize");
+            )*
-pub const U8: Name = Name::new_inline_ascii(b"u8");
+        };
-pub const U16: Name = Name::new_inline_ascii(b"u16");
+    }
-pub const U32: Name = Name::new_inline_ascii(b"u32");
-pub const U64: Name = Name::new_inline_ascii(b"u64");
+    known_names!(
-pub const U128: Name = Name::new_inline_ascii(b"u128");
+        // Primitives
-pub const F32: Name = Name::new_inline_ascii(b"f32");
+        isize,
-pub const F64: Name = Name::new_inline_ascii(b"f64");
+        i8,
-pub const BOOL: Name = Name::new_inline_ascii(b"bool");
+        i16,
-pub const CHAR: Name = Name::new_inline_ascii(b"char");
+        i32,
-pub const STR: Name = Name::new_inline_ascii(b"str");
+        i64,
+        i128,
-// Special names
+        usize,
-pub const SELF_PARAM: Name = Name::new_inline_ascii(b"self");
+        u8,
-pub const SELF_TYPE: Name = Name::new_inline_ascii(b"Self");
+        u16,
-pub const MACRO_RULES: Name = Name::new_inline_ascii(b"macro_rules");
+        u32,
+        u64,
-// Components of known path (value or mod name)
+        u128,
-pub const STD: Name = Name::new_inline_ascii(b"std");
+        f32,
-pub const ITER: Name = Name::new_inline_ascii(b"iter");
+        f64,
-pub const OPS: Name = Name::new_inline_ascii(b"ops");
+        bool,
-pub const FUTURE: Name = Name::new_inline_ascii(b"future");
+        char,
-pub const RESULT: Name = Name::new_inline_ascii(b"result");
+        str,
-pub const BOXED: Name = Name::new_inline_ascii(b"boxed");
+        // Special names
+        macro_rules,
-// Components of known path (type name)
+        // Components of known path (value or mod name)
-pub const INTO_ITERATOR_TYPE: Name = Name::new_inline_ascii(b"IntoIterator");
+        std,
-pub const ITEM_TYPE: Name = Name::new_inline_ascii(b"Item");
+        iter,
-pub const TRY_TYPE: Name = Name::new_inline_ascii(b"Try");
+        ops,
-pub const OK_TYPE: Name = Name::new_inline_ascii(b"Ok");
+        future,
-pub const FUTURE_TYPE: Name = Name::new_inline_ascii(b"Future");
+        result,
-pub const RESULT_TYPE: Name = Name::new_inline_ascii(b"Result");
+        boxed,
-pub const OUTPUT_TYPE: Name = Name::new_inline_ascii(b"Output");
+        // Components of known path (type name)
-pub const TARGET_TYPE: Name = Name::new_inline_ascii(b"Target");
+        IntoIterator,
-pub const BOX_TYPE: Name = Name::new_inline_ascii(b"Box");
+        Item,
-pub const RANGE_FROM_TYPE: Name = Name::new_inline_ascii(b"RangeFrom");
+        Try,
-pub const RANGE_FULL_TYPE: Name = Name::new_inline_ascii(b"RangeFull");
+        Ok,
-pub const RANGE_INCLUSIVE_TYPE: Name = Name::new_inline_ascii(b"RangeInclusive");
+        Future,
-pub const RANGE_TO_INCLUSIVE_TYPE: Name = Name::new_inline_ascii(b"RangeToInclusive");
+        Result,
-pub const RANGE_TO_TYPE: Name = Name::new_inline_ascii(b"RangeTo");
+        Output,
-pub const RANGE_TYPE: Name = Name::new_inline_ascii(b"Range");
+        Target,
-pub const NEG_TYPE: Name = Name::new_inline_ascii(b"Neg");
+        Box,
-pub const NOT_TYPE: Name = Name::new_inline_ascii(b"Not");
+        RangeFrom,
+        RangeFull,
-// Builtin Macros
+        RangeInclusive,
-pub const FILE_MACRO: Name = Name::new_inline_ascii(b"file");
+        RangeToInclusive,
-pub const COLUMN_MACRO: Name = Name::new_inline_ascii(b"column");
+        RangeTo,
-pub const COMPILE_ERROR_MACRO: Name = Name::new_inline_ascii(b"compile_error");
+        Range,
-pub const LINE_MACRO: Name = Name::new_inline_ascii(b"line");
+        Neg,
-pub const STRINGIFY_MACRO: Name = Name::new_inline_ascii(b"stringify");
+        Not,
-pub const FORMAT_ARGS_MACRO: Name = Name::new_inline_ascii(b"format_args");
+        // Builtin macros
-pub const FORMAT_ARGS_NL_MACRO: Name = Name::new_inline_ascii(b"format_args_nl");
+        file,
+        column,
-// Builtin derives
+        compile_error,
-pub const COPY_TRAIT: Name = Name::new_inline_ascii(b"Copy");
+        line,
-pub const CLONE_TRAIT: Name = Name::new_inline_ascii(b"Clone");
+        stringify,
-pub const DEFAULT_TRAIT: Name = Name::new_inline_ascii(b"Default");
+        format_args,
-pub const DEBUG_TRAIT: Name = Name::new_inline_ascii(b"Debug");
+        format_args_nl,
-pub const HASH_TRAIT: Name = Name::new_inline_ascii(b"Hash");
+        // Builtin derives
-pub const ORD_TRAIT: Name = Name::new_inline_ascii(b"Ord");
+        Copy,
-pub const PARTIAL_ORD_TRAIT: Name = Name::new_inline_ascii(b"PartialOrd");
+        Clone,
-pub const EQ_TRAIT: Name = Name::new_inline_ascii(b"Eq");
+        Default,
-pub const PARTIAL_EQ_TRAIT: Name = Name::new_inline_ascii(b"PartialEq");
+        Debug,
+        Hash,
+        Ord,
+        PartialOrd,
+        Eq,
+        PartialEq,
+    );
+    // self/Self cannot be used as an identifier
+    pub const SELF_PARAM: super::Name = super::Name::new_inline_ascii(b"self");
+    pub const SELF_TYPE: super::Name = super::Name::new_inline_ascii(b"Self");
+    #[macro_export]
+    macro_rules! name {
+        (self) => {
+            $crate::name::known::SELF_PARAM
+        };
+        (Self) => {
+            $crate::name::known::SELF_TYPE
+        };
+        ($ident:ident) => {
+            $crate::name::known::$ident
+        };
+    }
+}
+pub use crate::name;
diff --git a/crates/ra_hir_ty/src/autoderef.rs b/crates/ra_hir_ty/src/autoderef.rs
index d557962b4..ee48fa537 100644
--- a/crates/ra_hir_ty/src/autoderef.rs
+++ b/crates/ra_hir_ty/src/autoderef.rs
@@ -6,7 +6,7 @@
 use std::iter::successors;
 use hir_def::lang_item::LangItemTarget;
-use hir_expand::name;
+use hir_expand::name::name;
 use log::{info, warn};
 use ra_db::CrateId;
@@ -52,7 +52,7 @@ fn deref_by_trait(
        LangItemTarget::TraitId(it) => it,
        _ => return None,
    };
-    let target = db.trait_data(deref_trait).associated_type_by_name(&name::TARGET_TYPE)?;
+    let target = db.trait_data(deref_trait).associated_type_by_name(&name![Target])?;
    let generic_params = generics(db, target.into());
    if generic_params.len() != 1 {
diff --git a/crates/ra_hir_ty/src/expr.rs b/crates/ra_hir_ty/src/expr.rs
index d2bd64e5c..f752a9f09 100644
--- a/crates/ra_hir_ty/src/expr.rs
+++ b/crates/ra_hir_ty/src/expr.rs
@@ -3,7 +3,7 @@
 use std::sync::Arc;
 use hir_def::{
-    path::{known, Path},
+    path::{path, Path},
    resolver::HasResolver,
    AdtId, FunctionId,
 };
@@ -124,7 +124,7 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
            None => return,
        };
-        let std_result_path = known::std_result_result();
+        let std_result_path = path![std::result::Result];
        let resolver = self.func.resolver(db);
        let std_result_enum = match resolver.resolve_known_enum(db, &std_result_path) {
diff --git a/crates/ra_hir_ty/src/infer.rs b/crates/ra_hir_ty/src/infer.rs
index a1201b3e4..98ba05fc2 100644
--- a/crates/ra_hir_ty/src/infer.rs
+++ b/crates/ra_hir_ty/src/infer.rs
@@ -24,14 +24,15 @@ use hir_def::{
    body::Body,
    data::{ConstData, FunctionData},
    expr::{BindingAnnotation, ExprId, PatId},
-    path::{known, Path},
+    path::{path, Path},
    resolver::{HasResolver, Resolver, TypeNs},
    type_ref::{Mutability, TypeRef},
    AdtId, AssocItemId, DefWithBodyId, FunctionId, StructFieldId, TypeAliasId, VariantId,
 };
-use hir_expand::{diagnostics::DiagnosticSink, name};
+use hir_expand::{diagnostics::DiagnosticSink, name::name};
 use ra_arena::map::ArenaMap;
 use ra_prof::profile;
+use test_utils::tested_by;
 use super::{
    primitive::{FloatTy, IntTy},
@@ -274,6 +275,29 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
        self.normalize_associated_types_in(ty)
    }
+    /// Replaces `impl Trait` in `ty` by type variables and obligations for
+    /// those variables. This is done for function arguments when calling a
+    /// function, and for return types when inside the function body, i.e. in
+    /// the cases where the `impl Trait` is 'transparent'. In other cases, `impl
+    /// Trait` is represented by `Ty::Opaque`.
+    fn insert_vars_for_impl_trait(&mut self, ty: Ty) -> Ty {
+        ty.fold(&mut |ty| match ty {
+            Ty::Opaque(preds) => {
+                tested_by!(insert_vars_for_impl_trait);
+                let var = self.table.new_type_var();
+                let var_subst = Substs::builder(1).push(var.clone()).build();
+                self.obligations.extend(
+                    preds
+                        .iter()
+                        .map(|pred| pred.clone().subst_bound_vars(&var_subst))
+                        .filter_map(Obligation::from_predicate),
+                );
+                var
+            }
+            _ => ty,
+        })
+    }
    /// Replaces Ty::Unknown by a new type var, so we can maybe still infer it.
    fn insert_type_vars_shallow(&mut self, ty: Ty) -> Ty {
        match ty {
@@ -386,7 +410,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
        let resolver = &self.resolver;
        // FIXME: this should resolve assoc items as well, see this example:
        // https://play.rust-lang.org/?gist=087992e9e22495446c01c0d4e2d69521
-        match resolver.resolve_path_in_type_ns_fully(self.db, &path) {
+        match resolver.resolve_path_in_type_ns_fully(self.db, path.mod_path()) {
            Some(TypeNs::AdtId(AdtId::StructId(strukt))) => {
                let substs = Ty::substs_from_path(self.db, resolver, path, strukt.into());
                let ty = self.db.ty(strukt.into());
@@ -414,7 +438,8 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
            self.infer_pat(*pat, &ty, BindingMode::default());
        }
-        self.return_ty = self.make_ty(&data.ret_type);
+        let return_ty = self.make_ty(&data.ret_type);
+        self.return_ty = self.insert_vars_for_impl_trait(return_ty);
    }
    fn infer_body(&mut self) {
@@ -422,73 +447,73 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
    }
    fn resolve_into_iter_item(&self) -> Option<TypeAliasId> {
-        let path = known::std_iter_into_iterator();
+        let path = path![std::iter::IntoIterator];
        let trait_ = self.resolver.resolve_known_trait(self.db, &path)?;
-        self.db.trait_data(trait_).associated_type_by_name(&name::ITEM_TYPE)
+        self.db.trait_data(trait_).associated_type_by_name(&name![Item])
    }
    fn resolve_ops_try_ok(&self) -> Option<TypeAliasId> {
-        let path = known::std_ops_try();
+        let path = path![std::ops::Try];
        let trait_ = self.resolver.resolve_known_trait(self.db, &path)?;
-        self.db.trait_data(trait_).associated_type_by_name(&name::OK_TYPE)
+        self.db.trait_data(trait_).associated_type_by_name(&name![Ok])
    }
    fn resolve_ops_neg_output(&self) -> Option<TypeAliasId> {
-        let path = known::std_ops_neg();
+        let path = path![std::ops::Neg];
        let trait_ = self.resolver.resolve_known_trait(self.db, &path)?;
-        self.db.trait_data(trait_).associated_type_by_name(&name::OUTPUT_TYPE)
+        self.db.trait_data(trait_).associated_type_by_name(&name![Output])
    }
    fn resolve_ops_not_output(&self) -> Option<TypeAliasId> {
-        let path = known::std_ops_not();
+        let path = path![std::ops::Not];
        let trait_ = self.resolver.resolve_known_trait(self.db, &path)?;
-        self.db.trait_data(trait_).associated_type_by_name(&name::OUTPUT_TYPE)
+        self.db.trait_data(trait_).associated_type_by_name(&name![Output])
    }
    fn resolve_future_future_output(&self) -> Option<TypeAliasId> {
-        let path = known::std_future_future();
+        let path = path![std::future::Future];
        let trait_ = self.resolver.resolve_known_trait(self.db, &path)?;
-        self.db.trait_data(trait_).associated_type_by_name(&name::OUTPUT_TYPE)
+        self.db.trait_data(trait_).associated_type_by_name(&name![Output])
    }
    fn resolve_boxed_box(&self) -> Option<AdtId> {
-        let path = known::std_boxed_box();
+        let path = path![std::boxed::Box];
        let struct_ = self.resolver.resolve_known_struct(self.db, &path)?;
        Some(struct_.into())
    }
    fn resolve_range_full(&self) -> Option<AdtId> {
-        let path = known::std_ops_range_full();
+        let path = path![std::ops::RangeFull];
        let struct_ = self.resolver.resolve_known_struct(self.db, &path)?;
        Some(struct_.into())
    }
    fn resolve_range(&self) -> Option<AdtId> {
-        let path = known::std_ops_range();
+        let path = path![std::ops::Range];
        let struct_ = self.resolver.resolve_known_struct(self.db, &path)?;
        Some(struct_.into())
    }
    fn resolve_range_inclusive(&self) -> Option<AdtId> {
-        let path = known::std_ops_range_inclusive();
+        let path = path![std::ops::RangeInclusive];
        let struct_ = self.resolver.resolve_known_struct(self.db, &path)?;
        Some(struct_.into())
    }
    fn resolve_range_from(&self) -> Option<AdtId> {
-        let path = known::std_ops_range_from();
+        let path = path![std::ops::RangeFrom];
        let struct_ = self.resolver.resolve_known_struct(self.db, &path)?;
        Some(struct_.into())
    }
    fn resolve_range_to(&self) -> Option<AdtId> {
-        let path = known::std_ops_range_to();
+        let path = path![std::ops::RangeTo];
        let struct_ = self.resolver.resolve_known_struct(self.db, &path)?;
        Some(struct_.into())
    }
    fn resolve_range_to_inclusive(&self) -> Option<AdtId> {
-        let path = known::std_ops_range_to_inclusive();
+        let path = path![std::ops::RangeToInclusive];
        let struct_ = self.resolver.resolve_known_struct(self.db, &path)?;
        Some(struct_.into())
    }
diff --git a/crates/ra_hir_ty/src/infer/expr.rs b/crates/ra_hir_ty/src/infer/expr.rs
index f8c00a7b4..924ad3e81 100644
--- a/crates/ra_hir_ty/src/infer/expr.rs
+++ b/crates/ra_hir_ty/src/infer/expr.rs
@@ -10,7 +10,7 @@ use hir_def::{
    resolver::resolver_for_expr,
    AdtId, ContainerId, Lookup, StructFieldId,
 };
-use hir_expand::name::{self, Name};
+use hir_expand::name::{name, Name};
 use ra_syntax::ast::RangeOp;
 use crate::{
@@ -613,6 +613,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                    continue;
                }
+                let param_ty = self.insert_vars_for_impl_trait(param_ty);
                let param_ty = self.normalize_associated_types_in(param_ty);
                self.infer_expr_coerce(arg, &Expectation::has_type(param_ty.clone()));
            }
@@ -631,7 +632,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
        // Parent arguments are unknown, except for the receiver type
        if let Some(parent_generics) = def_generics.as_ref().map(|p| p.iter_parent()) {
            for (_id, param) in parent_generics {
-                if param.name == name::SELF_TYPE {
+                if param.name == name![Self] {
                    substs.push(receiver_ty.clone());
                } else {
                    substs.push(Ty::Unknown);
diff --git a/crates/ra_hir_ty/src/infer/path.rs b/crates/ra_hir_ty/src/infer/path.rs
index 37db005ea..3bae0ca6c 100644
--- a/crates/ra_hir_ty/src/infer/path.rs
+++ b/crates/ra_hir_ty/src/infer/path.rs
@@ -32,21 +32,21 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
        path: &Path,
        id: ExprOrPatId,
    ) -> Option<Ty> {
-        let (value, self_subst) = if let PathKind::Type(type_ref) = &path.kind {
+        let (value, self_subst) = if let PathKind::Type(type_ref) = path.kind() {
-            if path.segments.is_empty() {
+            if path.segments().is_empty() {
                // This can't actually happen syntax-wise
                return None;
            }
            let ty = self.make_ty(type_ref);
-            let remaining_segments_for_ty = &path.segments[..path.segments.len() - 1];
+            let remaining_segments_for_ty = path.segments().take(path.segments().len() - 1);
            let ty = Ty::from_type_relative_path(self.db, resolver, ty, remaining_segments_for_ty);
            self.resolve_ty_assoc_item(
                ty,
-                &path.segments.last().expect("path had at least one segment").name,
+                &path.segments().last().expect("path had at least one segment").name,
                id,
            )?
        } else {
-            let value_or_partial = resolver.resolve_path_in_value_ns(self.db, &path)?;
+            let value_or_partial = resolver.resolve_path_in_value_ns(self.db, path.mod_path())?;
            match value_or_partial {
                ResolveValueResult::ValueNs(it) => (it, None),
@@ -85,13 +85,13 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
        remaining_index: usize,
        id: ExprOrPatId,
    ) -> Option<(ValueNs, Option<Substs>)> {
-        assert!(remaining_index < path.segments.len());
+        assert!(remaining_index < path.segments().len());
        // there may be more intermediate segments between the resolved one and
        // the end. Only the last segment needs to be resolved to a value; from
        // the segments before that, we need to get either a type or a trait ref.
-        let resolved_segment = &path.segments[remaining_index - 1];
+        let resolved_segment = path.segments().get(remaining_index - 1).unwrap();
-        let remaining_segments = &path.segments[remaining_index..];
+        let remaining_segments = path.segments().skip(remaining_index);
        let is_before_last = remaining_segments.len() == 1;
        match (def, is_before_last) {
@@ -112,7 +112,8 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                // trait but it's not the last segment, so the next segment
                // should resolve to an associated type of that trait (e.g. `<T
                // as Iterator>::Item::default`)
-                let remaining_segments_for_ty = &remaining_segments[..remaining_segments.len() - 1];
+                let remaining_segments_for_ty =
+                    remaining_segments.take(remaining_segments.len() - 1);
                let ty = Ty::from_partly_resolved_hir_path(
                    self.db,
                    &self.resolver,
@@ -138,7 +139,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
    fn resolve_trait_assoc_item(
        &mut self,
        trait_ref: TraitRef,
-        segment: &PathSegment,
+        segment: PathSegment<'_>,
        id: ExprOrPatId,
    ) -> Option<(ValueNs, Option<Substs>)> {
        let trait_ = trait_ref.trait_;
@@ -150,7 +151,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
            .map(|(_name, id)| (*id).into())
            .find_map(|item| match item {
                AssocItemId::FunctionId(func) => {
-                    if segment.name == self.db.function_data(func).name {
+                    if segment.name == &self.db.function_data(func).name {
                        Some(AssocItemId::FunctionId(func))
                    } else {
                        None
@@ -158,7 +159,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                }
                AssocItemId::ConstId(konst) => {
-                    if self.db.const_data(konst).name.as_ref().map_or(false, |n| n == &segment.name)
+                    if self.db.const_data(konst).name.as_ref().map_or(false, |n| n == segment.name)
                    {
                        Some(AssocItemId::ConstId(konst))
                    } else {
diff --git a/crates/ra_hir_ty/src/lower.rs b/crates/ra_hir_ty/src/lower.rs
index 5f795bc02..a4ddfc8ef 100644
--- a/crates/ra_hir_ty/src/lower.rs
+++ b/crates/ra_hir_ty/src/lower.rs
@@ -11,7 +11,7 @@ use std::sync::Arc;
 use hir_def::{
    builtin_type::BuiltinType,
    generics::WherePredicate,
-    path::{GenericArg, Path, PathKind, PathSegment},
+    path::{GenericArg, Path, PathKind, PathSegment, PathSegments},
    resolver::{HasResolver, Resolver, TypeNs},
    type_ref::{TypeBound, TypeRef},
    AdtId, ConstId, EnumId, EnumVariantId, FunctionId, GenericDefId, HasModule, ImplId,
@@ -101,13 +101,13 @@ impl Ty {
            TypeRef::Path(path) => path,
            _ => return None,
        };
-        if let PathKind::Type(_) = &path.kind {
+        if let PathKind::Type(_) = path.kind() {
            return None;
        }
-        if path.segments.len() > 1 {
+        if path.segments().len() > 1 {
            return None;
        }
-        let resolution = match resolver.resolve_path_in_type_ns(db, path) {
+        let resolution = match resolver.resolve_path_in_type_ns(db, path.mod_path()) {
            Some((it, None)) => it,
            _ => return None,
        };
@@ -124,11 +124,11 @@ impl Ty {
        db: &impl HirDatabase,
        resolver: &Resolver,
        ty: Ty,
-        remaining_segments: &[PathSegment],
+        remaining_segments: PathSegments<'_>,
    ) -> Ty {
        if remaining_segments.len() == 1 {
            // resolve unselected assoc types
-            let segment = &remaining_segments[0];
+            let segment = remaining_segments.first().unwrap();
            Ty::select_associated_type(db, resolver, ty, segment)
        } else if remaining_segments.len() > 1 {
            // FIXME report error (ambiguous associated type)
@@ -142,15 +142,15 @@ impl Ty {
        db: &impl HirDatabase,
        resolver: &Resolver,
        resolution: TypeNs,
-        resolved_segment: &PathSegment,
+        resolved_segment: PathSegment<'_>,
-        remaining_segments: &[PathSegment],
+        remaining_segments: PathSegments<'_>,
    ) -> Ty {
        let ty = match resolution {
            TypeNs::TraitId(trait_) => {
                let trait_ref =
                    TraitRef::from_resolved_path(db, resolver, trait_, resolved_segment, None);
                return if remaining_segments.len() == 1 {
-                    let segment = &remaining_segments[0];
+                    let segment = remaining_segments.first().unwrap();
                    let associated_ty = associated_type_by_name_including_super_traits(
                        db,
                        trait_ref.trait_,
@@ -202,21 +202,21 @@ impl Ty {
    pub(crate) fn from_hir_path(db: &impl HirDatabase, resolver: &Resolver, path: &Path) -> Ty {
        // Resolve the path (in type namespace)
-        if let PathKind::Type(type_ref) = &path.kind {
+        if let PathKind::Type(type_ref) = path.kind() {
            let ty = Ty::from_hir(db, resolver, &type_ref);
-            let remaining_segments = &path.segments[..];
+            return Ty::from_type_relative_path(db, resolver, ty, path.segments());
-            return Ty::from_type_relative_path(db, resolver, ty, remaining_segments);
        }
-        let (resolution, remaining_index) = match resolver.resolve_path_in_type_ns(db, path) {
+        let (resolution, remaining_index) =
-            Some(it) => it,
+            match resolver.resolve_path_in_type_ns(db, path.mod_path()) {
-            None => return Ty::Unknown,
+                Some(it) => it,
-        };
+                None => return Ty::Unknown,
+            };
        let (resolved_segment, remaining_segments) = match remaining_index {
            None => (
-                path.segments.last().expect("resolved path has at least one element"),
+                path.segments().last().expect("resolved path has at least one element"),
-                &[] as &[PathSegment],
+                PathSegments::EMPTY,
            ),
-            Some(i) => (&path.segments[i - 1], &path.segments[i..]),
+            Some(i) => (path.segments().get(i - 1).unwrap(), path.segments().skip(i)),
        };
        Ty::from_partly_resolved_hir_path(
            db,
@@ -231,7 +231,7 @@ impl Ty {
        db: &impl HirDatabase,
        resolver: &Resolver,
        self_ty: Ty,
-        segment: &PathSegment,
+        segment: PathSegment<'_>,
    ) -> Ty {
        let param_idx = match self_ty {
            Ty::Param { idx, .. } => idx,
@@ -261,7 +261,7 @@ impl Ty {
    fn from_hir_path_inner(
        db: &impl HirDatabase,
        resolver: &Resolver,
-        segment: &PathSegment,
+        segment: PathSegment<'_>,
        typable: TyDefId,
    ) -> Ty {
        let generic_def = match typable {
@@ -284,7 +284,7 @@ impl Ty {
        // special-case enum variants
        resolved: ValueTyDefId,
    ) -> Substs {
-        let last = path.segments.last().expect("path should have at least one segment");
+        let last = path.segments().last().expect("path should have at least one segment");
        let (segment, generic_def) = match resolved {
            ValueTyDefId::FunctionId(it) => (last, Some(it.into())),
            ValueTyDefId::StructId(it) => (last, Some(it.into())),
@@ -296,13 +296,11 @@ impl Ty {
                // referring to the variant. So `Option::<T>::None` and
                // `Option::None::<T>` are both allowed (though the former is
                // preferred). See also `def_ids_for_path_segments` in rustc.
-                let len = path.segments.len();
+                let len = path.segments().len();
-                let segment = if len >= 2 && path.segments[len - 2].args_and_bindings.is_some() {
+                let penultimate = if len >= 2 { path.segments().get(len - 2) } else { None };
-                    // Option::<T>::None
+                let segment = match penultimate {
-                    &path.segments[len - 2]
+                    Some(segment) if segment.args_and_bindings.is_some() => segment,
-                } else {
+                    _ => last,
-                    // Option::None::<T>
-                    last
                };
                (segment, Some(var.parent.into()))
            }
@@ -314,7 +312,7 @@ impl Ty {
 pub(super) fn substs_from_path_segment(
    db: &impl HirDatabase,
    resolver: &Resolver,
-    segment: &PathSegment,
+    segment: PathSegment<'_>,
    def_generic: Option<GenericDefId>,
    add_self_param: bool,
 ) -> Substs {
@@ -372,11 +370,11 @@ impl TraitRef {
        path: &Path,
        explicit_self_ty: Option<Ty>,
    ) -> Option<Self> {
-        let resolved = match resolver.resolve_path_in_type_ns_fully(db, &path)? {
+        let resolved = match resolver.resolve_path_in_type_ns_fully(db, path.mod_path())? {
            TypeNs::TraitId(tr) => tr,
            _ => return None,
        };
-        let segment = path.segments.last().expect("path should have at least one segment");
+        let segment = path.segments().last().expect("path should have at least one segment");
        Some(TraitRef::from_resolved_path(db, resolver, resolved.into(), segment, explicit_self_ty))
    }
@@ -384,7 +382,7 @@ impl TraitRef {
        db: &impl HirDatabase,
        resolver: &Resolver,
        resolved: TraitId,
-        segment: &PathSegment,
+        segment: PathSegment<'_>,
        explicit_self_ty: Option<Ty>,
    ) -> Self {
        let mut substs = TraitRef::substs_from_path(db, resolver, segment, resolved);
@@ -410,7 +408,7 @@ impl TraitRef {
    fn substs_from_path(
        db: &impl HirDatabase,
        resolver: &Resolver,
-        segment: &PathSegment,
+        segment: PathSegment<'_>,
        resolved: TraitId,
    ) -> Substs {
        let has_self_param =
@@ -464,12 +462,12 @@ fn assoc_type_bindings_from_type_bound<'a>(
    trait_ref: TraitRef,
 ) -> impl Iterator<Item = GenericPredicate> + 'a {
    let last_segment = match bound {
-        TypeBound::Path(path) => path.segments.last(),
+        TypeBound::Path(path) => path.segments().last(),
        TypeBound::Error => None,
    };
    last_segment
        .into_iter()
-        .flat_map(|segment| segment.args_and_bindings.iter())
+        .flat_map(|segment| segment.args_and_bindings.into_iter())
        .flat_map(|args_and_bindings| args_and_bindings.bindings.iter())
        .map(move |(name, type_ref)| {
            let associated_ty =
diff --git a/crates/ra_hir_ty/src/marks.rs b/crates/ra_hir_ty/src/marks.rs
index 0f754eb9c..fe74acf11 100644
--- a/crates/ra_hir_ty/src/marks.rs
+++ b/crates/ra_hir_ty/src/marks.rs
@@ -6,4 +6,5 @@ test_utils::marks!(
    type_var_resolves_to_int_var
    match_ergonomics_ref
    coerce_merge_fail_fallback
+    insert_vars_for_impl_trait
 );
diff --git a/crates/ra_hir_ty/src/tests/traits.rs b/crates/ra_hir_ty/src/tests/traits.rs
index 6139adb72..802937cb0 100644
--- a/crates/ra_hir_ty/src/tests/traits.rs
+++ b/crates/ra_hir_ty/src/tests/traits.rs
@@ -1,7 +1,10 @@
-use super::{infer, type_at, type_at_pos};
-use crate::test_db::TestDB;
 use insta::assert_snapshot;
 use ra_db::fixture::WithFixture;
+use test_utils::covers;
+use super::{infer, infer_with_mismatches, type_at, type_at_pos};
+use crate::test_db::TestDB;
 #[test]
 fn infer_await() {
@@ -1486,3 +1489,61 @@ fn test<T, U>() where T: Trait<U::Item>, U: Trait<T::Item> {
    // this is a legitimate cycle
    assert_eq!(t, "{unknown}");
 }
+#[test]
+fn unify_impl_trait() {
+    covers!(insert_vars_for_impl_trait);
+    assert_snapshot!(
+        infer_with_mismatches(r#"
+trait Trait<T> {}
+fn foo(x: impl Trait<u32>) { loop {} }
+fn bar<T>(x: impl Trait<T>) -> T { loop {} }
+struct S<T>(T);
+impl<T> Trait<T> for S<T> {}
+fn default<T>() -> T { loop {} }
+fn test() -> impl Trait<i32> {
+    let s1 = S(default());
+    foo(s1);
+    let x: i32 = bar(S(default()));
+    S(default())
+}
+"#, true),
+        @r###"
+    [27; 28) 'x': impl Trait<u32>
+    [47; 58) '{ loop {} }': ()
+    [49; 56) 'loop {}': !
+    [54; 56) '{}': ()
+    [69; 70) 'x': impl Trait<T>
+    [92; 103) '{ loop {} }': T
+    [94; 101) 'loop {}': !
+    [99; 101) '{}': ()
+    [172; 183) '{ loop {} }': T
+    [174; 181) 'loop {}': !
+    [179; 181) '{}': ()
+    [214; 310) '{     ...t()) }': S<i32>
+    [224; 226) 's1': S<u32>
+    [229; 230) 'S': S<u32>(T) -> S<T>
+    [229; 241) 'S(default())': S<u32>
+    [231; 238) 'default': fn default<u32>() -> T
+    [231; 240) 'default()': u32
+    [247; 250) 'foo': fn foo(impl Trait<u32>) -> ()
+    [247; 254) 'foo(s1)': ()
+    [251; 253) 's1': S<u32>
+    [264; 265) 'x': i32
+    [273; 276) 'bar': fn bar<i32>(impl Trait<T>) -> T
+    [273; 290) 'bar(S(...lt()))': i32
+    [277; 278) 'S': S<i32>(T) -> S<T>
+    [277; 289) 'S(default())': S<i32>
+    [279; 286) 'default': fn default<i32>() -> T
+    [279; 288) 'default()': i32
+    [296; 297) 'S': S<i32>(T) -> S<T>
+    [296; 308) 'S(default())': S<i32>
+    [298; 305) 'default': fn default<i32>() -> T
+    [298; 307) 'default()': i32
+    "###
+    );
+}
diff --git a/crates/ra_hir_ty/src/traits/builtin.rs b/crates/ra_hir_ty/src/traits/builtin.rs
index 598fd81e3..cd587a338 100644
--- a/crates/ra_hir_ty/src/traits/builtin.rs
+++ b/crates/ra_hir_ty/src/traits/builtin.rs
@@ -1,7 +1,7 @@
 //! This module provides the built-in trait implementations, e.g. to make
 //! closures implement `Fn`.
 use hir_def::{expr::Expr, lang_item::LangItemTarget, TraitId, TypeAliasId};
-use hir_expand::name;
+use hir_expand::name::name;
 use ra_db::CrateId;
 use super::{AssocTyValue, Impl};
@@ -79,7 +79,7 @@ fn closure_fn_trait_impl_datum(
    // and don't want to return a valid value only to find out later that FnOnce
    // is broken
    let fn_once_trait = get_fn_trait(db, krate, super::FnTrait::FnOnce)?;
-    let _output = db.trait_data(fn_once_trait).associated_type_by_name(&name::OUTPUT_TYPE)?;
+    let _output = db.trait_data(fn_once_trait).associated_type_by_name(&name![Output])?;
    let num_args: u16 = match &db.body(data.def.into())[data.expr] {
        Expr::Lambda { args, .. } => args.len() as u16,
@@ -137,7 +137,7 @@ fn closure_fn_trait_output_assoc_ty_value(
    let output_ty_id = db
        .trait_data(fn_once_trait)
-        .associated_type_by_name(&name::OUTPUT_TYPE)
+        .associated_type_by_name(&name![Output])
        .expect("assoc ty value should not exist");
    BuiltinImplAssocTyValueData {
diff --git a/crates/ra_hir_ty/src/utils.rs b/crates/ra_hir_ty/src/utils.rs
index aeb211a91..29799a8cb 100644
--- a/crates/ra_hir_ty/src/utils.rs
+++ b/crates/ra_hir_ty/src/utils.rs
@@ -6,14 +6,13 @@ use hir_def::{
    adt::VariantData,
    db::DefDatabase,
    generics::{GenericParams, TypeParamData},
+    path::Path,
    resolver::{HasResolver, TypeNs},
    type_ref::TypeRef,
    ContainerId, GenericDefId, Lookup, TraitId, TypeAliasId, TypeParamId, VariantId,
 };
-use hir_expand::name::{self, Name};
+use hir_expand::name::{name, Name};
-// FIXME: this is wrong, b/c it can't express `trait T: PartialEq<()>`.
-// We should return a `TraitREf` here.
 fn direct_super_traits(db: &impl DefDatabase, trait_: TraitId) -> Vec<TraitId> {
    let resolver = trait_.resolver(db);
    // returning the iterator directly doesn't easily work because of
@@ -24,10 +23,10 @@ fn direct_super_traits(db: &impl DefDatabase, trait_: TraitId) -> Vec<TraitId> {
        .where_predicates
        .iter()
        .filter_map(|pred| match &pred.type_ref {
-            TypeRef::Path(p) if p.as_ident() == Some(&name::SELF_TYPE) => pred.bound.as_path(),
+            TypeRef::Path(p) if p == &Path::from(name![Self]) => pred.bound.as_path(),
            _ => None,
        })
-        .filter_map(|path| match resolver.resolve_path_in_type_ns_fully(db, path) {
+        .filter_map(|path| match resolver.resolve_path_in_type_ns_fully(db, path.mod_path()) {
            Some(TypeNs::TraitId(t)) => Some(t),
            _ => None,
        })
diff --git a/crates/ra_ide/src/completion/completion_context.rs b/crates/ra_ide/src/completion/completion_context.rs
index ca0a483d4..981da2b79 100644
--- a/crates/ra_ide/src/completion/completion_context.rs
+++ b/crates/ra_ide/src/completion/completion_context.rs
@@ -188,10 +188,9 @@ impl<'a> CompletionContext<'a> {
            self.is_path_type = path.syntax().parent().and_then(ast::PathType::cast).is_some();
            self.has_type_args = segment.type_arg_list().is_some();
-            if let Some(mut path) = hir::Path::from_ast(path.clone()) {
+            if let Some(path) = hir::Path::from_ast(path.clone()) {
-                if !path.is_ident() {
+                if let Some(path_prefix) = path.qualifier() {
-                    path.segments.pop().unwrap();
+                    self.path_prefix = Some(path_prefix);
-                    self.path_prefix = Some(path);
                    return;
                }
            }
diff --git a/crates/ra_ide/src/goto_definition.rs b/crates/ra_ide/src/goto_definition.rs
index 2c634990d..bee8e9df2 100644
--- a/crates/ra_ide/src/goto_definition.rs
+++ b/crates/ra_ide/src/goto_definition.rs
@@ -3,7 +3,9 @@
 use hir::{db::AstDatabase, InFile};
 use ra_syntax::{
    ast::{self, DocCommentsOwner},
-    match_ast, AstNode, SyntaxNode,
+    match_ast, AstNode,
+    SyntaxKind::*,
+    SyntaxNode, SyntaxToken, TokenAtOffset,
 };
 use crate::{
@@ -19,8 +21,7 @@ pub(crate) fn goto_definition(
    position: FilePosition,
 ) -> Option<RangeInfo<Vec<NavigationTarget>>> {
    let file = db.parse_or_expand(position.file_id.into())?;
-    let original_token =
+    let original_token = pick_best(file.token_at_offset(position.offset))?;
-        file.token_at_offset(position.offset).filter(|it| !it.kind().is_trivia()).next()?;
    let token = descend_into_macros(db, position.file_id, original_token.clone());
    let nav_targets = match_ast! {
@@ -38,6 +39,17 @@ pub(crate) fn goto_definition(
    Some(RangeInfo::new(original_token.text_range(), nav_targets))
 }
+fn pick_best(tokens: TokenAtOffset<SyntaxToken>) -> Option<SyntaxToken> {
+    return tokens.max_by_key(priority);
+    fn priority(n: &SyntaxToken) -> usize {
+        match n.kind() {
+            IDENT | INT_NUMBER => 2,
+            kind if kind.is_trivia() => 0,
+            _ => 1,
+        }
+    }
+}
 #[derive(Debug)]
 pub(crate) enum ReferenceResult {
    Exact(NavigationTarget),
@@ -253,6 +265,18 @@ mod tests {
    }
    #[test]
+    fn goto_definition_works_at_start_of_item() {
+        check_goto(
+            "
+            //- /lib.rs
+            struct Foo;
+            enum E { X(<|>Foo) }
+            ",
+            "Foo STRUCT_DEF FileId(1) [0; 11) [7; 10)",
+        );
+    }
+    #[test]
    fn goto_definition_resolves_correct_name() {
        check_goto(
            "
@@ -453,6 +477,22 @@ mod tests {
    }
    #[test]
+    fn goto_for_tuple_fields() {
+        check_goto(
+            "
+            //- /lib.rs
+            struct Foo(u32);
+            fn bar() {
+                let foo = Foo(0);
+                foo.<|>0;
+            }
+            ",
+            "TUPLE_FIELD_DEF FileId(1) [11; 14)",
+        );
+    }
+    #[test]
    fn goto_definition_works_for_ufcs_inherent_methods() {
        check_goto(
            "
diff --git a/crates/ra_ide/src/goto_type_definition.rs b/crates/ra_ide/src/goto_type_definition.rs
index 992a08809..ce8b6c72a 100644
--- a/crates/ra_ide/src/goto_type_definition.rs
+++ b/crates/ra_ide/src/goto_type_definition.rs
@@ -1,7 +1,7 @@
 //! FIXME: write short doc here
 use hir::db::AstDatabase;
-use ra_syntax::{ast, AstNode};
+use ra_syntax::{ast, AstNode, SyntaxKind::*, SyntaxToken, TokenAtOffset};
 use crate::{
    db::RootDatabase, display::ToNav, expand::descend_into_macros, FilePosition, NavigationTarget,
@@ -13,7 +13,7 @@ pub(crate) fn goto_type_definition(
    position: FilePosition,
 ) -> Option<RangeInfo<Vec<NavigationTarget>>> {
    let file = db.parse_or_expand(position.file_id.into())?;
-    let token = file.token_at_offset(position.offset).filter(|it| !it.kind().is_trivia()).next()?;
+    let token = pick_best(file.token_at_offset(position.offset))?;
    let token = descend_into_macros(db, position.file_id, token);
    let node = token.value.ancestors().find_map(|token| {
@@ -41,6 +41,17 @@ pub(crate) fn goto_type_definition(
    Some(RangeInfo::new(node.text_range(), vec![nav]))
 }
+fn pick_best(tokens: TokenAtOffset<SyntaxToken>) -> Option<SyntaxToken> {
+    return tokens.max_by_key(priority);
+    fn priority(n: &SyntaxToken) -> usize {
+        match n.kind() {
+            IDENT | INT_NUMBER => 2,
+            kind if kind.is_trivia() => 0,
+            _ => 1,
+        }
+    }
+}
 #[cfg(test)]
 mod tests {
    use crate::mock_analysis::analysis_and_position;
@@ -102,4 +113,32 @@ mod tests {
            "Foo STRUCT_DEF FileId(1) [52; 65) [59; 62)",
        );
    }
+    #[test]
+    fn goto_type_definition_for_param() {
+        check_goto(
+            "
+            //- /lib.rs
+            struct Foo;
+            fn foo(<|>f: Foo) {}
+            ",
+            "Foo STRUCT_DEF FileId(1) [0; 11) [7; 10)",
+        );
+    }
+    #[test]
+    fn goto_type_definition_for_tuple_field() {
+        check_goto(
+            "
+            //- /lib.rs
+            struct Foo;
+            struct Bar(Foo);
+            fn foo() {
+                let bar = Bar(Foo);
+                bar.<|>0;
+            }
+            ",
+            "Foo STRUCT_DEF FileId(1) [0; 11) [7; 10)",
+        );
+    }
 }
diff --git a/crates/ra_ide/src/hover.rs b/crates/ra_ide/src/hover.rs
index d372ca758..51e320128 100644
--- a/crates/ra_ide/src/hover.rs
+++ b/crates/ra_ide/src/hover.rs
@@ -6,6 +6,8 @@ use ra_syntax::{
    algo::find_covering_element,
    ast::{self, DocCommentsOwner},
    match_ast, AstNode,
+    SyntaxKind::*,
+    SyntaxToken, TokenAtOffset,
 };
 use crate::{
@@ -156,7 +158,7 @@ fn hover_text_from_name_kind(
 pub(crate) fn hover(db: &RootDatabase, position: FilePosition) -> Option<RangeInfo<HoverResult>> {
    let file = db.parse_or_expand(position.file_id.into())?;
-    let token = file.token_at_offset(position.offset).filter(|it| !it.kind().is_trivia()).next()?;
+    let token = pick_best(file.token_at_offset(position.offset))?;
    let token = descend_into_macros(db, position.file_id, token);
    let mut res = HoverResult::new();
@@ -218,6 +220,18 @@ pub(crate) fn hover(db: &RootDatabase, position: FilePosition) -> Option<RangeIn
    Some(RangeInfo::new(range, res))
 }
+fn pick_best(tokens: TokenAtOffset<SyntaxToken>) -> Option<SyntaxToken> {
+    return tokens.max_by_key(priority);
+    fn priority(n: &SyntaxToken) -> usize {
+        match n.kind() {
+            IDENT | INT_NUMBER => 3,
+            L_PAREN | R_PAREN => 2,
+            kind if kind.is_trivia() => 0,
+            _ => 1,
+        }
+    }
+}
 pub(crate) fn type_of(db: &RootDatabase, frange: FileRange) -> Option<String> {
    let parse = db.parse(frange.file_id);
    let leaf_node = find_covering_element(parse.tree().syntax(), frange.range);
@@ -505,6 +519,13 @@ fn func(foo: i32) { if true { <|>foo; }; }
    }
    #[test]
+    fn hover_for_param_edge() {
+        let (analysis, position) = single_file_with_position("fn func(<|>foo: i32) {}");
+        let hover = analysis.hover(position).unwrap().unwrap();
+        assert_eq!(trim_markup_opt(hover.info.first()), Some("i32"));
+    }
+    #[test]
    fn test_type_of_for_function() {
        let (analysis, range) = single_file_with_range(
            "
diff --git a/crates/ra_ide/src/snapshots/highlighting.html b/crates/ra_ide/src/snapshots/highlighting.html
index 4166a8f90..40605d9ef 100644
--- a/crates/ra_ide/src/snapshots/highlighting.html
+++ b/crates/ra_ide/src/snapshots/highlighting.html
@@ -10,8 +10,10 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .builtin            { color: #DD6718; }
 .text               { color: #DCDCCC; }
 .type               { color: #7CB8BB; }
+.type\.param       { color: #20999D; }
 .attribute          { color: #94BFF3; }
 .literal            { color: #BFEBBF; }
+.literal\.numeric  { color: #6A8759; }
 .macro              { color: #94BFF3; }
 .variable           { color: #DCDCCC; }
 .variable\.mut     { color: #DCDCCC; text-decoration: underline; }
@@ -22,36 +24,36 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 </style>
 <pre><code><span class="attribute">#</span><span class="attribute">[</span><span class="attribute">derive</span><span class="attribute">(</span><span class="attribute">Clone</span><span class="attribute">,</span><span class="attribute"> </span><span class="attribute">Debug</span><span class="attribute">)</span><span class="attribute">]</span>
 <span class="keyword">struct</span> <span class="type">Foo</span> {
-    <span class="keyword">pub</span> <span class="field">x</span>: <span class="type">i32</span>,
+    <span class="keyword">pub</span> <span class="field">x</span>: <span class="type.builtin">i32</span>,
-    <span class="keyword">pub</span> <span class="field">y</span>: <span class="type">i32</span>,
+    <span class="keyword">pub</span> <span class="field">y</span>: <span class="type.builtin">i32</span>,
 }
-<span class="keyword">fn</span> <span class="function">foo</span>&lt;<span class="type">T</span>&gt;() -&gt; <span class="type">T</span> {
+<span class="keyword">fn</span> <span class="function">foo</span>&lt;<span class="type.param">T</span>&gt;() -&gt; <span class="type.param">T</span> {
    <span class="macro">unimplemented</span><span class="macro">!</span>();
-    <span class="function">foo</span>::&lt;<span class="type">i32</span>&gt;();
+    <span class="function">foo</span>::&lt;<span class="type.builtin">i32</span>&gt;();
 }
 <span class="comment">// comment</span>
 <span class="keyword">fn</span> <span class="function">main</span>() {
-    <span class="macro">println</span><span class="macro">!</span>(<span class="string">"Hello, {}!"</span>, <span class="literal">92</span>);
+    <span class="macro">println</span><span class="macro">!</span>(<span class="string">"Hello, {}!"</span>, <span class="literal.numeric">92</span>);
    <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable.mut">vec</span> = <span class="text">Vec</span>::<span class="text">new</span>();
    <span class="keyword.control">if</span> <span class="keyword">true</span> {
-        <span class="variable.mut">vec</span>.<span class="text">push</span>(<span class="type">Foo</span> { <span class="field">x</span>: <span class="literal">0</span>, <span class="field">y</span>: <span class="literal">1</span> });
+        <span class="variable.mut">vec</span>.<span class="text">push</span>(<span class="type">Foo</span> { <span class="field">x</span>: <span class="literal.numeric">0</span>, <span class="field">y</span>: <span class="literal.numeric">1</span> });
    }
-    <span class="keyword.unsafe">unsafe</span> { <span class="variable.mut">vec</span>.<span class="text">set_len</span>(<span class="literal">0</span>); }
+    <span class="keyword.unsafe">unsafe</span> { <span class="variable.mut">vec</span>.<span class="text">set_len</span>(<span class="literal.numeric">0</span>); }
-    <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable.mut">x</span> = <span class="literal">42</span>;
+    <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable.mut">x</span> = <span class="literal.numeric">42</span>;
    <span class="keyword">let</span> <span class="variable.mut">y</span> = &<span class="keyword">mut</span> <span class="variable.mut">x</span>;
    <span class="keyword">let</span> <span class="variable">z</span> = &<span class="variable.mut">y</span>;
    <span class="variable.mut">y</span>;
 }
-<span class="keyword">enum</span> <span class="type">E</span>&lt;<span class="type">X</span>&gt; {
+<span class="keyword">enum</span> <span class="type">E</span>&lt;<span class="type.param">X</span>&gt; {
-    <span class="constant">V</span>(<span class="type">X</span>)
+    <span class="constant">V</span>(<span class="type.param">X</span>)
 }
-<span class="keyword">impl</span>&lt;<span class="type">X</span>&gt; <span class="type">E</span>&lt;<span class="type">X</span>&gt; {
+<span class="keyword">impl</span>&lt;<span class="type.param">X</span>&gt; <span class="type">E</span>&lt;<span class="type.param">X</span>&gt; {
-    <span class="keyword">fn</span> <span class="function">new</span>&lt;<span class="type">T</span>&gt;() -&gt; <span class="type">E</span>&lt;<span class="type">T</span>&gt; {}
+    <span class="keyword">fn</span> <span class="function">new</span>&lt;<span class="type.param">T</span>&gt;() -&gt; <span class="type">E</span>&lt;<span class="type.param">T</span>&gt; {}
 }</code></pre>
 \ No newline at end of file
diff --git a/crates/ra_ide/src/snapshots/rainbow_highlighting.html b/crates/ra_ide/src/snapshots/rainbow_highlighting.html
index 9dfbc8047..ecf26c708 100644
--- a/crates/ra_ide/src/snapshots/rainbow_highlighting.html
+++ b/crates/ra_ide/src/snapshots/rainbow_highlighting.html
@@ -10,8 +10,10 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .builtin            { color: #DD6718; }
 .text               { color: #DCDCCC; }
 .type               { color: #7CB8BB; }
+.type\.param       { color: #20999D; }
 .attribute          { color: #94BFF3; }
 .literal            { color: #BFEBBF; }
+.literal\.numeric  { color: #6A8759; }
 .macro              { color: #94BFF3; }
 .variable           { color: #DCDCCC; }
 .variable\.mut     { color: #DCDCCC; text-decoration: underline; }
diff --git a/crates/ra_ide/src/syntax_highlighting.rs b/crates/ra_ide/src/syntax_highlighting.rs
index 7ecb1a027..eb3dd1779 100644
--- a/crates/ra_ide/src/syntax_highlighting.rs
+++ b/crates/ra_ide/src/syntax_highlighting.rs
@@ -16,6 +16,34 @@ use crate::{
    FileId,
 };
+pub mod tags {
+    pub(crate) const FIELD: &'static str = "field";
+    pub(crate) const FUNCTION: &'static str = "function";
+    pub(crate) const MODULE: &'static str = "module";
+    pub(crate) const TYPE: &'static str = "type";
+    pub(crate) const CONSTANT: &'static str = "constant";
+    pub(crate) const MACRO: &'static str = "macro";
+    pub(crate) const VARIABLE: &'static str = "variable";
+    pub(crate) const VARIABLE_MUT: &'static str = "variable.mut";
+    pub(crate) const TEXT: &'static str = "text";
+    pub(crate) const TYPE_BUILTIN: &'static str = "type.builtin";
+    pub(crate) const TYPE_SELF: &'static str = "type.self";
+    pub(crate) const TYPE_PARAM: &'static str = "type.param";
+    pub(crate) const TYPE_LIFETIME: &'static str = "type.lifetime";
+    pub(crate) const LITERAL_BYTE: &'static str = "literal.byte";
+    pub(crate) const LITERAL_NUMERIC: &'static str = "literal.numeric";
+    pub(crate) const LITERAL_CHAR: &'static str = "literal.char";
+    pub(crate) const LITERAL_COMMENT: &'static str = "comment";
+    pub(crate) const LITERAL_STRING: &'static str = "string";
+    pub(crate) const LITERAL_ATTRIBUTE: &'static str = "attribute";
+    pub(crate) const KEYWORD_UNSAFE: &'static str = "keyword.unsafe";
+    pub(crate) const KEYWORD_CONTROL: &'static str = "keyword.control";
+    pub(crate) const KEYWORD: &'static str = "keyword";
+}
 #[derive(Debug)]
 pub struct HighlightedRange {
    pub range: TextRange,
@@ -71,9 +99,9 @@ pub(crate) fn highlight(db: &RootDatabase, file_id: FileId) -> Vec<HighlightedRa
                bindings_shadow_count.clear();
                continue;
            }
-            COMMENT => "comment",
+            COMMENT => tags::LITERAL_COMMENT,
-            STRING | RAW_STRING | RAW_BYTE_STRING | BYTE_STRING => "string",
+            STRING | RAW_STRING | RAW_BYTE_STRING | BYTE_STRING => tags::LITERAL_STRING,
-            ATTR => "attribute",
+            ATTR => tags::LITERAL_ATTRIBUTE,
            NAME_REF => {
                if node.ancestors().any(|it| it.kind() == ATTR) {
                    continue;
@@ -90,7 +118,7 @@ pub(crate) fn highlight(db: &RootDatabase, file_id: FileId) -> Vec<HighlightedRa
                    }
                };
-                name_kind.map_or("text", |it| highlight_name(db, it))
+                name_kind.map_or(tags::TEXT, |it| highlight_name(db, it))
            }
            NAME => {
                let name = node.as_node().cloned().and_then(ast::Name::cast).unwrap();
@@ -107,18 +135,21 @@ pub(crate) fn highlight(db: &RootDatabase, file_id: FileId) -> Vec<HighlightedRa
                match name_kind {
                    Some(name_kind) => highlight_name(db, name_kind),
-                    None => name.syntax().parent().map_or("function", |x| match x.kind() {
+                    None => name.syntax().parent().map_or(tags::FUNCTION, |x| match x.kind() {
-                        TYPE_PARAM | STRUCT_DEF | ENUM_DEF | TRAIT_DEF | TYPE_ALIAS_DEF => "type",
+                        STRUCT_DEF | ENUM_DEF | TRAIT_DEF | TYPE_ALIAS_DEF => tags::TYPE,
-                        RECORD_FIELD_DEF => "field",
+                        TYPE_PARAM => tags::TYPE_PARAM,
-                        _ => "function",
+                        RECORD_FIELD_DEF => tags::FIELD,
+                        _ => tags::FUNCTION,
                    }),
                }
            }
-            INT_NUMBER | FLOAT_NUMBER | CHAR | BYTE => "literal",
+            INT_NUMBER | FLOAT_NUMBER => tags::LITERAL_NUMERIC,
-            LIFETIME => "parameter",
+            BYTE => tags::LITERAL_BYTE,
-            T![unsafe] => "keyword.unsafe",
+            CHAR => tags::LITERAL_CHAR,
-            k if is_control_keyword(k) => "keyword.control",
+            LIFETIME => tags::TYPE_LIFETIME,
-            k if k.is_keyword() => "keyword",
+            T![unsafe] => tags::KEYWORD_UNSAFE,
+            k if is_control_keyword(k) => tags::KEYWORD_CONTROL,
+            k if k.is_keyword() => tags::KEYWORD,
            _ => {
                if let Some(macro_call) = node.as_node().cloned().and_then(ast::MacroCall::cast) {
                    if let Some(path) = macro_call.path() {
@@ -135,7 +166,7 @@ pub(crate) fn highlight(db: &RootDatabase, file_id: FileId) -> Vec<HighlightedRa
                                }
                                res.push(HighlightedRange {
                                    range: TextRange::from_to(range_start, range_end),
-                                    tag: "macro",
+                                    tag: tags::MACRO,
                                    binding_hash: None,
                                })
                            }
@@ -211,28 +242,29 @@ pub(crate) fn highlight_as_html(db: &RootDatabase, file_id: FileId, rainbow: boo
 fn highlight_name(db: &RootDatabase, name_kind: NameKind) -> &'static str {
    match name_kind {
-        Macro(_) => "macro",
+        Macro(_) => tags::MACRO,
-        Field(_) => "field",
+        Field(_) => tags::FIELD,
-        AssocItem(hir::AssocItem::Function(_)) => "function",
+        AssocItem(hir::AssocItem::Function(_)) => tags::FUNCTION,
-        AssocItem(hir::AssocItem::Const(_)) => "constant",
+        AssocItem(hir::AssocItem::Const(_)) => tags::CONSTANT,
-        AssocItem(hir::AssocItem::TypeAlias(_)) => "type",
+        AssocItem(hir::AssocItem::TypeAlias(_)) => tags::TYPE,
-        Def(hir::ModuleDef::Module(_)) => "module",
+        Def(hir::ModuleDef::Module(_)) => tags::MODULE,
-        Def(hir::ModuleDef::Function(_)) => "function",
+        Def(hir::ModuleDef::Function(_)) => tags::FUNCTION,
-        Def(hir::ModuleDef::Adt(_)) => "type",
+        Def(hir::ModuleDef::Adt(_)) => tags::TYPE,
-        Def(hir::ModuleDef::EnumVariant(_)) => "constant",
+        Def(hir::ModuleDef::EnumVariant(_)) => tags::CONSTANT,
-        Def(hir::ModuleDef::Const(_)) => "constant",
+        Def(hir::ModuleDef::Const(_)) => tags::CONSTANT,
-        Def(hir::ModuleDef::Static(_)) => "constant",
+        Def(hir::ModuleDef::Static(_)) => tags::CONSTANT,
-        Def(hir::ModuleDef::Trait(_)) => "type",
+        Def(hir::ModuleDef::Trait(_)) => tags::TYPE,
-        Def(hir::ModuleDef::TypeAlias(_)) => "type",
+        Def(hir::ModuleDef::TypeAlias(_)) => tags::TYPE,
-        Def(hir::ModuleDef::BuiltinType(_)) => "type",
+        Def(hir::ModuleDef::BuiltinType(_)) => tags::TYPE_BUILTIN,
-        SelfType(_) | TypeParam(_) => "type",
+        SelfType(_) => tags::TYPE_SELF,
+        TypeParam(_) => tags::TYPE_PARAM,
        Local(local) => {
            if local.is_mut(db) {
-                "variable.mut"
+                tags::VARIABLE_MUT
            } else if local.ty(db).is_mutable_reference() {
-                "variable.mut"
+                tags::VARIABLE_MUT
            } else {
-                "variable"
+                tags::VARIABLE
            }
        }
    }
@@ -255,8 +287,10 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .builtin            { color: #DD6718; }
 .text               { color: #DCDCCC; }
 .type               { color: #7CB8BB; }
+.type\\.param       { color: #20999D; }
 .attribute          { color: #94BFF3; }
 .literal            { color: #BFEBBF; }
+.literal\\.numeric  { color: #6A8759; }
 .macro              { color: #94BFF3; }
 .variable           { color: #DCDCCC; }
 .variable\\.mut     { color: #DCDCCC; text-decoration: underline; }
diff --git a/crates/ra_lsp_server/src/world.rs b/crates/ra_lsp_server/src/world.rs
index 927449b45..16cc11e8c 100644
--- a/crates/ra_lsp_server/src/world.rs
+++ b/crates/ra_lsp_server/src/world.rs
@@ -17,11 +17,13 @@ use ra_project_model::{get_rustc_cfg_options, ProjectWorkspace};
 use ra_vfs::{LineEndings, RootEntry, Vfs, VfsChange, VfsFile, VfsRoot, VfsTask, Watch};
 use ra_vfs_glob::{Glob, RustPackageFilterBuilder};
 use relative_path::RelativePathBuf;
+use std::path::{Component, Prefix};
 use crate::{
    main_loop::pending_requests::{CompletedRequest, LatestRequests},
    LspError, Result,
 };
+use std::str::FromStr;
 #[derive(Debug, Clone)]
 pub struct Options {
@@ -233,8 +235,8 @@ impl WorldSnapshot {
    pub fn file_id_to_uri(&self, id: FileId) -> Result<Url> {
        let path = self.vfs.read().file2path(VfsFile(id.0));
-        let url = Url::from_file_path(&path)
+        let url = url_from_path_with_drive_lowercasing(path)?;
-            .map_err(|_| format!("can't convert path to url: {}", path.display()))?;
        Ok(url)
    }
@@ -279,3 +281,65 @@ impl WorldSnapshot {
        self.analysis.feature_flags()
    }
 }
+/// Returns a `Url` object from a given path, will lowercase drive letters if present.
+/// This will only happen when processing windows paths.
+///
+/// When processing non-windows path, this is essentially the same as `Url::from_file_path`.
+fn url_from_path_with_drive_lowercasing(path: impl AsRef<Path>) -> Result<Url> {
+    let component_has_windows_drive = path
+        .as_ref()
+        .components()
+        .find(|comp| {
+            if let Component::Prefix(c) = comp {
+                match c.kind() {
+                    Prefix::Disk(_) | Prefix::VerbatimDisk(_) => return true,
+                    _ => return false,
+                }
+            }
+            false
+        })
+        .is_some();
+    // VSCode expects drive letters to be lowercased, where rust will uppercase the drive letters.
+    if component_has_windows_drive {
+        let url_original = Url::from_file_path(&path)
+            .map_err(|_| format!("can't convert path to url: {}", path.as_ref().display()))?;
+        let drive_partition: Vec<&str> = url_original.as_str().rsplitn(2, ':').collect();
+        // There is a drive partition, but we never found a colon.
+        // This should not happen, but in this case we just pass it through.
+        if drive_partition.len() == 1 {
+            return Ok(url_original);
+        }
+        let joined = drive_partition[1].to_ascii_lowercase() + ":" + drive_partition[0];
+        let url = Url::from_str(&joined).expect("This came from a valid `Url`");
+        Ok(url)
+    } else {
+        Ok(Url::from_file_path(&path)
+            .map_err(|_| format!("can't convert path to url: {}", path.as_ref().display()))?)
+    }
+}
+// `Url` is not able to parse windows paths on unix machines.
+#[cfg(target_os = "windows")]
+#[cfg(test)]
+mod path_conversion_windows_tests {
+    use super::url_from_path_with_drive_lowercasing;
+    #[test]
+    fn test_lowercase_drive_letter_with_drive() {
+        let url = url_from_path_with_drive_lowercasing("C:\\Test").unwrap();
+        assert_eq!(url.to_string(), "file:///c:/Test");
+    }
+    #[test]
+    fn test_drive_without_colon_passthrough() {
+        let url = url_from_path_with_drive_lowercasing(r#"\\localhost\C$\my_dir"#).unwrap();
+        assert_eq!(url.to_string(), "file://localhost/C$/my_dir");
+    }
+}
diff --git a/crates/ra_parser/src/grammar/expressions/atom.rs b/crates/ra_parser/src/grammar/expressions/atom.rs
index f06191963..09f0a2d98 100644
--- a/crates/ra_parser/src/grammar/expressions/atom.rs
+++ b/crates/ra_parser/src/grammar/expressions/atom.rs
@@ -248,7 +248,12 @@ fn lambda_expr(p: &mut Parser) -> CompletedMarker {
            p.error("expected `{`");
        }
    }
-    expr(p);
+    if p.at_ts(EXPR_FIRST) {
+        expr(p);
+    } else {
+        p.error("expected expression");
+    }
    m.complete(p, LAMBDA_EXPR)
 }
diff --git a/crates/ra_project_model/src/cargo_workspace.rs b/crates/ra_project_model/src/cargo_workspace.rs
index 4a0437da3..c862d3912 100644
--- a/crates/ra_project_model/src/cargo_workspace.rs
+++ b/crates/ra_project_model/src/cargo_workspace.rs
@@ -24,7 +24,7 @@ pub struct CargoWorkspace {
    pub(crate) workspace_root: PathBuf,
 }
-#[derive(Deserialize, Clone, Debug, PartialEq, Eq, Default)]
+#[derive(Deserialize, Clone, Debug, PartialEq, Eq)]
 #[serde(rename_all = "camelCase", default)]
 pub struct CargoFeatures {
    /// Do not activate the `default` feature.
@@ -38,6 +38,12 @@ pub struct CargoFeatures {
    pub features: Vec<String>,
 }
+impl Default for CargoFeatures {
+    fn default() -> Self {
+        CargoFeatures { no_default_features: false, all_features: true, features: Vec::new() }
+    }
+}
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub struct Package(RawId);
 impl_arena_id!(Package);
diff --git a/crates/ra_syntax/test_data/parser/err/0039_lambda_recovery.rs b/crates/ra_syntax/test_data/parser/err/0039_lambda_recovery.rs
new file mode 100644
index 000000000..a2f74bd87
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/err/0039_lambda_recovery.rs
@@ -0,0 +1,5 @@
+fn foo() -> i32 {
+    [1, 2, 3].iter()
+        .map(|it|)
+        .max::<i32>();
+}
diff --git a/crates/ra_syntax/test_data/parser/err/0039_lambda_recovery.txt b/crates/ra_syntax/test_data/parser/err/0039_lambda_recovery.txt
new file mode 100644
index 000000000..d1544634c
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/err/0039_lambda_recovery.txt
@@ -0,0 +1,83 @@
+SOURCE_FILE@[0; 83)
+  FN_DEF@[0; 82)
+    FN_KW@[0; 2) "fn"
+    WHITESPACE@[2; 3) " "
+    NAME@[3; 6)
+      IDENT@[3; 6) "foo"
+    PARAM_LIST@[6; 8)
+      L_PAREN@[6; 7) "("
+      R_PAREN@[7; 8) ")"
+    WHITESPACE@[8; 9) " "
+    RET_TYPE@[9; 15)
+      THIN_ARROW@[9; 11) "->"
+      WHITESPACE@[11; 12) " "
+      PATH_TYPE@[12; 15)
+        PATH@[12; 15)
+          PATH_SEGMENT@[12; 15)
+            NAME_REF@[12; 15)
+              IDENT@[12; 15) "i32"
+    WHITESPACE@[15; 16) " "
+    BLOCK_EXPR@[16; 82)
+      BLOCK@[16; 82)
+        L_CURLY@[16; 17) "{"
+        WHITESPACE@[17; 22) "\n    "
+        EXPR_STMT@[22; 80)
+          METHOD_CALL_EXPR@[22; 79)
+            METHOD_CALL_EXPR@[22; 57)
+              METHOD_CALL_EXPR@[22; 38)
+                ARRAY_EXPR@[22; 31)
+                  L_BRACK@[22; 23) "["
+                  LITERAL@[23; 24)
+                    INT_NUMBER@[23; 24) "1"
+                  COMMA@[24; 25) ","
+                  WHITESPACE@[25; 26) " "
+                  LITERAL@[26; 27)
+                    INT_NUMBER@[26; 27) "2"
+                  COMMA@[27; 28) ","
+                  WHITESPACE@[28; 29) " "
+                  LITERAL@[29; 30)
+                    INT_NUMBER@[29; 30) "3"
+                  R_BRACK@[30; 31) "]"
+                DOT@[31; 32) "."
+                NAME_REF@[32; 36)
+                  IDENT@[32; 36) "iter"
+                ARG_LIST@[36; 38)
+                  L_PAREN@[36; 37) "("
+                  R_PAREN@[37; 38) ")"
+              WHITESPACE@[38; 47) "\n        "
+              DOT@[47; 48) "."
+              NAME_REF@[48; 51)
+                IDENT@[48; 51) "map"
+              ARG_LIST@[51; 57)
+                L_PAREN@[51; 52) "("
+                LAMBDA_EXPR@[52; 56)
+                  PARAM_LIST@[52; 56)
+                    PIPE@[52; 53) "|"
+                    PARAM@[53; 55)
+                      BIND_PAT@[53; 55)
+                        NAME@[53; 55)
+                          IDENT@[53; 55) "it"
+                    PIPE@[55; 56) "|"
+                R_PAREN@[56; 57) ")"
+            WHITESPACE@[57; 66) "\n        "
+            DOT@[66; 67) "."
+            NAME_REF@[67; 70)
+              IDENT@[67; 70) "max"
+            TYPE_ARG_LIST@[70; 77)
+              COLONCOLON@[70; 72) "::"
+              L_ANGLE@[72; 73) "<"
+              TYPE_ARG@[73; 76)
+                PATH_TYPE@[73; 76)
+                  PATH@[73; 76)
+                    PATH_SEGMENT@[73; 76)
+                      NAME_REF@[73; 76)
+                        IDENT@[73; 76) "i32"
+              R_ANGLE@[76; 77) ">"
+            ARG_LIST@[77; 79)
+              L_PAREN@[77; 78) "("
+              R_PAREN@[78; 79) ")"
+          SEMI@[79; 80) ";"
+        WHITESPACE@[80; 81) "\n"
+        R_CURLY@[81; 82) "}"
+  WHITESPACE@[82; 83) "\n"
+error 56: expected expression