Recurse into refs when checking impls of ConstParamTy on refs

Author: sjwang05

compiler/rustc_hir_analysis/messages.ftl

@@ -78,6 +78,11 @@ hir_analysis_const_impl_for_non_const_trait =
     .note = marking a trait with `#[const_trait]` ensures all default method bodies are `const`
     .adding = adding a non-const method body in the future would be a breaking change
 
+hir_analysis_const_param_ty_impl_on_infringing_referee =
+    the trait `ConstParamTy` cannot be implemented for this type
+    .label = the trait `ConstParamTy` is not implemented for this {$def_descr}
+    .suggestion = consider annotating this {$def_descr} with `#[derive(ConstParamTy)]`
+
 hir_analysis_const_param_ty_impl_on_non_adt =
     the trait `ConstParamTy` may not be implemented for this type
     .label = type is not a structure or enumeration

compiler/rustc_hir_analysis/src/check/wfcheck.rs

@@ -987,6 +987,10 @@ fn check_param_wf(tcx: TyCtxt<'_>, param: &hir::GenericParam<'_>) -> Result<(),
 
                         ty_is_local(ty)
                     }
+                    // Same as above.
+                    Err(ConstParamTyImplementationError::InfringingReferee(def_id)) => {
+                        def_id.is_local()
+                    }
                     // Implments `ConstParamTy`, suggest adding the feature to enable.
                     Ok(..) => true,
                 };

compiler/rustc_hir_analysis/src/coherence/builtin.rs

@@ -118,6 +118,15 @@ fn visit_implementation_of_const_param_ty(tcx: TyCtxt<'_>, impl_did: LocalDefId)
         Err(ConstParamTyImplementationError::NotAnAdtOrBuiltinAllowed) => {
             tcx.dcx().emit_err(errors::ConstParamTyImplOnNonAdt { span });
         }
+        Err(ConstParamTyImplementationError::InfringingReferee(def_id)) => {
+            let def_span = tcx.def_span(def_id);
+            tcx.dcx().emit_err(errors::ConstParamTyImplOnInfringingReferee {
+                span,
+                def_span,
+                def_descr: tcx.def_descr(def_id),
+                sugg: def_id.is_local().then_some(def_span.shrink_to_lo()),
+            });
+        }
     }
 }
 

compiler/rustc_hir_analysis/src/errors.rs

@@ -227,6 +227,22 @@ pub struct ConstParamTyImplOnNonAdt {
     pub span: Span,
 }
 
+#[derive(Diagnostic)]
+#[diag(hir_analysis_const_param_ty_impl_on_infringing_referee)]
+pub struct ConstParamTyImplOnInfringingReferee {
+    #[primary_span]
+    pub span: Span,
+    #[label]
+    pub def_span: Span,
+    pub def_descr: &'static str,
+    #[suggestion(
+        applicability = "maybe-incorrect",
+        style = "verbose",
+        code = "#[derive(ConstParamTy)]\n"
+    )]
+    pub sugg: Option<Span>,
+}
+
 #[derive(Diagnostic)]
 #[diag(hir_analysis_trait_object_declared_with_no_traits, code = "E0224")]
 pub struct TraitObjectDeclaredWithNoTraits {

compiler/rustc_trait_selection/src/traits/misc.rs

@@ -5,6 +5,7 @@ use crate::traits::{self, ObligationCause, ObligationCtxt};
 use hir::LangItem;
 use rustc_data_structures::fx::FxIndexSet;
 use rustc_hir as hir;
+use rustc_hir::def_id::DefId;
 use rustc_infer::infer::canonical::Canonical;
 use rustc_infer::infer::{RegionResolutionError, TyCtxtInferExt};
 use rustc_infer::traits::query::NoSolution;
@@ -22,6 +23,7 @@ pub enum CopyImplementationError<'tcx> {
 
 pub enum ConstParamTyImplementationError<'tcx> {
     InfrigingFields(Vec<(&'tcx ty::FieldDef, Ty<'tcx>, InfringingFieldsReason<'tcx>)>),
+    InfringingReferee(DefId),
     NotAnAdtOrBuiltinAllowed,
 }
 
@@ -92,6 +94,49 @@ pub fn type_allowed_to_implement_const_param_ty<'tcx>(
     parent_cause: ObligationCause<'tcx>,
 ) -> Result<(), ConstParamTyImplementationError<'tcx>> {
     let (adt, args) = match self_type.kind() {
+        // Special case for impls like `impl ConstParamTy for &Foo`, where
+        // Foo doesn't `impl ConstParamTy`. These kinds of impls aren't caught
+        // by coherence checking since `core`'s impl is restricted to &T where
+        // T: ConstParamTy.
+        // `has_concrete_skeleton()` avoids reporting `core`'s blanket impl.
+        &ty::Ref(.., ty, hir::Mutability::Not) if ty.peel_refs().has_concrete_skeleton() => {
+            let ty = ty.peel_refs();
+            type_allowed_to_implement_const_param_ty(tcx, param_env, ty, parent_cause)?;
+            // Check the ty behind the ref impls `ConstParamTy` itself. This additional
+            // logic is needed when checking refs because we need to check not only if
+            // all fields implement ConstParamTy, but also that the type itself implements
+            // ConstParamTy. Simply recursing into the ref only checks the former.
+            if !ty.references_error()
+                && let &ty::Adt(adt, _) = ty.kind()
+            {
+                let adt_did = adt.did();
+                let adt_span = tcx.def_span(adt_did);
+                let trait_did = tcx.require_lang_item(hir::LangItem::ConstParamTy, Some(adt_span));
+
+                let infcx = tcx.infer_ctxt().build();
+                let ocx = traits::ObligationCtxt::new(&infcx);
+
+                let ty = ocx.normalize(&ObligationCause::dummy_with_span(adt_span), param_env, ty);
+                let norm_errs = ocx.select_where_possible();
+                if !norm_errs.is_empty() || ty.references_error() {
+                    return Ok(());
+                }
+
+                ocx.register_bound(
+                    ObligationCause::dummy_with_span(adt_span),
+                    param_env,
+                    ty,
+                    trait_did,
+                );
+                let errs = ocx.select_all_or_error();
+                if !errs.is_empty() {
+                    return Err(ConstParamTyImplementationError::InfringingReferee(adt_did));
+                }
+            }
+
+            return Ok(());
+        }
+
         // `core` provides these impls.
         ty::Uint(_)
         | ty::Int(_)

tests/ui/const-generics/adt_const_params/const_param_ty_impl_bad_referee.rs

@@ -0,0 +1,26 @@
+#![feature(adt_const_params)]
+#![allow(incomplete_features)]
+
+use std::marker::ConstParamTy;
+
+// #112124
+
+struct Foo;
+
+impl ConstParamTy for &Foo {}
+//~^ ERROR the trait `ConstParamTy` cannot be implemented for this type
+
+// #119299 (ICE)
+
+#[derive(Eq, PartialEq)]
+struct Wrapper(*const i32, usize);
+
+impl ConstParamTy for &Wrapper {}
+//~^ ERROR the trait `ConstParamTy` cannot be implemented for this type
+
+const fn foo<const S: &'static Wrapper>() {}
+
+fn main() {
+    const FOO: Wrapper = Wrapper(&42 as *const i32, 42);
+    foo::<{&FOO}>();
+}

tests/ui/const-generics/adt_const_params/const_param_ty_impl_bad_referee.stderr

@@ -0,0 +1,27 @@
+error: the trait `ConstParamTy` cannot be implemented for this type
+  --> $DIR/const_param_ty_impl_bad_referee.rs:10:23
+   |
+LL | struct Foo;
+   | ---------- the trait `ConstParamTy` is not implemented for this struct
+LL |
+LL | impl ConstParamTy for &Foo {}
+   |                       ^^^^
+   |
+help: consider annotating this struct with `#[derive(ConstParamTy)]`
+   |
+LL + #[derive(ConstParamTy)]
+LL | struct Foo;
+   |
+
+error[E0204]: the trait `ConstParamTy` cannot be implemented for this type
+  --> $DIR/const_param_ty_impl_bad_referee.rs:18:23
+   |
+LL | struct Wrapper(*const i32, usize);
+   |                ---------- this field does not implement `ConstParamTy`
+LL |
+LL | impl ConstParamTy for &Wrapper {}
+   |                       ^^^^^^^^
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0204`.

tests/ui/const-generics/issues/issue-63322-forbid-dyn.min.stderr

@@ -5,7 +5,6 @@ LL | fn test<const T: &'static dyn A>() {
    |                  ^^^^^^^^^^^^^^
    |
    = note: the only supported types are integers, `bool` and `char`
-   = help: add `#![feature(adt_const_params)]` to the crate attributes to enable more complex and user defined types
 
 error: aborting due to 1 previous error