compiler/rustc_resolve/src/imports.rs

   1 //! A bunch of methods and structures more or less related to resolving imports.
   2
   3 use crate::diagnostics::Suggestion;
   4 use crate::Determinacy::{self, *};
   5 use crate::Namespace::{MacroNS, TypeNS};
   6 use crate::{module_to_string, names_to_string};
   7 use crate::{AmbiguityKind, BindingKey, ModuleKind, ResolutionError, Resolver, Segment};
   8 use crate::{Finalize, Module, ModuleOrUniformRoot, ParentScope, PerNS, ScopeSet};
   9 use crate::{NameBinding, NameBindingKind, PathResult};
  10
  11 use rustc_ast::NodeId;
  12 use rustc_data_structures::fx::FxHashSet;
  13 use rustc_data_structures::intern::Interned;
  14 use rustc_errors::{pluralize, struct_span_err, Applicability, MultiSpan};
  15 use rustc_hir::def::{self, DefKind, PartialRes};
  16 use rustc_middle::metadata::ModChild;
  17 use rustc_middle::span_bug;
  18 use rustc_middle::ty;
  19 use rustc_session::lint::builtin::{PUB_USE_OF_PRIVATE_EXTERN_CRATE, UNUSED_IMPORTS};
  20 use rustc_session::lint::BuiltinLintDiagnostics;
  21 use rustc_span::hygiene::LocalExpnId;
  22 use rustc_span::lev_distance::find_best_match_for_name;
  23 use rustc_span::symbol::{kw, Ident, Symbol};
  24 use rustc_span::Span;
  25
  26 use std::cell::Cell;
  27 use std::{mem, ptr};
  28
  29 type Res = def::Res<NodeId>;
  30
  31 /// Contains data for specific kinds of imports.
  32 #[derive(Clone)]
  33 pub enum ImportKind<'a> {
  34     Single {
  35         /// `source` in `use prefix::source as target`.
  36         source: Ident,
  37         /// `target` in `use prefix::source as target`.
  38         target: Ident,
  39         /// Bindings to which `source` refers to.
  40         source_bindings: PerNS<Cell<Result<&'a NameBinding<'a>, Determinacy>>>,
  41         /// Bindings introduced by `target`.
  42         target_bindings: PerNS<Cell<Option<&'a NameBinding<'a>>>>,
  43         /// `true` for `...::{self [as target]}` imports, `false` otherwise.
  44         type_ns_only: bool,
  45         /// Did this import result from a nested import? ie. `use foo::{bar, baz};`
  46         nested: bool,
  47         /// Additional `NodeId`s allocated to a `ast::UseTree` for automatically generated `use` statement
  48         /// (eg. implicit struct constructors)
  49         additional_ids: (NodeId, NodeId),
  50     },
  51     Glob {
  52         is_prelude: bool,
  53         max_vis: Cell<Option<ty::Visibility>>, // The visibility of the greatest re-export.
  54                                                // n.b. `max_vis` is only used in `finalize_import` to check for re-export errors.
  55     },
  56     ExternCrate {
  57         source: Option<Symbol>,
  58         target: Ident,
  59     },
  60     MacroUse,
  61 }
  62
  63 /// Manually implement `Debug` for `ImportKind` because the `source/target_bindings`
  64 /// contain `Cell`s which can introduce infinite loops while printing.
  65 impl<'a> std::fmt::Debug for ImportKind<'a> {
  66     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  67         use ImportKind::*;
  68         match self {
  69             Single {
  70                 ref source,
  71                 ref target,
  72                 ref type_ns_only,
  73                 ref nested,
  74                 ref additional_ids,
  75                 // Ignore the following to avoid an infinite loop while printing.
  76                 source_bindings: _,
  77                 target_bindings: _,
  78             } => f
  79                 .debug_struct("Single")
  80                 .field("source", source)
  81                 .field("target", target)
  82                 .field("type_ns_only", type_ns_only)
  83                 .field("nested", nested)
  84                 .field("additional_ids", additional_ids)
  85                 .finish_non_exhaustive(),
  86             Glob { ref is_prelude, ref max_vis } => f
  87                 .debug_struct("Glob")
  88                 .field("is_prelude", is_prelude)
  89                 .field("max_vis", max_vis)
  90                 .finish(),
  91             ExternCrate { ref source, ref target } => f
  92                 .debug_struct("ExternCrate")
  93                 .field("source", source)
  94                 .field("target", target)
  95                 .finish(),
  96             MacroUse => f.debug_struct("MacroUse").finish(),
  97         }
  98     }
  99 }
 100
 101 /// One import.
 102 #[derive(Debug, Clone)]
 103 pub(crate) struct Import<'a> {
 104     pub kind: ImportKind<'a>,
 105
 106     /// The ID of the `extern crate`, `UseTree` etc that imported this `Import`.
 107     ///
 108     /// In the case where the `Import` was expanded from a "nested" use tree,
 109     /// this id is the ID of the leaf tree. For example:
 110     ///
 111     /// ```ignore (pacify the merciless tidy)
 112     /// use foo::bar::{a, b}
 113     /// ```
 114     ///
 115     /// If this is the import for `foo::bar::a`, we would have the ID of the `UseTree`
 116     /// for `a` in this field.
 117     pub id: NodeId,
 118
 119     /// The `id` of the "root" use-kind -- this is always the same as
 120     /// `id` except in the case of "nested" use trees, in which case
 121     /// it will be the `id` of the root use tree. e.g., in the example
 122     /// from `id`, this would be the ID of the `use foo::bar`
 123     /// `UseTree` node.
 124     pub root_id: NodeId,
 125
 126     /// Span of the entire use statement.
 127     pub use_span: Span,
 128
 129     /// Span of the entire use statement with attributes.
 130     pub use_span_with_attributes: Span,
 131
 132     /// Did the use statement have any attributes?
 133     pub has_attributes: bool,
 134
 135     /// Span of this use tree.
 136     pub span: Span,
 137
 138     /// Span of the *root* use tree (see `root_id`).
 139     pub root_span: Span,
 140
 141     pub parent_scope: ParentScope<'a>,
 142     pub module_path: Vec<Segment>,
 143     /// The resolution of `module_path`.
 144     pub imported_module: Cell<Option<ModuleOrUniformRoot<'a>>>,
 145     pub vis: Cell<Option<ty::Visibility>>,
 146     pub used: Cell<bool>,
 147 }
 148
 149 impl<'a> Import<'a> {
 150     pub fn is_glob(&self) -> bool {
 151         matches!(self.kind, ImportKind::Glob { .. })
 152     }
 153
 154     pub fn is_nested(&self) -> bool {
 155         match self.kind {
 156             ImportKind::Single { nested, .. } => nested,
 157             _ => false,
 158         }
 159     }
 160
 161     pub(crate) fn expect_vis(&self) -> ty::Visibility {
 162         self.vis.get().expect("encountered cleared import visibility")
 163     }
 164 }
 165
 166 /// Records information about the resolution of a name in a namespace of a module.
 167 #[derive(Clone, Default, Debug)]
 168 pub(crate) struct NameResolution<'a> {
 169     /// Single imports that may define the name in the namespace.
 170     /// Imports are arena-allocated, so it's ok to use pointers as keys.
 171     pub single_imports: FxHashSet<Interned<'a, Import<'a>>>,
 172     /// The least shadowable known binding for this name, or None if there are no known bindings.
 173     pub binding: Option<&'a NameBinding<'a>>,
 174     pub shadowed_glob: Option<&'a NameBinding<'a>>,
 175 }
 176
 177 impl<'a> NameResolution<'a> {
 178     // Returns the binding for the name if it is known or None if it not known.
 179     pub(crate) fn binding(&self) -> Option<&'a NameBinding<'a>> {
 180         self.binding.and_then(|binding| {
 181             if !binding.is_glob_import() || self.single_imports.is_empty() {
 182                 Some(binding)
 183             } else {
 184                 None
 185             }
 186         })
 187     }
 188
 189     pub(crate) fn add_single_import(&mut self, import: &'a Import<'a>) {
 190         self.single_imports.insert(Interned::new_unchecked(import));
 191     }
 192 }
 193
 194 // Reexports of the form `pub use foo as bar;` where `foo` is `extern crate foo;`
 195 // are permitted for backward-compatibility under a deprecation lint.
 196 fn pub_use_of_private_extern_crate_hack(import: &Import<'_>, binding: &NameBinding<'_>) -> bool {
 197     match (&import.kind, &binding.kind) {
 198         (
 199             ImportKind::Single { .. },
 200             NameBindingKind::Import {
 201                 import: Import { kind: ImportKind::ExternCrate { .. }, .. },
 202                 ..
 203             },
 204         ) => import.expect_vis().is_public(),
 205         _ => false,
 206     }
 207 }
 208
 209 impl<'a> Resolver<'a> {
 210     // Given a binding and an import that resolves to it,
 211     // return the corresponding binding defined by the import.
 212     pub(crate) fn import(
 213         &self,
 214         binding: &'a NameBinding<'a>,
 215         import: &'a Import<'a>,
 216     ) -> &'a NameBinding<'a> {
 217         let import_vis = import.expect_vis();
 218         let vis = if binding.vis.is_at_least(import_vis, self)
 219             || pub_use_of_private_extern_crate_hack(import, binding)
 220         {
 221             import_vis
 222         } else {
 223             binding.vis
 224         };
 225
 226         if let ImportKind::Glob { ref max_vis, .. } = import.kind {
 227             if vis == import_vis
 228                 || max_vis.get().map_or(true, |max_vis| vis.is_at_least(max_vis, self))
 229             {
 230                 max_vis.set(Some(vis))
 231             }
 232         }
 233
 234         self.arenas.alloc_name_binding(NameBinding {
 235             kind: NameBindingKind::Import { binding, import, used: Cell::new(false) },
 236             ambiguity: None,
 237             span: import.span,
 238             vis,
 239             expansion: import.parent_scope.expansion,
 240         })
 241     }
 242
 243     // Define the name or return the existing binding if there is a collision.
 244     pub(crate) fn try_define(
 245         &mut self,
 246         module: Module<'a>,
 247         key: BindingKey,
 248         binding: &'a NameBinding<'a>,
 249     ) -> Result<(), &'a NameBinding<'a>> {
 250         let res = binding.res();
 251         self.check_reserved_macro_name(key.ident, res);
 252         self.set_binding_parent_module(binding, module);
 253         self.update_resolution(module, key, |this, resolution| {
 254             if let Some(old_binding) = resolution.binding {
 255                 if res == Res::Err {
 256                     // Do not override real bindings with `Res::Err`s from error recovery.
 257                     return Ok(());
 258                 }
 259                 match (old_binding.is_glob_import(), binding.is_glob_import()) {
 260                     (true, true) => {
 261                         if res != old_binding.res() {
 262                             resolution.binding = Some(this.ambiguity(
 263                                 AmbiguityKind::GlobVsGlob,
 264                                 old_binding,
 265                                 binding,
 266                             ));
 267                         } else if !old_binding.vis.is_at_least(binding.vis, &*this) {
 268                             // We are glob-importing the same item but with greater visibility.
 269                             resolution.binding = Some(binding);
 270                         }
 271                     }
 272                     (old_glob @ true, false) | (old_glob @ false, true) => {
 273                         let (glob_binding, nonglob_binding) =
 274                             if old_glob { (old_binding, binding) } else { (binding, old_binding) };
 275                         if glob_binding.res() != nonglob_binding.res()
 276                             && key.ns == MacroNS
 277                             && nonglob_binding.expansion != LocalExpnId::ROOT
 278                         {
 279                             resolution.binding = Some(this.ambiguity(
 280                                 AmbiguityKind::GlobVsExpanded,
 281                                 nonglob_binding,
 282                                 glob_binding,
 283                             ));
 284                         } else {
 285                             resolution.binding = Some(nonglob_binding);
 286                         }
 287                         resolution.shadowed_glob = Some(glob_binding);
 288                     }
 289                     (false, false) => {
 290                         return Err(old_binding);
 291                     }
 292                 }
 293             } else {
 294                 resolution.binding = Some(binding);
 295             }
 296
 297             Ok(())
 298         })
 299     }
 300
 301     fn ambiguity(
 302         &self,
 303         kind: AmbiguityKind,
 304         primary_binding: &'a NameBinding<'a>,
 305         secondary_binding: &'a NameBinding<'a>,
 306     ) -> &'a NameBinding<'a> {
 307         self.arenas.alloc_name_binding(NameBinding {
 308             ambiguity: Some((secondary_binding, kind)),
 309             ..primary_binding.clone()
 310         })
 311     }
 312
 313     // Use `f` to mutate the resolution of the name in the module.
 314     // If the resolution becomes a success, define it in the module's glob importers.
 315     fn update_resolution<T, F>(&mut self, module: Module<'a>, key: BindingKey, f: F) -> T
 316     where
 317         F: FnOnce(&mut Resolver<'a>, &mut NameResolution<'a>) -> T,
 318     {
 319         // Ensure that `resolution` isn't borrowed when defining in the module's glob importers,
 320         // during which the resolution might end up getting re-defined via a glob cycle.
 321         let (binding, t) = {
 322             let resolution = &mut *self.resolution(module, key).borrow_mut();
 323             let old_binding = resolution.binding();
 324
 325             let t = f(self, resolution);
 326
 327             match resolution.binding() {
 328                 _ if old_binding.is_some() => return t,
 329                 None => return t,
 330                 Some(binding) => match old_binding {
 331                     Some(old_binding) if ptr::eq(old_binding, binding) => return t,
 332                     _ => (binding, t),
 333                 },
 334             }
 335         };
 336
 337         // Define `binding` in `module`s glob importers.
 338         for import in module.glob_importers.borrow_mut().iter() {
 339             let mut ident = key.ident;
 340             let scope = match ident.span.reverse_glob_adjust(module.expansion, import.span) {
 341                 Some(Some(def)) => self.expn_def_scope(def),
 342                 Some(None) => import.parent_scope.module,
 343                 None => continue,
 344             };
 345             if self.is_accessible_from(binding.vis, scope) {
 346                 let imported_binding = self.import(binding, import);
 347                 let key = BindingKey { ident, ..key };
 348                 let _ = self.try_define(import.parent_scope.module, key, imported_binding);
 349             }
 350         }
 351
 352         t
 353     }
 354
 355     // Define a dummy resolution containing a `Res::Err` as a placeholder for a failed resolution,
 356     // also mark such failed imports as used to avoid duplicate diagnostics.
 357     fn import_dummy_binding(&mut self, import: &'a Import<'a>) {
 358         if let ImportKind::Single { target, ref target_bindings, .. } = import.kind {
 359             if target_bindings.iter().any(|binding| binding.get().is_some()) {
 360                 return; // Has resolution, do not create the dummy binding
 361             }
 362             let dummy_binding = self.dummy_binding;
 363             let dummy_binding = self.import(dummy_binding, import);
 364             self.per_ns(|this, ns| {
 365                 let key = this.new_key(target, ns);
 366                 let _ = this.try_define(import.parent_scope.module, key, dummy_binding);
 367             });
 368             self.record_use(target, dummy_binding, false);
 369         } else if import.imported_module.get().is_none() {
 370             import.used.set(true);
 371             self.used_imports.insert(import.id);
 372         }
 373     }
 374 }
 375
 376 /// An error that may be transformed into a diagnostic later. Used to combine multiple unresolved
 377 /// import errors within the same use tree into a single diagnostic.
 378 #[derive(Debug, Clone)]
 379 struct UnresolvedImportError {
 380     span: Span,
 381     label: Option<String>,
 382     note: Option<String>,
 383     suggestion: Option<Suggestion>,
 384 }
 385
 386 pub struct ImportResolver<'a, 'b> {
 387     pub r: &'a mut Resolver<'b>,
 388 }
 389
 390 impl<'a, 'b> ImportResolver<'a, 'b> {
 391     // Import resolution
 392     //
 393     // This is a fixed-point algorithm. We resolve imports until our efforts
 394     // are stymied by an unresolved import; then we bail out of the current
 395     // module and continue. We terminate successfully once no more imports
 396     // remain or unsuccessfully when no forward progress in resolving imports
 397     // is made.
 398
 399     /// Resolves all imports for the crate. This method performs the fixed-
 400     /// point iteration.
 401     pub fn resolve_imports(&mut self) {
 402         let mut prev_num_indeterminates = self.r.indeterminate_imports.len() + 1;
 403         while self.r.indeterminate_imports.len() < prev_num_indeterminates {
 404             prev_num_indeterminates = self.r.indeterminate_imports.len();
 405             for import in mem::take(&mut self.r.indeterminate_imports) {
 406                 match self.resolve_import(&import) {
 407                     true => self.r.determined_imports.push(import),
 408                     false => self.r.indeterminate_imports.push(import),
 409                 }
 410             }
 411         }
 412     }
 413
 414     pub fn finalize_imports(&mut self) {
 415         for module in self.r.arenas.local_modules().iter() {
 416             self.finalize_resolutions_in(module);
 417         }
 418
 419         let mut seen_spans = FxHashSet::default();
 420         let mut errors = vec![];
 421         let mut prev_root_id: NodeId = NodeId::from_u32(0);
 422         let determined_imports = mem::take(&mut self.r.determined_imports);
 423         let indeterminate_imports = mem::take(&mut self.r.indeterminate_imports);
 424
 425         for (is_indeterminate, import) in determined_imports
 426             .into_iter()
 427             .map(|i| (false, i))
 428             .chain(indeterminate_imports.into_iter().map(|i| (true, i)))
 429         {
 430             let unresolved_import_error = self.finalize_import(import);
 431
 432             // If this import is unresolved then create a dummy import
 433             // resolution for it so that later resolve stages won't complain.
 434             self.r.import_dummy_binding(import);
 435
 436             if let Some(err) = unresolved_import_error {
 437                 if let ImportKind::Single { source, ref source_bindings, .. } = import.kind {
 438                     if source.name == kw::SelfLower {
 439                         // Silence `unresolved import` error if E0429 is already emitted
 440                         if let Err(Determined) = source_bindings.value_ns.get() {
 441                             continue;
 442                         }
 443                     }
 444                 }
 445
 446                 if prev_root_id.as_u32() != 0
 447                     && prev_root_id.as_u32() != import.root_id.as_u32()
 448                     && !errors.is_empty()
 449                 {
 450                     // In the case of a new import line, throw a diagnostic message
 451                     // for the previous line.
 452                     self.throw_unresolved_import_error(errors, None);
 453                     errors = vec![];
 454                 }
 455                 if seen_spans.insert(err.span) {
 456                     let path = import_path_to_string(
 457                         &import.module_path.iter().map(|seg| seg.ident).collect::<Vec<_>>(),
 458                         &import.kind,
 459                         err.span,
 460                     );
 461                     errors.push((path, err));
 462                     prev_root_id = import.root_id;
 463                 }
 464             } else if is_indeterminate {
 465                 let path = import_path_to_string(
 466                     &import.module_path.iter().map(|seg| seg.ident).collect::<Vec<_>>(),
 467                     &import.kind,
 468                     import.span,
 469                 );
 470                 let err = UnresolvedImportError {
 471                     span: import.span,
 472                     label: None,
 473                     note: None,
 474                     suggestion: None,
 475                 };
 476                 if path.contains("::") {
 477                     errors.push((path, err))
 478                 }
 479             }
 480         }
 481
 482         if !errors.is_empty() {
 483             self.throw_unresolved_import_error(errors, None);
 484         }
 485     }
 486
 487     fn throw_unresolved_import_error(
 488         &self,
 489         errors: Vec<(String, UnresolvedImportError)>,
 490         span: Option<MultiSpan>,
 491     ) {
 492         /// Upper limit on the number of `span_label` messages.
 493         const MAX_LABEL_COUNT: usize = 10;
 494
 495         let (span, msg) = if errors.is_empty() {
 496             (span.unwrap(), "unresolved import".to_string())
 497         } else {
 498             let span = MultiSpan::from_spans(errors.iter().map(|(_, err)| err.span).collect());
 499
 500             let paths = errors.iter().map(|(path, _)| format!("`{}`", path)).collect::<Vec<_>>();
 501
 502             let msg = format!("unresolved import{} {}", pluralize!(paths.len()), paths.join(", "),);
 503
 504             (span, msg)
 505         };
 506
 507         let mut diag = struct_span_err!(self.r.session, span, E0432, "{}", &msg);
 508
 509         if let Some((_, UnresolvedImportError { note: Some(note), .. })) = errors.iter().last() {
 510             diag.note(note);
 511         }
 512
 513         for (_, err) in errors.into_iter().take(MAX_LABEL_COUNT) {
 514             if let Some(label) = err.label {
 515                 diag.span_label(err.span, label);
 516             }
 517
 518             if let Some((suggestions, msg, applicability)) = err.suggestion {
 519                 if suggestions.is_empty() {
 520                     diag.help(&msg);
 521                     continue;
 522                 }
 523                 diag.multipart_suggestion(&msg, suggestions, applicability);
 524             }
 525         }
 526
 527         diag.emit();
 528     }
 529
 530     /// Attempts to resolve the given import, returning true if its resolution is determined.
 531     /// If successful, the resolved bindings are written into the module.
 532     fn resolve_import(&mut self, import: &'b Import<'b>) -> bool {
 533         debug!(
 534             "(resolving import for module) resolving import `{}::...` in `{}`",
 535             Segment::names_to_string(&import.module_path),
 536             module_to_string(import.parent_scope.module).unwrap_or_else(|| "???".to_string()),
 537         );
 538
 539         let module = if let Some(module) = import.imported_module.get() {
 540             module
 541         } else {
 542             // For better failure detection, pretend that the import will
 543             // not define any names while resolving its module path.
 544             let orig_vis = import.vis.take();
 545             let path_res =
 546                 self.r.maybe_resolve_path(&import.module_path, None, &import.parent_scope);
 547             import.vis.set(orig_vis);
 548
 549             match path_res {
 550                 PathResult::Module(module) => module,
 551                 PathResult::Indeterminate => return false,
 552                 PathResult::NonModule(..) | PathResult::Failed { .. } => return true,
 553             }
 554         };
 555
 556         import.imported_module.set(Some(module));
 557         let (source, target, source_bindings, target_bindings, type_ns_only) = match import.kind {
 558             ImportKind::Single {
 559                 source,
 560                 target,
 561                 ref source_bindings,
 562                 ref target_bindings,
 563                 type_ns_only,
 564                 ..
 565             } => (source, target, source_bindings, target_bindings, type_ns_only),
 566             ImportKind::Glob { .. } => {
 567                 self.resolve_glob_import(import);
 568                 return true;
 569             }
 570             _ => unreachable!(),
 571         };
 572
 573         let mut indeterminate = false;
 574         self.r.per_ns(|this, ns| {
 575             if !type_ns_only || ns == TypeNS {
 576                 if let Err(Undetermined) = source_bindings[ns].get() {
 577                     // For better failure detection, pretend that the import will
 578                     // not define any names while resolving its module path.
 579                     let orig_vis = import.vis.take();
 580                     let binding = this.resolve_ident_in_module(
 581                         module,
 582                         source,
 583                         ns,
 584                         &import.parent_scope,
 585                         None,
 586                         None,
 587                     );
 588                     import.vis.set(orig_vis);
 589                     source_bindings[ns].set(binding);
 590                 } else {
 591                     return;
 592                 };
 593
 594                 let parent = import.parent_scope.module;
 595                 match source_bindings[ns].get() {
 596                     Err(Undetermined) => indeterminate = true,
 597                     // Don't update the resolution, because it was never added.
 598                     Err(Determined) if target.name == kw::Underscore => {}
 599                     Ok(binding) if binding.is_importable() => {
 600                         let imported_binding = this.import(binding, import);
 601                         target_bindings[ns].set(Some(imported_binding));
 602                         this.define(parent, target, ns, imported_binding);
 603                     }
 604                     source_binding @ (Ok(..) | Err(Determined)) => {
 605                         if source_binding.is_ok() {
 606                             let msg = format!("`{}` is not directly importable", target);
 607                             struct_span_err!(this.session, import.span, E0253, "{}", &msg)
 608                                 .span_label(import.span, "cannot be imported directly")
 609                                 .emit();
 610                         }
 611                         let key = this.new_key(target, ns);
 612                         this.update_resolution(parent, key, |_, resolution| {
 613                             resolution.single_imports.remove(&Interned::new_unchecked(import));
 614                         });
 615                     }
 616                 }
 617             }
 618         });
 619
 620         !indeterminate
 621     }
 622
 623     /// Performs final import resolution, consistency checks and error reporting.
 624     ///
 625     /// Optionally returns an unresolved import error. This error is buffered and used to
 626     /// consolidate multiple unresolved import errors into a single diagnostic.
 627     fn finalize_import(&mut self, import: &'b Import<'b>) -> Option<UnresolvedImportError> {
 628         let orig_vis = import.vis.take();
 629         let ignore_binding = match &import.kind {
 630             ImportKind::Single { target_bindings, .. } => target_bindings[TypeNS].get(),
 631             _ => None,
 632         };
 633         let prev_ambiguity_errors_len = self.r.ambiguity_errors.len();
 634         let finalize = Finalize::with_root_span(import.root_id, import.span, import.root_span);
 635         let path_res = self.r.resolve_path(
 636             &import.module_path,
 637             None,
 638             &import.parent_scope,
 639             Some(finalize),
 640             ignore_binding,
 641         );
 642         let no_ambiguity = self.r.ambiguity_errors.len() == prev_ambiguity_errors_len;
 643         import.vis.set(orig_vis);
 644         let module = match path_res {
 645             PathResult::Module(module) => {
 646                 // Consistency checks, analogous to `finalize_macro_resolutions`.
 647                 if let Some(initial_module) = import.imported_module.get() {
 648                     if !ModuleOrUniformRoot::same_def(module, initial_module) && no_ambiguity {
 649                         span_bug!(import.span, "inconsistent resolution for an import");
 650                     }
 651                 } else if self.r.privacy_errors.is_empty() {
 652                     let msg = "cannot determine resolution for the import";
 653                     let msg_note = "import resolution is stuck, try simplifying other imports";
 654                     self.r.session.struct_span_err(import.span, msg).note(msg_note).emit();
 655                 }
 656
 657                 module
 658             }
 659             PathResult::Failed { is_error_from_last_segment: false, span, label, suggestion } => {
 660                 if no_ambiguity {
 661                     assert!(import.imported_module.get().is_none());
 662                     self.r
 663                         .report_error(span, ResolutionError::FailedToResolve { label, suggestion });
 664                 }
 665                 return None;
 666             }
 667             PathResult::Failed { is_error_from_last_segment: true, span, label, suggestion } => {
 668                 if no_ambiguity {
 669                     assert!(import.imported_module.get().is_none());
 670                     let err = match self.make_path_suggestion(
 671                         span,
 672                         import.module_path.clone(),
 673                         &import.parent_scope,
 674                     ) {
 675                         Some((suggestion, note)) => UnresolvedImportError {
 676                             span,
 677                             label: None,
 678                             note,
 679                             suggestion: Some((
 680                                 vec![(span, Segment::names_to_string(&suggestion))],
 681                                 String::from("a similar path exists"),
 682                                 Applicability::MaybeIncorrect,
 683                             )),
 684                         },
 685                         None => UnresolvedImportError {
 686                             span,
 687                             label: Some(label),
 688                             note: None,
 689                             suggestion,
 690                         },
 691                     };
 692                     return Some(err);
 693                 }
 694                 return None;
 695             }
 696             PathResult::NonModule(_) => {
 697                 if no_ambiguity {
 698                     assert!(import.imported_module.get().is_none());
 699                 }
 700                 // The error was already reported earlier.
 701                 return None;
 702             }
 703             PathResult::Indeterminate => unreachable!(),
 704         };
 705
 706         let (ident, target, source_bindings, target_bindings, type_ns_only) = match import.kind {
 707             ImportKind::Single {
 708                 source,
 709                 target,
 710                 ref source_bindings,
 711                 ref target_bindings,
 712                 type_ns_only,
 713                 ..
 714             } => (source, target, source_bindings, target_bindings, type_ns_only),
 715             ImportKind::Glob { is_prelude, ref max_vis } => {
 716                 if import.module_path.len() <= 1 {
 717                     // HACK(eddyb) `lint_if_path_starts_with_module` needs at least
 718                     // 2 segments, so the `resolve_path` above won't trigger it.
 719                     let mut full_path = import.module_path.clone();
 720                     full_path.push(Segment::from_ident(Ident::empty()));
 721                     self.r.lint_if_path_starts_with_module(Some(finalize), &full_path, None);
 722                 }
 723
 724                 if let ModuleOrUniformRoot::Module(module) = module {
 725                     if ptr::eq(module, import.parent_scope.module) {
 726                         // Importing a module into itself is not allowed.
 727                         return Some(UnresolvedImportError {
 728                             span: import.span,
 729                             label: Some(String::from("cannot glob-import a module into itself")),
 730                             note: None,
 731                             suggestion: None,
 732                         });
 733                     }
 734                 }
 735                 if !is_prelude
 736                     && let Some(max_vis) = max_vis.get()
 737                     && !max_vis.is_at_least(import.expect_vis(), &*self.r)
 738                 {
 739                     let msg = "glob import doesn't reexport anything because no candidate is public enough";
 740                     self.r.lint_buffer.buffer_lint(UNUSED_IMPORTS, import.id, import.span, msg);
 741                 }
 742                 return None;
 743             }
 744             _ => unreachable!(),
 745         };
 746
 747         let mut all_ns_err = true;
 748         self.r.per_ns(|this, ns| {
 749             if !type_ns_only || ns == TypeNS {
 750                 let orig_vis = import.vis.take();
 751                 let binding = this.resolve_ident_in_module(
 752                     module,
 753                     ident,
 754                     ns,
 755                     &import.parent_scope,
 756                     Some(Finalize { report_private: false, ..finalize }),
 757                     target_bindings[ns].get(),
 758                 );
 759                 import.vis.set(orig_vis);
 760
 761                 match binding {
 762                     Ok(binding) => {
 763                         // Consistency checks, analogous to `finalize_macro_resolutions`.
 764                         let initial_res = source_bindings[ns].get().map(|initial_binding| {
 765                             all_ns_err = false;
 766                             if let Some(target_binding) = target_bindings[ns].get() {
 767                                 if target.name == kw::Underscore
 768                                     && initial_binding.is_extern_crate()
 769                                     && !initial_binding.is_import()
 770                                 {
 771                                     this.record_use(
 772                                         ident,
 773                                         target_binding,
 774                                         import.module_path.is_empty(),
 775                                     );
 776                                 }
 777                             }
 778                             initial_binding.res()
 779                         });
 780                         let res = binding.res();
 781                         if let Ok(initial_res) = initial_res {
 782                             if res != initial_res && this.ambiguity_errors.is_empty() {
 783                                 span_bug!(import.span, "inconsistent resolution for an import");
 784                             }
 785                         } else if res != Res::Err
 786                             && this.ambiguity_errors.is_empty()
 787                             && this.privacy_errors.is_empty()
 788                         {
 789                             let msg = "cannot determine resolution for the import";
 790                             let msg_note =
 791                                 "import resolution is stuck, try simplifying other imports";
 792                             this.session.struct_span_err(import.span, msg).note(msg_note).emit();
 793                         }
 794                     }
 795                     Err(..) => {
 796                         // FIXME: This assert may fire if public glob is later shadowed by a private
 797                         // single import (see test `issue-55884-2.rs`). In theory single imports should
 798                         // always block globs, even if they are not yet resolved, so that this kind of
 799                         // self-inconsistent resolution never happens.
 800                         // Re-enable the assert when the issue is fixed.
 801                         // assert!(result[ns].get().is_err());
 802                     }
 803                 }
 804             }
 805         });
 806
 807         if all_ns_err {
 808             let mut all_ns_failed = true;
 809             self.r.per_ns(|this, ns| {
 810                 if !type_ns_only || ns == TypeNS {
 811                     let binding = this.resolve_ident_in_module(
 812                         module,
 813                         ident,
 814                         ns,
 815                         &import.parent_scope,
 816                         Some(finalize),
 817                         None,
 818                     );
 819                     if binding.is_ok() {
 820                         all_ns_failed = false;
 821                     }
 822                 }
 823             });
 824
 825             return if all_ns_failed {
 826                 let resolutions = match module {
 827                     ModuleOrUniformRoot::Module(module) => {
 828                         Some(self.r.resolutions(module).borrow())
 829                     }
 830                     _ => None,
 831                 };
 832                 let resolutions = resolutions.as_ref().into_iter().flat_map(|r| r.iter());
 833                 let names = resolutions
 834                     .filter_map(|(BindingKey { ident: i, .. }, resolution)| {
 835                         if *i == ident {
 836                             return None;
 837                         } // Never suggest the same name
 838                         match *resolution.borrow() {
 839                             NameResolution { binding: Some(name_binding), .. } => {
 840                                 match name_binding.kind {
 841                                     NameBindingKind::Import { binding, .. } => {
 842                                         match binding.kind {
 843                                             // Never suggest the name that has binding error
 844                                             // i.e., the name that cannot be previously resolved
 845                                             NameBindingKind::Res(Res::Err, _) => None,
 846                                             _ => Some(i.name),
 847                                         }
 848                                     }
 849                                     _ => Some(i.name),
 850                                 }
 851                             }
 852                             NameResolution { ref single_imports, .. }
 853                                 if single_imports.is_empty() =>
 854                             {
 855                                 None
 856                             }
 857                             _ => Some(i.name),
 858                         }
 859                     })
 860                     .collect::<Vec<Symbol>>();
 861
 862                 let lev_suggestion =
 863                     find_best_match_for_name(&names, ident.name, None).map(|suggestion| {
 864                         (
 865                             vec![(ident.span, suggestion.to_string())],
 866                             String::from("a similar name exists in the module"),
 867                             Applicability::MaybeIncorrect,
 868                         )
 869                     });
 870
 871                 let (suggestion, note) =
 872                     match self.check_for_module_export_macro(import, module, ident) {
 873                         Some((suggestion, note)) => (suggestion.or(lev_suggestion), note),
 874                         _ => (lev_suggestion, None),
 875                     };
 876
 877                 let label = match module {
 878                     ModuleOrUniformRoot::Module(module) => {
 879                         let module_str = module_to_string(module);
 880                         if let Some(module_str) = module_str {
 881                             format!("no `{}` in `{}`", ident, module_str)
 882                         } else {
 883                             format!("no `{}` in the root", ident)
 884                         }
 885                     }
 886                     _ => {
 887                         if !ident.is_path_segment_keyword() {
 888                             format!("no external crate `{}`", ident)
 889                         } else {
 890                             // HACK(eddyb) this shows up for `self` & `super`, which
 891                             // should work instead - for now keep the same error message.
 892                             format!("no `{}` in the root", ident)
 893                         }
 894                     }
 895                 };
 896
 897                 Some(UnresolvedImportError {
 898                     span: import.span,
 899                     label: Some(label),
 900                     note,
 901                     suggestion,
 902                 })
 903             } else {
 904                 // `resolve_ident_in_module` reported a privacy error.
 905                 None
 906             };
 907         }
 908
 909         let mut reexport_error = None;
 910         let mut any_successful_reexport = false;
 911         let mut crate_private_reexport = false;
 912         self.r.per_ns(|this, ns| {
 913             if let Ok(binding) = source_bindings[ns].get() {
 914                 if !binding.vis.is_at_least(import.expect_vis(), &*this) {
 915                     reexport_error = Some((ns, binding));
 916                     if let ty::Visibility::Restricted(binding_def_id) = binding.vis {
 917                         if binding_def_id.is_top_level_module() {
 918                             crate_private_reexport = true;
 919                         }
 920                     }
 921                 } else {
 922                     any_successful_reexport = true;
 923                 }
 924             }
 925         });
 926
 927         // All namespaces must be re-exported with extra visibility for an error to occur.
 928         if !any_successful_reexport {
 929             let (ns, binding) = reexport_error.unwrap();
 930             if pub_use_of_private_extern_crate_hack(import, binding) {
 931                 let msg = format!(
 932                     "extern crate `{}` is private, and cannot be \
 933                                    re-exported (error E0365), consider declaring with \
 934                                    `pub`",
 935                     ident
 936                 );
 937                 self.r.lint_buffer.buffer_lint(
 938                     PUB_USE_OF_PRIVATE_EXTERN_CRATE,
 939                     import.id,
 940                     import.span,
 941                     &msg,
 942                 );
 943             } else {
 944                 let error_msg = if crate_private_reexport {
 945                     format!(
 946                         "`{}` is only public within the crate, and cannot be re-exported outside",
 947                         ident
 948                     )
 949                 } else {
 950                     format!("`{}` is private, and cannot be re-exported", ident)
 951                 };
 952
 953                 if ns == TypeNS {
 954                     let label_msg = if crate_private_reexport {
 955                         format!("re-export of crate public `{}`", ident)
 956                     } else {
 957                         format!("re-export of private `{}`", ident)
 958                     };
 959
 960                     struct_span_err!(self.r.session, import.span, E0365, "{}", error_msg)
 961                         .span_label(import.span, label_msg)
 962                         .note(&format!("consider declaring type or module `{}` with `pub`", ident))
 963                         .emit();
 964                 } else {
 965                     let mut err =
 966                         struct_span_err!(self.r.session, import.span, E0364, "{error_msg}");
 967                     match binding.kind {
 968                         NameBindingKind::Res(Res::Def(DefKind::Macro(_), def_id), _)
 969                             // exclude decl_macro
 970                             if self.r.get_macro_by_def_id(def_id).macro_rules =>
 971                         {
 972                             err.span_help(
 973                                 binding.span,
 974                                 "consider adding a `#[macro_export]` to the macro in the imported module",
 975                             );
 976                         }
 977                         _ => {
 978                             err.span_note(
 979                                 import.span,
 980                                 &format!(
 981                                     "consider marking `{ident}` as `pub` in the imported module"
 982                                 ),
 983                             );
 984                         }
 985                     }
 986                     err.emit();
 987                 }
 988             }
 989         }
 990
 991         if import.module_path.len() <= 1 {
 992             // HACK(eddyb) `lint_if_path_starts_with_module` needs at least
 993             // 2 segments, so the `resolve_path` above won't trigger it.
 994             let mut full_path = import.module_path.clone();
 995             full_path.push(Segment::from_ident(ident));
 996             self.r.per_ns(|this, ns| {
 997                 if let Ok(binding) = source_bindings[ns].get() {
 998                     this.lint_if_path_starts_with_module(Some(finalize), &full_path, Some(binding));
 999                 }
1000             });
1001         }
1002
1003         // Record what this import resolves to for later uses in documentation,
1004         // this may resolve to either a value or a type, but for documentation
1005         // purposes it's good enough to just favor one over the other.
1006         self.r.per_ns(|this, ns| {
1007             if let Ok(binding) = source_bindings[ns].get() {
1008                 this.import_res_map.entry(import.id).or_default()[ns] = Some(binding.res());
1009             }
1010         });
1011
1012         self.check_for_redundant_imports(ident, import, source_bindings, target_bindings, target);
1013
1014         debug!("(resolving single import) successfully resolved import");
1015         None
1016     }
1017
1018     fn check_for_redundant_imports(
1019         &mut self,
1020         ident: Ident,
1021         import: &'b Import<'b>,
1022         source_bindings: &PerNS<Cell<Result<&'b NameBinding<'b>, Determinacy>>>,
1023         target_bindings: &PerNS<Cell<Option<&'b NameBinding<'b>>>>,
1024         target: Ident,
1025     ) {
1026         // Skip if the import was produced by a macro.
1027         if import.parent_scope.expansion != LocalExpnId::ROOT {
1028             return;
1029         }
1030
1031         // Skip if we are inside a named module (in contrast to an anonymous
1032         // module defined by a block).
1033         if let ModuleKind::Def(..) = import.parent_scope.module.kind {
1034             return;
1035         }
1036
1037         let mut is_redundant = PerNS { value_ns: None, type_ns: None, macro_ns: None };
1038
1039         let mut redundant_span = PerNS { value_ns: None, type_ns: None, macro_ns: None };
1040
1041         self.r.per_ns(|this, ns| {
1042             if let Ok(binding) = source_bindings[ns].get() {
1043                 if binding.res() == Res::Err {
1044                     return;
1045                 }
1046
1047                 match this.early_resolve_ident_in_lexical_scope(
1048                     target,
1049                     ScopeSet::All(ns, false),
1050                     &import.parent_scope,
1051                     None,
1052                     false,
1053                     target_bindings[ns].get(),
1054                 ) {
1055                     Ok(other_binding) => {
1056                         is_redundant[ns] = Some(
1057                             binding.res() == other_binding.res() && !other_binding.is_ambiguity(),
1058                         );
1059                         redundant_span[ns] = Some((other_binding.span, other_binding.is_import()));
1060                     }
1061                     Err(_) => is_redundant[ns] = Some(false),
1062                 }
1063             }
1064         });
1065
1066         if !is_redundant.is_empty() && is_redundant.present_items().all(|is_redundant| is_redundant)
1067         {
1068             let mut redundant_spans: Vec<_> = redundant_span.present_items().collect();
1069             redundant_spans.sort();
1070             redundant_spans.dedup();
1071             self.r.lint_buffer.buffer_lint_with_diagnostic(
1072                 UNUSED_IMPORTS,
1073                 import.id,
1074                 import.span,
1075                 &format!("the item `{}` is imported redundantly", ident),
1076                 BuiltinLintDiagnostics::RedundantImport(redundant_spans, ident),
1077             );
1078         }
1079     }
1080
1081     fn resolve_glob_import(&mut self, import: &'b Import<'b>) {
1082         let ModuleOrUniformRoot::Module(module) = import.imported_module.get().unwrap() else {
1083             self.r.session.span_err(import.span, "cannot glob-import all possible crates");
1084             return;
1085         };
1086
1087         if module.is_trait() {
1088             self.r.session.span_err(import.span, "items in traits are not importable");
1089             return;
1090         } else if ptr::eq(module, import.parent_scope.module) {
1091             return;
1092         } else if let ImportKind::Glob { is_prelude: true, .. } = import.kind {
1093             self.r.prelude = Some(module);
1094             return;
1095         }
1096
1097         // Add to module's glob_importers
1098         module.glob_importers.borrow_mut().push(import);
1099
1100         // Ensure that `resolutions` isn't borrowed during `try_define`,
1101         // since it might get updated via a glob cycle.
1102         let bindings = self
1103             .r
1104             .resolutions(module)
1105             .borrow()
1106             .iter()
1107             .filter_map(|(key, resolution)| {
1108                 resolution.borrow().binding().map(|binding| (*key, binding))
1109             })
1110             .collect::<Vec<_>>();
1111         for (mut key, binding) in bindings {
1112             let scope = match key.ident.span.reverse_glob_adjust(module.expansion, import.span) {
1113                 Some(Some(def)) => self.r.expn_def_scope(def),
1114                 Some(None) => import.parent_scope.module,
1115                 None => continue,
1116             };
1117             if self.r.is_accessible_from(binding.vis, scope) {
1118                 let imported_binding = self.r.import(binding, import);
1119                 let _ = self.r.try_define(import.parent_scope.module, key, imported_binding);
1120             }
1121         }
1122
1123         // Record the destination of this import
1124         self.r.record_partial_res(import.id, PartialRes::new(module.res().unwrap()));
1125     }
1126
1127     // Miscellaneous post-processing, including recording re-exports,
1128     // reporting conflicts, and reporting unresolved imports.
1129     fn finalize_resolutions_in(&mut self, module: Module<'b>) {
1130         // Since import resolution is finished, globs will not define any more names.
1131         *module.globs.borrow_mut() = Vec::new();
1132
1133         if let Some(def_id) = module.opt_def_id() {
1134             let mut reexports = Vec::new();
1135
1136             module.for_each_child(self.r, |this, ident, _, binding| {
1137                 if let Some(res) = this.is_reexport(binding) {
1138                     reexports.push(ModChild {
1139                         ident,
1140                         res,
1141                         vis: binding.vis,
1142                         span: binding.span,
1143                         macro_rules: false,
1144                     });
1145                 }
1146             });
1147
1148             if !reexports.is_empty() {
1149                 // Call to `expect_local` should be fine because current
1150                 // code is only called for local modules.
1151                 self.r.reexport_map.insert(def_id.expect_local(), reexports);
1152             }
1153         }
1154     }
1155 }
1156
1157 fn import_path_to_string(names: &[Ident], import_kind: &ImportKind<'_>, span: Span) -> String {
1158     let pos = names.iter().position(|p| span == p.span && p.name != kw::PathRoot);
1159     let global = !names.is_empty() && names[0].name == kw::PathRoot;
1160     if let Some(pos) = pos {
1161         let names = if global { &names[1..pos + 1] } else { &names[..pos + 1] };
1162         names_to_string(&names.iter().map(|ident| ident.name).collect::<Vec<_>>())
1163     } else {
1164         let names = if global { &names[1..] } else { names };
1165         if names.is_empty() {
1166             import_kind_to_string(import_kind)
1167         } else {
1168             format!(
1169                 "{}::{}",
1170                 names_to_string(&names.iter().map(|ident| ident.name).collect::<Vec<_>>()),
1171                 import_kind_to_string(import_kind),
1172             )
1173         }
1174     }
1175 }
1176
1177 fn import_kind_to_string(import_kind: &ImportKind<'_>) -> String {
1178     match import_kind {
1179         ImportKind::Single { source, .. } => source.to_string(),
1180         ImportKind::Glob { .. } => "*".to_string(),
1181         ImportKind::ExternCrate { .. } => "<extern crate>".to_string(),
1182         ImportKind::MacroUse => "#[macro_use]".to_string(),
1183     }
1184 }