Auto merge of #143183 - GuillaumeGomez:rollup-g60lr91, r=GuillaumeGomez

Rollup of 4 pull requests

Successful merges:

 - rust-lang/rust#142078 (Add SIMD funnel shift and round-to-even intrinsics)
 - rust-lang/rust#142214 (`tests/ui`: A New Order [9/N])
 - rust-lang/rust#142417 (`tests/ui`: A New Order [12/N])
 - rust-lang/rust#143030 (Fix suggestion spans inside macros for the `unused_must_use` lint)

r? `@ghost`
`@rustbot` modify labels: rollup

43 files changed, 555 insertions, 245 deletions

diff --git a/tests/ui/empty-allocation-non-null.rs b/tests/ui/allocator/empty-alloc-nonnull-guarantee.rs
index 45035a42a5f..f4081306c77 100644
--- a/tests/ui/empty-allocation-non-null.rs
+++ b/tests/ui/allocator/empty-alloc-nonnull-guarantee.rs
@@ -1,3 +1,7 @@
+//! Check that the default global Rust allocator produces non-null Box allocations for ZSTs.
+//!
+//! See https://github.com/rust-lang/rust/issues/11998
+
 //@ run-pass
 
 pub fn main() {
diff --git a/tests/ui/associated-types/unconstrained-lifetime-assoc-type.rs b/tests/ui/associated-types/unconstrained-lifetime-assoc-type.rs
new file mode 100644
index 00000000000..2c4af7da921
--- /dev/null
+++ b/tests/ui/associated-types/unconstrained-lifetime-assoc-type.rs
@@ -0,0 +1,21 @@
+//! Regression test for issue #22077
+//! lifetime parameters must be constrained in associated type definitions
+
+trait Fun {
+    type Output;
+    fn call<'x>(&'x self) -> Self::Output;
+}
+
+struct Holder {
+    x: String,
+}
+
+impl<'a> Fun for Holder {
+    //~^ ERROR E0207
+    type Output = &'a str;
+    fn call<'b>(&'b self) -> &'b str {
+        &self.x[..]
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/impl-unused-rps-in-assoc-type.stderr b/tests/ui/associated-types/unconstrained-lifetime-assoc-type.stderr
index ef61fa4be48..15d0820c895 100644
--- a/tests/ui/impl-unused-rps-in-assoc-type.stderr
+++ b/tests/ui/associated-types/unconstrained-lifetime-assoc-type.stderr
@@ -1,5 +1,5 @@
 error[E0207]: the lifetime parameter `'a` is not constrained by the impl trait, self type, or predicates
-  --> $DIR/impl-unused-rps-in-assoc-type.rs:11:6
+  --> $DIR/unconstrained-lifetime-assoc-type.rs:13:6
    |
 LL | impl<'a> Fun for Holder {
    |      ^^ unconstrained lifetime parameter
diff --git a/tests/ui/inline-disallow-on-variant.rs b/tests/ui/attributes/inline-attribute-enum-variant-error.rs
index d92a4e8cc8d..305b285d2a4 100644
--- a/tests/ui/inline-disallow-on-variant.rs
+++ b/tests/ui/attributes/inline-attribute-enum-variant-error.rs
@@ -1,3 +1,5 @@
+//! Test that #[inline] attribute cannot be applied to enum variants
+
 enum Foo {
     #[inline]
     //~^ ERROR attribute should be applied
diff --git a/tests/ui/inline-disallow-on-variant.stderr b/tests/ui/attributes/inline-attribute-enum-variant-error.stderr
index 255f6bc6a19..a4564d8f722 100644
--- a/tests/ui/inline-disallow-on-variant.stderr
+++ b/tests/ui/attributes/inline-attribute-enum-variant-error.stderr
@@ -1,5 +1,5 @@
 error[E0518]: attribute should be applied to function or closure
-  --> $DIR/inline-disallow-on-variant.rs:2:5
+  --> $DIR/inline-attribute-enum-variant-error.rs:4:5
    |
 LL |     #[inline]
    |     ^^^^^^^^^
diff --git a/tests/ui/attributes/inline-main.rs b/tests/ui/attributes/inline-main.rs
new file mode 100644
index 00000000000..7181ee19b67
--- /dev/null
+++ b/tests/ui/attributes/inline-main.rs
@@ -0,0 +1,6 @@
+//! Test that #[inline(always)] can be applied to main function
+
+//@ run-pass
+
+#[inline(always)]
+fn main() {}
diff --git a/tests/ui/diverging-fn-tail-35849.rs b/tests/ui/diverging-fn-tail-35849.rs
deleted file mode 100644
index f21ce2973e9..00000000000
--- a/tests/ui/diverging-fn-tail-35849.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-fn assert_sizeof() -> ! {
-    unsafe {
-        ::std::mem::transmute::<f64, [u8; 8]>(panic!())
-            //~^ ERROR mismatched types
-    }
-}
-
-fn main() { }
diff --git a/tests/ui/early-ret-binop-add.rs b/tests/ui/early-ret-binop-add.rs
deleted file mode 100644
index 3fec66f35fb..00000000000
--- a/tests/ui/early-ret-binop-add.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-//@ run-pass
-
-#![allow(dead_code)]
-#![allow(unreachable_code)]
-
-use std::ops::Add;
-
-fn wsucc<T:Add<Output=T> + Copy>(n: T) -> T { n + { return n } }
-
-pub fn main() { }
diff --git a/tests/ui/elide-errors-on-mismatched-tuple.rs b/tests/ui/elide-errors-on-mismatched-tuple.rs
deleted file mode 100644
index 7d87b0a7756..00000000000
--- a/tests/ui/elide-errors-on-mismatched-tuple.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-// Hide irrelevant E0277 errors (#50333)
-
-trait T {}
-
-struct A;
-impl T for A {}
-impl A {
-    fn new() -> Self {
-        Self {}
-    }
-}
-
-fn main() {
-    let (a, b, c) = (A::new(), A::new()); // This tuple is 2 elements, should be three
-    //~^ ERROR mismatched types
-    let ts: Vec<&dyn T> = vec![&a, &b, &c];
-    // There is no E0277 error above, as `a`, `b` and `c` are `TyErr`
-}
diff --git a/tests/ui/elided-test.rs b/tests/ui/elided-test.rs
deleted file mode 100644
index 2bedc25e17b..00000000000
--- a/tests/ui/elided-test.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-// Since we're not compiling a test runner this function should be elided
-// and the build will fail because main doesn't exist
-#[test]
-fn main() {
-} //~ ERROR `main` function not found in crate `elided_test`
diff --git a/tests/ui/elided-test.stderr b/tests/ui/elided-test.stderr
deleted file mode 100644
index 7aebe5d8264..00000000000
--- a/tests/ui/elided-test.stderr
+++ /dev/null
@@ -1,9 +0,0 @@
-error[E0601]: `main` function not found in crate `elided_test`
-  --> $DIR/elided-test.rs:5:2
-   |
-LL | }
-   |  ^ consider adding a `main` function to `$DIR/elided-test.rs`
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0601`.
diff --git a/tests/ui/else-if.rs b/tests/ui/else-if.rs
deleted file mode 100644
index 2161b28c58c..00000000000
--- a/tests/ui/else-if.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-//@ run-pass
-
-pub fn main() {
-    if 1 == 2 {
-        assert!((false));
-    } else if 2 == 3 {
-        assert!((false));
-    } else if 3 == 4 { assert!((false)); } else { assert!((true)); }
-    if 1 == 2 { assert!((false)); } else if 2 == 2 { assert!((true)); }
-    if 1 == 2 {
-        assert!((false));
-    } else if 2 == 2 {
-        if 1 == 1 {
-            assert!((true));
-        } else { if 2 == 1 { assert!((false)); } else { assert!((false)); } }
-    }
-    if 1 == 2 {
-        assert!((false));
-    } else { if 1 == 2 { assert!((false)); } else { assert!((true)); } }
-}
diff --git a/tests/ui/expr/early-return-in-binop.rs b/tests/ui/expr/early-return-in-binop.rs
new file mode 100644
index 00000000000..389d25210f7
--- /dev/null
+++ b/tests/ui/expr/early-return-in-binop.rs
@@ -0,0 +1,19 @@
+//! Test early return within binary operation expressions
+
+//@ run-pass
+
+#![allow(dead_code)]
+#![allow(unreachable_code)]
+
+use std::ops::Add;
+
+/// Function that performs addition with an early return in the right operand
+fn add_with_early_return<T: Add<Output = T> + Copy>(n: T) -> T {
+    n + { return n }
+}
+
+pub fn main() {
+    // Test with different numeric types to ensure generic behavior works
+    let _result1 = add_with_early_return(42i32);
+    let _result2 = add_with_early_return(3.14f64);
+}
diff --git a/tests/ui/generics/unconstrained-type-params-inherent-impl.rs b/tests/ui/generics/unconstrained-type-params-inherent-impl.rs
new file mode 100644
index 00000000000..c971de0d1f2
--- /dev/null
+++ b/tests/ui/generics/unconstrained-type-params-inherent-impl.rs
@@ -0,0 +1,32 @@
+//! Test for unconstrained type parameters in inherent implementations
+
+struct MyType;
+
+struct MyType1<T>(T);
+
+trait Bar {
+    type Out;
+}
+
+impl<T> MyType {
+    //~^ ERROR the type parameter `T` is not constrained
+    // T is completely unused - this should fail
+}
+
+impl<T> MyType1<T> {
+    // OK: T is used in the self type `MyType1<T>`
+}
+
+impl<T, U> MyType1<T> {
+    //~^ ERROR the type parameter `U` is not constrained
+    // T is used in self type, but U is unconstrained - this should fail
+}
+
+impl<T, U> MyType1<T>
+where
+    T: Bar<Out = U>,
+{
+    // OK: T is used in self type, U is constrained through the where clause
+}
+
+fn main() {}
diff --git a/tests/ui/impl-unused-tps-inherent.stderr b/tests/ui/generics/unconstrained-type-params-inherent-impl.stderr
index 43f63cf968c..19b02ad396c 100644
--- a/tests/ui/impl-unused-tps-inherent.stderr
+++ b/tests/ui/generics/unconstrained-type-params-inherent-impl.stderr
@@ -1,14 +1,14 @@
 error[E0207]: the type parameter `T` is not constrained by the impl trait, self type, or predicates
-  --> $DIR/impl-unused-tps-inherent.rs:9:6
+  --> $DIR/unconstrained-type-params-inherent-impl.rs:11:6
    |
 LL | impl<T> MyType {
    |      ^ unconstrained type parameter
 
 error[E0207]: the type parameter `U` is not constrained by the impl trait, self type, or predicates
-  --> $DIR/impl-unused-tps-inherent.rs:17:8
+  --> $DIR/unconstrained-type-params-inherent-impl.rs:20:9
    |
-LL | impl<T,U> MyType1<T> {
-   |        ^ unconstrained type parameter
+LL | impl<T, U> MyType1<T> {
+   |         ^ unconstrained type parameter
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/impl-unused-rps-in-assoc-type.rs b/tests/ui/impl-unused-rps-in-assoc-type.rs
deleted file mode 100644
index ea41997a698..00000000000
--- a/tests/ui/impl-unused-rps-in-assoc-type.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-// Test that lifetime parameters must be constrained if they appear in
-// an associated type def'n. Issue #22077.
-
-trait Fun {
-    type Output;
-    fn call<'x>(&'x self) -> Self::Output;
-}
-
-struct Holder { x: String }
-
-impl<'a> Fun for Holder { //~ ERROR E0207
-    type Output = &'a str;
-    fn call<'b>(&'b self) -> &'b str {
-        &self.x[..]
-    }
-}
-
-fn main() { }
diff --git a/tests/ui/impl-unused-tps-inherent.rs b/tests/ui/impl-unused-tps-inherent.rs
deleted file mode 100644
index 83a228e551a..00000000000
--- a/tests/ui/impl-unused-tps-inherent.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-struct MyType;
-
-struct MyType1<T>(T);
-
-trait Bar {
-    type Out;
-}
-
-impl<T> MyType {
-    //~^ ERROR  the type parameter `T` is not constrained
-}
-
-impl<T> MyType1<T> {
-    // OK, T is used in `Foo<T>`.
-}
-
-impl<T,U> MyType1<T> {
-    //~^ ERROR  the type parameter `U` is not constrained
-}
-
-impl<T,U> MyType1<T> where T: Bar<Out=U> {
-    // OK, T is used in `Foo<T>`.
-}
-
-fn main() { }
diff --git a/tests/ui/implicit-method-bind.rs b/tests/ui/implicit-method-bind.rs
deleted file mode 100644
index 5e27516a89a..00000000000
--- a/tests/ui/implicit-method-bind.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-fn main() {
-    let _f = 10i32.abs; //~ ERROR attempted to take value of method
-}
diff --git a/tests/ui/implicit-method-bind.stderr b/tests/ui/implicit-method-bind.stderr
deleted file mode 100644
index e9357113f36..00000000000
--- a/tests/ui/implicit-method-bind.stderr
+++ /dev/null
@@ -1,14 +0,0 @@
-error[E0615]: attempted to take value of method `abs` on type `i32`
-  --> $DIR/implicit-method-bind.rs:2:20
-   |
-LL |     let _f = 10i32.abs;
-   |                    ^^^ method, not a field
-   |
-help: use parentheses to call the method
-   |
-LL |     let _f = 10i32.abs();
-   |                       ++
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0615`.
diff --git a/tests/ui/double-type-import.rs b/tests/ui/imports/duplicate-use-bindings.rs
index 6b1eb65d5ae..8cec23ea732 100644
--- a/tests/ui/double-type-import.rs
+++ b/tests/ui/imports/duplicate-use-bindings.rs
@@ -1,3 +1,5 @@
+//! Test that duplicate use bindings in same namespace produce error
+
 mod foo {
     pub use self::bar::X;
     use self::bar::X;
diff --git a/tests/ui/double-type-import.stderr b/tests/ui/imports/duplicate-use-bindings.stderr
index 8a8fe05ec19..1d4f1fc82db 100644
--- a/tests/ui/double-type-import.stderr
+++ b/tests/ui/imports/duplicate-use-bindings.stderr
@@ -1,5 +1,5 @@
 error[E0252]: the name `X` is defined multiple times
-  --> $DIR/double-type-import.rs:3:9
+  --> $DIR/duplicate-use-bindings.rs:5:9
    |
 LL |     pub use self::bar::X;
    |             ------------ previous import of the type `X` here
diff --git a/tests/ui/inlined-main.rs b/tests/ui/inlined-main.rs
deleted file mode 100644
index 731ac0dddca..00000000000
--- a/tests/ui/inlined-main.rs
+++ /dev/null
@@ -1,4 +0,0 @@
-//@ run-pass
-
-#[inline(always)]
-fn main() {}
diff --git a/tests/ui/lint/unused/must-use-macros.fixed b/tests/ui/lint/unused/must-use-macros.fixed
new file mode 100644
index 00000000000..609d0c6392b
--- /dev/null
+++ b/tests/ui/lint/unused/must-use-macros.fixed
@@ -0,0 +1,60 @@
+// Makes sure the suggestions of the `unused_must_use` lint are not inside
+//
+// See <https://github.com/rust-lang/rust/issues/143025>
+
+//@ check-pass
+//@ run-rustfix
+
+#![expect(unused_macros)]
+#![warn(unused_must_use)]
+
+fn main() {
+    {
+        macro_rules! cmp {
+            ($a:tt, $b:tt) => {
+                $a == $b
+            };
+        }
+
+        // FIXME(Urgau): For some unknown reason the spans we get are not
+        // recorded to be from any expansions, preventing us from either
+        // suggesting in front of the macro or not at all.
+        // cmp!(1, 1);
+    }
+
+    {
+        macro_rules! cmp {
+            ($a:ident, $b:ident) => {
+                $a == $b
+            }; //~^ WARN unused comparison that must be used
+        }
+
+        let a = 1;
+        let b = 1;
+        let _ = cmp!(a, b);
+        //~^ SUGGESTION let _
+    }
+
+    {
+        macro_rules! cmp {
+            ($a:expr, $b:expr) => {
+                $a == $b
+            }; //~^ WARN unused comparison that must be used
+        }
+
+        let _ = cmp!(1, 1);
+        //~^ SUGGESTION let _
+    }
+
+    {
+        macro_rules! cmp {
+            ($a:tt, $b:tt) => {
+                $a.eq(&$b)
+            };
+        }
+
+        let _ = cmp!(1, 1);
+        //~^ WARN unused return value
+        //~| SUGGESTION let _
+    }
+}
diff --git a/tests/ui/lint/unused/must-use-macros.rs b/tests/ui/lint/unused/must-use-macros.rs
new file mode 100644
index 00000000000..63e246ed374
--- /dev/null
+++ b/tests/ui/lint/unused/must-use-macros.rs
@@ -0,0 +1,60 @@
+// Makes sure the suggestions of the `unused_must_use` lint are not inside
+//
+// See <https://github.com/rust-lang/rust/issues/143025>
+
+//@ check-pass
+//@ run-rustfix
+
+#![expect(unused_macros)]
+#![warn(unused_must_use)]
+
+fn main() {
+    {
+        macro_rules! cmp {
+            ($a:tt, $b:tt) => {
+                $a == $b
+            };
+        }
+
+        // FIXME(Urgau): For some unknown reason the spans we get are not
+        // recorded to be from any expansions, preventing us from either
+        // suggesting in front of the macro or not at all.
+        // cmp!(1, 1);
+    }
+
+    {
+        macro_rules! cmp {
+            ($a:ident, $b:ident) => {
+                $a == $b
+            }; //~^ WARN unused comparison that must be used
+        }
+
+        let a = 1;
+        let b = 1;
+        cmp!(a, b);
+        //~^ SUGGESTION let _
+    }
+
+    {
+        macro_rules! cmp {
+            ($a:expr, $b:expr) => {
+                $a == $b
+            }; //~^ WARN unused comparison that must be used
+        }
+
+        cmp!(1, 1);
+        //~^ SUGGESTION let _
+    }
+
+    {
+        macro_rules! cmp {
+            ($a:tt, $b:tt) => {
+                $a.eq(&$b)
+            };
+        }
+
+        cmp!(1, 1);
+        //~^ WARN unused return value
+        //~| SUGGESTION let _
+    }
+}
diff --git a/tests/ui/lint/unused/must-use-macros.stderr b/tests/ui/lint/unused/must-use-macros.stderr
new file mode 100644
index 00000000000..2ad174e10b5
--- /dev/null
+++ b/tests/ui/lint/unused/must-use-macros.stderr
@@ -0,0 +1,48 @@
+warning: unused comparison that must be used
+  --> $DIR/must-use-macros.rs:28:17
+   |
+LL |                 $a == $b
+   |                 ^^^^^^^^ the comparison produces a value
+...
+LL |         cmp!(a, b);
+   |         ---------- in this macro invocation
+   |
+note: the lint level is defined here
+  --> $DIR/must-use-macros.rs:9:9
+   |
+LL | #![warn(unused_must_use)]
+   |         ^^^^^^^^^^^^^^^
+   = note: this warning originates in the macro `cmp` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: use `let _ = ...` to ignore the resulting value
+   |
+LL |         let _ = cmp!(a, b);
+   |         +++++++
+
+warning: unused comparison that must be used
+  --> $DIR/must-use-macros.rs:41:17
+   |
+LL |                 $a == $b
+   |                 ^^^^^^^^ the comparison produces a value
+...
+LL |         cmp!(1, 1);
+   |         ---------- in this macro invocation
+   |
+   = note: this warning originates in the macro `cmp` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: use `let _ = ...` to ignore the resulting value
+   |
+LL |         let _ = cmp!(1, 1);
+   |         +++++++
+
+warning: unused return value of `std::cmp::PartialEq::eq` that must be used
+  --> $DIR/must-use-macros.rs:56:9
+   |
+LL |         cmp!(1, 1);
+   |         ^^^^^^^^^^
+   |
+help: use `let _ = ...` to ignore the resulting value
+   |
+LL |         let _ = cmp!(1, 1);
+   |         +++++++
+
+warning: 3 warnings emitted
+
diff --git a/tests/ui/macros/must-use-in-macro-55516.stderr b/tests/ui/macros/must-use-in-macro-55516.stderr
index 7bf4aaab51c..b93d40d7e5a 100644
--- a/tests/ui/macros/must-use-in-macro-55516.stderr
+++ b/tests/ui/macros/must-use-in-macro-55516.stderr
@@ -7,7 +7,10 @@ LL |     write!(&mut example, "{}", 42);
    = note: this `Result` may be an `Err` variant, which should be handled
    = note: `-W unused-must-use` implied by `-W unused`
    = help: to override `-W unused` add `#[allow(unused_must_use)]`
-   = note: this warning originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: use `let _ = ...` to ignore the resulting value
+   |
+LL |     let _ = write!(&mut example, "{}", 42);
+   |     +++++++
 
 warning: 1 warning emitted
 
diff --git a/tests/ui/methods/method-missing-call.rs b/tests/ui/methods/method-missing-call.rs
deleted file mode 100644
index 7ce1e9a4f1b..00000000000
--- a/tests/ui/methods/method-missing-call.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-// Tests to make sure that parens are needed for method calls without arguments.
-// outputs text to make sure either an anonymous function is provided or
-// open-close '()' parens are given
-
-
-struct Point {
-    x: isize,
-    y: isize
-}
-impl Point {
-    fn new() -> Point {
-        Point{x:0, y:0}
-    }
-    fn get_x(&self) -> isize {
-        self.x
-    }
-}
-
-fn main() {
-    let point: Point = Point::new();
-    let px: isize =  point
-                        .get_x;//~ ERROR attempted to take value of method `get_x` on type `Point`
-
-    // Ensure the span is useful
-    let ys = &[1,2,3,4,5,6,7];
-    let a = ys.iter()
-              .map(|x| x)
-              .filter(|&&x| x == 1)
-              .filter_map; //~ ERROR attempted to take value of method `filter_map` on type
-}
diff --git a/tests/ui/methods/method-missing-call.stderr b/tests/ui/methods/method-missing-call.stderr
deleted file mode 100644
index bc508461b69..00000000000
--- a/tests/ui/methods/method-missing-call.stderr
+++ /dev/null
@@ -1,25 +0,0 @@
-error[E0615]: attempted to take value of method `get_x` on type `Point`
-  --> $DIR/method-missing-call.rs:22:26
-   |
-LL |                         .get_x;
-   |                          ^^^^^ method, not a field
-   |
-help: use parentheses to call the method
-   |
-LL |                         .get_x();
-   |                               ++
-
-error[E0615]: attempted to take value of method `filter_map` on type `Filter<Map<std::slice::Iter<'_, {integer}>, {closure@$DIR/method-missing-call.rs:27:20: 27:23}>, {closure@$DIR/method-missing-call.rs:28:23: 28:28}>`
-  --> $DIR/method-missing-call.rs:29:16
-   |
-LL |               .filter_map;
-   |                ^^^^^^^^^^ method, not a field
-   |
-help: use parentheses to call the method
-   |
-LL |               .filter_map(_);
-   |                          +++
-
-error: aborting due to 2 previous errors
-
-For more information about this error, try `rustc --explain E0615`.
diff --git a/tests/ui/methods/method-value-without-call.rs b/tests/ui/methods/method-value-without-call.rs
new file mode 100644
index 00000000000..43bee4864b4
--- /dev/null
+++ b/tests/ui/methods/method-value-without-call.rs
@@ -0,0 +1,33 @@
+//! Test taking a method value without parentheses
+
+struct Point {
+    x: isize,
+    y: isize,
+}
+
+impl Point {
+    fn new() -> Point {
+        Point { x: 0, y: 0 }
+    }
+
+    fn get_x(&self) -> isize {
+        self.x
+    }
+}
+
+fn main() {
+    // Test with primitive type method
+    let _f = 10i32.abs; //~ ERROR attempted to take value of method
+
+    // Test with custom type method
+    let point: Point = Point::new();
+    let px: isize = point.get_x; //~ ERROR attempted to take value of method `get_x` on type `Point`
+
+    // Test with method chains - ensure the span is useful
+    let ys = &[1, 2, 3, 4, 5, 6, 7];
+    let a = ys
+        .iter()
+        .map(|x| x)
+        .filter(|&&x| x == 1)
+        .filter_map; //~ ERROR attempted to take value of method `filter_map` on type
+}
diff --git a/tests/ui/methods/method-value-without-call.stderr b/tests/ui/methods/method-value-without-call.stderr
new file mode 100644
index 00000000000..0c3870e2868
--- /dev/null
+++ b/tests/ui/methods/method-value-without-call.stderr
@@ -0,0 +1,36 @@
+error[E0615]: attempted to take value of method `abs` on type `i32`
+  --> $DIR/method-value-without-call.rs:20:20
+   |
+LL |     let _f = 10i32.abs;
+   |                    ^^^ method, not a field
+   |
+help: use parentheses to call the method
+   |
+LL |     let _f = 10i32.abs();
+   |                       ++
+
+error[E0615]: attempted to take value of method `get_x` on type `Point`
+  --> $DIR/method-value-without-call.rs:24:27
+   |
+LL |     let px: isize = point.get_x;
+   |                           ^^^^^ method, not a field
+   |
+help: use parentheses to call the method
+   |
+LL |     let px: isize = point.get_x();
+   |                                ++
+
+error[E0615]: attempted to take value of method `filter_map` on type `Filter<Map<std::slice::Iter<'_, {integer}>, {closure@$DIR/method-value-without-call.rs:30:14: 30:17}>, {closure@$DIR/method-value-without-call.rs:31:17: 31:22}>`
+  --> $DIR/method-value-without-call.rs:32:10
+   |
+LL |         .filter_map;
+   |          ^^^^^^^^^^ method, not a field
+   |
+help: use parentheses to call the method
+   |
+LL |         .filter_map(_);
+   |                    +++
+
+error: aborting due to 3 previous errors
+
+For more information about this error, try `rustc --explain E0615`.
diff --git a/tests/ui/mismatched_types/elide-on-tuple-mismatch.rs b/tests/ui/mismatched_types/elide-on-tuple-mismatch.rs
new file mode 100644
index 00000000000..c36d041d296
--- /dev/null
+++ b/tests/ui/mismatched_types/elide-on-tuple-mismatch.rs
@@ -0,0 +1,25 @@
+//! Regression test for issue #50333: elide irrelevant E0277 errors on tuple mismatch
+
+// Hide irrelevant E0277 errors (#50333)
+
+trait T {}
+
+struct A;
+
+impl T for A {}
+
+impl A {
+    fn new() -> Self {
+        Self {}
+    }
+}
+
+fn main() {
+    // This creates a tuple type mismatch: 2-element tuple destructured into 3 variables
+    let (a, b, c) = (A::new(), A::new());
+    //~^ ERROR mismatched types
+
+    // This line should NOT produce an E0277 error about `Sized` trait bounds,
+    // because `a`, `b`, and `c` are `TyErr` due to the mismatch above
+    let _ts: Vec<&dyn T> = vec![&a, &b, &c];
+}
diff --git a/tests/ui/elide-errors-on-mismatched-tuple.stderr b/tests/ui/mismatched_types/elide-on-tuple-mismatch.stderr
index f852a223b42..7de45eb40ca 100644
--- a/tests/ui/elide-errors-on-mismatched-tuple.stderr
+++ b/tests/ui/mismatched_types/elide-on-tuple-mismatch.stderr
@@ -1,7 +1,7 @@
 error[E0308]: mismatched types
-  --> $DIR/elide-errors-on-mismatched-tuple.rs:14:9
+  --> $DIR/elide-on-tuple-mismatch.rs:19:9
    |
-LL |     let (a, b, c) = (A::new(), A::new()); // This tuple is 2 elements, should be three
+LL |     let (a, b, c) = (A::new(), A::new());
    |         ^^^^^^^^^   -------------------- this expression has type `(A, A)`
    |         |
    |         expected a tuple with 2 elements, found one with 3 elements
diff --git a/tests/ui/double-ref.rs b/tests/ui/parser/reference-whitespace-parsing.rs
index eecf68ff209..7109c5911ae 100644
--- a/tests/ui/double-ref.rs
+++ b/tests/ui/parser/reference-whitespace-parsing.rs
@@ -1,3 +1,5 @@
+//! Test parsing of multiple references with various whitespace arrangements
+
 //@ run-pass
 
 #![allow(dead_code)]
diff --git a/tests/ui/simd/intrinsic/float-math-pass.rs b/tests/ui/simd/intrinsic/float-math-pass.rs
index 4c28568a739..01fed8537d0 100644
--- a/tests/ui/simd/intrinsic/float-math-pass.rs
+++ b/tests/ui/simd/intrinsic/float-math-pass.rs
@@ -85,6 +85,9 @@ fn main() {
         let r = simd_round(h);
         assert_eq!(x, r);
 
+        let r = simd_round_ties_even(h);
+        assert_eq!(z, r);
+
         let r = simd_trunc(h);
         assert_eq!(z, r);
     }
diff --git a/tests/ui/simd/intrinsic/generic-arithmetic-2.rs b/tests/ui/simd/intrinsic/generic-arithmetic-2.rs
index fdf06b7882e..caec607d6fe 100644
--- a/tests/ui/simd/intrinsic/generic-arithmetic-2.rs
+++ b/tests/ui/simd/intrinsic/generic-arithmetic-2.rs
@@ -43,6 +43,10 @@ fn main() {
         simd_shl(y, y);
         simd_shr(x, x);
         simd_shr(y, y);
+        simd_funnel_shl(x, x, x);
+        simd_funnel_shl(y, y, y);
+        simd_funnel_shr(x, x, x);
+        simd_funnel_shr(y, y, y);
         simd_and(x, x);
         simd_and(y, y);
         simd_or(x, x);
@@ -73,6 +77,10 @@ fn main() {
         //~^ ERROR expected SIMD input type, found non-SIMD `i32`
         simd_shr(0, 0);
         //~^ ERROR expected SIMD input type, found non-SIMD `i32`
+        simd_funnel_shl(0, 0, 0);
+        //~^ ERROR expected SIMD input type, found non-SIMD `i32`
+        simd_funnel_shr(0, 0, 0);
+        //~^ ERROR expected SIMD input type, found non-SIMD `i32`
         simd_and(0, 0);
         //~^ ERROR expected SIMD input type, found non-SIMD `i32`
         simd_or(0, 0);
@@ -95,6 +103,10 @@ fn main() {
         //~^ ERROR unsupported operation on `f32x4` with element `f32`
         simd_shr(z, z);
         //~^ ERROR unsupported operation on `f32x4` with element `f32`
+        simd_funnel_shl(z, z, z);
+        //~^ ERROR unsupported operation on `f32x4` with element `f32`
+        simd_funnel_shr(z, z, z);
+        //~^ ERROR unsupported operation on `f32x4` with element `f32`
         simd_and(z, z);
         //~^ ERROR unsupported operation on `f32x4` with element `f32`
         simd_or(z, z);
diff --git a/tests/ui/simd/intrinsic/generic-arithmetic-2.stderr b/tests/ui/simd/intrinsic/generic-arithmetic-2.stderr
index 76db6d5328f..a27a8d721fb 100644
--- a/tests/ui/simd/intrinsic/generic-arithmetic-2.stderr
+++ b/tests/ui/simd/intrinsic/generic-arithmetic-2.stderr
@@ -1,147 +1,171 @@
 error[E0511]: invalid monomorphization of `simd_add` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-arithmetic-2.rs:64:9
+  --> $DIR/generic-arithmetic-2.rs:68:9
    |
 LL |         simd_add(0, 0);
    |         ^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_sub` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-arithmetic-2.rs:66:9
+  --> $DIR/generic-arithmetic-2.rs:70:9
    |
 LL |         simd_sub(0, 0);
    |         ^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_mul` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-arithmetic-2.rs:68:9
+  --> $DIR/generic-arithmetic-2.rs:72:9
    |
 LL |         simd_mul(0, 0);
    |         ^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_div` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-arithmetic-2.rs:70:9
+  --> $DIR/generic-arithmetic-2.rs:74:9
    |
 LL |         simd_div(0, 0);
    |         ^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_shl` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-arithmetic-2.rs:72:9
+  --> $DIR/generic-arithmetic-2.rs:76:9
    |
 LL |         simd_shl(0, 0);
    |         ^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_shr` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-arithmetic-2.rs:74:9
+  --> $DIR/generic-arithmetic-2.rs:78:9
    |
 LL |         simd_shr(0, 0);
    |         ^^^^^^^^^^^^^^
 
+error[E0511]: invalid monomorphization of `simd_funnel_shl` intrinsic: expected SIMD input type, found non-SIMD `i32`
+  --> $DIR/generic-arithmetic-2.rs:80:9
+   |
+LL |         simd_funnel_shl(0, 0, 0);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0511]: invalid monomorphization of `simd_funnel_shr` intrinsic: expected SIMD input type, found non-SIMD `i32`
+  --> $DIR/generic-arithmetic-2.rs:82:9
+   |
+LL |         simd_funnel_shr(0, 0, 0);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^
+
 error[E0511]: invalid monomorphization of `simd_and` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-arithmetic-2.rs:76:9
+  --> $DIR/generic-arithmetic-2.rs:84:9
    |
 LL |         simd_and(0, 0);
    |         ^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_or` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-arithmetic-2.rs:78:9
+  --> $DIR/generic-arithmetic-2.rs:86:9
    |
 LL |         simd_or(0, 0);
    |         ^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_xor` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-arithmetic-2.rs:80:9
+  --> $DIR/generic-arithmetic-2.rs:88:9
    |
 LL |         simd_xor(0, 0);
    |         ^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_neg` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-arithmetic-2.rs:83:9
+  --> $DIR/generic-arithmetic-2.rs:91:9
    |
 LL |         simd_neg(0);
    |         ^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_bswap` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-arithmetic-2.rs:85:9
+  --> $DIR/generic-arithmetic-2.rs:93:9
    |
 LL |         simd_bswap(0);
    |         ^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_bitreverse` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-arithmetic-2.rs:87:9
+  --> $DIR/generic-arithmetic-2.rs:95:9
    |
 LL |         simd_bitreverse(0);
    |         ^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_ctlz` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-arithmetic-2.rs:89:9
+  --> $DIR/generic-arithmetic-2.rs:97:9
    |
 LL |         simd_ctlz(0);
    |         ^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_cttz` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-arithmetic-2.rs:91:9
+  --> $DIR/generic-arithmetic-2.rs:99:9
    |
 LL |         simd_cttz(0);
    |         ^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_shl` intrinsic: unsupported operation on `f32x4` with element `f32`
-  --> $DIR/generic-arithmetic-2.rs:94:9
+  --> $DIR/generic-arithmetic-2.rs:102:9
    |
 LL |         simd_shl(z, z);
    |         ^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_shr` intrinsic: unsupported operation on `f32x4` with element `f32`
-  --> $DIR/generic-arithmetic-2.rs:96:9
+  --> $DIR/generic-arithmetic-2.rs:104:9
    |
 LL |         simd_shr(z, z);
    |         ^^^^^^^^^^^^^^
 
+error[E0511]: invalid monomorphization of `simd_funnel_shl` intrinsic: unsupported operation on `f32x4` with element `f32`
+  --> $DIR/generic-arithmetic-2.rs:106:9
+   |
+LL |         simd_funnel_shl(z, z, z);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0511]: invalid monomorphization of `simd_funnel_shr` intrinsic: unsupported operation on `f32x4` with element `f32`
+  --> $DIR/generic-arithmetic-2.rs:108:9
+   |
+LL |         simd_funnel_shr(z, z, z);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^
+
 error[E0511]: invalid monomorphization of `simd_and` intrinsic: unsupported operation on `f32x4` with element `f32`
-  --> $DIR/generic-arithmetic-2.rs:98:9
+  --> $DIR/generic-arithmetic-2.rs:110:9
    |
 LL |         simd_and(z, z);
    |         ^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_or` intrinsic: unsupported operation on `f32x4` with element `f32`
-  --> $DIR/generic-arithmetic-2.rs:100:9
+  --> $DIR/generic-arithmetic-2.rs:112:9
    |
 LL |         simd_or(z, z);
    |         ^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_xor` intrinsic: unsupported operation on `f32x4` with element `f32`
-  --> $DIR/generic-arithmetic-2.rs:102:9
+  --> $DIR/generic-arithmetic-2.rs:114:9
    |
 LL |         simd_xor(z, z);
    |         ^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_bswap` intrinsic: unsupported operation on `f32x4` with element `f32`
-  --> $DIR/generic-arithmetic-2.rs:104:9
+  --> $DIR/generic-arithmetic-2.rs:116:9
    |
 LL |         simd_bswap(z);
    |         ^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_bitreverse` intrinsic: unsupported operation on `f32x4` with element `f32`
-  --> $DIR/generic-arithmetic-2.rs:106:9
+  --> $DIR/generic-arithmetic-2.rs:118:9
    |
 LL |         simd_bitreverse(z);
    |         ^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_ctlz` intrinsic: unsupported operation on `f32x4` with element `f32`
-  --> $DIR/generic-arithmetic-2.rs:108:9
+  --> $DIR/generic-arithmetic-2.rs:120:9
    |
 LL |         simd_ctlz(z);
    |         ^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_ctpop` intrinsic: unsupported operation on `f32x4` with element `f32`
-  --> $DIR/generic-arithmetic-2.rs:110:9
+  --> $DIR/generic-arithmetic-2.rs:122:9
    |
 LL |         simd_ctpop(z);
    |         ^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_cttz` intrinsic: unsupported operation on `f32x4` with element `f32`
-  --> $DIR/generic-arithmetic-2.rs:112:9
+  --> $DIR/generic-arithmetic-2.rs:124:9
    |
 LL |         simd_cttz(z);
    |         ^^^^^^^^^^^^
 
-error: aborting due to 24 previous errors
+error: aborting due to 28 previous errors
 
 For more information about this error, try `rustc --explain E0511`.
diff --git a/tests/ui/simd/intrinsic/generic-arithmetic-pass.rs b/tests/ui/simd/intrinsic/generic-arithmetic-pass.rs
index 3f0325d690b..4c97fb2141d 100644
--- a/tests/ui/simd/intrinsic/generic-arithmetic-pass.rs
+++ b/tests/ui/simd/intrinsic/generic-arithmetic-pass.rs
@@ -83,6 +83,80 @@ fn main() {
         all_eq!(simd_shr(simd_shl(y1, y2), y2), y1);
         all_eq!(simd_shr(simd_shl(y2, y1), y1), y2);
 
+        all_eq!(
+            simd_funnel_shl(x1, x2, x1),
+            i32x4([
+                (1 << 1) | (2 >> 31),
+                (2 << 2) | (3 >> 30),
+                (3 << 3) | (4 >> 29),
+                (4 << 4) | (5 >> 28)
+            ])
+        );
+        all_eq!(
+            simd_funnel_shl(x2, x1, x1),
+            i32x4([
+                (2 << 1) | (1 >> 31),
+                (3 << 2) | (2 >> 30),
+                (4 << 3) | (3 >> 29),
+                (5 << 4) | (4 >> 28)
+            ])
+        );
+        all_eq!(
+            simd_funnel_shl(y1, y2, y1),
+            U32::<4>([
+                (1 << 1) | (2 >> 31),
+                (2 << 2) | (3 >> 30),
+                (3 << 3) | (4 >> 29),
+                (4 << 4) | (5 >> 28)
+            ])
+        );
+        all_eq!(
+            simd_funnel_shl(y2, y1, y1),
+            U32::<4>([
+                (2 << 1) | (1 >> 31),
+                (3 << 2) | (2 >> 30),
+                (4 << 3) | (3 >> 29),
+                (5 << 4) | (4 >> 28)
+            ])
+        );
+
+        all_eq!(
+            simd_funnel_shr(x1, x2, x1),
+            i32x4([
+                (1 << 31) | (2 >> 1),
+                (2 << 30) | (3 >> 2),
+                (3 << 29) | (4 >> 3),
+                (4 << 28) | (5 >> 4)
+            ])
+        );
+        all_eq!(
+            simd_funnel_shr(x2, x1, x1),
+            i32x4([
+                (2 << 31) | (1 >> 1),
+                (3 << 30) | (2 >> 2),
+                (4 << 29) | (3 >> 3),
+                (5 << 28) | (4 >> 4)
+            ])
+        );
+        all_eq!(
+            simd_funnel_shr(y1, y2, y1),
+            U32::<4>([
+                (1 << 31) | (2 >> 1),
+                (2 << 30) | (3 >> 2),
+                (3 << 29) | (4 >> 3),
+                (4 << 28) | (5 >> 4)
+            ])
+        );
+        all_eq!(
+            simd_funnel_shr(y2, y1, y1),
+            U32::<4>([
+                (2 << 31) | (1 >> 1),
+                (3 << 30) | (2 >> 2),
+                (4 << 29) | (3 >> 3),
+                (5 << 28) | (4 >> 4)
+            ])
+        );
+
         // ensure we get logical vs. arithmetic shifts correct
         let (a, b, c, d) = (-12, -123, -1234, -12345);
         all_eq!(simd_shr(i32x4([a, b, c, d]), x1), i32x4([a >> 1, b >> 2, c >> 3, d >> 4]));
diff --git a/tests/ui/test-attrs/test-function-elided-no-main.rs b/tests/ui/test-attrs/test-function-elided-no-main.rs
new file mode 100644
index 00000000000..97654581567
--- /dev/null
+++ b/tests/ui/test-attrs/test-function-elided-no-main.rs
@@ -0,0 +1,8 @@
+//! Test that #[test] functions are elided when not running tests, causing missing main error
+
+#[test]
+fn main() {
+    // This function would normally serve as main, but since it's marked with #[test],
+    // it gets elided when not running tests
+}
+//~^ ERROR `main` function not found in crate `test_function_elided_no_main`
diff --git a/tests/ui/test-attrs/test-function-elided-no-main.stderr b/tests/ui/test-attrs/test-function-elided-no-main.stderr
new file mode 100644
index 00000000000..0bae690be2b
--- /dev/null
+++ b/tests/ui/test-attrs/test-function-elided-no-main.stderr
@@ -0,0 +1,9 @@
+error[E0601]: `main` function not found in crate `test_function_elided_no_main`
+  --> $DIR/test-function-elided-no-main.rs:7:2
+   |
+LL | }
+   |  ^ consider adding a `main` function to `$DIR/test-function-elided-no-main.rs`
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0601`.
diff --git a/tests/ui/impl-unused-tps.rs b/tests/ui/traits/constrained-type-params-trait-impl.rs
index a5836db3c8e..301bbdb2ccb 100644
--- a/tests/ui/impl-unused-tps.rs
+++ b/tests/ui/traits/constrained-type-params-trait-impl.rs
@@ -1,3 +1,11 @@
+//! Comprehensive test for type parameter constraints in trait implementations
+//!
+//! This tests various scenarios of type parameter usage in trait implementations:
+//! - Properly constrained parameters through trait bounds
+//! - Unconstrained parameters that should cause compilation errors
+//! - Complex constraint scenarios with `where` clauses and associated types
+//! - Conflicting implementations detection
+
 trait Foo<A> {
     fn get(&self, A: &A) {}
 }
@@ -7,34 +15,34 @@ trait Bar {
 }
 
 impl<T> Foo<T> for [isize; 0] {
-    // OK, T is used in `Foo<T>`.
+    // OK: T is used in the trait bound `Foo<T>`
 }
 
 impl<T, U> Foo<T> for [isize; 1] {
     //~^ ERROR the type parameter `U` is not constrained
+    // T is constrained by `Foo<T>`, but U is completely unused
 }
 
 impl<T, U> Foo<T> for [isize; 2]
 where
     T: Bar<Out = U>,
 {
-    // OK, `U` is now constrained by the output type parameter.
+    // OK: T is constrained by `Foo<T>`, U is constrained by the where clause
 }
 
 impl<T: Bar<Out = U>, U> Foo<T> for [isize; 3] {
-    // OK, same as above but written differently.
+    // OK: Same as above but using bound syntax instead of where clause
 }
 
 impl<T, U> Foo<T> for U {
     //~^ ERROR conflicting implementations of trait `Foo<_>` for type `[isize; 0]`
+    // This conflicts with the first impl when U = [isize; 0]
 }
 
 impl<T, U> Bar for T {
     //~^ ERROR the type parameter `U` is not constrained
-
     type Out = U;
-
-    // Using `U` in an associated type within the impl is not good enough!
+    // Using U only in associated type definition is insufficient for constraint
 }
 
 impl<T, U> Bar for T
@@ -43,7 +51,7 @@ where
 {
     //~^^^^ ERROR the type parameter `U` is not constrained by the impl trait, self type, or predicates
     //~| ERROR conflicting implementations of trait `Bar`
-    // This crafty self-referential attempt is still no good.
+    // Self-referential constraint doesn't properly constrain U
 }
 
 impl<T, U, V> Foo<T> for T
@@ -53,9 +61,7 @@ where
     //~^^^^ ERROR the type parameter `U` is not constrained
     //~| ERROR the type parameter `V` is not constrained
     //~| ERROR conflicting implementations of trait `Foo<[isize; 0]>` for type `[isize; 0]`
-
-    // Here, `V` is bound by an output type parameter, but the inputs
-    // are not themselves constrained.
+    // V is bound through output type, but U and V are not properly constrained as inputs
 }
 
 impl<T, U, V> Foo<(T, U)> for T
@@ -63,7 +69,7 @@ where
     (T, U): Bar<Out = V>,
 {
     //~^^^^ ERROR conflicting implementations of trait `Foo<([isize; 0], _)>` for type `[isize; 0]`
-    // As above, but both T and U ARE constrained.
+    // Both T and U are constrained through `Foo<(T, U)>`, but creates conflicting impl
 }
 
 fn main() {}
diff --git a/tests/ui/impl-unused-tps.stderr b/tests/ui/traits/constrained-type-params-trait-impl.stderr
index eff5ffff9b6..2175129a8df 100644
--- a/tests/ui/impl-unused-tps.stderr
+++ b/tests/ui/traits/constrained-type-params-trait-impl.stderr
@@ -1,5 +1,5 @@
 error[E0119]: conflicting implementations of trait `Foo<_>` for type `[isize; 0]`
-  --> $DIR/impl-unused-tps.rs:28:1
+  --> $DIR/constrained-type-params-trait-impl.rs:37:1
    |
 LL | impl<T> Foo<T> for [isize; 0] {
    | ----------------------------- first implementation here
@@ -8,7 +8,7 @@ LL | impl<T, U> Foo<T> for U {
    | ^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `[isize; 0]`
 
 error[E0119]: conflicting implementations of trait `Foo<[isize; 0]>` for type `[isize; 0]`
-  --> $DIR/impl-unused-tps.rs:49:1
+  --> $DIR/constrained-type-params-trait-impl.rs:57:1
    |
 LL |   impl<T> Foo<T> for [isize; 0] {
    |   ----------------------------- first implementation here
@@ -19,7 +19,7 @@ LL | |     (T, U): Bar<Out = V>,
    | |_________________________^ conflicting implementation for `[isize; 0]`
 
 error[E0119]: conflicting implementations of trait `Foo<([isize; 0], _)>` for type `[isize; 0]`
-  --> $DIR/impl-unused-tps.rs:61:1
+  --> $DIR/constrained-type-params-trait-impl.rs:67:1
    |
 LL |   impl<T> Foo<T> for [isize; 0] {
    |   ----------------------------- first implementation here
@@ -30,37 +30,37 @@ LL | |     (T, U): Bar<Out = V>,
    | |_________________________^ conflicting implementation for `[isize; 0]`
 
 error[E0207]: the type parameter `U` is not constrained by the impl trait, self type, or predicates
-  --> $DIR/impl-unused-tps.rs:13:9
+  --> $DIR/constrained-type-params-trait-impl.rs:21:9
    |
 LL | impl<T, U> Foo<T> for [isize; 1] {
    |         ^ unconstrained type parameter
 
 error[E0207]: the type parameter `U` is not constrained by the impl trait, self type, or predicates
-  --> $DIR/impl-unused-tps.rs:32:9
+  --> $DIR/constrained-type-params-trait-impl.rs:42:9
    |
 LL | impl<T, U> Bar for T {
    |         ^ unconstrained type parameter
 
 error[E0207]: the type parameter `U` is not constrained by the impl trait, self type, or predicates
-  --> $DIR/impl-unused-tps.rs:40:9
+  --> $DIR/constrained-type-params-trait-impl.rs:48:9
    |
 LL | impl<T, U> Bar for T
    |         ^ unconstrained type parameter
 
 error[E0207]: the type parameter `U` is not constrained by the impl trait, self type, or predicates
-  --> $DIR/impl-unused-tps.rs:49:9
+  --> $DIR/constrained-type-params-trait-impl.rs:57:9
    |
 LL | impl<T, U, V> Foo<T> for T
    |         ^ unconstrained type parameter
 
 error[E0207]: the type parameter `V` is not constrained by the impl trait, self type, or predicates
-  --> $DIR/impl-unused-tps.rs:49:12
+  --> $DIR/constrained-type-params-trait-impl.rs:57:12
    |
 LL | impl<T, U, V> Foo<T> for T
    |            ^ unconstrained type parameter
 
 error[E0119]: conflicting implementations of trait `Bar`
-  --> $DIR/impl-unused-tps.rs:40:1
+  --> $DIR/constrained-type-params-trait-impl.rs:48:1
    |
 LL |   impl<T, U> Bar for T {
    |   -------------------- first implementation here
diff --git a/tests/ui/transmute/diverging-fn-transmute.rs b/tests/ui/transmute/diverging-fn-transmute.rs
new file mode 100644
index 00000000000..aca82037a0c
--- /dev/null
+++ b/tests/ui/transmute/diverging-fn-transmute.rs
@@ -0,0 +1,10 @@
+//! Regression test for issue #35849: transmute with panic in diverging function
+
+fn assert_sizeof() -> ! {
+    unsafe {
+        ::std::mem::transmute::<f64, [u8; 8]>(panic!())
+        //~^ ERROR mismatched types
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/diverging-fn-tail-35849.stderr b/tests/ui/transmute/diverging-fn-transmute.stderr
index 614f9b9cb5d..b9aeae7ed62 100644
--- a/tests/ui/diverging-fn-tail-35849.stderr
+++ b/tests/ui/transmute/diverging-fn-transmute.stderr
@@ -1,5 +1,5 @@
 error[E0308]: mismatched types
-  --> $DIR/diverging-fn-tail-35849.rs:3:9
+  --> $DIR/diverging-fn-transmute.rs:5:9
    |
 LL | fn assert_sizeof() -> ! {
    |                       - expected `!` because of return type