---

yaml
---
r: 60157
b: refs/heads/master
c: 7a4c6e5
h: refs/heads/master
i:
  60155: 6f491f6
v: v3

Author: bors

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: dc2ca9d8830a7a34242aa7722f545bc242813af3
+refs/heads/master: 7a4c6e587d631c0316d51c9b4a50d406f38221cd
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/try: c50a9d5b664478e533ba1d1d353213d70c8ad589

trunk/src/librustc/driver/session.rs

@@ -237,6 +237,7 @@ pub impl Session_ {
                  msg: &str) {
         let level = lint::get_lint_settings_level(
             self.lint_settings, lint_mode, expr_id, item_id);
+        let msg = fmt!("%s [-W %s]", msg, lint::get_lint_name(lint_mode));
         self.span_lint_level(level, span, msg);
     }
     fn next_node_id(@self) -> ast::node_id {

trunk/src/librustc/metadata/tydecode.rs

@@ -555,34 +555,18 @@ fn parse_type_param_def(st: @mut PState, conv: conv_did) -> ty::TypeParameterDef
                           bounds: parse_bounds(st, conv)}
 }
 
-fn parse_bounds(st: @mut PState, conv: conv_did) -> @ty::ParamBounds {
-    let mut param_bounds = ty::ParamBounds {
-        builtin_bounds: ty::EmptyBuiltinBounds(),
-        trait_bounds: ~[]
-    };
+fn parse_bounds(st: @mut PState, conv: conv_did) -> @~[ty::param_bound] {
+    let mut bounds = ~[];
     loop {
-        match next(st) {
-            'S' => {
-                param_bounds.builtin_bounds.add(ty::BoundOwned);
-            }
-            'C' => {
-                param_bounds.builtin_bounds.add(ty::BoundCopy);
-            }
-            'K' => {
-                param_bounds.builtin_bounds.add(ty::BoundConst);
-            }
-            'O' => {
-                param_bounds.builtin_bounds.add(ty::BoundStatic);
-            }
-            'I' => {
-                param_bounds.trait_bounds.push(@parse_trait_ref(st, conv));
-            }
-            '.' => {
-                return @param_bounds;
-            }
-            _ => {
-                fail!(~"parse_bounds: bad bounds")
-            }
-        }
+        bounds.push(match next(st) {
+          'S' => ty::bound_owned,
+          'C' => ty::bound_copy,
+          'K' => ty::bound_const,
+          'O' => ty::bound_durable,
+          'I' => ty::bound_trait(@parse_trait_ref(st, conv)),
+          '.' => break,
+          _ => fail!(~"parse_bounds: bad bounds")
+        });
     }
+    @bounds
 }

trunk/src/librustc/metadata/tyencode.rs

@@ -396,21 +396,19 @@ fn enc_fn_sig(w: @io::Writer, cx: @ctxt, fsig: &ty::FnSig) {
     enc_ty(w, cx, fsig.output);
 }
 
-fn enc_bounds(w: @io::Writer, cx: @ctxt, bs: @ty::ParamBounds) {
-    for bs.builtin_bounds.each |bound| {
-        match bound {
-            ty::BoundOwned => w.write_char('S'),
-            ty::BoundCopy => w.write_char('C'),
-            ty::BoundConst => w.write_char('K'),
-            ty::BoundStatic => w.write_char('O'),
+fn enc_bounds(w: @io::Writer, cx: @ctxt, bs: @~[ty::param_bound]) {
+    for (*bs).each |bound| {
+        match *bound {
+          ty::bound_owned => w.write_char('S'),
+          ty::bound_copy => w.write_char('C'),
+          ty::bound_const => w.write_char('K'),
+          ty::bound_durable => w.write_char('O'),
+          ty::bound_trait(tp) => {
+              w.write_char('I');
+              enc_trait_ref(w, cx, tp);
+          }
         }
     }
-
-    for bs.trait_bounds.each |&tp| {
-        w.write_char('I');
-        enc_trait_ref(w, cx, tp);
-    }
-
     w.write_char('.');
 }
 

trunk/src/librustc/middle/kind.rs

@@ -14,7 +14,6 @@ use middle::pat_util;
 use middle::ty;
 use middle::typeck;
 use util::ppaux::{Repr, ty_to_str};
-use util::ppaux::UserString;
 
 use syntax::ast::*;
 use syntax::attr::attrs_contains_name;
@@ -339,19 +338,46 @@ pub fn check_bounds(cx: Context,
                     type_param_def: &ty::TypeParameterDef)
 {
     let kind = ty::type_contents(cx.tcx, ty);
-    let mut missing = ty::EmptyBuiltinBounds();
-    for type_param_def.bounds.builtin_bounds.each |bound| {
-        if !kind.meets_bound(cx.tcx, bound) {
-            missing.add(bound);
+    let mut missing = ~[];
+    for type_param_def.bounds.each |bound| {
+        match *bound {
+            ty::bound_trait(_) => {
+                /* Not our job, checking in typeck */
+            }
+
+            ty::bound_copy => {
+                if !kind.is_copy(cx.tcx) {
+                    missing.push("Copy");
+                }
+            }
+
+            ty::bound_durable => {
+                if !kind.is_durable(cx.tcx) {
+                    missing.push("'static");
+                }
+            }
+
+            ty::bound_owned => {
+                if !kind.is_owned(cx.tcx) {
+                    missing.push("Owned");
+                }
+            }
+
+            ty::bound_const => {
+                if !kind.is_const(cx.tcx) {
+                    missing.push("Const");
+                }
+            }
         }
     }
+
     if !missing.is_empty() {
         cx.tcx.sess.span_err(
             sp,
             fmt!("instantiating a type parameter with an incompatible type \
                   `%s`, which does not fulfill `%s`",
                  ty_to_str(cx.tcx, ty),
-                 missing.user_string(cx.tcx)));
+                 str::connect_slices(missing, " ")));
     }
 }
 
@@ -414,7 +440,7 @@ pub fn check_owned(cx: Context, ty: ty::t, sp: span) -> bool {
 
 // note: also used from middle::typeck::regionck!
 pub fn check_durable(tcx: ty::ctxt, ty: ty::t, sp: span) -> bool {
-    if !ty::type_is_static(tcx, ty) {
+    if !ty::type_is_durable(tcx, ty) {
         match ty::get(ty).sty {
           ty::ty_param(*) => {
             tcx.sess.span_err(sp, "value may contain borrowed \

trunk/src/librustc/middle/lint.rs

@@ -237,6 +237,14 @@ pub fn get_lint_dict() -> LintDict {
     return @map;
 }
 
+pub fn get_lint_name(lint_mode: lint) -> ~str {
+    for lint_table.each |&(name, spec)| {
+        if spec.lint == lint_mode {
+            return name.to_str();
+        }
+    }
+    fail!();
+}
 // This is a highly not-optimal set of data structure decisions.
 type LintModes = @mut SmallIntMap<level>;
 type LintModeMap = @mut HashMap<ast::node_id, LintModes>;

trunk/src/librustc/middle/subst.rs

@@ -78,11 +78,9 @@ impl<T:Subst> Subst for ~[T] {
     }
 }
 
-impl<T:Subst> Subst for @T {
-    fn subst(&self, tcx: ty::ctxt, substs: &ty::substs) -> @T {
-        match self {
-            &@ref t => @t.subst(tcx, substs)
-        }
+impl<T:Subst> Subst for @~[T] {
+    fn subst(&self, tcx: ty::ctxt, substs: &ty::substs) -> @~[T] {
+        @(**self).subst(tcx, substs)
     }
 }
 
@@ -117,11 +115,19 @@ impl Subst for ty::BareFnTy {
     }
 }
 
-impl Subst for ty::ParamBounds {
-    fn subst(&self, tcx: ty::ctxt, substs: &ty::substs) -> ty::ParamBounds {
-        ty::ParamBounds {
-            builtin_bounds: self.builtin_bounds,
-            trait_bounds: self.trait_bounds.subst(tcx, substs)
+impl Subst for ty::param_bound {
+    fn subst(&self, tcx: ty::ctxt, substs: &ty::substs) -> ty::param_bound {
+        match self {
+            &ty::bound_copy |
+            &ty::bound_durable |
+            &ty::bound_owned |
+            &ty::bound_const => {
+                *self
+            }
+
+            &ty::bound_trait(tref) => {
+                ty::bound_trait(@tref.subst(tcx, substs))
+            }
         }
     }
 }

trunk/src/librustc/middle/trans/monomorphize.rs

@@ -348,9 +348,14 @@ pub fn make_mono_id(ccx: @CrateContext,
         let mut i = 0;
         vec::map_zip(*item_ty.generics.type_param_defs, substs, |type_param_def, subst| {
             let mut v = ~[];
-            for type_param_def.bounds.trait_bounds.each |_bound| {
-                v.push(meth::vtable_id(ccx, /*bad*/copy vts[i]));
-                i += 1;
+            for type_param_def.bounds.each |bound| {
+                match *bound {
+                  ty::bound_trait(_) => {
+                    v.push(meth::vtable_id(ccx, /*bad*/copy vts[i]));
+                    i += 1;
+                  }
+                  _ => ()
+                }
             }
             (*subst, if !v.is_empty() { Some(v) } else { None })
         })