Rollup merge of #135826 - yotamofek:resolve-cleanups4, r=petrochenkov
Misc. `rustc_resolve` cleanups
Hopefully this PR should make `rustc_resolve` a bit cleaner.
Each commit here stands on its own. I tried to only include changes that are easy to review, and are a clear improvement. (but I'll be happy to revert any changes that turn out to be more controversial than I'd thought)
Best viewed with whitespace ignored 😁 (especially [these two commits](a93616acf3..ae87d005bc?diff=unified&w=1))
This commit is contained in:
Matthias Krüger
GitHub
commit
41885a4858
6 changed files with 564 additions and 608 deletions
|
|
@ -645,11 +645,11 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
|
|||
let self_spans = items
|
||||
.iter()
|
||||
.filter_map(|(use_tree, _)| {
|
||||
if let ast::UseTreeKind::Simple(..) = use_tree.kind {
|
||||
if use_tree.ident().name == kw::SelfLower {
|
||||
if let ast::UseTreeKind::Simple(..) = use_tree.kind
|
||||
&& use_tree.ident().name == kw::SelfLower
|
||||
{
|
||||
return Some(use_tree.span);
|
||||
}
|
||||
}
|
||||
|
||||
None
|
||||
})
|
||||
|
|
@ -947,12 +947,13 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
|
|||
let imported_binding = self.r.import(binding, import);
|
||||
if parent == self.r.graph_root {
|
||||
let ident = ident.normalize_to_macros_2_0();
|
||||
if let Some(entry) = self.r.extern_prelude.get(&ident) {
|
||||
if expansion != LocalExpnId::ROOT && orig_name.is_some() && !entry.is_import() {
|
||||
if let Some(entry) = self.r.extern_prelude.get(&ident)
|
||||
&& expansion != LocalExpnId::ROOT
|
||||
&& orig_name.is_some()
|
||||
&& !entry.is_import()
|
||||
{
|
||||
self.r.dcx().emit_err(
|
||||
errors::MacroExpandedExternCrateCannotShadowExternArguments {
|
||||
span: item.span,
|
||||
},
|
||||
errors::MacroExpandedExternCrateCannotShadowExternArguments { span: item.span },
|
||||
);
|
||||
// `return` is intended to discard this binding because it's an
|
||||
// unregistered ambiguity error which would result in a panic
|
||||
|
|
@ -960,7 +961,6 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
|
|||
// more details: https://github.com/rust-lang/rust/pull/111761
|
||||
return;
|
||||
}
|
||||
}
|
||||
let entry = self
|
||||
.r
|
||||
.extern_prelude
|
||||
|
|
@ -1040,11 +1040,11 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
|
|||
span: item.span,
|
||||
});
|
||||
}
|
||||
if let ItemKind::ExternCrate(Some(orig_name)) = item.kind {
|
||||
if orig_name == kw::SelfLower {
|
||||
if let ItemKind::ExternCrate(Some(orig_name)) = item.kind
|
||||
&& orig_name == kw::SelfLower
|
||||
{
|
||||
self.r.dcx().emit_err(errors::MacroUseExternCrateSelf { span: attr.span });
|
||||
}
|
||||
}
|
||||
let ill_formed = |span| {
|
||||
self.r.dcx().emit_err(errors::BadMacroImport { span });
|
||||
};
|
||||
|
|
@ -1179,15 +1179,13 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
|
|||
return Some((MacroKind::Bang, item.ident, item.span));
|
||||
} else if ast::attr::contains_name(&item.attrs, sym::proc_macro_attribute) {
|
||||
return Some((MacroKind::Attr, item.ident, item.span));
|
||||
} else if let Some(attr) = ast::attr::find_by_name(&item.attrs, sym::proc_macro_derive) {
|
||||
if let Some(meta_item_inner) =
|
||||
} else if let Some(attr) = ast::attr::find_by_name(&item.attrs, sym::proc_macro_derive)
|
||||
&& let Some(meta_item_inner) =
|
||||
attr.meta_item_list().and_then(|list| list.get(0).cloned())
|
||||
&& let Some(ident) = meta_item_inner.ident()
|
||||
{
|
||||
if let Some(ident) = meta_item_inner.ident() {
|
||||
return Some((MacroKind::Derive, ident, ident.span));
|
||||
}
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -225,11 +225,9 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
|
|||
let (name, span) =
|
||||
(ident.name, self.tcx.sess.source_map().guess_head_span(new_binding.span));
|
||||
|
||||
if let Some(s) = self.name_already_seen.get(&name) {
|
||||
if s == &span {
|
||||
if self.name_already_seen.get(&name) == Some(&span) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
let old_kind = match (ns, old_binding.module()) {
|
||||
(ValueNS, _) => "value",
|
||||
|
|
@ -380,22 +378,16 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
|
|||
suggestion = Some(format!("self as {suggested_name}"))
|
||||
}
|
||||
ImportKind::Single { source, .. } => {
|
||||
if let Some(pos) =
|
||||
source.span.hi().0.checked_sub(binding_span.lo().0).map(|pos| pos as usize)
|
||||
if let Some(pos) = source.span.hi().0.checked_sub(binding_span.lo().0)
|
||||
&& let Ok(snippet) = self.tcx.sess.source_map().span_to_snippet(binding_span)
|
||||
&& pos as usize <= snippet.len()
|
||||
{
|
||||
if let Ok(snippet) = self.tcx.sess.source_map().span_to_snippet(binding_span) {
|
||||
if pos <= snippet.len() {
|
||||
span = binding_span
|
||||
.with_lo(binding_span.lo() + BytePos(pos as u32))
|
||||
.with_hi(
|
||||
binding_span.hi()
|
||||
- BytePos(if snippet.ends_with(';') { 1 } else { 0 }),
|
||||
span = binding_span.with_lo(binding_span.lo() + BytePos(pos)).with_hi(
|
||||
binding_span.hi() - BytePos(if snippet.ends_with(';') { 1 } else { 0 }),
|
||||
);
|
||||
suggestion = Some(format!(" as {suggested_name}"));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
ImportKind::ExternCrate { source, target, .. } => {
|
||||
suggestion = Some(format!(
|
||||
"extern crate {} as {};",
|
||||
|
|
@ -510,14 +502,13 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
|
|||
// If the first element of our path was actually resolved to an
|
||||
// `ExternCrate` (also used for `crate::...`) then no need to issue a
|
||||
// warning, this looks all good!
|
||||
if let Some(binding) = second_binding {
|
||||
if let NameBindingKind::Import { import, .. } = binding.kind {
|
||||
if let Some(binding) = second_binding
|
||||
&& let NameBindingKind::Import { import, .. } = binding.kind
|
||||
// Careful: we still want to rewrite paths from renamed extern crates.
|
||||
if let ImportKind::ExternCrate { source: None, .. } = import.kind {
|
||||
&& let ImportKind::ExternCrate { source: None, .. } = import.kind
|
||||
{
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let diag = BuiltinLintDiag::AbsPathWithModule(root_span);
|
||||
self.lint_buffer.buffer_lint(
|
||||
|
|
@ -1047,14 +1038,16 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
|
|||
if filter_fn(res) {
|
||||
for derive in parent_scope.derives {
|
||||
let parent_scope = &ParentScope { derives: &[], ..*parent_scope };
|
||||
if let Ok((Some(ext), _)) = this.resolve_macro_path(
|
||||
let Ok((Some(ext), _)) = this.resolve_macro_path(
|
||||
derive,
|
||||
Some(MacroKind::Derive),
|
||||
parent_scope,
|
||||
false,
|
||||
false,
|
||||
None,
|
||||
) {
|
||||
) else {
|
||||
continue;
|
||||
};
|
||||
suggestions.extend(
|
||||
ext.helper_attrs
|
||||
.iter()
|
||||
|
|
@ -1063,7 +1056,6 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
|
|||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Scope::MacroRules(macro_rules_scope) => {
|
||||
if let MacroRulesScope::Binding(macro_rules_binding) = macro_rules_scope.get() {
|
||||
let res = macro_rules_binding.binding.res();
|
||||
|
|
@ -1215,13 +1207,12 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
|
|||
}
|
||||
|
||||
// #90113: Do not count an inaccessible reexported item as a candidate.
|
||||
if let NameBindingKind::Import { binding, .. } = name_binding.kind {
|
||||
if this.is_accessible_from(binding.vis, parent_scope.module)
|
||||
if let NameBindingKind::Import { binding, .. } = name_binding.kind
|
||||
&& this.is_accessible_from(binding.vis, parent_scope.module)
|
||||
&& !this.is_accessible_from(name_binding.vis, parent_scope.module)
|
||||
{
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
let res = name_binding.res();
|
||||
let did = match res {
|
||||
|
|
@ -1253,15 +1244,14 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
|
|||
segms.push(ast::PathSegment::from_ident(ident));
|
||||
let path = Path { span: name_binding.span, segments: segms, tokens: None };
|
||||
|
||||
if child_accessible {
|
||||
if child_accessible
|
||||
// Remove invisible match if exists
|
||||
if let Some(idx) = candidates
|
||||
&& let Some(idx) = candidates
|
||||
.iter()
|
||||
.position(|v: &ImportSuggestion| v.did == did && !v.accessible)
|
||||
{
|
||||
candidates.remove(idx);
|
||||
}
|
||||
}
|
||||
|
||||
if candidates.iter().all(|v: &ImportSuggestion| v.did != did) {
|
||||
// See if we're recommending TryFrom, TryInto, or FromIterator and add
|
||||
|
|
@ -1373,8 +1363,11 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
|
|||
// otherwise cause duplicate suggestions.
|
||||
continue;
|
||||
}
|
||||
let crate_id = self.crate_loader(|c| c.maybe_process_path_extern(ident.name));
|
||||
if let Some(crate_id) = crate_id {
|
||||
let Some(crate_id) = self.crate_loader(|c| c.maybe_process_path_extern(ident.name))
|
||||
else {
|
||||
continue;
|
||||
};
|
||||
|
||||
let crate_def_id = crate_id.as_def_id();
|
||||
let crate_root = self.expect_module(crate_def_id);
|
||||
|
||||
|
|
@ -1416,7 +1409,6 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
|
|||
));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
suggestions
|
||||
}
|
||||
|
|
@ -1511,7 +1503,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
|
|||
});
|
||||
}
|
||||
for ns in [Namespace::MacroNS, Namespace::TypeNS, Namespace::ValueNS] {
|
||||
if let Ok(binding) = self.early_resolve_ident_in_lexical_scope(
|
||||
let Ok(binding) = self.early_resolve_ident_in_lexical_scope(
|
||||
ident,
|
||||
ScopeSet::All(ns),
|
||||
parent_scope,
|
||||
|
|
@ -1519,11 +1511,12 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
|
|||
false,
|
||||
None,
|
||||
None,
|
||||
) {
|
||||
) else {
|
||||
continue;
|
||||
};
|
||||
|
||||
let desc = match binding.res() {
|
||||
Res::Def(DefKind::Macro(MacroKind::Bang), _) => {
|
||||
"a function-like macro".to_string()
|
||||
}
|
||||
Res::Def(DefKind::Macro(MacroKind::Bang), _) => "a function-like macro".to_string(),
|
||||
Res::Def(DefKind::Macro(MacroKind::Attr), _) | Res::NonMacroAttr(..) => {
|
||||
format!("an attribute: `#[{ident}]`")
|
||||
}
|
||||
|
|
@ -1545,8 +1538,9 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
|
|||
macro_kind.descr_expected(),
|
||||
),
|
||||
};
|
||||
if let crate::NameBindingKind::Import { import, .. } = binding.kind {
|
||||
if !import.span.is_dummy() {
|
||||
if let crate::NameBindingKind::Import { import, .. } = binding.kind
|
||||
&& !import.span.is_dummy()
|
||||
{
|
||||
let note = errors::IdentImporterHereButItIsDesc {
|
||||
span: import.span,
|
||||
imported_ident: ident,
|
||||
|
|
@ -1558,7 +1552,6 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
|
|||
self.record_use(ident, binding, Used::Other);
|
||||
return;
|
||||
}
|
||||
}
|
||||
let note = errors::IdentInScopeButItIsDesc {
|
||||
imported_ident: ident,
|
||||
imported_ident_desc: &desc,
|
||||
|
|
@ -1567,7 +1560,6 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
|
|||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn add_typo_suggestion(
|
||||
&self,
|
||||
|
|
@ -1749,15 +1741,16 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
|
|||
/// If the binding refers to a tuple struct constructor with fields,
|
||||
/// returns the span of its fields.
|
||||
fn ctor_fields_span(&self, binding: NameBinding<'_>) -> Option<Span> {
|
||||
if let NameBindingKind::Res(Res::Def(
|
||||
let NameBindingKind::Res(Res::Def(
|
||||
DefKind::Ctor(CtorOf::Struct, CtorKind::Fn),
|
||||
ctor_def_id,
|
||||
)) = binding.kind
|
||||
{
|
||||
else {
|
||||
return None;
|
||||
};
|
||||
|
||||
let def_id = self.tcx.parent(ctor_def_id);
|
||||
return self.field_idents(def_id)?.iter().map(|&f| f.span).reduce(Span::to); // None for `struct Foo()`
|
||||
}
|
||||
None
|
||||
self.field_idents(def_id)?.iter().map(|&f| f.span).reduce(Span::to) // None for `struct Foo()`
|
||||
}
|
||||
|
||||
fn report_privacy_error(&mut self, privacy_error: &PrivacyError<'ra>) {
|
||||
|
|
@ -1983,10 +1976,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
|
|||
.collect::<Vec<_>>();
|
||||
candidates.sort();
|
||||
candidates.dedup();
|
||||
match find_best_match_for_name(&candidates, ident, None) {
|
||||
Some(sugg) if sugg == ident => None,
|
||||
sugg => sugg,
|
||||
}
|
||||
find_best_match_for_name(&candidates, ident, None).filter(|sugg| *sugg != ident)
|
||||
}
|
||||
|
||||
pub(crate) fn report_path_resolution_error(
|
||||
|
|
@ -2410,7 +2400,9 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
|
|||
let binding_key = BindingKey::new(ident, MacroNS);
|
||||
let resolution = resolutions.get(&binding_key)?;
|
||||
let binding = resolution.borrow().binding()?;
|
||||
if let Res::Def(DefKind::Macro(MacroKind::Bang), _) = binding.res() {
|
||||
let Res::Def(DefKind::Macro(MacroKind::Bang), _) = binding.res() else {
|
||||
return None;
|
||||
};
|
||||
let module_name = crate_module.kind.name().unwrap();
|
||||
let import_snippet = match import.kind {
|
||||
ImportKind::Single { source, target, .. } if source != target => {
|
||||
|
|
@ -2436,7 +2428,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
|
|||
debug!(found_closing_brace, ?binding_span);
|
||||
|
||||
let mut removal_span = binding_span;
|
||||
if found_closing_brace {
|
||||
|
||||
// If the binding span ended with a closing brace, as in the below example:
|
||||
// ie. `use a::b::{c, d};`
|
||||
// ^
|
||||
|
|
@ -2444,13 +2436,13 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
|
|||
// binding's trailing comma.
|
||||
// ie. `use a::b::{c, d};`
|
||||
// ^^^
|
||||
if let Some(previous_span) =
|
||||
if found_closing_brace
|
||||
&& let Some(previous_span) =
|
||||
extend_span_to_previous_binding(self.tcx.sess, binding_span)
|
||||
{
|
||||
debug!(?previous_span);
|
||||
removal_span = removal_span.with_lo(previous_span.lo());
|
||||
}
|
||||
}
|
||||
debug!(?removal_span);
|
||||
|
||||
// Remove the `removal_span`.
|
||||
|
|
@ -2462,11 +2454,8 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
|
|||
// ^^^^^^^^^
|
||||
// or `use a::{b, c, d}};`
|
||||
// ^^^^^^^^^^^
|
||||
let (has_nested, after_crate_name) = find_span_immediately_after_crate_name(
|
||||
self.tcx.sess,
|
||||
module_name,
|
||||
import.use_span,
|
||||
);
|
||||
let (has_nested, after_crate_name) =
|
||||
find_span_immediately_after_crate_name(self.tcx.sess, module_name, import.use_span);
|
||||
debug!(has_nested, ?after_crate_name);
|
||||
|
||||
let source_map = self.tcx.sess.source_map();
|
||||
|
|
@ -2496,8 +2485,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
|
|||
|
||||
// Add a `};` to the end if nested, matching the `{` added at the start.
|
||||
if !has_nested {
|
||||
corrections
|
||||
.push((source_map.end_point(after_crate_name), "};".to_string()));
|
||||
corrections.push((source_map.end_point(after_crate_name), "};".to_string()));
|
||||
}
|
||||
} else {
|
||||
// If the root import is module-relative, add the import separately
|
||||
|
|
@ -2513,12 +2501,14 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
|
|||
String::from("a macro with this name exists at the root of the crate"),
|
||||
Applicability::MaybeIncorrect,
|
||||
));
|
||||
Some((suggestion, Some("this could be because a macro annotated with `#[macro_export]` will be exported \
|
||||
Some((
|
||||
suggestion,
|
||||
Some(
|
||||
"this could be because a macro annotated with `#[macro_export]` will be exported \
|
||||
at the root of the crate instead of the module where it is defined"
|
||||
.to_string())))
|
||||
} else {
|
||||
None
|
||||
}
|
||||
.to_string(),
|
||||
),
|
||||
))
|
||||
}
|
||||
|
||||
/// Finds a cfg-ed out item inside `module` with the matching name.
|
||||
|
|
@ -3042,7 +3032,6 @@ impl<'tcx> visit::Visitor<'tcx> for UsePlacementFinder {
|
|||
self.first_legal_span = Some(inject);
|
||||
}
|
||||
self.first_use_span = search_for_any_use_in_items(&c.items);
|
||||
return;
|
||||
} else {
|
||||
visit::walk_crate(self, c);
|
||||
}
|
||||
|
|
@ -3056,7 +3045,6 @@ impl<'tcx> visit::Visitor<'tcx> for UsePlacementFinder {
|
|||
self.first_legal_span = Some(inject);
|
||||
}
|
||||
self.first_use_span = search_for_any_use_in_items(items);
|
||||
return;
|
||||
}
|
||||
} else {
|
||||
visit::walk_item(self, item);
|
||||
|
|
@ -3066,8 +3054,9 @@ impl<'tcx> visit::Visitor<'tcx> for UsePlacementFinder {
|
|||
|
||||
fn search_for_any_use_in_items(items: &[P<ast::Item>]) -> Option<Span> {
|
||||
for item in items {
|
||||
if let ItemKind::Use(..) = item.kind {
|
||||
if is_span_suitable_for_use_injection(item.span) {
|
||||
if let ItemKind::Use(..) = item.kind
|
||||
&& is_span_suitable_for_use_injection(item.span)
|
||||
{
|
||||
let mut lo = item.span.lo();
|
||||
for attr in &item.attrs {
|
||||
if attr.span.eq_ctxt(item.span) {
|
||||
|
|
@ -3077,7 +3066,6 @@ fn search_for_any_use_in_items(items: &[P<ast::Item>]) -> Option<Span> {
|
|||
return Some(Span::new(lo, lo, item.span.ctxt(), item.span.parent()));
|
||||
}
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -118,7 +118,9 @@ impl<'a, 'ra, 'tcx> EffectiveVisibilitiesVisitor<'a, 'ra, 'tcx> {
|
|||
let resolutions = self.r.resolutions(module);
|
||||
|
||||
for (_, name_resolution) in resolutions.borrow().iter() {
|
||||
if let Some(mut binding) = name_resolution.borrow().binding() {
|
||||
let Some(mut binding) = name_resolution.borrow().binding() else {
|
||||
continue;
|
||||
};
|
||||
// Set the given effective visibility level to `Level::Direct` and
|
||||
// sets the rest of the `use` chain to `Level::Reexported` until
|
||||
// we hit the actual exported item.
|
||||
|
|
@ -151,7 +153,6 @@ impl<'a, 'ra, 'tcx> EffectiveVisibilitiesVisitor<'a, 'ra, 'tcx> {
|
|||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn effective_vis_or_private(&mut self, parent_id: ParentId<'ra>) -> EffectiveVisibility {
|
||||
// Private nodes are only added to the table for caching, they could be added or removed at
|
||||
|
|
|
|||
|
|
@ -246,14 +246,15 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
|
|||
// ---- end
|
||||
// ```
|
||||
// So we have to fall back to the module's parent during lexical resolution in this case.
|
||||
if derive_fallback_lint_id.is_some() {
|
||||
if let Some(parent) = module.parent {
|
||||
// Inner module is inside the macro, parent module is outside of the macro.
|
||||
if module.expansion != parent.expansion
|
||||
if derive_fallback_lint_id.is_some()
|
||||
&& let Some(parent) = module.parent
|
||||
// Inner module is inside the macro
|
||||
&& module.expansion != parent.expansion
|
||||
// Parent module is outside of the macro
|
||||
&& module.expansion.is_descendant_of(parent.expansion)
|
||||
{
|
||||
// The macro is a proc macro derive
|
||||
if let Some(def_id) = module.expansion.expn_data().macro_def_id {
|
||||
&& let Some(def_id) = module.expansion.expn_data().macro_def_id
|
||||
{
|
||||
let ext = &self.get_macro_by_def_id(def_id).ext;
|
||||
if ext.builtin_name.is_none()
|
||||
&& ext.macro_kind() == MacroKind::Derive
|
||||
|
|
@ -262,9 +263,6 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
|
|||
return Some((parent, derive_fallback_lint_id));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
None
|
||||
}
|
||||
|
|
@ -593,8 +591,8 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
|
|||
},
|
||||
Scope::StdLibPrelude => {
|
||||
let mut result = Err(Determinacy::Determined);
|
||||
if let Some(prelude) = this.prelude {
|
||||
if let Ok(binding) = this.resolve_ident_in_module_unadjusted(
|
||||
if let Some(prelude) = this.prelude
|
||||
&& let Ok(binding) = this.resolve_ident_in_module_unadjusted(
|
||||
ModuleOrUniformRoot::Module(prelude),
|
||||
ident,
|
||||
ns,
|
||||
|
|
@ -603,14 +601,13 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
|
|||
None,
|
||||
ignore_binding,
|
||||
ignore_import,
|
||||
) {
|
||||
if matches!(use_prelude, UsePrelude::Yes)
|
||||
|| this.is_builtin_macro(binding.res())
|
||||
)
|
||||
&& (matches!(use_prelude, UsePrelude::Yes)
|
||||
|| this.is_builtin_macro(binding.res()))
|
||||
{
|
||||
result = Ok((binding, Flags::MISC_FROM_PRELUDE));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
result
|
||||
}
|
||||
Scope::BuiltinTypes => match this.builtin_types_bindings.get(&ident.name) {
|
||||
|
|
@ -939,11 +936,11 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
|
|||
};
|
||||
|
||||
// Items and single imports are not shadowable, if we have one, then it's determined.
|
||||
if let Some(binding) = binding {
|
||||
if !binding.is_glob_import() {
|
||||
if let Some(binding) = binding
|
||||
&& !binding.is_glob_import()
|
||||
{
|
||||
return check_usable(self, binding);
|
||||
}
|
||||
}
|
||||
|
||||
// --- From now on we either have a glob resolution or no resolution. ---
|
||||
|
||||
|
|
@ -1437,14 +1434,13 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
|
|||
for (segment_idx, &Segment { ident, id, .. }) in path.iter().enumerate() {
|
||||
debug!("resolve_path ident {} {:?} {:?}", segment_idx, ident, id);
|
||||
let record_segment_res = |this: &mut Self, res| {
|
||||
if finalize.is_some() {
|
||||
if let Some(id) = id {
|
||||
if !this.partial_res_map.contains_key(&id) {
|
||||
if finalize.is_some()
|
||||
&& let Some(id) = id
|
||||
&& !this.partial_res_map.contains_key(&id)
|
||||
{
|
||||
assert!(id != ast::DUMMY_NODE_ID, "Trying to resolve dummy id");
|
||||
this.record_partial_res(id, PartialRes::new(res));
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
let is_last = segment_idx + 1 == path.len();
|
||||
|
|
@ -1463,14 +1459,13 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
|
|||
_ => None,
|
||||
},
|
||||
};
|
||||
if let Some(self_module) = self_module {
|
||||
if let Some(parent) = self_module.parent {
|
||||
module = Some(ModuleOrUniformRoot::Module(
|
||||
self.resolve_self(&mut ctxt, parent),
|
||||
));
|
||||
if let Some(self_module) = self_module
|
||||
&& let Some(parent) = self_module.parent
|
||||
{
|
||||
module =
|
||||
Some(ModuleOrUniformRoot::Module(self.resolve_self(&mut ctxt, parent)));
|
||||
continue;
|
||||
}
|
||||
}
|
||||
return PathResult::failed(
|
||||
ident,
|
||||
false,
|
||||
|
|
@ -1644,14 +1639,15 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
|
|||
}
|
||||
Err(Undetermined) => return PathResult::Indeterminate,
|
||||
Err(Determined) => {
|
||||
if let Some(ModuleOrUniformRoot::Module(module)) = module {
|
||||
if opt_ns.is_some() && !module.is_normal() {
|
||||
if let Some(ModuleOrUniformRoot::Module(module)) = module
|
||||
&& opt_ns.is_some()
|
||||
&& !module.is_normal()
|
||||
{
|
||||
return PathResult::NonModule(PartialRes::with_unresolved_segments(
|
||||
module.res().unwrap(),
|
||||
path.len() - segment_idx,
|
||||
));
|
||||
}
|
||||
}
|
||||
|
||||
return PathResult::failed(
|
||||
ident,
|
||||
|
|
|
|||
|
|
@ -287,13 +287,12 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
|
|||
binding.vis
|
||||
};
|
||||
|
||||
if let ImportKind::Glob { ref max_vis, .. } = import.kind {
|
||||
if vis == import_vis
|
||||
|| max_vis.get().is_none_or(|max_vis| vis.is_at_least(max_vis, self.tcx))
|
||||
if let ImportKind::Glob { ref max_vis, .. } = import.kind
|
||||
&& (vis == import_vis
|
||||
|| max_vis.get().is_none_or(|max_vis| vis.is_at_least(max_vis, self.tcx)))
|
||||
{
|
||||
max_vis.set(Some(vis.expect_local()))
|
||||
}
|
||||
}
|
||||
|
||||
self.arenas.alloc_name_binding(NameBindingData {
|
||||
kind: NameBindingKind::Import { binding, import },
|
||||
|
|
@ -543,21 +542,19 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
|
|||
// resolution for it so that later resolve stages won't complain.
|
||||
self.import_dummy_binding(*import, is_indeterminate);
|
||||
|
||||
if let Some(err) = unresolved_import_error {
|
||||
let Some(err) = unresolved_import_error else { continue };
|
||||
|
||||
glob_error |= import.is_glob();
|
||||
|
||||
if let ImportKind::Single { source, ref source_bindings, .. } = import.kind {
|
||||
if source.name == kw::SelfLower {
|
||||
if let ImportKind::Single { source, ref source_bindings, .. } = import.kind
|
||||
&& source.name == kw::SelfLower
|
||||
// Silence `unresolved import` error if E0429 is already emitted
|
||||
if let Err(Determined) = source_bindings.value_ns.get() {
|
||||
&& let Err(Determined) = source_bindings.value_ns.get()
|
||||
{
|
||||
continue;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if prev_root_id != NodeId::ZERO
|
||||
&& prev_root_id != import.root_id
|
||||
&& !errors.is_empty()
|
||||
if prev_root_id != NodeId::ZERO && prev_root_id != import.root_id && !errors.is_empty()
|
||||
{
|
||||
// In the case of a new import line, throw a diagnostic message
|
||||
// for the previous line.
|
||||
|
|
@ -569,7 +566,6 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
|
|||
prev_root_id = import.root_id;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if !errors.is_empty() {
|
||||
self.throw_unresolved_import_error(errors, glob_error);
|
||||
|
|
@ -609,7 +605,8 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
|
|||
for (key, resolution) in self.resolutions(*module).borrow().iter() {
|
||||
let resolution = resolution.borrow();
|
||||
|
||||
if let Some(binding) = resolution.binding {
|
||||
let Some(binding) = resolution.binding else { continue };
|
||||
|
||||
if let NameBindingKind::Import { import, .. } = binding.kind
|
||||
&& let Some((amb_binding, _)) = binding.ambiguity
|
||||
&& binding.res() != Res::Err
|
||||
|
|
@ -666,7 +663,6 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
|
|||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn throw_unresolved_import_error(
|
||||
&mut self,
|
||||
|
|
@ -1006,14 +1002,13 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
|
|||
self.lint_if_path_starts_with_module(Some(finalize), &full_path, None);
|
||||
}
|
||||
|
||||
if let ModuleOrUniformRoot::Module(module) = module {
|
||||
if module == import.parent_scope.module {
|
||||
if let ModuleOrUniformRoot::Module(module) = module
|
||||
&& module == import.parent_scope.module
|
||||
{
|
||||
// Importing a module into itself is not allowed.
|
||||
return Some(UnresolvedImportError {
|
||||
span: import.span,
|
||||
label: Some(String::from(
|
||||
"cannot glob-import a module into itself",
|
||||
)),
|
||||
label: Some(String::from("cannot glob-import a module into itself")),
|
||||
note: None,
|
||||
suggestion: None,
|
||||
candidates: None,
|
||||
|
|
@ -1021,7 +1016,6 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
|
|||
module: None,
|
||||
});
|
||||
}
|
||||
}
|
||||
if !is_prelude
|
||||
&& let Some(max_vis) = max_vis.get()
|
||||
&& !max_vis.is_at_least(import.vis, self.tcx)
|
||||
|
|
@ -1081,8 +1075,8 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
|
|||
// Consistency checks, analogous to `finalize_macro_resolutions`.
|
||||
let initial_res = source_bindings[ns].get().map(|initial_binding| {
|
||||
all_ns_err = false;
|
||||
if let Some(target_binding) = target_bindings[ns].get() {
|
||||
if target.name == kw::Underscore
|
||||
if let Some(target_binding) = target_bindings[ns].get()
|
||||
&& target.name == kw::Underscore
|
||||
&& initial_binding.is_extern_crate()
|
||||
&& !initial_binding.is_import()
|
||||
{
|
||||
|
|
@ -1093,7 +1087,6 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
|
|||
};
|
||||
this.record_use(ident, target_binding, used);
|
||||
}
|
||||
}
|
||||
initial_binding.res()
|
||||
});
|
||||
let res = binding.res();
|
||||
|
|
@ -1247,18 +1240,20 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
|
|||
let mut any_successful_reexport = false;
|
||||
let mut crate_private_reexport = false;
|
||||
self.per_ns(|this, ns| {
|
||||
if let Ok(binding) = source_bindings[ns].get() {
|
||||
let Ok(binding) = source_bindings[ns].get() else {
|
||||
return;
|
||||
};
|
||||
|
||||
if !binding.vis.is_at_least(import.vis, this.tcx) {
|
||||
reexport_error = Some((ns, binding));
|
||||
if let ty::Visibility::Restricted(binding_def_id) = binding.vis {
|
||||
if binding_def_id.is_top_level_module() {
|
||||
if let ty::Visibility::Restricted(binding_def_id) = binding.vis
|
||||
&& binding_def_id.is_top_level_module()
|
||||
{
|
||||
crate_private_reexport = true;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
any_successful_reexport = true;
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
// All namespaces must be re-exported with extra visibility for an error to occur.
|
||||
|
|
@ -1474,7 +1469,8 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
|
|||
// Since import resolution is finished, globs will not define any more names.
|
||||
*module.globs.borrow_mut() = Vec::new();
|
||||
|
||||
if let Some(def_id) = module.opt_def_id() {
|
||||
let Some(def_id) = module.opt_def_id() else { return };
|
||||
|
||||
let mut children = Vec::new();
|
||||
|
||||
module.for_each_child(self, |this, ident, _, binding| {
|
||||
|
|
@ -1497,7 +1493,6 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
|
|||
self.module_children.insert(def_id.expect_local(), children);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn import_path_to_string(names: &[Ident], import_kind: &ImportKind<'_>, span: Span) -> String {
|
||||
|
|
|
|||
|
|
@ -468,16 +468,12 @@ impl<'a> PathSource<'a> {
|
|||
{
|
||||
"external crate"
|
||||
}
|
||||
ExprKind::Path(_, path) => {
|
||||
let mut msg = "function";
|
||||
if let Some(segment) = path.segments.iter().last() {
|
||||
if let Some(c) = segment.ident.to_string().chars().next() {
|
||||
if c.is_uppercase() {
|
||||
msg = "function, tuple struct or tuple variant";
|
||||
}
|
||||
}
|
||||
}
|
||||
msg
|
||||
ExprKind::Path(_, path)
|
||||
if let Some(segment) = path.segments.last()
|
||||
&& let Some(c) = segment.ident.to_string().chars().next()
|
||||
&& c.is_uppercase() =>
|
||||
{
|
||||
"function, tuple struct or tuple variant"
|
||||
}
|
||||
_ => "function",
|
||||
},
|
||||
|
|
@ -1182,10 +1178,11 @@ impl<'ra: 'ast, 'ast, 'tcx> Visitor<'ast> for LateResolutionVisitor<'_, 'ast, 'r
|
|||
// namespace first, and if that fails we try again in the value namespace. If
|
||||
// resolution in the value namespace succeeds, we have an generic const argument on
|
||||
// our hands.
|
||||
if let TyKind::Path(None, ref path) = ty.kind {
|
||||
if let TyKind::Path(None, ref path) = ty.kind
|
||||
// We cannot disambiguate multi-segment paths right now as that requires type
|
||||
// checking.
|
||||
if path.is_potential_trivial_const_arg() {
|
||||
&& path.is_potential_trivial_const_arg()
|
||||
{
|
||||
let mut check_ns = |ns| {
|
||||
self.maybe_resolve_ident_in_lexical_scope(path.segments[0].ident, ns)
|
||||
.is_some()
|
||||
|
|
@ -1195,12 +1192,7 @@ impl<'ra: 'ast, 'ast, 'tcx> Visitor<'ast> for LateResolutionVisitor<'_, 'ast, 'r
|
|||
true,
|
||||
AnonConstKind::ConstArg(IsRepeatExpr::No),
|
||||
|this| {
|
||||
this.smart_resolve_path(
|
||||
ty.id,
|
||||
&None,
|
||||
path,
|
||||
PathSource::Expr(None),
|
||||
);
|
||||
this.smart_resolve_path(ty.id, &None, path, PathSource::Expr(None));
|
||||
this.visit_path(path, ty.id);
|
||||
},
|
||||
);
|
||||
|
|
@ -1209,7 +1201,6 @@ impl<'ra: 'ast, 'ast, 'tcx> Visitor<'ast> for LateResolutionVisitor<'_, 'ast, 'r
|
|||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
self.visit_ty(ty);
|
||||
}
|
||||
|
|
@ -1243,7 +1234,10 @@ impl<'ra: 'ast, 'ast, 'tcx> Visitor<'ast> for LateResolutionVisitor<'_, 'ast, 'r
|
|||
}
|
||||
|
||||
fn visit_path_segment(&mut self, path_segment: &'ast PathSegment) {
|
||||
if let Some(ref args) = path_segment.args {
|
||||
let Some(ref args) = path_segment.args else {
|
||||
return;
|
||||
};
|
||||
|
||||
match &**args {
|
||||
GenericArgs::AngleBracketed(..) => visit::walk_generic_args(self, args),
|
||||
GenericArgs::Parenthesized(p_args) => {
|
||||
|
|
@ -1292,7 +1286,6 @@ impl<'ra: 'ast, 'ast, 'tcx> Visitor<'ast> for LateResolutionVisitor<'_, 'ast, 'r
|
|||
GenericArgs::ParenthesizedElided(_) => {}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn visit_where_predicate(&mut self, p: &'ast WherePredicate) {
|
||||
debug!("visit_where_predicate {:?}", p);
|
||||
|
|
@ -1735,13 +1728,8 @@ impl<'a, 'ast, 'ra: 'ast, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
|
|||
}
|
||||
|
||||
let normalized_ident = ident.normalize_to_macros_2_0();
|
||||
let mut outer_res = None;
|
||||
for rib in lifetime_rib_iter {
|
||||
if let Some((&outer, _)) = rib.bindings.get_key_value(&normalized_ident) {
|
||||
outer_res = Some(outer);
|
||||
break;
|
||||
}
|
||||
}
|
||||
let outer_res = lifetime_rib_iter
|
||||
.find_map(|rib| rib.bindings.get_key_value(&normalized_ident).map(|(&outer, _)| outer));
|
||||
|
||||
self.emit_undeclared_lifetime_error(lifetime, outer_res);
|
||||
self.record_lifetime_res(lifetime.id, LifetimeRes::Error, LifetimeElisionCandidate::Named);
|
||||
|
|
@ -1808,23 +1796,21 @@ impl<'a, 'ast, 'ra: 'ast, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
|
|||
}
|
||||
LifetimeRibKind::AnonymousReportError => {
|
||||
if elided {
|
||||
let mut suggestion = None;
|
||||
for rib in self.lifetime_ribs[i..].iter().rev() {
|
||||
let suggestion = self.lifetime_ribs[i..].iter().rev().find_map(|rib| {
|
||||
if let LifetimeRibKind::Generics {
|
||||
span,
|
||||
kind: LifetimeBinderKind::PolyTrait | LifetimeBinderKind::WhereBound,
|
||||
..
|
||||
} = &rib.kind
|
||||
} = rib.kind
|
||||
{
|
||||
suggestion =
|
||||
Some(errors::ElidedAnonymousLivetimeReportErrorSuggestion {
|
||||
lo: span.shrink_to_lo(),
|
||||
hi: lifetime.ident.span.shrink_to_hi(),
|
||||
})
|
||||
} else {
|
||||
None
|
||||
}
|
||||
});
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// are we trying to use an anonymous lifetime
|
||||
// on a non GAT associated trait type?
|
||||
if !self.in_func_body
|
||||
|
|
@ -2460,13 +2446,13 @@ impl<'a, 'ast, 'ra: 'ast, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
|
|||
for i in (0..self.label_ribs.len()).rev() {
|
||||
let rib = &self.label_ribs[i];
|
||||
|
||||
if let RibKind::MacroDefinition(def) = rib.kind {
|
||||
if let RibKind::MacroDefinition(def) = rib.kind
|
||||
// If an invocation of this macro created `ident`, give up on `ident`
|
||||
// and switch to `ident`'s source from the macro definition.
|
||||
if def == self.r.macro_def(label.span.ctxt()) {
|
||||
&& def == self.r.macro_def(label.span.ctxt())
|
||||
{
|
||||
label.span.remove_mark();
|
||||
}
|
||||
}
|
||||
|
||||
let ident = label.normalize_to_macro_rules();
|
||||
if let Some((ident, id)) = rib.bindings.get_key_value(&ident) {
|
||||
|
|
@ -2493,14 +2479,7 @@ impl<'a, 'ast, 'ra: 'ast, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
|
|||
/// Determine whether or not a label from the `rib_index`th label rib is reachable.
|
||||
fn is_label_valid_from_rib(&self, rib_index: usize) -> bool {
|
||||
let ribs = &self.label_ribs[rib_index + 1..];
|
||||
|
||||
for rib in ribs {
|
||||
if rib.kind.is_label_barrier() {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
true
|
||||
ribs.iter().all(|rib| !rib.kind.is_label_barrier())
|
||||
}
|
||||
|
||||
fn resolve_adt(&mut self, item: &'ast Item, generics: &'ast Generics) {
|
||||
|
|
@ -3505,7 +3484,7 @@ impl<'a, 'ast, 'ra: 'ast, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
|
|||
self.visit_ty(&qself.ty);
|
||||
}
|
||||
self.visit_path(&delegation.path, delegation.id);
|
||||
if let Some(body) = &delegation.body {
|
||||
let Some(body) = &delegation.body else { return };
|
||||
self.with_rib(ValueNS, RibKind::FnOrCoroutine, |this| {
|
||||
// `PatBoundCtx` is not necessary in this context
|
||||
let mut bindings = smallvec![(PatBoundCtx::Product, Default::default())];
|
||||
|
|
@ -3520,7 +3499,6 @@ impl<'a, 'ast, 'ra: 'ast, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
|
|||
this.visit_block(body);
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
fn resolve_params(&mut self, params: &'ast [Param]) {
|
||||
let mut bindings = smallvec![(PatBoundCtx::Product, Default::default())];
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue