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::{import_candidates, Suggestion};
   4 use crate::Determinacy::{self, *};
   5 use crate::Namespace::*;
   6 use crate::{module_to_string, names_to_string, ImportSuggestion};
   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().to_def_id();
 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.expect_local()))
 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 && old_binding.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     candidate: Option<Vec<ImportSuggestion>>,
 385 }
 386
 387 pub struct ImportResolver<'a, 'b> {
 388     pub r: &'a mut Resolver<'b>,
 389 }
 390
 391 impl<'a, 'b> ImportResolver<'a, 'b> {
 392     // Import resolution
 393     //
 394     // This is a fixed-point algorithm. We resolve imports until our efforts
 395     // are stymied by an unresolved import; then we bail out of the current
 396     // module and continue. We terminate successfully once no more imports
 397     // remain or unsuccessfully when no forward progress in resolving imports
 398     // is made.
 399
 400     /// Resolves all imports for the crate. This method performs the fixed-
 401     /// point iteration.
 402     pub fn resolve_imports(&mut self) {
 403         let mut prev_num_indeterminates = self.r.indeterminate_imports.len() + 1;
 404         while self.r.indeterminate_imports.len() < prev_num_indeterminates {
 405             prev_num_indeterminates = self.r.indeterminate_imports.len();
 406             for import in mem::take(&mut self.r.indeterminate_imports) {
 407                 match self.resolve_import(&import) {
 408                     true => self.r.determined_imports.push(import),
 409                     false => self.r.indeterminate_imports.push(import),
 410                 }
 411             }
 412         }
 413     }
 414
 415     pub fn finalize_imports(&mut self) {
 416         for module in self.r.arenas.local_modules().iter() {
 417             self.finalize_resolutions_in(module);
 418         }
 419
 420         let mut seen_spans = FxHashSet::default();
 421         let mut errors = vec![];
 422         let mut prev_root_id: NodeId = NodeId::from_u32(0);
 423         let determined_imports = mem::take(&mut self.r.determined_imports);
 424         let indeterminate_imports = mem::take(&mut self.r.indeterminate_imports);
 425
 426         for (is_indeterminate, import) in determined_imports
 427             .into_iter()
 428             .map(|i| (false, i))
 429             .chain(indeterminate_imports.into_iter().map(|i| (true, i)))
 430         {
 431             let unresolved_import_error = self.finalize_import(import);
 432
 433             // If this import is unresolved then create a dummy import
 434             // resolution for it so that later resolve stages won't complain.
 435             self.r.import_dummy_binding(import);
 436
 437             if let Some(err) = unresolved_import_error {
 438                 if let ImportKind::Single { source, ref source_bindings, .. } = import.kind {
 439                     if source.name == kw::SelfLower {
 440                         // Silence `unresolved import` error if E0429 is already emitted
 441                         if let Err(Determined) = source_bindings.value_ns.get() {
 442                             continue;
 443                         }
 444                     }
 445                 }
 446
 447                 if prev_root_id.as_u32() != 0
 448                     && prev_root_id.as_u32() != import.root_id.as_u32()
 449                     && !errors.is_empty()
 450                 {
 451                     // In the case of a new import line, throw a diagnostic message
 452                     // for the previous line.
 453                     self.throw_unresolved_import_error(errors, None);
 454                     errors = vec![];
 455                 }
 456                 if seen_spans.insert(err.span) {
 457                     let path = import_path_to_string(
 458                         &import.module_path.iter().map(|seg| seg.ident).collect::<Vec<_>>(),
 459                         &import.kind,
 460                         err.span,
 461                     );
 462                     errors.push((path, err));
 463                     prev_root_id = import.root_id;
 464                 }
 465             } else if is_indeterminate {
 466                 let path = import_path_to_string(
 467                     &import.module_path.iter().map(|seg| seg.ident).collect::<Vec<_>>(),
 468                     &import.kind,
 469                     import.span,
 470                 );
 471                 let err = UnresolvedImportError {
 472                     span: import.span,
 473                     label: None,
 474                     note: None,
 475                     suggestion: None,
 476                     candidate: None,
 477                 };
 478                 if path.contains("::") {
 479                     errors.push((path, err))
 480                 }
 481             }
 482         }
 483
 484         if !errors.is_empty() {
 485             self.throw_unresolved_import_error(errors, None);
 486         }
 487     }
 488
 489     fn throw_unresolved_import_error(
 490         &self,
 491         errors: Vec<(String, UnresolvedImportError)>,
 492         span: Option<MultiSpan>,
 493     ) {
 494         /// Upper limit on the number of `span_label` messages.
 495         const MAX_LABEL_COUNT: usize = 10;
 496
 497         let (span, msg) = if errors.is_empty() {
 498             (span.unwrap(), "unresolved import".to_string())
 499         } else {
 500             let span = MultiSpan::from_spans(errors.iter().map(|(_, err)| err.span).collect());
 501
 502             let paths = errors.iter().map(|(path, _)| format!("`{}`", path)).collect::<Vec<_>>();
 503
 504             let msg = format!("unresolved import{} {}", pluralize!(paths.len()), paths.join(", "),);
 505
 506             (span, msg)
 507         };
 508
 509         let mut diag = struct_span_err!(self.r.session, span, E0432, "{}", &msg);
 510
 511         if let Some((_, UnresolvedImportError { note: Some(note), .. })) = errors.iter().last() {
 512             diag.note(note);
 513         }
 514
 515         for (_, err) in errors.into_iter().take(MAX_LABEL_COUNT) {
 516             if let Some(label) = err.label {
 517                 diag.span_label(err.span, label);
 518             }
 519
 520             if let Some((suggestions, msg, applicability)) = err.suggestion {
 521                 if suggestions.is_empty() {
 522                     diag.help(&msg);
 523                     continue;
 524                 }
 525                 diag.multipart_suggestion(&msg, suggestions, applicability);
 526             }
 527
 528             if let Some(candidate) = &err.candidate {
 529                 import_candidates(
 530                     self.r.session,
 531                     &self.r.source_span,
 532                     &mut diag,
 533                     Some(err.span),
 534                     &candidate,
 535                 )
 536             }
 537         }
 538
 539         diag.emit();
 540     }
 541
 542     /// Attempts to resolve the given import, returning true if its resolution is determined.
 543     /// If successful, the resolved bindings are written into the module.
 544     fn resolve_import(&mut self, import: &'b Import<'b>) -> bool {
 545         debug!(
 546             "(resolving import for module) resolving import `{}::...` in `{}`",
 547             Segment::names_to_string(&import.module_path),
 548             module_to_string(import.parent_scope.module).unwrap_or_else(|| "???".to_string()),
 549         );
 550
 551         let module = if let Some(module) = import.imported_module.get() {
 552             module
 553         } else {
 554             // For better failure detection, pretend that the import will
 555             // not define any names while resolving its module path.
 556             let orig_vis = import.vis.take();
 557             let path_res =
 558                 self.r.maybe_resolve_path(&import.module_path, None, &import.parent_scope);
 559             import.vis.set(orig_vis);
 560
 561             match path_res {
 562                 PathResult::Module(module) => module,
 563                 PathResult::Indeterminate => return false,
 564                 PathResult::NonModule(..) | PathResult::Failed { .. } => return true,
 565             }
 566         };
 567
 568         import.imported_module.set(Some(module));
 569         let (source, target, source_bindings, target_bindings, type_ns_only) = match import.kind {
 570             ImportKind::Single {
 571                 source,
 572                 target,
 573                 ref source_bindings,
 574                 ref target_bindings,
 575                 type_ns_only,
 576                 ..
 577             } => (source, target, source_bindings, target_bindings, type_ns_only),
 578             ImportKind::Glob { .. } => {
 579                 self.resolve_glob_import(import);
 580                 return true;
 581             }
 582             _ => unreachable!(),
 583         };
 584
 585         let mut indeterminate = false;
 586         self.r.per_ns(|this, ns| {
 587             if !type_ns_only || ns == TypeNS {
 588                 if let Err(Undetermined) = source_bindings[ns].get() {
 589                     // For better failure detection, pretend that the import will
 590                     // not define any names while resolving its module path.
 591                     let orig_vis = import.vis.take();
 592                     let binding = this.resolve_ident_in_module(
 593                         module,
 594                         source,
 595                         ns,
 596                         &import.parent_scope,
 597                         None,
 598                         None,
 599                     );
 600                     import.vis.set(orig_vis);
 601                     source_bindings[ns].set(binding);
 602                 } else {
 603                     return;
 604                 };
 605
 606                 let parent = import.parent_scope.module;
 607                 match source_bindings[ns].get() {
 608                     Err(Undetermined) => indeterminate = true,
 609                     // Don't update the resolution, because it was never added.
 610                     Err(Determined) if target.name == kw::Underscore => {}
 611                     Ok(binding) if binding.is_importable() => {
 612                         let imported_binding = this.import(binding, import);
 613                         target_bindings[ns].set(Some(imported_binding));
 614                         this.define(parent, target, ns, imported_binding);
 615                     }
 616                     source_binding @ (Ok(..) | Err(Determined)) => {
 617                         if source_binding.is_ok() {
 618                             let msg = format!("`{}` is not directly importable", target);
 619                             struct_span_err!(this.session, import.span, E0253, "{}", &msg)
 620                                 .span_label(import.span, "cannot be imported directly")
 621                                 .emit();
 622                         }
 623                         let key = this.new_key(target, ns);
 624                         this.update_resolution(parent, key, |_, resolution| {
 625                             resolution.single_imports.remove(&Interned::new_unchecked(import));
 626                         });
 627                     }
 628                 }
 629             }
 630         });
 631
 632         !indeterminate
 633     }
 634
 635     /// Performs final import resolution, consistency checks and error reporting.
 636     ///
 637     /// Optionally returns an unresolved import error. This error is buffered and used to
 638     /// consolidate multiple unresolved import errors into a single diagnostic.
 639     fn finalize_import(&mut self, import: &'b Import<'b>) -> Option<UnresolvedImportError> {
 640         let orig_vis = import.vis.take();
 641         let ignore_binding = match &import.kind {
 642             ImportKind::Single { target_bindings, .. } => target_bindings[TypeNS].get(),
 643             _ => None,
 644         };
 645         let prev_ambiguity_errors_len = self.r.ambiguity_errors.len();
 646         let finalize = Finalize::with_root_span(import.root_id, import.span, import.root_span);
 647         let path_res = self.r.resolve_path(
 648             &import.module_path,
 649             None,
 650             &import.parent_scope,
 651             Some(finalize),
 652             ignore_binding,
 653         );
 654
 655         let no_ambiguity = self.r.ambiguity_errors.len() == prev_ambiguity_errors_len;
 656         import.vis.set(orig_vis);
 657         let module = match path_res {
 658             PathResult::Module(module) => {
 659                 // Consistency checks, analogous to `finalize_macro_resolutions`.
 660                 if let Some(initial_module) = import.imported_module.get() {
 661                     if !ModuleOrUniformRoot::same_def(module, initial_module) && no_ambiguity {
 662                         span_bug!(import.span, "inconsistent resolution for an import");
 663                     }
 664                 } else if self.r.privacy_errors.is_empty() {
 665                     let msg = "cannot determine resolution for the import";
 666                     let msg_note = "import resolution is stuck, try simplifying other imports";
 667                     self.r.session.struct_span_err(import.span, msg).note(msg_note).emit();
 668                 }
 669
 670                 module
 671             }
 672             PathResult::Failed { is_error_from_last_segment: false, span, label, suggestion } => {
 673                 if no_ambiguity {
 674                     assert!(import.imported_module.get().is_none());
 675                     self.r
 676                         .report_error(span, ResolutionError::FailedToResolve { label, suggestion });
 677                 }
 678                 return None;
 679             }
 680             PathResult::Failed { is_error_from_last_segment: true, span, label, suggestion } => {
 681                 if no_ambiguity {
 682                     assert!(import.imported_module.get().is_none());
 683                     let err = match self.make_path_suggestion(
 684                         span,
 685                         import.module_path.clone(),
 686                         &import.parent_scope,
 687                     ) {
 688                         Some((suggestion, note)) => UnresolvedImportError {
 689                             span,
 690                             label: None,
 691                             note,
 692                             suggestion: Some((
 693                                 vec![(span, Segment::names_to_string(&suggestion))],
 694                                 String::from("a similar path exists"),
 695                                 Applicability::MaybeIncorrect,
 696                             )),
 697                             candidate: None,
 698                         },
 699                         None => UnresolvedImportError {
 700                             span,
 701                             label: Some(label),
 702                             note: None,
 703                             suggestion,
 704                             candidate: None,
 705                         },
 706                     };
 707                     return Some(err);
 708                 }
 709                 return None;
 710             }
 711             PathResult::NonModule(_) => {
 712                 if no_ambiguity {
 713                     assert!(import.imported_module.get().is_none());
 714                 }
 715                 // The error was already reported earlier.
 716                 return None;
 717             }
 718             PathResult::Indeterminate => unreachable!(),
 719         };
 720
 721         let (ident, target, source_bindings, target_bindings, type_ns_only) = match import.kind {
 722             ImportKind::Single {
 723                 source,
 724                 target,
 725                 ref source_bindings,
 726                 ref target_bindings,
 727                 type_ns_only,
 728                 ..
 729             } => (source, target, source_bindings, target_bindings, type_ns_only),
 730             ImportKind::Glob { is_prelude, ref max_vis } => {
 731                 if import.module_path.len() <= 1 {
 732                     // HACK(eddyb) `lint_if_path_starts_with_module` needs at least
 733                     // 2 segments, so the `resolve_path` above won't trigger it.
 734                     let mut full_path = import.module_path.clone();
 735                     full_path.push(Segment::from_ident(Ident::empty()));
 736                     self.r.lint_if_path_starts_with_module(Some(finalize), &full_path, None);
 737                 }
 738
 739                 if let ModuleOrUniformRoot::Module(module) = module {
 740                     if ptr::eq(module, import.parent_scope.module) {
 741                         // Importing a module into itself is not allowed.
 742                         return Some(UnresolvedImportError {
 743                             span: import.span,
 744                             label: Some(String::from("cannot glob-import a module into itself")),
 745                             note: None,
 746                             suggestion: None,
 747                             candidate: None,
 748                         });
 749                     }
 750                 }
 751                 if !is_prelude
 752                     && let Some(max_vis) = max_vis.get()
 753                     && !max_vis.is_at_least(import.expect_vis(), &*self.r)
 754                 {
 755                     let msg = "glob import doesn't reexport anything because no candidate is public enough";
 756                     self.r.lint_buffer.buffer_lint(UNUSED_IMPORTS, import.id, import.span, msg);
 757                 }
 758                 return None;
 759             }
 760             _ => unreachable!(),
 761         };
 762
 763         let mut all_ns_err = true;
 764         self.r.per_ns(|this, ns| {
 765             if !type_ns_only || ns == TypeNS {
 766                 let orig_vis = import.vis.take();
 767                 let binding = this.resolve_ident_in_module(
 768                     module,
 769                     ident,
 770                     ns,
 771                     &import.parent_scope,
 772                     Some(Finalize { report_private: false, ..finalize }),
 773                     target_bindings[ns].get(),
 774                 );
 775                 import.vis.set(orig_vis);
 776
 777                 match binding {
 778                     Ok(binding) => {
 779                         // Consistency checks, analogous to `finalize_macro_resolutions`.
 780                         let initial_res = source_bindings[ns].get().map(|initial_binding| {
 781                             all_ns_err = false;
 782                             if let Some(target_binding) = target_bindings[ns].get() {
 783                                 if target.name == kw::Underscore
 784                                     && initial_binding.is_extern_crate()
 785                                     && !initial_binding.is_import()
 786                                 {
 787                                     this.record_use(
 788                                         ident,
 789                                         target_binding,
 790                                         import.module_path.is_empty(),
 791                                     );
 792                                 }
 793                             }
 794                             initial_binding.res()
 795                         });
 796                         let res = binding.res();
 797                         if let Ok(initial_res) = initial_res {
 798                             if res != initial_res && this.ambiguity_errors.is_empty() {
 799                                 span_bug!(import.span, "inconsistent resolution for an import");
 800                             }
 801                         } else if res != Res::Err
 802                             && this.ambiguity_errors.is_empty()
 803                             && this.privacy_errors.is_empty()
 804                         {
 805                             let msg = "cannot determine resolution for the import";
 806                             let msg_note =
 807                                 "import resolution is stuck, try simplifying other imports";
 808                             this.session.struct_span_err(import.span, msg).note(msg_note).emit();
 809                         }
 810                     }
 811                     Err(..) => {
 812                         // FIXME: This assert may fire if public glob is later shadowed by a private
 813                         // single import (see test `issue-55884-2.rs`). In theory single imports should
 814                         // always block globs, even if they are not yet resolved, so that this kind of
 815                         // self-inconsistent resolution never happens.
 816                         // Re-enable the assert when the issue is fixed.
 817                         // assert!(result[ns].get().is_err());
 818                     }
 819                 }
 820             }
 821         });
 822
 823         if all_ns_err {
 824             let mut all_ns_failed = true;
 825             self.r.per_ns(|this, ns| {
 826                 if !type_ns_only || ns == TypeNS {
 827                     let binding = this.resolve_ident_in_module(
 828                         module,
 829                         ident,
 830                         ns,
 831                         &import.parent_scope,
 832                         Some(finalize),
 833                         None,
 834                     );
 835                     if binding.is_ok() {
 836                         all_ns_failed = false;
 837                     }
 838                 }
 839             });
 840
 841             return if all_ns_failed {
 842                 let resolutions = match module {
 843                     ModuleOrUniformRoot::Module(module) => {
 844                         Some(self.r.resolutions(module).borrow())
 845                     }
 846                     _ => None,
 847                 };
 848                 let resolutions = resolutions.as_ref().into_iter().flat_map(|r| r.iter());
 849                 let names = resolutions
 850                     .filter_map(|(BindingKey { ident: i, .. }, resolution)| {
 851                         if *i == ident {
 852                             return None;
 853                         } // Never suggest the same name
 854                         match *resolution.borrow() {
 855                             NameResolution { binding: Some(name_binding), .. } => {
 856                                 match name_binding.kind {
 857                                     NameBindingKind::Import { binding, .. } => {
 858                                         match binding.kind {
 859                                             // Never suggest the name that has binding error
 860                                             // i.e., the name that cannot be previously resolved
 861                                             NameBindingKind::Res(Res::Err, _) => None,
 862                                             _ => Some(i.name),
 863                                         }
 864                                     }
 865                                     _ => Some(i.name),
 866                                 }
 867                             }
 868                             NameResolution { ref single_imports, .. }
 869                                 if single_imports.is_empty() =>
 870                             {
 871                                 None
 872                             }
 873                             _ => Some(i.name),
 874                         }
 875                     })
 876                     .collect::<Vec<Symbol>>();
 877
 878                 let lev_suggestion =
 879                     find_best_match_for_name(&names, ident.name, None).map(|suggestion| {
 880                         (
 881                             vec![(ident.span, suggestion.to_string())],
 882                             String::from("a similar name exists in the module"),
 883                             Applicability::MaybeIncorrect,
 884                         )
 885                     });
 886
 887                 let (suggestion, note) =
 888                     match self.check_for_module_export_macro(import, module, ident) {
 889                         Some((suggestion, note)) => (suggestion.or(lev_suggestion), note),
 890                         _ => (lev_suggestion, None),
 891                     };
 892
 893                 let label = match module {
 894                     ModuleOrUniformRoot::Module(module) => {
 895                         let module_str = module_to_string(module);
 896                         if let Some(module_str) = module_str {
 897                             format!("no `{}` in `{}`", ident, module_str)
 898                         } else {
 899                             format!("no `{}` in the root", ident)
 900                         }
 901                     }
 902                     _ => {
 903                         if !ident.is_path_segment_keyword() {
 904                             format!("no external crate `{}`", ident)
 905                         } else {
 906                             // HACK(eddyb) this shows up for `self` & `super`, which
 907                             // should work instead - for now keep the same error message.
 908                             format!("no `{}` in the root", ident)
 909                         }
 910                     }
 911                 };
 912
 913                 let parent_suggestion =
 914                     self.r.lookup_import_candidates(ident, TypeNS, &import.parent_scope, |_| true);
 915
 916                 Some(UnresolvedImportError {
 917                     span: import.span,
 918                     label: Some(label),
 919                     note,
 920                     suggestion,
 921                     candidate: if !parent_suggestion.is_empty() {
 922                         Some(parent_suggestion)
 923                     } else {
 924                         None
 925                     },
 926                 })
 927             } else {
 928                 // `resolve_ident_in_module` reported a privacy error.
 929                 None
 930             };
 931         }
 932
 933         let mut reexport_error = None;
 934         let mut any_successful_reexport = false;
 935         let mut crate_private_reexport = false;
 936         self.r.per_ns(|this, ns| {
 937             if let Ok(binding) = source_bindings[ns].get() {
 938                 if !binding.vis.is_at_least(import.expect_vis(), &*this) {
 939                     reexport_error = Some((ns, binding));
 940                     if let ty::Visibility::Restricted(binding_def_id) = binding.vis {
 941                         if binding_def_id.is_top_level_module() {
 942                             crate_private_reexport = true;
 943                         }
 944                     }
 945                 } else {
 946                     any_successful_reexport = true;
 947                 }
 948             }
 949         });
 950
 951         // All namespaces must be re-exported with extra visibility for an error to occur.
 952         if !any_successful_reexport {
 953             let (ns, binding) = reexport_error.unwrap();
 954             if pub_use_of_private_extern_crate_hack(import, binding) {
 955                 let msg = format!(
 956                     "extern crate `{}` is private, and cannot be \
 957                                    re-exported (error E0365), consider declaring with \
 958                                    `pub`",
 959                     ident
 960                 );
 961                 self.r.lint_buffer.buffer_lint(
 962                     PUB_USE_OF_PRIVATE_EXTERN_CRATE,
 963                     import.id,
 964                     import.span,
 965                     &msg,
 966                 );
 967             } else {
 968                 let error_msg = if crate_private_reexport {
 969                     format!(
 970                         "`{}` is only public within the crate, and cannot be re-exported outside",
 971                         ident
 972                     )
 973                 } else {
 974                     format!("`{}` is private, and cannot be re-exported", ident)
 975                 };
 976
 977                 if ns == TypeNS {
 978                     let label_msg = if crate_private_reexport {
 979                         format!("re-export of crate public `{}`", ident)
 980                     } else {
 981                         format!("re-export of private `{}`", ident)
 982                     };
 983
 984                     struct_span_err!(self.r.session, import.span, E0365, "{}", error_msg)
 985                         .span_label(import.span, label_msg)
 986                         .note(&format!("consider declaring type or module `{}` with `pub`", ident))
 987                         .emit();
 988                 } else {
 989                     let mut err =
 990                         struct_span_err!(self.r.session, import.span, E0364, "{error_msg}");
 991                     match binding.kind {
 992                         NameBindingKind::Res(Res::Def(DefKind::Macro(_), def_id), _)
 993                             // exclude decl_macro
 994                             if self.r.get_macro_by_def_id(def_id).macro_rules =>
 995                         {
 996                             err.span_help(
 997                                 binding.span,
 998                                 "consider adding a `#[macro_export]` to the macro in the imported module",
 999                             );
1000                         }
1001                         _ => {
1002                             err.span_note(
1003                                 import.span,
1004                                 &format!(
1005                                     "consider marking `{ident}` as `pub` in the imported module"
1006                                 ),
1007                             );
1008                         }
1009                     }
1010                     err.emit();
1011                 }
1012             }
1013         }
1014
1015         if import.module_path.len() <= 1 {
1016             // HACK(eddyb) `lint_if_path_starts_with_module` needs at least
1017             // 2 segments, so the `resolve_path` above won't trigger it.
1018             let mut full_path = import.module_path.clone();
1019             full_path.push(Segment::from_ident(ident));
1020             self.r.per_ns(|this, ns| {
1021                 if let Ok(binding) = source_bindings[ns].get() {
1022                     this.lint_if_path_starts_with_module(Some(finalize), &full_path, Some(binding));
1023                 }
1024             });
1025         }
1026
1027         // Record what this import resolves to for later uses in documentation,
1028         // this may resolve to either a value or a type, but for documentation
1029         // purposes it's good enough to just favor one over the other.
1030         self.r.per_ns(|this, ns| {
1031             if let Ok(binding) = source_bindings[ns].get() {
1032                 this.import_res_map.entry(import.id).or_default()[ns] = Some(binding.res());
1033             }
1034         });
1035
1036         self.check_for_redundant_imports(ident, import, source_bindings, target_bindings, target);
1037
1038         debug!("(resolving single import) successfully resolved import");
1039         None
1040     }
1041
1042     fn check_for_redundant_imports(
1043         &mut self,
1044         ident: Ident,
1045         import: &'b Import<'b>,
1046         source_bindings: &PerNS<Cell<Result<&'b NameBinding<'b>, Determinacy>>>,
1047         target_bindings: &PerNS<Cell<Option<&'b NameBinding<'b>>>>,
1048         target: Ident,
1049     ) {
1050         // Skip if the import was produced by a macro.
1051         if import.parent_scope.expansion != LocalExpnId::ROOT {
1052             return;
1053         }
1054
1055         // Skip if we are inside a named module (in contrast to an anonymous
1056         // module defined by a block).
1057         if let ModuleKind::Def(..) = import.parent_scope.module.kind {
1058             return;
1059         }
1060
1061         let mut is_redundant = PerNS { value_ns: None, type_ns: None, macro_ns: None };
1062
1063         let mut redundant_span = PerNS { value_ns: None, type_ns: None, macro_ns: None };
1064
1065         self.r.per_ns(|this, ns| {
1066             if let Ok(binding) = source_bindings[ns].get() {
1067                 if binding.res() == Res::Err {
1068                     return;
1069                 }
1070
1071                 match this.early_resolve_ident_in_lexical_scope(
1072                     target,
1073                     ScopeSet::All(ns, false),
1074                     &import.parent_scope,
1075                     None,
1076                     false,
1077                     target_bindings[ns].get(),
1078                 ) {
1079                     Ok(other_binding) => {
1080                         is_redundant[ns] = Some(
1081                             binding.res() == other_binding.res() && !other_binding.is_ambiguity(),
1082                         );
1083                         redundant_span[ns] = Some((other_binding.span, other_binding.is_import()));
1084                     }
1085                     Err(_) => is_redundant[ns] = Some(false),
1086                 }
1087             }
1088         });
1089
1090         if !is_redundant.is_empty() && is_redundant.present_items().all(|is_redundant| is_redundant)
1091         {
1092             let mut redundant_spans: Vec<_> = redundant_span.present_items().collect();
1093             redundant_spans.sort();
1094             redundant_spans.dedup();
1095             self.r.lint_buffer.buffer_lint_with_diagnostic(
1096                 UNUSED_IMPORTS,
1097                 import.id,
1098                 import.span,
1099                 &format!("the item `{}` is imported redundantly", ident),
1100                 BuiltinLintDiagnostics::RedundantImport(redundant_spans, ident),
1101             );
1102         }
1103     }
1104
1105     fn resolve_glob_import(&mut self, import: &'b Import<'b>) {
1106         let ModuleOrUniformRoot::Module(module) = import.imported_module.get().unwrap() else {
1107             self.r.session.span_err(import.span, "cannot glob-import all possible crates");
1108             return;
1109         };
1110
1111         if module.is_trait() {
1112             self.r.session.span_err(import.span, "items in traits are not importable");
1113             return;
1114         } else if ptr::eq(module, import.parent_scope.module) {
1115             return;
1116         } else if let ImportKind::Glob { is_prelude: true, .. } = import.kind {
1117             self.r.prelude = Some(module);
1118             return;
1119         }
1120
1121         // Add to module's glob_importers
1122         module.glob_importers.borrow_mut().push(import);
1123
1124         // Ensure that `resolutions` isn't borrowed during `try_define`,
1125         // since it might get updated via a glob cycle.
1126         let bindings = self
1127             .r
1128             .resolutions(module)
1129             .borrow()
1130             .iter()
1131             .filter_map(|(key, resolution)| {
1132                 resolution.borrow().binding().map(|binding| (*key, binding))
1133             })
1134             .collect::<Vec<_>>();
1135         for (mut key, binding) in bindings {
1136             let scope = match key.ident.span.reverse_glob_adjust(module.expansion, import.span) {
1137                 Some(Some(def)) => self.r.expn_def_scope(def),
1138                 Some(None) => import.parent_scope.module,
1139                 None => continue,
1140             };
1141             if self.r.is_accessible_from(binding.vis, scope) {
1142                 let imported_binding = self.r.import(binding, import);
1143                 let _ = self.r.try_define(import.parent_scope.module, key, imported_binding);
1144             }
1145         }
1146
1147         // Record the destination of this import
1148         self.r.record_partial_res(import.id, PartialRes::new(module.res().unwrap()));
1149     }
1150
1151     // Miscellaneous post-processing, including recording re-exports,
1152     // reporting conflicts, and reporting unresolved imports.
1153     fn finalize_resolutions_in(&mut self, module: Module<'b>) {
1154         // Since import resolution is finished, globs will not define any more names.
1155         *module.globs.borrow_mut() = Vec::new();
1156
1157         if let Some(def_id) = module.opt_def_id() {
1158             let mut reexports = Vec::new();
1159
1160             module.for_each_child(self.r, |this, ident, _, binding| {
1161                 if let Some(res) = this.is_reexport(binding) {
1162                     reexports.push(ModChild {
1163                         ident,
1164                         res,
1165                         vis: binding.vis,
1166                         span: binding.span,
1167                         macro_rules: false,
1168                     });
1169                 }
1170             });
1171
1172             if !reexports.is_empty() {
1173                 // Call to `expect_local` should be fine because current
1174                 // code is only called for local modules.
1175                 self.r.reexport_map.insert(def_id.expect_local(), reexports);
1176             }
1177         }
1178     }
1179 }
1180
1181 fn import_path_to_string(names: &[Ident], import_kind: &ImportKind<'_>, span: Span) -> String {
1182     let pos = names.iter().position(|p| span == p.span && p.name != kw::PathRoot);
1183     let global = !names.is_empty() && names[0].name == kw::PathRoot;
1184     if let Some(pos) = pos {
1185         let names = if global { &names[1..pos + 1] } else { &names[..pos + 1] };
1186         names_to_string(&names.iter().map(|ident| ident.name).collect::<Vec<_>>())
1187     } else {
1188         let names = if global { &names[1..] } else { names };
1189         if names.is_empty() {
1190             import_kind_to_string(import_kind)
1191         } else {
1192             format!(
1193                 "{}::{}",
1194                 names_to_string(&names.iter().map(|ident| ident.name).collect::<Vec<_>>()),
1195                 import_kind_to_string(import_kind),
1196             )
1197         }
1198     }
1199 }
1200
1201 fn import_kind_to_string(import_kind: &ImportKind<'_>) -> String {
1202     match import_kind {
1203         ImportKind::Single { source, .. } => source.to_string(),
1204         ImportKind::Glob { .. } => "*".to_string(),
1205         ImportKind::ExternCrate { .. } => "<extern crate>".to_string(),
1206         ImportKind::MacroUse => "#[macro_use]".to_string(),
1207     }
1208 }