Reason about nested free variables that appear in a function

signature.  In a nutshell, the idea is to (1) report an error if, for
a region pointer `'a T`, the lifetime `'a` is longer than any
lifetimes that appear in `T` (in other words, if a borrowed pointer
outlives any portion of its contents) and then (2) use this to assume
that in a function like `fn(self: &'a &'b T)`, the relationship `'a <=
'b` holds. This is needed for #5656.  Fixes #5728.

src/test/compile-fail/kindck-owned-trait-contains.rs

@@ -27,5 +27,6 @@ fn main() {
         let x: &'blk int = &3;
         repeater(@x)
     };
-    assert!(3 == *(y.get())); //~ ERROR reference is not valid
+    assert!(3 == *(y.get())); //~ ERROR dereference of reference outside its lifetime
+    //~^ ERROR reference is not valid outside of its lifetime
 }

src/test/compile-fail/regions-escape-via-trait-or-not.rs

@@ -24,9 +24,9 @@ fn with<R:deref>(f: &fn(x: &int) -> R) -> int {
 
 fn return_it() -> int {
     with(|o| o)
-    //~^ ERROR reference is not valid outside of its lifetime
+    //~^ ERROR cannot infer an appropriate lifetime due to conflicting requirements
     //~^^ ERROR reference is not valid outside of its lifetime
-    //~^^^ ERROR cannot infer an appropriate lifetime
+    //~^^^ ERROR reference is not valid outside of its lifetime
 }
 
 fn main() {

src/test/compile-fail/regions-free-region-ordering-callee.rs

@@ -0,0 +1,37 @@
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Tests that callees correctly infer an ordering between free regions
+// that appear in their parameter list.  See also
+// regions-free-region-ordering-caller.rs
+
+fn ordering1<'a, 'b>(x: &'a &'b uint) -> &'a uint {
+    // It is safe to assume that 'a <= 'b due to the type of x
+    let y: &'b uint = &**x;
+    return y;
+}
+
+fn ordering2<'a, 'b>(x: &'a &'b uint, y: &'a uint) -> &'b uint {
+    // However, it is not safe to assume that 'b <= 'a
+    &*y //~ ERROR cannot infer an appropriate lifetime
+}
+
+fn ordering3<'a, 'b>(x: &'a uint, y: &'b uint) -> &'a &'b uint {
+    // Do not infer an ordering from the return value.
+    let z: &'b uint = &*x;
+    //~^ ERROR cannot infer an appropriate lifetime due to conflicting requirements
+    fail!();
+}
+
+fn ordering4<'a, 'b>(a: &'a uint, b: &'b uint, x: &fn(&'a &'b uint)) {
+    let z: Option<&'a &'b uint> = None;
+}
+
+fn main() {}

src/test/compile-fail/regions-free-region-ordering-caller.rs

@@ -0,0 +1,40 @@
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Test various ways to construct a pointer with a longer lifetime
+// than the thing it points at and ensure that they result in
+// errors. See also regions-free-region-ordering-callee.rs
+
+struct Paramd<'self> { x: &'self uint }
+
+fn call1<'a>(x: &'a uint) {
+    let y: uint = 3;
+    let z: &'a &'blk uint = &(&y);
+    //~^ ERROR pointer has a longer lifetime than the data it references
+}
+
+fn call2<'a, 'b>(a: &'a uint, b: &'b uint) {
+    let z: Option<&'b &'a uint> = None;
+    //~^ ERROR pointer has a longer lifetime than the data it references
+}
+
+fn call3<'a, 'b>(a: &'a uint, b: &'b uint) {
+    let y: Paramd<'a> = Paramd { x: a };
+    let z: Option<&'b Paramd<'a>> = None;
+    //~^ ERROR pointer has a longer lifetime than the data it references
+}
+
+fn call4<'a, 'b>(a: &'a uint, b: &'b uint) {
+    let z: Option<&fn(&'a &'b uint)> = None;
+    //~^ ERROR pointer has a longer lifetime than the data it references
+}
+
+
+fn main() {}

src/test/compile-fail/regions-trait-2.rs

@@ -8,6 +8,11 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+// xfail-test #5723
+
+// Test that you cannot escape a borrowed pointer
+// into a trait.
+
 struct ctxt { v: uint }
 
 trait get_ctxt {
@@ -24,8 +29,9 @@ fn make_gc() -> @get_ctxt  {
     let ctxt = ctxt { v: 22u };
     let hc = has_ctxt { c: &ctxt };
     return @hc as @get_ctxt;
+    //^~ ERROR source contains borrowed pointer
 }
 
 fn main() {
-    make_gc().get_ctxt().v; //~ ERROR illegal borrow
+    make_gc().get_ctxt().v;
 }