Rename trait Value as FromCycleError.

`Value` is an unhelpfully generic name. Standard naming procedure for a
trait with a single method is for the trait name to match the method
name, which is what this commit does. Likewise, the enclosing module is
renamed from `values` to `from_cycle_error`.

Also add a comment about some non-obvious behaviour.

Author: nnethercote

compiler/rustc_middle/src/queries.rs

@@ -150,10 +150,10 @@ use crate::{dep_graph, mir, thir};
 // `Providers` that the driver creates (using several `rustc_*` crates).
 //
 // The result type of each query must implement `Clone`, and additionally
-// `ty::query::values::Value`, which produces an appropriate placeholder
-// (error) value if the query resulted in a query cycle.
+// `ty::query::from_cycle_error::FromCycleError`, which produces an appropriate
+// placeholder (error) value if the query resulted in a query cycle.
 // Queries marked with `cycle_fatal` do not need the latter implementation,
-// as they will raise an fatal error on query cycles instead.
+// as they will raise a fatal error on query cycles instead.
 rustc_queries! {
     /// Caches the expansion of a derive proc macro, e.g. `#[derive(Serialize)]`.
     /// The key is:

compiler/rustc_query_impl/src/values.rs …rustc_query_impl/src/from_cycle_error.rscompiler/rustc_query_impl/src/values.rs renamed to compiler/rustc_query_impl/src/from_cycle_error.rs compiler/rustc_query_impl/src/values.rs renamed to compiler/rustc_query_impl/src/from_cycle_error.rs

@@ -17,19 +17,23 @@ use rustc_span::{ErrorGuaranteed, Span};
 
 use crate::job::report_cycle;
 
-pub(crate) trait Value<'tcx>: Sized {
+pub(crate) trait FromCycleError<'tcx>: Sized {
+    /// Try to produce a `Self` value that represents an error form (e.g. `TyKind::Error`).
+    ///
+    /// Note: the default impl calls `raise_fatal`, ending compilation immediately! Only a few
+    /// types override this with a non-fatal impl.
     fn from_cycle_error(tcx: TyCtxt<'tcx>, cycle_error: CycleError, guar: ErrorGuaranteed) -> Self;
 }
 
-impl<'tcx, T> Value<'tcx> for T {
+impl<'tcx, T> FromCycleError<'tcx> for T {
     default fn from_cycle_error(
         tcx: TyCtxt<'tcx>,
         cycle_error: CycleError,
         _guar: ErrorGuaranteed,
     ) -> T {
         let Some(guar) = tcx.sess.dcx().has_errors() else {
             bug!(
-                "<{} as Value>::from_cycle_error called without errors: {:#?}",
+                "<{} as FromCycleError>::from_cycle_error called without errors: {:#?}",
                 std::any::type_name::<T>(),
                 cycle_error.cycle,
             );
@@ -38,21 +42,21 @@ impl<'tcx, T> Value<'tcx> for T {
     }
 }
 
-impl<'tcx> Value<'tcx> for Ty<'_> {
+impl<'tcx> FromCycleError<'tcx> for Ty<'_> {
     fn from_cycle_error(tcx: TyCtxt<'tcx>, _: CycleError, guar: ErrorGuaranteed) -> Self {
         // SAFETY: This is never called when `Self` is not `Ty<'tcx>`.
         // FIXME: Represent the above fact in the trait system somehow.
         unsafe { std::mem::transmute::<Ty<'tcx>, Ty<'_>>(Ty::new_error(tcx, guar)) }
     }
 }
 
-impl<'tcx> Value<'tcx> for Result<ty::EarlyBinder<'_, Ty<'_>>, CyclePlaceholder> {
+impl<'tcx> FromCycleError<'tcx> for Result<ty::EarlyBinder<'_, Ty<'_>>, CyclePlaceholder> {
     fn from_cycle_error(_tcx: TyCtxt<'tcx>, _: CycleError, guar: ErrorGuaranteed) -> Self {
         Err(CyclePlaceholder(guar))
     }
 }
 
-impl<'tcx> Value<'tcx> for ty::SymbolName<'_> {
+impl<'tcx> FromCycleError<'tcx> for ty::SymbolName<'_> {
     fn from_cycle_error(tcx: TyCtxt<'tcx>, _: CycleError, _guar: ErrorGuaranteed) -> Self {
         // SAFETY: This is never called when `Self` is not `SymbolName<'tcx>`.
         // FIXME: Represent the above fact in the trait system somehow.
@@ -64,7 +68,7 @@ impl<'tcx> Value<'tcx> for ty::SymbolName<'_> {
     }
 }
 
-impl<'tcx> Value<'tcx> for ty::Binder<'_, ty::FnSig<'_>> {
+impl<'tcx> FromCycleError<'tcx> for ty::Binder<'_, ty::FnSig<'_>> {
     fn from_cycle_error(tcx: TyCtxt<'tcx>, cycle_error: CycleError, guar: ErrorGuaranteed) -> Self {
         let err = Ty::new_error(tcx, guar);
 
@@ -94,7 +98,7 @@ impl<'tcx> Value<'tcx> for ty::Binder<'_, ty::FnSig<'_>> {
     }
 }
 
-impl<'tcx> Value<'tcx> for Representability {
+impl<'tcx> FromCycleError<'tcx> for Representability {
     fn from_cycle_error(
         tcx: TyCtxt<'tcx>,
         cycle_error: CycleError,
@@ -130,19 +134,19 @@ impl<'tcx> Value<'tcx> for Representability {
     }
 }
 
-impl<'tcx> Value<'tcx> for ty::EarlyBinder<'_, Ty<'_>> {
+impl<'tcx> FromCycleError<'tcx> for ty::EarlyBinder<'_, Ty<'_>> {
     fn from_cycle_error(tcx: TyCtxt<'tcx>, cycle_error: CycleError, guar: ErrorGuaranteed) -> Self {
         ty::EarlyBinder::bind(Ty::from_cycle_error(tcx, cycle_error, guar))
     }
 }
 
-impl<'tcx> Value<'tcx> for ty::EarlyBinder<'_, ty::Binder<'_, ty::FnSig<'_>>> {
+impl<'tcx> FromCycleError<'tcx> for ty::EarlyBinder<'_, ty::Binder<'_, ty::FnSig<'_>>> {
     fn from_cycle_error(tcx: TyCtxt<'tcx>, cycle_error: CycleError, guar: ErrorGuaranteed) -> Self {
         ty::EarlyBinder::bind(ty::Binder::from_cycle_error(tcx, cycle_error, guar))
     }
 }
 
-impl<'tcx> Value<'tcx> for &[ty::Variance] {
+impl<'tcx> FromCycleError<'tcx> for &[ty::Variance] {
     fn from_cycle_error(
         tcx: TyCtxt<'tcx>,
         cycle_error: CycleError,
@@ -190,7 +194,7 @@ fn search_for_cycle_permutation<Q, T>(
     otherwise()
 }
 
-impl<'tcx, T> Value<'tcx> for Result<T, &'_ ty::layout::LayoutError<'_>> {
+impl<'tcx, T> FromCycleError<'tcx> for Result<T, &'_ ty::layout::LayoutError<'_>> {
     fn from_cycle_error(
         tcx: TyCtxt<'tcx>,
         cycle_error: CycleError,

compiler/rustc_query_impl/src/lib.rs

@@ -18,22 +18,22 @@ use rustc_middle::ty::TyCtxt;
 use rustc_span::Span;
 
 pub use crate::dep_kind_vtables::make_dep_kind_vtables;
+use crate::from_cycle_error::FromCycleError;
 pub use crate::job::{QueryJobMap, break_query_cycles, print_query_stack};
 pub use crate::plumbing::{collect_active_jobs_from_all_queries, query_key_hash_verify_all};
 use crate::plumbing::{encode_all_query_results, try_mark_green};
 use crate::profiling_support::QueryKeyStringCache;
 pub use crate::profiling_support::alloc_self_profile_query_strings;
-use crate::values::Value;
 
 #[macro_use]
 mod plumbing;
 
 mod dep_kind_vtables;
 mod error;
 mod execution;
+mod from_cycle_error;
 mod job;
 mod profiling_support;
-mod values;
 
 /// Trait that knows how to look up the [`QueryVTable`] for a particular query.
 ///

compiler/rustc_query_impl/src/plumbing.rs

@@ -603,7 +603,8 @@ macro_rules! define_queries {
                         None
                     }),
                     value_from_cycle_error: |tcx, cycle, guar| {
-                        let result: queries::$name::Value<'tcx> = Value::from_cycle_error(tcx, cycle, guar);
+                        let result: queries::$name::Value<'tcx> =
+                            FromCycleError::from_cycle_error(tcx, cycle, guar);
                         erase::erase_val(result)
                     },
                     hash_result: hash_result!([$($modifiers)*][queries::$name::Value<'tcx>]),