diff --git a/src/doc/unstable-book/src/library-features/proc-macro.md b/src/doc/unstable-book/src/library-features/proc-macro.md deleted file mode 100644 index 19e7f663c7ac3..0000000000000 --- a/src/doc/unstable-book/src/library-features/proc-macro.md +++ /dev/null @@ -1,7 +0,0 @@ -# `proc_macro` - -The tracking issue for this feature is: [#38356] - -[#38356]: https://github.com/rust-lang/rust/issues/38356 - ------------------------- diff --git a/src/liballoc/slice.rs b/src/liballoc/slice.rs index ab574c9f7e769..fa73197885be7 100644 --- a/src/liballoc/slice.rs +++ b/src/liballoc/slice.rs @@ -606,14 +606,14 @@ impl [T] { core_slice::SliceExt::windows(self, size) } - /// Returns an iterator over `size` elements of the slice at a - /// time. The chunks are slices and do not overlap. If `size` does + /// Returns an iterator over `chunk_size` elements of the slice at a + /// time. The chunks are slices and do not overlap. If `chunk_size` does /// not divide the length of the slice, then the last chunk will - /// not have length `size`. + /// not have length `chunk_size`. /// /// # Panics /// - /// Panics if `size` is 0. + /// Panics if `chunk_size` is 0. /// /// # Examples /// @@ -627,8 +627,8 @@ impl [T] { /// ``` #[stable(feature = "rust1", since = "1.0.0")] #[inline] - pub fn chunks(&self, size: usize) -> Chunks { - core_slice::SliceExt::chunks(self, size) + pub fn chunks(&self, chunk_size: usize) -> Chunks { + core_slice::SliceExt::chunks(self, chunk_size) } /// Returns an iterator over `chunk_size` elements of the slice at a time. @@ -1725,6 +1725,14 @@ impl [u8] { reason = "trait should not have to exist", issue = "27747")] /// An extension trait for concatenating slices +/// +/// While this trait is unstable, the methods are stable. `SliceConcatExt` is +/// included in the [standard library prelude], so you can use [`join()`] and +/// [`concat()`] as if they existed on `[T]` itself. +/// +/// [standard library prelude]: ../../std/prelude/index.html +/// [`join()`]: #tymethod.join +/// [`concat()`]: #tymethod.concat pub trait SliceConcatExt { #[unstable(feature = "slice_concat_ext", reason = "trait should not have to exist", diff --git a/src/liballoc/vec.rs b/src/liballoc/vec.rs index 93d7e66b7b203..301e44632b823 100644 --- a/src/liballoc/vec.rs +++ b/src/liballoc/vec.rs @@ -715,7 +715,7 @@ impl Vec { /// /// # Panics /// - /// Panics if `index` is out of bounds. + /// Panics if `index > len`. /// /// # Examples /// diff --git a/src/libcore/slice/memchr.rs b/src/libcore/slice/memchr.rs index 00183be97e751..69c9cb37dcfd3 100644 --- a/src/libcore/slice/memchr.rs +++ b/src/libcore/slice/memchr.rs @@ -56,7 +56,7 @@ fn repeat_byte(b: u8) -> usize { rep } -/// Return the first index matching the byte `a` in `text`. +/// Return the first index matching the byte `x` in `text`. pub fn memchr(x: u8, text: &[u8]) -> Option { // Scan for a single byte value by reading two `usize` words at a time. // @@ -101,7 +101,7 @@ pub fn memchr(x: u8, text: &[u8]) -> Option { text[offset..].iter().position(|elt| *elt == x).map(|i| offset + i) } -/// Return the last index matching the byte `a` in `text`. +/// Return the last index matching the byte `x` in `text`. pub fn memrchr(x: u8, text: &[u8]) -> Option { // Scan for a single byte value by reading two `usize` words at a time. // diff --git a/src/libcore/slice/mod.rs b/src/libcore/slice/mod.rs index 20d586a402170..6b6ec7147b306 100644 --- a/src/libcore/slice/mod.rs +++ b/src/libcore/slice/mod.rs @@ -348,9 +348,9 @@ impl SliceExt for [T] { } #[inline] - fn chunks(&self, size: usize) -> Chunks { - assert!(size != 0); - Chunks { v: self, size: size } + fn chunks(&self, chunk_size: usize) -> Chunks { + assert!(chunk_size != 0); + Chunks { v: self, chunk_size: chunk_size } } #[inline] @@ -532,7 +532,7 @@ impl SliceExt for [T] { #[inline] fn chunks_mut(&mut self, chunk_size: usize) -> ChunksMut { - assert!(chunk_size > 0); + assert!(chunk_size != 0); ChunksMut { v: self, chunk_size: chunk_size } } @@ -2117,7 +2117,7 @@ impl<'a, T> ExactSizeIterator for Windows<'a, T> {} #[unstable(feature = "fused", issue = "35602")] impl<'a, T> FusedIterator for Windows<'a, T> {} -/// An iterator over a slice in (non-overlapping) chunks (`size` elements at a +/// An iterator over a slice in (non-overlapping) chunks (`chunk_size` elements at a /// time). /// /// When the slice len is not evenly divided by the chunk size, the last slice @@ -2131,7 +2131,7 @@ impl<'a, T> FusedIterator for Windows<'a, T> {} #[stable(feature = "rust1", since = "1.0.0")] pub struct Chunks<'a, T:'a> { v: &'a [T], - size: usize + chunk_size: usize } // FIXME(#26925) Remove in favor of `#[derive(Clone)]` @@ -2140,7 +2140,7 @@ impl<'a, T> Clone for Chunks<'a, T> { fn clone(&self) -> Chunks<'a, T> { Chunks { v: self.v, - size: self.size, + chunk_size: self.chunk_size, } } } @@ -2154,7 +2154,7 @@ impl<'a, T> Iterator for Chunks<'a, T> { if self.v.is_empty() { None } else { - let chunksz = cmp::min(self.v.len(), self.size); + let chunksz = cmp::min(self.v.len(), self.chunk_size); let (fst, snd) = self.v.split_at(chunksz); self.v = snd; Some(fst) @@ -2166,8 +2166,8 @@ impl<'a, T> Iterator for Chunks<'a, T> { if self.v.is_empty() { (0, Some(0)) } else { - let n = self.v.len() / self.size; - let rem = self.v.len() % self.size; + let n = self.v.len() / self.chunk_size; + let rem = self.v.len() % self.chunk_size; let n = if rem > 0 { n+1 } else { n }; (n, Some(n)) } @@ -2180,12 +2180,12 @@ impl<'a, T> Iterator for Chunks<'a, T> { #[inline] fn nth(&mut self, n: usize) -> Option { - let (start, overflow) = n.overflowing_mul(self.size); + let (start, overflow) = n.overflowing_mul(self.chunk_size); if start >= self.v.len() || overflow { self.v = &[]; None } else { - let end = match start.checked_add(self.size) { + let end = match start.checked_add(self.chunk_size) { Some(sum) => cmp::min(self.v.len(), sum), None => self.v.len(), }; @@ -2200,7 +2200,7 @@ impl<'a, T> Iterator for Chunks<'a, T> { if self.v.is_empty() { None } else { - let start = (self.v.len() - 1) / self.size * self.size; + let start = (self.v.len() - 1) / self.chunk_size * self.chunk_size; Some(&self.v[start..]) } } @@ -2213,8 +2213,8 @@ impl<'a, T> DoubleEndedIterator for Chunks<'a, T> { if self.v.is_empty() { None } else { - let remainder = self.v.len() % self.size; - let chunksz = if remainder != 0 { remainder } else { self.size }; + let remainder = self.v.len() % self.chunk_size; + let chunksz = if remainder != 0 { remainder } else { self.chunk_size }; let (fst, snd) = self.v.split_at(self.v.len() - chunksz); self.v = fst; Some(snd) @@ -2228,7 +2228,7 @@ impl<'a, T> ExactSizeIterator for Chunks<'a, T> {} #[unstable(feature = "fused", issue = "35602")] impl<'a, T> FusedIterator for Chunks<'a, T> {} -/// An iterator over a slice in (non-overlapping) mutable chunks (`size` +/// An iterator over a slice in (non-overlapping) mutable chunks (`chunk_size` /// elements at a time). When the slice len is not evenly divided by the chunk /// size, the last slice of the iteration will be the remainder. /// diff --git a/src/librustc/mir/README.md b/src/librustc/mir/README.md index fb0c7ce1df23d..cac86be0fcb75 100644 --- a/src/librustc/mir/README.md +++ b/src/librustc/mir/README.md @@ -59,7 +59,7 @@ ensure that, before the MIR at a particular phase in the processing pipeline is stolen, anyone who may want to read from it has already done so. Concretely, this means that if you have some query `foo(D)` that wants to access the result of `mir_const(D)` or -`mir_validated(D)`, you need to have the successor pass either "force" +`mir_validated(D)`, you need to have the successor pass "force" `foo(D)` using `ty::queries::foo::force(...)`. This will force a query to execute even though you don't directly require its result. diff --git a/src/librustc_typeck/check/dropck.rs b/src/librustc_typeck/check/dropck.rs index 55700c452e57b..4aed688027f76 100644 --- a/src/librustc_typeck/check/dropck.rs +++ b/src/librustc_typeck/check/dropck.rs @@ -59,11 +59,13 @@ pub fn check_drop_impl<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, } _ => { // Destructors only work on nominal types. This was - // already checked by coherence, so we can panic here. + // already checked by coherence, but compilation may + // not have been terminated. let span = tcx.def_span(drop_impl_did); - span_bug!(span, - "should have been rejected by coherence check: {}", - dtor_self_type); + tcx.sess.delay_span_bug(span, + &format!("should have been rejected by coherence check: {}", + dtor_self_type)); + Err(ErrorReported) } } } diff --git a/src/librustdoc/html/static/main.js b/src/librustdoc/html/static/main.js index 559f8494fc3c0..c128a812b93b0 100644 --- a/src/librustdoc/html/static/main.js +++ b/src/librustdoc/html/static/main.js @@ -258,6 +258,7 @@ addClass(search, "hidden"); removeClass(document.getElementById("main"), "hidden"); } + defocusSearchBar(); break; case "s": @@ -1884,3 +1885,8 @@ function focusSearchBar() { document.getElementsByClassName('search-input')[0].focus(); } + +// Removes the focus from the search bar +function defocusSearchBar() { + document.getElementsByClassName('search-input')[0].blur(); +} diff --git a/src/libstd/io/buffered.rs b/src/libstd/io/buffered.rs index 8308ab48d9ceb..7001d8e042196 100644 --- a/src/libstd/io/buffered.rs +++ b/src/libstd/io/buffered.rs @@ -486,6 +486,10 @@ impl BufWriter { /// /// The buffer is written out before returning the writer. /// + /// # Errors + /// + /// An `Err` will be returned if an error occurs while flushing the buffer. + /// /// # Examples /// /// ```no_run @@ -650,6 +654,9 @@ impl fmt::Display for IntoInnerError { /// completed, rather than the entire buffer at once. Enter `LineWriter`. It /// does exactly that. /// +/// Like [`BufWriter`], a `LineWriter`’s buffer will also be flushed when the +/// `LineWriter` goes out of scope or when its internal buffer is full. +/// /// [bufwriter]: struct.BufWriter.html /// /// If there's still a partial line in the buffer when the `LineWriter` is @@ -785,6 +792,10 @@ impl LineWriter { /// /// The internal buffer is written out before returning the writer. /// + // # Errors + /// + /// An `Err` will be returned if an error occurs while flushing the buffer. + /// /// # Examples /// /// ``` diff --git a/src/test/compile-fail/issue-41974.rs b/src/test/compile-fail/issue-41974.rs new file mode 100644 index 0000000000000..5c9077783c794 --- /dev/null +++ b/src/test/compile-fail/issue-41974.rs @@ -0,0 +1,24 @@ +// Copyright 2017 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#[derive(Copy, Clone)] +struct Flags; + +trait A { +} + +impl Drop for T where T: A { //~ ERROR E0119 + //~^ ERROR E0120 + //~| ERROR E0210 + fn drop(&mut self) { + } +} + +fn main() {} diff --git a/src/tools/tidy/src/unstable_book.rs b/src/tools/tidy/src/unstable_book.rs index ff032b14ad1d5..a4a35a706fd91 100644 --- a/src/tools/tidy/src/unstable_book.rs +++ b/src/tools/tidy/src/unstable_book.rs @@ -87,7 +87,9 @@ pub fn check(path: &path::Path, bad: &mut bool) { // Library features let lang_features = collect_lang_features(path); - let lib_features = collect_lib_features(path); + let lib_features = collect_lib_features(path).into_iter().filter(|&(ref name, _)| { + !lang_features.contains_key(name) + }).collect(); let unstable_lib_feature_names = collect_unstable_feature_names(&lib_features); let unstable_book_lib_features_section_file_names = diff --git a/src/tools/unstable-book-gen/src/main.rs b/src/tools/unstable-book-gen/src/main.rs index 5c2bd1e3e087d..f66a18547c3b5 100644 --- a/src/tools/unstable-book-gen/src/main.rs +++ b/src/tools/unstable-book-gen/src/main.rs @@ -129,7 +129,9 @@ fn main() { let dest_path = Path::new(&dest_path_str).join("src"); let lang_features = collect_lang_features(src_path); - let lib_features = collect_lib_features(src_path); + let lib_features = collect_lib_features(src_path).into_iter().filter(|&(ref name, _)| { + !lang_features.contains_key(name) + }).collect(); let doc_src_path = src_path.join(PATH_STR);