src/librustc/middle/resolve_lifetime.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 //! Name resolution for lifetimes.
  12 //!
  13 //! Name resolution for lifetimes follows MUCH simpler rules than the
  14 //! full resolve. For example, lifetime names are never exported or
  15 //! used between functions, and they operate in a purely top-down
  16 //! way. Therefore we break lifetime name resolution into a separate pass.
  17
  18 pub use self::DefRegion::*;
  19 use self::ScopeChain::*;
  20
  21 use dep_graph::DepNode;
  22 use hir::map::Map;
  23 use session::Session;
  24 use hir::def::Def;
  25 use hir::def_id::DefId;
  26 use middle::region;
  27 use ty;
  28 use std::mem::replace;
  29 use syntax::ast;
  30 use syntax::symbol::keywords;
  31 use syntax_pos::Span;
  32 use util::nodemap::NodeMap;
  33
  34 use rustc_data_structures::fx::FxHashSet;
  35 use hir;
  36 use hir::intravisit::{self, Visitor, FnKind, NestedVisitorMap};
  37
  38 #[derive(Clone, Copy, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable, Debug)]
  39 pub enum DefRegion {
  40     DefStaticRegion,
  41     DefEarlyBoundRegion(/* index */ u32,
  42                         /* lifetime decl */ ast::NodeId),
  43     DefLateBoundRegion(ty::DebruijnIndex,
  44                        /* lifetime decl */ ast::NodeId),
  45     DefFreeRegion(region::CallSiteScopeData,
  46                   /* lifetime decl */ ast::NodeId),
  47 }
  48
  49 // Maps the id of each lifetime reference to the lifetime decl
  50 // that it corresponds to.
  51 pub struct NamedRegionMap {
  52     // maps from every use of a named (not anonymous) lifetime to a
  53     // `DefRegion` describing how that region is bound
  54     pub defs: NodeMap<DefRegion>,
  55
  56     // the set of lifetime def ids that are late-bound; late-bound ids
  57     // are named regions appearing in fn arguments that do not appear
  58     // in where-clauses
  59     pub late_bound: NodeMap<ty::Issue32330>,
  60 }
  61
  62 struct LifetimeContext<'a, 'tcx: 'a> {
  63     sess: &'a Session,
  64     hir_map: &'a Map<'tcx>,
  65     map: &'a mut NamedRegionMap,
  66     scope: Scope<'a>,
  67     // Deep breath. Our representation for poly trait refs contains a single
  68     // binder and thus we only allow a single level of quantification. However,
  69     // the syntax of Rust permits quantification in two places, e.g., `T: for <'a> Foo<'a>`
  70     // and `for <'a, 'b> &'b T: Foo<'a>`. In order to get the de Bruijn indices
  71     // correct when representing these constraints, we should only introduce one
  72     // scope. However, we want to support both locations for the quantifier and
  73     // during lifetime resolution we want precise information (so we can't
  74     // desugar in an earlier phase).
  75
  76     // SO, if we encounter a quantifier at the outer scope, we set
  77     // trait_ref_hack to true (and introduce a scope), and then if we encounter
  78     // a quantifier at the inner scope, we error. If trait_ref_hack is false,
  79     // then we introduce the scope at the inner quantifier.
  80
  81     // I'm sorry.
  82     trait_ref_hack: bool,
  83
  84     // List of labels in the function/method currently under analysis.
  85     labels_in_fn: Vec<(ast::Name, Span)>,
  86 }
  87
  88 #[derive(PartialEq, Debug)]
  89 enum ScopeChain<'a> {
  90     /// EarlyScope(['a, 'b, ...], start, s) extends s with early-bound
  91     /// lifetimes, with consecutive parameter indices from `start`.
  92     /// That is, 'a has index `start`, 'b has index `start + 1`, etc.
  93     /// Indices before `start` correspond to other generic parameters
  94     /// of a parent item (trait/impl of a method), or `Self` in traits.
  95     EarlyScope(&'a [hir::LifetimeDef], u32, Scope<'a>),
  96     /// LateScope(['a, 'b, ...], s) extends s with late-bound
  97     /// lifetimes introduced by the declaration binder_id.
  98     LateScope(&'a [hir::LifetimeDef], Scope<'a>),
  99
 100     /// lifetimes introduced by a fn are scoped to the call-site for that fn.
 101     FnScope { fn_id: ast::NodeId, body_id: ast::NodeId, s: Scope<'a> },
 102     RootScope
 103 }
 104
 105 type Scope<'a> = &'a ScopeChain<'a>;
 106
 107 static ROOT_SCOPE: ScopeChain<'static> = RootScope;
 108
 109 pub fn krate(sess: &Session,
 110              hir_map: &Map)
 111              -> Result<NamedRegionMap, usize> {
 112     let _task = hir_map.dep_graph.in_task(DepNode::ResolveLifetimes);
 113     let krate = hir_map.krate();
 114     let mut map = NamedRegionMap {
 115         defs: NodeMap(),
 116         late_bound: NodeMap(),
 117     };
 118     sess.track_errors(|| {
 119         intravisit::walk_crate(&mut LifetimeContext {
 120             sess: sess,
 121             hir_map: hir_map,
 122             map: &mut map,
 123             scope: &ROOT_SCOPE,
 124             trait_ref_hack: false,
 125             labels_in_fn: vec![],
 126         }, krate);
 127     })?;
 128     Ok(map)
 129 }
 130
 131 impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> {
 132     // Override the nested functions -- lifetimes follow lexical scope,
 133     // so it's convenient to walk the tree in lexical order.
 134     fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> {
 135         NestedVisitorMap::All(&self.hir_map)
 136     }
 137
 138     fn visit_item(&mut self, item: &'tcx hir::Item) {
 139         // Save labels for nested items.
 140         let saved_labels_in_fn = replace(&mut self.labels_in_fn, vec![]);
 141
 142         // Items always introduce a new root scope
 143         self.with(RootScope, |_, this| {
 144             match item.node {
 145                 hir::ItemFn(..) => {
 146                     // Fn lifetimes get added in visit_fn below:
 147                     intravisit::walk_item(this, item);
 148                 }
 149                 hir::ItemExternCrate(_) |
 150                 hir::ItemUse(..) |
 151                 hir::ItemMod(..) |
 152                 hir::ItemDefaultImpl(..) |
 153                 hir::ItemForeignMod(..) |
 154                 hir::ItemStatic(..) |
 155                 hir::ItemConst(..) => {
 156                     // These sorts of items have no lifetime parameters at all.
 157                     intravisit::walk_item(this, item);
 158                 }
 159                 hir::ItemTy(_, ref generics) |
 160                 hir::ItemEnum(_, ref generics) |
 161                 hir::ItemStruct(_, ref generics) |
 162                 hir::ItemUnion(_, ref generics) |
 163                 hir::ItemTrait(_, ref generics, ..) |
 164                 hir::ItemImpl(_, _, ref generics, ..) => {
 165                     // These kinds of items have only early bound lifetime parameters.
 166                     let lifetimes = &generics.lifetimes;
 167                     let start = if let hir::ItemTrait(..) = item.node {
 168                         1 // Self comes before lifetimes
 169                     } else {
 170                         0
 171                     };
 172                     this.with(EarlyScope(lifetimes, start, &ROOT_SCOPE), |old_scope, this| {
 173                         this.check_lifetime_defs(old_scope, lifetimes);
 174                         intravisit::walk_item(this, item);
 175                     });
 176                 }
 177             }
 178         });
 179
 180         // Done traversing the item; remove any labels it created
 181         self.labels_in_fn = saved_labels_in_fn;
 182     }
 183
 184     fn visit_foreign_item(&mut self, item: &'tcx hir::ForeignItem) {
 185         // Items save/restore the set of labels. This way inner items
 186         // can freely reuse names, be they loop labels or lifetimes.
 187         let saved = replace(&mut self.labels_in_fn, vec![]);
 188
 189         // Items always introduce a new root scope
 190         self.with(RootScope, |_, this| {
 191             match item.node {
 192                 hir::ForeignItemFn(ref decl, _, ref generics) => {
 193                     this.visit_early_late(item.id, decl, generics, |this| {
 194                         intravisit::walk_foreign_item(this, item);
 195                     })
 196                 }
 197                 hir::ForeignItemStatic(..) => {
 198                     intravisit::walk_foreign_item(this, item);
 199                 }
 200             }
 201         });
 202
 203         // Done traversing the item; restore saved set of labels.
 204         replace(&mut self.labels_in_fn, saved);
 205     }
 206
 207     fn visit_fn(&mut self, fk: FnKind<'tcx>, decl: &'tcx hir::FnDecl,
 208                 b: hir::BodyId, s: Span, fn_id: ast::NodeId) {
 209         match fk {
 210             FnKind::ItemFn(_, generics, ..) => {
 211                 self.visit_early_late(fn_id,decl, generics, |this| {
 212                     this.add_scope_and_walk_fn(fk, decl, b, s, fn_id)
 213                 })
 214             }
 215             FnKind::Method(_, sig, ..) => {
 216                 self.visit_early_late(
 217                     fn_id,
 218                     decl,
 219                     &sig.generics,
 220                     |this| this.add_scope_and_walk_fn(fk, decl, b, s, fn_id));
 221             }
 222             FnKind::Closure(_) => {
 223                 // Closures have their own set of labels, save labels just
 224                 // like for foreign items above.
 225                 let saved = replace(&mut self.labels_in_fn, vec![]);
 226                 let result = self.add_scope_and_walk_fn(fk, decl, b, s, fn_id);
 227                 replace(&mut self.labels_in_fn, saved);
 228                 result
 229             }
 230         }
 231     }
 232
 233     fn visit_ty(&mut self, ty: &'tcx hir::Ty) {
 234         match ty.node {
 235             hir::TyBareFn(ref c) => {
 236                 self.with(LateScope(&c.lifetimes, self.scope), |old_scope, this| {
 237                     // a bare fn has no bounds, so everything
 238                     // contained within is scoped within its binder.
 239                     this.check_lifetime_defs(old_scope, &c.lifetimes);
 240                     intravisit::walk_ty(this, ty);
 241                 });
 242             }
 243             hir::TyPath(hir::QPath::Resolved(None, ref path)) => {
 244                 // if this path references a trait, then this will resolve to
 245                 // a trait ref, which introduces a binding scope.
 246                 match path.def {
 247                     Def::Trait(..) => {
 248                         self.with(LateScope(&[], self.scope), |_, this| {
 249                             this.visit_path(path, ty.id);
 250                         });
 251                     }
 252                     _ => {
 253                         intravisit::walk_ty(self, ty);
 254                     }
 255                 }
 256             }
 257             _ => {
 258                 intravisit::walk_ty(self, ty)
 259             }
 260         }
 261     }
 262
 263     fn visit_trait_item(&mut self, trait_item: &'tcx hir::TraitItem) {
 264         // We reset the labels on every trait item, so that different
 265         // methods in an impl can reuse label names.
 266         let saved = replace(&mut self.labels_in_fn, vec![]);
 267
 268         if let hir::TraitItemKind::Method(ref sig, hir::TraitMethod::Required(_)) =
 269                 trait_item.node {
 270             self.visit_early_late(
 271                 trait_item.id,
 272                 &sig.decl, &sig.generics,
 273                 |this| intravisit::walk_trait_item(this, trait_item))
 274         } else {
 275             intravisit::walk_trait_item(self, trait_item);
 276         }
 277
 278         replace(&mut self.labels_in_fn, saved);
 279     }
 280
 281     fn visit_lifetime(&mut self, lifetime_ref: &'tcx hir::Lifetime) {
 282         if lifetime_ref.name == keywords::StaticLifetime.name() {
 283             self.insert_lifetime(lifetime_ref, DefStaticRegion);
 284             return;
 285         }
 286         self.resolve_lifetime_ref(lifetime_ref);
 287     }
 288
 289     fn visit_generics(&mut self, generics: &'tcx hir::Generics) {
 290         for ty_param in generics.ty_params.iter() {
 291             walk_list!(self, visit_ty_param_bound, &ty_param.bounds);
 292             if let Some(ref ty) = ty_param.default {
 293                 self.visit_ty(&ty);
 294             }
 295         }
 296         for predicate in &generics.where_clause.predicates {
 297             match predicate {
 298                 &hir::WherePredicate::BoundPredicate(hir::WhereBoundPredicate{ ref bounded_ty,
 299                                                                                ref bounds,
 300                                                                                ref bound_lifetimes,
 301                                                                                .. }) => {
 302                     if !bound_lifetimes.is_empty() {
 303                         self.trait_ref_hack = true;
 304                         let result = self.with(LateScope(bound_lifetimes, self.scope),
 305                                                |old_scope, this| {
 306                             this.check_lifetime_defs(old_scope, bound_lifetimes);
 307                             this.visit_ty(&bounded_ty);
 308                             walk_list!(this, visit_ty_param_bound, bounds);
 309                         });
 310                         self.trait_ref_hack = false;
 311                         result
 312                     } else {
 313                         self.visit_ty(&bounded_ty);
 314                         walk_list!(self, visit_ty_param_bound, bounds);
 315                     }
 316                 }
 317                 &hir::WherePredicate::RegionPredicate(hir::WhereRegionPredicate{ref lifetime,
 318                                                                                 ref bounds,
 319                                                                                 .. }) => {
 320
 321                     self.visit_lifetime(lifetime);
 322                     for bound in bounds {
 323                         self.visit_lifetime(bound);
 324                     }
 325                 }
 326                 &hir::WherePredicate::EqPredicate(hir::WhereEqPredicate{ id,
 327                                                                          ref path,
 328                                                                          ref ty,
 329                                                                          .. }) => {
 330                     self.visit_path(path, id);
 331                     self.visit_ty(&ty);
 332                 }
 333             }
 334         }
 335     }
 336
 337     fn visit_poly_trait_ref(&mut self,
 338                             trait_ref: &'tcx hir::PolyTraitRef,
 339                             _modifier: &'tcx hir::TraitBoundModifier) {
 340         debug!("visit_poly_trait_ref trait_ref={:?}", trait_ref);
 341
 342         if !self.trait_ref_hack || !trait_ref.bound_lifetimes.is_empty() {
 343             if self.trait_ref_hack {
 344                 span_err!(self.sess, trait_ref.span, E0316,
 345                           "nested quantification of lifetimes");
 346             }
 347             self.with(LateScope(&trait_ref.bound_lifetimes, self.scope), |old_scope, this| {
 348                 this.check_lifetime_defs(old_scope, &trait_ref.bound_lifetimes);
 349                 for lifetime in &trait_ref.bound_lifetimes {
 350                     this.visit_lifetime_def(lifetime);
 351                 }
 352                 intravisit::walk_path(this, &trait_ref.trait_ref.path)
 353             })
 354         } else {
 355             self.visit_trait_ref(&trait_ref.trait_ref)
 356         }
 357     }
 358 }
 359
 360 #[derive(Copy, Clone, PartialEq)]
 361 enum ShadowKind { Label, Lifetime }
 362 struct Original { kind: ShadowKind, span: Span }
 363 struct Shadower { kind: ShadowKind, span: Span }
 364
 365 fn original_label(span: Span) -> Original {
 366     Original { kind: ShadowKind::Label, span: span }
 367 }
 368 fn shadower_label(span: Span) -> Shadower {
 369     Shadower { kind: ShadowKind::Label, span: span }
 370 }
 371 fn original_lifetime(l: &hir::Lifetime) -> Original {
 372     Original { kind: ShadowKind::Lifetime, span: l.span }
 373 }
 374 fn shadower_lifetime(l: &hir::Lifetime) -> Shadower {
 375     Shadower { kind: ShadowKind::Lifetime, span: l.span }
 376 }
 377
 378 impl ShadowKind {
 379     fn desc(&self) -> &'static str {
 380         match *self {
 381             ShadowKind::Label => "label",
 382             ShadowKind::Lifetime => "lifetime",
 383         }
 384     }
 385 }
 386
 387 fn signal_shadowing_problem(sess: &Session, name: ast::Name, orig: Original, shadower: Shadower) {
 388     let mut err = if let (ShadowKind::Lifetime, ShadowKind::Lifetime) = (orig.kind, shadower.kind) {
 389         // lifetime/lifetime shadowing is an error
 390         struct_span_err!(sess, shadower.span, E0496,
 391                          "{} name `{}` shadows a \
 392                           {} name that is already in scope",
 393                          shadower.kind.desc(), name, orig.kind.desc())
 394     } else {
 395         // shadowing involving a label is only a warning, due to issues with
 396         // labels and lifetimes not being macro-hygienic.
 397         sess.struct_span_warn(shadower.span,
 398                               &format!("{} name `{}` shadows a \
 399                                         {} name that is already in scope",
 400                                        shadower.kind.desc(), name, orig.kind.desc()))
 401     };
 402     err.span_label(orig.span, &"first declared here");
 403     err.span_label(shadower.span,
 404                    &format!("lifetime {} already in scope", name));
 405     err.emit();
 406 }
 407
 408 // Adds all labels in `b` to `ctxt.labels_in_fn`, signalling a warning
 409 // if one of the label shadows a lifetime or another label.
 410 fn extract_labels(ctxt: &mut LifetimeContext, b: hir::BodyId) {
 411     struct GatherLabels<'a> {
 412         sess: &'a Session,
 413         scope: Scope<'a>,
 414         labels_in_fn: &'a mut Vec<(ast::Name, Span)>,
 415     }
 416
 417     let mut gather = GatherLabels {
 418         sess: ctxt.sess,
 419         scope: ctxt.scope,
 420         labels_in_fn: &mut ctxt.labels_in_fn,
 421     };
 422     gather.visit_body(ctxt.hir_map.body(b));
 423     return;
 424
 425     impl<'v, 'a> Visitor<'v> for GatherLabels<'a> {
 426         fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'v> {
 427             NestedVisitorMap::None
 428         }
 429
 430         fn visit_expr(&mut self, ex: &'v hir::Expr) {
 431             // do not recurse into closures defined in the block
 432             // since they are treated as separate fns from the POV of
 433             // labels_in_fn
 434             if let hir::ExprClosure(..) = ex.node {
 435                 return
 436             }
 437             if let Some((label, label_span)) = expression_label(ex) {
 438                 for &(prior, prior_span) in &self.labels_in_fn[..] {
 439                     // FIXME (#24278): non-hygienic comparison
 440                     if label == prior {
 441                         signal_shadowing_problem(self.sess,
 442                                                  label,
 443                                                  original_label(prior_span),
 444                                                  shadower_label(label_span));
 445                     }
 446                 }
 447
 448                 check_if_label_shadows_lifetime(self.sess,
 449                                                 self.scope,
 450                                                 label,
 451                                                 label_span);
 452
 453                 self.labels_in_fn.push((label, label_span));
 454             }
 455             intravisit::walk_expr(self, ex)
 456         }
 457
 458         fn visit_item(&mut self, _: &hir::Item) {
 459             // do not recurse into items defined in the block
 460         }
 461     }
 462
 463     fn expression_label(ex: &hir::Expr) -> Option<(ast::Name, Span)> {
 464         match ex.node {
 465             hir::ExprWhile(.., Some(label)) |
 466             hir::ExprLoop(_, Some(label), _) => Some((label.node, label.span)),
 467             _ => None,
 468         }
 469     }
 470
 471     fn check_if_label_shadows_lifetime<'a>(sess: &'a Session,
 472                                            mut scope: Scope<'a>,
 473                                            label: ast::Name,
 474                                            label_span: Span) {
 475         loop {
 476             match *scope {
 477                 FnScope { s, .. } => { scope = s; }
 478                 RootScope => { return; }
 479
 480                 EarlyScope(lifetimes, _, s) |
 481                 LateScope(lifetimes, s) => {
 482                     for lifetime_def in lifetimes {
 483                         // FIXME (#24278): non-hygienic comparison
 484                         if label == lifetime_def.lifetime.name {
 485                             signal_shadowing_problem(
 486                                 sess,
 487                                 label,
 488                                 original_lifetime(&lifetime_def.lifetime),
 489                                 shadower_label(label_span));
 490                             return;
 491                         }
 492                     }
 493                     scope = s;
 494                 }
 495             }
 496         }
 497     }
 498 }
 499
 500 impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
 501     fn add_scope_and_walk_fn(&mut self,
 502                              fk: FnKind<'tcx>,
 503                              fd: &'tcx hir::FnDecl,
 504                              fb: hir::BodyId,
 505                              _span: Span,
 506                              fn_id: ast::NodeId) {
 507         match fk {
 508             FnKind::ItemFn(_, generics, ..) => {
 509                 intravisit::walk_fn_decl(self, fd);
 510                 self.visit_generics(generics);
 511             }
 512             FnKind::Method(_, sig, ..) => {
 513                 intravisit::walk_fn_decl(self, fd);
 514                 self.visit_generics(&sig.generics);
 515             }
 516             FnKind::Closure(_) => {
 517                 intravisit::walk_fn_decl(self, fd);
 518             }
 519         }
 520
 521         // After inpsecting the decl, add all labels from the body to
 522         // `self.labels_in_fn`.
 523         extract_labels(self, fb);
 524
 525         self.with(FnScope { fn_id: fn_id, body_id: fb.node_id, s: self.scope },
 526                   |_old_scope, this| this.visit_nested_body(fb))
 527     }
 528
 529     // FIXME(#37666) this works around a limitation in the region inferencer
 530     fn hack<F>(&mut self, f: F) where
 531         F: for<'b> FnOnce(&mut LifetimeContext<'b, 'tcx>),
 532     {
 533         f(self)
 534     }
 535
 536     fn with<F>(&mut self, wrap_scope: ScopeChain, f: F) where
 537         F: for<'b> FnOnce(Scope, &mut LifetimeContext<'b, 'tcx>),
 538     {
 539         let LifetimeContext {sess, hir_map, ref mut map, ..} = *self;
 540         let mut this = LifetimeContext {
 541             sess: sess,
 542             hir_map: hir_map,
 543             map: *map,
 544             scope: &wrap_scope,
 545             trait_ref_hack: self.trait_ref_hack,
 546             labels_in_fn: self.labels_in_fn.clone(),
 547         };
 548         debug!("entering scope {:?}", this.scope);
 549         f(self.scope, &mut this);
 550         debug!("exiting scope {:?}", this.scope);
 551     }
 552
 553     /// Visits self by adding a scope and handling recursive walk over the contents with `walk`.
 554     ///
 555     /// Handles visiting fns and methods. These are a bit complicated because we must distinguish
 556     /// early- vs late-bound lifetime parameters. We do this by checking which lifetimes appear
 557     /// within type bounds; those are early bound lifetimes, and the rest are late bound.
 558     ///
 559     /// For example:
 560     ///
 561     ///    fn foo<'a,'b,'c,T:Trait<'b>>(...)
 562     ///
 563     /// Here `'a` and `'c` are late bound but `'b` is early bound. Note that early- and late-bound
 564     /// lifetimes may be interspersed together.
 565     ///
 566     /// If early bound lifetimes are present, we separate them into their own list (and likewise
 567     /// for late bound). They will be numbered sequentially, starting from the lowest index that is
 568     /// already in scope (for a fn item, that will be 0, but for a method it might not be). Late
 569     /// bound lifetimes are resolved by name and associated with a binder id (`binder_id`), so the
 570     /// ordering is not important there.
 571     fn visit_early_late<F>(&mut self,
 572                            fn_id: ast::NodeId,
 573                            decl: &'tcx hir::FnDecl,
 574                            generics: &'tcx hir::Generics,
 575                            walk: F) where
 576         F: for<'b, 'c> FnOnce(&'b mut LifetimeContext<'c, 'tcx>),
 577     {
 578         let fn_def_id = self.hir_map.local_def_id(fn_id);
 579         insert_late_bound_lifetimes(self.map,
 580                                     fn_def_id,
 581                                     decl,
 582                                     generics);
 583
 584         let (late, early): (Vec<_>, _) =
 585             generics.lifetimes
 586                     .iter()
 587                     .cloned()
 588                     .partition(|l| self.map.late_bound.contains_key(&l.lifetime.id));
 589
 590         // Find the start of nested early scopes, e.g. in methods.
 591         let mut start = 0;
 592         if let EarlyScope(..) = *self.scope {
 593             let parent = self.hir_map.expect_item(self.hir_map.get_parent(fn_id));
 594             if let hir::ItemTrait(..) = parent.node {
 595                 start += 1; // Self comes first.
 596             }
 597             match parent.node {
 598                 hir::ItemTrait(_, ref generics, ..) |
 599                 hir::ItemImpl(_, _, ref generics, ..) => {
 600                     start += generics.lifetimes.len() + generics.ty_params.len();
 601                 }
 602                 _ => {}
 603             }
 604         }
 605
 606         self.with(EarlyScope(&early, start as u32, self.scope), move |old_scope, this| {
 607             this.with(LateScope(&late, this.scope), move |_, this| {
 608                 this.check_lifetime_defs(old_scope, &generics.lifetimes);
 609                 this.hack(walk); // FIXME(#37666) workaround in place of `walk(this)`
 610             });
 611         });
 612     }
 613
 614     fn resolve_lifetime_ref(&mut self, lifetime_ref: &hir::Lifetime) {
 615         // Walk up the scope chain, tracking the number of fn scopes
 616         // that we pass through, until we find a lifetime with the
 617         // given name or we run out of scopes. If we encounter a code
 618         // block, then the lifetime is not bound but free, so switch
 619         // over to `resolve_free_lifetime_ref()` to complete the
 620         // search.
 621         let mut late_depth = 0;
 622         let mut scope = self.scope;
 623         loop {
 624             match *scope {
 625                 FnScope {fn_id, body_id, s } => {
 626                     return self.resolve_free_lifetime_ref(
 627                         region::CallSiteScopeData { fn_id: fn_id, body_id: body_id },
 628                         lifetime_ref,
 629                         s);
 630                 }
 631
 632                 RootScope => {
 633                     break;
 634                 }
 635
 636                 EarlyScope(lifetimes, start, s) => {
 637                     match search_lifetimes(lifetimes, lifetime_ref) {
 638                         Some((index, lifetime_def)) => {
 639                             let decl_id = lifetime_def.id;
 640                             let def = DefEarlyBoundRegion(start + index, decl_id);
 641                             self.insert_lifetime(lifetime_ref, def);
 642                             return;
 643                         }
 644                         None => {
 645                             scope = s;
 646                         }
 647                     }
 648                 }
 649
 650                 LateScope(lifetimes, s) => {
 651                     match search_lifetimes(lifetimes, lifetime_ref) {
 652                         Some((_index, lifetime_def)) => {
 653                             let decl_id = lifetime_def.id;
 654                             let debruijn = ty::DebruijnIndex::new(late_depth + 1);
 655                             let def = DefLateBoundRegion(debruijn, decl_id);
 656                             self.insert_lifetime(lifetime_ref, def);
 657                             return;
 658                         }
 659
 660                         None => {
 661                             late_depth += 1;
 662                             scope = s;
 663                         }
 664                     }
 665                 }
 666             }
 667         }
 668
 669         self.unresolved_lifetime_ref(lifetime_ref);
 670     }
 671
 672     fn resolve_free_lifetime_ref(&mut self,
 673                                  scope_data: region::CallSiteScopeData,
 674                                  lifetime_ref: &hir::Lifetime,
 675                                  scope: Scope) {
 676         debug!("resolve_free_lifetime_ref \
 677                 scope_data: {:?} lifetime_ref: {:?} scope: {:?}",
 678                scope_data, lifetime_ref, scope);
 679
 680         // Walk up the scope chain, tracking the outermost free scope,
 681         // until we encounter a scope that contains the named lifetime
 682         // or we run out of scopes.
 683         let mut scope_data = scope_data;
 684         let mut scope = scope;
 685         let mut search_result = None;
 686         loop {
 687             debug!("resolve_free_lifetime_ref \
 688                     scope_data: {:?} scope: {:?} search_result: {:?}",
 689                    scope_data, scope, search_result);
 690             match *scope {
 691                 FnScope { fn_id, body_id, s } => {
 692                     scope_data = region::CallSiteScopeData {
 693                         fn_id: fn_id, body_id: body_id
 694                     };
 695                     scope = s;
 696                 }
 697
 698                 RootScope => {
 699                     break;
 700                 }
 701
 702                 EarlyScope(lifetimes, _, s) |
 703                 LateScope(lifetimes, s) => {
 704                     search_result = search_lifetimes(lifetimes, lifetime_ref);
 705                     if search_result.is_some() {
 706                         break;
 707                     }
 708                     scope = s;
 709                 }
 710             }
 711         }
 712
 713         match search_result {
 714             Some((_depth, lifetime)) => {
 715                 let def = DefFreeRegion(scope_data, lifetime.id);
 716                 self.insert_lifetime(lifetime_ref, def);
 717             }
 718
 719             None => {
 720                 self.unresolved_lifetime_ref(lifetime_ref);
 721             }
 722         }
 723
 724     }
 725
 726     fn unresolved_lifetime_ref(&self, lifetime_ref: &hir::Lifetime) {
 727         struct_span_err!(self.sess, lifetime_ref.span, E0261,
 728             "use of undeclared lifetime name `{}`", lifetime_ref.name)
 729             .span_label(lifetime_ref.span, &format!("undeclared lifetime"))
 730             .emit();
 731     }
 732
 733     fn check_lifetime_defs(&mut self, old_scope: Scope, lifetimes: &[hir::LifetimeDef]) {
 734         for i in 0..lifetimes.len() {
 735             let lifetime_i = &lifetimes[i];
 736
 737             for lifetime in lifetimes {
 738                 if lifetime.lifetime.name == keywords::StaticLifetime.name() {
 739                     let lifetime = lifetime.lifetime;
 740                     let mut err = struct_span_err!(self.sess, lifetime.span, E0262,
 741                                   "invalid lifetime parameter name: `{}`", lifetime.name);
 742                     err.span_label(lifetime.span,
 743                                    &format!("{} is a reserved lifetime name", lifetime.name));
 744                     err.emit();
 745                 }
 746             }
 747
 748             // It is a hard error to shadow a lifetime within the same scope.
 749             for j in i + 1..lifetimes.len() {
 750                 let lifetime_j = &lifetimes[j];
 751
 752                 if lifetime_i.lifetime.name == lifetime_j.lifetime.name {
 753                     struct_span_err!(self.sess, lifetime_j.lifetime.span, E0263,
 754                                      "lifetime name `{}` declared twice in the same scope",
 755                                      lifetime_j.lifetime.name)
 756                         .span_label(lifetime_j.lifetime.span,
 757                                     &format!("declared twice"))
 758                         .span_label(lifetime_i.lifetime.span,
 759                                    &format!("previous declaration here"))
 760                         .emit();
 761                 }
 762             }
 763
 764             // It is a soft error to shadow a lifetime within a parent scope.
 765             self.check_lifetime_def_for_shadowing(old_scope, &lifetime_i.lifetime);
 766
 767             for bound in &lifetime_i.bounds {
 768                 self.resolve_lifetime_ref(bound);
 769             }
 770         }
 771     }
 772
 773     fn check_lifetime_def_for_shadowing(&self,
 774                                         mut old_scope: Scope,
 775                                         lifetime: &hir::Lifetime)
 776     {
 777         for &(label, label_span) in &self.labels_in_fn {
 778             // FIXME (#24278): non-hygienic comparison
 779             if lifetime.name == label {
 780                 signal_shadowing_problem(self.sess,
 781                                          lifetime.name,
 782                                          original_label(label_span),
 783                                          shadower_lifetime(&lifetime));
 784                 return;
 785             }
 786         }
 787
 788         loop {
 789             match *old_scope {
 790                 FnScope { s, .. } => {
 791                     old_scope = s;
 792                 }
 793
 794                 RootScope => {
 795                     return;
 796                 }
 797
 798                 EarlyScope(lifetimes, _, s) |
 799                 LateScope(lifetimes, s) => {
 800                     if let Some((_, lifetime_def)) = search_lifetimes(lifetimes, lifetime) {
 801                         signal_shadowing_problem(
 802                             self.sess,
 803                             lifetime.name,
 804                             original_lifetime(&lifetime_def),
 805                             shadower_lifetime(&lifetime));
 806                         return;
 807                     }
 808
 809                     old_scope = s;
 810                 }
 811             }
 812         }
 813     }
 814
 815     fn insert_lifetime(&mut self,
 816                        lifetime_ref: &hir::Lifetime,
 817                        def: DefRegion) {
 818         if lifetime_ref.id == ast::DUMMY_NODE_ID {
 819             span_bug!(lifetime_ref.span,
 820                       "lifetime reference not renumbered, \
 821                        probably a bug in syntax::fold");
 822         }
 823
 824         debug!("{} resolved to {:?} span={:?}",
 825                self.hir_map.node_to_string(lifetime_ref.id),
 826                def,
 827                self.sess.codemap().span_to_string(lifetime_ref.span));
 828         self.map.defs.insert(lifetime_ref.id, def);
 829     }
 830 }
 831
 832 fn search_lifetimes<'a>(lifetimes: &'a [hir::LifetimeDef],
 833                     lifetime_ref: &hir::Lifetime)
 834                     -> Option<(u32, &'a hir::Lifetime)> {
 835     for (i, lifetime_decl) in lifetimes.iter().enumerate() {
 836         if lifetime_decl.lifetime.name == lifetime_ref.name {
 837             return Some((i as u32, &lifetime_decl.lifetime));
 838         }
 839     }
 840     return None;
 841 }
 842
 843 ///////////////////////////////////////////////////////////////////////////
 844
 845 /// Detects late-bound lifetimes and inserts them into
 846 /// `map.late_bound`.
 847 ///
 848 /// A region declared on a fn is **late-bound** if:
 849 /// - it is constrained by an argument type;
 850 /// - it does not appear in a where-clause.
 851 ///
 852 /// "Constrained" basically means that it appears in any type but
 853 /// not amongst the inputs to a projection.  In other words, `<&'a
 854 /// T as Trait<''b>>::Foo` does not constrain `'a` or `'b`.
 855 fn insert_late_bound_lifetimes(map: &mut NamedRegionMap,
 856                                fn_def_id: DefId,
 857                                decl: &hir::FnDecl,
 858                                generics: &hir::Generics) {
 859     debug!("insert_late_bound_lifetimes(decl={:?}, generics={:?})", decl, generics);
 860
 861     let mut constrained_by_input = ConstrainedCollector { regions: FxHashSet() };
 862     for arg_ty in &decl.inputs {
 863         constrained_by_input.visit_ty(arg_ty);
 864     }
 865
 866     let mut appears_in_output = AllCollector {
 867         regions: FxHashSet(),
 868         impl_trait: false
 869     };
 870     intravisit::walk_fn_ret_ty(&mut appears_in_output, &decl.output);
 871
 872     debug!("insert_late_bound_lifetimes: constrained_by_input={:?}",
 873            constrained_by_input.regions);
 874
 875     // Walk the lifetimes that appear in where clauses.
 876     //
 877     // Subtle point: because we disallow nested bindings, we can just
 878     // ignore binders here and scrape up all names we see.
 879     let mut appears_in_where_clause = AllCollector {
 880         regions: FxHashSet(),
 881         impl_trait: false
 882     };
 883     for ty_param in generics.ty_params.iter() {
 884         walk_list!(&mut appears_in_where_clause,
 885                    visit_ty_param_bound,
 886                    &ty_param.bounds);
 887     }
 888     walk_list!(&mut appears_in_where_clause,
 889                visit_where_predicate,
 890                &generics.where_clause.predicates);
 891     for lifetime_def in &generics.lifetimes {
 892         if !lifetime_def.bounds.is_empty() {
 893             // `'a: 'b` means both `'a` and `'b` are referenced
 894             appears_in_where_clause.visit_lifetime_def(lifetime_def);
 895         }
 896     }
 897
 898     debug!("insert_late_bound_lifetimes: appears_in_where_clause={:?}",
 899            appears_in_where_clause.regions);
 900
 901     // Late bound regions are those that:
 902     // - appear in the inputs
 903     // - do not appear in the where-clauses
 904     // - are not implicitly captured by `impl Trait`
 905     for lifetime in &generics.lifetimes {
 906         let name = lifetime.lifetime.name;
 907
 908         // appears in the where clauses? early-bound.
 909         if appears_in_where_clause.regions.contains(&name) { continue; }
 910
 911         // any `impl Trait` in the return type? early-bound.
 912         if appears_in_output.impl_trait { continue; }
 913
 914         // does not appear in the inputs, but appears in the return
 915         // type? eventually this will be early-bound, but for now we
 916         // just mark it so we can issue warnings.
 917         let constrained_by_input = constrained_by_input.regions.contains(&name);
 918         let appears_in_output = appears_in_output.regions.contains(&name);
 919         let will_change = !constrained_by_input && appears_in_output;
 920         let issue_32330 = if will_change {
 921             ty::Issue32330::WillChange {
 922                 fn_def_id: fn_def_id,
 923                 region_name: name,
 924             }
 925         } else {
 926             ty::Issue32330::WontChange
 927         };
 928
 929         debug!("insert_late_bound_lifetimes: \
 930                 lifetime {:?} with id {:?} is late-bound ({:?}",
 931                lifetime.lifetime.name, lifetime.lifetime.id, issue_32330);
 932
 933         let prev = map.late_bound.insert(lifetime.lifetime.id, issue_32330);
 934         assert!(prev.is_none(), "visited lifetime {:?} twice", lifetime.lifetime.id);
 935     }
 936
 937     return;
 938
 939     struct ConstrainedCollector {
 940         regions: FxHashSet<ast::Name>,
 941     }
 942
 943     impl<'v> Visitor<'v> for ConstrainedCollector {
 944         fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'v> {
 945             NestedVisitorMap::None
 946         }
 947
 948         fn visit_ty(&mut self, ty: &'v hir::Ty) {
 949             match ty.node {
 950                 hir::TyPath(hir::QPath::Resolved(Some(_), _)) |
 951                 hir::TyPath(hir::QPath::TypeRelative(..)) => {
 952                     // ignore lifetimes appearing in associated type
 953                     // projections, as they are not *constrained*
 954                     // (defined above)
 955                 }
 956
 957                 hir::TyPath(hir::QPath::Resolved(None, ref path)) => {
 958                     // consider only the lifetimes on the final
 959                     // segment; I am not sure it's even currently
 960                     // valid to have them elsewhere, but even if it
 961                     // is, those would be potentially inputs to
 962                     // projections
 963                     if let Some(last_segment) = path.segments.last() {
 964                         self.visit_path_segment(path.span, last_segment);
 965                     }
 966                 }
 967
 968                 _ => {
 969                     intravisit::walk_ty(self, ty);
 970                 }
 971             }
 972         }
 973
 974         fn visit_lifetime(&mut self, lifetime_ref: &'v hir::Lifetime) {
 975             self.regions.insert(lifetime_ref.name);
 976         }
 977     }
 978
 979     struct AllCollector {
 980         regions: FxHashSet<ast::Name>,
 981         impl_trait: bool
 982     }
 983
 984     impl<'v> Visitor<'v> for AllCollector {
 985         fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'v> {
 986             NestedVisitorMap::None
 987         }
 988
 989         fn visit_lifetime(&mut self, lifetime_ref: &'v hir::Lifetime) {
 990             self.regions.insert(lifetime_ref.name);
 991         }
 992
 993         fn visit_ty(&mut self, ty: &hir::Ty) {
 994             if let hir::TyImplTrait(_) = ty.node {
 995                 self.impl_trait = true;
 996             }
 997             intravisit::walk_ty(self, ty);
 998         }
 999     }
1000 }