add generics to hir::AnonConst

Author: lcnr

compiler/rustc_ast_lowering/src/lib.rs

@@ -512,6 +512,13 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     _ => visit::walk_ty(self, t),
                 }
             }
+
+            fn visit_anon_const(&mut self, ct: &'tcx AnonConst) {
+                self.lctx.allocate_hir_id_counter(ct.id);
+                self.with_hir_id_owner(Some(ct.id), |this| {
+                    visit::walk_anon_const(this, ct);
+                });
+            }
         }
 
         self.lower_node_id(CRATE_NODE_ID);
@@ -1158,9 +1165,9 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                                 tokens: None,
                             };
 
-                            let ct = self.with_new_scopes(|this| hir::AnonConst {
-                                hir_id: this.lower_node_id(node_id),
-                                body: this.lower_const_body(path_expr.span, Some(&path_expr)),
+                            let ct = self.lower_anon_const(&AnonConst {
+                                id: node_id,
+                                value: ast::ptr::P(path_expr),
                             });
                             return GenericArg::Const(ConstArg { value: ct, span: ty.span });
                         }
@@ -1169,7 +1176,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 GenericArg::Type(self.lower_ty_direct(&ty, itctx))
             }
             ast::GenericArg::Const(ct) => GenericArg::Const(ConstArg {
-                value: self.lower_anon_const(&ct),
+                value: self.lower_anon_const(ct),
                 span: ct.value.span,
             }),
         }
@@ -2320,10 +2327,57 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         self.expr_block(block, AttrVec::new())
     }
 
-    fn lower_anon_const(&mut self, c: &AnonConst) -> hir::AnonConst {
-        self.with_new_scopes(|this| hir::AnonConst {
-            hir_id: this.lower_node_id(c.id),
-            body: this.lower_const_body(c.value.span, Some(&c.value)),
+    fn lower_anon_const(&mut self, c: &AnonConst) -> hir::AnonConst<'hir> {
+        self.with_new_scopes(|this| {
+            this.allocate_hir_id_counter(c.id);
+            this.with_hir_id_owner(c.id, |this| {
+                let def_id = this.resolver.local_def_id(c.id);
+
+                let hir_id = this.lower_node_id(c.id);
+                // Calculate all the lifetimes that should be captured
+                // by the opaque type. This should include all in-scope
+                // lifetime parameters, including those defined in-band.
+                //
+                // Note: this must be done after lowering the output type,
+                // as the output type may introduce new in-band lifetimes.
+                let lifetime_params: Vec<(Span, ParamName)> = this
+                    .in_scope_lifetimes
+                    .iter()
+                    .cloned()
+                    .map(|name| (name.ident().span, name))
+                    .chain(this.lifetimes_to_define.iter().cloned())
+                    .collect();
+
+                let generic_params =
+                    this.arena.alloc_from_iter(lifetime_params.iter().map(|&(span, hir_name)| {
+                        this.lifetime_to_generic_param(span, hir_name, def_id)
+                    }));
+
+                let mut generic_args = Vec::with_capacity(lifetime_params.len());
+                generic_args.extend(lifetime_params.iter().map(|&(span, hir_name)| {
+                    GenericArg::Lifetime(hir::Lifetime {
+                        hir_id: this.next_id(),
+                        span,
+                        name: hir::LifetimeName::Param(hir_name),
+                    })
+                }));
+                let generic_args = this.arena.alloc_from_iter(generic_args);
+
+                hir::AnonConst {
+                    hir_id,
+                    generics: hir::Generics {
+                        params: generic_params,
+                        where_clause: hir::WhereClause { predicates: &[], span: c.value.span },
+                        span: c.value.span,
+                    },
+                    generic_args: hir::GenericArgs {
+                        args: generic_args,
+                        bindings: &[],
+                        parenthesized: false,
+                    },
+                    body: this.lower_const_body(c.value.span, Some(&c.value)),
+                }
+            })
         })
     }
 

compiler/rustc_hir/src/hir.rs

@@ -241,17 +241,17 @@ impl<'hir> PathSegment<'hir> {
     }
 }
 
-#[derive(Encodable, Debug, HashStable_Generic)]
-pub struct ConstArg {
-    pub value: AnonConst,
+#[derive(Debug, HashStable_Generic)]
+pub struct ConstArg<'hir> {
+    pub value: AnonConst<'hir>,
     pub span: Span,
 }
 
 #[derive(Debug, HashStable_Generic)]
 pub enum GenericArg<'hir> {
     Lifetime(Lifetime),
     Type(Ty<'hir>),
-    Const(ConstArg),
+    Const(ConstArg<'hir>),
 }
 
 impl GenericArg<'_> {
@@ -1354,9 +1354,11 @@ pub type Lit = Spanned<LitKind>;
 /// These are usually found nested inside types (e.g., array lengths)
 /// or expressions (e.g., repeat counts), and also used to define
 /// explicit discriminant values for enum variants.
-#[derive(Copy, Clone, PartialEq, Eq, Encodable, Debug, HashStable_Generic)]
-pub struct AnonConst {
+#[derive(Debug, HashStable_Generic)]
+pub struct AnonConst<'hir> {
     pub hir_id: HirId,
+    pub generics: Generics<'hir>,
+    pub generic_args: GenericArgs<'hir>,
     pub body: BodyId,
 }
 
@@ -1371,7 +1373,7 @@ pub struct Expr<'hir> {
 
 // `Expr` is used a lot. Make sure it doesn't unintentionally get bigger.
 #[cfg(target_arch = "x86_64")]
-rustc_data_structures::static_assert_size!(Expr<'static>, 72);
+rustc_data_structures::static_assert_size!(Expr<'static>, 144);
 
 impl Expr<'_> {
     pub fn precedence(&self) -> ExprPrecedence {
@@ -1519,7 +1521,7 @@ pub enum ExprKind<'hir> {
     /// A `box x` expression.
     Box(&'hir Expr<'hir>),
     /// Allow anonymous constants from an inline `const` block
-    ConstBlock(AnonConst),
+    ConstBlock(AnonConst<'hir>),
     /// An array (e.g., `[a, b, c, d]`).
     Array(&'hir [Expr<'hir>]),
     /// A function call.
@@ -1619,7 +1621,7 @@ pub enum ExprKind<'hir> {
     ///
     /// E.g., `[1; 5]`. The first expression is the element
     /// to be repeated; the second is the number of times to repeat it.
-    Repeat(&'hir Expr<'hir>, AnonConst),
+    Repeat(&'hir Expr<'hir>, AnonConst<'hir>),
 
     /// A suspension point for generators (i.e., `yield <expr>`).
     Yield(&'hir Expr<'hir>, YieldSource),
@@ -2064,7 +2066,7 @@ pub enum TyKind<'hir> {
     /// A variable length slice (i.e., `[T]`).
     Slice(&'hir Ty<'hir>),
     /// A fixed length array (i.e., `[T; n]`).
-    Array(&'hir Ty<'hir>, AnonConst),
+    Array(&'hir Ty<'hir>, AnonConst<'hir>),
     /// A raw pointer (i.e., `*const T` or `*mut T`).
     Ptr(MutTy<'hir>),
     /// A reference (i.e., `&'a T` or `&'a mut T`).
@@ -2090,7 +2092,7 @@ pub enum TyKind<'hir> {
     /// where `Bound` is a trait or a lifetime.
     TraitObject(&'hir [PolyTraitRef<'hir>], Lifetime),
     /// Unused for now.
-    Typeof(AnonConst),
+    Typeof(AnonConst<'hir>),
     /// `TyKind::Infer` means the type should be inferred instead of it having been
     /// specified. This can appear anywhere in a type.
     Infer,
@@ -2306,7 +2308,7 @@ pub struct Variant<'hir> {
     /// Fields and constructor id of the variant.
     pub data: VariantData<'hir>,
     /// Explicit discriminant (e.g., `Foo = 1`).
-    pub disr_expr: Option<AnonConst>,
+    pub disr_expr: Option<AnonConst<'hir>>,
     /// Span
     pub span: Span,
 }
@@ -2693,7 +2695,7 @@ pub enum Node<'hir> {
     ImplItem(&'hir ImplItem<'hir>),
     Variant(&'hir Variant<'hir>),
     Field(&'hir StructField<'hir>),
-    AnonConst(&'hir AnonConst),
+    AnonConst(&'hir AnonConst<'hir>),
     Expr(&'hir Expr<'hir>),
     Stmt(&'hir Stmt<'hir>),
     PathSegment(&'hir PathSegment<'hir>),

compiler/rustc_hir/src/intravisit.rs

@@ -362,7 +362,7 @@ pub trait Visitor<'v>: Sized {
     fn visit_pat(&mut self, p: &'v Pat<'v>) {
         walk_pat(self, p)
     }
-    fn visit_anon_const(&mut self, c: &'v AnonConst) {
+    fn visit_anon_const(&mut self, c: &'v AnonConst<'v>) {
         walk_anon_const(self, c)
     }
     fn visit_expr(&mut self, ex: &'v Expr<'v>) {
@@ -1089,7 +1089,7 @@ pub fn walk_stmt<'v, V: Visitor<'v>>(visitor: &mut V, statement: &'v Stmt<'v>) {
     }
 }
 
-pub fn walk_anon_const<'v, V: Visitor<'v>>(visitor: &mut V, constant: &'v AnonConst) {
+pub fn walk_anon_const<'v, V: Visitor<'v>>(visitor: &mut V, constant: &'v AnonConst<'v>) {
     visitor.visit_id(constant.hir_id);
     visitor.visit_nested_body(constant.body);
 }

compiler/rustc_hir_pretty/src/lib.rs

@@ -1083,7 +1083,7 @@ impl<'a> State<'a> {
         self.ann.post(self, AnnNode::Block(blk))
     }
 
-    pub fn print_anon_const(&mut self, constant: &hir::AnonConst) {
+    pub fn print_anon_const(&mut self, constant: &hir::AnonConst<'_>) {
         self.ann.nested(self, Nested::Body(constant.body))
     }
 
@@ -1132,14 +1132,14 @@ impl<'a> State<'a> {
         self.end()
     }
 
-    fn print_expr_anon_const(&mut self, anon_const: &hir::AnonConst) {
+    fn print_expr_anon_const(&mut self, anon_const: &hir::AnonConst<'_>) {
         self.ibox(INDENT_UNIT);
         self.s.word_space("const");
         self.print_anon_const(anon_const);
         self.end()
     }
 
-    fn print_expr_repeat(&mut self, element: &hir::Expr<'_>, count: &hir::AnonConst) {
+    fn print_expr_repeat(&mut self, element: &hir::Expr<'_>, count: &hir::AnonConst<'_>) {
         self.ibox(INDENT_UNIT);
         self.s.word("[");
         self.print_expr(element);

compiler/rustc_metadata/src/rmeta/encoder.rs

@@ -1780,7 +1780,7 @@ impl Visitor<'tcx> for EncodeContext<'a, 'tcx> {
         intravisit::walk_expr(self, ex);
         self.encode_info_for_expr(ex);
     }
-    fn visit_anon_const(&mut self, c: &'tcx AnonConst) {
+    fn visit_anon_const(&mut self, c: &'tcx AnonConst<'_>) {
         intravisit::walk_anon_const(self, c);
         let def_id = self.tcx.hir().local_def_id(c.hir_id);
         self.encode_info_for_anon_const(def_id);

compiler/rustc_middle/src/hir/map/collector.rs

@@ -441,11 +441,17 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {
         });
     }
 
-    fn visit_anon_const(&mut self, constant: &'hir AnonConst) {
-        self.insert(DUMMY_SP, constant.hir_id, Node::AnonConst(constant));
+    fn visit_anon_const(&mut self, constant: &'hir AnonConst<'hir>) {
+        debug_assert_eq!(
+            constant.hir_id.owner,
+            self.definitions.opt_hir_id_to_local_def_id(constant.hir_id).unwrap()
+        );
+        self.with_dep_node_owner(constant.hir_id.owner, constant, |this, hash| {
+            this.insert_with_hash(DUMMY_SP, constant.hir_id, Node::AnonConst(constant), hash);
 
-        self.with_parent(constant.hir_id, |this| {
-            intravisit::walk_anon_const(this, constant);
+            this.with_parent(constant.hir_id, |this| {
+                intravisit::walk_anon_const(this, constant);
+            })
         });
     }
 

compiler/rustc_middle/src/ty/consts.rs

@@ -3,6 +3,7 @@ use crate::mir::interpret::{LitToConstInput, Scalar};
 use crate::ty::subst::InternalSubsts;
 use crate::ty::{self, Ty, TyCtxt};
 use crate::ty::{ParamEnv, ParamEnvAnd};
+use crate::middle::resolve_lifetime as rl;
 use rustc_errors::ErrorReported;
 use rustc_hir as hir;
 use rustc_hir::def_id::LocalDefId;
@@ -41,15 +42,17 @@ impl<'tcx> Const<'tcx> {
 
         let hir_id = tcx.hir().local_def_id_to_hir_id(def.did);
 
-        let body_id = match tcx.hir().get(hir_id) {
-            hir::Node::AnonConst(ac) => ac.body,
+        let hir_ct = match tcx.hir().get(hir_id) {
+            hir::Node::AnonConst(ac) => ac,
             _ => span_bug!(
                 tcx.def_span(def.did.to_def_id()),
                 "from_anon_const can only process anonymous constants"
             ),
         };
 
-        let expr = &tcx.hir().body(body_id).value;
+        warn!(?hir_ct.generics, ?hir_ct.generic_args);
+
+        let expr = &tcx.hir().body(hir_ct.body).value;
 
         let ty = tcx.type_of(def.def_id_for_type_of());
 
@@ -97,11 +100,77 @@ impl<'tcx> Const<'tcx> {
                 let name = tcx.hir().name(hir_id);
                 ty::ConstKind::Param(ty::ParamConst::new(index, name))
             }
-            _ => ty::ConstKind::Unevaluated(
-                def.to_global(),
-                InternalSubsts::identity_for_item(tcx, def.did.to_def_id()),
-                None,
-            ),
+            _ => {
+                let generics = tcx.generics_of(def.did);
+                let substs = InternalSubsts::for_item(tcx, def.did.to_def_id(), |param, _| {
+                    if let Some(i) =
+                        (param.index as usize).checked_sub(generics.parent_count)
+                    {
+                        // Our own parameters are the resolved lifetimes.
+                        match param.kind {
+                            ty::GenericParamDefKind::Lifetime => {
+                                if let hir::GenericArg::Lifetime(lifetime) = &hir_ct.generic_args.args[i] {
+                                    let lifetime_name = |def_id| {
+                                        tcx.hir().name(tcx.hir().local_def_id_to_hir_id(def_id))
+                                    };
+
+                                    match tcx.named_region(lifetime.hir_id) {
+                                        Some(rl::Region::Static) => tcx.lifetimes.re_static,
+
+                                        Some(rl::Region::LateBound(debruijn, id, _)) => {
+                                            let name = lifetime_name(id.expect_local());
+                                            tcx.mk_region(ty::ReLateBound(
+                                                debruijn,
+                                                ty::BrNamed(id, name),
+                                            ))
+                                        }
+
+                                        Some(rl::Region::LateBoundAnon(debruijn, index)) => tcx
+                                            .mk_region(ty::ReLateBound(
+                                                debruijn,
+                                                ty::BrAnon(index),
+                                            )),
+
+                                        Some(rl::Region::EarlyBound(index, id, _)) => {
+                                            let name = lifetime_name(id.expect_local());
+                                            tcx.mk_region(ty::ReEarlyBound(ty::EarlyBoundRegion {
+                                                def_id: id,
+                                                index,
+                                                name,
+                                            }))
+                                        }
+
+                                        Some(rl::Region::Free(scope, id)) => {
+                                            let name = lifetime_name(id.expect_local());
+                                            tcx.mk_region(ty::ReFree(ty::FreeRegion {
+                                                scope,
+                                                bound_region: ty::BrNamed(id, name),
+                                            }))
+
+                                            // (*) -- not late-bound, won't change
+                                        }
+
+                                        None => {
+                                            tcx.sess.delay_span_bug(
+                                                lifetime.span,
+                                                "unelided lifetime in signature",
+                                            );
+                                            tcx.lifetimes.re_static
+                                        }
+                                    }
+                                } else {
+                                    bug!()
+                                }
+                            }.into(),
+                            _ => bug!(),
+                        }
+                    } else {
+                        tcx.mk_param_from_def(param)
+                    }
+                });
+
+                ty::ConstKind::Unevaluated(def.to_global(), substs, None)
+            }
         };
 
         tcx.mk_const(ty::Const { val, ty })

compiler/rustc_passes/src/check_const.rs

@@ -183,7 +183,7 @@ impl<'tcx> Visitor<'tcx> for CheckConstVisitor<'tcx> {
         NestedVisitorMap::OnlyBodies(self.tcx.hir())
     }
 
-    fn visit_anon_const(&mut self, anon: &'tcx hir::AnonConst) {
+    fn visit_anon_const(&mut self, anon: &'tcx hir::AnonConst<'_>) {
         let kind = Some(hir::ConstContext::Const);
         self.recurse_into(kind, None, |this| intravisit::walk_anon_const(this, anon));
     }