bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Remove "RibKind" suffix from RibKind variants

Browse source
This commit is contained in:
Maybe Waffle 2023-05-01 15:54:48 +00:00
parent 6197e4d209
commit 0fa59204e5
3 changed files with 103 additions and 109 deletions
Download patch file Download diff file Expand all files Collapse all files

56
compiler/rustc_resolve/src/ident.rs
View file

@ -323,7 +323,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
} }
module = match ribs[i].kind { module = match ribs[i].kind {
RibKind::ModuleRibKind(module) => module, RibKind::Module(module) => module,
RibKind::MacroDefinition(def) if def == self.macro_def(ident.span.ctxt()) => { RibKind::MacroDefinition(def) if def == self.macro_def(ident.span.ctxt()) => {
// If an invocation of this macro created `ident`, give up on `ident` // If an invocation of this macro created `ident`, give up on `ident`
// and switch to `ident`'s source from the macro definition. // and switch to `ident`'s source from the macro definition.
@ -1083,7 +1083,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
let ribs = &all_ribs[rib_index + 1..]; let ribs = &all_ribs[rib_index + 1..];
// An invalid forward use of a generic parameter from a previous default. // An invalid forward use of a generic parameter from a previous default.
if let RibKind::ForwardGenericParamBanRibKind = all_ribs[rib_index].kind { if let RibKind::ForwardGenericParamBan = all_ribs[rib_index].kind {
if let Some(span) = finalize { if let Some(span) = finalize {
let res_error = if rib_ident.name == kw::SelfUpper { let res_error = if rib_ident.name == kw::SelfUpper {
ResolutionError::SelfInGenericParamDefault ResolutionError::SelfInGenericParamDefault
@ -1103,14 +1103,14 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
for rib in ribs { for rib in ribs {
match rib.kind { match rib.kind {
RibKind::NormalRibKind RibKind::Normal
| RibKind::ClosureOrAsyncRibKind | RibKind::ClosureOrAsync
| RibKind::ModuleRibKind(..) | RibKind::Module(..)
| RibKind::MacroDefinition(..) | RibKind::MacroDefinition(..)
| RibKind::ForwardGenericParamBanRibKind => { | RibKind::ForwardGenericParamBan => {
// Nothing to do. Continue. // Nothing to do. Continue.
} }
RibKind::ItemRibKind(_) | RibKind::AssocItemRibKind => { RibKind::Item(_) | RibKind::AssocItem => {
// This was an attempt to access an upvar inside a // This was an attempt to access an upvar inside a
// named function item. This is not allowed, so we // named function item. This is not allowed, so we
// report an error. // report an error.
@ -1122,7 +1122,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
res_err = Some((span, CannotCaptureDynamicEnvironmentInFnItem)); res_err = Some((span, CannotCaptureDynamicEnvironmentInFnItem));
} }
} }
RibKind::ConstantItemRibKind(_, item) => { RibKind::ConstantItem(_, item) => {
// Still doesn't deal with upvars // Still doesn't deal with upvars
if let Some(span) = finalize { if let Some(span) = finalize {
let (span, resolution_error) = let (span, resolution_error) =
@ -1151,13 +1151,13 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
} }
return Res::Err; return Res::Err;
} }
RibKind::ConstParamTyRibKind => { RibKind::ConstParamTy => {
if let Some(span) = finalize { if let Some(span) = finalize {
self.report_error(span, ParamInTyOfConstParam(rib_ident.name)); self.report_error(span, ParamInTyOfConstParam(rib_ident.name));
} }
return Res::Err; return Res::Err;
} }
RibKind::InlineAsmSymRibKind => { RibKind::InlineAsmSym => {
if let Some(span) = finalize { if let Some(span) = finalize {
self.report_error(span, InvalidAsmSym); self.report_error(span, InvalidAsmSym);
} }
@ -1173,18 +1173,18 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
Res::Def(DefKind::TyParam, _) | Res::SelfTyParam { .. } | Res::SelfTyAlias { .. } => { Res::Def(DefKind::TyParam, _) | Res::SelfTyParam { .. } | Res::SelfTyAlias { .. } => {
for rib in ribs { for rib in ribs {
let has_generic_params: HasGenericParams = match rib.kind { let has_generic_params: HasGenericParams = match rib.kind {
RibKind::NormalRibKind RibKind::Normal
| RibKind::ClosureOrAsyncRibKind | RibKind::ClosureOrAsync
| RibKind::ModuleRibKind(..) | RibKind::Module(..)
| RibKind::MacroDefinition(..) | RibKind::MacroDefinition(..)
| RibKind::InlineAsmSymRibKind | RibKind::InlineAsmSym
| RibKind::AssocItemRibKind | RibKind::AssocItem
| RibKind::ForwardGenericParamBanRibKind => { | RibKind::ForwardGenericParamBan => {
// Nothing to do. Continue. // Nothing to do. Continue.
continue; continue;
} }
RibKind::ConstantItemRibKind(trivial, _) => { RibKind::ConstantItem(trivial, _) => {
let features = self.tcx.sess.features_untracked(); let features = self.tcx.sess.features_untracked();
// HACK(min_const_generics): We currently only allow `N` or `{ N }`. // HACK(min_const_generics): We currently only allow `N` or `{ N }`.
if !(trivial == ConstantHasGenerics::Yes if !(trivial == ConstantHasGenerics::Yes
@ -1225,8 +1225,8 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
} }
// This was an attempt to use a type parameter outside its scope. // This was an attempt to use a type parameter outside its scope.
RibKind::ItemRibKind(has_generic_params) => has_generic_params, RibKind::Item(has_generic_params) => has_generic_params,
RibKind::ConstParamTyRibKind => { RibKind::ConstParamTy => {
if let Some(span) = finalize { if let Some(span) = finalize {
self.report_error( self.report_error(
span, span,
@ -1252,15 +1252,15 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
Res::Def(DefKind::ConstParam, _) => { Res::Def(DefKind::ConstParam, _) => {
for rib in ribs { for rib in ribs {
let has_generic_params = match rib.kind { let has_generic_params = match rib.kind {
RibKind::NormalRibKind RibKind::Normal
| RibKind::ClosureOrAsyncRibKind | RibKind::ClosureOrAsync
| RibKind::ModuleRibKind(..) | RibKind::Module(..)
| RibKind::MacroDefinition(..) | RibKind::MacroDefinition(..)
| RibKind::InlineAsmSymRibKind | RibKind::InlineAsmSym
| RibKind::AssocItemRibKind | RibKind::AssocItem
| RibKind::ForwardGenericParamBanRibKind => continue, | RibKind::ForwardGenericParamBan => continue,
RibKind::ConstantItemRibKind(trivial, _) => { RibKind::ConstantItem(trivial, _) => {
let features = self.tcx.sess.features_untracked(); let features = self.tcx.sess.features_untracked();
// HACK(min_const_generics): We currently only allow `N` or `{ N }`. // HACK(min_const_generics): We currently only allow `N` or `{ N }`.
if !(trivial == ConstantHasGenerics::Yes if !(trivial == ConstantHasGenerics::Yes
@ -1283,8 +1283,8 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
continue; continue;
} }
RibKind::ItemRibKind(has_generic_params) => has_generic_params, RibKind::Item(has_generic_params) => has_generic_params,
RibKind::ConstParamTyRibKind => { RibKind::ConstParamTy => {
if let Some(span) = finalize { if let Some(span) = finalize {
self.report_error( self.report_error(
span, span,

152
compiler/rustc_resolve/src/late.rs
View file

@ -131,28 +131,28 @@ enum RecordPartialRes {
#[derive(Copy, Clone, Debug)] #[derive(Copy, Clone, Debug)]
pub(crate) enum RibKind<'a> { pub(crate) enum RibKind<'a> {
/// No restriction needs to be applied. /// No restriction needs to be applied.
NormalRibKind, Normal,
/// We passed through an impl or trait and are now in one of its /// We passed through an impl or trait and are now in one of its
/// methods or associated types. Allow references to ty params that impl or trait /// methods or associated types. Allow references to ty params that impl or trait
/// binds. Disallow any other upvars (including other ty params that are /// binds. Disallow any other upvars (including other ty params that are
/// upvars). /// upvars).
AssocItemRibKind, AssocItem,
/// We passed through a closure. Disallow labels. /// We passed through a closure. Disallow labels.
ClosureOrAsyncRibKind, ClosureOrAsync,
/// We passed through an item scope. Disallow upvars. /// We passed through an item scope. Disallow upvars.
ItemRibKind(HasGenericParams), Item(HasGenericParams),
/// We're in a constant item. Can't refer to dynamic stuff. /// We're in a constant item. Can't refer to dynamic stuff.
/// ///
/// The item may reference generic parameters in trivial constant expressions. /// The item may reference generic parameters in trivial constant expressions.
/// All other constants aren't allowed to use generic params at all. /// All other constants aren't allowed to use generic params at all.
ConstantItemRibKind(ConstantHasGenerics, Option<(Ident, ConstantItemKind)>), ConstantItem(ConstantHasGenerics, Option<(Ident, ConstantItemKind)>),
/// We passed through a module. /// We passed through a module.
ModuleRibKind(Module<'a>), Module(Module<'a>),
/// We passed through a `macro_rules!` statement /// We passed through a `macro_rules!` statement
MacroDefinition(DefId), MacroDefinition(DefId),
@ -160,15 +160,15 @@ pub(crate) enum RibKind<'a> {
/// All bindings in this rib are generic parameters that can't be used /// All bindings in this rib are generic parameters that can't be used
/// from the default of a generic parameter because they're not declared /// from the default of a generic parameter because they're not declared
/// before said generic parameter. Also see the `visit_generics` override. /// before said generic parameter. Also see the `visit_generics` override.
ForwardGenericParamBanRibKind, ForwardGenericParamBan,
/// We are inside of the type of a const parameter. Can't refer to any /// We are inside of the type of a const parameter. Can't refer to any
/// parameters. /// parameters.
ConstParamTyRibKind, ConstParamTy,
/// We are inside a `sym` inline assembly operand. Can only refer to /// We are inside a `sym` inline assembly operand. Can only refer to
/// globals. /// globals.
InlineAsmSymRibKind, InlineAsmSym,
} }
impl RibKind<'_> { impl RibKind<'_> {
@ -176,32 +176,30 @@ impl RibKind<'_> {
/// variables. /// variables.
pub(crate) fn contains_params(&self) -> bool { pub(crate) fn contains_params(&self) -> bool {
match self { match self {
RibKind::NormalRibKind RibKind::Normal
| RibKind::ClosureOrAsyncRibKind | RibKind::ClosureOrAsync
| RibKind::ConstantItemRibKind(..) | RibKind::ConstantItem(..)
| RibKind::ModuleRibKind(_) | RibKind::Module(_)
| RibKind::MacroDefinition(_) | RibKind::MacroDefinition(_)
| RibKind::ConstParamTyRibKind | RibKind::ConstParamTy
| RibKind::InlineAsmSymRibKind => false, | RibKind::InlineAsmSym => false,
RibKind::AssocItemRibKind RibKind::AssocItem | RibKind::Item(_) | RibKind::ForwardGenericParamBan => true,
| RibKind::ItemRibKind(_)
| RibKind::ForwardGenericParamBanRibKind => true,
} }
} }
/// This rib forbids referring to labels defined in upwards ribs. /// This rib forbids referring to labels defined in upwards ribs.
fn is_label_barrier(self) -> bool { fn is_label_barrier(self) -> bool {
match self { match self {
RibKind::NormalRibKind | RibKind::MacroDefinition(..) => false, RibKind::Normal | RibKind::MacroDefinition(..) => false,
RibKind::AssocItemRibKind RibKind::AssocItem
| RibKind::ClosureOrAsyncRibKind | RibKind::ClosureOrAsync
| RibKind::ItemRibKind(..) | RibKind::Item(..)
| RibKind::ConstantItemRibKind(..) | RibKind::ConstantItem(..)
| RibKind::ModuleRibKind(..) | RibKind::Module(..)
| RibKind::ForwardGenericParamBanRibKind | RibKind::ForwardGenericParamBan
| RibKind::ConstParamTyRibKind | RibKind::ConstParamTy
| RibKind::InlineAsmSymRibKind => true, | RibKind::InlineAsmSym => true,
} }
} }
} }
@ -705,7 +703,7 @@ impl<'a: 'ast, 'ast, 'tcx> Visitor<'ast> for LateResolutionVisitor<'a, '_, 'ast,
let span = ty.span.shrink_to_lo().to(path.span.shrink_to_lo()); let span = ty.span.shrink_to_lo().to(path.span.shrink_to_lo());
self.with_generic_param_rib( self.with_generic_param_rib(
&[], &[],
RibKind::NormalRibKind, RibKind::Normal,
LifetimeRibKind::Generics { LifetimeRibKind::Generics {
binder: ty.id, binder: ty.id,
kind: LifetimeBinderKind::PolyTrait, kind: LifetimeBinderKind::PolyTrait,
@ -743,7 +741,7 @@ impl<'a: 'ast, 'ast, 'tcx> Visitor<'ast> for LateResolutionVisitor<'a, '_, 'ast,
let span = ty.span.shrink_to_lo().to(bare_fn.decl_span.shrink_to_lo()); let span = ty.span.shrink_to_lo().to(bare_fn.decl_span.shrink_to_lo());
self.with_generic_param_rib( self.with_generic_param_rib(
&bare_fn.generic_params, &bare_fn.generic_params,
RibKind::NormalRibKind, RibKind::Normal,
LifetimeRibKind::Generics { LifetimeRibKind::Generics {
binder: ty.id, binder: ty.id,
kind: LifetimeBinderKind::BareFnType, kind: LifetimeBinderKind::BareFnType,
@ -783,7 +781,7 @@ impl<'a: 'ast, 'ast, 'tcx> Visitor<'ast> for LateResolutionVisitor<'a, '_, 'ast,
let span = tref.span.shrink_to_lo().to(tref.trait_ref.path.span.shrink_to_lo()); let span = tref.span.shrink_to_lo().to(tref.trait_ref.path.span.shrink_to_lo());
self.with_generic_param_rib( self.with_generic_param_rib(
&tref.bound_generic_params, &tref.bound_generic_params,
RibKind::NormalRibKind, RibKind::Normal,
LifetimeRibKind::Generics { LifetimeRibKind::Generics {
binder: tref.trait_ref.ref_id, binder: tref.trait_ref.ref_id,
kind: LifetimeBinderKind::PolyTrait, kind: LifetimeBinderKind::PolyTrait,
@ -807,7 +805,7 @@ impl<'a: 'ast, 'ast, 'tcx> Visitor<'ast> for LateResolutionVisitor<'a, '_, 'ast,
ForeignItemKind::TyAlias(box TyAlias { ref generics, .. }) => { ForeignItemKind::TyAlias(box TyAlias { ref generics, .. }) => {
self.with_generic_param_rib( self.with_generic_param_rib(
&generics.params, &generics.params,
RibKind::ItemRibKind(HasGenericParams::Yes(generics.span)), RibKind::Item(HasGenericParams::Yes(generics.span)),
LifetimeRibKind::Generics { LifetimeRibKind::Generics {
binder: foreign_item.id, binder: foreign_item.id,
kind: LifetimeBinderKind::Item, kind: LifetimeBinderKind::Item,
@ -819,7 +817,7 @@ impl<'a: 'ast, 'ast, 'tcx> Visitor<'ast> for LateResolutionVisitor<'a, '_, 'ast,
ForeignItemKind::Fn(box Fn { ref generics, .. }) => { ForeignItemKind::Fn(box Fn { ref generics, .. }) => {
self.with_generic_param_rib( self.with_generic_param_rib(
&generics.params, &generics.params,
RibKind::ItemRibKind(HasGenericParams::Yes(generics.span)), RibKind::Item(HasGenericParams::Yes(generics.span)),
LifetimeRibKind::Generics { LifetimeRibKind::Generics {
binder: foreign_item.id, binder: foreign_item.id,
kind: LifetimeBinderKind::Function, kind: LifetimeBinderKind::Function,
@ -873,9 +871,9 @@ impl<'a: 'ast, 'ast, 'tcx> Visitor<'ast> for LateResolutionVisitor<'a, '_, 'ast,
debug!("(resolving function) entering function"); debug!("(resolving function) entering function");
// Create a value rib for the function. // Create a value rib for the function.
self.with_rib(ValueNS, RibKind::ClosureOrAsyncRibKind, |this| { self.with_rib(ValueNS, RibKind::ClosureOrAsync, |this| {
// Create a label rib for the function. // Create a label rib for the function.
this.with_label_rib(RibKind::ClosureOrAsyncRibKind, |this| { this.with_label_rib(RibKind::ClosureOrAsync, |this| {
match fn_kind { match fn_kind {
FnKind::Fn(_, _, sig, _, generics, body) => { FnKind::Fn(_, _, sig, _, generics, body) => {
this.visit_generics(generics); this.visit_generics(generics);
@ -1132,7 +1130,7 @@ impl<'a: 'ast, 'ast, 'tcx> Visitor<'ast> for LateResolutionVisitor<'a, '_, 'ast,
let span = predicate_span.shrink_to_lo().to(bounded_ty.span.shrink_to_lo()); let span = predicate_span.shrink_to_lo().to(bounded_ty.span.shrink_to_lo());
this.with_generic_param_rib( this.with_generic_param_rib(
&bound_generic_params, &bound_generic_params,
RibKind::NormalRibKind, RibKind::Normal,
LifetimeRibKind::Generics { LifetimeRibKind::Generics {
binder: bounded_ty.id, binder: bounded_ty.id,
kind: LifetimeBinderKind::WhereBound, kind: LifetimeBinderKind::WhereBound,
@ -1178,9 +1176,9 @@ impl<'a: 'ast, 'ast, 'tcx> Visitor<'ast> for LateResolutionVisitor<'a, '_, 'ast,
fn visit_inline_asm_sym(&mut self, sym: &'ast InlineAsmSym) { fn visit_inline_asm_sym(&mut self, sym: &'ast InlineAsmSym) {
// This is similar to the code for AnonConst. // This is similar to the code for AnonConst.
self.with_rib(ValueNS, RibKind::InlineAsmSymRibKind, |this| { self.with_rib(ValueNS, RibKind::InlineAsmSym, |this| {
this.with_rib(TypeNS, RibKind::InlineAsmSymRibKind, |this| { this.with_rib(TypeNS, RibKind::InlineAsmSym, |this| {
this.with_label_rib(RibKind::InlineAsmSymRibKind, |this| { this.with_label_rib(RibKind::InlineAsmSym, |this| {
this.smart_resolve_path(sym.id, &sym.qself, &sym.path, PathSource::Expr(None)); this.smart_resolve_path(sym.id, &sym.qself, &sym.path, PathSource::Expr(None));
visit::walk_inline_asm_sym(this, sym); visit::walk_inline_asm_sym(this, sym);
}); });
@ -1205,7 +1203,7 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
// although it may be useful to track other components as well for diagnostics. // although it may be useful to track other components as well for diagnostics.
let graph_root = resolver.graph_root; let graph_root = resolver.graph_root;
let parent_scope = ParentScope::module(graph_root, resolver); let parent_scope = ParentScope::module(graph_root, resolver);
let start_rib_kind = RibKind::ModuleRibKind(graph_root); let start_rib_kind = RibKind::Module(graph_root);
LateResolutionVisitor { LateResolutionVisitor {
r: resolver, r: resolver,
parent_scope, parent_scope,
@ -1309,8 +1307,8 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
if let Some(module) = self.r.get_module(self.r.local_def_id(id).to_def_id()) { if let Some(module) = self.r.get_module(self.r.local_def_id(id).to_def_id()) {
// Move down in the graph. // Move down in the graph.
let orig_module = replace(&mut self.parent_scope.module, module); let orig_module = replace(&mut self.parent_scope.module, module);
self.with_rib(ValueNS, RibKind::ModuleRibKind(module), |this| { self.with_rib(ValueNS, RibKind::Module(module), |this| {
this.with_rib(TypeNS, RibKind::ModuleRibKind(module), |this| { this.with_rib(TypeNS, RibKind::Module(module), |this| {
let ret = f(this); let ret = f(this);
this.parent_scope.module = orig_module; this.parent_scope.module = orig_module;
ret ret
@ -1327,8 +1325,8 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
// provide previous type parameters as they're built. We // provide previous type parameters as they're built. We
// put all the parameters on the ban list and then remove // put all the parameters on the ban list and then remove
// them one by one as they are processed and become available. // them one by one as they are processed and become available.
let mut forward_ty_ban_rib = Rib::new(RibKind::ForwardGenericParamBanRibKind); let mut forward_ty_ban_rib = Rib::new(RibKind::ForwardGenericParamBan);
let mut forward_const_ban_rib = Rib::new(RibKind::ForwardGenericParamBanRibKind); let mut forward_const_ban_rib = Rib::new(RibKind::ForwardGenericParamBan);
for param in params.iter() { for param in params.iter() {
match param.kind { match param.kind {
GenericParamKind::Type { .. } => { GenericParamKind::Type { .. } => {
@ -1389,8 +1387,8 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
// Const parameters can't have param bounds. // Const parameters can't have param bounds.
assert!(param.bounds.is_empty()); assert!(param.bounds.is_empty());
this.ribs[TypeNS].push(Rib::new(RibKind::ConstParamTyRibKind)); this.ribs[TypeNS].push(Rib::new(RibKind::ConstParamTy));
this.ribs[ValueNS].push(Rib::new(RibKind::ConstParamTyRibKind)); this.ribs[ValueNS].push(Rib::new(RibKind::ConstParamTy));
this.with_lifetime_rib(LifetimeRibKind::ConstGeneric, |this| { this.with_lifetime_rib(LifetimeRibKind::ConstGeneric, |this| {
this.visit_ty(ty) this.visit_ty(ty)
}); });
@ -2160,7 +2158,7 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
self.with_current_self_item(item, |this| { self.with_current_self_item(item, |this| {
this.with_generic_param_rib( this.with_generic_param_rib(
&generics.params, &generics.params,
RibKind::ItemRibKind(HasGenericParams::Yes(generics.span)), RibKind::Item(HasGenericParams::Yes(generics.span)),
LifetimeRibKind::Generics { LifetimeRibKind::Generics {
binder: item.id, binder: item.id,
kind: LifetimeBinderKind::Item, kind: LifetimeBinderKind::Item,
@ -2241,7 +2239,7 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
ItemKind::TyAlias(box TyAlias { ref generics, .. }) => { ItemKind::TyAlias(box TyAlias { ref generics, .. }) => {
self.with_generic_param_rib( self.with_generic_param_rib(
&generics.params, &generics.params,
RibKind::ItemRibKind(HasGenericParams::Yes(generics.span)), RibKind::Item(HasGenericParams::Yes(generics.span)),
LifetimeRibKind::Generics { LifetimeRibKind::Generics {
binder: item.id, binder: item.id,
kind: LifetimeBinderKind::Item, kind: LifetimeBinderKind::Item,
@ -2254,7 +2252,7 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
ItemKind::Fn(box Fn { ref generics, .. }) => { ItemKind::Fn(box Fn { ref generics, .. }) => {
self.with_generic_param_rib( self.with_generic_param_rib(
&generics.params, &generics.params,
RibKind::ItemRibKind(HasGenericParams::Yes(generics.span)), RibKind::Item(HasGenericParams::Yes(generics.span)),
LifetimeRibKind::Generics { LifetimeRibKind::Generics {
binder: item.id, binder: item.id,
kind: LifetimeBinderKind::Function, kind: LifetimeBinderKind::Function,
@ -2293,7 +2291,7 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
// Create a new rib for the trait-wide type parameters. // Create a new rib for the trait-wide type parameters.
self.with_generic_param_rib( self.with_generic_param_rib(
&generics.params, &generics.params,
RibKind::ItemRibKind(HasGenericParams::Yes(generics.span)), RibKind::Item(HasGenericParams::Yes(generics.span)),
LifetimeRibKind::Generics { LifetimeRibKind::Generics {
binder: item.id, binder: item.id,
kind: LifetimeBinderKind::Item, kind: LifetimeBinderKind::Item,
@ -2314,7 +2312,7 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
// Create a new rib for the trait-wide type parameters. // Create a new rib for the trait-wide type parameters.
self.with_generic_param_rib( self.with_generic_param_rib(
&generics.params, &generics.params,
RibKind::ItemRibKind(HasGenericParams::Yes(generics.span)), RibKind::Item(HasGenericParams::Yes(generics.span)),
LifetimeRibKind::Generics { LifetimeRibKind::Generics {
binder: item.id, binder: item.id,
kind: LifetimeBinderKind::Item, kind: LifetimeBinderKind::Item,
@ -2417,11 +2415,11 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
let mut seen_lifetimes = FxHashSet::default(); let mut seen_lifetimes = FxHashSet::default();
// We also can't shadow bindings from the parent item // We also can't shadow bindings from the parent item
if let RibKind::AssocItemRibKind = kind { if let RibKind::AssocItem = kind {
let mut add_bindings_for_ns = |ns| { let mut add_bindings_for_ns = |ns| {
let parent_rib = self.ribs[ns] let parent_rib = self.ribs[ns]
.iter() .iter()
.rfind(|r| matches!(r.kind, RibKind::ItemRibKind(_))) .rfind(|r| matches!(r.kind, RibKind::Item(_)))
.expect("associated item outside of an item"); .expect("associated item outside of an item");
seen_bindings.extend(parent_rib.bindings.keys().map(|ident| (*ident, ident.span))); seen_bindings.extend(parent_rib.bindings.keys().map(|ident| (*ident, ident.span)));
}; };
@ -2510,10 +2508,8 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
}; };
let res = match kind { let res = match kind {
RibKind::ItemRibKind(..) | RibKind::AssocItemRibKind => { RibKind::Item(..) | RibKind::AssocItem => Res::Def(def_kind, def_id.to_def_id()),
Res::Def(def_kind, def_id.to_def_id()) RibKind::Normal => {
}
RibKind::NormalRibKind => {
if self.r.tcx.sess.features_untracked().non_lifetime_binders { if self.r.tcx.sess.features_untracked().non_lifetime_binders {
Res::Def(def_kind, def_id.to_def_id()) Res::Def(def_kind, def_id.to_def_id())
} else { } else {
@ -2559,7 +2555,7 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
} }
fn with_static_rib(&mut self, f: impl FnOnce(&mut Self)) { fn with_static_rib(&mut self, f: impl FnOnce(&mut Self)) {
let kind = RibKind::ItemRibKind(HasGenericParams::No); let kind = RibKind::Item(HasGenericParams::No);
self.with_rib(ValueNS, kind, |this| this.with_rib(TypeNS, kind, f)) self.with_rib(ValueNS, kind, |this| this.with_rib(TypeNS, kind, f))
} }
@ -2579,15 +2575,15 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
item: Option<(Ident, ConstantItemKind)>, item: Option<(Ident, ConstantItemKind)>,
f: impl FnOnce(&mut Self), f: impl FnOnce(&mut Self),
) { ) {
self.with_rib(ValueNS, RibKind::ConstantItemRibKind(may_use_generics, item), |this| { self.with_rib(ValueNS, RibKind::ConstantItem(may_use_generics, item), |this| {
this.with_rib( this.with_rib(
TypeNS, TypeNS,
RibKind::ConstantItemRibKind( RibKind::ConstantItem(
may_use_generics.force_yes_if(is_repeat == IsRepeatExpr::Yes), may_use_generics.force_yes_if(is_repeat == IsRepeatExpr::Yes),
item, item,
), ),
|this| { |this| {
this.with_label_rib(RibKind::ConstantItemRibKind(may_use_generics, item), f); this.with_label_rib(RibKind::ConstantItem(may_use_generics, item), f);
}, },
) )
}); });
@ -2619,7 +2615,7 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
|this: &mut Self, generics: &Generics, kind, item: &'ast AssocItem| { |this: &mut Self, generics: &Generics, kind, item: &'ast AssocItem| {
this.with_generic_param_rib( this.with_generic_param_rib(
&generics.params, &generics.params,
RibKind::AssocItemRibKind, RibKind::AssocItem,
LifetimeRibKind::Generics { binder: item.id, span: generics.span, kind }, LifetimeRibKind::Generics { binder: item.id, span: generics.span, kind },
|this| visit::walk_assoc_item(this, item, AssocCtxt::Trait), |this| visit::walk_assoc_item(this, item, AssocCtxt::Trait),
); );
@ -2700,7 +2696,7 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
} }
fn with_self_rib_ns(&mut self, ns: Namespace, self_res: Res, f: impl FnOnce(&mut Self)) { fn with_self_rib_ns(&mut self, ns: Namespace, self_res: Res, f: impl FnOnce(&mut Self)) {
let mut self_type_rib = Rib::new(RibKind::NormalRibKind); let mut self_type_rib = Rib::new(RibKind::Normal);
// Plain insert (no renaming, since types are not currently hygienic) // Plain insert (no renaming, since types are not currently hygienic)
self_type_rib.bindings.insert(Ident::with_dummy_span(kw::SelfUpper), self_res); self_type_rib.bindings.insert(Ident::with_dummy_span(kw::SelfUpper), self_res);
@ -2726,7 +2722,7 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
// If applicable, create a rib for the type parameters. // If applicable, create a rib for the type parameters.
self.with_generic_param_rib( self.with_generic_param_rib(
&generics.params, &generics.params,
RibKind::ItemRibKind(HasGenericParams::Yes(generics.span)), RibKind::Item(HasGenericParams::Yes(generics.span)),
LifetimeRibKind::Generics { LifetimeRibKind::Generics {
span: generics.span, span: generics.span,
binder: item_id, binder: item_id,
@ -2840,7 +2836,7 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
// We also need a new scope for the impl item type parameters. // We also need a new scope for the impl item type parameters.
self.with_generic_param_rib( self.with_generic_param_rib(
&generics.params, &generics.params,
RibKind::AssocItemRibKind, RibKind::AssocItem,
LifetimeRibKind::Generics { LifetimeRibKind::Generics {
binder: item.id, binder: item.id,
span: generics.span, span: generics.span,
@ -2868,7 +2864,7 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
// We also need a new scope for the impl item type parameters. // We also need a new scope for the impl item type parameters.
self.with_generic_param_rib( self.with_generic_param_rib(
&generics.params, &generics.params,
RibKind::AssocItemRibKind, RibKind::AssocItem,
LifetimeRibKind::Generics { LifetimeRibKind::Generics {
binder: item.id, binder: item.id,
span: generics.span, span: generics.span,
@ -3140,7 +3136,7 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
} }
fn resolve_arm(&mut self, arm: &'ast Arm) { fn resolve_arm(&mut self, arm: &'ast Arm) {
self.with_rib(ValueNS, RibKind::NormalRibKind, |this| { self.with_rib(ValueNS, RibKind::Normal, |this| {
this.resolve_pattern_top(&arm.pat, PatternSource::Match); this.resolve_pattern_top(&arm.pat, PatternSource::Match);
walk_list!(this, visit_expr, &arm.guard); walk_list!(this, visit_expr, &arm.guard);
this.visit_expr(&arm.body); this.visit_expr(&arm.body);
@ -3862,7 +3858,7 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
diagnostics::signal_label_shadowing(self.r.tcx.sess, orig_span, label.ident) diagnostics::signal_label_shadowing(self.r.tcx.sess, orig_span, label.ident)
} }
self.with_label_rib(RibKind::NormalRibKind, |this| { self.with_label_rib(RibKind::Normal, |this| {
let ident = label.ident.normalize_to_macro_rules(); let ident = label.ident.normalize_to_macro_rules();
this.label_ribs.last_mut().unwrap().bindings.insert(ident, id); this.label_ribs.last_mut().unwrap().bindings.insert(ident, id);
f(this); f(this);
@ -3885,11 +3881,11 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
let mut num_macro_definition_ribs = 0; let mut num_macro_definition_ribs = 0;
if let Some(anonymous_module) = anonymous_module { if let Some(anonymous_module) = anonymous_module {
debug!("(resolving block) found anonymous module, moving down"); debug!("(resolving block) found anonymous module, moving down");
self.ribs[ValueNS].push(Rib::new(RibKind::ModuleRibKind(anonymous_module))); self.ribs[ValueNS].push(Rib::new(RibKind::Module(anonymous_module)));
self.ribs[TypeNS].push(Rib::new(RibKind::ModuleRibKind(anonymous_module))); self.ribs[TypeNS].push(Rib::new(RibKind::Module(anonymous_module)));
self.parent_scope.module = anonymous_module; self.parent_scope.module = anonymous_module;
} else { } else {
self.ribs[ValueNS].push(Rib::new(RibKind::NormalRibKind)); self.ribs[ValueNS].push(Rib::new(RibKind::Normal));
} }
let prev = self.diagnostic_metadata.current_block_could_be_bare_struct_literal.take(); let prev = self.diagnostic_metadata.current_block_could_be_bare_struct_literal.take();
@ -3994,7 +3990,7 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
} }
ExprKind::If(ref cond, ref then, ref opt_else) => { ExprKind::If(ref cond, ref then, ref opt_else) => {
self.with_rib(ValueNS, RibKind::NormalRibKind, |this| { self.with_rib(ValueNS, RibKind::Normal, |this| {
let old = this.diagnostic_metadata.in_if_condition.replace(cond); let old = this.diagnostic_metadata.in_if_condition.replace(cond);
this.visit_expr(cond); this.visit_expr(cond);
this.diagnostic_metadata.in_if_condition = old; this.diagnostic_metadata.in_if_condition = old;
@ -4011,7 +4007,7 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
ExprKind::While(ref cond, ref block, label) => { ExprKind::While(ref cond, ref block, label) => {
self.with_resolved_label(label, expr.id, |this| { self.with_resolved_label(label, expr.id, |this| {
this.with_rib(ValueNS, RibKind::NormalRibKind, |this| { this.with_rib(ValueNS, RibKind::Normal, |this| {
let old = this.diagnostic_metadata.in_if_condition.replace(cond); let old = this.diagnostic_metadata.in_if_condition.replace(cond);
this.visit_expr(cond); this.visit_expr(cond);
this.diagnostic_metadata.in_if_condition = old; this.diagnostic_metadata.in_if_condition = old;
@ -4022,7 +4018,7 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
ExprKind::ForLoop(ref pat, ref iter_expr, ref block, label) => { ExprKind::ForLoop(ref pat, ref iter_expr, ref block, label) => {
self.visit_expr(iter_expr); self.visit_expr(iter_expr);
self.with_rib(ValueNS, RibKind::NormalRibKind, |this| { self.with_rib(ValueNS, RibKind::Normal, |this| {
this.resolve_pattern_top(pat, PatternSource::For); this.resolve_pattern_top(pat, PatternSource::For);
this.resolve_labeled_block(label, expr.id, block); this.resolve_labeled_block(label, expr.id, block);
}); });
@ -4087,8 +4083,8 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
ref body, ref body,
.. ..
}) => { }) => {
self.with_rib(ValueNS, RibKind::NormalRibKind, |this| { self.with_rib(ValueNS, RibKind::Normal, |this| {
this.with_label_rib(RibKind::ClosureOrAsyncRibKind, |this| { this.with_label_rib(RibKind::ClosureOrAsync, |this| {
// Resolve arguments: // Resolve arguments:
this.resolve_params(&fn_decl.inputs); this.resolve_params(&fn_decl.inputs);
// No need to resolve return type -- // No need to resolve return type --
@ -4112,7 +4108,7 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
}) => { }) => {
self.with_generic_param_rib( self.with_generic_param_rib(
&generic_params, &generic_params,
RibKind::NormalRibKind, RibKind::Normal,
LifetimeRibKind::Generics { LifetimeRibKind::Generics {
binder: expr.id, binder: expr.id,
kind: LifetimeBinderKind::Closure, kind: LifetimeBinderKind::Closure,
@ -4123,9 +4119,7 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
} }
ExprKind::Closure(..) => visit::walk_expr(self, expr), ExprKind::Closure(..) => visit::walk_expr(self, expr),
ExprKind::Async(..) => { ExprKind::Async(..) => {
self.with_label_rib(RibKind::ClosureOrAsyncRibKind, |this| { self.with_label_rib(RibKind::ClosureOrAsync, |this| visit::walk_expr(this, expr));
visit::walk_expr(this, expr)
});
} }
ExprKind::Repeat(ref elem, ref ct) => { ExprKind::Repeat(ref elem, ref ct) => {
self.visit_expr(elem); self.visit_expr(elem);

4
compiler/rustc_resolve/src/late/diagnostics.rs
View file

@ -623,7 +623,7 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
} }
// Try to find in last block rib // Try to find in last block rib
if let Some(rib) = &self.last_block_rib && let RibKind::NormalRibKind = rib.kind { if let Some(rib) = &self.last_block_rib && let RibKind::Normal = rib.kind {
for (ident, &res) in &rib.bindings { for (ident, &res) in &rib.bindings {
if let Res::Local(_) = res && path.len() == 1 && if let Res::Local(_) = res && path.len() == 1 &&
ident.span.eq_ctxt(path[0].ident.span) && ident.span.eq_ctxt(path[0].ident.span) &&
@ -1728,7 +1728,7 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
} }
// Items in scope // Items in scope
if let RibKind::ModuleRibKind(module) = rib.kind { if let RibKind::Module(module) = rib.kind {
// Items from this module // Items from this module
self.r.add_module_candidates(module, &mut names, &filter_fn, Some(ctxt)); self.r.add_module_candidates(module, &mut names, &filter_fn, Some(ctxt));