convert most of libcore records into structs

Author: erickt

src/libcore/gc.rs

@@ -87,7 +87,10 @@ unsafe fn get_safe_point_count() -> uint {
     return *module_meta;
 }
 
-type SafePoint = { sp_meta: *Word, fn_meta: *Word };
+struct SafePoint {
+    sp_meta: *Word,
+    fn_meta: *Word,
+}
 
 // Returns the safe point metadata for the given program counter, if
 // any.
@@ -106,7 +109,10 @@ unsafe fn is_safe_point(pc: *Word) -> Option<SafePoint> {
         let sp: **Word = bump(safe_points, spi*3);
         let sp_loc = *sp;
         if sp_loc == pc {
-            return Some({sp_meta: *bump(sp, 1), fn_meta: *bump(sp, 2)});
+            return Some(SafePoint {
+                sp_meta: *bump(sp, 1),
+                fn_meta: *bump(sp, 2),
+            });
         }
         spi += 1;
     }

src/libcore/io.rs

@@ -1086,11 +1086,9 @@ pub fn read_whole_file(file: &Path) -> Result<~[u8], ~str> {
 // fsync related
 
 pub mod fsync {
+    use prelude::*;
     use io::{FILERes, FdRes, fd_t};
-    use kinds::Copy;
     use libc;
-    use option::Option;
-    use option;
     use os;
 
     pub enum Level {
@@ -1127,19 +1125,19 @@ pub mod fsync {
         }
     }
 
-    pub type Arg<t> = {
+    pub struct Arg<t> {
         val: t,
         opt_level: Option<Level>,
-        fsync_fn: fn@(f: t, Level) -> int
-    };
+        fsync_fn: fn@(f: t, Level) -> int,
+    }
 
     // fsync file after executing blk
     // FIXME (#2004) find better way to create resources within lifetime of
     // outer res
     pub fn FILE_res_sync(file: &FILERes, opt_level: Option<Level>,
                          blk: fn(v: Res<*libc::FILE>)) {
         unsafe {
-            blk(move Res({
+            blk(Res(Arg {
                 val: file.f, opt_level: opt_level,
                 fsync_fn: fn@(file: *libc::FILE, l: Level) -> int {
                     unsafe {
@@ -1153,7 +1151,7 @@ pub mod fsync {
     // fsync fd after executing blk
     pub fn fd_res_sync(fd: &FdRes, opt_level: Option<Level>,
                        blk: fn(v: Res<fd_t>)) {
-        blk(move Res({
+        blk(Res(Arg {
             val: fd.fd, opt_level: opt_level,
             fsync_fn: fn@(fd: fd_t, l: Level) -> int {
                 return os::fsync_fd(fd, l) as int;
@@ -1167,7 +1165,7 @@ pub mod fsync {
     // Call o.fsync after executing blk
     pub fn obj_sync(o: FSyncable, opt_level: Option<Level>,
                     blk: fn(v: Res<FSyncable>)) {
-        blk(Res({
+        blk(Res(Arg {
             val: o, opt_level: opt_level,
             fsync_fn: fn@(o: FSyncable, l: Level) -> int {
                 return o.fsync(l);

src/libcore/rand.rs

@@ -42,7 +42,10 @@ pub trait Rng {
 }
 
 /// A value with a particular weight compared to other values
-pub type Weighted<T> = { weight: uint, item: T };
+pub struct Weighted<T> {
+    weight: uint,
+    item: T,
+}
 
 /// Extension methods for random number generators
 impl Rng {
@@ -312,12 +315,12 @@ pub fn seeded_rng(seed: &~[u8]) -> Rng {
     }
 }
 
-type XorShiftState = {
+struct XorShiftState {
     mut x: u32,
     mut y: u32,
     mut z: u32,
-    mut w: u32
-};
+    mut w: u32,
+}
 
 impl XorShiftState: Rng {
     fn next() -> u32 {
@@ -338,7 +341,7 @@ pub pure fn xorshift() -> Rng {
 }
 
 pub pure fn seeded_xorshift(x: u32, y: u32, z: u32, w: u32) -> Rng {
-    {mut x: x, mut y: y, mut z: z, mut w: w} as Rng
+    XorShiftState { x: x, y: y, z: z, w: w } as Rng
 }
 
 
@@ -492,21 +495,24 @@ pub mod tests {
     #[test]
     pub fn choose_weighted() {
         let r = rand::Rng();
-        assert r.choose_weighted(~[{weight: 1u, item: 42}]) == 42;
         assert r.choose_weighted(~[
-            {weight: 0u, item: 42},
-            {weight: 1u, item: 43}
+            rand::Weighted { weight: 1u, item: 42 },
+        ]) == 42;
+        assert r.choose_weighted(~[
+            rand::Weighted { weight: 0u, item: 42 },
+            rand::Weighted { weight: 1u, item: 43 },
         ]) == 43;
     }
 
     #[test]
     pub fn choose_weighted_option() {
         let r = rand::Rng();
-        assert r.choose_weighted_option(~[{weight: 1u, item: 42}]) ==
-               Some(42);
         assert r.choose_weighted_option(~[
-            {weight: 0u, item: 42},
-            {weight: 1u, item: 43}
+            rand::Weighted { weight: 1u, item: 42 },
+        ]) == Some(42);
+        assert r.choose_weighted_option(~[
+            rand::Weighted { weight: 0u, item: 42 },
+            rand::Weighted { weight: 1u, item: 43 },
         ]) == Some(43);
         let v: Option<int> = r.choose_weighted_option([]);
         assert v.is_none();
@@ -518,9 +524,9 @@ pub mod tests {
         let empty: ~[int] = ~[];
         assert r.weighted_vec(~[]) == empty;
         assert r.weighted_vec(~[
-            {weight: 0u, item: 3u},
-            {weight: 1u, item: 2u},
-            {weight: 2u, item: 1u}
+            rand::Weighted { weight: 0u, item: 3u },
+            rand::Weighted { weight: 1u, item: 2u },
+            rand::Weighted { weight: 2u, item: 1u },
         ]) == ~[2u, 1u, 1u];
     }
 

src/libcore/run.rs

@@ -220,11 +220,13 @@ pub fn start_program(prog: &str, args: &[~str]) -> Program {
             libc::close(pipe_err.out);
         }
 
-        type ProgRepr = {pid: pid_t,
-                         mut in_fd: c_int,
-                         out_file: *libc::FILE,
-                         err_file: *libc::FILE,
-                         mut finished: bool};
+        struct ProgRepr {
+            pid: pid_t,
+            mut in_fd: c_int,
+            out_file: *libc::FILE,
+            err_file: *libc::FILE,
+            mut finished: bool,
+        }
 
         fn close_repr_input(r: &ProgRepr) {
             let invalid_fd = -1i32;
@@ -274,12 +276,15 @@ pub fn start_program(prog: &str, args: &[~str]) -> Program {
             fn finish() -> int { finish_repr(&self.r) }
             fn destroy() { destroy_repr(&self.r); }
         }
-        let repr = {pid: pid,
-                    mut in_fd: pipe_input.out,
-                    out_file: os::fdopen(pipe_output.in),
-                    err_file: os::fdopen(pipe_err.in),
-                    mut finished: false};
-        return ProgRes(move repr) as Program;
+        let repr = ProgRepr {
+            pid: pid,
+            in_fd: pipe_input.out,
+            out_file: os::fdopen(pipe_output.in),
+            err_file: os::fdopen(pipe_err.in),
+            finished: false,
+        };
+
+        ProgRes(repr) as Program
     }
 }
 

src/libcore/task/mod.rs

@@ -168,10 +168,10 @@ impl SchedMode : cmp::Eq {
  *     default these foreign stacks have unspecified size, but with this
  *     option their size can be precisely specified.
  */
-pub type SchedOpts = {
+pub struct SchedOpts {
     mode: SchedMode,
-    foreign_stack_size: Option<uint>
-};
+    foreign_stack_size: Option<uint>,
+}
 
 /**
  * Task configuration options
@@ -200,12 +200,12 @@ pub type SchedOpts = {
  *     into foreign code that blocks. Without doing so in a different
  *     scheduler other tasks will be impeded or even blocked indefinitely.
  */
-pub type TaskOpts = {
+pub struct TaskOpts {
     linked: bool,
     supervised: bool,
     mut notify_chan: Option<Chan<TaskResult>>,
     sched: Option<SchedOpts>,
-};
+}
 
 /**
  * The task builder type.
@@ -251,15 +251,15 @@ priv impl TaskBuilder {
         self.consumed = true;
         let notify_chan = replace(&mut self.opts.notify_chan, None);
         TaskBuilder {
-            opts: {
+            opts: TaskOpts {
                 linked: self.opts.linked,
                 supervised: self.opts.supervised,
-                mut notify_chan: move notify_chan,
+                notify_chan: notify_chan,
                 sched: self.opts.sched
             },
             gen_body: self.gen_body,
             can_not_copy: None,
-            mut consumed: false
+            consumed: false
         }
     }
 }
@@ -272,10 +272,10 @@ impl TaskBuilder {
     fn unlinked() -> TaskBuilder {
         let notify_chan = replace(&mut self.opts.notify_chan, None);
         TaskBuilder {
-            opts: {
+            opts: TaskOpts {
                 linked: false,
                 supervised: self.opts.supervised,
-                mut notify_chan: move notify_chan,
+                notify_chan: notify_chan,
                 sched: self.opts.sched
             },
             can_not_copy: None,
@@ -290,10 +290,10 @@ impl TaskBuilder {
     fn supervised() -> TaskBuilder {
         let notify_chan = replace(&mut self.opts.notify_chan, None);
         TaskBuilder {
-            opts: {
+            opts: TaskOpts {
                 linked: false,
                 supervised: true,
-                mut notify_chan: move notify_chan,
+                notify_chan: notify_chan,
                 sched: self.opts.sched
             },
             can_not_copy: None,
@@ -307,10 +307,10 @@ impl TaskBuilder {
     fn linked() -> TaskBuilder {
         let notify_chan = replace(&mut self.opts.notify_chan, None);
         TaskBuilder {
-            opts: {
+            opts: TaskOpts {
                 linked: true,
                 supervised: false,
-                mut notify_chan: move notify_chan,
+                notify_chan: notify_chan,
                 sched: self.opts.sched
             },
             can_not_copy: None,
@@ -352,10 +352,10 @@ impl TaskBuilder {
 
         // Reconfigure self to use a notify channel.
         TaskBuilder {
-            opts: {
+            opts: TaskOpts {
                 linked: self.opts.linked,
                 supervised: self.opts.supervised,
-                mut notify_chan: Some(move notify_pipe_ch),
+                notify_chan: Some(notify_pipe_ch),
                 sched: self.opts.sched
             },
             can_not_copy: None,
@@ -366,11 +366,14 @@ impl TaskBuilder {
     fn sched_mode(mode: SchedMode) -> TaskBuilder {
         let notify_chan = replace(&mut self.opts.notify_chan, None);
         TaskBuilder {
-            opts: {
+            opts: TaskOpts {
                 linked: self.opts.linked,
                 supervised: self.opts.supervised,
-                mut notify_chan: move notify_chan,
-                sched: Some({ mode: mode, foreign_stack_size: None})
+                notify_chan: notify_chan,
+                sched: Some(SchedOpts {
+                    mode: mode,
+                    foreign_stack_size: None,
+                })
             },
             can_not_copy: None,
             .. self.consume()
@@ -393,10 +396,10 @@ impl TaskBuilder {
         let prev_gen_body = self.gen_body;
         let notify_chan = replace(&mut self.opts.notify_chan, None);
         TaskBuilder {
-            opts: {
+            opts: TaskOpts {
                 linked: self.opts.linked,
                 supervised: self.opts.supervised,
-                mut notify_chan: move notify_chan,
+                notify_chan: notify_chan,
                 sched: self.opts.sched
             },
             // tjc: I think this is the line that gets miscompiled
@@ -424,10 +427,10 @@ impl TaskBuilder {
     fn spawn(f: fn~()) {
         let notify_chan = replace(&mut self.opts.notify_chan, None);
         let x = self.consume();
-        let opts = {
+        let opts = TaskOpts {
             linked: x.opts.linked,
             supervised: x.opts.supervised,
-            mut notify_chan: move notify_chan,
+            notify_chan: notify_chan,
             sched: x.opts.sched
         };
         spawn::spawn_raw(move opts, (x.gen_body)(move f));
@@ -482,10 +485,10 @@ pub fn default_task_opts() -> TaskOpts {
      * into the same scheduler, and do not post lifecycle notifications.
      */
 
-    {
+    TaskOpts {
         linked: true,
         supervised: false,
-        mut notify_chan: None,
+        notify_chan: None,
         sched: None
     }
 }