7 files changed, 168 insertions, 30 deletions

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())
     }
 }