diff --git a/compiler/rustc_ast/src/attr/mod.rs b/compiler/rustc_ast/src/attr/mod.rs
index 70ad43ecad219..ec87a88f4aba7 100644
--- a/compiler/rustc_ast/src/attr/mod.rs
+++ b/compiler/rustc_ast/src/attr/mod.rs
@@ -360,7 +360,7 @@ pub fn list_contains_name(items: &[NestedMetaItem], name: Symbol) -> bool {
impl MetaItem {
fn token_trees_and_spacings(&self) -> Vec<TreeAndSpacing> {
let mut idents = vec![];
- let mut last_pos = BytePos(0 as u32);
+ let mut last_pos = BytePos(0_u32);
for (i, segment) in self.path.segments.iter().enumerate() {
let is_first = i == 0;
if !is_first {
diff --git a/compiler/rustc_infer/src/infer/error_reporting/need_type_info.rs b/compiler/rustc_infer/src/infer/error_reporting/need_type_info.rs
index 21023a06bb2d9..868989539d4fd 100644
--- a/compiler/rustc_infer/src/infer/error_reporting/need_type_info.rs
+++ b/compiler/rustc_infer/src/infer/error_reporting/need_type_info.rs
@@ -739,7 +739,6 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
"cannot infer {} {} {} `{}`{}",
kind_str, preposition, descr, type_name, parent_desc
)
- .into()
}
}
}
diff --git a/compiler/rustc_interface/src/util.rs b/compiler/rustc_interface/src/util.rs
index 46a6c5861d59d..3ed7d20ae4571 100644
--- a/compiler/rustc_interface/src/util.rs
+++ b/compiler/rustc_interface/src/util.rs
@@ -246,10 +246,10 @@ pub fn get_codegen_backend(sopts: &config::Options) -> Box<dyn CodegenBackend> {
INIT.call_once(|| {
#[cfg(feature = "llvm")]
- const DEFAULT_CODEGEN_BACKEND: &'static str = "llvm";
+ const DEFAULT_CODEGEN_BACKEND: &str = "llvm";
#[cfg(not(feature = "llvm"))]
- const DEFAULT_CODEGEN_BACKEND: &'static str = "cranelift";
+ const DEFAULT_CODEGEN_BACKEND: &str = "cranelift";
let codegen_name = sopts
.debugging_opts
@@ -414,11 +414,10 @@ pub fn get_codegen_sysroot(backend_name: &str) -> fn() -> Box<dyn CodegenBackend
let libdir = filesearch::relative_target_lib_path(&sysroot, &target);
sysroot.join(libdir).with_file_name("codegen-backends")
})
- .filter(|f| {
+ .find(|f| {
info!("codegen backend candidate: {}", f.display());
f.exists()
- })
- .next();
+ });
let sysroot = sysroot.unwrap_or_else(|| {
let candidates = sysroot_candidates
.iter()
diff --git a/compiler/rustc_middle/src/middle/stability.rs b/compiler/rustc_middle/src/middle/stability.rs
index 1a206b245d37b..978f08927c6ef 100644
--- a/compiler/rustc_middle/src/middle/stability.rs
+++ b/compiler/rustc_middle/src/middle/stability.rs
@@ -399,7 +399,7 @@ impl<'tcx> TyCtxt<'tcx> {
def_id: DefId,
id: Option<HirId>,
span: Span,
- unmarked: impl FnOnce(Span, DefId) -> (),
+ unmarked: impl FnOnce(Span, DefId),
) {
let soft_handler = |lint, span, msg: &_| {
self.struct_span_lint_hir(lint, id.unwrap_or(hir::CRATE_HIR_ID), span, |lint| {
diff --git a/compiler/rustc_middle/src/mir/terminator.rs b/compiler/rustc_middle/src/mir/terminator.rs
index c9493c679879e..709ffc3049ab8 100644
--- a/compiler/rustc_middle/src/mir/terminator.rs
+++ b/compiler/rustc_middle/src/mir/terminator.rs
@@ -46,7 +46,7 @@ impl SwitchTargets {
pub fn new(targets: impl Iterator<Item = (u128, BasicBlock)>, otherwise: BasicBlock) -> Self {
let (values, mut targets): (SmallVec<_>, SmallVec<_>) = targets.unzip();
targets.push(otherwise);
- Self { values: values.into(), targets }
+ Self { values, targets }
}
/// Builds a switch targets definition that jumps to `then` if the tested value equals `value`,
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
index 0a7bec1a342f3..aa5a696b09c3b 100644
--- a/compiler/rustc_middle/src/ty/mod.rs
+++ b/compiler/rustc_middle/src/ty/mod.rs
@@ -1641,7 +1641,7 @@ pub type PlaceholderConst = Placeholder<BoundVar>;
#[derive(Hash, HashStable)]
pub struct WithOptConstParam<T> {
pub did: T,
- /// The `DefId` of the corresponding generic paramter in case `did` is
+ /// The `DefId` of the corresponding generic parameter in case `did` is
/// a const argument.
///
/// Note that even if `did` is a const argument, this may still be `None`.
diff --git a/compiler/rustc_mir/src/borrow_check/diagnostics/conflict_errors.rs b/compiler/rustc_mir/src/borrow_check/diagnostics/conflict_errors.rs
index dca0d6d7790d4..1474c7abfadaf 100644
--- a/compiler/rustc_mir/src/borrow_check/diagnostics/conflict_errors.rs
+++ b/compiler/rustc_mir/src/borrow_check/diagnostics/conflict_errors.rs
@@ -120,7 +120,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
let move_out = self.move_data.moves[(*move_site).moi];
let moved_place = &self.move_data.move_paths[move_out.path].place;
// `*(_1)` where `_1` is a `Box` is actually a move out.
- let is_box_move = moved_place.as_ref().projection == &[ProjectionElem::Deref]
+ let is_box_move = moved_place.as_ref().projection == [ProjectionElem::Deref]
&& self.body.local_decls[moved_place.local].ty.is_box();
!is_box_move
diff --git a/compiler/rustc_mir/src/transform/match_branches.rs b/compiler/rustc_mir/src/transform/match_branches.rs
index 06690dcbf6eb7..82c0b924f287e 100644
--- a/compiler/rustc_mir/src/transform/match_branches.rs
+++ b/compiler/rustc_mir/src/transform/match_branches.rs
@@ -63,7 +63,7 @@ impl<'tcx> MirPass<'tcx> for MatchBranchSimplification {
};
// Check that destinations are identical, and if not, then don't optimize this block
- if &bbs[first].terminator().kind != &bbs[second].terminator().kind {
+ if bbs[first].terminator().kind != bbs[second].terminator().kind {
continue;
}
diff --git a/compiler/rustc_resolve/src/late/diagnostics.rs b/compiler/rustc_resolve/src/late/diagnostics.rs
index a3e0028dc75d7..14f8c7b09f8e1 100644
--- a/compiler/rustc_resolve/src/late/diagnostics.rs
+++ b/compiler/rustc_resolve/src/late/diagnostics.rs
@@ -1886,9 +1886,8 @@ impl<'tcx> LifetimeContext<'_, 'tcx> {
if snippet.starts_with('&') && !snippet.starts_with("&'") {
introduce_suggestion
.push((param.span, format!("&'a {}", &snippet[1..])));
- } else if snippet.starts_with("&'_ ") {
- introduce_suggestion
- .push((param.span, format!("&'a {}", &snippet[4..])));
+ } else if let Some(stripped) = snippet.strip_prefix("&'_ ") {
+ introduce_suggestion.push((param.span, format!("&'a {}", &stripped)));
}
}
}
diff --git a/compiler/rustc_span/src/lib.rs b/compiler/rustc_span/src/lib.rs
index 97b5c11b0fefb..f52b64f488345 100644
--- a/compiler/rustc_span/src/lib.rs
+++ b/compiler/rustc_span/src/lib.rs
@@ -1574,7 +1574,7 @@ fn normalize_src(src: &mut String, start_pos: BytePos) -> Vec<NormalizedPos> {
/// Removes UTF-8 BOM, if any.
fn remove_bom(src: &mut String, normalized_pos: &mut Vec<NormalizedPos>) {
- if src.starts_with("\u{feff}") {
+ if src.starts_with('\u{feff}') {
src.drain(..3);
normalized_pos.push(NormalizedPos { pos: BytePos(0), diff: 3 });
}
diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs
index f8bd3ab96e254..2d57c39f7c7e1 100644
--- a/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs
+++ b/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs
@@ -1388,11 +1388,7 @@ impl<'a, 'tcx> InferCtxtPrivExt<'tcx> for InferCtxt<'a, 'tcx> {
trait_ref: &ty::PolyTraitRef<'tcx>,
) {
let get_trait_impl = |trait_def_id| {
- self.tcx.find_map_relevant_impl(
- trait_def_id,
- trait_ref.skip_binder().self_ty(),
- |impl_def_id| Some(impl_def_id),
- )
+ self.tcx.find_map_relevant_impl(trait_def_id, trait_ref.skip_binder().self_ty(), Some)
};
let required_trait_path = self.tcx.def_path_str(trait_ref.def_id());
let all_traits = self.tcx.all_traits(LOCAL_CRATE);
diff --git a/compiler/rustc_trait_selection/src/traits/fulfill.rs b/compiler/rustc_trait_selection/src/traits/fulfill.rs
index 9a8b5534dfe83..538c14c6b720e 100644
--- a/compiler/rustc_trait_selection/src/traits/fulfill.rs
+++ b/compiler/rustc_trait_selection/src/traits/fulfill.rs
@@ -499,7 +499,7 @@ impl<'a, 'b, 'tcx> FulfillProcessor<'a, 'b, 'tcx> {
Err(ErrorHandled::TooGeneric) => {
pending_obligation.stalled_on = substs
.iter()
- .filter_map(|ty| TyOrConstInferVar::maybe_from_generic_arg(ty))
+ .filter_map(TyOrConstInferVar::maybe_from_generic_arg)
.collect();
ProcessResult::Unchanged
}
diff --git a/library/alloc/tests/slice.rs b/library/alloc/tests/slice.rs
index 1f561bebd908b..a4f0fb415fb3c 100644
--- a/library/alloc/tests/slice.rs
+++ b/library/alloc/tests/slice.rs
@@ -1,5 +1,6 @@
use std::cell::Cell;
use std::cmp::Ordering::{self, Equal, Greater, Less};
+use std::convert::identity;
use std::mem;
use std::panic;
use std::rc::Rc;
@@ -1778,3 +1779,122 @@ fn repeat_generic_slice() {
assert_eq!([1, 2, 3, 4].repeat(1), vec![1, 2, 3, 4]);
assert_eq!([1, 2, 3, 4].repeat(3), vec![1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]);
}
+
+#[test]
+#[allow(unreachable_patterns)]
+fn subslice_patterns() {
+ // This test comprehensively checks the passing static and dynamic semantics
+ // of subslice patterns `..`, `x @ ..`, `ref x @ ..`, and `ref mut @ ..`
+ // in slice patterns `[$($pat), $(,)?]` .
+
+ #[derive(PartialEq, Debug, Clone)]
+ struct N(u8);
+
+ macro_rules! n {
+ ($($e:expr),* $(,)?) => {
+ [$(N($e)),*]
+ }
+ }
+
+ macro_rules! c {
+ ($inp:expr, $typ:ty, $out:expr $(,)?) => {
+ assert_eq!($out, identity::<$typ>($inp));
+ };
+ }
+
+ macro_rules! m {
+ ($e:expr, $p:pat => $b:expr) => {
+ match $e {
+ $p => $b,
+ _ => panic!(),
+ }
+ };
+ }
+
+ // == Slices ==
+
+ // Matching slices using `ref` patterns:
+ let mut v = vec![N(0), N(1), N(2), N(3), N(4)];
+ let mut vc = (0..=4).collect::<Vec<u8>>();
+
+ let [..] = v[..]; // Always matches.
+ m!(v[..], [N(0), ref sub @ .., N(4)] => c!(sub, &[N], n![1, 2, 3]));
+ m!(v[..], [N(0), ref sub @ ..] => c!(sub, &[N], n![1, 2, 3, 4]));
+ m!(v[..], [ref sub @ .., N(4)] => c!(sub, &[N], n![0, 1, 2, 3]));
+ m!(v[..], [ref sub @ .., _, _, _, _, _] => c!(sub, &[N], &n![] as &[N]));
+ m!(v[..], [_, _, _, _, _, ref sub @ ..] => c!(sub, &[N], &n![] as &[N]));
+ m!(vc[..], [x, .., y] => c!((x, y), (u8, u8), (0, 4)));
+
+ // Matching slices using `ref mut` patterns:
+ let [..] = v[..]; // Always matches.
+ m!(v[..], [N(0), ref mut sub @ .., N(4)] => c!(sub, &mut [N], n![1, 2, 3]));
+ m!(v[..], [N(0), ref mut sub @ ..] => c!(sub, &mut [N], n![1, 2, 3, 4]));
+ m!(v[..], [ref mut sub @ .., N(4)] => c!(sub, &mut [N], n![0, 1, 2, 3]));
+ m!(v[..], [ref mut sub @ .., _, _, _, _, _] => c!(sub, &mut [N], &mut n![] as &mut [N]));
+ m!(v[..], [_, _, _, _, _, ref mut sub @ ..] => c!(sub, &mut [N], &mut n![] as &mut [N]));
+ m!(vc[..], [x, .., y] => c!((x, y), (u8, u8), (0, 4)));
+
+ // Matching slices using default binding modes (&):
+ let [..] = &v[..]; // Always matches.
+ m!(&v[..], [N(0), sub @ .., N(4)] => c!(sub, &[N], n![1, 2, 3]));
+ m!(&v[..], [N(0), sub @ ..] => c!(sub, &[N], n![1, 2, 3, 4]));
+ m!(&v[..], [sub @ .., N(4)] => c!(sub, &[N], n![0, 1, 2, 3]));
+ m!(&v[..], [sub @ .., _, _, _, _, _] => c!(sub, &[N], &n![] as &[N]));
+ m!(&v[..], [_, _, _, _, _, sub @ ..] => c!(sub, &[N], &n![] as &[N]));
+ m!(&vc[..], [x, .., y] => c!((x, y), (&u8, &u8), (&0, &4)));
+
+ // Matching slices using default binding modes (&mut):
+ let [..] = &mut v[..]; // Always matches.
+ m!(&mut v[..], [N(0), sub @ .., N(4)] => c!(sub, &mut [N], n![1, 2, 3]));
+ m!(&mut v[..], [N(0), sub @ ..] => c!(sub, &mut [N], n![1, 2, 3, 4]));
+ m!(&mut v[..], [sub @ .., N(4)] => c!(sub, &mut [N], n![0, 1, 2, 3]));
+ m!(&mut v[..], [sub @ .., _, _, _, _, _] => c!(sub, &mut [N], &mut n![] as &mut [N]));
+ m!(&mut v[..], [_, _, _, _, _, sub @ ..] => c!(sub, &mut [N], &mut n![] as &mut [N]));
+ m!(&mut vc[..], [x, .., y] => c!((x, y), (&mut u8, &mut u8), (&mut 0, &mut 4)));
+
+ // == Arrays ==
+ let mut v = n![0, 1, 2, 3, 4];
+ let vc = [0, 1, 2, 3, 4];
+
+ // Matching arrays by value:
+ m!(v.clone(), [N(0), sub @ .., N(4)] => c!(sub, [N; 3], n![1, 2, 3]));
+ m!(v.clone(), [N(0), sub @ ..] => c!(sub, [N; 4], n![1, 2, 3, 4]));
+ m!(v.clone(), [sub @ .., N(4)] => c!(sub, [N; 4], n![0, 1, 2, 3]));
+ m!(v.clone(), [sub @ .., _, _, _, _, _] => c!(sub, [N; 0], n![] as [N; 0]));
+ m!(v.clone(), [_, _, _, _, _, sub @ ..] => c!(sub, [N; 0], n![] as [N; 0]));
+ m!(v.clone(), [x, .., y] => c!((x, y), (N, N), (N(0), N(4))));
+ m!(v.clone(), [..] => ());
+
+ // Matching arrays by ref patterns:
+ m!(v, [N(0), ref sub @ .., N(4)] => c!(sub, &[N; 3], &n![1, 2, 3]));
+ m!(v, [N(0), ref sub @ ..] => c!(sub, &[N; 4], &n![1, 2, 3, 4]));
+ m!(v, [ref sub @ .., N(4)] => c!(sub, &[N; 4], &n![0, 1, 2, 3]));
+ m!(v, [ref sub @ .., _, _, _, _, _] => c!(sub, &[N; 0], &n![] as &[N; 0]));
+ m!(v, [_, _, _, _, _, ref sub @ ..] => c!(sub, &[N; 0], &n![] as &[N; 0]));
+ m!(vc, [x, .., y] => c!((x, y), (u8, u8), (0, 4)));
+
+ // Matching arrays by ref mut patterns:
+ m!(v, [N(0), ref mut sub @ .., N(4)] => c!(sub, &mut [N; 3], &mut n![1, 2, 3]));
+ m!(v, [N(0), ref mut sub @ ..] => c!(sub, &mut [N; 4], &mut n![1, 2, 3, 4]));
+ m!(v, [ref mut sub @ .., N(4)] => c!(sub, &mut [N; 4], &mut n![0, 1, 2, 3]));
+ m!(v, [ref mut sub @ .., _, _, _, _, _] => c!(sub, &mut [N; 0], &mut n![] as &mut [N; 0]));
+ m!(v, [_, _, _, _, _, ref mut sub @ ..] => c!(sub, &mut [N; 0], &mut n![] as &mut [N; 0]));
+
+ // Matching arrays by default binding modes (&):
+ m!(&v, [N(0), sub @ .., N(4)] => c!(sub, &[N; 3], &n![1, 2, 3]));
+ m!(&v, [N(0), sub @ ..] => c!(sub, &[N; 4], &n![1, 2, 3, 4]));
+ m!(&v, [sub @ .., N(4)] => c!(sub, &[N; 4], &n![0, 1, 2, 3]));
+ m!(&v, [sub @ .., _, _, _, _, _] => c!(sub, &[N; 0], &n![] as &[N; 0]));
+ m!(&v, [_, _, _, _, _, sub @ ..] => c!(sub, &[N; 0], &n![] as &[N; 0]));
+ m!(&v, [..] => ());
+ m!(&v, [x, .., y] => c!((x, y), (&N, &N), (&N(0), &N(4))));
+
+ // Matching arrays by default binding modes (&mut):
+ m!(&mut v, [N(0), sub @ .., N(4)] => c!(sub, &mut [N; 3], &mut n![1, 2, 3]));
+ m!(&mut v, [N(0), sub @ ..] => c!(sub, &mut [N; 4], &mut n![1, 2, 3, 4]));
+ m!(&mut v, [sub @ .., N(4)] => c!(sub, &mut [N; 4], &mut n![0, 1, 2, 3]));
+ m!(&mut v, [sub @ .., _, _, _, _, _] => c!(sub, &mut [N; 0], &mut n![] as &[N; 0]));
+ m!(&mut v, [_, _, _, _, _, sub @ ..] => c!(sub, &mut [N; 0], &mut n![] as &[N; 0]));
+ m!(&mut v, [..] => ());
+ m!(&mut v, [x, .., y] => c!((x, y), (&mut N, &mut N), (&mut N(0), &mut N(4))));
+}
diff --git a/library/alloc/tests/vec.rs b/library/alloc/tests/vec.rs
index 771a293b8e5d4..47ebe56f9fd3b 100644
--- a/library/alloc/tests/vec.rs
+++ b/library/alloc/tests/vec.rs
@@ -3,7 +3,7 @@ use std::cell::Cell;
use std::collections::TryReserveError::*;
use std::fmt::Debug;
use std::iter::InPlaceIterable;
-use std::mem::size_of;
+use std::mem::{size_of, swap};
use std::ops::Bound::*;
use std::panic::{catch_unwind, AssertUnwindSafe};
use std::rc::Rc;
@@ -1912,3 +1912,45 @@ fn test_vec_cycle_wrapped() {
c3.refs.v[0].set(Some(&c1));
c3.refs.v[1].set(Some(&c2));
}
+
+#[test]
+fn test_zero_sized_vec_push() {
+ const N: usize = 8;
+
+ for len in 0..N {
+ let mut tester = Vec::with_capacity(len);
+ assert_eq!(tester.len(), 0);
+ assert!(tester.capacity() >= len);
+ for _ in 0..len {
+ tester.push(());
+ }
+ assert_eq!(tester.len(), len);
+ assert_eq!(tester.iter().count(), len);
+ tester.clear();
+ }
+}
+
+#[test]
+fn test_vec_macro_repeat() {
+ assert_eq!(vec![1; 3], vec![1, 1, 1]);
+ assert_eq!(vec![1; 2], vec![1, 1]);
+ assert_eq!(vec![1; 1], vec![1]);
+ assert_eq!(vec![1; 0], vec![]);
+
+ // from_elem syntax (see RFC 832)
+ let el = Box::new(1);
+ let n = 3;
+ assert_eq!(vec![el; n], vec![Box::new(1), Box::new(1), Box::new(1)]);
+}
+
+#[test]
+fn test_vec_swap() {
+ let mut a: Vec<isize> = vec![0, 1, 2, 3, 4, 5, 6];
+ a.swap(2, 4);
+ assert_eq!(a[2], 4);
+ assert_eq!(a[4], 2);
+ let mut n = 42;
+ swap(&mut n, &mut a[0]);
+ assert_eq!(a[0], 42);
+ assert_eq!(n, 0);
+}
diff --git a/library/alloc/tests/vec_deque.rs b/library/alloc/tests/vec_deque.rs
index 05cb3a2c03d79..705f0d62fbb7a 100644
--- a/library/alloc/tests/vec_deque.rs
+++ b/library/alloc/tests/vec_deque.rs
@@ -1698,3 +1698,33 @@ fn test_binary_search_by_key() {
assert_eq!(deque.binary_search_by_key(&3, |&(v,)| v), Ok(2));
assert_eq!(deque.binary_search_by_key(&4, |&(v,)| v), Err(3));
}
+
+#[test]
+fn test_zero_sized_push() {
+ const N: usize = 8;
+
+ // Zero sized type
+ struct Zst;
+
+ // Test that for all possible sequences of push_front / push_back,
+ // we end up with a deque of the correct size
+
+ for len in 0..N {
+ let mut tester = VecDeque::with_capacity(len);
+ assert_eq!(tester.len(), 0);
+ assert!(tester.capacity() >= len);
+ for case in 0..(1 << len) {
+ assert_eq!(tester.len(), 0);
+ for bit in 0..len {
+ if case & (1 << bit) != 0 {
+ tester.push_front(Zst);
+ } else {
+ tester.push_back(Zst);
+ }
+ }
+ assert_eq!(tester.len(), len);
+ assert_eq!(tester.iter().count(), len);
+ tester.clear();
+ }
+ }
+}
diff --git a/library/core/src/array/mod.rs b/library/core/src/array/mod.rs
index 1d55a5ef659d4..123a191dd2cc2 100644
--- a/library/core/src/array/mod.rs
+++ b/library/core/src/array/mod.rs
@@ -353,8 +353,9 @@ impl<T: Ord, const N: usize> Ord for [T; N] {
}
}
-// The Default impls cannot be generated using the array_impls! macro because
-// they require array literals.
+// The Default impls cannot be done with const generics because `[T; 0]` doesn't
+// require Default to be implemented, and having different impl blocks for
+// different numbers isn't supported yet.
macro_rules! array_impl_default {
{$n:expr, $t:ident $($ts:ident)*} => {
diff --git a/library/core/src/cell.rs b/library/core/src/cell.rs
index 7140218fa9101..ef2a5dd570f73 100644
--- a/library/core/src/cell.rs
+++ b/library/core/src/cell.rs
@@ -1733,8 +1733,7 @@ impl<T: ?Sized> UnsafeCell<T> {
#[inline]
#[unstable(feature = "unsafe_cell_get_mut", issue = "76943")]
pub fn get_mut(&mut self) -> &mut T {
- // SAFETY: (outer) `&mut` guarantees unique access.
- unsafe { &mut *self.get() }
+ &mut self.value
}
/// Gets a mutable pointer to the wrapped value.
diff --git a/library/core/src/intrinsics.rs b/library/core/src/intrinsics.rs
index 3e5d7caa2fe5d..7d0ba97de6eba 100644
--- a/library/core/src/intrinsics.rs
+++ b/library/core/src/intrinsics.rs
@@ -719,7 +719,7 @@ extern "rust-intrinsic" {
/// macro, which panics when it is executed, it is *undefined behavior* to
/// reach code marked with this function.
///
- /// The stabilized version of this intrinsic is [`crate::hint::unreachable_unchecked`].
+ /// The stabilized version of this intrinsic is [`core::hint::unreachable_unchecked`](crate::hint::unreachable_unchecked).
#[rustc_const_unstable(feature = "const_unreachable_unchecked", issue = "53188")]
pub fn unreachable() -> !;
@@ -764,7 +764,7 @@ extern "rust-intrinsic" {
/// More specifically, this is the offset in bytes between successive
/// items of the same type, including alignment padding.
///
- /// The stabilized version of this intrinsic is [`crate::mem::size_of`].
+ /// The stabilized version of this intrinsic is [`core::mem::size_of`](crate::mem::size_of).
#[rustc_const_stable(feature = "const_size_of", since = "1.40.0")]
pub fn size_of<T>() -> usize;
@@ -772,12 +772,12 @@ extern "rust-intrinsic" {
///
/// Drop glue is not run on the destination.
///
- /// The stabilized version of this intrinsic is [`crate::ptr::write`].
+ /// The stabilized version of this intrinsic is [`core::ptr::write`](crate::ptr::write).
pub fn move_val_init<T>(dst: *mut T, src: T);
/// The minimum alignment of a type.
///
- /// The stabilized version of this intrinsic is [`crate::mem::align_of`].
+ /// The stabilized version of this intrinsic is [`core::mem::align_of`](crate::mem::align_of).
#[rustc_const_stable(feature = "const_min_align_of", since = "1.40.0")]
pub fn min_align_of<T>() -> usize;
/// The preferred alignment of a type.
@@ -793,13 +793,13 @@ extern "rust-intrinsic" {
pub fn size_of_val<T: ?Sized>(_: *const T) -> usize;
/// The required alignment of the referenced value.
///
- /// The stabilized version of this intrinsic is [`crate::mem::align_of_val`].
+ /// The stabilized version of this intrinsic is [`core::mem::align_of_val`](crate::mem::align_of_val).
#[rustc_const_unstable(feature = "const_align_of_val", issue = "46571")]
pub fn min_align_of_val<T: ?Sized>(_: *const T) -> usize;
/// Gets a static string slice containing the name of a type.
///
- /// The stabilized version of this intrinsic is [`crate::any::type_name`].
+ /// The stabilized version of this intrinsic is [`core::any::type_name`](crate::any::type_name).
#[rustc_const_unstable(feature = "const_type_name", issue = "63084")]
pub fn type_name<T: ?Sized>() -> &'static str;
@@ -807,7 +807,7 @@ extern "rust-intrinsic" {
/// function will return the same value for a type regardless of whichever
/// crate it is invoked in.
///
- /// The stabilized version of this intrinsic is [`crate::any::TypeId::of`].
+ /// The stabilized version of this intrinsic is [`core::any::TypeId::of`](crate::any::TypeId::of).
#[rustc_const_unstable(feature = "const_type_id", issue = "77125")]
pub fn type_id<T: ?Sized + 'static>() -> u64;
@@ -831,7 +831,7 @@ extern "rust-intrinsic" {
/// Gets a reference to a static `Location` indicating where it was called.
///
- /// Consider using [`crate::panic::Location::caller`] instead.
+ /// Consider using [`core::panic::Location::caller`](crate::panic::Location::caller) instead.
#[rustc_const_unstable(feature = "const_caller_location", issue = "76156")]
pub fn caller_location() -> &'static crate::panic::Location<'static>;
@@ -1152,11 +1152,11 @@ extern "rust-intrinsic" {
/// Performs a volatile load from the `src` pointer.
///
- /// The stabilized version of this intrinsic is [`crate::ptr::read_volatile`].
+ /// The stabilized version of this intrinsic is [`core::ptr::read_volatile`](crate::ptr::read_volatile).
pub fn volatile_load<T>(src: *const T) -> T;
/// Performs a volatile store to the `dst` pointer.
///
- /// The stabilized version of this intrinsic is [`crate::ptr::write_volatile`].
+ /// The stabilized version of this intrinsic is [`core::ptr::write_volatile`](crate::ptr::write_volatile).
pub fn volatile_store<T>(dst: *mut T, val: T);
/// Performs a volatile load from the `src` pointer
@@ -1697,7 +1697,7 @@ extern "rust-intrinsic" {
/// Returns the value of the discriminant for the variant in 'v',
/// cast to a `u64`; if `T` has no discriminant, returns 0.
///
- /// The stabilized version of this intrinsic is [`crate::mem::discriminant`].
+ /// The stabilized version of this intrinsic is [`core::mem::discriminant`](crate::mem::discriminant).
#[rustc_const_unstable(feature = "const_discriminant", issue = "69821")]
pub fn discriminant_value<T>(v: &T) -> <T as DiscriminantKind>::Discriminant;
diff --git a/library/core/tests/num/mod.rs b/library/core/tests/num/mod.rs
index 378c8af344b59..190528fd445bf 100644
--- a/library/core/tests/num/mod.rs
+++ b/library/core/tests/num/mod.rs
@@ -27,6 +27,8 @@ mod bignum;
mod dec2flt;
mod flt2dec;
+mod nan;
+
/// Adds the attribute to all items in the block.
macro_rules! cfg_block {
($(#[$attr:meta]{$($it:item)*})*) => {$($(
diff --git a/src/test/ui/format-nan.rs b/library/core/tests/num/nan.rs
similarity index 78%
rename from src/test/ui/format-nan.rs
rename to library/core/tests/num/nan.rs
index e4a134fa2fbe0..011ffa790beee 100644
--- a/src/test/ui/format-nan.rs
+++ b/library/core/tests/num/nan.rs
@@ -1,7 +1,6 @@
-// run-pass
-
-pub fn main() {
- use std::f64;
+#[test]
+fn test_nan() {
+ use core::f64;
let x = "NaN".to_string();
assert_eq!(format!("{}", f64::NAN), x);
assert_eq!(format!("{:e}", f64::NAN), x);
diff --git a/library/core/tests/ops.rs b/library/core/tests/ops.rs
index 3c83f0f230003..8f0cd3be4066e 100644
--- a/library/core/tests/ops.rs
+++ b/library/core/tests/ops.rs
@@ -1,6 +1,6 @@
use core::ops::{Bound, Range, RangeFrom, RangeFull, RangeInclusive, RangeTo};
-// Test the Range structs without the syntactic sugar.
+// Test the Range structs and syntax.
#[test]
fn test_range() {
@@ -94,3 +94,60 @@ fn test_bound_cloned_included() {
fn test_bound_cloned_excluded() {
assert_eq!(Bound::Excluded(&3).cloned(), Bound::Excluded(3));
}
+
+#[test]
+#[allow(unused_comparisons)]
+#[allow(unused_mut)]
+fn test_range_syntax() {
+ let mut count = 0;
+ for i in 0_usize..10 {
+ assert!(i >= 0 && i < 10);
+ count += i;
+ }
+ assert_eq!(count, 45);
+
+ let mut count = 0;
+ let mut range = 0_usize..10;
+ for i in range {
+ assert!(i >= 0 && i < 10);
+ count += i;
+ }
+ assert_eq!(count, 45);
+
+ let mut count = 0;
+ let mut rf = 3_usize..;
+ for i in rf.take(10) {
+ assert!(i >= 3 && i < 13);
+ count += i;
+ }
+ assert_eq!(count, 75);
+
+ let _ = 0_usize..4 + 4 - 3;
+
+ fn foo() -> isize {
+ 42
+ }
+ let _ = 0..foo();
+
+ let _ = { &42..&100 }; // references to literals are OK
+ let _ = ..42_usize;
+
+ // Test we can use two different types with a common supertype.
+ let x = &42;
+ {
+ let y = 42;
+ let _ = x..&y;
+ }
+}
+
+#[test]
+#[allow(dead_code)]
+fn test_range_syntax_in_return_statement() {
+ fn return_range_to() -> RangeTo<i32> {
+ return ..1;
+ }
+ fn return_full_range() -> RangeFull {
+ return ..;
+ }
+ // Not much to test.
+}
diff --git a/library/proc_macro/src/lib.rs b/library/proc_macro/src/lib.rs
index 5a4b69cf6fc1b..03733d3b3edac 100644
--- a/library/proc_macro/src/lib.rs
+++ b/library/proc_macro/src/lib.rs
@@ -882,7 +882,7 @@ impl Ident {
}
/// Returns the span of this `Ident`, encompassing the entire string returned
- /// by `as_str`.
+ /// by [`to_string`](Self::to_string).
#[stable(feature = "proc_macro_lib2", since = "1.29.0")]
pub fn span(&self) -> Span {
Span(self.0.span())
diff --git a/library/std/src/keyword_docs.rs b/library/std/src/keyword_docs.rs
index 9b704ee9ecab2..b990b78570393 100644
--- a/library/std/src/keyword_docs.rs
+++ b/library/std/src/keyword_docs.rs
@@ -15,18 +15,24 @@
/// ```
///
/// In general, any cast that can be performed via ascribing the type can also be done using `as`,
-/// so instead of writing `let x: u32 = 123`, you can write `let x = 123 as u32` (Note: `let x: u32
-/// = 123` would be best in that situation). The same is not true in the other direction, however,
+/// so instead of writing `let x: u32 = 123`, you can write `let x = 123 as u32` (note: `let x: u32
+/// = 123` would be best in that situation). The same is not true in the other direction, however;
/// explicitly using `as` allows a few more coercions that aren't allowed implicitly, such as
/// changing the type of a raw pointer or turning closures into raw pointers.
///
-/// Other places `as` is used include as extra syntax for [`crate`] and `use`, to change the name
-/// something is imported as.
+/// `as` is also used to rename imports in [`use`] and [`extern crate`] statements:
///
-/// For more information on what `as` is capable of, see the [Reference]
+/// ```
+/// # #[allow(unused_imports)]
+/// use std::{mem as memory, net as network};
+/// // Now you can use the names `memory` and `network` to refer to `std::mem` and `std::net`.
+/// ```
+///
+/// For more information on what `as` is capable of, see the [Reference].
///
/// [Reference]: ../reference/expressions/operator-expr.html#type-cast-expressions
-/// [`crate`]: keyword.crate.html
+/// [`use`]: keyword.use.html
+/// [`extern crate`]: keyword.crate.html
mod as_keyword {}
#[doc(keyword = "break")]
@@ -397,6 +403,7 @@ mod enum_keyword {}
/// [Rust book]:
/// ../book/ch19-01-unsafe-rust.html#using-extern-functions-to-call-external-code
/// [Reference]: ../reference/items/external-blocks.html
+/// [`crate`]: keyword.crate.html
mod extern_keyword {}
#[doc(keyword = "false")]
diff --git a/library/std/src/primitive_docs.rs b/library/std/src/primitive_docs.rs
index ae678479234a8..83a282c8cd6b5 100644
--- a/library/std/src/primitive_docs.rs
+++ b/library/std/src/primitive_docs.rs
@@ -389,7 +389,7 @@ mod prim_unit {}
//
/// Raw, unsafe pointers, `*const T`, and `*mut T`.
///
-/// *[See also the `std::ptr` module][`ptr`].*
+/// *[See also the `std::ptr` module](ptr).*
///
/// Working with raw pointers in Rust is uncommon, typically limited to a few patterns.
/// Raw pointers can be unaligned or [`null`]. However, when a raw pointer is
@@ -491,6 +491,8 @@ mod prim_pointer {}
///
/// Arrays of *any* size implement the following traits if the element type allows it:
///
+/// - [`Copy`]
+/// - [`Clone`]
/// - [`Debug`]
/// - [`IntoIterator`] (implemented for `&[T; N]` and `&mut [T; N]`)
/// - [`PartialEq`], [`PartialOrd`], [`Eq`], [`Ord`]
@@ -498,15 +500,10 @@ mod prim_pointer {}
/// - [`AsRef`], [`AsMut`]
/// - [`Borrow`], [`BorrowMut`]
///
-/// Arrays of sizes from 0 to 32 (inclusive) implement [`Default`] trait
+/// Arrays of sizes from 0 to 32 (inclusive) implement the [`Default`] trait
/// if the element type allows it. As a stopgap, trait implementations are
/// statically generated up to size 32.
///
-/// Arrays of *any* size are [`Copy`] if the element type is [`Copy`]
-/// and [`Clone`] if the element type is [`Clone`]. This works
-/// because [`Copy`] and [`Clone`] traits are specially known
-/// to the compiler.
-///
/// Arrays coerce to [slices (`[T]`)][slice], so a slice method may be called on
/// an array. Indeed, this provides most of the API for working with arrays.
/// Slices have a dynamic size and do not coerce to arrays.
@@ -580,7 +577,7 @@ mod prim_array {}
/// means that elements are laid out so that every element is the same
/// distance from its neighbors.
///
-/// *[See also the `std::slice` module][`crate::slice`].*
+/// *[See also the `std::slice` module](crate::slice).*
///
/// Slices are a view into a block of memory represented as a pointer and a
/// length.
@@ -625,7 +622,7 @@ mod prim_slice {}
//
/// String slices.
///
-/// *[See also the `std::str` module][`crate::str`].*
+/// *[See also the `std::str` module](crate::str).*
///
/// The `str` type, also called a 'string slice', is the most primitive string
/// type. It is usually seen in its borrowed form, `&str`. It is also the type
@@ -800,7 +797,7 @@ mod prim_tuple {}
/// calculation with floats round to a nearby representable number. For example,
/// `5.0` and `1.0` can be exactly represented as `f32`, but `1.0 / 5.0` results
/// in `0.20000000298023223876953125` since `0.2` cannot be exactly represented
-/// as `f32`. Note however, that printing floats with `println` and friends will
+/// as `f32`. Note, however, that printing floats with `println` and friends will
/// often discard insignificant digits: `println!("{}", 1.0f32 / 5.0f32)` will
/// print `0.2`.
///
@@ -820,7 +817,7 @@ mod prim_tuple {}
///
/// For more information on floating point numbers, see [Wikipedia][wikipedia].
///
-/// *[See also the `std::f32::consts` module][`crate::f32::consts`].*
+/// *[See also the `std::f32::consts` module](crate::f32::consts).*
///
/// [wikipedia]: https://en.wikipedia.org/wiki/Single-precision_floating-point_format
#[stable(feature = "rust1", since = "1.0.0")]
@@ -834,7 +831,7 @@ mod prim_f32 {}
/// `f32`][`f32`] or [Wikipedia on double precision
/// values][wikipedia] for more information.
///
-/// *[See also the `std::f64::consts` module][`crate::f64::consts`].*
+/// *[See also the `std::f64::consts` module](crate::f64::consts).*
///
/// [`f32`]: prim@f32
/// [wikipedia]: https://en.wikipedia.org/wiki/Double-precision_floating-point_format
diff --git a/src/librustdoc/html/layout.rs b/src/librustdoc/html/layout.rs
index b089bcb0862a5..db73af7ec1689 100644
--- a/src/librustdoc/html/layout.rs
+++ b/src/librustdoc/html/layout.rs
@@ -79,12 +79,12 @@ pub fn render<T: Print, S: Print>(
{sidebar}\
</nav>\
<div class=\"theme-picker\">\
- <button id=\"theme-picker\" aria-label=\"Pick another theme!\">\
+ <button id=\"theme-picker\" aria-label=\"Pick another theme!\" aria-haspopup=\"menu\">\
<img src=\"{static_root_path}brush{suffix}.svg\" \
width=\"18\" \
alt=\"Pick another theme!\">\
</button>\
- <div id=\"theme-choices\"></div>\
+ <div id=\"theme-choices\" role=\"menu\"></div>\
</div>\
<script src=\"{static_root_path}theme{suffix}.js\"></script>\
<nav class=\"sub\">\
diff --git a/src/librustdoc/html/render/mod.rs b/src/librustdoc/html/render/mod.rs
index 0621eafd91347..5ac0ffcfbf1c2 100644
--- a/src/librustdoc/html/render/mod.rs
+++ b/src/librustdoc/html/render/mod.rs
@@ -798,10 +798,10 @@ function handleThemeButtonsBlur(e) {{
var active = document.activeElement;
var related = e.relatedTarget;
- if (active.id !== "themePicker" &&
+ if (active.id !== "theme-picker" &&
(!active.parentNode || active.parentNode.id !== "theme-choices") &&
(!related ||
- (related.id !== "themePicker" &&
+ (related.id !== "theme-picker" &&
(!related.parentNode || related.parentNode.id !== "theme-choices")))) {{
hideThemeButtonState();
}}
diff --git a/src/librustdoc/html/static/main.js b/src/librustdoc/html/static/main.js
index 28bd1ba5247d6..de4792a5bd2f7 100644
--- a/src/librustdoc/html/static/main.js
+++ b/src/librustdoc/html/static/main.js
@@ -4,6 +4,7 @@
// Local js definitions:
/* global addClass, getCurrentValue, hasClass */
/* global onEachLazy, hasOwnProperty, removeClass, updateLocalStorage */
+/* global hideThemeButtonState, showThemeButtonState */
if (!String.prototype.startsWith) {
String.prototype.startsWith = function(searchString, position) {
@@ -47,6 +48,14 @@ function getSearchElement() {
return document.getElementById("search");
}
+function getThemesElement() {
+ return document.getElementById("theme-choices");
+}
+
+function getThemePickerElement() {
+ return document.getElementById("theme-picker");
+}
+
// Sets the focus on the search bar at the top of the page
function focusSearchBar() {
getSearchInput().focus();
@@ -137,10 +146,6 @@ function defocusSearchBar() {
sidebar.appendChild(div);
}
}
- var themePickers = document.getElementsByClassName("theme-picker");
- if (themePickers && themePickers.length > 0) {
- themePickers[0].style.display = "none";
- }
}
function hideSidebar() {
@@ -155,10 +160,6 @@ function defocusSearchBar() {
filler.remove();
}
document.getElementsByTagName("body")[0].style.marginTop = "";
- var themePickers = document.getElementsByClassName("theme-picker");
- if (themePickers && themePickers.length > 0) {
- themePickers[0].style.display = null;
- }
}
function showSearchResults(search) {
@@ -376,6 +377,7 @@ function defocusSearchBar() {
document.title = titleBeforeSearch;
}
defocusSearchBar();
+ hideThemeButtonState();
}
function handleShortcut(ev) {
@@ -412,7 +414,57 @@ function defocusSearchBar() {
case "?":
displayHelp(true, ev);
break;
+
+ default:
+ var themePicker = getThemePickerElement();
+ if (themePicker.parentNode.contains(ev.target)) {
+ handleThemeKeyDown(ev);
+ }
+ }
+ }
+ }
+
+ function handleThemeKeyDown(ev) {
+ var active = document.activeElement;
+ var themes = getThemesElement();
+ switch (getVirtualKey(ev)) {
+ case "ArrowUp":
+ ev.preventDefault();
+ if (active.previousElementSibling && ev.target.id !== "theme-picker") {
+ active.previousElementSibling.focus();
+ } else {
+ showThemeButtonState();
+ themes.lastElementChild.focus();
+ }
+ break;
+ case "ArrowDown":
+ ev.preventDefault();
+ if (active.nextElementSibling && ev.target.id !== "theme-picker") {
+ active.nextElementSibling.focus();
+ } else {
+ showThemeButtonState();
+ themes.firstElementChild.focus();
+ }
+ break;
+ case "Enter":
+ case "Return":
+ case "Space":
+ if (ev.target.id === "theme-picker" && themes.style.display === "none") {
+ ev.preventDefault();
+ showThemeButtonState();
+ themes.firstElementChild.focus();
}
+ break;
+ case "Home":
+ ev.preventDefault();
+ themes.firstElementChild.focus();
+ break;
+ case "End":
+ ev.preventDefault();
+ themes.lastElementChild.focus();
+ break;
+ // The escape key is handled in handleEscape, not here,
+ // so that pressing escape will close the menu even if it isn't focused
}
}
diff --git a/src/test/rustdoc/impl-everywhere.rs b/src/test/rustdoc/impl-everywhere.rs
index 9d86dd3c29e98..742813262589b 100644
--- a/src/test/rustdoc/impl-everywhere.rs
+++ b/src/test/rustdoc/impl-everywhere.rs
@@ -8,23 +8,23 @@ pub struct Bar;
impl Foo for Bar {}
impl Foo2 for Bar {}
-// @!has foo/fn.foo.html '//section[@id="main"]//pre' "x: &\'x impl Foo"
-// @!has foo/fn.foo.html '//section[@id="main"]//pre' "-> &\'x impl Foo {"
+// @has foo/fn.foo.html '//section[@id="main"]//pre' "x: &'x impl Foo"
+// @has foo/fn.foo.html '//section[@id="main"]//pre' "-> &'x impl Foo"
pub fn foo<'x>(x: &'x impl Foo) -> &'x impl Foo {
x
}
-// @!has foo/fn.foo2.html '//section[@id="main"]//pre' "x: &\'x impl Foo"
-// @!has foo/fn.foo2.html '//section[@id="main"]//pre' '-> impl Foo2 {'
+// @has foo/fn.foo2.html '//section[@id="main"]//pre' "x: &'x impl Foo"
+// @has foo/fn.foo2.html '//section[@id="main"]//pre' '-> impl Foo2'
pub fn foo2<'x>(_x: &'x impl Foo) -> impl Foo2 {
Bar
}
-// @!has foo/fn.foo_foo.html '//section[@id="main"]//pre' '-> impl Foo + Foo2 {'
+// @has foo/fn.foo_foo.html '//section[@id="main"]//pre' '-> impl Foo + Foo2'
pub fn foo_foo() -> impl Foo + Foo2 {
Bar
}
-// @!has foo/fn.foo2.html '//section[@id="main"]//pre' "x: &'x (impl Foo + Foo2)"
+// @has foo/fn.foo_foo_foo.html '//section[@id="main"]//pre' "x: &'x impl Foo + Foo2"
pub fn foo_foo_foo<'x>(_x: &'x (impl Foo + Foo2)) {
}
diff --git a/src/test/ui/array-slice-vec/subslice-patterns-pass.rs b/src/test/ui/array-slice-vec/subslice-patterns-pass.rs
deleted file mode 100644
index e05790911f52d..0000000000000
--- a/src/test/ui/array-slice-vec/subslice-patterns-pass.rs
+++ /dev/null
@@ -1,126 +0,0 @@
-// This test comprehensively checks the passing static and dynamic semantics
-// of subslice patterns `..`, `x @ ..`, `ref x @ ..`, and `ref mut @ ..`
-// in slice patterns `[$($pat), $(,)?]` .
-
-// run-pass
-
-#![allow(unreachable_patterns)]
-
-use std::convert::identity;
-
-#[derive(PartialEq, Debug, Clone)]
-struct N(u8);
-
-macro_rules! n {
- ($($e:expr),* $(,)?) => {
- [$(N($e)),*]
- }
-}
-
-macro_rules! c {
- ($inp:expr, $typ:ty, $out:expr $(,)?) => {
- assert_eq!($out, identity::<$typ>($inp));
- }
-}
-
-macro_rules! m {
- ($e:expr, $p:pat => $b:expr) => {
- match $e {
- $p => $b,
- _ => panic!(),
- }
- }
-}
-
-fn main() {
- slices();
- arrays();
-}
-
-fn slices() {
- // Matching slices using `ref` patterns:
- let mut v = vec![N(0), N(1), N(2), N(3), N(4)];
- let mut vc = (0..=4).collect::<Vec<u8>>();
-
- let [..] = v[..]; // Always matches.
- m!(v[..], [N(0), ref sub @ .., N(4)] => c!(sub, &[N], n![1, 2, 3]));
- m!(v[..], [N(0), ref sub @ ..] => c!(sub, &[N], n![1, 2, 3, 4]));
- m!(v[..], [ref sub @ .., N(4)] => c!(sub, &[N], n![0, 1, 2, 3]));
- m!(v[..], [ref sub @ .., _, _, _, _, _] => c!(sub, &[N], &n![] as &[N]));
- m!(v[..], [_, _, _, _, _, ref sub @ ..] => c!(sub, &[N], &n![] as &[N]));
- m!(vc[..], [x, .., y] => c!((x, y), (u8, u8), (0, 4)));
-
- // Matching slices using `ref mut` patterns:
- let [..] = v[..]; // Always matches.
- m!(v[..], [N(0), ref mut sub @ .., N(4)] => c!(sub, &mut [N], n![1, 2, 3]));
- m!(v[..], [N(0), ref mut sub @ ..] => c!(sub, &mut [N], n![1, 2, 3, 4]));
- m!(v[..], [ref mut sub @ .., N(4)] => c!(sub, &mut [N], n![0, 1, 2, 3]));
- m!(v[..], [ref mut sub @ .., _, _, _, _, _] => c!(sub, &mut [N], &mut n![] as &mut [N]));
- m!(v[..], [_, _, _, _, _, ref mut sub @ ..] => c!(sub, &mut [N], &mut n![] as &mut [N]));
- m!(vc[..], [x, .., y] => c!((x, y), (u8, u8), (0, 4)));
-
- // Matching slices using default binding modes (&):
- let [..] = &v[..]; // Always matches.
- m!(&v[..], [N(0), sub @ .., N(4)] => c!(sub, &[N], n![1, 2, 3]));
- m!(&v[..], [N(0), sub @ ..] => c!(sub, &[N], n![1, 2, 3, 4]));
- m!(&v[..], [sub @ .., N(4)] => c!(sub, &[N], n![0, 1, 2, 3]));
- m!(&v[..], [sub @ .., _, _, _, _, _] => c!(sub, &[N], &n![] as &[N]));
- m!(&v[..], [_, _, _, _, _, sub @ ..] => c!(sub, &[N], &n![] as &[N]));
- m!(&vc[..], [x, .., y] => c!((x, y), (&u8, &u8), (&0, &4)));
-
- // Matching slices using default binding modes (&mut):
- let [..] = &mut v[..]; // Always matches.
- m!(&mut v[..], [N(0), sub @ .., N(4)] => c!(sub, &mut [N], n![1, 2, 3]));
- m!(&mut v[..], [N(0), sub @ ..] => c!(sub, &mut [N], n![1, 2, 3, 4]));
- m!(&mut v[..], [sub @ .., N(4)] => c!(sub, &mut [N], n![0, 1, 2, 3]));
- m!(&mut v[..], [sub @ .., _, _, _, _, _] => c!(sub, &mut [N], &mut n![] as &mut [N]));
- m!(&mut v[..], [_, _, _, _, _, sub @ ..] => c!(sub, &mut [N], &mut n![] as &mut [N]));
- m!(&mut vc[..], [x, .., y] => c!((x, y), (&mut u8, &mut u8), (&mut 0, &mut 4)));
-}
-
-fn arrays() {
- let mut v = n![0, 1, 2, 3, 4];
- let vc = [0, 1, 2, 3, 4];
-
- // Matching arrays by value:
- m!(v.clone(), [N(0), sub @ .., N(4)] => c!(sub, [N; 3], n![1, 2, 3]));
- m!(v.clone(), [N(0), sub @ ..] => c!(sub, [N; 4], n![1, 2, 3, 4]));
- m!(v.clone(), [sub @ .., N(4)] => c!(sub, [N; 4], n![0, 1, 2, 3]));
- m!(v.clone(), [sub @ .., _, _, _, _, _] => c!(sub, [N; 0], n![] as [N; 0]));
- m!(v.clone(), [_, _, _, _, _, sub @ ..] => c!(sub, [N; 0], n![] as [N; 0]));
- m!(v.clone(), [x, .., y] => c!((x, y), (N, N), (N(0), N(4))));
- m!(v.clone(), [..] => ());
-
- // Matching arrays by ref patterns:
- m!(v, [N(0), ref sub @ .., N(4)] => c!(sub, &[N; 3], &n![1, 2, 3]));
- m!(v, [N(0), ref sub @ ..] => c!(sub, &[N; 4], &n![1, 2, 3, 4]));
- m!(v, [ref sub @ .., N(4)] => c!(sub, &[N; 4], &n![0, 1, 2, 3]));
- m!(v, [ref sub @ .., _, _, _, _, _] => c!(sub, &[N; 0], &n![] as &[N; 0]));
- m!(v, [_, _, _, _, _, ref sub @ ..] => c!(sub, &[N; 0], &n![] as &[N; 0]));
- m!(vc, [x, .., y] => c!((x, y), (u8, u8), (0, 4)));
-
- // Matching arrays by ref mut patterns:
- m!(v, [N(0), ref mut sub @ .., N(4)] => c!(sub, &mut [N; 3], &mut n![1, 2, 3]));
- m!(v, [N(0), ref mut sub @ ..] => c!(sub, &mut [N; 4], &mut n![1, 2, 3, 4]));
- m!(v, [ref mut sub @ .., N(4)] => c!(sub, &mut [N; 4], &mut n![0, 1, 2, 3]));
- m!(v, [ref mut sub @ .., _, _, _, _, _] => c!(sub, &mut [N; 0], &mut n![] as &mut [N; 0]));
- m!(v, [_, _, _, _, _, ref mut sub @ ..] => c!(sub, &mut [N; 0], &mut n![] as &mut [N; 0]));
-
- // Matching arrays by default binding modes (&):
- m!(&v, [N(0), sub @ .., N(4)] => c!(sub, &[N; 3], &n![1, 2, 3]));
- m!(&v, [N(0), sub @ ..] => c!(sub, &[N; 4], &n![1, 2, 3, 4]));
- m!(&v, [sub @ .., N(4)] => c!(sub, &[N; 4], &n![0, 1, 2, 3]));
- m!(&v, [sub @ .., _, _, _, _, _] => c!(sub, &[N; 0], &n![] as &[N; 0]));
- m!(&v, [_, _, _, _, _, sub @ ..] => c!(sub, &[N; 0], &n![] as &[N; 0]));
- m!(&v, [..] => ());
- m!(&v, [x, .., y] => c!((x, y), (&N, &N), (&N(0), &N(4))));
-
- // Matching arrays by default binding modes (&mut):
- m!(&mut v, [N(0), sub @ .., N(4)] => c!(sub, &mut [N; 3], &mut n![1, 2, 3]));
- m!(&mut v, [N(0), sub @ ..] => c!(sub, &mut [N; 4], &mut n![1, 2, 3, 4]));
- m!(&mut v, [sub @ .., N(4)] => c!(sub, &mut [N; 4], &mut n![0, 1, 2, 3]));
- m!(&mut v, [sub @ .., _, _, _, _, _] => c!(sub, &mut [N; 0], &mut n![] as &[N; 0]));
- m!(&mut v, [_, _, _, _, _, sub @ ..] => c!(sub, &mut [N; 0], &mut n![] as &[N; 0]));
- m!(&mut v, [..] => ());
- m!(&mut v, [x, .., y] => c!((x, y), (&mut N, &mut N), (&mut N(0), &mut N(4))));
-}
diff --git a/src/test/ui/array-slice-vec/vec-macro-repeat.rs b/src/test/ui/array-slice-vec/vec-macro-repeat.rs
deleted file mode 100644
index 7be8dadbe170e..0000000000000
--- a/src/test/ui/array-slice-vec/vec-macro-repeat.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-// run-pass
-
-
-
-pub fn main() {
- assert_eq!(vec![1; 3], vec![1, 1, 1]);
- assert_eq!(vec![1; 2], vec![1, 1]);
- assert_eq!(vec![1; 1], vec![1]);
- assert_eq!(vec![1; 0], vec![]);
-
- // from_elem syntax (see RFC 832)
- let el = Box::new(1);
- let n = 3;
- assert_eq!(vec![el; n], vec![Box::new(1), Box::new(1), Box::new(1)]);
-}
diff --git a/src/test/ui/range.rs b/src/test/ui/range.rs
deleted file mode 100644
index f3f7508d12434..0000000000000
--- a/src/test/ui/range.rs
+++ /dev/null
@@ -1,51 +0,0 @@
-// run-pass
-#![allow(unused_braces)]
-#![allow(unused_comparisons)]
-#![allow(dead_code)]
-#![allow(unused_mut)]
-// Test range syntax.
-
-
-fn foo() -> isize { 42 }
-
-// Test that range syntax works in return statements
-fn return_range_to() -> ::std::ops::RangeTo<i32> { return ..1; }
-fn return_full_range() -> ::std::ops::RangeFull { return ..; }
-
-pub fn main() {
- let mut count = 0;
- for i in 0_usize..10 {
- assert!(i >= 0 && i < 10);
- count += i;
- }
- assert_eq!(count, 45);
-
- let mut count = 0;
- let mut range = 0_usize..10;
- for i in range {
- assert!(i >= 0 && i < 10);
- count += i;
- }
- assert_eq!(count, 45);
-
- let mut count = 0;
- let mut rf = 3_usize..;
- for i in rf.take(10) {
- assert!(i >= 3 && i < 13);
- count += i;
- }
- assert_eq!(count, 75);
-
- let _ = 0_usize..4+4-3;
- let _ = 0..foo();
-
- let _ = { &42..&100 }; // references to literals are OK
- let _ = ..42_usize;
-
- // Test we can use two different types with a common supertype.
- let x = &42;
- {
- let y = 42;
- let _ = x..&y;
- }
-}
diff --git a/src/test/ui/swap-2.rs b/src/test/ui/swap-2.rs
deleted file mode 100644
index c8f298ec0e5cb..0000000000000
--- a/src/test/ui/swap-2.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-// run-pass
-
-use std::mem::swap;
-
-pub fn main() {
- let mut a: Vec<isize> = vec![0, 1, 2, 3, 4, 5, 6];
- a.swap(2, 4);
- assert_eq!(a[2], 4);
- assert_eq!(a[4], 2);
- let mut n = 42;
- swap(&mut n, &mut a[0]);
- assert_eq!(a[0], 42);
- assert_eq!(n, 0);
-}
diff --git a/src/test/ui/zero-sized/zero-sized-vec-deque-push.rs b/src/test/ui/zero-sized/zero-sized-vec-deque-push.rs
deleted file mode 100644
index c541208703b6b..0000000000000
--- a/src/test/ui/zero-sized/zero-sized-vec-deque-push.rs
+++ /dev/null
@@ -1,32 +0,0 @@
-// run-pass
-use std::collections::VecDeque;
-use std::iter::Iterator;
-
-fn main() {
- const N: usize = 8;
-
- // Zero sized type
- struct Zst;
-
- // Test that for all possible sequences of push_front / push_back,
- // we end up with a deque of the correct size
-
- for len in 0..N {
- let mut tester = VecDeque::with_capacity(len);
- assert_eq!(tester.len(), 0);
- assert!(tester.capacity() >= len);
- for case in 0..(1 << len) {
- assert_eq!(tester.len(), 0);
- for bit in 0..len {
- if case & (1 << bit) != 0 {
- tester.push_front(Zst);
- } else {
- tester.push_back(Zst);
- }
- }
- assert_eq!(tester.len(), len);
- assert_eq!(tester.iter().count(), len);
- tester.clear();
- }
- }
-}
diff --git a/src/test/ui/zero-sized/zero-sized-vec-push.rs b/src/test/ui/zero-sized/zero-sized-vec-push.rs
deleted file mode 100644
index 9e9fbc972d5c1..0000000000000
--- a/src/test/ui/zero-sized/zero-sized-vec-push.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-// run-pass
-#![allow(unused_variables)]
-use std::iter::Iterator;
-use std::vec::Vec;
-
-fn main() {
- const N: usize = 8;
-
- for len in 0..N {
- let mut tester = Vec::with_capacity(len);
- assert_eq!(tester.len(), 0);
- assert!(tester.capacity() >= len);
- for bit in 0..len {
- tester.push(());
- }
- assert_eq!(tester.len(), len);
- assert_eq!(tester.iter().count(), len);
- tester.clear();
- }
-}