mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Auto merge of #32001 - Manishearth:rollup, r=Manishearth

Browse Source 
- Successful merges: #31919, #31982, #31985, #31989, #31999
- Failed merges:
This commit is contained in:
bors 2016-03-02 02:40:07 +00:00
commit 0400d929e8
15 changed files with 163 additions and 190 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
src/libcollectionstest/str.rs
View File

@ -1508,6 +1508,19 @@ generate_iterator_test! {
with str::rsplitn;
}
#[test]
fn different_str_pattern_forwarding_lifetimes() {
use std::str::pattern::Pattern;
fn foo<'a, P>(p: P) where for<'b> &'b P: Pattern<'a> {
for _ in 0..3 {
"asdf".find(&p);
}
}
foo::<&str>("x");
}
mod bench {
use test::{Bencher, black_box};

6
src/libcore/cell.rs
View File

@ -241,6 +241,9 @@ impl<T:Copy> Cell<T> {
#[stable(feature = "rust1", since = "1.0.0")]
unsafe impl<T> Send for Cell<T> where T: Send {}
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> !Sync for Cell<T> {}
#[stable(feature = "rust1", since = "1.0.0")]
impl<T:Copy> Clone for Cell<T> {
#[inline]
@ -461,6 +464,9 @@ impl<T: ?Sized> RefCell<T> {
#[stable(feature = "rust1", since = "1.0.0")]
unsafe impl<T: ?Sized> Send for RefCell<T> where T: Send {}
#[stable(feature = "rust1", since = "1.0.0")]
impl<T: ?Sized> !Sync for RefCell<T> {}
#[stable(feature = "rust1", since = "1.0.0")]
impl<T: Clone> Clone for RefCell<T> {
#[inline]

8
src/libcore/slice.rs
View File

@ -285,12 +285,12 @@ impl<T> SliceExt for [T] {
#[inline]
unsafe fn get_unchecked(&self, index: usize) -> &T {
&*(self.repr().data.offset(index as isize))
&*(self.as_ptr().offset(index as isize))
}
#[inline]
fn as_ptr(&self) -> *const T {
self.repr().data
self as *const [T] as *const T
}
fn binary_search_by<F>(&self, mut f: F) -> Result<usize, usize> where
@ -448,12 +448,12 @@ impl<T> SliceExt for [T] {
#[inline]
unsafe fn get_unchecked_mut(&mut self, index: usize) -> &mut T {
&mut *(self.repr().data as *mut T).offset(index as isize)
&mut *self.as_mut_ptr().offset(index as isize)
}
#[inline]
fn as_mut_ptr(&mut self) -> *mut T {
self.repr().data as *mut T
self as *mut [T] as *mut T
}
#[inline]

2
src/libcore/str/mod.rs
View File

@ -1894,7 +1894,7 @@ impl StrExt for str {
#[inline]
fn as_ptr(&self) -> *const u8 {
self.repr().data
self as *const str as *const u8
}
#[inline]

2
src/libcore/str/pattern.rs
View File

@ -492,7 +492,7 @@ impl<'a, F> Pattern<'a> for F where F: FnMut(char) -> bool {
/////////////////////////////////////////////////////////////////////////////
/// Delegates to the `&str` impl.
impl<'a, 'b> Pattern<'a> for &'b &'b str {
impl<'a, 'b, 'c> Pattern<'a> for &'c &'b str {
pattern_methods!(StrSearcher<'a, 'b>, |&s| s, |s| s);
}

85
src/librustc_privacy/lib.rs
View File

@ -1129,43 +1129,19 @@ impl<'a, 'tcx, 'v> Visitor<'v> for PrivacyVisitor<'a, 'tcx> {
struct SanePrivacyVisitor<'a, 'tcx: 'a> {
tcx: &'a ty::ctxt<'tcx>,
in_block: bool,
}
impl<'a, 'tcx, 'v> Visitor<'v> for SanePrivacyVisitor<'a, 'tcx> {
/// We want to visit items in the context of their containing
/// module and so forth, so supply a crate for doing a deep walk.
fn visit_nested_item(&mut self, item: hir::ItemId) {
self.visit_item(self.tcx.map.expect_item(item.id))
}
fn visit_item(&mut self, item: &hir::Item) {
self.check_sane_privacy(item);
if self.in_block {
self.check_all_inherited(item);
}
let orig_in_block = self.in_block;
// Modules turn privacy back on, otherwise we inherit
self.in_block = if let hir::ItemMod(..) = item.node { false } else { orig_in_block };
intravisit::walk_item(self, item);
self.in_block = orig_in_block;
}
fn visit_block(&mut self, b: &'v hir::Block) {
let orig_in_block = replace(&mut self.in_block, true);
intravisit::walk_block(self, b);
self.in_block = orig_in_block;
}
}
impl<'a, 'tcx> SanePrivacyVisitor<'a, 'tcx> {
/// Validates all of the visibility qualifiers placed on the item given. This
/// ensures that there are no extraneous qualifiers that don't actually do
/// anything. In theory these qualifiers wouldn't parse, but that may happen
/// later on down the road...
/// Validate that items that shouldn't have visibility qualifiers don't have them.
/// Such qualifiers can be set by syntax extensions even if the parser doesn't allow them,
/// so we check things like variant fields too.
fn check_sane_privacy(&self, item: &hir::Item) {
let check_inherited = |sp, vis, note: &str| {
if vis != hir::Inherited {
@ -1179,13 +1155,12 @@ impl<'a, 'tcx> SanePrivacyVisitor<'a, 'tcx> {
};
match item.node {
// implementations of traits don't need visibility qualifiers because
// that's controlled by having the trait in scope.
hir::ItemImpl(_, _, _, Some(..), _, ref impl_items) => {
check_inherited(item.span, item.vis,
"visibility qualifiers have no effect on trait impls");
for impl_item in impl_items {
check_inherited(impl_item.span, impl_item.vis, "");
check_inherited(impl_item.span, impl_item.vis,
"visibility qualifiers have no effect on trait impl items");
}
}
hir::ItemImpl(_, _, _, None, _, _) => {
@ -1200,41 +1175,15 @@ impl<'a, 'tcx> SanePrivacyVisitor<'a, 'tcx> {
check_inherited(item.span, item.vis,
"place qualifiers on individual functions instead");
}
hir::ItemStruct(..) | hir::ItemEnum(..) | hir::ItemTrait(..) |
hir::ItemConst(..) | hir::ItemStatic(..) | hir::ItemFn(..) |
hir::ItemMod(..) | hir::ItemExternCrate(..) |
hir::ItemUse(..) | hir::ItemTy(..) => {}
}
}
/// When inside of something like a function or a method, visibility has no
/// control over anything so this forbids any mention of any visibility
fn check_all_inherited(&self, item: &hir::Item) {
let check_inherited = |sp, vis| {
if vis != hir::Inherited {
span_err!(self.tcx.sess, sp, E0447,
"visibility has no effect inside functions or block expressions");
}
};
check_inherited(item.span, item.vis);
match item.node {
hir::ItemImpl(_, _, _, _, _, ref impl_items) => {
for impl_item in impl_items {
check_inherited(impl_item.span, impl_item.vis);
hir::ItemEnum(ref def, _) => {
for variant in &def.variants {
for field in variant.node.data.fields() {
check_inherited(field.span, field.node.kind.visibility(),
"visibility qualifiers have no effect on variant fields");
}
}
}
hir::ItemForeignMod(ref fm) => {
for fi in &fm.items {
check_inherited(fi.span, fi.vis);
}
}
hir::ItemStruct(ref vdata, _) => {
for f in vdata.fields() {
check_inherited(f.span, f.node.kind.visibility());
}
}
hir::ItemDefaultImpl(..) | hir::ItemEnum(..) | hir::ItemTrait(..) |
hir::ItemStruct(..) | hir::ItemTrait(..) |
hir::ItemConst(..) | hir::ItemStatic(..) | hir::ItemFn(..) |
hir::ItemMod(..) | hir::ItemExternCrate(..) |
hir::ItemUse(..) | hir::ItemTy(..) => {}
@ -1821,13 +1770,9 @@ pub fn check_crate(tcx: &ty::ctxt,
let krate = tcx.map.krate();
// Sanity check to make sure that all privacy usage and controls are
// reasonable.
let mut visitor = SanePrivacyVisitor {
tcx: tcx,
in_block: false,
};
intravisit::walk_crate(&mut visitor, krate);
// Sanity check to make sure that all privacy usage is reasonable.
let mut visitor = SanePrivacyVisitor { tcx: tcx };
krate.visit_all_items(&mut visitor);
// Figure out who everyone's parent is
let mut visitor = ParentVisitor {

2
src/libstd/build.rs
View File

@ -23,7 +23,7 @@ fn main() {
let target = env::var("TARGET").unwrap();
let host = env::var("HOST").unwrap();
if !target.contains("apple") && !target.contains("msvc") {
if !target.contains("apple") && !target.contains("msvc") && !target.contains("emscripten"){
build_libbacktrace(&host, &target);
}

6
src/libstd/sync/mpsc/mod.rs
View File

@ -299,6 +299,9 @@ pub struct Receiver<T> {
#[stable(feature = "rust1", since = "1.0.0")]
unsafe impl<T: Send> Send for Receiver<T> { }
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> !Sync for Receiver<T> { }
/// An iterator over messages on a receiver, this iterator will block
/// whenever `next` is called, waiting for a new message, and `None` will be
/// returned when the corresponding channel has hung up.
@ -327,6 +330,9 @@ pub struct Sender<T> {
#[stable(feature = "rust1", since = "1.0.0")]
unsafe impl<T: Send> Send for Sender<T> { }
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> !Sync for Sender<T> { }
/// The sending-half of Rust's synchronous channel type. This half can only be
/// owned by one thread, but it can be cloned to send to other threads.
#[stable(feature = "rust1", since = "1.0.0")]

17
src/test/compile-fail/comm-not-freeze-receiver.rs
View File

@ -1,17 +0,0 @@
// Copyright 2013 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 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use std::sync::mpsc::Receiver;
fn test<T: Sync>() {}
fn main() {
test::<Receiver<isize>>(); //~ ERROR: `core::marker::Sync` is not implemented
}

17
src/test/compile-fail/comm-not-freeze.rs
View File

@ -1,17 +0,0 @@
// Copyright 2013 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 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use std::sync::mpsc::Sender;
fn test<T: Sync>() {}
fn main() {
test::<Sender<isize>>(); //~ ERROR: `core::marker::Sync` is not implemented
}

20
src/test/compile-fail/no_share-rc.rs
View File

@ -1,20 +0,0 @@
// Copyright 2013 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 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use std::rc::Rc;
use std::cell::RefCell;
fn bar<T: Sync>(_: T) {}
fn main() {
let x = Rc::new(RefCell::new(5));
bar(x);
//~^ ERROR the trait `core::marker::Sync` is not implemented
}

34
src/test/compile-fail/not-sync.rs Normal file
View File

@ -0,0 +1,34 @@
// 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 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use std::cell::{Cell, RefCell};
use std::rc::{Rc, Weak};
use std::sync::mpsc::{Receiver, Sender, SyncSender};
fn test<T: Sync>() {}
fn main() {
test::<Cell<i32>>();
//~^ ERROR marker::Sync` is not implemented for the type `core::cell::Cell<i32>`
test::<RefCell<i32>>();
//~^ ERROR marker::Sync` is not implemented for the type `core::cell::RefCell<i32>`
test::<Rc<i32>>();
//~^ ERROR marker::Sync` is not implemented for the type `alloc::rc::Rc<i32>`
test::<Weak<i32>>();
//~^ ERROR marker::Sync` is not implemented for the type `alloc::rc::Weak<i32>`
test::<Receiver<i32>>();
//~^ ERROR marker::Sync` is not implemented for the type `std::sync::mpsc::Receiver<i32>`
test::<Sender<i32>>();
//~^ ERROR marker::Sync` is not implemented for the type `std::sync::mpsc::Sender<i32>`
test::<SyncSender<i32>>();
//~^ ERROR marker::Sync` is not implemented for the type `std::sync::mpsc::SyncSender<i32>`
}

50
src/test/compile-fail/privacy-sanity.rs
View File

@ -40,37 +40,30 @@ pub extern "C" { //~ ERROR unnecessary visibility qualifier
const MAIN: u8 = {
trait MarkerTr {}
pub trait Tr { //~ ERROR visibility has no effect inside functions or block
pub trait Tr {
fn f();
const C: u8;
type T;
}
pub struct S { //~ ERROR visibility has no effect inside functions or block
pub a: u8 //~ ERROR visibility has no effect inside functions or block
pub struct S {
pub a: u8
}
struct Ts(pub u8); //~ ERROR visibility has no effect inside functions or block
struct Ts(pub u8);
pub impl MarkerTr for .. {} //~ ERROR unnecessary visibility qualifier
//~^ ERROR visibility has no effect inside functions or block
pub impl Tr for S { //~ ERROR unnecessary visibility qualifier
//~^ ERROR visibility has no effect inside functions or block
pub fn f() {} //~ ERROR unnecessary visibility qualifier
//~^ ERROR visibility has no effect inside functions or block
pub const C: u8 = 0; //~ ERROR unnecessary visibility qualifier
//~^ ERROR visibility has no effect inside functions or block
pub type T = u8; //~ ERROR unnecessary visibility qualifier
//~^ ERROR visibility has no effect inside functions or block
}
pub impl S { //~ ERROR unnecessary visibility qualifier
//~^ ERROR visibility has no effect inside functions or block
pub fn f() {} //~ ERROR visibility has no effect inside functions or block
pub const C: u8 = 0; //~ ERROR visibility has no effect inside functions or block
// pub type T = u8; // ERROR visibility has no effect inside functions or block
pub fn f() {}
pub const C: u8 = 0;
// pub type T = u8;
}
pub extern "C" { //~ ERROR unnecessary visibility qualifier
//~^ ERROR visibility has no effect inside functions or block
pub fn f(); //~ ERROR visibility has no effect inside functions or block
pub static St: u8; //~ ERROR visibility has no effect inside functions or block
pub fn f();
pub static St: u8;
}
0
@ -78,36 +71,29 @@ const MAIN: u8 = {
fn main() {
trait MarkerTr {}
pub trait Tr { //~ ERROR visibility has no effect inside functions or block
pub trait Tr {
fn f();
const C: u8;
type T;
}
pub struct S { //~ ERROR visibility has no effect inside functions or block
pub a: u8 //~ ERROR visibility has no effect inside functions or block
pub struct S {
pub a: u8
}
struct Ts(pub u8); //~ ERROR visibility has no effect inside functions or block
struct Ts(pub u8);
pub impl MarkerTr for .. {} //~ ERROR unnecessary visibility qualifier
//~^ ERROR visibility has no effect inside functions or block
pub impl Tr for S { //~ ERROR unnecessary visibility qualifier
//~^ ERROR visibility has no effect inside functions or block
pub fn f() {} //~ ERROR unnecessary visibility qualifier
//~^ ERROR visibility has no effect inside functions or block
pub const C: u8 = 0; //~ ERROR unnecessary visibility qualifier
//~^ ERROR visibility has no effect inside functions or block
pub type T = u8; //~ ERROR unnecessary visibility qualifier
//~^ ERROR visibility has no effect inside functions or block
}
pub impl S { //~ ERROR unnecessary visibility qualifier
//~^ ERROR visibility has no effect inside functions or block
pub fn f() {} //~ ERROR visibility has no effect inside functions or block
pub const C: u8 = 0; //~ ERROR visibility has no effect inside functions or block
// pub type T = u8; // ERROR visibility has no effect inside functions or block
pub fn f() {}
pub const C: u8 = 0;
// pub type T = u8;
}
pub extern "C" { //~ ERROR unnecessary visibility qualifier
//~^ ERROR visibility has no effect inside functions or block
pub fn f(); //~ ERROR visibility has no effect inside functions or block
pub static St: u8; //~ ERROR visibility has no effect inside functions or block
pub fn f();
pub static St: u8;
}
}

27
src/test/compile-fail/unnecessary-private.rs
View File

@ -1,27 +0,0 @@
// Copyright 2013-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 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
fn main() {
pub use std::usize; //~ ERROR: visibility has no effect
pub struct A; //~ ERROR: visibility has no effect
pub enum B {} //~ ERROR: visibility has no effect
pub trait C { //~ ERROR: visibility has no effect
fn foo(&self) {}
}
impl A {
pub fn foo(&self) {} //~ ERROR: visibility has no effect
}
struct D {
pub foo: isize, //~ ERROR: visibility has no effect
}
pub fn foo() {} //~ ERROR: visibility has no effect
pub mod bar {} //~ ERROR: visibility has no effect
}

64
src/test/run-pass/issue-31776.rs Normal file
View File

@ -0,0 +1,64 @@
// 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 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
// Various scenarios in which `pub` is required in blocks
struct S;
mod m {
fn f() {
impl ::S {
pub fn s(&self) {}
}
}
}
// ------------------------------------------------------
pub trait Tr {
type A;
}
pub struct S1;
fn f() {
pub struct Z;
impl ::Tr for ::S1 {
type A = Z; // Private-in-public error unless `struct Z` is pub
}
}
// ------------------------------------------------------
trait Tr1 {
type A;
fn pull(&self) -> Self::A;
}
struct S2;
mod m1 {
fn f() {
struct Z {
pub field: u8
}
impl ::Tr1 for ::S2 {
type A = Z;
fn pull(&self) -> Self::A { Z{field: 10} }
}
}
}
// ------------------------------------------------------
fn main() {
S.s(); // Privacy error, unless `fn s` is pub
let a = S2.pull().field; // Privacy error unless `field: u8` is pub
}