---

yaml
---
r: 42397
b: refs/heads/master
c: a380df8
h: refs/heads/master
i:
  42395: 61c0612
v: v3

Author: nikomatsakis

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 14930fbffe95971e9258cb2eb45a1642eb735bbe
+refs/heads/master: a380df809c8eb874540a123780612f14cfc7303e
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 2f46b763da2c098913884f101b6d71d69af41b49
 refs/heads/try: 3d5418789064fdb463e872a4e651af1c628a3650

trunk/src/libcargo/cargo.rc

@@ -457,7 +457,7 @@ pub fn parse_source(name: ~str, j: &json::Json) -> @Source {
     }
 
     match *j {
-        json::Object(j) => {
+        json::Object(ref j) => {
             let mut url = match j.find(&~"url") {
                 Some(&json::String(u)) => copy u,
                 _ => die!(~"needed 'url' field in source")
@@ -563,7 +563,7 @@ pub fn load_one_source_package(src: @Source, p: &json::Object) {
 
     let mut tags = ~[];
     match p.find(&~"tags") {
-        Some(&json::List(js)) => {
+        Some(&json::List(ref js)) => {
           for js.each |j| {
                 match *j {
                     json::String(ref j) => tags.grow(1u, j),
@@ -635,11 +635,11 @@ pub fn load_source_packages(c: &Cargo, src: @Source) {
     if !os::path_exists(&pkgfile) { return; }
     let pkgstr = io::read_whole_file_str(&pkgfile);
     match json::from_str(pkgstr.get()) {
-        Ok(json::List(js)) => {
+        Ok(json::List(ref js)) => {
           for js.each |j| {
                 match *j {
-                    json::Object(p) => {
-                        load_one_source_package(src, p);
+                    json::Object(ref p) => {
+                        load_one_source_package(src, *p);
                     }
                     _ => {
                         warn(~"malformed source json: " + src.name +

trunk/src/libcore/str.rs

@@ -220,6 +220,16 @@ pub pure fn connect(v: &[~str], sep: &str) -> ~str {
     s
 }
 
+/// Concatenate a vector of strings, placing a given separator between each
+pub pure fn connect_slices(v: &[&str], sep: &str) -> ~str {
+    let mut s = ~"", first = true;
+    for vec::each(v) |ss| {
+        if first { first = false; } else { unsafe { push_str(&mut s, sep); } }
+        unsafe { push_str(&mut s, *ss) };
+    }
+    s
+}
+
 /// Given a string, make a new string with repeated copies of it
 pub pure fn repeat(ss: &str, nn: uint) -> ~str {
     let mut acc = ~"";
@@ -2667,6 +2677,17 @@ mod tests {
         t(~[~"hi"], ~" ", ~"hi");
     }
 
+    #[test]
+    fn test_connect_slices() {
+        fn t(v: &[&str], sep: &str, s: &str) {
+            assert connect_slices(v, sep) == s.to_str();
+        }
+        t(["you", "know", "I'm", "no", "good"],
+          " ", "you know I'm no good");
+        t([], " ", "");
+        t(["hi"], " ", "hi");
+    }
+
     #[test]
     fn test_repeat() {
         assert repeat(~"x", 4) == ~"xxxx";

trunk/src/librustc/lib/llvm.rs

@@ -382,7 +382,6 @@ pub extern mod llvm {
     pub unsafe fn LLVMGetUsedValue(U: UseRef) -> ValueRef;
 
     /* Operations on Users */
-    pub unsafe fn LLVMGetNumOperands(Val: ValueRef) -> c_int;
     pub unsafe fn LLVMGetOperand(Val: ValueRef, Index: c_uint) -> ValueRef;
     pub unsafe fn LLVMSetOperand(Val: ValueRef, Index: c_uint, Op: ValueRef);
 

trunk/src/librustc/middle/kind.rs

@@ -15,7 +15,6 @@ use middle::freevars;
 use middle::lint::{non_implicitly_copyable_typarams, implicit_copies};
 use middle::liveness;
 use middle::pat_util;
-use middle::ty::{Kind, kind_copyable, kind_noncopyable, kind_const};
 use middle::ty;
 use middle::typeck;
 use middle;
@@ -61,26 +60,6 @@ use syntax::{visit, ast_util};
 
 pub const try_adding: &str = "Try adding a move";
 
-pub fn kind_to_str(k: Kind) -> ~str {
-    let mut kinds = ~[];
-
-    if ty::kind_lteq(kind_const(), k) {
-        kinds.push(~"const");
-    }
-
-    if ty::kind_can_be_copied(k) {
-        kinds.push(~"copy");
-    }
-
-    if ty::kind_can_be_sent(k) {
-        kinds.push(~"owned");
-    } else if ty::kind_is_durable(k) {
-        kinds.push(~"&static");
-    }
-
-    str::connect(kinds, ~" ")
-}
-
 pub type rval_map = HashMap<node_id, ()>;
 
 pub type ctx = {
@@ -119,11 +98,11 @@ type check_fn = fn@(ctx, @freevar_entry);
 // closure.
 fn with_appropriate_checker(cx: ctx, id: node_id, b: fn(check_fn)) {
     fn check_for_uniq(cx: ctx, fv: @freevar_entry) {
-        // all captured data must be sendable, regardless of whether it is
-        // moved in or copied in.  Note that send implies owned.
+        // all captured data must be owned, regardless of whether it is
+        // moved in or copied in.
         let id = ast_util::def_id_of_def(fv.def).node;
         let var_t = ty::node_id_to_type(cx.tcx, id);
-        if !check_send(cx, var_t, fv.span) { return; }
+        if !check_owned(cx, var_t, fv.span) { return; }
 
         // check that only immutable variables are implicitly copied in
         check_imm_free_var(cx, fv.def, fv.span);
@@ -281,30 +260,54 @@ fn check_ty(aty: @Ty, cx: ctx, v: visit::vt<ctx>) {
     visit::visit_ty(aty, cx, v);
 }
 
-pub fn check_bounds(cx: ctx, id: node_id, sp: span,
-                    ty: ty::t, bounds: ty::param_bounds) {
-    let kind = ty::type_kind(cx.tcx, ty);
-    let p_kind = ty::param_bounds_to_kind(bounds);
-    if !ty::kind_lteq(p_kind, kind) {
-        // If the only reason the kind check fails is because the
-        // argument type isn't implicitly copyable, consult the warning
-        // settings to figure out what to do.
-        let implicit = ty::kind_implicitly_copyable() - ty::kind_copyable();
-        if ty::kind_lteq(p_kind, kind | implicit) {
-            cx.tcx.sess.span_lint(
-                non_implicitly_copyable_typarams,
-                id, cx.current_item, sp,
-                ~"instantiating copy type parameter with a \
-                 not implicitly copyable type");
-        } else {
-            cx.tcx.sess.span_err(
-                sp,
-                ~"instantiating a type parameter with an incompatible type " +
-                ~"(needs `" + kind_to_str(p_kind) +
-                ~"`, got `" + kind_to_str(kind) +
-                ~"`, missing `" + kind_to_str(p_kind - kind) + ~"`)");
+pub fn check_bounds(cx: ctx,
+                    _type_parameter_id: node_id,
+                    sp: span,
+                    ty: ty::t,
+                    bounds: ty::param_bounds)
+{
+    let kind = ty::type_contents(cx.tcx, ty);
+    let mut missing = ~[];
+    for 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),
+                 str::connect_slices(missing, " ")));
+    }
 }
 
 fn is_nullary_variant(cx: ctx, ex: @expr) -> bool {
@@ -342,16 +345,22 @@ fn check_imm_free_var(cx: ctx, def: def, sp: span) {
 }
 
 fn check_copy(cx: ctx, ty: ty::t, sp: span, reason: &str) {
-    let k = ty::type_kind(cx.tcx, ty);
-    if !ty::kind_can_be_copied(k) {
-        cx.tcx.sess.span_err(sp, ~"copying a noncopyable value");
+    debug!("type_contents(%s)=%s",
+           ty_to_str(cx.tcx, ty),
+           ty::type_contents(cx.tcx, ty).to_str());
+    if !ty::type_is_copyable(cx.tcx, ty) {
+        cx.tcx.sess.span_err(
+            sp, fmt!("copying a value of non-copyable type `%s`",
+                     ty_to_str(cx.tcx, ty)));
         cx.tcx.sess.span_note(sp, fmt!("%s", reason));
     }
 }
 
-pub fn check_send(cx: ctx, ty: ty::t, sp: span) -> bool {
-    if !ty::kind_can_be_sent(ty::type_kind(cx.tcx, ty)) {
-        cx.tcx.sess.span_err(sp, ~"not a sendable value");
+pub fn check_owned(cx: ctx, ty: ty::t, sp: span) -> bool {
+    if !ty::type_is_owned(cx.tcx, ty) {
+        cx.tcx.sess.span_err(
+            sp, fmt!("value has non-owned type `%s`",
+                     ty_to_str(cx.tcx, ty)));
         false
     } else {
         true
@@ -360,7 +369,7 @@ pub fn check_send(cx: ctx, 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::kind_is_durable(ty::type_kind(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 \
@@ -403,8 +412,8 @@ pub fn check_durable(tcx: ty::ctxt, ty: ty::t, sp: span) -> bool {
 pub fn check_cast_for_escaping_regions(
     cx: ctx,
     source: @expr,
-    target: @expr) {
-
+    target: @expr)
+{
     // Determine what type we are casting to; if it is not an trait, then no
     // worries.
     let target_ty = ty::expr_ty(cx.tcx, target);
@@ -450,13 +459,9 @@ pub fn check_kind_bounds_of_cast(cx: ctx, source: @expr, target: @expr) {
     match ty::get(target_ty).sty {
         ty::ty_trait(_, _, ty::vstore_uniq) => {
             let source_ty = ty::expr_ty(cx.tcx, source);
-            let source_kind = ty::type_kind(cx.tcx, source_ty);
-            if !ty::kind_can_be_copied(source_kind) {
-                cx.tcx.sess.span_err(target.span,
-                    ~"uniquely-owned trait objects must be copyable");
-            }
-            if !ty::kind_can_be_sent(source_kind) {
-                cx.tcx.sess.span_err(target.span,
+            if !ty::type_is_owned(cx.tcx, source_ty) {
+                cx.tcx.sess.span_err(
+                    target.span,
                     ~"uniquely-owned trait objects must be sendable");
             }
         }

trunk/src/librustc/middle/lint.rs

@@ -925,8 +925,8 @@ fn check_fn_deprecated_modes(tcx: ty::ctxt, fn_ty: ty::t, decl: ast::fn_decl,
 
                     ast::infer(_) => {
                         if tcx.legacy_modes {
-                            let kind = ty::type_kind(tcx, arg_ty.ty);
-                            if !ty::kind_is_safe_for_default_mode(kind) {
+                            let kind = ty::type_contents(tcx, arg_ty.ty);
+                            if !kind.is_safe_for_default_mode(tcx) {
                                 tcx.sess.span_lint(
                                     deprecated_mode, id, id,
                                     span,

trunk/src/librustc/middle/moves.rs

@@ -374,7 +374,7 @@ impl VisitContext {
          * not implicitly copyable.
          */
 
-        let result = if ty::type_implicitly_moves(self.tcx, ty) {
+        let result = if ty::type_moves_by_default(self.tcx, ty) {
             MoveInWhole
         } else {
             Read
@@ -495,7 +495,7 @@ impl VisitContext {
                     // moves-by-default:
                     let consume_with = with_fields.any(|tf| {
                         !fields.any(|f| f.node.ident == tf.ident) &&
-                            ty::type_implicitly_moves(self.tcx, tf.mt.ty)
+                            ty::type_moves_by_default(self.tcx, tf.mt.ty)
                     });
 
                     if consume_with {
@@ -830,7 +830,7 @@ impl VisitContext {
                 let fvar_ty = ty::node_id_to_type(self.tcx, fvar_def_id);
                 debug!("fvar_def_id=%? fvar_ty=%s",
                        fvar_def_id, ppaux::ty_to_str(self.tcx, fvar_ty));
-                let mode = if ty::type_implicitly_moves(self.tcx, fvar_ty) {
+                let mode = if ty::type_moves_by_default(self.tcx, fvar_ty) {
                     CapMove
                 } else {
                     CapCopy