---

yaml
---
r: 85343
b: refs/heads/dist-snap
c: 0efbb25
h: refs/heads/master
i:
  85341: 650ac61
  85339: e79b8e6
  85335: a26bc58
  85327: 29450e3
  85311: 7928096
v: v3

Author: bors

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: 0983ebe5310d4eb6d289f636f7ed0536c08bbc0e
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: 783c6a1fbf9c44bc58e3ba9224d5920db1de91f0
+refs/heads/dist-snap: 0efbb25a26d9a793ce5aa67e030b3d0bee43f5fa
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/librustc/middle/typeck/check/mod.rs

@@ -3208,10 +3208,19 @@ pub fn instantiate_path(fcx: @mut FnCtxt,
                   ty_param_count, ty_substs_len));
         fcx.infcx().next_ty_vars(ty_param_count)
     } else if ty_substs_len < ty_param_count {
+        let is_static_method = match fcx.ccx.tcx.def_map.find(&node_id) {
+            Some(&ast::def_static_method(*)) => true,
+            _ => false
+        };
         fcx.ccx.tcx.sess.span_err
             (span,
              fmt!("not enough type parameters provided: expected %u, found %u",
                   ty_param_count, ty_substs_len));
+        if is_static_method {
+            fcx.ccx.tcx.sess.span_note
+                (span, "Static methods have an extra implicit type parameter -- \
+                 did you omit the type parameter for the `Self` type?");
+        }
         fcx.infcx().next_ty_vars(ty_param_count)
     } else {
         pth.types.map(|aty| fcx.to_ty(aty))

branches/dist-snap/src/librustc/middle/typeck/check/regionck.rs

@@ -391,7 +391,7 @@ fn visit_expr(expr: @ast::expr, (rcx, v): (@mut Rcx, rvt)) {
             let target_ty = rcx.resolve_node_type(expr.id);
             match ty::get(target_ty).sty {
                 ty::ty_trait(_, _, ty::RegionTraitStore(trait_region), _, _) => {
-                    let source_ty = rcx.fcx.expr_ty(source);
+                    let source_ty = rcx.resolve_expr_type_adjusted(source);
                     constrain_regions_in_type(
                         rcx,
                         trait_region,
@@ -1153,17 +1153,20 @@ pub mod guarantor {
         match ty::get(ty).sty {
             ty::ty_rptr(r, _) |
             ty::ty_evec(_, ty::vstore_slice(r)) |
+            ty::ty_trait(_, _, ty::RegionTraitStore(r), _, _) |
             ty::ty_estr(ty::vstore_slice(r)) => {
                 BorrowedPointer(r)
             }
             ty::ty_uniq(*) |
             ty::ty_estr(ty::vstore_uniq) |
+            ty::ty_trait(_, _, ty::UniqTraitStore, _, _) |
             ty::ty_evec(_, ty::vstore_uniq) => {
                 OwnedPointer
             }
             ty::ty_box(*) |
             ty::ty_ptr(*) |
             ty::ty_evec(_, ty::vstore_box) |
+            ty::ty_trait(_, _, ty::BoxTraitStore, _, _) |
             ty::ty_estr(ty::vstore_box) => {
                 OtherPointer
             }

branches/dist-snap/src/librustc/middle/typeck/infer/coercion.rs

@@ -121,9 +121,9 @@ impl Coerce {
                 };
             }
 
-            ty::ty_trait(_, _, ty::RegionTraitStore(*), _, _) => {
+            ty::ty_trait(_, _, ty::RegionTraitStore(*), m, _) => {
                 return do self.unpack_actual_value(a) |sty_a| {
-                    self.coerce_borrowed_object(a, sty_a, b)
+                    self.coerce_borrowed_object(a, sty_a, b, m)
                 };
             }
 
@@ -274,34 +274,30 @@ impl Coerce {
     fn coerce_borrowed_object(&self,
                               a: ty::t,
                               sty_a: &ty::sty,
-                              b: ty::t) -> CoerceResult
+                              b: ty::t,
+                              b_mutbl: ast::mutability) -> CoerceResult
     {
         debug!("coerce_borrowed_object(a=%s, sty_a=%?, b=%s)",
                a.inf_str(self.infcx), sty_a,
                b.inf_str(self.infcx));
 
         let tcx = self.infcx.tcx;
         let r_a = self.infcx.next_region_var(Coercion(self.trace));
-        let trt_mut;
 
         let a_borrowed = match *sty_a {
-            ty::ty_trait(_, _, ty::RegionTraitStore(_), _, _) => {
-                return self.subtype(a, b);
-            }
-            ty::ty_trait(did, ref substs, _, m, b) => {
-                trt_mut = m;
+            ty::ty_trait(did, ref substs, _, _, b) => {
                 ty::mk_trait(tcx, did, substs.clone(),
-                             ty::RegionTraitStore(r_a), m, b)
+                             ty::RegionTraitStore(r_a), b_mutbl, b)
             }
             _ => {
                 return self.subtype(a, b);
             }
         };
 
-        if_ok!(self.tys(a_borrowed, b));
+        if_ok!(self.subtype(a_borrowed, b));
         Ok(Some(@AutoDerefRef(AutoDerefRef {
             autoderefs: 0,
-            autoref: Some(AutoBorrowObj(r_a, trt_mut))
+            autoref: Some(AutoBorrowObj(r_a, b_mutbl))
         })))
     }
 

branches/dist-snap/src/test/auxiliary/iss.rs

@@ -8,23 +8,15 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// aux-build:issue_3907.rs
-extern mod issue_3907;
-
-type Foo = issue_3907::Foo; //~ ERROR: reference to trait
-
-struct S {
-    name: int
+pub trait Nummy {
+    fn from_inty<T>() -> Self;
 }
 
-impl Foo for S { //~ ERROR: Foo is not a trait
-    fn bar() { }
+impl Nummy for float {
+    fn from_inty<T>() -> float { 0.0 }
 }
 
 fn main() {
-    let s = S {
-        name: 0
-    };
-    s.bar();
+    let _1:float = Nummy::from_inty::<int>();  //~ ERROR not enough type
+    //~^ NOTE Static methods have an extra implicit type parameter
 }
-

branches/dist-snap/src/test/auxiliary/issue_3907.rs

@@ -0,0 +1,22 @@
+// error-pattern:borrowed
+
+trait Foo {
+    fn foo(&self, @mut int);
+}
+
+impl Foo for int {
+    fn foo(&self, x: @mut int) {
+        *x += *self;
+    }
+}
+
+fn it_takes_two(f: &Foo, g: &mut Foo) {
+}
+
+fn main() {
+    let x = @mut 3_i;
+    let y = x as @mut Foo;
+    let z = y;
+
+    it_takes_two(y, z);
+}