use crate::dep_graph::{DepConstructor, DepNode, WorkProduct, WorkProductId};
use crate::ich::{Fingerprint, NodeIdHashingMode, StableHashingContext};
use crate::session::config::OptLevel;
-use crate::traits::TraitQueryMode;
use crate::ty::print::obsolete::DefPathBasedNames;
use crate::ty::{subst::InternalSubsts, Instance, InstanceDef, SymbolName, TyCtxt};
use rustc_data_structures::base_n;
MonoItem::GlobalAsm(..) => return true,
};
- // We shouldn't encounter any overflow here, so we use TraitQueryMode::Standard\
- // to report an error if overflow somehow occurs.
- tcx.substitute_normalize_and_test_predicates((def_id, &substs, TraitQueryMode::Standard))
+ tcx.substitute_normalize_and_test_predicates((def_id, &substs))
}
pub fn to_string(&self, tcx: TyCtxt<'tcx>, debug: bool) -> String {
desc { "normalizing `{:?}`", goal }
}
- query substitute_normalize_and_test_predicates(key: (DefId, SubstsRef<'tcx>, traits::TraitQueryMode)) -> bool {
+ query substitute_normalize_and_test_predicates(key: (DefId, SubstsRef<'tcx>)) -> bool {
no_force
desc { |tcx|
- "testing substituted normalized predicates in mode {:?}:`{}`",
- key.2, tcx.def_path_str(key.0)
+ "testing substituted normalized predicates:`{}`",
+ tcx.def_path_str(key.0)
}
}
use super::{ConstEvalFailure, Unimplemented};
use super::{FulfillmentError, FulfillmentErrorCode};
use super::{ObligationCause, PredicateObligation};
-use crate::traits::TraitQueryMode;
impl<'tcx> ForestObligation for PendingPredicateObligation<'tcx> {
type Predicate = ty::Predicate<'tcx>;
// a snapshot (they don't *straddle* a snapshot, so there
// is no trouble there).
usable_in_snapshot: bool,
-
- // The `TraitQueryMode` used when constructing a `SelectionContext`
- query_mode: TraitQueryMode,
}
#[derive(Clone, Debug)]
static_assert_size!(PendingPredicateObligation<'_>, 136);
impl<'a, 'tcx> FulfillmentContext<'tcx> {
- /// Creates a new fulfillment context with `TraitQueryMode::Standard`
- /// You almost always want to use this instead of `with_query_mode`
+ /// Creates a new fulfillment context.
pub fn new() -> FulfillmentContext<'tcx> {
FulfillmentContext {
predicates: ObligationForest::new(),
register_region_obligations: true,
usable_in_snapshot: false,
- query_mode: TraitQueryMode::Standard,
- }
- }
-
- /// Creates a new fulfillment context with the specified query mode.
- /// This should only be used when you want to ignore overflow,
- /// rather than reporting it as an error.
- pub fn with_query_mode(query_mode: TraitQueryMode) -> FulfillmentContext<'tcx> {
- FulfillmentContext {
- predicates: ObligationForest::new(),
- register_region_obligations: true,
- usable_in_snapshot: false,
- query_mode,
}
}
predicates: ObligationForest::new(),
register_region_obligations: true,
usable_in_snapshot: true,
- query_mode: TraitQueryMode::Standard,
}
}
predicates: ObligationForest::new(),
register_region_obligations: false,
usable_in_snapshot: false,
- query_mode: TraitQueryMode::Standard,
}
}
&mut self,
infcx: &InferCtxt<'_, 'tcx>,
) -> Result<(), Vec<FulfillmentError<'tcx>>> {
- let mut selcx = SelectionContext::with_query_mode(infcx, self.query_mode);
+ let mut selcx = SelectionContext::new(infcx);
self.select(&mut selcx)
}
}
/// The mode that trait queries run in.
-#[derive(Copy, Clone, PartialEq, Eq, Debug, Hash, HashStable)]
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
pub enum TraitQueryMode {
// Standard/un-canonicalized queries get accurate
// spans etc. passed in and hence can do reasonable
/// environment. If this returns false, then either normalize
/// encountered an error or one of the predicates did not hold. Used
/// when creating vtables to check for unsatisfiable methods.
-fn normalize_and_test_predicates<'tcx>(
+pub fn normalize_and_test_predicates<'tcx>(
tcx: TyCtxt<'tcx>,
predicates: Vec<ty::Predicate<'tcx>>,
- mode: TraitQueryMode,
) -> bool {
- debug!("normalize_and_test_predicates(predicates={:?}, mode={:?})", predicates, mode);
+ debug!("normalize_and_test_predicates(predicates={:?})", predicates);
let result = tcx.infer_ctxt().enter(|infcx| {
let param_env = ty::ParamEnv::reveal_all();
- let mut selcx = SelectionContext::with_query_mode(&infcx, mode);
- let mut fulfill_cx = FulfillmentContext::with_query_mode(mode);
+ let mut selcx = SelectionContext::new(&infcx);
+ let mut fulfill_cx = FulfillmentContext::new();
let cause = ObligationCause::dummy();
let Normalized { value: predicates, obligations } =
normalize(&mut selcx, param_env, cause.clone(), &predicates);
fn substitute_normalize_and_test_predicates<'tcx>(
tcx: TyCtxt<'tcx>,
- key: (DefId, SubstsRef<'tcx>, TraitQueryMode),
+ key: (DefId, SubstsRef<'tcx>),
) -> bool {
debug!("substitute_normalize_and_test_predicates(key={:?})", key);
let predicates = tcx.predicates_of(key.0).instantiate(tcx, key.1).predicates;
- let result = normalize_and_test_predicates(tcx, predicates, key.2);
+ let result = normalize_and_test_predicates(tcx, predicates);
debug!("substitute_normalize_and_test_predicates(key={:?}) = {:?}", key, result);
result
// Note that this method could then never be called, so we
// do not want to try and codegen it, in that case (see #23435).
let predicates = tcx.predicates_of(def_id).instantiate_own(tcx, substs);
- // We don't expect overflow here, so report an error if it somehow ends
- // up happening.
- if !normalize_and_test_predicates(tcx, predicates.predicates, TraitQueryMode::Standard)
- {
+ if !normalize_and_test_predicates(tcx, predicates.predicates) {
debug!("vtable_methods: predicates do not hold");
return None;
}
}
}
-impl<'tcx> Key for (DefId, SubstsRef<'tcx>, traits::TraitQueryMode) {
- fn query_crate(&self) -> CrateNum {
- self.0.krate
- }
- fn default_span(&self, tcx: TyCtxt<'_>) -> Span {
- self.0.default_span(tcx)
- }
-}
-
impl<'tcx> Key for (ty::ParamEnv<'tcx>, ty::PolyTraitRef<'tcx>) {
fn query_crate(&self) -> CrateNum {
self.1.def_id().krate
projects / rust.git / commitdiff