) {
debug!("report_region_errors(): {} errors to start", errors.len());
- if will_later_be_reported_by_nll && self.tcx.nll() {
+ if will_later_be_reported_by_nll && self.tcx.use_mir() {
// With `#![feature(nll)]`, we want to present a nice user
// experience, so don't even mention the errors from the
// AST checker.
return;
}
- // But with -Znll, it's nice to have some note for later.
+ // But with nll, it's nice to have some note for later.
for error in errors {
match *error {
RegionResolutionError::ConcreteFailure(ref origin, ..)
| RegionResolutionError::GenericBoundFailure(ref origin, ..) => {
self.tcx
.sess
- .span_warn(origin.span(), "not reporting region error due to -Znll");
+ .span_warn(origin.span(), "not reporting region error due to nll");
}
RegionResolutionError::SubSupConflict(ref rvo, ..) => {
self.tcx
.sess
- .span_warn(rvo.span(), "not reporting region error due to -Znll");
+ .span_warn(rvo.span(), "not reporting region error due to nll");
}
}
}
useful for profiling / PGO."),
relro_level: Option<RelroLevel> = (None, parse_relro_level, [TRACKED],
"choose which RELRO level to use"),
- nll: bool = (false, parse_bool, [UNTRACKED],
- "run the non-lexical lifetimes MIR pass"),
disable_nll_user_type_assert: bool = (false, parse_bool, [UNTRACKED],
"disable user provided type assertion in NLL"),
trans_time_graph: bool = (false, parse_bool, [UNTRACKED],
self.on_disk_query_result_cache.serialize(self.global_tcx(), encoder)
}
- /// If true, we should use NLL-style region checking instead of
- /// lexical style.
- pub fn nll(self) -> bool {
- self.features().nll || self.sess.opts.debugging_opts.nll
- }
-
/// If true, we should use the MIR-based borrowck (we may *also* use
/// the AST-based borrowck).
pub fn use_mir(self) -> bool {
mode @ BorrowckMode::Compare => mode,
mode @ BorrowckMode::Ast => {
- if self.nll() {
+ if self.features().nll {
BorrowckMode::Mir
} else {
mode
/// MIR borrowck, but not when NLL is used. They are also consumed
/// by the validation stuff.
pub fn emit_end_regions(self) -> bool {
- // FIXME(#46875) -- we should not emit end regions when NLL is enabled,
- // but for now we can't stop doing so because it causes false positives
self.sess.opts.debugging_opts.emit_end_regions ||
self.sess.opts.debugging_opts.mir_emit_validate > 0 ||
self.use_mir()
use rustc::mir::traversal;
use rustc::mir::visit::{PlaceContext, Visitor};
use rustc::mir::{self, Location, Mir, Place};
-use rustc::ty::{self, Region, RegionKind, TyCtxt};
+use rustc::ty::{Region, TyCtxt};
use rustc::util::nodemap::{FxHashMap, FxHashSet};
use rustc_data_structures::indexed_vec::IndexVec;
use std::fmt;
use std::hash::Hash;
use std::ops::Index;
-use syntax_pos::Span;
crate struct BorrowSet<'tcx> {
/// The fundamental map relating bitvector indexes to the borrows
/// Map from local to all the borrows on that local
crate local_map: FxHashMap<mir::Local, FxHashSet<BorrowIndex>>,
-
- /// Maps regions to their corresponding source spans
- /// Only contains ReScope()s as keys
- crate region_span_map: FxHashMap<RegionKind, Span>,
}
impl<'tcx> Index<BorrowIndex> for BorrowSet<'tcx> {
activation_map: FxHashMap(),
region_map: FxHashMap(),
local_map: FxHashMap(),
- region_span_map: FxHashMap(),
pending_activations: FxHashMap(),
};
activation_map: visitor.activation_map,
region_map: visitor.region_map,
local_map: visitor.local_map,
- region_span_map: visitor.region_span_map,
}
}
activation_map: FxHashMap<Location, Vec<BorrowIndex>>,
region_map: FxHashMap<Region<'tcx>, FxHashSet<BorrowIndex>>,
local_map: FxHashMap<mir::Local, FxHashSet<BorrowIndex>>,
- region_span_map: FxHashMap<RegionKind, Span>,
/// When we encounter a 2-phase borrow statement, it will always
/// be assigning into a temporary TEMP:
statement: &mir::Statement<'tcx>,
location: Location,
) {
- if let mir::StatementKind::EndRegion(region_scope) = statement.kind {
- self.region_span_map
- .insert(ty::ReScope(region_scope), statement.source_info.span);
- }
return self.super_statement(block, statement, location);
}
}
(place, span): (&Place<'tcx>, Span),
gen_borrow_kind: BorrowKind,
issued_borrow: &BorrowData<'tcx>,
- end_issued_loan_span: Option<Span>,
) {
let issued_span = self.retrieve_borrow_span(issued_borrow);
"it",
rgt,
"",
- end_issued_loan_span,
+ None,
Origin::Mir,
)
}
"",
issued_span,
"",
- end_issued_loan_span,
+ None,
Origin::Mir,
)
}
span,
&desc_place,
issued_span,
- end_issued_loan_span,
+ None,
Origin::Mir,
)
}
issued_span,
"it",
"",
- end_issued_loan_span,
+ None,
Origin::Mir,
),
lft,
issued_span,
"",
- end_issued_loan_span,
+ None,
Origin::Mir,
)
}
lft,
issued_span,
"",
- end_issued_loan_span,
+ None,
Origin::Mir,
)
}
borrow: &BorrowData<'tcx>,
drop_span: Span,
) {
- let end_span = self.opt_region_end_span(&borrow.region);
let scope_tree = self.tcx.region_scope_tree(self.mir_def_id);
let root_place = self.prefixes(&borrow.borrowed_place, PrefixSet::All)
.last()
drop_span,
borrow_span,
proper_span,
- end_span,
);
}
(RegionKind::ReScope(_), None) => {
drop_span,
borrow_span,
proper_span,
- end_span,
);
}
(RegionKind::ReEarlyBound(_), Some(name))
drop_span,
borrow_span,
proper_span,
- end_span,
);
}
(RegionKind::ReEarlyBound(_), None)
drop_span,
borrow_span,
proper_span,
- end_span,
);
}
(RegionKind::ReLateBound(_, _), _)
drop_span: Span,
borrow_span: Span,
_proper_span: Span,
- end_span: Option<Span>,
) {
let tcx = self.tcx;
let mut err =
drop_span,
format!("`{}` dropped here while still borrowed", name),
);
- if let Some(end) = end_span {
- err.span_label(end, "borrowed value needs to live until here");
- }
self.explain_why_borrow_contains_point(context, borrow, &mut err);
err.emit();
}
drop_span: Span,
_borrow_span: Span,
proper_span: Span,
- end_span: Option<Span>,
) {
let tcx = self.tcx;
let mut err =
"temporary value dropped here while still borrowed",
);
err.note("consider using a `let` binding to increase its lifetime");
- if let Some(end) = end_span {
- err.span_label(end, "temporary value needs to live until here");
- }
self.explain_why_borrow_contains_point(context, borrow, &mut err);
err.emit();
}
drop_span: Span,
borrow_span: Span,
_proper_span: Span,
- _end_span: Option<Span>,
) {
debug!(
"report_unscoped_local_value_does_not_live_long_enough(\
err.span_label(borrow_span, "borrowed value does not live long enough");
err.span_label(drop_span, "borrowed value only lives until here");
- if !tcx.nll() {
- tcx.note_and_explain_region(
- scope_tree,
- &mut err,
- "borrowed value must be valid for ",
- borrow.region,
- "...",
- );
- }
-
self.explain_why_borrow_contains_point(context, borrow, &mut err);
err.emit();
}
drop_span: Span,
_borrow_span: Span,
proper_span: Span,
- _end_span: Option<Span>,
) {
debug!(
"report_unscoped_temporary_value_does_not_live_long_enough(\
err.span_label(proper_span, "temporary value does not live long enough");
err.span_label(drop_span, "temporary value only lives until here");
- if !tcx.nll() {
- tcx.note_and_explain_region(
- scope_tree,
- &mut err,
- "borrowed value must be valid for ",
- borrow.region,
- "...",
- );
- }
-
self.explain_why_borrow_contains_point(context, borrow, &mut err);
err.emit();
}
.as_local_node_id(def_id)
.expect("do_mir_borrowck: non-local DefId");
- // Make our own copy of the MIR. This copy will be modified (in place) to
- // contain non-lexical lifetimes. It will have a lifetime tied
- // to the inference context.
+ // Replace all regions with fresh inference variables. This
+ // requires first making our own copy of the MIR. This copy will
+ // be modified (in place) to contain non-lexical lifetimes. It
+ // will have a lifetime tied to the inference context.
let mut mir: Mir<'tcx> = input_mir.clone();
- let free_regions = if !tcx.nll() {
- None
- } else {
- let mir = &mut mir;
-
- // Replace all regions with fresh inference variables.
- Some(nll::replace_regions_in_mir(infcx, def_id, param_env, mir))
- };
- let mir = &mir;
+ let free_regions = nll::replace_regions_in_mir(infcx, def_id, param_env, &mut mir);
+ let mir = &mir; // no further changes
let move_data: MoveData<'tcx> = match MoveData::gather_moves(mir, tcx) {
Ok(move_data) => move_data,
let borrow_set = Rc::new(BorrowSet::build(tcx, mir));
// If we are in non-lexical mode, compute the non-lexical lifetimes.
- let (opt_regioncx, opt_closure_req) = if let Some(free_regions) = free_regions {
- let (regioncx, opt_closure_req) = nll::compute_regions(
- infcx,
- def_id,
- free_regions,
- mir,
- param_env,
- &mut flow_inits,
- &mdpe.move_data,
- &borrow_set,
- );
- (Some(Rc::new(regioncx)), opt_closure_req)
- } else {
- assert!(!tcx.nll());
- (None, None)
- };
+ let (regioncx, opt_closure_req) = nll::compute_regions(
+ infcx,
+ def_id,
+ free_regions,
+ mir,
+ param_env,
+ &mut flow_inits,
+ &mdpe.move_data,
+ &borrow_set,
+ );
+ let regioncx = Rc::new(regioncx);
let flow_inits = flow_inits; // remove mut
let flow_borrows = FlowAtLocation::new(do_dataflow(
id,
&attributes,
&dead_unwinds,
- Borrows::new(tcx, mir, opt_regioncx.clone(), def_id, body_id, &borrow_set),
+ Borrows::new(tcx, mir, regioncx.clone(), def_id, body_id, &borrow_set),
|rs, i| DebugFormatted::new(&rs.location(i)),
));
access_place_error_reported: FxHashSet(),
reservation_error_reported: FxHashSet(),
moved_error_reported: FxHashSet(),
- nonlexical_regioncx: opt_regioncx,
+ nonlexical_regioncx: regioncx,
nonlexical_cause_info: None,
borrow_set,
dominators,
/// Non-lexical region inference context, if NLL is enabled. This
/// contains the results from region inference and lets us e.g.
/// find out which CFG points are contained in each borrow region.
- nonlexical_regioncx: Option<Rc<RegionInferenceContext<'tcx>>>,
+ nonlexical_regioncx: Rc<RegionInferenceContext<'tcx>>,
nonlexical_cause_info: Option<RegionCausalInfo>,
/// The set of borrows extracted from the MIR
this.report_use_while_mutably_borrowed(context, place_span, borrow)
}
ReadKind::Borrow(bk) => {
- let end_issued_loan_span = this.opt_region_end_span(&borrow.region);
error_reported = true;
this.report_conflicting_borrow(
context,
place_span,
bk,
&borrow,
- end_issued_loan_span,
)
}
}
match kind {
WriteKind::MutableBorrow(bk) => {
- let end_issued_loan_span = this.opt_region_end_span(&borrow.region);
-
error_reported = true;
this.report_conflicting_borrow(
context,
place_span,
bk,
&borrow,
- end_issued_loan_span,
)
}
WriteKind::StorageDeadOrDrop => {
_ => None,
}
}
-
- /// Returns the span for the "end point" given region. This will
- /// return `None` if NLL is enabled, since that concept has no
- /// meaning there. Otherwise, return region span if it exists and
- /// span for end of the function if it doesn't exist.
- pub(crate) fn opt_region_end_span(&self, region: &ty::Region<'tcx>) -> Option<Span> {
- match self.nonlexical_regioncx {
- Some(_) => None,
- None => {
- match self.borrow_set.region_span_map.get(region) {
- Some(span) => Some(self.tcx.sess.codemap().end_point(*span)),
- None => Some(self.tcx.sess.codemap().end_point(self.mir.span))
- }
- }
- }
- }
}
#[derive(Copy, Clone, PartialEq, Eq, Debug)]
borrow: &BorrowData<'tcx>,
err: &mut DiagnosticBuilder<'_>,
) {
- if let Some(regioncx) = &self.nonlexical_regioncx {
- let mir = self.mir;
+ let regioncx = &&self.nonlexical_regioncx;
+ let mir = self.mir;
- if self.nonlexical_cause_info.is_none() {
- self.nonlexical_cause_info = Some(regioncx.compute_causal_info(mir));
- }
+ if self.nonlexical_cause_info.is_none() {
+ self.nonlexical_cause_info = Some(regioncx.compute_causal_info(mir));
+ }
+
+ let cause_info = self.nonlexical_cause_info.as_ref().unwrap();
+ if let Some(cause) = cause_info.why_region_contains_point(borrow.region, context.loc) {
+ match *cause.root_cause() {
+ Cause::LiveVar(local, location) => {
+ match find_regular_use(mir, regioncx, borrow, location, local) {
+ Some(p) => {
+ err.span_label(
+ mir.source_info(p).span,
+ format!("borrow later used here"),
+ );
+ }
+
+ None => {
+ span_bug!(
+ mir.source_info(context.loc).span,
+ "Cause should end in a LiveVar"
+ );
+ }
+ }
+ }
- let cause_info = self.nonlexical_cause_info.as_ref().unwrap();
- if let Some(cause) = cause_info.why_region_contains_point(borrow.region, context.loc) {
- match *cause.root_cause() {
- Cause::LiveVar(local, location) => {
- match find_regular_use(mir, regioncx, borrow, location, local) {
- Some(p) => {
+ Cause::DropVar(local, location) => {
+ match find_drop_use(mir, regioncx, borrow, location, local) {
+ Some(p) => match &mir.local_decls[local].name {
+ Some(local_name) => {
err.span_label(
mir.source_info(p).span,
- format!("borrow later used here"),
+ format!(
+ "borrow later used here, when `{}` is dropped",
+ local_name
+ ),
);
}
-
None => {
- span_bug!(
- mir.source_info(context.loc).span,
- "Cause should end in a LiveVar"
+ err.span_label(
+ mir.local_decls[local].source_info.span,
+ "borrow may end up in a temporary, created here",
);
- }
- }
- }
- Cause::DropVar(local, location) => {
- match find_drop_use(mir, regioncx, borrow, location, local) {
- Some(p) => match &mir.local_decls[local].name {
- Some(local_name) => {
- err.span_label(
- mir.source_info(p).span,
- format!(
- "borrow later used here, when `{}` is dropped",
- local_name
- ),
- );
- }
- None => {
- err.span_label(
- mir.local_decls[local].source_info.span,
- "borrow may end up in a temporary, created here",
- );
-
- err.span_label(
- mir.source_info(p).span,
- "temporary later dropped here, \
- potentially using the reference",
- );
- }
- },
-
- None => {
- span_bug!(
- mir.source_info(context.loc).span,
- "Cause should end in a DropVar"
+ err.span_label(
+ mir.source_info(p).span,
+ "temporary later dropped here, \
+ potentially using the reference",
);
}
- }
- }
+ },
- Cause::UniversalRegion(region_vid) => {
- if let Some(region) = regioncx.to_error_region(region_vid) {
- self.tcx.note_and_explain_free_region(
- err,
- "borrowed value must be valid for ",
- region,
- "...",
+ None => {
+ span_bug!(
+ mir.source_info(context.loc).span,
+ "Cause should end in a DropVar"
);
}
}
+ }
- _ => {}
+ Cause::UniversalRegion(region_vid) => {
+ if let Some(region) = regioncx.to_error_region(region_vid) {
+ self.tcx.note_and_explain_free_region(
+ err,
+ "borrowed value must be valid for ",
+ region,
+ "...",
+ );
+ }
}
+
+ _ => {}
}
}
}
// When NLL is enabled, the borrow checker runs the typeck
// itself, so we don't need this MIR pass anymore.
- if tcx.nll() {
+ if tcx.use_mir() {
return;
}
borrow_set: Rc<BorrowSet<'tcx>>,
/// NLL region inference context with which NLL queries should be resolved
- nonlexical_regioncx: Option<Rc<RegionInferenceContext<'tcx>>>,
+ nonlexical_regioncx: Rc<RegionInferenceContext<'tcx>>,
}
impl<'a, 'gcx, 'tcx> Borrows<'a, 'gcx, 'tcx> {
crate fn new(
tcx: TyCtxt<'a, 'gcx, 'tcx>,
mir: &'a Mir<'tcx>,
- nonlexical_regioncx: Option<Rc<RegionInferenceContext<'tcx>>>,
+ nonlexical_regioncx: Rc<RegionInferenceContext<'tcx>>,
def_id: DefId,
body_id: Option<hir::BodyId>,
borrow_set: &Rc<BorrowSet<'tcx>>
fn kill_loans_out_of_scope_at_location(&self,
sets: &mut BlockSets<BorrowIndex>,
location: Location) {
- if let Some(ref regioncx) = self.nonlexical_regioncx {
- // NOTE: The state associated with a given `location`
- // reflects the dataflow on entry to the statement. If it
- // does not contain `borrow_region`, then then that means
- // that the statement at `location` kills the borrow.
- //
- // We are careful always to call this function *before* we
- // set up the gen-bits for the statement or
- // termanator. That way, if the effect of the statement or
- // terminator *does* introduce a new loan of the same
- // region, then setting that gen-bit will override any
- // potential kill introduced here.
- for (borrow_index, borrow_data) in self.borrow_set.borrows.iter_enumerated() {
- let borrow_region = borrow_data.region.to_region_vid();
- if !regioncx.region_contains_point(borrow_region, location) {
- sets.kill(&borrow_index);
- }
+ let regioncx = &self.nonlexical_regioncx;
+
+ // NOTE: The state associated with a given `location`
+ // reflects the dataflow on entry to the statement. If it
+ // does not contain `borrow_region`, then then that means
+ // that the statement at `location` kills the borrow.
+ //
+ // We are careful always to call this function *before* we
+ // set up the gen-bits for the statement or
+ // termanator. That way, if the effect of the statement or
+ // terminator *does* introduce a new loan of the same
+ // region, then setting that gen-bit will override any
+ // potential kill introduced here.
+ for (borrow_index, borrow_data) in self.borrow_set.borrows.iter_enumerated() {
+ let borrow_region = borrow_data.region.to_region_vid();
+ if !regioncx.region_contains_point(borrow_region, location) {
+ sets.kill(&borrow_index);
}
}
}
self.kill_loans_out_of_scope_at_location(sets, location);
match stmt.kind {
- // EndRegion kills any borrows (reservations and active borrows both)
- mir::StatementKind::EndRegion(region_scope) => {
- if let Some(borrow_indexes) =
- self.borrow_set.region_map.get(&ReScope(region_scope))
- {
- assert!(self.nonlexical_regioncx.is_none());
- for idx in borrow_indexes {
- sets.kill(idx);
- }
- } else {
- // (if there is no entry, then there are no borrows to be tracked)
- }
+ mir::StatementKind::EndRegion(_) => {
}
mir::StatementKind::Assign(ref lhs, ref rhs) => {
inside_closure(a)
};
outside_closure_1(a); //[ast]~ ERROR cannot borrow `*a` as mutable because previous closure requires unique access
- //[mir]~^ ERROR cannot borrow `*a` as mutable because previous closure requires unique access
+ //[mir]~^ ERROR cannot borrow `*a` as mutable because previous closure requires unique access
outside_closure_2(a); //[ast]~ ERROR cannot borrow `*a` as immutable because previous closure requires unique access
- //[mir]~^ ERROR cannot borrow `*a` as immutable because previous closure requires unique access
+ //[mir]~^ ERROR cannot borrow `*a` as immutable because previous closure requires unique access
+
+ drop(bar);
}
fn main() {
// ignore-sparc
// revisions: ast mir
-//[mir]compile-flags: -Z borrowck=mir -Z nll
+//[mir]compile-flags: -Z borrowck=mir
#![feature(asm)]
let mut x = 3;
let c1 = || x = 4;
let c2 = || x * 5; //[ast]~ ERROR cannot borrow `x`
- //[mir]~^ ERROR cannot borrow `x` as immutable because it is also borrowed as mutable
+ //[mir]~^ ERROR cannot borrow `x` as immutable because it is also borrowed as mutable
+ drop(c1);
}
fn b() {
let c1 = || set(&mut x);
let c2 = || get(&x); //[ast]~ ERROR cannot borrow `x`
//[mir]~^ ERROR cannot borrow `x` as immutable because it is also borrowed as mutable
+ drop(c1);
}
fn c() {
let c1 = || set(&mut x);
let c2 = || x * 5; //[ast]~ ERROR cannot borrow `x`
//[mir]~^ ERROR cannot borrow `x` as immutable because it is also borrowed as mutable
+ drop(c1);
}
fn d() {
let c2 = || x * 5;
x = 5; //[ast]~ ERROR cannot assign
//[mir]~^ ERROR cannot assign to `x` because it is borrowed
+ drop(c2);
}
fn e() {
let c1 = || get(&x);
x = 5; //[ast]~ ERROR cannot assign
//[mir]~^ ERROR cannot assign to `x` because it is borrowed
+ drop(c1);
}
fn f() {
let c1 = || get(&*x);
*x = 5; //[ast]~ ERROR cannot assign to `*x`
//[mir]~^ ERROR cannot assign to `*x` because it is borrowed
+ drop(c1);
}
fn g() {
let c1 = || get(&*x.f);
*x.f = 5; //[ast]~ ERROR cannot assign to `*x.f`
//[mir]~^ ERROR cannot assign to `*x.f` because it is borrowed
+ drop(c1);
}
fn h() {
let c1 = || get(&*x.f);
let c2 = || *x.f = 5; //[ast]~ ERROR cannot borrow `x` as mutable
//[mir]~^ ERROR cannot borrow `x` as mutable because it is also borrowed as immutable
+ drop(c1);
}
fn main() {
// Local and field from struct
{
let mut f = Foo { x: 22 };
- let _x = f.x();
+ let x = f.x();
f.x; //[ast]~ ERROR cannot use `f.x` because it was mutably borrowed
- //[mir]~^ ERROR cannot use `f.x` because it was mutably borrowed
+ //[mir]~^ ERROR cannot use `f.x` because it was mutably borrowed
+ drop(x);
}
// Local and field from tuple-struct
{
let mut g = Bar(22);
- let _0 = g.x();
+ let x = g.x();
g.0; //[ast]~ ERROR cannot use `g.0` because it was mutably borrowed
//[mir]~^ ERROR cannot use `g.0` because it was mutably borrowed
+ drop(x);
}
// Local and field from tuple
{
let mut h = (22, 23);
- let _0 = &mut h.0;
+ let x = &mut h.0;
h.0; //[ast]~ ERROR cannot use `h.0` because it was mutably borrowed
//[mir]~^ ERROR cannot use `h.0` because it was mutably borrowed
+ drop(x);
}
// Local and field from enum
{
let mut e = Baz::X(2);
- let _e0 = e.x();
+ let x = e.x();
match e { //[mir]~ ERROR cannot use `e` because it was mutably borrowed
Baz::X(value) => value
//[ast]~^ ERROR cannot use `e.0` because it was mutably borrowed
//[mir]~^^ ERROR cannot use `e.0` because it was mutably borrowed
};
+ drop(x);
}
// Local and field from union
unsafe {
let mut u = U { b: 0 };
- let _ra = &mut u.a;
+ let x = &mut u.a;
u.a; //[ast]~ ERROR cannot use `u.a` because it was mutably borrowed
//[mir]~^ ERROR cannot use `u.a` because it was mutably borrowed
+ drop(x);
}
// Deref and field from struct
{
let mut f = Box::new(Foo { x: 22 });
- let _x = f.x();
+ let x = f.x();
f.x; //[ast]~ ERROR cannot use `f.x` because it was mutably borrowed
//[mir]~^ ERROR cannot use `f.x` because it was mutably borrowed
+ drop(x);
}
// Deref and field from tuple-struct
{
let mut g = Box::new(Bar(22));
- let _0 = g.x();
+ let x = g.x();
g.0; //[ast]~ ERROR cannot use `g.0` because it was mutably borrowed
//[mir]~^ ERROR cannot use `g.0` because it was mutably borrowed
+ drop(x);
}
// Deref and field from tuple
{
let mut h = Box::new((22, 23));
- let _0 = &mut h.0;
+ let x = &mut h.0;
h.0; //[ast]~ ERROR cannot use `h.0` because it was mutably borrowed
//[mir]~^ ERROR cannot use `h.0` because it was mutably borrowed
+ drop(x);
}
// Deref and field from enum
{
let mut e = Box::new(Baz::X(3));
- let _e0 = e.x();
+ let x = e.x();
match *e { //[mir]~ ERROR cannot use `*e` because it was mutably borrowed
Baz::X(value) => value
//[ast]~^ ERROR cannot use `e.0` because it was mutably borrowed
//[mir]~^^ ERROR cannot use `e.0` because it was mutably borrowed
};
+ drop(x);
}
// Deref and field from union
unsafe {
let mut u = Box::new(U { b: 0 });
- let _ra = &mut u.a;
+ let x = &mut u.a;
u.a; //[ast]~ ERROR cannot use `u.a` because it was mutably borrowed
//[mir]~^ ERROR cannot use `u.a` because it was mutably borrowed
+ drop(x);
}
// Constant index
{
let mut v = &[1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
- let _v = &mut v;
+ let x = &mut v;
match v { //[mir]~ ERROR cannot use `v` because it was mutably borrowed
&[x, _, .., _, _] => println!("{}", x),
//[ast]~^ ERROR cannot use `v[..]` because it was mutably borrowed
//[mir]~^^ ERROR cannot use `v[..]` because it was mutably borrowed
_ => panic!("other case"),
}
+ drop(x);
}
// Subslices
{
let mut v = &[1, 2, 3, 4, 5];
- let _v = &mut v;
+ let x = &mut v;
match v { //[mir]~ ERROR cannot use `v` because it was mutably borrowed
&[x..] => println!("{:?}", x),
//[ast]~^ ERROR cannot use `v[..]` because it was mutably borrowed
//[mir]~^^ ERROR cannot use `v[..]` because it was mutably borrowed
_ => panic!("other case"),
}
+ drop(x);
}
// Downcasted field
{
enum E<X> { A(X), B { x: X } }
let mut e = E::A(3);
- let _e = &mut e;
+ let x = &mut e;
match e { //[mir]~ ERROR cannot use `e` because it was mutably borrowed
E::A(ref ax) =>
//[ast]~^ ERROR cannot borrow `e.0` as immutable because `e` is also borrowed as mutable
//[mir]~^^ ERROR cannot borrow `e.x` as immutable because it is also borrowed as mutable
println!("e.bx: {:?}", bx),
}
+ drop(x);
}
// Field in field
{
struct F { x: u32, y: u32 };
struct S { x: F, y: (u32, u32), };
let mut s = S { x: F { x: 1, y: 2}, y: (999, 998) };
- let _s = &mut s;
+ let x = &mut s;
match s { //[mir]~ ERROR cannot use `s` because it was mutably borrowed
S { y: (ref y0, _), .. } =>
//[ast]~^ ERROR cannot borrow `s.y.0` as immutable because `s` is also borrowed as mutable
println!("x0: {:?}", x0),
_ => panic!("other case"),
}
+ drop(x);
}
// Field of ref
{
let p: &'a u8 = &*block.current;
//[mir]~^ ERROR cannot borrow `*block.current` as immutable because it is also borrowed as mutable
// No errors in AST because of issue rust#38899
+ drop(x);
}
}
// Field of ptr
let p : *const u8 = &*(*block).current;
//[mir]~^ ERROR cannot borrow `*block.current` as immutable because it is also borrowed as mutable
// No errors in AST because of issue rust#38899
+ drop(x);
}
}
// Field of index
{
struct F {x: u32, y: u32};
let mut v = &[F{x: 1, y: 2}, F{x: 3, y: 4}];
- let _v = &mut v;
+ let x = &mut v;
v[0].y;
//[ast]~^ ERROR cannot use `v[..].y` because it was mutably borrowed
//[mir]~^^ ERROR cannot use `v[..].y` because it was mutably borrowed
//[mir]~| ERROR cannot use `*v` because it was mutably borrowed
+ drop(x);
}
// Field of constant index
{
struct F {x: u32, y: u32};
let mut v = &[F{x: 1, y: 2}, F{x: 3, y: 4}];
- let _v = &mut v;
+ let x = &mut v;
match v { //[mir]~ ERROR cannot use `v` because it was mutably borrowed
&[_, F {x: ref xf, ..}] => println!("{}", xf),
//[mir]~^ ERROR cannot borrow `v[..].x` as immutable because it is also borrowed as mutable
// No errors in AST
_ => panic!("other case")
}
+ drop(x);
}
// Field from upvar
{
}
// Field from upvar nested
{
+ // FIXME(#49824) -- the free region error below should probably not be there
let mut x = 0;
|| {
- || {
- let y = &mut x;
- &mut x; //[ast]~ ERROR cannot borrow `**x` as mutable more than once at a time
- //[mir]~^ ERROR cannot borrow `x` as mutable more than once at a time
- *y = 1;
+ || { //[mir]~ ERROR free region `` does not outlive
+ let y = &mut x;
+ &mut x; //[ast]~ ERROR cannot borrow `**x` as mutable more than once at a time
+ //[mir]~^ ERROR cannot borrow `x` as mutable more than once at a time
+ *y = 1;
+ drop(y);
}
};
}
fn main() {
let mut _a = 3;
- let _b = &mut _a;
+ let b = &mut _a;
{
- let _c = &*_b;
+ let c = &*b;
_a = 4; //[ast]~ ERROR cannot assign to `_a`
- //[mir]~^ ERROR cannot assign to `_a` because it is borrowed
+ //[mir]~^ ERROR cannot assign to `_a` because it is borrowed
+ drop(c);
}
+ drop(b);
}
// fact no outstanding loan of x!
x = Some(0);
}
- Some(ref __isize) => {
+ Some(ref r) => {
x = Some(1); //[ast]~ ERROR cannot assign
- //[mir]~^ ERROR cannot assign to `x` because it is borrowed
+ //[mir]~^ ERROR cannot assign to `x` because it is borrowed
+ drop(r);
}
}
x.clone(); // just to prevent liveness warnings
Foo::A(x) => x //[ast]~ ERROR [E0503]
//[mir]~^ ERROR [E0503]
};
+ drop(p);
}
fn main() {
let mut x = 1;
- let _x = &mut x;
+ let r = &mut x;
let _ = match x { //[mir]~ ERROR [E0503]
x => x + 1, //[ast]~ ERROR [E0503]
//[mir]~^ ERROR [E0503]
y => y + 2, //[ast]~ ERROR [E0503]
//[mir]~^ ERROR [E0503]
};
+ drop(r);
}
fn main() {
let mut x = 1;
- let mut addr;
+ let mut addr = vec![];
loop {
match 1 {
- 1 => { addr = &mut x; } //[ast]~ ERROR [E0499]
+ 1 => { addr.push(&mut x); } //[ast]~ ERROR [E0499]
//[mir]~^ ERROR [E0499]
- 2 => { addr = &mut x; } //[ast]~ ERROR [E0499]
+ 2 => { addr.push(&mut x); } //[ast]~ ERROR [E0499]
//[mir]~^ ERROR [E0499]
- _ => { addr = &mut x; } //[ast]~ ERROR [E0499]
+ _ => { addr.push(&mut x); } //[ast]~ ERROR [E0499]
//[mir]~^ ERROR [E0499]
}
}
s[2] = 20;
//[ast]~^ ERROR cannot assign to immutable indexed content
//[mir]~^^ ERROR cannot assign to immutable item
+ drop(rs);
}
Some(ref i) => {
// But on this branch, `i` is an outstanding borrow
x = Some(*i+1); //[ast]~ ERROR cannot assign to `x`
- //[mir]~^ ERROR cannot assign to `x` because it is borrowed
+ //[mir]~^ ERROR cannot assign to `x` because it is borrowed
+ drop(i);
}
}
x.clone(); // just to prevent liveness warnings
{
let ra = &u.a;
let ra2 = &u.a; // OK
+ drop(ra);
}
{
let ra = &u.a;
let a = u.a; // OK
+ drop(ra);
}
{
let ra = &u.a;
let rma = &mut u.a; //[ast]~ ERROR cannot borrow `u.a` as mutable because it is also borrowed as immutable
//[mir]~^ ERROR cannot borrow `u.a` as mutable because it is also borrowed as immutable
+ drop(ra);
}
{
let ra = &u.a;
u.a = 1; //[ast]~ ERROR cannot assign to `u.a` because it is borrowed
//[mir]~^ ERROR cannot assign to `u.a` because it is borrowed
+ drop(ra);
}
// Imm borrow, other field
{
let ra = &u.a;
let rb = &u.b; // OK
+ drop(ra);
}
{
let ra = &u.a;
let b = u.b; // OK
+ drop(ra);
}
{
let ra = &u.a;
let rmb = &mut u.b; //[ast]~ ERROR cannot borrow `u` (via `u.b`) as mutable because `u` is also borrowed as immutable (via `u.a`)
//[mir]~^ ERROR cannot borrow `u.b` as mutable because it is also borrowed as immutable
+ drop(ra);
}
{
let ra = &u.a;
u.b = 1; //[ast]~ ERROR cannot assign to `u.b` because it is borrowed
//[mir]~^ ERROR cannot assign to `u.b` because it is borrowed
+ drop(ra);
}
// Mut borrow, same field
{
let rma = &mut u.a;
let ra = &u.a; //[ast]~ ERROR cannot borrow `u.a` as immutable because it is also borrowed as mutable
//[mir]~^ ERROR cannot borrow `u.a` as immutable because it is also borrowed as mutable
+ drop(rma);
}
{
let ra = &mut u.a;
let a = u.a; //[ast]~ ERROR cannot use `u.a` because it was mutably borrowed
//[mir]~^ ERROR cannot use `u.a` because it was mutably borrowed
+ drop(ra);
}
{
let rma = &mut u.a;
let rma2 = &mut u.a; //[ast]~ ERROR cannot borrow `u.a` as mutable more than once at a time
//[mir]~^ ERROR cannot borrow `u.a` as mutable more than once at a time
+ drop(rma);
}
{
let rma = &mut u.a;
u.a = 1; //[ast]~ ERROR cannot assign to `u.a` because it is borrowed
//[mir]~^ ERROR cannot assign to `u.a` because it is borrowed
+ drop(rma);
}
// Mut borrow, other field
{
let rma = &mut u.a;
let rb = &u.b; //[ast]~ ERROR cannot borrow `u` (via `u.b`) as immutable because `u` is also borrowed as mutable (via `u.a`)
//[mir]~^ ERROR cannot borrow `u.b` as immutable because it is also borrowed as mutable
+ drop(rma);
}
{
let ra = &mut u.a;
let b = u.b; //[ast]~ ERROR cannot use `u.b` because it was mutably borrowed
//[mir]~^ ERROR cannot use `u.b` because it was mutably borrowed
+ drop(ra);
}
{
let rma = &mut u.a;
let rmb2 = &mut u.b; //[ast]~ ERROR cannot borrow `u` (via `u.b`) as mutable more than once at a time
//[mir]~^ ERROR cannot borrow `u.b` as mutable more than once at a time
+ drop(rma);
}
{
let rma = &mut u.a;
u.b = 1; //[ast]~ ERROR cannot assign to `u.b` because it is borrowed
//[mir]~^ ERROR cannot assign to `u.b` because it is borrowed
+ drop(rma);
}
}
}
// revisions: nll_target
// The following revisions are disabled due to missing support from two-phase beyond autorefs
-//[lxl_beyond] compile-flags: -Z borrowck=mir -Z two-phase-borrows -Z two-phase-beyond-autoref
-//[nll_beyond] compile-flags: -Z borrowck=mir -Z two-phase-borrows -Z two-phase-beyond-autoref -Z nll
+//[nll_beyond] compile-flags: -Z borrowck=mir -Z two-phase-borrows -Z two-phase-beyond-autoref
-//[nll_target] compile-flags: -Z borrowck=mir -Z two-phase-borrows -Z nll
+//[nll_target] compile-flags: -Z borrowck=mir -Z two-phase-borrows
// This is an important corner case pointed out by Niko: one is
// allowed to initiate a shared borrow during a reservation, but it
// revisions: nll_target
// The following revisions are disabled due to missing support for two_phase_beyond_autoref
-//[lxl_beyond] compile-flags: -Z borrowck=mir -Z two-phase-borrows -Z two_phase_beyond_autoref
-//[nll_beyond] compile-flags: -Z borrowck=mir -Z two-phase-borrows -Z two_phase_beyond_autoref -Z nll
+//[nll_beyond] compile-flags: -Z borrowck=mir -Z two-phase-borrows -Z two_phase_beyond_autoref
-
-//[nll_target] compile-flags: -Z borrowck=mir -Z two-phase-borrows -Z nll
+//[nll_target] compile-flags: -Z borrowck=mir -Z two-phase-borrows
// This is the second counter-example from Niko's blog post
// smallcultfollowing.com/babysteps/blog/2017/03/01/nested-method-calls-via-two-phase-borrowing/
/*3*/ *p += 1; // (mutable borrow of `i` starts here, since `p` is used)
- /*4*/ let k = i; //[lxl_beyond]~ ERROR cannot use `i` because it was mutably borrowed [E0503]
- //[nll_beyond]~^ ERROR cannot use `i` because it was mutably borrowed [E0503]
- //[nll_target]~^^ ERROR cannot use `i` because it was mutably borrowed [E0503]
+ /*4*/ let k = i; //[nll_beyond]~ ERROR cannot use `i` because it was mutably borrowed [E0503]
+ //[nll_target]~^ ERROR cannot use `i` because it was mutably borrowed [E0503]
/*5*/ *p += 1;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// revisions: lxl nll
-//[lxl]compile-flags: -Z borrowck=mir -Z two-phase-borrows
-//[nll]compile-flags: -Z borrowck=mir -Z two-phase-borrows -Z nll
+// compile-flags: -Z borrowck=mir -Z two-phase-borrows
// This is the third counter-example from Niko's blog post
// smallcultfollowing.com/babysteps/blog/2017/03/01/nested-method-calls-via-two-phase-borrowing/
vec.get({
vec.push(2);
- //[lxl]~^ ERROR cannot borrow `vec` as mutable because it is also borrowed as immutable
- //[nll]~^^ ERROR cannot borrow `vec` as mutable because it is also borrowed as immutable
+ //~^ ERROR cannot borrow `vec` as mutable because it is also borrowed as immutable
0
});
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// revisions: ast lxl nll
+// revisions: ast nll
//[ast]compile-flags:
-//[lxl]compile-flags: -Z borrowck=mir -Z two-phase-borrows
-//[nll]compile-flags: -Z borrowck=mir -Z two-phase-borrows -Z nll
+//[nll]compile-flags: -Z borrowck=mir -Z two-phase-borrows
-//[g2p]compile-flags: -Z borrowck=mir -Z two-phase-borrows -Z nll -Z two-phase-beyond-autoref
+//[g2p]compile-flags: -Z borrowck=mir -Z two-phase-borrows -Z two-phase-beyond-autoref
// the above revision is disabled until two-phase-beyond-autoref support is better
// This is a test checking that when we limit two-phase borrows to
fn twice_ten_sm<F: FnMut(i32) -> i32>(f: &mut F) {
f(f(10));
- //[lxl]~^ ERROR cannot borrow `*f` as mutable more than once at a time
- //[nll]~^^ ERROR cannot borrow `*f` as mutable more than once at a time
- //[g2p]~^^^ ERROR cannot borrow `*f` as mutable more than once at a time
- //[ast]~^^^^ ERROR cannot borrow `*f` as mutable more than once at a time
+ //[nll]~^ ERROR cannot borrow `*f` as mutable more than once at a time
+ //[g2p]~^^ ERROR cannot borrow `*f` as mutable more than once at a time
+ //[ast]~^^^ ERROR cannot borrow `*f` as mutable more than once at a time
}
fn twice_ten_si<F: Fn(i32) -> i32>(f: &mut F) {
f(f(10));
}
fn twice_ten_so<F: FnOnce(i32) -> i32>(f: Box<F>) {
f(f(10));
- //[lxl]~^ ERROR use of moved value: `*f`
- //[nll]~^^ ERROR use of moved value: `*f`
- //[g2p]~^^^ ERROR use of moved value: `*f`
- //[ast]~^^^^ ERROR use of moved value: `*f`
+ //[nll]~^ ERROR use of moved value: `*f`
+ //[g2p]~^^ ERROR use of moved value: `*f`
+ //[ast]~^^^ ERROR use of moved value: `*f`
}
fn twice_ten_om(f: &mut FnMut(i32) -> i32) {
f(f(10));
- //[lxl]~^ ERROR cannot borrow `*f` as mutable more than once at a time
- //[nll]~^^ ERROR cannot borrow `*f` as mutable more than once at a time
- //[g2p]~^^^ ERROR cannot borrow `*f` as mutable more than once at a time
- //[ast]~^^^^ ERROR cannot borrow `*f` as mutable more than once at a time
+ //[nll]~^ ERROR cannot borrow `*f` as mutable more than once at a time
+ //[g2p]~^^ ERROR cannot borrow `*f` as mutable more than once at a time
+ //[ast]~^^^ ERROR cannot borrow `*f` as mutable more than once at a time
}
fn twice_ten_oi(f: &mut Fn(i32) -> i32) {
f(f(10));
}
fn twice_ten_oo(f: Box<FnOnce(i32) -> i32>) {
f(f(10));
- //[lxl]~^ ERROR cannot move a value of type
- //[lxl]~^^ ERROR cannot move a value of type
- //[lxl]~^^^ ERROR use of moved value: `*f`
- //[nll]~^^^^ ERROR cannot move a value of type
- //[nll]~^^^^^ ERROR cannot move a value of type
- //[nll]~^^^^^^ ERROR use of moved value: `*f`
- //[g2p]~^^^^^^^ ERROR cannot move a value of type
- //[g2p]~^^^^^^^^ ERROR cannot move a value of type
- //[g2p]~^^^^^^^^^ ERROR use of moved value: `*f`
- //[ast]~^^^^^^^^^^ ERROR use of moved value: `*f`
+ //[nll]~^ ERROR cannot move a value of type
+ //[nll]~^^ ERROR cannot move a value of type
+ //[nll]~^^^ ERROR use of moved value: `*f`
+ //[g2p]~^^^^ ERROR cannot move a value of type
+ //[g2p]~^^^^^ ERROR cannot move a value of type
+ //[g2p]~^^^^^^ ERROR use of moved value: `*f`
+ //[ast]~^^^^^^^ ERROR use of moved value: `*f`
}
twice_ten_sm(&mut |x| x + 1);
// This is not okay.
double_access(&mut a, &a);
- //[lxl]~^ ERROR cannot borrow `a` as immutable because it is also borrowed as mutable [E0502]
- //[nll]~^^ ERROR cannot borrow `a` as immutable because it is also borrowed as mutable [E0502]
- //[g2p]~^^^ ERROR cannot borrow `a` as immutable because it is also borrowed as mutable [E0502]
- //[ast]~^^^^ ERROR cannot borrow `a` as immutable because it is also borrowed as mutable [E0502]
+ //[nll]~^ ERROR cannot borrow `a` as immutable because it is also borrowed as mutable [E0502]
+ //[g2p]~^^ ERROR cannot borrow `a` as immutable because it is also borrowed as mutable [E0502]
+ //[ast]~^^^ ERROR cannot borrow `a` as immutable because it is also borrowed as mutable [E0502]
// But this is okay.
a.m(a.i(10));
fn coerce_index_op() {
let mut i = I(10);
i[i[3]] = 4;
- //[lxl]~^ ERROR cannot borrow `i` as immutable because it is also borrowed as mutable [E0502]
- //[nll]~^^ ERROR cannot borrow `i` as immutable because it is also borrowed as mutable [E0502]
- //[ast]~^^^ ERROR cannot borrow `i` as immutable because it is also borrowed as mutable [E0502]
+ //[nll]~^ ERROR cannot borrow `i` as immutable because it is also borrowed as mutable [E0502]
+ //[ast]~^^ ERROR cannot borrow `i` as immutable because it is also borrowed as mutable [E0502]
i[3] = i[4];
i[i[3]] = i[4];
- //[lxl]~^ ERROR cannot borrow `i` as immutable because it is also borrowed as mutable [E0502]
- //[nll]~^^ ERROR cannot borrow `i` as immutable because it is also borrowed as mutable [E0502]
- //[ast]~^^^ ERROR cannot borrow `i` as immutable because it is also borrowed as mutable [E0502]
+ //[nll]~^ ERROR cannot borrow `i` as immutable because it is also borrowed as mutable [E0502]
+ //[ast]~^^ ERROR cannot borrow `i` as immutable because it is also borrowed as mutable [E0502]
}
fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// revisions: lxl nll
-//[lxl]compile-flags: -Z borrowck=mir -Z two-phase-borrows
-//[nll]compile-flags: -Z borrowck=mir -Z two-phase-borrows -Z nll
+// compile-flags: -Z borrowck=mir -Z two-phase-borrows
// This is similar to two-phase-reservation-sharing-interference.rs
// in that it shows a reservation that overlaps with a shared borrow.
#![feature(rustc_attrs)]
#[rustc_error]
-fn main() { //[nll]~ ERROR compilation successful
+fn main() { //~ ERROR compilation successful
let mut v = vec![0, 1, 2];
let shared = &v;
v.push(shared.len());
- //[lxl]~^ ERROR cannot borrow `v` as mutable because it is also borrowed as immutable [E0502]
assert_eq!(v, [0, 1, 2, 3]);
}
// ignore-tidy-linelength
-// revisions: lxl_beyond nll_beyond nll_target
+// revisions: nll_beyond nll_target
// The following revisions are disabled due to missing support from two-phase beyond autorefs
-//[lxl_beyond]compile-flags: -Z borrowck=mir -Z two-phase-borrows -Z two-phase-beyond-autoref
-//[lxl_beyond] should-fail
-//[nll_beyond]compile-flags: -Z borrowck=mir -Z two-phase-borrows -Z two-phase-beyond-autoref -Z nll
+//[nll_beyond]compile-flags: -Z borrowck=mir -Z two-phase-borrows -Z two-phase-beyond-autoref
//[nll_beyond] should-fail
-//[nll_target]compile-flags: -Z borrowck=mir -Z two-phase-borrows -Z nll
+//[nll_target]compile-flags: -Z borrowck=mir -Z two-phase-borrows
// This is a corner case that the current implementation is (probably)
// treating more conservatively than is necessary. But it also does
// with the shared borrow. But in the current implementation,
// its an error.
delay = &mut vec;
- //[lxl_beyond]~^ ERROR cannot borrow `vec` as mutable because it is also borrowed as immutable
- //[nll_beyond]~^^ ERROR cannot borrow `vec` as mutable because it is also borrowed as immutable
- //[nll_target]~^^^ ERROR cannot borrow `vec` as mutable because it is also borrowed as immutable
+ //[nll_beyond]~^ ERROR cannot borrow `vec` as mutable because it is also borrowed as immutable
+ //[nll_target]~^^ ERROR cannot borrow `vec` as mutable because it is also borrowed as immutable
shared[0];
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// revisions: lxl nll
-//[lxl]compile-flags: -Z borrowck=mir -Z two-phase-borrows
-//[nll]compile-flags: -Z borrowck=mir -Z two-phase-borrows -Z nll
+// cmpile-flags: -Z borrowck=mir -Z two-phase-borrows
// This is the first counter-example from Niko's blog post
// smallcultfollowing.com/babysteps/blog/2017/03/01/nested-method-calls-via-two-phase-borrowing/
v[0].push_str({
v.push(format!("foo"));
- //[lxl]~^ ERROR cannot borrow `v` as mutable more than once at a time [E0499]
- //[nll]~^^ ERROR cannot borrow `v` as mutable more than once at a time [E0499]
+ //~^ ERROR cannot borrow `v` as mutable more than once at a time [E0499]
"World!"
});
let z = borrow_mut(x);
//[ast]~^ ERROR cannot borrow `*x` as mutable more than once at a time
//[mir]~^^ ERROR cannot borrow `*x` as mutable more than once at a time
+ drop((y, z));
}
fn double_imm_borrow(x: &mut Box<i32>) {
**x += 1;
//[ast]~^ ERROR cannot assign to `**x` because it is borrowed
//[mir]~^^ ERROR cannot assign to `**x` because it is borrowed
+ drop((y, z));
}
fn double_mut_borrow2<T>(x: &mut Box<T>) {
f.call(&x);
f.call(&x);
x = 5;
+ drop(y);
}
fn main() {
// revisions: ast mir
//[mir]compile-flags: -Z borrowck=mir
+// FIXME(#49821) -- No tip about using a let binding
+
use std::cell::RefCell;
fn main() {
//[ast]~| NOTE temporary value does not live long enough
//[ast]~| NOTE consider using a `let` binding to increase its lifetime
//[mir]~^^^^^ ERROR borrowed value does not live long enough [E0597]
- //[mir]~| NOTE temporary value dropped here while still borrowed
//[mir]~| NOTE temporary value does not live long enough
- //[mir]~| NOTE consider using a `let` binding to increase its lifetime
+ //[mir]~| NOTE temporary value only lives until here
println!("{}", val);
+ //[mir]~^ borrow later used here
}
//[ast]~^ NOTE temporary value needs to live until here
-//[mir]~^^ NOTE temporary value needs to live until here
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// compile-flags: -Z borrowck=mir -Z nll
+// compile-flags: -Z borrowck=mir
#![allow(dead_code)]
let g: fn(_, _) -> _ = |_x, y| y;
//~^ ERROR free region `'b` does not outlive free region `'a`
g
- //~^ WARNING not reporting region error due to -Znll
+ //~^ WARNING not reporting region error due to nll
}
fn main() {}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// compile-flags: -Z borrowck=mir -Z nll
+// compile-flags: -Zborrowck=mir
#![allow(dead_code)]
// The MIR type checker must therefore relate `'?0` to `'?1` and `'?2`
// as part of checking the `ReifyFnPointer`.
let f: fn(_) -> _ = foo;
- //~^ WARNING not reporting region error due to -Znll
+ //~^ WARNING not reporting region error due to nll
//~| ERROR free region `'a` does not outlive free region `'static`
f(x)
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// compile-flags: -Z borrowck=mir -Z nll
+// compile-flags: -Zborrowck=mir
#![allow(dead_code)]
// Here the NLL checker must relate the types in `f` to the types
// in `g`. These are related via the `UnsafeFnPointer` cast.
let g: unsafe fn(_) -> _ = f;
- //~^ WARNING not reporting region error due to -Znll
+ //~^ WARNING not reporting region error due to nll
//~| ERROR free region `'a` does not outlive free region `'static`
unsafe { g(input) }
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// compile-flags: -Z borrowck=mir -Z nll
+// compile-flags: -Z borrowck=mir
#![allow(dead_code)]
#![feature(dyn_trait)]
fn bar<'a>(x: &'a u32) -> &'static dyn Debug {
//~^ ERROR free region `'a` does not outlive free region `'static`
x
- //~^ WARNING not reporting region error due to -Znll
+ //~^ WARNING not reporting region error due to nll
}
fn main() {}
// check borrowing is detected successfully
let &mut ref x = foo;
*foo += 1; //[ast]~ ERROR cannot assign to `*foo` because it is borrowed
- //[mir]~^ ERROR cannot assign to `*foo` because it is borrowed
+ //[mir]~^ ERROR cannot assign to `*foo` because it is borrowed
+ drop(x);
}
// except according to those terms.
-// compile-flags:-Zborrowck=compare -Znll
+// compile-flags:-Zborrowck=compare
#![allow(warnings)]
#![feature(rustc_attrs)]
// except according to those terms.
-// compile-flags:-Zborrowck=compare -Znll
+// compile-flags:-Zborrowck=compare
#![allow(warnings)]
#![feature(rustc_attrs)]
// except according to those terms.
//revisions: ast mir
-//[mir] compile-flags: -Z borrowck=mir -Z nll
+//[mir] compile-flags: -Z borrowck=mir
#![allow(unused_assignments)]
// in the type of `p` includes the points after `&v[0]` up to (but not
// including) the call to `use_x`. The `else` branch is not included.
-// compile-flags:-Zborrowck=compare -Znll
+// compile-flags:-Zborrowck=compare
#![allow(warnings)]
#![feature(rustc_attrs)]
// in the type of `p` includes the points after `&v[0]` up to (but not
// including) the call to `use_x`. The `else` branch is not included.
-// compile-flags:-Zborrowck=compare -Znll
+// compile-flags:-Zborrowck=compare
#![allow(warnings)]
#![feature(rustc_attrs)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// compile-flags: -Z borrowck=mir -Z nll
+// compile-flags: -Zborrowck=mir
#![allow(dead_code)]
fn bar<'a, 'b>(x: &'a u32, y: &'b u32) -> (&'a u32, &'b u32) {
foo(x, y)
//~^ ERROR lifetime mismatch [E0623]
- //~| WARNING not reporting region error due to -Znll
+ //~| WARNING not reporting region error due to nll
}
fn main() {}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// compile-flags: -Z borrowck=mir -Z nll
+// compile-flags: -Z borrowck=mir
#![allow(dead_code)]
fn bar<'a, 'b>(x: Cell<&'a u32>, y: Cell<&'b u32>) {
Foo { x, y };
//~^ ERROR lifetime mismatch [E0623]
- //~| WARNING not reporting region error due to -Znll
+ //~| WARNING not reporting region error due to nll
}
fn main() {}
match (&a1,) {
(&ref b0,) => {
a1 = &f; //[ast]~ ERROR cannot assign
- //[mir]~^ ERROR cannot assign to `a1` because it is borrowed
+ //[mir]~^ ERROR cannot assign to `a1` because it is borrowed
+ drop(b0);
}
}
}
// except according to those terms.
// revisions: ll nll
-//[nll] compile-flags: -Znll -Zborrowck=mir
+//[nll] compile-flags:-Zborrowck=mir
fn static_id<'a,'b>(t: &'a ()) -> &'static ()
where 'a: 'static { t }
where 'a: 'b, 'b: 'static { t }
fn static_id_wrong_way<'a>(t: &'a ()) -> &'static () where 'static: 'a {
t //[ll]~ ERROR E0312
- //[nll]~^ WARNING not reporting region error due to -Znll
+ //[nll]~^ WARNING not reporting region error due to nll
//[nll]~| ERROR free region `'a` does not outlive free region `'static`
}
fn error(u: &(), v: &()) {
static_id(&u); //[ll]~ ERROR explicit lifetime required in the type of `u` [E0621]
- //[nll]~^ WARNING not reporting region error due to -Znll
+ //[nll]~^ WARNING not reporting region error due to nll
//[nll]~| ERROR explicit lifetime required in the type of `u` [E0621]
static_id_indirect(&v); //[ll]~ ERROR explicit lifetime required in the type of `v` [E0621]
- //[nll]~^ WARNING not reporting region error due to -Znll
+ //[nll]~^ WARNING not reporting region error due to nll
//[nll]~| ERROR explicit lifetime required in the type of `v` [E0621]
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// compile-flags:-Znll
+// compile-flags:-Zborrowck=mir
fn can_panic() -> Box<usize> {
Box::new(44)
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// compile-flags:-Znll
+// compile-flags:-Zborrowck=mir
#![allow(warnings)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// compile-flags:-Znll
+// compile-flags:-Zborrowck=mir
fn cond() -> bool { false }
// suitable variables and that we setup the outlives relationship
// between R0 and R1 properly.
-// compile-flags:-Znll -Zverbose
-// ^^^^^^^^^ force compiler to dump more region information
+// compile-flags:-Zborrowck=mir -Zverbose
+// ^^^^^^^^^ force compiler to dump more region information
// ignore-tidy-linelength
#![allow(warnings)]
// in the type of `r_a` must outlive the region (`R7`) that appears in
// the type of `r_b`
-// compile-flags:-Znll -Zverbose
-// ^^^^^^^^^ force compiler to dump more region information
+// compile-flags:-Zborrowck=mir -Zverbose
+// ^^^^^^^^^ force compiler to dump more region information
#![allow(warnings)]
// in the type of `p` includes the points after `&v[0]` up to (but not
// including) the call to `use_x`. The `else` branch is not included.
-// compile-flags:-Znll -Zverbose
-// ^^^^^^^^^ force compiler to dump more region information
+// compile-flags:-Zborrowck=mir -Zverbose
+// ^^^^^^^^^ force compiler to dump more region information
#![allow(warnings)]
// but only at a particular point, and hence they wind up including
// distinct regions.
-// compile-flags:-Znll -Zverbose
-// ^^^^^^^^^ force compiler to dump more region information
+// compile-flags:-Zborrowck=mir -Zverbose
+// ^^^^^^^^^ force compiler to dump more region information
#![allow(warnings)]
// in the type of `p` includes the points after `&v[0]` up to (but not
// including) the call to `use_x`. The `else` branch is not included.
-// compile-flags:-Znll -Zverbose
-// ^^^^^^^^^ force compiler to dump more region information
+// compile-flags:-Zborrowck=mir -Zverbose
+// ^^^^^^^^^ force compiler to dump more region information
#![allow(warnings)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// revisions: lxl nll
-//[lxl]compile-flags: -Z borrowck=mir -Z two-phase-borrows
-//[nll]compile-flags: -Z borrowck=mir -Z two-phase-borrows -Z nll
+// compile-flags: -Z borrowck=mir -Z two-phase-borrows
// This is the "goto example" for why we want two phase borrows.
// except according to those terms.
// revisions: normal nll
-//[nll] compile-flags: -Znll -Zborrowck=mir
+//[nll] compile-flags:-Zborrowck=mir
#![feature(fn_traits,
step_trait,
let c1 = to_fn_mut(|| x = 4);
let c2 = to_fn_mut(|| x = 5); //~ ERROR cannot borrow `x` as mutable more than once
//~| ERROR cannot borrow `x` as mutable more than once
+ drop((c1, c2));
}
fn set(x: &mut isize) {
let c1 = to_fn_mut(|| set(&mut x));
let c2 = to_fn_mut(|| set(&mut x)); //~ ERROR cannot borrow `x` as mutable more than once
//~| ERROR cannot borrow `x` as mutable more than once
+ drop((c1, c2));
}
fn c() {
let c1 = to_fn_mut(|| x = 5);
let c2 = to_fn_mut(|| set(&mut x)); //~ ERROR cannot borrow `x` as mutable more than once
//~| ERROR cannot borrow `x` as mutable more than once
+ drop((c1, c2));
}
fn d() {
let c2 = to_fn_mut(|| { let _y = to_fn_mut(|| set(&mut x)); }); // (nested closure)
//~^ ERROR cannot borrow `x` as mutable more than once
//~| ERROR cannot borrow `x` as mutable more than once
+ drop((c1, c2));
}
fn g() {
let c2 = to_fn_mut(|| set(&mut *x.f));
//~^ ERROR cannot borrow `x` as mutable more than once
//~| ERROR cannot borrow `x` as mutable more than once
+ drop((c1, c2));
}
fn main() {
| ^^ - borrow occurs due to use of `x` in closure
| |
| second mutable borrow occurs here
-LL | //~| ERROR cannot borrow `x` as mutable more than once
+...
LL | }
| - first borrow ends here
error[E0499]: cannot borrow `x` as mutable more than once at a time (Ast)
- --> $DIR/borrowck-closures-two-mut.rs:35:24
+ --> $DIR/borrowck-closures-two-mut.rs:36:24
|
LL | let c1 = to_fn_mut(|| set(&mut x));
| -- - previous borrow occurs due to use of `x` in closure
| ^^ - borrow occurs due to use of `x` in closure
| |
| second mutable borrow occurs here
-LL | //~| ERROR cannot borrow `x` as mutable more than once
+...
LL | }
| - first borrow ends here
error[E0499]: cannot borrow `x` as mutable more than once at a time (Ast)
- --> $DIR/borrowck-closures-two-mut.rs:42:24
+ --> $DIR/borrowck-closures-two-mut.rs:44:24
|
LL | let c1 = to_fn_mut(|| x = 5);
| -- - previous borrow occurs due to use of `x` in closure
| ^^ - borrow occurs due to use of `x` in closure
| |
| second mutable borrow occurs here
-LL | //~| ERROR cannot borrow `x` as mutable more than once
+...
LL | }
| - first borrow ends here
error[E0499]: cannot borrow `x` as mutable more than once at a time (Ast)
- --> $DIR/borrowck-closures-two-mut.rs:49:24
+ --> $DIR/borrowck-closures-two-mut.rs:52:24
|
LL | let c1 = to_fn_mut(|| x = 5);
| -- - previous borrow occurs due to use of `x` in closure
| - first borrow ends here
error[E0499]: cannot borrow `x` as mutable more than once at a time (Ast)
- --> $DIR/borrowck-closures-two-mut.rs:61:24
+ --> $DIR/borrowck-closures-two-mut.rs:65:24
|
LL | let c1 = to_fn_mut(|| set(&mut *x.f));
| -- - previous borrow occurs due to use of `x` in closure
| |
| second mutable borrow occurs here
LL | //~| ERROR cannot borrow `x` as mutable more than once
-LL | }
- | - first borrow ends here
+LL | drop((c1, c2));
+ | -- borrow later used here
error[E0499]: cannot borrow `x` as mutable more than once at a time (Mir)
- --> $DIR/borrowck-closures-two-mut.rs:35:24
+ --> $DIR/borrowck-closures-two-mut.rs:36:24
|
LL | let c1 = to_fn_mut(|| set(&mut x));
| -- - previous borrow occurs due to use of `x` in closure
| |
| second mutable borrow occurs here
LL | //~| ERROR cannot borrow `x` as mutable more than once
-LL | }
- | - first borrow ends here
+LL | drop((c1, c2));
+ | -- borrow later used here
error[E0499]: cannot borrow `x` as mutable more than once at a time (Mir)
- --> $DIR/borrowck-closures-two-mut.rs:42:24
+ --> $DIR/borrowck-closures-two-mut.rs:44:24
|
LL | let c1 = to_fn_mut(|| x = 5);
| -- - previous borrow occurs due to use of `x` in closure
| |
| second mutable borrow occurs here
LL | //~| ERROR cannot borrow `x` as mutable more than once
-LL | }
- | - first borrow ends here
+LL | drop((c1, c2));
+ | -- borrow later used here
error[E0499]: cannot borrow `x` as mutable more than once at a time (Mir)
- --> $DIR/borrowck-closures-two-mut.rs:49:24
+ --> $DIR/borrowck-closures-two-mut.rs:52:24
|
LL | let c1 = to_fn_mut(|| x = 5);
| -- - previous borrow occurs due to use of `x` in closure
| |
| second mutable borrow occurs here
...
-LL | }
- | - first borrow ends here
+LL | drop((c1, c2));
+ | -- borrow later used here
error[E0499]: cannot borrow `x` as mutable more than once at a time (Mir)
- --> $DIR/borrowck-closures-two-mut.rs:61:24
+ --> $DIR/borrowck-closures-two-mut.rs:65:24
|
LL | let c1 = to_fn_mut(|| set(&mut *x.f));
| -- - previous borrow occurs due to use of `x` in closure
| |
| second mutable borrow occurs here
...
-LL | }
- | - first borrow ends here
+LL | drop((c1, c2));
+ | -- borrow later used here
error: aborting due to 10 previous errors
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// revisions: lxl nll
-//[lxl]compile-flags: -Z borrowck=mir -Z two-phase-borrows
-//[nll]compile-flags: -Z borrowck=mir -Z two-phase-borrows -Z nll
+// compile-flags: -Z borrowck=mir -Z two-phase-borrows
// run-pass
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// revisions: lxl nll
-//[lxl]compile-flags: -Z borrowck=mir -Z two-phase-borrows
-//[nll]compile-flags: -Z borrowck=mir -Z two-phase-borrows -Z nll
+// compile-flags: -Z borrowck=mir -Z two-phase-borrows
// run-pass
*y.pointer += 1;
//~^ ERROR cannot assign to `*y.pointer` because it is borrowed (Ast) [E0506]
//~| ERROR cannot use `*y.pointer` because it was mutably borrowed (Mir) [E0503]
+ //~| ERROR cannot assign to `*y.pointer` because it is borrowed (Mir) [E0506]
*z.pointer += 1;
}
}
| ------ borrow of `y` occurs here
LL | *y.pointer += 1;
| ^^^^^^^^^^^^^^^ use of borrowed `y`
+...
+LL | *z.pointer += 1;
+ | --------------- borrow later used here
-error: aborting due to 2 previous errors
+error[E0506]: cannot assign to `*y.pointer` because it is borrowed (Mir)
+ --> $DIR/issue-45697-1.rs:30:9
+ |
+LL | let z = copy_borrowed_ptr(&mut y);
+ | ------ borrow of `*y.pointer` occurs here
+LL | *y.pointer += 1;
+ | ^^^^^^^^^^^^^^^ assignment to borrowed `*y.pointer` occurs here
+...
+LL | *z.pointer += 1;
+ | --------------- borrow later used here
+
+error: aborting due to 3 previous errors
Some errors occurred: E0503, E0506.
For more information about an error, try `rustc --explain E0503`.
*y.pointer += 1;
//~^ ERROR cannot assign to `*y.pointer` because it is borrowed (Ast) [E0506]
//~| ERROR cannot use `*y.pointer` because it was mutably borrowed (Mir) [E0503]
+ //~| ERROR cannot assign to `*y.pointer` because it is borrowed (Mir) [E0506]
*z.pointer += 1;
}
}
| ------ borrow of `y` occurs here
LL | *y.pointer += 1;
| ^^^^^^^^^^^^^^^ use of borrowed `y`
+...
+LL | *z.pointer += 1;
+ | --------------- borrow later used here
-error: aborting due to 2 previous errors
+error[E0506]: cannot assign to `*y.pointer` because it is borrowed (Mir)
+ --> $DIR/issue-45697.rs:30:9
+ |
+LL | let z = copy_borrowed_ptr(&mut y);
+ | ------ borrow of `*y.pointer` occurs here
+LL | *y.pointer += 1;
+ | ^^^^^^^^^^^^^^^ assignment to borrowed `*y.pointer` occurs here
+...
+LL | *z.pointer += 1;
+ | --------------- borrow later used here
+
+error: aborting due to 3 previous errors
Some errors occurred: E0503, E0506.
For more information about an error, try `rustc --explain E0503`.
error[E0597]: `z` does not live long enough (Mir)
--> $DIR/issue-46471-1.rs:16:9
|
-LL | &mut z
- | ^^^^^^ borrowed value does not live long enough
-LL | };
- | - `z` dropped here while still borrowed
-...
-LL | }
- | - borrowed value needs to live until here
+LL | let y = {
+ | _____________-
+LL | | let mut z = 0;
+LL | | &mut z
+ | | ^^^^^^ borrowed value does not live long enough
+LL | | };
+ | | -
+ | | |
+ | |_____borrowed value only lives until here
+ | borrow later used here
error: aborting due to 2 previous errors
// that appear free in its type (hence, we see it before the closure's
// "external requirements" report).
-// compile-flags:-Znll -Zborrowck=mir -Zverbose
+// compile-flags:-Zborrowck=mir -Zverbose
#![feature(rustc_attrs)]
let y = 22;
let mut closure = expect_sig(|p, y| *p = y);
//~^ ERROR does not outlive free region
- //~| WARNING not reporting region error due to -Znll
+ //~| WARNING not reporting region error due to nll
closure(&mut p, &y);
}
-warning: not reporting region error due to -Znll
+warning: not reporting region error due to nll
--> $DIR/escape-argument-callee.rs:36:50
|
LL | let mut closure = expect_sig(|p, y| *p = y);
// basically checking that the MIR type checker correctly enforces the
// closure signature.
-// compile-flags:-Znll -Zborrowck=mir -Zverbose
+// compile-flags:-Zborrowck=mir -Zverbose
#![feature(rustc_attrs)]
//
// except that the closure does so via a second closure.
-// compile-flags:-Znll -Zborrowck=mir -Zverbose
+// compile-flags:-Zborrowck=mir -Zverbose
#![feature(rustc_attrs)]
// `'b`. This relationship is propagated to the closure creator,
// which reports an error.
-// compile-flags:-Znll -Zborrowck=mir -Zverbose
+// compile-flags:-Zborrowck=mir -Zverbose
#![feature(rustc_attrs)]
// Test where we fail to approximate due to demanding a postdom
// relationship between our upper bounds.
-// compile-flags:-Znll -Zborrowck=mir -Zverbose
+// compile-flags:-Zborrowck=mir -Zverbose
#![feature(rustc_attrs)]
|_outlives1, _outlives2, _outlives3, x, y| {
// Only works if 'x: 'y:
let p = x.get();
- //~^ WARN not reporting region error due to -Znll
+ //~^ WARN not reporting region error due to nll
//~| ERROR does not outlive free region
demand_y(x, y, p)
},
-warning: not reporting region error due to -Znll
+warning: not reporting region error due to nll
--> $DIR/propagate-approximated-fail-no-postdom.rs:55:21
|
LL | let p = x.get();
LL | / |_outlives1, _outlives2, _outlives3, x, y| {
LL | | // Only works if 'x: 'y:
LL | | let p = x.get();
-LL | | //~^ WARN not reporting region error due to -Znll
+LL | | //~^ WARN not reporting region error due to nll
LL | | //~| ERROR does not outlive free region
LL | | demand_y(x, y, p)
LL | | },
// Note: the use of `Cell` here is to introduce invariance. One less
// variable.
-// compile-flags:-Znll -Zborrowck=mir -Zverbose
+// compile-flags:-Zborrowck=mir -Zverbose
#![feature(rustc_attrs)]
//~^ ERROR lifetime mismatch
// Only works if 'x: 'y:
- demand_y(x, y, x.get()) //~ WARNING not reporting region error due to -Znll
+ demand_y(x, y, x.get()) //~ WARNING not reporting region error due to nll
});
}
-warning: not reporting region error due to -Znll
+warning: not reporting region error due to nll
--> $DIR/propagate-approximated-ref.rs:57:9
|
-LL | demand_y(x, y, x.get()) //~ WARNING not reporting region error due to -Znll
+LL | demand_y(x, y, x.get()) //~ WARNING not reporting region error due to nll
| ^^^^^^^^^^^^^^^^^^^^^^^
note: External requirements
LL | | //~^ ERROR lifetime mismatch
LL | |
LL | | // Only works if 'x: 'y:
-LL | | demand_y(x, y, x.get()) //~ WARNING not reporting region error due to -Znll
+LL | | demand_y(x, y, x.get()) //~ WARNING not reporting region error due to nll
LL | | });
| |_____^
|
// where `'x` is bound in closure type but `'a` is free. This forces
// us to approximate `'x` one way or the other.
-// compile-flags:-Znll -Zborrowck=mir -Zverbose
+// compile-flags:-Zborrowck=mir -Zverbose
#![feature(rustc_attrs)]
let a = 0;
let cell = Cell::new(&a);
foo(cell, |cell_a, cell_x| {
- //~^ WARNING not reporting region error due to -Znll
+ //~^ WARNING not reporting region error due to nll
cell_a.set(cell_x.get()); // forces 'x: 'a, error in closure
//~^ ERROR does not outlive free region
})
-warning: not reporting region error due to -Znll
+warning: not reporting region error due to nll
--> $DIR/propagate-approximated-shorter-to-static-comparing-against-free.rs:31:5
|
LL | foo(cell, |cell_a, cell_x| {
|
LL | foo(cell, |cell_a, cell_x| {
| _______________^
-LL | | //~^ WARNING not reporting region error due to -Znll
+LL | | //~^ WARNING not reporting region error due to nll
LL | | cell_a.set(cell_x.get()); // forces 'x: 'a, error in closure
LL | | //~^ ERROR does not outlive free region
LL | | })
// FIXME(#45827) Because of shortcomings in the MIR type checker,
// these errors are not (yet) reported.
-// compile-flags:-Znll -Zborrowck=mir -Zverbose
+// compile-flags:-Zborrowck=mir -Zverbose
#![feature(rustc_attrs)]
//~^ ERROR does not outlive free region
// Only works if 'x: 'y:
- demand_y(x, y, x.get()) //~ WARNING not reporting region error due to -Znll
+ demand_y(x, y, x.get()) //~ WARNING not reporting region error due to nll
});
}
-warning: not reporting region error due to -Znll
+warning: not reporting region error due to nll
--> $DIR/propagate-approximated-shorter-to-static-no-bound.rs:49:9
|
-LL | demand_y(x, y, x.get()) //~ WARNING not reporting region error due to -Znll
+LL | demand_y(x, y, x.get()) //~ WARNING not reporting region error due to nll
| ^^^^^^^^^^^^^^^^^^^^^^^
note: External requirements
LL | | //~^ ERROR does not outlive free region
LL | |
LL | | // Only works if 'x: 'y:
-LL | | demand_y(x, y, x.get()) //~ WARNING not reporting region error due to -Znll
+LL | | demand_y(x, y, x.get()) //~ WARNING not reporting region error due to nll
LL | | });
| |_____^
|
LL | | //~^ ERROR does not outlive free region
LL | |
LL | | // Only works if 'x: 'y:
-LL | | demand_y(x, y, x.get()) //~ WARNING not reporting region error due to -Znll
+LL | | demand_y(x, y, x.get()) //~ WARNING not reporting region error due to nll
LL | | });
| |_____^
// FIXME(#45827) Because of shortcomings in the MIR type checker,
// these errors are not (yet) reported.
-// compile-flags:-Znll -Zborrowck=mir -Zverbose
+// compile-flags:-Zborrowck=mir -Zverbose
#![feature(rustc_attrs)]
//~^ ERROR does not outlive free region
// Only works if 'x: 'y:
demand_y(x, y, x.get())
- //~^ WARNING not reporting region error due to -Znll
+ //~^ WARNING not reporting region error due to nll
});
}
-warning: not reporting region error due to -Znll
+warning: not reporting region error due to nll
--> $DIR/propagate-approximated-shorter-to-static-wrong-bound.rs:51:9
|
LL | demand_y(x, y, x.get())
LL | | //~^ ERROR does not outlive free region
LL | | // Only works if 'x: 'y:
LL | | demand_y(x, y, x.get())
-LL | | //~^ WARNING not reporting region error due to -Znll
+LL | | //~^ WARNING not reporting region error due to nll
LL | | });
| |_____^
|
LL | | //~^ ERROR does not outlive free region
LL | | // Only works if 'x: 'y:
LL | | demand_y(x, y, x.get())
-LL | | //~^ WARNING not reporting region error due to -Znll
+LL | | //~^ WARNING not reporting region error due to nll
LL | | });
| |_____^
// relationships. In the 'main' variant, there are a number of
// anonymous regions as well.
-// compile-flags:-Znll -Zborrowck=mir -Zverbose
+// compile-flags:-Zborrowck=mir -Zverbose
#![feature(rustc_attrs)]
//~^ ERROR lifetime mismatch
// Only works if 'x: 'y:
- demand_y(outlives1, outlives2, x.get()) //~ WARNING not reporting region error due to -Znll
+ demand_y(outlives1, outlives2, x.get()) //~ WARNING not reporting region error due to nll
});
}
-warning: not reporting region error due to -Znll
+warning: not reporting region error due to nll
--> $DIR/propagate-approximated-val.rs:50:9
|
-LL | demand_y(outlives1, outlives2, x.get()) //~ WARNING not reporting region error due to -Znll
+LL | demand_y(outlives1, outlives2, x.get()) //~ WARNING not reporting region error due to nll
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
note: External requirements
LL | | //~^ ERROR lifetime mismatch
LL | |
LL | | // Only works if 'x: 'y:
-LL | | demand_y(outlives1, outlives2, x.get()) //~ WARNING not reporting region error due to -Znll
+LL | | demand_y(outlives1, outlives2, x.get()) //~ WARNING not reporting region error due to nll
LL | | });
| |_____^
|
// need to propagate; but in fact we do because identity of free
// regions is erased.
-// compile-flags:-Znll -Zborrowck=mir -Zverbose
+// compile-flags:-Zborrowck=mir -Zverbose
// compile-pass
#![feature(rustc_attrs)]
-warning: not reporting region error due to -Znll
+warning: not reporting region error due to nll
--> $DIR/propagate-despite-same-free-region.rs:54:21
|
LL | let p = x.get();
// as it knows of no relationships between `'x` and any
// non-higher-ranked regions.
-// compile-flags:-Znll -Zborrowck=mir -Zverbose
+// compile-flags:-Zborrowck=mir -Zverbose
#![feature(rustc_attrs)]
establish_relationships(&cell_a, &cell_b, |_outlives, x, y| {
// Only works if 'x: 'y:
demand_y(x, y, x.get())
- //~^ WARN not reporting region error due to -Znll
+ //~^ WARN not reporting region error due to nll
//~| ERROR does not outlive free region
});
}
-warning: not reporting region error due to -Znll
+warning: not reporting region error due to nll
--> $DIR/propagate-fail-to-approximate-longer-no-bounds.rs:47:9
|
LL | demand_y(x, y, x.get())
| _______________________________________________^
LL | | // Only works if 'x: 'y:
LL | | demand_y(x, y, x.get())
-LL | | //~^ WARN not reporting region error due to -Znll
+LL | | //~^ WARN not reporting region error due to nll
LL | | //~| ERROR does not outlive free region
LL | | });
| |_____^
// as it only knows of regions that `'x` is outlived by, and none that
// `'x` outlives.
-// compile-flags:-Znll -Zborrowck=mir -Zverbose
+// compile-flags:-Zborrowck=mir -Zverbose
#![feature(rustc_attrs)]
establish_relationships(&cell_a, &cell_b, |_outlives1, _outlives2, x, y| {
// Only works if 'x: 'y:
demand_y(x, y, x.get())
- //~^ WARN not reporting region error due to -Znll
+ //~^ WARN not reporting region error due to nll
//~| ERROR does not outlive free region
});
}
-warning: not reporting region error due to -Znll
+warning: not reporting region error due to nll
--> $DIR/propagate-fail-to-approximate-longer-wrong-bounds.rs:51:9
|
LL | demand_y(x, y, x.get())
| _______________________________________________^
LL | | // Only works if 'x: 'y:
LL | | demand_y(x, y, x.get())
-LL | | //~^ WARN not reporting region error due to -Znll
+LL | | //~^ WARN not reporting region error due to nll
LL | | //~| ERROR does not outlive free region
LL | | });
| |_____^
// the same `'a` for which it implements `Trait`, which can only be the `'a`
// from the function definition.
-// compile-flags:-Znll -Zborrowck=mir -Zverbose
+// compile-flags:-Zborrowck=mir -Zverbose
#![feature(rustc_attrs)]
#![allow(dead_code)]
// The latter does not hold.
require(value);
- //~^ WARNING not reporting region error due to -Znll
+ //~^ WARNING not reporting region error due to nll
});
}
-warning: not reporting region error due to -Znll
+warning: not reporting region error due to nll
--> $DIR/propagate-from-trait-match.rs:55:9
|
LL | require(value);
LL | |
LL | | // This function call requires that
... |
-LL | | //~^ WARNING not reporting region error due to -Znll
+LL | | //~^ WARNING not reporting region error due to nll
LL | | });
| |_____^
|
LL | |
LL | | // This function call requires that
... |
-LL | | //~^ WARNING not reporting region error due to -Znll
+LL | | //~^ WARNING not reporting region error due to nll
LL | | });
| |_____^
|
// a variety of errors from the older, AST-based machinery (notably
// borrowck), and then we get the NLL error at the end.
-// compile-flags:-Znll -Zborrowck=mir -Zverbose
+// compile-flags:-Zborrowck=mir -Zverbose
fn foo(x: &u32) -> &'static u32 {
&*x
- //~^ WARN not reporting region error due to -Znll
+ //~^ WARN not reporting region error due to nll
//~| ERROR explicit lifetime required in the type of `x`
}
-warning: not reporting region error due to -Znll
+warning: not reporting region error due to nll
--> $DIR/region-lbr-anon-does-not-outlive-static.rs:19:5
|
LL | &*x
// a variety of errors from the older, AST-based machinery (notably
// borrowck), and then we get the NLL error at the end.
-// compile-flags:-Znll -Zborrowck=mir -Zverbose
+// compile-flags:-Zborrowck=mir -Zverbose
fn foo<'a>(x: &'a u32) -> &'static u32 {
&*x
- //~^ WARN not reporting region error due to -Znll
+ //~^ WARN not reporting region error due to nll
//~| ERROR does not outlive free region
}
-warning: not reporting region error due to -Znll
+warning: not reporting region error due to nll
--> $DIR/region-lbr-named-does-not-outlive-static.rs:19:5
|
LL | &*x
// a variety of errors from the older, AST-based machinery (notably
// borrowck), and then we get the NLL error at the end.
-// compile-flags:-Znll -Zborrowck=mir -Zverbose
+// compile-flags:-Zborrowck=mir -Zverbose
fn foo<'a, 'b>(x: &'a u32, y: &'b u32) -> &'b u32 {
&*x
- //~^ WARN not reporting region error due to -Znll
+ //~^ WARN not reporting region error due to nll
//~| ERROR lifetime mismatch
}
-warning: not reporting region error due to -Znll
+warning: not reporting region error due to nll
--> $DIR/region-lbr1-does-not-outlive-ebr2.rs:19:5
|
LL | &*x
// Basic test for free regions in the NLL code. This test does not
// report an error because of the (implied) bound that `'b: 'a`.
-// compile-flags:-Znll -Zborrowck=mir -Zverbose
+// compile-flags:-Zborrowck=mir -Zverbose
// compile-pass
#![allow(warnings)]
// the first, but actually returns the second. This should fail within
// the closure.
-// compile-flags:-Znll -Zborrowck=mir -Zverbose
+// compile-flags:-Zborrowck=mir -Zverbose
#![feature(rustc_attrs)]
#[rustc_regions]
fn test() {
expect_sig(|a, b| b); // ought to return `a`
- //~^ WARN not reporting region error due to -Znll
+ //~^ WARN not reporting region error due to nll
//~| ERROR does not outlive free region
}
-warning: not reporting region error due to -Znll
+warning: not reporting region error due to nll
--> $DIR/return-wrong-bound-region.rs:21:23
|
LL | expect_sig(|a, b| b); // ought to return `a`
|
LL | / fn test() {
LL | | expect_sig(|a, b| b); // ought to return `a`
-LL | | //~^ WARN not reporting region error due to -Znll
+LL | | //~^ WARN not reporting region error due to nll
LL | | //~| ERROR does not outlive free region
LL | | }
| |_^
// Test that MIR borrowck and NLL analysis can handle constants of
// arbitrary types without ICEs.
-// compile-flags:-Znll -Zborrowck=mir -Zverbose
+// compile-flags:-Zborrowck=mir -Zverbose
// compile-pass
const HI: &str = "hi";
// in the type of `p` includes the points after `&v[0]` up to (but not
// including) the call to `use_x`. The `else` branch is not included.
-// compile-flags:-Znll -Zborrowck=mir
+// compile-flags:-Zborrowck=mir
// compile-pass
#![allow(warnings)]
// because of destructor. (Note that the stderr also identifies this
// destructor in the error message.)
-// compile-flags:-Znll -Zborrowck=mir
+// compile-flags:-Zborrowck=mir
#![allow(warnings)]
#![feature(dropck_eyepatch)]
// a variety of errors from the older, AST-based machinery (notably
// borrowck), and then we get the NLL error at the end.
-// compile-flags:-Znll -Zborrowck=compare
+// compile-flags:-Zborrowck=compare
struct Map {
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-//compile-flags: -Z emit-end-regions -Zborrowck=mir -Znll
+//compile-flags: -Z emit-end-regions -Zborrowck=mir
#![allow(warnings)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-//compile-flags: -Z emit-end-regions -Zborrowck=mir -Z nll
+// compile-flags: -Z emit-end-regions -Zborrowck=mir
// compile-pass
#![allow(warnings)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-//compile-flags: -Z emit-end-regions -Zborrowck=mir -Znll
+//compile-flags: -Z emit-end-regions -Zborrowck=mir
#![allow(warnings)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-//compile-flags: -Z emit-end-regions -Zborrowck=mir -Znll
+//compile-flags: -Z emit-end-regions -Zborrowck=mir
#![allow(warnings)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-//compile-flags: -Z emit-end-regions -Zborrowck=mir -Znll
+//compile-flags: -Z emit-end-regions -Zborrowck=mir
#![allow(warnings)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// compile-flags:-Znll -Zborrowck=mir
+// compile-flags:-Zborrowck=mir
// compile-pass
#![feature(rustc_attrs)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// compile-flags:-Znll -Zborrowck=mir -Zverbose
+// compile-flags:-Zborrowck=mir -Zverbose
#![allow(warnings)]
fn foo<'a, T>(x: &T) -> impl Foo<'a> {
x
- //~^ WARNING not reporting region error due to -Znll
+ //~^ WARNING not reporting region error due to nll
//~| ERROR explicit lifetime required in the type of `x` [E0621]
}
-warning: not reporting region error due to -Znll
+warning: not reporting region error due to nll
--> $DIR/impl-trait-captures.rs:21:5
|
LL | x
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// compile-flags:-Znll -Zborrowck=mir -Zverbose
+// compile-flags:-Zborrowck=mir -Zverbose
#![allow(warnings)]
use std::fmt::Debug;
fn no_region<'a, T>(x: Box<T>) -> impl Debug + 'a
- //~^ WARNING not reporting region error due to -Znll
+ //~^ WARNING not reporting region error due to nll
where
T: Debug,
{
}
fn wrong_region<'a, 'b, T>(x: Box<T>) -> impl Debug + 'a
- //~^ WARNING not reporting region error due to -Znll
+ //~^ WARNING not reporting region error due to nll
where
T: 'b + Debug,
{
-warning: not reporting region error due to -Znll
+warning: not reporting region error due to nll
--> $DIR/impl-trait-outlives.rs:17:35
|
LL | fn no_region<'a, T>(x: Box<T>) -> impl Debug + 'a
| ^^^^^^^^^^^^^^^
-warning: not reporting region error due to -Znll
+warning: not reporting region error due to nll
--> $DIR/impl-trait-outlives.rs:33:42
|
LL | fn wrong_region<'a, 'b, T>(x: Box<T>) -> impl Debug + 'a
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// compile-flags:-Znll -Zborrowck=mir -Zverbose
+// compile-flags:-Zborrowck=mir -Zverbose
// Test that we can deduce when projections like `T::Item` outlive the
// function body. Test that this does not imply that `T: 'a` holds.
#[rustc_errors]
fn generic2<T: Iterator>(value: T) {
twice(value, |value_ref, item| invoke2(value_ref, item));
- //~^ WARNING not reporting region error due to -Znll
+ //~^ WARNING not reporting region error due to nll
//~| ERROR the parameter type `T` may not live long enough
}
-warning: not reporting region error due to -Znll
+warning: not reporting region error due to nll
--> $DIR/projection-implied-bounds.rs:45:36
|
LL | twice(value, |value_ref, item| invoke2(value_ref, item));
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// compile-flags:-Znll -Zborrowck=mir -Zverbose
+// compile-flags:-Zborrowck=mir -Zverbose
// Tests closures that propagate an outlives relationship to their
// creator where the subject is a projection with no regions (`<T as
T: Iterator,
{
with_signature(x, |mut y| Box::new(y.next()))
- //~^ WARNING not reporting region error due to -Znll
+ //~^ WARNING not reporting region error due to nll
//~| ERROR the associated type `<T as std::iter::Iterator>::Item` may not live long enough
}
T: 'b + Iterator,
{
with_signature(x, |mut y| Box::new(y.next()))
- //~^ WARNING not reporting region error due to -Znll
+ //~^ WARNING not reporting region error due to nll
//~| ERROR the associated type `<T as std::iter::Iterator>::Item` may not live long enough
}
-warning: not reporting region error due to -Znll
+warning: not reporting region error due to nll
--> $DIR/projection-no-regions-closure.rs:36:31
|
LL | with_signature(x, |mut y| Box::new(y.next()))
| ^^^^^^^^^^^^^^^^^^
-warning: not reporting region error due to -Znll
+warning: not reporting region error due to nll
--> $DIR/projection-no-regions-closure.rs:54:31
|
LL | with_signature(x, |mut y| Box::new(y.next()))
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// compile-flags:-Znll -Zborrowck=mir -Zverbose
+// compile-flags:-Zborrowck=mir -Zverbose
#![allow(warnings)]
#![feature(dyn_trait)]
T: Iterator,
{
Box::new(x.next())
- //~^ WARNING not reporting region error due to -Znll
+ //~^ WARNING not reporting region error due to nll
//~| the associated type `<T as std::iter::Iterator>::Item` may not live long enough
}
T: 'b + Iterator,
{
Box::new(x.next())
- //~^ WARNING not reporting region error due to -Znll
+ //~^ WARNING not reporting region error due to nll
//~| the associated type `<T as std::iter::Iterator>::Item` may not live long enough
}
-warning: not reporting region error due to -Znll
+warning: not reporting region error due to nll
--> $DIR/projection-no-regions-fn.rs:24:5
|
LL | Box::new(x.next())
| ^^^^^^^^^^^^^^^^^^
-warning: not reporting region error due to -Znll
+warning: not reporting region error due to nll
--> $DIR/projection-no-regions-fn.rs:40:5
|
LL | Box::new(x.next())
//
// Ensuring that both `T: 'a` and `'b: 'a` holds does work (`elements_outlive`).
-// compile-flags:-Znll -Zborrowck=mir -Zverbose
+// compile-flags:-Zborrowck=mir -Zverbose
#![allow(warnings)]
#![feature(dyn_trait)]
T: Anything<'b>,
{
with_signature(cell, t, |cell, t| require(cell, t));
- //~^ WARNING not reporting region error due to -Znll
+ //~^ WARNING not reporting region error due to nll
//~| ERROR the parameter type `T` may not live long enough
//~| ERROR does not outlive free region
}
'a: 'a,
{
with_signature(cell, t, |cell, t| require(cell, t));
- //~^ WARNING not reporting region error due to -Znll
+ //~^ WARNING not reporting region error due to nll
//~| ERROR the parameter type `T` may not live long enough
//~| ERROR does not outlive free region
}
// can do better here with a more involved verification step.
with_signature(cell, t, |cell, t| require(cell, t));
- //~^ WARNING not reporting region error due to -Znll
+ //~^ WARNING not reporting region error due to nll
//~| ERROR the parameter type `T` may not live long enough
//~| ERROR free region `ReEarlyBound(1, 'b)` does not outlive free region `ReEarlyBound(0, 'a)`
}
-warning: not reporting region error due to -Znll
+warning: not reporting region error due to nll
--> $DIR/projection-one-region-closure.rs:56:39
|
LL | with_signature(cell, t, |cell, t| require(cell, t));
| ^^^^^^^
-warning: not reporting region error due to -Znll
+warning: not reporting region error due to nll
--> $DIR/projection-one-region-closure.rs:68:39
|
LL | with_signature(cell, t, |cell, t| require(cell, t));
| ^^^^^^^
-warning: not reporting region error due to -Znll
+warning: not reporting region error due to nll
--> $DIR/projection-one-region-closure.rs:90:39
|
LL | with_signature(cell, t, |cell, t| require(cell, t));
// case, the best way to satisfy the trait bound is to show that `'b:
// 'a`, which can be done in various ways.
-// compile-flags:-Znll -Zborrowck=mir -Zverbose
+// compile-flags:-Zborrowck=mir -Zverbose
#![allow(warnings)]
#![feature(dyn_trait)]
T: Anything<'b>,
{
with_signature(cell, t, |cell, t| require(cell, t));
- //~^ WARNING not reporting region error due to -Znll
+ //~^ WARNING not reporting region error due to nll
//~| ERROR does not outlive free region
}
'a: 'a,
{
with_signature(cell, t, |cell, t| require(cell, t));
- //~^ WARNING not reporting region error due to -Znll
+ //~^ WARNING not reporting region error due to nll
//~| ERROR does not outlive free region
}
// can do better here with a more involved verification step.
with_signature(cell, t, |cell, t| require(cell, t));
- //~^ WARNING not reporting region error due to -Znll
+ //~^ WARNING not reporting region error due to nll
//~| ERROR does not outlive free region
}
-warning: not reporting region error due to -Znll
+warning: not reporting region error due to nll
--> $DIR/projection-one-region-trait-bound-closure.rs:48:39
|
LL | with_signature(cell, t, |cell, t| require(cell, t));
| ^^^^^^^
-warning: not reporting region error due to -Znll
+warning: not reporting region error due to nll
--> $DIR/projection-one-region-trait-bound-closure.rs:59:39
|
LL | with_signature(cell, t, |cell, t| require(cell, t));
| ^^^^^^^
-warning: not reporting region error due to -Znll
+warning: not reporting region error due to nll
--> $DIR/projection-one-region-trait-bound-closure.rs:80:39
|
LL | with_signature(cell, t, |cell, t| require(cell, t));
// outlive `'static`. In this case, we don't get any errors, and in fact
// we don't even propagate constraints from the closures to the callers.
-// compile-flags:-Znll -Zborrowck=mir -Zverbose
+// compile-flags:-Zborrowck=mir -Zverbose
// compile-pass
#![allow(warnings)]
// the trait bound, and hence we propagate it to the caller as a type
// test.
-// compile-flags:-Znll -Zborrowck=mir -Zverbose
+// compile-flags:-Zborrowck=mir -Zverbose
#![allow(warnings)]
#![feature(dyn_trait)]
T: Anything<'b, 'c>,
{
with_signature(cell, t, |cell, t| require(cell, t));
- //~^ WARNING not reporting region error due to -Znll
+ //~^ WARNING not reporting region error due to nll
//~| ERROR associated type `<T as Anything<'_#5r, '_#6r>>::AssocType` may not live long enough
}
'a: 'a,
{
with_signature(cell, t, |cell, t| require(cell, t));
- //~^ WARNING not reporting region error due to -Znll
+ //~^ WARNING not reporting region error due to nll
//~| ERROR associated type `<T as Anything<'_#6r, '_#7r>>::AssocType` may not live long enough
}
// can do better here with a more involved verification step.
with_signature(cell, t, |cell, t| require(cell, t));
- //~^ WARNING not reporting region error due to -Znll
+ //~^ WARNING not reporting region error due to nll
//~| ERROR associated type `<T as Anything<'_#6r, '_#7r>>::AssocType` may not live long enough
}
T: Anything<'b, 'b>,
{
with_signature(cell, t, |cell, t| require(cell, t));
- //~^ WARNING not reporting region error due to -Znll
+ //~^ WARNING not reporting region error due to nll
//~| ERROR does not outlive free region
}
-warning: not reporting region error due to -Znll
+warning: not reporting region error due to nll
--> $DIR/projection-two-region-trait-bound-closure.rs:49:39
|
LL | with_signature(cell, t, |cell, t| require(cell, t));
| ^^^^^^^
-warning: not reporting region error due to -Znll
+warning: not reporting region error due to nll
--> $DIR/projection-two-region-trait-bound-closure.rs:60:39
|
LL | with_signature(cell, t, |cell, t| require(cell, t));
| ^^^^^^^
-warning: not reporting region error due to -Znll
+warning: not reporting region error due to nll
--> $DIR/projection-two-region-trait-bound-closure.rs:81:39
|
LL | with_signature(cell, t, |cell, t| require(cell, t));
| ^^^^^^^
-warning: not reporting region error due to -Znll
+warning: not reporting region error due to nll
--> $DIR/projection-two-region-trait-bound-closure.rs:109:39
|
LL | with_signature(cell, t, |cell, t| require(cell, t));
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// compile-flags:-Znll -Zborrowck=mir -Zverbose
+// compile-flags:-Zborrowck=mir -Zverbose
#![allow(warnings)]
#![feature(dyn_trait)]
-warning: not reporting region error due to -Znll
+warning: not reporting region error due to nll
--> $DIR/ty-param-closure-approximate-lower-bound.rs:35:31
|
LL | twice(cell, value, |a, b| invoke(a, b));
| ^^^^^^^^^^^^
-warning: not reporting region error due to -Znll
+warning: not reporting region error due to nll
--> $DIR/ty-param-closure-approximate-lower-bound.rs:43:31
|
LL | twice(cell, value, |a, b| invoke(a, b));
| ^^^^^^
-warning: not reporting region error due to -Znll
+warning: not reporting region error due to nll
--> $DIR/ty-param-closure-approximate-lower-bound.rs:43:31
|
LL | twice(cell, value, |a, b| invoke(a, b));
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// compile-flags:-Znll -Zborrowck=mir -Zverbose
+// compile-flags:-Zborrowck=mir -Zverbose
#![allow(warnings)]
#![feature(dyn_trait)]
// `'a` (and subsequently reports an error).
with_signature(x, |y| y)
- //~^ WARNING not reporting region error due to -Znll
+ //~^ WARNING not reporting region error due to nll
//~| ERROR the parameter type `T` may not live long enough
}
T: 'b + Debug,
{
x
- //~^ WARNING not reporting region error due to -Znll
+ //~^ WARNING not reporting region error due to nll
//~| ERROR the parameter type `T` may not live long enough
}
-warning: not reporting region error due to -Znll
+warning: not reporting region error due to nll
--> $DIR/ty-param-closure-outlives-from-return-type.rs:37:27
|
LL | with_signature(x, |y| y)
| ^
-warning: not reporting region error due to -Znll
+warning: not reporting region error due to nll
--> $DIR/ty-param-closure-outlives-from-return-type.rs:53:5
|
LL | x
// `correct_region` for an explanation of how this test is setup; it's
// somewhat intricate.
-// compile-flags:-Znll -Zborrowck=mir -Zverbose
+// compile-flags:-Zborrowck=mir -Zverbose
#![allow(warnings)]
#![feature(dyn_trait)]
// function, there is no where clause *anywhere*, and hence we
// get an error (but reported by the closure creator).
require(&x, &y)
- //~^ WARNING not reporting region error due to -Znll
+ //~^ WARNING not reporting region error due to nll
})
}
//~^ ERROR the parameter type `T` may not live long enough
// See `correct_region`
require(&x, &y)
- //~^ WARNING not reporting region error due to -Znll
+ //~^ WARNING not reporting region error due to nll
})
}
-warning: not reporting region error due to -Znll
+warning: not reporting region error due to nll
--> $DIR/ty-param-closure-outlives-from-where-clause.rs:45:9
|
LL | require(&x, &y)
| ^^^^^^^
-warning: not reporting region error due to -Znll
+warning: not reporting region error due to nll
--> $DIR/ty-param-closure-outlives-from-where-clause.rs:79:9
|
LL | require(&x, &y)
LL | | //
LL | | // See `correct_region`, which explains the point of this
... |
-LL | | //~^ WARNING not reporting region error due to -Znll
+LL | | //~^ WARNING not reporting region error due to nll
LL | | })
| |_____^
|
LL | | //
LL | | // See `correct_region`, which explains the point of this
... |
-LL | | //~^ WARNING not reporting region error due to -Znll
+LL | | //~^ WARNING not reporting region error due to nll
LL | | })
| |_____^
|
LL | | //~^ ERROR the parameter type `T` may not live long enough
LL | | // See `correct_region`
LL | | require(&x, &y)
-LL | | //~^ WARNING not reporting region error due to -Znll
+LL | | //~^ WARNING not reporting region error due to nll
LL | | })
| |_____^
|
LL | | //~^ ERROR the parameter type `T` may not live long enough
LL | | // See `correct_region`
LL | | require(&x, &y)
-LL | | //~^ WARNING not reporting region error due to -Znll
+LL | | //~^ WARNING not reporting region error due to nll
LL | | })
| |_____^
|
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// compile-flags:-Znll -Zborrowck=mir
+// compile-flags:-Zborrowck=mir
// Test that we assume that universal types like `T` outlive the
// function body.
// Error here, because T: 'a is not satisfied.
fn region_static<'a, T>(cell: Cell<&'a usize>, t: T) {
outlives(cell, t)
- //~^ WARNING not reporting region error due to -Znll
+ //~^ WARNING not reporting region error due to nll
//~| ERROR the parameter type `T` may not live long enough
}
-warning: not reporting region error due to -Znll
+warning: not reporting region error due to nll
--> $DIR/ty-param-fn-body.rs:30:5
|
LL | outlives(cell, t)
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// compile-flags:-Znll -Zborrowck=mir
+// compile-flags:-Zborrowck=mir
#![allow(warnings)]
#![feature(dyn_trait)]
T: Debug,
{
x
- //~^ WARNING not reporting region error due to -Znll
+ //~^ WARNING not reporting region error due to nll
//~| the parameter type `T` may not live long enough
}
T: 'b + Debug,
{
x
- //~^ WARNING not reporting region error due to -Znll
+ //~^ WARNING not reporting region error due to nll
//~| the parameter type `T` may not live long enough
}
-warning: not reporting region error due to -Znll
+warning: not reporting region error due to nll
--> $DIR/ty-param-fn.rs:22:5
|
LL | x
| ^
-warning: not reporting region error due to -Znll
+warning: not reporting region error due to nll
--> $DIR/ty-param-fn.rs:38:5
|
LL | x
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// compile-flags:-Znll -Zborrowck=mir -Zverbose
+// compile-flags:-Zborrowck=mir -Zverbose
// compile-pass
// Test that we assume that universal types like `T` outlive the
match self.config.compare_mode {
Some(CompareMode::Nll) => {
- rustc.args(&["-Znll", "-Zborrowck=mir", "-Ztwo-phase-borrows"]);
+ rustc.args(&["-Zborrowck=mir", "-Ztwo-phase-borrows"]);
},
None => {},
}