core: Remove struct ctors

Author: brson

src/libcore/comm.rs

@@ -99,7 +99,6 @@ fn listen<T: send, U>(f: fn(Chan<T>) -> U) -> U {
 
 struct PortPtr<T:send> {
   let po: *rust_port;
-  new(po: *rust_port) { self.po = po; }
   drop unsafe {
       do task::unkillable {
         // Once the port is detached it's guaranteed not to receive further
@@ -122,6 +121,12 @@ struct PortPtr<T:send> {
   }
 }
 
+fn PortPtr<T: send>(po: *rust_port) -> PortPtr<T> {
+    PortPtr {
+        po: po
+    }
+}
+
 /**
  * Internal function for converting from a channel to a port
  *
@@ -134,14 +139,19 @@ fn as_raw_port<T: send, U>(ch: comm::Chan<T>, f: fn(*rust_port) -> U) -> U {
 
     struct PortRef {
        let p: *rust_port;
-       new(p: *rust_port) { self.p = p; }
        drop {
          if !ptr::is_null(self.p) {
            rustrt::rust_port_drop(self.p);
          }
        }
     }
 
+    fn PortRef(p: *rust_port) -> PortRef {
+        PortRef {
+            p: p
+        }
+    }
+
     let p = PortRef(rustrt::rust_port_take(*ch));
 
     if ptr::is_null(p.p) {

src/libcore/io.rs

@@ -247,10 +247,15 @@ impl<T: Reader, C> {base: T, cleanup: C}: Reader {
 
 struct FILERes {
     let f: *libc::FILE;
-    new(f: *libc::FILE) { self.f = f; }
     drop { libc::fclose(self.f); }
 }
 
+fn FILERes(f: *libc::FILE) -> FILERes {
+    FILERes {
+        f: f
+    }
+}
+
 fn FILE_reader(f: *libc::FILE, cleanup: bool) -> Reader {
     if cleanup {
         {base: f, cleanup: FILERes(f)} as Reader
@@ -417,10 +422,15 @@ impl fd_t: Writer {
 
 struct FdRes {
     let fd: fd_t;
-    new(fd: fd_t) { self.fd = fd; }
     drop { libc::close(self.fd); }
 }
 
+fn FdRes(fd: fd_t) -> FdRes {
+    FdRes {
+        fd: fd
+    }
+}
+
 fn fd_writer(fd: fd_t, cleanup: bool) -> Writer {
     if cleanup {
         {base: fd, cleanup: FdRes(fd)} as Writer
@@ -768,7 +778,6 @@ mod fsync {
     // Artifacts that need to fsync on destruction
     struct Res<t> {
         let arg: Arg<t>;
-        new(-arg: Arg<t>) { self.arg <- arg; }
         drop {
           match self.arg.opt_level {
             option::None => (),
@@ -780,6 +789,12 @@ mod fsync {
         }
     }
 
+    fn Res<t>(-arg: Arg<t>) -> Res<t>{
+        Res {
+            arg: move arg
+        }
+    }
+
     type Arg<t> = {
         val: t,
         opt_level: Option<Level>,

src/libcore/option.rs

@@ -292,9 +292,15 @@ fn test_unwrap_str() {
 fn test_unwrap_resource() {
     struct R {
        let i: @mut int;
-       new(i: @mut int) { self.i = i; }
        drop { *(self.i) += 1; }
     }
+
+    fn R(i: @mut int) -> R {
+        R {
+            i: i
+        }
+    }
+
     let i = @mut 0;
     {
         let x = R(i);

src/libcore/pipes.rs

@@ -135,12 +135,16 @@ struct BufferHeader {
     // get away with restricting it to 0 or 1, if we're careful.
     let mut ref_count: int;
 
-    new() { self.ref_count = 0; }
-
     // We may want a drop, and to be careful about stringing this
     // thing along.
 }
 
+fn BufferHeader() -> BufferHeader{
+    BufferHeader {
+        ref_count: 0
+    }
+}
+
 // XXX remove me
 #[cfg(stage0)]
 fn buffer_header() -> BufferHeader { BufferHeader() }
@@ -160,12 +164,6 @@ struct PacketHeader {
     // to a buffer_header if need be.
     let mut buffer: *libc::c_void;
 
-    new() {
-        self.state = Empty;
-        self.blocked_task = ptr::null();
-        self.buffer = ptr::null();
-    }
-
     // Returns the old state.
     unsafe fn mark_blocked(this: *rust_task) -> State {
         rustrt::rust_task_ref(this);
@@ -197,6 +195,14 @@ struct PacketHeader {
     }
 }
 
+fn PacketHeader() -> PacketHeader {
+    PacketHeader {
+        state: Empty,
+        blocked_task: ptr::null(),
+        buffer: ptr::null()
+    }
+}
+
 #[doc(hidden)]
 type Packet<T: send> = {
     header: PacketHeader,
@@ -368,12 +374,6 @@ unsafe fn get_buffer<T: send>(p: *PacketHeader) -> ~Buffer<T> {
 // This could probably be done with SharedMutableState to avoid move_it!().
 struct BufferResource<T: send> {
     let buffer: ~Buffer<T>;
-    new(+b: ~Buffer<T>) {
-        //let p = ptr::addr_of(*b);
-        //error!("take %?", p);
-        atomic_add_acq(&mut b.header.ref_count, 1);
-        self.buffer = b;
-    }
 
     drop unsafe {
         let b = move_it!(self.buffer);
@@ -392,6 +392,16 @@ struct BufferResource<T: send> {
     }
 }
 
+fn BufferResource<T: send>(+b: ~Buffer<T>) -> BufferResource<T> {
+    //let p = ptr::addr_of(*b);
+    //error!("take %?", p);
+    atomic_add_acq(&mut b.header.ref_count, 1);
+
+    BufferResource {
+        buffer: b
+    }
+}
+
 #[doc(hidden)]
 fn send<T: send, Tbuffer: send>(+p: SendPacketBuffered<T, Tbuffer>,
                                 +payload: T) -> bool {
@@ -770,15 +780,6 @@ fn send_packet<T: send>(p: *packet<T>) -> SendPacket<T> {
 struct SendPacketBuffered<T: send, Tbuffer: send> {
     let mut p: Option<*Packet<T>>;
     let mut buffer: Option<BufferResource<Tbuffer>>;
-    new(p: *Packet<T>) {
-        //debug!("take send %?", p);
-        self.p = Some(p);
-        unsafe {
-            self.buffer = Some(
-                BufferResource(
-                    get_buffer(ptr::addr_of((*p).header))));
-        };
-    }
     drop {
         //if self.p != none {
         //    debug!("drop send %?", option::get(self.p));
@@ -819,6 +820,18 @@ struct SendPacketBuffered<T: send, Tbuffer: send> {
     }
 }
 
+fn SendPacketBuffered<T: send, Tbuffer: send>(p: *Packet<T>)
+    -> SendPacketBuffered<T, Tbuffer> {
+        //debug!("take send %?", p);
+    SendPacketBuffered {
+        p: Some(p),
+        buffer: unsafe {
+            Some(BufferResource(
+                get_buffer(ptr::addr_of((*p).header))))
+        }
+    }
+}
+
 // XXX remove me
 #[cfg(stage0)]
 #[allow(non_camel_case_types)]
@@ -848,15 +861,6 @@ fn recv_packet<T: send>(p: *packet<T>) -> RecvPacket<T> {
 struct RecvPacketBuffered<T: send, Tbuffer: send> : Selectable {
     let mut p: Option<*Packet<T>>;
     let mut buffer: Option<BufferResource<Tbuffer>>;
-    new(p: *Packet<T>) {
-        //debug!("take recv %?", p);
-        self.p = Some(p);
-        unsafe {
-            self.buffer = Some(
-                BufferResource(
-                    get_buffer(ptr::addr_of((*p).header))));
-        };
-    }
     drop {
         //if self.p != none {
         //    debug!("drop recv %?", option::get(self.p));
@@ -897,6 +901,18 @@ struct RecvPacketBuffered<T: send, Tbuffer: send> : Selectable {
     }
 }
 
+fn RecvPacketBuffered<T: send, Tbuffer: send>(p: *Packet<T>)
+    -> RecvPacketBuffered<T, Tbuffer> {
+    //debug!("take recv %?", p);
+    RecvPacketBuffered {
+        p: Some(p),
+        buffer: unsafe {
+            Some(BufferResource(
+                get_buffer(ptr::addr_of((*p).header))))
+        }
+    }
+}
+
 // XXX remove me
 #[cfg(stage0)]
 #[allow(non_camel_case_types)]
@@ -1083,8 +1099,6 @@ impl<T: send> Port<T>: Recv<T> {
 struct PortSet<T: send> : Recv<T> {
     let mut ports: ~[pipes::Port<T>];
 
-    new() { self.ports = ~[]; }
-
     fn add(+port: pipes::Port<T>) {
         vec::push(self.ports, port)
     }
@@ -1131,6 +1145,12 @@ struct PortSet<T: send> : Recv<T> {
     }
 }
 
+fn PortSet<T: send>() -> PortSet<T>{
+    PortSet {
+        ports: ~[]
+    }
+}
+
 impl<T: send> Port<T>: Selectable {
     pure fn header() -> *PacketHeader unchecked {
         match self.endp {

src/libcore/priv.rs

@@ -196,11 +196,16 @@ unsafe fn weaken_task(f: fn(comm::Port<()>)) {
 
     struct Unweaken {
       let ch: comm::Chan<()>;
-      new(ch: comm::Chan<()>) { self.ch = ch; }
       drop unsafe {
         rustrt::rust_task_unweaken(unsafe::reinterpret_cast(&self.ch));
       }
     }
+
+    fn Unweaken(ch: comm::Chan<()>) -> Unweaken {
+        Unweaken {
+            ch: ch
+        }
+    }
 }
 
 #[test]

src/libcore/rand.rs

@@ -245,10 +245,15 @@ impl Rng {
 
 struct RandRes {
     let c: *rctx;
-    new(c: *rctx) { self.c = c; }
     drop { rustrt::rand_free(self.c); }
 }
 
+fn RandRes(c: *rctx) -> RandRes {
+    RandRes {
+        c: c
+    }
+}
+
 impl @RandRes: Rng {
     fn next() -> u32 { return rustrt::rand_next((*self).c); }
 }

src/libcore/run.rs

@@ -228,10 +228,15 @@ fn start_program(prog: &str, args: &[~str]) -> Program {
     }
     struct ProgRes {
         let r: ProgRepr;
-        new(+r: ProgRepr) { self.r = r; }
         drop { destroy_repr(&self.r); }
     }
 
+    fn ProgRes(+r: ProgRepr) -> ProgRes {
+        ProgRes {
+            r: r
+        }
+    }
+
     impl ProgRes: Program {
         fn get_id() -> pid_t { return self.r.pid; }
         fn input() -> io::Writer { io::fd_writer(self.r.in_fd, false) }

src/libcore/stackwalk.rs

@@ -8,9 +8,11 @@ type Word = uint;
 
 struct Frame {
     let fp: *Word;
+}
 
-    new(fp: *Word) {
-        self.fp = fp;
+fn Frame(fp: *Word) -> Frame {
+    Frame {
+        fp: fp
     }
 }