From 51a478c90b31c1b2248a1d24fa933c570048593c Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Fri, 1 Sep 2017 22:29:49 -0700 Subject: [PATCH 01/13] rustc: Separately feature gate repr(i128) Brought up during the discussion of #35118, the support for this is still somewhat buggy and so stabilization likely wants to be considered independently of the type itself. --- src/librustc_typeck/check/mod.rs | 7 +++++-- src/libsyntax/feature_gate.rs | 3 +++ src/test/compile-fail/feature-gate-repr128.rs | 17 +++++++++++++++++ 3 files changed, 25 insertions(+), 2 deletions(-) create mode 100644 src/test/compile-fail/feature-gate-repr128.rs diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index 2fa80a10d12e4..538d9ee72d64b 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -1599,9 +1599,12 @@ pub fn check_enum<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, let repr_type_ty = def.repr.discr_type().to_ty(tcx); if repr_type_ty == tcx.types.i128 || repr_type_ty == tcx.types.u128 { - if !tcx.sess.features.borrow().i128_type { + if !tcx.sess.features.borrow().repr128 { emit_feature_err(&tcx.sess.parse_sess, - "i128_type", sp, GateIssue::Language, "128-bit type is unstable"); + "repr128", + sp, + GateIssue::Language, + "repr with 128-bit type is unstable"); } } diff --git a/src/libsyntax/feature_gate.rs b/src/libsyntax/feature_gate.rs index 8251b03632aeb..83827a25d61bf 100644 --- a/src/libsyntax/feature_gate.rs +++ b/src/libsyntax/feature_gate.rs @@ -312,6 +312,9 @@ declare_features! ( // The `i128` type (active, i128_type, "1.16.0", Some(35118)), + // The `repr(i128)` annotation for enums + (active, repr128, "1.16.0", Some(35118)), + // The `unadjusted` ABI. Perma unstable. (active, abi_unadjusted, "1.16.0", None), diff --git a/src/test/compile-fail/feature-gate-repr128.rs b/src/test/compile-fail/feature-gate-repr128.rs new file mode 100644 index 0000000000000..96fffa6cdd0dc --- /dev/null +++ b/src/test/compile-fail/feature-gate-repr128.rs @@ -0,0 +1,17 @@ +// Copyright 2016 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. + +#[repr(u128)] +enum A { //~ ERROR repr with 128-bit type is unstable + //~| HELP: add #![feature(repr128)] + A(u64) +} + +fn main() {} From 258ec30116b1a80f4a9fb4b14aa22dd88eb8bf31 Mon Sep 17 00:00:00 2001 From: Wonwoo Choi Date: Tue, 5 Sep 2017 18:25:42 +0900 Subject: [PATCH 02/13] Expect pipe symbol after closure parameter lists --- src/libsyntax/parse/parser.rs | 2 +- src/test/compile-fail/issue-44021.rs | 16 ++++++++++++++++ 2 files changed, 17 insertions(+), 1 deletion(-) create mode 100644 src/test/compile-fail/issue-44021.rs diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 1f033b25fe4f6..a52d048830715 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -4699,7 +4699,7 @@ impl<'a> Parser<'a> { SeqSep::trailing_allowed(token::Comma), |p| p.parse_fn_block_arg() ); - self.bump(); + self.expect(&token::BinOp(token::Or))?; args } }; diff --git a/src/test/compile-fail/issue-44021.rs b/src/test/compile-fail/issue-44021.rs new file mode 100644 index 0000000000000..b6ec21b94c73f --- /dev/null +++ b/src/test/compile-fail/issue-44021.rs @@ -0,0 +1,16 @@ +// Copyright 2014 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. + +struct MyStruct; +impl MyStruct { + fn f() {|x, y} //~ ERROR expected one of `:`, `@`, or `|`, found `}` +} + +fn main() {} From 05739498c236e8d26ad83bdcad0d9b8c09c6a7ac Mon Sep 17 00:00:00 2001 From: Nick Cameron Date: Tue, 5 Sep 2017 16:16:48 +1200 Subject: [PATCH 03/13] Fixup some nits from #44238 --- src/librustdoc/html/render.rs | 102 ++++++++-------------------------- 1 file changed, 22 insertions(+), 80 deletions(-) diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs index cc84e340c74f8..6dd046554e475 100644 --- a/src/librustdoc/html/render.rs +++ b/src/librustdoc/html/render.rs @@ -606,12 +606,20 @@ pub fn run(mut krate: clean::Crate, } // A short, single-line view of `s`. -fn concise_str(s: &str) -> String { +fn concise_str(mut s: &str) -> String { if s.contains('\n') { - return format!("{}...", s.lines().next().expect("Impossible! We just found a newline")); + s = s.lines().next().expect("Impossible! We just found a newline"); } if s.len() > 70 { - return format!("{} ... {}", &s[..50], &s[s.len()-20..]); + let mut lo = 50; + let mut hi = s.len() - 20; + while !s.is_char_boundary(lo) { + lo -= 1; + } + while !s.is_char_boundary(hi) { + hi += 1; + } + return format!("{} ... {}", &s[..lo], &s[hi..]); } s.to_owned() } @@ -1756,18 +1764,18 @@ fn render_markdown(w: &mut fmt::Formatter, // We only emit warnings if the user has opted-in to Pulldown rendering. let output = if render_type == RenderType::Pulldown { let pulldown_output = format!("{}", Markdown(md_text, RenderType::Pulldown)); - let differences = html_diff::get_differences(&pulldown_output, &hoedown_output); - let differences = differences.into_iter() - .filter(|s| { - match *s { - html_diff::Difference::NodeText { ref elem_text, - ref opposite_elem_text, - .. } - if match_non_whitespace(elem_text, opposite_elem_text) => false, - _ => true, + let mut differences = html_diff::get_differences(&pulldown_output, &hoedown_output); + differences.retain(|s| { + match *s { + html_diff::Difference::NodeText { ref elem_text, + ref opposite_elem_text, + .. } + if elem_text.split_whitespace().eq(opposite_elem_text.split_whitespace()) => { + false } - }) - .collect::>(); + _ => true, + } + }); if !differences.is_empty() { scx.markdown_warnings.borrow_mut().push((span, md_text.to_owned(), differences)); @@ -1781,40 +1789,6 @@ fn render_markdown(w: &mut fmt::Formatter, write!(w, "
{}{}
", prefix, output) } -// Returns true iff s1 and s2 match, ignoring whitespace. -fn match_non_whitespace(s1: &str, s2: &str) -> bool { - let s1 = s1.trim(); - let s2 = s2.trim(); - let mut cs1 = s1.chars(); - let mut cs2 = s2.chars(); - while let Some(c1) = cs1.next() { - if c1.is_whitespace() { - continue; - } - - loop { - if let Some(c2) = cs2.next() { - if !c2.is_whitespace() { - if c1 != c2 { - return false; - } - break; - } - } else { - return false; - } - } - } - - while let Some(c2) = cs2.next() { - if !c2.is_whitespace() { - return false; - } - } - - true -} - fn document_short(w: &mut fmt::Formatter, item: &clean::Item, link: AssocItemLink, cx: &Context, prefix: &str) -> fmt::Result { if let Some(s) = item.doc_value() { @@ -3729,35 +3703,3 @@ fn test_name_sorting() { sorted.sort_by_key(|&s| name_key(s)); assert_eq!(names, sorted); } - -#[cfg(test)] -#[test] -fn test_match_non_whitespace() { - assert!(match_non_whitespace("", "")); - assert!(match_non_whitespace(" ", "")); - assert!(match_non_whitespace("", " ")); - - assert!(match_non_whitespace("a", "a")); - assert!(match_non_whitespace(" a ", "a")); - assert!(match_non_whitespace("a", " a")); - assert!(match_non_whitespace("abc", "abc")); - assert!(match_non_whitespace("abc", " abc ")); - assert!(match_non_whitespace("abc ", "abc")); - assert!(match_non_whitespace("abc xyz", "abc xyz")); - assert!(match_non_whitespace("abc xyz", "abc\nxyz")); - assert!(match_non_whitespace("abc xyz", "abcxyz")); - assert!(match_non_whitespace("abcxyz", "abc xyz")); - assert!(match_non_whitespace("abc xyz ", " abc xyz\n")); - - assert!(!match_non_whitespace("a", "b")); - assert!(!match_non_whitespace(" a ", "c")); - assert!(!match_non_whitespace("a", " aa")); - assert!(!match_non_whitespace("abc", "ac")); - assert!(!match_non_whitespace("abc", " adc ")); - assert!(!match_non_whitespace("abc ", "abca")); - assert!(!match_non_whitespace("abc xyz", "abc xy")); - assert!(!match_non_whitespace("abc xyz", "bc\nxyz")); - assert!(!match_non_whitespace("abc xyz", "abc.xyz")); - assert!(!match_non_whitespace("abcxyz", "abc.xyz")); - assert!(!match_non_whitespace("abc xyz ", " abc xyz w")); -} From 502e707fa70c845e55f86bf9d840a814d04945a6 Mon Sep 17 00:00:00 2001 From: Guillaume Gomez Date: Tue, 5 Sep 2017 20:54:01 +0200 Subject: [PATCH 04/13] Reduce false positives number in rustdoc html diff --- src/librustdoc/html/render.rs | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs index cc84e340c74f8..7e0e1e5b41663 100644 --- a/src/librustdoc/html/render.rs +++ b/src/librustdoc/html/render.rs @@ -660,9 +660,13 @@ fn render_difference(diff: &html_diff::Difference) { elem.path, elem.element_name, elem_attributes, opposite_elem_attributes); } html_diff::Difference::NodeText { ref elem, ref elem_text, ref opposite_elem_text, .. } => { - let (s1, s2) = concise_compared_strs(elem_text, opposite_elem_text); - println!(" {} Text differs:\n expected: `{}`\n found: `{}`", - elem.path, s1, s2); + if elem_text.split("\n") + .zip(opposite_elem_text.split("\n")) + .any(|(a, b)| a.trim() != b.trim()) { + let (s1, s2) = concise_compared_strs(elem_text, opposite_elem_text); + println!(" {} Text differs:\n expected: `{}`\n found: `{}`", + elem.path, s1, s2); + } } html_diff::Difference::NotPresent { ref elem, ref opposite_elem } => { if let Some(ref elem) = *elem { From 5b76b8681c088d935b60da05e8ae81e2594f46f5 Mon Sep 17 00:00:00 2001 From: bgermann Date: Wed, 6 Sep 2017 21:31:19 +0200 Subject: [PATCH 05/13] Use memalign instead of posix_memalign for Solaris As pointed out in https://github.com/rust-lang/libc/commit/deb61c8, Solaris 10 does not support posix_memalign. Use memalign for all Solaris versions instead. With this change applied I am able to cross-build rustc for Solaris 10. --- src/liballoc_system/lib.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/liballoc_system/lib.rs b/src/liballoc_system/lib.rs index 1defe308713a7..599d79104c3b0 100644 --- a/src/liballoc_system/lib.rs +++ b/src/liballoc_system/lib.rs @@ -221,7 +221,7 @@ mod platform { } } - #[cfg(any(target_os = "android", target_os = "redox"))] + #[cfg(any(target_os = "android", target_os = "redox", target_os = "solaris"))] #[inline] unsafe fn aligned_malloc(layout: &Layout) -> *mut u8 { // On android we currently target API level 9 which unfortunately @@ -244,7 +244,7 @@ mod platform { libc::memalign(layout.align(), layout.size()) as *mut u8 } - #[cfg(not(any(target_os = "android", target_os = "redox")))] + #[cfg(not(any(target_os = "android", target_os = "redox", target_os = "solaris")))] #[inline] unsafe fn aligned_malloc(layout: &Layout) -> *mut u8 { let mut out = ptr::null_mut(); From f633284b3da04a6eb2f6525e51efd81de6320f2e Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Wed, 6 Sep 2017 22:13:59 -0700 Subject: [PATCH 06/13] std: Fix a segfault on OSX with backtraces Apparently `dladdr` can succeed but still give you NULL pointers! Closes #44379 --- src/libstd/sys/unix/backtrace/printing/dladdr.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/libstd/sys/unix/backtrace/printing/dladdr.rs b/src/libstd/sys/unix/backtrace/printing/dladdr.rs index 05a071a797838..2c0cda2c8f1cc 100644 --- a/src/libstd/sys/unix/backtrace/printing/dladdr.rs +++ b/src/libstd/sys/unix/backtrace/printing/dladdr.rs @@ -22,7 +22,8 @@ pub fn resolve_symname(frame: Frame, { unsafe { let mut info: Dl_info = intrinsics::init(); - let symname = if dladdr(frame.exact_position, &mut info) == 0 { + let symname = if dladdr(frame.exact_position, &mut info) == 0 || + info.dli_sname.is_null() { None } else { CStr::from_ptr(info.dli_sname).to_str().ok() From fc44447bb9f4f97399496998b0be325679aa57f1 Mon Sep 17 00:00:00 2001 From: est31 Date: Thu, 7 Sep 2017 09:07:44 +0200 Subject: [PATCH 07/13] Update the libcompiler_builins submodule Pulls in https://github.com/rust-lang-nursery/compiler-builtins/pull/187 for nicer build output :) --- src/libcompiler_builtins | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/libcompiler_builtins b/src/libcompiler_builtins index 6b9281d2b2f0e..38ffaf97aa418 160000 --- a/src/libcompiler_builtins +++ b/src/libcompiler_builtins @@ -1 +1 @@ -Subproject commit 6b9281d2b2f0ebb94838814b1e8ace2de4b7035b +Subproject commit 38ffaf97aa418cc369ca0197a72a0b927cc0f622 From ddb072b8d77dbb4708ffa89b361375d761debc9f Mon Sep 17 00:00:00 2001 From: Joshua Liebow-Feeser Date: Thu, 7 Sep 2017 12:57:08 -0700 Subject: [PATCH 08/13] std::thread::LocalKey: Document limitation with initializers --- src/libstd/thread/local.rs | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/libstd/thread/local.rs b/src/libstd/thread/local.rs index 4ee8132f55cee..a53c76a333a99 100644 --- a/src/libstd/thread/local.rs +++ b/src/libstd/thread/local.rs @@ -31,6 +31,10 @@ use mem; /// within a thread, and values that implement [`Drop`] get destructed when a /// thread exits. Some caveats apply, which are explained below. /// +/// A `LocalKey`'s initializer cannot recursively depend on itself, and using +/// a `LocalKey` in this way will cause the initializer to infinitely recurse +/// on the first call to `with`. +/// /// # Examples /// /// ``` From 3e8fadc2ac5d5e25aaf0449d50988c54be92dbe4 Mon Sep 17 00:00:00 2001 From: Tommy Ip Date: Sat, 9 Sep 2017 09:05:54 +0100 Subject: [PATCH 09/13] Add doc example to String::as_str Fixes #44428. --- src/liballoc/string.rs | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/src/liballoc/string.rs b/src/liballoc/string.rs index ddb23b2ef37bf..1708f3e398756 100644 --- a/src/liballoc/string.rs +++ b/src/liballoc/string.rs @@ -743,6 +743,16 @@ impl String { } /// Extracts a string slice containing the entire string. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let s = String::from("foo"); + /// + /// assert_eq!("foo", s.as_str()); + /// ``` #[inline] #[stable(feature = "string_as_str", since = "1.7.0")] pub fn as_str(&self) -> &str { From 967c4e63477a847a946186dc1b6e5fd601caf464 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?John=20K=C3=A5re=20Alsaker?= Date: Sat, 9 Sep 2017 11:11:13 +0200 Subject: [PATCH 10/13] Fix bitrotted generator panic emission --- src/librustc_trans/mir/block.rs | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/src/librustc_trans/mir/block.rs b/src/librustc_trans/mir/block.rs index 0f42a244a1ff9..3e802c8be5bf4 100644 --- a/src/librustc_trans/mir/block.rs +++ b/src/librustc_trans/mir/block.rs @@ -383,16 +383,16 @@ impl<'a, 'tcx> MirContext<'a, 'tcx> { }; let msg_str = Symbol::intern(str).as_str(); let msg_str = C_str_slice(bcx.ccx, msg_str); - let msg_file_line = C_struct(bcx.ccx, - &[msg_str, filename, line], + let msg_file_line_col = C_struct(bcx.ccx, + &[msg_str, filename, line, col], false); - let align = llalign_of_min(bcx.ccx, common::val_ty(msg_file_line)); - let msg_file_line = consts::addr_of(bcx.ccx, - msg_file_line, - align, - "panic_loc"); + let align = llalign_of_min(bcx.ccx, common::val_ty(msg_file_line_col)); + let msg_file_line_col = consts::addr_of(bcx.ccx, + msg_file_line_col, + align, + "panic_loc"); (lang_items::PanicFnLangItem, - vec![msg_file_line], + vec![msg_file_line_col], None) } }; From 6c8993532c7799c745247fb7dc6293156e5c5b05 Mon Sep 17 00:00:00 2001 From: Ethan Dagner Date: Sat, 9 Sep 2017 10:27:47 -0600 Subject: [PATCH 11/13] Add doc examples for str::as_bytes_mut Fixes #44427 --- src/liballoc/str.rs | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/src/liballoc/str.rs b/src/liballoc/str.rs index 79b2bbce2af7c..c1252b219c47d 100644 --- a/src/liballoc/str.rs +++ b/src/liballoc/str.rs @@ -297,6 +297,34 @@ impl str { /// [`str::from_utf8_mut`] function. /// /// [`str::from_utf8_mut`]: ./str/fn.from_utf8_mut.html + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let mut s = String::from("Hello"); + /// let bytes = unsafe { s.as_bytes_mut() }; + /// + /// assert_eq!(b"Hello", bytes); + /// ``` + /// + /// Mutability: + /// + /// ``` + /// let mut s = String::from("🗻∈🌏"); + /// + /// unsafe { + /// let bytes = s.as_bytes_mut(); + /// + /// bytes[0] = 0xF0; + /// bytes[1] = 0x9F; + /// bytes[2] = 0x8D; + /// bytes[3] = 0x94; + /// } + /// + /// assert_eq!("🍔∈🌏", s); + /// ``` #[stable(feature = "str_mut_extras", since = "1.20.0")] #[inline(always)] pub unsafe fn as_bytes_mut(&mut self) -> &mut [u8] { From 4928d25457a5ca87fd680521c74619c4c4d14507 Mon Sep 17 00:00:00 2001 From: "Evgeniy A. Dushistov" Date: Sat, 9 Sep 2017 23:12:41 +0300 Subject: [PATCH 12/13] add test for #41229 Closes #41229 --- src/test/compile-fail/issue-41229-ref-str.rs | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) create mode 100644 src/test/compile-fail/issue-41229-ref-str.rs diff --git a/src/test/compile-fail/issue-41229-ref-str.rs b/src/test/compile-fail/issue-41229-ref-str.rs new file mode 100644 index 0000000000000..31bc21c23ba5f --- /dev/null +++ b/src/test/compile-fail/issue-41229-ref-str.rs @@ -0,0 +1,16 @@ +// 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. + +pub fn example(ref s: str) {} +//~^ ERROR the trait bound `str: std::marker::Sized` is not satisfied +//~| `str` does not have a constant size known at compile-time +//~| the trait `std::marker::Sized` is not implemented for `str` + +fn main() {} From c430fa8084277c9ee36b022dd028ed302b3f5afe Mon Sep 17 00:00:00 2001 From: toidiu Date: Sat, 9 Sep 2017 16:56:12 -0400 Subject: [PATCH 13/13] documentation update to demonstrate mutability --- src/liballoc/str.rs | 23 ++++++++++++++++------- 1 file changed, 16 insertions(+), 7 deletions(-) diff --git a/src/liballoc/str.rs b/src/liballoc/str.rs index 79b2bbce2af7c..e6b28d4d1c251 100644 --- a/src/liballoc/str.rs +++ b/src/liballoc/str.rs @@ -362,16 +362,25 @@ impl str { /// # Examples /// /// ``` - /// let mut v = String::from("🗻∈🌏"); - /// - /// assert_eq!(Some("🗻"), v.get_mut(0..4).map(|v| &*v)); - /// - /// // indices not on UTF-8 sequence boundaries - /// assert!(v.get_mut(1..).is_none()); - /// assert!(v.get_mut(..8).is_none()); + /// use std::ascii::AsciiExt; /// + /// let mut v = String::from("hello"); + /// // correct length + /// assert!(v.get_mut(0..5).is_some()); /// // out of bounds /// assert!(v.get_mut(..42).is_none()); + /// assert_eq!(Some("he"), v.get_mut(0..2).map(|v| &*v)); + /// + /// assert_eq!("hello", v); + /// { + /// let s = v.get_mut(0..2); + /// let s = s.map(|s| { + /// s.make_ascii_uppercase(); + /// &*s + /// }); + /// assert_eq!(Some("HE"), s); + /// } + /// assert_eq!("HEllo", v); /// ``` #[stable(feature = "str_checked_slicing", since = "1.20.0")] #[inline]