From df4821698e867a468c9237af30cd5bc4a7bc2773 Mon Sep 17 00:00:00 2001 From: Vadim Petrochenkov Date: Fri, 26 Feb 2016 21:20:56 +0300 Subject: [PATCH 1/7] Permit `pub` items in blocks --- src/librustc_privacy/lib.rs | 64 +------------------- src/test/compile-fail/privacy-sanity.rs | 50 ++++++--------- src/test/compile-fail/unnecessary-private.rs | 27 --------- 3 files changed, 20 insertions(+), 121 deletions(-) delete mode 100644 src/test/compile-fail/unnecessary-private.rs diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs index 8908dac7a36dd..0b0753ac327e8 100644 --- a/src/librustc_privacy/lib.rs +++ b/src/librustc_privacy/lib.rs @@ -1129,35 +1129,12 @@ 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; } } @@ -1206,40 +1183,6 @@ impl<'a, 'tcx> SanePrivacyVisitor<'a, 'tcx> { 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::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::ItemConst(..) | hir::ItemStatic(..) | hir::ItemFn(..) | - hir::ItemMod(..) | hir::ItemExternCrate(..) | - hir::ItemUse(..) | hir::ItemTy(..) => {} - } - } } /////////////////////////////////////////////////////////////////////////////// @@ -1823,11 +1766,8 @@ pub fn check_crate(tcx: &ty::ctxt, // 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); + let mut visitor = SanePrivacyVisitor { tcx: tcx }; + krate.visit_all_items(&mut visitor); // Figure out who everyone's parent is let mut visitor = ParentVisitor { diff --git a/src/test/compile-fail/privacy-sanity.rs b/src/test/compile-fail/privacy-sanity.rs index 336913b877271..063848f62aa9e 100644 --- a/src/test/compile-fail/privacy-sanity.rs +++ b/src/test/compile-fail/privacy-sanity.rs @@ -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; } } diff --git a/src/test/compile-fail/unnecessary-private.rs b/src/test/compile-fail/unnecessary-private.rs deleted file mode 100644 index 113393490cb6d..0000000000000 --- a/src/test/compile-fail/unnecessary-private.rs +++ /dev/null @@ -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 or the MIT license -// , 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 -} From fa427266ee5241868332f0401cf7e86ce3c29cc9 Mon Sep 17 00:00:00 2001 From: Vadim Petrochenkov Date: Fri, 26 Feb 2016 22:06:39 +0300 Subject: [PATCH 2/7] Some drive-by improvements to SanePrivacyVisitor Check that variant fields are not marked public by syntax extensions --- src/librustc_privacy/lib.rs | 25 +++++++++++++++---------- 1 file changed, 15 insertions(+), 10 deletions(-) diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs index 0b0753ac327e8..e0ede288523b4 100644 --- a/src/librustc_privacy/lib.rs +++ b/src/librustc_privacy/lib.rs @@ -1139,10 +1139,9 @@ impl<'a, 'tcx, 'v> Visitor<'v> for SanePrivacyVisitor<'a, 'tcx> { } 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 { @@ -1156,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, _, _) => { @@ -1177,7 +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::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::ItemStruct(..) | hir::ItemTrait(..) | hir::ItemConst(..) | hir::ItemStatic(..) | hir::ItemFn(..) | hir::ItemMod(..) | hir::ItemExternCrate(..) | hir::ItemUse(..) | hir::ItemTy(..) => {} @@ -1764,8 +1770,7 @@ 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. + // Sanity check to make sure that all privacy usage is reasonable. let mut visitor = SanePrivacyVisitor { tcx: tcx }; krate.visit_all_items(&mut visitor); From b6f441d9861868eefd81460e0c3e4295fca12ffe Mon Sep 17 00:00:00 2001 From: Vadim Petrochenkov Date: Sun, 28 Feb 2016 14:50:58 +0300 Subject: [PATCH 3/7] Add some tests --- src/test/run-pass/issue-31776.rs | 64 ++++++++++++++++++++++++++++++++ 1 file changed, 64 insertions(+) create mode 100644 src/test/run-pass/issue-31776.rs diff --git a/src/test/run-pass/issue-31776.rs b/src/test/run-pass/issue-31776.rs new file mode 100644 index 0000000000000..a12e569df2bc9 --- /dev/null +++ b/src/test/run-pass/issue-31776.rs @@ -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 or the MIT license +// , 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 +} From dd67e55c10acf80dbd2c14a8eb231e265b5776a4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Marvin=20L=C3=B6bel?= Date: Tue, 1 Mar 2016 17:53:51 +0100 Subject: [PATCH 4/7] Changed `std::pattern::Pattern` impl on `&'a &'a str` to `&'a &'b str` in order to allow a bit more felixibility in how to use it. --- src/libcollectionstest/str.rs | 13 +++++++++++++ src/libcore/str/pattern.rs | 2 +- 2 files changed, 14 insertions(+), 1 deletion(-) diff --git a/src/libcollectionstest/str.rs b/src/libcollectionstest/str.rs index 25457043a9df4..b84b37dbf752c 100644 --- a/src/libcollectionstest/str.rs +++ b/src/libcollectionstest/str.rs @@ -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}; diff --git a/src/libcore/str/pattern.rs b/src/libcore/str/pattern.rs index 29130100e996f..abad29cb7751e 100644 --- a/src/libcore/str/pattern.rs +++ b/src/libcore/str/pattern.rs @@ -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); } From 63c4065af00a61aef24153a1d3dde76013f433bb Mon Sep 17 00:00:00 2001 From: Ulrik Sverdrup Date: Tue, 1 Mar 2016 20:21:55 +0100 Subject: [PATCH 5/7] Use raw pointer casts for slice, str's .as_ptr() We can now use raw pointer casts `*const [T] as *const T` and `*const str as *const u8` instead of .repr() for getting the pointer out of a slice. --- src/libcore/slice.rs | 8 ++++---- src/libcore/str/mod.rs | 2 +- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/libcore/slice.rs b/src/libcore/slice.rs index afda70f4fcc0a..fb15533f33c54 100644 --- a/src/libcore/slice.rs +++ b/src/libcore/slice.rs @@ -285,12 +285,12 @@ impl 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(&self, mut f: F) -> Result where @@ -448,12 +448,12 @@ impl 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] diff --git a/src/libcore/str/mod.rs b/src/libcore/str/mod.rs index 4d367cfd432f9..a555b8592912e 100644 --- a/src/libcore/str/mod.rs +++ b/src/libcore/str/mod.rs @@ -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] From f522d882373067ab79ea0fdc30be6150eeccb1fd Mon Sep 17 00:00:00 2001 From: Andrew Paseltiner Date: Mon, 29 Feb 2016 22:03:23 -0500 Subject: [PATCH 6/7] Explicitly opt out of `Sync` for `cell` and `mpsc` types These types were already `!Sync`, but this improves error messages when they are used in contexts that require `Sync`, aligning them with conventions used with `Rc`, among others. --- src/libcore/cell.rs | 6 ++++ src/libstd/sync/mpsc/mod.rs | 6 ++++ .../compile-fail/comm-not-freeze-receiver.rs | 17 ---------- src/test/compile-fail/comm-not-freeze.rs | 17 ---------- src/test/compile-fail/no_share-rc.rs | 20 ----------- src/test/compile-fail/not-sync.rs | 34 +++++++++++++++++++ 6 files changed, 46 insertions(+), 54 deletions(-) delete mode 100644 src/test/compile-fail/comm-not-freeze-receiver.rs delete mode 100644 src/test/compile-fail/comm-not-freeze.rs delete mode 100644 src/test/compile-fail/no_share-rc.rs create mode 100644 src/test/compile-fail/not-sync.rs diff --git a/src/libcore/cell.rs b/src/libcore/cell.rs index 255c846244bdc..144adde12e42b 100644 --- a/src/libcore/cell.rs +++ b/src/libcore/cell.rs @@ -241,6 +241,9 @@ impl Cell { #[stable(feature = "rust1", since = "1.0.0")] unsafe impl Send for Cell where T: Send {} +#[stable(feature = "rust1", since = "1.0.0")] +impl !Sync for Cell {} + #[stable(feature = "rust1", since = "1.0.0")] impl Clone for Cell { #[inline] @@ -461,6 +464,9 @@ impl RefCell { #[stable(feature = "rust1", since = "1.0.0")] unsafe impl Send for RefCell where T: Send {} +#[stable(feature = "rust1", since = "1.0.0")] +impl !Sync for RefCell {} + #[stable(feature = "rust1", since = "1.0.0")] impl Clone for RefCell { #[inline] diff --git a/src/libstd/sync/mpsc/mod.rs b/src/libstd/sync/mpsc/mod.rs index fadca390986ce..dbcc2bc95bc21 100644 --- a/src/libstd/sync/mpsc/mod.rs +++ b/src/libstd/sync/mpsc/mod.rs @@ -299,6 +299,9 @@ pub struct Receiver { #[stable(feature = "rust1", since = "1.0.0")] unsafe impl Send for Receiver { } +#[stable(feature = "rust1", since = "1.0.0")] +impl !Sync for Receiver { } + /// 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 { #[stable(feature = "rust1", since = "1.0.0")] unsafe impl Send for Sender { } +#[stable(feature = "rust1", since = "1.0.0")] +impl !Sync for Sender { } + /// 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")] diff --git a/src/test/compile-fail/comm-not-freeze-receiver.rs b/src/test/compile-fail/comm-not-freeze-receiver.rs deleted file mode 100644 index 305acfec40114..0000000000000 --- a/src/test/compile-fail/comm-not-freeze-receiver.rs +++ /dev/null @@ -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 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -use std::sync::mpsc::Receiver; - -fn test() {} - -fn main() { - test::>(); //~ ERROR: `core::marker::Sync` is not implemented -} diff --git a/src/test/compile-fail/comm-not-freeze.rs b/src/test/compile-fail/comm-not-freeze.rs deleted file mode 100644 index de2c96920c38b..0000000000000 --- a/src/test/compile-fail/comm-not-freeze.rs +++ /dev/null @@ -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 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -use std::sync::mpsc::Sender; - -fn test() {} - -fn main() { - test::>(); //~ ERROR: `core::marker::Sync` is not implemented -} diff --git a/src/test/compile-fail/no_share-rc.rs b/src/test/compile-fail/no_share-rc.rs deleted file mode 100644 index 4bc3442871f5d..0000000000000 --- a/src/test/compile-fail/no_share-rc.rs +++ /dev/null @@ -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 or the MIT license -// , 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) {} - -fn main() { - let x = Rc::new(RefCell::new(5)); - bar(x); - //~^ ERROR the trait `core::marker::Sync` is not implemented -} diff --git a/src/test/compile-fail/not-sync.rs b/src/test/compile-fail/not-sync.rs new file mode 100644 index 0000000000000..a60138c6e1f69 --- /dev/null +++ b/src/test/compile-fail/not-sync.rs @@ -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 or the MIT license +// , 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() {} + +fn main() { + test::>(); + //~^ ERROR marker::Sync` is not implemented for the type `core::cell::Cell` + test::>(); + //~^ ERROR marker::Sync` is not implemented for the type `core::cell::RefCell` + + test::>(); + //~^ ERROR marker::Sync` is not implemented for the type `alloc::rc::Rc` + test::>(); + //~^ ERROR marker::Sync` is not implemented for the type `alloc::rc::Weak` + + test::>(); + //~^ ERROR marker::Sync` is not implemented for the type `std::sync::mpsc::Receiver` + test::>(); + //~^ ERROR marker::Sync` is not implemented for the type `std::sync::mpsc::Sender` + test::>(); + //~^ ERROR marker::Sync` is not implemented for the type `std::sync::mpsc::SyncSender` +} From d846f490a04df5899471218dfe904e7cfe42b13f Mon Sep 17 00:00:00 2001 From: ashleysommer Date: Tue, 1 Mar 2016 20:57:43 +1000 Subject: [PATCH 7/7] Fix compiling libstd with emscripten target. Was getting error: ``` running: "sh" "/home/flubba86/rust/src/libstd/../libbacktrace/configure" "--with-pic" "--disable-multilib" "--disable-shared" "--disable-host-shared" "--host=asmjs-unknown-emscripten" "--build=x86_64-unknown-linux-gnu" ... Invalid configuration `asmjs-unknown-emscripten': system `emscripten' not recognized ``` Undo change to libbacktrace configure script. Modify libstd build.rs to not build libbacktrace in the case of targeting emscripten. --- src/libstd/build.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/libstd/build.rs b/src/libstd/build.rs index 8fb49a1be4ea6..a1144a964fd37 100644 --- a/src/libstd/build.rs +++ b/src/libstd/build.rs @@ -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); }