Register new snapshots

Author: alexcrichton

src/doc/complement-cheatsheet.md

@@ -152,7 +152,7 @@ struct Foo {
 }
 
 struct FooClosure<'a> {
-    myfunc: 'a |int, uint| -> i32
+    myfunc: |int, uint|: 'a -> i32
 }
 
 fn a(a: int, b: uint) -> i32 {

src/doc/rust.md

@@ -3415,7 +3415,7 @@ fn add(x: int, y: int) -> int {
 
 let mut x = add(5,7);
 
-type Binop<'a> = 'a |int,int| -> int;
+type Binop<'a> = |int,int|: 'a -> int;
 let bo: Binop = add;
 x = bo(5,7);
 ~~~~

src/libcollections/deque.rs

@@ -96,7 +96,7 @@ pub mod bench {
             map.insert(*k, 1);
         }
 
-        rng.shuffle_mut(keys);
+        rng.shuffle(keys);
 
         // measure
         let mut i = 0;

src/libgreen/basic.rs

@@ -27,7 +27,7 @@ pub fn event_loop() -> ~EventLoop:Send {
 }
 
 struct BasicLoop {
-    work: ~[proc:Send()],             // pending work
+    work: ~[proc():Send],             // pending work
     idle: Option<*mut BasicPausable>, // only one is allowed
     remotes: ~[(uint, ~Callback:Send)],
     next_remote: uint,
@@ -135,7 +135,7 @@ impl EventLoop for BasicLoop {
         }
     }
 
-    fn callback(&mut self, f: proc:Send()) {
+    fn callback(&mut self, f: proc():Send) {
         self.work.push(f);
     }
 

src/liblibc/lib.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 #![feature(globs)]
-#![crate_id = "libc#0.10-pre"]
+#![crate_id = "libc#0.11-pre"]
 #![experimental]
 #![no_std] // we don't need std, and we can't have std, since it doesn't exist
            // yet. std depends on us.
@@ -75,8 +75,6 @@
 #![allow(missing_doc)]
 #![allow(uppercase_variables)]
 
-#![feature(link_args)] // NOTE: remove after stage0
-
 #[cfg(test)] extern crate std;
 #[cfg(test)] extern crate test;
 #[cfg(test)] extern crate native;
@@ -199,11 +197,6 @@ pub use funcs::posix88::unistd::{rmdir, unlink, write};
 #[link(name = "m")]
 extern {}
 
-// NOTE: remove this after a stage0 snap
-#[cfg(stage0, windows)]
-#[link_args = "-Wl,--enable-long-section-names"]
-extern {}
-
 /// A wrapper for a nullable pointer. Don't use this except for interacting
 /// with libc. Basically Option, but without the dependance on libstd.
 // If/when libprim happens, this can be removed in favor of that

src/libnative/io/p

@@ -580,7 +580,7 @@ fn spawn_process_os(config: p::ProcessConfig,
 }
 
 #[cfg(unix)]
-fn with_argv<T>(prog: &str, args: &[~str], cb: proc:(**libc::c_char) -> T) -> T {
+fn with_argv<T>(prog: &str, args: &[~str], cb: proc(**libc::c_char) -> T) -> T {
     use std::slice;
 
     // We can't directly convert `str`s into `*char`s, as someone needs to hold
@@ -606,7 +606,7 @@ fn with_argv<T>(prog: &str, args: &[~str], cb: proc:(**libc::c_char) -> T) -> T
 }
 
 #[cfg(unix)]
-fn with_envp<T>(env: Option<~[(~str, ~str)]>, cb: proc:(*c_void) -> T) -> T {
+fn with_envp<T>(env: Option<~[(~str, ~str)]>, cb: proc(*c_void) -> T) -> T {
     use std::slice;
 
     // On posixy systems we can pass a char** for envp, which is a

src/libnative/io/process.rs

@@ -50,13 +50,13 @@ fn ops() -> ~Ops {
 }
 
 /// Spawns a function with the default configuration
-pub fn spawn(f: proc:Send()) {
+pub fn spawn(f: proc():Send) {
     spawn_opts(TaskOpts::new(), f)
 }
 
 /// Spawns a new task given the configuration options and a procedure to run
 /// inside the task.
-pub fn spawn_opts(opts: TaskOpts, f: proc:Send()) {
+pub fn spawn_opts(opts: TaskOpts, f: proc():Send) {
     let TaskOpts {
         notify_chan, name, stack_size,
         stderr, stdout,
@@ -238,7 +238,7 @@ impl rt::Runtime for Ops {
         }
     }
 
-    fn spawn_sibling(~self, mut cur_task: ~Task, opts: TaskOpts, f: proc:Send()) {
+    fn spawn_sibling(~self, mut cur_task: ~Task, opts: TaskOpts, f: proc():Send) {
         cur_task.put_runtime(self);
         Local::put(cur_task);
 

src/libnative/task.rs

@@ -209,8 +209,8 @@ fn ziggurat<R:Rng>(
             symmetric: bool,
             x_tab: ziggurat_tables::ZigTable,
             f_tab: ziggurat_tables::ZigTable,
-            pdf: 'static |f64| -> f64,
-            zero_case: 'static |&mut R, f64| -> f64)
+            pdf: |f64|: 'static -> f64,
+            zero_case: |&mut R, f64|: 'static -> f64)
             -> f64 {
     static SCALE: f64 = (1u64 << 53) as f64;
     loop {

src/librand/distributions/mod.rs

@@ -801,7 +801,7 @@ mod test {
     #[test]
     fn test_shuffle() {
         let mut r = task_rng();
-        let mut empty: &mut [int] = &mut [];
+        let empty: &mut [int] = &mut [];
         r.shuffle(empty);
         let mut one = [1];
         r.shuffle(one);

src/librand/lib.rs

@@ -13,7 +13,7 @@ use syntax::{ast, fold, attr};
 use syntax::codemap;
 
 struct Context<'a> {
-    in_cfg: 'a |attrs: &[ast::Attribute]| -> bool,
+    in_cfg: |attrs: &[ast::Attribute]|: 'a -> bool,
 }
 
 // Support conditional compilation by transforming the AST, stripping out

src/librustc/front/config.rs

@@ -364,7 +364,7 @@ fn parse_crate_attrs(sess: &session::Session, input: &d::Input) ->
 ///
 /// The diagnostic emitter yielded to the procedure should be used for reporting
 /// errors of the compiler.
-pub fn monitor(f: proc:Send()) {
+pub fn monitor(f: proc():Send) {
     // FIXME: This is a hack for newsched since it doesn't support split stacks.
     // rustc needs a lot of stack! When optimizations are disabled, it needs
     // even *more* stack than usual as well.

src/librustc/lib.rs

@@ -76,7 +76,7 @@ fn lookup_hash<'a>(d: ebml::Doc<'a>, eq_fn: |&[u8]| -> bool,
     ret
 }
 
-pub type GetCrateDataCb<'a> = 'a |ast::CrateNum| -> Cmd;
+pub type GetCrateDataCb<'a> = |ast::CrateNum|: 'a -> Cmd;
 
 pub fn maybe_find_item<'a>(item_id: ast::NodeId,
                            items: ebml::Doc<'a>) -> Option<ebml::Doc<'a>> {
@@ -637,11 +637,11 @@ pub fn get_item_path(cdata: Cmd, id: ast::NodeId) -> Vec<ast_map::PathElem> {
     item_path(lookup_item(id, cdata.data()))
 }
 
-pub type DecodeInlinedItem<'a> = 'a |cdata: @cstore::crate_metadata,
-                                     tcx: &ty::ctxt,
-                                     path: Vec<ast_map::PathElem>,
-                                     par_doc: ebml::Doc|
-                                     -> Result<ast::InlinedItem, Vec<ast_map::PathElem> >;
+pub type DecodeInlinedItem<'a> = |cdata: @cstore::crate_metadata,
+                                  tcx: &ty::ctxt,
+                                  path: Vec<ast_map::PathElem>,
+                                  par_doc: ebml::Doc|: 'a
+                                  -> Result<ast::InlinedItem, Vec<ast_map::PathElem> >;
 
 pub fn maybe_get_item_ast(cdata: Cmd, tcx: &ty::ctxt, id: ast::NodeId,
                           decode_inlined_item: DecodeInlinedItem)

src/librustc/metadata/decoder.rs

@@ -64,9 +64,9 @@ pub enum InlinedItemRef<'a> {
 
 pub type Encoder<'a> = writer::Encoder<'a, MemWriter>;
 
-pub type EncodeInlinedItem<'a> = 'a |ecx: &EncodeContext,
-                                     ebml_w: &mut Encoder,
-                                     ii: InlinedItemRef|;
+pub type EncodeInlinedItem<'a> = |ecx: &EncodeContext,
+                                  ebml_w: &mut Encoder,
+                                  ii: InlinedItemRef|: 'a;
 
 pub struct EncodeParams<'a> {
     pub diag: &'a SpanHandler,

src/librustc/metadata/encoder.rs

@@ -23,7 +23,7 @@ pub enum FileMatch { FileMatches, FileDoesntMatch }
 
 /// Functions with type `pick` take a parent directory as well as
 /// a file found in that directory.
-pub type pick<'a> = 'a |path: &Path| -> FileMatch;
+pub type pick<'a> = |path: &Path|: 'a -> FileMatch;
 
 pub struct FileSearch<'a> {
     pub sysroot: &'a Path,

src/librustc/metadata/filesearch.rs

@@ -54,7 +54,7 @@ pub enum DefIdSource {
     RegionParameter,
 }
 pub type conv_did<'a> =
-    'a |source: DefIdSource, ast::DefId| -> ast::DefId;
+    |source: DefIdSource, ast::DefId|: 'a -> ast::DefId;
 
 pub struct PState<'a> {
     data: &'a [u8],

src/librustc/metadata/tydecode.rs

@@ -503,7 +503,7 @@ fn assert_is_binding_or_wild(bcx: &Block, p: @ast::Pat) {
     }
 }
 
-type enter_pat<'a> = 'a |@ast::Pat| -> Option<Vec<@ast::Pat>>;
+type enter_pat<'a> = |@ast::Pat|: 'a -> Option<Vec<@ast::Pat>>;
 
 fn enter_match<'r,'b>(
                bcx: &'b Block<'b>,

src/librustc/middle/trans/_match.rs

@@ -613,7 +613,7 @@ pub fn compare_scalar_values<'a>(
 }
 
 pub type val_and_ty_fn<'r,'b> =
-    'r |&'b Block<'b>, ValueRef, ty::t| -> &'b Block<'b>;
+    |&'b Block<'b>, ValueRef, ty::t|: 'r -> &'b Block<'b>;
 
 // Iterates through the elements of a structural type.
 pub fn iter_structural_ty<'r,

src/librustc/middle/trans/base.rs

@@ -525,7 +525,7 @@ pub fn get_base_and_len(bcx: &Block,
 }
 
 pub type iter_vec_block<'r,'b> =
-    'r |&'b Block<'b>, ValueRef, ty::t| -> &'b Block<'b>;
+    |&'b Block<'b>, ValueRef, ty::t|: 'r -> &'b Block<'b>;
 
 pub fn iter_vec_loop<'r,
                      'b>(

src/librustc/middle/trans/tvec.rs

@@ -217,7 +217,7 @@ pub fn super_fold_trait_store<T:TypeFolder>(this: &mut T,
 
 pub struct BottomUpFolder<'a> {
     pub tcx: &'a ty::ctxt,
-    pub fldop: 'a |ty::t| -> ty::t,
+    pub fldop: |ty::t|: 'a -> ty::t,
 }
 
 impl<'a> TypeFolder for BottomUpFolder<'a> {
@@ -234,14 +234,14 @@ impl<'a> TypeFolder for BottomUpFolder<'a> {
 
 pub struct RegionFolder<'a> {
     tcx: &'a ty::ctxt,
-    fld_t: 'a |ty::t| -> ty::t,
-    fld_r: 'a |ty::Region| -> ty::Region,
+    fld_t: |ty::t|: 'a -> ty::t,
+    fld_r: |ty::Region|: 'a -> ty::Region,
 }
 
 impl<'a> RegionFolder<'a> {
     pub fn general(tcx: &'a ty::ctxt,
-                   fld_r: 'a |ty::Region| -> ty::Region,
-                   fld_t: 'a |ty::t| -> ty::t)
+                   fld_r: |ty::Region|: 'a -> ty::Region,
+                   fld_t: |ty::t|: 'a -> ty::t)
                    -> RegionFolder<'a> {
         RegionFolder {
             tcx: tcx,
@@ -250,7 +250,7 @@ impl<'a> RegionFolder<'a> {
         }
     }
 
-    pub fn regions(tcx: &'a ty::ctxt, fld_r: 'a |ty::Region| -> ty::Region)
+    pub fn regions(tcx: &'a ty::ctxt, fld_r: |ty::Region|: 'a -> ty::Region)
                    -> RegionFolder<'a> {
         fn noop(t: ty::t) -> ty::t { t }
 

src/librustc/middle/ty_fold.rs

@@ -86,7 +86,7 @@ pub fn relate_nested_regions(tcx: &ty::ctxt,
     struct RegionRelator<'a> {
         tcx: &'a ty::ctxt,
         stack: Vec<ty::Region>,
-        relate_op: 'a |ty::Region, ty::Region|,
+        relate_op: |ty::Region, ty::Region|: 'a,
     }
 
     // FIXME(#10151) -- Define more precisely when a region is

src/librustc/middle/typeck/check/regionmanip.rs

@@ -54,7 +54,7 @@ pub trait LatticeValue {
 }
 
 pub type LatticeOp<'a, T> =
-    'a |cf: &CombineFields, a: &T, b: &T| -> cres<T>;
+    |cf: &CombineFields, a: &T, b: &T|: 'a -> cres<T>;
 
 impl LatticeValue for ty::t {
     fn sub(cf: &CombineFields, a: &ty::t, b: &ty::t) -> ures {
@@ -407,7 +407,7 @@ pub fn super_lattice_tys<L:LatticeDir+TyLatticeDir+Combine>(this: &L,
     }
 }
 
-pub type LatticeDirOp<'a, T> = 'a |a: &T, b: &T| -> cres<T>;
+pub type LatticeDirOp<'a, T> = |a: &T, b: &T|: 'a -> cres<T>;
 
 #[deriving(Clone)]
 pub enum LatticeVarResult<V,T> {

src/librustc/middle/typeck/infer/lattice.rs

@@ -64,7 +64,7 @@ pub fn indenter() -> _indenter {
 }
 
 struct LoopQueryVisitor<'a> {
-    p: 'a |&ast::Expr_| -> bool,
+    p: |&ast::Expr_|: 'a -> bool,
     flag: bool,
 }
 
@@ -92,7 +92,7 @@ pub fn loop_query(b: &ast::Block, p: |&ast::Expr_| -> bool) -> bool {
 }
 
 struct BlockQueryVisitor<'a> {
-    p: 'a |&ast::Expr| -> bool,
+    p: |&ast::Expr|: 'a -> bool,
     flag: bool,
 }
 

src/librustc/util/common.rs

@@ -46,7 +46,7 @@ use raw;
 pub struct CVec<T> {
     base: *mut T,
     len: uint,
-    dtor: Option<proc:Send()>,
+    dtor: Option<proc():Send>,
 }
 
 #[unsafe_destructor]
@@ -90,7 +90,7 @@ impl<T> CVec<T> {
     /// * dtor - A proc to run when the value is destructed, useful
     ///          for freeing the buffer, etc.
     pub unsafe fn new_with_dtor(base: *mut T, len: uint,
-                                dtor: proc:Send()) -> CVec<T> {
+                                dtor: proc():Send) -> CVec<T> {
         assert!(base != ptr::mut_null());
         CVec {
             base: base,

src/libstd/c_vec.rs

@@ -141,7 +141,7 @@ mod tests {
     use io::*;
     use io::test::*;
 
-    pub fn smalltest(server: proc:Send(UnixStream), client: proc:Send(UnixStream)) {
+    pub fn smalltest(server: proc(UnixStream):Send, client: proc(UnixStream):Send) {
         let path1 = next_test_unix();
         let path2 = path1.clone();