Bump chalk

Author: lnicola

Cargo.lock

@@ -27,8 +27,8 @@ test_utils = { path = "../test_utils" }
 
 scoped-tls = "1"
 
-chalk-solve = "0.11"
-chalk-ir = "0.11"
+chalk-solve = "0.14"
+chalk-ir = "0.14"
 
 [dev-dependencies]
 insta = "0.16.0"

crates/ra_hir_ty/Cargo.toml

@@ -664,6 +664,8 @@ fn test() {
 fn coerce_unsize_trait_object() {
     assert_snapshot!(
         infer_with_mismatches(r#"
+#[lang = "sized"]
+pub trait Sized {}
 #[lang = "unsize"]
 pub trait Unsize<T> {}
 #[lang = "coerce_unsized"]
@@ -689,19 +691,19 @@ fn test() {
 }
 "#, true),
         @r###"
-    388..573 '{     ...bj2; }': ()
-    398..401 'obj': &dyn Baz<i8, i16>
-    423..425 '&S': &S<i8, i16>
-    424..425 'S': S<i8, i16>
-    435..438 'obj': &dyn Bar<usize, i8, i16>
-    460..463 'obj': &dyn Baz<i8, i16>
-    473..476 'obj': &dyn Foo<i8, usize>
-    495..498 'obj': &dyn Bar<usize, i8, i16>
-    508..512 'obj2': &dyn Baz<i8, i16>
-    534..536 '&S': &S<i8, i16>
-    535..536 'S': S<i8, i16>
-    546..547 '_': &dyn Foo<i8, usize>
-    566..570 'obj2': &dyn Baz<i8, i16>
+    425..610 '{     ...bj2; }': ()
+    435..438 'obj': &dyn Baz<i8, i16>
+    460..462 '&S': &S<i8, i16>
+    461..462 'S': S<i8, i16>
+    472..475 'obj': &dyn Bar<usize, i8, i16>
+    497..500 'obj': &dyn Baz<i8, i16>
+    510..513 'obj': &dyn Foo<i8, usize>
+    532..535 'obj': &dyn Bar<usize, i8, i16>
+    545..549 'obj2': &dyn Baz<i8, i16>
+    571..573 '&S': &S<i8, i16>
+    572..573 'S': S<i8, i16>
+    583..584 '_': &dyn Foo<i8, usize>
+    603..607 'obj2': &dyn Baz<i8, i16>
     "###
     );
 }
@@ -710,6 +712,8 @@ fn test() {
 fn coerce_unsize_super_trait_cycle() {
     assert_snapshot!(
         infer_with_mismatches(r#"
+#[lang = "sized"]
+pub trait Sized {}
 #[lang = "unsize"]
 pub trait Unsize<T> {}
 #[lang = "coerce_unsized"]
@@ -734,12 +738,12 @@ fn test() {
 }
 "#, true),
         @r###"
-    292..348 '{     ...obj; }': ()
-    302..305 'obj': &dyn D
-    316..318 '&S': &S
-    317..318 'S': S
-    328..331 'obj': &dyn A
-    342..345 'obj': &dyn D
+    329..385 '{     ...obj; }': ()
+    339..342 'obj': &dyn D
+    353..355 '&S': &S
+    354..355 'S': S
+    365..368 'obj': &dyn A
+    379..382 'obj': &dyn D
     "###
     );
 }

crates/ra_hir_ty/src/tests/coercion.rs

@@ -1742,24 +1742,24 @@ fn test() {
 }
 "#),
         @r###"
-75..79 'self': Self
-81..85 'args': Args
-140..144 'self': &Self
-244..248 'self': &Bar<F>
-261..263 '{}': ()
-347..351 'self': Opt<T>
-353..354 'f': F
-369..371 '{}': ()
-385..501 '{     ...(f); }': ()
-395..398 'bar': Bar<fn(u8) -> u32>
-424..427 'bar': Bar<fn(u8) -> u32>
-424..433 'bar.foo()': {unknown}
-444..447 'opt': Opt<u8>
-466..467 'f': fn(u8) -> u32
-488..491 'opt': Opt<u8>
-488..498 'opt.map(f)': Opt<FnOnce::Output<fn(u8) -> u32, (u8,)>>
-496..497 'f': fn(u8) -> u32
-"###
+    75..79 'self': Self
+    81..85 'args': Args
+    140..144 'self': &Self
+    244..248 'self': &Bar<F>
+    261..263 '{}': ()
+    347..351 'self': Opt<T>
+    353..354 'f': F
+    369..371 '{}': ()
+    385..501 '{     ...(f); }': ()
+    395..398 'bar': Bar<fn(u8) -> u32>
+    424..427 'bar': Bar<fn(u8) -> u32>
+    424..433 'bar.foo()': (u8, u32)
+    444..447 'opt': Opt<u8>
+    466..467 'f': fn(u8) -> u32
+    488..491 'opt': Opt<u8>
+    488..498 'opt.map(f)': Opt<u32>
+    496..497 'f': fn(u8) -> u32
+    "###
     );
 }
 
@@ -1830,9 +1830,9 @@ fn test() {
     635..644 'Lazy::new': fn new<Foo, fn() -> Foo>(fn() -> Foo) -> Lazy<Foo, fn() -> Foo>
     635..661 'Lazy::...n_ptr)': Lazy<Foo, fn() -> Foo>
     645..660 'make_foo_fn_ptr': fn() -> Foo
-    671..673 'r2': {unknown}
+    671..673 'r2': usize
     676..681 'lazy2': Lazy<Foo, fn() -> Foo>
-    676..687 'lazy2.foo()': {unknown}
+    676..687 'lazy2.foo()': usize
     550..552 '{}': ()
     "###
     );

crates/ra_hir_ty/src/tests/traits.rs

@@ -128,8 +128,7 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
         well_known_trait: rust_ir::WellKnownTrait,
     ) -> Option<chalk_ir::TraitId<Interner>> {
         let lang_attr = lang_attr_from_well_known_trait(well_known_trait);
-        let lang_items = self.db.crate_lang_items(self.krate);
-        let trait_ = match lang_items.target(lang_attr) {
+        let trait_ = match self.db.lang_item(self.krate, lang_attr.into()) {
             Some(LangItemTarget::TraitId(trait_)) => trait_,
             _ => return None,
         };
@@ -186,6 +185,39 @@ impl<'a> chalk_solve::RustIrDatabase<Interner> for ChalkContext<'a> {
         // FIXME: implement actual object safety
         true
     }
+
+    fn closure_kind(
+        &self,
+        _closure_id: chalk_ir::ClosureId<Interner>,
+        _substs: &chalk_ir::Substitution<Interner>,
+    ) -> rust_ir::ClosureKind {
+        // FIXME: implement closure support
+        unimplemented!()
+    }
+    fn closure_inputs_and_output(
+        &self,
+        _closure_id: chalk_ir::ClosureId<Interner>,
+        _substs: &chalk_ir::Substitution<Interner>,
+    ) -> chalk_ir::Binders<rust_ir::FnDefInputsAndOutputDatum<Interner>> {
+        // FIXME: implement closure support
+        unimplemented!()
+    }
+    fn closure_upvars(
+        &self,
+        _closure_id: chalk_ir::ClosureId<Interner>,
+        _substs: &chalk_ir::Substitution<Interner>,
+    ) -> chalk_ir::Binders<chalk_ir::Ty<Interner>> {
+        // FIXME: implement closure support
+        unimplemented!()
+    }
+    fn closure_fn_substitution(
+        &self,
+        _closure_id: chalk_ir::ClosureId<Interner>,
+        _substs: &chalk_ir::Substitution<Interner>,
+    ) -> chalk_ir::Substitution<Interner> {
+        // FIXME: implement closure support
+        unimplemented!()
+    }
 }
 
 pub(crate) fn program_clauses_for_chalk_env_query(
@@ -272,20 +304,28 @@ pub(crate) fn trait_datum_query(
 
 fn well_known_trait_from_lang_attr(name: &str) -> Option<WellKnownTrait> {
     Some(match name {
-        "sized" => WellKnownTrait::SizedTrait,
-        "copy" => WellKnownTrait::CopyTrait,
-        "clone" => WellKnownTrait::CloneTrait,
-        "drop" => WellKnownTrait::DropTrait,
+        "sized" => WellKnownTrait::Sized,
+        "copy" => WellKnownTrait::Copy,
+        "clone" => WellKnownTrait::Clone,
+        "drop" => WellKnownTrait::Drop,
+        "fn_once" => WellKnownTrait::FnOnce,
+        "fn_mut" => WellKnownTrait::FnMut,
+        "fn" => WellKnownTrait::Fn,
+        "unsize" => WellKnownTrait::Unsize,
         _ => return None,
     })
 }
 
 fn lang_attr_from_well_known_trait(attr: WellKnownTrait) -> &'static str {
     match attr {
-        WellKnownTrait::SizedTrait => "sized",
-        WellKnownTrait::CopyTrait => "copy",
-        WellKnownTrait::CloneTrait => "clone",
-        WellKnownTrait::DropTrait => "drop",
+        WellKnownTrait::Sized => "sized",
+        WellKnownTrait::Copy => "copy",
+        WellKnownTrait::Clone => "clone",
+        WellKnownTrait::Drop => "drop",
+        WellKnownTrait::FnOnce => "fn_once",
+        WellKnownTrait::FnMut => "fn_mut",
+        WellKnownTrait::Fn => "fn",
+        WellKnownTrait::Unsize => "unsize",
     }
 }
 
@@ -309,8 +349,9 @@ pub(crate) fn struct_datum_query(
         .unwrap_or_else(Vec::new);
     let flags = rust_ir::AdtFlags {
         upstream,
-        // FIXME set fundamental flag correctly
+        // FIXME set fundamental and phantom_data flags correctly
         fundamental: false,
+        phantom_data: false,
     };
     let struct_datum_bound = rust_ir::AdtDatumBound {
         fields: Vec::new(), // FIXME add fields (only relevant for auto traits)
@@ -448,11 +489,23 @@ pub(crate) fn fn_def_datum_query(
     let where_clauses = convert_where_clauses(db, callable_def.into(), &bound_vars);
     let bound = rust_ir::FnDefDatumBound {
         // Note: Chalk doesn't actually use this information yet as far as I am aware, but we provide it anyway
-        argument_types: sig.value.params().iter().map(|ty| ty.clone().to_chalk(db)).collect(),
-        return_type: sig.value.ret().clone().to_chalk(db),
+        inputs_and_output: make_binders(
+            rust_ir::FnDefInputsAndOutputDatum {
+                argument_types: sig
+                    .value
+                    .params()
+                    .iter()
+                    .map(|ty| ty.clone().to_chalk(db))
+                    .collect(),
+                return_type: sig.value.ret().clone().to_chalk(db),
+            }
+            .shifted_in(&Interner),
+            0,
+        ),
         where_clauses,
     };
-    let datum = FnDefDatum { id: fn_def_id, binders: make_binders(bound, sig.num_binders) };
+    let datum =
+        FnDefDatum { id: fn_def_id, binders: make_binders(bound, sig.num_binders), abi: () };
     Arc::new(datum)
 }
 

crates/ra_hir_ty/src/traits/chalk.rs

@@ -42,6 +42,7 @@ impl chalk_ir::interner::Interner for Interner {
     type DefId = InternId;
     type InternedAdtId = crate::TypeCtorId;
     type Identifier = TypeAliasId;
+    type FnAbi = ();
 
     fn debug_adt_id(type_kind_id: AdtId, fmt: &mut fmt::Formatter<'_>) -> Option<fmt::Result> {
         tls::with_current_program(|prog| Some(prog?.debug_struct_id(type_kind_id, fmt)))