---

yaml
---
r: 32431
b: refs/heads/dist-snap
c: 46990ad
h: refs/heads/master
i:
  32429: dc5c758
  32427: 58ce198
  32423: c16d587
  32415: 5d84939
v: v3

Author: catamorphism

[refs]

@@ -7,6 +7,6 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: d0c6ce338884ee21843f4b40bf6bf18d222ce5df
 refs/heads/incoming: d9317a174e434d4c99fc1a37fd7dc0d2f5328d37
-refs/heads/dist-snap: c5e2cf2ee5b47a526b2eeebf26312fb184fcf7a6
+refs/heads/dist-snap: 46990ad1116024ed7e6de00b3678dcd1733df967
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/dist-snap/src/rustc/middle/kind.rs

@@ -241,17 +241,25 @@ fn check_arm(a: arm, cx: ctx, v: visit::vt<ctx>) {
 
 fn check_expr(e: @expr, cx: ctx, v: visit::vt<ctx>) {
     debug!("kind::check_expr(%s)", expr_to_str(e, cx.tcx.sess.intr()));
+    let id_to_use = match e.node {
+        expr_index(*)|expr_assign_op(*)|
+        expr_unary(*)|expr_binary(*) => e.callee_id,
+        _ => e.id
+    };
 
     // Handle any kind bounds on type parameters
-    do option::iter(cx.tcx.node_type_substs.find(e.id)) |ts| {
+    do option::iter(cx.tcx.node_type_substs.find(id_to_use)) |ts| {
         let bounds = match e.node {
           expr_path(_) => {
             let did = ast_util::def_id_of_def(cx.tcx.def_map.get(e.id));
             ty::lookup_item_type(cx.tcx, did).bounds
           }
           _ => {
-            // Type substitions should only occur on paths and
+            // Type substitutions should only occur on paths and
             // method calls, so this needs to be a method call.
+
+            // Even though the callee_id may have been the id with
+            // node_type_substs, e.id is correct here.
             ty::method_call_bounds(cx.tcx, cx.method_map, e.id).expect(
                 ~"non path/method call expr has type substs??")
           }
@@ -265,7 +273,7 @@ fn check_expr(e: @expr, cx: ctx, v: visit::vt<ctx>) {
                       *bounds, (*bounds).len());
         }
         do vec::iter2(ts, *bounds) |ty, bound| {
-            check_bounds(cx, e.id, e.span, ty, bound)
+            check_bounds(cx, id_to_use, e.span, ty, bound)
         }
     }
 

branches/dist-snap/src/test/run-pass/issue-2548.rs renamed to branches/dist-snap/src/test/compile-fail/issue-2548.rs

@@ -1,26 +1,28 @@
 // A test case for #2548.
 
-// xfail-test
-
 struct foo {
     x: @mut int;
 
-    new(x: @mut int) { self.x = x; }
 
     drop {
         io::println("Goodbye, World!");
         *self.x += 1;
     }
 }
 
+fn foo(x: @mut int) -> foo {
+    foo { x: x }
+}
+
 fn main() {
     let x = @mut 0;
 
     {
         let mut res = foo(x);
 
         let mut v = ~[mut];
-        v <- ~[mut res] + v;
+        v <- ~[mut res] + v; //~ ERROR instantiating a type parameter with an incompatible type (needs `copy`, got `owned`, missing `copy`)
+        assert (v.len() == 2);
     }
 
     assert *x == 1;

branches/dist-snap/src/test/run-pass/monad.rs

@@ -1,9 +1,9 @@
 trait vec_monad<A> {
-    fn bind<B>(f: fn(A) -> ~[B]) -> ~[B];
+    fn bind<B: copy>(f: fn(A) -> ~[B]) -> ~[B];
 }
 
 impl<A> ~[A]: vec_monad<A> {
-    fn bind<B>(f: fn(A) -> ~[B]) -> ~[B] {
+    fn bind<B: copy>(f: fn(A) -> ~[B]) -> ~[B] {
         let mut r = ~[];
         for self.each |elt| { r += f(elt); }
         r

branches/dist-snap/src/test/run-pass/static-impl.rs

@@ -28,13 +28,13 @@ impl uint: uint_utils {
 trait vec_utils<T> {
     fn length_() -> uint;
     fn iter_(f: fn(T));
-    fn map_<U>(f: fn(T) -> U) -> ~[U];
+    fn map_<U: copy>(f: fn(T) -> U) -> ~[U];
 }
 
 impl<T> ~[T]: vec_utils<T> {
     fn length_() -> uint { vec::len(self) }
     fn iter_(f: fn(T)) { for self.each |x| { f(x); } }
-    fn map_<U>(f: fn(T) -> U) -> ~[U] {
+    fn map_<U: copy>(f: fn(T) -> U) -> ~[U] {
         let mut r = ~[];
         for self.each |elt| { r += ~[f(elt)]; }
         r

branches/dist-snap/src/test/run-pass/trait-generic.rs

@@ -5,17 +5,17 @@ impl int: to_str {
     fn to_str() -> ~str { int::str(self) }
 }
 impl ~str: to_str {
-    fn to_str() -> ~str { self }
+    fn to_str() -> ~str { copy self }
 }
 impl (): to_str {
     fn to_str() -> ~str { ~"()" }
 }
 
 trait map<T> {
-    fn map<U>(f: fn(T) -> U) -> ~[U];
+    fn map<U: copy>(f: fn(T) -> U) -> ~[U];
 }
 impl<T> ~[T]: map<T> {
-    fn map<U>(f: fn(T) -> U) -> ~[U] {
+    fn map<U: copy>(f: fn(T) -> U) -> ~[U] {
         let mut r = ~[];
         for self.each |x| { r += ~[f(x)]; }
         r