adding changes for detecing named regions

Author: gaurikholkar

src/librustc/infer/error_reporting/anon_anon_conflict.rs

@@ -39,18 +39,19 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
     // }
     // It will later be extended to trait objects.
     pub fn try_report_anon_anon_conflict(&self, error: &RegionResolutionError<'tcx>) -> bool {
+        debug!("try_report_anon_anon_conflict");
         let (span, sub, sup) = match *error {
             ConcreteFailure(ref origin, sub, sup) => (origin.span(), sub, sup),
             _ => return false, // inapplicable
         };
 
         // Determine whether the sub and sup consist of both anonymous (elided) regions.
         let (ty1, ty2, scope_def_id_1, scope_def_id_2, bregion1, bregion2) = if
-            self.is_suitable_anonymous_region(sup, true).is_some() &&
-            self.is_suitable_anonymous_region(sub, true).is_some() {
+            self.is_suitable_region(sup, true).is_some() &&
+            self.is_suitable_region(sub, true).is_some() {
             if let (Some(anon_reg1), Some(anon_reg2)) =
-                (self.is_suitable_anonymous_region(sup, true),
-                 self.is_suitable_anonymous_region(sub, true)) {
+                (self.is_suitable_region(sup, true),
+                 self.is_suitable_region(sub, true)) {
                 let ((def_id1, br1), (def_id2, br2)) = (anon_reg1, anon_reg2);
                 let found_arg1 = self.find_anon_type(sup, &br1);
                 let found_arg2 = self.find_anon_type(sub, &br2);
@@ -133,6 +134,7 @@ pub struct FindNestedTypeVisitor<'a, 'gcx: 'a + 'tcx, 'tcx: 'a> {
     // The type where the anonymous lifetime appears
     // for e.g. Vec<`&u8`> and <`&u8`>
     pub found_type: Option<&'gcx hir::Ty>,
+    //pub depth: u32,
 }
 
 impl<'a, 'gcx, 'tcx> Visitor<'gcx> for FindNestedTypeVisitor<'a, 'gcx, 'tcx> {
@@ -144,24 +146,52 @@ impl<'a, 'gcx, 'tcx> Visitor<'gcx> for FindNestedTypeVisitor<'a, 'gcx, 'tcx> {
         // Find the index of the anonymous region that was part of the
         // error. We will then search the function parameters for a bound
         // region at the right depth with the same index.
-        let br_index = match self.bound_region {
-            ty::BrAnon(index) => index,
-            _ => return,
-        };
-
         match arg.node {
             hir::TyRptr(ref lifetime, _) => {
                 match self.infcx.tcx.named_region_map.defs.get(&lifetime.id) {
                     // the lifetime of the TyRptr
-                    Some(&rl::Region::LateBoundAnon(debuijn_index, anon_index)) => {
-                        if debuijn_index.depth == 1 && anon_index == br_index {
+                    Some(&rl::Region::LateBoundAnon(debruijn_index, anon_index)) => {
+                        let br_index = match self.bound_region {
+                            ty::BrAnon(index) => index,
+                            _ => return,
+                        };
+                        debug!("LateBoundAnon depth = {:?} anon_index = {:?} br_index={:?}",debruijn_index.depth
+                        ,anon_index,br_index);
+                        if debruijn_index.depth == 1 && anon_index == br_index {
                             self.found_type = Some(arg);
                             return; // we can stop visiting now
                         }
                     }
+                    Some(&rl::Region::EarlyBound(_, id)) => {
+                        let def_id = match self.bound_region {
+                            ty::BrNamed(def_id, _) => def_id,//def_id of hir::Lifetime
+                            _ => return,
+                        };
+                        debug!("EarlyBound self.infcx.tcx.hir.local_def_id(id) ={:?}
+                        def_id={:?}",
+                        self.infcx.tcx.hir.local_def_id(id), def_id);
+                        if self.infcx.tcx.hir.local_def_id(id) == def_id {
+                            self.found_type = Some(arg);
+                            return; // we can stop visiting now
+                        }
+
+                    }
+
+                    Some(&rl::Region::LateBound(debruijn_index, id)) => {
+                       let def_id = match self.bound_region {
+                            ty::BrNamed(def_id, _) => def_id,//def_id of hir::Lifetime
+                            _ => return,
+                        }; 
+                        debug!("LateBound depth = {:?} self.infcx.tcx.hir.local_def_id(id) ={:?}
+                        def_id={:?}",debruijn_index.depth
+                        ,self.infcx.tcx.hir.local_def_id(id), def_id);
+                        if debruijn_index.depth == 1 &&  self.infcx.tcx.hir.local_def_id(id) == def_id{
+                           self.found_type = Some(arg);
+                            return; // we can stop visiting now
+                        }
+                    }
+
                     Some(&rl::Region::Static) |
-                    Some(&rl::Region::EarlyBound(_, _)) |
-                    Some(&rl::Region::LateBound(_, _)) |
                     Some(&rl::Region::Free(_, _)) |
                     None => {
                         debug!("no arg found");

src/librustc/infer/error_reporting/named_anon_conflict.rs

@@ -13,12 +13,14 @@
 use infer::InferCtxt;
 use infer::region_inference::RegionResolutionError::*;
 use infer::region_inference::RegionResolutionError;
+use ty::{self};
 
 impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
     // This method generates the error message for the case when
     // the function arguments consist of a named region and an anonymous
     // region and corresponds to `ConcreteFailure(..)`
     pub fn try_report_named_anon_conflict(&self, error: &RegionResolutionError<'tcx>) -> bool {
+        debug!("try_report_named_anon_conflict");
         let (span, sub, sup) = match *error {
             ConcreteFailure(ref origin, sub, sup) => (origin.span(), sub, sup),
             _ => return false, // inapplicable
@@ -31,21 +33,28 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
         // version new_ty of its type where the anonymous region is replaced
         // with the named one.
         let (named, (arg, new_ty, br, is_first), (scope_def_id, _), anon) = if
-            sub.is_named_region() && self.is_suitable_anonymous_region(sup, false).is_some() {
+            sub.is_named_region() && self.is_suitable_region(sup, false).is_some() {
+            debug!("1.1");
             (sub,
              self.find_arg_with_anonymous_region(sup, sub).unwrap(),
-             self.is_suitable_anonymous_region(sup, false).unwrap(),
+             self.is_suitable_region(sup, false).unwrap(),
              sup)
         } else if
-            sup.is_named_region() && self.is_suitable_anonymous_region(sub, false).is_some() {
+            sup.is_named_region() && self.is_suitable_region(sub, false).is_some() {
+            debug!("1.2");
             (sup,
              self.find_arg_with_anonymous_region(sub, sup).unwrap(),
-             self.is_suitable_anonymous_region(sub, false).unwrap(),
+             self.is_suitable_region(sub, false).unwrap(),
              sub)
         } else {
+            debug!("1.3");
             return false; // inapplicable
         };
 
+        match br 
+        { ty::BrAnon(_) => {},
+         _ => { /* not an anonymous region */ return false; } }
+
         if self.is_return_type_anon(scope_def_id, br) || self.is_self_anon(is_first, scope_def_id) {
             return false;
         } else {

src/librustc/infer/error_reporting/util.rs

@@ -59,6 +59,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
                                     });
                                 if found_anon_region {
                                     let is_first = index == 0;
+                                    debug!("arg={:?}",arg);
                                     Some((arg, new_arg_ty, free_region.bound_region, is_first))
                                 } else {
                                     None
@@ -79,14 +80,13 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
         }
     }
 
-    // This method returns whether the given Region is Anonymous
+    // This method returns whether the given Region is Anonymous or Named
     // and returns the DefId and the BoundRegion corresponding to the given region
-    pub fn is_suitable_anonymous_region(&self,
+    pub fn is_suitable_region(&self,
                                         region: Region<'tcx>,
                                         is_anon_anon: bool)
                                         -> Option<(DefId, ty::BoundRegion)> {
         if let ty::ReFree(ref free_region) = *region {
-            if let ty::BrAnon(..) = free_region.bound_region {
                 let anonymous_region_binding_scope = free_region.scope;
                 let node_id = self.tcx
                     .hir
@@ -119,7 +119,6 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
                     // we target only top-level functions
                 }
                 return Some((anonymous_region_binding_scope, free_region.bound_region));
-            }
         }
         None
     }
@@ -176,7 +175,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
     /// The function returns the nested type corresponding to the anonymous region
     /// for e.g. `&u8` and Vec<`&u8`.
     pub fn find_anon_type(&self, region: Region<'tcx>, br: &ty::BoundRegion) -> Option<(&hir::Ty)> {
-        if let Some(anon_reg) = self.is_suitable_anonymous_region(region, true) {
+        if let Some(anon_reg) = self.is_suitable_region(region, true) {
             let (def_id, _) = anon_reg;
             if let Some(node_id) = self.tcx.hir.as_local_node_id(def_id) {
                 let ret_ty = self.tcx.type_of(def_id);