Remove struct ctors

10 files changed, 277 insertions, 197 deletions

diff --git a/src/rustc/driver/rustc.rs b/src/rustc/driver/rustc.rs
index c6b8bc2d7b9..8b8325853cc 100644
--- a/src/rustc/driver/rustc.rs
+++ b/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)
     } {
diff --git a/src/rustc/lib/llvm.rs b/src/rustc/lib/llvm.rs
index fe737442bd0..23566e59cf9 100644
--- a/src/rustc/lib/llvm.rs
+++ b/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 {
diff --git a/src/rustc/metadata/decoder.rs b/src/rustc/metadata/decoder.rs
index d9ecc114062..4e2c7b8ee72 100644
--- a/src/rustc/metadata/decoder.rs
+++ b/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
     }
 }
 
diff --git a/src/rustc/middle/lang_items.rs b/src/rustc/middle/lang_items.rs
index b57f1eac19b..3d8771166b6 100644
--- a/src/rustc/middle/lang_items.rs
+++ b/src/rustc/middle/lang_items.rs
@@ -72,6 +72,41 @@ mod LanguageItems {
     }
 }
 
+fn LanguageItemCollector(crate: @crate, session: session,
+                         items: &r/LanguageItems)
+    -> LanguageItemCollector/&r {
+
+    let item_refs = str_hash();
+
+    item_refs.insert(~"const", &mut items.const_trait);
+    item_refs.insert(~"copy", &mut items.copy_trait);
+    item_refs.insert(~"send", &mut items.send_trait);
+    item_refs.insert(~"owned", &mut items.owned_trait);
+
+    item_refs.insert(~"add", &mut items.add_trait);
+    item_refs.insert(~"sub", &mut items.sub_trait);
+    item_refs.insert(~"mul", &mut items.mul_trait);
+    item_refs.insert(~"div", &mut items.div_trait);
+    item_refs.insert(~"modulo", &mut items.modulo_trait);
+    item_refs.insert(~"neg", &mut items.neg_trait);
+    item_refs.insert(~"bitxor", &mut items.bitxor_trait);
+    item_refs.insert(~"bitand", &mut items.bitand_trait);
+    item_refs.insert(~"bitor", &mut items.bitor_trait);
+    item_refs.insert(~"shl", &mut items.shl_trait);
+    item_refs.insert(~"shr", &mut items.shr_trait);
+    item_refs.insert(~"index", &mut items.index_trait);
+
+    item_refs.insert(~"eq", &mut items.eq_trait);
+    item_refs.insert(~"ord", &mut items.ord_trait);
+
+    LanguageItemCollector {
+        crate: crate,
+        session: session,
+        items: items,
+        item_refs: item_refs
+    }
+}
+
 struct LanguageItemCollector {
     let items: &LanguageItems;
 
@@ -80,34 +115,6 @@ struct LanguageItemCollector {
 
     let item_refs: hashmap<~str,&mut Option<def_id>>;
 
-    new(crate: @crate, session: session, items: &self/LanguageItems) {
-        self.crate = crate;
-        self.session = session;
-        self.items = items;
-        self.item_refs = str_hash();
-
-        self.item_refs.insert(~"const", &mut self.items.const_trait);
-        self.item_refs.insert(~"copy", &mut self.items.copy_trait);
-        self.item_refs.insert(~"send", &mut self.items.send_trait);
-        self.item_refs.insert(~"owned", &mut self.items.owned_trait);
-
-        self.item_refs.insert(~"add", &mut self.items.add_trait);
-        self.item_refs.insert(~"sub", &mut self.items.sub_trait);
-        self.item_refs.insert(~"mul", &mut self.items.mul_trait);
-        self.item_refs.insert(~"div", &mut self.items.div_trait);
-        self.item_refs.insert(~"modulo", &mut self.items.modulo_trait);
-        self.item_refs.insert(~"neg", &mut self.items.neg_trait);
-        self.item_refs.insert(~"bitxor", &mut self.items.bitxor_trait);
-        self.item_refs.insert(~"bitand", &mut self.items.bitand_trait);
-        self.item_refs.insert(~"bitor", &mut self.items.bitor_trait);
-        self.item_refs.insert(~"shl", &mut self.items.shl_trait);
-        self.item_refs.insert(~"shr", &mut self.items.shr_trait);
-        self.item_refs.insert(~"index", &mut self.items.index_trait);
-
-        self.item_refs.insert(~"eq", &mut self.items.eq_trait);
-        self.item_refs.insert(~"ord", &mut self.items.ord_trait);
-    }
-
     fn match_and_collect_meta_item(item_def_id: def_id,
                                    meta_item: meta_item) {
 
diff --git a/src/rustc/middle/resolve.rs b/src/rustc/middle/resolve.rs
index 05872159f8c..1168260b519 100644
--- a/src/rustc/middle/resolve.rs
+++ b/src/rustc/middle/resolve.rs
@@ -311,26 +311,30 @@ fn atom_hashmap<V:copy>() -> hashmap<Atom,V> {
 struct Rib {
     let bindings: hashmap<Atom,def_like>;
     let kind: RibKind;
+}
 
-    new(kind: RibKind) {
-        self.bindings = atom_hashmap();
-        self.kind = kind;
+fn Rib(kind: RibKind) -> Rib {
+    Rib {
+        bindings: atom_hashmap(),
+        kind: kind
     }
 }
 
+
 /// One import directive.
 struct ImportDirective {
     let module_path: @DVec<Atom>;
     let subclass: @ImportDirectiveSubclass;
     let span: span;
+}
 
-    new(module_path: @DVec<Atom>,
-        subclass: @ImportDirectiveSubclass,
-        span: span) {
-
-        self.module_path = module_path;
-        self.subclass = subclass;
-        self.span = span;
+fn ImportDirective(module_path: @DVec<Atom>,
+                   subclass: @ImportDirectiveSubclass,
+                   span: span) -> ImportDirective {
+    ImportDirective {
+        module_path: module_path,
+        subclass: subclass,
+        span: span
     }
 }
 
@@ -338,10 +342,12 @@ struct ImportDirective {
 struct Target {
     let target_module: @Module;
     let bindings: @NameBindings;
+}
 
-    new(target_module: @Module, bindings: @NameBindings) {
-        self.target_module = target_module;
-        self.bindings = bindings;
+fn Target(target_module: @Module, bindings: @NameBindings) -> Target {
+    Target {
+        target_module: target_module,
+        bindings: bindings
     }
 }
 
@@ -360,18 +366,6 @@ struct ImportResolution {
 
     let mut used: bool;
 
-    new(span: span) {
-        self.span = span;
-
-        self.outstanding_references = 0u;
-
-        self.module_target = None;
-        self.value_target = None;
-        self.type_target = None;
-
-        self.used = false;
-    }
-
     fn target_for_namespace(namespace: Namespace) -> Option<Target> {
         match namespace {
             ModuleNS    => return copy self.module_target,
@@ -381,6 +375,17 @@ struct ImportResolution {
     }
 }
 
+fn ImportResolution(span: span) -> ImportResolution {
+    ImportResolution {
+        span: span,
+        outstanding_references: 0u,
+        module_target: None,
+        value_target: None,
+        type_target: None,
+        used: false
+    }
+}
+
 /// The link from a module up to its nearest parent node.
 enum ParentLink {
     NoParentLink,
@@ -430,27 +435,25 @@ struct Module {
     // The index of the import we're resolving.
     let mut resolved_import_count: uint;
 
-    new(parent_link: ParentLink, def_id: Option<def_id>) {
-        self.parent_link = parent_link;
-        self.def_id = def_id;
-
-        self.children = atom_hashmap();
-        self.imports = DVec();
-
-        self.anonymous_children = int_hash();
-
-        self.exported_names = atom_hashmap();
-
-        self.import_resolutions = atom_hashmap();
-        self.glob_count = 0u;
-        self.resolved_import_count = 0u;
-    }
-
     fn all_imports_resolved() -> bool {
         return self.imports.len() == self.resolved_import_count;
     }
 }
 
+fn Module(parent_link: ParentLink, def_id: Option<def_id>) -> Module {
+    Module {
+        parent_link: parent_link,
+        def_id: def_id,
+        children: atom_hashmap(),
+        imports: DVec(),
+        anonymous_children: int_hash(),
+        exported_names: atom_hashmap(),
+        import_resolutions: atom_hashmap(),
+        glob_count: 0u,
+        resolved_import_count: 0u
+    }
+}
+
 // XXX: This is a workaround due to is_none in the standard library mistakenly
 // requiring a T:copy.
 
@@ -501,15 +504,6 @@ struct NameBindings {
     let mut type_span: Option<span>;
     let mut value_span: Option<span>;
 
-    new() {
-        self.module_def = NoModuleDef;
-        self.type_def = None;
-        self.value_def = None;
-        self.module_span = None;
-        self.type_span = None;
-        self.value_span = None;
-    }
-
     /// Creates a new module in this set of name bindings.
     fn define_module(parent_link: ParentLink, def_id: Option<def_id>,
                      sp: span) {
@@ -598,31 +592,22 @@ struct NameBindings {
     }
 }
 
+fn NameBindings() -> NameBindings {
+    NameBindings {
+        module_def: NoModuleDef,
+        type_def: None,
+        value_def: None,
+        module_span: None,
+        type_span: None,
+        value_span: None
+    }
+}
+
+
 /// Interns the names of the primitive types.
 struct PrimitiveTypeTable {
     let primitive_types: hashmap<Atom,prim_ty>;
 
-    new(intr: ident_interner) {
-        self.primitive_types = atom_hashmap();
-
-        self.intern(intr, @~"bool",    ty_bool);
-        self.intern(intr, @~"char",    ty_int(ty_char));
-        self.intern(intr, @~"float",   ty_float(ty_f));
-        self.intern(intr, @~"f32",     ty_float(ty_f32));
-        self.intern(intr, @~"f64",     ty_float(ty_f64));
-        self.intern(intr, @~"int",     ty_int(ty_i));
-        self.intern(intr, @~"i8",      ty_int(ty_i8));
-        self.intern(intr, @~"i16",     ty_int(ty_i16));
-        self.intern(intr, @~"i32",     ty_int(ty_i32));
-        self.intern(intr, @~"i64",     ty_int(ty_i64));
-        self.intern(intr, @~"str",     ty_str);
-        self.intern(intr, @~"uint",    ty_uint(ty_u));
-        self.intern(intr, @~"u8",      ty_uint(ty_u8));
-        self.intern(intr, @~"u16",     ty_uint(ty_u16));
-        self.intern(intr, @~"u32",     ty_uint(ty_u32));
-        self.intern(intr, @~"u64",     ty_uint(ty_u64));
-    }
-
     fn intern(intr: ident_interner, string: @~str,
               primitive_type: prim_ty) {
         let atom = intr.intern(string);
@@ -630,6 +615,32 @@ struct PrimitiveTypeTable {
     }
 }
 
+fn PrimitiveTypeTable(intr: ident_interner) -> PrimitiveTypeTable {
+    let table = PrimitiveTypeTable {
+        primitive_types: atom_hashmap()
+    };
+
+    table.intern(intr, @~"bool",    ty_bool);
+    table.intern(intr, @~"char",    ty_int(ty_char));
+    table.intern(intr, @~"float",   ty_float(ty_f));
+    table.intern(intr, @~"f32",     ty_float(ty_f32));
+    table.intern(intr, @~"f64",     ty_float(ty_f64));
+    table.intern(intr, @~"int",     ty_int(ty_i));
+    table.intern(intr, @~"i8",      ty_int(ty_i8));
+    table.intern(intr, @~"i16",     ty_int(ty_i16));
+    table.intern(intr, @~"i32",     ty_int(ty_i32));
+    table.intern(intr, @~"i64",     ty_int(ty_i64));
+    table.intern(intr, @~"str",     ty_str);
+    table.intern(intr, @~"uint",    ty_uint(ty_u));
+    table.intern(intr, @~"u8",      ty_uint(ty_u8));
+    table.intern(intr, @~"u16",     ty_uint(ty_u16));
+    table.intern(intr, @~"u32",     ty_uint(ty_u32));
+    table.intern(intr, @~"u64",     ty_uint(ty_u64));
+
+    return table;
+}
+
+
 fn namespace_to_str(ns: Namespace) -> ~str {
     match ns {
       TypeNS   => ~"type",
@@ -638,6 +649,59 @@ fn namespace_to_str(ns: Namespace) -> ~str {
     }
 }
 
+fn Resolver(session: session, lang_items: LanguageItems,
+            crate: @crate) -> Resolver {
+
+    let graph_root = @NameBindings();
+
+    (*graph_root).define_module(NoParentLink,
+                                Some({ crate: 0, node: 0 }),
+                                crate.span);
+
+    let current_module = (*graph_root).get_module();
+
+    let self = Resolver {
+        session: session,
+        lang_items: copy lang_items,
+        crate: crate,
+
+        // The outermost module has def ID 0; this is not reflected in the
+        // AST.
+
+        graph_root: graph_root,
+
+        unused_import_lint_level: unused_import_lint_level(session),
+
+        trait_info: new_def_hash(),
+        structs: new_def_hash(),
+
+        unresolved_imports: 0u,
+
+        current_module: current_module,
+        value_ribs: @DVec(),
+        type_ribs: @DVec(),
+        label_ribs: @DVec(),
+
+        xray_context: NoXray,
+        current_trait_refs: None,
+
+        self_atom: syntax::parse::token::special_idents::self_,
+        primitive_type_table: @PrimitiveTypeTable(session.
+                                                  parse_sess.interner),
+
+        namespaces: ~[ ModuleNS, TypeNS, ValueNS ],
+
+        def_map: int_hash(),
+        export_map: int_hash(),
+        export_map2: int_hash(),
+        trait_map: @int_hash(),
+
+        intr: session.intr()
+    };
+
+    return self;
+}
+
 /// The main resolver class.
 struct Resolver {
     let session: session;
@@ -690,48 +754,6 @@ struct Resolver {
     let export_map2: ExportMap2;
     let trait_map: TraitMap;
 
-    new(session: session, lang_items: LanguageItems, crate: @crate) {
-        self.session = session;
-        self.lang_items = copy lang_items;
-        self.crate = crate;
-
-        // The outermost module has def ID 0; this is not reflected in the
-        // AST.
-
-        self.graph_root = @NameBindings();
-        (*self.graph_root).define_module(NoParentLink,
-                                         Some({ crate: 0, node: 0 }),
-                                         crate.span);
-
-        self.unused_import_lint_level = unused_import_lint_level(session);
-
-        self.trait_info = new_def_hash();
-        self.structs = new_def_hash();
-
-        self.unresolved_imports = 0u;
-
-        self.current_module = (*self.graph_root).get_module();
-        self.value_ribs = @DVec();
-        self.type_ribs = @DVec();
-        self.label_ribs = @DVec();
-
-        self.xray_context = NoXray;
-        self.current_trait_refs = None;
-
-        self.self_atom = syntax::parse::token::special_idents::self_;
-        self.primitive_type_table = @PrimitiveTypeTable(self.session.
-                                                        parse_sess.interner);
-
-        self.namespaces = ~[ ModuleNS, TypeNS, ValueNS ];
-
-        self.def_map = int_hash();
-        self.export_map = int_hash();
-        self.export_map2 = int_hash();
-        self.trait_map = @int_hash();
-
-        self.intr = session.intr();
-    }
-
     /// The main name resolution procedure.
     fn resolve(@self, this: @Resolver) {
         self.build_reduced_graph(this);
diff --git a/src/rustc/middle/trans/base.rs b/src/rustc/middle/trans/base.rs
index b74d89dc465..3eef274e9d6 100644
--- a/src/rustc/middle/trans/base.rs
+++ b/src/rustc/middle/trans/base.rs
@@ -56,7 +56,6 @@ use option::{is_none, is_some};
 
 struct icx_popper {
     let ccx: @crate_ctxt;
-    new(ccx: @crate_ctxt) { self.ccx = ccx; }
     drop {
       if self.ccx.sess.count_llvm_insns() {
           vec::pop(*(self.ccx.stats.llvm_insn_ctxt));
@@ -64,6 +63,12 @@ struct icx_popper {
     }
 }
 
+fn icx_popper(ccx: @crate_ctxt) -> icx_popper {
+    icx_popper {
+        ccx: ccx
+    }
+}
+
 trait get_insn_ctxt {
     fn insn_ctxt(s: &str) -> icx_popper;
 }
diff --git a/src/rustc/middle/trans/common.rs b/src/rustc/middle/trans/common.rs
index 6fb547d757d..6b3e4063d67 100644
--- a/src/rustc/middle/trans/common.rs
+++ b/src/rustc/middle/trans/common.rs
@@ -95,10 +95,15 @@ type stats =
 
 struct BuilderRef_res {
     let B: BuilderRef;
-    new(B: BuilderRef) { self.B = B; }
     drop { llvm::LLVMDisposeBuilder(self.B); }
 }
 
+fn BuilderRef_res(B: BuilderRef) -> BuilderRef_res {
+    BuilderRef_res {
+        B: B
+    }
+}
+
 // Crate context.  Every crate we compile has one of these.
 type crate_ctxt = {
      sess: session::session,
@@ -485,12 +490,21 @@ struct block_ {
     // The function context for the function to which this block is
     // attached.
     let fcx: fn_ctxt;
-    new(llbb: BasicBlockRef, parent: Option<block>, -kind: block_kind,
-        is_lpad: bool, node_info: Option<node_info>, fcx: fn_ctxt) {
-        // sigh
-        self.llbb = llbb; self.terminated = false; self.unreachable = false;
-        self.parent = parent; self.kind = kind; self.is_lpad = is_lpad;
-        self.node_info = node_info; self.fcx = fcx;
+}
+
+fn block_(llbb: BasicBlockRef, parent: Option<block>, -kind: block_kind,
+          is_lpad: bool, node_info: Option<node_info>, fcx: fn_ctxt)
+    -> block_ {
+
+    block_ {
+        llbb: llbb,
+        terminated: false,
+        unreachable: false,
+        parent: parent,
+        kind: kind,
+        is_lpad: is_lpad,
+        node_info: node_info,
+        fcx: fcx
     }
 }
 
diff --git a/src/rustc/middle/typeck/check/method.rs b/src/rustc/middle/typeck/check/method.rs
index cb4bd4296e3..b356a1b7f67 100644
--- a/src/rustc/middle/typeck/check/method.rs
+++ b/src/rustc/middle/typeck/check/method.rs
@@ -63,6 +63,35 @@ fn get_mode_from_self_type(self_type: ast::self_ty_) -> ast::rmode {
     }
 }
 
+fn lookup(fcx: @fn_ctxt,
+
+        // In a call `a.b::<X, Y, ...>(...)`:
+        expr: @ast::expr,        // The expression `a.b`.
+        self_expr: @ast::expr,   // The expression `a`.
+        borrow_lb: ast::node_id, // Scope to borrow the expression `a` for.
+        node_id: ast::node_id,   // The node_id in which to store the type of
+                                 // `a.b`.
+        m_name: ast::ident,      // The ident `b`.
+        self_ty: ty::t,          // The type of `a`.
+        supplied_tps: ~[ty::t],  // The list of types X, Y, ... .
+        include_private: bool) -> lookup {
+
+    lookup {
+        fcx: fcx,
+        expr: expr,
+        self_expr: self_expr,
+        borrow_lb: borrow_lb,
+        node_id: node_id,
+        m_name: m_name,
+        self_ty: self_ty,
+        derefs: 0u,
+        candidates: DVec(),
+        candidate_impls: new_def_hash(),
+        supplied_tps: supplied_tps,
+        include_private: include_private
+    }
+}
+
 struct lookup {
     let fcx: @fn_ctxt;
     let expr: @ast::expr;
@@ -77,33 +106,6 @@ struct lookup {
     let supplied_tps: ~[ty::t];
     let include_private: bool;
 
-    new(fcx: @fn_ctxt,
-
-        // In a call `a.b::<X, Y, ...>(...)`:
-        expr: @ast::expr,        // The expression `a.b`.
-        self_expr: @ast::expr,   // The expression `a`.
-        borrow_lb: ast::node_id, // Scope to borrow the expression `a` for.
-        node_id: ast::node_id,   // The node_id in which to store the type of
-                                 // `a.b`.
-        m_name: ast::ident,      // The ident `b`.
-        self_ty: ty::t,          // The type of `a`.
-        supplied_tps: ~[ty::t],  // The list of types X, Y, ... .
-        include_private: bool) {
-
-        self.fcx = fcx;
-        self.expr = expr;
-        self.self_expr = self_expr;
-        self.borrow_lb = borrow_lb;
-        self.node_id = node_id;
-        self.m_name = m_name;
-        self.self_ty = self_ty;
-        self.derefs = 0u;
-        self.candidates = DVec();
-        self.candidate_impls = new_def_hash();
-        self.supplied_tps = supplied_tps;
-        self.include_private = include_private;
-    }
-
     // Entrypoint:
     fn method() -> Option<method_map_entry> {
         debug!("method lookup(m_name=%s, self_ty=%s, %?)",
diff --git a/src/rustc/middle/typeck/coherence.rs b/src/rustc/middle/typeck/coherence.rs
index 1377e41cdca..a01b0983e70 100644
--- a/src/rustc/middle/typeck/coherence.rs
+++ b/src/rustc/middle/typeck/coherence.rs
@@ -126,10 +126,22 @@ struct CoherenceInfo {
     // Contains implementations of methods associated with a trait. For these,
     // the associated trait must be imported at the call site.
     let extension_methods: hashmap<def_id,@DVec<@Impl>>;
+}
+
+fn CoherenceInfo() -> CoherenceInfo {
+    CoherenceInfo {
+        inherent_methods: new_def_hash(),
+        extension_methods: new_def_hash()
+    }
+}
 
-    new() {
-        self.inherent_methods = new_def_hash();
-        self.extension_methods = new_def_hash();
+fn CoherenceChecker(crate_context: @crate_ctxt) -> CoherenceChecker {
+    CoherenceChecker {
+        crate_context: crate_context,
+        inference_context: new_infer_ctxt(crate_context.tcx),
+
+        base_type_def_ids: new_def_hash(),
+        privileged_implementations: int_hash()
     }
 }
 
@@ -147,14 +159,6 @@ struct CoherenceChecker {
 
     let privileged_implementations: hashmap<node_id,()>;
 
-    new(crate_context: @crate_ctxt) {
-        self.crate_context = crate_context;
-        self.inference_context = new_infer_ctxt(crate_context.tcx);
-
-        self.base_type_def_ids = new_def_hash();
-        self.privileged_implementations = int_hash();
-    }
-
     // Create a mapping containing a MethodInfo for every provided
     // method in every trait.
     fn build_provided_methods_map(crate: @crate) {
diff --git a/src/rustc/util/common.rs b/src/rustc/util/common.rs
index a4754fd4769..ee941c0ed01 100644
--- a/src/rustc/util/common.rs
+++ b/src/rustc/util/common.rs
@@ -16,10 +16,15 @@ fn indent<R>(op: fn() -> R) -> R {
 
 struct _indenter {
     let _i: ();
-    new(_i: ()) { self._i = (); }
     drop { debug!("<<"); }
 }
 
+fn _indenter(_i: ()) -> _indenter {
+    _indenter {
+        _i: ()
+    }
+}
+
 fn indenter() -> _indenter {
     debug!(">>");
     _indenter(())