27 files changed, 369 insertions, 116 deletions

diff --git a/crates/ra_assists/src/ast_transform.rs b/crates/ra_assists/src/ast_transform.rs
index 0e53c1eee..42856f0ca 100644
--- a/crates/ra_assists/src/ast_transform.rs
+++ b/crates/ra_assists/src/ast_transform.rs
@@ -178,5 +178,10 @@ impl<'a> AstTransform<'a> for QualifyPaths<'a> {
 
 pub(crate) fn path_to_ast(path: hir::ModPath) -> ast::Path {
     let parse = ast::SourceFile::parse(&path.to_string());
-    parse.tree().syntax().descendants().find_map(ast::Path::cast).unwrap()
+    parse
+        .tree()
+        .syntax()
+        .descendants()
+        .find_map(ast::Path::cast)
+        .unwrap_or_else(|| panic!("failed to parse path {:?}, `{}`", path, path))
 }
diff --git a/crates/ra_cargo_watch/Cargo.toml b/crates/ra_cargo_watch/Cargo.toml
index 1fdbffea1..731d50371 100644
--- a/crates/ra_cargo_watch/Cargo.toml
+++ b/crates/ra_cargo_watch/Cargo.toml
@@ -6,7 +6,7 @@ authors = ["rust-analyzer developers"]
 
 [dependencies]
 crossbeam-channel = "0.4.0"
-lsp-types = { version = "0.71.0", features = ["proposed"] }
+lsp-types = { version = "0.72.0", features = ["proposed"] }
 log = "0.4.8"
 cargo_metadata = "0.9.1"
 serde_json = "1.0.48"
diff --git a/crates/ra_hir/src/semantics.rs b/crates/ra_hir/src/semantics.rs
index a0853957c..afc7f7ee7 100644
--- a/crates/ra_hir/src/semantics.rs
+++ b/crates/ra_hir/src/semantics.rs
@@ -107,8 +107,11 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
         self.analyze(field.syntax()).resolve_field(field)
     }
 
-    pub fn resolve_record_field(&self, field: &ast::RecordField) -> Option<StructField> {
-        self.analyze(field.syntax()).resolve_record_field(field)
+    pub fn resolve_record_field(
+        &self,
+        field: &ast::RecordField,
+    ) -> Option<(StructField, Option<Local>)> {
+        self.analyze(field.syntax()).resolve_record_field(self.db, field)
     }
 
     pub fn resolve_record_literal(&self, record_lit: &ast::RecordLit) -> Option<VariantDef> {
diff --git a/crates/ra_hir/src/source_analyzer.rs b/crates/ra_hir/src/source_analyzer.rs
index 4c121eb73..015389fb0 100644
--- a/crates/ra_hir/src/source_analyzer.rs
+++ b/crates/ra_hir/src/source_analyzer.rs
@@ -5,7 +5,7 @@
 //!
 //! So, this modules should not be used during hir construction, it exists
 //! purely for "IDE needs".
-use std::sync::Arc;
+use std::{iter::once, sync::Arc};
 
 use either::Either;
 use hir_def::{
@@ -25,8 +25,8 @@ use ra_syntax::{
 };
 
 use crate::{
-    db::HirDatabase, Adt, Const, EnumVariant, Function, Local, MacroDef, ModuleDef, Path, Static,
-    Struct, Trait, Type, TypeAlias, TypeParam,
+    db::HirDatabase, Adt, Const, EnumVariant, Function, Local, MacroDef, ModPath, ModuleDef, Path,
+    PathKind, Static, Struct, Trait, Type, TypeAlias, TypeParam,
 };
 
 /// `SourceAnalyzer` is a convenience wrapper which exposes HIR API in terms of
@@ -162,16 +162,27 @@ impl SourceAnalyzer {
 
     pub(crate) fn resolve_record_field(
         &self,
+        db: &impl HirDatabase,
         field: &ast::RecordField,
-    ) -> Option<crate::StructField> {
-        let expr_id = match field.expr() {
-            Some(it) => self.expr_id(&it)?,
+    ) -> Option<(crate::StructField, Option<Local>)> {
+        let (expr_id, local) = match field.expr() {
+            Some(it) => (self.expr_id(&it)?, None),
             None => {
                 let src = InFile { file_id: self.file_id, value: field };
-                self.body_source_map.as_ref()?.field_init_shorthand_expr(src)?
+                let expr_id = self.body_source_map.as_ref()?.field_init_shorthand_expr(src)?;
+                let local_name = field.name_ref()?.as_name();
+                let path = ModPath::from_segments(PathKind::Plain, once(local_name));
+                let local = match self.resolver.resolve_path_in_value_ns_fully(db, &path) {
+                    Some(ValueNs::LocalBinding(pat_id)) => {
+                        Some(Local { pat_id, parent: self.resolver.body_owner()? })
+                    }
+                    _ => None,
+                };
+                (expr_id, local)
             }
         };
-        self.infer.as_ref()?.record_field_resolution(expr_id).map(|it| it.into())
+        let struct_field = self.infer.as_ref()?.record_field_resolution(expr_id)?;
+        Some((struct_field.into(), local))
     }
 
     pub(crate) fn resolve_record_literal(
diff --git a/crates/ra_hir_def/src/nameres/tests.rs b/crates/ra_hir_def/src/nameres/tests.rs
index 82f0f835c..dda5ed699 100644
--- a/crates/ra_hir_def/src/nameres/tests.rs
+++ b/crates/ra_hir_def/src/nameres/tests.rs
@@ -66,6 +66,42 @@ fn crate_def_map_smoke_test() {
 }
 
 #[test]
+fn crate_def_map_super_super() {
+    let map = def_map(
+        "
+        //- /lib.rs
+        mod a {
+            const A: usize = 0;
+
+            mod b {
+                const B: usize = 0;
+
+                mod c {
+                    use super::super::*;
+                }
+            }
+        }
+        ",
+    );
+    assert_snapshot!(map, @r###"
+        ⋮crate
+        ⋮a: t
+        ⋮
+        ⋮crate::a
+        ⋮A: v
+        ⋮b: t
+        ⋮
+        ⋮crate::a::b
+        ⋮B: v
+        ⋮c: t
+        ⋮
+        ⋮crate::a::b::c
+        ⋮A: v
+        ⋮b: t
+    "###)
+}
+
+#[test]
 fn bogus_paths() {
     covers!(bogus_paths);
     let map = def_map(
diff --git a/crates/ra_hir_def/src/path/lower.rs b/crates/ra_hir_def/src/path/lower.rs
index 62aafd508..4900000fe 100644
--- a/crates/ra_hir_def/src/path/lower.rs
+++ b/crates/ra_hir_def/src/path/lower.rs
@@ -101,8 +101,8 @@ pub(super) fn lower_path(mut path: ast::Path, hygiene: &Hygiene) -> Option<Path>
                 break;
             }
             ast::PathSegmentKind::SuperKw => {
-                kind = PathKind::Super(1);
-                break;
+                let nested_super_count = if let PathKind::Super(n) = kind { n } else { 0 };
+                kind = PathKind::Super(nested_super_count + 1);
             }
         }
         path = match qualifier(&path) {
diff --git a/crates/ra_hir_def/src/path/lower/lower_use.rs b/crates/ra_hir_def/src/path/lower/lower_use.rs
index b6d1125e2..278d5196e 100644
--- a/crates/ra_hir_def/src/path/lower/lower_use.rs
+++ b/crates/ra_hir_def/src/path/lower/lower_use.rs
@@ -103,10 +103,13 @@ fn convert_path(prefix: Option<ModPath>, path: ast::Path, hygiene: &Hygiene) ->
             ModPath::from_segments(PathKind::Super(0), iter::empty())
         }
         ast::PathSegmentKind::SuperKw => {
-            if prefix.is_some() {
-                return None;
-            }
-            ModPath::from_segments(PathKind::Super(1), iter::empty())
+            let nested_super_count = match prefix.map(|p| p.kind) {
+                Some(PathKind::Super(n)) => n,
+                Some(_) => return None,
+                None => 0,
+            };
+
+            ModPath::from_segments(PathKind::Super(nested_super_count + 1), iter::empty())
         }
         ast::PathSegmentKind::Type { .. } => {
             // not allowed in imports
diff --git a/crates/ra_hir_ty/Cargo.toml b/crates/ra_hir_ty/Cargo.toml
index 99e2fe1bf..f2558b579 100644
--- a/crates/ra_hir_ty/Cargo.toml
+++ b/crates/ra_hir_ty/Cargo.toml
@@ -21,11 +21,9 @@ ra_prof = { path = "../ra_prof" }
 ra_syntax = { path = "../ra_syntax" }
 test_utils = { path = "../test_utils" }
 
-chalk-solve =   { git = "https://github.com/rust-lang/chalk.git", rev = "2939913fb7bb94ac2a6721087dc086be11410702" }
-chalk-rust-ir = { git = "https://github.com/rust-lang/chalk.git", rev = "2939913fb7bb94ac2a6721087dc086be11410702" }
-chalk-ir =      { git = "https://github.com/rust-lang/chalk.git", rev = "2939913fb7bb94ac2a6721087dc086be11410702" }
-
-lalrpop-intern = "0.15.1"
+chalk-solve =   { git = "https://github.com/rust-lang/chalk.git", rev = "177d71340acc7a7204a33115fc63075d86452179" }
+chalk-rust-ir = { git = "https://github.com/rust-lang/chalk.git", rev = "177d71340acc7a7204a33115fc63075d86452179" }
+chalk-ir =      { git = "https://github.com/rust-lang/chalk.git", rev = "177d71340acc7a7204a33115fc63075d86452179" }
 
 [dev-dependencies]
 insta = "0.13.1"
diff --git a/crates/ra_hir_ty/src/infer/pat.rs b/crates/ra_hir_ty/src/infer/pat.rs
index bf8ea192b..7a84e47f8 100644
--- a/crates/ra_hir_ty/src/infer/pat.rs
+++ b/crates/ra_hir_ty/src/infer/pat.rs
@@ -185,6 +185,19 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
                 self.write_pat_ty(pat, bound_ty);
                 return inner_ty;
             }
+            Pat::Slice { prefix, slice: _slice, suffix } => {
+                let (container_ty, elem_ty) = match &expected {
+                    ty_app!(TypeCtor::Array, st) => (TypeCtor::Array, st.as_single().clone()),
+                    ty_app!(TypeCtor::Slice, st) => (TypeCtor::Slice, st.as_single().clone()),
+                    _ => (TypeCtor::Slice, Ty::Unknown),
+                };
+
+                for pat_id in prefix.iter().chain(suffix) {
+                    self.infer_pat(*pat_id, &elem_ty, default_bm);
+                }
+
+                Ty::apply_one(container_ty, elem_ty)
+            }
             _ => Ty::Unknown,
         };
         // use a new type variable if we got Ty::Unknown here
diff --git a/crates/ra_hir_ty/src/infer/unify.rs b/crates/ra_hir_ty/src/infer/unify.rs
index aed527fe5..82b85d570 100644
--- a/crates/ra_hir_ty/src/infer/unify.rs
+++ b/crates/ra_hir_ty/src/infer/unify.rs
@@ -142,12 +142,21 @@ impl<T> Canonicalized<T> {
 
 pub fn unify(ty1: &Canonical<Ty>, ty2: &Canonical<Ty>) -> Option<Substs> {
     let mut table = InferenceTable::new();
+    let num_vars = ty1.num_vars.max(ty2.num_vars);
     let vars =
-        Substs::builder(ty1.num_vars).fill(std::iter::repeat_with(|| table.new_type_var())).build();
-    let ty_with_vars = ty1.value.clone().subst_bound_vars(&vars);
-    if !table.unify(&ty_with_vars, &ty2.value) {
+        Substs::builder(num_vars).fill(std::iter::repeat_with(|| table.new_type_var())).build();
+    let ty1_with_vars = ty1.value.clone().subst_bound_vars(&vars);
+    let ty2_with_vars = ty2.value.clone().subst_bound_vars(&vars);
+    if !table.unify(&ty1_with_vars, &ty2_with_vars) {
         return None;
     }
+    // default any type vars that weren't unified back to their original bound vars
+    // (kind of hacky)
+    for (i, var) in vars.iter().enumerate() {
+        if &*table.resolve_ty_shallow(var) == var {
+            table.unify(var, &Ty::Bound(i as u32));
+        }
+    }
     Some(
         Substs::builder(ty1.num_vars)
             .fill(vars.iter().map(|v| table.resolve_ty_completely(v.clone())))
diff --git a/crates/ra_hir_ty/src/lib.rs b/crates/ra_hir_ty/src/lib.rs
index 0009c426c..ca194f806 100644
--- a/crates/ra_hir_ty/src/lib.rs
+++ b/crates/ra_hir_ty/src/lib.rs
@@ -355,6 +355,10 @@ impl Substs {
         Substs(self.0[..std::cmp::min(self.0.len(), n)].into())
     }
 
+    pub fn suffix(&self, n: usize) -> Substs {
+        Substs(self.0[self.0.len() - std::cmp::min(self.0.len(), n)..].into())
+    }
+
     pub fn as_single(&self) -> &Ty {
         if self.0.len() != 1 {
             panic!("expected substs of len 1, got {:?}", self);
diff --git a/crates/ra_hir_ty/src/method_resolution.rs b/crates/ra_hir_ty/src/method_resolution.rs
index 74b908c2e..b7e8855fb 100644
--- a/crates/ra_hir_ty/src/method_resolution.rs
+++ b/crates/ra_hir_ty/src/method_resolution.rs
@@ -508,10 +508,17 @@ pub(crate) fn inherent_impl_substs(
     impl_id: ImplId,
     self_ty: &Canonical<Ty>,
 ) -> Option<Substs> {
-    let vars = Substs::build_for_def(db, impl_id).fill_with_bound_vars(0).build();
+    // we create a var for each type parameter of the impl; we need to keep in
+    // mind here that `self_ty` might have vars of its own
+    let vars =
+        Substs::build_for_def(db, impl_id).fill_with_bound_vars(self_ty.num_vars as u32).build();
     let self_ty_with_vars = db.impl_self_ty(impl_id).subst(&vars);
-    let self_ty_with_vars = Canonical { num_vars: vars.len(), value: self_ty_with_vars };
-    super::infer::unify(&self_ty_with_vars, self_ty)
+    let self_ty_with_vars =
+        Canonical { num_vars: vars.len() + self_ty.num_vars, value: self_ty_with_vars };
+    let substs = super::infer::unify(&self_ty_with_vars, self_ty);
+    // we only want the substs for the vars we added, not the ones from self_ty
+    let result = substs.map(|s| s.suffix(vars.len()));
+    result
 }
 
 fn transform_receiver_ty(
diff --git a/crates/ra_hir_ty/src/tests/method_resolution.rs b/crates/ra_hir_ty/src/tests/method_resolution.rs
index f9b394f05..af3e5b12c 100644
--- a/crates/ra_hir_ty/src/tests/method_resolution.rs
+++ b/crates/ra_hir_ty/src/tests/method_resolution.rs
@@ -1049,6 +1049,25 @@ where
 }
 
 #[test]
+fn method_resolution_3373() {
+    let t = type_at(
+        r#"
+//- /main.rs
+struct A<T>(T);
+
+impl A<i32> {
+    fn from(v: i32) -> A<i32> { A(v) }
+}
+
+fn main() {
+    A::from(3)<|>;
+}
+"#,
+    );
+    assert_eq!(t, "A<i32>");
+}
+
+#[test]
 fn method_resolution_slow() {
     // this can get quite slow if we set the solver size limit too high
     let t = type_at(
diff --git a/crates/ra_hir_ty/src/tests/patterns.rs b/crates/ra_hir_ty/src/tests/patterns.rs
index 81d00c2af..76aa32024 100644
--- a/crates/ra_hir_ty/src/tests/patterns.rs
+++ b/crates/ra_hir_ty/src/tests/patterns.rs
@@ -53,8 +53,9 @@ fn test(x: &i32) {
     [140; 141) 'g': {unknown}
     [144; 145) 'e': {unknown}
     [158; 205) 'if let...     }': ()
-    [165; 170) '[val]': {unknown}
-    [173; 176) 'opt': {unknown}
+    [165; 170) '[val]': [{unknown}]
+    [166; 169) 'val': {unknown}
+    [173; 176) 'opt': [{unknown}]
     [177; 205) '{     ...     }': ()
     [191; 192) 'h': {unknown}
     [195; 198) 'val': {unknown}
@@ -137,6 +138,94 @@ fn test() {
 }
 
 #[test]
+fn infer_pattern_match_slice() {
+    assert_snapshot!(
+        infer(r#"
+fn test() {
+    let slice: &[f64] = &[0.0];
+    match slice {
+        &[] => {},
+        &[a] => {
+            a;
+        },
+        &[b, c] => {
+            b;
+            c;
+        }
+        _ => {}
+    }
+}
+"#),
+    @r###"
+    [11; 210) '{     ...   } }': ()
+    [21; 26) 'slice': &[f64]
+    [37; 43) '&[0.0]': &[f64; _]
+    [38; 43) '[0.0]': [f64; _]
+    [39; 42) '0.0': f64
+    [49; 208) 'match ...     }': ()
+    [55; 60) 'slice': &[f64]
+    [71; 74) '&[]': &[f64]
+    [72; 74) '[]': [f64]
+    [78; 80) '{}': ()
+    [90; 94) '&[a]': &[f64]
+    [91; 94) '[a]': [f64]
+    [92; 93) 'a': f64
+    [98; 124) '{     ...     }': ()
+    [112; 113) 'a': f64
+    [134; 141) '&[b, c]': &[f64]
+    [135; 141) '[b, c]': [f64]
+    [136; 137) 'b': f64
+    [139; 140) 'c': f64
+    [145; 186) '{     ...     }': ()
+    [159; 160) 'b': f64
+    [174; 175) 'c': f64
+    [195; 196) '_': &[f64]
+    [200; 202) '{}': ()
+    "###
+    );
+}
+
+#[test]
+fn infer_pattern_match_arr() {
+    assert_snapshot!(
+        infer(r#"
+fn test() {
+    let arr: [f64; 2] = [0.0, 1.0];
+    match arr {
+        [1.0, a] => {
+            a;
+        },
+        [b, c] => {
+            b;
+            c;
+        }
+    }
+}
+"#),
+    @r###"
+    [11; 180) '{     ...   } }': ()
+    [21; 24) 'arr': [f64; _]
+    [37; 47) '[0.0, 1.0]': [f64; _]
+    [38; 41) '0.0': f64
+    [43; 46) '1.0': f64
+    [53; 178) 'match ...     }': ()
+    [59; 62) 'arr': [f64; _]
+    [73; 81) '[1.0, a]': [f64; _]
+    [74; 77) '1.0': f64
+    [79; 80) 'a': f64
+    [85; 111) '{     ...     }': ()
+    [99; 100) 'a': f64
+    [121; 127) '[b, c]': [f64; _]
+    [122; 123) 'b': f64
+    [125; 126) 'c': f64
+    [131; 172) '{     ...     }': ()
+    [145; 146) 'b': f64
+    [160; 161) 'c': f64
+    "###
+    );
+}
+
+#[test]
 fn infer_adt_pattern() {
     assert_snapshot!(
         infer(r#"
diff --git a/crates/ra_hir_ty/src/traits/chalk.rs b/crates/ra_hir_ty/src/traits/chalk.rs
index 4001aa941..62509bc29 100644
--- a/crates/ra_hir_ty/src/traits/chalk.rs
+++ b/crates/ra_hir_ty/src/traits/chalk.rs
@@ -18,7 +18,7 @@ use crate::{
 };
 
 #[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
-pub struct Interner {}
+pub struct Interner;
 
 impl chalk_ir::interner::Interner for Interner {
     type InternedType = Box<chalk_ir::TyData<Self>>;
@@ -27,6 +27,7 @@ impl chalk_ir::interner::Interner for Interner {
     type InternedGoal = Arc<GoalData<Self>>;
     type InternedGoals = Vec<Goal<Self>>;
     type InternedSubstitution = Vec<Parameter<Self>>;
+    type Identifier = TypeAliasId;
     type DefId = InternId;
 
     // FIXME: implement these
@@ -58,7 +59,7 @@ impl chalk_ir::interner::Interner for Interner {
         None
     }
 
-    fn intern_ty(ty: chalk_ir::TyData<Self>) -> Box<chalk_ir::TyData<Self>> {
+    fn intern_ty(&self, ty: chalk_ir::TyData<Self>) -> Box<chalk_ir::TyData<Self>> {
         Box::new(ty)
     }
 
@@ -121,7 +122,7 @@ pub type StructId = chalk_ir::StructId<Interner>;
 pub type StructDatum = chalk_rust_ir::StructDatum<Interner>;
 pub type ImplId = chalk_ir::ImplId<Interner>;
 pub type ImplDatum = chalk_rust_ir::ImplDatum<Interner>;
-pub type AssociatedTyValueId = chalk_rust_ir::AssociatedTyValueId;
+pub type AssociatedTyValueId = chalk_rust_ir::AssociatedTyValueId<Interner>;
 pub type AssociatedTyValue = chalk_rust_ir::AssociatedTyValue<Interner>;
 
 pub(super) trait ToChalk {
@@ -144,12 +145,12 @@ impl ToChalk for Ty {
             Ty::Apply(apply_ty) => {
                 let name = apply_ty.ctor.to_chalk(db);
                 let substitution = apply_ty.parameters.to_chalk(db);
-                chalk_ir::ApplicationTy { name, substitution }.cast().intern()
+                chalk_ir::ApplicationTy { name, substitution }.cast().intern(&Interner)
             }
             Ty::Projection(proj_ty) => {
                 let associated_ty_id = proj_ty.associated_ty.to_chalk(db);
                 let substitution = proj_ty.parameters.to_chalk(db);
-                chalk_ir::AliasTy { associated_ty_id, substitution }.cast().intern()
+                chalk_ir::AliasTy { associated_ty_id, substitution }.cast().intern(&Interner)
             }
             Ty::Placeholder(id) => {
                 let interned_id = db.intern_type_param_id(id);
@@ -157,9 +158,9 @@ impl ToChalk for Ty {
                     ui: UniverseIndex::ROOT,
                     idx: interned_id.as_intern_id().as_usize(),
                 }
-                .to_ty::<Interner>()
+                .to_ty::<Interner>(&Interner)
             }
-            Ty::Bound(idx) => chalk_ir::TyData::BoundVar(idx as usize).intern(),
+            Ty::Bound(idx) => chalk_ir::TyData::BoundVar(idx as usize).intern(&Interner),
             Ty::Infer(_infer_ty) => panic!("uncanonicalized infer ty"),
             Ty::Dyn(predicates) => {
                 let where_clauses = predicates
@@ -169,12 +170,12 @@ impl ToChalk for Ty {
                     .map(|p| p.to_chalk(db))
                     .collect();
                 let bounded_ty = chalk_ir::DynTy { bounds: make_binders(where_clauses, 1) };
-                chalk_ir::TyData::Dyn(bounded_ty).intern()
+                chalk_ir::TyData::Dyn(bounded_ty).intern(&Interner)
             }
             Ty::Opaque(_) | Ty::Unknown => {
                 let substitution = chalk_ir::Substitution::empty();
                 let name = TypeName::Error;
-                chalk_ir::ApplicationTy { name, substitution }.cast().intern()
+                chalk_ir::ApplicationTy { name, substitution }.cast().intern(&Interner)
             }
         }
     }
@@ -611,6 +612,9 @@ where
             _ => None,
         }
     }
+    fn interner(&self) -> &Interner {
+        &Interner
+    }
 }
 
 pub(crate) fn associated_ty_data_query(
@@ -632,7 +636,7 @@ pub(crate) fn associated_ty_data_query(
     let datum = AssociatedTyDatum {
         trait_id: trait_.to_chalk(db),
         id,
-        name: lalrpop_intern::intern(&db.type_alias_data(type_alias).name.to_string()),
+        name: type_alias,
         binders: make_binders(bound_data, generic_params.len()),
     };
     Arc::new(datum)
@@ -822,13 +826,6 @@ fn type_alias_associated_ty_value(
     Arc::new(value)
 }
 
-fn id_from_chalk<T: InternKey>(chalk_id: chalk_ir::RawId) -> T {
-    T::from_intern_id(InternId::from(chalk_id.index))
-}
-fn id_to_chalk<T: InternKey>(salsa_id: T) -> chalk_ir::RawId {
-    chalk_ir::RawId { index: salsa_id.as_intern_id().as_u32() }
-}
-
 impl From<StructId> for crate::TypeCtorId {
     fn from(struct_id: StructId) -> Self {
         InternKey::from_intern_id(struct_id.0)
@@ -853,14 +850,14 @@ impl From<crate::traits::GlobalImplId> for ImplId {
     }
 }
 
-impl From<chalk_rust_ir::AssociatedTyValueId> for crate::traits::AssocTyValueId {
-    fn from(id: chalk_rust_ir::AssociatedTyValueId) -> Self {
-        id_from_chalk(id.0)
+impl From<chalk_rust_ir::AssociatedTyValueId<Interner>> for crate::traits::AssocTyValueId {
+    fn from(id: chalk_rust_ir::AssociatedTyValueId<Interner>) -> Self {
+        Self::from_intern_id(id.0)
     }
 }
 
-impl From<crate::traits::AssocTyValueId> for chalk_rust_ir::AssociatedTyValueId {
+impl From<crate::traits::AssocTyValueId> for chalk_rust_ir::AssociatedTyValueId<Interner> {
     fn from(assoc_ty_value_id: crate::traits::AssocTyValueId) -> Self {
-        chalk_rust_ir::AssociatedTyValueId(id_to_chalk(assoc_ty_value_id))
+        chalk_rust_ir::AssociatedTyValueId(assoc_ty_value_id.as_intern_id())
     }
 }
diff --git a/crates/ra_ide/src/completion/complete_dot.rs b/crates/ra_ide/src/completion/complete_dot.rs
index a6e0158b2..9145aa183 100644
--- a/crates/ra_ide/src/completion/complete_dot.rs
+++ b/crates/ra_ide/src/completion/complete_dot.rs
@@ -545,4 +545,43 @@ mod tests {
         "###
         )
     }
+
+    #[test]
+    fn test_super_super_completion() {
+        assert_debug_snapshot!(
+        do_ref_completion(
+                r"
+                mod a {
+                    const A: usize = 0;
+
+                    mod b {
+                        const B: usize = 0;
+
+                        mod c {
+                            use super::super::<|>
+                        }
+                    }
+                }
+                ",
+        ),
+            @r###"
+        [
+            CompletionItem {
+                label: "A",
+                source_range: [217; 217),
+                delete: [217; 217),
+                insert: "A",
+                kind: Const,
+            },
+            CompletionItem {
+                label: "b",
+                source_range: [217; 217),
+                delete: [217; 217),
+                insert: "b",
+                kind: Module,
+            },
+        ]
+        "###
+        );
+    }
 }
diff --git a/crates/ra_ide/src/goto_definition.rs b/crates/ra_ide/src/goto_definition.rs
index e67585203..76ee232a3 100644
--- a/crates/ra_ide/src/goto_definition.rs
+++ b/crates/ra_ide/src/goto_definition.rs
@@ -76,6 +76,8 @@ pub(crate) fn reference_definition(
 
     let name_kind = classify_name_ref(sema, name_ref);
     if let Some(def) = name_kind {
+        let def = def.definition();
+
         return match def.try_to_nav(sema.db) {
             Some(nav) => ReferenceResult::Exact(nav),
             None => ReferenceResult::Approximate(Vec::new()),
@@ -795,8 +797,8 @@ mod tests {
                 Foo { x<|> };
             }
             ",
-            "x RECORD_FIELD_DEF FileId(1) [13; 19) [13; 14)",
-            "x: i32|x",
+            "x BIND_PAT FileId(1) [42; 43)",
+            "x",
         )
     }
 }
diff --git a/crates/ra_ide/src/hover.rs b/crates/ra_ide/src/hover.rs
index 5073bb1cf..b31956626 100644
--- a/crates/ra_ide/src/hover.rs
+++ b/crates/ra_ide/src/hover.rs
@@ -153,7 +153,7 @@ pub(crate) fn hover(db: &RootDatabase, position: FilePosition) -> Option<RangeIn
     if let Some((node, name_kind)) = match_ast! {
         match (token.parent()) {
             ast::NameRef(name_ref) => {
-                classify_name_ref(&sema, &name_ref).map(|d| (name_ref.syntax().clone(), d))
+                classify_name_ref(&sema, &name_ref).map(|d| (name_ref.syntax().clone(), d.definition()))
             },
             ast::Name(name) => {
                 classify_name(&sema, &name).map(|d| (name.syntax().clone(), d.definition()))
diff --git a/crates/ra_ide/src/references.rs b/crates/ra_ide/src/references.rs
index f763013ae..2eb047c96 100644
--- a/crates/ra_ide/src/references.rs
+++ b/crates/ra_ide/src/references.rs
@@ -27,7 +27,10 @@ use test_utils::tested_by;
 
 use crate::{display::TryToNav, FilePosition, FileRange, NavigationTarget, RangeInfo};
 
-pub(crate) use self::{classify::classify_name_ref, rename::rename};
+pub(crate) use self::{
+    classify::{classify_name_ref, NameRefClass},
+    rename::rename,
+};
 pub(crate) use ra_ide_db::defs::{classify_name, NameDefinition};
 
 pub use self::search_scope::SearchScope;
@@ -160,7 +163,7 @@ fn find_name(
         return Some(RangeInfo::new(range, (name.text().to_string(), def)));
     }
     let name_ref = find_node_at_offset::<ast::NameRef>(&syntax, position.offset)?;
-    let def = classify_name_ref(sema, &name_ref)?;
+    let def = classify_name_ref(sema, &name_ref)?.definition();
     let range = name_ref.syntax().text_range();
     Some(RangeInfo::new(range, (name_ref.text().to_string(), def)))
 }
@@ -212,6 +215,7 @@ fn process_definition(
             // See https://github.com/rust-lang/rust/pull/68198#issuecomment-574269098
 
             if let Some(d) = classify_name_ref(&sema, &name_ref) {
+                let d = d.definition();
                 if d == def {
                     let kind =
                         if is_record_lit_name_ref(&name_ref) || is_call_expr_name_ref(&name_ref) {
diff --git a/crates/ra_ide/src/references/classify.rs b/crates/ra_ide/src/references/classify.rs
index fdd07d8d1..571236fdc 100644
--- a/crates/ra_ide/src/references/classify.rs
+++ b/crates/ra_ide/src/references/classify.rs
@@ -1,18 +1,30 @@
 //! Functions that are used to classify an element from its definition or reference.
 
-use hir::{PathResolution, Semantics};
+use hir::{Local, PathResolution, Semantics};
 use ra_ide_db::defs::NameDefinition;
 use ra_ide_db::RootDatabase;
 use ra_prof::profile;
 use ra_syntax::{ast, AstNode};
 use test_utils::tested_by;
 
-pub use ra_ide_db::defs::{from_module_def, from_struct_field};
+pub enum NameRefClass {
+    NameDefinition(NameDefinition),
+    FieldShorthand { local: Local, field: NameDefinition },
+}
+
+impl NameRefClass {
+    pub fn definition(self) -> NameDefinition {
+        match self {
+            NameRefClass::NameDefinition(def) => def,
+            NameRefClass::FieldShorthand { local, field: _ } => NameDefinition::Local(local),
+        }
+    }
+}
 
 pub(crate) fn classify_name_ref(
     sema: &Semantics<RootDatabase>,
     name_ref: &ast::NameRef,
-) -> Option<NameDefinition> {
+) -> Option<NameRefClass> {
     let _p = profile("classify_name_ref");
 
     let parent = name_ref.syntax().parent()?;
@@ -20,48 +32,53 @@ pub(crate) fn classify_name_ref(
     if let Some(method_call) = ast::MethodCallExpr::cast(parent.clone()) {
         tested_by!(goto_def_for_methods);
         if let Some(func) = sema.resolve_method_call(&method_call) {
-            return Some(from_module_def(func.into()));
+            return Some(NameRefClass::NameDefinition(NameDefinition::ModuleDef(func.into())));
         }
     }
 
     if let Some(field_expr) = ast::FieldExpr::cast(parent.clone()) {
         tested_by!(goto_def_for_fields);
         if let Some(field) = sema.resolve_field(&field_expr) {
-            return Some(from_struct_field(field));
+            return Some(NameRefClass::NameDefinition(NameDefinition::StructField(field)));
         }
     }
 
     if let Some(record_field) = ast::RecordField::cast(parent.clone()) {
         tested_by!(goto_def_for_record_fields);
         tested_by!(goto_def_for_field_init_shorthand);
-        if let Some(field_def) = sema.resolve_record_field(&record_field) {
-            return Some(from_struct_field(field_def));
+        if let Some((field, local)) = sema.resolve_record_field(&record_field) {
+            let field = NameDefinition::StructField(field);
+            let res = match local {
+                None => NameRefClass::NameDefinition(field),
+                Some(local) => NameRefClass::FieldShorthand { field, local },
+            };
+            return Some(res);
         }
     }
 
     if let Some(macro_call) = parent.ancestors().find_map(ast::MacroCall::cast) {
         tested_by!(goto_def_for_macros);
         if let Some(macro_def) = sema.resolve_macro_call(&macro_call) {
-            return Some(NameDefinition::Macro(macro_def));
+            return Some(NameRefClass::NameDefinition(NameDefinition::Macro(macro_def)));
         }
     }
 
     let path = name_ref.syntax().ancestors().find_map(ast::Path::cast)?;
     let resolved = sema.resolve_path(&path)?;
     let res = match resolved {
-        PathResolution::Def(def) => from_module_def(def),
+        PathResolution::Def(def) => NameDefinition::ModuleDef(def),
         PathResolution::AssocItem(item) => {
             let def = match item {
                 hir::AssocItem::Function(it) => it.into(),
                 hir::AssocItem::Const(it) => it.into(),
                 hir::AssocItem::TypeAlias(it) => it.into(),
             };
-            from_module_def(def)
+            NameDefinition::ModuleDef(def)
         }
         PathResolution::Local(local) => NameDefinition::Local(local),
         PathResolution::TypeParam(par) => NameDefinition::TypeParam(par),
         PathResolution::Macro(def) => NameDefinition::Macro(def),
         PathResolution::SelfType(impl_def) => NameDefinition::SelfType(impl_def),
     };
-    Some(res)
+    Some(NameRefClass::NameDefinition(res))
 }
diff --git a/crates/ra_ide/src/syntax_highlighting.rs b/crates/ra_ide/src/syntax_highlighting.rs
index 28117b4d8..b89501aff 100644
--- a/crates/ra_ide/src/syntax_highlighting.rs
+++ b/crates/ra_ide/src/syntax_highlighting.rs
@@ -19,7 +19,11 @@ use ra_syntax::{
 };
 use rustc_hash::FxHashMap;
 
-use crate::{call_info::call_info_for_token, references::classify_name_ref, Analysis, FileId};
+use crate::{
+    call_info::call_info_for_token,
+    references::{classify_name_ref, NameRefClass},
+    Analysis, FileId,
+};
 
 pub(crate) use html::highlight_as_html;
 pub use tags::{Highlight, HighlightModifier, HighlightModifiers, HighlightTag};
@@ -186,24 +190,24 @@ fn highlight_element(
         }
 
         // Highlight references like the definitions they resolve to
-
-        // Special-case field init shorthand
-        NAME_REF if element.parent().and_then(ast::RecordField::cast).is_some() => {
-            HighlightTag::Field.into()
-        }
         NAME_REF if element.ancestors().any(|it| it.kind() == ATTR) => return None,
         NAME_REF => {
             let name_ref = element.into_node().and_then(ast::NameRef::cast).unwrap();
             let name_kind = classify_name_ref(sema, &name_ref)?;
 
-            if let NameDefinition::Local(local) = &name_kind {
-                if let Some(name) = local.name(db) {
-                    let shadow_count = bindings_shadow_count.entry(name.clone()).or_default();
-                    binding_hash = Some(calc_binding_hash(&name, *shadow_count))
+            match name_kind {
+                NameRefClass::NameDefinition(def) => {
+                    if let NameDefinition::Local(local) = &def {
+                        if let Some(name) = local.name(db) {
+                            let shadow_count =
+                                bindings_shadow_count.entry(name.clone()).or_default();
+                            binding_hash = Some(calc_binding_hash(&name, *shadow_count))
+                        }
+                    };
+                    highlight_name(db, def)
                 }
-            };
-
-            highlight_name(db, name_kind)
+                NameRefClass::FieldShorthand { .. } => HighlightTag::Field.into(),
+            }
         }
 
         // Simple token-based highlighting
diff --git a/crates/ra_ide_db/src/defs.rs b/crates/ra_ide_db/src/defs.rs
index ad4638906..7b1030a14 100644
--- a/crates/ra_ide_db/src/defs.rs
+++ b/crates/ra_ide_db/src/defs.rs
@@ -111,47 +111,47 @@ fn classify_name_inner(sema: &Semantics<RootDatabase>, name: &ast::Name) -> Opti
             },
             ast::RecordFieldDef(it) => {
                 let field: hir::StructField = sema.to_def(&it)?;
-                Some(from_struct_field(field))
+                Some(NameDefinition::StructField(field))
             },
             ast::Module(it) => {
                 let def = sema.to_def(&it)?;
-                Some(from_module_def(def.into()))
+                Some(NameDefinition::ModuleDef(def.into()))
             },
             ast::StructDef(it) => {
                 let def: hir::Struct = sema.to_def(&it)?;
-                Some(from_module_def(def.into()))
+                Some(NameDefinition::ModuleDef(def.into()))
             },
             ast::UnionDef(it) => {
                 let def: hir::Union = sema.to_def(&it)?;
-                Some(from_module_def(def.into()))
+                Some(NameDefinition::ModuleDef(def.into()))
             },
             ast::EnumDef(it) => {
                 let def: hir::Enum = sema.to_def(&it)?;
-                Some(from_module_def(def.into()))
+                Some(NameDefinition::ModuleDef(def.into()))
             },
             ast::TraitDef(it) => {
                 let def: hir::Trait = sema.to_def(&it)?;
-                Some(from_module_def(def.into()))
+                Some(NameDefinition::ModuleDef(def.into()))
             },
             ast::StaticDef(it) => {
                 let def: hir::Static = sema.to_def(&it)?;
-                Some(from_module_def(def.into()))
+                Some(NameDefinition::ModuleDef(def.into()))
             },
             ast::EnumVariant(it) => {
                 let def: hir::EnumVariant = sema.to_def(&it)?;
-                Some(from_module_def(def.into()))
+                Some(NameDefinition::ModuleDef(def.into()))
             },
             ast::FnDef(it) => {
                 let def: hir::Function = sema.to_def(&it)?;
-                Some(from_module_def(def.into()))
+                Some(NameDefinition::ModuleDef(def.into()))
             },
             ast::ConstDef(it) => {
                 let def: hir::Const = sema.to_def(&it)?;
-                Some(from_module_def(def.into()))
+                Some(NameDefinition::ModuleDef(def.into()))
             },
             ast::TypeAliasDef(it) => {
                 let def: hir::TypeAlias = sema.to_def(&it)?;
-                Some(from_module_def(def.into()))
+                Some(NameDefinition::ModuleDef(def.into()))
             },
             ast::MacroCall(it) => {
                 let def = sema.to_def(&it)?;
@@ -165,11 +165,3 @@ fn classify_name_inner(sema: &Semantics<RootDatabase>, name: &ast::Name) -> Opti
         }
     }
 }
-
-pub fn from_struct_field(field: StructField) -> NameDefinition {
-    NameDefinition::StructField(field)
-}
-
-pub fn from_module_def(def: ModuleDef) -> NameDefinition {
-    NameDefinition::ModuleDef(def)
-}
diff --git a/crates/rust-analyzer/Cargo.toml b/crates/rust-analyzer/Cargo.toml
index d00545121..b14ebb268 100644
--- a/crates/rust-analyzer/Cargo.toml
+++ b/crates/rust-analyzer/Cargo.toml
@@ -20,7 +20,7 @@ globset = "0.4.4"
 itertools = "0.8.2"
 jod-thread = "0.1.0"
 log = "0.4.8"
-lsp-types = { version = "0.71.0", features = ["proposed"] }
+lsp-types = { version = "0.72.0", features = ["proposed"] }
 parking_lot = "0.10.0"
 pico-args = "0.3.1"
 rand = { version = "0.7.3", features = ["small_rng"] }
diff --git a/crates/rust-analyzer/src/caps.rs b/crates/rust-analyzer/src/caps.rs
index 759bceb32..45b60768a 100644
--- a/crates/rust-analyzer/src/caps.rs
+++ b/crates/rust-analyzer/src/caps.rs
@@ -63,8 +63,8 @@ pub fn server_capabilities() -> ServerCapabilities {
         semantic_tokens_provider: Some(
             SemanticTokensOptions {
                 legend: SemanticTokensLegend {
-                    token_types: semantic_tokens::SUPPORTED_TYPES.iter().cloned().collect(),
-                    token_modifiers: semantic_tokens::SUPPORTED_MODIFIERS.iter().cloned().collect(),
+                    token_types: semantic_tokens::SUPPORTED_TYPES.to_vec(),
+                    token_modifiers: semantic_tokens::SUPPORTED_MODIFIERS.to_vec(),
                 },
 
                 document_provider: Some(SemanticTokensDocumentProvider::Bool(true)),
diff --git a/crates/rust-analyzer/src/main_loop/handlers.rs b/crates/rust-analyzer/src/main_loop/handlers.rs
index 6f517760f..f51263f22 100644
--- a/crates/rust-analyzer/src/main_loop/handlers.rs
+++ b/crates/rust-analyzer/src/main_loop/handlers.rs
@@ -184,6 +184,10 @@ pub fn handle_on_type_formatting(
     // `text.char_at(position) == typed_char`.
     position.offset -= TextUnit::of_char('.');
     let char_typed = params.ch.chars().next().unwrap_or('\0');
+    assert!({
+        let text = world.analysis().file_text(position.file_id)?;
+        text[position.offset.to_usize()..].starts_with(char_typed)
+    });
 
     // We have an assist that inserts ` ` after typing `->` in `fn foo() ->{`,
     // but it requires precise cursor positioning to work, and one can't
diff --git a/crates/rust-analyzer/src/req.rs b/crates/rust-analyzer/src/req.rs
index fd6aef597..a3efe3b9f 100644
--- a/crates/rust-analyzer/src/req.rs
+++ b/crates/rust-analyzer/src/req.rs
@@ -42,14 +42,14 @@ impl Request for SyntaxTree {
     const METHOD: &'static str = "rust-analyzer/syntaxTree";
 }
 
-#[derive(Deserialize, Debug)]
+#[derive(Deserialize, Serialize, Debug)]
 #[serde(rename_all = "camelCase")]
 pub struct SyntaxTreeParams {
     pub text_document: TextDocumentIdentifier,
     pub range: Option<Range>,
 }
 
-#[derive(Serialize, Debug)]
+#[derive(Deserialize, Serialize, Debug)]
 #[serde(rename_all = "camelCase")]
 pub struct ExpandedMacro {
     pub name: String,
@@ -64,7 +64,7 @@ impl Request for ExpandMacro {
     const METHOD: &'static str = "rust-analyzer/expandMacro";
 }
 
-#[derive(Deserialize, Debug)]
+#[derive(Deserialize, Serialize, Debug)]
 #[serde(rename_all = "camelCase")]
 pub struct ExpandMacroParams {
     pub text_document: TextDocumentIdentifier,
@@ -79,7 +79,7 @@ impl Request for FindMatchingBrace {
     const METHOD: &'static str = "rust-analyzer/findMatchingBrace";
 }
 
-#[derive(Deserialize, Debug)]
+#[derive(Deserialize, Serialize, Debug)]
 #[serde(rename_all = "camelCase")]
 pub struct FindMatchingBraceParams {
     pub text_document: TextDocumentIdentifier,
@@ -101,14 +101,14 @@ impl Notification for PublishDecorations {
     const METHOD: &'static str = "rust-analyzer/publishDecorations";
 }
 
-#[derive(Serialize, Debug)]
+#[derive(Deserialize, Serialize, Debug)]
 #[serde(rename_all = "camelCase")]
 pub struct PublishDecorationsParams {
     pub uri: Url,
     pub decorations: Vec<Decoration>,
 }
 
-#[derive(Serialize, Debug)]
+#[derive(Deserialize, Serialize, Debug)]
 #[serde(rename_all = "camelCase")]
 pub struct Decoration {
     pub range: Range,
@@ -132,7 +132,7 @@ impl Request for JoinLines {
     const METHOD: &'static str = "rust-analyzer/joinLines";
 }
 
-#[derive(Deserialize, Debug)]
+#[derive(Deserialize, Serialize, Debug)]
 #[serde(rename_all = "camelCase")]
 pub struct JoinLinesParams {
     pub text_document: TextDocumentIdentifier,
@@ -162,7 +162,7 @@ pub struct RunnablesParams {
     pub position: Option<Position>,
 }
 
-#[derive(Serialize, Debug)]
+#[derive(Deserialize, Serialize, Debug)]
 #[serde(rename_all = "camelCase")]
 pub struct Runnable {
     pub range: Range,
@@ -173,7 +173,7 @@ pub struct Runnable {
     pub cwd: Option<String>,
 }
 
-#[derive(Serialize, Debug)]
+#[derive(Deserialize, Serialize, Debug)]
 #[serde(rename_all = "camelCase")]
 pub struct SourceChange {
     pub label: String,
diff --git a/crates/rust-analyzer/src/semantic_tokens.rs b/crates/rust-analyzer/src/semantic_tokens.rs
index 1b146e4d8..d9ba77050 100644
--- a/crates/rust-analyzer/src/semantic_tokens.rs
+++ b/crates/rust-analyzer/src/semantic_tokens.rs
@@ -49,12 +49,9 @@ pub(crate) const SUPPORTED_MODIFIERS: &[SemanticTokenModifier] = &[
     SemanticTokenModifier::DOCUMENTATION,
     SemanticTokenModifier::DECLARATION,
     SemanticTokenModifier::DEFINITION,
-    SemanticTokenModifier::REFERENCE,
     SemanticTokenModifier::STATIC,
     SemanticTokenModifier::ABSTRACT,
     SemanticTokenModifier::DEPRECATED,
-    SemanticTokenModifier::ASYNC,
-    SemanticTokenModifier::VOLATILE,
     SemanticTokenModifier::READONLY,
     CONSTANT,
     MUTABLE,