Adding changes to track anonymous region in self

Author: gaurikholkar

src/librustc/infer/error_reporting/named_anon_conflict.rs

@@ -27,19 +27,21 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
     // Consider the example `fn foo<'a>(x: &'a i32, y: &i32) -> &'a i32`
     // Here, we would return the hir::Arg for y, we return the type &'a
     // i32, which is the type of y but with the anonymous region replaced
-    // with 'a and also the corresponding bound region.
-    fn find_arg_with_anonymous_region(&self,
-                                      anon_region: Region<'tcx>,
-                                      named_region: Region<'tcx>)
-                                      -> Option<(&hir::Arg, ty::Ty<'tcx>, ty::BoundRegion)> {
+    // with 'a, the corresponding bound region and is_first which is true if
+    // the hir::Arg is the first argument in the function declaration.
+    fn find_arg_with_anonymous_region
+        (&self,
+         anon_region: Region<'tcx>,
+         named_region: Region<'tcx>)
+         -> Option<(&hir::Arg, ty::Ty<'tcx>, ty::BoundRegion, bool)> {
 
         match *anon_region {
             ty::ReFree(ref free_region) => {
 
                 let id = free_region.scope;
                 let node_id = self.tcx.hir.as_local_node_id(id).unwrap();
                 let body_id = self.tcx.hir.maybe_body_owned_by(node_id).unwrap();
-
+                let mut is_first = false;
                 let body = self.tcx.hir.body(body_id);
                 body.arguments
                     .iter()
@@ -56,7 +58,13 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
                                                           r
                                                       });
                                     if found_anon_region {
-                                        return Some((arg, new_arg_ty, free_region.bound_region));
+                                        if body.arguments.iter().nth(0) == Some(&arg) {
+                                            is_first = true;
+                                        }
+                                        return Some((arg,
+                                                     new_arg_ty,
+                                                     free_region.bound_region,
+                                                     is_first));
                                     } else {
                                         None
                                     }
@@ -86,19 +94,19 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
         // only introduced anonymous regions in parameters) as well as a
         // version new_ty of its type where the anonymous region is replaced
         // with the named one.
-        let (named, (arg, new_ty, br), scope_def_id) =
-            if self.is_named_region(sub) && self.is_suitable_anonymous_region(sup).is_some() {
-                (sub,
-                 self.find_arg_with_anonymous_region(sup, sub).unwrap(),
-                 self.is_suitable_anonymous_region(sup).unwrap())
-            } else if self.is_named_region(sup) &&
-                      self.is_suitable_anonymous_region(sub).is_some() {
-                (sup,
-                 self.find_arg_with_anonymous_region(sub, sup).unwrap(),
-                 self.is_suitable_anonymous_region(sub).unwrap())
-            } else {
-                return false; // inapplicable
-            };
+        let (named, (arg, new_ty, br, is_first), scope_def_id) = if
+            self.is_named_region(sub) && self.is_suitable_anonymous_region(sup).is_some() {
+            (sub,
+             self.find_arg_with_anonymous_region(sup, sub).unwrap(),
+             self.is_suitable_anonymous_region(sup).unwrap())
+        } else if
+            self.is_named_region(sup) && self.is_suitable_anonymous_region(sub).is_some() {
+            (sup,
+             self.find_arg_with_anonymous_region(sub, sup).unwrap(),
+             self.is_suitable_anonymous_region(sub).unwrap())
+        } else {
+            return false; // inapplicable
+        };
 
         // Here, we check for the case where the anonymous region
         // is in the return type.
@@ -116,6 +124,18 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
             _ => {}
         }
 
+        // Here we check for the case where anonymous region
+        // corresponds to self and if yes, we display E0312.
+        // FIXME(#42700) - Need to format self properly to
+        // enable E0611 for it.
+        if is_first &&
+           self.tcx
+               .opt_associated_item(scope_def_id)
+               .map(|i| i.method_has_self_argument)
+               .unwrap_or(false) {
+            return false;
+        }
+
         if let Some(simple_name) = arg.pat.simple_name() {
             struct_span_err!(self.tcx.sess,
                              span,

src/test/ui/lifetime-errors/ex1-return-one-existing-name-if-else-using-impl-3.stderr

@@ -3,7 +3,7 @@ error[E0611]: explicit lifetime required in the type of `x`
    |
 16 |   fn foo<'a>(&'a self, x: &i32) -> &i32 {
    |                        - consider changing the type of `x` to `&'a i32`
-17 |    
+17 | 
 18 |     if true { &self.field } else { x }
    |                                    ^ lifetime `'a` required
 

src/test/ui/lifetime-errors/ex1-return-one-existing-name-return-type-is-anon.stderr

@@ -8,7 +8,7 @@ note: ...the reference is valid for the anonymous lifetime #1 defined on the met
   --> $DIR/ex1-return-one-existing-name-return-type-is-anon.rs:16:3
    |
 16 | /   fn foo<'a>(&self, x: &'a i32) -> &i32 {
-17 | |    
+17 | |
 18 | |     x
 19 | |
 20 | |   }
@@ -17,7 +17,7 @@ note: ...but the borrowed content is only valid for the lifetime 'a as defined o
   --> $DIR/ex1-return-one-existing-name-return-type-is-anon.rs:16:3
    |
 16 | /   fn foo<'a>(&self, x: &'a i32) -> &i32 {
-17 | |    
+17 | |
 18 | |     x
 19 | |
 20 | |   }

src/test/ui/lifetime-errors/ex1-return-one-existing-name-self-is-anon.rs

@@ -0,0 +1,23 @@
+// Copyright 2016 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.
+
+struct Foo {
+    field: i32,
+}
+
+impl Foo {
+    fn foo<'a>(&self, x: &'a Foo) -> &'a Foo {
+
+        if true { x } else { self }
+
+    }
+}
+
+fn main() {}

src/test/ui/lifetime-errors/ex1-return-one-existing-name-self-is-anon.stderr

@@ -0,0 +1,27 @@
+error[E0312]: lifetime of reference outlives lifetime of borrowed content...
+  --> $DIR/ex1-return-one-existing-name-self-is-anon.rs:18:30
+   |
+18 |         if true { x } else { self }
+   |                              ^^^^
+   |
+note: ...the reference is valid for the lifetime 'a as defined on the method body at 16:5...
+  --> $DIR/ex1-return-one-existing-name-self-is-anon.rs:16:5
+   |
+16 | /     fn foo<'a>(&self, x: &'a Foo) -> &'a Foo {
+17 | |
+18 | |         if true { x } else { self }
+19 | |
+20 | |     }
+   | |_____^
+note: ...but the borrowed content is only valid for the anonymous lifetime #1 defined on the method body at 16:5
+  --> $DIR/ex1-return-one-existing-name-self-is-anon.rs:16:5
+   |
+16 | /     fn foo<'a>(&self, x: &'a Foo) -> &'a Foo {
+17 | |
+18 | |         if true { x } else { self }
+19 | |
+20 | |     }
+   | |_____^
+
+error: aborting due to previous error(s)
+