diff --git a/compiler/rustc_driver/src/lib.rs b/compiler/rustc_driver/src/lib.rs
index 136c9f6ec7da0..d99e335a77a00 100644
--- a/compiler/rustc_driver/src/lib.rs
+++ b/compiler/rustc_driver/src/lib.rs
@@ -1258,9 +1258,9 @@ pub fn report_ice(info: &panic::PanicInfo<'_>, bug_report_url: &str) {
// If backtraces are enabled, also print the query stack
let backtrace = env::var_os("RUST_BACKTRACE").map(|x| &x != "0").unwrap_or(false);
- if backtrace {
- TyCtxt::try_print_query_stack(&handler);
- }
+ let num_frames = if backtrace { None } else { Some(2) };
+
+ TyCtxt::try_print_query_stack(&handler, num_frames);
#[cfg(windows)]
unsafe {
diff --git a/compiler/rustc_error_codes/src/error_codes/E0007.md b/compiler/rustc_error_codes/src/error_codes/E0007.md
index 2be7870d5aeee..2c22b86af9246 100644
--- a/compiler/rustc_error_codes/src/error_codes/E0007.md
+++ b/compiler/rustc_error_codes/src/error_codes/E0007.md
@@ -1,3 +1,5 @@
+#### Note: this error code is no longer emitted by the compiler.
+
This error indicates that the bindings in a match arm would require a value to
be moved into more than one location, thus violating unique ownership. Code
like the following is invalid as it requires the entire `Option<String>` to be
@@ -6,11 +8,13 @@ inner `String` to be moved into a variable called `s`.
Erroneous code example:
-```compile_fail,E0007
+```compile_fail,E0382
+#![feature(bindings_after_at)]
+
let x = Some("s".to_string());
match x {
- op_string @ Some(s) => {}, // error: cannot bind by-move with sub-bindings
+ op_string @ Some(s) => {}, // error: use of moved value
None => {},
}
```
diff --git a/compiler/rustc_feature/src/accepted.rs b/compiler/rustc_feature/src/accepted.rs
index e2492efb9d79e..4401ec0a04ea5 100644
--- a/compiler/rustc_feature/src/accepted.rs
+++ b/compiler/rustc_feature/src/accepted.rs
@@ -270,6 +270,9 @@ declare_features! (
(accepted, track_caller, "1.46.0", Some(47809), None),
/// Allows `#[doc(alias = "...")]`.
(accepted, doc_alias, "1.48.0", Some(50146), None),
+ /// Allows patterns with concurrent by-move and by-ref bindings.
+ /// For example, you can write `Foo(a, ref b)` where `a` is by-move and `b` is by-ref.
+ (accepted, move_ref_pattern, "1.48.0", Some(68354), None),
// -------------------------------------------------------------------------
// feature-group-end: accepted features
diff --git a/compiler/rustc_feature/src/active.rs b/compiler/rustc_feature/src/active.rs
index 8a7f0517e732b..7fbd070a609b7 100644
--- a/compiler/rustc_feature/src/active.rs
+++ b/compiler/rustc_feature/src/active.rs
@@ -526,10 +526,6 @@ declare_features! (
/// For example, you can write `x @ Some(y)`.
(active, bindings_after_at, "1.41.0", Some(65490), None),
- /// Allows patterns with concurrent by-move and by-ref bindings.
- /// For example, you can write `Foo(a, ref b)` where `a` is by-move and `b` is by-ref.
- (active, move_ref_pattern, "1.42.0", Some(68354), None),
-
/// Allows `impl const Trait for T` syntax.
(active, const_trait_impl, "1.42.0", Some(67792), None),
diff --git a/compiler/rustc_middle/src/ty/instance.rs b/compiler/rustc_middle/src/ty/instance.rs
index f8e8c209d373d..4a2c97b4a400f 100644
--- a/compiler/rustc_middle/src/ty/instance.rs
+++ b/compiler/rustc_middle/src/ty/instance.rs
@@ -291,7 +291,17 @@ impl<'tcx> Instance<'tcx> {
}
pub fn mono(tcx: TyCtxt<'tcx>, def_id: DefId) -> Instance<'tcx> {
- Instance::new(def_id, tcx.empty_substs_for_def_id(def_id))
+ let substs = InternalSubsts::for_item(tcx, def_id, |param, _| match param.kind {
+ ty::GenericParamDefKind::Lifetime => tcx.lifetimes.re_erased.into(),
+ ty::GenericParamDefKind::Type { .. } => {
+ bug!("Instance::mono: {:?} has type parameters", def_id)
+ }
+ ty::GenericParamDefKind::Const { .. } => {
+ bug!("Instance::mono: {:?} has const parameters", def_id)
+ }
+ });
+
+ Instance::new(def_id, substs)
}
#[inline]
diff --git a/compiler/rustc_middle/src/ty/query/plumbing.rs b/compiler/rustc_middle/src/ty/query/plumbing.rs
index f3fa3634026fd..27bf22dac75cb 100644
--- a/compiler/rustc_middle/src/ty/query/plumbing.rs
+++ b/compiler/rustc_middle/src/ty/query/plumbing.rs
@@ -124,20 +124,23 @@ impl<'tcx> TyCtxt<'tcx> {
})
}
- pub fn try_print_query_stack(handler: &Handler) {
+ pub fn try_print_query_stack(handler: &Handler, num_frames: Option<usize>) {
eprintln!("query stack during panic:");
// Be careful reyling on global state here: this code is called from
// a panic hook, which means that the global `Handler` may be in a weird
// state if it was responsible for triggering the panic.
+ let mut i = 0;
ty::tls::with_context_opt(|icx| {
if let Some(icx) = icx {
let query_map = icx.tcx.queries.try_collect_active_jobs();
let mut current_query = icx.query;
- let mut i = 0;
while let Some(query) = current_query {
+ if Some(i) == num_frames {
+ break;
+ }
let query_info =
if let Some(info) = query_map.as_ref().and_then(|map| map.get(&query)) {
info
@@ -163,7 +166,11 @@ impl<'tcx> TyCtxt<'tcx> {
}
});
- eprintln!("end of query stack");
+ if num_frames == None || num_frames >= Some(i) {
+ eprintln!("end of query stack");
+ } else {
+ eprintln!("we're just showing a limited slice of the query stack");
+ }
}
}
diff --git a/compiler/rustc_middle/src/ty/util.rs b/compiler/rustc_middle/src/ty/util.rs
index 8734acad9b228..b0f0f0ba57fad 100644
--- a/compiler/rustc_middle/src/ty/util.rs
+++ b/compiler/rustc_middle/src/ty/util.rs
@@ -6,9 +6,9 @@ use crate::mir::interpret::{sign_extend, truncate};
use crate::ty::fold::TypeFolder;
use crate::ty::layout::IntegerExt;
use crate::ty::query::TyCtxtAt;
-use crate::ty::subst::{GenericArgKind, InternalSubsts, Subst, SubstsRef};
+use crate::ty::subst::{GenericArgKind, Subst, SubstsRef};
use crate::ty::TyKind::*;
-use crate::ty::{self, DefIdTree, GenericParamDefKind, List, Ty, TyCtxt, TypeFoldable};
+use crate::ty::{self, DefIdTree, List, Ty, TyCtxt, TypeFoldable};
use rustc_apfloat::Float as _;
use rustc_ast as ast;
use rustc_attr::{self as attr, SignedInt, UnsignedInt};
@@ -509,20 +509,6 @@ impl<'tcx> TyCtxt<'tcx> {
Some(ty::Binder::bind(env_ty))
}
- /// Given the `DefId` of some item that has no type or const parameters, make
- /// a suitable "empty substs" for it.
- pub fn empty_substs_for_def_id(self, item_def_id: DefId) -> SubstsRef<'tcx> {
- InternalSubsts::for_item(self, item_def_id, |param, _| match param.kind {
- GenericParamDefKind::Lifetime => self.lifetimes.re_erased.into(),
- GenericParamDefKind::Type { .. } => {
- bug!("empty_substs_for_def_id: {:?} has type parameters", item_def_id)
- }
- GenericParamDefKind::Const { .. } => {
- bug!("empty_substs_for_def_id: {:?} has const parameters", item_def_id)
- }
- })
- }
-
/// Returns `true` if the node pointed to by `def_id` is a `static` item.
pub fn is_static(self, def_id: DefId) -> bool {
self.static_mutability(def_id).is_some()
diff --git a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
index 25a8565fb43b3..69de7c7e2ee0b 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
@@ -71,13 +71,13 @@ impl<'tcx> Visitor<'tcx> for MatchVisitor<'_, 'tcx> {
hir::LocalSource::AwaitDesugar => ("`await` future binding", None),
};
self.check_irrefutable(&loc.pat, msg, sp);
- self.check_patterns(false, &loc.pat);
+ self.check_patterns(&loc.pat);
}
fn visit_param(&mut self, param: &'tcx hir::Param<'tcx>) {
intravisit::walk_param(self, param);
self.check_irrefutable(¶m.pat, "function argument", None);
- self.check_patterns(false, ¶m.pat);
+ self.check_patterns(¶m.pat);
}
}
@@ -119,10 +119,7 @@ impl PatCtxt<'_, '_> {
}
impl<'tcx> MatchVisitor<'_, 'tcx> {
- fn check_patterns(&mut self, has_guard: bool, pat: &Pat<'_>) {
- if !self.tcx.features().move_ref_pattern {
- check_legality_of_move_bindings(self, has_guard, pat);
- }
+ fn check_patterns(&mut self, pat: &Pat<'_>) {
pat.walk_always(|pat| check_borrow_conflicts_in_at_patterns(self, pat));
if !self.tcx.features().bindings_after_at {
check_legality_of_bindings_in_at_patterns(self, pat);
@@ -165,7 +162,7 @@ impl<'tcx> MatchVisitor<'_, 'tcx> {
) {
for arm in arms {
// Check the arm for some things unrelated to exhaustiveness.
- self.check_patterns(arm.guard.is_some(), &arm.pat);
+ self.check_patterns(&arm.pat);
}
let mut cx = self.new_cx(scrut.hir_id);
@@ -601,65 +598,6 @@ fn is_binding_by_move(cx: &MatchVisitor<'_, '_>, hir_id: HirId, span: Span) -> b
!cx.typeck_results.node_type(hir_id).is_copy_modulo_regions(cx.tcx.at(span), cx.param_env)
}
-/// Check the legality of legality of by-move bindings.
-fn check_legality_of_move_bindings(cx: &mut MatchVisitor<'_, '_>, has_guard: bool, pat: &Pat<'_>) {
- let sess = cx.tcx.sess;
- let typeck_results = cx.typeck_results;
-
- // Find all by-ref spans.
- let mut by_ref_spans = Vec::new();
- pat.each_binding(|_, hir_id, span, _| {
- if let Some(ty::BindByReference(_)) =
- typeck_results.extract_binding_mode(sess, hir_id, span)
- {
- by_ref_spans.push(span);
- }
- });
-
- // Find bad by-move spans:
- let by_move_spans = &mut Vec::new();
- let mut check_move = |p: &Pat<'_>, sub: Option<&Pat<'_>>| {
- // Check legality of moving out of the enum.
- //
- // `x @ Foo(..)` is legal, but `x @ Foo(y)` isn't.
- if sub.map_or(false, |p| p.contains_bindings()) {
- struct_span_err!(sess, p.span, E0007, "cannot bind by-move with sub-bindings")
- .span_label(p.span, "binds an already bound by-move value by moving it")
- .emit();
- } else if !has_guard && !by_ref_spans.is_empty() {
- by_move_spans.push(p.span);
- }
- };
- pat.walk_always(|p| {
- if let hir::PatKind::Binding(.., sub) = &p.kind {
- if let Some(ty::BindByValue(_)) =
- typeck_results.extract_binding_mode(sess, p.hir_id, p.span)
- {
- if is_binding_by_move(cx, p.hir_id, p.span) {
- check_move(p, sub.as_deref());
- }
- }
- }
- });
-
- // Found some bad by-move spans, error!
- if !by_move_spans.is_empty() {
- let mut err = feature_err(
- &sess.parse_sess,
- sym::move_ref_pattern,
- by_move_spans.clone(),
- "binding by-move and by-ref in the same pattern is unstable",
- );
- for span in by_ref_spans.iter() {
- err.span_label(*span, "by-ref pattern here");
- }
- for span in by_move_spans.iter() {
- err.span_label(*span, "by-move pattern here");
- }
- err.emit();
- }
-}
-
/// Check that there are no borrow or move conflicts in `binding @ subpat` patterns.
///
/// For example, this would reject:
diff --git a/compiler/rustc_parse/src/parser/expr.rs b/compiler/rustc_parse/src/parser/expr.rs
index a6df41f47ce55..17cbaf65420f6 100644
--- a/compiler/rustc_parse/src/parser/expr.rs
+++ b/compiler/rustc_parse/src/parser/expr.rs
@@ -246,11 +246,7 @@ impl<'a> Parser<'a> {
this.parse_assoc_expr_with(prec + prec_adjustment, LhsExpr::NotYetParsed)
})?;
- // Make sure that the span of the parent node is larger than the span of lhs and rhs,
- // including the attributes.
- let lhs_span =
- lhs.attrs.iter().find(|a| a.style == AttrStyle::Outer).map_or(lhs_span, |a| a.span);
- let span = lhs_span.to(rhs.span);
+ let span = self.mk_expr_sp(&lhs, lhs_span, rhs.span);
lhs = match op {
AssocOp::Add
| AssocOp::Subtract
@@ -411,7 +407,7 @@ impl<'a> Parser<'a> {
None
};
let rhs_span = rhs.as_ref().map_or(cur_op_span, |x| x.span);
- let span = lhs.span.to(rhs_span);
+ let span = self.mk_expr_sp(&lhs, lhs.span, rhs_span);
let limits =
if op == AssocOp::DotDot { RangeLimits::HalfOpen } else { RangeLimits::Closed };
Ok(self.mk_expr(span, self.mk_range(Some(lhs), rhs, limits)?, AttrVec::new()))
@@ -571,7 +567,11 @@ impl<'a> Parser<'a> {
expr_kind: fn(P<Expr>, P<Ty>) -> ExprKind,
) -> PResult<'a, P<Expr>> {
let mk_expr = |this: &mut Self, rhs: P<Ty>| {
- this.mk_expr(lhs_span.to(rhs.span), expr_kind(lhs, rhs), AttrVec::new())
+ this.mk_expr(
+ this.mk_expr_sp(&lhs, lhs_span, rhs.span),
+ expr_kind(lhs, rhs),
+ AttrVec::new(),
+ )
};
// Save the state of the parser before parsing type normally, in case there is a
@@ -2324,4 +2324,14 @@ impl<'a> Parser<'a> {
pub(super) fn mk_expr_err(&self, span: Span) -> P<Expr> {
self.mk_expr(span, ExprKind::Err, AttrVec::new())
}
+
+ /// Create expression span ensuring the span of the parent node
+ /// is larger than the span of lhs and rhs, including the attributes.
+ fn mk_expr_sp(&self, lhs: &P<Expr>, lhs_span: Span, rhs_span: Span) -> Span {
+ lhs.attrs
+ .iter()
+ .find(|a| a.style == AttrStyle::Outer)
+ .map_or(lhs_span, |a| a.span)
+ .to(rhs_span)
+ }
}
diff --git a/compiler/rustc_symbol_mangling/src/legacy.rs b/compiler/rustc_symbol_mangling/src/legacy.rs
index b96e318bd3ea1..2c9caf73b8e42 100644
--- a/compiler/rustc_symbol_mangling/src/legacy.rs
+++ b/compiler/rustc_symbol_mangling/src/legacy.rs
@@ -115,7 +115,6 @@ fn get_symbol_hash<'tcx>(
}
// also include any type parameters (for generic items)
- assert!(!substs.has_erasable_regions());
substs.hash_stable(&mut hcx, &mut hasher);
if let Some(instantiating_crate) = instantiating_crate {
diff --git a/compiler/rustc_symbol_mangling/src/test.rs b/compiler/rustc_symbol_mangling/src/test.rs
index d2c9b05c5607f..822a835293474 100644
--- a/compiler/rustc_symbol_mangling/src/test.rs
+++ b/compiler/rustc_symbol_mangling/src/test.rs
@@ -6,7 +6,7 @@
use rustc_hir as hir;
use rustc_middle::ty::print::with_no_trimmed_paths;
-use rustc_middle::ty::{Instance, TyCtxt};
+use rustc_middle::ty::{subst::InternalSubsts, Instance, TyCtxt};
use rustc_span::symbol::{sym, Symbol};
const SYMBOL_NAME: Symbol = sym::rustc_symbol_name;
@@ -36,8 +36,11 @@ impl SymbolNamesTest<'tcx> {
let def_id = tcx.hir().local_def_id(hir_id);
for attr in tcx.get_attrs(def_id.to_def_id()).iter() {
if tcx.sess.check_name(attr, SYMBOL_NAME) {
- // for now, can only use on monomorphic names
- let instance = Instance::mono(tcx, def_id.to_def_id());
+ let def_id = def_id.to_def_id();
+ let instance = Instance::new(
+ def_id,
+ tcx.erase_regions(&InternalSubsts::identity_for_item(tcx, def_id)),
+ );
let mangled = tcx.symbol_name(instance);
tcx.sess.span_err(attr.span, &format!("symbol-name({})", mangled));
if let Ok(demangling) = rustc_demangle::try_demangle(mangled.name) {
diff --git a/compiler/rustc_symbol_mangling/src/v0.rs b/compiler/rustc_symbol_mangling/src/v0.rs
index 183a11a527723..16d0b86903ea8 100644
--- a/compiler/rustc_symbol_mangling/src/v0.rs
+++ b/compiler/rustc_symbol_mangling/src/v0.rs
@@ -259,7 +259,7 @@ impl Printer<'tcx> for SymbolMangler<'tcx> {
}
fn print_impl_path(
- self,
+ mut self,
impl_def_id: DefId,
substs: &'tcx [GenericArg<'tcx>],
mut self_ty: Ty<'tcx>,
@@ -284,12 +284,37 @@ impl Printer<'tcx> for SymbolMangler<'tcx> {
}
}
- self.path_append_impl(
- |cx| cx.print_def_path(parent_def_id, &[]),
- &key.disambiguated_data,
- self_ty,
- impl_trait_ref,
- )
+ self.push(match impl_trait_ref {
+ Some(_) => "X",
+ None => "M",
+ });
+
+ // Encode impl generic params if the substitutions contain parameters (implying
+ // polymorphization is enabled) and this isn't an inherent impl.
+ if impl_trait_ref.is_some() && substs.iter().any(|a| a.has_param_types_or_consts()) {
+ self = self.path_generic_args(
+ |this| {
+ this.path_append_ns(
+ |cx| cx.print_def_path(parent_def_id, &[]),
+ 'I',
+ key.disambiguated_data.disambiguator as u64,
+ "",
+ )
+ },
+ substs,
+ )?;
+ } else {
+ self.push_disambiguator(key.disambiguated_data.disambiguator as u64);
+ self = self.print_def_path(parent_def_id, &[])?;
+ }
+
+ self = self_ty.print(self)?;
+
+ if let Some(trait_ref) = impl_trait_ref {
+ self = self.print_def_path(trait_ref.def_id, trait_ref.substs)?;
+ }
+
+ Ok(self)
}
fn print_region(mut self, region: ty::Region<'_>) -> Result<Self::Region, Self::Error> {
@@ -538,6 +563,7 @@ impl Printer<'tcx> for SymbolMangler<'tcx> {
self.push_ident(&name);
Ok(self)
}
+
fn path_qualified(
mut self,
self_ty: Ty<'tcx>,
@@ -552,24 +578,16 @@ impl Printer<'tcx> for SymbolMangler<'tcx> {
}
fn path_append_impl(
- mut self,
- print_prefix: impl FnOnce(Self) -> Result<Self::Path, Self::Error>,
- disambiguated_data: &DisambiguatedDefPathData,
- self_ty: Ty<'tcx>,
- trait_ref: Option<ty::TraitRef<'tcx>>,
+ self,
+ _: impl FnOnce(Self) -> Result<Self::Path, Self::Error>,
+ _: &DisambiguatedDefPathData,
+ _: Ty<'tcx>,
+ _: Option<ty::TraitRef<'tcx>>,
) -> Result<Self::Path, Self::Error> {
- self.push(match trait_ref {
- Some(_) => "X",
- None => "M",
- });
- self.push_disambiguator(disambiguated_data.disambiguator as u64);
- self = print_prefix(self)?;
- self = self_ty.print(self)?;
- if let Some(trait_ref) = trait_ref {
- self = self.print_def_path(trait_ref.def_id, trait_ref.substs)?;
- }
- Ok(self)
+ // Inlined into `print_impl_path`
+ unreachable!()
}
+
fn path_append(
self,
print_prefix: impl FnOnce(Self) -> Result<Self::Path, Self::Error>,
@@ -603,6 +621,7 @@ impl Printer<'tcx> for SymbolMangler<'tcx> {
name.as_ref().map_or("", |s| &s[..]),
)
}
+
fn path_generic_args(
mut self,
print_prefix: impl FnOnce(Self) -> Result<Self::Path, Self::Error>,
diff --git a/library/alloc/src/collections/btree/map/tests.rs b/library/alloc/src/collections/btree/map/tests.rs
index 118e173bb16db..b51b95a635c87 100644
--- a/library/alloc/src/collections/btree/map/tests.rs
+++ b/library/alloc/src/collections/btree/map/tests.rs
@@ -1,4 +1,4 @@
-use super::super::{navigate::Position, node, DeterministicRng};
+use super::super::{node, DeterministicRng};
use super::Entry::{Occupied, Vacant};
use super::*;
use crate::boxed::Box;
@@ -7,7 +7,7 @@ use crate::rc::Rc;
use crate::string::{String, ToString};
use crate::vec::Vec;
use std::convert::TryFrom;
-use std::iter::FromIterator;
+use std::iter::{self, FromIterator};
use std::mem;
use std::ops::Bound::{self, Excluded, Included, Unbounded};
use std::ops::RangeBounds;
@@ -42,19 +42,6 @@ fn test_all_refs<'a, T: 'a>(dummy: &mut T, iter: impl Iterator<Item = &'a mut T>
}
}
-struct SeriesChecker<T> {
- previous: Option<T>,
-}
-
-impl<T: Copy + Debug + Ord> SeriesChecker<T> {
- fn is_ascending(&mut self, next: T) {
- if let Some(previous) = self.previous {
- assert!(previous < next, "{:?} >= {:?}", previous, next);
- }
- self.previous = Some(next);
- }
-}
-
impl<'a, K: 'a, V: 'a> BTreeMap<K, V> {
/// Panics if the map (or the code navigating it) is corrupted.
fn check(&self)
@@ -63,44 +50,10 @@ impl<'a, K: 'a, V: 'a> BTreeMap<K, V> {
{
if let Some(root) = &self.root {
let root_node = root.node_as_ref();
- let mut checker = SeriesChecker { previous: None };
- let mut internal_length = 0;
- let mut internal_kv_count = 0;
- let mut leaf_length = 0;
- root_node.visit_nodes_in_order(|pos| match pos {
- Position::Leaf(node) => {
- let is_root = root_node.height() == 0;
- let min_len = if is_root { 0 } else { node::MIN_LEN };
- assert!(node.len() >= min_len, "{} < {}", node.len(), min_len);
-
- for idx in 0..node.len() {
- let key = *unsafe { node.key_at(idx) };
- checker.is_ascending(key);
- }
- leaf_length += node.len();
- }
- Position::Internal(node) => {
- let is_root = root_node.height() == node.height();
- let min_len = if is_root { 1 } else { node::MIN_LEN };
- assert!(node.len() >= min_len, "{} < {}", node.len(), min_len);
-
- for idx in 0..=node.len() {
- let edge = unsafe { node::Handle::new_edge(node, idx) };
- assert!(edge.descend().ascend().ok().unwrap() == edge);
- }
-
- internal_length += node.len();
- }
- Position::InternalKV(kv) => {
- let key = *kv.into_kv().0;
- checker.is_ascending(key);
-
- internal_kv_count += 1;
- }
- });
- assert_eq!(internal_length, internal_kv_count);
- assert_eq!(root_node.calc_length(), internal_length + leaf_length);
- assert_eq!(self.length, internal_length + leaf_length);
+ assert!(root_node.ascend().is_err());
+ root_node.assert_back_pointers();
+ root_node.assert_ascending();
+ assert_eq!(self.length, root_node.assert_and_add_lengths());
} else {
assert_eq!(self.length, 0);
}
@@ -116,28 +69,7 @@ impl<'a, K: 'a, V: 'a> BTreeMap<K, V> {
K: Debug,
{
if let Some(root) = self.root.as_ref() {
- let mut result = String::new();
- let root_node = root.node_as_ref();
- root_node.visit_nodes_in_order(|pos| match pos {
- Position::Leaf(leaf) => {
- let depth = root_node.height();
- let indent = " ".repeat(depth);
- result += &format!("\n{}", indent);
- for idx in 0..leaf.len() {
- if idx > 0 {
- result += ", ";
- }
- result += &format!("{:?}", unsafe { leaf.key_at(idx) });
- }
- }
- Position::Internal(_) => {}
- Position::InternalKV(kv) => {
- let depth = root_node.height() - kv.into_node().height();
- let indent = " ".repeat(depth);
- result += &format!("\n{}{:?}", indent, kv.into_kv().0);
- }
- });
- result
+ root.node_as_ref().dump_keys()
} else {
String::from("not yet allocated")
}
@@ -170,7 +102,6 @@ fn test_levels() {
let last_key = *map.last_key_value().unwrap().0;
map.insert(last_key + 1, ());
}
- println!("{}", map.dump_keys());
map.check();
// Structure:
// - 1 element in internal root node with 2 children
@@ -372,7 +303,7 @@ fn test_iter_rev() {
fn do_test_iter_mut_mutation<T>(size: usize)
where
T: Copy + Debug + Ord + TryFrom<usize>,
- <T as std::convert::TryFrom<usize>>::Error: std::fmt::Debug,
+ <T as TryFrom<usize>>::Error: Debug,
{
let zero = T::try_from(0).unwrap();
let mut map: BTreeMap<T, T> = (0..size).map(|i| (T::try_from(i).unwrap(), zero)).collect();
@@ -857,7 +788,7 @@ mod test_drain_filter {
fn consuming_nothing() {
let pairs = (0..3).map(|i| (i, i));
let mut map: BTreeMap<_, _> = pairs.collect();
- assert!(map.drain_filter(|_, _| false).eq(std::iter::empty()));
+ assert!(map.drain_filter(|_, _| false).eq(iter::empty()));
map.check();
}
@@ -878,7 +809,7 @@ mod test_drain_filter {
*v += 6;
false
})
- .eq(std::iter::empty())
+ .eq(iter::empty())
);
assert!(map.keys().copied().eq(0..3));
assert!(map.values().copied().eq(6..9));
diff --git a/library/alloc/src/collections/btree/node/tests.rs b/library/alloc/src/collections/btree/node/tests.rs
index 54c3709821acd..6a36df4238276 100644
--- a/library/alloc/src/collections/btree/node/tests.rs
+++ b/library/alloc/src/collections/btree/node/tests.rs
@@ -1,4 +1,109 @@
+use super::super::navigate;
use super::*;
+use crate::fmt::Debug;
+use crate::string::String;
+
+impl<'a, K: 'a, V: 'a> NodeRef<marker::Immut<'a>, K, V, marker::LeafOrInternal> {
+ pub fn assert_back_pointers(self) {
+ match self.force() {
+ ForceResult::Leaf(_) => {}
+ ForceResult::Internal(node) => {
+ for idx in 0..=node.len() {
+ let edge = unsafe { Handle::new_edge(node, idx) };
+ let child = edge.descend();
+ assert!(child.ascend().ok() == Some(edge));
+ child.assert_back_pointers();
+ }
+ }
+ }
+ }
+
+ pub fn assert_ascending(self)
+ where
+ K: Copy + Debug + Ord,
+ {
+ struct SeriesChecker<T> {
+ previous: Option<T>,
+ }
+ impl<T: Copy + Debug + Ord> SeriesChecker<T> {
+ fn is_ascending(&mut self, next: T) {
+ if let Some(previous) = self.previous {
+ assert!(previous < next, "{:?} >= {:?}", previous, next);
+ }
+ self.previous = Some(next);
+ }
+ }
+
+ let mut checker = SeriesChecker { previous: None };
+ self.visit_nodes_in_order(|pos| match pos {
+ navigate::Position::Leaf(node) => {
+ for idx in 0..node.len() {
+ let key = *unsafe { node.key_at(idx) };
+ checker.is_ascending(key);
+ }
+ }
+ navigate::Position::InternalKV(kv) => {
+ let key = *kv.into_kv().0;
+ checker.is_ascending(key);
+ }
+ navigate::Position::Internal(_) => {}
+ });
+ }
+
+ pub fn assert_and_add_lengths(self) -> usize {
+ let mut internal_length = 0;
+ let mut internal_kv_count = 0;
+ let mut leaf_length = 0;
+ self.visit_nodes_in_order(|pos| match pos {
+ navigate::Position::Leaf(node) => {
+ let is_root = self.height() == 0;
+ let min_len = if is_root { 0 } else { MIN_LEN };
+ assert!(node.len() >= min_len, "{} < {}", node.len(), min_len);
+ leaf_length += node.len();
+ }
+ navigate::Position::Internal(node) => {
+ let is_root = self.height() == node.height();
+ let min_len = if is_root { 1 } else { MIN_LEN };
+ assert!(node.len() >= min_len, "{} < {}", node.len(), min_len);
+ internal_length += node.len();
+ }
+ navigate::Position::InternalKV(_) => {
+ internal_kv_count += 1;
+ }
+ });
+ assert_eq!(internal_length, internal_kv_count);
+ let total = internal_length + leaf_length;
+ assert_eq!(self.calc_length(), total);
+ total
+ }
+
+ pub fn dump_keys(self) -> String
+ where
+ K: Debug,
+ {
+ let mut result = String::new();
+ self.visit_nodes_in_order(|pos| match pos {
+ navigate::Position::Leaf(leaf) => {
+ let depth = self.height();
+ let indent = " ".repeat(depth);
+ result += &format!("\n{}", indent);
+ for idx in 0..leaf.len() {
+ if idx > 0 {
+ result += ", ";
+ }
+ result += &format!("{:?}", unsafe { leaf.key_at(idx) });
+ }
+ }
+ navigate::Position::Internal(_) => {}
+ navigate::Position::InternalKV(kv) => {
+ let depth = self.height() - kv.into_node().height();
+ let indent = " ".repeat(depth);
+ result += &format!("\n{}{:?}", indent, kv.into_kv().0);
+ }
+ });
+ result
+ }
+}
#[test]
fn test_splitpoint() {
diff --git a/library/core/src/intrinsics.rs b/library/core/src/intrinsics.rs
index b2798ea66250f..2a7c105e807f4 100644
--- a/library/core/src/intrinsics.rs
+++ b/library/core/src/intrinsics.rs
@@ -1082,7 +1082,7 @@ extern "rust-intrinsic" {
/// If the actual type neither requires drop glue nor implements
/// `Copy`, then the return value of this function is unspecified.
///
- /// The stabilized version of this intrinsic is [`needs_drop`].
+ /// The stabilized version of this intrinsic is [`mem::needs_drop`](crate::mem::needs_drop).
#[rustc_const_stable(feature = "const_needs_drop", since = "1.40.0")]
pub fn needs_drop<T>() -> bool;
diff --git a/library/std/src/backtrace.rs b/library/std/src/backtrace.rs
index cc29e1c0b0522..a9d8a4e2a81c1 100644
--- a/library/std/src/backtrace.rs
+++ b/library/std/src/backtrace.rs
@@ -303,7 +303,8 @@ impl Backtrace {
// Capture a backtrace which start just before the function addressed by
// `ip`
fn create(ip: usize) -> Backtrace {
- let _lock = lock();
+ // SAFETY: We don't attempt to lock this reentrantly.
+ let _lock = unsafe { lock() };
let mut frames = Vec::new();
let mut actual_start = None;
unsafe {
@@ -408,7 +409,8 @@ impl Capture {
// Use the global backtrace lock to synchronize this as it's a
// requirement of the `backtrace` crate, and then actually resolve
// everything.
- let _lock = lock();
+ // SAFETY: We don't attempt to lock this reentrantly.
+ let _lock = unsafe { lock() };
for frame in self.frames.iter_mut() {
let symbols = &mut frame.symbols;
let frame = match &frame.frame {
diff --git a/library/std/src/sys/cloudabi/condvar.rs b/library/std/src/sys/cloudabi/condvar.rs
index 82d89b260fafd..f09bc01701b74 100644
--- a/library/std/src/sys/cloudabi/condvar.rs
+++ b/library/std/src/sys/cloudabi/condvar.rs
@@ -1,4 +1,3 @@
-use crate::cell::UnsafeCell;
use crate::mem;
use crate::sync::atomic::{AtomicU32, Ordering};
use crate::sys::cloudabi::abi;
@@ -12,7 +11,7 @@ extern "C" {
}
pub struct Condvar {
- condvar: UnsafeCell<AtomicU32>,
+ condvar: AtomicU32,
}
pub type MovableCondvar = Condvar;
@@ -20,29 +19,28 @@ pub type MovableCondvar = Condvar;
unsafe impl Send for Condvar {}
unsafe impl Sync for Condvar {}
-const NEW: Condvar =
- Condvar { condvar: UnsafeCell::new(AtomicU32::new(abi::CONDVAR_HAS_NO_WAITERS.0)) };
-
impl Condvar {
pub const fn new() -> Condvar {
- NEW
+ Condvar { condvar: AtomicU32::new(abi::CONDVAR_HAS_NO_WAITERS.0) }
}
pub unsafe fn init(&mut self) {}
pub unsafe fn notify_one(&self) {
- let condvar = self.condvar.get();
- if (*condvar).load(Ordering::Relaxed) != abi::CONDVAR_HAS_NO_WAITERS.0 {
- let ret = abi::condvar_signal(condvar as *mut abi::condvar, abi::scope::PRIVATE, 1);
+ if self.condvar.load(Ordering::Relaxed) != abi::CONDVAR_HAS_NO_WAITERS.0 {
+ let ret = abi::condvar_signal(
+ &self.condvar as *const AtomicU32 as *mut abi::condvar,
+ abi::scope::PRIVATE,
+ 1,
+ );
assert_eq!(ret, abi::errno::SUCCESS, "Failed to signal on condition variable");
}
}
pub unsafe fn notify_all(&self) {
- let condvar = self.condvar.get();
- if (*condvar).load(Ordering::Relaxed) != abi::CONDVAR_HAS_NO_WAITERS.0 {
+ if self.condvar.load(Ordering::Relaxed) != abi::CONDVAR_HAS_NO_WAITERS.0 {
let ret = abi::condvar_signal(
- condvar as *mut abi::condvar,
+ &self.condvar as *const AtomicU32 as *mut abi::condvar,
abi::scope::PRIVATE,
abi::nthreads::MAX,
);
@@ -53,20 +51,19 @@ impl Condvar {
pub unsafe fn wait(&self, mutex: &Mutex) {
let mutex = mutex::raw(mutex);
assert_eq!(
- (*mutex).load(Ordering::Relaxed) & !abi::LOCK_KERNEL_MANAGED.0,
+ mutex.load(Ordering::Relaxed) & !abi::LOCK_KERNEL_MANAGED.0,
__pthread_thread_id.0 | abi::LOCK_WRLOCKED.0,
"This lock is not write-locked by this thread"
);
// Call into the kernel to wait on the condition variable.
- let condvar = self.condvar.get();
let subscription = abi::subscription {
type_: abi::eventtype::CONDVAR,
union: abi::subscription_union {
condvar: abi::subscription_condvar {
- condvar: condvar as *mut abi::condvar,
+ condvar: &self.condvar as *const AtomicU32 as *mut abi::condvar,
condvar_scope: abi::scope::PRIVATE,
- lock: mutex as *mut abi::lock,
+ lock: mutex as *const AtomicU32 as *mut abi::lock,
lock_scope: abi::scope::PRIVATE,
},
},
@@ -86,13 +83,12 @@ impl Condvar {
pub unsafe fn wait_timeout(&self, mutex: &Mutex, dur: Duration) -> bool {
let mutex = mutex::raw(mutex);
assert_eq!(
- (*mutex).load(Ordering::Relaxed) & !abi::LOCK_KERNEL_MANAGED.0,
+ mutex.load(Ordering::Relaxed) & !abi::LOCK_KERNEL_MANAGED.0,
__pthread_thread_id.0 | abi::LOCK_WRLOCKED.0,
"This lock is not write-locked by this thread"
);
// Call into the kernel to wait on the condition variable.
- let condvar = self.condvar.get();
let timeout =
checked_dur2intervals(&dur).expect("overflow converting duration to nanoseconds");
let subscriptions = [
@@ -100,9 +96,9 @@ impl Condvar {
type_: abi::eventtype::CONDVAR,
union: abi::subscription_union {
condvar: abi::subscription_condvar {
- condvar: condvar as *mut abi::condvar,
+ condvar: &self.condvar as *const AtomicU32 as *mut abi::condvar,
condvar_scope: abi::scope::PRIVATE,
- lock: mutex as *mut abi::lock,
+ lock: mutex as *const AtomicU32 as *mut abi::lock,
lock_scope: abi::scope::PRIVATE,
},
},
@@ -124,7 +120,7 @@ impl Condvar {
let mut nevents: mem::MaybeUninit<usize> = mem::MaybeUninit::uninit();
let ret = abi::poll(
subscriptions.as_ptr(),
- mem::MaybeUninit::first_ptr_mut(&mut events),
+ mem::MaybeUninit::slice_as_mut_ptr(&mut events),
2,
nevents.as_mut_ptr(),
);
@@ -144,9 +140,8 @@ impl Condvar {
}
pub unsafe fn destroy(&self) {
- let condvar = self.condvar.get();
assert_eq!(
- (*condvar).load(Ordering::Relaxed),
+ self.condvar.load(Ordering::Relaxed),
abi::CONDVAR_HAS_NO_WAITERS.0,
"Attempted to destroy a condition variable with blocked threads"
);
diff --git a/library/std/src/sys/cloudabi/mutex.rs b/library/std/src/sys/cloudabi/mutex.rs
index 66839e05bf076..1203d8de0c572 100644
--- a/library/std/src/sys/cloudabi/mutex.rs
+++ b/library/std/src/sys/cloudabi/mutex.rs
@@ -1,4 +1,4 @@
-use crate::cell::UnsafeCell;
+use crate::cell::Cell;
use crate::mem;
use crate::mem::MaybeUninit;
use crate::sync::atomic::{AtomicU32, Ordering};
@@ -17,7 +17,7 @@ pub struct Mutex(RWLock);
pub type MovableMutex = Mutex;
-pub unsafe fn raw(m: &Mutex) -> *mut AtomicU32 {
+pub unsafe fn raw(m: &Mutex) -> &AtomicU32 {
rwlock::raw(&m.0)
}
@@ -50,28 +50,23 @@ impl Mutex {
}
pub struct ReentrantMutex {
- lock: UnsafeCell<MaybeUninit<AtomicU32>>,
- recursion: UnsafeCell<MaybeUninit<u32>>,
+ lock: AtomicU32,
+ recursion: Cell<u32>,
}
+unsafe impl Send for ReentrantMutex {}
+unsafe impl Sync for ReentrantMutex {}
+
impl ReentrantMutex {
pub const unsafe fn uninitialized() -> ReentrantMutex {
- ReentrantMutex {
- lock: UnsafeCell::new(MaybeUninit::uninit()),
- recursion: UnsafeCell::new(MaybeUninit::uninit()),
- }
+ ReentrantMutex { lock: AtomicU32::new(abi::LOCK_UNLOCKED.0), recursion: Cell::new(0) }
}
- pub unsafe fn init(&self) {
- *self.lock.get() = MaybeUninit::new(AtomicU32::new(abi::LOCK_UNLOCKED.0));
- *self.recursion.get() = MaybeUninit::new(0);
- }
+ pub unsafe fn init(&self) {}
pub unsafe fn try_lock(&self) -> bool {
// Attempt to acquire the lock.
- let lock = (*self.lock.get()).as_mut_ptr();
- let recursion = (*self.recursion.get()).as_mut_ptr();
- if let Err(old) = (*lock).compare_exchange(
+ if let Err(old) = self.lock.compare_exchange(
abi::LOCK_UNLOCKED.0,
__pthread_thread_id.0 | abi::LOCK_WRLOCKED.0,
Ordering::Acquire,
@@ -80,14 +75,14 @@ impl ReentrantMutex {
// If we fail to acquire the lock, it may be the case
// that we've already acquired it and may need to recurse.
if old & !abi::LOCK_KERNEL_MANAGED.0 == __pthread_thread_id.0 | abi::LOCK_WRLOCKED.0 {
- *recursion += 1;
+ self.recursion.set(self.recursion.get() + 1);
true
} else {
false
}
} else {
// Success.
- assert_eq!(*recursion, 0, "Mutex has invalid recursion count");
+ assert_eq!(self.recursion.get(), 0, "Mutex has invalid recursion count");
true
}
}
@@ -95,7 +90,7 @@ impl ReentrantMutex {
pub unsafe fn lock(&self) {
if !self.try_lock() {
// Call into the kernel to acquire a write lock.
- let lock = self.lock.get();
+ let lock = &self.lock as *const AtomicU32;
let subscription = abi::subscription {
type_: abi::eventtype::LOCK_WRLOCK,
union: abi::subscription_union {
@@ -116,17 +111,17 @@ impl ReentrantMutex {
}
pub unsafe fn unlock(&self) {
- let lock = (*self.lock.get()).as_mut_ptr();
- let recursion = (*self.recursion.get()).as_mut_ptr();
assert_eq!(
- (*lock).load(Ordering::Relaxed) & !abi::LOCK_KERNEL_MANAGED.0,
+ self.lock.load(Ordering::Relaxed) & !abi::LOCK_KERNEL_MANAGED.0,
__pthread_thread_id.0 | abi::LOCK_WRLOCKED.0,
"This mutex is locked by a different thread"
);
- if *recursion > 0 {
- *recursion -= 1;
- } else if !(*lock)
+ let r = self.recursion.get();
+ if r > 0 {
+ self.recursion.set(r - 1);
+ } else if !self
+ .lock
.compare_exchange(
__pthread_thread_id.0 | abi::LOCK_WRLOCKED.0,
abi::LOCK_UNLOCKED.0,
@@ -137,19 +132,20 @@ impl ReentrantMutex {
{
// Lock is managed by kernelspace. Call into the kernel
// to unblock waiting threads.
- let ret = abi::lock_unlock(lock as *mut abi::lock, abi::scope::PRIVATE);
+ let ret = abi::lock_unlock(
+ &self.lock as *const AtomicU32 as *mut abi::lock,
+ abi::scope::PRIVATE,
+ );
assert_eq!(ret, abi::errno::SUCCESS, "Failed to unlock a mutex");
}
}
pub unsafe fn destroy(&self) {
- let lock = (*self.lock.get()).as_mut_ptr();
- let recursion = (*self.recursion.get()).as_mut_ptr();
assert_eq!(
- (*lock).load(Ordering::Relaxed),
+ self.lock.load(Ordering::Relaxed),
abi::LOCK_UNLOCKED.0,
"Attempted to destroy locked mutex"
);
- assert_eq!(*recursion, 0, "Recursion counter invalid");
+ assert_eq!(self.recursion.get(), 0, "Recursion counter invalid");
}
}
diff --git a/library/std/src/sys/cloudabi/rwlock.rs b/library/std/src/sys/cloudabi/rwlock.rs
index b8af5af1d701c..508de8ba47c6e 100644
--- a/library/std/src/sys/cloudabi/rwlock.rs
+++ b/library/std/src/sys/cloudabi/rwlock.rs
@@ -1,4 +1,3 @@
-use crate::cell::UnsafeCell;
use crate::mem;
use crate::mem::MaybeUninit;
use crate::sync::atomic::{AtomicU32, Ordering};
@@ -13,28 +12,25 @@ extern "C" {
static mut RDLOCKS_ACQUIRED: u32 = 0;
pub struct RWLock {
- lock: UnsafeCell<AtomicU32>,
+ lock: AtomicU32,
}
-pub unsafe fn raw(r: &RWLock) -> *mut AtomicU32 {
- r.lock.get()
+pub unsafe fn raw(r: &RWLock) -> &AtomicU32 {
+ &r.lock
}
unsafe impl Send for RWLock {}
unsafe impl Sync for RWLock {}
-const NEW: RWLock = RWLock { lock: UnsafeCell::new(AtomicU32::new(abi::LOCK_UNLOCKED.0)) };
-
impl RWLock {
pub const fn new() -> RWLock {
- NEW
+ RWLock { lock: AtomicU32::new(abi::LOCK_UNLOCKED.0) }
}
pub unsafe fn try_read(&self) -> bool {
- let lock = self.lock.get();
let mut old = abi::LOCK_UNLOCKED.0;
while let Err(cur) =
- (*lock).compare_exchange_weak(old, old + 1, Ordering::Acquire, Ordering::Relaxed)
+ self.lock.compare_exchange_weak(old, old + 1, Ordering::Acquire, Ordering::Relaxed)
{
if (cur & abi::LOCK_WRLOCKED.0) != 0 {
// Another thread already has a write lock.
@@ -61,12 +57,11 @@ impl RWLock {
pub unsafe fn read(&self) {
if !self.try_read() {
// Call into the kernel to acquire a read lock.
- let lock = self.lock.get();
let subscription = abi::subscription {
type_: abi::eventtype::LOCK_RDLOCK,
union: abi::subscription_union {
lock: abi::subscription_lock {
- lock: lock as *mut abi::lock,
+ lock: &self.lock as *const AtomicU32 as *mut abi::lock,
lock_scope: abi::scope::PRIVATE,
},
},
@@ -96,11 +91,10 @@ impl RWLock {
assert!(RDLOCKS_ACQUIRED > 0, "Bad lock count");
let mut old = 1;
loop {
- let lock = self.lock.get();
if old == 1 | abi::LOCK_KERNEL_MANAGED.0 {
// Last read lock while threads are waiting. Attempt to upgrade
// to a write lock before calling into the kernel to unlock.
- if let Err(cur) = (*lock).compare_exchange_weak(
+ if let Err(cur) = self.lock.compare_exchange_weak(
old,
__pthread_thread_id.0 | abi::LOCK_WRLOCKED.0 | abi::LOCK_KERNEL_MANAGED.0,
Ordering::Acquire,
@@ -109,7 +103,10 @@ impl RWLock {
old = cur;
} else {
// Call into the kernel to unlock.
- let ret = abi::lock_unlock(lock as *mut abi::lock, abi::scope::PRIVATE);
+ let ret = abi::lock_unlock(
+ &self.lock as *const AtomicU32 as *mut abi::lock,
+ abi::scope::PRIVATE,
+ );
assert_eq!(ret, abi::errno::SUCCESS, "Failed to write unlock a rwlock");
break;
}
@@ -122,7 +119,7 @@ impl RWLock {
0,
"Attempted to read-unlock a write-locked rwlock"
);
- if let Err(cur) = (*lock).compare_exchange_weak(
+ if let Err(cur) = self.lock.compare_exchange_weak(
old,
old - 1,
Ordering::Acquire,
@@ -140,8 +137,7 @@ impl RWLock {
pub unsafe fn try_write(&self) -> bool {
// Attempt to acquire the lock.
- let lock = self.lock.get();
- if let Err(old) = (*lock).compare_exchange(
+ if let Err(old) = self.lock.compare_exchange(
abi::LOCK_UNLOCKED.0,
__pthread_thread_id.0 | abi::LOCK_WRLOCKED.0,
Ordering::Acquire,
@@ -163,12 +159,11 @@ impl RWLock {
pub unsafe fn write(&self) {
if !self.try_write() {
// Call into the kernel to acquire a write lock.
- let lock = self.lock.get();
let subscription = abi::subscription {
type_: abi::eventtype::LOCK_WRLOCK,
union: abi::subscription_union {
lock: abi::subscription_lock {
- lock: lock as *mut abi::lock,
+ lock: &self.lock as *const AtomicU32 as *mut abi::lock,
lock_scope: abi::scope::PRIVATE,
},
},
@@ -184,14 +179,14 @@ impl RWLock {
}
pub unsafe fn write_unlock(&self) {
- let lock = self.lock.get();
assert_eq!(
- (*lock).load(Ordering::Relaxed) & !abi::LOCK_KERNEL_MANAGED.0,
+ self.lock.load(Ordering::Relaxed) & !abi::LOCK_KERNEL_MANAGED.0,
__pthread_thread_id.0 | abi::LOCK_WRLOCKED.0,
"This rwlock is not write-locked by this thread"
);
- if !(*lock)
+ if !self
+ .lock
.compare_exchange(
__pthread_thread_id.0 | abi::LOCK_WRLOCKED.0,
abi::LOCK_UNLOCKED.0,
@@ -202,15 +197,17 @@ impl RWLock {
{
// Lock is managed by kernelspace. Call into the kernel
// to unblock waiting threads.
- let ret = abi::lock_unlock(lock as *mut abi::lock, abi::scope::PRIVATE);
+ let ret = abi::lock_unlock(
+ &self.lock as *const AtomicU32 as *mut abi::lock,
+ abi::scope::PRIVATE,
+ );
assert_eq!(ret, abi::errno::SUCCESS, "Failed to write unlock a rwlock");
}
}
pub unsafe fn destroy(&self) {
- let lock = self.lock.get();
assert_eq!(
- (*lock).load(Ordering::Relaxed),
+ self.lock.load(Ordering::Relaxed),
abi::LOCK_UNLOCKED.0,
"Attempted to destroy locked rwlock"
);
diff --git a/library/std/src/sys/unix/os.rs b/library/std/src/sys/unix/os.rs
index c9f9ed01e120e..2392238d0a194 100644
--- a/library/std/src/sys/unix/os.rs
+++ b/library/std/src/sys/unix/os.rs
@@ -470,7 +470,7 @@ pub unsafe fn environ() -> *mut *const *const c_char {
&mut environ
}
-pub unsafe fn env_lock() -> StaticMutexGuard<'static> {
+pub unsafe fn env_lock() -> StaticMutexGuard {
// It is UB to attempt to acquire this mutex reentrantly!
static ENV_LOCK: StaticMutex = StaticMutex::new();
ENV_LOCK.lock()
diff --git a/library/std/src/sys/vxworks/os.rs b/library/std/src/sys/vxworks/os.rs
index 08394a8d29de1..6eaec6f1e50df 100644
--- a/library/std/src/sys/vxworks/os.rs
+++ b/library/std/src/sys/vxworks/os.rs
@@ -212,7 +212,7 @@ pub unsafe fn environ() -> *mut *const *const c_char {
&mut environ
}
-pub unsafe fn env_lock() -> StaticMutexGuard<'static> {
+pub unsafe fn env_lock() -> StaticMutexGuard {
// It is UB to attempt to acquire this mutex reentrantly!
static ENV_LOCK: StaticMutex = StaticMutex::new();
ENV_LOCK.lock()
diff --git a/library/std/src/sys/wasm/futex_atomics.rs b/library/std/src/sys/wasm/futex_atomics.rs
new file mode 100644
index 0000000000000..3d8bf42f7255e
--- /dev/null
+++ b/library/std/src/sys/wasm/futex_atomics.rs
@@ -0,0 +1,17 @@
+use crate::arch::wasm32;
+use crate::convert::TryInto;
+use crate::sync::atomic::AtomicI32;
+use crate::time::Duration;
+
+pub fn futex_wait(futex: &AtomicI32, expected: i32, timeout: Option<Duration>) {
+ let timeout = timeout.and_then(|t| t.as_nanos().try_into().ok()).unwrap_or(-1);
+ unsafe {
+ wasm32::memory_atomic_wait32(futex as *const AtomicI32 as *mut i32, expected, timeout);
+ }
+}
+
+pub fn futex_wake(futex: &AtomicI32) {
+ unsafe {
+ wasm32::memory_atomic_notify(futex as *const AtomicI32 as *mut i32, 1);
+ }
+}
diff --git a/library/std/src/sys/wasm/mod.rs b/library/std/src/sys/wasm/mod.rs
index 18295e1129a05..11c6896f050b2 100644
--- a/library/std/src/sys/wasm/mod.rs
+++ b/library/std/src/sys/wasm/mod.rs
@@ -55,6 +55,8 @@ cfg_if::cfg_if! {
pub mod mutex;
#[path = "rwlock_atomics.rs"]
pub mod rwlock;
+ #[path = "futex_atomics.rs"]
+ pub mod futex;
} else {
#[path = "../unsupported/condvar.rs"]
pub mod condvar;
diff --git a/library/std/src/sys_common/backtrace.rs b/library/std/src/sys_common/backtrace.rs
index 1c5fbf7d70102..a549770d8b378 100644
--- a/library/std/src/sys_common/backtrace.rs
+++ b/library/std/src/sys_common/backtrace.rs
@@ -8,27 +8,15 @@ use crate::io;
use crate::io::prelude::*;
use crate::path::{self, Path, PathBuf};
use crate::sync::atomic::{self, Ordering};
-use crate::sys::mutex::Mutex;
+use crate::sys_common::mutex::StaticMutex;
/// Max number of frames to print.
const MAX_NB_FRAMES: usize = 100;
-pub fn lock() -> impl Drop {
- struct Guard;
- static LOCK: Mutex = Mutex::new();
-
- impl Drop for Guard {
- fn drop(&mut self) {
- unsafe {
- LOCK.unlock();
- }
- }
- }
-
- unsafe {
- LOCK.lock();
- Guard
- }
+// SAFETY: Don't attempt to lock this reentrantly.
+pub unsafe fn lock() -> impl Drop {
+ static LOCK: StaticMutex = StaticMutex::new();
+ LOCK.lock()
}
/// Prints the current backtrace.
diff --git a/library/std/src/sys_common/mutex.rs b/library/std/src/sys_common/mutex.rs
index 91d919a3f9b75..f3e7efb955a2f 100644
--- a/library/std/src/sys_common/mutex.rs
+++ b/library/std/src/sys_common/mutex.rs
@@ -3,8 +3,7 @@ use crate::sys::mutex as imp;
/// An OS-based mutual exclusion lock, meant for use in static variables.
///
/// This mutex has a const constructor ([`StaticMutex::new`]), does not
-/// implement `Drop` to cleanup resources, and causes UB when moved or used
-/// reentrantly.
+/// implement `Drop` to cleanup resources, and causes UB when used reentrantly.
///
/// This mutex does not implement poisoning.
///
@@ -16,11 +15,6 @@ unsafe impl Sync for StaticMutex {}
impl StaticMutex {
/// Creates a new mutex for use.
- ///
- /// Behavior is undefined if the mutex is moved after it is
- /// first used with any of the functions below.
- /// Also, the behavior is undefined if this mutex is ever used reentrantly,
- /// i.e., `lock` is called by the thread currently holding the lock.
pub const fn new() -> Self {
Self(imp::Mutex::new())
}
@@ -28,19 +22,19 @@ impl StaticMutex {
/// Calls raw_lock() and then returns an RAII guard to guarantee the mutex
/// will be unlocked.
///
- /// It is undefined behaviour to call this function while locked, or if the
- /// mutex has been moved since the last time this was called.
+ /// It is undefined behaviour to call this function while locked by the
+ /// same thread.
#[inline]
- pub unsafe fn lock(&self) -> StaticMutexGuard<'_> {
+ pub unsafe fn lock(&'static self) -> StaticMutexGuard {
self.0.lock();
StaticMutexGuard(&self.0)
}
}
#[must_use]
-pub struct StaticMutexGuard<'a>(&'a imp::Mutex);
+pub struct StaticMutexGuard(&'static imp::Mutex);
-impl Drop for StaticMutexGuard<'_> {
+impl Drop for StaticMutexGuard {
#[inline]
fn drop(&mut self) {
unsafe {
diff --git a/library/std/src/sys_common/thread_parker/mod.rs b/library/std/src/sys_common/thread_parker/mod.rs
index 23c17c8e2cf26..5e75ac65de419 100644
--- a/library/std/src/sys_common/thread_parker/mod.rs
+++ b/library/std/src/sys_common/thread_parker/mod.rs
@@ -1,5 +1,9 @@
cfg_if::cfg_if! {
- if #[cfg(any(target_os = "linux", target_os = "android"))] {
+ if #[cfg(any(
+ target_os = "linux",
+ target_os = "android",
+ all(target_arch = "wasm32", target_feature = "atomics"),
+ ))] {
mod futex;
pub use futex::Parker;
} else {
diff --git a/library/std/src/thread/available_concurrency.rs b/library/std/src/thread/available_concurrency.rs
new file mode 100644
index 0000000000000..22a2c01d4c28e
--- /dev/null
+++ b/library/std/src/thread/available_concurrency.rs
@@ -0,0 +1,157 @@
+use crate::io;
+use crate::num::NonZeroUsize;
+
+/// Returns the number of hardware threads available to the program.
+///
+/// This value should be considered only a hint.
+///
+/// # Platform-specific behavior
+///
+/// If interpreted as the number of actual hardware threads, it may undercount on
+/// Windows systems with more than 64 hardware threads. If interpreted as the
+/// available concurrency for that process, it may overcount on Windows systems
+/// when limited by a process wide affinity mask or job object limitations, and
+/// it may overcount on Linux systems when limited by a process wide affinity
+/// mask or affected by cgroups limits.
+///
+/// # Errors
+///
+/// This function will return an error in the following situations, but is not
+/// limited to just these cases:
+///
+/// - If the number of hardware threads is not known for the target platform.
+/// - The process lacks permissions to view the number of hardware threads
+/// available.
+///
+/// # Examples
+///
+/// ```
+/// # #![allow(dead_code)]
+/// #![feature(available_concurrency)]
+/// use std::thread;
+///
+/// let count = thread::available_concurrency().map(|n| n.get()).unwrap_or(1);
+/// ```
+#[unstable(feature = "available_concurrency", issue = "74479")]
+pub fn available_concurrency() -> io::Result<NonZeroUsize> {
+ available_concurrency_internal()
+}
+
+cfg_if::cfg_if! {
+ if #[cfg(windows)] {
+ #[allow(nonstandard_style)]
+ fn available_concurrency_internal() -> io::Result<NonZeroUsize> {
+ #[repr(C)]
+ struct SYSTEM_INFO {
+ wProcessorArchitecture: u16,
+ wReserved: u16,
+ dwPageSize: u32,
+ lpMinimumApplicationAddress: *mut u8,
+ lpMaximumApplicationAddress: *mut u8,
+ dwActiveProcessorMask: *mut u8,
+ dwNumberOfProcessors: u32,
+ dwProcessorType: u32,
+ dwAllocationGranularity: u32,
+ wProcessorLevel: u16,
+ wProcessorRevision: u16,
+ }
+ extern "system" {
+ fn GetSystemInfo(info: *mut SYSTEM_INFO) -> i32;
+ }
+ let res = unsafe {
+ let mut sysinfo = crate::mem::zeroed();
+ GetSystemInfo(&mut sysinfo);
+ sysinfo.dwNumberOfProcessors as usize
+ };
+ match res {
+ 0 => Err(io::Error::new(io::ErrorKind::NotFound, "The number of hardware threads is not known for the target platform")),
+ cpus => Ok(unsafe { NonZeroUsize::new_unchecked(cpus) }),
+ }
+ }
+ } else if #[cfg(any(
+ target_os = "android",
+ target_os = "cloudabi",
+ target_os = "emscripten",
+ target_os = "fuchsia",
+ target_os = "ios",
+ target_os = "linux",
+ target_os = "macos",
+ target_os = "solaris",
+ target_os = "illumos",
+ ))] {
+ fn available_concurrency_internal() -> io::Result<NonZeroUsize> {
+ match unsafe { libc::sysconf(libc::_SC_NPROCESSORS_ONLN) } {
+ -1 => Err(io::Error::last_os_error()),
+ 0 => Err(io::Error::new(io::ErrorKind::NotFound, "The number of hardware threads is not known for the target platform")),
+ cpus => Ok(unsafe { NonZeroUsize::new_unchecked(cpus as usize) }),
+ }
+ }
+ } else if #[cfg(any(target_os = "freebsd", target_os = "dragonfly", target_os = "netbsd"))] {
+ fn available_concurrency_internal() -> io::Result<NonZeroUsize> {
+ use crate::ptr;
+
+ let mut cpus: libc::c_uint = 0;
+ let mut cpus_size = crate::mem::size_of_val(&cpus);
+
+ unsafe {
+ cpus = libc::sysconf(libc::_SC_NPROCESSORS_ONLN) as libc::c_uint;
+ }
+
+ // Fallback approach in case of errors or no hardware threads.
+ if cpus < 1 {
+ let mut mib = [libc::CTL_HW, libc::HW_NCPU, 0, 0];
+ let res = unsafe {
+ libc::sysctl(
+ mib.as_mut_ptr(),
+ 2,
+ &mut cpus as *mut _ as *mut _,
+ &mut cpus_size as *mut _ as *mut _,
+ ptr::null_mut(),
+ 0,
+ );
+ }
+
+ // Handle errors if any.
+ if res == -1 {
+ return Err(io::Error::last_os_error());
+ } else if cpus == 0 {
+ return Err(io::Error::new(io::ErrorKind::NotFound, "The number of hardware threads is not known for the target platform"))
+ }
+ }
+ Ok(unsafe { NonZeroUsize::new_unchecked(cpus) })
+ }
+ } else if #[cfg(target_os = "openbsd")] {
+ fn available_concurrency_internal() -> io::Result<NonZeroUsize> {
+ use crate::ptr;
+
+ let mut cpus: libc::c_uint = 0;
+ let mut cpus_size = crate::mem::size_of_val(&cpus);
+ let mut mib = [libc::CTL_HW, libc::HW_NCPU, 0, 0];
+
+ let res = unsafe {
+ libc::sysctl(
+ mib.as_mut_ptr(),
+ 2,
+ &mut cpus as *mut _ as *mut _,
+ &mut cpus_size as *mut _ as *mut _,
+ ptr::null_mut(),
+ 0,
+ );
+ };
+
+ // Handle errors if any.
+ if res == -1 {
+ return Err(io::Error::last_os_error());
+ } else if cpus == 0 {
+ return Err(io::Error::new(io::ErrorKind::NotFound, "The number of hardware threads is not known for the target platform"))
+ }
+
+ Ok(unsafe { NonZeroUsize::new_unchecked(cpus as usize) })
+ }
+ } else {
+ // FIXME: implement on vxWorks, Redox, HermitCore, Haiku, l4re
+ fn available_concurrency_internal() -> io::Result<NonZeroUsize> {
+ Err(io::Error::new(io::ErrorKind::NotFound, "The number of hardware threads is not known for the target platform"))
+ }
+ }
+}
diff --git a/library/std/src/thread/mod.rs b/library/std/src/thread/mod.rs
index 087175bb92ab3..45c10266ba255 100644
--- a/library/std/src/thread/mod.rs
+++ b/library/std/src/thread/mod.rs
@@ -175,9 +175,15 @@ use crate::time::Duration;
#[macro_use]
mod local;
+#[unstable(feature = "available_concurrency", issue = "74479")]
+mod available_concurrency;
+
#[stable(feature = "rust1", since = "1.0.0")]
pub use self::local::{AccessError, LocalKey};
+#[unstable(feature = "available_concurrency", issue = "74479")]
+pub use available_concurrency::available_concurrency;
+
// The types used by the thread_local! macro to access TLS keys. Note that there
// are two types, the "OS" type and the "fast" type. The OS thread local key
// type is accessed via platform-specific API calls and is slow, while the fast
diff --git a/library/test/src/helpers/concurrency.rs b/library/test/src/helpers/concurrency.rs
index 7ca27bf0dc15e..7e9bd50f5566e 100644
--- a/library/test/src/helpers/concurrency.rs
+++ b/library/test/src/helpers/concurrency.rs
@@ -1,6 +1,7 @@
//! Helper module which helps to determine amount of threads to be used
//! during tests execution.
use std::env;
+use std::thread;
#[allow(deprecated)]
pub fn get_concurrency() -> usize {
@@ -12,106 +13,6 @@ pub fn get_concurrency() -> usize {
_ => panic!("RUST_TEST_THREADS is `{}`, should be a positive integer.", s),
}
}
- Err(..) => num_cpus(),
- }
-}
-
-cfg_if::cfg_if! {
- if #[cfg(windows)] {
- #[allow(nonstandard_style)]
- fn num_cpus() -> usize {
- #[repr(C)]
- struct SYSTEM_INFO {
- wProcessorArchitecture: u16,
- wReserved: u16,
- dwPageSize: u32,
- lpMinimumApplicationAddress: *mut u8,
- lpMaximumApplicationAddress: *mut u8,
- dwActiveProcessorMask: *mut u8,
- dwNumberOfProcessors: u32,
- dwProcessorType: u32,
- dwAllocationGranularity: u32,
- wProcessorLevel: u16,
- wProcessorRevision: u16,
- }
- extern "system" {
- fn GetSystemInfo(info: *mut SYSTEM_INFO) -> i32;
- }
- unsafe {
- let mut sysinfo = std::mem::zeroed();
- GetSystemInfo(&mut sysinfo);
- sysinfo.dwNumberOfProcessors as usize
- }
- }
- } else if #[cfg(any(
- target_os = "android",
- target_os = "cloudabi",
- target_os = "emscripten",
- target_os = "fuchsia",
- target_os = "ios",
- target_os = "linux",
- target_os = "macos",
- target_os = "solaris",
- target_os = "illumos",
- ))] {
- fn num_cpus() -> usize {
- unsafe { libc::sysconf(libc::_SC_NPROCESSORS_ONLN) as usize }
- }
- } else if #[cfg(any(target_os = "freebsd", target_os = "dragonfly", target_os = "netbsd"))] {
- fn num_cpus() -> usize {
- use std::ptr;
-
- let mut cpus: libc::c_uint = 0;
- let mut cpus_size = std::mem::size_of_val(&cpus);
-
- unsafe {
- cpus = libc::sysconf(libc::_SC_NPROCESSORS_ONLN) as libc::c_uint;
- }
- if cpus < 1 {
- let mut mib = [libc::CTL_HW, libc::HW_NCPU, 0, 0];
- unsafe {
- libc::sysctl(
- mib.as_mut_ptr(),
- 2,
- &mut cpus as *mut _ as *mut _,
- &mut cpus_size as *mut _ as *mut _,
- ptr::null_mut(),
- 0,
- );
- }
- if cpus < 1 {
- cpus = 1;
- }
- }
- cpus as usize
- }
- } else if #[cfg(target_os = "openbsd")] {
- fn num_cpus() -> usize {
- use std::ptr;
-
- let mut cpus: libc::c_uint = 0;
- let mut cpus_size = std::mem::size_of_val(&cpus);
- let mut mib = [libc::CTL_HW, libc::HW_NCPU, 0, 0];
-
- unsafe {
- libc::sysctl(
- mib.as_mut_ptr(),
- 2,
- &mut cpus as *mut _ as *mut _,
- &mut cpus_size as *mut _ as *mut _,
- ptr::null_mut(),
- 0,
- );
- }
- if cpus < 1 {
- cpus = 1;
- }
- cpus as usize
- }
- } else {
- // FIXME: implement on vxWorks, Redox, HermitCore, Haiku, l4re
- fn num_cpus() -> usize {
- 1
- }
+ Err(..) => thread::available_concurrency().map(|n| n.get()).unwrap_or(1),
}
}
diff --git a/library/test/src/lib.rs b/library/test/src/lib.rs
index b0b81f85fe08f..9c5bb8957b548 100644
--- a/library/test/src/lib.rs
+++ b/library/test/src/lib.rs
@@ -24,6 +24,7 @@
#![feature(rustc_private)]
#![feature(nll)]
#![feature(bool_to_option)]
+#![feature(available_concurrency)]
#![feature(set_stdio)]
#![feature(panic_unwind)]
#![feature(staged_api)]
diff --git a/src/librustdoc/clean/cfg.rs b/src/librustdoc/clean/cfg.rs
index c039b181178a4..b659f3eab4318 100644
--- a/src/librustdoc/clean/cfg.rs
+++ b/src/librustdoc/clean/cfg.rs
@@ -201,6 +201,37 @@ impl Cfg {
_ => false,
}
}
+
+ /// Attempt to simplify this cfg by assuming that `assume` is already known to be true, will
+ /// return `None` if simplification managed to completely eliminate any requirements from this
+ /// `Cfg`.
+ ///
+ /// See `tests::test_simplify_with` for examples.
+ pub(crate) fn simplify_with(&self, assume: &Cfg) -> Option<Cfg> {
+ if self == assume {
+ return None;
+ }
+
+ if let Cfg::All(a) = self {
+ let mut sub_cfgs: Vec<Cfg> = if let Cfg::All(b) = assume {
+ a.iter().filter(|a| !b.contains(a)).cloned().collect()
+ } else {
+ a.iter().filter(|&a| a != assume).cloned().collect()
+ };
+ let len = sub_cfgs.len();
+ return match len {
+ 0 => None,
+ 1 => sub_cfgs.pop(),
+ _ => Some(Cfg::All(sub_cfgs)),
+ };
+ } else if let Cfg::All(b) = assume {
+ if b.contains(self) {
+ return None;
+ }
+ }
+
+ Some(self.clone())
+ }
}
impl ops::Not for Cfg {
diff --git a/src/librustdoc/clean/cfg/tests.rs b/src/librustdoc/clean/cfg/tests.rs
index 794a7bcaf1cb7..3a78269f19af0 100644
--- a/src/librustdoc/clean/cfg/tests.rs
+++ b/src/librustdoc/clean/cfg/tests.rs
@@ -433,3 +433,39 @@ fn test_render_long_html() {
);
})
}
+
+#[test]
+fn test_simplify_with() {
+ // This is a tiny subset of things that could be simplified, but it likely covers 90% of
+ // real world usecases well.
+ with_default_session_globals(|| {
+ let foo = word_cfg("foo");
+ let bar = word_cfg("bar");
+ let baz = word_cfg("baz");
+ let quux = word_cfg("quux");
+
+ let foobar = Cfg::All(vec![foo.clone(), bar.clone()]);
+ let barbaz = Cfg::All(vec![bar.clone(), baz.clone()]);
+ let foobarbaz = Cfg::All(vec![foo.clone(), bar.clone(), baz.clone()]);
+ let bazquux = Cfg::All(vec![baz.clone(), quux.clone()]);
+
+ // Unrelated cfgs don't affect each other
+ assert_eq!(foo.simplify_with(&bar).as_ref(), Some(&foo));
+ assert_eq!(foobar.simplify_with(&bazquux).as_ref(), Some(&foobar));
+
+ // Identical cfgs are eliminated
+ assert_eq!(foo.simplify_with(&foo), None);
+ assert_eq!(foobar.simplify_with(&foobar), None);
+
+ // Multiple cfgs eliminate a single assumed cfg
+ assert_eq!(foobar.simplify_with(&foo).as_ref(), Some(&bar));
+ assert_eq!(foobar.simplify_with(&bar).as_ref(), Some(&foo));
+
+ // A single cfg is eliminated by multiple assumed cfg containing it
+ assert_eq!(foo.simplify_with(&foobar), None);
+
+ // Multiple cfgs eliminate the matching subset of multiple assumed cfg
+ assert_eq!(foobar.simplify_with(&barbaz).as_ref(), Some(&foo));
+ assert_eq!(foobar.simplify_with(&foobarbaz), None);
+ });
+}
diff --git a/src/librustdoc/html/render/mod.rs b/src/librustdoc/html/render/mod.rs
index f81ea0f6d46ac..22ae7af617fc7 100644
--- a/src/librustdoc/html/render/mod.rs
+++ b/src/librustdoc/html/render/mod.rs
@@ -1763,11 +1763,11 @@ crate fn shorten(s: String) -> String {
}
}
-fn document(w: &mut Buffer, cx: &Context, item: &clean::Item) {
+fn document(w: &mut Buffer, cx: &Context, item: &clean::Item, parent: Option<&clean::Item>) {
if let Some(ref name) = item.name {
info!("Documenting {}", name);
}
- document_stability(w, cx, item, false);
+ document_stability(w, cx, item, false, parent);
document_full(w, item, cx, "", false);
}
@@ -1851,8 +1851,14 @@ fn document_full(w: &mut Buffer, item: &clean::Item, cx: &Context, prefix: &str,
}
}
-fn document_stability(w: &mut Buffer, cx: &Context, item: &clean::Item, is_hidden: bool) {
- let stabilities = short_stability(item, cx);
+fn document_stability(
+ w: &mut Buffer,
+ cx: &Context,
+ item: &clean::Item,
+ is_hidden: bool,
+ parent: Option<&clean::Item>,
+) {
+ let stabilities = short_stability(item, cx, parent);
if !stabilities.is_empty() {
write!(w, "<div class='stability{}'>", if is_hidden { " hidden" } else { "" });
for stability in stabilities {
@@ -1952,7 +1958,7 @@ pub fn compare_names(mut lhs: &str, mut rhs: &str) -> Ordering {
}
fn item_module(w: &mut Buffer, cx: &Context, item: &clean::Item, items: &[clean::Item]) {
- document(w, cx, item);
+ document(w, cx, item, None);
let mut indices = (0..items.len()).filter(|i| !items[*i].is_stripped()).collect::<Vec<usize>>();
@@ -2111,7 +2117,7 @@ fn item_module(w: &mut Buffer, cx: &Context, item: &clean::Item, items: &[clean:
<td class='docblock-short'>{stab_tags}{docs}</td>\
</tr>",
name = *myitem.name.as_ref().unwrap(),
- stab_tags = stability_tags(myitem),
+ stab_tags = stability_tags(myitem, item),
docs = MarkdownSummaryLine(doc_value, &myitem.links()).into_string(),
class = myitem.type_(),
add = add,
@@ -2135,7 +2141,7 @@ fn item_module(w: &mut Buffer, cx: &Context, item: &clean::Item, items: &[clean:
/// Render the stability and deprecation tags that are displayed in the item's summary at the
/// module level.
-fn stability_tags(item: &clean::Item) -> String {
+fn stability_tags(item: &clean::Item, parent: &clean::Item) -> String {
let mut tags = String::new();
fn tag_html(class: &str, title: &str, contents: &str) -> String {
@@ -2159,7 +2165,13 @@ fn stability_tags(item: &clean::Item) -> String {
tags += &tag_html("unstable", "", "Experimental");
}
- if let Some(ref cfg) = item.attrs.cfg {
+ let cfg = match (&item.attrs.cfg, parent.attrs.cfg.as_ref()) {
+ (Some(cfg), Some(parent_cfg)) => cfg.simplify_with(parent_cfg),
+ (cfg, _) => cfg.as_deref().cloned(),
+ };
+
+ debug!("Portability {:?} - {:?} = {:?}", item.attrs.cfg, parent.attrs.cfg, cfg);
+ if let Some(ref cfg) = cfg {
tags += &tag_html("portability", &cfg.render_long_plain(), &cfg.render_short_html());
}
@@ -2168,7 +2180,7 @@ fn stability_tags(item: &clean::Item) -> String {
/// Render the stability and/or deprecation warning that is displayed at the top of the item's
/// documentation.
-fn short_stability(item: &clean::Item, cx: &Context) -> Vec<String> {
+fn short_stability(item: &clean::Item, cx: &Context, parent: Option<&clean::Item>) -> Vec<String> {
let mut stability = vec![];
let error_codes = cx.shared.codes;
@@ -2243,7 +2255,18 @@ fn short_stability(item: &clean::Item, cx: &Context) -> Vec<String> {
stability.push(format!("<div class='stab unstable'>{}</div>", message));
}
- if let Some(ref cfg) = item.attrs.cfg {
+ let cfg = match (&item.attrs.cfg, parent.and_then(|p| p.attrs.cfg.as_ref())) {
+ (Some(cfg), Some(parent_cfg)) => cfg.simplify_with(parent_cfg),
+ (cfg, _) => cfg.as_deref().cloned(),
+ };
+
+ debug!(
+ "Portability {:?} - {:?} = {:?}",
+ item.attrs.cfg,
+ parent.and_then(|p| p.attrs.cfg.as_ref()),
+ cfg
+ );
+ if let Some(cfg) = cfg {
stability.push(format!("<div class='stab portability'>{}</div>", cfg.render_long_html()));
}
@@ -2282,7 +2305,7 @@ fn item_constant(w: &mut Buffer, cx: &Context, it: &clean::Item, c: &clean::Cons
}
write!(w, "</pre>");
- document(w, cx, it)
+ document(w, cx, it, None)
}
fn item_static(w: &mut Buffer, cx: &Context, it: &clean::Item, s: &clean::Static) {
@@ -2296,7 +2319,7 @@ fn item_static(w: &mut Buffer, cx: &Context, it: &clean::Item, s: &clean::Static
name = it.name.as_ref().unwrap(),
typ = s.type_.print()
);
- document(w, cx, it)
+ document(w, cx, it, None)
}
fn item_function(w: &mut Buffer, cx: &Context, it: &clean::Item, f: &clean::Function) {
@@ -2329,7 +2352,7 @@ fn item_function(w: &mut Buffer, cx: &Context, it: &clean::Item, f: &clean::Func
.print(),
spotlight = spotlight_decl(&f.decl),
);
- document(w, cx, it)
+ document(w, cx, it, None)
}
fn render_implementor(
@@ -2354,6 +2377,7 @@ fn render_implementor(
w,
cx,
implementor,
+ None,
AssocItemLink::Anchor(None),
RenderMode::Normal,
implementor.impl_item.stable_since().as_deref(),
@@ -2383,6 +2407,7 @@ fn render_impls(
&mut buffer,
cx,
i,
+ Some(containing_item),
assoc_link,
RenderMode::Normal,
containing_item.stable_since().as_deref(),
@@ -2502,7 +2527,7 @@ fn item_trait(w: &mut Buffer, cx: &Context, it: &clean::Item, t: &clean::Trait,
});
// Trait documentation
- document(w, cx, it);
+ document(w, cx, it, None);
fn write_small_section_header(w: &mut Buffer, id: &str, title: &str, extra_content: &str) {
write!(
@@ -2520,6 +2545,7 @@ fn item_trait(w: &mut Buffer, cx: &Context, it: &clean::Item, t: &clean::Trait,
fn trait_item(w: &mut Buffer, cx: &Context, m: &clean::Item, t: &clean::Item) {
let name = m.name.as_ref().unwrap();
+ info!("Documenting {} on {}", name, t.name.as_deref().unwrap_or_default());
let item_type = m.type_();
let id = cx.derive_id(format!("{}.{}", item_type, name));
write!(w, "<h3 id='{id}' class='method'><code>", id = id,);
@@ -2527,7 +2553,7 @@ fn item_trait(w: &mut Buffer, cx: &Context, it: &clean::Item, t: &clean::Trait,
write!(w, "</code>");
render_stability_since(w, m, t);
write!(w, "</h3>");
- document(w, cx, m);
+ document(w, cx, m, Some(t));
}
if !types.is_empty() {
@@ -2628,6 +2654,7 @@ fn item_trait(w: &mut Buffer, cx: &Context, it: &clean::Item, t: &clean::Trait,
w,
cx,
&implementor,
+ None,
assoc_link,
RenderMode::Normal,
implementor.impl_item.stable_since().as_deref(),
@@ -2890,7 +2917,7 @@ fn item_struct(w: &mut Buffer, cx: &Context, it: &clean::Item, s: &clean::Struct
write!(w, "</pre>")
});
- document(w, cx, it);
+ document(w, cx, it, None);
let mut fields = s
.fields
.iter()
@@ -2925,7 +2952,7 @@ fn item_struct(w: &mut Buffer, cx: &Context, it: &clean::Item, s: &clean::Struct
name = field.name.as_ref().unwrap(),
ty = ty.print()
);
- document(w, cx, field);
+ document(w, cx, field, Some(it));
}
}
}
@@ -2940,7 +2967,7 @@ fn item_union(w: &mut Buffer, cx: &Context, it: &clean::Item, s: &clean::Union,
write!(w, "</pre>")
});
- document(w, cx, it);
+ document(w, cx, it, None);
let mut fields = s
.fields
.iter()
@@ -2972,7 +2999,7 @@ fn item_union(w: &mut Buffer, cx: &Context, it: &clean::Item, s: &clean::Union,
if let Some(stability_class) = field.stability_class() {
write!(w, "<span class='stab {stab}'></span>", stab = stability_class);
}
- document(w, cx, field);
+ document(w, cx, field, Some(it));
}
}
render_assoc_items(w, cx, it, it.def_id, AssocItemRender::All, cache)
@@ -3027,7 +3054,7 @@ fn item_enum(w: &mut Buffer, cx: &Context, it: &clean::Item, e: &clean::Enum, ca
write!(w, "</pre>")
});
- document(w, cx, it);
+ document(w, cx, it, None);
if !e.variants.is_empty() {
write!(
w,
@@ -3060,7 +3087,7 @@ fn item_enum(w: &mut Buffer, cx: &Context, it: &clean::Item, e: &clean::Enum, ca
}
}
write!(w, "</code></div>");
- document(w, cx, variant);
+ document(w, cx, variant, Some(it));
document_non_exhaustive(w, variant);
use crate::clean::{Variant, VariantKind};
@@ -3095,7 +3122,7 @@ fn item_enum(w: &mut Buffer, cx: &Context, it: &clean::Item, e: &clean::Enum, ca
f = field.name.as_ref().unwrap(),
t = ty.print()
);
- document(w, cx, field);
+ document(w, cx, field, Some(variant));
}
}
write!(w, "</div></div>");
@@ -3293,6 +3320,10 @@ fn render_assoc_items(
what: AssocItemRender<'_>,
cache: &Cache,
) {
+ info!(
+ "Documenting associated items of {}",
+ containing_item.name.as_deref().unwrap_or_default()
+ );
let v = match cache.impls.get(&it) {
Some(v) => v,
None => return,
@@ -3327,6 +3358,7 @@ fn render_assoc_items(
w,
cx,
i,
+ Some(containing_item),
AssocItemLink::Anchor(None),
render_mode,
containing_item.stable_since().as_deref(),
@@ -3518,6 +3550,7 @@ fn render_impl(
w: &mut Buffer,
cx: &Context,
i: &Impl,
+ parent: Option<&clean::Item>,
link: AssocItemLink<'_>,
render_mode: RenderMode,
outer_version: Option<&str>,
@@ -3600,6 +3633,7 @@ fn render_impl(
w: &mut Buffer,
cx: &Context,
item: &clean::Item,
+ parent: Option<&clean::Item>,
link: AssocItemLink<'_>,
render_mode: RenderMode,
is_default_item: bool,
@@ -3684,7 +3718,7 @@ fn render_impl(
if let Some(it) = t.items.iter().find(|i| i.name == item.name) {
// We need the stability of the item from the trait
// because impls can't have a stability.
- document_stability(w, cx, it, is_hidden);
+ document_stability(w, cx, it, is_hidden, parent);
if item.doc_value().is_some() {
document_full(w, item, cx, "", is_hidden);
} else if show_def_docs {
@@ -3694,13 +3728,13 @@ fn render_impl(
}
}
} else {
- document_stability(w, cx, item, is_hidden);
+ document_stability(w, cx, item, is_hidden, parent);
if show_def_docs {
document_full(w, item, cx, "", is_hidden);
}
}
} else {
- document_stability(w, cx, item, is_hidden);
+ document_stability(w, cx, item, is_hidden, parent);
if show_def_docs {
document_short(w, item, link, "", is_hidden);
}
@@ -3717,6 +3751,7 @@ fn render_impl(
w,
cx,
trait_item,
+ parent,
link,
render_mode,
false,
@@ -3732,6 +3767,7 @@ fn render_impl(
cx: &Context,
t: &clean::Trait,
i: &clean::Impl,
+ parent: Option<&clean::Item>,
render_mode: RenderMode,
outer_version: Option<&str>,
show_def_docs: bool,
@@ -3749,6 +3785,7 @@ fn render_impl(
w,
cx,
trait_item,
+ parent,
assoc_link,
render_mode,
true,
@@ -3771,6 +3808,7 @@ fn render_impl(
cx,
t,
&i.inner_impl(),
+ parent,
render_mode,
outer_version,
show_def_docs,
@@ -3799,7 +3837,7 @@ fn item_opaque_ty(
bounds = bounds(&t.bounds, false)
);
- document(w, cx, it);
+ document(w, cx, it, None);
// Render any items associated directly to this alias, as otherwise they
// won't be visible anywhere in the docs. It would be nice to also show
@@ -3826,7 +3864,7 @@ fn item_trait_alias(
bounds(&t.bounds, true)
);
- document(w, cx, it);
+ document(w, cx, it, None);
// Render any items associated directly to this alias, as otherwise they
// won't be visible anywhere in the docs. It would be nice to also show
@@ -3847,7 +3885,7 @@ fn item_typedef(w: &mut Buffer, cx: &Context, it: &clean::Item, t: &clean::Typed
type_ = t.type_.print()
);
- document(w, cx, it);
+ document(w, cx, it, None);
// Render any items associated directly to this alias, as otherwise they
// won't be visible anywhere in the docs. It would be nice to also show
@@ -3866,7 +3904,7 @@ fn item_foreign_type(w: &mut Buffer, cx: &Context, it: &clean::Item, cache: &Cac
it.name.as_ref().unwrap(),
);
- document(w, cx, it);
+ document(w, cx, it, None);
render_assoc_items(w, cx, it, it.def_id, AssocItemRender::All, cache)
}
@@ -4511,7 +4549,7 @@ fn item_macro(w: &mut Buffer, cx: &Context, it: &clean::Item, t: &clean::Macro)
None,
))
});
- document(w, cx, it)
+ document(w, cx, it, None)
}
fn item_proc_macro(w: &mut Buffer, cx: &Context, it: &clean::Item, m: &clean::ProcMacro) {
@@ -4541,16 +4579,16 @@ fn item_proc_macro(w: &mut Buffer, cx: &Context, it: &clean::Item, m: &clean::Pr
write!(w, "</pre>");
}
}
- document(w, cx, it)
+ document(w, cx, it, None)
}
fn item_primitive(w: &mut Buffer, cx: &Context, it: &clean::Item, cache: &Cache) {
- document(w, cx, it);
+ document(w, cx, it, None);
render_assoc_items(w, cx, it, it.def_id, AssocItemRender::All, cache)
}
fn item_keyword(w: &mut Buffer, cx: &Context, it: &clean::Item) {
- document(w, cx, it)
+ document(w, cx, it, None)
}
crate const BASIC_KEYWORDS: &str = "rust, rustlang, rust-lang";
diff --git a/src/test/rustdoc/doc-cfg-simplification.rs b/src/test/rustdoc/doc-cfg-simplification.rs
new file mode 100644
index 0000000000000..633df661be026
--- /dev/null
+++ b/src/test/rustdoc/doc-cfg-simplification.rs
@@ -0,0 +1,182 @@
+#![crate_name = "globuliferous"]
+#![feature(doc_cfg)]
+
+// @has 'globuliferous/index.html'
+// @count - '//*[@class="stab portability"]' 1
+// @matches - '//*[@class="stab portability"]' '^ratel$'
+
+// @has 'globuliferous/ratel/index.html'
+// @count - '//*[@class="stab portability"]' 8
+// @matches - '//*[@class="stab portability"]' 'crate feature ratel'
+// @matches - '//*[@class="stab portability"]' '^zoonosology$'
+// @matches - '//*[@class="stab portability"]' '^yusho$'
+// @matches - '//*[@class="stab portability"]' '^nunciative$'
+// @matches - '//*[@class="stab portability"]' '^thionic$'
+// @matches - '//*[@class="stab portability"]' '^zincic$'
+// @matches - '//*[@class="stab portability"]' '^cosmotellurian$'
+// @matches - '//*[@class="stab portability"]' '^aposiopesis$'
+#[doc(cfg(feature = "ratel"))]
+pub mod ratel {
+ // @has 'globuliferous/ratel/fn.ovicide.html'
+ // @count - '//*[@class="stab portability"]' 1
+ // @matches - '//*[@class="stab portability"]' 'crate feature ratel'
+ pub fn ovicide() {}
+
+ // @has 'globuliferous/ratel/fn.zoonosology.html'
+ // @count - '//*[@class="stab portability"]' 1
+ // @matches - '//*[@class="stab portability"]' 'crate features ratel and zoonosology'
+ #[doc(cfg(feature = "zoonosology"))]
+ pub fn zoonosology() {}
+
+ // @has 'globuliferous/ratel/constant.DIAGRAPHICS.html'
+ // @count - '//*[@class="stab portability"]' 1
+ // @matches - '//*[@class="stab portability"]' 'crate feature ratel'
+ pub const DIAGRAPHICS: () = ();
+
+ // @has 'globuliferous/ratel/constant.YUSHO.html'
+ // @count - '//*[@class="stab portability"]' 1
+ // @matches - '//*[@class="stab portability"]' 'crate features ratel and yusho'
+ #[doc(cfg(feature = "yusho"))]
+ pub const YUSHO: () = ();
+
+ // @has 'globuliferous/ratel/static.KEYBUGLE.html'
+ // @count - '//*[@class="stab portability"]' 1
+ // @matches - '//*[@class="stab portability"]' 'crate feature ratel'
+ pub static KEYBUGLE: () = ();
+
+ // @has 'globuliferous/ratel/static.NUNCIATIVE.html'
+ // @count - '//*[@class="stab portability"]' 1
+ // @matches - '//*[@class="stab portability"]' 'crate features ratel and nunciative'
+ #[doc(cfg(feature = "nunciative"))]
+ pub static NUNCIATIVE: () = ();
+
+ // @has 'globuliferous/ratel/type.Wrick.html'
+ // @count - '//*[@class="stab portability"]' 1
+ // @matches - '//*[@class="stab portability"]' 'crate feature ratel'
+ pub type Wrick = ();
+
+ // @has 'globuliferous/ratel/type.Thionic.html'
+ // @count - '//*[@class="stab portability"]' 1
+ // @matches - '//*[@class="stab portability"]' 'crate features ratel and thionic'
+ #[doc(cfg(feature = "thionic"))]
+ pub type Thionic = ();
+
+ // @has 'globuliferous/ratel/struct.Eventration.html'
+ // @count - '//*[@class="stab portability"]' 1
+ // @matches - '//*[@class="stab portability"]' 'crate feature ratel'
+ pub struct Eventration;
+
+ // @has 'globuliferous/ratel/struct.Zincic.html'
+ // @count - '//*[@class="stab portability"]' 2
+ // @matches - '//*[@class="stab portability"]' 'crate features ratel and zincic'
+ // @matches - '//*[@class="stab portability"]' 'crate feature rutherford'
+ #[doc(cfg(feature = "zincic"))]
+ pub struct Zincic {
+ pub rectigrade: (),
+
+ #[doc(cfg(feature = "rutherford"))]
+ pub rutherford: (),
+ }
+
+ // @has 'globuliferous/ratel/enum.Cosmotellurian.html'
+ // @count - '//*[@class="stab portability"]' 10
+ // @matches - '//*[@class="stab portability"]' 'crate features ratel and cosmotellurian'
+ // @matches - '//*[@class="stab portability"]' 'crate feature biotaxy'
+ // @matches - '//*[@class="stab portability"]' 'crate feature xiphopagus'
+ // @matches - '//*[@class="stab portability"]' 'crate feature juxtapositive'
+ // @matches - '//*[@class="stab portability"]' 'crate feature fuero'
+ // @matches - '//*[@class="stab portability"]' 'crate feature palaeophile'
+ // @matches - '//*[@class="stab portability"]' 'crate feature broadcloth'
+ // @matches - '//*[@class="stab portability"]' 'crate features broadcloth and xanthocomic'
+ // @matches - '//*[@class="stab portability"]' 'crate feature broadcloth'
+ // @matches - '//*[@class="stab portability"]' 'crate features broadcloth and whosoever'
+ #[doc(cfg(feature = "cosmotellurian"))]
+ pub enum Cosmotellurian {
+ Groundsel {
+ jagger: (),
+
+ #[doc(cfg(feature = "xiphopagus"))]
+ xiphopagus: (),
+ },
+
+ #[doc(cfg(feature = "biotaxy"))]
+ Biotaxy {
+ glossography: (),
+
+ #[doc(cfg(feature = "juxtapositive"))]
+ juxtapositive: (),
+ },
+ }
+
+ impl Cosmotellurian {
+ pub fn uxoricide() {}
+
+ #[doc(cfg(feature = "fuero"))]
+ pub fn fuero() {}
+
+ pub const MAMELLE: () = ();
+
+ #[doc(cfg(feature = "palaeophile"))]
+ pub const PALAEOPHILE: () = ();
+ }
+
+ #[doc(cfg(feature = "broadcloth"))]
+ impl Cosmotellurian {
+ pub fn trabeculated() {}
+
+ #[doc(cfg(feature = "xanthocomic"))]
+ pub fn xanthocomic() {}
+
+ pub const BRACHIFEROUS: () = ();
+
+ #[doc(cfg(feature = "whosoever"))]
+ pub const WHOSOEVER: () = ();
+ }
+
+ // @has 'globuliferous/ratel/trait.Gnotobiology.html'
+ // @count - '//*[@class="stab portability"]' 4
+ // @matches - '//*[@class="stab portability"]' 'crate feature ratel'
+ // @matches - '//*[@class="stab portability"]' 'crate feature unzymotic'
+ // @matches - '//*[@class="stab portability"]' 'crate feature summate'
+ // @matches - '//*[@class="stab portability"]' 'crate feature unctuous'
+ pub trait Gnotobiology {
+ const XYLOTHERAPY: ();
+
+ #[doc(cfg(feature = "unzymotic"))]
+ const UNZYMOTIC: ();
+
+ type Lepadoid;
+
+ #[doc(cfg(feature = "summate"))]
+ type Summate;
+
+ fn decalcomania();
+
+ #[doc(cfg(feature = "unctuous"))]
+ fn unctuous();
+ }
+
+ // @has 'globuliferous/ratel/trait.Aposiopesis.html'
+ // @count - '//*[@class="stab portability"]' 4
+ // @matches - '//*[@class="stab portability"]' 'crate features ratel and aposiopesis'
+ // @matches - '//*[@class="stab portability"]' 'crate feature umbracious'
+ // @matches - '//*[@class="stab portability"]' 'crate feature uakari'
+ // @matches - '//*[@class="stab portability"]' 'crate feature rotograph'
+ #[doc(cfg(feature = "aposiopesis"))]
+ pub trait Aposiopesis {
+ const REDHIBITION: ();
+
+ #[doc(cfg(feature = "umbracious"))]
+ const UMBRACIOUS: ();
+
+ type Ophthalmoscope;
+
+ #[doc(cfg(feature = "uakari"))]
+ type Uakari;
+
+ fn meseems();
+
+ #[doc(cfg(feature = "rotograph"))]
+ fn rotograph();
+ }
+}
diff --git a/src/test/rustdoc/doc-cfg.rs b/src/test/rustdoc/doc-cfg.rs
index aa407b7e92618..d7041ee2f1af8 100644
--- a/src/test/rustdoc/doc-cfg.rs
+++ b/src/test/rustdoc/doc-cfg.rs
@@ -10,9 +10,8 @@ pub struct Portable;
// @has doc_cfg/unix_only/index.html \
// '//*[@id="main"]/*[@class="stability"]/*[@class="stab portability"]' \
// 'This is supported on Unix only.'
-// @matches - '//*[@class="module-item"]//*[@class="stab portability"]' '\AUnix\Z'
-// @matches - '//*[@class="module-item"]//*[@class="stab portability"]' '\AUnix and ARM\Z'
-// @count - '//*[@class="stab portability"]' 3
+// @matches - '//*[@class="module-item"]//*[@class="stab portability"]' '\AARM\Z'
+// @count - '//*[@class="stab portability"]' 2
#[doc(cfg(unix))]
pub mod unix_only {
// @has doc_cfg/unix_only/fn.unix_only_function.html \
@@ -26,7 +25,7 @@ pub mod unix_only {
// @has doc_cfg/unix_only/trait.ArmOnly.html \
// '//*[@id="main"]/*[@class="stability"]/*[@class="stab portability"]' \
// 'This is supported on Unix and ARM only.'
- // @count - '//*[@class="stab portability"]' 3
+ // @count - '//*[@class="stab portability"]' 2
#[doc(cfg(target_arch = "arm"))]
pub trait ArmOnly {
fn unix_and_arm_only_function();
diff --git a/src/test/rustdoc/duplicate-cfg.rs b/src/test/rustdoc/duplicate-cfg.rs
index 47ba362c97789..7b938af3c7d50 100644
--- a/src/test/rustdoc/duplicate-cfg.rs
+++ b/src/test/rustdoc/duplicate-cfg.rs
@@ -14,45 +14,41 @@
pub struct Foo;
// @has 'foo/bar/index.html'
-// @matches '-' '//*[@class="module-item"]//*[@class="stab portability"]' '^sync$'
-// @has '-' '//*[@class="module-item"]//*[@class="stab portability"]/@title' 'This is supported on crate feature `sync` only'
-
-// @has 'foo/bar/struct.Bar.html'
// @has '-' '//*[@class="stab portability"]' 'This is supported on crate feature sync only.'
#[doc(cfg(feature = "sync"))]
pub mod bar {
+ // @has 'foo/bar/struct.Bar.html'
+ // @has '-' '//*[@class="stab portability"]' 'This is supported on crate feature sync only.'
#[doc(cfg(feature = "sync"))]
pub struct Bar;
}
// @has 'foo/baz/index.html'
-// @matches '-' '//*[@class="module-item"]//*[@class="stab portability"]' '^sync and send$'
-// @has '-' '//*[@class="module-item"]//*[@class="stab portability"]/@title' 'This is supported on crate features `sync` and `send` only'
-
-// @has 'foo/baz/struct.Baz.html'
// @has '-' '//*[@class="stab portability"]' 'This is supported on crate features sync and send only.'
#[doc(cfg(all(feature = "sync", feature = "send")))]
pub mod baz {
+ // @has 'foo/baz/struct.Baz.html'
+ // @has '-' '//*[@class="stab portability"]' 'This is supported on crate features sync and send only.'
#[doc(cfg(feature = "sync"))]
pub struct Baz;
}
-// @has 'foo/qux/struct.Qux.html'
-// @has '-' '//*[@class="stab portability"]' 'This is supported on crate features sync and send only.'
+// @has 'foo/qux/index.html'
+// @has '-' '//*[@class="stab portability"]' 'This is supported on crate feature sync only.'
#[doc(cfg(feature = "sync"))]
pub mod qux {
+ // @has 'foo/qux/struct.Qux.html'
+ // @has '-' '//*[@class="stab portability"]' 'This is supported on crate features sync and send only.'
#[doc(cfg(all(feature = "sync", feature = "send")))]
pub struct Qux;
}
// @has 'foo/quux/index.html'
-// @matches '-' '//*[@class="module-item"]//*[@class="stab portability"]' '^sync and send and foo and bar$'
-// @has '-' '//*[@class="module-item"]//*[@class="stab portability"]/@title' 'This is supported on crate feature `sync` and crate feature `send` and `foo` and `bar` only'
-
-// @has 'foo/quux/struct.Quux.html'
-// @has '-' '//*[@class="stab portability"]' 'This is supported on crate feature sync and crate feature send and foo and bar only.'
+// @has '-' '//*[@class="stab portability"]' 'This is supported on crate feature sync and crate feature send and foo only.'
#[doc(cfg(all(feature = "sync", feature = "send", foo)))]
pub mod quux {
+ // @has 'foo/quux/struct.Quux.html'
+ // @has '-' '//*[@class="stab portability"]' 'This is supported on crate feature sync and crate feature send and foo and bar only.'
#[doc(cfg(all(feature = "send", feature = "sync", bar)))]
pub struct Quux;
}
diff --git a/src/test/ui/borrowck/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs b/src/test/ui/borrowck/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs
index b67d494866b85..97f96ab69295f 100644
--- a/src/test/ui/borrowck/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs
+++ b/src/test/ui/borrowck/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs
@@ -3,8 +3,6 @@
#![feature(or_patterns)]
#![feature(box_patterns)]
-#![feature(move_ref_pattern)]
-
enum Test {
Foo,
Bar,
diff --git a/src/test/ui/borrowck/bindings-after-at-or-patterns-slice-patterns-box-patterns.stderr b/src/test/ui/borrowck/bindings-after-at-or-patterns-slice-patterns-box-patterns.stderr
index 1bf8158927552..96e313b39ed1e 100644
--- a/src/test/ui/borrowck/bindings-after-at-or-patterns-slice-patterns-box-patterns.stderr
+++ b/src/test/ui/borrowck/bindings-after-at-or-patterns-slice-patterns-box-patterns.stderr
@@ -1,5 +1,5 @@
error: cannot borrow value as mutable because it is also borrowed as immutable
- --> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:40:9
+ --> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:38:9
|
LL | ref foo @ [.., ref mut bar] => (),
| -------^^^^^^^^-----------^
@@ -8,7 +8,7 @@ LL | ref foo @ [.., ref mut bar] => (),
| immutable borrow, by `foo`, occurs here
error: cannot borrow value as mutable because it is also borrowed as immutable
- --> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:124:9
+ --> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:122:9
|
LL | ref foo @ Some(box ref mut s) => (),
| -------^^^^^^^^^^^^---------^
@@ -17,7 +17,7 @@ LL | ref foo @ Some(box ref mut s) => (),
| immutable borrow, by `foo`, occurs here
error[E0382]: borrow of moved value: `x`
- --> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:22:5
+ --> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:20:5
|
LL | fn bindings_after_at_slice_patterns_move_binding(x: [String; 4]) {
| - move occurs because `x` has type `[String; 4]`, which does not implement the `Copy` trait
@@ -29,7 +29,7 @@ LL | &x;
| ^^ value borrowed here after move
error[E0502]: cannot borrow `x` as immutable because it is also borrowed as mutable
- --> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:32:5
+ --> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:30:5
|
LL | ref mut foo @ [.., _] => Some(foo),
| --------------------- mutable borrow occurs here
@@ -41,7 +41,7 @@ LL | drop(r);
| - mutable borrow later used here
error[E0502]: cannot borrow `x` as mutable because it is also borrowed as immutable
- --> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:54:5
+ --> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:52:5
|
LL | [ref foo @ .., ref bar] => Some(foo),
| ------------ immutable borrow occurs here
@@ -53,7 +53,7 @@ LL | drop(r);
| - immutable borrow later used here
error[E0502]: cannot borrow `x` as mutable because it is also borrowed as immutable
- --> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:66:5
+ --> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:64:5
|
LL | ref foo @ [.., ref bar] => Some(foo),
| ----------------------- immutable borrow occurs here
@@ -65,7 +65,7 @@ LL | drop(r);
| - immutable borrow later used here
error[E0382]: borrow of moved value: `x`
- --> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:80:5
+ --> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:78:5
|
LL | fn bindings_after_at_or_patterns_move(x: Option<Test>) {
| - move occurs because `x` has type `Option<Test>`, which does not implement the `Copy` trait
@@ -80,7 +80,7 @@ LL | &x;
| ^^ value borrowed here after move
error[E0502]: cannot borrow `x` as mutable because it is also borrowed as immutable
- --> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:90:5
+ --> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:88:5
|
LL | ref foo @ Some(Test::Foo | Test::Bar) => Some(foo),
| ------------------------------------- immutable borrow occurs here
@@ -92,7 +92,7 @@ LL | drop(r);
| - immutable borrow later used here
error[E0502]: cannot borrow `x` as immutable because it is also borrowed as mutable
- --> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:102:5
+ --> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:100:5
|
LL | ref mut foo @ Some(Test::Foo | Test::Bar) => Some(foo),
| ----------------------------------------- mutable borrow occurs here
@@ -104,7 +104,7 @@ LL | drop(r);
| - mutable borrow later used here
error[E0502]: cannot borrow `x` as mutable because it is also borrowed as immutable
- --> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:116:5
+ --> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:114:5
|
LL | ref foo @ Some(box ref s) => Some(foo),
| ------------------------- immutable borrow occurs here
@@ -116,7 +116,7 @@ LL | drop(r);
| - immutable borrow later used here
error[E0382]: borrow of moved value: `x`
- --> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:138:5
+ --> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:136:5
|
LL | fn bindings_after_at_slice_patterns_or_patterns_moves(x: [Option<Test>; 4]) {
| - move occurs because `x` has type `[Option<Test>; 4]`, which does not implement the `Copy` trait
@@ -131,7 +131,7 @@ LL | &x;
| ^^ value borrowed here after move
error[E0502]: cannot borrow `x` as mutable because it is also borrowed as immutable
- --> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:148:5
+ --> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:146:5
|
LL | ref a @ [ref b @ .., Some(Test::Foo | Test::Bar)] => Some(a),
| ------------------------------------------------- immutable borrow occurs here
@@ -143,7 +143,7 @@ LL | drop(r);
| - immutable borrow later used here
error[E0502]: cannot borrow `x` as mutable because it is also borrowed as immutable
- --> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:160:5
+ --> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:158:5
|
LL | ref a @ [ref b @ .., Some(Test::Foo | Test::Bar)] => Some(b),
| ---------- immutable borrow occurs here
@@ -155,7 +155,7 @@ LL | drop(r);
| - immutable borrow later used here
error[E0502]: cannot borrow `x` as mutable because it is also borrowed as immutable
- --> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:174:5
+ --> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:172:5
|
LL | [_, ref a @ Some(box ref b), ..] => Some(a),
| ----------------------- immutable borrow occurs here
@@ -167,7 +167,7 @@ LL | drop(r);
| - immutable borrow later used here
error[E0502]: cannot borrow `x` as mutable because it is also borrowed as immutable
- --> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:190:5
+ --> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:188:5
|
LL | [_, ref a @ Some(box Test::Foo | box Test::Bar), ..] => Some(a),
| ------------------------------------------- immutable borrow occurs here
@@ -179,7 +179,7 @@ LL | drop(r);
| - immutable borrow later used here
error[E0502]: cannot borrow `x` as immutable because it is also borrowed as mutable
- --> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:204:5
+ --> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:202:5
|
LL | [_, ref mut a @ Some(box Test::Foo | box Test::Bar), ..] => Some(a),
| ----------------------------------------------- mutable borrow occurs here
@@ -191,7 +191,7 @@ LL | drop(r);
| - mutable borrow later used here
error[E0502]: cannot borrow `x` as mutable because it is also borrowed as immutable
- --> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:218:5
+ --> $DIR/bindings-after-at-or-patterns-slice-patterns-box-patterns.rs:216:5
|
LL | ref a @ [_, ref b @ Some(box Test::Foo | box Test::Bar), ..] => Some(a),
| ------------------------------------------------------------ immutable borrow occurs here
diff --git a/src/test/ui/drop/dynamic-drop-async.rs b/src/test/ui/drop/dynamic-drop-async.rs
index 88d36ab6aa664..b027faa9d7c3a 100644
--- a/src/test/ui/drop/dynamic-drop-async.rs
+++ b/src/test/ui/drop/dynamic-drop-async.rs
@@ -7,8 +7,6 @@
// edition:2018
// ignore-wasm32-bare compiled with panic=abort by default
-#![feature(move_ref_pattern)]
-
#![allow(unused)]
use std::{
diff --git a/src/test/ui/drop/dynamic-drop.rs b/src/test/ui/drop/dynamic-drop.rs
index d31736f142c3f..ada61bf0df04c 100644
--- a/src/test/ui/drop/dynamic-drop.rs
+++ b/src/test/ui/drop/dynamic-drop.rs
@@ -2,7 +2,6 @@
// ignore-wasm32-bare compiled with panic=abort by default
#![feature(generators, generator_trait, untagged_unions)]
-#![feature(move_ref_pattern)]
#![feature(bindings_after_at)]
#![allow(unused_assignments)]
diff --git a/src/test/ui/error-codes/E0007.rs b/src/test/ui/error-codes/E0007.rs
deleted file mode 100644
index 022ac5fc113dd..0000000000000
--- a/src/test/ui/error-codes/E0007.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-#![feature(bindings_after_at)]
-
-fn main() {
- let x = Some("s".to_string());
- match x {
- op_string @ Some(s) => {},
- //~^ ERROR E0007
- //~| ERROR E0382
- None => {},
- }
-}
diff --git a/src/test/ui/error-codes/E0007.stderr b/src/test/ui/error-codes/E0007.stderr
deleted file mode 100644
index 89c1051619438..0000000000000
--- a/src/test/ui/error-codes/E0007.stderr
+++ /dev/null
@@ -1,22 +0,0 @@
-error[E0007]: cannot bind by-move with sub-bindings
- --> $DIR/E0007.rs:6:9
- |
-LL | op_string @ Some(s) => {},
- | ^^^^^^^^^^^^^^^^^^^ binds an already bound by-move value by moving it
-
-error[E0382]: use of moved value
- --> $DIR/E0007.rs:6:26
- |
-LL | let x = Some("s".to_string());
- | - move occurs because `x` has type `Option<String>`, which does not implement the `Copy` trait
-LL | match x {
-LL | op_string @ Some(s) => {},
- | -----------------^-
- | | |
- | | value used here after move
- | value moved here
-
-error: aborting due to 2 previous errors
-
-Some errors have detailed explanations: E0007, E0382.
-For more information about an error, try `rustc --explain E0007`.
diff --git a/src/test/ui/pattern/bindings-after-at/bind-by-move-neither-can-live-while-the-other-survives-1.rs b/src/test/ui/pattern/bindings-after-at/bind-by-move-neither-can-live-while-the-other-survives-1.rs
index c00296c34c4e5..ba9543bf73869 100644
--- a/src/test/ui/pattern/bindings-after-at/bind-by-move-neither-can-live-while-the-other-survives-1.rs
+++ b/src/test/ui/pattern/bindings-after-at/bind-by-move-neither-can-live-while-the-other-survives-1.rs
@@ -3,7 +3,6 @@
// where one side is by-ref and the other is by-move.
#![feature(bindings_after_at)]
-#![feature(move_ref_pattern)]
struct X {
x: (),
diff --git a/src/test/ui/pattern/bindings-after-at/bind-by-move-neither-can-live-while-the-other-survives-1.stderr b/src/test/ui/pattern/bindings-after-at/bind-by-move-neither-can-live-while-the-other-survives-1.stderr
index 8a6ea8e91a25a..44dbcb9a75466 100644
--- a/src/test/ui/pattern/bindings-after-at/bind-by-move-neither-can-live-while-the-other-survives-1.stderr
+++ b/src/test/ui/pattern/bindings-after-at/bind-by-move-neither-can-live-while-the-other-survives-1.stderr
@@ -1,5 +1,5 @@
error: cannot move out of value because it is borrowed
- --> $DIR/bind-by-move-neither-can-live-while-the-other-survives-1.rs:15:14
+ --> $DIR/bind-by-move-neither-can-live-while-the-other-survives-1.rs:14:14
|
LL | Some(ref _y @ _z) => {}
| ------^^^--
@@ -8,7 +8,7 @@ LL | Some(ref _y @ _z) => {}
| value borrowed, by `_y`, here
error: borrow of moved value
- --> $DIR/bind-by-move-neither-can-live-while-the-other-survives-1.rs:21:14
+ --> $DIR/bind-by-move-neither-can-live-while-the-other-survives-1.rs:20:14
|
LL | Some(_z @ ref _y) => {}
| --^^^------
@@ -18,7 +18,7 @@ LL | Some(_z @ ref _y) => {}
| move occurs because `_z` has type `X` which does not implement the `Copy` trait
error: cannot move out of value because it is borrowed
- --> $DIR/bind-by-move-neither-can-live-while-the-other-survives-1.rs:29:14
+ --> $DIR/bind-by-move-neither-can-live-while-the-other-survives-1.rs:28:14
|
LL | Some(ref mut _y @ _z) => {}
| ----------^^^--
@@ -27,7 +27,7 @@ LL | Some(ref mut _y @ _z) => {}
| value borrowed, by `_y`, here
error: borrow of moved value
- --> $DIR/bind-by-move-neither-can-live-while-the-other-survives-1.rs:35:14
+ --> $DIR/bind-by-move-neither-can-live-while-the-other-survives-1.rs:34:14
|
LL | Some(_z @ ref mut _y) => {}
| --^^^----------
@@ -37,7 +37,7 @@ LL | Some(_z @ ref mut _y) => {}
| move occurs because `_z` has type `X` which does not implement the `Copy` trait
error[E0382]: borrow of moved value
- --> $DIR/bind-by-move-neither-can-live-while-the-other-survives-1.rs:21:19
+ --> $DIR/bind-by-move-neither-can-live-while-the-other-survives-1.rs:20:19
|
LL | Some(_z @ ref _y) => {}
| -----^^^^^^
@@ -52,7 +52,7 @@ LL | Some(ref _z @ ref _y) => {}
| ^^^
error[E0382]: borrow of moved value
- --> $DIR/bind-by-move-neither-can-live-while-the-other-survives-1.rs:35:19
+ --> $DIR/bind-by-move-neither-can-live-while-the-other-survives-1.rs:34:19
|
LL | Some(_z @ ref mut _y) => {}
| -----^^^^^^^^^^
diff --git a/src/test/ui/pattern/bindings-after-at/bind-by-move-no-subbindings-fun-param.rs b/src/test/ui/pattern/bindings-after-at/bind-by-move-no-subbindings-fun-param.rs
index 7a2e5128b8537..3ab6f40725cfb 100644
--- a/src/test/ui/pattern/bindings-after-at/bind-by-move-no-subbindings-fun-param.rs
+++ b/src/test/ui/pattern/bindings-after-at/bind-by-move-no-subbindings-fun-param.rs
@@ -1,7 +1,6 @@
// See issue #12534.
#![feature(bindings_after_at)]
-#![feature(move_ref_pattern)]
fn main() {}
diff --git a/src/test/ui/pattern/bindings-after-at/bind-by-move-no-subbindings-fun-param.stderr b/src/test/ui/pattern/bindings-after-at/bind-by-move-no-subbindings-fun-param.stderr
index cfd978e132709..f25d5a2d9b82d 100644
--- a/src/test/ui/pattern/bindings-after-at/bind-by-move-no-subbindings-fun-param.stderr
+++ b/src/test/ui/pattern/bindings-after-at/bind-by-move-no-subbindings-fun-param.stderr
@@ -1,5 +1,5 @@
error[E0382]: use of moved value
- --> $DIR/bind-by-move-no-subbindings-fun-param.rs:10:12
+ --> $DIR/bind-by-move-no-subbindings-fun-param.rs:9:12
|
LL | fn f(a @ A(u): A) -> Box<u8> {
| ------^-
diff --git a/src/test/ui/pattern/bindings-after-at/borrowck-move-and-move.rs b/src/test/ui/pattern/bindings-after-at/borrowck-move-and-move.rs
index 10865b92393b6..d014c9828da2a 100644
--- a/src/test/ui/pattern/bindings-after-at/borrowck-move-and-move.rs
+++ b/src/test/ui/pattern/bindings-after-at/borrowck-move-and-move.rs
@@ -1,7 +1,6 @@
// Test that moving on both sides of an `@` pattern is not allowed.
#![feature(bindings_after_at)]
-#![feature(move_ref_pattern)]
fn main() {
struct U; // Not copy!
diff --git a/src/test/ui/pattern/bindings-after-at/borrowck-move-and-move.stderr b/src/test/ui/pattern/bindings-after-at/borrowck-move-and-move.stderr
index d28edd11e1283..5039f580ff6ea 100644
--- a/src/test/ui/pattern/bindings-after-at/borrowck-move-and-move.stderr
+++ b/src/test/ui/pattern/bindings-after-at/borrowck-move-and-move.stderr
@@ -1,5 +1,5 @@
error[E0382]: use of moved value
- --> $DIR/borrowck-move-and-move.rs:14:13
+ --> $DIR/borrowck-move-and-move.rs:13:13
|
LL | let a @ b = U;
| ----^ - move occurs because value has type `U`, which does not implement the `Copy` trait
@@ -8,7 +8,7 @@ LL | let a @ b = U;
| value moved here
error[E0382]: use of moved value
- --> $DIR/borrowck-move-and-move.rs:16:17
+ --> $DIR/borrowck-move-and-move.rs:15:17
|
LL | let a @ (b, c) = (U, U);
| --------^- ------ move occurs because value has type `(U, U)`, which does not implement the `Copy` trait
@@ -17,7 +17,7 @@ LL | let a @ (b, c) = (U, U);
| value moved here
error[E0382]: use of moved value
- --> $DIR/borrowck-move-and-move.rs:18:17
+ --> $DIR/borrowck-move-and-move.rs:17:17
|
LL | let a @ (b, c) = (u(), u());
| --------^- ---------- move occurs because value has type `(U, U)`, which does not implement the `Copy` trait
@@ -26,7 +26,7 @@ LL | let a @ (b, c) = (u(), u());
| value moved here
error[E0382]: use of moved value
- --> $DIR/borrowck-move-and-move.rs:21:16
+ --> $DIR/borrowck-move-and-move.rs:20:16
|
LL | match Ok(U) {
| ----- move occurs because value has type `std::result::Result<U, U>`, which does not implement the `Copy` trait
@@ -37,7 +37,7 @@ LL | a @ Ok(b) | a @ Err(b) => {}
| value moved here
error[E0382]: use of moved value
- --> $DIR/borrowck-move-and-move.rs:21:29
+ --> $DIR/borrowck-move-and-move.rs:20:29
|
LL | match Ok(U) {
| ----- move occurs because value has type `std::result::Result<U, U>`, which does not implement the `Copy` trait
@@ -48,7 +48,7 @@ LL | a @ Ok(b) | a @ Err(b) => {}
| value moved here
error[E0382]: use of moved value
- --> $DIR/borrowck-move-and-move.rs:28:22
+ --> $DIR/borrowck-move-and-move.rs:27:22
|
LL | match [u(), u(), u(), u()] {
| -------------------- move occurs because value has type `[U; 4]`, which does not implement the `Copy` trait
@@ -59,7 +59,7 @@ LL | xs @ [a, .., b] => {}
| value moved here
error[E0382]: use of moved value
- --> $DIR/borrowck-move-and-move.rs:32:18
+ --> $DIR/borrowck-move-and-move.rs:31:18
|
LL | match [u(), u(), u(), u()] {
| -------------------- move occurs because value has type `[U; 4]`, which does not implement the `Copy` trait
@@ -70,7 +70,7 @@ LL | xs @ [_, ys @ .., _] => {}
| value moved here
error[E0382]: use of moved value
- --> $DIR/borrowck-move-and-move.rs:25:16
+ --> $DIR/borrowck-move-and-move.rs:24:16
|
LL | fn fun(a @ b: U) {}
| ----^
diff --git a/src/test/ui/pattern/bindings-after-at/borrowck-pat-at-and-box-pass.rs b/src/test/ui/pattern/bindings-after-at/borrowck-pat-at-and-box-pass.rs
index 271f4bca0fcb8..f1ee87bc9c69b 100644
--- a/src/test/ui/pattern/bindings-after-at/borrowck-pat-at-and-box-pass.rs
+++ b/src/test/ui/pattern/bindings-after-at/borrowck-pat-at-and-box-pass.rs
@@ -3,7 +3,6 @@
// Test `@` patterns combined with `box` patterns.
#![feature(bindings_after_at)]
-#![feature(move_ref_pattern)]
#![feature(box_patterns)]
#[derive(Copy, Clone)]
diff --git a/src/test/ui/pattern/bindings-after-at/borrowck-pat-at-and-box.rs b/src/test/ui/pattern/bindings-after-at/borrowck-pat-at-and-box.rs
index f1680e9e8884e..236710ed85493 100644
--- a/src/test/ui/pattern/bindings-after-at/borrowck-pat-at-and-box.rs
+++ b/src/test/ui/pattern/bindings-after-at/borrowck-pat-at-and-box.rs
@@ -1,7 +1,6 @@
// Test `@` patterns combined with `box` patterns.
#![feature(bindings_after_at)]
-#![feature(move_ref_pattern)]
#![feature(box_patterns)]
#[derive(Copy, Clone)]
diff --git a/src/test/ui/pattern/bindings-after-at/borrowck-pat-at-and-box.stderr b/src/test/ui/pattern/bindings-after-at/borrowck-pat-at-and-box.stderr
index 44888369ab2f7..d9a8bbfb6b103 100644
--- a/src/test/ui/pattern/bindings-after-at/borrowck-pat-at-and-box.stderr
+++ b/src/test/ui/pattern/bindings-after-at/borrowck-pat-at-and-box.stderr
@@ -1,5 +1,5 @@
error: cannot move out of value because it is borrowed
- --> $DIR/borrowck-pat-at-and-box.rs:37:9
+ --> $DIR/borrowck-pat-at-and-box.rs:36:9
|
LL | let ref a @ box b = Box::new(NC);
| -----^^^^^^^-
@@ -8,7 +8,7 @@ LL | let ref a @ box b = Box::new(NC);
| value borrowed, by `a`, here
error: cannot borrow value as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-at-and-box.rs:39:9
+ --> $DIR/borrowck-pat-at-and-box.rs:38:9
|
LL | let ref a @ box ref mut b = Box::new(nc());
| -----^^^^^^^---------
@@ -17,7 +17,7 @@ LL | let ref a @ box ref mut b = Box::new(nc());
| immutable borrow, by `a`, occurs here
error: cannot borrow value as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-at-and-box.rs:41:9
+ --> $DIR/borrowck-pat-at-and-box.rs:40:9
|
LL | let ref a @ box ref mut b = Box::new(NC);
| -----^^^^^^^---------
@@ -26,7 +26,7 @@ LL | let ref a @ box ref mut b = Box::new(NC);
| immutable borrow, by `a`, occurs here
error: cannot borrow value as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-at-and-box.rs:43:9
+ --> $DIR/borrowck-pat-at-and-box.rs:42:9
|
LL | let ref a @ box ref mut b = Box::new(NC);
| -----^^^^^^^---------
@@ -35,7 +35,7 @@ LL | let ref a @ box ref mut b = Box::new(NC);
| immutable borrow, by `a`, occurs here
error: cannot borrow value as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-at-and-box.rs:46:9
+ --> $DIR/borrowck-pat-at-and-box.rs:45:9
|
LL | let ref a @ box ref mut b = Box::new(NC);
| -----^^^^^^^---------
@@ -44,7 +44,7 @@ LL | let ref a @ box ref mut b = Box::new(NC);
| immutable borrow, by `a`, occurs here
error: cannot borrow value as immutable because it is also borrowed as mutable
- --> $DIR/borrowck-pat-at-and-box.rs:52:9
+ --> $DIR/borrowck-pat-at-and-box.rs:51:9
|
LL | let ref mut a @ box ref b = Box::new(NC);
| ---------^^^^^^^-----
@@ -53,7 +53,7 @@ LL | let ref mut a @ box ref b = Box::new(NC);
| mutable borrow, by `a`, occurs here
error: cannot borrow value as immutable because it is also borrowed as mutable
- --> $DIR/borrowck-pat-at-and-box.rs:66:9
+ --> $DIR/borrowck-pat-at-and-box.rs:65:9
|
LL | ref mut a @ box ref b => {
| ---------^^^^^^^-----
@@ -62,7 +62,7 @@ LL | ref mut a @ box ref b => {
| mutable borrow, by `a`, occurs here
error: cannot borrow value as immutable because it is also borrowed as mutable
- --> $DIR/borrowck-pat-at-and-box.rs:58:11
+ --> $DIR/borrowck-pat-at-and-box.rs:57:11
|
LL | fn f5(ref mut a @ box ref b: Box<NC>) {
| ---------^^^^^^^-----
@@ -71,7 +71,7 @@ LL | fn f5(ref mut a @ box ref b: Box<NC>) {
| mutable borrow, by `a`, occurs here
error[E0382]: use of moved value
- --> $DIR/borrowck-pat-at-and-box.rs:21:18
+ --> $DIR/borrowck-pat-at-and-box.rs:20:18
|
LL | let a @ box &b = Box::new(&C);
| ---------^ ------------ move occurs because value has type `Box<&C>`, which does not implement the `Copy` trait
@@ -80,7 +80,7 @@ LL | let a @ box &b = Box::new(&C);
| value moved here
error[E0382]: use of moved value
- --> $DIR/borrowck-pat-at-and-box.rs:24:17
+ --> $DIR/borrowck-pat-at-and-box.rs:23:17
|
LL | let a @ box b = Box::new(C);
| --------^ ----------- move occurs because value has type `Box<C>`, which does not implement the `Copy` trait
@@ -89,7 +89,7 @@ LL | let a @ box b = Box::new(C);
| value moved here
error[E0382]: use of moved value
- --> $DIR/borrowck-pat-at-and-box.rs:34:17
+ --> $DIR/borrowck-pat-at-and-box.rs:33:17
|
LL | match Box::new(C) {
| ----------- move occurs because value has type `Box<C>`, which does not implement the `Copy` trait
@@ -100,7 +100,7 @@ LL | a @ box b => {}
| value moved here
error[E0502]: cannot borrow value as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-at-and-box.rs:46:21
+ --> $DIR/borrowck-pat-at-and-box.rs:45:21
|
LL | let ref a @ box ref mut b = Box::new(NC);
| ------------^^^^^^^^^
@@ -112,7 +112,7 @@ LL | drop(a);
| - immutable borrow later used here
error[E0502]: cannot borrow value as immutable because it is also borrowed as mutable
- --> $DIR/borrowck-pat-at-and-box.rs:52:25
+ --> $DIR/borrowck-pat-at-and-box.rs:51:25
|
LL | let ref mut a @ box ref b = Box::new(NC);
| ----------------^^^^^
@@ -124,7 +124,7 @@ LL | *a = Box::new(NC);
| -- mutable borrow later used here
error[E0502]: cannot borrow value as immutable because it is also borrowed as mutable
- --> $DIR/borrowck-pat-at-and-box.rs:66:25
+ --> $DIR/borrowck-pat-at-and-box.rs:65:25
|
LL | ref mut a @ box ref b => {
| ----------------^^^^^
@@ -136,7 +136,7 @@ LL | *a = Box::new(NC);
| -- mutable borrow later used here
error[E0382]: use of moved value
- --> $DIR/borrowck-pat-at-and-box.rs:27:20
+ --> $DIR/borrowck-pat-at-and-box.rs:26:20
|
LL | fn f1(a @ box &b: Box<&C>) {}
| ---------^
@@ -146,7 +146,7 @@ LL | fn f1(a @ box &b: Box<&C>) {}
| move occurs because value has type `Box<&C>`, which does not implement the `Copy` trait
error[E0382]: use of moved value
- --> $DIR/borrowck-pat-at-and-box.rs:30:19
+ --> $DIR/borrowck-pat-at-and-box.rs:29:19
|
LL | fn f2(a @ box b: Box<C>) {}
| --------^
@@ -156,7 +156,7 @@ LL | fn f2(a @ box b: Box<C>) {}
| move occurs because value has type `Box<C>`, which does not implement the `Copy` trait
error[E0502]: cannot borrow value as immutable because it is also borrowed as mutable
- --> $DIR/borrowck-pat-at-and-box.rs:58:27
+ --> $DIR/borrowck-pat-at-and-box.rs:57:27
|
LL | fn f5(ref mut a @ box ref b: Box<NC>) {
| ----------------^^^^^
diff --git a/src/test/ui/pattern/bindings-after-at/borrowck-pat-by-move-and-ref-inverse-promotion.rs b/src/test/ui/pattern/bindings-after-at/borrowck-pat-by-move-and-ref-inverse-promotion.rs
index 993954b450e37..a22d27763d261 100644
--- a/src/test/ui/pattern/bindings-after-at/borrowck-pat-by-move-and-ref-inverse-promotion.rs
+++ b/src/test/ui/pattern/bindings-after-at/borrowck-pat-by-move-and-ref-inverse-promotion.rs
@@ -2,7 +2,6 @@
// Currently this logic exists in THIR match checking as opposed to borrowck.
#![feature(bindings_after_at)]
-#![feature(move_ref_pattern)]
fn main() {
struct U;
diff --git a/src/test/ui/pattern/bindings-after-at/borrowck-pat-by-move-and-ref-inverse-promotion.stderr b/src/test/ui/pattern/bindings-after-at/borrowck-pat-by-move-and-ref-inverse-promotion.stderr
index dacf23f9ded98..0e09d478e3a10 100644
--- a/src/test/ui/pattern/bindings-after-at/borrowck-pat-by-move-and-ref-inverse-promotion.stderr
+++ b/src/test/ui/pattern/bindings-after-at/borrowck-pat-by-move-and-ref-inverse-promotion.stderr
@@ -1,5 +1,5 @@
error: borrow of moved value
- --> $DIR/borrowck-pat-by-move-and-ref-inverse-promotion.rs:9:9
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse-promotion.rs:8:9
|
LL | let a @ ref b = U;
| -^^^-----
diff --git a/src/test/ui/pattern/bindings-after-at/borrowck-pat-by-move-and-ref-inverse.rs b/src/test/ui/pattern/bindings-after-at/borrowck-pat-by-move-and-ref-inverse.rs
index 7d9618c8df78d..3e5a543c4c36a 100644
--- a/src/test/ui/pattern/bindings-after-at/borrowck-pat-by-move-and-ref-inverse.rs
+++ b/src/test/ui/pattern/bindings-after-at/borrowck-pat-by-move-and-ref-inverse.rs
@@ -1,7 +1,6 @@
// Test that `by_move_binding @ pat_with_by_ref_bindings` is prevented.
#![feature(bindings_after_at)]
-#![feature(move_ref_pattern)]
fn main() {
struct U;
diff --git a/src/test/ui/pattern/bindings-after-at/borrowck-pat-by-move-and-ref-inverse.stderr b/src/test/ui/pattern/bindings-after-at/borrowck-pat-by-move-and-ref-inverse.stderr
index 86e09e55585f7..282031aeb0754 100644
--- a/src/test/ui/pattern/bindings-after-at/borrowck-pat-by-move-and-ref-inverse.stderr
+++ b/src/test/ui/pattern/bindings-after-at/borrowck-pat-by-move-and-ref-inverse.stderr
@@ -1,5 +1,5 @@
error: borrow of moved value
- --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:29:9
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:28:9
|
LL | let a @ ref b = U;
| -^^^-----
@@ -9,7 +9,7 @@ LL | let a @ ref b = U;
| move occurs because `a` has type `U` which does not implement the `Copy` trait
error: borrow of moved value
- --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:31:9
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:30:9
|
LL | let a @ (mut b @ ref mut c, d @ ref e) = (U, U);
| -^^^^^^^^^^^^---------^^^^^^-----^
@@ -20,7 +20,7 @@ LL | let a @ (mut b @ ref mut c, d @ ref e) = (U, U);
| move occurs because `a` has type `(U, U)` which does not implement the `Copy` trait
error: borrow of moved value
- --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:31:14
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:30:14
|
LL | let a @ (mut b @ ref mut c, d @ ref e) = (U, U);
| -----^^^---------
@@ -30,7 +30,7 @@ LL | let a @ (mut b @ ref mut c, d @ ref e) = (U, U);
| move occurs because `b` has type `U` which does not implement the `Copy` trait
error: borrow of moved value
- --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:31:33
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:30:33
|
LL | let a @ (mut b @ ref mut c, d @ ref e) = (U, U);
| -^^^-----
@@ -40,7 +40,7 @@ LL | let a @ (mut b @ ref mut c, d @ ref e) = (U, U);
| move occurs because `d` has type `U` which does not implement the `Copy` trait
error: borrow of moved value
- --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:38:9
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:37:9
|
LL | let a @ [ref mut b, ref c] = [U, U];
| -^^^^---------^^-----^
@@ -51,7 +51,7 @@ LL | let a @ [ref mut b, ref c] = [U, U];
| move occurs because `a` has type `[U; 2]` which does not implement the `Copy` trait
error: borrow of moved value
- --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:41:9
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:40:9
|
LL | let a @ ref b = u();
| -^^^-----
@@ -61,7 +61,7 @@ LL | let a @ ref b = u();
| move occurs because `a` has type `U` which does not implement the `Copy` trait
error: borrow of moved value
- --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:44:9
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:43:9
|
LL | let a @ (mut b @ ref mut c, d @ ref e) = (u(), u());
| -^^^^^^^^^^^^---------^^^^^^-----^
@@ -72,7 +72,7 @@ LL | let a @ (mut b @ ref mut c, d @ ref e) = (u(), u());
| move occurs because `a` has type `(U, U)` which does not implement the `Copy` trait
error: borrow of moved value
- --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:44:14
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:43:14
|
LL | let a @ (mut b @ ref mut c, d @ ref e) = (u(), u());
| -----^^^---------
@@ -82,7 +82,7 @@ LL | let a @ (mut b @ ref mut c, d @ ref e) = (u(), u());
| move occurs because `b` has type `U` which does not implement the `Copy` trait
error: borrow of moved value
- --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:44:33
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:43:33
|
LL | let a @ (mut b @ ref mut c, d @ ref e) = (u(), u());
| -^^^-----
@@ -92,7 +92,7 @@ LL | let a @ (mut b @ ref mut c, d @ ref e) = (u(), u());
| move occurs because `d` has type `U` which does not implement the `Copy` trait
error: borrow of moved value
- --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:51:9
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:50:9
|
LL | let a @ [ref mut b, ref c] = [u(), u()];
| -^^^^---------^^-----^
@@ -103,7 +103,7 @@ LL | let a @ [ref mut b, ref c] = [u(), u()];
| move occurs because `a` has type `[U; 2]` which does not implement the `Copy` trait
error: borrow of moved value
- --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:56:9
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:55:9
|
LL | a @ Some(ref b) => {}
| -^^^^^^^^-----^
@@ -113,7 +113,7 @@ LL | a @ Some(ref b) => {}
| move occurs because `a` has type `Option<U>` which does not implement the `Copy` trait
error: borrow of moved value
- --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:61:9
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:60:9
|
LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {}
| -^^^^^^^^^^^^^^^^^---------^^^^^^-----^^
@@ -124,7 +124,7 @@ LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {}
| move occurs because `a` has type `Option<(U, U)>` which does not implement the `Copy` trait
error: borrow of moved value
- --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:61:19
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:60:19
|
LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {}
| -----^^^---------
@@ -134,7 +134,7 @@ LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {}
| move occurs because `b` has type `U` which does not implement the `Copy` trait
error: borrow of moved value
- --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:61:38
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:60:38
|
LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {}
| -^^^-----
@@ -144,7 +144,7 @@ LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {}
| move occurs because `d` has type `U` which does not implement the `Copy` trait
error: borrow of moved value
- --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:71:9
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:70:9
|
LL | mut a @ Some([ref b, ref mut c]) => {}
| -----^^^^^^^^^-----^^---------^^
@@ -155,7 +155,7 @@ LL | mut a @ Some([ref b, ref mut c]) => {}
| move occurs because `a` has type `Option<[U; 2]>` which does not implement the `Copy` trait
error: borrow of moved value
- --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:77:9
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:76:9
|
LL | a @ Some(ref b) => {}
| -^^^^^^^^-----^
@@ -165,7 +165,7 @@ LL | a @ Some(ref b) => {}
| move occurs because `a` has type `Option<U>` which does not implement the `Copy` trait
error: borrow of moved value
- --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:83:9
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:82:9
|
LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {}
| -^^^^^^^^^^^^^^^^^---------^^^^^^-----^^
@@ -176,7 +176,7 @@ LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {}
| move occurs because `a` has type `Option<(U, U)>` which does not implement the `Copy` trait
error: borrow of moved value
- --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:83:19
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:82:19
|
LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {}
| -----^^^---------
@@ -186,7 +186,7 @@ LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {}
| move occurs because `b` has type `U` which does not implement the `Copy` trait
error: borrow of moved value
- --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:83:38
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:82:38
|
LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {}
| -^^^-----
@@ -196,7 +196,7 @@ LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {}
| move occurs because `d` has type `U` which does not implement the `Copy` trait
error: borrow of moved value
- --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:93:9
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:92:9
|
LL | mut a @ Some([ref b, ref mut c]) => {}
| -----^^^^^^^^^-----^^---------^^
@@ -207,7 +207,7 @@ LL | mut a @ Some([ref b, ref mut c]) => {}
| move occurs because `a` has type `Option<[U; 2]>` which does not implement the `Copy` trait
error: borrow of moved value
- --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:14:11
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:13:11
|
LL | fn f1(a @ ref b: U) {}
| -^^^-----
@@ -217,7 +217,7 @@ LL | fn f1(a @ ref b: U) {}
| move occurs because `a` has type `U` which does not implement the `Copy` trait
error: borrow of moved value
- --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:18:11
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:17:11
|
LL | fn f2(mut a @ (b @ ref c, mut d @ ref e): (U, U)) {}
| -----^^^^^^^^-----^^^^^^^^^^-----^
@@ -228,7 +228,7 @@ LL | fn f2(mut a @ (b @ ref c, mut d @ ref e): (U, U)) {}
| move occurs because `a` has type `(U, U)` which does not implement the `Copy` trait
error: borrow of moved value
- --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:18:20
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:17:20
|
LL | fn f2(mut a @ (b @ ref c, mut d @ ref e): (U, U)) {}
| -^^^-----
@@ -238,7 +238,7 @@ LL | fn f2(mut a @ (b @ ref c, mut d @ ref e): (U, U)) {}
| move occurs because `b` has type `U` which does not implement the `Copy` trait
error: borrow of moved value
- --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:18:31
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:17:31
|
LL | fn f2(mut a @ (b @ ref c, mut d @ ref e): (U, U)) {}
| -----^^^-----
@@ -248,7 +248,7 @@ LL | fn f2(mut a @ (b @ ref c, mut d @ ref e): (U, U)) {}
| move occurs because `d` has type `U` which does not implement the `Copy` trait
error: borrow of moved value
- --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:25:11
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:24:11
|
LL | fn f3(a @ [ref mut b, ref c]: [U; 2]) {}
| -^^^^---------^^-----^
@@ -259,7 +259,7 @@ LL | fn f3(a @ [ref mut b, ref c]: [U; 2]) {}
| move occurs because `a` has type `[U; 2]` which does not implement the `Copy` trait
error[E0382]: borrow of moved value
- --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:31:22
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:30:22
|
LL | let a @ (mut b @ ref mut c, d @ ref e) = (U, U);
| --------^^^^^^^^^
@@ -270,7 +270,7 @@ LL | let a @ (mut b @ ref mut c, d @ ref e) = (U, U);
= note: move occurs because value has type `U`, which does not implement the `Copy` trait
error[E0382]: use of moved value
- --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:31:33
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:30:33
|
LL | let a @ (mut b @ ref mut c, d @ ref e) = (U, U);
| ------------------------^^^^^^^^^- ------ move occurs because value has type `(U, U)`, which does not implement the `Copy` trait
@@ -279,7 +279,7 @@ LL | let a @ (mut b @ ref mut c, d @ ref e) = (U, U);
| value moved here
error[E0382]: borrow of moved value
- --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:31:37
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:30:37
|
LL | let a @ (mut b @ ref mut c, d @ ref e) = (U, U);
| ----^^^^^
@@ -290,7 +290,7 @@ LL | let a @ (mut b @ ref mut c, d @ ref e) = (U, U);
= note: move occurs because value has type `U`, which does not implement the `Copy` trait
error[E0382]: borrow of moved value
- --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:38:25
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:37:25
|
LL | let a @ [ref mut b, ref c] = [U, U];
| ----------------^^^^^- ------ move occurs because value has type `[U; 2]`, which does not implement the `Copy` trait
@@ -299,7 +299,7 @@ LL | let a @ [ref mut b, ref c] = [U, U];
| value moved here
error[E0382]: borrow of moved value
- --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:41:13
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:40:13
|
LL | let a @ ref b = u();
| ----^^^^^ --- move occurs because value has type `U`, which does not implement the `Copy` trait
@@ -308,7 +308,7 @@ LL | let a @ ref b = u();
| value moved here
error[E0382]: borrow of moved value
- --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:44:22
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:43:22
|
LL | let a @ (mut b @ ref mut c, d @ ref e) = (u(), u());
| --------^^^^^^^^^
@@ -319,7 +319,7 @@ LL | let a @ (mut b @ ref mut c, d @ ref e) = (u(), u());
= note: move occurs because value has type `U`, which does not implement the `Copy` trait
error[E0382]: use of moved value
- --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:44:33
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:43:33
|
LL | let a @ (mut b @ ref mut c, d @ ref e) = (u(), u());
| ------------------------^^^^^^^^^- ---------- move occurs because value has type `(U, U)`, which does not implement the `Copy` trait
@@ -328,7 +328,7 @@ LL | let a @ (mut b @ ref mut c, d @ ref e) = (u(), u());
| value moved here
error[E0382]: borrow of moved value
- --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:44:37
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:43:37
|
LL | let a @ (mut b @ ref mut c, d @ ref e) = (u(), u());
| ----^^^^^
@@ -339,7 +339,7 @@ LL | let a @ (mut b @ ref mut c, d @ ref e) = (u(), u());
= note: move occurs because value has type `U`, which does not implement the `Copy` trait
error[E0382]: borrow of moved value
- --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:51:25
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:50:25
|
LL | let a @ [ref mut b, ref c] = [u(), u()];
| ----------------^^^^^- ---------- move occurs because value has type `[U; 2]`, which does not implement the `Copy` trait
@@ -348,7 +348,7 @@ LL | let a @ [ref mut b, ref c] = [u(), u()];
| value moved here
error[E0382]: borrow of moved value
- --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:61:27
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:60:27
|
LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {}
| --------^^^^^^^^^
@@ -363,7 +363,7 @@ LL | a @ Some((ref mut b @ ref mut c, d @ ref e)) => {}
| ^^^
error[E0382]: use of moved value
- --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:61:38
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:60:38
|
LL | match Some((U, U)) {
| ------------ move occurs because value has type `Option<(U, U)>`, which does not implement the `Copy` trait
@@ -374,7 +374,7 @@ LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {}
| value moved here
error[E0382]: borrow of moved value
- --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:61:42
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:60:42
|
LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {}
| ----^^^^^
@@ -389,7 +389,7 @@ LL | a @ Some((mut b @ ref mut c, ref d @ ref e)) => {}
| ^^^
error[E0382]: borrow of moved value
- --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:71:30
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:70:30
|
LL | match Some([U, U]) {
| ------------ move occurs because value has type `Option<[U; 2]>`, which does not implement the `Copy` trait
@@ -400,7 +400,7 @@ LL | mut a @ Some([ref b, ref mut c]) => {}
| value moved here
error[E0382]: borrow of moved value
- --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:77:18
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:76:18
|
LL | match Some(u()) {
| --------- move occurs because value has type `Option<U>`, which does not implement the `Copy` trait
@@ -411,7 +411,7 @@ LL | a @ Some(ref b) => {}
| value moved here
error[E0382]: borrow of moved value
- --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:83:27
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:82:27
|
LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {}
| --------^^^^^^^^^
@@ -426,7 +426,7 @@ LL | a @ Some((ref mut b @ ref mut c, d @ ref e)) => {}
| ^^^
error[E0382]: use of moved value
- --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:83:38
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:82:38
|
LL | match Some((u(), u())) {
| ---------------- move occurs because value has type `Option<(U, U)>`, which does not implement the `Copy` trait
@@ -437,7 +437,7 @@ LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {}
| value moved here
error[E0382]: borrow of moved value
- --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:83:42
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:82:42
|
LL | a @ Some((mut b @ ref mut c, d @ ref e)) => {}
| ----^^^^^
@@ -452,7 +452,7 @@ LL | a @ Some((mut b @ ref mut c, ref d @ ref e)) => {}
| ^^^
error[E0382]: borrow of moved value
- --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:93:30
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:92:30
|
LL | match Some([u(), u()]) {
| ---------------- move occurs because value has type `Option<[U; 2]>`, which does not implement the `Copy` trait
@@ -463,7 +463,7 @@ LL | mut a @ Some([ref b, ref mut c]) => {}
| value moved here
error[E0382]: borrow of moved value
- --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:14:15
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:13:15
|
LL | fn f1(a @ ref b: U) {}
| ----^^^^^
@@ -473,7 +473,7 @@ LL | fn f1(a @ ref b: U) {}
| move occurs because value has type `U`, which does not implement the `Copy` trait
error[E0382]: borrow of moved value
- --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:18:24
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:17:24
|
LL | fn f2(mut a @ (b @ ref c, mut d @ ref e): (U, U)) {}
| ----^^^^^
@@ -484,7 +484,7 @@ LL | fn f2(mut a @ (b @ ref c, mut d @ ref e): (U, U)) {}
= note: move occurs because value has type `U`, which does not implement the `Copy` trait
error[E0382]: use of moved value
- --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:18:31
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:17:31
|
LL | fn f2(mut a @ (b @ ref c, mut d @ ref e): (U, U)) {}
| --------------------^^^^^^^^^^^^^-
@@ -494,7 +494,7 @@ LL | fn f2(mut a @ (b @ ref c, mut d @ ref e): (U, U)) {}
| move occurs because value has type `(U, U)`, which does not implement the `Copy` trait
error[E0382]: borrow of moved value
- --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:18:39
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:17:39
|
LL | fn f2(mut a @ (b @ ref c, mut d @ ref e): (U, U)) {}
| --------^^^^^
@@ -505,7 +505,7 @@ LL | fn f2(mut a @ (b @ ref c, mut d @ ref e): (U, U)) {}
= note: move occurs because value has type `U`, which does not implement the `Copy` trait
error[E0382]: borrow of moved value
- --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:25:27
+ --> $DIR/borrowck-pat-by-move-and-ref-inverse.rs:24:27
|
LL | fn f3(a @ [ref mut b, ref c]: [U; 2]) {}
| ----------------^^^^^-
diff --git a/src/test/ui/pattern/bindings-after-at/borrowck-pat-by-move-and-ref.rs b/src/test/ui/pattern/bindings-after-at/borrowck-pat-by-move-and-ref.rs
index b7c8c8766c00a..42c3290ddfbb2 100644
--- a/src/test/ui/pattern/bindings-after-at/borrowck-pat-by-move-and-ref.rs
+++ b/src/test/ui/pattern/bindings-after-at/borrowck-pat-by-move-and-ref.rs
@@ -1,7 +1,6 @@
// Test that `ref mut? @ pat_with_by_move_bindings` is prevented.
#![feature(bindings_after_at)]
-#![feature(move_ref_pattern)]
fn main() {
struct U;
diff --git a/src/test/ui/pattern/bindings-after-at/borrowck-pat-by-move-and-ref.stderr b/src/test/ui/pattern/bindings-after-at/borrowck-pat-by-move-and-ref.stderr
index e5419efa00b36..a275705b19332 100644
--- a/src/test/ui/pattern/bindings-after-at/borrowck-pat-by-move-and-ref.stderr
+++ b/src/test/ui/pattern/bindings-after-at/borrowck-pat-by-move-and-ref.stderr
@@ -1,5 +1,5 @@
error: cannot move out of value because it is borrowed
- --> $DIR/borrowck-pat-by-move-and-ref.rs:23:9
+ --> $DIR/borrowck-pat-by-move-and-ref.rs:22:9
|
LL | let ref a @ b = U;
| -----^^^-
@@ -8,7 +8,7 @@ LL | let ref a @ b = U;
| value borrowed, by `a`, here
error: cannot move out of value because it is borrowed
- --> $DIR/borrowck-pat-by-move-and-ref.rs:25:9
+ --> $DIR/borrowck-pat-by-move-and-ref.rs:24:9
|
LL | let ref a @ (ref b @ mut c, ref d @ e) = (U, U);
| -----^^^^^^^^^^^^-----^^^^^^^^^^-^
@@ -18,7 +18,7 @@ LL | let ref a @ (ref b @ mut c, ref d @ e) = (U, U);
| value borrowed, by `a`, here
error: cannot move out of value because it is borrowed
- --> $DIR/borrowck-pat-by-move-and-ref.rs:25:18
+ --> $DIR/borrowck-pat-by-move-and-ref.rs:24:18
|
LL | let ref a @ (ref b @ mut c, ref d @ e) = (U, U);
| -----^^^-----
@@ -27,7 +27,7 @@ LL | let ref a @ (ref b @ mut c, ref d @ e) = (U, U);
| value borrowed, by `b`, here
error: cannot move out of value because it is borrowed
- --> $DIR/borrowck-pat-by-move-and-ref.rs:25:33
+ --> $DIR/borrowck-pat-by-move-and-ref.rs:24:33
|
LL | let ref a @ (ref b @ mut c, ref d @ e) = (U, U);
| -----^^^-
@@ -36,7 +36,7 @@ LL | let ref a @ (ref b @ mut c, ref d @ e) = (U, U);
| value borrowed, by `d`, here
error: cannot move out of value because it is borrowed
- --> $DIR/borrowck-pat-by-move-and-ref.rs:29:9
+ --> $DIR/borrowck-pat-by-move-and-ref.rs:28:9
|
LL | let ref mut a @ [b, mut c] = [U, U];
| ---------^^^^-^^-----^
@@ -46,7 +46,7 @@ LL | let ref mut a @ [b, mut c] = [U, U];
| value borrowed, by `a`, here
error: cannot move out of value because it is borrowed
- --> $DIR/borrowck-pat-by-move-and-ref.rs:31:9
+ --> $DIR/borrowck-pat-by-move-and-ref.rs:30:9
|
LL | let ref a @ b = u();
| -----^^^-
@@ -55,7 +55,7 @@ LL | let ref a @ b = u();
| value borrowed, by `a`, here
error: cannot move out of value because it is borrowed
- --> $DIR/borrowck-pat-by-move-and-ref.rs:33:9
+ --> $DIR/borrowck-pat-by-move-and-ref.rs:32:9
|
LL | let ref a @ (ref b @ mut c, ref d @ e) = (u(), u());
| -----^^^^^^^^^^^^-----^^^^^^^^^^-^
@@ -65,7 +65,7 @@ LL | let ref a @ (ref b @ mut c, ref d @ e) = (u(), u());
| value borrowed, by `a`, here
error: cannot move out of value because it is borrowed
- --> $DIR/borrowck-pat-by-move-and-ref.rs:33:18
+ --> $DIR/borrowck-pat-by-move-and-ref.rs:32:18
|
LL | let ref a @ (ref b @ mut c, ref d @ e) = (u(), u());
| -----^^^-----
@@ -74,7 +74,7 @@ LL | let ref a @ (ref b @ mut c, ref d @ e) = (u(), u());
| value borrowed, by `b`, here
error: cannot move out of value because it is borrowed
- --> $DIR/borrowck-pat-by-move-and-ref.rs:33:33
+ --> $DIR/borrowck-pat-by-move-and-ref.rs:32:33
|
LL | let ref a @ (ref b @ mut c, ref d @ e) = (u(), u());
| -----^^^-
@@ -83,7 +83,7 @@ LL | let ref a @ (ref b @ mut c, ref d @ e) = (u(), u());
| value borrowed, by `d`, here
error: cannot move out of value because it is borrowed
- --> $DIR/borrowck-pat-by-move-and-ref.rs:37:9
+ --> $DIR/borrowck-pat-by-move-and-ref.rs:36:9
|
LL | let ref mut a @ [b, mut c] = [u(), u()];
| ---------^^^^-^^-----^
@@ -93,7 +93,7 @@ LL | let ref mut a @ [b, mut c] = [u(), u()];
| value borrowed, by `a`, here
error: cannot move out of value because it is borrowed
- --> $DIR/borrowck-pat-by-move-and-ref.rs:41:9
+ --> $DIR/borrowck-pat-by-move-and-ref.rs:40:9
|
LL | ref a @ Some(b) => {}
| -----^^^^^^^^-^
@@ -102,7 +102,7 @@ LL | ref a @ Some(b) => {}
| value borrowed, by `a`, here
error: cannot move out of value because it is borrowed
- --> $DIR/borrowck-pat-by-move-and-ref.rs:46:9
+ --> $DIR/borrowck-pat-by-move-and-ref.rs:45:9
|
LL | ref a @ Some((ref b @ mut c, ref d @ e)) => {}
| -----^^^^^^^^^^^^^^^^^-----^^^^^^^^^^-^^
@@ -112,7 +112,7 @@ LL | ref a @ Some((ref b @ mut c, ref d @ e)) => {}
| value borrowed, by `a`, here
error: cannot move out of value because it is borrowed
- --> $DIR/borrowck-pat-by-move-and-ref.rs:46:23
+ --> $DIR/borrowck-pat-by-move-and-ref.rs:45:23
|
LL | ref a @ Some((ref b @ mut c, ref d @ e)) => {}
| -----^^^-----
@@ -121,7 +121,7 @@ LL | ref a @ Some((ref b @ mut c, ref d @ e)) => {}
| value borrowed, by `b`, here
error: cannot move out of value because it is borrowed
- --> $DIR/borrowck-pat-by-move-and-ref.rs:46:38
+ --> $DIR/borrowck-pat-by-move-and-ref.rs:45:38
|
LL | ref a @ Some((ref b @ mut c, ref d @ e)) => {}
| -----^^^-
@@ -130,7 +130,7 @@ LL | ref a @ Some((ref b @ mut c, ref d @ e)) => {}
| value borrowed, by `d`, here
error: cannot move out of value because it is borrowed
- --> $DIR/borrowck-pat-by-move-and-ref.rs:53:9
+ --> $DIR/borrowck-pat-by-move-and-ref.rs:52:9
|
LL | ref mut a @ Some([b, mut c]) => {}
| ---------^^^^^^^^^-^^-----^^
@@ -140,7 +140,7 @@ LL | ref mut a @ Some([b, mut c]) => {}
| value borrowed, by `a`, here
error: cannot move out of value because it is borrowed
- --> $DIR/borrowck-pat-by-move-and-ref.rs:58:9
+ --> $DIR/borrowck-pat-by-move-and-ref.rs:57:9
|
LL | ref a @ Some(b) => {}
| -----^^^^^^^^-^
@@ -149,7 +149,7 @@ LL | ref a @ Some(b) => {}
| value borrowed, by `a`, here
error: cannot move out of value because it is borrowed
- --> $DIR/borrowck-pat-by-move-and-ref.rs:63:9
+ --> $DIR/borrowck-pat-by-move-and-ref.rs:62:9
|
LL | ref a @ Some((ref b @ mut c, ref d @ e)) => {}
| -----^^^^^^^^^^^^^^^^^-----^^^^^^^^^^-^^
@@ -159,7 +159,7 @@ LL | ref a @ Some((ref b @ mut c, ref d @ e)) => {}
| value borrowed, by `a`, here
error: cannot move out of value because it is borrowed
- --> $DIR/borrowck-pat-by-move-and-ref.rs:63:23
+ --> $DIR/borrowck-pat-by-move-and-ref.rs:62:23
|
LL | ref a @ Some((ref b @ mut c, ref d @ e)) => {}
| -----^^^-----
@@ -168,7 +168,7 @@ LL | ref a @ Some((ref b @ mut c, ref d @ e)) => {}
| value borrowed, by `b`, here
error: cannot move out of value because it is borrowed
- --> $DIR/borrowck-pat-by-move-and-ref.rs:63:38
+ --> $DIR/borrowck-pat-by-move-and-ref.rs:62:38
|
LL | ref a @ Some((ref b @ mut c, ref d @ e)) => {}
| -----^^^-
@@ -177,7 +177,7 @@ LL | ref a @ Some((ref b @ mut c, ref d @ e)) => {}
| value borrowed, by `d`, here
error: cannot move out of value because it is borrowed
- --> $DIR/borrowck-pat-by-move-and-ref.rs:70:9
+ --> $DIR/borrowck-pat-by-move-and-ref.rs:69:9
|
LL | ref mut a @ Some([b, mut c]) => {}
| ---------^^^^^^^^^-^^-----^^
@@ -187,7 +187,7 @@ LL | ref mut a @ Some([b, mut c]) => {}
| value borrowed, by `a`, here
error: cannot move out of value because it is borrowed
- --> $DIR/borrowck-pat-by-move-and-ref.rs:14:11
+ --> $DIR/borrowck-pat-by-move-and-ref.rs:13:11
|
LL | fn f1(ref a @ b: U) {}
| -----^^^-
@@ -196,7 +196,7 @@ LL | fn f1(ref a @ b: U) {}
| value borrowed, by `a`, here
error: cannot move out of value because it is borrowed
- --> $DIR/borrowck-pat-by-move-and-ref.rs:16:11
+ --> $DIR/borrowck-pat-by-move-and-ref.rs:15:11
|
LL | fn f2(ref a @ (ref b @ mut c, ref d @ e): (U, U)) {}
| -----^^^^^^^^^^^^-----^^^^^^^^^^-^
@@ -206,7 +206,7 @@ LL | fn f2(ref a @ (ref b @ mut c, ref d @ e): (U, U)) {}
| value borrowed, by `a`, here
error: cannot move out of value because it is borrowed
- --> $DIR/borrowck-pat-by-move-and-ref.rs:16:20
+ --> $DIR/borrowck-pat-by-move-and-ref.rs:15:20
|
LL | fn f2(ref a @ (ref b @ mut c, ref d @ e): (U, U)) {}
| -----^^^-----
@@ -215,7 +215,7 @@ LL | fn f2(ref a @ (ref b @ mut c, ref d @ e): (U, U)) {}
| value borrowed, by `b`, here
error: cannot move out of value because it is borrowed
- --> $DIR/borrowck-pat-by-move-and-ref.rs:16:35
+ --> $DIR/borrowck-pat-by-move-and-ref.rs:15:35
|
LL | fn f2(ref a @ (ref b @ mut c, ref d @ e): (U, U)) {}
| -----^^^-
@@ -224,7 +224,7 @@ LL | fn f2(ref a @ (ref b @ mut c, ref d @ e): (U, U)) {}
| value borrowed, by `d`, here
error: cannot move out of value because it is borrowed
- --> $DIR/borrowck-pat-by-move-and-ref.rs:20:11
+ --> $DIR/borrowck-pat-by-move-and-ref.rs:19:11
|
LL | fn f3(ref mut a @ [b, mut c]: [U; 2]) {}
| ---------^^^^-^^-----^
diff --git a/src/test/ui/pattern/bindings-after-at/borrowck-pat-ref-mut-and-ref.rs b/src/test/ui/pattern/bindings-after-at/borrowck-pat-ref-mut-and-ref.rs
index 2b5e339c6396e..f67cd45ca95ab 100644
--- a/src/test/ui/pattern/bindings-after-at/borrowck-pat-ref-mut-and-ref.rs
+++ b/src/test/ui/pattern/bindings-after-at/borrowck-pat-ref-mut-and-ref.rs
@@ -1,5 +1,4 @@
#![feature(bindings_after_at)]
-#![feature(move_ref_pattern)]
enum Option<T> {
None,
diff --git a/src/test/ui/pattern/bindings-after-at/borrowck-pat-ref-mut-and-ref.stderr b/src/test/ui/pattern/bindings-after-at/borrowck-pat-ref-mut-and-ref.stderr
index 695da9639af9a..e6231dd49bade 100644
--- a/src/test/ui/pattern/bindings-after-at/borrowck-pat-ref-mut-and-ref.stderr
+++ b/src/test/ui/pattern/bindings-after-at/borrowck-pat-ref-mut-and-ref.stderr
@@ -1,5 +1,5 @@
error: cannot borrow value as immutable because it is also borrowed as mutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:11:9
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:10:9
|
LL | ref mut z @ &mut Some(ref a) => {
| ---------^^^^^^^^^^^^^-----^
@@ -8,7 +8,7 @@ LL | ref mut z @ &mut Some(ref a) => {
| mutable borrow, by `z`, occurs here
error: cannot borrow value as mutable more than once at a time
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:35:9
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:34:9
|
LL | let ref mut a @ (ref b @ ref mut c) = u(); // sub-in-sub
| ---------^^^^-----------------^
@@ -18,7 +18,7 @@ LL | let ref mut a @ (ref b @ ref mut c) = u(); // sub-in-sub
| first mutable borrow, by `a`, occurs here
error: cannot borrow value as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:35:22
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:34:22
|
LL | let ref mut a @ (ref b @ ref mut c) = u(); // sub-in-sub
| -----^^^---------
@@ -27,7 +27,7 @@ LL | let ref mut a @ (ref b @ ref mut c) = u(); // sub-in-sub
| immutable borrow, by `b`, occurs here
error: cannot borrow value as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:39:9
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:38:9
|
LL | let ref a @ ref mut b = U;
| -----^^^---------
@@ -36,7 +36,7 @@ LL | let ref a @ ref mut b = U;
| immutable borrow, by `a`, occurs here
error: cannot borrow value as immutable because it is also borrowed as mutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:41:9
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:40:9
|
LL | let ref mut a @ ref b = U;
| ---------^^^-----
@@ -45,7 +45,7 @@ LL | let ref mut a @ ref b = U;
| mutable borrow, by `a`, occurs here
error: cannot borrow value as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:43:9
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:42:9
|
LL | let ref a @ (ref mut b, ref mut c) = (U, U);
| -----^^^^---------^^---------^
@@ -55,7 +55,7 @@ LL | let ref a @ (ref mut b, ref mut c) = (U, U);
| immutable borrow, by `a`, occurs here
error: cannot borrow value as immutable because it is also borrowed as mutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:45:9
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:44:9
|
LL | let ref mut a @ (ref b, ref c) = (U, U);
| ---------^^^^-----^^-----^
@@ -65,7 +65,7 @@ LL | let ref mut a @ (ref b, ref c) = (U, U);
| mutable borrow, by `a`, occurs here
error: cannot borrow value as immutable because it is also borrowed as mutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:48:9
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:47:9
|
LL | let ref mut a @ ref b = u();
| ---------^^^-----
@@ -74,7 +74,7 @@ LL | let ref mut a @ ref b = u();
| mutable borrow, by `a`, occurs here
error: cannot borrow value as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:53:9
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:52:9
|
LL | let ref a @ ref mut b = u();
| -----^^^---------
@@ -83,7 +83,7 @@ LL | let ref a @ ref mut b = u();
| immutable borrow, by `a`, occurs here
error: cannot borrow value as immutable because it is also borrowed as mutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:59:9
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:58:9
|
LL | let ref mut a @ ref b = U;
| ---------^^^-----
@@ -92,7 +92,7 @@ LL | let ref mut a @ ref b = U;
| mutable borrow, by `a`, occurs here
error: cannot borrow value as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:63:9
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:62:9
|
LL | let ref a @ ref mut b = U;
| -----^^^---------
@@ -101,7 +101,7 @@ LL | let ref a @ ref mut b = U;
| immutable borrow, by `a`, occurs here
error: cannot borrow value as immutable because it is also borrowed as mutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:69:9
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:68:9
|
LL | ref mut a @ Ok(ref b) | ref mut a @ Err(ref b) => {
| ---------^^^^^^-----^
@@ -110,7 +110,7 @@ LL | ref mut a @ Ok(ref b) | ref mut a @ Err(ref b) => {
| mutable borrow, by `a`, occurs here
error: cannot borrow value as immutable because it is also borrowed as mutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:69:33
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:68:33
|
LL | ref mut a @ Ok(ref b) | ref mut a @ Err(ref b) => {
| ---------^^^^^^^-----^
@@ -119,7 +119,7 @@ LL | ref mut a @ Ok(ref b) | ref mut a @ Err(ref b) => {
| mutable borrow, by `a`, occurs here
error: cannot borrow value as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:78:9
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:77:9
|
LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) => {
| -----^^^^^^---------^
@@ -128,7 +128,7 @@ LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) => {
| immutable borrow, by `a`, occurs here
error: cannot borrow value as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:78:33
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:77:33
|
LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) => {
| -----^^^^^^^---------^
@@ -137,7 +137,7 @@ LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) => {
| immutable borrow, by `a`, occurs here
error: cannot borrow value as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:89:9
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:88:9
|
LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) if { *b = U; false } => {}
| -----^^^^^^---------^
@@ -146,7 +146,7 @@ LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) if { *b = U; false }
| immutable borrow, by `a`, occurs here
error: cannot borrow value as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:89:33
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:88:33
|
LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) if { *b = U; false } => {}
| -----^^^^^^^---------^
@@ -155,7 +155,7 @@ LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) if { *b = U; false }
| immutable borrow, by `a`, occurs here
error: cannot borrow value as immutable because it is also borrowed as mutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:96:9
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:95:9
|
LL | ref mut a @ Ok(ref b) | ref mut a @ Err(ref b) if { *a = Err(U); false } => {}
| ---------^^^^^^-----^
@@ -164,7 +164,7 @@ LL | ref mut a @ Ok(ref b) | ref mut a @ Err(ref b) if { *a = Err(U); fa
| mutable borrow, by `a`, occurs here
error: cannot borrow value as immutable because it is also borrowed as mutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:96:33
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:95:33
|
LL | ref mut a @ Ok(ref b) | ref mut a @ Err(ref b) if { *a = Err(U); false } => {}
| ---------^^^^^^^-----^
@@ -173,7 +173,7 @@ LL | ref mut a @ Ok(ref b) | ref mut a @ Err(ref b) if { *a = Err(U); fa
| mutable borrow, by `a`, occurs here
error: cannot borrow value as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:103:9
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:102:9
|
LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) if { drop(b); false } => {}
| -----^^^^^^---------^
@@ -182,7 +182,7 @@ LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) if { drop(b); false
| immutable borrow, by `a`, occurs here
error: cannot borrow value as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:103:33
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:102:33
|
LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) if { drop(b); false } => {}
| -----^^^^^^^---------^
@@ -191,7 +191,7 @@ LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) if { drop(b); false
| immutable borrow, by `a`, occurs here
error: cannot borrow value as immutable because it is also borrowed as mutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:111:9
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:110:9
|
LL | ref mut a @ Ok(ref b) | ref mut a @ Err(ref b) if { drop(a); false } => {}
| ---------^^^^^^-----^
@@ -200,7 +200,7 @@ LL | ref mut a @ Ok(ref b) | ref mut a @ Err(ref b) if { drop(a); false
| mutable borrow, by `a`, occurs here
error: cannot borrow value as immutable because it is also borrowed as mutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:111:33
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:110:33
|
LL | ref mut a @ Ok(ref b) | ref mut a @ Err(ref b) if { drop(a); false } => {}
| ---------^^^^^^^-----^
@@ -209,7 +209,7 @@ LL | ref mut a @ Ok(ref b) | ref mut a @ Err(ref b) if { drop(a); false
| mutable borrow, by `a`, occurs here
error: cannot borrow value as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:119:9
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:118:9
|
LL | let ref a @ (ref mut b, ref mut c) = (U, U);
| -----^^^^---------^^---------^
@@ -219,7 +219,7 @@ LL | let ref a @ (ref mut b, ref mut c) = (U, U);
| immutable borrow, by `a`, occurs here
error: cannot borrow value as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:124:9
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:123:9
|
LL | let ref a @ (ref mut b, ref mut c) = (U, U);
| -----^^^^---------^^---------^
@@ -229,7 +229,7 @@ LL | let ref a @ (ref mut b, ref mut c) = (U, U);
| immutable borrow, by `a`, occurs here
error: cannot borrow value as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:131:9
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:130:9
|
LL | let ref a @ (ref mut b, ref mut c) = (U, U);
| -----^^^^---------^^---------^
@@ -239,7 +239,7 @@ LL | let ref a @ (ref mut b, ref mut c) = (U, U);
| immutable borrow, by `a`, occurs here
error: cannot borrow value as immutable because it is also borrowed as mutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:136:9
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:135:9
|
LL | let ref mut a @ (ref b, ref c) = (U, U);
| ---------^^^^-----^^-----^
@@ -249,7 +249,7 @@ LL | let ref mut a @ (ref b, ref c) = (U, U);
| mutable borrow, by `a`, occurs here
error: cannot borrow value as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:25:11
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:24:11
|
LL | fn f1(ref a @ ref mut b: U) {}
| -----^^^---------
@@ -258,7 +258,7 @@ LL | fn f1(ref a @ ref mut b: U) {}
| immutable borrow, by `a`, occurs here
error: cannot borrow value as immutable because it is also borrowed as mutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:27:11
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:26:11
|
LL | fn f2(ref mut a @ ref b: U) {}
| ---------^^^-----
@@ -267,7 +267,7 @@ LL | fn f2(ref mut a @ ref b: U) {}
| mutable borrow, by `a`, occurs here
error: cannot borrow value as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:29:11
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:28:11
|
LL | fn f3(ref a @ [ref b, ref mut mid @ .., ref c]: [U; 4]) {}
| -----^^^^^^^^^^^----------------^^^^^^^^
@@ -276,7 +276,7 @@ LL | fn f3(ref a @ [ref b, ref mut mid @ .., ref c]: [U; 4]) {}
| immutable borrow, by `a`, occurs here
error: cannot borrow value as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:31:22
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:30:22
|
LL | fn f4_also_moved(ref a @ ref mut b @ c: U) {}
| -----^^^-------------
@@ -286,7 +286,7 @@ LL | fn f4_also_moved(ref a @ ref mut b @ c: U) {}
| immutable borrow, by `a`, occurs here
error: cannot move out of value because it is borrowed
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:31:30
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:30:30
|
LL | fn f4_also_moved(ref a @ ref mut b @ c: U) {}
| ---------^^^-
@@ -295,7 +295,7 @@ LL | fn f4_also_moved(ref a @ ref mut b @ c: U) {}
| value borrowed, by `b`, here
error[E0502]: cannot borrow value as immutable because it is also borrowed as mutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:11:31
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:10:31
|
LL | ref mut z @ &mut Some(ref a) => {
| ----------------------^^^^^-
@@ -307,7 +307,7 @@ LL | **z = None;
| ---------- mutable borrow later used here
error[E0502]: cannot borrow value as immutable because it is also borrowed as mutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:48:21
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:47:21
|
LL | let ref mut a @ ref b = u();
| ------------^^^^^
@@ -319,7 +319,7 @@ LL | *a = u();
| -------- mutable borrow later used here
error[E0502]: cannot borrow value as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:53:17
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:52:17
|
LL | let ref a @ ref mut b = u();
| --------^^^^^^^^^
@@ -331,7 +331,7 @@ LL | drop(a);
| - immutable borrow later used here
error[E0502]: cannot borrow value as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:78:20
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:77:20
|
LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) => {
| -----------^^^^^^^^^-
@@ -343,7 +343,7 @@ LL | drop(a);
| - immutable borrow later used here
error[E0502]: cannot borrow value as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:78:45
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:77:45
|
LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) => {
| ------------^^^^^^^^^-
@@ -355,7 +355,7 @@ LL | drop(a);
| - immutable borrow later used here
error[E0594]: cannot assign to `*b`, as it is immutable for the pattern guard
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:89:61
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:88:61
|
LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) if { *b = U; false } => {}
| ^^^^^^ cannot assign
@@ -363,7 +363,7 @@ LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) if { *b = U; false }
= note: variables bound in patterns are immutable until the end of the pattern guard
error[E0594]: cannot assign to `*a`, as it is immutable for the pattern guard
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:96:61
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:95:61
|
LL | ref mut a @ Ok(ref b) | ref mut a @ Err(ref b) if { *a = Err(U); false } => {}
| ^^^^^^^^^^^ cannot assign
@@ -371,7 +371,7 @@ LL | ref mut a @ Ok(ref b) | ref mut a @ Err(ref b) if { *a = Err(U); fa
= note: variables bound in patterns are immutable until the end of the pattern guard
error[E0507]: cannot move out of `b` in pattern guard
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:103:66
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:102:66
|
LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) if { drop(b); false } => {}
| ^ move occurs because `b` has type `&mut U`, which does not implement the `Copy` trait
@@ -379,7 +379,7 @@ LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) if { drop(b); false
= note: variables bound in patterns cannot be moved from until after the end of the pattern guard
error[E0507]: cannot move out of `b` in pattern guard
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:103:66
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:102:66
|
LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) if { drop(b); false } => {}
| ^ move occurs because `b` has type `&mut U`, which does not implement the `Copy` trait
@@ -387,7 +387,7 @@ LL | ref a @ Ok(ref mut b) | ref a @ Err(ref mut b) if { drop(b); false
= note: variables bound in patterns cannot be moved from until after the end of the pattern guard
error[E0507]: cannot move out of `a` in pattern guard
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:111:66
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:110:66
|
LL | ref mut a @ Ok(ref b) | ref mut a @ Err(ref b) if { drop(a); false } => {}
| ^ move occurs because `a` has type `&mut std::result::Result<U, U>`, which does not implement the `Copy` trait
@@ -395,7 +395,7 @@ LL | ref mut a @ Ok(ref b) | ref mut a @ Err(ref b) if { drop(a); false
= note: variables bound in patterns cannot be moved from until after the end of the pattern guard
error[E0507]: cannot move out of `a` in pattern guard
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:111:66
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:110:66
|
LL | ref mut a @ Ok(ref b) | ref mut a @ Err(ref b) if { drop(a); false } => {}
| ^ move occurs because `a` has type `&mut std::result::Result<U, U>`, which does not implement the `Copy` trait
@@ -403,7 +403,7 @@ LL | ref mut a @ Ok(ref b) | ref mut a @ Err(ref b) if { drop(a); false
= note: variables bound in patterns cannot be moved from until after the end of the pattern guard
error[E0502]: cannot borrow value as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:124:18
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:123:18
|
LL | let ref a @ (ref mut b, ref mut c) = (U, U);
| ---------^^^^^^^^^------------
@@ -415,7 +415,7 @@ LL | drop(a);
| - immutable borrow later used here
error[E0502]: cannot borrow value as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:124:29
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:123:29
|
LL | let ref a @ (ref mut b, ref mut c) = (U, U);
| --------------------^^^^^^^^^-
@@ -427,7 +427,7 @@ LL | drop(a);
| - immutable borrow later used here
error[E0502]: cannot borrow value as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:131:18
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:130:18
|
LL | let ref a @ (ref mut b, ref mut c) = (U, U);
| ---------^^^^^^^^^------------
@@ -439,7 +439,7 @@ LL | drop(a);
| - immutable borrow later used here
error[E0502]: cannot borrow value as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-pat-ref-mut-and-ref.rs:131:29
+ --> $DIR/borrowck-pat-ref-mut-and-ref.rs:130:29
|
LL | let ref a @ (ref mut b, ref mut c) = (U, U);
| --------------------^^^^^^^^^-
diff --git a/src/test/ui/pattern/bindings-after-at/borrowck-pat-ref-mut-twice.rs b/src/test/ui/pattern/bindings-after-at/borrowck-pat-ref-mut-twice.rs
index a208d0087ff53..8faaa1c881fbf 100644
--- a/src/test/ui/pattern/bindings-after-at/borrowck-pat-ref-mut-twice.rs
+++ b/src/test/ui/pattern/bindings-after-at/borrowck-pat-ref-mut-twice.rs
@@ -1,7 +1,6 @@
// Test that `ref mut x @ ref mut y` and varieties of that are not allowed.
#![feature(bindings_after_at)]
-#![feature(move_ref_pattern)]
fn main() {
struct U;
diff --git a/src/test/ui/pattern/bindings-after-at/borrowck-pat-ref-mut-twice.stderr b/src/test/ui/pattern/bindings-after-at/borrowck-pat-ref-mut-twice.stderr
index 1cd3e267b9950..2e0f5fcabddf3 100644
--- a/src/test/ui/pattern/bindings-after-at/borrowck-pat-ref-mut-twice.stderr
+++ b/src/test/ui/pattern/bindings-after-at/borrowck-pat-ref-mut-twice.stderr
@@ -1,5 +1,5 @@
error: cannot borrow value as mutable more than once at a time
- --> $DIR/borrowck-pat-ref-mut-twice.rs:28:9
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:27:9
|
LL | let ref mut a @ ref mut b = U;
| ---------^^^---------
@@ -8,7 +8,7 @@ LL | let ref mut a @ ref mut b = U;
| first mutable borrow, by `a`, occurs here
error: cannot borrow value as mutable more than once at a time
- --> $DIR/borrowck-pat-ref-mut-twice.rs:32:9
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:31:9
|
LL | let ref mut a @ ref mut b = U;
| ---------^^^---------
@@ -17,7 +17,7 @@ LL | let ref mut a @ ref mut b = U;
| first mutable borrow, by `a`, occurs here
error: cannot borrow value as mutable more than once at a time
- --> $DIR/borrowck-pat-ref-mut-twice.rs:35:9
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:34:9
|
LL | let ref mut a @ ref mut b = U;
| ---------^^^---------
@@ -26,7 +26,7 @@ LL | let ref mut a @ ref mut b = U;
| first mutable borrow, by `a`, occurs here
error: cannot borrow value as mutable more than once at a time
- --> $DIR/borrowck-pat-ref-mut-twice.rs:38:9
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:37:9
|
LL | let ref mut a @ ref mut b = U;
| ---------^^^---------
@@ -35,7 +35,7 @@ LL | let ref mut a @ ref mut b = U;
| first mutable borrow, by `a`, occurs here
error: cannot borrow value as mutable more than once at a time
- --> $DIR/borrowck-pat-ref-mut-twice.rs:42:9
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:41:9
|
LL | let ref mut a @ ref mut b = U;
| ---------^^^---------
@@ -44,7 +44,7 @@ LL | let ref mut a @ ref mut b = U;
| first mutable borrow, by `a`, occurs here
error: cannot borrow value as mutable more than once at a time
- --> $DIR/borrowck-pat-ref-mut-twice.rs:46:9
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:45:9
|
LL | let ref mut a @ (
| ^--------
@@ -66,7 +66,7 @@ LL | | ) = (U, [U, U, U]);
| |_____^
error: cannot borrow value as mutable more than once at a time
- --> $DIR/borrowck-pat-ref-mut-twice.rs:56:9
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:55:9
|
LL | let ref mut a @ (
| ^--------
@@ -88,7 +88,7 @@ LL | | ) = (u(), [u(), u(), u()]);
| |_________^
error: borrow of moved value
- --> $DIR/borrowck-pat-ref-mut-twice.rs:66:9
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:65:9
|
LL | let a @ (ref mut b, ref mut c) = (U, U);
| -^^^^---------^^---------^
@@ -99,7 +99,7 @@ LL | let a @ (ref mut b, ref mut c) = (U, U);
| move occurs because `a` has type `(U, U)` which does not implement the `Copy` trait
error: borrow of moved value
- --> $DIR/borrowck-pat-ref-mut-twice.rs:70:9
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:69:9
|
LL | let a @ (b, [c, d]) = &mut val; // Same as ^--
| -^^^^-^^^-^^-^^
@@ -111,7 +111,7 @@ LL | let a @ (b, [c, d]) = &mut val; // Same as ^--
| move occurs because `a` has type `&mut (U, [U; 2])` which does not implement the `Copy` trait
error: borrow of moved value
- --> $DIR/borrowck-pat-ref-mut-twice.rs:74:9
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:73:9
|
LL | let a @ &mut ref mut b = &mut U;
| -^^^^^^^^---------
@@ -121,7 +121,7 @@ LL | let a @ &mut ref mut b = &mut U;
| move occurs because `a` has type `&mut U` which does not implement the `Copy` trait
error: borrow of moved value
- --> $DIR/borrowck-pat-ref-mut-twice.rs:77:9
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:76:9
|
LL | let a @ &mut (ref mut b, ref mut c) = &mut (U, U);
| -^^^^^^^^^---------^^---------^
@@ -132,7 +132,7 @@ LL | let a @ &mut (ref mut b, ref mut c) = &mut (U, U);
| move occurs because `a` has type `&mut (U, U)` which does not implement the `Copy` trait
error: cannot borrow value as mutable more than once at a time
- --> $DIR/borrowck-pat-ref-mut-twice.rs:82:9
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:81:9
|
LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => {
| ---------^^^^^^---------^
@@ -141,7 +141,7 @@ LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => {
| first mutable borrow, by `a`, occurs here
error: cannot borrow value as mutable more than once at a time
- --> $DIR/borrowck-pat-ref-mut-twice.rs:82:37
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:81:37
|
LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => {
| ---------^^^^^^^---------^
@@ -150,7 +150,7 @@ LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => {
| first mutable borrow, by `a`, occurs here
error: cannot borrow value as mutable more than once at a time
- --> $DIR/borrowck-pat-ref-mut-twice.rs:88:9
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:87:9
|
LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => {
| ---------^^^^^^---------^
@@ -159,7 +159,7 @@ LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => {
| first mutable borrow, by `a`, occurs here
error: cannot borrow value as mutable more than once at a time
- --> $DIR/borrowck-pat-ref-mut-twice.rs:88:37
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:87:37
|
LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => {
| ---------^^^^^^^---------^
@@ -168,7 +168,7 @@ LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => {
| first mutable borrow, by `a`, occurs here
error: cannot borrow value as mutable more than once at a time
- --> $DIR/borrowck-pat-ref-mut-twice.rs:95:9
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:94:9
|
LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => {
| ---------^^^^^^---------^
@@ -177,7 +177,7 @@ LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => {
| first mutable borrow, by `a`, occurs here
error: cannot borrow value as mutable more than once at a time
- --> $DIR/borrowck-pat-ref-mut-twice.rs:95:37
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:94:37
|
LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => {
| ---------^^^^^^^---------^
@@ -186,7 +186,7 @@ LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => {
| first mutable borrow, by `a`, occurs here
error: cannot borrow value as mutable more than once at a time
- --> $DIR/borrowck-pat-ref-mut-twice.rs:107:9
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:106:9
|
LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => {
| ---------^^^^^^---------^
@@ -195,7 +195,7 @@ LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => {
| first mutable borrow, by `a`, occurs here
error: cannot borrow value as mutable more than once at a time
- --> $DIR/borrowck-pat-ref-mut-twice.rs:107:37
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:106:37
|
LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => {
| ---------^^^^^^^---------^
@@ -204,7 +204,7 @@ LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => {
| first mutable borrow, by `a`, occurs here
error: cannot borrow value as mutable more than once at a time
- --> $DIR/borrowck-pat-ref-mut-twice.rs:11:11
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:10:11
|
LL | fn f1(ref mut a @ ref mut b: U) {}
| ---------^^^---------
@@ -213,7 +213,7 @@ LL | fn f1(ref mut a @ ref mut b: U) {}
| first mutable borrow, by `a`, occurs here
error: cannot borrow value as mutable more than once at a time
- --> $DIR/borrowck-pat-ref-mut-twice.rs:13:11
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:12:11
|
LL | fn f2(ref mut a @ ref mut b: U) {}
| ---------^^^---------
@@ -222,7 +222,7 @@ LL | fn f2(ref mut a @ ref mut b: U) {}
| first mutable borrow, by `a`, occurs here
error: cannot borrow value as mutable more than once at a time
- --> $DIR/borrowck-pat-ref-mut-twice.rs:16:9
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:15:9
|
LL | ref mut a @ [
| ^--------
@@ -240,7 +240,7 @@ LL | | ] : [[U; 4]; 5]
| |_________^
error: cannot borrow value as mutable more than once at a time
- --> $DIR/borrowck-pat-ref-mut-twice.rs:24:22
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:23:22
|
LL | fn f4_also_moved(ref mut a @ ref mut b @ c: U) {}
| ---------^^^-------------
@@ -250,7 +250,7 @@ LL | fn f4_also_moved(ref mut a @ ref mut b @ c: U) {}
| first mutable borrow, by `a`, occurs here
error: cannot move out of value because it is borrowed
- --> $DIR/borrowck-pat-ref-mut-twice.rs:24:34
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:23:34
|
LL | fn f4_also_moved(ref mut a @ ref mut b @ c: U) {}
| ---------^^^-
@@ -259,7 +259,7 @@ LL | fn f4_also_moved(ref mut a @ ref mut b @ c: U) {}
| value borrowed, by `b`, here
error[E0499]: cannot borrow value as mutable more than once at a time
- --> $DIR/borrowck-pat-ref-mut-twice.rs:28:21
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:27:21
|
LL | let ref mut a @ ref mut b = U;
| ------------^^^^^^^^^
@@ -271,7 +271,7 @@ LL | drop(a);
| - first borrow later used here
error[E0499]: cannot borrow value as mutable more than once at a time
- --> $DIR/borrowck-pat-ref-mut-twice.rs:38:21
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:37:21
|
LL | let ref mut a @ ref mut b = U;
| ------------^^^^^^^^^
@@ -283,7 +283,7 @@ LL | *a = U;
| ------ first borrow later used here
error[E0382]: borrow of moved value
- --> $DIR/borrowck-pat-ref-mut-twice.rs:66:25
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:65:25
|
LL | let a @ (ref mut b, ref mut c) = (U, U);
| ----------------^^^^^^^^^- ------ move occurs because value has type `(U, U)`, which does not implement the `Copy` trait
@@ -292,7 +292,7 @@ LL | let a @ (ref mut b, ref mut c) = (U, U);
| value moved here
error[E0382]: borrow of moved value
- --> $DIR/borrowck-pat-ref-mut-twice.rs:70:21
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:69:21
|
LL | let a @ (b, [c, d]) = &mut val; // Same as ^--
| ------------^-- -------- move occurs because value has type `&mut (U, [U; 2])`, which does not implement the `Copy` trait
@@ -301,7 +301,7 @@ LL | let a @ (b, [c, d]) = &mut val; // Same as ^--
| value moved here
error[E0382]: borrow of moved value
- --> $DIR/borrowck-pat-ref-mut-twice.rs:74:18
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:73:18
|
LL | let a @ &mut ref mut b = &mut U;
| ---------^^^^^^^^^ ------ move occurs because value has type `&mut U`, which does not implement the `Copy` trait
@@ -310,7 +310,7 @@ LL | let a @ &mut ref mut b = &mut U;
| value moved here
error[E0382]: borrow of moved value
- --> $DIR/borrowck-pat-ref-mut-twice.rs:77:30
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:76:30
|
LL | let a @ &mut (ref mut b, ref mut c) = &mut (U, U);
| ---------------------^^^^^^^^^- ----------- move occurs because value has type `&mut (U, U)`, which does not implement the `Copy` trait
@@ -319,7 +319,7 @@ LL | let a @ &mut (ref mut b, ref mut c) = &mut (U, U);
| value moved here
error[E0499]: cannot borrow value as mutable more than once at a time
- --> $DIR/borrowck-pat-ref-mut-twice.rs:95:24
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:94:24
|
LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => {
| ---------------^^^^^^^^^-
@@ -331,7 +331,7 @@ LL | *a = Err(U);
| ----------- first borrow later used here
error[E0499]: cannot borrow value as mutable more than once at a time
- --> $DIR/borrowck-pat-ref-mut-twice.rs:95:53
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:94:53
|
LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => {
| ----------------^^^^^^^^^-
@@ -343,7 +343,7 @@ LL | *a = Err(U);
| ----------- first borrow later used here
error[E0499]: cannot borrow value as mutable more than once at a time
- --> $DIR/borrowck-pat-ref-mut-twice.rs:107:24
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:106:24
|
LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => {
| ---------------^^^^^^^^^-
@@ -355,7 +355,7 @@ LL | drop(a);
| - first borrow later used here
error[E0499]: cannot borrow value as mutable more than once at a time
- --> $DIR/borrowck-pat-ref-mut-twice.rs:107:53
+ --> $DIR/borrowck-pat-ref-mut-twice.rs:106:53
|
LL | ref mut a @ Ok(ref mut b) | ref mut a @ Err(ref mut b) => {
| ----------------^^^^^^^^^-
diff --git a/src/test/ui/pattern/bindings-after-at/copy-and-move-mixed.rs b/src/test/ui/pattern/bindings-after-at/copy-and-move-mixed.rs
index 821d4b42962bf..3954d17e1c2bc 100644
--- a/src/test/ui/pattern/bindings-after-at/copy-and-move-mixed.rs
+++ b/src/test/ui/pattern/bindings-after-at/copy-and-move-mixed.rs
@@ -1,7 +1,6 @@
// Test that mixing `Copy` and non-`Copy` types in `@` patterns is forbidden.
#![feature(bindings_after_at)]
-#![feature(move_ref_pattern)]
#[derive(Copy, Clone)]
struct C;
diff --git a/src/test/ui/pattern/bindings-after-at/copy-and-move-mixed.stderr b/src/test/ui/pattern/bindings-after-at/copy-and-move-mixed.stderr
index 7e89008a60496..cc2786a13f4e8 100644
--- a/src/test/ui/pattern/bindings-after-at/copy-and-move-mixed.stderr
+++ b/src/test/ui/pattern/bindings-after-at/copy-and-move-mixed.stderr
@@ -1,5 +1,5 @@
error[E0382]: use of moved value
- --> $DIR/copy-and-move-mixed.rs:12:19
+ --> $DIR/copy-and-move-mixed.rs:11:19
|
LL | let a @ NC(b, c) = NC(C, C);
| ----------^- -------- move occurs because value has type `NC<C, C>`, which does not implement the `Copy` trait
@@ -8,7 +8,7 @@ LL | let a @ NC(b, c) = NC(C, C);
| value moved here
error[E0382]: use of moved value
- --> $DIR/copy-and-move-mixed.rs:15:19
+ --> $DIR/copy-and-move-mixed.rs:14:19
|
LL | let a @ NC(b, c @ NC(d, e)) = NC(C, NC(C, C));
| ----------^^^^^^^^^^^^- --------------- move occurs because value has type `NC<C, NC<C, C>>`, which does not implement the `Copy` trait
@@ -17,7 +17,7 @@ LL | let a @ NC(b, c @ NC(d, e)) = NC(C, NC(C, C));
| value moved here
error[E0382]: use of moved value
- --> $DIR/copy-and-move-mixed.rs:15:29
+ --> $DIR/copy-and-move-mixed.rs:14:29
|
LL | let a @ NC(b, c @ NC(d, e)) = NC(C, NC(C, C));
| ----------^-
diff --git a/src/test/ui/pattern/bindings-after-at/default-binding-modes-both-sides-independent.rs b/src/test/ui/pattern/bindings-after-at/default-binding-modes-both-sides-independent.rs
index a45497229ac9e..276088b9a9ee9 100644
--- a/src/test/ui/pattern/bindings-after-at/default-binding-modes-both-sides-independent.rs
+++ b/src/test/ui/pattern/bindings-after-at/default-binding-modes-both-sides-independent.rs
@@ -8,7 +8,6 @@
// this would create problems for the generalization aforementioned.
#![feature(bindings_after_at)]
-#![feature(move_ref_pattern)]
fn main() {
struct NotCopy;
diff --git a/src/test/ui/pattern/bindings-after-at/default-binding-modes-both-sides-independent.stderr b/src/test/ui/pattern/bindings-after-at/default-binding-modes-both-sides-independent.stderr
index a63a5a1e6c7d4..11d5e24f34e13 100644
--- a/src/test/ui/pattern/bindings-after-at/default-binding-modes-both-sides-independent.stderr
+++ b/src/test/ui/pattern/bindings-after-at/default-binding-modes-both-sides-independent.stderr
@@ -1,5 +1,5 @@
error: cannot move out of value because it is borrowed
- --> $DIR/default-binding-modes-both-sides-independent.rs:28:9
+ --> $DIR/default-binding-modes-both-sides-independent.rs:27:9
|
LL | let ref a @ b = NotCopy;
| -----^^^-
@@ -8,7 +8,7 @@ LL | let ref a @ b = NotCopy;
| value borrowed, by `a`, here
error: cannot move out of value because it is borrowed
- --> $DIR/default-binding-modes-both-sides-independent.rs:31:9
+ --> $DIR/default-binding-modes-both-sides-independent.rs:30:9
|
LL | let ref mut a @ b = NotCopy;
| ---------^^^-
@@ -17,7 +17,7 @@ LL | let ref mut a @ b = NotCopy;
| value borrowed, by `a`, here
error: cannot move out of value because it is borrowed
- --> $DIR/default-binding-modes-both-sides-independent.rs:36:12
+ --> $DIR/default-binding-modes-both-sides-independent.rs:35:12
|
LL | Ok(ref a @ b) | Err(b @ ref a) => {
| -----^^^-
@@ -26,7 +26,7 @@ LL | Ok(ref a @ b) | Err(b @ ref a) => {
| value borrowed, by `a`, here
error: borrow of moved value
- --> $DIR/default-binding-modes-both-sides-independent.rs:36:29
+ --> $DIR/default-binding-modes-both-sides-independent.rs:35:29
|
LL | Ok(ref a @ b) | Err(b @ ref a) => {
| -^^^-----
@@ -36,7 +36,7 @@ LL | Ok(ref a @ b) | Err(b @ ref a) => {
| move occurs because `b` has type `NotCopy` which does not implement the `Copy` trait
error: cannot move out of value because it is borrowed
- --> $DIR/default-binding-modes-both-sides-independent.rs:44:9
+ --> $DIR/default-binding-modes-both-sides-independent.rs:43:9
|
LL | ref a @ b => {
| -----^^^-
@@ -45,7 +45,7 @@ LL | ref a @ b => {
| value borrowed, by `a`, here
error[E0505]: cannot move out of value because it is borrowed
- --> $DIR/default-binding-modes-both-sides-independent.rs:31:21
+ --> $DIR/default-binding-modes-both-sides-independent.rs:30:21
|
LL | let ref mut a @ b = NotCopy;
| ------------^
diff --git a/src/test/ui/pattern/move-ref-patterns/borrowck-move-ref-pattern-pass.rs b/src/test/ui/pattern/move-ref-patterns/borrowck-move-ref-pattern-pass.rs
index d2d4e61e049b2..5445696fdff7d 100644
--- a/src/test/ui/pattern/move-ref-patterns/borrowck-move-ref-pattern-pass.rs
+++ b/src/test/ui/pattern/move-ref-patterns/borrowck-move-ref-pattern-pass.rs
@@ -1,7 +1,5 @@
// check-pass
-#![feature(move_ref_pattern)]
-
fn main() {}
struct U;
diff --git a/src/test/ui/pattern/move-ref-patterns/borrowck-move-ref-pattern.rs b/src/test/ui/pattern/move-ref-patterns/borrowck-move-ref-pattern.rs
index 3ee008fd84f09..9c320edc4dc0e 100644
--- a/src/test/ui/pattern/move-ref-patterns/borrowck-move-ref-pattern.rs
+++ b/src/test/ui/pattern/move-ref-patterns/borrowck-move-ref-pattern.rs
@@ -1,5 +1,3 @@
-#![feature(move_ref_pattern)]
-
fn main() {}
struct U;
diff --git a/src/test/ui/pattern/move-ref-patterns/borrowck-move-ref-pattern.stderr b/src/test/ui/pattern/move-ref-patterns/borrowck-move-ref-pattern.stderr
index d718ee29cf9b5..285c203f382df 100644
--- a/src/test/ui/pattern/move-ref-patterns/borrowck-move-ref-pattern.stderr
+++ b/src/test/ui/pattern/move-ref-patterns/borrowck-move-ref-pattern.stderr
@@ -1,5 +1,5 @@
error[E0505]: cannot move out of `arr[..]` because it is borrowed
- --> $DIR/borrowck-move-ref-pattern.rs:10:24
+ --> $DIR/borrowck-move-ref-pattern.rs:8:24
|
LL | let hold_all = &arr;
| ---- borrow of `arr` occurs here
@@ -10,7 +10,7 @@ LL | drop(hold_all);
| -------- borrow later used here
error[E0384]: cannot assign twice to immutable variable `_x1`
- --> $DIR/borrowck-move-ref-pattern.rs:11:5
+ --> $DIR/borrowck-move-ref-pattern.rs:9:5
|
LL | let [ref _x0_hold, _x1, ref xs_hold @ ..] = arr;
| ---
@@ -21,7 +21,7 @@ LL | _x1 = U;
| ^^^^^^^ cannot assign twice to immutable variable
error[E0505]: cannot move out of `arr[..]` because it is borrowed
- --> $DIR/borrowck-move-ref-pattern.rs:13:10
+ --> $DIR/borrowck-move-ref-pattern.rs:11:10
|
LL | let [ref _x0_hold, _x1, ref xs_hold @ ..] = arr;
| ------------ borrow of `arr[..]` occurs here
@@ -32,7 +32,7 @@ LL | drop(_x0_hold);
| -------- borrow later used here
error[E0502]: cannot borrow `arr[..]` as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-move-ref-pattern.rs:15:16
+ --> $DIR/borrowck-move-ref-pattern.rs:13:16
|
LL | let [ref _x0_hold, _x1, ref xs_hold @ ..] = arr;
| ---------------- immutable borrow occurs here
@@ -44,7 +44,7 @@ LL | drop(xs_hold);
| ------- immutable borrow later used here
error[E0505]: cannot move out of `arr[..]` because it is borrowed
- --> $DIR/borrowck-move-ref-pattern.rs:15:29
+ --> $DIR/borrowck-move-ref-pattern.rs:13:29
|
LL | let [ref _x0_hold, _x1, ref xs_hold @ ..] = arr;
| ---------------- borrow of `arr[..]` occurs here
@@ -56,7 +56,7 @@ LL | drop(xs_hold);
| ------- borrow later used here
error[E0505]: cannot move out of `arr[..]` because it is borrowed
- --> $DIR/borrowck-move-ref-pattern.rs:15:34
+ --> $DIR/borrowck-move-ref-pattern.rs:13:34
|
LL | let [ref _x0_hold, _x1, ref xs_hold @ ..] = arr;
| ---------------- borrow of `arr[..]` occurs here
@@ -68,7 +68,7 @@ LL | drop(xs_hold);
| ------- borrow later used here
error[E0384]: cannot assign twice to immutable variable `_x1`
- --> $DIR/borrowck-move-ref-pattern.rs:25:5
+ --> $DIR/borrowck-move-ref-pattern.rs:23:5
|
LL | let (ref _x0, _x1, ref _x2, ..) = tup;
| ---
@@ -79,7 +79,7 @@ LL | _x1 = U;
| ^^^^^^^ cannot assign twice to immutable variable
error[E0502]: cannot borrow `tup.0` as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-move-ref-pattern.rs:26:20
+ --> $DIR/borrowck-move-ref-pattern.rs:24:20
|
LL | let (ref _x0, _x1, ref _x2, ..) = tup;
| ------- immutable borrow occurs here
@@ -91,7 +91,7 @@ LL | *_x0 = U;
| -------- immutable borrow later used here
error[E0502]: cannot borrow `tup.0` as mutable because it is also borrowed as immutable
- --> $DIR/borrowck-move-ref-pattern.rs:27:10
+ --> $DIR/borrowck-move-ref-pattern.rs:25:10
|
LL | let (ref _x0, _x1, ref _x2, ..) = tup;
| ------- immutable borrow occurs here
@@ -102,7 +102,7 @@ LL | *_x0 = U;
| -------- immutable borrow later used here
error[E0594]: cannot assign to `*_x0` which is behind a `&` reference
- --> $DIR/borrowck-move-ref-pattern.rs:28:5
+ --> $DIR/borrowck-move-ref-pattern.rs:26:5
|
LL | let (ref _x0, _x1, ref _x2, ..) = tup;
| ------- help: consider changing this to be a mutable reference: `ref mut _x0`
@@ -111,7 +111,7 @@ LL | *_x0 = U;
| ^^^^^^^^ `_x0` is a `&` reference, so the data it refers to cannot be written
error[E0594]: cannot assign to `*_x2` which is behind a `&` reference
- --> $DIR/borrowck-move-ref-pattern.rs:29:5
+ --> $DIR/borrowck-move-ref-pattern.rs:27:5
|
LL | let (ref _x0, _x1, ref _x2, ..) = tup;
| ------- help: consider changing this to be a mutable reference: `ref mut _x2`
@@ -120,7 +120,7 @@ LL | *_x2 = U;
| ^^^^^^^^ `_x2` is a `&` reference, so the data it refers to cannot be written
error[E0382]: use of moved value: `tup.1`
- --> $DIR/borrowck-move-ref-pattern.rs:30:10
+ --> $DIR/borrowck-move-ref-pattern.rs:28:10
|
LL | let (ref _x0, _x1, ref _x2, ..) = tup;
| --- value moved here
@@ -131,7 +131,7 @@ LL | drop(tup.1);
= note: move occurs because `tup.1` has type `U`, which does not implement the `Copy` trait
error[E0382]: borrow of moved value: `tup.1`
- --> $DIR/borrowck-move-ref-pattern.rs:31:20
+ --> $DIR/borrowck-move-ref-pattern.rs:29:20
|
LL | drop(tup.1);
| ----- value moved here
@@ -141,7 +141,7 @@ LL | let _x1_hold = &tup.1;
= note: move occurs because `tup.1` has type `U`, which does not implement the `Copy` trait
error[E0502]: cannot borrow `tup.3` as immutable because it is also borrowed as mutable
- --> $DIR/borrowck-move-ref-pattern.rs:33:20
+ --> $DIR/borrowck-move-ref-pattern.rs:31:20
|
LL | let (.., ref mut _x3) = tup;
| ----------- mutable borrow occurs here
@@ -152,7 +152,7 @@ LL | drop(_x3);
| --- mutable borrow later used here
error[E0499]: cannot borrow `tup.3` as mutable more than once at a time
- --> $DIR/borrowck-move-ref-pattern.rs:34:20
+ --> $DIR/borrowck-move-ref-pattern.rs:32:20
|
LL | let (.., ref mut _x3) = tup;
| ----------- first mutable borrow occurs here
@@ -164,7 +164,7 @@ LL | drop(_x3);
| --- first borrow later used here
error[E0499]: cannot borrow `tup.3` as mutable more than once at a time
- --> $DIR/borrowck-move-ref-pattern.rs:35:14
+ --> $DIR/borrowck-move-ref-pattern.rs:33:14
|
LL | let (.., ref mut _x3) = tup;
| ----------- first mutable borrow occurs here
@@ -176,7 +176,7 @@ LL | drop(_x3);
| --- first borrow later used here
error[E0502]: cannot borrow `tup.3` as immutable because it is also borrowed as mutable
- --> $DIR/borrowck-move-ref-pattern.rs:36:14
+ --> $DIR/borrowck-move-ref-pattern.rs:34:14
|
LL | let (.., ref mut _x3) = tup;
| ----------- mutable borrow occurs here
@@ -187,7 +187,7 @@ LL | drop(_x3);
| --- mutable borrow later used here
error[E0382]: use of moved value: `tup`
- --> $DIR/borrowck-move-ref-pattern.rs:45:14
+ --> $DIR/borrowck-move-ref-pattern.rs:43:14
|
LL | let mut tup = (U, U, U);
| ------- move occurs because `tup` has type `(U, U, U)`, which does not implement the `Copy` trait
diff --git a/src/test/ui/pattern/move-ref-patterns/by-move-sub-pat-unreachable.rs b/src/test/ui/pattern/move-ref-patterns/by-move-sub-pat-unreachable.rs
index 08fb5cd2e1688..18663c3fe3f96 100644
--- a/src/test/ui/pattern/move-ref-patterns/by-move-sub-pat-unreachable.rs
+++ b/src/test/ui/pattern/move-ref-patterns/by-move-sub-pat-unreachable.rs
@@ -4,7 +4,6 @@
// check-pass
-#![feature(move_ref_pattern)]
#![feature(bindings_after_at)]
fn main() {
diff --git a/src/test/ui/pattern/move-ref-patterns/feature-gate-move_ref_pattern.rs b/src/test/ui/pattern/move-ref-patterns/feature-gate-move_ref_pattern.rs
deleted file mode 100644
index fb92eb1ba32e0..0000000000000
--- a/src/test/ui/pattern/move-ref-patterns/feature-gate-move_ref_pattern.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-fn main() {
- #[derive(Clone)]
- struct X {
- x: (),
- }
- let mut tup = (X { x: () }, X { x: () });
- match Some(tup.clone()) {
- Some((y, ref z)) => {}
- //~^ ERROR binding by-move and by-ref in the same pattern is unstable
- None => panic!(),
- }
-
- let (ref a, b) = tup.clone();
- //~^ ERROR binding by-move and by-ref in the same pattern is unstable
-
- let (a, mut b) = &tup;
- //~^ ERROR binding by-move and by-ref in the same pattern is unstable
- //~| ERROR cannot move out of a shared reference
-
- let (mut a, b) = &mut tup;
- //~^ ERROR binding by-move and by-ref in the same pattern is unstable
- //~| ERROR cannot move out of a mutable reference
-}
diff --git a/src/test/ui/pattern/move-ref-patterns/feature-gate-move_ref_pattern.stderr b/src/test/ui/pattern/move-ref-patterns/feature-gate-move_ref_pattern.stderr
deleted file mode 100644
index 5335569a972b2..0000000000000
--- a/src/test/ui/pattern/move-ref-patterns/feature-gate-move_ref_pattern.stderr
+++ /dev/null
@@ -1,66 +0,0 @@
-error[E0658]: binding by-move and by-ref in the same pattern is unstable
- --> $DIR/feature-gate-move_ref_pattern.rs:8:15
- |
-LL | Some((y, ref z)) => {}
- | ^ ----- by-ref pattern here
- | |
- | by-move pattern here
- |
- = note: see issue #68354 <https://github.com/rust-lang/rust/issues/68354> for more information
- = help: add `#![feature(move_ref_pattern)]` to the crate attributes to enable
-
-error[E0658]: binding by-move and by-ref in the same pattern is unstable
- --> $DIR/feature-gate-move_ref_pattern.rs:13:17
- |
-LL | let (ref a, b) = tup.clone();
- | ----- ^ by-move pattern here
- | |
- | by-ref pattern here
- |
- = note: see issue #68354 <https://github.com/rust-lang/rust/issues/68354> for more information
- = help: add `#![feature(move_ref_pattern)]` to the crate attributes to enable
-
-error[E0658]: binding by-move and by-ref in the same pattern is unstable
- --> $DIR/feature-gate-move_ref_pattern.rs:16:13
- |
-LL | let (a, mut b) = &tup;
- | - ^^^^^ by-move pattern here
- | |
- | by-ref pattern here
- |
- = note: see issue #68354 <https://github.com/rust-lang/rust/issues/68354> for more information
- = help: add `#![feature(move_ref_pattern)]` to the crate attributes to enable
-
-error[E0658]: binding by-move and by-ref in the same pattern is unstable
- --> $DIR/feature-gate-move_ref_pattern.rs:20:10
- |
-LL | let (mut a, b) = &mut tup;
- | ^^^^^ - by-ref pattern here
- | |
- | by-move pattern here
- |
- = note: see issue #68354 <https://github.com/rust-lang/rust/issues/68354> for more information
- = help: add `#![feature(move_ref_pattern)]` to the crate attributes to enable
-
-error[E0507]: cannot move out of a shared reference
- --> $DIR/feature-gate-move_ref_pattern.rs:16:22
- |
-LL | let (a, mut b) = &tup;
- | ----- ^^^^
- | |
- | data moved here
- | move occurs because `b` has type `X`, which does not implement the `Copy` trait
-
-error[E0507]: cannot move out of a mutable reference
- --> $DIR/feature-gate-move_ref_pattern.rs:20:22
- |
-LL | let (mut a, b) = &mut tup;
- | ----- ^^^^^^^^
- | |
- | data moved here
- | move occurs because `a` has type `X`, which does not implement the `Copy` trait
-
-error: aborting due to 6 previous errors
-
-Some errors have detailed explanations: E0507, E0658.
-For more information about an error, try `rustc --explain E0507`.
diff --git a/src/test/ui/pattern/move-ref-patterns/issue-53840.rs b/src/test/ui/pattern/move-ref-patterns/issue-53840.rs
index ab7d10d9f837d..80effc497ed93 100644
--- a/src/test/ui/pattern/move-ref-patterns/issue-53840.rs
+++ b/src/test/ui/pattern/move-ref-patterns/issue-53840.rs
@@ -1,7 +1,5 @@
// check-pass
-#![feature(move_ref_pattern)]
-
enum E {
Foo(String, String, String),
}
diff --git a/src/test/ui/pattern/move-ref-patterns/move-ref-patterns-closure-captures-inside.rs b/src/test/ui/pattern/move-ref-patterns/move-ref-patterns-closure-captures-inside.rs
index 4c3ca62e16586..ebb1683af7de6 100644
--- a/src/test/ui/pattern/move-ref-patterns/move-ref-patterns-closure-captures-inside.rs
+++ b/src/test/ui/pattern/move-ref-patterns/move-ref-patterns-closure-captures-inside.rs
@@ -1,5 +1,3 @@
-#![feature(move_ref_pattern)]
-
fn main() {
struct S; // Not `Copy`.
diff --git a/src/test/ui/pattern/move-ref-patterns/move-ref-patterns-closure-captures-inside.stderr b/src/test/ui/pattern/move-ref-patterns/move-ref-patterns-closure-captures-inside.stderr
index 9ad84879595e7..f19fed0891740 100644
--- a/src/test/ui/pattern/move-ref-patterns/move-ref-patterns-closure-captures-inside.stderr
+++ b/src/test/ui/pattern/move-ref-patterns/move-ref-patterns-closure-captures-inside.stderr
@@ -1,5 +1,5 @@
error[E0382]: borrow of moved value: `tup0`
- --> $DIR/move-ref-patterns-closure-captures-inside.rs:33:10
+ --> $DIR/move-ref-patterns-closure-captures-inside.rs:31:10
|
LL | let mut tup0 = (S, S);
| -------- move occurs because `tup0` has type `(S, S)`, which does not implement the `Copy` trait
@@ -14,7 +14,7 @@ LL | drop(&tup0);
| ^^^^^ value borrowed here after move
error[E0382]: borrow of moved value: `tup1`
- --> $DIR/move-ref-patterns-closure-captures-inside.rs:34:10
+ --> $DIR/move-ref-patterns-closure-captures-inside.rs:32:10
|
LL | let mut tup1 = (S, S, S);
| -------- move occurs because `tup1` has type `(S, S, S)`, which does not implement the `Copy` trait
@@ -29,7 +29,7 @@ LL | drop(&tup1);
| ^^^^^ value borrowed here after move
error[E0382]: borrow of moved value: `tup2`
- --> $DIR/move-ref-patterns-closure-captures-inside.rs:35:10
+ --> $DIR/move-ref-patterns-closure-captures-inside.rs:33:10
|
LL | let tup2 = (S, S);
| ---- move occurs because `tup2` has type `(S, S)`, which does not implement the `Copy` trait
@@ -44,7 +44,7 @@ LL | drop(&tup2);
| ^^^^^ value borrowed here after move
error[E0382]: borrow of moved value: `tup3`
- --> $DIR/move-ref-patterns-closure-captures-inside.rs:36:10
+ --> $DIR/move-ref-patterns-closure-captures-inside.rs:34:10
|
LL | let tup3 = (S, S, S);
| ---- move occurs because `tup3` has type `(S, S, S)`, which does not implement the `Copy` trait
@@ -59,7 +59,7 @@ LL | drop(&tup3);
| ^^^^^ value borrowed here after move
error[E0382]: borrow of moved value: `tup4`
- --> $DIR/move-ref-patterns-closure-captures-inside.rs:41:10
+ --> $DIR/move-ref-patterns-closure-captures-inside.rs:39:10
|
LL | let tup4 = (S, S);
| ---- move occurs because `tup4` has type `(S, S)`, which does not implement the `Copy` trait
@@ -74,7 +74,7 @@ LL | drop(&tup4.0);
| ^^^^^^^ value borrowed here after move
error[E0382]: borrow of moved value: `arr0`
- --> $DIR/move-ref-patterns-closure-captures-inside.rs:43:10
+ --> $DIR/move-ref-patterns-closure-captures-inside.rs:41:10
|
LL | let mut arr0 = [S, S, S];
| -------- move occurs because `arr0` has type `[S; 3]`, which does not implement the `Copy` trait
@@ -89,7 +89,7 @@ LL | drop(&arr0);
| ^^^^^ value borrowed here after move
error[E0382]: borrow of moved value: `arr1`
- --> $DIR/move-ref-patterns-closure-captures-inside.rs:44:36
+ --> $DIR/move-ref-patterns-closure-captures-inside.rs:42:36
|
LL | let mut arr1 = [S, S, S, S, S];
| -------- move occurs because `arr1` has type `[S; 5]`, which does not implement the `Copy` trait
@@ -104,7 +104,7 @@ LL | let [_, mov1, mov2, mov3, _] = &arr1;
| ^^^^^ value borrowed here after move
error[E0382]: borrow of moved value: `arr2`
- --> $DIR/move-ref-patterns-closure-captures-inside.rs:45:10
+ --> $DIR/move-ref-patterns-closure-captures-inside.rs:43:10
|
LL | let arr2 = [S, S, S];
| ---- move occurs because `arr2` has type `[S; 3]`, which does not implement the `Copy` trait
@@ -119,7 +119,7 @@ LL | drop(&arr2);
| ^^^^^ value borrowed here after move
error[E0382]: borrow of moved value: `arr3`
- --> $DIR/move-ref-patterns-closure-captures-inside.rs:46:36
+ --> $DIR/move-ref-patterns-closure-captures-inside.rs:44:36
|
LL | let arr3 = [S, S, S, S, S];
| ---- move occurs because `arr3` has type `[S; 5]`, which does not implement the `Copy` trait
@@ -134,7 +134,7 @@ LL | let [_, mov1, mov2, mov3, _] = &arr3;
| ^^^^^ value borrowed here after move
error[E0382]: borrow of moved value: `tup0`
- --> $DIR/move-ref-patterns-closure-captures-inside.rs:77:10
+ --> $DIR/move-ref-patterns-closure-captures-inside.rs:75:10
|
LL | let mut tup0: Option<(S, S)> = None;
| -------- move occurs because `tup0` has type `Option<(S, S)>`, which does not implement the `Copy` trait
@@ -148,7 +148,7 @@ LL | drop(&tup0);
| ^^^^^ value borrowed here after move
error[E0382]: borrow of moved value: `tup1`
- --> $DIR/move-ref-patterns-closure-captures-inside.rs:78:10
+ --> $DIR/move-ref-patterns-closure-captures-inside.rs:76:10
|
LL | let mut tup1: Option<(S, S, S)> = None;
| -------- move occurs because `tup1` has type `Option<(S, S, S)>`, which does not implement the `Copy` trait
@@ -163,7 +163,7 @@ LL | drop(&tup1);
| ^^^^^ value borrowed here after move
error[E0382]: borrow of moved value: `tup2`
- --> $DIR/move-ref-patterns-closure-captures-inside.rs:79:10
+ --> $DIR/move-ref-patterns-closure-captures-inside.rs:77:10
|
LL | let tup2: Option<(S, S)> = None;
| ---- move occurs because `tup2` has type `Option<(S, S)>`, which does not implement the `Copy` trait
@@ -178,7 +178,7 @@ LL | drop(&tup2);
| ^^^^^ value borrowed here after move
error[E0382]: borrow of moved value: `tup3`
- --> $DIR/move-ref-patterns-closure-captures-inside.rs:80:10
+ --> $DIR/move-ref-patterns-closure-captures-inside.rs:78:10
|
LL | let tup3: Option<(S, S, S)> = None;
| ---- move occurs because `tup3` has type `Option<(S, S, S)>`, which does not implement the `Copy` trait
@@ -193,7 +193,7 @@ LL | drop(&tup3);
| ^^^^^ value borrowed here after move
error[E0382]: borrow of moved value: `tup4`
- --> $DIR/move-ref-patterns-closure-captures-inside.rs:81:21
+ --> $DIR/move-ref-patterns-closure-captures-inside.rs:79:21
|
LL | let tup4: Option<(S, S)> = None;
| ---- move occurs because `tup4` has type `Option<(S, S)>`, which does not implement the `Copy` trait
@@ -208,7 +208,7 @@ LL | m!((ref x, _) = &tup4);
| ^^^^^ value borrowed here after move
error[E0382]: borrow of moved value: `arr0`
- --> $DIR/move-ref-patterns-closure-captures-inside.rs:82:10
+ --> $DIR/move-ref-patterns-closure-captures-inside.rs:80:10
|
LL | let mut arr0: Option<[S; 3]> = None;
| -------- move occurs because `arr0` has type `Option<[S; 3]>`, which does not implement the `Copy` trait
@@ -223,7 +223,7 @@ LL | drop(&arr0);
| ^^^^^ value borrowed here after move
error[E0382]: borrow of moved value: `arr1`
- --> $DIR/move-ref-patterns-closure-captures-inside.rs:83:35
+ --> $DIR/move-ref-patterns-closure-captures-inside.rs:81:35
|
LL | let mut arr1: Option<[S; 5]> = None;
| -------- move occurs because `arr1` has type `Option<[S; 5]>`, which does not implement the `Copy` trait
@@ -238,7 +238,7 @@ LL | m!([_, mov1, mov2, mov3, _] = &arr1);
| ^^^^^ value borrowed here after move
error[E0382]: borrow of moved value: `arr2`
- --> $DIR/move-ref-patterns-closure-captures-inside.rs:84:10
+ --> $DIR/move-ref-patterns-closure-captures-inside.rs:82:10
|
LL | let arr2: Option<[S; 3]> = None;
| ---- move occurs because `arr2` has type `Option<[S; 3]>`, which does not implement the `Copy` trait
@@ -253,7 +253,7 @@ LL | drop(&arr2);
| ^^^^^ value borrowed here after move
error[E0382]: borrow of moved value: `arr3`
- --> $DIR/move-ref-patterns-closure-captures-inside.rs:85:35
+ --> $DIR/move-ref-patterns-closure-captures-inside.rs:83:35
|
LL | let arr3: Option<[S; 5]> = None;
| ---- move occurs because `arr3` has type `Option<[S; 5]>`, which does not implement the `Copy` trait
@@ -267,7 +267,7 @@ LL | m!([_, mov1, mov2, mov3, _] = &arr3);
| ^^^^^ value borrowed here after move
error[E0382]: borrow of moved value: `tup0`
- --> $DIR/move-ref-patterns-closure-captures-inside.rs:113:10
+ --> $DIR/move-ref-patterns-closure-captures-inside.rs:111:10
|
LL | let mut tup0: Option<(S, S)> = None;
| -------- move occurs because `tup0` has type `Option<(S, S)>`, which does not implement the `Copy` trait
@@ -281,7 +281,7 @@ LL | drop(&tup0);
| ^^^^^ value borrowed here after move
error[E0382]: borrow of moved value: `tup1`
- --> $DIR/move-ref-patterns-closure-captures-inside.rs:114:10
+ --> $DIR/move-ref-patterns-closure-captures-inside.rs:112:10
|
LL | let mut tup1: Option<(S, S, S)> = None;
| -------- move occurs because `tup1` has type `Option<(S, S, S)>`, which does not implement the `Copy` trait
@@ -296,7 +296,7 @@ LL | drop(&tup1);
| ^^^^^ value borrowed here after move
error[E0382]: borrow of moved value: `tup2`
- --> $DIR/move-ref-patterns-closure-captures-inside.rs:115:10
+ --> $DIR/move-ref-patterns-closure-captures-inside.rs:113:10
|
LL | let tup2: Option<(S, S)> = None;
| ---- move occurs because `tup2` has type `Option<(S, S)>`, which does not implement the `Copy` trait
@@ -311,7 +311,7 @@ LL | drop(&tup2);
| ^^^^^ value borrowed here after move
error[E0382]: borrow of moved value: `tup3`
- --> $DIR/move-ref-patterns-closure-captures-inside.rs:116:10
+ --> $DIR/move-ref-patterns-closure-captures-inside.rs:114:10
|
LL | let tup3: Option<(S, S, S)> = None;
| ---- move occurs because `tup3` has type `Option<(S, S, S)>`, which does not implement the `Copy` trait
@@ -326,7 +326,7 @@ LL | drop(&tup3);
| ^^^^^ value borrowed here after move
error[E0382]: borrow of moved value: `tup4`
- --> $DIR/move-ref-patterns-closure-captures-inside.rs:117:21
+ --> $DIR/move-ref-patterns-closure-captures-inside.rs:115:21
|
LL | let tup4: Option<(S, S)> = None;
| ---- move occurs because `tup4` has type `Option<(S, S)>`, which does not implement the `Copy` trait
@@ -341,7 +341,7 @@ LL | m!((ref x, _) = &tup4);
| ^^^^^ value borrowed here after move
error[E0382]: borrow of moved value: `arr0`
- --> $DIR/move-ref-patterns-closure-captures-inside.rs:118:10
+ --> $DIR/move-ref-patterns-closure-captures-inside.rs:116:10
|
LL | let mut arr0: Option<[S; 3]> = None;
| -------- move occurs because `arr0` has type `Option<[S; 3]>`, which does not implement the `Copy` trait
@@ -356,7 +356,7 @@ LL | drop(&arr0);
| ^^^^^ value borrowed here after move
error[E0382]: borrow of moved value: `arr1`
- --> $DIR/move-ref-patterns-closure-captures-inside.rs:119:35
+ --> $DIR/move-ref-patterns-closure-captures-inside.rs:117:35
|
LL | let mut arr1: Option<[S; 5]> = None;
| -------- move occurs because `arr1` has type `Option<[S; 5]>`, which does not implement the `Copy` trait
@@ -371,7 +371,7 @@ LL | m!([_, mov1, mov2, mov3, _] = &arr1);
| ^^^^^ value borrowed here after move
error[E0382]: borrow of moved value: `arr2`
- --> $DIR/move-ref-patterns-closure-captures-inside.rs:120:10
+ --> $DIR/move-ref-patterns-closure-captures-inside.rs:118:10
|
LL | let arr2: Option<[S; 3]> = None;
| ---- move occurs because `arr2` has type `Option<[S; 3]>`, which does not implement the `Copy` trait
@@ -386,7 +386,7 @@ LL | drop(&arr2);
| ^^^^^ value borrowed here after move
error[E0382]: borrow of moved value: `arr3`
- --> $DIR/move-ref-patterns-closure-captures-inside.rs:121:35
+ --> $DIR/move-ref-patterns-closure-captures-inside.rs:119:35
|
LL | let arr3: Option<[S; 5]> = None;
| ---- move occurs because `arr3` has type `Option<[S; 5]>`, which does not implement the `Copy` trait
diff --git a/src/test/ui/pattern/move-ref-patterns/move-ref-patterns-closure-captures-pass.rs b/src/test/ui/pattern/move-ref-patterns/move-ref-patterns-closure-captures-pass.rs
index e1844d36e4aa4..583f70f41aa70 100644
--- a/src/test/ui/pattern/move-ref-patterns/move-ref-patterns-closure-captures-pass.rs
+++ b/src/test/ui/pattern/move-ref-patterns/move-ref-patterns-closure-captures-pass.rs
@@ -1,7 +1,5 @@
// check-pass
-#![feature(move_ref_pattern)]
-
fn main() {
struct U;
fn accept_fn_once(_: impl FnOnce()) {}
diff --git a/src/test/ui/pattern/move-ref-patterns/move-ref-patterns-closure-captures.rs b/src/test/ui/pattern/move-ref-patterns/move-ref-patterns-closure-captures.rs
index 7f1c02c05cb0d..cd619cc41eb27 100644
--- a/src/test/ui/pattern/move-ref-patterns/move-ref-patterns-closure-captures.rs
+++ b/src/test/ui/pattern/move-ref-patterns/move-ref-patterns-closure-captures.rs
@@ -1,5 +1,3 @@
-#![feature(move_ref_pattern)]
-
fn main() {
struct U;
fn accept_fn_once(_: &impl FnOnce()) {}
diff --git a/src/test/ui/pattern/move-ref-patterns/move-ref-patterns-closure-captures.stderr b/src/test/ui/pattern/move-ref-patterns/move-ref-patterns-closure-captures.stderr
index ca82353c1c9ab..d96e863939c02 100644
--- a/src/test/ui/pattern/move-ref-patterns/move-ref-patterns-closure-captures.stderr
+++ b/src/test/ui/pattern/move-ref-patterns/move-ref-patterns-closure-captures.stderr
@@ -1,5 +1,5 @@
error[E0525]: expected a closure that implements the `FnMut` trait, but this closure only implements `FnOnce`
- --> $DIR/move-ref-patterns-closure-captures.rs:11:14
+ --> $DIR/move-ref-patterns-closure-captures.rs:9:14
|
LL | let c1 = || {
| ^^ this closure implements `FnOnce`, not `FnMut`
@@ -11,7 +11,7 @@ LL | accept_fn_mut(&c1);
| ------------- the requirement to implement `FnMut` derives from here
error[E0525]: expected a closure that implements the `Fn` trait, but this closure only implements `FnOnce`
- --> $DIR/move-ref-patterns-closure-captures.rs:11:14
+ --> $DIR/move-ref-patterns-closure-captures.rs:9:14
|
LL | let c1 = || {
| ^^ this closure implements `FnOnce`, not `Fn`
@@ -23,7 +23,7 @@ LL | accept_fn(&c1);
| --------- the requirement to implement `Fn` derives from here
error[E0525]: expected a closure that implements the `Fn` trait, but this closure only implements `FnMut`
- --> $DIR/move-ref-patterns-closure-captures.rs:22:14
+ --> $DIR/move-ref-patterns-closure-captures.rs:20:14
|
LL | let c2 = || {
| ^^ this closure implements `FnMut`, not `Fn`
diff --git a/src/test/ui/pattern/move-ref-patterns/move-ref-patterns-default-binding-modes.rs b/src/test/ui/pattern/move-ref-patterns/move-ref-patterns-default-binding-modes.rs
index 5c51c47d9798a..1dd66aad57a33 100644
--- a/src/test/ui/pattern/move-ref-patterns/move-ref-patterns-default-binding-modes.rs
+++ b/src/test/ui/pattern/move-ref-patterns/move-ref-patterns-default-binding-modes.rs
@@ -1,5 +1,3 @@
-#![feature(move_ref_pattern)]
-
fn main() {
struct U;
diff --git a/src/test/ui/pattern/move-ref-patterns/move-ref-patterns-default-binding-modes.stderr b/src/test/ui/pattern/move-ref-patterns/move-ref-patterns-default-binding-modes.stderr
index f92699f5c3cc7..6952c743a3069 100644
--- a/src/test/ui/pattern/move-ref-patterns/move-ref-patterns-default-binding-modes.stderr
+++ b/src/test/ui/pattern/move-ref-patterns/move-ref-patterns-default-binding-modes.stderr
@@ -1,5 +1,5 @@
error[E0507]: cannot move out of a shared reference
- --> $DIR/move-ref-patterns-default-binding-modes.rs:10:22
+ --> $DIR/move-ref-patterns-default-binding-modes.rs:8:22
|
LL | let (a, mut b) = &p;
| ----- ^^
@@ -8,7 +8,7 @@ LL | let (a, mut b) = &p;
| move occurs because `b` has type `U`, which does not implement the `Copy` trait
error[E0507]: cannot move out of a mutable reference
- --> $DIR/move-ref-patterns-default-binding-modes.rs:14:22
+ --> $DIR/move-ref-patterns-default-binding-modes.rs:12:22
|
LL | let (a, mut b) = &mut p;
| ----- ^^^^^^
diff --git a/src/test/ui/pattern/move-ref-patterns/move-ref-patterns-dynamic-semantics.rs b/src/test/ui/pattern/move-ref-patterns/move-ref-patterns-dynamic-semantics.rs
index c78695390b598..1d6d9acead1d4 100644
--- a/src/test/ui/pattern/move-ref-patterns/move-ref-patterns-dynamic-semantics.rs
+++ b/src/test/ui/pattern/move-ref-patterns/move-ref-patterns-dynamic-semantics.rs
@@ -3,8 +3,6 @@
// This test checks the dynamic semantics and drop order of pattern matching
// where a product pattern has both a by-move and by-ref binding.
-#![feature(move_ref_pattern)]
-
use std::cell::RefCell;
use std::rc::Rc;
diff --git a/src/test/ui/proc-macro/invalid-punct-ident-1.rs b/src/test/ui/proc-macro/invalid-punct-ident-1.rs
index 3f78dea917b19..a3133a1a79070 100644
--- a/src/test/ui/proc-macro/invalid-punct-ident-1.rs
+++ b/src/test/ui/proc-macro/invalid-punct-ident-1.rs
@@ -9,6 +9,9 @@
// normalize-stderr-test "note: we would appreciate a bug report.*\n\n" -> ""
// normalize-stderr-test "note: compiler flags.*\n\n" -> ""
// normalize-stderr-test "note: rustc.*running on.*\n\n" -> ""
+// normalize-stderr-test "query stack during panic:\n" -> ""
+// normalize-stderr-test "we're just showing a limited slice of the query stack\n" -> ""
+// normalize-stderr-test "end of query stack\n" -> ""
#[macro_use]
extern crate invalid_punct_ident;
diff --git a/src/test/ui/proc-macro/invalid-punct-ident-1.stderr b/src/test/ui/proc-macro/invalid-punct-ident-1.stderr
index fc821d29d5a0c..5ef22709cb371 100644
--- a/src/test/ui/proc-macro/invalid-punct-ident-1.stderr
+++ b/src/test/ui/proc-macro/invalid-punct-ident-1.stderr
@@ -1,5 +1,5 @@
error: proc macro panicked
- --> $DIR/invalid-punct-ident-1.rs:16:1
+ --> $DIR/invalid-punct-ident-1.rs:19:1
|
LL | invalid_punct!();
| ^^^^^^^^^^^^^^^^^
diff --git a/src/test/ui/proc-macro/invalid-punct-ident-2.rs b/src/test/ui/proc-macro/invalid-punct-ident-2.rs
index 4e89e80ae7c41..04a0a8733115a 100644
--- a/src/test/ui/proc-macro/invalid-punct-ident-2.rs
+++ b/src/test/ui/proc-macro/invalid-punct-ident-2.rs
@@ -9,6 +9,9 @@
// normalize-stderr-test "note: we would appreciate a bug report.*\n\n" -> ""
// normalize-stderr-test "note: compiler flags.*\n\n" -> ""
// normalize-stderr-test "note: rustc.*running on.*\n\n" -> ""
+// normalize-stderr-test "query stack during panic:\n" -> ""
+// normalize-stderr-test "we're just showing a limited slice of the query stack\n" -> ""
+// normalize-stderr-test "end of query stack\n" -> ""
#[macro_use]
extern crate invalid_punct_ident;
diff --git a/src/test/ui/proc-macro/invalid-punct-ident-2.stderr b/src/test/ui/proc-macro/invalid-punct-ident-2.stderr
index 8b30edaf85c09..4bd7a5351d3a0 100644
--- a/src/test/ui/proc-macro/invalid-punct-ident-2.stderr
+++ b/src/test/ui/proc-macro/invalid-punct-ident-2.stderr
@@ -1,5 +1,5 @@
error: proc macro panicked
- --> $DIR/invalid-punct-ident-2.rs:16:1
+ --> $DIR/invalid-punct-ident-2.rs:19:1
|
LL | invalid_ident!();
| ^^^^^^^^^^^^^^^^^
diff --git a/src/test/ui/proc-macro/invalid-punct-ident-3.rs b/src/test/ui/proc-macro/invalid-punct-ident-3.rs
index 8d8ce8f932e71..aebba341625ae 100644
--- a/src/test/ui/proc-macro/invalid-punct-ident-3.rs
+++ b/src/test/ui/proc-macro/invalid-punct-ident-3.rs
@@ -9,6 +9,9 @@
// normalize-stderr-test "note: we would appreciate a bug report.*\n\n" -> ""
// normalize-stderr-test "note: compiler flags.*\n\n" -> ""
// normalize-stderr-test "note: rustc.*running on.*\n\n" -> ""
+// normalize-stderr-test "query stack during panic:\n" -> ""
+// normalize-stderr-test "we're just showing a limited slice of the query stack\n" -> ""
+// normalize-stderr-test "end of query stack\n" -> ""
#[macro_use]
extern crate invalid_punct_ident;
diff --git a/src/test/ui/proc-macro/invalid-punct-ident-3.stderr b/src/test/ui/proc-macro/invalid-punct-ident-3.stderr
index d46fab08e14f0..072d13956ac6c 100644
--- a/src/test/ui/proc-macro/invalid-punct-ident-3.stderr
+++ b/src/test/ui/proc-macro/invalid-punct-ident-3.stderr
@@ -1,5 +1,5 @@
error: proc macro panicked
- --> $DIR/invalid-punct-ident-3.rs:16:1
+ --> $DIR/invalid-punct-ident-3.rs:19:1
|
LL | invalid_raw_ident!();
| ^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/test/ui/proc-macro/load-panic-backtrace.rs b/src/test/ui/proc-macro/load-panic-backtrace.rs
index 90fe109abb8f0..4a3ba9aee7453 100644
--- a/src/test/ui/proc-macro/load-panic-backtrace.rs
+++ b/src/test/ui/proc-macro/load-panic-backtrace.rs
@@ -10,6 +10,9 @@
// normalize-stderr-test "note: we would appreciate a bug report.*\n\n" -> ""
// normalize-stderr-test "note: compiler flags.*\n\n" -> ""
// normalize-stderr-test "note: rustc.*running on.*\n\n" -> ""
+// normalize-stderr-test "query stack during panic:\n" -> ""
+// normalize-stderr-test "we're just showing a limited slice of the query stack\n" -> ""
+// normalize-stderr-test "end of query stack\n" -> ""
#[macro_use]
extern crate test_macros;
diff --git a/src/test/ui/proc-macro/load-panic-backtrace.stderr b/src/test/ui/proc-macro/load-panic-backtrace.stderr
index 63378b5735a3c..f825047e33168 100644
--- a/src/test/ui/proc-macro/load-panic-backtrace.stderr
+++ b/src/test/ui/proc-macro/load-panic-backtrace.stderr
@@ -1,6 +1,6 @@
at 'panic-derive', $DIR/auxiliary/test-macros.rs:43:5
error: proc-macro derive panicked
- --> $DIR/load-panic-backtrace.rs:17:10
+ --> $DIR/load-panic-backtrace.rs:20:10
|
LL | #[derive(Panic)]
| ^^^^^
diff --git a/src/test/ui/rfc-2005-default-binding-mode/for.rs b/src/test/ui/rfc-2005-default-binding-mode/for.rs
index aa42c7bb9c2f1..d6c5a13b1bdb0 100644
--- a/src/test/ui/rfc-2005-default-binding-mode/for.rs
+++ b/src/test/ui/rfc-2005-default-binding-mode/for.rs
@@ -1,5 +1,3 @@
-#![feature(move_ref_pattern)]
-
struct Foo {}
pub fn main() {
diff --git a/src/test/ui/rfc-2005-default-binding-mode/for.stderr b/src/test/ui/rfc-2005-default-binding-mode/for.stderr
index ef62431388081..9cc20a7bf3144 100644
--- a/src/test/ui/rfc-2005-default-binding-mode/for.stderr
+++ b/src/test/ui/rfc-2005-default-binding-mode/for.stderr
@@ -1,5 +1,5 @@
error[E0507]: cannot move out of a shared reference
- --> $DIR/for.rs:8:23
+ --> $DIR/for.rs:6:23
|
LL | for (n, mut m) in &tups {
| ----- ^^^^^
diff --git a/src/test/ui/symbol-names/issue-75326.legacy.stderr b/src/test/ui/symbol-names/issue-75326.legacy.stderr
new file mode 100644
index 0000000000000..5f822f6660c09
--- /dev/null
+++ b/src/test/ui/symbol-names/issue-75326.legacy.stderr
@@ -0,0 +1,20 @@
+error: symbol-name(_ZN72_$LT$issue_75326..Foo$LT$I$C$E$GT$$u20$as$u20$issue_75326..Iterator2$GT$4next17SYMBOL_HASH)
+ --> $DIR/issue-75326.rs:43:5
+ |
+LL | #[rustc_symbol_name]
+ | ^^^^^^^^^^^^^^^^^^^^
+
+error: demangling(<issue_75326::Foo<I,E> as issue_75326::Iterator2>::next::SYMBOL_HASH)
+ --> $DIR/issue-75326.rs:43:5
+ |
+LL | #[rustc_symbol_name]
+ | ^^^^^^^^^^^^^^^^^^^^
+
+error: demangling-alt(<issue_75326::Foo<I,E> as issue_75326::Iterator2>::next)
+ --> $DIR/issue-75326.rs:43:5
+ |
+LL | #[rustc_symbol_name]
+ | ^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 3 previous errors
+
diff --git a/src/test/ui/symbol-names/issue-75326.rs b/src/test/ui/symbol-names/issue-75326.rs
new file mode 100644
index 0000000000000..ce315164cefd3
--- /dev/null
+++ b/src/test/ui/symbol-names/issue-75326.rs
@@ -0,0 +1,58 @@
+// build-fail
+// ignore-tidy-linelength
+// revisions: legacy v0
+//[legacy]compile-flags: -Z symbol-mangling-version=legacy
+//[v0]compile-flags: -Z symbol-mangling-version=v0
+//[legacy]normalize-stderr-32bit: "h[\d\w]+" -> "SYMBOL_HASH"
+//[legacy]normalize-stderr-64bit: "h[\d\w]+" -> "SYMBOL_HASH"
+
+#![feature(rustc_attrs)]
+
+pub(crate) struct Foo<I, E>(I, E);
+
+pub trait Iterator2 {
+ type Item;
+
+ fn next(&mut self) -> Option<Self::Item>;
+
+ fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
+ where
+ Self: Sized,
+ P: FnMut(&Self::Item) -> bool,
+ {
+ unimplemented!()
+ }
+}
+
+struct Bar;
+
+impl Iterator2 for Bar {
+ type Item = (u32, u16);
+
+ fn next(&mut self) -> Option<Self::Item> {
+ unimplemented!()
+ }
+}
+
+impl<I, T, E> Iterator2 for Foo<I, E>
+where
+ I: Iterator2<Item = (T, E)>,
+{
+ type Item = T;
+
+ #[rustc_symbol_name]
+ //[legacy]~^ ERROR symbol-name(_ZN72_$LT$issue_75326..Foo$LT$I$C$E$GT$$u20$as$u20$issue_75326..Iterator2$GT$4next
+ //[legacy]~| ERROR demangling(<issue_75326::Foo<I,E> as issue_75326::Iterator2>::next
+ //[legacy]~| ERROR demangling-alt(<issue_75326::Foo<I,E> as issue_75326::Iterator2>::next)
+ //[v0]~^^^^ ERROR symbol-name(_RNvXINICs4fqI2P2rA04_11issue_75326s_0pppEINtB5_3FooppENtB5_9Iterator24nextB5_)
+ //[v0]~| ERROR demangling(<issue_75326[317d481089b8c8fe]::Foo<_, _> as issue_75326[317d481089b8c8fe]::Iterator2>::next)
+ //[v0]~| ERROR demangling-alt(<issue_75326::Foo<_, _> as issue_75326::Iterator2>::next)
+ fn next(&mut self) -> Option<Self::Item> {
+ self.find(|_| true)
+ }
+}
+
+fn main() {
+ let mut a = Foo(Bar, 1u16);
+ let _ = a.next();
+}
diff --git a/src/test/ui/symbol-names/issue-75326.v0.stderr b/src/test/ui/symbol-names/issue-75326.v0.stderr
new file mode 100644
index 0000000000000..59bdfa8ca3681
--- /dev/null
+++ b/src/test/ui/symbol-names/issue-75326.v0.stderr
@@ -0,0 +1,20 @@
+error: symbol-name(_RNvXINICs4fqI2P2rA04_11issue_75326s_0pppEINtB5_3FooppENtB5_9Iterator24nextB5_)
+ --> $DIR/issue-75326.rs:43:5
+ |
+LL | #[rustc_symbol_name]
+ | ^^^^^^^^^^^^^^^^^^^^
+
+error: demangling(<issue_75326[317d481089b8c8fe]::Foo<_, _> as issue_75326[317d481089b8c8fe]::Iterator2>::next)
+ --> $DIR/issue-75326.rs:43:5
+ |
+LL | #[rustc_symbol_name]
+ | ^^^^^^^^^^^^^^^^^^^^
+
+error: demangling-alt(<issue_75326::Foo<_, _> as issue_75326::Iterator2>::next)
+ --> $DIR/issue-75326.rs:43:5
+ |
+LL | #[rustc_symbol_name]
+ | ^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 3 previous errors
+
diff --git a/src/tools/clippy/src/driver.rs b/src/tools/clippy/src/driver.rs
index 377f6d2244635..805828eece1f2 100644
--- a/src/tools/clippy/src/driver.rs
+++ b/src/tools/clippy/src/driver.rs
@@ -277,9 +277,9 @@ fn report_clippy_ice(info: &panic::PanicInfo<'_>, bug_report_url: &str) {
// If backtraces are enabled, also print the query stack
let backtrace = env::var_os("RUST_BACKTRACE").map_or(false, |x| &x != "0");
- if backtrace {
- TyCtxt::try_print_query_stack(&handler);
- }
+ let num_frames = if backtrace { None } else { Some(2) };
+
+ TyCtxt::try_print_query_stack(&handler, num_frames);
}
fn toolchain_path(home: Option<String>, toolchain: Option<String>) -> Option<PathBuf> {
diff --git a/src/tools/clippy/tests/ui/custom_ice_message.stderr b/src/tools/clippy/tests/ui/custom_ice_message.stderr
index a9a65a38c109d..a1b8e2ee162cf 100644
--- a/src/tools/clippy/tests/ui/custom_ice_message.stderr
+++ b/src/tools/clippy/tests/ui/custom_ice_message.stderr
@@ -9,3 +9,5 @@ note: we would appreciate a bug report: https://github.com/rust-lang/rust-clippy
note: Clippy version: foo
+query stack during panic:
+end of query stack