self.inferred_values = Some(inferred_values);
}
- #[inline(never)] // ensure dfs is identifiable in profiles
fn compute_region_values(&self, _mir: &Mir<'tcx>) -> RegionValues {
debug!("compute_region_values()");
debug!("compute_region_values: constraints={:#?}", {
/// indices of constraints that need to be re-evaluated when X changes.
/// These are constraints like Y: X @ P -- so if X changed, we may
/// need to grow Y.
- #[inline(never)] // ensure dfs is identifiable in profiles
fn build_dependency_map(&mut self) -> IndexVec<RegionVid, Option<ConstraintIndex>> {
let mut map = IndexVec::from_elem(None, &self.definitions);
use super::{Locations, TypeChecker};
impl<'a, 'gcx, 'tcx> TypeChecker<'a, 'gcx, 'tcx> {
- #[inline(never)]
pub(super) fn equate_inputs_and_outputs(
&mut self,
mir: &Mir<'tcx>,
/// the regions in its type must be live at `location`. The
/// precise set will depend on the dropck constraints, and in
/// particular this takes `#[may_dangle]` into account.
- #[inline(never)]
fn add_drop_live_constraint(
&mut self,
dropped_local: Local,
}
}
- #[inline(never)]
fn compute_drop_data(
cx: &mut TypeChecker<'_, 'gcx, 'tcx>,
dropped_ty: Ty<'tcx>,
/// obligations. If the same `op` were to be performed at some
/// other location, then the same set of region obligations would
/// be generated there, so this can be useful for caching.
- #[inline(never)]
fn fully_perform_op_and_get_region_constraint_data<R>(
&mut self,
describe_op: impl Fn() -> String,
}
}
- #[inline(never)]
fn sub_types(
&mut self,
sub: Ty<'tcx>,
)
}
- #[inline(never)]
fn eq_types(&mut self, a: Ty<'tcx>, b: Ty<'tcx>, locations: Locations) -> UnitResult<'tcx> {
// Micro-optimization.
if a == b {
);
}
- #[inline(never)]
fn prove_predicates<T>(&mut self, predicates: T, location: Location)
where
T: IntoIterator<Item = ty::Predicate<'tcx>> + Clone,
}
}
- #[inline(never)]
fn normalize<T>(&mut self, value: &T, location: impl ToLocations) -> T
where
T: fmt::Debug + TypeFoldable<'tcx>,