fix: rename generator to coroutine also in dependencies

Follow the rename in nightly (see https://blog.rust-lang.org/inside-rust/2023/10/23/coroutines.html)

Author: mohe2015

Cargo.lock

@@ -23,10 +23,10 @@ oorandom = "11.1.3"
 tracing.workspace = true
 rustc-hash.workspace = true
 scoped-tls = "1.0.0"
-chalk-solve = { version = "0.95.0", default-features = false }
-chalk-ir = "0.95.0"
-chalk-recursive = { version = "0.95.0", default-features = false }
-chalk-derive = "0.95.0"
+chalk-solve = { version = "0.96.0", default-features = false }
+chalk-ir = "0.96.0"
+chalk-recursive = { version = "0.96.0", default-features = false }
+chalk-derive = "0.96.0"
 la-arena.workspace = true
 once_cell = "1.17.0"
 triomphe.workspace = true

crates/hir-ty/Cargo.toml

@@ -424,18 +424,18 @@ impl chalk_solve::RustIrDatabase<Interner> for ChalkContext<'_> {
     fn fn_def_name(&self, fn_def_id: chalk_ir::FnDefId<Interner>) -> String {
         format!("fn_{}", fn_def_id.0)
     }
-    fn generator_datum(
+    fn coroutine_datum(
         &self,
-        id: chalk_ir::GeneratorId<Interner>,
-    ) -> Arc<chalk_solve::rust_ir::GeneratorDatum<Interner>> {
+        id: chalk_ir::CoroutineId<Interner>,
+    ) -> Arc<chalk_solve::rust_ir::CoroutineDatum<Interner>> {
         let (parent, expr) = self.db.lookup_intern_coroutine(id.into());
 
         // We fill substitution with unknown type, because we only need to know whether the generic
         // params are types or consts to build `Binders` and those being filled up are for
         // `resume_type`, `yield_type`, and `return_type` of the coroutine in question.
         let subst = TyBuilder::subst_for_coroutine(self.db, parent).fill_with_unknown().build();
 
-        let input_output = rust_ir::GeneratorInputOutputDatum {
+        let input_output = rust_ir::CoroutineInputOutputDatum {
             resume_type: TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0))
                 .intern(Interner),
             yield_type: TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 1))
@@ -463,25 +463,25 @@ impl chalk_solve::RustIrDatabase<Interner> for ChalkContext<'_> {
             Movability::Movable => rust_ir::Movability::Movable,
         };
 
-        Arc::new(rust_ir::GeneratorDatum { movability, input_output })
+        Arc::new(rust_ir::CoroutineDatum { movability, input_output })
     }
-    fn generator_witness_datum(
+    fn coroutine_witness_datum(
         &self,
-        id: chalk_ir::GeneratorId<Interner>,
-    ) -> Arc<chalk_solve::rust_ir::GeneratorWitnessDatum<Interner>> {
+        id: chalk_ir::CoroutineId<Interner>,
+    ) -> Arc<chalk_solve::rust_ir::CoroutineWitnessDatum<Interner>> {
         // FIXME: calculate inner types
         let inner_types =
-            rust_ir::GeneratorWitnessExistential { types: wrap_empty_binders(vec![]) };
+            rust_ir::CoroutineWitnessExistential { types: wrap_empty_binders(vec![]) };
 
         let (parent, _) = self.db.lookup_intern_coroutine(id.into());
-        // See the comment in `generator_datum()` for unknown types.
+        // See the comment in `coroutine_datum()` for unknown types.
         let subst = TyBuilder::subst_for_coroutine(self.db, parent).fill_with_unknown().build();
         let it = subst
             .iter(Interner)
             .map(|it| it.constant(Interner).map(|c| c.data(Interner).ty.clone()));
         let inner_types = crate::make_type_and_const_binders(it, inner_types);
 
-        Arc::new(rust_ir::GeneratorWitnessDatum { inner_types })
+        Arc::new(rust_ir::CoroutineWitnessDatum { inner_types })
     }
 
     fn unification_database(&self) -> &dyn chalk_ir::UnificationDatabase<Interner> {
@@ -617,7 +617,7 @@ fn well_known_trait_from_lang_item(item: LangItem) -> Option<WellKnownTrait> {
         LangItem::Fn => WellKnownTrait::Fn,
         LangItem::FnMut => WellKnownTrait::FnMut,
         LangItem::FnOnce => WellKnownTrait::FnOnce,
-        LangItem::Coroutine => WellKnownTrait::Generator,
+        LangItem::Coroutine => WellKnownTrait::Coroutine,
         LangItem::Sized => WellKnownTrait::Sized,
         LangItem::Unpin => WellKnownTrait::Unpin,
         LangItem::Unsize => WellKnownTrait::Unsize,
@@ -639,7 +639,7 @@ fn lang_item_from_well_known_trait(trait_: WellKnownTrait) -> LangItem {
         WellKnownTrait::Fn => LangItem::Fn,
         WellKnownTrait::FnMut => LangItem::FnMut,
         WellKnownTrait::FnOnce => LangItem::FnOnce,
-        WellKnownTrait::Generator => LangItem::Coroutine,
+        WellKnownTrait::Coroutine => LangItem::Coroutine,
         WellKnownTrait::Sized => LangItem::Sized,
         WellKnownTrait::Tuple => LangItem::Tuple,
         WellKnownTrait::Unpin => LangItem::Unpin,

crates/hir-ty/src/chalk_db.rs

@@ -659,8 +659,8 @@ fn render_const_scalar(
         }
         TyKind::Never => f.write_str("!"),
         TyKind::Closure(_, _) => f.write_str("<closure>"),
-        TyKind::Generator(_, _) => f.write_str("<coroutine>"),
-        TyKind::GeneratorWitness(_, _) => f.write_str("<coroutine-witness>"),
+        TyKind::Coroutine(_, _) => f.write_str("<coroutine>"),
+        TyKind::CoroutineWitness(_, _) => f.write_str("<coroutine-witness>"),
         // The below arms are unreachable, since const eval will bail out before here.
         TyKind::Foreign(_) => f.write_str("<extern-type>"),
         TyKind::Error
@@ -1205,7 +1205,7 @@ impl HirDisplay for Ty {
                 write!(f, "{{unknown}}")?;
             }
             TyKind::InferenceVar(..) => write!(f, "_")?,
-            TyKind::Generator(_, subst) => {
+            TyKind::Coroutine(_, subst) => {
                 if f.display_target.is_source_code() {
                     return Err(HirDisplayError::DisplaySourceCodeError(
                         DisplaySourceCodeError::Coroutine,
@@ -1232,7 +1232,7 @@ impl HirDisplay for Ty {
                     write!(f, "{{coroutine}}")?;
                 }
             }
-            TyKind::GeneratorWitness(..) => write!(f, "{{coroutine witness}}")?,
+            TyKind::CoroutineWitness(..) => write!(f, "{{coroutine witness}}")?,
         }
         Ok(())
     }

crates/hir-ty/src/display.rs

@@ -51,7 +51,7 @@ impl InferenceContext<'_> {
         let _ = self.coerce(Some(closure_expr), closure_ty, &expected_ty);
 
         // Coroutines are not Fn* so return early.
-        if matches!(closure_ty.kind(Interner), TyKind::Generator(..)) {
+        if matches!(closure_ty.kind(Interner), TyKind::Coroutine(..)) {
             return;
         }
 

crates/hir-ty/src/infer/closure.rs

@@ -250,7 +250,7 @@ impl InferenceContext<'_> {
                             .build();
 
                         let coroutine_id = self.db.intern_coroutine((self.owner, tgt_expr)).into();
-                        let coroutine_ty = TyKind::Generator(coroutine_id, subst).intern(Interner);
+                        let coroutine_ty = TyKind::Coroutine(coroutine_id, subst).intern(Interner);
 
                         (None, coroutine_ty, Some((resume_ty, yield_ty)))
                     }

crates/hir-ty/src/infer/expr.rs

@@ -408,7 +408,7 @@ pub fn layout_of_ty_query(
             cx.univariant(dl, &fields, &ReprOptions::default(), StructKind::AlwaysSized)
                 .ok_or(LayoutError::Unknown)?
         }
-        TyKind::Generator(_, _) | TyKind::GeneratorWitness(_, _) => {
+        TyKind::Coroutine(_, _) | TyKind::CoroutineWitness(_, _) => {
             return Err(LayoutError::NotImplemented)
         }
         TyKind::Error => return Err(LayoutError::HasErrorType),

crates/hir-ty/src/layout.rs

@@ -103,15 +103,15 @@ impl From<crate::db::InternedClosureId> for chalk_ir::ClosureId<Interner> {
     }
 }
 
-impl From<chalk_ir::GeneratorId<Interner>> for crate::db::InternedCoroutineId {
-    fn from(id: chalk_ir::GeneratorId<Interner>) -> Self {
+impl From<chalk_ir::CoroutineId<Interner>> for crate::db::InternedCoroutineId {
+    fn from(id: chalk_ir::CoroutineId<Interner>) -> Self {
         Self::from_intern_id(id.0)
     }
 }
 
-impl From<crate::db::InternedCoroutineId> for chalk_ir::GeneratorId<Interner> {
+impl From<crate::db::InternedCoroutineId> for chalk_ir::CoroutineId<Interner> {
     fn from(id: crate::db::InternedCoroutineId) -> Self {
-        chalk_ir::GeneratorId(id.as_intern_id())
+        chalk_ir::CoroutineId(id.as_intern_id())
     }
 }
 

crates/hir-ty/src/mapping.rs

@@ -96,8 +96,8 @@ impl TyFingerprint {
             | TyKind::OpaqueType(_, _)
             | TyKind::FnDef(_, _)
             | TyKind::Closure(_, _)
-            | TyKind::Generator(..)
-            | TyKind::GeneratorWitness(..) => TyFingerprint::Unnameable,
+            | TyKind::Coroutine(..)
+            | TyKind::CoroutineWitness(..) => TyFingerprint::Unnameable,
             TyKind::Function(fn_ptr) => {
                 TyFingerprint::Function(fn_ptr.substitution.0.len(Interner) as u32)
             }

crates/hir-ty/src/method_resolution.rs

@@ -2147,8 +2147,8 @@ impl Evaluator<'_> {
             | TyKind::Str
             | TyKind::Never
             | TyKind::Closure(_, _)
-            | TyKind::Generator(_, _)
-            | TyKind::GeneratorWitness(_, _)
+            | TyKind::Coroutine(_, _)
+            | TyKind::CoroutineWitness(_, _)
             | TyKind::Foreign(_)
             | TyKind::Error
             | TyKind::Placeholder(_)
@@ -2635,8 +2635,8 @@ impl Evaluator<'_> {
             | TyKind::Str
             | TyKind::Never
             | TyKind::Closure(_, _)
-            | TyKind::Generator(_, _)
-            | TyKind::GeneratorWitness(_, _)
+            | TyKind::Coroutine(_, _)
+            | TyKind::CoroutineWitness(_, _)
             | TyKind::Foreign(_)
             | TyKind::Error
             | TyKind::Placeholder(_)

crates/hir-ty/src/mir/eval.rs

@@ -4103,8 +4103,8 @@ impl Type {
                 | TyKind::Function(_)
                 | TyKind::Alias(_)
                 | TyKind::Foreign(_)
-                | TyKind::Generator(..)
-                | TyKind::GeneratorWitness(..) => false,
+                | TyKind::Coroutine(..)
+                | TyKind::CoroutineWitness(..) => false,
             }
         }
     }