---

yaml
---
r: 159755
b: refs/heads/auto
c: c8a94c5
h: refs/heads/master
i:
  159753: 754b3a0
  159751: f1b3801
v: v3

Author: nikomatsakis

[refs]

@@ -10,7 +10,7 @@ refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 9c808ffee44afad69aeeeec835601d44bf0e9147
+refs/heads/auto: c8a94c5dfaaf5f1dacc110bb81d292c4382554d9
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/librustc/middle/resolve.rs

@@ -5038,10 +5038,10 @@ impl<'a> Resolver<'a> {
                 visit::walk_ty(self, ty);
             }
 
-            TyPolyTraitRef(ref poly_trait_ref) => {
-                self.resolve_poly_trait_reference(
+            TyPolyTraitRef(ref bounds) => {
+                self.resolve_type_parameter_bounds(
                     ty.id,
-                    &**poly_trait_ref,
+                    bounds,
                     TraitObject);
                 visit::walk_ty(self, ty);
             }

branches/auto/src/librustc/middle/typeck/astconv.rs

@@ -883,15 +883,8 @@ pub fn ast_ty_to_ty<'tcx, AC: AstConv<'tcx>, RS: RegionScope>(
 
                 ty::mk_closure(tcx, fn_decl)
             }
-            ast::TyPolyTraitRef(ref data) => {
-                // FIXME(#18639) this is just a placeholder for code to come
-                let principal = instantiate_trait_ref(this, rscope, &data.trait_ref, None, None);
-                let bounds = conv_existential_bounds(this,
-                                                     rscope,
-                                                     ast_ty.span,
-                                                     &[principal.clone()],
-                                                     &[]);
-                ty::mk_trait(tcx, (*principal).clone(), bounds)
+            ast::TyPolyTraitRef(ref bounds) => {
+                conv_ty_poly_trait_ref(this, rscope, ast_ty.span, bounds.as_slice())
             }
             ast::TyPath(ref path, ref bounds, id) => {
                 let a_def = match tcx.def_map.borrow().get(&id) {
@@ -1371,15 +1364,66 @@ pub fn conv_existential_bounds<'tcx, AC: AstConv<'tcx>, RS:RegionScope>(
     let ast_bound_refs: Vec<&ast::TyParamBound> =
         ast_bounds.iter().collect();
 
+    let partitioned_bounds =
+        partition_bounds(this.tcx(), span, ast_bound_refs.as_slice());
+
+    conv_existential_bounds_from_partitioned_bounds(
+        this, rscope, span, main_trait_refs, partitioned_bounds)
+}
+
+fn conv_ty_poly_trait_ref<'tcx, AC, RS>(
+    this: &AC,
+    rscope: &RS,
+    span: Span,
+    ast_bounds: &[ast::TyParamBound])
+    -> ty::t
+    where AC: AstConv<'tcx>, RS:RegionScope
+{
+    let ast_bounds: Vec<&ast::TyParamBound> = ast_bounds.iter().collect();
+    let mut partitioned_bounds = partition_bounds(this.tcx(), span, ast_bounds[]);
+
+    let main_trait_bound = match partitioned_bounds.trait_bounds.remove(0) {
+        Some(trait_bound) => {
+            Some(instantiate_poly_trait_ref(this, rscope, trait_bound, None, None))
+        }
+        None => {
+            this.tcx().sess.span_err(
+                span,
+                "at least one non-builtin trait is required for an object type");
+            None
+        }
+    };
+
+    let bounds = conv_existential_bounds_from_partitioned_bounds(this,
+                                                                 rscope,
+                                                                 span,
+                                                                 main_trait_bound.as_slice(),
+                                                                 partitioned_bounds);
+
+    match main_trait_bound {
+        None => ty::mk_err(),
+        Some(principal) => ty::mk_trait(this.tcx(), (*principal).clone(), bounds)
+    }
+}
+
+pub fn conv_existential_bounds_from_partitioned_bounds<'tcx, AC, RS>(
+    this: &AC,
+    rscope: &RS,
+    span: Span,
+    main_trait_refs: &[Rc<ty::TraitRef>],
+    partitioned_bounds: PartitionedBounds)
+    -> ty::ExistentialBounds
+    where AC: AstConv<'tcx>, RS:RegionScope
+{
     let PartitionedBounds { builtin_bounds,
                             trait_bounds,
                             region_bounds } =
-        partition_bounds(this.tcx(), span, ast_bound_refs.as_slice());
+        partitioned_bounds;
 
     if !trait_bounds.is_empty() {
         let b = &trait_bounds[0];
         this.tcx().sess.span_err(
-            b.path.span,
+            b.trait_ref.path.span,
             format!("only the builtin traits can be used \
                      as closure or object bounds").as_slice());
     }

branches/auto/src/libsyntax/ast.rs

@@ -1154,7 +1154,7 @@ pub enum Ty_ {
     /// Type parameters are stored in the Path itself
     TyPath(Path, Option<TyParamBounds>, NodeId), // for #7264; see above
     /// A type like `for<'a> Foo<&'a Bar>`
-    TyPolyTraitRef(P<PolyTraitRef>),
+    TyPolyTraitRef(TyParamBounds),
     /// A "qualified path", e.g. `<Vec<T> as SomeTrait>::SomeType`
     TyQPath(P<QPath>),
     /// No-op; kept solely so that we can pretty-print faithfully

branches/auto/src/libsyntax/ast_util.rs

@@ -494,10 +494,10 @@ impl<'a, 'v, O: IdVisitingOperation> Visitor<'v> for IdVisitor<'a, O> {
         }
 
         visit::walk_fn(self,
-                        function_kind,
-                        function_declaration,
-                        block,
-                        span);
+                       function_kind,
+                       function_declaration,
+                       block,
+                       span);
 
         if !self.pass_through_items {
             match function_kind {

branches/auto/src/libsyntax/fold.rs

@@ -445,10 +445,12 @@ pub fn noop_fold_ty<T: Folder>(t: P<Ty>, fld: &mut T) -> P<Ty> {
             TyFixedLengthVec(ty, e) => {
                 TyFixedLengthVec(fld.fold_ty(ty), fld.fold_expr(e))
             }
-            TyTypeof(expr) => TyTypeof(fld.fold_expr(expr)),
-            TyPolyTraitRef(poly_trait_ref) => {
-                TyPolyTraitRef(poly_trait_ref.map(|p| fld.fold_poly_trait_ref(p)))
-            },
+            TyTypeof(expr) => {
+                TyTypeof(fld.fold_expr(expr))
+            }
+            TyPolyTraitRef(bounds) => {
+                TyPolyTraitRef(bounds.move_map(|b| fld.fold_ty_param_bound(b)))
+            }
         },
         span: fld.new_span(span)
     })

branches/auto/src/libsyntax/parse/parser.rs

@@ -1023,10 +1023,21 @@ impl<'a> Parser<'a> {
             self.parse_ty_bare_fn_or_ty_closure(lifetime_defs)
         } else if self.token == token::ModSep ||
                   self.token.is_ident() ||
-                  self.token.is_path() {
+                  self.token.is_path()
+        {
             let trait_ref = self.parse_trait_ref();
-            TyPolyTraitRef(P(PolyTraitRef { bound_lifetimes: lifetime_defs,
-                                            trait_ref: trait_ref }))
+            let poly_trait_ref = ast::PolyTraitRef { bound_lifetimes: lifetime_defs,
+                                                     trait_ref: trait_ref };
+            let other_bounds = if self.eat(&token::BinOp(token::Plus)) {
+                self.parse_ty_param_bounds()
+            } else {
+                OwnedSlice::empty()
+            };
+            let all_bounds =
+                Some(TraitTyParamBound(poly_trait_ref)).into_iter()
+                .chain(other_bounds.into_vec().into_iter())
+                .collect();
+            ast::TyPolyTraitRef(all_bounds)
         } else {
             self.parse_ty_closure(lifetime_defs)
         }

branches/auto/src/libsyntax/print/pprust.rs

@@ -739,8 +739,8 @@ impl<'a> State<'a> {
             ast::TyPath(ref path, ref bounds, _) => {
                 try!(self.print_bounded_path(path, bounds));
             }
-            ast::TyPolyTraitRef(ref poly_trait_ref) => {
-                try!(self.print_poly_trait_ref(&**poly_trait_ref));
+            ast::TyPolyTraitRef(ref bounds) => {
+                try!(self.print_bounds("", bounds));
             }
             ast::TyQPath(ref qpath) => {
                 try!(word(&mut self.s, "<"));