Auto merge of #150843 - fmease:dyn-ace, r=BoxyUwU

mGCA: Make trait object types with type-level associated consts dyn compatible

Under feature `min_generic_const_args` (mGCA) (#132980), render traits with non-parametrized type-level associated constants (i.e., `#[type_const]` ones) dyn compatible but force the user to specify all type-level associated consts in the trait object type via bindings (either directly, via supertrait bounds and/or behind trait aliases) just like associated types, their sibling.

Fixes #130300 (feature request).
Fixes #136063 (bug).
Fixes #137260 (bug).
Fixes #137514 (bug).

While I'm accounting for most illegal `Self` references via const projections & params, I'm intentionally ignoring RUST-123140 (and duplicates) in this PR which is to be tackled some other time.

Additional context: Crate `rustc-demangle` had to be updated to fix v0 demangling. I've patched it in PR rust-lang/rustc-demangle#87 which was was released in version 0.1.27 via PR rust-lang/rustc-demangle#88.

Author: bors

Cargo.lock

@@ -3356,9 +3356,9 @@ dependencies = [
 
 [[package]]
 name = "rustc-demangle"
-version = "0.1.26"
+version = "0.1.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56f7d92ca342cea22a06f2121d944b4fd82af56988c270852495420f961d4ace"
+checksum = "b50b8869d9fc858ce7266cce0194bd74df58b9d0e3f6df3a9fc8eb470d95c09d"
 
 [[package]]
 name = "rustc-hash"

compiler/rustc_codegen_cranelift/src/debuginfo/mod.rs

@@ -242,7 +242,7 @@ impl DebugContext {
         let generics = tcx.generics_of(enclosing_fn_def_id);
         let args = instance.args.truncate_to(tcx, generics);
 
-        type_names::push_generic_params(
+        type_names::push_generic_args(
             tcx,
             tcx.normalize_erasing_regions(ty::TypingEnv::fully_monomorphized(), args),
             &mut name,

compiler/rustc_codegen_llvm/src/debuginfo/mod.rs

@@ -456,7 +456,7 @@ impl<'ll, 'tcx> DebugInfoCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
         let generics = tcx.generics_of(enclosing_fn_def_id);
         let args = instance.args.truncate_to(tcx, generics);
 
-        type_names::push_generic_params(
+        type_names::push_generic_args(
             tcx,
             tcx.normalize_erasing_regions(self.typing_env(), args),
             &mut name,

compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs

@@ -109,14 +109,14 @@ fn push_debuginfo_type_name<'tcx>(
                     ty_and_layout,
                     &|output, visited| {
                         push_item_name(tcx, def.did(), true, output);
-                        push_generic_params_internal(tcx, args, output, visited);
+                        push_generic_args_internal(tcx, args, output, visited);
                     },
                     output,
                     visited,
                 );
             } else {
                 push_item_name(tcx, def.did(), qualified, output);
-                push_generic_params_internal(tcx, args, output, visited);
+                push_generic_args_internal(tcx, args, output, visited);
             }
         }
         ty::Tuple(component_types) => {
@@ -253,19 +253,18 @@ fn push_debuginfo_type_name<'tcx>(
                 );
                 push_item_name(tcx, principal.def_id, qualified, output);
                 let principal_has_generic_params =
-                    push_generic_params_internal(tcx, principal.args, output, visited);
+                    push_generic_args_internal(tcx, principal.args, output, visited);
 
                 let projection_bounds: SmallVec<[_; 4]> = trait_data
                     .projection_bounds()
                     .map(|bound| {
                         let ExistentialProjection { def_id: item_def_id, term, .. } =
                             tcx.instantiate_bound_regions_with_erased(bound);
-                        // FIXME(mgca): allow for consts here
-                        (item_def_id, term.expect_type())
+                        (item_def_id, term)
                     })
                     .collect();
 
-                if projection_bounds.len() != 0 {
+                if !projection_bounds.is_empty() {
                     if principal_has_generic_params {
                         // push_generic_params_internal() above added a `>` but we actually
                         // want to add more items to that list, so remove that again...
@@ -279,17 +278,17 @@ fn push_debuginfo_type_name<'tcx>(
                         output.push('<');
                     }
 
-                    for (item_def_id, ty) in projection_bounds {
+                    for (item_def_id, term) in projection_bounds {
                         if cpp_like_debuginfo {
                             output.push_str("assoc$<");
                             push_item_name(tcx, item_def_id, false, output);
                             push_arg_separator(cpp_like_debuginfo, output);
-                            push_debuginfo_type_name(tcx, ty, true, output, visited);
+                            push_debuginfo_term_name(tcx, term, true, output, visited);
                             push_close_angle_bracket(cpp_like_debuginfo, output);
                         } else {
                             push_item_name(tcx, item_def_id, false, output);
                             output.push('=');
-                            push_debuginfo_type_name(tcx, ty, true, output, visited);
+                            push_debuginfo_term_name(tcx, term, true, output, visited);
                         }
                         push_arg_separator(cpp_like_debuginfo, output);
                     }
@@ -533,7 +532,7 @@ pub fn compute_debuginfo_vtable_name<'tcx>(
             tcx.normalize_erasing_regions(ty::TypingEnv::fully_monomorphized(), trait_ref);
         push_item_name(tcx, trait_ref.def_id, true, &mut vtable_name);
         visited.clear();
-        push_generic_params_internal(tcx, trait_ref.args, &mut vtable_name, &mut visited);
+        push_generic_args_internal(tcx, trait_ref.args, &mut vtable_name, &mut visited);
     } else {
         vtable_name.push('_');
     }
@@ -631,7 +630,13 @@ fn push_unqualified_item_name(
     };
 }
 
-fn push_generic_params_internal<'tcx>(
+pub fn push_generic_args<'tcx>(tcx: TyCtxt<'tcx>, args: GenericArgsRef<'tcx>, output: &mut String) {
+    let _prof = tcx.prof.generic_activity("compute_debuginfo_type_name");
+    let mut visited = FxHashSet::default();
+    push_generic_args_internal(tcx, args, output, &mut visited);
+}
+
+fn push_generic_args_internal<'tcx>(
     tcx: TyCtxt<'tcx>,
     args: GenericArgsRef<'tcx>,
     output: &mut String,
@@ -646,14 +651,10 @@ fn push_generic_params_internal<'tcx>(
 
     output.push('<');
 
-    for type_parameter in args {
-        match type_parameter {
-            GenericArgKind::Type(type_parameter) => {
-                push_debuginfo_type_name(tcx, type_parameter, true, output, visited);
-            }
-            GenericArgKind::Const(ct) => {
-                push_const_param(tcx, ct, output);
-            }
+    for arg in args {
+        match arg {
+            GenericArgKind::Type(ty) => push_debuginfo_type_name(tcx, ty, true, output, visited),
+            GenericArgKind::Const(ct) => push_debuginfo_const_name(tcx, ct, output),
             other => bug!("Unexpected non-erasable generic: {:?}", other),
         }
 
@@ -665,7 +666,20 @@ fn push_generic_params_internal<'tcx>(
     true
 }
 
-fn push_const_param<'tcx>(tcx: TyCtxt<'tcx>, ct: ty::Const<'tcx>, output: &mut String) {
+fn push_debuginfo_term_name<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    term: ty::Term<'tcx>,
+    qualified: bool,
+    output: &mut String,
+    visited: &mut FxHashSet<Ty<'tcx>>,
+) {
+    match term.kind() {
+        ty::TermKind::Ty(ty) => push_debuginfo_type_name(tcx, ty, qualified, output, visited),
+        ty::TermKind::Const(ct) => push_debuginfo_const_name(tcx, ct, output),
+    }
+}
+
+fn push_debuginfo_const_name<'tcx>(tcx: TyCtxt<'tcx>, ct: ty::Const<'tcx>, output: &mut String) {
     match ct.kind() {
         ty::ConstKind::Param(param) => {
             write!(output, "{}", param.name)
@@ -715,16 +729,6 @@ fn push_const_param<'tcx>(tcx: TyCtxt<'tcx>, ct: ty::Const<'tcx>, output: &mut S
     .unwrap();
 }
 
-pub fn push_generic_params<'tcx>(
-    tcx: TyCtxt<'tcx>,
-    args: GenericArgsRef<'tcx>,
-    output: &mut String,
-) {
-    let _prof = tcx.prof.generic_activity("compute_debuginfo_type_name");
-    let mut visited = FxHashSet::default();
-    push_generic_params_internal(tcx, args, output, &mut visited);
-}
-
 fn push_closure_or_coroutine_name<'tcx>(
     tcx: TyCtxt<'tcx>,
     def_id: DefId,
@@ -767,7 +771,7 @@ fn push_closure_or_coroutine_name<'tcx>(
     // FIXME(async_closures): This is probably not going to be correct w.r.t.
     // multiple coroutine flavors. Maybe truncate to (parent + 1)?
     let args = args.truncate_to(tcx, generics);
-    push_generic_params_internal(tcx, args, output, visited);
+    push_generic_args_internal(tcx, args, output, visited);
 }
 
 fn push_close_angle_bracket(cpp_like_debuginfo: bool, output: &mut String) {

compiler/rustc_hir_analysis/messages.ftl

@@ -165,6 +165,11 @@ hir_analysis_drop_impl_reservation = reservation `Drop` impls are not supported
 hir_analysis_duplicate_precise_capture = cannot capture parameter `{$name}` twice
     .label = parameter captured again here
 
+hir_analysis_dyn_trait_assoc_item_binding_mentions_self =
+    {$kind} binding in trait object type mentions `Self`
+    .label = contains a mention of `Self`
+    .binding_label = this binding mentions `Self`
+
 hir_analysis_eii_with_generics =
     `{$impl_name}` cannot have generic parameters other than lifetimes
     .label = required by this attribute
@@ -330,37 +335,18 @@ hir_analysis_manual_implementation =
 hir_analysis_method_should_return_future = method should be `async` or return a future, but it is synchronous
     .note = this method is `async` so it expects a future to be returned
 
-hir_analysis_missing_one_of_trait_item = not all trait items implemented, missing one of: `{$missing_items_msg}`
-    .label = missing one of `{$missing_items_msg}` in implementation
-    .note = required because of this annotation
-
-hir_analysis_missing_trait_item = not all trait items implemented, missing: `{$missing_items_msg}`
-    .label = missing `{$missing_items_msg}` in implementation
-
-hir_analysis_missing_trait_item_label = `{$item}` from trait
-
-hir_analysis_missing_trait_item_suggestion = implement the missing item: `{$snippet}`
-
-hir_analysis_missing_trait_item_unstable = not all trait items implemented, missing: `{$missing_item_name}`
-    .note = default implementation of `{$missing_item_name}` is unstable
-    .some_note = use of unstable library feature `{$feature}`: {$reason}
-    .none_note = use of unstable library feature `{$feature}`
-
-hir_analysis_missing_type_params =
-    the type {$parameterCount ->
+hir_analysis_missing_generic_params =
+    the {$descr} {$parameterCount ->
         [one] parameter
         *[other] parameters
     } {$parameters} must be explicitly specified
-    .label = type {$parameterCount ->
+    .label = {$descr} {$parameterCount ->
         [one] parameter
         *[other] parameters
     } {$parameters} must be specified for this
-    .suggestion = set the type {$parameterCount ->
+    .suggestion = explicitly specify the {$descr} {$parameterCount ->
         [one] parameter
         *[other] parameters
-    } to the desired {$parameterCount ->
-        [one] type
-        *[other] types
     }
     .no_suggestion_label = missing {$parameterCount ->
         [one] reference
@@ -372,7 +358,23 @@ hir_analysis_missing_type_params =
     } `Self`, the {$parameterCount ->
         [one] parameter
         *[other] parameters
-    } must be specified on the object type
+    } must be specified on the trait object type
+
+hir_analysis_missing_one_of_trait_item = not all trait items implemented, missing one of: `{$missing_items_msg}`
+    .label = missing one of `{$missing_items_msg}` in implementation
+    .note = required because of this annotation
+
+hir_analysis_missing_trait_item = not all trait items implemented, missing: `{$missing_items_msg}`
+    .label = missing `{$missing_items_msg}` in implementation
+
+hir_analysis_missing_trait_item_label = `{$item}` from trait
+
+hir_analysis_missing_trait_item_suggestion = implement the missing item: `{$snippet}`
+
+hir_analysis_missing_trait_item_unstable = not all trait items implemented, missing: `{$missing_item_name}`
+    .note = default implementation of `{$missing_item_name}` is unstable
+    .some_note = use of unstable library feature `{$feature}`: {$reason}
+    .none_note = use of unstable library feature `{$feature}`
 
 hir_analysis_no_variant_named = no variant named `{$ident}` found for enum `{$ty}`
 
@@ -481,9 +483,6 @@ hir_analysis_self_in_impl_self =
     `Self` is not valid in the self type of an impl block
     .note = replace `Self` with a different type
 
-hir_analysis_self_in_type_alias = `Self` is not allowed in type aliases
-    .label = `Self` is only available in impls, traits, and concrete type definitions
-
 hir_analysis_self_ty_not_captured = `impl Trait` must mention the `Self` type of the trait in `use<...>`
     .label = `Self` type parameter is implicitly captured by this `impl Trait`
     .note = currently, all type parameters are required to be mentioned in the precise captures list

compiler/rustc_hir_analysis/src/check/compare_impl_item.rs

@@ -1960,7 +1960,7 @@ fn compare_generic_param_kinds<'tcx>(
     trait_item: ty::AssocItem,
     delay: bool,
 ) -> Result<(), ErrorGuaranteed> {
-    assert_eq!(impl_item.as_tag(), trait_item.as_tag());
+    assert_eq!(impl_item.tag(), trait_item.tag());
 
     let ty_const_params_of = |def_id| {
         tcx.generics_of(def_id).own_params.iter().filter(|param| {