always create DefId
s when lowering anon-consts
This commit is contained in:
parent
467e200cd5
commit
94131bd0a8
9 changed files with 61 additions and 185 deletions
|
@ -12,23 +12,16 @@ use rustc_span::hygiene::LocalExpnId;
|
|||
use rustc_span::symbol::{Symbol, kw, sym};
|
||||
use tracing::debug;
|
||||
|
||||
use crate::{ImplTraitContext, InvocationParent, PendingAnonConstInfo, Resolver};
|
||||
use crate::{ImplTraitContext, InvocationParent, Resolver};
|
||||
|
||||
pub(crate) fn collect_definitions(
|
||||
resolver: &mut Resolver<'_, '_>,
|
||||
fragment: &AstFragment,
|
||||
expansion: LocalExpnId,
|
||||
) {
|
||||
let InvocationParent { parent_def, pending_anon_const_info, impl_trait_context, in_attr } =
|
||||
let InvocationParent { parent_def, impl_trait_context, in_attr } =
|
||||
resolver.invocation_parents[&expansion];
|
||||
let mut visitor = DefCollector {
|
||||
resolver,
|
||||
parent_def,
|
||||
pending_anon_const_info,
|
||||
expansion,
|
||||
impl_trait_context,
|
||||
in_attr,
|
||||
};
|
||||
let mut visitor = DefCollector { resolver, parent_def, expansion, impl_trait_context, in_attr };
|
||||
fragment.visit_with(&mut visitor);
|
||||
}
|
||||
|
||||
|
@ -36,13 +29,6 @@ pub(crate) fn collect_definitions(
|
|||
struct DefCollector<'a, 'ra, 'tcx> {
|
||||
resolver: &'a mut Resolver<'ra, 'tcx>,
|
||||
parent_def: LocalDefId,
|
||||
/// If we have an anon const that consists of a macro invocation, e.g. `Foo<{ m!() }>`,
|
||||
/// we need to wait until we know what the macro expands to before we create the def for
|
||||
/// the anon const. That's because we lower some anon consts into `hir::ConstArgKind::Path`,
|
||||
/// which don't have defs.
|
||||
///
|
||||
/// See `Self::visit_anon_const()`.
|
||||
pending_anon_const_info: Option<PendingAnonConstInfo>,
|
||||
impl_trait_context: ImplTraitContext,
|
||||
in_attr: bool,
|
||||
expansion: LocalExpnId,
|
||||
|
@ -110,61 +96,13 @@ impl<'a, 'ra, 'tcx> DefCollector<'a, 'ra, 'tcx> {
|
|||
|
||||
fn visit_macro_invoc(&mut self, id: NodeId) {
|
||||
let id = id.placeholder_to_expn_id();
|
||||
let pending_anon_const_info = self.pending_anon_const_info.take();
|
||||
let old_parent = self.resolver.invocation_parents.insert(id, InvocationParent {
|
||||
parent_def: self.parent_def,
|
||||
pending_anon_const_info,
|
||||
impl_trait_context: self.impl_trait_context,
|
||||
in_attr: self.in_attr,
|
||||
});
|
||||
assert!(old_parent.is_none(), "parent `LocalDefId` is reset for an invocation");
|
||||
}
|
||||
|
||||
/// Determines whether the const argument `AnonConst` is a simple macro call, optionally
|
||||
/// surrounded with braces.
|
||||
///
|
||||
/// If this const argument *is* a trivial macro call then the id for the macro call is
|
||||
/// returned along with the information required to build the anon const's def if
|
||||
/// the macro call expands to a non-trivial expression.
|
||||
fn is_const_arg_trivial_macro_expansion(
|
||||
&self,
|
||||
anon_const: &'a AnonConst,
|
||||
) -> Option<(PendingAnonConstInfo, NodeId)> {
|
||||
anon_const.value.optionally_braced_mac_call(false).map(|(block_was_stripped, id)| {
|
||||
(
|
||||
PendingAnonConstInfo {
|
||||
id: anon_const.id,
|
||||
span: anon_const.value.span,
|
||||
block_was_stripped,
|
||||
},
|
||||
id,
|
||||
)
|
||||
})
|
||||
}
|
||||
|
||||
/// Determines whether the expression `const_arg_sub_expr` is a simple macro call, sometimes
|
||||
/// surrounded with braces if a set of braces has not already been entered. This is required
|
||||
/// as `{ N }` is treated as equivalent to a bare parameter `N` whereas `{{ N }}` is treated as
|
||||
/// a real block expression and is lowered to an anonymous constant which is not allowed to use
|
||||
/// generic parameters.
|
||||
///
|
||||
/// If this expression is a trivial macro call then the id for the macro call is
|
||||
/// returned along with the information required to build the anon const's def if
|
||||
/// the macro call expands to a non-trivial expression.
|
||||
fn is_const_arg_sub_expr_trivial_macro_expansion(
|
||||
&self,
|
||||
const_arg_sub_expr: &'a Expr,
|
||||
) -> Option<(PendingAnonConstInfo, NodeId)> {
|
||||
let pending_anon = self.pending_anon_const_info.unwrap_or_else(||
|
||||
panic!("Checking expr is trivial macro call without having entered anon const: `{const_arg_sub_expr:?}`"),
|
||||
);
|
||||
|
||||
const_arg_sub_expr.optionally_braced_mac_call(pending_anon.block_was_stripped).map(
|
||||
|(block_was_stripped, id)| {
|
||||
(PendingAnonConstInfo { block_was_stripped, ..pending_anon }, id)
|
||||
},
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> {
|
||||
|
@ -376,78 +314,34 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> {
|
|||
}
|
||||
|
||||
fn visit_anon_const(&mut self, constant: &'a AnonConst) {
|
||||
// HACK(min_generic_const_args): don't create defs for anon consts if we think they will
|
||||
// later be turned into ConstArgKind::Path's. because this is before resolve is done, we
|
||||
// may accidentally identify a construction of a unit struct as a param and not create a
|
||||
// def. we'll then create a def later in ast lowering in this case. the parent of nested
|
||||
// items will be messed up, but that's ok because there can't be any if we're just looking
|
||||
// for bare idents.
|
||||
|
||||
if let Some((pending_anon, macro_invoc)) =
|
||||
self.is_const_arg_trivial_macro_expansion(constant)
|
||||
{
|
||||
self.pending_anon_const_info = Some(pending_anon);
|
||||
return self.visit_macro_invoc(macro_invoc);
|
||||
} else if constant.value.is_potential_trivial_const_arg(true) {
|
||||
return visit::walk_anon_const(self, constant);
|
||||
}
|
||||
|
||||
let def = self.create_def(constant.id, kw::Empty, DefKind::AnonConst, constant.value.span);
|
||||
self.with_parent(def, |this| visit::walk_anon_const(this, constant));
|
||||
let parent =
|
||||
self.create_def(constant.id, kw::Empty, DefKind::AnonConst, constant.value.span);
|
||||
self.with_parent(parent, |this| visit::walk_anon_const(this, constant));
|
||||
}
|
||||
|
||||
fn visit_expr(&mut self, expr: &'a Expr) {
|
||||
// If we're visiting the expression of a const argument that was a macro call then
|
||||
// check if it is *still* unknown whether it is a trivial const arg or not. If so
|
||||
// recurse into the macro call and delay creating the anon const def until expansion.
|
||||
if self.pending_anon_const_info.is_some()
|
||||
&& let Some((pending_anon, macro_invoc)) =
|
||||
self.is_const_arg_sub_expr_trivial_macro_expansion(expr)
|
||||
{
|
||||
self.pending_anon_const_info = Some(pending_anon);
|
||||
return self.visit_macro_invoc(macro_invoc);
|
||||
}
|
||||
|
||||
// See self.pending_anon_const_info for explanation
|
||||
let parent_def = self
|
||||
.pending_anon_const_info
|
||||
.take()
|
||||
// If we already stripped away a set of braces then do not do it again when determining
|
||||
// if the macro expanded to a trivial const arg. This arises in cases such as:
|
||||
// `Foo<{ bar!() }>` where `bar!()` expands to `{ N }`. This should not be considered a
|
||||
// trivial const argument even though `{ N }` by itself *is*.
|
||||
.filter(|pending_anon| {
|
||||
!expr.is_potential_trivial_const_arg(!pending_anon.block_was_stripped)
|
||||
})
|
||||
.map(|pending_anon| {
|
||||
self.create_def(pending_anon.id, kw::Empty, DefKind::AnonConst, pending_anon.span)
|
||||
})
|
||||
.unwrap_or(self.parent_def);
|
||||
|
||||
self.with_parent(parent_def, |this| {
|
||||
let parent_def = match expr.kind {
|
||||
ExprKind::MacCall(..) => return this.visit_macro_invoc(expr.id),
|
||||
ExprKind::Closure(..) | ExprKind::Gen(..) => {
|
||||
this.create_def(expr.id, kw::Empty, DefKind::Closure, expr.span)
|
||||
let parent_def = match expr.kind {
|
||||
ExprKind::MacCall(..) => return self.visit_macro_invoc(expr.id),
|
||||
ExprKind::Closure(..) | ExprKind::Gen(..) => {
|
||||
self.create_def(expr.id, kw::Empty, DefKind::Closure, expr.span)
|
||||
}
|
||||
ExprKind::ConstBlock(ref constant) => {
|
||||
for attr in &expr.attrs {
|
||||
visit::walk_attribute(self, attr);
|
||||
}
|
||||
ExprKind::ConstBlock(ref constant) => {
|
||||
for attr in &expr.attrs {
|
||||
visit::walk_attribute(this, attr);
|
||||
}
|
||||
let def = this.create_def(
|
||||
constant.id,
|
||||
kw::Empty,
|
||||
DefKind::InlineConst,
|
||||
constant.value.span,
|
||||
);
|
||||
this.with_parent(def, |this| visit::walk_anon_const(this, constant));
|
||||
return;
|
||||
}
|
||||
_ => this.parent_def,
|
||||
};
|
||||
let def = self.create_def(
|
||||
constant.id,
|
||||
kw::Empty,
|
||||
DefKind::InlineConst,
|
||||
constant.value.span,
|
||||
);
|
||||
self.with_parent(def, |this| visit::walk_anon_const(this, constant));
|
||||
return;
|
||||
}
|
||||
_ => self.parent_def,
|
||||
};
|
||||
|
||||
this.with_parent(parent_def, |this| visit::walk_expr(this, expr))
|
||||
})
|
||||
self.with_parent(parent_def, |this| visit::walk_expr(this, expr))
|
||||
}
|
||||
|
||||
fn visit_ty(&mut self, ty: &'a Ty) {
|
||||
|
|
|
@ -4521,7 +4521,7 @@ impl<'a, 'ast, 'ra: 'ast, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
|
|||
);
|
||||
|
||||
self.resolve_anon_const_manual(
|
||||
constant.value.is_potential_trivial_const_arg(true),
|
||||
constant.value.is_potential_trivial_const_arg(),
|
||||
anon_const_kind,
|
||||
|this| this.resolve_expr(&constant.value, None),
|
||||
)
|
||||
|
@ -4685,7 +4685,7 @@ impl<'a, 'ast, 'ra: 'ast, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
|
|||
// that is how they will be later lowered to HIR.
|
||||
if const_args.contains(&idx) {
|
||||
self.resolve_anon_const_manual(
|
||||
argument.is_potential_trivial_const_arg(true),
|
||||
argument.is_potential_trivial_const_arg(),
|
||||
AnonConstKind::ConstArg(IsRepeatExpr::No),
|
||||
|this| this.resolve_expr(argument, None),
|
||||
);
|
||||
|
|
|
@ -174,7 +174,6 @@ impl<'ra> ParentScope<'ra> {
|
|||
#[derive(Copy, Debug, Clone)]
|
||||
struct InvocationParent {
|
||||
parent_def: LocalDefId,
|
||||
pending_anon_const_info: Option<PendingAnonConstInfo>,
|
||||
impl_trait_context: ImplTraitContext,
|
||||
in_attr: bool,
|
||||
}
|
||||
|
@ -182,23 +181,11 @@ struct InvocationParent {
|
|||
impl InvocationParent {
|
||||
const ROOT: Self = Self {
|
||||
parent_def: CRATE_DEF_ID,
|
||||
pending_anon_const_info: None,
|
||||
impl_trait_context: ImplTraitContext::Existential,
|
||||
in_attr: false,
|
||||
};
|
||||
}
|
||||
|
||||
#[derive(Copy, Debug, Clone)]
|
||||
struct PendingAnonConstInfo {
|
||||
// A const arg is only a "trivial" const arg if it has at *most* one set of braces
|
||||
// around the argument. We track whether we have stripped an outter brace so that
|
||||
// if a macro expands to a braced expression *and* the macro was itself inside of
|
||||
// some braces then we can consider it to be a non-trivial const argument.
|
||||
block_was_stripped: bool,
|
||||
id: NodeId,
|
||||
span: Span,
|
||||
}
|
||||
|
||||
#[derive(Copy, Debug, Clone)]
|
||||
enum ImplTraitContext {
|
||||
Existential,
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue