};
use crate::infer::nll_relate::{NormalizationStrategy, TypeRelating, TypeRelatingDelegate};
use crate::infer::region_constraints::{Constraint, RegionConstraintData};
-use crate::infer::{InferCtxt, InferOk, InferResult, NLLRegionVariableOrigin};
+use crate::infer::{InferCtxt, InferOk, InferResult, NllRegionVariableOrigin};
use crate::traits::query::{Fallible, NoSolution};
use crate::traits::TraitEngine;
use crate::traits::{Obligation, ObligationCause, PredicateObligation};
}
fn next_existential_region_var(&mut self, from_forall: bool) -> ty::Region<'tcx> {
- let origin = NLLRegionVariableOrigin::Existential { from_forall };
+ let origin = NllRegionVariableOrigin::Existential { from_forall };
self.infcx.next_nll_region_var(origin)
}
fn generalize_existential(&mut self, universe: ty::UniverseIndex) -> ty::Region<'tcx> {
self.infcx.next_nll_region_var_in_universe(
- NLLRegionVariableOrigin::Existential { from_forall: false },
+ NllRegionVariableOrigin::Existential { from_forall: false },
universe,
)
}
let var_name = self.tcx.hir().name(upvar_id.var_path.hir_id);
format!(" for capture of `{}` by closure", var_name)
}
- infer::NLL(..) => bug!("NLL variable found in lexical phase"),
+ infer::Nll(..) => bug!("NLL variable found in lexical phase"),
};
struct_span_err!(
/// This origin is used for the inference variables that we create
/// during NLL region processing.
- NLL(NLLRegionVariableOrigin),
+ Nll(NllRegionVariableOrigin),
}
#[derive(Copy, Clone, Debug)]
-pub enum NLLRegionVariableOrigin {
+pub enum NllRegionVariableOrigin {
/// During NLL region processing, we create variables for free
/// regions that we encounter in the function signature and
/// elsewhere. This origin indices we've got one of those.
}
/// Just a convenient wrapper of `next_region_var` for using during NLL.
- pub fn next_nll_region_var(&self, origin: NLLRegionVariableOrigin) -> ty::Region<'tcx> {
- self.next_region_var(RegionVariableOrigin::NLL(origin))
+ pub fn next_nll_region_var(&self, origin: NllRegionVariableOrigin) -> ty::Region<'tcx> {
+ self.next_region_var(RegionVariableOrigin::Nll(origin))
}
/// Just a convenient wrapper of `next_region_var` for using during NLL.
pub fn next_nll_region_var_in_universe(
&self,
- origin: NLLRegionVariableOrigin,
+ origin: NllRegionVariableOrigin,
universe: ty::UniverseIndex,
) -> ty::Region<'tcx> {
- self.next_region_var_in_universe(RegionVariableOrigin::NLL(origin), universe)
+ self.next_region_var_in_universe(RegionVariableOrigin::Nll(origin), universe)
}
pub fn var_for_def(&self, span: Span, param: &ty::GenericParamDef) -> GenericArg<'tcx> {
| LateBoundRegion(a, ..)
| UpvarRegion(_, a) => a,
BoundRegionInCoherence(_) => rustc_span::DUMMY_SP,
- NLL(..) => bug!("NLL variable used with `span`"),
+ Nll(..) => bug!("NLL variable used with `span`"),
}
}
}
use rustc_data_structures::fx::FxHashSet;
use rustc_errors::{Applicability, DiagnosticBuilder};
use rustc_index::vec::IndexVec;
-use rustc_infer::infer::NLLRegionVariableOrigin;
+use rustc_infer::infer::NllRegionVariableOrigin;
use rustc_middle::mir::{
Body, CastKind, ConstraintCategory, FakeReadCause, Local, Location, Operand, Place, Rvalue,
Statement, StatementKind, TerminatorKind,
let (category, from_closure, span) = self.regioncx.best_blame_constraint(
&self.body,
borrow_region,
- NLLRegionVariableOrigin::FreeRegion,
+ NllRegionVariableOrigin::FreeRegion,
|r| self.regioncx.provides_universal_region(r, borrow_region, outlived_region),
);
use rustc_errors::{Applicability, DiagnosticBuilder};
use rustc_infer::infer::{
error_reporting::nice_region_error::NiceRegionError,
- error_reporting::unexpected_hidden_region_diagnostic, NLLRegionVariableOrigin,
+ error_reporting::unexpected_hidden_region_diagnostic, NllRegionVariableOrigin,
};
use rustc_middle::mir::{ConstraintCategory, ReturnConstraint};
use rustc_middle::ty::subst::Subst;
/// The region element that erroneously must be outlived by `longer_fr`.
error_element: RegionElement,
/// The origin of the placeholder region.
- fr_origin: NLLRegionVariableOrigin,
+ fr_origin: NllRegionVariableOrigin,
},
/// Any other lifetime error.
RegionError {
/// The origin of the region.
- fr_origin: NLLRegionVariableOrigin,
+ fr_origin: NllRegionVariableOrigin,
/// The region that should outlive `shorter_fr`.
longer_fr: RegionVid,
/// The region that should be shorter, but we can't prove it.
pub(in crate::borrow_check) fn report_region_error(
&mut self,
fr: RegionVid,
- fr_origin: NLLRegionVariableOrigin,
+ fr_origin: NllRegionVariableOrigin,
outlived_fr: RegionVid,
outlives_suggestion: &mut OutlivesSuggestionBuilder,
) {
use super::{OutlivesConstraint, RegionInferenceContext};
use crate::borrow_check::type_check::Locations;
-use rustc_infer::infer::NLLRegionVariableOrigin;
+use rustc_infer::infer::NllRegionVariableOrigin;
use rustc_middle::ty::TyCtxt;
use std::io::{self, Write};
writeln!(out, "| Free Region Mapping")?;
for region in self.regions() {
- if let NLLRegionVariableOrigin::FreeRegion = self.definitions[region].origin {
+ if let NllRegionVariableOrigin::FreeRegion = self.definitions[region].origin {
let classification = self.universal_regions.region_classification(region).unwrap();
let outlived_by = self.universal_region_relations.regions_outlived_by(region);
writeln!(
use rustc_index::vec::IndexVec;
use rustc_infer::infer::canonical::QueryOutlivesConstraint;
use rustc_infer::infer::region_constraints::{GenericKind, VarInfos, VerifyBound};
-use rustc_infer::infer::{InferCtxt, NLLRegionVariableOrigin, RegionVariableOrigin};
+use rustc_infer::infer::{InferCtxt, NllRegionVariableOrigin, RegionVariableOrigin};
use rustc_middle::mir::{
Body, ClosureOutlivesRequirement, ClosureOutlivesSubject, ClosureRegionRequirements,
ConstraintCategory, Local, Location, ReturnConstraint,
pub(crate) struct RegionDefinition<'tcx> {
/// What kind of variable is this -- a free region? existential
- /// variable? etc. (See the `NLLRegionVariableOrigin` for more
+ /// variable? etc. (See the `NllRegionVariableOrigin` for more
/// info.)
- pub(in crate::borrow_check) origin: NLLRegionVariableOrigin,
+ pub(in crate::borrow_check) origin: NllRegionVariableOrigin,
/// Which universe is this region variable defined in? This is
/// most often `ty::UniverseIndex::ROOT`, but when we encounter
let scc = self.constraint_sccs.scc(variable);
match self.definitions[variable].origin {
- NLLRegionVariableOrigin::FreeRegion => {
+ NllRegionVariableOrigin::FreeRegion => {
// For each free, universally quantified region X:
// Add all nodes in the CFG to liveness constraints
self.scc_values.add_element(scc, variable);
}
- NLLRegionVariableOrigin::Placeholder(placeholder) => {
+ NllRegionVariableOrigin::Placeholder(placeholder) => {
// Each placeholder region is only visible from
// its universe `ui` and its extensions. So we
// can't just add it into `scc` unless the
}
}
- NLLRegionVariableOrigin::RootEmptyRegion
- | NLLRegionVariableOrigin::Existential { .. } => {
+ NllRegionVariableOrigin::RootEmptyRegion
+ | NllRegionVariableOrigin::Existential { .. } => {
// For existential, regions, nothing to do.
}
}
) {
for (fr, fr_definition) in self.definitions.iter_enumerated() {
match fr_definition.origin {
- NLLRegionVariableOrigin::FreeRegion => {
+ NllRegionVariableOrigin::FreeRegion => {
// Go through each of the universal regions `fr` and check that
// they did not grow too large, accumulating any requirements
// for our caller into the `outlives_requirements` vector.
);
}
- NLLRegionVariableOrigin::Placeholder(placeholder) => {
+ NllRegionVariableOrigin::Placeholder(placeholder) => {
self.check_bound_universal_region(fr, placeholder, errors_buffer);
}
- NLLRegionVariableOrigin::RootEmptyRegion
- | NLLRegionVariableOrigin::Existential { .. } => {
+ NllRegionVariableOrigin::RootEmptyRegion
+ | NllRegionVariableOrigin::Existential { .. } => {
// nothing to check here
}
}
errors_buffer.push(RegionErrorKind::RegionError {
longer_fr: *longer_fr,
shorter_fr: *shorter_fr,
- fr_origin: NLLRegionVariableOrigin::FreeRegion,
+ fr_origin: NllRegionVariableOrigin::FreeRegion,
is_reported: true,
});
}
// a more complete picture on how to separate this responsibility.
for (fr, fr_definition) in self.definitions.iter_enumerated() {
match fr_definition.origin {
- NLLRegionVariableOrigin::FreeRegion => {
+ NllRegionVariableOrigin::FreeRegion => {
// handled by polonius above
}
- NLLRegionVariableOrigin::Placeholder(placeholder) => {
+ NllRegionVariableOrigin::Placeholder(placeholder) => {
self.check_bound_universal_region(fr, placeholder, errors_buffer);
}
- NLLRegionVariableOrigin::RootEmptyRegion
- | NLLRegionVariableOrigin::Existential { .. } => {
+ NllRegionVariableOrigin::RootEmptyRegion
+ | NllRegionVariableOrigin::Existential { .. } => {
// nothing to check here
}
}
errors_buffer.push(RegionErrorKind::RegionError {
longer_fr,
shorter_fr: representative,
- fr_origin: NLLRegionVariableOrigin::FreeRegion,
+ fr_origin: NllRegionVariableOrigin::FreeRegion,
is_reported: true,
});
}
errors_buffer.push(RegionErrorKind::RegionError {
longer_fr,
shorter_fr,
- fr_origin: NLLRegionVariableOrigin::FreeRegion,
+ fr_origin: NllRegionVariableOrigin::FreeRegion,
is_reported: !error_reported,
});
let blame_span_category = self.find_outlives_blame_span(
body,
longer_fr,
- NLLRegionVariableOrigin::FreeRegion,
+ NllRegionVariableOrigin::FreeRegion,
shorter_fr,
);
errors_buffer.push(RegionErrorKind::BoundUniversalRegionError {
longer_fr,
error_element,
- fr_origin: NLLRegionVariableOrigin::Placeholder(placeholder),
+ fr_origin: NllRegionVariableOrigin::Placeholder(placeholder),
});
}
debug!("cannot_name_value_of(r1={:?}, r2={:?})", r1, r2);
match self.definitions[r2].origin {
- NLLRegionVariableOrigin::Placeholder(placeholder) => {
+ NllRegionVariableOrigin::Placeholder(placeholder) => {
let universe1 = self.definitions[r1].universe;
debug!(
"cannot_name_value_of: universe1={:?} placeholder={:?}",
universe1.cannot_name(placeholder.universe)
}
- NLLRegionVariableOrigin::RootEmptyRegion
- | NLLRegionVariableOrigin::FreeRegion
- | NLLRegionVariableOrigin::Existential { .. } => false,
+ NllRegionVariableOrigin::RootEmptyRegion
+ | NllRegionVariableOrigin::FreeRegion
+ | NllRegionVariableOrigin::Existential { .. } => false,
}
}
&self,
body: &Body<'tcx>,
fr1: RegionVid,
- fr1_origin: NLLRegionVariableOrigin,
+ fr1_origin: NllRegionVariableOrigin,
fr2: RegionVid,
) -> (ConstraintCategory, Span) {
let (category, _, span) = self.best_blame_constraint(body, fr1, fr1_origin, |r| {
.definitions
.iter_enumerated()
.find_map(|(r, definition)| match definition.origin {
- NLLRegionVariableOrigin::Placeholder(p) if p == error_placeholder => Some(r),
+ NllRegionVariableOrigin::Placeholder(p) if p == error_placeholder => Some(r),
_ => None,
})
.unwrap(),
&self,
body: &Body<'tcx>,
from_region: RegionVid,
- from_region_origin: NLLRegionVariableOrigin,
+ from_region_origin: NllRegionVariableOrigin,
target_test: impl Fn(RegionVid) -> bool,
) -> (ConstraintCategory, bool, Span) {
debug!(
//
// and here we prefer to blame the source (the y = x statement).
let blame_source = match from_region_origin {
- NLLRegionVariableOrigin::FreeRegion
- | NLLRegionVariableOrigin::Existential { from_forall: false } => true,
- NLLRegionVariableOrigin::RootEmptyRegion
- | NLLRegionVariableOrigin::Placeholder(_)
- | NLLRegionVariableOrigin::Existential { from_forall: true } => false,
+ NllRegionVariableOrigin::FreeRegion
+ | NllRegionVariableOrigin::Existential { from_forall: false } => true,
+ NllRegionVariableOrigin::RootEmptyRegion
+ | NllRegionVariableOrigin::Placeholder(_)
+ | NllRegionVariableOrigin::Existential { from_forall: true } => false,
};
let find_region = |i: &usize| {
// `init_universal_regions`.
let origin = match rv_origin {
- RegionVariableOrigin::NLL(origin) => origin,
- _ => NLLRegionVariableOrigin::Existential { from_forall: false },
+ RegionVariableOrigin::Nll(origin) => origin,
+ _ => NllRegionVariableOrigin::Existential { from_forall: false },
};
Self { origin, universe, external_name: None }
use rustc_index::vec::IndexVec;
-use rustc_infer::infer::{InferCtxt, NLLRegionVariableOrigin};
+use rustc_infer::infer::{InferCtxt, NllRegionVariableOrigin};
use rustc_middle::mir::visit::{MutVisitor, TyContext};
use rustc_middle::mir::{Body, Location, PlaceElem, Promoted};
use rustc_middle::ty::subst::SubstsRef;
debug!("renumber_mir()");
debug!("renumber_mir: body.arg_count={:?}", body.arg_count);
- let mut visitor = NLLVisitor { infcx };
+ let mut visitor = NllVisitor { infcx };
for body in promoted.iter_mut() {
visitor.visit_body(body);
debug!("renumber_regions(value={:?})", value);
infcx.tcx.fold_regions(value, &mut false, |_region, _depth| {
- let origin = NLLRegionVariableOrigin::Existential { from_forall: false };
+ let origin = NllRegionVariableOrigin::Existential { from_forall: false };
infcx.next_nll_region_var(origin)
})
}
-struct NLLVisitor<'a, 'tcx> {
+struct NllVisitor<'a, 'tcx> {
infcx: &'a InferCtxt<'a, 'tcx>,
}
-impl<'a, 'tcx> NLLVisitor<'a, 'tcx> {
+impl<'a, 'tcx> NllVisitor<'a, 'tcx> {
fn renumber_regions<T>(&mut self, value: T) -> T
where
T: TypeFoldable<'tcx>,
}
}
-impl<'a, 'tcx> MutVisitor<'tcx> for NLLVisitor<'a, 'tcx> {
+impl<'a, 'tcx> MutVisitor<'tcx> for NllVisitor<'a, 'tcx> {
fn tcx(&self) -> TyCtxt<'tcx> {
self.infcx.tcx
}
use rustc_infer::infer::outlives::env::RegionBoundPairs;
use rustc_infer::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
use rustc_infer::infer::{
- InferCtxt, InferOk, LateBoundRegionConversionTime, NLLRegionVariableOrigin,
+ InferCtxt, InferOk, LateBoundRegionConversionTime, NllRegionVariableOrigin,
};
use rustc_middle::mir::tcx::PlaceTy;
use rustc_middle::mir::visit::{NonMutatingUseContext, PlaceContext, Visitor};
match self.placeholder_index_to_region.get(placeholder_index) {
Some(&v) => v,
None => {
- let origin = NLLRegionVariableOrigin::Placeholder(placeholder);
+ let origin = NllRegionVariableOrigin::Placeholder(placeholder);
let region = infcx.next_nll_region_var_in_universe(origin, placeholder.universe);
self.placeholder_index_to_region.push(region);
region
use rustc_infer::infer::nll_relate::{NormalizationStrategy, TypeRelating, TypeRelatingDelegate};
-use rustc_infer::infer::{InferCtxt, NLLRegionVariableOrigin};
+use rustc_infer::infer::{InferCtxt, NllRegionVariableOrigin};
use rustc_middle::mir::ConstraintCategory;
use rustc_middle::ty::relate::TypeRelation;
use rustc_middle::ty::{self, Const, Ty};
fn next_existential_region_var(&mut self, from_forall: bool) -> ty::Region<'tcx> {
if self.borrowck_context.is_some() {
- let origin = NLLRegionVariableOrigin::Existential { from_forall };
+ let origin = NllRegionVariableOrigin::Existential { from_forall };
self.infcx.next_nll_region_var(origin)
} else {
self.infcx.tcx.lifetimes.re_erased
fn generalize_existential(&mut self, universe: ty::UniverseIndex) -> ty::Region<'tcx> {
self.infcx.next_nll_region_var_in_universe(
- NLLRegionVariableOrigin::Existential { from_forall: false },
+ NllRegionVariableOrigin::Existential { from_forall: false },
universe,
)
}
use rustc_hir::lang_items::LangItem;
use rustc_hir::{BodyOwnerKind, HirId};
use rustc_index::vec::{Idx, IndexVec};
-use rustc_infer::infer::{InferCtxt, NLLRegionVariableOrigin};
+use rustc_infer::infer::{InferCtxt, NllRegionVariableOrigin};
use rustc_middle::ty::fold::TypeFoldable;
use rustc_middle::ty::subst::{InternalSubsts, Subst, SubstsRef};
use rustc_middle::ty::{self, RegionVid, Ty, TyCtxt};
param_env: ty::ParamEnv<'tcx>,
}
-const FR: NLLRegionVariableOrigin = NLLRegionVariableOrigin::FreeRegion;
+const FR: NllRegionVariableOrigin = NllRegionVariableOrigin::FreeRegion;
impl<'cx, 'tcx> UniversalRegionsBuilder<'cx, 'tcx> {
fn build(self) -> UniversalRegions<'tcx> {
let root_empty = self
.infcx
- .next_nll_region_var(NLLRegionVariableOrigin::RootEmptyRegion)
+ .next_nll_region_var(NllRegionVariableOrigin::RootEmptyRegion)
.to_region_vid();
UniversalRegions {
trait InferCtxtExt<'tcx> {
fn replace_free_regions_with_nll_infer_vars<T>(
&self,
- origin: NLLRegionVariableOrigin,
+ origin: NllRegionVariableOrigin,
value: T,
) -> T
where
fn replace_bound_regions_with_nll_infer_vars<T>(
&self,
- origin: NLLRegionVariableOrigin,
+ origin: NllRegionVariableOrigin,
all_outlive_scope: LocalDefId,
value: ty::Binder<T>,
indices: &mut UniversalRegionIndices<'tcx>,
impl<'cx, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'cx, 'tcx> {
fn replace_free_regions_with_nll_infer_vars<T>(
&self,
- origin: NLLRegionVariableOrigin,
+ origin: NllRegionVariableOrigin,
value: T,
) -> T
where
fn replace_bound_regions_with_nll_infer_vars<T>(
&self,
- origin: NLLRegionVariableOrigin,
+ origin: NllRegionVariableOrigin,
all_outlive_scope: LocalDefId,
value: ty::Binder<T>,
indices: &mut UniversalRegionIndices<'tcx>,