libsyntax: De-mut the pipe compiler

pcwalton · pcwalton · commit 17dcaee9d13a · 2013-02-22T16:09:15.000-08:00
diff --git a/src/libsyntax/diagnostic.rs b/src/libsyntax/diagnostic.rs
@@ -158,7 +158,7 @@ pub fn mk_handler(emitter: Option<Emitter>) -> @handler {
         }
     };
 
-    @mut HandlerT { mut err_count: 0, emit: emit } as @handler
+    @mut HandlerT { err_count: 0, emit: emit } as @handler
 }
 
 #[deriving_eq]
diff --git a/src/libsyntax/ext/pipes/mod.rs b/src/libsyntax/ext/pipes/mod.rs
@@ -73,7 +73,7 @@ pub fn expand_proto(cx: ext_ctxt, _sp: span, id: ast::ident,
     let rdr = tt_rdr as reader;
     let rust_parser = Parser(sess, cfg, rdr.dup());
 
-    let proto = rust_parser.parse_proto(cx.str_of(id));
+    let mut proto = rust_parser.parse_proto(cx.str_of(id));
 
     // check for errors
     visit(proto, cx);
diff --git a/src/libsyntax/ext/pipes/pipec.rs b/src/libsyntax/ext/pipes/pipec.rs
@@ -27,8 +27,8 @@ use core::to_str::ToStr;
 use core::vec;
 
 pub trait gen_send {
-    fn gen_send(&self, cx: ext_ctxt, try: bool) -> @ast::item;
-    fn to_ty(&self, cx: ext_ctxt) -> @ast::Ty;
+    fn gen_send(&mut self, cx: ext_ctxt, try: bool) -> @ast::item;
+    fn to_ty(&mut self, cx: ext_ctxt) -> @ast::Ty;
 }
 
 pub trait to_type_decls {
@@ -47,7 +47,7 @@ pub trait gen_init {
 }
 
 pub impl gen_send for message {
-    fn gen_send(&self, cx: ext_ctxt, try: bool) -> @ast::item {
+    fn gen_send(&mut self, cx: ext_ctxt, try: bool) -> @ast::item {
         debug!("pipec: gen_send");
         match *self {
           message(ref _id, span, ref tys, this, Some(ref next_state)) => {
@@ -193,7 +193,7 @@ pub impl gen_send for message {
           }
         }
 
-    fn to_ty(&self, cx: ext_ctxt) -> @ast::Ty {
+    fn to_ty(&mut self, cx: ext_ctxt) -> @ast::Ty {
         cx.ty_path_ast_builder(path(~[cx.ident_of(self.name())], self.span())
           .add_tys(cx.ty_vars_global(self.get_params())))
     }
@@ -259,10 +259,14 @@ pub impl to_type_decls for state {
           recv => (*self).dir.reverse()
         };
         let mut items = ~[];
-        for self.messages.each |m| {
-            if dir == send {
-                items.push(m.gen_send(cx, true));
-                items.push(m.gen_send(cx, false));
+
+        {
+            let messages = &mut *self.messages;
+            for vec::each_mut(*messages) |m| {
+                if dir == send {
+                    items.push(m.gen_send(cx, true));
+                    items.push(m.gen_send(cx, false));
+                }
             }
         }
 
@@ -395,7 +399,8 @@ pub impl gen_init for protocol {
         }
 
         cx.ty_path_ast_builder(path(~[cx.ident_of(~"super"),
-                                      cx.ident_of(~"__Buffer")], self.span)
+                                      cx.ident_of(~"__Buffer")],
+                                    copy self.span)
                                .add_tys(cx.ty_vars_global(params)))
     }
 
@@ -453,12 +458,12 @@ pub impl gen_init for protocol {
         }
 
         items.push(cx.item_mod(cx.ident_of(~"client"),
-                               self.span,
+                               copy self.span,
                                client_states));
         items.push(cx.item_mod(cx.ident_of(~"server"),
-                               self.span,
+                               copy self.span,
                                server_states));
 
-        cx.item_mod(cx.ident_of(self.name), self.span, items)
+        cx.item_mod(cx.ident_of(self.name), copy self.span, items)
     }
 }
diff --git a/src/libsyntax/ext/pipes/proto.rs b/src/libsyntax/ext/pipes/proto.rs
@@ -16,7 +16,6 @@ use ext::base::ext_ctxt;
 use ext::pipes::ast_builder::{append_types, ext_ctxt_ast_builder, path};
 
 use core::cmp;
-use core::dvec::DVec;
 use core::to_str::ToStr;
 
 #[deriving_eq]
@@ -45,26 +44,24 @@ pub struct next_state {
     tys: ~[@ast::Ty],
 }
 
-pub enum message {
-    // name, span, data, current state, next state
-    message(~str, span, ~[@ast::Ty], state, Option<next_state>)
-}
+// name, span, data, current state, next state
+pub struct message(~str, span, ~[@ast::Ty], state, Option<next_state>);
 
 pub impl message {
-    fn name(&self) -> ~str {
+    fn name(&mut self) -> ~str {
         match *self {
           message(ref id, _, _, _, _) => (*id)
         }
     }
 
-    fn span(&self) -> span {
+    fn span(&mut self) -> span {
         match *self {
           message(_, span, _, _, _) => span
         }
     }
 
     /// Return the type parameters actually used by this message
-    fn get_params(&self) -> ~[ast::ty_param] {
+    fn get_params(&mut self) -> ~[ast::ty_param] {
         match *self {
           message(_, _, _, this, _) => this.ty_params
         }
@@ -80,7 +77,7 @@ pub struct state_ {
     span: span,
     dir: direction,
     ty_params: ~[ast::ty_param],
-    messages: DVec<message>,
+    messages: @mut ~[message],
     proto: protocol
 }
 
@@ -121,56 +118,56 @@ pub impl state_ {
     }
 }
 
-pub type protocol = @protocol_;
+pub type protocol = @mut protocol_;
 
 pub fn protocol(name: ~str, +span: span) -> protocol {
-    @protocol_(name, span)
+    @mut protocol_(name, span)
 }
 
 pub fn protocol_(name: ~str, span: span) -> protocol_ {
     protocol_ {
         name: name,
         span: span,
-        states: DVec(),
+        states: @mut ~[],
         bounded: None
     }
 }
 
 pub struct protocol_ {
     name: ~str,
     span: span,
-    states: DVec<state>,
+    states: @mut ~[state],
 
-    mut bounded: Option<bool>,
+    bounded: Option<bool>,
 }
 
 pub impl protocol_ {
     /// Get a state.
-    fn get_state(&self, name: ~str) -> state {
+    fn get_state(&mut self, name: ~str) -> state {
         self.states.find(|i| i.name == name).get()
     }
 
-    fn get_state_by_id(&self, id: uint) -> state { self.states[id] }
+    fn get_state_by_id(&mut self, id: uint) -> state { self.states[id] }
 
-    fn has_state(&self, name: ~str) -> bool {
+    fn has_state(&mut self, name: ~str) -> bool {
         self.states.find(|i| i.name == name).is_some()
     }
 
-    fn filename(&self) -> ~str {
+    fn filename(&mut self) -> ~str {
         ~"proto://" + self.name
     }
 
-    fn num_states(&self) -> uint { self.states.len() }
+    fn num_states(&mut self) -> uint { self.states.len() }
 
-    fn has_ty_params(&self) -> bool {
+    fn has_ty_params(&mut self) -> bool {
         for self.states.each |s| {
             if s.ty_params.len() > 0 {
                 return true;
             }
         }
         false
     }
-    fn is_bounded(&self) -> bool {
+    fn is_bounded(&mut self) -> bool {
         let bounded = self.bounded.get();
         bounded
     }
@@ -179,7 +176,7 @@ pub impl protocol_ {
 pub impl protocol {
     fn add_state_poly(&self, name: ~str, ident: ast::ident, dir: direction,
                       +ty_params: ~[ast::ty_param]) -> state {
-        let messages = DVec();
+        let messages = @mut ~[];
 
         let state = @state_ {
             id: self.states.len(),
diff --git a/src/libsyntax/ext/tt/transcribe.rs b/src/libsyntax/ext/tt/transcribe.rs
@@ -59,7 +59,7 @@ pub fn new_tt_reader(sp_diag: span_handler,
     let r = @mut TtReader {
         sp_diag: sp_diag,
         interner: itr,
-        mut cur: @mut TtFrame {
+        cur: @mut TtFrame {
             readme: @mut src,
             idx: 0u,
             dotdotdoted: false,

Original file line number	Diff line number	Diff line change
`@@ -158,7 +158,7 @@ pub fn mk_handler(emitter: Option<Emitter>) -> @handler {`
`158`	`158`	`}`
`159`	`159`	`};`
`160`	`160`
`161`		`- @mut HandlerT { mut err_count: 0, emit: emit } as @handler`
	`161`	`+ @mut HandlerT { err_count: 0, emit: emit } as @handler`
`162`	`162`	`}`
`163`	`163`
`164`	`164`	`#[deriving_eq]`
Original file line number	Diff line number	Diff line change
`@@ -27,8 +27,8 @@ use core::to_str::ToStr;`
`27`	`27`	`use core::vec;`
`28`	`28`
`29`	`29`	`pub trait gen_send {`
`30`		`- fn gen_send(&self, cx: ext_ctxt, try: bool) -> @ast::item;`
`31`		`- fn to_ty(&self, cx: ext_ctxt) -> @ast::Ty;`
	`30`	`+ fn gen_send(&mut self, cx: ext_ctxt, try: bool) -> @ast::item;`
	`31`	`+ fn to_ty(&mut self, cx: ext_ctxt) -> @ast::Ty;`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`pub trait to_type_decls {`
`@@ -47,7 +47,7 @@ pub trait gen_init {`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`pub impl gen_send for message {`
`50`		`- fn gen_send(&self, cx: ext_ctxt, try: bool) -> @ast::item {`
	`50`	`+ fn gen_send(&mut self, cx: ext_ctxt, try: bool) -> @ast::item {`
`51`	`51`	`debug!("pipec: gen_send");`
`52`	`52`	`match *self {`
`53`	`53`	`message(ref _id, span, ref tys, this, Some(ref next_state)) => {`
`@@ -193,7 +193,7 @@ pub impl gen_send for message {`
`193`	`193`	`}`
`194`	`194`	`}`
`195`	`195`
`196`		`- fn to_ty(&self, cx: ext_ctxt) -> @ast::Ty {`
	`196`	`+ fn to_ty(&mut self, cx: ext_ctxt) -> @ast::Ty {`
`197`	`197`	`cx.ty_path_ast_builder(path(~[cx.ident_of(self.name())], self.span())`
`198`	`198`	`.add_tys(cx.ty_vars_global(self.get_params())))`
`199`	`199`	`}`
`@@ -259,10 +259,14 @@ pub impl to_type_decls for state {`
`259`	`259`	`recv => (*self).dir.reverse()`
`260`	`260`	`};`
`261`	`261`	`let mut items = ~[];`
`262`		`- for self.messages.each \|m\| {`
`263`		`- if dir == send {`
`264`		`- items.push(m.gen_send(cx, true));`
`265`		`- items.push(m.gen_send(cx, false));`
	`262`	`+`
	`263`	`+ {`
	`264`	`+ let messages = &mut *self.messages;`
	`265`	`+ for vec::each_mut(*messages) \|m\| {`
	`266`	`+ if dir == send {`
	`267`	`+ items.push(m.gen_send(cx, true));`
	`268`	`+ items.push(m.gen_send(cx, false));`
	`269`	`+ }`
`266`	`270`	`}`
`267`	`271`	`}`
`268`	`272`
`@@ -395,7 +399,8 @@ pub impl gen_init for protocol {`
`395`	`399`	`}`
`396`	`400`
`397`	`401`	`cx.ty_path_ast_builder(path(~[cx.ident_of(~"super"),`
`398`		`- cx.ident_of(~"__Buffer")], self.span)`
	`402`	`+ cx.ident_of(~"__Buffer")],`
	`403`	`+ copy self.span)`
`399`	`404`	`.add_tys(cx.ty_vars_global(params)))`
`400`	`405`	`}`
`401`	`406`
`@@ -453,12 +458,12 @@ pub impl gen_init for protocol {`
`453`	`458`	`}`
`454`	`459`
`455`	`460`	`items.push(cx.item_mod(cx.ident_of(~"client"),`
`456`		`- self.span,`
	`461`	`+ copy self.span,`
`457`	`462`	`client_states));`
`458`	`463`	`items.push(cx.item_mod(cx.ident_of(~"server"),`
`459`		`- self.span,`
	`464`	`+ copy self.span,`
`460`	`465`	`server_states));`
`461`	`466`
`462`		`- cx.item_mod(cx.ident_of(self.name), self.span, items)`
	`467`	`+ cx.item_mod(cx.ident_of(self.name), copy self.span, items)`
`463`	`468`	`}`
`464`	`469`	`}`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,6 @@ use ext::base::ext_ctxt;`
`16`	`16`	`use ext::pipes::ast_builder::{append_types, ext_ctxt_ast_builder, path};`
`17`	`17`
`18`	`18`	`use core::cmp;`
`19`		`-use core::dvec::DVec;`
`20`	`19`	`use core::to_str::ToStr;`
`21`	`20`
`22`	`21`	`#[deriving_eq]`
`@@ -45,26 +44,24 @@ pub struct next_state {`
`45`	`44`	`tys: ~[@ast::Ty],`
`46`	`45`	`}`
`47`	`46`
`48`		`-pub enum message {`
`49`		`- // name, span, data, current state, next state`
`50`		`- message(~str, span, ~[@ast::Ty], state, Option<next_state>)`
`51`		`-}`
	`47`	`+// name, span, data, current state, next state`
	`48`	`+pub struct message(~str, span, ~[@ast::Ty], state, Option<next_state>);`
`52`	`49`
`53`	`50`	`pub impl message {`
`54`		`- fn name(&self) -> ~str {`
	`51`	`+ fn name(&mut self) -> ~str {`
`55`	`52`	`match *self {`
`56`	`53`	`message(ref id, _, _, _, _) => (*id)`
`57`	`54`	`}`
`58`	`55`	`}`
`59`	`56`
`60`		`- fn span(&self) -> span {`
	`57`	`+ fn span(&mut self) -> span {`
`61`	`58`	`match *self {`
`62`	`59`	`message(_, span, _, _, _) => span`
`63`	`60`	`}`
`64`	`61`	`}`
`65`	`62`
`66`	`63`	`/// Return the type parameters actually used by this message`
`67`		`- fn get_params(&self) -> ~[ast::ty_param] {`
	`64`	`+ fn get_params(&mut self) -> ~[ast::ty_param] {`
`68`	`65`	`match *self {`
`69`	`66`	`message(_, _, _, this, _) => this.ty_params`
`70`	`67`	`}`
`@@ -80,7 +77,7 @@ pub struct state_ {`
`80`	`77`	`span: span,`
`81`	`78`	`dir: direction,`
`82`	`79`	`ty_params: ~[ast::ty_param],`
`83`		`- messages: DVec<message>,`
	`80`	`+ messages: @mut ~[message],`
`84`	`81`	`proto: protocol`
`85`	`82`	`}`
`86`	`83`
`@@ -121,56 +118,56 @@ pub impl state_ {`
`121`	`118`	`}`
`122`	`119`	`}`
`123`	`120`
`124`		`-pub type protocol = @protocol_;`
	`121`	`+pub type protocol = @mut protocol_;`
`125`	`122`
`126`	`123`	`pub fn protocol(name: ~str, +span: span) -> protocol {`
`127`		`- @protocol_(name, span)`
	`124`	`+ @mut protocol_(name, span)`
`128`	`125`	`}`
`129`	`126`
`130`	`127`	`pub fn protocol_(name: ~str, span: span) -> protocol_ {`
`131`	`128`	`protocol_ {`
`132`	`129`	`name: name,`
`133`	`130`	`span: span,`
`134`		`- states: DVec(),`
	`131`	`+ states: @mut ~[],`
`135`	`132`	`bounded: None`
`136`	`133`	`}`
`137`	`134`	`}`
`138`	`135`
`139`	`136`	`pub struct protocol_ {`
`140`	`137`	`name: ~str,`
`141`	`138`	`span: span,`
`142`		`- states: DVec<state>,`
	`139`	`+ states: @mut ~[state],`
`143`	`140`
`144`		`- mut bounded: Option<bool>,`
	`141`	`+ bounded: Option<bool>,`
`145`	`142`	`}`
`146`	`143`
`147`	`144`	`pub impl protocol_ {`
`148`	`145`	`/// Get a state.`
`149`		`- fn get_state(&self, name: ~str) -> state {`
	`146`	`+ fn get_state(&mut self, name: ~str) -> state {`
`150`	`147`	`self.states.find(\|i\| i.name == name).get()`
`151`	`148`	`}`
`152`	`149`
`153`		`- fn get_state_by_id(&self, id: uint) -> state { self.states[id] }`
	`150`	`+ fn get_state_by_id(&mut self, id: uint) -> state { self.states[id] }`
`154`	`151`
`155`		`- fn has_state(&self, name: ~str) -> bool {`
	`152`	`+ fn has_state(&mut self, name: ~str) -> bool {`
`156`	`153`	`self.states.find(\|i\| i.name == name).is_some()`
`157`	`154`	`}`
`158`	`155`
`159`		`- fn filename(&self) -> ~str {`
	`156`	`+ fn filename(&mut self) -> ~str {`
`160`	`157`	`~"proto://" + self.name`
`161`	`158`	`}`
`162`	`159`
`163`		`- fn num_states(&self) -> uint { self.states.len() }`
	`160`	`+ fn num_states(&mut self) -> uint { self.states.len() }`
`164`	`161`
`165`		`- fn has_ty_params(&self) -> bool {`
	`162`	`+ fn has_ty_params(&mut self) -> bool {`
`166`	`163`	`for self.states.each \|s\| {`
`167`	`164`	`if s.ty_params.len() > 0 {`
`168`	`165`	`return true;`
`169`	`166`	`}`
`170`	`167`	`}`
`171`	`168`	`false`
`172`	`169`	`}`
`173`		`- fn is_bounded(&self) -> bool {`
	`170`	`+ fn is_bounded(&mut self) -> bool {`
`174`	`171`	`let bounded = self.bounded.get();`
`175`	`172`	`bounded`
`176`	`173`	`}`
`@@ -179,7 +176,7 @@ pub impl protocol_ {`
`179`	`176`	`pub impl protocol {`
`180`	`177`	`fn add_state_poly(&self, name: ~str, ident: ast::ident, dir: direction,`
`181`	`178`	`+ty_params: ~[ast::ty_param]) -> state {`
`182`		`- let messages = DVec();`
	`179`	`+ let messages = @mut ~[];`
`183`	`180`
`184`	`181`	`let state = @state_ {`
`185`	`182`	`id: self.states.len(),`