src/librustc/infer/error_reporting/anon_anon_conflict.rs

   1 // Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 //! Error Reporting for Anonymous Region Lifetime Errors
  12 //! where both the regions are anonymous.
  13 use hir;
  14 use infer::InferCtxt;
  15 use ty::{self, Region};
  16 use infer::region_inference::RegionResolutionError::*;
  17 use infer::region_inference::RegionResolutionError;
  18 use hir::map as hir_map;
  19 use middle::resolve_lifetime as rl;
  20 use hir::intravisit::{self, Visitor, NestedVisitorMap};
  21
  22 impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
  23     // This method prints the error message for lifetime errors when both the concerned regions
  24     // are anonymous.
  25     // Consider a case where we have
  26     // fn foo(x: &mut Vec<&u8>, y: &u8)
  27     //    { x.push(y); }.
  28     // The example gives
  29     // fn foo(x: &mut Vec<&u8>, y: &u8) {
  30     //                    ---      --- these references are declared with different lifetimes...
  31     //            x.push(y);
  32     //            ^ ...but data from `y` flows into `x` here
  33     // It has been extended for the case of structs too.
  34     // Consider the example
  35     // struct Ref<'a> { x: &'a u32 }
  36     // fn foo(mut x: Vec<Ref>, y: Ref) {
  37     //                   ---      --- these structs are declared with different lifetimes...
  38     //               x.push(y);
  39     //               ^ ...but data from `y` flows into `x` here
  40     // }
  41     // It will later be extended to trait objects.
  42     pub fn try_report_anon_anon_conflict(&self, error: &RegionResolutionError<'tcx>) -> bool {
  43         let (span, sub, sup) = match *error {
  44             ConcreteFailure(ref origin, sub, sup) => (origin.span(), sub, sup),
  45             _ => return false, // inapplicable
  46         };
  47
  48         // Determine whether the sub and sup consist of both anonymous (elided) regions.
  49         let anon_reg_sup = or_false!(self.is_suitable_anonymous_region(sup));
  50
  51         let anon_reg_sub = or_false!(self.is_suitable_anonymous_region(sub));
  52         let scope_def_id_sup = anon_reg_sup.def_id;
  53         let bregion_sup = anon_reg_sup.boundregion;
  54         let scope_def_id_sub = anon_reg_sub.def_id;
  55         let bregion_sub = anon_reg_sub.boundregion;
  56
  57         let ty_sup = or_false!(self.find_anon_type(sup, &bregion_sup));
  58
  59         let ty_sub = or_false!(self.find_anon_type(sub, &bregion_sub));
  60
  61         let (main_label, label1, label2) = if let (Some(sup_arg), Some(sub_arg)) =
  62             (self.find_arg_with_anonymous_region(sup, sup),
  63              self.find_arg_with_anonymous_region(sub, sub)) {
  64
  65             let (anon_arg_sup, is_first_sup, anon_arg_sub, is_first_sub) =
  66                 (sup_arg.arg, sup_arg.is_first, sub_arg.arg, sub_arg.is_first);
  67             if self.is_self_anon(is_first_sup, scope_def_id_sup) ||
  68                self.is_self_anon(is_first_sub, scope_def_id_sub) {
  69                 return false;
  70             }
  71
  72             if self.is_return_type_anon(scope_def_id_sup, bregion_sup) ||
  73                self.is_return_type_anon(scope_def_id_sub, bregion_sub) {
  74                 return false;
  75             }
  76
  77             if anon_arg_sup == anon_arg_sub {
  78                 (format!("this type was declared with multiple lifetimes..."),
  79                  format!(" with one lifetime"),
  80                  format!(" into the other"))
  81             } else {
  82                 let span_label_var1 = if let Some(simple_name) = anon_arg_sup.pat.simple_name() {
  83                     format!(" from `{}`", simple_name)
  84                 } else {
  85                     format!("")
  86                 };
  87
  88                 let span_label_var2 = if let Some(simple_name) = anon_arg_sub.pat.simple_name() {
  89                     format!(" into `{}`", simple_name)
  90                 } else {
  91                     format!("")
  92                 };
  93
  94                 let span_label =
  95                     format!("these two types are declared with different lifetimes...",);
  96
  97                 (span_label, span_label_var1, span_label_var2)
  98             }
  99         } else {
 100             return false;
 101         };
 102
 103         struct_span_err!(self.tcx.sess, span, E0623, "lifetime mismatch")
 104             .span_label(ty_sup.span, main_label)
 105             .span_label(ty_sub.span, format!(""))
 106             .span_label(span, format!("...but data{} flows{} here", label1, label2))
 107             .emit();
 108         return true;
 109     }
 110
 111     /// This function calls the `visit_ty` method for the parameters
 112     /// corresponding to the anonymous regions. The `nested_visitor.found_type`
 113     /// contains the anonymous type.
 114     ///
 115     /// # Arguments
 116     /// region - the anonymous region corresponding to the anon_anon conflict
 117     /// br - the bound region corresponding to the above region which is of type `BrAnon(_)`
 118     ///
 119     /// # Example
 120     /// ```
 121     /// fn foo(x: &mut Vec<&u8>, y: &u8)
 122     ///    { x.push(y); }
 123     /// ```
 124     /// The function returns the nested type corresponding to the anonymous region
 125     /// for e.g. `&u8` and Vec<`&u8`.
 126     pub fn find_anon_type(&self, region: Region<'tcx>, br: &ty::BoundRegion) -> Option<&hir::Ty> {
 127         if let Some(anon_reg) = self.is_suitable_anonymous_region(region) {
 128             let def_id = anon_reg.def_id;
 129             if let Some(node_id) = self.tcx.hir.as_local_node_id(def_id) {
 130                 let ret_ty = self.tcx.type_of(def_id);
 131                 if let ty::TyFnDef(_, _) = ret_ty.sty {
 132                     let inputs: &[_] =
 133                         match self.tcx.hir.get(node_id) {
 134                             hir_map::NodeItem(&hir::Item {
 135                                                   node: hir::ItemFn(ref fndecl, ..), ..
 136                                               }) => &fndecl.inputs,
 137                             hir_map::NodeTraitItem(&hir::TraitItem {
 138                                                    node: hir::TraitItemKind::Method(ref fndecl, ..),
 139                                                    ..
 140                                                }) => &fndecl.decl.inputs,
 141                             hir_map::NodeImplItem(&hir::ImplItem {
 142                                                   node: hir::ImplItemKind::Method(ref fndecl, ..),
 143                                                   ..
 144                                               }) => &fndecl.decl.inputs,
 145
 146                             _ => &[],
 147                         };
 148
 149                     return inputs
 150                                .iter()
 151                                .filter_map(|arg| {
 152                                                self.find_component_for_bound_region(&**arg, br)
 153                                            })
 154                                .next();
 155                 }
 156             }
 157         }
 158         None
 159     }
 160
 161     // This method creates a FindNestedTypeVisitor which returns the type corresponding
 162     // to the anonymous region.
 163     fn find_component_for_bound_region(&self,
 164                                        arg: &'gcx hir::Ty,
 165                                        br: &ty::BoundRegion)
 166                                        -> Option<(&'gcx hir::Ty)> {
 167         let mut nested_visitor = FindNestedTypeVisitor {
 168             infcx: &self,
 169             hir_map: &self.tcx.hir,
 170             bound_region: *br,
 171             found_type: None,
 172         };
 173         nested_visitor.visit_ty(arg);
 174         nested_visitor.found_type
 175     }
 176 }
 177
 178 // The FindNestedTypeVisitor captures the corresponding `hir::Ty` of the
 179 // anonymous region. The example above would lead to a conflict between
 180 // the two anonymous lifetimes for &u8 in x and y respectively. This visitor
 181 // would be invoked twice, once for each lifetime, and would
 182 // walk the types like &mut Vec<&u8> and &u8 looking for the HIR
 183 // where that lifetime appears. This allows us to highlight the
 184 // specific part of the type in the error message.
 185 struct FindNestedTypeVisitor<'a, 'gcx: 'a + 'tcx, 'tcx: 'a> {
 186     infcx: &'a InferCtxt<'a, 'gcx, 'tcx>,
 187     hir_map: &'a hir::map::Map<'gcx>,
 188     // The bound_region corresponding to the Refree(freeregion)
 189     // associated with the anonymous region we are looking for.
 190     bound_region: ty::BoundRegion,
 191     // The type where the anonymous lifetime appears
 192     // for e.g. Vec<`&u8`> and <`&u8`>
 193     found_type: Option<&'gcx hir::Ty>,
 194 }
 195
 196 impl<'a, 'gcx, 'tcx> Visitor<'gcx> for FindNestedTypeVisitor<'a, 'gcx, 'tcx> {
 197     fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'gcx> {
 198         NestedVisitorMap::OnlyBodies(&self.hir_map)
 199     }
 200
 201     fn visit_ty(&mut self, arg: &'gcx hir::Ty) {
 202         // Find the index of the anonymous region that was part of the
 203         // error. We will then search the function parameters for a bound
 204         // region at the right depth with the same index.
 205         let br_index = match self.bound_region {
 206             ty::BrAnon(index) => index,
 207             _ => return,
 208         };
 209
 210         match arg.node {
 211             hir::TyRptr(ref lifetime, _) => {
 212                 match self.infcx.tcx.named_region_map.defs.get(&lifetime.id) {
 213                     // the lifetime of the TyRptr
 214                     Some(&rl::Region::LateBoundAnon(debruijn_index, anon_index)) => {
 215                         if debruijn_index.depth == 1 && anon_index == br_index {
 216                             self.found_type = Some(arg);
 217                             return; // we can stop visiting now
 218                         }
 219                     }
 220                     Some(&rl::Region::Static) |
 221                     Some(&rl::Region::EarlyBound(_, _)) |
 222                     Some(&rl::Region::LateBound(_, _)) |
 223                     Some(&rl::Region::Free(_, _)) |
 224                     None => {
 225                         debug!("no arg found");
 226                     }
 227                 }
 228             }
 229             // Checks if it is of type `hir::TyPath` which corresponds to a struct.
 230             hir::TyPath(_) => {
 231                 let subvisitor = &mut TyPathVisitor {
 232                                           infcx: self.infcx,
 233                                           found_it: false,
 234                                           bound_region: self.bound_region,
 235                                           hir_map: self.hir_map,
 236                                       };
 237                 intravisit::walk_ty(subvisitor, arg); // call walk_ty; as visit_ty is empty,
 238                 // this will visit only outermost type
 239                 if subvisitor.found_it {
 240                     self.found_type = Some(arg);
 241                 }
 242             }
 243             _ => {}
 244         }
 245         // walk the embedded contents: e.g., if we are visiting `Vec<&Foo>`,
 246         // go on to visit `&Foo`
 247         intravisit::walk_ty(self, arg);
 248     }
 249 }
 250
 251 // The visitor captures the corresponding `hir::Ty` of the anonymous region
 252 // in the case of structs ie. `hir::TyPath`.
 253 // This visitor would be invoked for each lifetime corresponding to a struct,
 254 // and would walk the types like Vec<Ref> in the above example and Ref looking for the HIR
 255 // where that lifetime appears. This allows us to highlight the
 256 // specific part of the type in the error message.
 257 struct TyPathVisitor<'a, 'gcx: 'a + 'tcx, 'tcx: 'a> {
 258     infcx: &'a InferCtxt<'a, 'gcx, 'tcx>,
 259     hir_map: &'a hir::map::Map<'gcx>,
 260     found_it: bool,
 261     bound_region: ty::BoundRegion,
 262 }
 263
 264 impl<'a, 'gcx, 'tcx> Visitor<'gcx> for TyPathVisitor<'a, 'gcx, 'tcx> {
 265     fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'gcx> {
 266         NestedVisitorMap::OnlyBodies(&self.hir_map)
 267     }
 268
 269     fn visit_lifetime(&mut self, lifetime: &hir::Lifetime) {
 270         let br_index = match self.bound_region {
 271             ty::BrAnon(index) => index,
 272             _ => return,
 273         };
 274
 275         match self.infcx.tcx.named_region_map.defs.get(&lifetime.id) {
 276             // the lifetime of the TyPath!
 277             Some(&rl::Region::LateBoundAnon(debruijn_index, anon_index)) => {
 278                 if debruijn_index.depth == 1 && anon_index == br_index {
 279                     self.found_it = true;
 280                 }
 281             }
 282             Some(&rl::Region::Static) |
 283             Some(&rl::Region::EarlyBound(_, _)) |
 284             Some(&rl::Region::LateBound(_, _)) |
 285             Some(&rl::Region::Free(_, _)) |
 286             None => {
 287                 debug!("no arg found");
 288             }
 289         }
 290     }
 291
 292     fn visit_ty(&mut self, arg: &'gcx hir::Ty) {
 293         // ignore nested types
 294         //
 295         // If you have a type like `Foo<'a, &Ty>` we
 296         // are only interested in the immediate lifetimes ('a).
 297         //
 298         // Making `visit_ty` empty will ignore the `&Ty` embedded
 299         // inside, it will get reached by the outer visitor.
 300         debug!("`Ty` corresponding to a struct is {:?}", arg);
 301     }
 302 }