Make TyTrait embed a TraitRef, so that when we extend TraitRef, it naturally carries over to object types.

I wanted to embed an `Rc<TraitRef>`, but I was foiled by the current
static rules, which prohibit non-Sync values from being stored in
static locations. This means that the constants for `ty_int` and so
forth cannot be initialized.

Author: nikomatsakis

src/librustc/metadata/tydecode.rs

@@ -389,11 +389,10 @@ fn parse_ty(st: &mut PState, conv: conv_did) -> ty::t {
       }
       'x' => {
         assert_eq!(next(st), '[');
-        let def = parse_def(st, NominalType, |x,y| conv(x,y));
-        let substs = parse_substs(st, |x,y| conv(x,y));
+        let trait_ref = parse_trait_ref(st, |x,y| conv(x,y));
         let bounds = parse_existential_bounds(st, |x,y| conv(x,y));
         assert_eq!(next(st), ']');
-        return ty::mk_trait(st.tcx, def, substs, bounds);
+        return ty::mk_trait(st.tcx, trait_ref, bounds);
       }
       'p' => {
         let did = parse_def(st, TypeParameter, |x,y| conv(x,y));

src/librustc/metadata/tyencode.rs

@@ -231,13 +231,10 @@ fn enc_sty(w: &mut SeekableMemWriter, cx: &ctxt, st: &ty::sty) {
             enc_substs(w, cx, substs);
             mywrite!(w, "]");
         }
-        ty::ty_trait(box ty::TyTrait {
-                def_id,
-                ref substs,
-                ref bounds
-            }) => {
-            mywrite!(w, "x[{}|", (cx.ds)(def_id));
-            enc_substs(w, cx, substs);
+        ty::ty_trait(box ty::TyTrait { ref principal,
+                                       ref bounds }) => {
+            mywrite!(w, "x[");
+            enc_trait_ref(w, cx, principal);
             enc_existential_bounds(w, cx, bounds);
             mywrite!(w, "]");
         }

src/librustc/middle/astencode.rs

@@ -1085,16 +1085,19 @@ impl<'a> rbml_writer_helpers for Encoder<'a> {
                         this.emit_enum_variant_arg(1, |this| idx.encode(this))
                     })
                 }
-                ty::UnsizeVtable(ty::TyTrait { def_id,
-                                               bounds: ref b,
-                                               ref substs },
+                ty::UnsizeVtable(ty::TyTrait { ref principal,
+                                               bounds: ref b },
                                  self_ty) => {
                     this.emit_enum_variant("UnsizeVtable", 2, 4, |this| {
-                        this.emit_enum_variant_arg(
-                            0, |this| Ok(this.emit_existential_bounds(ecx, b)));
-                        this.emit_enum_variant_arg(1, |this| def_id.encode(this));
-                        this.emit_enum_variant_arg(2, |this| Ok(this.emit_ty(ecx, self_ty)));
-                        this.emit_enum_variant_arg(3, |this| Ok(this.emit_substs(ecx, substs)))
+                        this.emit_enum_variant_arg(0, |this| {
+                            try!(this.emit_struct_field("principal", 0, |this| {
+                                Ok(this.emit_trait_ref(ecx, &*principal))
+                            }));
+                            this.emit_struct_field("bounds", 1, |this| {
+                                Ok(this.emit_existential_bounds(ecx, b))
+                            })
+                        });
+                        this.emit_enum_variant_arg(1, |this| Ok(this.emit_ty(ecx, self_ty)))
                     })
                 }
             }
@@ -1693,18 +1696,19 @@ impl<'a> rbml_decoder_decoder_helpers for reader::Decoder<'a> {
                         ty::UnsizeStruct(box uk, idx)
                     }
                     2 => {
-                        let b =
-                            this.read_enum_variant_arg(
-                                0, |this| Ok(this.read_existential_bounds(dcx))).unwrap();
-                        let def_id: ast::DefId =
-                            this.read_enum_variant_arg(1, |this| Decodable::decode(this)).unwrap();
+                        let ty_trait = try!(this.read_enum_variant_arg(0, |this| {
+                            let principal = try!(this.read_struct_field("principal", 0, |this| {
+                                Ok(this.read_trait_ref(dcx))
+                            }));
+                            Ok(ty::TyTrait {
+                                principal: (*principal).clone(),
+                                bounds: try!(this.read_struct_field("bounds", 1, |this| {
+                                    Ok(this.read_existential_bounds(dcx))
+                                })),
+                            })
+                        }));
                         let self_ty =
-                            this.read_enum_variant_arg(2, |this| Ok(this.read_ty(dcx))).unwrap();
-                        let substs = this.read_enum_variant_arg(3,
-                            |this| Ok(this.read_substs(dcx))).unwrap();
-                        let ty_trait = ty::TyTrait { def_id: def_id.tr(dcx),
-                                                     bounds: b,
-                                                     substs: substs };
+                            this.read_enum_variant_arg(1, |this| Ok(this.read_ty(dcx))).unwrap();
                         ty::UnsizeVtable(ty_trait, self_ty)
                     }
                     _ => panic!("bad enum variant for ty::UnsizeKind")

src/librustc/middle/traits/coherence.rs

@@ -143,7 +143,7 @@ pub fn ty_is_local(tcx: &ty::ctxt,
         }
 
         ty::ty_trait(ref tt) => {
-            tt.def_id.krate == ast::LOCAL_CRATE
+            tt.principal.def_id.krate == ast::LOCAL_CRATE
         }
 
         // Type parameters may be bound to types that are not local to

src/librustc/middle/trans/debuginfo.rs

@@ -423,8 +423,8 @@ impl TypeMap {
 
                 from_def_id_and_substs(self,
                                        cx,
-                                       trait_data.def_id,
-                                       &trait_data.substs,
+                                       trait_data.principal.def_id,
+                                       &trait_data.principal.substs,
                                        &mut unique_type_id);
             },
             ty::ty_bare_fn(ty::BareFnTy{ fn_style, abi, ref sig } ) => {
@@ -2813,7 +2813,7 @@ fn trait_pointer_metadata(cx: &CrateContext,
     // But it does not describe the trait's methods.
 
     let def_id = match ty::get(trait_type).sty {
-        ty::ty_trait(box ty::TyTrait { def_id, .. }) => def_id,
+        ty::ty_trait(box ty::TyTrait { ref principal, .. }) => principal.def_id,
         _ => {
             let pp_type_name = ppaux::ty_to_string(cx.tcx(), trait_type);
             cx.sess().bug(format!("debuginfo: Unexpected trait-object type in \
@@ -3739,8 +3739,8 @@ fn push_debuginfo_type_name(cx: &CrateContext,
             output.push(']');
         },
         ty::ty_trait(ref trait_data) => {
-            push_item_name(cx, trait_data.def_id, false, output);
-            push_type_params(cx, &trait_data.substs, output);
+            push_item_name(cx, trait_data.principal.def_id, false, output);
+            push_type_params(cx, &trait_data.principal.substs, output);
         },
         ty::ty_bare_fn(ty::BareFnTy{ fn_style, abi, ref sig } ) => {
             if fn_style == ast::UnsafeFn {

src/librustc/middle/trans/expr.rs

@@ -324,10 +324,10 @@ fn apply_adjustments<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
                 _ => bcx.sess().bug(format!("UnsizeStruct with bad sty: {}",
                                           bcx.ty_to_string(unsized_ty)).as_slice())
             },
-            &ty::UnsizeVtable(ty::TyTrait { def_id, ref substs, .. }, _) => {
-                let substs = substs.with_self_ty(unsized_ty);
+            &ty::UnsizeVtable(ty::TyTrait { ref principal, .. }, _) => {
+                let substs = principal.substs.with_self_ty(unsized_ty);
                 let trait_ref =
-                    Rc::new(ty::TraitRef { def_id: def_id,
+                    Rc::new(ty::TraitRef { def_id: principal.def_id,
                                            substs: substs });
                 let trait_ref =
                     trait_ref.subst(bcx.tcx(), &bcx.fcx.param_substs.substs);

src/librustc/middle/ty.rs

@@ -378,14 +378,14 @@ pub fn type_of_adjust(cx: &ctxt, adj: &AutoAdjustment) -> Option<t> {
     fn type_of_autoref(cx: &ctxt, autoref: &AutoRef) -> Option<t> {
         match autoref {
             &AutoUnsize(ref k) => match k {
-                &UnsizeVtable(TyTrait { def_id, ref substs, bounds }, _) => {
-                    Some(mk_trait(cx, def_id, substs.clone(), bounds))
+                &UnsizeVtable(TyTrait { ref principal, bounds }, _) => {
+                    Some(mk_trait(cx, (*principal).clone(), bounds))
                 }
                 _ => None
             },
             &AutoUnsizeUniq(ref k) => match k {
-                &UnsizeVtable(TyTrait { def_id, ref substs, bounds }, _) => {
-                    Some(mk_uniq(cx, mk_trait(cx, def_id, substs.clone(), bounds)))
+                &UnsizeVtable(TyTrait { ref principal, bounds }, _) => {
+                    Some(mk_uniq(cx, mk_trait(cx, (*principal).clone(), bounds)))
                 }
                 _ => None
             },
@@ -983,12 +983,12 @@ pub enum sty {
 
 #[deriving(Clone, PartialEq, Eq, Hash, Show)]
 pub struct TyTrait {
-    pub def_id: DefId,
-    pub substs: Substs,
+    // Principal trait reference.
+    pub principal: TraitRef, // would use Rc<TraitRef>, but it runs afoul of some static rules
     pub bounds: ExistentialBounds
 }
 
-#[deriving(PartialEq, Eq, Hash, Show)]
+#[deriving(Clone, PartialEq, Eq, Hash, Show)]
 pub struct TraitRef {
     pub def_id: DefId,
     pub substs: Substs,
@@ -1643,8 +1643,8 @@ pub fn mk_t(cx: &ctxt, st: sty) -> t {
       &ty_enum(_, ref substs) | &ty_struct(_, ref substs) => {
           flags = flags | sflags(substs);
       }
-      &ty_trait(box TyTrait { ref substs, ref bounds, .. }) => {
-          flags = flags | sflags(substs);
+      &ty_trait(box TyTrait { ref principal, ref bounds }) => {
+          flags = flags | sflags(&principal.substs);
           flags = flags | flags_for_bounds(bounds);
       }
       &ty_uniq(tt) | &ty_vec(tt, _) | &ty_open(tt) => {
@@ -1874,14 +1874,12 @@ pub fn mk_ctor_fn(cx: &ctxt,
 
 
 pub fn mk_trait(cx: &ctxt,
-                did: ast::DefId,
-                substs: Substs,
+                principal: ty::TraitRef,
                 bounds: ExistentialBounds)
                 -> t {
     // take a copy of substs so that we own the vectors inside
     let inner = box TyTrait {
-        def_id: did,
-        substs: substs,
+        principal: principal,
         bounds: bounds
     };
     mk_t(cx, ty_trait(inner))
@@ -1934,9 +1932,15 @@ pub fn maybe_walk_ty(ty: t, f: |t| -> bool) {
         ty_ptr(ref tm) | ty_rptr(_, ref tm) => {
             maybe_walk_ty(tm.ty, f);
         }
-        ty_enum(_, ref substs) | ty_struct(_, ref substs) | ty_unboxed_closure(_, _, ref substs) |
-        ty_trait(box TyTrait { ref substs, .. }) => {
-            for subty in (*substs).types.iter() {
+        ty_trait(box TyTrait { ref principal, .. }) => {
+            for subty in principal.substs.types.iter() {
+                maybe_walk_ty(*subty, |x| f(x));
+            }
+        }
+        ty_enum(_, ref substs) |
+        ty_struct(_, ref substs) |
+        ty_unboxed_closure(_, _, ref substs) => {
+            for subty in substs.types.iter() {
                 maybe_walk_ty(*subty, |x| f(x));
             }
         }
@@ -3554,8 +3558,8 @@ pub fn unsize_ty(cx: &ctxt,
                                   format!("UnsizeStruct with bad sty: {}",
                                           ty_to_string(cx, ty)).as_slice())
         },
-        &UnsizeVtable(TyTrait { def_id, ref substs, bounds }, _) => {
-            mk_trait(cx, def_id, substs.clone(), bounds)
+        &UnsizeVtable(TyTrait { ref principal, bounds }, _) => {
+            mk_trait(cx, (*principal).clone(), bounds)
         }
     }
 }
@@ -3808,7 +3812,7 @@ pub fn ty_sort_string(cx: &ctxt, t: t) -> String {
         ty_bare_fn(_) => "extern fn".to_string(),
         ty_closure(_) => "fn".to_string(),
         ty_trait(ref inner) => {
-            format!("trait {}", item_path_str(cx, inner.def_id))
+            format!("trait {}", item_path_str(cx, inner.principal.def_id))
         }
         ty_struct(id, _) => {
             format!("struct {}", item_path_str(cx, id))
@@ -4230,11 +4234,14 @@ pub fn try_add_builtin_trait(
 
 pub fn ty_to_def_id(ty: t) -> Option<ast::DefId> {
     match get(ty).sty {
-        ty_trait(box TyTrait { def_id: id, .. }) |
+        ty_trait(ref tt) =>
+            Some(tt.principal.def_id),
         ty_struct(id, _) |
         ty_enum(id, _) |
-        ty_unboxed_closure(id, _, _) => Some(id),
-        _ => None
+        ty_unboxed_closure(id, _, _) =>
+            Some(id),
+        _ =>
+            None
     }
 }
 
@@ -5213,9 +5220,9 @@ pub fn hash_crate_independent(tcx: &ctxt, t: t, svh: &Svh) -> u64 {
                     }
                 }
             }
-            ty_trait(box TyTrait { def_id: d, bounds, .. }) => {
+            ty_trait(box TyTrait { ref principal, bounds }) => {
                 byte!(17);
-                did(&mut state, d);
+                did(&mut state, principal.def_id);
                 hash!(bounds);
             }
             ty_struct(d, _) => {
@@ -5504,12 +5511,13 @@ pub fn accumulate_lifetimes_in_type(accumulator: &mut Vec<ty::Region>,
                                     typ: t) {
     walk_ty(typ, |typ| {
         match get(typ).sty {
-            ty_rptr(region, _) => accumulator.push(region),
+            ty_rptr(region, _) => {
+                accumulator.push(region)
+            }
+            ty_trait(ref t) => {
+                accumulator.push_all(t.principal.substs.regions().as_slice());
+            }
             ty_enum(_, ref substs) |
-            ty_trait(box TyTrait {
-                ref substs,
-                ..
-            }) |
             ty_struct(_, ref substs) => {
                 accum_substs(accumulator, substs);
             }

src/librustc/middle/ty_fold.rs

@@ -373,12 +373,11 @@ impl TypeFoldable for ty::UnsizeKind {
         match *self {
             ty::UnsizeLength(len) => ty::UnsizeLength(len),
             ty::UnsizeStruct(box ref k, n) => ty::UnsizeStruct(box k.fold_with(folder), n),
-            ty::UnsizeVtable(ty::TyTrait{bounds, def_id, ref substs}, self_ty) => {
+            ty::UnsizeVtable(ty::TyTrait{ref principal, bounds}, self_ty) => {
                 ty::UnsizeVtable(
                     ty::TyTrait {
+                        principal: principal.fold_with(folder),
                         bounds: bounds.fold_with(folder),
-                        def_id: def_id,
-                        substs: substs.fold_with(folder)
                     },
                     self_ty.fold_with(folder))
             }
@@ -529,15 +528,10 @@ pub fn super_fold_sty<'tcx, T: TypeFolder<'tcx>>(this: &mut T,
         ty::ty_enum(tid, ref substs) => {
             ty::ty_enum(tid, substs.fold_with(this))
         }
-        ty::ty_trait(box ty::TyTrait {
-                def_id,
-                ref substs,
-                bounds
-            }) => {
+        ty::ty_trait(box ty::TyTrait { ref principal, bounds }) => {
             ty::ty_trait(box ty::TyTrait {
-                def_id: def_id,
-                substs: substs.fold_with(this),
-                bounds: this.fold_existential_bounds(bounds),
+                principal: (*principal).fold_with(this),
+                bounds: bounds.fold_with(this),
             })
         }
         ty::ty_tup(ref ts) => {