remove modes from ty.rs

Author: nikomatsakis

src/rustc/middle/trans/base.rs

@@ -745,10 +745,10 @@ fn make_free_glue(bcx: block, v: ValueRef, t: ty::t) {
       ty::ty_opaque_closure_ptr(ck) => {
         closure::make_opaque_cbox_free_glue(bcx, ck, v)
       }
-      ty::ty_class(did,substs) => {
+      ty::ty_class(did, ref substs) => {
         // Call the dtor if there is one
         do option::map_default(ty::ty_dtor(bcx.tcx(), did), bcx) |dt_id| {
-          trans_class_drop(bcx, v, dt_id, did, substs)
+            trans_class_drop(bcx, v, dt_id, did, substs)
         }
       }
       _ => bcx
@@ -758,7 +758,7 @@ fn make_free_glue(bcx: block, v: ValueRef, t: ty::t) {
 
 fn trans_class_drop(bcx: block, v0: ValueRef, dtor_did: ast::def_id,
                     class_did: ast::def_id,
-                    substs: ty::substs) -> block {
+                    substs: &ty::substs) -> block {
   let drop_flag = GEPi(bcx, v0, ~[0u, 0u]);
     do with_cond(bcx, IsNotNull(bcx, Load(bcx, drop_flag))) |cx| {
     let mut bcx = cx;
@@ -805,7 +805,7 @@ fn make_drop_glue(bcx: block, v0: ValueRef, t: ty::t) {
       ty::ty_unboxed_vec(_) => {
         tvec::make_drop_glue_unboxed(bcx, v0, t)
       }
-      ty::ty_class(did, substs) => {
+      ty::ty_class(did, ref substs) => {
         let tcx = bcx.tcx();
         match ty::ty_dtor(tcx, did) {
           some(dtor) => {
@@ -1081,7 +1081,7 @@ fn iter_structural_ty(cx: block, av: ValueRef, t: ty::t,
         }
         return next_cx;
       }
-      ty::ty_class(did, substs) => {
+      ty::ty_class(did, ref substs) => {
           // Take the drop bit into account
           let classptr = if is_some(ty::ty_dtor(cx.tcx(), did)) {
                   GEPi(cx, av, ~[0u, 1u])
@@ -1821,7 +1821,7 @@ fn autoderef(cx: block, e_id: ast::node_id,
             t1 = mt.ty;
             v1 = v;
           }
-          ty::ty_enum(did, substs) => {
+          ty::ty_enum(did, ref substs) => {
             let variants = ty::enum_variants(ccx.tcx, did);
             if (*variants).len() != 1u || variants[0].args.len() != 1u {
                 break;
@@ -2034,7 +2034,7 @@ fn normalize_for_monomorphization(tcx: ty::ctxt, ty: ty::t) -> option<ty::t> {
       ty::ty_box(mt) => {
         some(ty::mk_opaque_box(tcx))
       }
-      ty::ty_fn(fty) => {
+      ty::ty_fn(ref fty) => {
         some(ty::mk_fn(tcx, {purity: ast::impure_fn,
                              proto: fty.proto,
                              bounds: @~[],
@@ -2562,7 +2562,7 @@ fn trans_rec_field_inner(bcx: block, val: ValueRef, ty: ty::t,
     let mut llderef = false;
     let fields = match ty::get(ty).struct {
        ty::ty_rec(fs) => fs,
-       ty::ty_class(did, substs) => {
+       ty::ty_class(did, ref substs) => {
          if option::is_some(ty::ty_dtor(bcx.tcx(), did)) {
            llderef = true;
          }
@@ -3505,7 +3505,7 @@ fn trans_struct(block_context: block, span: span, fields: ~[ast::field],
     // Get the class ID and its fields.
     let class_fields, class_id, substitutions;
     match ty::get(struct_type).struct {
-        ty::ty_class(existing_class_id, existing_substitutions) => {
+        ty::ty_class(existing_class_id, ref existing_substitutions) => {
             class_id = existing_class_id;
             substitutions = existing_substitutions;
             class_fields = ty::lookup_class_fields(type_context, class_id);
@@ -4858,8 +4858,9 @@ fn trans_class_ctor(ccx: @crate_ctxt, path: path, decl: ast::fn_decl,
   else { selfptr };
 
   // initialize fields to zero
+  let dsubsts = dummy_substs(psubsts.tys);
   let fields = ty::class_items_as_mutable_fields(bcx_top.tcx(), parent_id,
-                                         dummy_substs(psubsts.tys));
+                                                 &dsubsts);
   let mut bcx = bcx_top;
   // Initialize fields to zero so init assignments can validly
   // drop their LHS

src/rustc/middle/trans/consts.rs

@@ -158,7 +158,7 @@ fn const_expr(cx: @crate_ctxt, e: @ast::expr) -> ValueRef {
           let (bt, bv) = const_autoderef(cx, bt, bv);
           let fields = match ty::get(bt).struct {
               ty::ty_rec(fs) => fs,
-              ty::ty_class(did, substs) =>
+              ty::ty_class(did, ref substs) =>
                   ty::class_items_as_mutable_fields(cx.tcx, did, substs),
               _ => cx.sess.span_bug(e.span,
                                     ~"field access on unknown type in const"),

src/rustc/middle/trans/reflect.rs

@@ -221,7 +221,7 @@ impl reflector {
             self.visit(~"leave_fn", extra);
           }
 
-          ty::ty_class(did, substs) => {
+          ty::ty_class(did, ref substs) => {
             let bcx = self.bcx;
             let tcx = bcx.ccx().tcx;
             let fields = ty::class_items_as_fields(tcx, did, substs);
@@ -241,7 +241,7 @@ impl reflector {
           // not ideal. It'll work but will get costly on big enums. Maybe
           // let the visitor tell us if it wants to visit only a particular
           // variant?
-          ty::ty_enum(did, substs) => {
+          ty::ty_enum(did, ref substs) => {
             let bcx = self.bcx;
             let tcx = bcx.ccx().tcx;
             let variants = ty::substd_enum_variants(tcx, did, substs);

src/rustc/middle/trans/shape.rs

@@ -324,7 +324,7 @@ fn shape_of(ccx: @crate_ctxt, t: ty::t) -> ~[u8] {
         s
       }
       ty::ty_trait(_, _) => ~[shape_box_fn],
-      ty::ty_class(did, substs) => {
+      ty::ty_class(did, ref substs) => {
         // same as records, unless there's a dtor
         let tps = substs.tps;
         let m_dtor_did = ty::ty_dtor(ccx.tcx, did);
@@ -378,7 +378,7 @@ fn gen_enum_shapes(ccx: @crate_ctxt) -> ValueRef {
     let mut enum_variants = ~[];
     while i < ccx.shape_cx.tag_order.len() {
         let {did, substs} = ccx.shape_cx.tag_order[i];
-        let variants = @ty::substd_enum_variants(ccx.tcx, did, substs);
+        let variants = @ty::substd_enum_variants(ccx.tcx, did, &substs);
         do vec::iter(*variants) |v| {
             offsets += ~[vec::len(data) as u16];
 
@@ -678,7 +678,7 @@ fn llalign_of(cx: @crate_ctxt, t: TypeRef) -> ValueRef {
 fn static_size_of_enum(cx: @crate_ctxt, t: ty::t) -> uint {
     if cx.enum_sizes.contains_key(t) { return cx.enum_sizes.get(t); }
     match ty::get(t).struct {
-      ty::ty_enum(tid, substs) => {
+      ty::ty_enum(tid, ref substs) => {
         // Compute max(variant sizes).
         let mut max_size = 0u;
         let variants = ty::enum_variants(cx.tcx, tid);
@@ -723,7 +723,7 @@ fn simplify_type(tcx: ty::ctxt, typ: ty::t) -> ty::t {
           }
           // Reduce a class type to a record type in which all the fields are
           // simplified
-          ty::ty_class(did, substs) => {
+          ty::ty_class(did, ref substs) => {
             let simpl_fields = (if is_some(ty::ty_dtor(tcx, did)) {
                 // remember the drop flag
                   ~[{ident: @~"drop", mt: {ty:

src/rustc/middle/trans/type_of.rs

@@ -179,11 +179,11 @@ fn type_of(cx: @crate_ctxt, t: ty::t) -> TypeRef {
       ty::ty_enum(did, _) => {
         fill_type_of_enum(cx, did, t, llty);
       }
-      ty::ty_class(did, ts) => {
+      ty::ty_class(did, ref substs) => {
         // Only instance vars are record fields at runtime.
         let fields = ty::lookup_class_fields(cx.tcx, did);
         let mut tys = do vec::map(fields) |f| {
-            let t = ty::lookup_field_type(cx.tcx, did, f.id, ts);
+            let t = ty::lookup_field_type(cx.tcx, did, f.id, substs);
             type_of(cx, t)
         };
 

src/rustc/middle/trans/type_use.rs

@@ -140,7 +140,7 @@ fn type_needs_inner(cx: ctx, use: uint, ty: ty::t,
                     let seen = @cons(did, enums_seen);
                     for vec::each(*ty::enum_variants(cx.ccx.tcx, did)) |v| {
                         for vec::each(v.args) |aty| {
-                            let t = ty::subst(cx.ccx.tcx, substs, aty);
+                            let t = ty::subst(cx.ccx.tcx, &substs, aty);
                             type_needs_inner(cx, use, t, seen);
                         }
                     }