Remove 'let' syntax for struct fields

Author: brson

src/libcore/comm.rs

@@ -98,7 +98,7 @@ fn listen<T: send, U>(f: fn(Chan<T>) -> U) -> U {
 }
 
 struct PortPtr<T:send> {
-  let po: *rust_port;
+    po: *rust_port,
   drop unsafe {
       do task::unkillable {
         // Once the port is detached it's guaranteed not to receive further
@@ -138,7 +138,7 @@ fn PortPtr<T: send>(po: *rust_port) -> PortPtr<T> {
 fn as_raw_port<T: send, U>(ch: comm::Chan<T>, f: fn(*rust_port) -> U) -> U {
 
     struct PortRef {
-       let p: *rust_port;
+        p: *rust_port,
        drop {
          if !ptr::is_null(self.p) {
            rustrt::rust_port_drop(self.p);

src/libcore/gc.rs

@@ -36,9 +36,9 @@ export cleanup_stack_for_failure;
 
 // Mirrors rust_stack.h stk_seg
 struct StackSegment {
-    let prev: *StackSegment;
-    let next: *StackSegment;
-    let end: uintptr_t;
+    prev: *StackSegment,
+    next: *StackSegment,
+    end: uintptr_t,
     // And other fields which we don't care about...
 }
 

src/libcore/io.rs

@@ -246,7 +246,7 @@ impl<T: Reader, C> {base: T, cleanup: C}: Reader {
 }
 
 struct FILERes {
-    let f: *libc::FILE;
+    f: *libc::FILE,
     drop { libc::fclose(self.f); }
 }
 
@@ -422,7 +422,7 @@ impl fd_t: Writer {
 }
 
 struct FdRes {
-    let fd: fd_t;
+    fd: fd_t,
     drop { libc::close(self.fd); }
 }
 
@@ -778,7 +778,7 @@ mod fsync {
 
     // Artifacts that need to fsync on destruction
     struct Res<t> {
-        let arg: Arg<t>;
+        arg: Arg<t>,
         drop {
           match self.arg.opt_level {
             option::None => (),

src/libcore/option.rs

@@ -292,7 +292,7 @@ fn test_unwrap_str() {
 #[test]
 fn test_unwrap_resource() {
     struct R {
-       let i: @mut int;
+       i: @mut int,
        drop { *(self.i) += 1; }
     }
 

src/libcore/pipes.rs

@@ -134,7 +134,7 @@ impl State: Eq {
 struct BufferHeader {
     // Tracks whether this buffer needs to be freed. We can probably
     // get away with restricting it to 0 or 1, if we're careful.
-    let mut ref_count: int;
+    mut ref_count: int,
 
     // We may want a drop, and to be careful about stringing this
     // thing along.
@@ -158,12 +158,12 @@ type Buffer<T: send> = {
 };
 
 struct PacketHeader {
-    let mut state: State;
-    let mut blocked_task: *rust_task;
+    mut state: State,
+    mut blocked_task: *rust_task,
 
     // This is a reinterpret_cast of a ~buffer, that can also be cast
     // to a buffer_header if need be.
-    let mut buffer: *libc::c_void;
+    mut buffer: *libc::c_void,
 
     // Returns the old state.
     unsafe fn mark_blocked(this: *rust_task) -> State {
@@ -374,7 +374,7 @@ 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>;
+    buffer: ~Buffer<T>,
 
     drop unsafe {
         let b = move_it!(self.buffer);
@@ -779,8 +779,8 @@ 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>>;
+    mut p: Option<*Packet<T>>,
+    mut buffer: Option<BufferResource<Tbuffer>>,
     drop {
         //if self.p != none {
         //    debug!("drop send %?", option::get(self.p));
@@ -860,8 +860,8 @@ 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>>;
+    mut p: Option<*Packet<T>>,
+    mut buffer: Option<BufferResource<Tbuffer>>,
     drop {
         //if self.p != none {
         //    debug!("drop recv %?", option::get(self.p));
@@ -1098,7 +1098,7 @@ impl<T: send> Port<T>: Recv<T> {
 
 /// Treat many ports as one.
 struct PortSet<T: send> : Recv<T> {
-    let mut ports: ~[pipes::Port<T>];
+    mut ports: ~[pipes::Port<T>],
 
     fn add(+port: pipes::Port<T>) {
         vec::push(self.ports, port)

src/libcore/priv.rs

@@ -195,7 +195,7 @@ unsafe fn weaken_task(f: fn(comm::Port<()>)) {
     f(po);
 
     struct Unweaken {
-      let ch: comm::Chan<()>;
+      ch: comm::Chan<()>,
       drop unsafe {
         rustrt::rust_task_unweaken(unsafe::reinterpret_cast(&self.ch));
       }

src/libcore/rand.rs

@@ -244,7 +244,7 @@ impl Rng {
 }
 
 struct RandRes {
-    let c: *rctx;
+    c: *rctx,
     drop { rustrt::rand_free(self.c); }
 }
 

src/libcore/run.rs

@@ -227,7 +227,7 @@ fn start_program(prog: &str, args: &[~str]) -> Program {
        libc::fclose(r.err_file);
     }
     struct ProgRes {
-        let r: ProgRepr;
+        r: ProgRepr,
         drop { destroy_repr(&self.r); }
     }
 

src/libcore/stackwalk.rs

@@ -7,7 +7,7 @@ use sys::size_of;
 type Word = uint;
 
 struct Frame {
-    let fp: *Word;
+    fp: *Word
 }
 
 fn Frame(fp: *Word) -> Frame {

src/libcore/task.rs

@@ -610,7 +610,7 @@ fn get_task() -> Task {
  */
 unsafe fn unkillable<U>(f: fn() -> U) -> U {
     struct AllowFailure {
-        let t: *rust_task;
+        t: *rust_task,
         drop { rustrt::rust_task_allow_kill(self.t); }
     }
 
@@ -629,7 +629,7 @@ unsafe fn unkillable<U>(f: fn() -> U) -> U {
 /// The inverse of unkillable. Only ever to be used nested in unkillable().
 unsafe fn rekillable<U>(f: fn() -> U) -> U {
     struct DisallowFailure {
-        let t: *rust_task;
+        t: *rust_task,
         drop { rustrt::rust_task_inhibit_kill(self.t); }
     }
 
@@ -651,7 +651,7 @@ unsafe fn rekillable<U>(f: fn() -> U) -> U {
  */
 unsafe fn atomically<U>(f: fn() -> U) -> U {
     struct DeferInterrupts {
-        let t: *rust_task;
+        t: *rust_task,
         drop {
             rustrt::rust_task_allow_yield(self.t);
             rustrt::rust_task_allow_kill(self.t);
@@ -948,13 +948,13 @@ fn each_ancestor(list:        &mut AncestorList,
 
 // One of these per task.
 struct TCB {
-    let me:            *rust_task;
+    me:            *rust_task,
     // List of tasks with whose fates this one's is intertwined.
-    let tasks:         TaskGroupArc; // 'none' means the group has failed.
+    tasks:         TaskGroupArc, // 'none' means the group has failed.
     // Lists of tasks who will kill us if they fail, but whom we won't kill.
-    let mut ancestors: AncestorList;
-    let is_main:       bool;
-    let notifier:      Option<AutoNotify>;
+    mut ancestors: AncestorList,
+    is_main:       bool,
+    notifier:      Option<AutoNotify>,
     // Runs on task exit.
     drop {
         // If we are failing, the whole taskgroup needs to die.
@@ -995,8 +995,8 @@ fn TCB(me: *rust_task, +tasks: TaskGroupArc, +ancestors: AncestorList,
 }
 
 struct AutoNotify {
-    let notify_chan: comm::Chan<Notification>;
-    let mut failed:  bool;
+    notify_chan: comm::Chan<Notification>,
+    mut failed:  bool,
     drop {
         let result = if self.failed { Failure } else { Success };
         comm::send(self.notify_chan, Exit(get_task(), result));

src/libcore/unsafe.rs

@@ -280,7 +280,7 @@ extern mod rustrt {
 }
 
 struct LittleLock {
-    let l: rust_little_lock;
+    l: rust_little_lock,
     drop { rustrt::rust_destroy_little_lock(self.l); }
 }
 
@@ -294,7 +294,7 @@ impl LittleLock {
     #[inline(always)]
     unsafe fn lock<T>(f: fn() -> T) -> T {
         struct Unlock {
-            let l: rust_little_lock;
+            l: rust_little_lock,
             drop { rustrt::rust_unlock_little_lock(self.l); }
         }
 

src/libstd/c_vec.rs

@@ -43,7 +43,7 @@ enum CVec<T> {
 }
 
 struct DtorRes {
-  let dtor: Option<fn@()>;
+  dtor: Option<fn@()>,
   drop {
     match self.dtor {
       option::None => (),

src/libstd/net_tcp.rs

@@ -39,7 +39,7 @@ extern mod rustrt {
  * data structure that is used for read/write operations over a TCP stream.
  */
 struct TcpSocket {
-  let socket_data: @TcpSocketData;
+  socket_data: @TcpSocketData,
   drop {
     unsafe {
         tear_down_socket_data(self.socket_data)
@@ -60,7 +60,7 @@ fn TcpSocket(socket_data: @TcpSocketData) -> TcpSocket {
  * satisfy both the `io::reader` and `io::writer` traits.
  */
 struct TcpSocketBuf {
-  let data: @TcpBufferedSocketData;
+    data: @TcpBufferedSocketData,
 }
 
 fn TcpSocketBuf(data: @TcpBufferedSocketData) -> TcpSocketBuf {

src/libsyntax/ext/pipes/proto.rs

@@ -129,11 +129,11 @@ fn protocol_(name: ~str, span: span) -> protocol_ {
 }
 
 struct protocol_ {
-    let name: ~str;
-    let span: span;
-    let states: DVec<state>;
+    name: ~str,
+    span: span,
+    states: DVec<state>,
 
-    let mut bounded: Option<bool>;
+    mut bounded: Option<bool>,
 
     /// Get a state.
     fn get_state(name: ~str) -> state {

src/libsyntax/parse/parser.rs

@@ -213,21 +213,21 @@ fn parser(sess: parse_sess, cfg: ast::crate_cfg,
 }
 
 struct parser {
-    let sess: parse_sess;
-    let cfg: crate_cfg;
-    let file_type: file_type;
-    let mut token: token::token;
-    let mut span: span;
-    let mut last_span: span;
-    let mut buffer: [mut {tok: token::token, sp: span}]/4;
-    let mut buffer_start: int;
-    let mut buffer_end: int;
-    let mut restriction: restriction;
-    let mut quote_depth: uint; // not (yet) related to the quasiquoter
-    let reader: reader;
-    let interner: interner<@~str>;
-    let keywords: hashmap<~str, ()>;
-    let restricted_keywords: hashmap<~str, ()>;
+    sess: parse_sess,
+    cfg: crate_cfg,
+    file_type: file_type,
+    mut token: token::token,
+    mut span: span,
+    mut last_span: span,
+    mut buffer: [mut {tok: token::token, sp: span}]/4,
+    mut buffer_start: int,
+    mut buffer_end: int,
+    mut restriction: restriction,
+    mut quote_depth: uint, // not (yet) related to the quasiquoter
+    reader: reader,
+    interner: interner<@~str>,
+    keywords: hashmap<~str, ()>,
+    restricted_keywords: hashmap<~str, ()>,
 
     drop {} /* do not copy the parser; its state is tied to outside state */
 
@@ -2726,8 +2726,7 @@ struct parser {
     }
 
     fn parse_single_class_item(vis: visibility) -> @class_member {
-        if (self.eat_keyword(~"let") ||
-                self.token_is_keyword(~"mut", copy self.token) ||
+        if (self.token_is_keyword(~"mut", copy self.token) ||
                 !self.is_any_keyword(copy self.token)) &&
                 !self.token_is_pound_or_doc_comment(self.token) {
             let a_var = self.parse_instance_var(vis);

src/rustc/driver/rustc.rs

@@ -241,7 +241,7 @@ fn monitor(+f: fn~(diagnostic::emitter)) {
         };
 
         struct finally {
-            let ch: comm::Chan<monitor_msg>;
+            ch: comm::Chan<monitor_msg>,
             drop { comm::send(self.ch, done); }
         }
 

src/rustc/lib/llvm.rs

@@ -1175,7 +1175,7 @@ fn fn_ty_param_tys(fn_ty: TypeRef) -> ~[TypeRef] unsafe {
 /* Memory-managed interface to target data. */
 
 struct target_data_res {
-    let TD: TargetDataRef;
+    TD: TargetDataRef,
     drop { llvm::LLVMDisposeTargetData(self.TD); }
 }
 
@@ -1196,7 +1196,7 @@ fn mk_target_data(string_rep: ~str) -> target_data {
 /* Memory-managed interface to pass managers. */
 
 struct pass_manager_res {
-    let PM: PassManagerRef;
+    PM: PassManagerRef,
     drop { llvm::LLVMDisposePassManager(self.PM); }
 }
 
@@ -1216,7 +1216,7 @@ fn mk_pass_manager() -> pass_manager {
 /* Memory-managed interface to object files. */
 
 struct object_file_res {
-    let ObjectFile: ObjectFileRef;
+    ObjectFile: ObjectFileRef,
     drop { llvm::LLVMDisposeObjectFile(self.ObjectFile); }
 }
 
@@ -1237,7 +1237,7 @@ fn mk_object_file(llmb: MemoryBufferRef) -> Option<object_file> {
 /* Memory-managed interface to section iterators. */
 
 struct section_iter_res {
-    let SI: SectionIteratorRef;
+    SI: SectionIteratorRef,
     drop { llvm::LLVMDisposeSectionIterator(self.SI); }
 }
 

src/rustc/metadata/decoder.rs

@@ -440,9 +440,9 @@ fn def_like_to_def(def_like: def_like) -> ast::def {
 // A path.
 struct path_entry {
     // The full path, separated by '::'.
-    let path_string: ~str;
+    path_string: ~str,
     // The definition, implementation, or field that this path corresponds to.
-    let def_like: def_like;
+    def_like: def_like,
 }
 
 fn path_entry(path_string: ~str, def_like: def_like) -> path_entry {