Fix ICE in pointer layout for DSTs with bogus Sized impls

A bogus `impl<T: ?Sized> Sized for T {}` (rejected as E0322) was
processed by the new trait solver (`-Znext-solver=globally`), making
DSTs like `[T]` appear sized. This caused `*const [T]` to receive a
thin-pointer (Scalar) layout instead of a fat-pointer (ScalarPair)
layout. When const evaluation then performed an array-to-slice unsizing
coercion and tried to write a ScalarPair value to a Scalar-layout place,
it triggered an ICE:

  "invalid immediate for given destination place: value ScalarPair(...)
   does not match ABI Scalar(...)"

The fix adds a structural cross-check in the pointer layout computation:
after `is_sized` returns true, we verify via `struct_tail_for_codegen`
(which is purely structural and unaffected by bogus trait impls) that
the pointee tail is not a known DST kind (Slice/Str/Dynamic). If it is,
we skip the thin-pointer early return and fall through to compute the
correct fat-pointer layout.

Author: GokhanKabar

compiler/rustc_ty_utils/src/layout.rs

@@ -414,7 +414,21 @@ fn layout_of_uncached<'tcx>(
             }
 
             if pointee.is_sized(tcx, cx.typing_env) {
-                return Ok(tcx.mk_layout(LayoutData::scalar(cx, data_ptr)));
+                // Guard against bogus `impl Sized` declarations (e.g.,
+                // `impl<T: ?Sized> Sized for T {}`), which are rejected with E0322
+                // but can still be processed by the trait solver in erroneous code.
+                // Such impls make DSTs like `[T]` appear sized, causing pointer
+                // layout to be computed as a thin pointer (Scalar) when it should
+                // be a fat pointer (ScalarPair). This mismatch causes an ICE during
+                // const evaluation. We cross-check using the structural tail: if it
+                // is a known DST kind, the pointer must be fat regardless of what
+                // the Sized trait says.
+                let tail = tcx.struct_tail_for_codegen(pointee, cx.typing_env);
+                if !matches!(tail.kind(), ty::Slice(_) | ty::Str | ty::Dynamic(..)) {
+                    return Ok(tcx.mk_layout(LayoutData::scalar(cx, data_ptr)));
+                }
+                // The structural tail is a DST — `is_sized` is unreliable here.
+                // Fall through to compute the correct fat-pointer layout below.
             }
 
             let metadata = if let Some(metadata_def_id) = tcx.lang_items().metadata_type() {

tests/ui/traits/next-solver/dont-ice-on-bogus-sized-impl-in-const-block.rs

@@ -0,0 +1,22 @@
+//@ compile-flags: -Znext-solver=globally
+
+// A bogus `impl Sized for T` (rejected with E0322) used to cause an ICE when
+// the new trait solver processed it and made DSTs like `[T]` appear sized. This
+// caused pointer layout to be computed as a thin-pointer (Scalar) instead of a
+// fat-pointer (ScalarPair), and const evaluation of unsafe pointer arithmetic
+// inside a `const {}` block would then ICE with:
+//   "invalid immediate for given destination place: value ScalarPair(...) does
+//    not match ABI Scalar(...)"
+
+impl<'a, T: ?Sized> Sized for T {}
+//~^ ERROR explicit impls for the `Sized` trait are not permitted
+//~| ERROR type parameter `T` must be used as the type parameter for some local type
+
+fn main() {
+    const {
+        unsafe {
+            let value = [1, 2];
+            let _ptr = value.as_ptr().add(2);
+        }
+    }
+}

tests/ui/traits/next-solver/dont-ice-on-bogus-sized-impl-in-const-block.stderr

@@ -0,0 +1,19 @@
+error[E0322]: explicit impls for the `Sized` trait are not permitted
+  --> $DIR/dont-ice-on-bogus-sized-impl-in-const-block.rs:11:1
+   |
+LL | impl<'a, T: ?Sized> Sized for T {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ impl of `Sized` not allowed
+
+error[E0210]: type parameter `T` must be used as the type parameter for some local type (e.g., `MyStruct<T>`)
+  --> $DIR/dont-ice-on-bogus-sized-impl-in-const-block.rs:11:10
+   |
+LL | impl<'a, T: ?Sized> Sized for T {}
+   |          ^ type parameter `T` must be used as the type parameter for some local type
+   |
+   = note: implementing a foreign trait is only possible if at least one of the types for which it is implemented is local
+   = note: only traits defined in the current crate can be implemented for a type parameter
+
+error: aborting due to 2 previous errors
+
+Some errors have detailed explanations: E0210, E0322.
+For more information about an error, try `rustc --explain E0210`.