---

yaml
---
r: 167386
b: refs/heads/snap-stage3
c: becbd81
h: refs/heads/master
v: v3

Author: nikomatsakis

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 023dfb0c898d851dee6ace2f8339b73b5287136b
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 82787c2252267561777303bcc4e4d0394c34e5c9
+refs/heads/snap-stage3: becbd81aaa1b8c60eb13fee898163d1a2ac33de3
 refs/heads/try: 5204084bd2e46af7cc6e0147430e44dd0d657bbb
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d

branches/snap-stage3/src/librustc/metadata/tydecode.rs

@@ -200,9 +200,9 @@ pub fn parse_bounds_data<'tcx>(data: &[u8], crate_num: ast::CrateNum,
     parse_bounds(&mut st, conv)
 }
 
-pub fn parse_existential_bounds_data(data: &[u8], crate_num: ast::CrateNum,
-                                     pos: uint, tcx: &ty::ctxt, conv: conv_did)
-                                     -> ty::ExistentialBounds {
+pub fn parse_existential_bounds_data<'tcx>(data: &[u8], crate_num: ast::CrateNum,
+                                           pos: uint, tcx: &ty::ctxt<'tcx>, conv: conv_did)
+                                           -> ty::ExistentialBounds<'tcx> {
     let mut st = parse_state_from_data(data, crate_num, pos, tcx);
     parse_existential_bounds(&mut st, conv)
 }
@@ -744,10 +744,18 @@ fn parse_type_param_def<'a, 'tcx>(st: &mut PState<'a, 'tcx>, conv: conv_did)
     }
 }
 
-fn parse_existential_bounds(st: &mut PState, conv: conv_did) -> ty::ExistentialBounds {
-    let r = parse_region(st, |x,y| conv(x,y));
-    let bb = parse_builtin_bounds(st, conv);
-    return ty::ExistentialBounds { region_bound: r, builtin_bounds: bb };
+fn parse_existential_bounds<'a,'tcx>(st: &mut PState<'a,'tcx>,
+                                     conv: conv_did)
+                                     -> ty::ExistentialBounds<'tcx>
+{
+    let ty::ParamBounds { trait_bounds, mut region_bounds, builtin_bounds, projection_bounds } =
+         parse_bounds(st, conv);
+    assert_eq!(region_bounds.len(), 1);
+    assert_eq!(trait_bounds.len(), 0);
+    let region_bound = region_bounds.pop().unwrap();
+    return ty::ExistentialBounds { region_bound: region_bound,
+                                   builtin_bounds: builtin_bounds,
+                                   projection_bounds: projection_bounds };
 }
 
 fn parse_builtin_bounds(st: &mut PState, _conv: conv_did) -> ty::BuiltinBounds {

branches/snap-stage3/src/librustc/metadata/tyencode.rs

@@ -392,9 +392,14 @@ pub fn enc_builtin_bounds(w: &mut SeekableMemWriter, _cx: &ctxt, bs: &ty::Builti
     mywrite!(w, ".");
 }
 
-pub fn enc_existential_bounds(w: &mut SeekableMemWriter, cx: &ctxt, bs: &ty::ExistentialBounds) {
-    enc_region(w, cx, bs.region_bound);
-    enc_builtin_bounds(w, cx, &bs.builtin_bounds);
+pub fn enc_existential_bounds<'a,'tcx>(w: &mut SeekableMemWriter,
+                                       cx: &ctxt<'a,'tcx>,
+                                       bs: &ty::ExistentialBounds<'tcx>) {
+    let param_bounds = ty::ParamBounds { trait_bounds: vec!(),
+                                         region_bounds: vec!(bs.region_bound),
+                                         builtin_bounds: bs.builtin_bounds,
+                                         projection_bounds: bs.projection_bounds.clone() };
+    enc_bounds(w, cx, &param_bounds);
 }
 
 pub fn enc_bounds<'a, 'tcx>(w: &mut SeekableMemWriter, cx: &ctxt<'a, 'tcx>,

branches/snap-stage3/src/librustc/middle/astencode.rs

@@ -842,7 +842,8 @@ trait rbml_writer_helpers<'tcx> {
                             type_scheme: ty::TypeScheme<'tcx>);
     fn emit_substs<'a>(&mut self, ecx: &e::EncodeContext<'a, 'tcx>,
                        substs: &subst::Substs<'tcx>);
-    fn emit_existential_bounds(&mut self, ecx: &e::EncodeContext, bounds: &ty::ExistentialBounds);
+    fn emit_existential_bounds<'b>(&mut self, ecx: &e::EncodeContext<'b,'tcx>,
+                                   bounds: &ty::ExistentialBounds<'tcx>);
     fn emit_builtin_bounds(&mut self, ecx: &e::EncodeContext, bounds: &ty::BuiltinBounds);
     fn emit_auto_adjustment<'a>(&mut self, ecx: &e::EncodeContext<'a, 'tcx>,
                                 adj: &ty::AutoAdjustment<'tcx>);
@@ -982,7 +983,8 @@ impl<'a, 'tcx> rbml_writer_helpers<'tcx> for Encoder<'a> {
         });
     }
 
-    fn emit_existential_bounds(&mut self, ecx: &e::EncodeContext, bounds: &ty::ExistentialBounds) {
+    fn emit_existential_bounds<'b>(&mut self, ecx: &e::EncodeContext<'b,'tcx>,
+                                   bounds: &ty::ExistentialBounds<'tcx>) {
         self.emit_opaque(|this| Ok(tyencode::enc_existential_bounds(this.writer,
                                                                     &ecx.ty_str_ctxt(),
                                                                     bounds)));
@@ -1372,7 +1374,7 @@ trait rbml_decoder_decoder_helpers<'tcx> {
     fn read_type_scheme<'a, 'b>(&mut self, dcx: &DecodeContext<'a, 'b, 'tcx>)
                                 -> ty::TypeScheme<'tcx>;
     fn read_existential_bounds<'a, 'b>(&mut self, dcx: &DecodeContext<'a, 'b, 'tcx>)
-                                       -> ty::ExistentialBounds;
+                                       -> ty::ExistentialBounds<'tcx>;
     fn read_substs<'a, 'b>(&mut self, dcx: &DecodeContext<'a, 'b, 'tcx>)
                            -> subst::Substs<'tcx>;
     fn read_auto_adjustment<'a, 'b>(&mut self, dcx: &DecodeContext<'a, 'b, 'tcx>)
@@ -1626,7 +1628,7 @@ impl<'a, 'tcx> rbml_decoder_decoder_helpers<'tcx> for reader::Decoder<'a> {
     }
 
     fn read_existential_bounds<'b, 'c>(&mut self, dcx: &DecodeContext<'b, 'c, 'tcx>)
-                                       -> ty::ExistentialBounds
+                                       -> ty::ExistentialBounds<'tcx>
     {
         self.read_opaque(|this, doc| {
             Ok(tydecode::parse_existential_bounds_data(doc.data,

branches/snap-stage3/src/librustc/middle/infer/coercion.rs

@@ -351,11 +351,11 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
                 (&ty::ty_trait(..), &ty::ty_trait(..)) => {
                     None
                 }
-                (_, &ty::ty_trait(box ty::TyTrait { ref principal, bounds })) => {
+                (_, &ty::ty_trait(box ty::TyTrait { ref principal, ref bounds })) => {
                     // FIXME what is the purpose of `ty`?
-                    let ty = ty::mk_trait(tcx, principal.clone(), bounds);
-                    Some((ty, ty::UnsizeVtable(ty::TyTrait { principal: (*principal).clone(),
-                                                             bounds: bounds },
+                    let ty = ty::mk_trait(tcx, principal.clone(), bounds.clone());
+                    Some((ty, ty::UnsizeVtable(ty::TyTrait { principal: principal.clone(),
+                                                             bounds: bounds.clone() },
                                                ty_a)))
                 }
                 (&ty::ty_struct(did_a, substs_a), &ty::ty_struct(did_b, substs_b))
@@ -458,10 +458,9 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
 
         match a.sty {
             ty::ty_rptr(_, ty::mt{ty, mutbl}) => match ty.sty {
-                ty::ty_trait(box ty::TyTrait { ref principal, bounds }) => {
+                ty::ty_trait(box ty::TyTrait { ref principal, ref bounds }) => {
                     debug!("mutbl={} b_mutbl={}", mutbl, b_mutbl);
-                    // FIXME what is purpose of this type `tr`?
-                    let tr = ty::mk_trait(tcx, principal.clone(), bounds);
+                    let tr = ty::mk_trait(tcx, principal.clone(), bounds.clone());
                     try!(self.subtype(mk_ty(tr), b));
                     Ok(Some(AdjustDerefRef(AutoDerefRef {
                         autoderefs: 1,

branches/snap-stage3/src/librustc/middle/infer/combine.rs

@@ -222,7 +222,7 @@ pub trait Combine<'tcx> {
         };
         let unsafety = try!(self.unsafeties(a.unsafety, b.unsafety));
         let onceness = try!(self.oncenesses(a.onceness, b.onceness));
-        let bounds = try!(self.existential_bounds(a.bounds, b.bounds));
+        let bounds = try!(self.existential_bounds(&a.bounds, &b.bounds));
         let sig = try!(self.binders(&a.sig, &b.sig));
         let abi = try!(self.abi(a.abi, b.abi));
         Ok(ty::ClosureTy {
@@ -289,15 +289,61 @@ pub trait Combine<'tcx> {
 
     fn oncenesses(&self, a: Onceness, b: Onceness) -> cres<'tcx, Onceness>;
 
+    fn projection_tys(&self,
+                      a: &ty::ProjectionTy<'tcx>,
+                      b: &ty::ProjectionTy<'tcx>)
+                      -> cres<'tcx, ty::ProjectionTy<'tcx>>
+    {
+        if a.item_name != b.item_name {
+            Err(ty::terr_projection_name_mismatched(
+                expected_found(self, a.item_name, b.item_name)))
+        } else {
+            let trait_ref = try!(self.trait_refs(&*a.trait_ref, &*b.trait_ref));
+            Ok(ty::ProjectionTy { trait_ref: Rc::new(trait_ref), item_name: a.item_name })
+        }
+    }
+
+    fn projection_predicates(&self,
+                             a: &ty::ProjectionPredicate<'tcx>,
+                             b: &ty::ProjectionPredicate<'tcx>)
+                             -> cres<'tcx, ty::ProjectionPredicate<'tcx>>
+    {
+        let projection_ty = try!(self.projection_tys(&a.projection_ty, &b.projection_ty));
+        let ty = try!(self.tys(a.ty, b.ty));
+        Ok(ty::ProjectionPredicate { projection_ty: projection_ty, ty: ty })
+    }
+
+    fn projection_bounds(&self,
+                         a: &Vec<ty::PolyProjectionPredicate<'tcx>>,
+                         b: &Vec<ty::PolyProjectionPredicate<'tcx>>)
+                         -> cres<'tcx, Vec<ty::PolyProjectionPredicate<'tcx>>>
+    {
+        // To be compatible, `a` and `b` must be for precisely the
+        // same set of traits and item names. We always require that
+        // projection bounds lists are sorted by trait-def-id and item-name,
+        // so we can just iterate through the lists pairwise, so long as they are the
+        // same length.
+        if a.len() != b.len() {
+            Err(ty::terr_projection_bounds_length(expected_found(self, a.len(), b.len())))
+        } else {
+            a.iter()
+                .zip(b.iter())
+                .map(|(a, b)| self.binders(a, b))
+                .collect()
+        }
+    }
+
     fn existential_bounds(&self,
-                          a: ty::ExistentialBounds,
-                          b: ty::ExistentialBounds)
-                          -> cres<'tcx, ty::ExistentialBounds>
+                          a: &ty::ExistentialBounds<'tcx>,
+                          b: &ty::ExistentialBounds<'tcx>)
+                          -> cres<'tcx, ty::ExistentialBounds<'tcx>>
     {
         let r = try!(self.contraregions(a.region_bound, b.region_bound));
         let nb = try!(self.builtin_bounds(a.builtin_bounds, b.builtin_bounds));
+        let pb = try!(self.projection_bounds(&a.projection_bounds, &b.projection_bounds));
         Ok(ty::ExistentialBounds { region_bound: r,
-                                   builtin_bounds: nb })
+                                   builtin_bounds: nb,
+                                   projection_bounds: pb })
     }
 
     fn builtin_bounds(&self,
@@ -381,6 +427,16 @@ impl<'tcx> Combineable<'tcx> for ty::TraitRef<'tcx> {
     }
 }
 
+impl<'tcx> Combineable<'tcx> for ty::ProjectionPredicate<'tcx> {
+    fn combine<C:Combine<'tcx>>(combiner: &C,
+                                a: &ty::ProjectionPredicate<'tcx>,
+                                b: &ty::ProjectionPredicate<'tcx>)
+                                -> cres<'tcx, ty::ProjectionPredicate<'tcx>>
+    {
+        combiner.projection_predicates(a, b)
+    }
+}
+
 impl<'tcx> Combineable<'tcx> for ty::FnSig<'tcx> {
     fn combine<C:Combine<'tcx>>(combiner: &C,
                                 a: &ty::FnSig<'tcx>,
@@ -496,7 +552,7 @@ pub fn super_tys<'tcx, C: Combine<'tcx>>(this: &C,
        &ty::ty_trait(ref b_)) => {
           debug!("Trying to match traits {} and {}", a, b);
           let principal = try!(this.binders(&a_.principal, &b_.principal));
-          let bounds = try!(this.existential_bounds(a_.bounds, b_.bounds));
+          let bounds = try!(this.existential_bounds(&a_.bounds, &b_.bounds));
           Ok(ty::mk_trait(tcx, principal, bounds))
       }
 
@@ -595,12 +651,8 @@ pub fn super_tys<'tcx, C: Combine<'tcx>>(this: &C,
       }
 
       (&ty::ty_projection(ref a_data), &ty::ty_projection(ref b_data)) => {
-          if a_data.item_name == b_data.item_name {
-              let trait_ref = try!(this.trait_refs(&*a_data.trait_ref, &*b_data.trait_ref));
-              Ok(ty::mk_projection(tcx, Rc::new(trait_ref), a_data.item_name))
-          } else {
-              Err(ty::terr_sorts(expected_found(this, a, b)))
-          }
+          let projection_ty = try!(this.projection_tys(a_data, b_data));
+          Ok(ty::mk_projection(tcx, projection_ty.trait_ref, projection_ty.item_name))
       }
 
       _ => Err(ty::terr_sorts(expected_found(this, a, b)))