diff --git a/src/librustc/metadata/csearch.rs b/src/librustc/metadata/csearch.rs
index 8d5be0cfb82..1a65b326bbd 100644
--- a/src/librustc/metadata/csearch.rs
+++ b/src/librustc/metadata/csearch.rs
@@ -18,6 +18,7 @@ use middle::ty;
 use middle::typeck;
 
 use std::vec;
+use std::rc::Rc;
 use reader = extra::ebml::reader;
 use syntax::ast;
 use syntax::ast_map;
@@ -221,8 +222,8 @@ pub fn get_field_type(tcx: ty::ctxt, class_id: ast::DefId,
                  class_id, def) );
     let ty = decoder::item_type(def, the_field, tcx, cdata);
     ty::ty_param_bounds_and_ty {
-        generics: ty::Generics {type_param_defs: @~[],
-                                region_param_defs: @[]},
+        generics: ty::Generics {type_param_defs: Rc::new(~[]),
+                                region_param_defs: Rc::new(~[])},
         ty: ty
     }
 }
diff --git a/src/librustc/metadata/decoder.rs b/src/librustc/metadata/decoder.rs
index 7e866b32631..8514025f9dd 100644
--- a/src/librustc/metadata/decoder.rs
+++ b/src/librustc/metadata/decoder.rs
@@ -25,11 +25,11 @@ use middle::ty;
 use middle::typeck;
 use middle::astencode::vtable_decoder_helpers;
 
-use std::at_vec;
 use std::u64;
 use std::io;
 use std::io::extensions::u64_from_be_bytes;
 use std::option;
+use std::rc::Rc;
 use std::vec;
 use extra::ebml::reader;
 use extra::ebml;
@@ -246,7 +246,7 @@ fn item_ty_param_defs(item: ebml::Doc,
                       tcx: ty::ctxt,
                       cdata: Cmd,
                       tag: uint)
-                      -> @~[ty::TypeParameterDef] {
+                      -> Rc<~[ty::TypeParameterDef]> {
     let mut bounds = ~[];
     reader::tagged_docs(item, tag, |p| {
         let bd = parse_type_param_def_data(
@@ -255,15 +255,15 @@ fn item_ty_param_defs(item: ebml::Doc,
         bounds.push(bd);
         true
     });
-    @bounds
+    Rc::new(bounds)
 }
 
 fn item_region_param_defs(item_doc: ebml::Doc,
                           tcx: ty::ctxt,
                           cdata: Cmd)
-                          -> @[ty::RegionParameterDef] {
-    at_vec::build(None, |push| {
-        reader::tagged_docs(item_doc, tag_region_param_def, |rp_doc| {
+                          -> Rc<~[ty::RegionParameterDef]> {
+    let mut v = ~[];
+    reader::tagged_docs(item_doc, tag_region_param_def, |rp_doc| {
             let ident_str_doc = reader::get_doc(rp_doc,
                                                 tag_region_param_def_ident);
             let ident = item_name(tcx.sess.intr(), ident_str_doc);
@@ -271,11 +271,11 @@ fn item_region_param_defs(item_doc: ebml::Doc,
                                              tag_region_param_def_def_id);
             let def_id = reader::with_doc_data(def_id_doc, parse_def_id);
             let def_id = translate_def_id(cdata, def_id);
-            push(ty::RegionParameterDef { ident: ident,
-                                          def_id: def_id });
+            v.push(ty::RegionParameterDef { ident: ident,
+                                            def_id: def_id });
             true
         });
-    })
+    Rc::new(v)
 }
 
 fn item_ty_param_count(item: ebml::Doc) -> uint {
diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs
index c7ba3ab01e9..4170d572f20 100644
--- a/src/librustc/metadata/encoder.rs
+++ b/src/librustc/metadata/encoder.rs
@@ -171,7 +171,7 @@ pub fn def_to_str(did: DefId) -> ~str {
 
 fn encode_ty_type_param_defs(ebml_w: &mut writer::Encoder,
                              ecx: &EncodeContext,
-                             params: @~[ty::TypeParameterDef],
+                             params: &[ty::TypeParameterDef],
                              tag: uint) {
     let ty_str_ctxt = @tyencode::ctxt {
         diag: ecx.diag,
@@ -188,7 +188,7 @@ fn encode_ty_type_param_defs(ebml_w: &mut writer::Encoder,
 
 fn encode_region_param_defs(ebml_w: &mut writer::Encoder,
                             ecx: &EncodeContext,
-                            params: @[ty::RegionParameterDef]) {
+                            params: &[ty::RegionParameterDef]) {
     for param in params.iter() {
         ebml_w.start_tag(tag_region_param_def);
 
@@ -215,9 +215,9 @@ fn encode_item_variances(ebml_w: &mut writer::Encoder,
 fn encode_bounds_and_type(ebml_w: &mut writer::Encoder,
                           ecx: &EncodeContext,
                           tpt: &ty::ty_param_bounds_and_ty) {
-    encode_ty_type_param_defs(ebml_w, ecx, tpt.generics.type_param_defs,
+    encode_ty_type_param_defs(ebml_w, ecx, tpt.generics.type_param_defs(),
                               tag_items_data_item_ty_param_bounds);
-    encode_region_param_defs(ebml_w, ecx, tpt.generics.region_param_defs);
+    encode_region_param_defs(ebml_w, ecx, tpt.generics.region_param_defs());
     encode_type(ecx, ebml_w, tpt.ty);
 }
 
@@ -786,7 +786,7 @@ fn encode_method_ty_fields(ecx: &EncodeContext,
     encode_def_id(ebml_w, method_ty.def_id);
     encode_name(ecx, ebml_w, method_ty.ident);
     encode_ty_type_param_defs(ebml_w, ecx,
-                              method_ty.generics.type_param_defs,
+                              method_ty.generics.type_param_defs(),
                               tag_item_method_tps);
     encode_method_fty(ecx, ebml_w, &method_ty.fty);
     encode_visibility(ebml_w, method_ty.vis);
@@ -827,7 +827,7 @@ fn encode_info_for_method(ecx: &EncodeContext,
     }
 
     for &ast_method in ast_method_opt.iter() {
-        let num_params = tpt.generics.type_param_defs.len();
+        let num_params = tpt.generics.type_param_defs().len();
         if num_params > 0u || is_default_impl
             || should_inline(ast_method.attrs) {
             (ecx.encode_inlined_item)(
@@ -1171,10 +1171,10 @@ fn encode_info_for_item(ecx: &EncodeContext,
         encode_item_variances(ebml_w, ecx, item.id);
         let trait_def = ty::lookup_trait_def(tcx, def_id);
         encode_ty_type_param_defs(ebml_w, ecx,
-                                  trait_def.generics.type_param_defs,
+                                  trait_def.generics.type_param_defs(),
                                   tag_items_data_item_ty_param_bounds);
         encode_region_param_defs(ebml_w, ecx,
-                                 trait_def.generics.region_param_defs);
+                                 trait_def.generics.region_param_defs());
         encode_trait_ref(ebml_w, ecx, trait_def.trait_ref, tag_item_trait_ref);
         encode_name(ecx, ebml_w, item.ident);
         encode_attributes(ebml_w, item.attrs);
diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs
index a601b624c19..29ea3475d34 100644
--- a/src/librustc/middle/astencode.rs
+++ b/src/librustc/middle/astencode.rs
@@ -32,10 +32,10 @@ use syntax::fold::Folder;
 use syntax::parse::token;
 use syntax;
 
-use std::at_vec;
 use std::libc;
 use std::cast;
 use std::io::Seek;
+use std::rc::Rc;
 
 use extra::ebml::reader;
 use extra::ebml;
@@ -812,13 +812,13 @@ impl<'a> ebml_writer_helpers for writer::Encoder<'a> {
             this.emit_struct_field("generics", 0, |this| {
                 this.emit_struct("Generics", 2, |this| {
                     this.emit_struct_field("type_param_defs", 0, |this| {
-                        this.emit_from_vec(*tpbt.generics.type_param_defs,
+                        this.emit_from_vec(tpbt.generics.type_param_defs(),
                                            |this, type_param_def| {
                             this.emit_type_param_def(ecx, type_param_def);
                         })
                     });
                     this.emit_struct_field("region_param_defs", 1, |this| {
-                        tpbt.generics.region_param_defs.encode(this);
+                        tpbt.generics.region_param_defs().encode(this);
                     })
                 })
             });
@@ -997,7 +997,7 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext,
             ebml_w.tag(c::tag_table_tcache, |ebml_w| {
                 ebml_w.id(id);
                 ebml_w.tag(c::tag_table_val, |ebml_w| {
-                    ebml_w.emit_tpbt(ecx, *tpbt);
+                    ebml_w.emit_tpbt(ecx, tpbt.clone());
                 })
             })
         }
@@ -1064,7 +1064,7 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext,
             ebml_w.tag(c::tag_table_capture_map, |ebml_w| {
                 ebml_w.id(id);
                 ebml_w.tag(c::tag_table_val, |ebml_w| {
-                    ebml_w.emit_from_vec(*cap_vars, |ebml_w, cap_var| {
+                    ebml_w.emit_from_vec(*cap_vars.borrow(), |ebml_w, cap_var| {
                         cap_var.encode(ebml_w);
                     })
                 })
@@ -1183,8 +1183,8 @@ impl<'a> ebml_decoder_decoder_helpers for reader::Decoder<'a> {
                                 this.read_struct_field("type_param_defs",
                                                        0,
                                                        |this| {
-                                    @this.read_to_vec(|this|
-                                        this.read_type_param_def(xcx))
+                                    Rc::new(this.read_to_vec(|this|
+                                                             this.read_type_param_def(xcx)))
                             }),
                             region_param_defs:
                                 this.read_struct_field("region_param_defs",
@@ -1382,13 +1382,11 @@ fn decode_side_tables(xcx: @ExtendedDecodeContext,
                     }
                     c::tag_table_capture_map => {
                         let cvars =
-                            at_vec::to_managed_move(
-                                val_dsr.read_to_vec(
-                                    |val_dsr| val_dsr.read_capture_var(xcx)));
+                                val_dsr.read_to_vec(|val_dsr| val_dsr.read_capture_var(xcx));
                         let mut capture_map = dcx.maps
                                                  .capture_map
                                                  .borrow_mut();
-                        capture_map.get().insert(id, cvars);
+                        capture_map.get().insert(id, Rc::new(cvars));
                     }
                     _ => {
                         xcx.dcx.tcx.sess.bug(
diff --git a/src/librustc/middle/borrowck/check_loans.rs b/src/librustc/middle/borrowck/check_loans.rs
index 59310d722e4..b280da31c45 100644
--- a/src/librustc/middle/borrowck/check_loans.rs
+++ b/src/librustc/middle/borrowck/check_loans.rs
@@ -733,7 +733,7 @@ fn check_loans_in_fn<'a>(this: &mut CheckLoanCtxt<'a>,
                                 span: Span) {
         let capture_map = this.bccx.capture_map.borrow();
         let cap_vars = capture_map.get().get(&closure_id);
-        for cap_var in cap_vars.iter() {
+        for cap_var in cap_vars.borrow().iter() {
             let var_id = ast_util::def_id_of_def(cap_var.def).node;
             let var_path = @LpVar(var_id);
             this.check_if_path_is_moved(closure_id, span,
@@ -839,4 +839,3 @@ fn check_loans_in_block<'a>(this: &mut CheckLoanCtxt<'a>,
     visit::walk_block(this, blk, ());
     this.check_for_conflicting_loans(blk.id);
 }
-
diff --git a/src/librustc/middle/borrowck/gather_loans/gather_moves.rs b/src/librustc/middle/borrowck/gather_loans/gather_moves.rs
index 78350a993b4..0d9b4b0b171 100644
--- a/src/librustc/middle/borrowck/gather_loans/gather_moves.rs
+++ b/src/librustc/middle/borrowck/gather_loans/gather_moves.rs
@@ -69,7 +69,7 @@ pub fn gather_captures(bccx: &BorrowckCtxt,
                        closure_expr: &ast::Expr) {
     let capture_map = bccx.capture_map.borrow();
     let captured_vars = capture_map.get().get(&closure_expr.id);
-    for captured_var in captured_vars.iter() {
+    for captured_var in captured_vars.borrow().iter() {
         match captured_var.mode {
             moves::CapMove => {
                 let fvar_id = ast_util::def_id_of_def(captured_var.def).node;
diff --git a/src/librustc/middle/const_eval.rs b/src/librustc/middle/const_eval.rs
index 51410068378..d0ca53116b8 100644
--- a/src/librustc/middle/const_eval.rs
+++ b/src/librustc/middle/const_eval.rs
@@ -24,6 +24,7 @@ use syntax::{ast, ast_map, ast_util};
 
 use std::cell::RefCell;
 use std::hashmap::HashMap;
+use std::rc::Rc;
 
 //
 // This pass classifies expressions by their constant-ness.
@@ -321,7 +322,7 @@ pub enum const_val {
     const_int(i64),
     const_uint(u64),
     const_str(InternedString),
-    const_binary(@[u8]),
+    const_binary(Rc<~[u8]>),
     const_bool(bool)
 }
 
@@ -510,7 +511,7 @@ pub fn eval_const_expr_partial<T: ty::ExprTyProvider>(tcx: &T, e: &Expr)
 pub fn lit_to_const(lit: &Lit) -> const_val {
     match lit.node {
         LitStr(ref s, _) => const_str((*s).clone()),
-        LitBinary(data) => const_binary(data),
+        LitBinary(ref data) => const_binary(data.clone()),
         LitChar(n) => const_uint(n as u64),
         LitInt(n, _) => const_int(n),
         LitUint(n, _) => const_uint(n),
diff --git a/src/librustc/middle/kind.rs b/src/librustc/middle/kind.rs
index c05ca3e8769..0d6dc6572c3 100644
--- a/src/librustc/middle/kind.rs
+++ b/src/librustc/middle/kind.rs
@@ -277,7 +277,7 @@ pub fn check_expr(cx: &mut Context, e: &Expr) {
               ExprPath(_) => {
                 let did = ast_util::def_id_of_def(def_map.get()
                                                          .get_copy(&e.id));
-                ty::lookup_item_type(cx.tcx, did).generics.type_param_defs
+                ty::lookup_item_type(cx.tcx, did).generics.type_param_defs.clone()
               }
               _ => {
                 // Type substitutions should only occur on paths and
@@ -289,6 +289,7 @@ pub fn check_expr(cx: &mut Context, e: &Expr) {
                     "non path/method call expr has type substs??")
               }
             };
+            let type_param_defs = type_param_defs.borrow();
             if ts.len() != type_param_defs.len() {
                 // Fail earlier to make debugging easier
                 fail!("internal error: in kind::check_expr, length \
@@ -362,8 +363,8 @@ fn check_ty(cx: &mut Context, aty: &Ty) {
             for ts in r.iter() {
                 let def_map = cx.tcx.def_map.borrow();
                 let did = ast_util::def_id_of_def(def_map.get().get_copy(&id));
-                let type_param_defs =
-                    ty::lookup_item_type(cx.tcx, did).generics.type_param_defs;
+                let generics = ty::lookup_item_type(cx.tcx, did).generics;
+                let type_param_defs = generics.type_param_defs();
                 for (&ty, type_param_def) in ts.iter().zip(type_param_defs.iter()) {
                     check_typaram_bounds(cx, aty.id, aty.span, ty, type_param_def)
                 }
diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs
index ed583f919ca..fb5e548e12f 100644
--- a/src/librustc/middle/liveness.rs
+++ b/src/librustc/middle/liveness.rs
@@ -502,7 +502,7 @@ fn visit_expr(v: &mut LivenessVisitor, expr: &Expr, this: @IrMaps) {
         let capture_map = this.capture_map.borrow();
         let cvs = capture_map.get().get(&expr.id);
         let mut call_caps = ~[];
-        for cv in cvs.iter() {
+        for cv in cvs.borrow().iter() {
             match moves::moved_variable_node_id_from_def(cv.def) {
               Some(rv) => {
                 let cv_ln = this.add_live_node(FreeVarNode(cv.span));
diff --git a/src/librustc/middle/moves.rs b/src/librustc/middle/moves.rs
index b0171eafeb3..d73d7f3d6f1 100644
--- a/src/librustc/middle/moves.rs
+++ b/src/librustc/middle/moves.rs
@@ -136,9 +136,9 @@ use util::ppaux::Repr;
 use util::common::indenter;
 use util::ppaux::UserString;
 
-use std::at_vec;
 use std::cell::RefCell;
 use std::hashmap::{HashSet, HashMap};
+use std::rc::Rc;
 use syntax::ast::*;
 use syntax::ast_util;
 use syntax::visit;
@@ -159,7 +159,7 @@ pub struct CaptureVar {
     mode: CaptureMode // How variable is being accessed
 }
 
-pub type CaptureMap = @RefCell<HashMap<NodeId, @[CaptureVar]>>;
+pub type CaptureMap = @RefCell<HashMap<NodeId, Rc<~[CaptureVar]>>>;
 
 pub type MovesMap = @RefCell<HashSet<NodeId>>;
 
@@ -681,23 +681,22 @@ impl VisitContext {
         self.consume_expr(arg_expr)
     }
 
-    pub fn compute_captures(&mut self, fn_expr_id: NodeId) -> @[CaptureVar] {
+    pub fn compute_captures(&mut self, fn_expr_id: NodeId) -> Rc<~[CaptureVar]> {
         debug!("compute_capture_vars(fn_expr_id={:?})", fn_expr_id);
         let _indenter = indenter();
 
         let fn_ty = ty::node_id_to_type(self.tcx, fn_expr_id);
         let sigil = ty::ty_closure_sigil(fn_ty);
         let freevars = freevars::get_freevars(self.tcx, fn_expr_id);
-        if sigil == BorrowedSigil {
+        let v = if sigil == BorrowedSigil {
             // || captures everything by ref
-            at_vec::from_fn(freevars.len(), |i| {
-                let fvar = &freevars[i];
-                CaptureVar {def: fvar.def, span: fvar.span, mode: CapRef}
-            })
+            freevars.iter()
+                    .map(|fvar| CaptureVar {def: fvar.def, span: fvar.span, mode: CapRef})
+                    .collect()
         } else {
             // @fn() and ~fn() capture by copy or by move depending on type
-            at_vec::from_fn(freevars.len(), |i| {
-                let fvar = &freevars[i];
+            freevars.iter()
+                    .map(|fvar| {
                 let fvar_def_id = ast_util::def_id_of_def(fvar.def).node;
                 let fvar_ty = ty::node_id_to_type(self.tcx, fvar_def_id);
                 debug!("fvar_def_id={:?} fvar_ty={}",
@@ -708,7 +707,9 @@ impl VisitContext {
                     CapCopy
                 };
                 CaptureVar {def: fvar.def, span: fvar.span, mode:mode}
-            })
-        }
+
+                }).collect()
+        };
+        Rc::new(v)
     }
 }
diff --git a/src/librustc/middle/subst.rs b/src/librustc/middle/subst.rs
index 067082992c6..c4a30171687 100644
--- a/src/librustc/middle/subst.rs
+++ b/src/librustc/middle/subst.rs
@@ -13,8 +13,9 @@
 use middle::ty;
 use middle::ty_fold;
 use middle::ty_fold::TypeFolder;
+
+use std::rc::Rc;
 use syntax::opt_vec::OptVec;
-use std::at_vec;
 
 ///////////////////////////////////////////////////////////////////////////
 // Public trait `Subst`
@@ -84,10 +85,9 @@ impl<T:Subst> Subst for ~[T] {
         self.map(|t| t.subst(tcx, substs))
     }
 }
-
-impl<T:Subst> Subst for @[T] {
-    fn subst(&self, tcx: ty::ctxt, substs: &ty::substs) -> @[T] {
-        at_vec::map(*self, |t| t.subst(tcx, substs))
+impl<T:Subst> Subst for Rc<T> {
+    fn subst(&self, tcx: ty::ctxt, substs: &ty::substs) -> Rc<T> {
+        Rc::new(self.borrow().subst(tcx, substs))
     }
 }
 
diff --git a/src/librustc/middle/trans/callee.rs b/src/librustc/middle/trans/callee.rs
index e10c7af7f31..80d92d85686 100644
--- a/src/librustc/middle/trans/callee.rs
+++ b/src/librustc/middle/trans/callee.rs
@@ -220,7 +220,7 @@ fn resolve_default_method_vtables(bcx: &Block,
         bcx.tcx(), param_substs, impl_res.trait_vtables);
 
     // Now we pull any vtables for parameters on the actual method.
-    let num_method_vtables = method.generics.type_param_defs.len();
+    let num_method_vtables = method.generics.type_param_defs().len();
     let method_vtables = match impl_vtables {
         Some(vtables) => {
             let num_impl_type_parameters =
diff --git a/src/librustc/middle/trans/closure.rs b/src/librustc/middle/trans/closure.rs
index d1979c3fee7..c9631a72ee7 100644
--- a/src/librustc/middle/trans/closure.rs
+++ b/src/librustc/middle/trans/closure.rs
@@ -403,11 +403,11 @@ pub fn trans_expr_fn<'a>(
         let capture_map = ccx.maps.capture_map.borrow();
         capture_map.get().get_copy(&user_id)
     };
-    let ClosureResult {llbox, cdata_ty, bcx} = build_closure(bcx, cap_vars, sigil);
+    let ClosureResult {llbox, cdata_ty, bcx} = build_closure(bcx, *cap_vars.borrow(), sigil);
     trans_closure(ccx, sub_path, decl, body, llfn,
                   bcx.fcx.param_substs, user_id,
                   [], ty::ty_fn_ret(fty),
-                  |bcx| load_environment(bcx, cdata_ty, cap_vars, sigil));
+                  |bcx| load_environment(bcx, cdata_ty, *cap_vars.borrow(), sigil));
     fill_fn_pair(bcx, dest_addr, llfn, llbox);
 
     bcx
diff --git a/src/librustc/middle/trans/inline.rs b/src/librustc/middle/trans/inline.rs
index 3a0b97813df..c60199b3c0d 100644
--- a/src/librustc/middle/trans/inline.rs
+++ b/src/librustc/middle/trans/inline.rs
@@ -152,7 +152,7 @@ pub fn maybe_instantiate_inline(ccx: @CrateContext, fn_id: ast::DefId)
 
             let impl_tpt = ty::lookup_item_type(ccx.tcx, impl_did);
             let num_type_params =
-                impl_tpt.generics.type_param_defs.len() +
+                impl_tpt.generics.type_param_defs().len() +
                 mth.generics.ty_params.len();
 
           if num_type_params == 0 {
diff --git a/src/librustc/middle/trans/meth.rs b/src/librustc/middle/trans/meth.rs
index 09bfa36ddc1..b13a8800cee 100644
--- a/src/librustc/middle/trans/meth.rs
+++ b/src/librustc/middle/trans/meth.rs
@@ -182,7 +182,7 @@ pub fn trans_static_method_callee(bcx: &Block,
     // out which impl the `Trait<T1...Tn>` bound on the type `self` was
     // bound to.
     let bound_index = ty::lookup_trait_def(bcx.tcx(), trait_id).
-        generics.type_param_defs.len();
+        generics.type_param_defs().len();
 
     let mname = if method_id.crate == ast::LOCAL_CRATE {
         {
@@ -318,7 +318,7 @@ pub fn combine_impl_and_methods_tps(bcx: &Block,
 
     let ccx = bcx.ccx();
     let method = ty::method(ccx.tcx, mth_did);
-    let n_m_tps = method.generics.type_param_defs.len();
+    let n_m_tps = method.generics.type_param_defs().len();
     let node_substs = node_id_type_params(bcx, callee_id);
     debug!("rcvr_substs={:?}", rcvr_substs.repr(ccx.tcx));
     let ty_substs
diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs
index 066be142f24..dd7c0803333 100644
--- a/src/librustc/middle/ty.rs
+++ b/src/librustc/middle/ty.rs
@@ -34,6 +34,7 @@ use std::cmp;
 use std::hashmap::{HashMap, HashSet};
 use std::ops;
 use std::ptr::to_unsafe_ptr;
+use std::rc::Rc;
 use std::to_bytes;
 use std::to_str::ToStr;
 use std::vec;
@@ -870,15 +871,21 @@ pub struct RegionParameterDef {
 #[deriving(Clone)]
 pub struct Generics {
     /// List of type parameters declared on the item.
-    type_param_defs: @~[TypeParameterDef],
+    type_param_defs: Rc<~[TypeParameterDef]>,
 
     /// List of region parameters declared on the item.
-    region_param_defs: @[RegionParameterDef],
+    region_param_defs: Rc<~[RegionParameterDef]>,
 }
 
 impl Generics {
     pub fn has_type_params(&self) -> bool {
-        !self.type_param_defs.is_empty()
+        !self.type_param_defs.borrow().is_empty()
+    }
+    pub fn type_param_defs<'a>(&'a self) -> &'a [TypeParameterDef] {
+        self.type_param_defs.borrow().as_slice()
+    }
+    pub fn region_param_defs<'a>(&'a self) -> &'a [RegionParameterDef] {
+        self.region_param_defs.borrow().as_slice()
     }
 }
 
@@ -3105,7 +3112,7 @@ pub fn expr_has_ty_params(cx: ctxt, expr: &ast::Expr) -> bool {
 pub fn method_call_type_param_defs(tcx: ctxt,
                                    method_map: typeck::method_map,
                                    id: ast::NodeId)
-                                   -> Option<@~[TypeParameterDef]> {
+                                   -> Option<Rc<~[TypeParameterDef]>> {
     let method_map = method_map.borrow();
     method_map.get().find(&id).map(|method| {
         match method.origin {
@@ -3125,12 +3132,12 @@ pub fn method_call_type_param_defs(tcx: ctxt,
             // method bounds, so we must preprend the tps from the
             // trait itself.  This ought to be harmonized.
             let trait_type_param_defs =
-                lookup_trait_def(tcx, trt_id).generics.type_param_defs;
-            @vec::append(
-                (*trait_type_param_defs).clone(),
-                *ty::trait_method(tcx,
-                                  trt_id,
-                                  n_mth).generics.type_param_defs)
+                lookup_trait_def(tcx, trt_id).generics.type_param_defs();
+            Rc::new(vec::append(
+                trait_type_param_defs.to_owned(),
+                ty::trait_method(tcx,
+                                 trt_id,
+                                 n_mth).generics.type_param_defs()))
           }
         }
     })
@@ -4212,7 +4219,7 @@ pub fn lookup_field_type(tcx: ctxt,
                Some(&ty_param_bounds_and_ty {ty, ..}) => ty,
                None => {
                    let tpt = csearch::get_field_type(tcx, struct_id, id);
-                   tcache.get().insert(id, tpt);
+                   tcache.get().insert(id, tpt.clone());
                    tpt.ty
                }
             }
diff --git a/src/librustc/middle/typeck/astconv.rs b/src/librustc/middle/typeck/astconv.rs
index 9f8b9140417..0cc646aa5c3 100644
--- a/src/librustc/middle/typeck/astconv.rs
+++ b/src/librustc/middle/typeck/astconv.rs
@@ -170,7 +170,7 @@ fn ast_path_substs<AC:AstConv,RS:RegionScope>(
     // If the type is parameterized by the this region, then replace this
     // region with the current anon region binding (in other words,
     // whatever & would get replaced with).
-    let expected_num_region_params = decl_generics.region_param_defs.len();
+    let expected_num_region_params = decl_generics.region_param_defs().len();
     let supplied_num_region_params = path.segments.last().unwrap().lifetimes.len();
     let regions = if expected_num_region_params == supplied_num_region_params {
         path.segments.last().unwrap().lifetimes.map(
@@ -197,8 +197,8 @@ fn ast_path_substs<AC:AstConv,RS:RegionScope>(
 
     // Convert the type parameters supplied by the user.
     let supplied_ty_param_count = path.segments.iter().flat_map(|s| s.types.iter()).len();
-    let formal_ty_param_count = decl_generics.type_param_defs.len();
-    let required_ty_param_count = decl_generics.type_param_defs.iter()
+    let formal_ty_param_count = decl_generics.type_param_defs().len();
+    let required_ty_param_count = decl_generics.type_param_defs().iter()
                                                .take_while(|x| x.default.is_none())
                                                .len();
     if supplied_ty_param_count < required_ty_param_count {
@@ -228,7 +228,7 @@ fn ast_path_substs<AC:AstConv,RS:RegionScope>(
                                  ~"provided type arguments with defaults");
     }
 
-    let defaults = decl_generics.type_param_defs.slice_from(supplied_ty_param_count)
+    let defaults = decl_generics.type_param_defs().slice_from(supplied_ty_param_count)
                                 .iter().map(|&x| x.default.unwrap());
     let tps = path.segments.iter().flat_map(|s| s.types.iter())
                             .map(|&a_t| ast_ty_to_ty(this, rscope, a_t))
diff --git a/src/librustc/middle/typeck/check/_match.rs b/src/librustc/middle/typeck/check/_match.rs
index 37862943dd7..e57e3ff4712 100644
--- a/src/librustc/middle/typeck/check/_match.rs
+++ b/src/librustc/middle/typeck/check/_match.rs
@@ -147,7 +147,7 @@ pub fn check_pat_variant(pcx: &pat_ctxt, pat: &ast::Pat, path: &ast::Path,
                             ty::enum_variant_with_id(tcx, enm, var);
                         let var_tpt = ty::lookup_item_type(tcx, var);
                         vinfo.args.map(|t| {
-                            if var_tpt.generics.type_param_defs.len() ==
+                            if var_tpt.generics.type_param_defs().len() ==
                                 expected_substs.tps.len()
                             {
                                 ty::subst(tcx, expected_substs, *t)
@@ -172,7 +172,7 @@ pub fn check_pat_variant(pcx: &pat_ctxt, pat: &ast::Pat, path: &ast::Path,
                              None);
                     fcx.write_error(pat.id);
                     kind_name = "[error]";
-                    arg_types = (*subpats).clone()
+                    arg_types = subpats.clone()
                                           .unwrap_or_default()
                                           .map(|_| ty::mk_err());
                 }
@@ -221,7 +221,7 @@ pub fn check_pat_variant(pcx: &pat_ctxt, pat: &ast::Pat, path: &ast::Path,
                     None);
             fcx.write_error(pat.id);
             kind_name = "[error]";
-            arg_types = (*subpats).clone()
+            arg_types = subpats.clone()
                                   .unwrap_or_default()
                                   .map(|_| ty::mk_err());
         }
@@ -699,4 +699,3 @@ pub fn check_pointer_pat(pcx: &pat_ctxt,
 
 #[deriving(Eq)]
 enum PointerKind { Send, Borrowed }
-
diff --git a/src/librustc/middle/typeck/check/method.rs b/src/librustc/middle/typeck/check/method.rs
index 09d04753def..e7e4f61741f 100644
--- a/src/librustc/middle/typeck/check/method.rs
+++ b/src/librustc/middle/typeck/check/method.rs
@@ -954,7 +954,7 @@ impl<'a> LookupContext<'a> {
         // If they were not explicitly supplied, just construct fresh
         // type variables.
         let num_supplied_tps = self.supplied_tps.len();
-        let num_method_tps = candidate.method_ty.generics.type_param_defs.len();
+        let num_method_tps = candidate.method_ty.generics.type_param_defs().len();
         let m_substs = {
             if num_supplied_tps == 0u {
                 self.fcx.infcx().next_ty_vars(num_method_tps)
diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs
index 121b0486fb1..f446326eb16 100644
--- a/src/librustc/middle/typeck/check/mod.rs
+++ b/src/librustc/middle/typeck/check/mod.rs
@@ -564,7 +564,7 @@ pub fn check_item(ccx: @CrateCtxt, it: &ast::Item) {
         let param_env = ty::construct_parameter_environment(
                 ccx.tcx,
                 None,
-                *fn_tpt.generics.type_param_defs,
+                fn_tpt.generics.type_param_defs(),
                 [],
                 [],
                 body.id);
@@ -674,9 +674,9 @@ fn check_method_body(ccx: @CrateCtxt,
         ty::construct_parameter_environment(
             ccx.tcx,
             self_bound,
-            *item_generics.type_param_defs,
-            *method_generics.type_param_defs,
-            item_generics.region_param_defs,
+            item_generics.type_param_defs(),
+            method_generics.type_param_defs(),
+            item_generics.region_param_defs(),
             method.body.id);
 
     // Compute the fty from point of view of inside fn
@@ -776,7 +776,7 @@ fn compare_impl_method(tcx: ty::ctxt,
     debug!("compare_impl_method()");
     let infcx = infer::new_infer_ctxt(tcx);
 
-    let impl_tps = impl_generics.type_param_defs.len();
+    let impl_tps = impl_generics.type_param_defs().len();
 
     // Try to give more informative error messages about self typing
     // mismatches.  Note that any mismatch will also be detected
@@ -812,8 +812,8 @@ fn compare_impl_method(tcx: ty::ctxt,
         }
     }
 
-    let num_impl_m_type_params = impl_m.generics.type_param_defs.len();
-    let num_trait_m_type_params = trait_m.generics.type_param_defs.len();
+    let num_impl_m_type_params = impl_m.generics.type_param_defs().len();
+    let num_trait_m_type_params = trait_m.generics.type_param_defs().len();
     if num_impl_m_type_params != num_trait_m_type_params {
         tcx.sess.span_err(
             impl_m_span,
@@ -838,10 +838,10 @@ fn compare_impl_method(tcx: ty::ctxt,
         return;
     }
 
-    for (i, trait_param_def) in trait_m.generics.type_param_defs.iter().enumerate() {
-        // For each of the corresponding impl ty param's bounds...
-        let impl_param_def = &impl_m.generics.type_param_defs[i];
+    let it = trait_m.generics.type_param_defs().iter()
+        .zip(impl_m.generics.type_param_defs().iter());
 
+    for (i, (trait_param_def, impl_param_def)) in it.enumerate() {
         // Check that the impl does not require any builtin-bounds
         // that the trait does not guarantee:
         let extra_bounds =
@@ -886,15 +886,15 @@ fn compare_impl_method(tcx: ty::ctxt,
     // impl type is "&'a str", then this would replace the self
     // type with a free region `self`.
     let dummy_impl_tps: ~[ty::t] =
-        impl_generics.type_param_defs.iter().enumerate().
+        impl_generics.type_param_defs().iter().enumerate().
         map(|(i,t)| ty::mk_param(tcx, i, t.def_id)).
         collect();
     let dummy_method_tps: ~[ty::t] =
-        impl_m.generics.type_param_defs.iter().enumerate().
+        impl_m.generics.type_param_defs().iter().enumerate().
         map(|(i,t)| ty::mk_param(tcx, i + impl_tps, t.def_id)).
         collect();
     let dummy_impl_regions: OptVec<ty::Region> =
-        impl_generics.region_param_defs.iter().
+        impl_generics.region_param_defs().iter().
         map(|l| ty::ReFree(ty::FreeRegion {
                 scope_id: impl_m_body_id,
                 bound_region: ty::BrNamed(l.def_id, l.ident)})).
@@ -1374,8 +1374,8 @@ pub fn impl_self_ty(vcx: &VtableContext,
 
     let (n_tps, n_rps, raw_ty) = {
         let ity = ty::lookup_item_type(tcx, did);
-        (ity.generics.type_param_defs.len(),
-         ity.generics.region_param_defs.len(),
+        (ity.generics.type_param_defs().len(),
+         ity.generics.region_param_defs().len(),
          ity.ty)
     };
 
@@ -1419,10 +1419,10 @@ fn generics_of_static_method_container(type_context: ty::ctxt,
                                        -> ty::Generics {
     match provenance {
         ast::FromTrait(trait_def_id) => {
-            ty::lookup_trait_def(type_context, trait_def_id).generics
+            ty::lookup_trait_def(type_context, trait_def_id).generics.clone()
         }
         ast::FromImpl(impl_def_id) => {
-            ty::lookup_item_type(type_context, impl_def_id).generics
+            ty::lookup_item_type(type_context, impl_def_id).generics.clone()
         }
     }
 }
@@ -1485,7 +1485,7 @@ fn check_type_parameter_positions_in_path(function_context: @FnCtxt,
 
             // Make sure lifetime parameterization agrees with the trait or
             // implementation type.
-            let trait_region_parameter_count = generics.region_param_defs.len();
+            let trait_region_parameter_count = generics.region_param_defs().len();
             let supplied_region_parameter_count = trait_segment.lifetimes.len();
             if trait_region_parameter_count != supplied_region_parameter_count
                 && supplied_region_parameter_count != 0 {
@@ -1501,8 +1501,8 @@ fn check_type_parameter_positions_in_path(function_context: @FnCtxt,
             // Make sure the number of type parameters supplied on the trait
             // or implementation segment equals the number of type parameters
             // on the trait or implementation definition.
-            let formal_ty_param_count = generics.type_param_defs.len();
-            let required_ty_param_count = generics.type_param_defs.iter()
+            let formal_ty_param_count = generics.type_param_defs().len();
+            let required_ty_param_count = generics.type_param_defs().iter()
                                                   .take_while(|x| x.default.is_none())
                                                   .len();
             let supplied_ty_param_count = trait_segment.types.len();
@@ -1517,7 +1517,7 @@ fn check_type_parameter_positions_in_path(function_context: @FnCtxt,
                 } else {
                     "s"
                 };
-                let needs = if required_ty_param_count < generics.type_param_defs.len() {
+                let needs = if required_ty_param_count < generics.type_param_defs().len() {
                     "needs at least"
                 } else {
                     "needs"
@@ -1539,7 +1539,7 @@ fn check_type_parameter_positions_in_path(function_context: @FnCtxt,
                 } else {
                     "s"
                 };
-                let needs = if required_ty_param_count < generics.type_param_defs.len() {
+                let needs = if required_ty_param_count < generics.type_param_defs().len() {
                     "needs at most"
                 } else {
                     "needs"
@@ -2465,8 +2465,8 @@ pub fn check_expr_with_unifier(fcx: @FnCtxt,
         // Look up the number of type parameters and the raw type, and
         // determine whether the class is region-parameterized.
         let item_type = ty::lookup_item_type(tcx, class_id);
-        let type_parameter_count = item_type.generics.type_param_defs.len();
-        let region_parameter_count = item_type.generics.region_param_defs.len();
+        let type_parameter_count = item_type.generics.type_param_defs().len();
+        let region_parameter_count = item_type.generics.region_param_defs().len();
         let raw_type = item_type.ty;
 
         // Generate the struct type.
@@ -2523,8 +2523,8 @@ pub fn check_expr_with_unifier(fcx: @FnCtxt,
         // Look up the number of type parameters and the raw type, and
         // determine whether the enum is region-parameterized.
         let item_type = ty::lookup_item_type(tcx, enum_id);
-        let type_parameter_count = item_type.generics.type_param_defs.len();
-        let region_parameter_count = item_type.generics.region_param_defs.len();
+        let type_parameter_count = item_type.generics.type_param_defs().len();
+        let region_parameter_count = item_type.generics.region_param_defs().len();
         let raw_type = item_type.ty;
 
         // Generate the enum type.
@@ -3710,8 +3710,8 @@ pub fn instantiate_path(fcx: @FnCtxt,
                         node_id: ast::NodeId) {
     debug!(">>> instantiate_path");
 
-    let ty_param_count = tpt.generics.type_param_defs.len();
-    let ty_param_req = tpt.generics.type_param_defs.iter()
+    let ty_param_count = tpt.generics.type_param_defs().len();
+    let ty_param_req = tpt.generics.type_param_defs().iter()
                                                    .take_while(|x| x.default.is_none())
                                                    .len();
     let mut ty_substs_len = 0;
@@ -3726,7 +3726,7 @@ pub fn instantiate_path(fcx: @FnCtxt,
 
     // determine the region parameters, using the value given by the user
     // (if any) and otherwise using a fresh region variable
-    let num_expected_regions = tpt.generics.region_param_defs.len();
+    let num_expected_regions = tpt.generics.region_param_defs().len();
     let num_supplied_regions = pth.segments.last().unwrap().lifetimes.len();
     let regions = if num_expected_regions == num_supplied_regions {
         pth.segments.last().unwrap().lifetimes.map(
@@ -3755,7 +3755,7 @@ pub fn instantiate_path(fcx: @FnCtxt,
         ast::DefStaticMethod(_, provenance @ ast::FromTrait(_), _) => {
             let generics = generics_of_static_method_container(fcx.ccx.tcx,
                                                                provenance);
-            (ty_param_count - 1, ty_param_req - 1, Some(generics.type_param_defs.len()))
+            (ty_param_count - 1, ty_param_req - 1, Some(generics.type_param_defs().len()))
         }
         _ => (ty_param_count, ty_param_req, None),
     };
@@ -3800,7 +3800,7 @@ pub fn instantiate_path(fcx: @FnCtxt,
         // at the appropriate position.
         let mut result = ~[];
         let mut pushed = false;
-        let defaults = tpt.generics.type_param_defs.iter()
+        let defaults = tpt.generics.type_param_defs().iter()
                           .enumerate().filter_map(|(i, x)| {
             match self_parameter_index {
                 Some(index) if index == i => None,
@@ -4305,7 +4305,7 @@ pub fn check_intrinsic_type(ccx: @CrateCtxt, it: &ast::ForeignItem) {
                     variadic: false}
     });
     let i_ty = ty::lookup_item_type(ccx.tcx, local_def(it.id));
-    let i_n_tps = i_ty.generics.type_param_defs.len();
+    let i_n_tps = i_ty.generics.type_param_defs().len();
     if i_n_tps != n_tps {
         tcx.sess.span_err(it.span, format!("intrinsic has wrong number \
                                          of type parameters: found {}, \
diff --git a/src/librustc/middle/typeck/check/vtable.rs b/src/librustc/middle/typeck/check/vtable.rs
index 0a231be5d45..4db43b2c913 100644
--- a/src/librustc/middle/typeck/check/vtable.rs
+++ b/src/librustc/middle/typeck/check/vtable.rs
@@ -423,7 +423,7 @@ fn search_for_vtable(vcx: &VtableContext,
         let im_generics =
             ty::lookup_item_type(tcx, im.did).generics;
         let subres = lookup_vtables(vcx, location_info,
-                                    *im_generics.type_param_defs, &substs,
+                                    im_generics.type_param_defs(), &substs,
                                     is_early);
 
 
@@ -688,12 +688,12 @@ pub fn early_resolve_expr(ex: &ast::Expr, fcx: @FnCtxt, is_early: bool) {
             let item_ty = ty::lookup_item_type(cx.tcx, did);
             debug!("early resolve expr: def {:?} {:?}, {:?}, {}", ex.id, did, def,
                    fcx.infcx().ty_to_str(item_ty.ty));
-            if has_trait_bounds(*item_ty.generics.type_param_defs) {
+            if has_trait_bounds(item_ty.generics.type_param_defs()) {
                 debug!("early_resolve_expr: looking up vtables for type params {}",
-                       item_ty.generics.type_param_defs.repr(fcx.tcx()));
+                       item_ty.generics.type_param_defs().repr(fcx.tcx()));
                 let vcx = fcx.vtable_context();
                 let vtbls = lookup_vtables(&vcx, &location_info_for_expr(ex),
-                                           *item_ty.generics.type_param_defs,
+                                           item_ty.generics.type_param_defs(),
                                            substs, is_early);
                 if !is_early {
                     insert_vtables(fcx, ex.id, vtbls);
@@ -717,11 +717,11 @@ pub fn early_resolve_expr(ex: &ast::Expr, fcx: @FnCtxt, is_early: bool) {
           Some(type_param_defs) => {
             debug!("vtable resolution on parameter bounds for method call {}",
                    ex.repr(fcx.tcx()));
-            if has_trait_bounds(*type_param_defs) {
+            if has_trait_bounds(*type_param_defs.borrow()) {
                 let substs = fcx.node_ty_substs(callee_id);
                 let vcx = fcx.vtable_context();
                 let vtbls = lookup_vtables(&vcx, &location_info_for_expr(ex),
-                                           *type_param_defs, &substs, is_early);
+                                           *type_param_defs.borrow(), &substs, is_early);
                 if !is_early {
                     insert_vtables(fcx, callee_id, vtbls);
                 }
@@ -784,9 +784,9 @@ pub fn resolve_impl(ccx: @CrateCtxt,
     let param_env = ty::construct_parameter_environment(
         ccx.tcx,
         None,
-        *impl_generics.type_param_defs,
+        impl_generics.type_param_defs(),
         [],
-        impl_generics.region_param_defs,
+        impl_generics.region_param_defs(),
         impl_item.id);
 
     let impl_trait_ref = @impl_trait_ref.subst(ccx.tcx, &param_env.free_substs);
@@ -800,7 +800,7 @@ pub fn resolve_impl(ccx: @CrateCtxt,
     let trait_def = ty::lookup_trait_def(ccx.tcx, impl_trait_ref.def_id);
     let vtbls = lookup_vtables(&vcx,
                                &loc_info,
-                               *trait_def.generics.type_param_defs,
+                               trait_def.generics.type_param_defs(),
                                &impl_trait_ref.substs,
                                false);
 
diff --git a/src/librustc/middle/typeck/coherence.rs b/src/librustc/middle/typeck/coherence.rs
index 0dcb3c7329b..5ca879fea4a 100644
--- a/src/librustc/middle/typeck/coherence.rs
+++ b/src/librustc/middle/typeck/coherence.rs
@@ -47,13 +47,13 @@ use syntax::visit;
 
 use std::cell::RefCell;
 use std::hashmap::HashSet;
-use std::result::Ok;
+use std::rc::Rc;
 use std::vec;
 
 pub struct UniversalQuantificationResult {
     monotype: t,
     type_variables: ~[ty::t],
-    type_param_defs: @~[ty::TypeParameterDef]
+    type_param_defs: Rc<~[ty::TypeParameterDef]>
 }
 
 pub fn get_base_type(inference_context: @InferCtxt,
@@ -356,11 +356,11 @@ impl CoherenceChecker {
             // construct the polytype for the method based on the method_ty
             let new_generics = ty::Generics {
                 type_param_defs:
-                    @vec::append(
-                        (*impl_poly_type.generics.type_param_defs).clone(),
-                        *new_method_ty.generics.type_param_defs),
+                    Rc::new(vec::append(
+                        impl_poly_type.generics.type_param_defs().to_owned(),
+                            new_method_ty.generics.type_param_defs())),
                 region_param_defs:
-                    impl_poly_type.generics.region_param_defs
+                    impl_poly_type.generics.region_param_defs.clone()
             };
             let new_polytype = ty::ty_param_bounds_and_ty {
                 generics: new_generics,
@@ -449,7 +449,7 @@ impl CoherenceChecker {
                     let polytype_b = self.get_self_type_for_implementation(
                             implementation_b);
 
-                    if self.polytypes_unify(polytype_a, polytype_b) {
+                    if self.polytypes_unify(polytype_a.clone(), polytype_b) {
                         let session = self.crate_context.tcx.sess;
                         session.span_err(
                             self.span_of_impl(implementation_b),
@@ -497,13 +497,13 @@ impl CoherenceChecker {
     pub fn universally_quantify_polytype(&self,
                                          polytype: ty_param_bounds_and_ty)
                                          -> UniversalQuantificationResult {
-        let region_parameter_count = polytype.generics.region_param_defs.len();
+        let region_parameter_count = polytype.generics.region_param_defs().len();
         let region_parameters =
             self.inference_context.next_region_vars(
                 infer::BoundRegionInCoherence,
                 region_parameter_count);
 
-        let bounds_count = polytype.generics.type_param_defs.len();
+        let bounds_count = polytype.generics.type_param_defs().len();
         let type_parameters = self.inference_context.next_ty_vars(bounds_count);
 
         let substitutions = substs {
@@ -518,7 +518,7 @@ impl CoherenceChecker {
         UniversalQuantificationResult {
             monotype: monotype,
             type_variables: substitutions.tps,
-            type_param_defs: polytype.generics.type_param_defs
+            type_param_defs: polytype.generics.type_param_defs.clone()
         }
     }
 
@@ -770,7 +770,7 @@ pub fn make_substs_for_receiver_types(tcx: ty::ctxt,
     // determine how many type parameters were declared on the impl
     let num_impl_type_parameters = {
         let impl_polytype = ty::lookup_item_type(tcx, impl_id);
-        impl_polytype.generics.type_param_defs.len()
+        impl_polytype.generics.type_param_defs().len()
     };
 
     // determine how many type parameters appear on the trait
@@ -778,7 +778,7 @@ pub fn make_substs_for_receiver_types(tcx: ty::ctxt,
 
     // the current method type has the type parameters from the trait + method
     let num_method_type_parameters =
-        num_trait_type_parameters + method.generics.type_param_defs.len();
+        num_trait_type_parameters + method.generics.type_param_defs().len();
 
     // the new method type will have the type parameters from the impl + method
     let combined_tps = vec::from_fn(num_method_type_parameters, |i| {
@@ -789,7 +789,7 @@ pub fn make_substs_for_receiver_types(tcx: ty::ctxt,
             // replace type parameters that belong to method with another
             // type parameter, this time with the index adjusted
             let method_index = i - num_trait_type_parameters;
-            let type_param_def = &method.generics.type_param_defs[method_index];
+            let type_param_def = &method.generics.type_param_defs()[method_index];
             let new_index = num_impl_type_parameters + method_index;
             ty::mk_param(tcx, new_index, type_param_def.def_id)
         }
diff --git a/src/librustc/middle/typeck/collect.rs b/src/librustc/middle/typeck/collect.rs
index d9a9d9f8fe1..c1a6e53069e 100644
--- a/src/librustc/middle/typeck/collect.rs
+++ b/src/librustc/middle/typeck/collect.rs
@@ -44,6 +44,7 @@ use middle::typeck::{CrateCtxt, lookup_def_tcx, no_params, write_ty_to_tcx};
 use util::ppaux;
 use util::ppaux::Repr;
 
+use std::rc::Rc;
 use std::vec;
 use syntax::abi::AbiSet;
 use syntax::ast::{RegionTyParamBound, TraitTyParamBound};
@@ -285,9 +286,9 @@ pub fn ensure_trait_methods(ccx: &CrateCtxt, trait_id: ast::NodeId) {
         let dummy_defid = ast::DefId {crate: 0, node: 0};
 
         // Represents [A',B',C']
-        let num_trait_bounds = trait_ty_generics.type_param_defs.len();
+        let num_trait_bounds = trait_ty_generics.type_param_defs().len();
         let non_shifted_trait_tps = vec::from_fn(num_trait_bounds, |i| {
-            ty::mk_param(tcx, i, trait_ty_generics.type_param_defs[i].def_id)
+            ty::mk_param(tcx, i, trait_ty_generics.type_param_defs()[i].def_id)
         });
 
         // Represents [D']
@@ -295,18 +296,18 @@ pub fn ensure_trait_methods(ccx: &CrateCtxt, trait_id: ast::NodeId) {
                                       dummy_defid);
 
         // Represents [E',F',G']
-        let num_method_bounds = m.generics.type_param_defs.len();
+        let num_method_bounds = m.generics.type_param_defs().len();
         let shifted_method_tps = vec::from_fn(num_method_bounds, |i| {
             ty::mk_param(tcx, i + num_trait_bounds + 1,
-                         m.generics.type_param_defs[i].def_id)
+                         m.generics.type_param_defs()[i].def_id)
         });
 
         // Convert the regions 'a, 'b, 'c defined on the trait into
         // bound regions on the fn. Note that because these appear in the
         // bound for `Self` they must be early bound.
-        let new_early_region_param_defs = trait_ty_generics.region_param_defs;
+        let new_early_region_param_defs = trait_ty_generics.region_param_defs.clone();
         let rps_from_trait =
-            trait_ty_generics.region_param_defs.iter().
+            trait_ty_generics.region_param_defs().iter().
             enumerate().
             map(|(index,d)| ty::ReEarlyBound(d.def_id.node, index, d.ident)).
             collect();
@@ -334,7 +335,7 @@ pub fn ensure_trait_methods(ccx: &CrateCtxt, trait_id: ast::NodeId) {
         let mut new_type_param_defs = ~[];
         let substd_type_param_defs =
             trait_ty_generics.type_param_defs.subst(tcx, &substs);
-        new_type_param_defs.push_all(*substd_type_param_defs);
+        new_type_param_defs.push_all(*substd_type_param_defs.borrow());
 
         // add in the "self" type parameter
         let self_trait_def = get_trait_def(ccx, local_def(trait_id));
@@ -351,7 +352,7 @@ pub fn ensure_trait_methods(ccx: &CrateCtxt, trait_id: ast::NodeId) {
 
         // add in the type parameters from the method
         let substd_type_param_defs = m.generics.type_param_defs.subst(tcx, &substs);
-        new_type_param_defs.push_all(*substd_type_param_defs);
+        new_type_param_defs.push_all(*substd_type_param_defs.borrow());
 
         debug!("static method {} type_param_defs={} ty={}, substs={}",
                m.def_id.repr(tcx),
@@ -363,7 +364,7 @@ pub fn ensure_trait_methods(ccx: &CrateCtxt, trait_id: ast::NodeId) {
         tcache.get().insert(m.def_id,
                           ty_param_bounds_and_ty {
                               generics: ty::Generics {
-                                  type_param_defs: @new_type_param_defs,
+                                  type_param_defs: Rc::new(new_type_param_defs),
                                   region_param_defs: new_early_region_param_defs
                               },
                               ty: ty
@@ -383,7 +384,7 @@ pub fn ensure_trait_methods(ccx: &CrateCtxt, trait_id: ast::NodeId) {
         let trait_self_ty = ty::mk_self(this.tcx, local_def(trait_id));
         let fty = astconv::ty_of_method(this, *m_id, *m_purity, trait_self_ty,
                                         *m_explicit_self, m_decl);
-        let num_trait_type_params = trait_generics.type_param_defs.len();
+        let num_trait_type_params = trait_generics.type_param_defs().len();
         ty::Method::new(
             *m_ident,
             // FIXME(#5121) -- distinguish early vs late lifetime params
@@ -466,7 +467,7 @@ fn convert_methods(ccx: &CrateCtxt,
 {
     let tcx = ccx.tcx;
     for m in ms.iter() {
-        let num_rcvr_ty_params = rcvr_ty_generics.type_param_defs.len();
+        let num_rcvr_ty_params = rcvr_ty_generics.type_param_defs().len();
         let m_ty_generics = ty_generics(ccx, &m.generics, num_rcvr_ty_params);
         let mty = @ty_of_method(ccx,
                                 container,
@@ -489,10 +490,10 @@ fn convert_methods(ccx: &CrateCtxt,
                 // itself
                 ty_param_bounds_and_ty {
                     generics: ty::Generics {
-                        type_param_defs: @vec::append(
-                            (*rcvr_ty_generics.type_param_defs).clone(),
-                            *m_ty_generics.type_param_defs),
-                        region_param_defs: rcvr_ty_generics.region_param_defs,
+                        type_param_defs: Rc::new(vec::append(
+                            rcvr_ty_generics.type_param_defs().to_owned(),
+                            m_ty_generics.type_param_defs())),
+                        region_param_defs: rcvr_ty_generics.region_param_defs.clone(),
                     },
                     ty: fty
                 });
@@ -574,7 +575,7 @@ pub fn convert(ccx: &CrateCtxt, it: &ast::Item) {
             let mut tcache = tcx.tcache.borrow_mut();
             tcache.get().insert(local_def(it.id),
                               ty_param_bounds_and_ty {
-                                  generics: i_ty_generics,
+                                  generics: i_ty_generics.clone(),
                                   ty: selfty});
         }
 
@@ -637,7 +638,7 @@ pub fn convert(ccx: &CrateCtxt, it: &ast::Item) {
 
         {
             let mut tcache = tcx.tcache.borrow_mut();
-            tcache.get().insert(local_def(it.id), tpt);
+            tcache.get().insert(local_def(it.id), tpt.clone());
         }
 
         convert_struct(ccx, struct_def, tpt, it.id);
@@ -816,7 +817,7 @@ pub fn ty_of_item(ccx: &CrateCtxt, it: &ast::Item)
     {
         let tcache = tcx.tcache.borrow();
         match tcache.get().find(&def_id) {
-            Some(&tpt) => return tpt,
+            Some(tpt) => return tpt.clone(),
             _ => {}
         }
     }
@@ -826,7 +827,7 @@ pub fn ty_of_item(ccx: &CrateCtxt, it: &ast::Item)
             let tpt = no_params(typ);
 
             let mut tcache = tcx.tcache.borrow_mut();
-            tcache.get().insert(local_def(it.id), tpt);
+            tcache.get().insert(local_def(it.id), tpt.clone());
             return tpt;
         }
         ast::ItemFn(decl, purity, abi, ref generics, _) => {
@@ -838,8 +839,8 @@ pub fn ty_of_item(ccx: &CrateCtxt, it: &ast::Item)
                                               decl);
             let tpt = ty_param_bounds_and_ty {
                 generics: ty::Generics {
-                    type_param_defs: ty_generics.type_param_defs,
-                    region_param_defs: @[],
+                    type_param_defs: ty_generics.type_param_defs.clone(),
+                    region_param_defs: Rc::new(~[]),
                 },
                 ty: ty::mk_bare_fn(ccx.tcx, tofd)
             };
@@ -849,14 +850,14 @@ pub fn ty_of_item(ccx: &CrateCtxt, it: &ast::Item)
                     ppaux::ty_to_str(tcx, tpt.ty));
 
             let mut tcache = ccx.tcx.tcache.borrow_mut();
-            tcache.get().insert(local_def(it.id), tpt);
+            tcache.get().insert(local_def(it.id), tpt.clone());
             return tpt;
         }
         ast::ItemTy(t, ref generics) => {
             {
                 let mut tcache = tcx.tcache.borrow_mut();
                 match tcache.get().find(&local_def(it.id)) {
-                    Some(&tpt) => return tpt,
+                    Some(tpt) => return tpt.clone(),
                     None => { }
                 }
             }
@@ -870,7 +871,7 @@ pub fn ty_of_item(ccx: &CrateCtxt, it: &ast::Item)
             };
 
             let mut tcache = tcx.tcache.borrow_mut();
-            tcache.get().insert(local_def(it.id), tpt);
+            tcache.get().insert(local_def(it.id), tpt.clone());
             return tpt;
         }
         ast::ItemEnum(_, ref generics) => {
@@ -884,7 +885,7 @@ pub fn ty_of_item(ccx: &CrateCtxt, it: &ast::Item)
             };
 
             let mut tcache = tcx.tcache.borrow_mut();
-            tcache.get().insert(local_def(it.id), tpt);
+            tcache.get().insert(local_def(it.id), tpt.clone());
             return tpt;
         }
         ast::ItemTrait(..) => {
@@ -902,7 +903,7 @@ pub fn ty_of_item(ccx: &CrateCtxt, it: &ast::Item)
             };
 
             let mut tcache = tcx.tcache.borrow_mut();
-            tcache.get().insert(local_def(it.id), tpt);
+            tcache.get().insert(local_def(it.id), tpt.clone());
             return tpt;
         }
         ast::ItemImpl(..) | ast::ItemMod(_) |
@@ -925,8 +926,8 @@ pub fn ty_of_foreign_item(ccx: &CrateCtxt,
         ast::ForeignItemStatic(t, _) => {
             ty::ty_param_bounds_and_ty {
                 generics: ty::Generics {
-                    type_param_defs: @~[],
-                    region_param_defs: @[],
+                    type_param_defs: Rc::new(~[]),
+                    region_param_defs: Rc::new(~[]),
                 },
                 ty: ast_ty_to_ty(ccx, &ExplicitRscope, t)
             }
@@ -938,11 +939,11 @@ pub fn ty_generics(ccx: &CrateCtxt,
                    generics: &ast::Generics,
                    base_index: uint) -> ty::Generics {
     return ty::Generics {
-        region_param_defs: generics.lifetimes.iter().map(|l| {
+        region_param_defs: Rc::new(generics.lifetimes.iter().map(|l| {
                 ty::RegionParameterDef { ident: l.ident,
                                          def_id: local_def(l.id) }
-            }).collect(),
-        type_param_defs: @generics.ty_params.mapi_to_vec(|offset, param| {
+            }).collect()),
+        type_param_defs: Rc::new(generics.ty_params.mapi_to_vec(|offset, param| {
             let existing_def_opt = {
                 let ty_param_defs = ccx.tcx.ty_param_defs.borrow();
                 ty_param_defs.get().find(&param.id).map(|def| *def)
@@ -969,7 +970,7 @@ pub fn ty_generics(ccx: &CrateCtxt,
                     def
                 }
             }
-        })
+        }))
     };
 
     fn compute_bounds(
@@ -1040,7 +1041,7 @@ pub fn ty_of_foreign_fn_decl(ccx: &CrateCtxt,
     };
 
     let mut tcache = ccx.tcx.tcache.borrow_mut();
-    tcache.get().insert(def_id, tpt);
+    tcache.get().insert(def_id, tpt.clone());
     return tpt;
 }
 
@@ -1049,11 +1050,11 @@ pub fn mk_item_substs(ccx: &CrateCtxt,
                       self_ty: Option<ty::t>) -> ty::substs
 {
     let params: ~[ty::t] =
-        ty_generics.type_param_defs.iter().enumerate().map(
+        ty_generics.type_param_defs().iter().enumerate().map(
             |(i, t)| ty::mk_param(ccx.tcx, i, t.def_id)).collect();
 
     let regions: OptVec<ty::Region> =
-        ty_generics.region_param_defs.iter().enumerate().map(
+        ty_generics.region_param_defs().iter().enumerate().map(
             |(i, l)| ty::ReEarlyBound(l.def_id.node, i, l.ident)).collect();
 
     substs {regions: ty::NonerasedRegions(regions),
diff --git a/src/librustc/middle/typeck/mod.rs b/src/librustc/middle/typeck/mod.rs
index 8837a978f43..a6fc91899f0 100644
--- a/src/librustc/middle/typeck/mod.rs
+++ b/src/librustc/middle/typeck/mod.rs
@@ -70,6 +70,7 @@ use util::ppaux;
 
 use std::cell::RefCell;
 use std::hashmap::HashMap;
+use std::rc::Rc;
 use std::result;
 use extra::list::List;
 use extra::list;
@@ -271,8 +272,8 @@ pub fn lookup_def_ccx(ccx: &CrateCtxt, sp: Span, id: ast::NodeId)
 
 pub fn no_params(t: ty::t) -> ty::ty_param_bounds_and_ty {
     ty::ty_param_bounds_and_ty {
-        generics: ty::Generics {type_param_defs: @~[],
-                                region_param_defs: @[]},
+        generics: ty::Generics {type_param_defs: Rc::new(~[]),
+                                region_param_defs: Rc::new(~[])},
         ty: t
     }
 }
diff --git a/src/librustc/middle/typeck/variance.rs b/src/librustc/middle/typeck/variance.rs
index 83be5fd2a30..cd4abd70ecd 100644
--- a/src/librustc/middle/typeck/variance.rs
+++ b/src/librustc/middle/typeck/variance.rs
@@ -750,7 +750,7 @@ impl<'a> ConstraintContext<'a> {
                                    variance: VarianceTermPtr<'a>) {
         debug!("add_constraints_from_substs(def_id={:?})", def_id);
 
-        for (i, p) in generics.type_param_defs.iter().enumerate() {
+        for (i, p) in generics.type_param_defs().iter().enumerate() {
             let variance_decl =
                 self.declared_variance(p.def_id, def_id, TypeParam, i);
             let variance_i = self.xform(variance, variance_decl);
@@ -760,7 +760,7 @@ impl<'a> ConstraintContext<'a> {
         match substs.regions {
             ty::ErasedRegions => {}
             ty::NonerasedRegions(ref rps) => {
-                for (i, p) in generics.region_param_defs.iter().enumerate() {
+                for (i, p) in generics.region_param_defs().iter().enumerate() {
                     let variance_decl =
                         self.declared_variance(p.def_id, def_id, RegionParam, i);
                     let variance_i = self.xform(variance, variance_decl);
diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs
index 8b6cfe88f41..27d15d73825 100644
--- a/src/librustc/util/ppaux.rs
+++ b/src/librustc/util/ppaux.rs
@@ -522,11 +522,11 @@ pub fn parameterized(cx: ctxt,
     }
 
     let generics = if is_trait {
-        ty::lookup_trait_def(cx, did).generics
+        ty::lookup_trait_def(cx, did).generics.clone()
     } else {
         ty::lookup_item_type(cx, did).generics
     };
-    let ty_params = generics.type_param_defs.iter();
+    let ty_params = generics.type_param_defs().iter();
     let num_defaults = ty_params.zip(tps.iter()).rev().take_while(|&(def, &actual)| {
         match def.default {
             Some(default) => default == actual,
@@ -789,8 +789,8 @@ impl Repr for ty::ty_param_bounds_and_ty {
 impl Repr for ty::Generics {
     fn repr(&self, tcx: ctxt) -> ~str {
         format!("Generics(type_param_defs: {}, region_param_defs: {})",
-                self.type_param_defs.repr(tcx),
-                self.region_param_defs.repr(tcx))
+                self.type_param_defs().repr(tcx),
+                self.region_param_defs().repr(tcx))
     }
 }
 
diff --git a/src/libstd/reflect.rs b/src/libstd/reflect.rs
index a7cea1c7e4a..d6b4d3f5656 100644
--- a/src/libstd/reflect.rs
+++ b/src/libstd/reflect.rs
@@ -250,7 +250,7 @@ impl<V:TyVisitor + MovePtr> TyVisitor for MovePtrAdaptor<V> {
         true
     }
 
-    fn visit_evec_box(&mut self, mtbl: uint, inner: *TyDesc) -> bool {
+    fn visit_evec_box(&mut self, _mtbl: uint, _inner: *TyDesc) -> bool {
         true
     }