ast conv for adt ctors and fns

Author: BoxyUwU

compiler/rustc_const_eval/src/const_eval/eval_queries.rs

@@ -3,7 +3,7 @@ use std::borrow::Cow;
 
 use either::{Left, Right};
 
-use rustc_hir::def::DefKind;
+use rustc_hir::def::{CtorKind, DefKind};
 use rustc_middle::mir;
 use rustc_middle::mir::interpret::ErrorHandled;
 use rustc_middle::mir::pretty::display_allocation;
@@ -44,6 +44,7 @@ fn eval_body_using_ecx<'mir, 'tcx>(
                     | DefKind::AnonConst
                     | DefKind::InlineConst
                     | DefKind::AssocConst
+                    | DefKind::Ctor(_, CtorKind::Const)
             ),
         "Unexpected DefKind: {:?}",
         ecx.tcx.def_kind(cid.instance.def_id())

compiler/rustc_hir_analysis/src/astconv/mod.rs

@@ -3839,8 +3839,44 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
                             )
                         }
 
-                        DefKind::Ctor(_, _) => todo!(),
-                        DefKind::Fn => todo!(),
+                        DefKind::Fn | DefKind::Ctor(_, _) => {
+                            let path_segs = self.def_ids_for_value_path_segments(
+                                path.segments,
+                                None,
+                                def_kind,
+                                def_id,
+                                ast_ct.span(),
+                            );
+
+                            let generic_segs: FxHashSet<_> =
+                                path_segs.iter().map(|&PathSeg(_, index)| index).collect();
+                            self.prohibit_generics(
+                                path.segments.iter().enumerate().filter_map(|(n, segment)| {
+                                    if generic_segs.contains(&n) { Some(segment) } else { None }
+                                }),
+                                |_| {},
+                            );
+
+                            let seg = path_segs.last().unwrap();
+                            let arg_segment = &path.segments[seg.1];
+
+                            let substs =
+                                self.ast_path_substs_for_ty(ast_ct.span(), seg.0, arg_segment);
+
+                            match def_kind {
+                                DefKind::Fn | DefKind::Ctor(_, CtorKind::Fn) => {
+                                    ty::Const::zero_sized(
+                                        tcx,
+                                        tcx.type_of(def_id).subst(tcx, substs),
+                                    )
+                                }
+                                DefKind::Ctor(_, CtorKind::Const) => tcx.mk_const(
+                                    UnevaluatedConst { def: def_id, substs },
+                                    tcx.type_of(def_id).subst(tcx, substs),
+                                ),
+                                _ => unreachable!(),
+                            }
+                        }
 
                         DefKind::AssocFn | DefKind::AssocConst => {
                             unimplemented!("multi segment paths are not supported")

compiler/rustc_middle/src/ty/print/pretty.rs

@@ -1344,7 +1344,7 @@ pub trait PrettyPrinter<'tcx>:
         match ct.kind() {
             ty::ConstKind::Unevaluated(ty::UnevaluatedConst { def, substs }) => {
                 match self.tcx().def_kind(def) {
-                    DefKind::Const | DefKind::AssocConst => {
+                    DefKind::Ctor(_, CtorKind::Const) | DefKind::Const | DefKind::AssocConst => {
                         p!(print_value_path(def, substs))
                     }
                     DefKind::AnonConst => {

compiler/rustc_mir_transform/src/lib.rs

@@ -215,7 +215,7 @@ fn mir_keys(tcx: TyCtxt<'_>, (): ()) -> FxIndexSet<LocalDefId> {
     }
     impl<'tcx> Visitor<'tcx> for GatherCtors<'_> {
         fn visit_variant_data(&mut self, v: &'tcx hir::VariantData<'tcx>) {
-            if let hir::VariantData::Tuple(_, _, def_id) = *v {
+            if let hir::VariantData::Tuple(_, _, def_id) | hir::VariantData::Unit(_, def_id) = *v {
                 self.set.insert(def_id);
             }
             intravisit::walk_struct_def(self, v)

compiler/rustc_mir_transform/src/shim.rs

@@ -1,3 +1,4 @@
+use hir::def::{CtorKind, CtorOf, DefKind};
 use rustc_hir as hir;
 use rustc_hir::def_id::DefId;
 use rustc_hir::lang_items::LangItem;
@@ -834,27 +835,40 @@ fn build_call_shim<'tcx>(
 }
 
 pub fn build_adt_ctor(tcx: TyCtxt<'_>, ctor_id: DefId) -> Body<'_> {
-    debug_assert!(tcx.is_constructor(ctor_id));
-
     let param_env = tcx.param_env_reveal_all_normalized(ctor_id);
+    let span = tcx.def_span(ctor_id);
 
-    // Normalize the sig.
-    let sig = tcx
-        .fn_sig(ctor_id)
-        .subst_identity()
-        .no_bound_vars()
-        .expect("LBR in ADT constructor signature");
-    let sig = tcx.normalize_erasing_regions(param_env, sig);
+    let (local_decls, inputs, adt_ty) = match tcx.def_kind(ctor_id) {
+        DefKind::Ctor(_, CtorKind::Fn) => {
+            // Normalize the sig.
+            let sig = tcx
+                .fn_sig(ctor_id)
+                .subst_identity()
+                .no_bound_vars()
+                .expect("LBR in ADT constructor signature");
+            let sig = tcx.normalize_erasing_regions(param_env, sig);
+            debug!("build_ctor: ctor_id={:?} sig={:?}", ctor_id, sig);
+
+            (local_decls_for_sig(&sig, span), sig.inputs().len(), sig.output())
+        }
+        DefKind::Ctor(of, CtorKind::Const) => {
+            let mut ctor_id = ctor_id;
+            if let CtorOf::Variant = of {
+                ctor_id = tcx.parent(ctor_id);
+            }
+            let adt = tcx.parent(ctor_id);
+            let adt_ty =
+                tcx.normalize_erasing_regions(param_env, tcx.type_of(adt).subst_identity());
 
-    let ty::Adt(adt_def, substs) = sig.output().kind() else {
-        bug!("unexpected type for ADT ctor {:?}", sig.output());
+            let local_decls = std::iter::once(LocalDecl::new(adt_ty, span)).collect();
+            (local_decls, 0, adt_ty)
+        }
+        def_kind => bug!("ctor_id {:?} was expected to be a `DefKind::Ctor`", def_kind),
     };
 
-    debug!("build_ctor: ctor_id={:?} sig={:?}", ctor_id, sig);
-
-    let span = tcx.def_span(ctor_id);
-
-    let local_decls = local_decls_for_sig(&sig, span);
+    let ty::Adt(adt_def, substs) = adt_ty.kind() else {
+        bug!("unexpected type for ADT ctor {:?}", adt_ty);
+    };
 
     let source_info = SourceInfo::outermost(span);
 
@@ -891,13 +905,7 @@ pub fn build_adt_ctor(tcx: TyCtxt<'_>, ctor_id: DefId) -> Body<'_> {
     };
 
     let source = MirSource::item(ctor_id);
-    let body = new_body(
-        source,
-        IndexVec::from_elem_n(start_block, 1),
-        local_decls,
-        sig.inputs().len(),
-        span,
-    );
+    let body = new_body(source, IndexVec::from_elem_n(start_block, 1), local_decls, inputs, span);
 
     crate::pass_manager::dump_mir_for_phase_change(tcx, &body);