rollup merge of #22319: huonw/send-is-not-static

Conflicts:
	src/libstd/sync/task_pool.rs
	src/libstd/thread.rs
	src/libtest/lib.rs
	src/test/bench/shootout-reverse-complement.rs
	src/test/bench/shootout-spectralnorm.rs

24 files changed, 122 insertions, 181 deletions

diff --git a/src/test/auxiliary/cci_capture_clause.rs b/src/test/auxiliary/cci_capture_clause.rs
index 29a6ce59658..b38e955231e 100644
--- a/src/test/auxiliary/cci_capture_clause.rs
+++ b/src/test/auxiliary/cci_capture_clause.rs
@@ -11,7 +11,7 @@
 use std::thread;
 use std::sync::mpsc::{Receiver, channel};
 
-pub fn foo<T:Send + Clone>(x: T) -> Receiver<T> {
+pub fn foo<T:'static + Send + Clone>(x: T) -> Receiver<T> {
     let (tx, rx) = channel();
     thread::spawn(move|| {
         tx.send(x.clone());
diff --git a/src/test/bench/shootout-reverse-complement.rs b/src/test/bench/shootout-reverse-complement.rs
index 3d8b6e82848..33d959dfe93 100644
--- a/src/test/bench/shootout-reverse-complement.rs
+++ b/src/test/bench/shootout-reverse-complement.rs
@@ -229,21 +229,12 @@ unsafe impl<T: 'static> Send for Racy<T> {}
 
 /// Executes a closure in parallel over the given iterator over mutable slice.
 /// The closure `f` is run in parallel with an element of `iter`.
-fn parallel<'a, I, T, F>(iter: I, f: F)
-        where T: 'a+Send + Sync,
-              I: Iterator<Item=&'a mut [T]>,
-              F: Fn(&mut [T]) + Sync {
-    use std::mem;
-    use std::raw::Repr;
-
-    iter.map(|chunk| {
-        // Need to convert `f` and `chunk` to something that can cross the task
-        // boundary.
-        let f = Racy(&f as *const F as *const uint);
-        let raw = Racy(chunk.repr());
-        thread::spawn(move|| {
-            let f = f.0 as *const F;
-            unsafe { (*f)(mem::transmute(raw.0)) }
+fn parallel<'a, I: Iterator, F>(iter: I, ref f: F)
+        where I::Item: Send + 'a,
+              F: Fn(I::Item) + Sync + 'a {
+    iter.map(|x| {
+        thread::scoped(move|| {
+            f(x)
         })
     }).collect::<Vec<_>>();
 }
diff --git a/src/test/bench/shootout-spectralnorm.rs b/src/test/bench/shootout-spectralnorm.rs
index 4b59015f8aa..76ba5acb16c 100644
--- a/src/test/bench/shootout-spectralnorm.rs
+++ b/src/test/bench/shootout-spectralnorm.rs
@@ -112,26 +112,16 @@ fn dot(v: &[f64], u: &[f64]) -> f64 {
 }
 
 
-struct Racy<T>(T);
-
-unsafe impl<T: 'static> Send for Racy<T> {}
-
 // Executes a closure in parallel over the given mutable slice. The closure `f`
 // is run in parallel and yielded the starting index within `v` as well as a
 // sub-slice of `v`.
-fn parallel<T, F>(v: &mut [T], f: F)
-                  where T: Send + Sync,
-                        F: Fn(uint, &mut [T]) + Sync {
+fn parallel<'a,T, F>(v: &mut [T], ref f: F)
+                  where T: Send + Sync + 'a,
+                        F: Fn(uint, &mut [T]) + Sync + 'a {
     let size = v.len() / os::num_cpus() + 1;
-
     v.chunks_mut(size).enumerate().map(|(i, chunk)| {
-        // Need to convert `f` and `chunk` to something that can cross the task
-        // boundary.
-        let f = Racy(&f as *const _ as *const uint);
-        let raw = Racy(chunk.repr());
-        thread::spawn(move|| {
-            let f = f.0 as *const F;
-            unsafe { (*f)(i * size, mem::transmute(raw.0)) }
+        thread::scoped(move|| {
+            f(i * size, chunk)
         })
     }).collect::<Vec<_>>();
 }
diff --git a/src/test/compile-fail/builtin-superkinds-simple.rs b/src/test/compile-fail/builtin-superkinds-simple.rs
index c7b75ade555..c3fb6a1be87 100644
--- a/src/test/compile-fail/builtin-superkinds-simple.rs
+++ b/src/test/compile-fail/builtin-superkinds-simple.rs
@@ -13,7 +13,7 @@
 
 trait Foo : Send { }
 
-impl <'a> Foo for &'a mut () { }
-//~^ ERROR the type `&'a mut ()` does not fulfill the required lifetime
+impl Foo for std::rc::Rc<i8> { }
+//~^ ERROR the trait `core::marker::Send` is not implemented
 
 fn main() { }
diff --git a/src/test/compile-fail/coherence-impls-builtin.rs b/src/test/compile-fail/coherence-impls-builtin.rs
index 2ca288b60a3..38730d241f6 100644
--- a/src/test/compile-fail/coherence-impls-builtin.rs
+++ b/src/test/compile-fail/coherence-impls-builtin.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(optin_builtin_traits)]
+
 use std::marker::Send;
 
 enum TestE {
@@ -16,18 +18,21 @@ enum TestE {
 
 struct MyType;
 
+struct NotSync;
+impl !Sync for NotSync {}
+
 unsafe impl Send for TestE {}
 unsafe impl Send for MyType {}
 unsafe impl Send for (MyType, MyType) {}
 //~^ ERROR builtin traits can only be implemented on structs or enums
 
-unsafe impl Send for &'static MyType {}
+unsafe impl Send for &'static NotSync {}
 //~^ ERROR builtin traits can only be implemented on structs or enums
 
 unsafe impl Send for [MyType] {}
 //~^ ERROR builtin traits can only be implemented on structs or enums
 
-unsafe impl Send for &'static [MyType] {}
+unsafe impl Send for &'static [NotSync] {}
 //~^ ERROR builtin traits can only be implemented on structs or enums
 
 fn is_send<T: Send>() {}
diff --git a/src/test/compile-fail/kindck-impl-type-params.rs b/src/test/compile-fail/kindck-impl-type-params.rs
index de7639c6213..d5276efa8be 100644
--- a/src/test/compile-fail/kindck-impl-type-params.rs
+++ b/src/test/compile-fail/kindck-impl-type-params.rs
@@ -17,7 +17,7 @@ struct S<T>;
 
 trait Gettable<T> {}
 
-impl<T: Send + Copy> Gettable<T> for S<T> {}
+impl<T: Send + Copy + 'static> Gettable<T> for S<T> {}
 
 fn f<T>(val: T) {
     let t: S<T> = S;
diff --git a/src/test/compile-fail/kindck-send-object.rs b/src/test/compile-fail/kindck-send-object.rs
index 7984b3b32c2..570f7ad7fe3 100644
--- a/src/test/compile-fail/kindck-send-object.rs
+++ b/src/test/compile-fail/kindck-send-object.rs
@@ -20,7 +20,7 @@ trait Message : Send { }
 
 fn object_ref_with_static_bound_not_ok() {
     assert_send::<&'static (Dummy+'static)>();
-    //~^ ERROR the trait `core::marker::Send` is not implemented
+    //~^ ERROR the trait `core::marker::Sync` is not implemented
 }
 
 fn box_object_with_no_bound_not_ok<'a>() {
@@ -28,7 +28,7 @@ fn box_object_with_no_bound_not_ok<'a>() {
 }
 
 fn object_with_send_bound_ok() {
-    assert_send::<&'static (Dummy+Send)>();
+    assert_send::<&'static (Dummy+Sync)>();
     assert_send::<Box<Dummy+Send>>();
 }
 
diff --git a/src/test/compile-fail/kindck-send-object1.rs b/src/test/compile-fail/kindck-send-object1.rs
index 3d47d33d7c3..48d5215b708 100644
--- a/src/test/compile-fail/kindck-send-object1.rs
+++ b/src/test/compile-fail/kindck-send-object1.rs
@@ -12,22 +12,22 @@
 // is broken into two parts because some errors occur in distinct
 // phases in the compiler. See kindck-send-object2.rs as well!
 
-fn assert_send<T:Send>() { }
+fn assert_send<T:Send+'static>() { }
 trait Dummy { }
 
 // careful with object types, who knows what they close over...
 fn test51<'a>() {
     assert_send::<&'a Dummy>();
-    //~^ ERROR the trait `core::marker::Send` is not implemented
+    //~^ ERROR the trait `core::marker::Sync` is not implemented
 }
 fn test52<'a>() {
-    assert_send::<&'a (Dummy+Send)>();
+    assert_send::<&'a (Dummy+Sync)>();
     //~^ ERROR does not fulfill the required lifetime
 }
 
 // ...unless they are properly bounded
 fn test60() {
-    assert_send::<&'static (Dummy+Send)>();
+    assert_send::<&'static (Dummy+Sync)>();
 }
 fn test61() {
     assert_send::<Box<Dummy+Send>>();
diff --git a/src/test/compile-fail/kindck-send-object2.rs b/src/test/compile-fail/kindck-send-object2.rs
index 75bae09b37f..d3d166e2a69 100644
--- a/src/test/compile-fail/kindck-send-object2.rs
+++ b/src/test/compile-fail/kindck-send-object2.rs
@@ -14,7 +14,7 @@ fn assert_send<T:Send>() { }
 trait Dummy { }
 
 fn test50() {
-    assert_send::<&'static Dummy>(); //~ ERROR the trait `core::marker::Send` is not implemented
+    assert_send::<&'static Dummy>(); //~ ERROR the trait `core::marker::Sync` is not implemented
 }
 
 fn test53() {
@@ -23,7 +23,7 @@ fn test53() {
 
 // ...unless they are properly bounded
 fn test60() {
-    assert_send::<&'static (Dummy+Send)>();
+    assert_send::<&'static (Dummy+Sync)>();
 }
 fn test61() {
     assert_send::<Box<Dummy+Send>>();
diff --git a/src/test/compile-fail/kindck-send-owned.rs b/src/test/compile-fail/kindck-send-owned.rs
index 266b6156656..406711902a5 100644
--- a/src/test/compile-fail/kindck-send-owned.rs
+++ b/src/test/compile-fail/kindck-send-owned.rs
@@ -18,8 +18,8 @@ fn test31() { assert_send::<String>(); }
 fn test32() { assert_send::<Vec<isize> >(); }
 
 // but not if they own a bad thing
-fn test40<'a>(_: &'a isize) {
-    assert_send::<Box<&'a isize>>(); //~ ERROR does not fulfill the required lifetime
+fn test40() {
+    assert_send::<Box<*mut u8>>(); //~ ERROR `core::marker::Send` is not implemented
 }
 
 fn main() { }
diff --git a/src/test/compile-fail/kindck-send-region-pointers.rs b/src/test/compile-fail/kindck-send-region-pointers.rs
deleted file mode 100644
index e2a5b0678a6..00000000000
--- a/src/test/compile-fail/kindck-send-region-pointers.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-// 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 <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.
-
-// Test that borrowed pointers are not sendable unless 'static.
-
-fn assert_send<T:Send>() { }
-
-// lifetime pointers with 'static lifetime are ok
-fn test01() { assert_send::<&'static isize>(); }
-fn test02() { assert_send::<&'static str>(); }
-fn test03() { assert_send::<&'static [isize]>(); }
-
-// whether or not they are mutable
-fn test10() { assert_send::<&'static mut isize>(); }
-
-// otherwise lifetime pointers are not ok
-fn test20<'a>(_: &'a isize) {
-    assert_send::<&'a isize>(); //~ ERROR does not fulfill the required lifetime
-}
-fn test21<'a>(_: &'a isize) {
-    assert_send::<&'a str>(); //~ ERROR does not fulfill the required lifetime
-}
-fn test22<'a>(_: &'a isize) {
-    assert_send::<&'a [isize]>(); //~ ERROR does not fulfill the required lifetime
-}
-
-fn main() { }
diff --git a/src/test/compile-fail/regions-bounded-by-send.rs b/src/test/compile-fail/regions-bounded-by-send.rs
deleted file mode 100644
index 71254e15d32..00000000000
--- a/src/test/compile-fail/regions-bounded-by-send.rs
+++ /dev/null
@@ -1,83 +0,0 @@
-// Copyright 2012 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.
-
-// Test which of the builtin types are considered sendable. The tests
-// in this file all test region bound and lifetime violations that are
-// detected during type check.
-
-extern crate core;
-use core::ptr::Unique;
-
-fn assert_send<T:Send>() { }
-trait Dummy:Send { }
-
-// lifetime pointers with 'static lifetime are ok
-
-fn static_lifime_ok<'a,T,U:Send>(_: &'a isize) {
-    assert_send::<&'static isize>();
-    assert_send::<&'static str>();
-    assert_send::<&'static [isize]>();
-
-    // whether or not they are mutable
-    assert_send::<&'static mut isize>();
-}
-
-// otherwise lifetime pointers are not ok
-
-fn param_not_ok<'a>(x: &'a isize) {
-    assert_send::<&'a isize>(); //~ ERROR does not fulfill the required lifetime
-}
-
-fn param_not_ok1<'a>(_: &'a isize) {
-    assert_send::<&'a str>(); //~ ERROR does not fulfill the required lifetime
-}
-
-fn param_not_ok2<'a>(_: &'a isize) {
-    assert_send::<&'a [isize]>(); //~ ERROR does not fulfill the required lifetime
-}
-
-// boxes are ok
-
-fn box_ok() {
-    assert_send::<Box<isize>>();
-    assert_send::<String>();
-    assert_send::<Vec<isize>>();
-}
-
-// but not if they own a bad thing
-
-fn box_with_region_not_ok<'a>() {
-    assert_send::<Box<&'a isize>>(); //~ ERROR does not fulfill the required lifetime
-}
-
-// objects with insufficient bounds no ok
-
-fn object_with_random_bound_not_ok<'a>() {
-    assert_send::<&'a (Dummy+'a)>();
-    //~^ ERROR reference has a longer lifetime
-}
-
-fn object_with_send_bound_not_ok<'a>() {
-    assert_send::<&'a (Dummy+Send)>();
-    //~^ ERROR does not fulfill the required lifetime
-}
-
-// unsafe pointers are ok unless they point at unsendable things
-
-struct UniqueUnsafePtr(Unique<*const isize>);
-
-unsafe impl Send for UniqueUnsafePtr {}
-
-fn unsafe_ok1<'a>(_: &'a isize) {
-    assert_send::<UniqueUnsafePtr>();
-}
-
-fn main() {
-}
diff --git a/src/test/compile-fail/regions-pattern-typing-issue-19552.rs b/src/test/compile-fail/regions-pattern-typing-issue-19552.rs
index 57ea607cbf6..3401dd1becd 100644
--- a/src/test/compile-fail/regions-pattern-typing-issue-19552.rs
+++ b/src/test/compile-fail/regions-pattern-typing-issue-19552.rs
@@ -8,11 +8,11 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn assert_send<T: Send>(_t: T) {}
+fn assert_static<T: 'static>(_t: T) {}
 
 fn main() {
     let line = String::new();
     match [&*line] { //~ ERROR `line` does not live long enough
-        [ word ] => { assert_send(word); }
+        [ word ] => { assert_static(word); }
     }
 }
diff --git a/src/test/compile-fail/send-is-not-static-ensures-scoping.rs b/src/test/compile-fail/send-is-not-static-ensures-scoping.rs
new file mode 100755
index 00000000000..0b74892d66c
--- /dev/null
+++ b/src/test/compile-fail/send-is-not-static-ensures-scoping.rs
@@ -0,0 +1,25 @@
+// 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 <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.
+
+#![feature(core, std_misc)]
+use std::thread::Thread;
+
+fn main() {
+    let bad = {
+        let x = 1;
+        let y = &x;
+
+        Thread::scoped(|| { //~ ERROR cannot infer an appropriate lifetime
+            let _z = y;
+        })
+    };
+
+    bad.join().ok().unwrap();
+}
diff --git a/src/test/compile-fail/trait-bounds-cant-coerce.rs b/src/test/compile-fail/trait-bounds-cant-coerce.rs
index 89e89cf8246..79174552ae0 100644
--- a/src/test/compile-fail/trait-bounds-cant-coerce.rs
+++ b/src/test/compile-fail/trait-bounds-cant-coerce.rs
@@ -22,7 +22,7 @@ fn c(x: Box<Foo+Sync+Send>) {
 fn d(x: Box<Foo>) {
     a(x); //~  ERROR mismatched types
           //~| expected `Box<Foo + Send>`
-          //~| found `Box<Foo + 'static>`
+          //~| found `Box<Foo>`
           //~| expected bounds `Send`
           //~| found no bounds
 }
diff --git a/src/test/run-pass/builtin-superkinds-capabilities-transitive.rs b/src/test/run-pass/builtin-superkinds-capabilities-transitive.rs
index 3df9dd25d86..379ac12a954 100644
--- a/src/test/run-pass/builtin-superkinds-capabilities-transitive.rs
+++ b/src/test/run-pass/builtin-superkinds-capabilities-transitive.rs
@@ -22,7 +22,7 @@ trait Foo : Bar { }
 impl <T: Send> Foo for T { }
 impl <T: Send> Bar for T { }
 
-fn foo<T: Foo>(val: T, chan: Sender<T>) {
+fn foo<T: Foo + 'static>(val: T, chan: Sender<T>) {
     chan.send(val).unwrap();
 }
 
diff --git a/src/test/run-pass/builtin-superkinds-capabilities-xc.rs b/src/test/run-pass/builtin-superkinds-capabilities-xc.rs
index 52b826393e9..cd019c21a3d 100644
--- a/src/test/run-pass/builtin-superkinds-capabilities-xc.rs
+++ b/src/test/run-pass/builtin-superkinds-capabilities-xc.rs
@@ -25,7 +25,7 @@ struct X<T>(T);
 impl <T: Sync> RequiresShare for X<T> { }
 impl <T: Sync+Send> RequiresRequiresShareAndSend for X<T> { }
 
-fn foo<T: RequiresRequiresShareAndSend>(val: T, chan: Sender<T>) {
+fn foo<T: RequiresRequiresShareAndSend + 'static>(val: T, chan: Sender<T>) {
     chan.send(val).unwrap();
 }
 
diff --git a/src/test/run-pass/builtin-superkinds-capabilities.rs b/src/test/run-pass/builtin-superkinds-capabilities.rs
index 034e5ff2d3a..dc61508eec4 100644
--- a/src/test/run-pass/builtin-superkinds-capabilities.rs
+++ b/src/test/run-pass/builtin-superkinds-capabilities.rs
@@ -18,7 +18,7 @@ trait Foo : Send { }
 
 impl <T: Send> Foo for T { }
 
-fn foo<T: Foo>(val: T, chan: Sender<T>) {
+fn foo<T: Foo + 'static>(val: T, chan: Sender<T>) {
     chan.send(val).unwrap();
 }
 
diff --git a/src/test/run-pass/builtin-superkinds-self-type.rs b/src/test/run-pass/builtin-superkinds-self-type.rs
index 1b3070ba3b0..1d05a7baa53 100644
--- a/src/test/run-pass/builtin-superkinds-self-type.rs
+++ b/src/test/run-pass/builtin-superkinds-self-type.rs
@@ -13,13 +13,13 @@
 
 use std::sync::mpsc::{Sender, channel};
 
-trait Foo : Send + Sized {
+trait Foo : Send + Sized + 'static {
     fn foo(self, tx: Sender<Self>) {
         tx.send(self).unwrap();
     }
 }
 
-impl <T: Send> Foo for T { }
+impl <T: Send + 'static> Foo for T { }
 
 pub fn main() {
     let (tx, rx) = channel();
diff --git a/src/test/run-pass/issue-18188.rs b/src/test/run-pass/issue-18188.rs
index 7a5a86822af..a4b09eb08e0 100644
--- a/src/test/run-pass/issue-18188.rs
+++ b/src/test/run-pass/issue-18188.rs
@@ -14,12 +14,12 @@ use std::thunk::Thunk;
 
 pub trait Promisable: Send + Sync {}
 impl<T: Send + Sync> Promisable for T {}
-pub fn propagate<T, E, F, G>(action: F) -> Thunk<Result<T, E>, Result<T, E>>
+pub fn propagate<'a, T, E, F, G>(action: F) -> Thunk<'a,Result<T, E>, Result<T, E>>
     where
-        T: Promisable + Clone,
-        E: Promisable + Clone,
-        F: FnOnce(&T) -> Result<T, E> + Send,
-        G: FnOnce(Result<T, E>) -> Result<T, E> {
+        T: Promisable + Clone + 'a,
+        E: Promisable + Clone + 'a,
+        F: FnOnce(&T) -> Result<T, E> + Send + 'a,
+        G: FnOnce(Result<T, E>) -> Result<T, E> + 'a {
     Thunk::with_arg(move |result: Result<T, E>| {
         match result {
             Ok(ref t) => action(t),
diff --git a/src/test/run-pass/issue-21058.rs b/src/test/run-pass/issue-21058.rs
index 044d43a57fa..3cdd57aed5a 100644
--- a/src/test/run-pass/issue-21058.rs
+++ b/src/test/run-pass/issue-21058.rs
@@ -14,7 +14,7 @@ struct DST { a: u32, b: str }
 
 fn main() {
     // get_tydesc should support unsized types
-    assert!(unsafe {(
+    assert_eq!(unsafe {(
         // Slice
         (*std::intrinsics::get_tydesc::<[u8]>()).name,
         // str
@@ -25,5 +25,5 @@ fn main() {
         (*std::intrinsics::get_tydesc::<NT>()).name,
         // DST
         (*std::intrinsics::get_tydesc::<DST>()).name
-    )} == ("[u8]", "str", "core::marker::Copy + 'static", "NT", "DST"));
+    )}, ("[u8]", "str", "core::marker::Copy", "NT", "DST"));
 }
diff --git a/src/test/run-pass/issue-2190-1.rs b/src/test/run-pass/issue-2190-1.rs
index 810bf385d7e..3025741694f 100644
--- a/src/test/run-pass/issue-2190-1.rs
+++ b/src/test/run-pass/issue-2190-1.rs
@@ -13,11 +13,11 @@ use std::thunk::Thunk;
 
 static generations: uint = 1024+256+128+49;
 
-fn spawn(f: Thunk) {
+fn spawn(f: Thunk<'static>) {
     Builder::new().stack_size(32 * 1024).spawn(move|| f.invoke(()));
 }
 
-fn child_no(x: uint) -> Thunk {
+fn child_no(x: uint) -> Thunk<'static> {
     Thunk::new(move|| {
         if x < generations {
             spawn(child_no(x+1));
diff --git a/src/test/run-pass/send-is-not-static-par-for.rs b/src/test/run-pass/send-is-not-static-par-for.rs
new file mode 100755
index 00000000000..c6b64d97fbd
--- /dev/null
+++ b/src/test/run-pass/send-is-not-static-par-for.rs
@@ -0,0 +1,47 @@
+// Copyright 2015 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.
+
+#![feature(core, std_misc)]
+use std::thread::Thread;
+use std::sync::Mutex;
+
+fn par_for<I, F>(iter: I, f: F)
+    where I: Iterator,
+          <I as Iterator>::Item: Send,
+          F: Fn(<I as Iterator>::Item) + Sync
+{
+    let f = &f;
+    let _guards: Vec<_> = iter.map(|elem| {
+        Thread::scoped(move || {
+            f(elem)
+        })
+    }).collect();
+
+}
+
+fn sum(x: &[i32]) {
+    let sum_lengths = Mutex::new(0);
+    par_for(x.windows(4), |x| {
+        *sum_lengths.lock().unwrap() += x.len()
+    });
+
+    assert_eq!(*sum_lengths.lock().unwrap(), (x.len() - 3) * 4);
+}
+
+fn main() {
+    let mut elements = [0; 20];
+
+    // iterators over references into this stack frame
+    par_for(elements.iter_mut().enumerate(), |(i, x)| {
+        *x = i as i32
+    });
+
+    sum(&elements)
+}
diff --git a/src/test/run-pass/send-type-inference.rs b/src/test/run-pass/send-type-inference.rs
index ae992a0a358..60093803f0b 100644
--- a/src/test/run-pass/send-type-inference.rs
+++ b/src/test/run-pass/send-type-inference.rs
@@ -16,7 +16,7 @@ struct Command<K, V> {
     val: V
 }
 
-fn cache_server<K:Send,V:Send>(mut tx: Sender<Sender<Command<K, V>>>) {
+fn cache_server<K:Send+'static,V:Send+'static>(mut tx: Sender<Sender<Command<K, V>>>) {
     let (tx1, _rx) = channel();
     tx.send(tx1);
 }