---

yaml
---
r: 138403
b: refs/heads/master
c: df714cf
h: refs/heads/master
i:
  138401: 78b9e9b
  138399: 0086df1
v: v3

Author: nikomatsakis

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 98e237a681c798ef6850395cb8483b82fc844452
+refs/heads/master: df714cfda728e201dd6b2227caa425bca3e048c7
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5

trunk/src/librustc/middle/borrowck/graphviz.rs

@@ -142,8 +142,8 @@ impl<'a, 'tcx> dot::Labeller<'a, Node<'a>, Edge<'a>> for DataflowLabeller<'a, 't
 }
 
 impl<'a, 'tcx> dot::GraphWalk<'a, Node<'a>, Edge<'a>> for DataflowLabeller<'a, 'tcx> {
-    fn nodes(&self) -> dot::Nodes<'a, Node<'a>> { self.inner.nodes() }
-    fn edges(&self) -> dot::Edges<'a, Edge<'a>> { self.inner.edges() }
-    fn source(&self, edge: &Edge<'a>) -> Node<'a> { self.inner.source(edge) }
-    fn target(&self, edge: &Edge<'a>) -> Node<'a> { self.inner.target(edge) }
+    fn nodes(&'a self) -> dot::Nodes<'a, Node<'a>> { self.inner.nodes() }
+    fn edges(&'a self) -> dot::Edges<'a, Edge<'a>> { self.inner.edges() }
+    fn source(&'a self, edge: &Edge<'a>) -> Node<'a> { self.inner.source(edge) }
+    fn target(&'a self, edge: &Edge<'a>) -> Node<'a> { self.inner.target(edge) }
 }

trunk/src/librustc/middle/cfg/graphviz.rs

@@ -91,29 +91,29 @@ impl<'a, 'ast> dot::Labeller<'a, Node<'a>, Edge<'a>> for LabelledCFG<'a, 'ast> {
 }
 
 impl<'a> dot::GraphWalk<'a, Node<'a>, Edge<'a>> for &'a cfg::CFG {
-    fn nodes(&self) -> dot::Nodes<'a, Node<'a>> {
+    fn nodes(&'a self) -> dot::Nodes<'a, Node<'a>> {
         let mut v = Vec::new();
         self.graph.each_node(|i, nd| { v.push((i, nd)); true });
         dot::maybe_owned_vec::Growable(v)
     }
-    fn edges(&self) -> dot::Edges<'a, Edge<'a>> {
+    fn edges(&'a self) -> dot::Edges<'a, Edge<'a>> {
         self.graph.all_edges().iter().collect()
     }
-    fn source(&self, edge: &Edge<'a>) -> Node<'a> {
+    fn source(&'a self, edge: &Edge<'a>) -> Node<'a> {
         let i = edge.source();
         (i, self.graph.node(i))
     }
-    fn target(&self, edge: &Edge<'a>) -> Node<'a> {
+    fn target(&'a self, edge: &Edge<'a>) -> Node<'a> {
         let i = edge.target();
         (i, self.graph.node(i))
     }
 }
 
 impl<'a, 'ast> dot::GraphWalk<'a, Node<'a>, Edge<'a>> for LabelledCFG<'a, 'ast>
 {
-    fn nodes(&self) -> dot::Nodes<'a, Node<'a>> { self.cfg.nodes() }
-    fn edges(&self) -> dot::Edges<'a, Edge<'a>> { self.cfg.edges() }
-    fn source(&self, edge: &Edge<'a>) -> Node<'a> { self.cfg.source(edge) }
-    fn target(&self, edge: &Edge<'a>) -> Node<'a> { self.cfg.target(edge) }
+    fn nodes(&'a self) -> dot::Nodes<'a, Node<'a>> { self.cfg.nodes() }
+    fn edges(&'a self) -> dot::Edges<'a, Edge<'a>> { self.cfg.edges() }
+    fn source(&'a self, edge: &Edge<'a>) -> Node<'a> { self.cfg.source(edge) }
+    fn target(&'a self, edge: &Edge<'a>) -> Node<'a> { self.cfg.target(edge) }
 }
 

trunk/src/test/auxiliary/regions-bounded-method-type-parameters-cross-crate-lib.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 // Check that method bounds declared on traits/impls in a cross-crate
-// scenario work. This is the libary portion of the test.
+// scenario work. This is the library portion of the test.
 
 pub enum MaybeOwned<'a> {
     Owned(int),
@@ -24,10 +24,19 @@ pub struct Inv<'a> { // invariant w/r/t 'a
 // trait, so I'll use that as the template for this test.
 pub trait IntoMaybeOwned<'a> {
     fn into_maybe_owned(self) -> MaybeOwned<'a>;
+
+    // Note: without this `into_inv` method, the trait is
+    // contravariant w/r/t `'a`, since if you look strictly at the
+    // interface, it only returns `'a`. This complicates the
+    // downstream test since it wants invariance to force an error.
+    // Hence we add this method.
+    fn into_inv(self) -> Inv<'a>;
+
     fn bigger_region<'b:'a>(self, b: Inv<'b>);
 }
 
 impl<'a> IntoMaybeOwned<'a> for Inv<'a> {
     fn into_maybe_owned(self) -> MaybeOwned<'a> { fail!() }
+    fn into_inv(self) -> Inv<'a> { fail!() }
     fn bigger_region<'b:'a>(self, b: Inv<'b>) { fail!() }
 }

trunk/src/test/compile-fail/regions-bounded-method-type-parameters-cross-crate.rs

@@ -18,15 +18,15 @@ use lib::Inv;
 use lib::MaybeOwned;
 use lib::IntoMaybeOwned;
 
-fn call_into_maybe_owned<'a,F:IntoMaybeOwned<'a>>(f: F) {
+fn call_into_maybe_owned<'x,F:IntoMaybeOwned<'x>>(f: F) {
     // Exercise a code path I found to be buggy. We were not encoding
     // the region parameters from the receiver correctly on trait
     // methods.
     f.into_maybe_owned();
 }
 
-fn call_bigger_region<'a, 'b>(a: Inv<'a>, b: Inv<'b>) {
-    // Here the value provided for 'y is 'b, and hence 'b:'a does not hold.
+fn call_bigger_region<'x, 'y>(a: Inv<'x>, b: Inv<'y>) {
+    // Here the value provided for 'y is 'y, and hence 'y:'x does not hold.
     a.bigger_region(b) //~ ERROR cannot infer
 }
 

trunk/src/test/compile-fail/wrong-mul-method-signature.rs

@@ -58,7 +58,13 @@ impl Mul<f64, i32> for Vec3 {
 }
 
 pub fn main() {
-    Vec1 { x: 1.0 } * 2.0;
-    Vec2 { x: 1.0, y: 2.0 } * 2.0;
-    Vec3 { x: 1.0, y: 2.0, z: 3.0 } * 2.0;
+    // Check that the usage goes from the trait declaration:
+
+    let x: Vec1 = Vec1 { x: 1.0 } * 2.0; // this is OK
+
+    let x: Vec2 = Vec2 { x: 1.0, y: 2.0 } * 2.0; // trait had reversed order
+    //~^ ERROR mismatched types
+    //~^^ ERROR mismatched types
+
+    let x: i32 = Vec3 { x: 1.0, y: 2.0, z: 3.0 } * 2.0;
 }