---

yaml
---
r: 22625
b: refs/heads/master
c: f676547
h: refs/heads/master
i:
  22623: ecd562a
v: v3

Author: nikomatsakis

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 978ca03cb2f46e13f9f8d512e17867aa26e8432f
+refs/heads/master: f676547c9788b919762bfb379b1e26ebd94d3dc9
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: cd6f24f9d14ac90d167386a56e7a6ac1f0318195
 refs/heads/try: ffbe0e0e00374358b789b0037bcb3a577cd218be

trunk/src/rustc/middle/typeck/infer.rs

@@ -2371,7 +2371,8 @@ impl of combine for glb {
                 }
               }
 
-              (ty::re_scope(a_id), ty::re_scope(b_id)) {
+              (ty::re_scope(a_id), ty::re_scope(b_id)) |
+              (ty::re_free(a_id, _), ty::re_free(b_id, _)) {
                 // We want to generate a region that is contained by both of
                 // these: so, if one of these scopes is a subscope of the
                 // other, return it.  Otherwise fail.
@@ -2385,7 +2386,6 @@ impl of combine for glb {
 
               // For these types, we cannot define any additional
               // relationship:
-              (ty::re_free(_, _), ty::re_free(_, _)) |
               (ty::re_bound(_), ty::re_bound(_)) |
               (ty::re_bound(_), ty::re_free(_, _)) |
               (ty::re_bound(_), ty::re_scope(_)) |

trunk/src/test/compile-fail/regions-infer-call-3.rs

@@ -0,0 +1,14 @@
+fn select(x: &int, y: &int) -> &int { x }
+
+fn with<T>(f: fn(x: &int) -> T) -> T {
+    f(&20)
+}
+
+fn manip(x: &a/int) -> int {
+    let z = do with |y| { select(x, y) };
+    //~^ ERROR reference is not valid outside of its lifetime
+    *z
+}
+
+fn main() {
+}

trunk/src/test/run-pass/regions-infer-call-2.rs

@@ -0,0 +1,13 @@
+fn takes_two(x: &int, y: &int) -> int { *x + *y }
+
+fn with<T>(f: fn(x: &int) -> T) -> T {
+    f(&20)
+}
+
+fn has_one(x: &a/int) -> int {
+    do with |y| { takes_two(x, y) }
+}
+
+fn main() {
+    assert has_one(&2) == 22;
+}

trunk/src/test/run-pass/regions-infer-call.rs

@@ -0,0 +1,9 @@
+fn takes_two(x: &int, y: &int) -> int { *x + *y }
+
+fn has_two(x: &a/int, y: &b/int) -> int {
+    takes_two(x, y)
+}
+
+fn main() {
+    assert has_two(&20, &2) == 22;
+}