compiler/rustc_resolve/src/late.rs

   1 //! "Late resolution" is the pass that resolves most of names in a crate beside imports and macros.
   2 //! It runs when the crate is fully expanded and its module structure is fully built.
   3 //! So it just walks through the crate and resolves all the expressions, types, etc.
   4 //!
   5 //! If you wonder why there's no `early.rs`, that's because it's split into three files -
   6 //! `build_reduced_graph.rs`, `macros.rs` and `imports.rs`.
   7
   8 use RibKind::*;
   9
  10 use crate::{path_names_to_string, BindingError, Finalize, LexicalScopeBinding};
  11 use crate::{Module, ModuleOrUniformRoot, NameBinding, ParentScope, PathResult};
  12 use crate::{ResolutionError, Resolver, Segment, UseError};
  13
  14 use rustc_ast::ptr::P;
  15 use rustc_ast::visit::{self, AssocCtxt, BoundKind, FnCtxt, FnKind, Visitor};
  16 use rustc_ast::*;
  17 use rustc_ast_lowering::{LifetimeRes, ResolverAstLowering};
  18 use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap};
  19 use rustc_errors::DiagnosticId;
  20 use rustc_hir::def::Namespace::{self, *};
  21 use rustc_hir::def::{self, CtorKind, DefKind, PartialRes, PerNS};
  22 use rustc_hir::def_id::{DefId, CRATE_DEF_ID};
  23 use rustc_hir::definitions::DefPathData;
  24 use rustc_hir::{PrimTy, TraitCandidate};
  25 use rustc_index::vec::Idx;
  26 use rustc_middle::ty::DefIdTree;
  27 use rustc_middle::{bug, span_bug};
  28 use rustc_session::lint;
  29 use rustc_span::symbol::{kw, sym, Ident, Symbol};
  30 use rustc_span::{BytePos, Span};
  31 use smallvec::{smallvec, SmallVec};
  32
  33 use rustc_span::source_map::{respan, Spanned};
  34 use std::collections::{hash_map::Entry, BTreeSet};
  35 use std::mem::{replace, take};
  36 use tracing::debug;
  37
  38 mod diagnostics;
  39 crate mod lifetimes;
  40
  41 type Res = def::Res<NodeId>;
  42
  43 type IdentMap<T> = FxHashMap<Ident, T>;
  44
  45 /// Map from the name in a pattern to its binding mode.
  46 type BindingMap = IdentMap<BindingInfo>;
  47
  48 #[derive(Copy, Clone, Debug)]
  49 struct BindingInfo {
  50     span: Span,
  51     binding_mode: BindingMode,
  52 }
  53
  54 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
  55 enum PatternSource {
  56     Match,
  57     Let,
  58     For,
  59     FnParam,
  60 }
  61
  62 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
  63 enum IsRepeatExpr {
  64     No,
  65     Yes,
  66 }
  67
  68 impl PatternSource {
  69     fn descr(self) -> &'static str {
  70         match self {
  71             PatternSource::Match => "match binding",
  72             PatternSource::Let => "let binding",
  73             PatternSource::For => "for binding",
  74             PatternSource::FnParam => "function parameter",
  75         }
  76     }
  77 }
  78
  79 /// Denotes whether the context for the set of already bound bindings is a `Product`
  80 /// or `Or` context. This is used in e.g., `fresh_binding` and `resolve_pattern_inner`.
  81 /// See those functions for more information.
  82 #[derive(PartialEq)]
  83 enum PatBoundCtx {
  84     /// A product pattern context, e.g., `Variant(a, b)`.
  85     Product,
  86     /// An or-pattern context, e.g., `p_0 | ... | p_n`.
  87     Or,
  88 }
  89
  90 /// Does this the item (from the item rib scope) allow generic parameters?
  91 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
  92 crate enum HasGenericParams {
  93     Yes,
  94     No,
  95 }
  96
  97 impl HasGenericParams {
  98     fn force_yes_if(self, b: bool) -> Self {
  99         if b { Self::Yes } else { self }
 100     }
 101 }
 102
 103 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
 104 crate enum ConstantItemKind {
 105     Const,
 106     Static,
 107 }
 108
 109 /// The rib kind restricts certain accesses,
 110 /// e.g. to a `Res::Local` of an outer item.
 111 #[derive(Copy, Clone, Debug)]
 112 crate enum RibKind<'a> {
 113     /// No restriction needs to be applied.
 114     NormalRibKind,
 115
 116     /// We passed through an impl or trait and are now in one of its
 117     /// methods or associated types. Allow references to ty params that impl or trait
 118     /// binds. Disallow any other upvars (including other ty params that are
 119     /// upvars).
 120     AssocItemRibKind,
 121
 122     /// We passed through a closure. Disallow labels.
 123     ClosureOrAsyncRibKind,
 124
 125     /// We passed through a function definition. Disallow upvars.
 126     /// Permit only those const parameters that are specified in the function's generics.
 127     FnItemRibKind,
 128
 129     /// We passed through an item scope. Disallow upvars.
 130     ItemRibKind(HasGenericParams),
 131
 132     /// We're in a constant item. Can't refer to dynamic stuff.
 133     ///
 134     /// The item may reference generic parameters in trivial constant expressions.
 135     /// All other constants aren't allowed to use generic params at all.
 136     ConstantItemRibKind(HasGenericParams, Option<(Ident, ConstantItemKind)>),
 137
 138     /// We passed through a module.
 139     ModuleRibKind(Module<'a>),
 140
 141     /// We passed through a `macro_rules!` statement
 142     MacroDefinition(DefId),
 143
 144     /// All bindings in this rib are generic parameters that can't be used
 145     /// from the default of a generic parameter because they're not declared
 146     /// before said generic parameter. Also see the `visit_generics` override.
 147     ForwardGenericParamBanRibKind,
 148
 149     /// We are inside of the type of a const parameter. Can't refer to any
 150     /// parameters.
 151     ConstParamTyRibKind,
 152
 153     /// We are inside a `sym` inline assembly operand. Can only refer to
 154     /// globals.
 155     InlineAsmSymRibKind,
 156 }
 157
 158 impl RibKind<'_> {
 159     /// Whether this rib kind contains generic parameters, as opposed to local
 160     /// variables.
 161     crate fn contains_params(&self) -> bool {
 162         match self {
 163             NormalRibKind
 164             | ClosureOrAsyncRibKind
 165             | FnItemRibKind
 166             | ConstantItemRibKind(..)
 167             | ModuleRibKind(_)
 168             | MacroDefinition(_)
 169             | ConstParamTyRibKind
 170             | InlineAsmSymRibKind => false,
 171             AssocItemRibKind | ItemRibKind(_) | ForwardGenericParamBanRibKind => true,
 172         }
 173     }
 174 }
 175
 176 /// A single local scope.
 177 ///
 178 /// A rib represents a scope names can live in. Note that these appear in many places, not just
 179 /// around braces. At any place where the list of accessible names (of the given namespace)
 180 /// changes or a new restrictions on the name accessibility are introduced, a new rib is put onto a
 181 /// stack. This may be, for example, a `let` statement (because it introduces variables), a macro,
 182 /// etc.
 183 ///
 184 /// Different [rib kinds](enum.RibKind) are transparent for different names.
 185 ///
 186 /// The resolution keeps a separate stack of ribs as it traverses the AST for each namespace. When
 187 /// resolving, the name is looked up from inside out.
 188 #[derive(Debug)]
 189 crate struct Rib<'a, R = Res> {
 190     pub bindings: IdentMap<R>,
 191     pub kind: RibKind<'a>,
 192 }
 193
 194 impl<'a, R> Rib<'a, R> {
 195     fn new(kind: RibKind<'a>) -> Rib<'a, R> {
 196         Rib { bindings: Default::default(), kind }
 197     }
 198 }
 199
 200 #[derive(Copy, Clone, Debug)]
 201 enum LifetimeRibKind {
 202     /// This rib acts as a barrier to forbid reference to lifetimes of a parent item.
 203     Item,
 204
 205     /// This rib declares generic parameters.
 206     Generics { parent: NodeId, span: Span, kind: LifetimeBinderKind },
 207
 208     /// FIXME(const_generics): This patches over an ICE caused by non-'static lifetimes in const
 209     /// generics. We are disallowing this until we can decide on how we want to handle non-'static
 210     /// lifetimes in const generics. See issue #74052 for discussion.
 211     ConstGeneric,
 212
 213     /// Non-static lifetimes are prohibited in anonymous constants under `min_const_generics`.
 214     /// This function will emit an error if `generic_const_exprs` is not enabled, the body identified by
 215     /// `body_id` is an anonymous constant and `lifetime_ref` is non-static.
 216     AnonConst,
 217
 218     /// For **Modern** cases, create a new anonymous region parameter
 219     /// and reference that.
 220     ///
 221     /// For **Dyn Bound** cases, pass responsibility to
 222     /// `resolve_lifetime` code.
 223     ///
 224     /// For **Deprecated** cases, report an error.
 225     AnonymousCreateParameter(NodeId),
 226
 227     /// Give a hard error when either `&` or `'_` is written. Used to
 228     /// rule out things like `where T: Foo<'_>`. Does not imply an
 229     /// error on default object bounds (e.g., `Box<dyn Foo>`).
 230     AnonymousReportError,
 231
 232     /// Pass responsibility to `resolve_lifetime` code for all cases.
 233     AnonymousPassThrough(NodeId),
 234 }
 235
 236 #[derive(Copy, Clone, Debug)]
 237 enum LifetimeBinderKind {
 238     BareFnType,
 239     PolyTrait,
 240     WhereBound,
 241     Item,
 242     Function,
 243     ImplBlock,
 244 }
 245
 246 impl LifetimeBinderKind {
 247     fn descr(self) -> &'static str {
 248         use LifetimeBinderKind::*;
 249         match self {
 250             BareFnType => "type",
 251             PolyTrait => "bound",
 252             WhereBound => "bound",
 253             Item => "item",
 254             ImplBlock => "impl block",
 255             Function => "function",
 256         }
 257     }
 258 }
 259
 260 #[derive(Debug)]
 261 struct LifetimeRib {
 262     kind: LifetimeRibKind,
 263     // We need to preserve insertion order for async fns.
 264     bindings: FxIndexMap<Ident, (NodeId, LifetimeRes)>,
 265 }
 266
 267 impl LifetimeRib {
 268     fn new(kind: LifetimeRibKind) -> LifetimeRib {
 269         LifetimeRib { bindings: Default::default(), kind }
 270     }
 271 }
 272
 273 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
 274 crate enum AliasPossibility {
 275     No,
 276     Maybe,
 277 }
 278
 279 #[derive(Copy, Clone, Debug)]
 280 crate enum PathSource<'a> {
 281     // Type paths `Path`.
 282     Type,
 283     // Trait paths in bounds or impls.
 284     Trait(AliasPossibility),
 285     // Expression paths `path`, with optional parent context.
 286     Expr(Option<&'a Expr>),
 287     // Paths in path patterns `Path`.
 288     Pat,
 289     // Paths in struct expressions and patterns `Path { .. }`.
 290     Struct,
 291     // Paths in tuple struct patterns `Path(..)`.
 292     TupleStruct(Span, &'a [Span]),
 293     // `m::A::B` in `<T as m::A>::B::C`.
 294     TraitItem(Namespace),
 295 }
 296
 297 impl<'a> PathSource<'a> {
 298     fn namespace(self) -> Namespace {
 299         match self {
 300             PathSource::Type | PathSource::Trait(_) | PathSource::Struct => TypeNS,
 301             PathSource::Expr(..) | PathSource::Pat | PathSource::TupleStruct(..) => ValueNS,
 302             PathSource::TraitItem(ns) => ns,
 303         }
 304     }
 305
 306     fn defer_to_typeck(self) -> bool {
 307         match self {
 308             PathSource::Type
 309             | PathSource::Expr(..)
 310             | PathSource::Pat
 311             | PathSource::Struct
 312             | PathSource::TupleStruct(..) => true,
 313             PathSource::Trait(_) | PathSource::TraitItem(..) => false,
 314         }
 315     }
 316
 317     fn descr_expected(self) -> &'static str {
 318         match &self {
 319             PathSource::Type => "type",
 320             PathSource::Trait(_) => "trait",
 321             PathSource::Pat => "unit struct, unit variant or constant",
 322             PathSource::Struct => "struct, variant or union type",
 323             PathSource::TupleStruct(..) => "tuple struct or tuple variant",
 324             PathSource::TraitItem(ns) => match ns {
 325                 TypeNS => "associated type",
 326                 ValueNS => "method or associated constant",
 327                 MacroNS => bug!("associated macro"),
 328             },
 329             PathSource::Expr(parent) => match parent.as_ref().map(|p| &p.kind) {
 330                 // "function" here means "anything callable" rather than `DefKind::Fn`,
 331                 // this is not precise but usually more helpful than just "value".
 332                 Some(ExprKind::Call(call_expr, _)) => match &call_expr.kind {
 333                     // the case of `::some_crate()`
 334                     ExprKind::Path(_, path)
 335                         if path.segments.len() == 2
 336                             && path.segments[0].ident.name == kw::PathRoot =>
 337                     {
 338                         "external crate"
 339                     }
 340                     ExprKind::Path(_, path) => {
 341                         let mut msg = "function";
 342                         if let Some(segment) = path.segments.iter().last() {
 343                             if let Some(c) = segment.ident.to_string().chars().next() {
 344                                 if c.is_uppercase() {
 345                                     msg = "function, tuple struct or tuple variant";
 346                                 }
 347                             }
 348                         }
 349                         msg
 350                     }
 351                     _ => "function",
 352                 },
 353                 _ => "value",
 354             },
 355         }
 356     }
 357
 358     fn is_call(self) -> bool {
 359         matches!(self, PathSource::Expr(Some(&Expr { kind: ExprKind::Call(..), .. })))
 360     }
 361
 362     crate fn is_expected(self, res: Res) -> bool {
 363         match self {
 364             PathSource::Type => matches!(
 365                 res,
 366                 Res::Def(
 367                     DefKind::Struct
 368                         | DefKind::Union
 369                         | DefKind::Enum
 370                         | DefKind::Trait
 371                         | DefKind::TraitAlias
 372                         | DefKind::TyAlias
 373                         | DefKind::AssocTy
 374                         | DefKind::TyParam
 375                         | DefKind::OpaqueTy
 376                         | DefKind::ForeignTy,
 377                     _,
 378                 ) | Res::PrimTy(..)
 379                     | Res::SelfTy { .. }
 380             ),
 381             PathSource::Trait(AliasPossibility::No) => matches!(res, Res::Def(DefKind::Trait, _)),
 382             PathSource::Trait(AliasPossibility::Maybe) => {
 383                 matches!(res, Res::Def(DefKind::Trait | DefKind::TraitAlias, _))
 384             }
 385             PathSource::Expr(..) => matches!(
 386                 res,
 387                 Res::Def(
 388                     DefKind::Ctor(_, CtorKind::Const | CtorKind::Fn)
 389                         | DefKind::Const
 390                         | DefKind::Static(_)
 391                         | DefKind::Fn
 392                         | DefKind::AssocFn
 393                         | DefKind::AssocConst
 394                         | DefKind::ConstParam,
 395                     _,
 396                 ) | Res::Local(..)
 397                     | Res::SelfCtor(..)
 398             ),
 399             PathSource::Pat => matches!(
 400                 res,
 401                 Res::Def(
 402                     DefKind::Ctor(_, CtorKind::Const) | DefKind::Const | DefKind::AssocConst,
 403                     _,
 404                 ) | Res::SelfCtor(..)
 405             ),
 406             PathSource::TupleStruct(..) => res.expected_in_tuple_struct_pat(),
 407             PathSource::Struct => matches!(
 408                 res,
 409                 Res::Def(
 410                     DefKind::Struct
 411                         | DefKind::Union
 412                         | DefKind::Variant
 413                         | DefKind::TyAlias
 414                         | DefKind::AssocTy,
 415                     _,
 416                 ) | Res::SelfTy { .. }
 417             ),
 418             PathSource::TraitItem(ns) => match res {
 419                 Res::Def(DefKind::AssocConst | DefKind::AssocFn, _) if ns == ValueNS => true,
 420                 Res::Def(DefKind::AssocTy, _) if ns == TypeNS => true,
 421                 _ => false,
 422             },
 423         }
 424     }
 425
 426     fn error_code(self, has_unexpected_resolution: bool) -> DiagnosticId {
 427         use rustc_errors::error_code;
 428         match (self, has_unexpected_resolution) {
 429             (PathSource::Trait(_), true) => error_code!(E0404),
 430             (PathSource::Trait(_), false) => error_code!(E0405),
 431             (PathSource::Type, true) => error_code!(E0573),
 432             (PathSource::Type, false) => error_code!(E0412),
 433             (PathSource::Struct, true) => error_code!(E0574),
 434             (PathSource::Struct, false) => error_code!(E0422),
 435             (PathSource::Expr(..), true) => error_code!(E0423),
 436             (PathSource::Expr(..), false) => error_code!(E0425),
 437             (PathSource::Pat | PathSource::TupleStruct(..), true) => error_code!(E0532),
 438             (PathSource::Pat | PathSource::TupleStruct(..), false) => error_code!(E0531),
 439             (PathSource::TraitItem(..), true) => error_code!(E0575),
 440             (PathSource::TraitItem(..), false) => error_code!(E0576),
 441         }
 442     }
 443 }
 444
 445 #[derive(Default)]
 446 struct DiagnosticMetadata<'ast> {
 447     /// The current trait's associated items' ident, used for diagnostic suggestions.
 448     current_trait_assoc_items: Option<&'ast [P<AssocItem>]>,
 449
 450     /// The current self type if inside an impl (used for better errors).
 451     current_self_type: Option<Ty>,
 452
 453     /// The current self item if inside an ADT (used for better errors).
 454     current_self_item: Option<NodeId>,
 455
 456     /// The current trait (used to suggest).
 457     current_item: Option<&'ast Item>,
 458
 459     /// When processing generics and encountering a type not found, suggest introducing a type
 460     /// param.
 461     currently_processing_generics: bool,
 462
 463     /// The current enclosing (non-closure) function (used for better errors).
 464     current_function: Option<(FnKind<'ast>, Span)>,
 465
 466     /// A list of labels as of yet unused. Labels will be removed from this map when
 467     /// they are used (in a `break` or `continue` statement)
 468     unused_labels: FxHashMap<NodeId, Span>,
 469
 470     /// Only used for better errors on `fn(): fn()`.
 471     current_type_ascription: Vec<Span>,
 472
 473     /// Only used for better errors on `let x = { foo: bar };`.
 474     /// In the case of a parse error with `let x = { foo: bar, };`, this isn't needed, it's only
 475     /// needed for cases where this parses as a correct type ascription.
 476     current_block_could_be_bare_struct_literal: Option<Span>,
 477
 478     /// Only used for better errors on `let <pat>: <expr, not type>;`.
 479     current_let_binding: Option<(Span, Option<Span>, Option<Span>)>,
 480
 481     /// Used to detect possible `if let` written without `let` and to provide structured suggestion.
 482     in_if_condition: Option<&'ast Expr>,
 483
 484     /// If we are currently in a trait object definition. Used to point at the bounds when
 485     /// encountering a struct or enum.
 486     current_trait_object: Option<&'ast [ast::GenericBound]>,
 487
 488     /// Given `where <T as Bar>::Baz: String`, suggest `where T: Bar<Baz = String>`.
 489     current_where_predicate: Option<&'ast WherePredicate>,
 490
 491     current_type_path: Option<&'ast Ty>,
 492 }
 493
 494 struct LateResolutionVisitor<'a, 'b, 'ast> {
 495     r: &'b mut Resolver<'a>,
 496
 497     /// The module that represents the current item scope.
 498     parent_scope: ParentScope<'a>,
 499
 500     /// The current set of local scopes for types and values.
 501     /// FIXME #4948: Reuse ribs to avoid allocation.
 502     ribs: PerNS<Vec<Rib<'a>>>,
 503
 504     /// The current set of local scopes, for labels.
 505     label_ribs: Vec<Rib<'a, NodeId>>,
 506
 507     /// The current set of local scopes for lifetimes.
 508     lifetime_ribs: Vec<LifetimeRib>,
 509
 510     /// The trait that the current context can refer to.
 511     current_trait_ref: Option<(Module<'a>, TraitRef)>,
 512
 513     /// Fields used to add information to diagnostic errors.
 514     diagnostic_metadata: DiagnosticMetadata<'ast>,
 515
 516     /// State used to know whether to ignore resolution errors for function bodies.
 517     ///
 518     /// In particular, rustdoc uses this to avoid giving errors for `cfg()` items.
 519     /// In most cases this will be `None`, in which case errors will always be reported.
 520     /// If it is `true`, then it will be updated when entering a nested function or trait body.
 521     in_func_body: bool,
 522 }
 523
 524 /// Walks the whole crate in DFS order, visiting each item, resolving names as it goes.
 525 impl<'a: 'ast, 'ast> Visitor<'ast> for LateResolutionVisitor<'a, '_, 'ast> {
 526     fn visit_attribute(&mut self, _: &'ast Attribute) {
 527         // We do not want to resolve expressions that appear in attributes,
 528         // as they do not correspond to actual code.
 529     }
 530     fn visit_item(&mut self, item: &'ast Item) {
 531         let prev = replace(&mut self.diagnostic_metadata.current_item, Some(item));
 532         // Always report errors in items we just entered.
 533         let old_ignore = replace(&mut self.in_func_body, false);
 534         self.with_lifetime_rib(LifetimeRibKind::Item, |this| this.resolve_item(item));
 535         self.in_func_body = old_ignore;
 536         self.diagnostic_metadata.current_item = prev;
 537     }
 538     fn visit_arm(&mut self, arm: &'ast Arm) {
 539         self.resolve_arm(arm);
 540     }
 541     fn visit_block(&mut self, block: &'ast Block) {
 542         self.resolve_block(block);
 543     }
 544     fn visit_anon_const(&mut self, constant: &'ast AnonConst) {
 545         // We deal with repeat expressions explicitly in `resolve_expr`.
 546         self.with_lifetime_rib(LifetimeRibKind::AnonConst, |this| {
 547             this.resolve_anon_const(constant, IsRepeatExpr::No);
 548         })
 549     }
 550     fn visit_expr(&mut self, expr: &'ast Expr) {
 551         self.resolve_expr(expr, None);
 552     }
 553     fn visit_local(&mut self, local: &'ast Local) {
 554         let local_spans = match local.pat.kind {
 555             // We check for this to avoid tuple struct fields.
 556             PatKind::Wild => None,
 557             _ => Some((
 558                 local.pat.span,
 559                 local.ty.as_ref().map(|ty| ty.span),
 560                 local.kind.init().map(|init| init.span),
 561             )),
 562         };
 563         let original = replace(&mut self.diagnostic_metadata.current_let_binding, local_spans);
 564         self.resolve_local(local);
 565         self.diagnostic_metadata.current_let_binding = original;
 566     }
 567     fn visit_ty(&mut self, ty: &'ast Ty) {
 568         let prev = self.diagnostic_metadata.current_trait_object;
 569         let prev_ty = self.diagnostic_metadata.current_type_path;
 570         match ty.kind {
 571             TyKind::Rptr(None, _) => {
 572                 // Elided lifetime in reference: we resolve as if there was some lifetime `'_` with
 573                 // NodeId `ty.id`.
 574                 let span = self.r.session.source_map().next_point(ty.span.shrink_to_lo());
 575                 self.resolve_elided_lifetime(ty.id, span);
 576             }
 577             TyKind::Path(ref qself, ref path) => {
 578                 self.diagnostic_metadata.current_type_path = Some(ty);
 579                 self.smart_resolve_path(ty.id, qself.as_ref(), path, PathSource::Type);
 580             }
 581             TyKind::ImplicitSelf => {
 582                 let self_ty = Ident::with_dummy_span(kw::SelfUpper);
 583                 let res = self
 584                     .resolve_ident_in_lexical_scope(
 585                         self_ty,
 586                         TypeNS,
 587                         Some(Finalize::new(ty.id, ty.span)),
 588                         None,
 589                     )
 590                     .map_or(Res::Err, |d| d.res());
 591                 self.r.record_partial_res(ty.id, PartialRes::new(res));
 592             }
 593             TyKind::TraitObject(ref bounds, ..) => {
 594                 self.diagnostic_metadata.current_trait_object = Some(&bounds[..]);
 595             }
 596             TyKind::BareFn(ref bare_fn) => {
 597                 let span = if bare_fn.generic_params.is_empty() {
 598                     ty.span.shrink_to_lo()
 599                 } else {
 600                     ty.span
 601                 };
 602                 self.with_generic_param_rib(
 603                     &bare_fn.generic_params,
 604                     NormalRibKind,
 605                     LifetimeRibKind::Generics {
 606                         parent: ty.id,
 607                         kind: LifetimeBinderKind::BareFnType,
 608                         span,
 609                     },
 610                     |this| {
 611                         this.with_lifetime_rib(
 612                             LifetimeRibKind::AnonymousPassThrough(ty.id),
 613                             |this| {
 614                                 this.visit_generic_param_vec(&bare_fn.generic_params, false);
 615                                 visit::walk_fn_decl(this, &bare_fn.decl);
 616                             },
 617                         );
 618                     },
 619                 );
 620                 self.diagnostic_metadata.current_trait_object = prev;
 621                 return;
 622             }
 623             _ => (),
 624         }
 625         visit::walk_ty(self, ty);
 626         self.diagnostic_metadata.current_trait_object = prev;
 627         self.diagnostic_metadata.current_type_path = prev_ty;
 628     }
 629     fn visit_poly_trait_ref(&mut self, tref: &'ast PolyTraitRef, _: &'ast TraitBoundModifier) {
 630         let span =
 631             if tref.bound_generic_params.is_empty() { tref.span.shrink_to_lo() } else { tref.span };
 632         self.with_generic_param_rib(
 633             &tref.bound_generic_params,
 634             NormalRibKind,
 635             LifetimeRibKind::Generics {
 636                 parent: tref.trait_ref.ref_id,
 637                 kind: LifetimeBinderKind::PolyTrait,
 638                 span,
 639             },
 640             |this| {
 641                 this.visit_generic_param_vec(&tref.bound_generic_params, false);
 642                 this.smart_resolve_path(
 643                     tref.trait_ref.ref_id,
 644                     None,
 645                     &tref.trait_ref.path,
 646                     PathSource::Trait(AliasPossibility::Maybe),
 647                 );
 648                 this.visit_trait_ref(&tref.trait_ref);
 649             },
 650         );
 651     }
 652     fn visit_foreign_item(&mut self, foreign_item: &'ast ForeignItem) {
 653         match foreign_item.kind {
 654             ForeignItemKind::TyAlias(box TyAlias { ref generics, .. }) => {
 655                 self.with_lifetime_rib(LifetimeRibKind::Item, |this| {
 656                     this.with_generic_param_rib(
 657                         &generics.params,
 658                         ItemRibKind(HasGenericParams::Yes),
 659                         LifetimeRibKind::Generics {
 660                             parent: foreign_item.id,
 661                             kind: LifetimeBinderKind::Item,
 662                             span: generics.span,
 663                         },
 664                         |this| visit::walk_foreign_item(this, foreign_item),
 665                     )
 666                 });
 667             }
 668             ForeignItemKind::Fn(box Fn { ref generics, .. }) => {
 669                 self.with_lifetime_rib(LifetimeRibKind::Item, |this| {
 670                     this.with_generic_param_rib(
 671                         &generics.params,
 672                         ItemRibKind(HasGenericParams::Yes),
 673                         LifetimeRibKind::Generics {
 674                             parent: foreign_item.id,
 675                             kind: LifetimeBinderKind::Function,
 676                             span: generics.span,
 677                         },
 678                         |this| visit::walk_foreign_item(this, foreign_item),
 679                     )
 680                 });
 681             }
 682             ForeignItemKind::Static(..) => {
 683                 self.with_item_rib(|this| {
 684                     visit::walk_foreign_item(this, foreign_item);
 685                 });
 686             }
 687             ForeignItemKind::MacCall(..) => {
 688                 panic!("unexpanded macro in resolve!")
 689             }
 690         }
 691     }
 692     fn visit_fn(&mut self, fn_kind: FnKind<'ast>, sp: Span, fn_id: NodeId) {
 693         let rib_kind = match fn_kind {
 694             // Bail if the function is foreign, and thus cannot validly have
 695             // a body, or if there's no body for some other reason.
 696             FnKind::Fn(FnCtxt::Foreign, _, sig, _, generics, _)
 697             | FnKind::Fn(_, _, sig, _, generics, None) => {
 698                 self.with_lifetime_rib(LifetimeRibKind::AnonymousPassThrough(fn_id), |this| {
 699                     // We don't need to deal with patterns in parameters, because
 700                     // they are not possible for foreign or bodiless functions.
 701                     this.visit_fn_header(&sig.header);
 702                     this.visit_generics(generics);
 703                     visit::walk_fn_decl(this, &sig.decl);
 704                 });
 705                 return;
 706             }
 707             FnKind::Fn(FnCtxt::Free, ..) => FnItemRibKind,
 708             FnKind::Fn(FnCtxt::Assoc(_), ..) => NormalRibKind,
 709             FnKind::Closure(..) => ClosureOrAsyncRibKind,
 710         };
 711         let previous_value = self.diagnostic_metadata.current_function;
 712         if matches!(fn_kind, FnKind::Fn(..)) {
 713             self.diagnostic_metadata.current_function = Some((fn_kind, sp));
 714         }
 715         debug!("(resolving function) entering function");
 716         let declaration = fn_kind.decl();
 717
 718         // Create a value rib for the function.
 719         self.with_rib(ValueNS, rib_kind, |this| {
 720             // Create a label rib for the function.
 721             this.with_label_rib(rib_kind, |this| {
 722                 let async_node_id = fn_kind.header().and_then(|h| h.asyncness.opt_return_id());
 723
 724                 if let FnKind::Fn(_, _, _, _, generics, _) = fn_kind {
 725                     this.visit_generics(generics);
 726                 }
 727
 728                 if let Some(async_node_id) = async_node_id {
 729                     // In `async fn`, argument-position elided lifetimes
 730                     // must be transformed into fresh generic parameters so that
 731                     // they can be applied to the opaque `impl Trait` return type.
 732                     this.with_lifetime_rib(
 733                         LifetimeRibKind::AnonymousCreateParameter(fn_id),
 734                         |this| {
 735                             // Add each argument to the rib.
 736                             this.resolve_params(&declaration.inputs)
 737                         },
 738                     );
 739
 740                     // Construct the list of in-scope lifetime parameters for async lowering.
 741                     // We include all lifetime parameters, either named or "Fresh".
 742                     // The order of those parameters does not matter, as long as it is
 743                     // deterministic.
 744                     let mut extra_lifetime_params =
 745                         this.r.extra_lifetime_params_map.get(&fn_id).cloned().unwrap_or_default();
 746                     for rib in this.lifetime_ribs.iter().rev() {
 747                         extra_lifetime_params.extend(
 748                             rib.bindings
 749                                 .iter()
 750                                 .map(|(&ident, &(node_id, res))| (ident, node_id, res)),
 751                         );
 752                         match rib.kind {
 753                             LifetimeRibKind::Item => break,
 754                             LifetimeRibKind::AnonymousCreateParameter(id) => {
 755                                 if let Some(earlier_fresh) =
 756                                     this.r.extra_lifetime_params_map.get(&id)
 757                                 {
 758                                     extra_lifetime_params.extend(earlier_fresh);
 759                                 }
 760                             }
 761                             _ => {}
 762                         }
 763                     }
 764                     this.r.extra_lifetime_params_map.insert(async_node_id, extra_lifetime_params);
 765
 766                     this.with_lifetime_rib(
 767                         LifetimeRibKind::AnonymousPassThrough(async_node_id),
 768                         |this| visit::walk_fn_ret_ty(this, &declaration.output),
 769                     );
 770                 } else {
 771                     this.with_lifetime_rib(LifetimeRibKind::AnonymousPassThrough(fn_id), |this| {
 772                         // Add each argument to the rib.
 773                         this.resolve_params(&declaration.inputs);
 774
 775                         visit::walk_fn_ret_ty(this, &declaration.output);
 776                     });
 777                 };
 778
 779                 // Ignore errors in function bodies if this is rustdoc
 780                 // Be sure not to set this until the function signature has been resolved.
 781                 let previous_state = replace(&mut this.in_func_body, true);
 782                 // Resolve the function body, potentially inside the body of an async closure
 783                 this.with_lifetime_rib(LifetimeRibKind::AnonymousPassThrough(fn_id), |this| {
 784                     match fn_kind {
 785                         FnKind::Fn(.., body) => walk_list!(this, visit_block, body),
 786                         FnKind::Closure(_, body) => this.visit_expr(body),
 787                     }
 788                 });
 789
 790                 debug!("(resolving function) leaving function");
 791                 this.in_func_body = previous_state;
 792             })
 793         });
 794         self.diagnostic_metadata.current_function = previous_value;
 795     }
 796     fn visit_lifetime(&mut self, lifetime: &'ast Lifetime) {
 797         self.resolve_lifetime(lifetime)
 798     }
 799
 800     fn visit_generics(&mut self, generics: &'ast Generics) {
 801         self.visit_generic_param_vec(
 802             &generics.params,
 803             self.diagnostic_metadata.current_self_item.is_some(),
 804         );
 805         for p in &generics.where_clause.predicates {
 806             self.visit_where_predicate(p);
 807         }
 808     }
 809
 810     fn visit_generic_arg(&mut self, arg: &'ast GenericArg) {
 811         debug!("visit_generic_arg({:?})", arg);
 812         let prev = replace(&mut self.diagnostic_metadata.currently_processing_generics, true);
 813         match arg {
 814             GenericArg::Type(ref ty) => {
 815                 // We parse const arguments as path types as we cannot distinguish them during
 816                 // parsing. We try to resolve that ambiguity by attempting resolution the type
 817                 // namespace first, and if that fails we try again in the value namespace. If
 818                 // resolution in the value namespace succeeds, we have an generic const argument on
 819                 // our hands.
 820                 if let TyKind::Path(ref qself, ref path) = ty.kind {
 821                     // We cannot disambiguate multi-segment paths right now as that requires type
 822                     // checking.
 823                     if path.segments.len() == 1 && path.segments[0].args.is_none() {
 824                         let mut check_ns = |ns| {
 825                             self.maybe_resolve_ident_in_lexical_scope(path.segments[0].ident, ns)
 826                                 .is_some()
 827                         };
 828                         if !check_ns(TypeNS) && check_ns(ValueNS) {
 829                             // This must be equivalent to `visit_anon_const`, but we cannot call it
 830                             // directly due to visitor lifetimes so we have to copy-paste some code.
 831                             //
 832                             // Note that we might not be inside of an repeat expression here,
 833                             // but considering that `IsRepeatExpr` is only relevant for
 834                             // non-trivial constants this is doesn't matter.
 835                             self.with_constant_rib(
 836                                 IsRepeatExpr::No,
 837                                 HasGenericParams::Yes,
 838                                 None,
 839                                 |this| {
 840                                     this.smart_resolve_path(
 841                                         ty.id,
 842                                         qself.as_ref(),
 843                                         path,
 844                                         PathSource::Expr(None),
 845                                     );
 846
 847                                     if let Some(ref qself) = *qself {
 848                                         this.visit_ty(&qself.ty);
 849                                     }
 850                                     this.visit_path(path, ty.id);
 851                                 },
 852                             );
 853
 854                             self.diagnostic_metadata.currently_processing_generics = prev;
 855                             return;
 856                         }
 857                     }
 858                 }
 859
 860                 self.visit_ty(ty);
 861             }
 862             GenericArg::Lifetime(lt) => self.visit_lifetime(lt),
 863             GenericArg::Const(ct) => self.visit_anon_const(ct),
 864         }
 865         self.diagnostic_metadata.currently_processing_generics = prev;
 866     }
 867
 868     fn visit_path_segment(&mut self, path_span: Span, path_segment: &'ast PathSegment) {
 869         if let Some(ref args) = path_segment.args {
 870             match &**args {
 871                 GenericArgs::AngleBracketed(..) => visit::walk_generic_args(self, path_span, args),
 872                 GenericArgs::Parenthesized(..) => self.with_lifetime_rib(
 873                     LifetimeRibKind::AnonymousPassThrough(path_segment.id),
 874                     |this| visit::walk_generic_args(this, path_span, args),
 875                 ),
 876             }
 877         }
 878     }
 879
 880     fn visit_where_predicate(&mut self, p: &'ast WherePredicate) {
 881         debug!("visit_where_predicate {:?}", p);
 882         let previous_value =
 883             replace(&mut self.diagnostic_metadata.current_where_predicate, Some(p));
 884         self.with_lifetime_rib(LifetimeRibKind::AnonymousReportError, |this| {
 885             if let WherePredicate::BoundPredicate(WhereBoundPredicate {
 886                 ref bounded_ty,
 887                 ref bounds,
 888                 ref bound_generic_params,
 889                 span: predicate_span,
 890                 ..
 891             }) = p
 892             {
 893                 let span = if bound_generic_params.is_empty() {
 894                     predicate_span.shrink_to_lo()
 895                 } else {
 896                     *predicate_span
 897                 };
 898                 this.with_generic_param_rib(
 899                     &bound_generic_params,
 900                     NormalRibKind,
 901                     LifetimeRibKind::Generics {
 902                         parent: bounded_ty.id,
 903                         kind: LifetimeBinderKind::WhereBound,
 904                         span,
 905                     },
 906                     |this| {
 907                         this.visit_generic_param_vec(&bound_generic_params, false);
 908                         this.visit_ty(bounded_ty);
 909                         for bound in bounds {
 910                             this.visit_param_bound(bound, BoundKind::Bound)
 911                         }
 912                     },
 913                 );
 914             } else {
 915                 visit::walk_where_predicate(this, p);
 916             }
 917         });
 918         self.diagnostic_metadata.current_where_predicate = previous_value;
 919     }
 920
 921     fn visit_inline_asm_sym(&mut self, sym: &'ast InlineAsmSym) {
 922         // This is similar to the code for AnonConst.
 923         self.with_rib(ValueNS, InlineAsmSymRibKind, |this| {
 924             this.with_rib(TypeNS, InlineAsmSymRibKind, |this| {
 925                 this.with_label_rib(InlineAsmSymRibKind, |this| {
 926                     this.smart_resolve_path(
 927                         sym.id,
 928                         sym.qself.as_ref(),
 929                         &sym.path,
 930                         PathSource::Expr(None),
 931                     );
 932                     visit::walk_inline_asm_sym(this, sym);
 933                 });
 934             })
 935         });
 936     }
 937 }
 938
 939 impl<'a: 'ast, 'b, 'ast> LateResolutionVisitor<'a, 'b, 'ast> {
 940     fn new(resolver: &'b mut Resolver<'a>) -> LateResolutionVisitor<'a, 'b, 'ast> {
 941         // During late resolution we only track the module component of the parent scope,
 942         // although it may be useful to track other components as well for diagnostics.
 943         let graph_root = resolver.graph_root;
 944         let parent_scope = ParentScope::module(graph_root, resolver);
 945         let start_rib_kind = ModuleRibKind(graph_root);
 946         LateResolutionVisitor {
 947             r: resolver,
 948             parent_scope,
 949             ribs: PerNS {
 950                 value_ns: vec![Rib::new(start_rib_kind)],
 951                 type_ns: vec![Rib::new(start_rib_kind)],
 952                 macro_ns: vec![Rib::new(start_rib_kind)],
 953             },
 954             label_ribs: Vec::new(),
 955             lifetime_ribs: Vec::new(),
 956             current_trait_ref: None,
 957             diagnostic_metadata: DiagnosticMetadata::default(),
 958             // errors at module scope should always be reported
 959             in_func_body: false,
 960         }
 961     }
 962
 963     fn maybe_resolve_ident_in_lexical_scope(
 964         &mut self,
 965         ident: Ident,
 966         ns: Namespace,
 967     ) -> Option<LexicalScopeBinding<'a>> {
 968         self.r.resolve_ident_in_lexical_scope(
 969             ident,
 970             ns,
 971             &self.parent_scope,
 972             None,
 973             &self.ribs[ns],
 974             None,
 975         )
 976     }
 977
 978     fn resolve_ident_in_lexical_scope(
 979         &mut self,
 980         ident: Ident,
 981         ns: Namespace,
 982         finalize: Option<Finalize>,
 983         ignore_binding: Option<&'a NameBinding<'a>>,
 984     ) -> Option<LexicalScopeBinding<'a>> {
 985         self.r.resolve_ident_in_lexical_scope(
 986             ident,
 987             ns,
 988             &self.parent_scope,
 989             finalize,
 990             &self.ribs[ns],
 991             ignore_binding,
 992         )
 993     }
 994
 995     fn resolve_path(
 996         &mut self,
 997         path: &[Segment],
 998         opt_ns: Option<Namespace>, // `None` indicates a module path in import
 999         finalize: Option<Finalize>,
1000     ) -> PathResult<'a> {
1001         self.r.resolve_path_with_ribs(
1002             path,
1003             opt_ns,
1004             &self.parent_scope,
1005             finalize,
1006             Some(&self.ribs),
1007             None,
1008         )
1009     }
1010
1011     // AST resolution
1012     //
1013     // We maintain a list of value ribs and type ribs.
1014     //
1015     // Simultaneously, we keep track of the current position in the module
1016     // graph in the `parent_scope.module` pointer. When we go to resolve a name in
1017     // the value or type namespaces, we first look through all the ribs and
1018     // then query the module graph. When we resolve a name in the module
1019     // namespace, we can skip all the ribs (since nested modules are not
1020     // allowed within blocks in Rust) and jump straight to the current module
1021     // graph node.
1022     //
1023     // Named implementations are handled separately. When we find a method
1024     // call, we consult the module node to find all of the implementations in
1025     // scope. This information is lazily cached in the module node. We then
1026     // generate a fake "implementation scope" containing all the
1027     // implementations thus found, for compatibility with old resolve pass.
1028
1029     /// Do some `work` within a new innermost rib of the given `kind` in the given namespace (`ns`).
1030     fn with_rib<T>(
1031         &mut self,
1032         ns: Namespace,
1033         kind: RibKind<'a>,
1034         work: impl FnOnce(&mut Self) -> T,
1035     ) -> T {
1036         self.ribs[ns].push(Rib::new(kind));
1037         let ret = work(self);
1038         self.ribs[ns].pop();
1039         ret
1040     }
1041
1042     fn with_scope<T>(&mut self, id: NodeId, f: impl FnOnce(&mut Self) -> T) -> T {
1043         if let Some(module) = self.r.get_module(self.r.local_def_id(id).to_def_id()) {
1044             // Move down in the graph.
1045             let orig_module = replace(&mut self.parent_scope.module, module);
1046             self.with_rib(ValueNS, ModuleRibKind(module), |this| {
1047                 this.with_rib(TypeNS, ModuleRibKind(module), |this| {
1048                     let ret = f(this);
1049                     this.parent_scope.module = orig_module;
1050                     ret
1051                 })
1052             })
1053         } else {
1054             f(self)
1055         }
1056     }
1057
1058     fn visit_generic_param_vec(&mut self, params: &'ast Vec<GenericParam>, add_self_upper: bool) {
1059         // For type parameter defaults, we have to ban access
1060         // to following type parameters, as the InternalSubsts can only
1061         // provide previous type parameters as they're built. We
1062         // put all the parameters on the ban list and then remove
1063         // them one by one as they are processed and become available.
1064         let mut forward_ty_ban_rib = Rib::new(ForwardGenericParamBanRibKind);
1065         let mut forward_const_ban_rib = Rib::new(ForwardGenericParamBanRibKind);
1066         for param in params.iter() {
1067             match param.kind {
1068                 GenericParamKind::Type { .. } => {
1069                     forward_ty_ban_rib
1070                         .bindings
1071                         .insert(Ident::with_dummy_span(param.ident.name), Res::Err);
1072                 }
1073                 GenericParamKind::Const { .. } => {
1074                     forward_const_ban_rib
1075                         .bindings
1076                         .insert(Ident::with_dummy_span(param.ident.name), Res::Err);
1077                 }
1078                 GenericParamKind::Lifetime => {}
1079             }
1080         }
1081
1082         // rust-lang/rust#61631: The type `Self` is essentially
1083         // another type parameter. For ADTs, we consider it
1084         // well-defined only after all of the ADT type parameters have
1085         // been provided. Therefore, we do not allow use of `Self`
1086         // anywhere in ADT type parameter defaults.
1087         //
1088         // (We however cannot ban `Self` for defaults on *all* generic
1089         // lists; e.g. trait generics can usefully refer to `Self`,
1090         // such as in the case of `trait Add<Rhs = Self>`.)
1091         if add_self_upper {
1092             // (`Some` if + only if we are in ADT's generics.)
1093             forward_ty_ban_rib.bindings.insert(Ident::with_dummy_span(kw::SelfUpper), Res::Err);
1094         }
1095
1096         self.with_lifetime_rib(LifetimeRibKind::AnonymousReportError, |this| {
1097             for param in params {
1098                 match param.kind {
1099                     GenericParamKind::Lifetime => {
1100                         for bound in &param.bounds {
1101                             this.visit_param_bound(bound, BoundKind::Bound);
1102                         }
1103                     }
1104                     GenericParamKind::Type { ref default } => {
1105                         for bound in &param.bounds {
1106                             this.visit_param_bound(bound, BoundKind::Bound);
1107                         }
1108
1109                         if let Some(ref ty) = default {
1110                             this.ribs[TypeNS].push(forward_ty_ban_rib);
1111                             this.ribs[ValueNS].push(forward_const_ban_rib);
1112                             this.visit_ty(ty);
1113                             forward_const_ban_rib = this.ribs[ValueNS].pop().unwrap();
1114                             forward_ty_ban_rib = this.ribs[TypeNS].pop().unwrap();
1115                         }
1116
1117                         // Allow all following defaults to refer to this type parameter.
1118                         forward_ty_ban_rib
1119                             .bindings
1120                             .remove(&Ident::with_dummy_span(param.ident.name));
1121                     }
1122                     GenericParamKind::Const { ref ty, kw_span: _, ref default } => {
1123                         // Const parameters can't have param bounds.
1124                         assert!(param.bounds.is_empty());
1125
1126                         this.ribs[TypeNS].push(Rib::new(ConstParamTyRibKind));
1127                         this.ribs[ValueNS].push(Rib::new(ConstParamTyRibKind));
1128                         this.with_lifetime_rib(LifetimeRibKind::ConstGeneric, |this| {
1129                             this.visit_ty(ty)
1130                         });
1131                         this.ribs[TypeNS].pop().unwrap();
1132                         this.ribs[ValueNS].pop().unwrap();
1133
1134                         if let Some(ref expr) = default {
1135                             this.ribs[TypeNS].push(forward_ty_ban_rib);
1136                             this.ribs[ValueNS].push(forward_const_ban_rib);
1137                             this.with_lifetime_rib(LifetimeRibKind::ConstGeneric, |this| {
1138                                 this.resolve_anon_const(expr, IsRepeatExpr::No)
1139                             });
1140                             forward_const_ban_rib = this.ribs[ValueNS].pop().unwrap();
1141                             forward_ty_ban_rib = this.ribs[TypeNS].pop().unwrap();
1142                         }
1143
1144                         // Allow all following defaults to refer to this const parameter.
1145                         forward_const_ban_rib
1146                             .bindings
1147                             .remove(&Ident::with_dummy_span(param.ident.name));
1148                     }
1149                 }
1150             }
1151         })
1152     }
1153
1154     #[tracing::instrument(level = "debug", skip(self, work))]
1155     fn with_lifetime_rib<T>(
1156         &mut self,
1157         kind: LifetimeRibKind,
1158         work: impl FnOnce(&mut Self) -> T,
1159     ) -> T {
1160         self.lifetime_ribs.push(LifetimeRib::new(kind));
1161         let ret = work(self);
1162         self.lifetime_ribs.pop();
1163         ret
1164     }
1165
1166     #[tracing::instrument(level = "debug", skip(self))]
1167     fn resolve_lifetime(&mut self, lifetime: &'ast Lifetime) {
1168         let ident = lifetime.ident;
1169
1170         if ident.name == kw::StaticLifetime {
1171             self.record_lifetime_res(lifetime.id, LifetimeRes::Static);
1172             return;
1173         }
1174
1175         if ident.name == kw::UnderscoreLifetime {
1176             return self.resolve_anonymous_lifetime(lifetime, false);
1177         }
1178
1179         let mut indices = (0..self.lifetime_ribs.len()).rev();
1180         for i in &mut indices {
1181             let rib = &self.lifetime_ribs[i];
1182             let normalized_ident = ident.normalize_to_macros_2_0();
1183             if let Some(&(_, region)) = rib.bindings.get(&normalized_ident) {
1184                 self.record_lifetime_res(lifetime.id, region);
1185                 return;
1186             }
1187
1188             match rib.kind {
1189                 LifetimeRibKind::Item => break,
1190                 LifetimeRibKind::ConstGeneric => {
1191                     self.emit_non_static_lt_in_const_generic_error(lifetime);
1192                     self.r.lifetimes_res_map.insert(lifetime.id, LifetimeRes::Error);
1193                     return;
1194                 }
1195                 LifetimeRibKind::AnonConst => {
1196                     self.maybe_emit_forbidden_non_static_lifetime_error(lifetime);
1197                     self.r.lifetimes_res_map.insert(lifetime.id, LifetimeRes::Error);
1198                     return;
1199                 }
1200                 _ => {}
1201             }
1202         }
1203
1204         let mut outer_res = None;
1205         for i in indices {
1206             let rib = &self.lifetime_ribs[i];
1207             let normalized_ident = ident.normalize_to_macros_2_0();
1208             if let Some((&outer, _)) = rib.bindings.get_key_value(&normalized_ident) {
1209                 outer_res = Some(outer);
1210                 break;
1211             }
1212         }
1213
1214         self.emit_undeclared_lifetime_error(lifetime, outer_res);
1215         self.record_lifetime_res(lifetime.id, LifetimeRes::Error);
1216     }
1217
1218     #[tracing::instrument(level = "debug", skip(self))]
1219     fn resolve_anonymous_lifetime(&mut self, lifetime: &Lifetime, elided: bool) {
1220         debug_assert_eq!(lifetime.ident.name, kw::UnderscoreLifetime);
1221
1222         for i in (0..self.lifetime_ribs.len()).rev() {
1223             let rib = &mut self.lifetime_ribs[i];
1224             match rib.kind {
1225                 LifetimeRibKind::AnonymousCreateParameter(item_node_id) => {
1226                     self.create_fresh_lifetime(lifetime.id, lifetime.ident, item_node_id);
1227                     return;
1228                 }
1229                 LifetimeRibKind::AnonymousReportError => {
1230                     let (msg, note) = if elided {
1231                         (
1232                             "`&` without an explicit lifetime name cannot be used here",
1233                             "explicit lifetime name needed here",
1234                         )
1235                     } else {
1236                         ("`'_` cannot be used here", "`'_` is a reserved lifetime name")
1237                     };
1238                     rustc_errors::struct_span_err!(
1239                         self.r.session,
1240                         lifetime.ident.span,
1241                         E0637,
1242                         "{}",
1243                         msg,
1244                     )
1245                     .span_label(lifetime.ident.span, note)
1246                     .emit();
1247
1248                     self.record_lifetime_res(lifetime.id, LifetimeRes::Error);
1249                     return;
1250                 }
1251                 LifetimeRibKind::AnonymousPassThrough(node_id) => {
1252                     self.record_lifetime_res(
1253                         lifetime.id,
1254                         LifetimeRes::Anonymous { binder: node_id, elided },
1255                     );
1256                     return;
1257                 }
1258                 LifetimeRibKind::Item => break,
1259                 _ => {}
1260             }
1261         }
1262         // This resolution is wrong, it passes the work to HIR lifetime resolution.
1263         // We cannot use `LifetimeRes::Error` because we do not emit a diagnostic.
1264         self.record_lifetime_res(
1265             lifetime.id,
1266             LifetimeRes::Anonymous { binder: DUMMY_NODE_ID, elided },
1267         );
1268     }
1269
1270     #[tracing::instrument(level = "debug", skip(self))]
1271     fn resolve_elided_lifetime(&mut self, anchor_id: NodeId, span: Span) {
1272         let id = self.r.next_node_id();
1273         self.record_lifetime_res(
1274             anchor_id,
1275             LifetimeRes::ElidedAnchor { start: id, end: NodeId::from_u32(id.as_u32() + 1) },
1276         );
1277
1278         let lt = Lifetime { id, ident: Ident::new(kw::UnderscoreLifetime, span) };
1279         self.resolve_anonymous_lifetime(&lt, true);
1280     }
1281
1282     #[tracing::instrument(level = "debug", skip(self))]
1283     fn create_fresh_lifetime(&mut self, id: NodeId, ident: Ident, item_node_id: NodeId) {
1284         debug_assert_eq!(ident.name, kw::UnderscoreLifetime);
1285         debug!(?ident.span);
1286         let item_def_id = self.r.local_def_id(item_node_id);
1287         let def_node_id = self.r.next_node_id();
1288         let def_id = self.r.create_def(
1289             item_def_id,
1290             def_node_id,
1291             DefPathData::LifetimeNs(kw::UnderscoreLifetime),
1292             self.parent_scope.expansion.to_expn_id(),
1293             ident.span,
1294         );
1295         debug!(?def_id);
1296
1297         let region = LifetimeRes::Fresh { param: def_id, binder: item_node_id };
1298         self.record_lifetime_res(id, region);
1299         self.r.extra_lifetime_params_map.entry(item_node_id).or_insert_with(Vec::new).push((
1300             ident,
1301             def_node_id,
1302             region,
1303         ));
1304     }
1305
1306     #[tracing::instrument(level = "debug", skip(self))]
1307     fn resolve_elided_lifetimes_in_path(
1308         &mut self,
1309         path_id: NodeId,
1310         partial_res: PartialRes,
1311         path: &[Segment],
1312         source: PathSource<'_>,
1313         path_span: Span,
1314     ) {
1315         let proj_start = path.len() - partial_res.unresolved_segments();
1316         for (i, segment) in path.iter().enumerate() {
1317             if segment.has_lifetime_args {
1318                 continue;
1319             }
1320             let Some(segment_id) = segment.id else {
1321                 continue;
1322             };
1323
1324             // Figure out if this is a type/trait segment,
1325             // which may need lifetime elision performed.
1326             let type_def_id = match partial_res.base_res() {
1327                 Res::Def(DefKind::AssocTy, def_id) if i + 2 == proj_start => {
1328                     self.r.parent(def_id).unwrap()
1329                 }
1330                 Res::Def(DefKind::Variant, def_id) if i + 1 == proj_start => {
1331                     self.r.parent(def_id).unwrap()
1332                 }
1333                 Res::Def(DefKind::Struct, def_id)
1334                 | Res::Def(DefKind::Union, def_id)
1335                 | Res::Def(DefKind::Enum, def_id)
1336                 | Res::Def(DefKind::TyAlias, def_id)
1337                 | Res::Def(DefKind::Trait, def_id)
1338                     if i + 1 == proj_start =>
1339                 {
1340                     def_id
1341                 }
1342                 _ => continue,
1343             };
1344
1345             let expected_lifetimes = self.r.item_generics_num_lifetimes(type_def_id);
1346             if expected_lifetimes == 0 {
1347                 continue;
1348             }
1349
1350             let missing = match source {
1351                 PathSource::Trait(..) | PathSource::TraitItem(..) | PathSource::Type => true,
1352                 PathSource::Expr(..)
1353                 | PathSource::Pat
1354                 | PathSource::Struct
1355                 | PathSource::TupleStruct(..) => false,
1356             };
1357             let mut res = LifetimeRes::Error;
1358             for rib in self.lifetime_ribs.iter().rev() {
1359                 match rib.kind {
1360                     // In create-parameter mode we error here because we don't want to support
1361                     // deprecated impl elision in new features like impl elision and `async fn`,
1362                     // both of which work using the `CreateParameter` mode:
1363                     //
1364                     //     impl Foo for std::cell::Ref<u32> // note lack of '_
1365                     //     async fn foo(_: std::cell::Ref<u32>) { ... }
1366                     LifetimeRibKind::AnonymousCreateParameter(_) => {
1367                         break;
1368                     }
1369                     // `PassThrough` is the normal case.
1370                     // `new_error_lifetime`, which would usually be used in the case of `ReportError`,
1371                     // is unsuitable here, as these can occur from missing lifetime parameters in a
1372                     // `PathSegment`, for which there is no associated `'_` or `&T` with no explicit
1373                     // lifetime. Instead, we simply create an implicit lifetime, which will be checked
1374                     // later, at which point a suitable error will be emitted.
1375                     LifetimeRibKind::AnonymousPassThrough(binder) => {
1376                         res = LifetimeRes::Anonymous { binder, elided: true };
1377                         break;
1378                     }
1379                     LifetimeRibKind::AnonymousReportError | LifetimeRibKind::Item => {
1380                         // FIXME(cjgillot) This resolution is wrong, but this does not matter
1381                         // since these cases are erroneous anyway.  Lifetime resolution should
1382                         // emit a "missing lifetime specifier" diagnostic.
1383                         res = LifetimeRes::Anonymous { binder: DUMMY_NODE_ID, elided: true };
1384                         break;
1385                     }
1386                     _ => {}
1387                 }
1388             }
1389
1390             let node_ids = self.r.next_node_ids(expected_lifetimes);
1391             self.record_lifetime_res(
1392                 segment_id,
1393                 LifetimeRes::ElidedAnchor { start: node_ids.start, end: node_ids.end },
1394             );
1395             for i in 0..expected_lifetimes {
1396                 let id = node_ids.start.plus(i);
1397                 self.record_lifetime_res(id, res);
1398             }
1399
1400             if !missing {
1401                 continue;
1402             }
1403
1404             let elided_lifetime_span = if segment.has_generic_args {
1405                 // If there are brackets, but not generic arguments, then use the opening bracket
1406                 segment.args_span.with_hi(segment.args_span.lo() + BytePos(1))
1407             } else {
1408                 // If there are no brackets, use the identifier span.
1409                 // HACK: we use find_ancestor_inside to properly suggest elided spans in paths
1410                 // originating from macros, since the segment's span might be from a macro arg.
1411                 segment.ident.span.find_ancestor_inside(path_span).unwrap_or(path_span)
1412             };
1413             if let LifetimeRes::Error = res {
1414                 let sess = self.r.session;
1415                 let mut err = rustc_errors::struct_span_err!(
1416                     sess,
1417                     path_span,
1418                     E0726,
1419                     "implicit elided lifetime not allowed here"
1420                 );
1421                 rustc_errors::add_elided_lifetime_in_path_suggestion(
1422                     sess.source_map(),
1423                     &mut err,
1424                     expected_lifetimes,
1425                     path_span,
1426                     !segment.has_generic_args,
1427                     elided_lifetime_span,
1428                 );
1429                 err.note("assuming a `'static` lifetime...");
1430                 err.emit();
1431             } else {
1432                 self.r.lint_buffer.buffer_lint_with_diagnostic(
1433                     lint::builtin::ELIDED_LIFETIMES_IN_PATHS,
1434                     segment_id,
1435                     elided_lifetime_span,
1436                     "hidden lifetime parameters in types are deprecated",
1437                     lint::BuiltinLintDiagnostics::ElidedLifetimesInPaths(
1438                         expected_lifetimes,
1439                         path_span,
1440                         !segment.has_generic_args,
1441                         elided_lifetime_span,
1442                     ),
1443                 );
1444             }
1445         }
1446     }
1447
1448     #[tracing::instrument(level = "debug", skip(self))]
1449     fn record_lifetime_res(&mut self, id: NodeId, res: LifetimeRes) {
1450         if let Some(prev_res) = self.r.lifetimes_res_map.insert(id, res) {
1451             panic!(
1452                 "lifetime {:?} resolved multiple times ({:?} before, {:?} now)",
1453                 id, prev_res, res
1454             )
1455         }
1456     }
1457
1458     /// Searches the current set of local scopes for labels. Returns the `NodeId` of the resolved
1459     /// label and reports an error if the label is not found or is unreachable.
1460     fn resolve_label(&mut self, mut label: Ident) -> Option<NodeId> {
1461         let mut suggestion = None;
1462
1463         // Preserve the original span so that errors contain "in this macro invocation"
1464         // information.
1465         let original_span = label.span;
1466
1467         for i in (0..self.label_ribs.len()).rev() {
1468             let rib = &self.label_ribs[i];
1469
1470             if let MacroDefinition(def) = rib.kind {
1471                 // If an invocation of this macro created `ident`, give up on `ident`
1472                 // and switch to `ident`'s source from the macro definition.
1473                 if def == self.r.macro_def(label.span.ctxt()) {
1474                     label.span.remove_mark();
1475                 }
1476             }
1477
1478             let ident = label.normalize_to_macro_rules();
1479             if let Some((ident, id)) = rib.bindings.get_key_value(&ident) {
1480                 let definition_span = ident.span;
1481                 return if self.is_label_valid_from_rib(i) {
1482                     Some(*id)
1483                 } else {
1484                     self.report_error(
1485                         original_span,
1486                         ResolutionError::UnreachableLabel {
1487                             name: label.name,
1488                             definition_span,
1489                             suggestion,
1490                         },
1491                     );
1492
1493                     None
1494                 };
1495             }
1496
1497             // Diagnostics: Check if this rib contains a label with a similar name, keep track of
1498             // the first such label that is encountered.
1499             suggestion = suggestion.or_else(|| self.suggestion_for_label_in_rib(i, label));
1500         }
1501
1502         self.report_error(
1503             original_span,
1504             ResolutionError::UndeclaredLabel { name: label.name, suggestion },
1505         );
1506         None
1507     }
1508
1509     /// Determine whether or not a label from the `rib_index`th label rib is reachable.
1510     fn is_label_valid_from_rib(&self, rib_index: usize) -> bool {
1511         let ribs = &self.label_ribs[rib_index + 1..];
1512
1513         for rib in ribs {
1514             match rib.kind {
1515                 NormalRibKind | MacroDefinition(..) => {
1516                     // Nothing to do. Continue.
1517                 }
1518
1519                 AssocItemRibKind
1520                 | ClosureOrAsyncRibKind
1521                 | FnItemRibKind
1522                 | ItemRibKind(..)
1523                 | ConstantItemRibKind(..)
1524                 | ModuleRibKind(..)
1525                 | ForwardGenericParamBanRibKind
1526                 | ConstParamTyRibKind
1527                 | InlineAsmSymRibKind => {
1528                     return false;
1529                 }
1530             }
1531         }
1532
1533         true
1534     }
1535
1536     fn resolve_adt(&mut self, item: &'ast Item, generics: &'ast Generics) {
1537         debug!("resolve_adt");
1538         self.with_current_self_item(item, |this| {
1539             this.with_generic_param_rib(
1540                 &generics.params,
1541                 ItemRibKind(HasGenericParams::Yes),
1542                 LifetimeRibKind::Generics {
1543                     parent: item.id,
1544                     kind: LifetimeBinderKind::Item,
1545                     span: generics.span,
1546                 },
1547                 |this| {
1548                     let item_def_id = this.r.local_def_id(item.id).to_def_id();
1549                     this.with_self_rib(
1550                         Res::SelfTy { trait_: None, alias_to: Some((item_def_id, false)) },
1551                         |this| {
1552                             visit::walk_item(this, item);
1553                         },
1554                     );
1555                 },
1556             );
1557         });
1558     }
1559
1560     fn future_proof_import(&mut self, use_tree: &UseTree) {
1561         let segments = &use_tree.prefix.segments;
1562         if !segments.is_empty() {
1563             let ident = segments[0].ident;
1564             if ident.is_path_segment_keyword() || ident.span.rust_2015() {
1565                 return;
1566             }
1567
1568             let nss = match use_tree.kind {
1569                 UseTreeKind::Simple(..) if segments.len() == 1 => &[TypeNS, ValueNS][..],
1570                 _ => &[TypeNS],
1571             };
1572             let report_error = |this: &Self, ns| {
1573                 let what = if ns == TypeNS { "type parameters" } else { "local variables" };
1574                 if this.should_report_errs() {
1575                     this.r
1576                         .session
1577                         .span_err(ident.span, &format!("imports cannot refer to {}", what));
1578                 }
1579             };
1580
1581             for &ns in nss {
1582                 match self.maybe_resolve_ident_in_lexical_scope(ident, ns) {
1583                     Some(LexicalScopeBinding::Res(..)) => {
1584                         report_error(self, ns);
1585                     }
1586                     Some(LexicalScopeBinding::Item(binding)) => {
1587                         if let Some(LexicalScopeBinding::Res(..)) =
1588                             self.resolve_ident_in_lexical_scope(ident, ns, None, Some(binding))
1589                         {
1590                             report_error(self, ns);
1591                         }
1592                     }
1593                     None => {}
1594                 }
1595             }
1596         } else if let UseTreeKind::Nested(use_trees) = &use_tree.kind {
1597             for (use_tree, _) in use_trees {
1598                 self.future_proof_import(use_tree);
1599             }
1600         }
1601     }
1602
1603     fn resolve_item(&mut self, item: &'ast Item) {
1604         let name = item.ident.name;
1605         debug!("(resolving item) resolving {} ({:?})", name, item.kind);
1606
1607         match item.kind {
1608             ItemKind::TyAlias(box TyAlias { ref generics, .. }) => {
1609                 self.with_generic_param_rib(
1610                     &generics.params,
1611                     ItemRibKind(HasGenericParams::Yes),
1612                     LifetimeRibKind::Generics {
1613                         parent: item.id,
1614                         kind: LifetimeBinderKind::Item,
1615                         span: generics.span,
1616                     },
1617                     |this| visit::walk_item(this, item),
1618                 );
1619             }
1620
1621             ItemKind::Fn(box Fn { ref generics, .. }) => {
1622                 self.with_generic_param_rib(
1623                     &generics.params,
1624                     ItemRibKind(HasGenericParams::Yes),
1625                     LifetimeRibKind::Generics {
1626                         parent: item.id,
1627                         kind: LifetimeBinderKind::Function,
1628                         span: generics.span,
1629                     },
1630                     |this| visit::walk_item(this, item),
1631                 );
1632             }
1633
1634             ItemKind::Enum(_, ref generics)
1635             | ItemKind::Struct(_, ref generics)
1636             | ItemKind::Union(_, ref generics) => {
1637                 self.resolve_adt(item, generics);
1638             }
1639
1640             ItemKind::Impl(box Impl {
1641                 ref generics,
1642                 ref of_trait,
1643                 ref self_ty,
1644                 items: ref impl_items,
1645                 ..
1646             }) => {
1647                 self.resolve_implementation(generics, of_trait, &self_ty, item.id, impl_items);
1648             }
1649
1650             ItemKind::Trait(box Trait { ref generics, ref bounds, ref items, .. }) => {
1651                 // Create a new rib for the trait-wide type parameters.
1652                 self.with_generic_param_rib(
1653                     &generics.params,
1654                     ItemRibKind(HasGenericParams::Yes),
1655                     LifetimeRibKind::Generics {
1656                         parent: item.id,
1657                         kind: LifetimeBinderKind::Item,
1658                         span: generics.span,
1659                     },
1660                     |this| {
1661                         let local_def_id = this.r.local_def_id(item.id).to_def_id();
1662                         this.with_self_rib(
1663                             Res::SelfTy { trait_: Some(local_def_id), alias_to: None },
1664                             |this| {
1665                                 this.visit_generics(generics);
1666                                 walk_list!(this, visit_param_bound, bounds, BoundKind::SuperTraits);
1667
1668                                 let walk_assoc_item =
1669                                     |this: &mut Self,
1670                                      generics: &Generics,
1671                                      kind,
1672                                      item: &'ast AssocItem| {
1673                                         this.with_generic_param_rib(
1674                                             &generics.params,
1675                                             AssocItemRibKind,
1676                                             LifetimeRibKind::Generics {
1677                                                 parent: item.id,
1678                                                 span: generics.span,
1679                                                 kind,
1680                                             },
1681                                             |this| {
1682                                                 visit::walk_assoc_item(this, item, AssocCtxt::Trait)
1683                                             },
1684                                         );
1685                                     };
1686
1687                                 this.with_trait_items(items, |this| {
1688                                     for item in items {
1689                                         match &item.kind {
1690                                             AssocItemKind::Const(_, ty, default) => {
1691                                                 this.visit_ty(ty);
1692                                                 // Only impose the restrictions of `ConstRibKind` for an
1693                                                 // actual constant expression in a provided default.
1694                                                 if let Some(expr) = default {
1695                                                     // We allow arbitrary const expressions inside of associated consts,
1696                                                     // even if they are potentially not const evaluatable.
1697                                                     //
1698                                                     // Type parameters can already be used and as associated consts are
1699                                                     // not used as part of the type system, this is far less surprising.
1700                                                     this.with_constant_rib(
1701                                                         IsRepeatExpr::No,
1702                                                         HasGenericParams::Yes,
1703                                                         None,
1704                                                         |this| this.visit_expr(expr),
1705                                                     );
1706                                                 }
1707                                             }
1708                                             AssocItemKind::Fn(box Fn { generics, .. }) => {
1709                                                 walk_assoc_item(
1710                                                     this,
1711                                                     generics,
1712                                                     LifetimeBinderKind::Function,
1713                                                     item,
1714                                                 );
1715                                             }
1716                                             AssocItemKind::TyAlias(box TyAlias {
1717                                                 generics,
1718                                                 ..
1719                                             }) => {
1720                                                 walk_assoc_item(
1721                                                     this,
1722                                                     generics,
1723                                                     LifetimeBinderKind::Item,
1724                                                     item,
1725                                                 );
1726                                             }
1727                                             AssocItemKind::MacCall(_) => {
1728                                                 panic!("unexpanded macro in resolve!")
1729                                             }
1730                                         };
1731                                     }
1732                                 });
1733                             },
1734                         );
1735                     },
1736                 );
1737             }
1738
1739             ItemKind::TraitAlias(ref generics, ref bounds) => {
1740                 // Create a new rib for the trait-wide type parameters.
1741                 self.with_generic_param_rib(
1742                     &generics.params,
1743                     ItemRibKind(HasGenericParams::Yes),
1744                     LifetimeRibKind::Generics {
1745                         parent: item.id,
1746                         kind: LifetimeBinderKind::Item,
1747                         span: generics.span,
1748                     },
1749                     |this| {
1750                         let local_def_id = this.r.local_def_id(item.id).to_def_id();
1751                         this.with_self_rib(
1752                             Res::SelfTy { trait_: Some(local_def_id), alias_to: None },
1753                             |this| {
1754                                 this.visit_generics(generics);
1755                                 walk_list!(this, visit_param_bound, bounds, BoundKind::Bound);
1756                             },
1757                         );
1758                     },
1759                 );
1760             }
1761
1762             ItemKind::Mod(..) | ItemKind::ForeignMod(_) => {
1763                 self.with_scope(item.id, |this| {
1764                     visit::walk_item(this, item);
1765                 });
1766             }
1767
1768             ItemKind::Static(ref ty, _, ref expr) | ItemKind::Const(_, ref ty, ref expr) => {
1769                 self.with_item_rib(|this| {
1770                     this.visit_ty(ty);
1771                     if let Some(expr) = expr {
1772                         let constant_item_kind = match item.kind {
1773                             ItemKind::Const(..) => ConstantItemKind::Const,
1774                             ItemKind::Static(..) => ConstantItemKind::Static,
1775                             _ => unreachable!(),
1776                         };
1777                         // We already forbid generic params because of the above item rib,
1778                         // so it doesn't matter whether this is a trivial constant.
1779                         this.with_constant_rib(
1780                             IsRepeatExpr::No,
1781                             HasGenericParams::Yes,
1782                             Some((item.ident, constant_item_kind)),
1783                             |this| this.visit_expr(expr),
1784                         );
1785                     }
1786                 });
1787             }
1788
1789             ItemKind::Use(ref use_tree) => {
1790                 self.future_proof_import(use_tree);
1791             }
1792
1793             ItemKind::ExternCrate(..) | ItemKind::MacroDef(..) => {
1794                 // do nothing, these are just around to be encoded
1795             }
1796
1797             ItemKind::GlobalAsm(_) => {
1798                 visit::walk_item(self, item);
1799             }
1800
1801             ItemKind::MacCall(_) => panic!("unexpanded macro in resolve!"),
1802         }
1803     }
1804
1805     fn with_generic_param_rib<'c, F>(
1806         &'c mut self,
1807         params: &'c Vec<GenericParam>,
1808         kind: RibKind<'a>,
1809         lifetime_kind: LifetimeRibKind,
1810         f: F,
1811     ) where
1812         F: FnOnce(&mut Self),
1813     {
1814         debug!("with_generic_param_rib");
1815         let mut function_type_rib = Rib::new(kind);
1816         let mut function_value_rib = Rib::new(kind);
1817         let mut function_lifetime_rib = LifetimeRib::new(lifetime_kind);
1818         let mut seen_bindings = FxHashMap::default();
1819
1820         // We also can't shadow bindings from the parent item
1821         if let AssocItemRibKind = kind {
1822             let mut add_bindings_for_ns = |ns| {
1823                 let parent_rib = self.ribs[ns]
1824                     .iter()
1825                     .rfind(|r| matches!(r.kind, ItemRibKind(_)))
1826                     .expect("associated item outside of an item");
1827                 seen_bindings
1828                     .extend(parent_rib.bindings.iter().map(|(ident, _)| (*ident, ident.span)));
1829             };
1830             add_bindings_for_ns(ValueNS);
1831             add_bindings_for_ns(TypeNS);
1832         }
1833
1834         for param in params {
1835             let ident = param.ident.normalize_to_macros_2_0();
1836             debug!("with_generic_param_rib: {}", param.id);
1837
1838             match seen_bindings.entry(ident) {
1839                 Entry::Occupied(entry) => {
1840                     let span = *entry.get();
1841                     let err = ResolutionError::NameAlreadyUsedInParameterList(ident.name, span);
1842                     if !matches!(param.kind, GenericParamKind::Lifetime) {
1843                         self.report_error(param.ident.span, err);
1844                     }
1845                 }
1846                 Entry::Vacant(entry) => {
1847                     entry.insert(param.ident.span);
1848                 }
1849             }
1850
1851             if param.ident.name == kw::UnderscoreLifetime {
1852                 rustc_errors::struct_span_err!(
1853                     self.r.session,
1854                     param.ident.span,
1855                     E0637,
1856                     "`'_` cannot be used here"
1857                 )
1858                 .span_label(param.ident.span, "`'_` is a reserved lifetime name")
1859                 .emit();
1860                 continue;
1861             }
1862
1863             if param.ident.name == kw::StaticLifetime {
1864                 rustc_errors::struct_span_err!(
1865                     self.r.session,
1866                     param.ident.span,
1867                     E0262,
1868                     "invalid lifetime parameter name: `{}`",
1869                     param.ident,
1870                 )
1871                 .span_label(param.ident.span, "'static is a reserved lifetime name")
1872                 .emit();
1873                 continue;
1874             }
1875
1876             let def_id = self.r.local_def_id(param.id);
1877
1878             // Plain insert (no renaming).
1879             let (rib, def_kind) = match param.kind {
1880                 GenericParamKind::Type { .. } => (&mut function_type_rib, DefKind::TyParam),
1881                 GenericParamKind::Const { .. } => (&mut function_value_rib, DefKind::ConstParam),
1882                 GenericParamKind::Lifetime => {
1883                     let LifetimeRibKind::Generics { parent, .. } = lifetime_kind else { panic!() };
1884                     let res = LifetimeRes::Param { param: def_id, binder: parent };
1885                     self.record_lifetime_res(param.id, res);
1886                     function_lifetime_rib.bindings.insert(ident, (param.id, res));
1887                     continue;
1888                 }
1889             };
1890             let res = Res::Def(def_kind, def_id.to_def_id());
1891             self.r.record_partial_res(param.id, PartialRes::new(res));
1892             rib.bindings.insert(ident, res);
1893         }
1894
1895         self.lifetime_ribs.push(function_lifetime_rib);
1896         self.ribs[ValueNS].push(function_value_rib);
1897         self.ribs[TypeNS].push(function_type_rib);
1898
1899         f(self);
1900
1901         self.ribs[TypeNS].pop();
1902         self.ribs[ValueNS].pop();
1903         self.lifetime_ribs.pop();
1904     }
1905
1906     fn with_label_rib(&mut self, kind: RibKind<'a>, f: impl FnOnce(&mut Self)) {
1907         self.label_ribs.push(Rib::new(kind));
1908         f(self);
1909         self.label_ribs.pop();
1910     }
1911
1912     fn with_item_rib(&mut self, f: impl FnOnce(&mut Self)) {
1913         let kind = ItemRibKind(HasGenericParams::No);
1914         self.with_lifetime_rib(LifetimeRibKind::Item, |this| {
1915             this.with_rib(ValueNS, kind, |this| this.with_rib(TypeNS, kind, f))
1916         })
1917     }
1918
1919     // HACK(min_const_generics,const_evaluatable_unchecked): We
1920     // want to keep allowing `[0; std::mem::size_of::<*mut T>()]`
1921     // with a future compat lint for now. We do this by adding an
1922     // additional special case for repeat expressions.
1923     //
1924     // Note that we intentionally still forbid `[0; N + 1]` during
1925     // name resolution so that we don't extend the future
1926     // compat lint to new cases.
1927     #[instrument(level = "debug", skip(self, f))]
1928     fn with_constant_rib(
1929         &mut self,
1930         is_repeat: IsRepeatExpr,
1931         may_use_generics: HasGenericParams,
1932         item: Option<(Ident, ConstantItemKind)>,
1933         f: impl FnOnce(&mut Self),
1934     ) {
1935         self.with_rib(ValueNS, ConstantItemRibKind(may_use_generics, item), |this| {
1936             this.with_rib(
1937                 TypeNS,
1938                 ConstantItemRibKind(
1939                     may_use_generics.force_yes_if(is_repeat == IsRepeatExpr::Yes),
1940                     item,
1941                 ),
1942                 |this| {
1943                     this.with_label_rib(ConstantItemRibKind(may_use_generics, item), f);
1944                 },
1945             )
1946         });
1947     }
1948
1949     fn with_current_self_type<T>(&mut self, self_type: &Ty, f: impl FnOnce(&mut Self) -> T) -> T {
1950         // Handle nested impls (inside fn bodies)
1951         let previous_value =
1952             replace(&mut self.diagnostic_metadata.current_self_type, Some(self_type.clone()));
1953         let result = f(self);
1954         self.diagnostic_metadata.current_self_type = previous_value;
1955         result
1956     }
1957
1958     fn with_current_self_item<T>(&mut self, self_item: &Item, f: impl FnOnce(&mut Self) -> T) -> T {
1959         let previous_value =
1960             replace(&mut self.diagnostic_metadata.current_self_item, Some(self_item.id));
1961         let result = f(self);
1962         self.diagnostic_metadata.current_self_item = previous_value;
1963         result
1964     }
1965
1966     /// When evaluating a `trait` use its associated types' idents for suggestions in E0412.
1967     fn with_trait_items<T>(
1968         &mut self,
1969         trait_items: &'ast [P<AssocItem>],
1970         f: impl FnOnce(&mut Self) -> T,
1971     ) -> T {
1972         let trait_assoc_items =
1973             replace(&mut self.diagnostic_metadata.current_trait_assoc_items, Some(&trait_items));
1974         let result = f(self);
1975         self.diagnostic_metadata.current_trait_assoc_items = trait_assoc_items;
1976         result
1977     }
1978
1979     /// This is called to resolve a trait reference from an `impl` (i.e., `impl Trait for Foo`).
1980     fn with_optional_trait_ref<T>(
1981         &mut self,
1982         opt_trait_ref: Option<&TraitRef>,
1983         f: impl FnOnce(&mut Self, Option<DefId>) -> T,
1984     ) -> T {
1985         let mut new_val = None;
1986         let mut new_id = None;
1987         if let Some(trait_ref) = opt_trait_ref {
1988             let path: Vec<_> = Segment::from_path(&trait_ref.path);
1989             let res = self.smart_resolve_path_fragment(
1990                 None,
1991                 &path,
1992                 PathSource::Trait(AliasPossibility::No),
1993                 Finalize::new(trait_ref.ref_id, trait_ref.path.span),
1994             );
1995             if let Some(def_id) = res.base_res().opt_def_id() {
1996                 new_id = Some(def_id);
1997                 new_val = Some((self.r.expect_module(def_id), trait_ref.clone()));
1998             }
1999         }
2000         let original_trait_ref = replace(&mut self.current_trait_ref, new_val);
2001         let result = f(self, new_id);
2002         self.current_trait_ref = original_trait_ref;
2003         result
2004     }
2005
2006     fn with_self_rib_ns(&mut self, ns: Namespace, self_res: Res, f: impl FnOnce(&mut Self)) {
2007         let mut self_type_rib = Rib::new(NormalRibKind);
2008
2009         // Plain insert (no renaming, since types are not currently hygienic)
2010         self_type_rib.bindings.insert(Ident::with_dummy_span(kw::SelfUpper), self_res);
2011         self.ribs[ns].push(self_type_rib);
2012         f(self);
2013         self.ribs[ns].pop();
2014     }
2015
2016     fn with_self_rib(&mut self, self_res: Res, f: impl FnOnce(&mut Self)) {
2017         self.with_self_rib_ns(TypeNS, self_res, f)
2018     }
2019
2020     fn resolve_implementation(
2021         &mut self,
2022         generics: &'ast Generics,
2023         opt_trait_reference: &'ast Option<TraitRef>,
2024         self_type: &'ast Ty,
2025         item_id: NodeId,
2026         impl_items: &'ast [P<AssocItem>],
2027     ) {
2028         debug!("resolve_implementation");
2029         // If applicable, create a rib for the type parameters.
2030         self.with_generic_param_rib(&generics.params, ItemRibKind(HasGenericParams::Yes), LifetimeRibKind::Generics { span: generics.span, parent: item_id, kind: LifetimeBinderKind::ImplBlock }, |this| {
2031             // Dummy self type for better errors if `Self` is used in the trait path.
2032             this.with_self_rib(Res::SelfTy { trait_: None, alias_to: None }, |this| {
2033                 this.with_lifetime_rib(LifetimeRibKind::AnonymousCreateParameter(item_id), |this| {
2034                     // Resolve the trait reference, if necessary.
2035                     this.with_optional_trait_ref(opt_trait_reference.as_ref(), |this, trait_id| {
2036                         let item_def_id = this.r.local_def_id(item_id);
2037
2038                         // Register the trait definitions from here.
2039                         if let Some(trait_id) = trait_id {
2040                             this.r.trait_impls.entry(trait_id).or_default().push(item_def_id);
2041                         }
2042
2043                         let item_def_id = item_def_id.to_def_id();
2044                         let res =
2045                             Res::SelfTy { trait_: trait_id, alias_to: Some((item_def_id, false)) };
2046                         this.with_self_rib(res, |this| {
2047                             if let Some(trait_ref) = opt_trait_reference.as_ref() {
2048                                 // Resolve type arguments in the trait path.
2049                                 visit::walk_trait_ref(this, trait_ref);
2050                             }
2051                             // Resolve the self type.
2052                             this.visit_ty(self_type);
2053                             // Resolve the generic parameters.
2054                             this.visit_generics(generics);
2055
2056                             // Resolve the items within the impl.
2057                             this.with_lifetime_rib(LifetimeRibKind::AnonymousPassThrough(item_id),
2058                                 |this| {
2059                                     this.with_current_self_type(self_type, |this| {
2060                                         this.with_self_rib_ns(ValueNS, Res::SelfCtor(item_def_id), |this| {
2061                                             debug!("resolve_implementation with_self_rib_ns(ValueNS, ...)");
2062                                             for item in impl_items {
2063                                                 use crate::ResolutionError::*;
2064                                                 match &item.kind {
2065                                                     AssocItemKind::Const(_default, _ty, _expr) => {
2066                                                         debug!("resolve_implementation AssocItemKind::Const");
2067                                                         // If this is a trait impl, ensure the const
2068                                                         // exists in trait
2069                                                         this.check_trait_item(
2070                                                             item.id,
2071                                                             item.ident,
2072                                                             &item.kind,
2073                                                             ValueNS,
2074                                                             item.span,
2075                                                             |i, s, c| ConstNotMemberOfTrait(i, s, c),
2076                                                         );
2077
2078                                                         // We allow arbitrary const expressions inside of associated consts,
2079                                                         // even if they are potentially not const evaluatable.
2080                                                         //
2081                                                         // Type parameters can already be used and as associated consts are
2082                                                         // not used as part of the type system, this is far less surprising.
2083                                                         this.with_constant_rib(
2084                                                             IsRepeatExpr::No,
2085                                                             HasGenericParams::Yes,
2086                                                             None,
2087                                                             |this| {
2088                                                                 visit::walk_assoc_item(
2089                                                                     this,
2090                                                                     item,
2091                                                                     AssocCtxt::Impl,
2092                                                                 )
2093                                                             },
2094                                                         );
2095                                                     }
2096                                                     AssocItemKind::Fn(box Fn { generics, .. }) => {
2097                                                         debug!("resolve_implementation AssocItemKind::Fn");
2098                                                         // We also need a new scope for the impl item type parameters.
2099                                                         this.with_generic_param_rib(
2100                                                             &generics.params,
2101                                                             AssocItemRibKind,
2102                                                             LifetimeRibKind::Generics { parent: item.id, span: generics.span, kind: LifetimeBinderKind::Function },
2103                                                             |this| {
2104                                                                 // If this is a trait impl, ensure the method
2105                                                                 // exists in trait
2106                                                                 this.check_trait_item(
2107                                                                     item.id,
2108                                                                     item.ident,
2109                                                                     &item.kind,
2110                                                                     ValueNS,
2111                                                                     item.span,
2112                                                                     |i, s, c| MethodNotMemberOfTrait(i, s, c),
2113                                                                 );
2114
2115                                                                 visit::walk_assoc_item(
2116                                                                     this,
2117                                                                     item,
2118                                                                     AssocCtxt::Impl,
2119                                                                 )
2120                                                             },
2121                                                         );
2122                                                     }
2123                                                     AssocItemKind::TyAlias(box TyAlias {
2124                                                         generics, ..
2125                                                     }) => {
2126                                                         debug!("resolve_implementation AssocItemKind::TyAlias");
2127                                                         // We also need a new scope for the impl item type parameters.
2128                                                         this.with_generic_param_rib(
2129                                                             &generics.params,
2130                                                             AssocItemRibKind,
2131                                                             LifetimeRibKind::Generics { parent: item.id, span: generics.span, kind: LifetimeBinderKind::Item },
2132                                                             |this| {
2133                                                                 // If this is a trait impl, ensure the type
2134                                                                 // exists in trait
2135                                                                 this.check_trait_item(
2136                                                                     item.id,
2137                                                                     item.ident,
2138                                                                     &item.kind,
2139                                                                     TypeNS,
2140                                                                     item.span,
2141                                                                     |i, s, c| TypeNotMemberOfTrait(i, s, c),
2142                                                                 );
2143
2144                                                                 visit::walk_assoc_item(
2145                                                                     this,
2146                                                                     item,
2147                                                                     AssocCtxt::Impl,
2148                                                                 )
2149                                                             },
2150                                                         );
2151                                                     }
2152                                                     AssocItemKind::MacCall(_) => {
2153                                                         panic!("unexpanded macro in resolve!")
2154                                                     }
2155                                                 }
2156                                             }
2157                                         });
2158                                     });
2159                                 },
2160                             );
2161                         });
2162                     });
2163                 });
2164             });
2165         });
2166     }
2167
2168     fn check_trait_item<F>(
2169         &mut self,
2170         id: NodeId,
2171         mut ident: Ident,
2172         kind: &AssocItemKind,
2173         ns: Namespace,
2174         span: Span,
2175         err: F,
2176     ) where
2177         F: FnOnce(Ident, String, Option<Symbol>) -> ResolutionError<'a>,
2178     {
2179         // If there is a TraitRef in scope for an impl, then the method must be in the trait.
2180         let Some((module, _)) = &self.current_trait_ref else { return; };
2181         ident.span.normalize_to_macros_2_0_and_adjust(module.expansion);
2182         let key = self.r.new_key(ident, ns);
2183         let mut binding = self.r.resolution(module, key).try_borrow().ok().and_then(|r| r.binding);
2184         debug!(?binding);
2185         if binding.is_none() {
2186             // We could not find the trait item in the correct namespace.
2187             // Check the other namespace to report an error.
2188             let ns = match ns {
2189                 ValueNS => TypeNS,
2190                 TypeNS => ValueNS,
2191                 _ => ns,
2192             };
2193             let key = self.r.new_key(ident, ns);
2194             binding = self.r.resolution(module, key).try_borrow().ok().and_then(|r| r.binding);
2195             debug!(?binding);
2196         }
2197         let Some(binding) = binding else {
2198             // We could not find the method: report an error.
2199             let candidate = self.find_similarly_named_assoc_item(ident.name, kind);
2200             let path = &self.current_trait_ref.as_ref().unwrap().1.path;
2201             let path_names = path_names_to_string(path);
2202             self.report_error(span, err(ident, path_names, candidate));
2203             return;
2204         };
2205
2206         let res = binding.res();
2207         let Res::Def(def_kind, _) = res else { bug!() };
2208         match (def_kind, kind) {
2209             (DefKind::AssocTy, AssocItemKind::TyAlias(..))
2210             | (DefKind::AssocFn, AssocItemKind::Fn(..))
2211             | (DefKind::AssocConst, AssocItemKind::Const(..)) => {
2212                 self.r.record_partial_res(id, PartialRes::new(res));
2213                 return;
2214             }
2215             _ => {}
2216         }
2217
2218         // The method kind does not correspond to what appeared in the trait, report.
2219         let path = &self.current_trait_ref.as_ref().unwrap().1.path;
2220         let (code, kind) = match kind {
2221             AssocItemKind::Const(..) => (rustc_errors::error_code!(E0323), "const"),
2222             AssocItemKind::Fn(..) => (rustc_errors::error_code!(E0324), "method"),
2223             AssocItemKind::TyAlias(..) => (rustc_errors::error_code!(E0325), "type"),
2224             AssocItemKind::MacCall(..) => span_bug!(span, "unexpanded macro"),
2225         };
2226         let trait_path = path_names_to_string(path);
2227         self.report_error(
2228             span,
2229             ResolutionError::TraitImplMismatch {
2230                 name: ident.name,
2231                 kind,
2232                 code,
2233                 trait_path,
2234                 trait_item_span: binding.span,
2235             },
2236         );
2237     }
2238
2239     fn resolve_params(&mut self, params: &'ast [Param]) {
2240         let mut bindings = smallvec![(PatBoundCtx::Product, Default::default())];
2241         for Param { pat, ty, .. } in params {
2242             self.resolve_pattern(pat, PatternSource::FnParam, &mut bindings);
2243             self.visit_ty(ty);
2244             debug!("(resolving function / closure) recorded parameter");
2245         }
2246     }
2247
2248     fn resolve_local(&mut self, local: &'ast Local) {
2249         debug!("resolving local ({:?})", local);
2250         // Resolve the type.
2251         walk_list!(self, visit_ty, &local.ty);
2252
2253         // Resolve the initializer.
2254         if let Some((init, els)) = local.kind.init_else_opt() {
2255             self.visit_expr(init);
2256
2257             // Resolve the `else` block
2258             if let Some(els) = els {
2259                 self.visit_block(els);
2260             }
2261         }
2262
2263         // Resolve the pattern.
2264         self.resolve_pattern_top(&local.pat, PatternSource::Let);
2265     }
2266
2267     /// build a map from pattern identifiers to binding-info's.
2268     /// this is done hygienically. This could arise for a macro
2269     /// that expands into an or-pattern where one 'x' was from the
2270     /// user and one 'x' came from the macro.
2271     fn binding_mode_map(&mut self, pat: &Pat) -> BindingMap {
2272         let mut binding_map = FxHashMap::default();
2273
2274         pat.walk(&mut |pat| {
2275             match pat.kind {
2276                 PatKind::Ident(binding_mode, ident, ref sub_pat)
2277                     if sub_pat.is_some() || self.is_base_res_local(pat.id) =>
2278                 {
2279                     binding_map.insert(ident, BindingInfo { span: ident.span, binding_mode });
2280                 }
2281                 PatKind::Or(ref ps) => {
2282                     // Check the consistency of this or-pattern and
2283                     // then add all bindings to the larger map.
2284                     for bm in self.check_consistent_bindings(ps) {
2285                         binding_map.extend(bm);
2286                     }
2287                     return false;
2288                 }
2289                 _ => {}
2290             }
2291
2292             true
2293         });
2294
2295         binding_map
2296     }
2297
2298     fn is_base_res_local(&self, nid: NodeId) -> bool {
2299         matches!(self.r.partial_res_map.get(&nid).map(|res| res.base_res()), Some(Res::Local(..)))
2300     }
2301
2302     /// Checks that all of the arms in an or-pattern have exactly the
2303     /// same set of bindings, with the same binding modes for each.
2304     fn check_consistent_bindings(&mut self, pats: &[P<Pat>]) -> Vec<BindingMap> {
2305         let mut missing_vars = FxHashMap::default();
2306         let mut inconsistent_vars = FxHashMap::default();
2307
2308         // 1) Compute the binding maps of all arms.
2309         let maps = pats.iter().map(|pat| self.binding_mode_map(pat)).collect::<Vec<_>>();
2310
2311         // 2) Record any missing bindings or binding mode inconsistencies.
2312         for (map_outer, pat_outer) in pats.iter().enumerate().map(|(idx, pat)| (&maps[idx], pat)) {
2313             // Check against all arms except for the same pattern which is always self-consistent.
2314             let inners = pats
2315                 .iter()
2316                 .enumerate()
2317                 .filter(|(_, pat)| pat.id != pat_outer.id)
2318                 .flat_map(|(idx, _)| maps[idx].iter())
2319                 .map(|(key, binding)| (key.name, map_outer.get(&key), binding));
2320
2321             for (name, info, &binding_inner) in inners {
2322                 match info {
2323                     None => {
2324                         // The inner binding is missing in the outer.
2325                         let binding_error =
2326                             missing_vars.entry(name).or_insert_with(|| BindingError {
2327                                 name,
2328                                 origin: BTreeSet::new(),
2329                                 target: BTreeSet::new(),
2330                                 could_be_path: name.as_str().starts_with(char::is_uppercase),
2331                             });
2332                         binding_error.origin.insert(binding_inner.span);
2333                         binding_error.target.insert(pat_outer.span);
2334                     }
2335                     Some(binding_outer) => {
2336                         if binding_outer.binding_mode != binding_inner.binding_mode {
2337                             // The binding modes in the outer and inner bindings differ.
2338                             inconsistent_vars
2339                                 .entry(name)
2340                                 .or_insert((binding_inner.span, binding_outer.span));
2341                         }
2342                     }
2343                 }
2344             }
2345         }
2346
2347         // 3) Report all missing variables we found.
2348         let mut missing_vars = missing_vars.into_iter().collect::<Vec<_>>();
2349         missing_vars.sort_by_key(|&(sym, ref _err)| sym);
2350
2351         for (name, mut v) in missing_vars.into_iter() {
2352             if inconsistent_vars.contains_key(&name) {
2353                 v.could_be_path = false;
2354             }
2355             self.report_error(
2356                 *v.origin.iter().next().unwrap(),
2357                 ResolutionError::VariableNotBoundInPattern(v, self.parent_scope),
2358             );
2359         }
2360
2361         // 4) Report all inconsistencies in binding modes we found.
2362         let mut inconsistent_vars = inconsistent_vars.iter().collect::<Vec<_>>();
2363         inconsistent_vars.sort();
2364         for (name, v) in inconsistent_vars {
2365             self.report_error(v.0, ResolutionError::VariableBoundWithDifferentMode(*name, v.1));
2366         }
2367
2368         // 5) Finally bubble up all the binding maps.
2369         maps
2370     }
2371
2372     /// Check the consistency of the outermost or-patterns.
2373     fn check_consistent_bindings_top(&mut self, pat: &'ast Pat) {
2374         pat.walk(&mut |pat| match pat.kind {
2375             PatKind::Or(ref ps) => {
2376                 self.check_consistent_bindings(ps);
2377                 false
2378             }
2379             _ => true,
2380         })
2381     }
2382
2383     fn resolve_arm(&mut self, arm: &'ast Arm) {
2384         self.with_rib(ValueNS, NormalRibKind, |this| {
2385             this.resolve_pattern_top(&arm.pat, PatternSource::Match);
2386             walk_list!(this, visit_expr, &arm.guard);
2387             this.visit_expr(&arm.body);
2388         });
2389     }
2390
2391     /// Arising from `source`, resolve a top level pattern.
2392     fn resolve_pattern_top(&mut self, pat: &'ast Pat, pat_src: PatternSource) {
2393         let mut bindings = smallvec![(PatBoundCtx::Product, Default::default())];
2394         self.resolve_pattern(pat, pat_src, &mut bindings);
2395     }
2396
2397     fn resolve_pattern(
2398         &mut self,
2399         pat: &'ast Pat,
2400         pat_src: PatternSource,
2401         bindings: &mut SmallVec<[(PatBoundCtx, FxHashSet<Ident>); 1]>,
2402     ) {
2403         // We walk the pattern before declaring the pattern's inner bindings,
2404         // so that we avoid resolving a literal expression to a binding defined
2405         // by the pattern.
2406         visit::walk_pat(self, pat);
2407         self.resolve_pattern_inner(pat, pat_src, bindings);
2408         // This has to happen *after* we determine which pat_idents are variants:
2409         self.check_consistent_bindings_top(pat);
2410     }
2411
2412     /// Resolve bindings in a pattern. This is a helper to `resolve_pattern`.
2413     ///
2414     /// ### `bindings`
2415     ///
2416     /// A stack of sets of bindings accumulated.
2417     ///
2418     /// In each set, `PatBoundCtx::Product` denotes that a found binding in it should
2419     /// be interpreted as re-binding an already bound binding. This results in an error.
2420     /// Meanwhile, `PatBound::Or` denotes that a found binding in the set should result
2421     /// in reusing this binding rather than creating a fresh one.
2422     ///
2423     /// When called at the top level, the stack must have a single element
2424     /// with `PatBound::Product`. Otherwise, pushing to the stack happens as
2425     /// or-patterns (`p_0 | ... | p_n`) are encountered and the context needs
2426     /// to be switched to `PatBoundCtx::Or` and then `PatBoundCtx::Product` for each `p_i`.
2427     /// When each `p_i` has been dealt with, the top set is merged with its parent.
2428     /// When a whole or-pattern has been dealt with, the thing happens.
2429     ///
2430     /// See the implementation and `fresh_binding` for more details.
2431     fn resolve_pattern_inner(
2432         &mut self,
2433         pat: &Pat,
2434         pat_src: PatternSource,
2435         bindings: &mut SmallVec<[(PatBoundCtx, FxHashSet<Ident>); 1]>,
2436     ) {
2437         // Visit all direct subpatterns of this pattern.
2438         pat.walk(&mut |pat| {
2439             debug!("resolve_pattern pat={:?} node={:?}", pat, pat.kind);
2440             match pat.kind {
2441                 PatKind::Ident(bmode, ident, ref sub) => {
2442                     // First try to resolve the identifier as some existing entity,
2443                     // then fall back to a fresh binding.
2444                     let has_sub = sub.is_some();
2445                     let res = self
2446                         .try_resolve_as_non_binding(pat_src, bmode, ident, has_sub)
2447                         .unwrap_or_else(|| self.fresh_binding(ident, pat.id, pat_src, bindings));
2448                     self.r.record_partial_res(pat.id, PartialRes::new(res));
2449                     self.r.record_pat_span(pat.id, pat.span);
2450                 }
2451                 PatKind::TupleStruct(ref qself, ref path, ref sub_patterns) => {
2452                     self.smart_resolve_path(
2453                         pat.id,
2454                         qself.as_ref(),
2455                         path,
2456                         PathSource::TupleStruct(
2457                             pat.span,
2458                             self.r.arenas.alloc_pattern_spans(sub_patterns.iter().map(|p| p.span)),
2459                         ),
2460                     );
2461                 }
2462                 PatKind::Path(ref qself, ref path) => {
2463                     self.smart_resolve_path(pat.id, qself.as_ref(), path, PathSource::Pat);
2464                 }
2465                 PatKind::Struct(ref qself, ref path, ..) => {
2466                     self.smart_resolve_path(pat.id, qself.as_ref(), path, PathSource::Struct);
2467                 }
2468                 PatKind::Or(ref ps) => {
2469                     // Add a new set of bindings to the stack. `Or` here records that when a
2470                     // binding already exists in this set, it should not result in an error because
2471                     // `V1(a) | V2(a)` must be allowed and are checked for consistency later.
2472                     bindings.push((PatBoundCtx::Or, Default::default()));
2473                     for p in ps {
2474                         // Now we need to switch back to a product context so that each
2475                         // part of the or-pattern internally rejects already bound names.
2476                         // For example, `V1(a) | V2(a, a)` and `V1(a, a) | V2(a)` are bad.
2477                         bindings.push((PatBoundCtx::Product, Default::default()));
2478                         self.resolve_pattern_inner(p, pat_src, bindings);
2479                         // Move up the non-overlapping bindings to the or-pattern.
2480                         // Existing bindings just get "merged".
2481                         let collected = bindings.pop().unwrap().1;
2482                         bindings.last_mut().unwrap().1.extend(collected);
2483                     }
2484                     // This or-pattern itself can itself be part of a product,
2485                     // e.g. `(V1(a) | V2(a), a)` or `(a, V1(a) | V2(a))`.
2486                     // Both cases bind `a` again in a product pattern and must be rejected.
2487                     let collected = bindings.pop().unwrap().1;
2488                     bindings.last_mut().unwrap().1.extend(collected);
2489
2490                     // Prevent visiting `ps` as we've already done so above.
2491                     return false;
2492                 }
2493                 _ => {}
2494             }
2495             true
2496         });
2497     }
2498
2499     fn fresh_binding(
2500         &mut self,
2501         ident: Ident,
2502         pat_id: NodeId,
2503         pat_src: PatternSource,
2504         bindings: &mut SmallVec<[(PatBoundCtx, FxHashSet<Ident>); 1]>,
2505     ) -> Res {
2506         // Add the binding to the local ribs, if it doesn't already exist in the bindings map.
2507         // (We must not add it if it's in the bindings map because that breaks the assumptions
2508         // later passes make about or-patterns.)
2509         let ident = ident.normalize_to_macro_rules();
2510
2511         let mut bound_iter = bindings.iter().filter(|(_, set)| set.contains(&ident));
2512         // Already bound in a product pattern? e.g. `(a, a)` which is not allowed.
2513         let already_bound_and = bound_iter.clone().any(|(ctx, _)| *ctx == PatBoundCtx::Product);
2514         // Already bound in an or-pattern? e.g. `V1(a) | V2(a)`.
2515         // This is *required* for consistency which is checked later.
2516         let already_bound_or = bound_iter.any(|(ctx, _)| *ctx == PatBoundCtx::Or);
2517
2518         if already_bound_and {
2519             // Overlap in a product pattern somewhere; report an error.
2520             use ResolutionError::*;
2521             let error = match pat_src {
2522                 // `fn f(a: u8, a: u8)`:
2523                 PatternSource::FnParam => IdentifierBoundMoreThanOnceInParameterList,
2524                 // `Variant(a, a)`:
2525                 _ => IdentifierBoundMoreThanOnceInSamePattern,
2526             };
2527             self.report_error(ident.span, error(ident.name));
2528         }
2529
2530         // Record as bound if it's valid:
2531         let ident_valid = ident.name != kw::Empty;
2532         if ident_valid {
2533             bindings.last_mut().unwrap().1.insert(ident);
2534         }
2535
2536         if already_bound_or {
2537             // `Variant1(a) | Variant2(a)`, ok
2538             // Reuse definition from the first `a`.
2539             self.innermost_rib_bindings(ValueNS)[&ident]
2540         } else {
2541             let res = Res::Local(pat_id);
2542             if ident_valid {
2543                 // A completely fresh binding add to the set if it's valid.
2544                 self.innermost_rib_bindings(ValueNS).insert(ident, res);
2545             }
2546             res
2547         }
2548     }
2549
2550     fn innermost_rib_bindings(&mut self, ns: Namespace) -> &mut IdentMap<Res> {
2551         &mut self.ribs[ns].last_mut().unwrap().bindings
2552     }
2553
2554     fn try_resolve_as_non_binding(
2555         &mut self,
2556         pat_src: PatternSource,
2557         bm: BindingMode,
2558         ident: Ident,
2559         has_sub: bool,
2560     ) -> Option<Res> {
2561         // An immutable (no `mut`) by-value (no `ref`) binding pattern without
2562         // a sub pattern (no `@ $pat`) is syntactically ambiguous as it could
2563         // also be interpreted as a path to e.g. a constant, variant, etc.
2564         let is_syntactic_ambiguity = !has_sub && bm == BindingMode::ByValue(Mutability::Not);
2565
2566         let ls_binding = self.maybe_resolve_ident_in_lexical_scope(ident, ValueNS)?;
2567         let (res, binding) = match ls_binding {
2568             LexicalScopeBinding::Item(binding)
2569                 if is_syntactic_ambiguity && binding.is_ambiguity() =>
2570             {
2571                 // For ambiguous bindings we don't know all their definitions and cannot check
2572                 // whether they can be shadowed by fresh bindings or not, so force an error.
2573                 // issues/33118#issuecomment-233962221 (see below) still applies here,
2574                 // but we have to ignore it for backward compatibility.
2575                 self.r.record_use(ident, binding, false);
2576                 return None;
2577             }
2578             LexicalScopeBinding::Item(binding) => (binding.res(), Some(binding)),
2579             LexicalScopeBinding::Res(res) => (res, None),
2580         };
2581
2582         match res {
2583             Res::SelfCtor(_) // See #70549.
2584             | Res::Def(
2585                 DefKind::Ctor(_, CtorKind::Const) | DefKind::Const | DefKind::ConstParam,
2586                 _,
2587             ) if is_syntactic_ambiguity => {
2588                 // Disambiguate in favor of a unit struct/variant or constant pattern.
2589                 if let Some(binding) = binding {
2590                     self.r.record_use(ident, binding, false);
2591                 }
2592                 Some(res)
2593             }
2594             Res::Def(DefKind::Ctor(..) | DefKind::Const | DefKind::Static(_), _) => {
2595                 // This is unambiguously a fresh binding, either syntactically
2596                 // (e.g., `IDENT @ PAT` or `ref IDENT`) or because `IDENT` resolves
2597                 // to something unusable as a pattern (e.g., constructor function),
2598                 // but we still conservatively report an error, see
2599                 // issues/33118#issuecomment-233962221 for one reason why.
2600                 let binding = binding.expect("no binding for a ctor or static");
2601                 self.report_error(
2602                     ident.span,
2603                     ResolutionError::BindingShadowsSomethingUnacceptable {
2604                         shadowing_binding_descr: pat_src.descr(),
2605                         name: ident.name,
2606                         participle: if binding.is_import() { "imported" } else { "defined" },
2607                         article: binding.res().article(),
2608                         shadowed_binding_descr: binding.res().descr(),
2609                         shadowed_binding_span: binding.span,
2610                     },
2611                 );
2612                 None
2613             }
2614             Res::Def(DefKind::ConstParam, def_id) => {
2615                 // Same as for DefKind::Const above, but here, `binding` is `None`, so we
2616                 // have to construct the error differently
2617                 self.report_error(
2618                     ident.span,
2619                     ResolutionError::BindingShadowsSomethingUnacceptable {
2620                         shadowing_binding_descr: pat_src.descr(),
2621                         name: ident.name,
2622                         participle: "defined",
2623                         article: res.article(),
2624                         shadowed_binding_descr: res.descr(),
2625                         shadowed_binding_span: self.r.opt_span(def_id).expect("const parameter defined outside of local crate"),
2626                     }
2627                 );
2628                 None
2629             }
2630             Res::Def(DefKind::Fn, _) | Res::Local(..) | Res::Err => {
2631                 // These entities are explicitly allowed to be shadowed by fresh bindings.
2632                 None
2633             }
2634             Res::SelfCtor(_) => {
2635                 // We resolve `Self` in pattern position as an ident sometimes during recovery,
2636                 // so delay a bug instead of ICEing.
2637                 self.r.session.delay_span_bug(
2638                     ident.span,
2639                     "unexpected `SelfCtor` in pattern, expected identifier"
2640                 );
2641                 None
2642             }
2643             _ => span_bug!(
2644                 ident.span,
2645                 "unexpected resolution for an identifier in pattern: {:?}",
2646                 res,
2647             ),
2648         }
2649     }
2650
2651     // High-level and context dependent path resolution routine.
2652     // Resolves the path and records the resolution into definition map.
2653     // If resolution fails tries several techniques to find likely
2654     // resolution candidates, suggest imports or other help, and report
2655     // errors in user friendly way.
2656     fn smart_resolve_path(
2657         &mut self,
2658         id: NodeId,
2659         qself: Option<&QSelf>,
2660         path: &Path,
2661         source: PathSource<'ast>,
2662     ) {
2663         self.smart_resolve_path_fragment(
2664             qself,
2665             &Segment::from_path(path),
2666             source,
2667             Finalize::new(id, path.span),
2668         );
2669     }
2670
2671     fn smart_resolve_path_fragment(
2672         &mut self,
2673         qself: Option<&QSelf>,
2674         path: &[Segment],
2675         source: PathSource<'ast>,
2676         finalize: Finalize,
2677     ) -> PartialRes {
2678         tracing::debug!(
2679             "smart_resolve_path_fragment(qself={:?}, path={:?}, finalize={:?})",
2680             qself,
2681             path,
2682             finalize,
2683         );
2684         let ns = source.namespace();
2685
2686         let Finalize { node_id, path_span, .. } = finalize;
2687         let report_errors = |this: &mut Self, res: Option<Res>| {
2688             if this.should_report_errs() {
2689                 let (err, candidates) =
2690                     this.smart_resolve_report_errors(path, path_span, source, res);
2691
2692                 let def_id = this.parent_scope.module.nearest_parent_mod();
2693                 let instead = res.is_some();
2694                 let suggestion =
2695                     if res.is_none() { this.report_missing_type_error(path) } else { None };
2696
2697                 this.r.use_injections.push(UseError {
2698                     err,
2699                     candidates,
2700                     def_id,
2701                     instead,
2702                     suggestion,
2703                 });
2704             }
2705
2706             PartialRes::new(Res::Err)
2707         };
2708
2709         // For paths originating from calls (like in `HashMap::new()`), tries
2710         // to enrich the plain `failed to resolve: ...` message with hints
2711         // about possible missing imports.
2712         //
2713         // Similar thing, for types, happens in `report_errors` above.
2714         let report_errors_for_call = |this: &mut Self, parent_err: Spanned<ResolutionError<'a>>| {
2715             if !source.is_call() {
2716                 return Some(parent_err);
2717             }
2718
2719             // Before we start looking for candidates, we have to get our hands
2720             // on the type user is trying to perform invocation on; basically:
2721             // we're transforming `HashMap::new` into just `HashMap`.
2722             let path = match path.split_last() {
2723                 Some((_, path)) if !path.is_empty() => path,
2724                 _ => return Some(parent_err),
2725             };
2726
2727             let (mut err, candidates) =
2728                 this.smart_resolve_report_errors(path, path_span, PathSource::Type, None);
2729
2730             if candidates.is_empty() {
2731                 err.cancel();
2732                 return Some(parent_err);
2733             }
2734
2735             // There are two different error messages user might receive at
2736             // this point:
2737             // - E0412 cannot find type `{}` in this scope
2738             // - E0433 failed to resolve: use of undeclared type or module `{}`
2739             //
2740             // The first one is emitted for paths in type-position, and the
2741             // latter one - for paths in expression-position.
2742             //
2743             // Thus (since we're in expression-position at this point), not to
2744             // confuse the user, we want to keep the *message* from E0432 (so
2745             // `parent_err`), but we want *hints* from E0412 (so `err`).
2746             //
2747             // And that's what happens below - we're just mixing both messages
2748             // into a single one.
2749             let mut parent_err = this.r.into_struct_error(parent_err.span, parent_err.node);
2750
2751             err.message = take(&mut parent_err.message);
2752             err.code = take(&mut parent_err.code);
2753             err.children = take(&mut parent_err.children);
2754
2755             parent_err.cancel();
2756
2757             let def_id = this.parent_scope.module.nearest_parent_mod();
2758
2759             if this.should_report_errs() {
2760                 this.r.use_injections.push(UseError {
2761                     err,
2762                     candidates,
2763                     def_id,
2764                     instead: false,
2765                     suggestion: None,
2766                 });
2767             } else {
2768                 err.cancel();
2769             }
2770
2771             // We don't return `Some(parent_err)` here, because the error will
2772             // be already printed as part of the `use` injections
2773             None
2774         };
2775
2776         let partial_res = match self.resolve_qpath_anywhere(
2777             qself,
2778             path,
2779             ns,
2780             path_span,
2781             source.defer_to_typeck(),
2782             finalize,
2783         ) {
2784             Ok(Some(partial_res)) if partial_res.unresolved_segments() == 0 => {
2785                 if source.is_expected(partial_res.base_res()) || partial_res.base_res() == Res::Err
2786                 {
2787                     partial_res
2788                 } else {
2789                     report_errors(self, Some(partial_res.base_res()))
2790                 }
2791             }
2792
2793             Ok(Some(partial_res)) if source.defer_to_typeck() => {
2794                 // Not fully resolved associated item `T::A::B` or `<T as Tr>::A::B`
2795                 // or `<T>::A::B`. If `B` should be resolved in value namespace then
2796                 // it needs to be added to the trait map.
2797                 if ns == ValueNS {
2798                     let item_name = path.last().unwrap().ident;
2799                     let traits = self.traits_in_scope(item_name, ns);
2800                     self.r.trait_map.insert(node_id, traits);
2801                 }
2802
2803                 if PrimTy::from_name(path[0].ident.name).is_some() {
2804                     let mut std_path = Vec::with_capacity(1 + path.len());
2805
2806                     std_path.push(Segment::from_ident(Ident::with_dummy_span(sym::std)));
2807                     std_path.extend(path);
2808                     if let PathResult::Module(_) | PathResult::NonModule(_) =
2809                         self.resolve_path(&std_path, Some(ns), None)
2810                     {
2811                         // Check if we wrote `str::from_utf8` instead of `std::str::from_utf8`
2812                         let item_span =
2813                             path.iter().last().map_or(path_span, |segment| segment.ident.span);
2814
2815                         self.r.confused_type_with_std_module.insert(item_span, path_span);
2816                         self.r.confused_type_with_std_module.insert(path_span, path_span);
2817                     }
2818                 }
2819
2820                 partial_res
2821             }
2822
2823             Err(err) => {
2824                 if let Some(err) = report_errors_for_call(self, err) {
2825                     self.report_error(err.span, err.node);
2826                 }
2827
2828                 PartialRes::new(Res::Err)
2829             }
2830
2831             _ => report_errors(self, None),
2832         };
2833
2834         if !matches!(source, PathSource::TraitItem(..)) {
2835             // Avoid recording definition of `A::B` in `<T as A>::B::C`.
2836             self.r.record_partial_res(node_id, partial_res);
2837             self.resolve_elided_lifetimes_in_path(node_id, partial_res, path, source, path_span);
2838         }
2839
2840         partial_res
2841     }
2842
2843     fn self_type_is_available(&mut self) -> bool {
2844         let binding = self
2845             .maybe_resolve_ident_in_lexical_scope(Ident::with_dummy_span(kw::SelfUpper), TypeNS);
2846         if let Some(LexicalScopeBinding::Res(res)) = binding { res != Res::Err } else { false }
2847     }
2848
2849     fn self_value_is_available(&mut self, self_span: Span) -> bool {
2850         let ident = Ident::new(kw::SelfLower, self_span);
2851         let binding = self.maybe_resolve_ident_in_lexical_scope(ident, ValueNS);
2852         if let Some(LexicalScopeBinding::Res(res)) = binding { res != Res::Err } else { false }
2853     }
2854
2855     /// A wrapper around [`Resolver::report_error`].
2856     ///
2857     /// This doesn't emit errors for function bodies if this is rustdoc.
2858     fn report_error(&mut self, span: Span, resolution_error: ResolutionError<'a>) {
2859         if self.should_report_errs() {
2860             self.r.report_error(span, resolution_error);
2861         }
2862     }
2863
2864     #[inline]
2865     /// If we're actually rustdoc then avoid giving a name resolution error for `cfg()` items.
2866     fn should_report_errs(&self) -> bool {
2867         !(self.r.session.opts.actually_rustdoc && self.in_func_body)
2868     }
2869
2870     // Resolve in alternative namespaces if resolution in the primary namespace fails.
2871     fn resolve_qpath_anywhere(
2872         &mut self,
2873         qself: Option<&QSelf>,
2874         path: &[Segment],
2875         primary_ns: Namespace,
2876         span: Span,
2877         defer_to_typeck: bool,
2878         finalize: Finalize,
2879     ) -> Result<Option<PartialRes>, Spanned<ResolutionError<'a>>> {
2880         let mut fin_res = None;
2881
2882         for (i, &ns) in [primary_ns, TypeNS, ValueNS].iter().enumerate() {
2883             if i == 0 || ns != primary_ns {
2884                 match self.resolve_qpath(qself, path, ns, finalize)? {
2885                     Some(partial_res)
2886                         if partial_res.unresolved_segments() == 0 || defer_to_typeck =>
2887                     {
2888                         return Ok(Some(partial_res));
2889                     }
2890                     partial_res => {
2891                         if fin_res.is_none() {
2892                             fin_res = partial_res;
2893                         }
2894                     }
2895                 }
2896             }
2897         }
2898
2899         assert!(primary_ns != MacroNS);
2900
2901         if qself.is_none() {
2902             let path_seg = |seg: &Segment| PathSegment::from_ident(seg.ident);
2903             let path = Path { segments: path.iter().map(path_seg).collect(), span, tokens: None };
2904             if let Ok((_, res)) =
2905                 self.r.resolve_macro_path(&path, None, &self.parent_scope, false, false)
2906             {
2907                 return Ok(Some(PartialRes::new(res)));
2908             }
2909         }
2910
2911         Ok(fin_res)
2912     }
2913
2914     /// Handles paths that may refer to associated items.
2915     fn resolve_qpath(
2916         &mut self,
2917         qself: Option<&QSelf>,
2918         path: &[Segment],
2919         ns: Namespace,
2920         finalize: Finalize,
2921     ) -> Result<Option<PartialRes>, Spanned<ResolutionError<'a>>> {
2922         debug!(
2923             "resolve_qpath(qself={:?}, path={:?}, ns={:?}, finalize={:?})",
2924             qself, path, ns, finalize,
2925         );
2926
2927         if let Some(qself) = qself {
2928             if qself.position == 0 {
2929                 // This is a case like `<T>::B`, where there is no
2930                 // trait to resolve.  In that case, we leave the `B`
2931                 // segment to be resolved by type-check.
2932                 return Ok(Some(PartialRes::with_unresolved_segments(
2933                     Res::Def(DefKind::Mod, CRATE_DEF_ID.to_def_id()),
2934                     path.len(),
2935                 )));
2936             }
2937
2938             // Make sure `A::B` in `<T as A::B>::C` is a trait item.
2939             //
2940             // Currently, `path` names the full item (`A::B::C`, in
2941             // our example).  so we extract the prefix of that that is
2942             // the trait (the slice upto and including
2943             // `qself.position`). And then we recursively resolve that,
2944             // but with `qself` set to `None`.
2945             let ns = if qself.position + 1 == path.len() { ns } else { TypeNS };
2946             let partial_res = self.smart_resolve_path_fragment(
2947                 None,
2948                 &path[..=qself.position],
2949                 PathSource::TraitItem(ns),
2950                 Finalize::with_root_span(finalize.node_id, finalize.path_span, qself.path_span),
2951             );
2952
2953             // The remaining segments (the `C` in our example) will
2954             // have to be resolved by type-check, since that requires doing
2955             // trait resolution.
2956             return Ok(Some(PartialRes::with_unresolved_segments(
2957                 partial_res.base_res(),
2958                 partial_res.unresolved_segments() + path.len() - qself.position - 1,
2959             )));
2960         }
2961
2962         let result = match self.resolve_path(&path, Some(ns), Some(finalize)) {
2963             PathResult::NonModule(path_res) => path_res,
2964             PathResult::Module(ModuleOrUniformRoot::Module(module)) if !module.is_normal() => {
2965                 PartialRes::new(module.res().unwrap())
2966             }
2967             // In `a(::assoc_item)*` `a` cannot be a module. If `a` does resolve to a module we
2968             // don't report an error right away, but try to fallback to a primitive type.
2969             // So, we are still able to successfully resolve something like
2970             //
2971             // use std::u8; // bring module u8 in scope
2972             // fn f() -> u8 { // OK, resolves to primitive u8, not to std::u8
2973             //     u8::max_value() // OK, resolves to associated function <u8>::max_value,
2974             //                     // not to non-existent std::u8::max_value
2975             // }
2976             //
2977             // Such behavior is required for backward compatibility.
2978             // The same fallback is used when `a` resolves to nothing.
2979             PathResult::Module(ModuleOrUniformRoot::Module(_)) | PathResult::Failed { .. }
2980                 if (ns == TypeNS || path.len() > 1)
2981                     && PrimTy::from_name(path[0].ident.name).is_some() =>
2982             {
2983                 let prim = PrimTy::from_name(path[0].ident.name).unwrap();
2984                 PartialRes::with_unresolved_segments(Res::PrimTy(prim), path.len() - 1)
2985             }
2986             PathResult::Module(ModuleOrUniformRoot::Module(module)) => {
2987                 PartialRes::new(module.res().unwrap())
2988             }
2989             PathResult::Failed { is_error_from_last_segment: false, span, label, suggestion } => {
2990                 return Err(respan(span, ResolutionError::FailedToResolve { label, suggestion }));
2991             }
2992             PathResult::Module(..) | PathResult::Failed { .. } => return Ok(None),
2993             PathResult::Indeterminate => bug!("indeterminate path result in resolve_qpath"),
2994         };
2995
2996         if path.len() > 1
2997             && result.base_res() != Res::Err
2998             && path[0].ident.name != kw::PathRoot
2999             && path[0].ident.name != kw::DollarCrate
3000         {
3001             let unqualified_result = {
3002                 match self.resolve_path(&[*path.last().unwrap()], Some(ns), None) {
3003                     PathResult::NonModule(path_res) => path_res.base_res(),
3004                     PathResult::Module(ModuleOrUniformRoot::Module(module)) => {
3005                         module.res().unwrap()
3006                     }
3007                     _ => return Ok(Some(result)),
3008                 }
3009             };
3010             if result.base_res() == unqualified_result {
3011                 let lint = lint::builtin::UNUSED_QUALIFICATIONS;
3012                 self.r.lint_buffer.buffer_lint(
3013                     lint,
3014                     finalize.node_id,
3015                     finalize.path_span,
3016                     "unnecessary qualification",
3017                 )
3018             }
3019         }
3020
3021         Ok(Some(result))
3022     }
3023
3024     fn with_resolved_label(&mut self, label: Option<Label>, id: NodeId, f: impl FnOnce(&mut Self)) {
3025         if let Some(label) = label {
3026             if label.ident.as_str().as_bytes()[1] != b'_' {
3027                 self.diagnostic_metadata.unused_labels.insert(id, label.ident.span);
3028             }
3029             self.with_label_rib(NormalRibKind, |this| {
3030                 let ident = label.ident.normalize_to_macro_rules();
3031                 this.label_ribs.last_mut().unwrap().bindings.insert(ident, id);
3032                 f(this);
3033             });
3034         } else {
3035             f(self);
3036         }
3037     }
3038
3039     fn resolve_labeled_block(&mut self, label: Option<Label>, id: NodeId, block: &'ast Block) {
3040         self.with_resolved_label(label, id, |this| this.visit_block(block));
3041     }
3042
3043     fn resolve_block(&mut self, block: &'ast Block) {
3044         debug!("(resolving block) entering block");
3045         // Move down in the graph, if there's an anonymous module rooted here.
3046         let orig_module = self.parent_scope.module;
3047         let anonymous_module = self.r.block_map.get(&block.id).cloned(); // clones a reference
3048
3049         let mut num_macro_definition_ribs = 0;
3050         if let Some(anonymous_module) = anonymous_module {
3051             debug!("(resolving block) found anonymous module, moving down");
3052             self.ribs[ValueNS].push(Rib::new(ModuleRibKind(anonymous_module)));
3053             self.ribs[TypeNS].push(Rib::new(ModuleRibKind(anonymous_module)));
3054             self.parent_scope.module = anonymous_module;
3055         } else {
3056             self.ribs[ValueNS].push(Rib::new(NormalRibKind));
3057         }
3058
3059         let prev = self.diagnostic_metadata.current_block_could_be_bare_struct_literal.take();
3060         if let (true, [Stmt { kind: StmtKind::Expr(expr), .. }]) =
3061             (block.could_be_bare_literal, &block.stmts[..])
3062             && let ExprKind::Type(..) = expr.kind
3063         {
3064             self.diagnostic_metadata.current_block_could_be_bare_struct_literal =
3065             Some(block.span);
3066         }
3067         // Descend into the block.
3068         for stmt in &block.stmts {
3069             if let StmtKind::Item(ref item) = stmt.kind
3070                 && let ItemKind::MacroDef(..) = item.kind {
3071                 num_macro_definition_ribs += 1;
3072                 let res = self.r.local_def_id(item.id).to_def_id();
3073                 self.ribs[ValueNS].push(Rib::new(MacroDefinition(res)));
3074                 self.label_ribs.push(Rib::new(MacroDefinition(res)));
3075             }
3076
3077             self.visit_stmt(stmt);
3078         }
3079         self.diagnostic_metadata.current_block_could_be_bare_struct_literal = prev;
3080
3081         // Move back up.
3082         self.parent_scope.module = orig_module;
3083         for _ in 0..num_macro_definition_ribs {
3084             self.ribs[ValueNS].pop();
3085             self.label_ribs.pop();
3086         }
3087         self.ribs[ValueNS].pop();
3088         if anonymous_module.is_some() {
3089             self.ribs[TypeNS].pop();
3090         }
3091         debug!("(resolving block) leaving block");
3092     }
3093
3094     fn resolve_anon_const(&mut self, constant: &'ast AnonConst, is_repeat: IsRepeatExpr) {
3095         debug!("resolve_anon_const {:?} is_repeat: {:?}", constant, is_repeat);
3096         self.with_constant_rib(
3097             is_repeat,
3098             if constant.value.is_potential_trivial_const_param() {
3099                 HasGenericParams::Yes
3100             } else {
3101                 HasGenericParams::No
3102             },
3103             None,
3104             |this| visit::walk_anon_const(this, constant),
3105         );
3106     }
3107
3108     fn resolve_expr(&mut self, expr: &'ast Expr, parent: Option<&'ast Expr>) {
3109         // First, record candidate traits for this expression if it could
3110         // result in the invocation of a method call.
3111
3112         self.record_candidate_traits_for_expr_if_necessary(expr);
3113
3114         // Next, resolve the node.
3115         match expr.kind {
3116             ExprKind::Path(ref qself, ref path) => {
3117                 self.smart_resolve_path(expr.id, qself.as_ref(), path, PathSource::Expr(parent));
3118                 visit::walk_expr(self, expr);
3119             }
3120
3121             ExprKind::Struct(ref se) => {
3122                 self.smart_resolve_path(expr.id, se.qself.as_ref(), &se.path, PathSource::Struct);
3123                 visit::walk_expr(self, expr);
3124             }
3125
3126             ExprKind::Break(Some(label), _) | ExprKind::Continue(Some(label)) => {
3127                 if let Some(node_id) = self.resolve_label(label.ident) {
3128                     // Since this res is a label, it is never read.
3129                     self.r.label_res_map.insert(expr.id, node_id);
3130                     self.diagnostic_metadata.unused_labels.remove(&node_id);
3131                 }
3132
3133                 // visit `break` argument if any
3134                 visit::walk_expr(self, expr);
3135             }
3136
3137             ExprKind::Break(None, Some(ref e)) => {
3138                 // We use this instead of `visit::walk_expr` to keep the parent expr around for
3139                 // better diagnostics.
3140                 self.resolve_expr(e, Some(&expr));
3141             }
3142
3143             ExprKind::Let(ref pat, ref scrutinee, _) => {
3144                 self.visit_expr(scrutinee);
3145                 self.resolve_pattern_top(pat, PatternSource::Let);
3146             }
3147
3148             ExprKind::If(ref cond, ref then, ref opt_else) => {
3149                 self.with_rib(ValueNS, NormalRibKind, |this| {
3150                     let old = this.diagnostic_metadata.in_if_condition.replace(cond);
3151                     this.visit_expr(cond);
3152                     this.diagnostic_metadata.in_if_condition = old;
3153                     this.visit_block(then);
3154                 });
3155                 if let Some(expr) = opt_else {
3156                     self.visit_expr(expr);
3157                 }
3158             }
3159
3160             ExprKind::Loop(ref block, label) => self.resolve_labeled_block(label, expr.id, &block),
3161
3162             ExprKind::While(ref cond, ref block, label) => {
3163                 self.with_resolved_label(label, expr.id, |this| {
3164                     this.with_rib(ValueNS, NormalRibKind, |this| {
3165                         let old = this.diagnostic_metadata.in_if_condition.replace(cond);
3166                         this.visit_expr(cond);
3167                         this.diagnostic_metadata.in_if_condition = old;
3168                         this.visit_block(block);
3169                     })
3170                 });
3171             }
3172
3173             ExprKind::ForLoop(ref pat, ref iter_expr, ref block, label) => {
3174                 self.visit_expr(iter_expr);
3175                 self.with_rib(ValueNS, NormalRibKind, |this| {
3176                     this.resolve_pattern_top(pat, PatternSource::For);
3177                     this.resolve_labeled_block(label, expr.id, block);
3178                 });
3179             }
3180
3181             ExprKind::Block(ref block, label) => self.resolve_labeled_block(label, block.id, block),
3182
3183             // Equivalent to `visit::walk_expr` + passing some context to children.
3184             ExprKind::Field(ref subexpression, _) => {
3185                 self.resolve_expr(subexpression, Some(expr));
3186             }
3187             ExprKind::MethodCall(ref segment, ref arguments, _) => {
3188                 let mut arguments = arguments.iter();
3189                 self.resolve_expr(arguments.next().unwrap(), Some(expr));
3190                 for argument in arguments {
3191                     self.resolve_expr(argument, None);
3192                 }
3193                 self.visit_path_segment(expr.span, segment);
3194             }
3195
3196             ExprKind::Call(ref callee, ref arguments) => {
3197                 self.resolve_expr(callee, Some(expr));
3198                 let const_args = self.r.legacy_const_generic_args(callee).unwrap_or_default();
3199                 for (idx, argument) in arguments.iter().enumerate() {
3200                     // Constant arguments need to be treated as AnonConst since
3201                     // that is how they will be later lowered to HIR.
3202                     if const_args.contains(&idx) {
3203                         self.with_constant_rib(
3204                             IsRepeatExpr::No,
3205                             if argument.is_potential_trivial_const_param() {
3206                                 HasGenericParams::Yes
3207                             } else {
3208                                 HasGenericParams::No
3209                             },
3210                             None,
3211                             |this| {
3212                                 this.resolve_expr(argument, None);
3213                             },
3214                         );
3215                     } else {
3216                         self.resolve_expr(argument, None);
3217                     }
3218                 }
3219             }
3220             ExprKind::Type(ref type_expr, ref ty) => {
3221                 // `ParseSess::type_ascription_path_suggestions` keeps spans of colon tokens in
3222                 // type ascription. Here we are trying to retrieve the span of the colon token as
3223                 // well, but only if it's written without spaces `expr:Ty` and therefore confusable
3224                 // with `expr::Ty`, only in this case it will match the span from
3225                 // `type_ascription_path_suggestions`.
3226                 self.diagnostic_metadata
3227                     .current_type_ascription
3228                     .push(type_expr.span.between(ty.span));
3229                 visit::walk_expr(self, expr);
3230                 self.diagnostic_metadata.current_type_ascription.pop();
3231             }
3232             // `async |x| ...` gets desugared to `|x| future_from_generator(|| ...)`, so we need to
3233             // resolve the arguments within the proper scopes so that usages of them inside the
3234             // closure are detected as upvars rather than normal closure arg usages.
3235             ExprKind::Closure(_, Async::Yes { .. }, _, ref fn_decl, ref body, _span) => {
3236                 self.with_rib(ValueNS, NormalRibKind, |this| {
3237                     this.with_label_rib(ClosureOrAsyncRibKind, |this| {
3238                         // Resolve arguments:
3239                         this.resolve_params(&fn_decl.inputs);
3240                         // No need to resolve return type --
3241                         // the outer closure return type is `FnRetTy::Default`.
3242
3243                         // Now resolve the inner closure
3244                         {
3245                             // No need to resolve arguments: the inner closure has none.
3246                             // Resolve the return type:
3247                             visit::walk_fn_ret_ty(this, &fn_decl.output);
3248                             // Resolve the body
3249                             this.visit_expr(body);
3250                         }
3251                     })
3252                 });
3253             }
3254             ExprKind::Async(..) | ExprKind::Closure(..) => {
3255                 self.with_label_rib(ClosureOrAsyncRibKind, |this| visit::walk_expr(this, expr));
3256             }
3257             ExprKind::Repeat(ref elem, ref ct) => {
3258                 self.visit_expr(elem);
3259                 self.with_lifetime_rib(LifetimeRibKind::AnonConst, |this| {
3260                     this.resolve_anon_const(ct, IsRepeatExpr::Yes)
3261                 });
3262             }
3263             ExprKind::ConstBlock(ref ct) => {
3264                 self.resolve_anon_const(ct, IsRepeatExpr::No);
3265             }
3266             ExprKind::Index(ref elem, ref idx) => {
3267                 self.resolve_expr(elem, Some(expr));
3268                 self.visit_expr(idx);
3269             }
3270             _ => {
3271                 visit::walk_expr(self, expr);
3272             }
3273         }
3274     }
3275
3276     fn record_candidate_traits_for_expr_if_necessary(&mut self, expr: &'ast Expr) {
3277         match expr.kind {
3278             ExprKind::Field(_, ident) => {
3279                 // FIXME(#6890): Even though you can't treat a method like a
3280                 // field, we need to add any trait methods we find that match
3281                 // the field name so that we can do some nice error reporting
3282                 // later on in typeck.
3283                 let traits = self.traits_in_scope(ident, ValueNS);
3284                 self.r.trait_map.insert(expr.id, traits);
3285             }
3286             ExprKind::MethodCall(ref segment, ..) => {
3287                 debug!("(recording candidate traits for expr) recording traits for {}", expr.id);
3288                 let traits = self.traits_in_scope(segment.ident, ValueNS);
3289                 self.r.trait_map.insert(expr.id, traits);
3290             }
3291             _ => {
3292                 // Nothing to do.
3293             }
3294         }
3295     }
3296
3297     fn traits_in_scope(&mut self, ident: Ident, ns: Namespace) -> Vec<TraitCandidate> {
3298         self.r.traits_in_scope(
3299             self.current_trait_ref.as_ref().map(|(module, _)| *module),
3300             &self.parent_scope,
3301             ident.span.ctxt(),
3302             Some((ident.name, ns)),
3303         )
3304     }
3305 }
3306
3307 struct LifetimeCountVisitor<'a, 'b> {
3308     r: &'b mut Resolver<'a>,
3309 }
3310
3311 /// Walks the whole crate in DFS order, visiting each item, counting the declared number of
3312 /// lifetime generic parameters.
3313 impl<'ast> Visitor<'ast> for LifetimeCountVisitor<'_, '_> {
3314     fn visit_item(&mut self, item: &'ast Item) {
3315         match &item.kind {
3316             ItemKind::TyAlias(box TyAlias { ref generics, .. })
3317             | ItemKind::Fn(box Fn { ref generics, .. })
3318             | ItemKind::Enum(_, ref generics)
3319             | ItemKind::Struct(_, ref generics)
3320             | ItemKind::Union(_, ref generics)
3321             | ItemKind::Impl(box Impl { ref generics, .. })
3322             | ItemKind::Trait(box Trait { ref generics, .. })
3323             | ItemKind::TraitAlias(ref generics, _) => {
3324                 let def_id = self.r.local_def_id(item.id);
3325                 let count = generics
3326                     .params
3327                     .iter()
3328                     .filter(|param| matches!(param.kind, ast::GenericParamKind::Lifetime { .. }))
3329                     .count();
3330                 self.r.item_generics_num_lifetimes.insert(def_id, count);
3331             }
3332
3333             ItemKind::Mod(..)
3334             | ItemKind::ForeignMod(..)
3335             | ItemKind::Static(..)
3336             | ItemKind::Const(..)
3337             | ItemKind::Use(..)
3338             | ItemKind::ExternCrate(..)
3339             | ItemKind::MacroDef(..)
3340             | ItemKind::GlobalAsm(..)
3341             | ItemKind::MacCall(..) => {}
3342         }
3343         visit::walk_item(self, item)
3344     }
3345 }
3346
3347 impl<'a> Resolver<'a> {
3348     pub(crate) fn late_resolve_crate(&mut self, krate: &Crate) {
3349         visit::walk_crate(&mut LifetimeCountVisitor { r: self }, krate);
3350         let mut late_resolution_visitor = LateResolutionVisitor::new(self);
3351         visit::walk_crate(&mut late_resolution_visitor, krate);
3352         for (id, span) in late_resolution_visitor.diagnostic_metadata.unused_labels.iter() {
3353             self.lint_buffer.buffer_lint(lint::builtin::UNUSED_LABELS, *id, *span, "unused label");
3354         }
3355     }
3356 }