Remove struct ctors

Author: brson

src/libsyntax/ext/pipes/proto.rs

@@ -118,20 +118,22 @@ fn protocol(name: ~str, +span: span) -> protocol {
     @protocol_(name, span)
 }
 
+fn protocol_(name: ~str, span: span) -> protocol_ {
+    protocol_ {
+        name: name,
+        span: span,
+        states: DVec(),
+        bounded: None
+    }
+}
+
 struct protocol_ {
     let name: ~str;
     let span: span;
     let states: DVec<state>;
 
     let mut bounded: Option<bool>;
 
-    new(name: ~str, span: span) {
-        self.name = name;
-        self.span = span;
-        self.states = DVec();
-        self.bounded = None;
-    }
-
     /// Get a state.
     fn get_state(name: ~str) -> state {
         self.states.find(|i| i.name == name).get()

src/libsyntax/parse/parser.rs

@@ -181,6 +181,37 @@ pure fn maybe_append(+lhs: ~[attribute], rhs: Option<~[attribute]>)
 
 /* ident is handled by common.rs */
 
+fn parser(sess: parse_sess, cfg: ast::crate_cfg,
+          +rdr: reader, ftype: file_type) -> parser {
+
+    let tok0 = rdr.next_token();
+    let span0 = tok0.sp;
+    let interner = rdr.interner();
+
+    parser {
+        reader: move rdr,
+        interner: move interner,
+        sess: sess,
+        cfg: cfg,
+        file_type: ftype,
+        token: tok0.tok,
+        span: span0,
+        last_span: span0,
+        buffer: [mut
+            {tok: tok0.tok, sp: span0},
+            {tok: tok0.tok, sp: span0},
+            {tok: tok0.tok, sp: span0},
+            {tok: tok0.tok, sp: span0}
+        ]/4,
+        buffer_start: 0,
+        buffer_end: 0,
+        restriction: UNRESTRICTED,
+        quote_depth: 0u,
+        keywords: token::keyword_table(),
+        restricted_keywords: token::restricted_keyword_table()
+    }
+}
+
 struct parser {
     let sess: parse_sess;
     let cfg: crate_cfg;
@@ -198,32 +229,6 @@ struct parser {
     let keywords: hashmap<~str, ()>;
     let restricted_keywords: hashmap<~str, ()>;
 
-    new(sess: parse_sess, cfg: ast::crate_cfg, +rdr: reader, ftype: file_type)
-    {
-        self.reader <- rdr;
-        self.interner = self.reader.interner();
-        let tok0 = self.reader.next_token();
-        let span0 = tok0.sp;
-        self.sess = sess;
-        self.cfg = cfg;
-        self.file_type = ftype;
-        self.token = tok0.tok;
-        self.span = span0;
-        self.last_span = span0;
-        self.buffer = [mut
-            {tok: tok0.tok, sp: span0},
-            {tok: tok0.tok, sp: span0},
-            {tok: tok0.tok, sp: span0},
-            {tok: tok0.tok, sp: span0}
-        ]/4;
-        self.buffer_start = 0;
-        self.buffer_end = 0;
-        self.restriction = UNRESTRICTED;
-        self.quote_depth = 0u;
-        self.keywords = token::keyword_table();
-        self.restricted_keywords = token::restricted_keyword_table();
-    }
-
     drop {} /* do not copy the parser; its state is tied to outside state */
 
     fn bump() {
@@ -2594,7 +2599,6 @@ struct parser {
         let class_name = self.parse_value_ident();
         self.parse_region_param();
         let ty_params = self.parse_ty_params();
-        let class_path = self.ident_to_path_tys(class_name, ty_params);
         let traits : ~[@trait_ref] = if self.eat(token::COLON)
             { self.parse_trait_ref_list(token::LBRACE) }
         else { ~[] };
@@ -2610,7 +2614,7 @@ struct parser {
             // It's a record-like struct.
             fields = ~[];
             while self.token != token::RBRACE {
-                match self.parse_class_item(class_path) {
+                match self.parse_class_item() {
                   ctor_decl(a_fn_decl, attrs, blk, s) => {
                       match the_ctor {
                         Some((_, _, _, s_first)) => {
@@ -2747,24 +2751,13 @@ struct parser {
         }
     }
 
-    fn parse_ctor(attrs: ~[attribute],
-                  result_ty: ast::ty_) -> class_contents {
-        let lo = self.last_span.lo;
-        let (decl_, _) = self.parse_fn_decl(|p| p.parse_arg());
-        let decl = {output: @{id: self.get_id(),
-                              node: result_ty, span: decl_.output.span},
-                    .. decl_};
-        let body = self.parse_block();
-        ctor_decl(decl, attrs, body, mk_sp(lo, self.last_span.hi))
-    }
-
     fn parse_dtor(attrs: ~[attribute]) -> class_contents {
         let lo = self.last_span.lo;
         let body = self.parse_block();
         dtor_decl(body, attrs, mk_sp(lo, self.last_span.hi))
     }
 
-    fn parse_class_item(class_name_with_tps: @path) -> class_contents {
+    fn parse_class_item() -> class_contents {
         if self.eat_keyword(~"priv") {
             // XXX: Remove after snapshot.
             match self.token {
@@ -2789,12 +2782,7 @@ struct parser {
 
         let attrs = self.parse_outer_attributes();
 
-        if self.eat_keyword(~"new") {
-            // result type is always the type of the class
-           return self.parse_ctor(attrs, ty_path(class_name_with_tps,
-                                        self.get_id()));
-        }
-        else if self.eat_keyword(~"drop") {
+        if self.eat_keyword(~"drop") {
            return self.parse_dtor(attrs);
         }
         else {
@@ -3019,12 +3007,12 @@ struct parser {
         }
     }
 
-    fn parse_struct_def(path: @path) -> @struct_def {
+    fn parse_struct_def() -> @struct_def {
         let mut the_dtor: Option<(blk, ~[attribute], codemap::span)> = None;
         let mut fields: ~[@struct_field] = ~[];
         let mut methods: ~[@method] = ~[];
         while self.token != token::RBRACE {
-            match self.parse_class_item(path) {
+            match self.parse_class_item() {
                 ctor_decl(*) => {
                     self.span_fatal(copy self.span,
                                     ~"deprecated explicit \
@@ -3076,7 +3064,7 @@ struct parser {
         };
     }
 
-    fn parse_enum_def(ident: ast::ident, ty_params: ~[ast::ty_param])
+    fn parse_enum_def(ty_params: ~[ast::ty_param])
                    -> enum_def {
         let mut variants: ~[variant] = ~[];
         let mut all_nullary = true, have_disr = false;
@@ -3092,8 +3080,7 @@ struct parser {
                     self.fatal(~"duplicate declaration of shared fields");
                 }
                 self.expect(token::LBRACE);
-                let path = self.ident_to_path_tys(ident, ty_params);
-                common_fields = Some(self.parse_struct_def(path));
+                common_fields = Some(self.parse_struct_def());
                 again;
             }
 
@@ -3105,16 +3092,15 @@ struct parser {
             if self.eat_keyword(~"enum") {
                 ident = self.parse_ident();
                 self.expect(token::LBRACE);
-                let nested_enum_def = self.parse_enum_def(ident, ty_params);
+                let nested_enum_def = self.parse_enum_def(ty_params);
                 kind = enum_variant_kind(move nested_enum_def);
                 needs_comma = false;
             } else {
                 ident = self.parse_value_ident();
                 if self.eat(token::LBRACE) {
                     // Parse a struct variant.
                     all_nullary = false;
-                    let path = self.ident_to_path_tys(ident, ty_params);
-                    kind = struct_variant_kind(self.parse_struct_def(path));
+                    kind = struct_variant_kind(self.parse_struct_def());
                 } else if self.token == token::LPAREN {
                     all_nullary = false;
                     let arg_tys = self.parse_unspanned_seq(
@@ -3176,7 +3162,7 @@ struct parser {
         }
         self.expect(token::LBRACE);
 
-        let enum_definition = self.parse_enum_def(id, ty_params);
+        let enum_definition = self.parse_enum_def(ty_params);
         (id, item_enum(enum_definition, ty_params), None)
     }
 

src/libsyntax/parse/token.rs

@@ -422,7 +422,6 @@ fn restricted_keyword_table() -> hashmap<~str, ()> {
         ~"if", ~"impl", ~"import",
         ~"let", ~"log", ~"loop",
         ~"match", ~"mod", ~"module", ~"move", ~"mut",
-        ~"new",
         ~"owned",
         ~"pure",
         ~"ref", ~"return",

src/rustc/driver/rustc.rs

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

src/rustc/lib/llvm.rs

@@ -1175,10 +1175,15 @@ fn fn_ty_param_tys(fn_ty: TypeRef) -> ~[TypeRef] unsafe {
 
 struct target_data_res {
     let TD: TargetDataRef;
-    new(TD: TargetDataRef) { self.TD = TD; }
     drop { llvm::LLVMDisposeTargetData(self.TD); }
 }
 
+fn target_data_res(TD: TargetDataRef) -> target_data_res {
+    target_data_res {
+        TD: TD
+    }
+}
+
 type target_data = {lltd: TargetDataRef, dtor: @target_data_res};
 
 fn mk_target_data(string_rep: ~str) -> target_data {
@@ -1191,10 +1196,15 @@ fn mk_target_data(string_rep: ~str) -> target_data {
 
 struct pass_manager_res {
     let PM: PassManagerRef;
-    new(PM: PassManagerRef) { self.PM = PM; }
     drop { llvm::LLVMDisposePassManager(self.PM); }
 }
 
+fn pass_manager_res(PM: PassManagerRef) -> pass_manager_res {
+    pass_manager_res {
+        PM: PM
+    }
+}
+
 type pass_manager = {llpm: PassManagerRef, dtor: @pass_manager_res};
 
 fn mk_pass_manager() -> pass_manager {
@@ -1206,10 +1216,15 @@ fn mk_pass_manager() -> pass_manager {
 
 struct object_file_res {
     let ObjectFile: ObjectFileRef;
-    new(ObjectFile: ObjectFileRef) { self.ObjectFile = ObjectFile; }
     drop { llvm::LLVMDisposeObjectFile(self.ObjectFile); }
 }
 
+fn object_file_res(ObjectFile: ObjectFileRef) -> object_file_res{
+    object_file_res {
+        ObjectFile: ObjectFile
+    }
+}
+
 type object_file = {llof: ObjectFileRef, dtor: @object_file_res};
 
 fn mk_object_file(llmb: MemoryBufferRef) -> Option<object_file> {
@@ -1222,10 +1237,15 @@ fn mk_object_file(llmb: MemoryBufferRef) -> Option<object_file> {
 
 struct section_iter_res {
     let SI: SectionIteratorRef;
-    new(SI: SectionIteratorRef) { self.SI = SI; }
     drop { llvm::LLVMDisposeSectionIterator(self.SI); }
 }
 
+fn section_iter_res(SI: SectionIteratorRef) -> section_iter_res {
+    section_iter_res {
+        SI: SI
+    }
+}
+
 type section_iter = {llsi: SectionIteratorRef, dtor: @section_iter_res};
 
 fn mk_section_iter(llof: ObjectFileRef) -> section_iter {

src/rustc/metadata/decoder.rs

@@ -442,10 +442,12 @@ struct path_entry {
     let path_string: ~str;
     // The definition, implementation, or field that this path corresponds to.
     let def_like: def_like;
+}
 
-    new(path_string: ~str, def_like: def_like) {
-        self.path_string = path_string;
-        self.def_like = def_like;
+fn path_entry(path_string: ~str, def_like: def_like) -> path_entry {
+    path_entry {
+        path_string: path_string,
+        def_like: def_like
     }
 }