impl astconv for ConstArgKind

BoxyUwU · BoxyUwU · commit 603f39156172 · 2023-05-11T17:59:16.000+01:00
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
@@ -2393,6 +2393,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     }
 
     fn lower_array_length(&mut self, c: &AnonConst) -> hir::ArrayLen {
+        // FIXME(const_arg_kind)
         match c.value.kind {
             ExprKind::Underscore => {
                 if self.tcx.features().generic_arg_infer {
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
@@ -259,6 +259,13 @@ impl<'hir> ConstArg<'hir> {
             ConstArgKind::Param(_, qpath) => qpath.span(),
         }
     }
+
+    pub fn hir_id(&self) -> HirId {
+        match self.kind {
+            ConstArgKind::AnonConst(_, ct) => ct.hir_id,
+            ConstArgKind::Param(id, _) => id,
+        }
+    }
 }
 
 #[derive(Clone, Copy, Debug, HashStable_Generic)]
@@ -295,10 +302,7 @@ impl GenericArg<'_> {
         match self {
             GenericArg::Lifetime(l) => l.hir_id,
             GenericArg::Type(t) => t.hir_id,
-            GenericArg::Const(c) => match c.kind {
-                ConstArgKind::AnonConst(_, ct) => ct.hir_id,
-                ConstArgKind::Param(id, _) => id,
-            },
+            GenericArg::Const(c) => c.hir_id(),
             GenericArg::Infer(i) => i.hir_id,
         }
     }
diff --git a/compiler/rustc_hir_analysis/src/astconv/generics.rs b/compiler/rustc_hir_analysis/src/astconv/generics.rs
@@ -108,16 +108,14 @@ fn generic_arg_mismatch_err(
             }
         }
         (GenericArg::Const(cnst), GenericParamDefKind::Type { .. })
-            if matches!(cnst.kind, hir::ConstArgKind::AnonConst(_, _)) =>
+            if matches!(cnst.kind, hir::ConstArgKind::Param(_, _)) =>
         {
-            // FIXME(const_arg_kind)
-            let body = match cnst.kind {
-                hir::ConstArgKind::AnonConst(_, cnst) => tcx.hir().body(cnst.body),
+            let path = match cnst.kind {
+                hir::ConstArgKind::Param(_, path) => path,
                 _ => unreachable!(),
             };
 
-            if let rustc_hir::ExprKind::Path(rustc_hir::QPath::Resolved(_, path)) = body.value.kind
-            {
+            if let rustc_hir::QPath::Resolved(_, path) = path {
                 if let Res::Def(DefKind::Fn { .. }, id) = path.res {
                     err.help(format!("`{}` is a function item, not a type", tcx.item_name(id)));
                     err.help("function item types cannot be named directly");
diff --git a/compiler/rustc_hir_analysis/src/astconv/mod.rs b/compiler/rustc_hir_analysis/src/astconv/mod.rs
@@ -15,6 +15,7 @@ use crate::errors::{
 };
 use crate::middle::resolve_bound_vars as rbv;
 use crate::require_c_abi_if_c_variadic;
+use hir::def::CtorKind;
 use rustc_ast::TraitObjectSyntax;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_errors::{
@@ -34,7 +35,9 @@ use rustc_middle::middle::stability::AllowUnstable;
 use rustc_middle::ty::fold::FnMutDelegate;
 use rustc_middle::ty::subst::{self, GenericArgKind, InternalSubsts, SubstsRef};
 use rustc_middle::ty::GenericParamDefKind;
-use rustc_middle::ty::{self, Const, IsSuggestable, Ty, TyCtxt, TypeVisitableExt};
+use rustc_middle::ty::{
+    self, Const, IsSuggestable, Ty, TyCtxt, TypeVisitableExt, UnevaluatedConst,
+};
 use rustc_middle::ty::{DynKind, ToPredicate};
 use rustc_session::lint::builtin::{AMBIGUOUS_ASSOCIATED_ITEMS, BARE_TRAIT_OBJECTS};
 use rustc_span::edit_distance::find_best_match_for_name;
@@ -449,15 +452,9 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
                     (&GenericParamDefKind::Type { has_default, .. }, GenericArg::Infer(inf)) => {
                         handle_ty_args(has_default, &inf.to_ty())
                     }
-                    (GenericParamDefKind::Const { .. }, GenericArg::Const(ct)) => match ct.kind {
-                        // FIXME(const_arg_kind)
-                        hir::ConstArgKind::AnonConst(_, ct) => {
-                            let did = ct.def_id;
-                            tcx.feed_anon_const_type(did, tcx.type_of(param.def_id));
-                            ty::Const::from_anon_const(tcx, did).into()
-                        }
-                        hir::ConstArgKind::Param(_, _) => todo!(),
-                    },
+                    (GenericParamDefKind::Const { .. }, GenericArg::Const(ct)) => {
+                        self.astconv.ast_const_to_const(ct, param.def_id).into()
+                    }
                     (&GenericParamDefKind::Const { .. }, hir::GenericArg::Infer(inf)) => {
                         let ty = tcx
                             .at(self.span)
@@ -3757,6 +3754,129 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
             }
         }
     }
+
+    #[instrument(level = "debug", skip(self), ret)]
+    pub fn ast_const_to_const(
+        &self,
+        ast_ct: &hir::ConstArg<'_>,
+        param_def_id: DefId,
+    ) -> Const<'tcx> {
+        let tcx = self.tcx();
+
+        match ast_ct.kind {
+            hir::ConstArgKind::AnonConst(_, ct) => {
+                tcx.feed_anon_const_type(ct.def_id, tcx.type_of(param_def_id));
+                Const::from_anon_const(tcx, ct.def_id)
+            }
+            hir::ConstArgKind::Param(_, path) => match path {
+                hir::QPath::Resolved(_, path) => match path.res {
+                    Res::Def(def_kind, def_id) => match def_kind {
+                        DefKind::ConstParam => {
+                            self.prohibit_generics(path.segments.iter(), |_| {});
+                            let param_ty = tcx.type_of(def_id).subst_identity();
+
+                            match tcx.named_bound_var(ast_ct.hir_id()) {
+                                Some(rbv::ResolvedArg::EarlyBound(_)) => {
+                                    // Find the name and index of the const parameter by indexing the generics of
+                                    // the parent item and construct a `ParamConst`.
+                                    let item_def_id = tcx.parent(def_id);
+                                    let generics = tcx.generics_of(item_def_id);
+                                    let index = generics.param_def_id_to_index[&def_id];
+                                    let name = tcx.item_name(def_id);
+                                    tcx.mk_const(ty::ParamConst::new(index, name), param_ty)
+                                }
+                                Some(rbv::ResolvedArg::LateBound(debruijn, index, _)) => tcx
+                                    .mk_const(
+                                        ty::ConstKind::Bound(
+                                            debruijn,
+                                            ty::BoundVar::from_u32(index),
+                                        ),
+                                        param_ty,
+                                    ),
+                                Some(rbv::ResolvedArg::Error(guar)) => {
+                                    tcx.const_error_with_guaranteed(param_ty, guar)
+                                }
+                                arg => bug!(
+                                    "unexpected bound var resolution for {:?}: {arg:?}",
+                                    ast_ct.hir_id()
+                                ),
+                            }
+                        }
+                        DefKind::Const => {
+                            let (last, prev) = path.segments.split_last().unwrap();
+                            self.prohibit_generics(prev.iter(), |_| {});
+                            let substs = self.ast_path_substs_for_ty(ast_ct.span(), def_id, last);
+                            tcx.mk_const(
+                                UnevaluatedConst { def: def_id, substs },
+                                tcx.type_of(def_id).subst(tcx, substs),
+                            )
+                        }
+
+                        DefKind::Ctor(_, _) => todo!(),
+                        DefKind::Fn => todo!(),
+
+                        DefKind::AssocFn | DefKind::AssocConst => {
+                            unimplemented!("multi segment paths are not supported")
+                        }
+
+                        // FIXME(const_arg_kind): somewhere else should be emitting this
+                        DefKind::Static(_) => {
+                            let e = tcx
+                                .sess
+                                .span_err(ast_ct.span(), "no static access in consts allowed");
+                            tcx.const_error_with_guaranteed(tcx.ty_error(e), e)
+                        }
+
+                        DefKind::OpaqueTy
+                        | DefKind::InlineConst
+                        | DefKind::ForeignMod
+                        | DefKind::AnonConst
+                        | DefKind::Macro(_)
+                        | DefKind::ExternCrate
+                        | DefKind::Use
+                        | DefKind::LifetimeParam
+                        | DefKind::Struct
+                        | DefKind::Union
+                        | DefKind::Enum
+                        | DefKind::Variant
+                        | DefKind::Trait
+                        | DefKind::TyAlias
+                        | DefKind::ForeignTy
+                        | DefKind::TraitAlias
+                        | DefKind::AssocTy
+                        | DefKind::TyParam
+                        | DefKind::ImplTraitPlaceholder
+                        | DefKind::Field
+                        | DefKind::GlobalAsm
+                        | DefKind::Impl { .. }
+                        | DefKind::Closure
+                        | DefKind::Mod
+                        | DefKind::Generator => bug!("unexpected path res of const arg"),
+                    },
+
+                    Res::SelfCtor(_) => todo!(),
+
+                    Res::Err
+                    | Res::Local(_)
+                    | Res::ToolMod
+                    | Res::NonMacroAttr(_)
+                    | Res::PrimTy(_)
+                    | Res::SelfTyParam { .. }
+                    | Res::SelfTyAlias { .. } => {
+                        let e = tcx.sess.delay_span_bug(
+                            ast_ct.span(),
+                            format!("unexpected path res {:?} of const arg {:?}", path.res, ast_ct),
+                        );
+                        tcx.const_error_with_guaranteed(tcx.ty_error(e), e)
+                    }
+                },
+                hir::QPath::TypeRelative(_, _) => {
+                    bug!("multi-segment path consts are not yet supported")
+                }
+                hir::QPath::LangItem(_, _, _) => unimplemented!(),
+            },
+        }
+    }
 }
 
 pub trait InferCtxtExt<'tcx> {
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
@@ -404,6 +404,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     }
 
     pub fn array_length_to_const(&self, length: &hir::ArrayLen) -> ty::Const<'tcx> {
+        // FIXME(const_arg_kind)
         match length {
             &hir::ArrayLen::Infer(_, span) => self.ct_infer(self.tcx.types.usize, None, span),
             hir::ArrayLen::Body(anon_const) => {
@@ -420,21 +421,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         ast_c: &hir::ConstArg<'_>,
         param_def_id: DefId,
     ) -> ty::Const<'tcx> {
-        // FIXME(const_arg_kind)
-        match ast_c.kind {
-            hir::ConstArgKind::AnonConst(_, ast_c) => {
-                let did = ast_c.def_id;
-                self.tcx.feed_anon_const_type(did, self.tcx.type_of(param_def_id));
-                let c = ty::Const::from_anon_const(self.tcx, did);
-                self.register_wf_obligation(
-                    c.into(),
-                    self.tcx.hir().span(ast_c.hir_id),
-                    ObligationCauseCode::WellFormed(None),
-                );
-                c
-            }
-            hir::ConstArgKind::Param(_, _) => todo!(),
-        }
+        let ct = self.astconv().ast_const_to_const(ast_c, param_def_id);
+        self.register_wf_obligation(ct.into(), ast_c.span(), ObligationCauseCode::WellFormed(None));
+        ct
     }
 
     // If the type given by the user has free regions, save it for later, since
diff --git a/compiler/rustc_middle/src/ty/consts.rs b/compiler/rustc_middle/src/ty/consts.rs
@@ -1,9 +1,7 @@
-use crate::middle::resolve_bound_vars as rbv;
 use crate::mir::interpret::LitToConstInput;
 use crate::ty::{self, InternalSubsts, ParamEnv, ParamEnvAnd, Ty, TyCtxt};
 use rustc_data_structures::intern::Interned;
 use rustc_hir as hir;
-use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::LocalDefId;
 use rustc_macros::HashStable;
 use std::fmt;
@@ -51,7 +49,7 @@ impl<'tcx> Const<'tcx> {
         self.0.kind
     }
 
-    /// Literals and const generic parameters are eagerly converted to a constant, everything else
+    /// Literals are eagerly converted to a constant, everything else
     /// becomes `Unevaluated`.
     #[instrument(skip(tcx), level = "debug")]
     pub fn from_anon_const(tcx: TyCtxt<'tcx>, def: LocalDefId) -> Self {
@@ -68,7 +66,7 @@ impl<'tcx> Const<'tcx> {
 
         let ty = tcx.type_of(def).no_bound_vars().expect("const parameter types cannot be generic");
 
-        match Self::try_eval_lit_or_param(tcx, ty, expr) {
+        match Self::try_eval_lit(tcx, ty, expr) {
             Some(v) => v,
             None => tcx.mk_const(
                 ty::UnevaluatedConst {
@@ -81,12 +79,8 @@ impl<'tcx> Const<'tcx> {
     }
 
     #[instrument(skip(tcx), level = "debug")]
-    fn try_eval_lit_or_param(
-        tcx: TyCtxt<'tcx>,
-        ty: Ty<'tcx>,
-        expr: &'tcx hir::Expr<'tcx>,
-    ) -> Option<Self> {
-        // Unwrap a block, so that e.g. `{ P }` is recognised as a parameter. Const arguments
+    fn try_eval_lit(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, expr: &'tcx hir::Expr<'tcx>) -> Option<Self> {
+        // Unwrap a block, so that e.g. `{ 1 }` is recognised as a literal. Const arguments
         // currently have to be wrapped in curly brackets, so it's necessary to special-case.
         let expr = match &expr.kind {
             hir::ExprKind::Block(block, _) if block.stmts.is_empty() && block.expr.is_some() => {
@@ -119,37 +113,7 @@ impl<'tcx> Const<'tcx> {
                 }
             }
         }
-
-        match expr.kind {
-            hir::ExprKind::Path(hir::QPath::Resolved(
-                _,
-                &hir::Path { res: Res::Def(DefKind::ConstParam, def_id), .. },
-            )) => {
-                // Use the type from the param's definition, since we can resolve it,
-                // not the expected parameter type from WithOptConstParam.
-                let param_ty = tcx.type_of(def_id).subst_identity();
-                match tcx.named_bound_var(expr.hir_id) {
-                    Some(rbv::ResolvedArg::EarlyBound(_)) => {
-                        // Find the name and index of the const parameter by indexing the generics of
-                        // the parent item and construct a `ParamConst`.
-                        let item_def_id = tcx.parent(def_id);
-                        let generics = tcx.generics_of(item_def_id);
-                        let index = generics.param_def_id_to_index[&def_id];
-                        let name = tcx.item_name(def_id);
-                        Some(tcx.mk_const(ty::ParamConst::new(index, name), param_ty))
-                    }
-                    Some(rbv::ResolvedArg::LateBound(debruijn, index, _)) => Some(tcx.mk_const(
-                        ty::ConstKind::Bound(debruijn, ty::BoundVar::from_u32(index)),
-                        param_ty,
-                    )),
-                    Some(rbv::ResolvedArg::Error(guar)) => {
-                        Some(tcx.const_error_with_guaranteed(param_ty, guar))
-                    }
-                    arg => bug!("unexpected bound var resolution for {:?}: {arg:?}", expr.hir_id),
-                }
-            }
-            _ => None,
-        }
+        None
     }
 
     /// Panics if self.kind != ty::ConstKind::Value

Original file line number	Diff line number	Diff line change
`@@ -2393,6 +2393,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {`
`2393`	`2393`	`}`
`2394`	`2394`
`2395`	`2395`	`fn lower_array_length(&mut self, c: &AnonConst) -> hir::ArrayLen {`
	`2396`	`+ // FIXME(const_arg_kind)`
`2396`	`2397`	`match c.value.kind {`
`2397`	`2398`	`ExprKind::Underscore => {`
`2398`	`2399`	`if self.tcx.features().generic_arg_infer {`
Original file line number	Diff line number	Diff line change
`@@ -259,6 +259,13 @@ impl<'hir> ConstArg<'hir> {`
`259`	`259`	`ConstArgKind::Param(_, qpath) => qpath.span(),`
`260`	`260`	`}`
`261`	`261`	`}`
	`262`	`+`
	`263`	`+ pub fn hir_id(&self) -> HirId {`
	`264`	`+ match self.kind {`
	`265`	`+ ConstArgKind::AnonConst(_, ct) => ct.hir_id,`
	`266`	`+ ConstArgKind::Param(id, _) => id,`
	`267`	`+ }`
	`268`	`+ }`
`262`	`269`	`}`
`263`	`270`
`264`	`271`	`#[derive(Clone, Copy, Debug, HashStable_Generic)]`
`@@ -295,10 +302,7 @@ impl GenericArg<'_> {`
`295`	`302`	`match self {`
`296`	`303`	`GenericArg::Lifetime(l) => l.hir_id,`
`297`	`304`	`GenericArg::Type(t) => t.hir_id,`
`298`		`- GenericArg::Const(c) => match c.kind {`
`299`		`- ConstArgKind::AnonConst(_, ct) => ct.hir_id,`
`300`		`- ConstArgKind::Param(id, _) => id,`
`301`		`- },`
	`305`	`+ GenericArg::Const(c) => c.hir_id(),`
`302`	`306`	`GenericArg::Infer(i) => i.hir_id,`
`303`	`307`	`}`
`304`	`308`	`}`