Fix review comments

Author: mu001999

compiler/rustc_hir_analysis/src/collect/type_of.rs

@@ -354,7 +354,11 @@ fn anon_const_type_of<'tcx>(icx: &ItemCtxt<'tcx>, def_id: LocalDefId) -> Ty<'tcx
             hir_id: arg_hir_id,
             kind: ConstArgKind::Anon(&AnonConst { hir_id: anon_hir_id, .. }),
             ..
-        }) if anon_hir_id == hir_id => const_arg_anon_type_of(icx, arg_hir_id, span),
+        }) if anon_hir_id == hir_id => Ty::new_error_with_message(
+            tcx,
+            span,
+            "`type_of` called on const argument's anon const before the const argument was lowered",
+        ),
 
         Node::Variant(Variant { disr_expr: Some(e), .. }) if e.hir_id == hir_id => {
             tcx.adt_def(tcx.hir_get_parent_item(hir_id)).repr().discr_type().to_ty(tcx)
@@ -374,42 +378,6 @@ fn anon_const_type_of<'tcx>(icx: &ItemCtxt<'tcx>, def_id: LocalDefId) -> Ty<'tcx
     }
 }
 
-fn const_arg_anon_type_of<'tcx>(icx: &ItemCtxt<'tcx>, arg_hir_id: HirId, span: Span) -> Ty<'tcx> {
-    use hir::*;
-    use rustc_middle::ty::Ty;
-
-    let tcx = icx.tcx;
-
-    match tcx.parent_hir_node(arg_hir_id) {
-        // Array length const arguments do not have `type_of` fed as there is never a corresponding
-        // generic parameter definition.
-        Node::Ty(&hir::Ty { kind: TyKind::Array(_, ref constant), .. })
-        | Node::Expr(&Expr { kind: ExprKind::Repeat(_, ref constant), .. })
-            if constant.hir_id == arg_hir_id =>
-        {
-            tcx.types.usize
-        }
-
-        Node::TyPat(pat) => {
-            let node = match tcx.parent_hir_node(pat.hir_id) {
-                // Or patterns can be nested one level deep
-                Node::TyPat(p) => tcx.parent_hir_node(p.hir_id),
-                other => other,
-            };
-            let hir::TyKind::Pat(ty, _) = node.expect_ty().kind else { bug!() };
-            icx.lower_ty(ty)
-        }
-
-        // This is not a `bug!` as const arguments in path segments that did not resolve to anything
-        // will result in `type_of` never being fed.
-        _ => Ty::new_error_with_message(
-            tcx,
-            span,
-            "`type_of` called on const argument's anon const before the const argument was lowered",
-        ),
-    }
-}
-
 fn infer_placeholder_type<'tcx>(
     cx: &dyn HirTyLowerer<'tcx>,
     def_id: LocalDefId,

compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs

@@ -1283,6 +1283,8 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                                             )
                                         });
 
+                                        // FIXME(mgca): code duplication with other places we lower
+                                        // the rhs' of associated const bindings
                                         let ty = projection_term.map_bound(|alias| {
                                             tcx.type_of(alias.def_id).instantiate(tcx, alias.args)
                                         });

src/librustdoc/clean/mod.rs

@@ -468,19 +468,13 @@ fn clean_middle_term<'tcx>(
 fn clean_hir_term<'tcx>(
     assoc_item: Option<DefId>,
     term: &hir::Term<'tcx>,
-    span: rustc_span::Span,
     cx: &mut DocContext<'tcx>,
 ) -> Term {
     match term {
         hir::Term::Ty(ty) => Term::Type(clean_ty(ty, cx)),
         hir::Term::Const(c) => {
-            let ty = if let Some(assoc_item) = assoc_item {
-                // FIXME(generic_const_items): this should instantiate with the alias item's args
-                cx.tcx.type_of(assoc_item).instantiate_identity()
-            } else {
-                Ty::new_error_with_message(cx.tcx, span, "cannot find the associated constant")
-            };
-
+            // FIXME(generic_const_items): this should instantiate with the alias item's args
+            let ty = cx.tcx.type_of(assoc_item.unwrap()).instantiate_identity();
             let ct = lower_const_arg_for_rustdoc(cx.tcx, c, ty);
             Term::Constant(clean_middle_const(ty::Binder::dummy(ct), cx))
         }
@@ -3164,9 +3158,7 @@ fn clean_assoc_item_constraint<'tcx>(
                     .associated_items(trait_did)
                     .find_by_ident_and_kind(cx.tcx, constraint.ident, assoc_tag, trait_did)
                     .map(|item| item.def_id);
-                AssocItemConstraintKind::Equality {
-                    term: clean_hir_term(assoc_item, term, constraint.span, cx),
-                }
+                AssocItemConstraintKind::Equality { term: clean_hir_term(assoc_item, term, cx) }
             }
             hir::AssocItemConstraintKind::Bound { bounds } => AssocItemConstraintKind::Bound {
                 bounds: bounds.iter().filter_map(|b| clean_generic_bound(b, cx)).collect(),