cleanud up some tests

Author: Kivooeo

compiler/rustc_const_eval/src/const_eval/error.rs

@@ -2,7 +2,7 @@ use std::mem;
 
 use rustc_errors::{Diag, DiagArgName, DiagArgValue, DiagMessage, IntoDiagArg};
 use rustc_middle::mir::AssertKind;
-use rustc_middle::mir::interpret::{Provenance, ReportedErrorInfo};
+use rustc_middle::mir::interpret::{Provenance, ReportedErrorInfo, UnsupportedOpInfo};
 use rustc_middle::query::TyCtxtAt;
 use rustc_middle::ty::layout::LayoutError;
 use rustc_middle::ty::{ConstInt, TyCtxt};
@@ -167,7 +167,7 @@ where
             // anyway (e.g. due to size overflow). And we allow OOM as that can happen any time.
             let allowed_in_infallible = matches!(
                 error,
-                InterpErrorKind::ResourceExhaustion(_) | InterpErrorKind::InvalidProgram(_)
+                InterpErrorKind::ResourceExhaustion(_) | InterpErrorKind::InvalidProgram(_) | InterpErrorKind::Unsupported(UnsupportedOpInfo::ReadPointerAsInt(_))
             );
 
             error.add_args(&mut err);

src/tools/cargo

@@ -0,0 +1,10 @@
+//! Smoke test: dereferencing boxed zero-sized types (ZSTs) should not crash.
+//!
+//! Originally a regression test of github.com/rust-lang/rust/issues/13360
+//! but repurposed for a smoke test.
+
+//@ run-pass
+
+pub fn main() {
+    let _: () = *Box::new(());
+}

tests/ui/box/empty-alloc-deref-rvalue.rs

@@ -1,4 +1,4 @@
-// issue #20126
+//! Regression test for issue #20126: Copy and Drop traits are mutually exclusive
 
 #[derive(Copy, Clone)] //~ ERROR the trait `Copy` cannot be implemented
 struct Foo;

tests/ui/exclusive-drop-and-copy.rs renamed to tests/ui/derives/copy-drop-mutually-exclusive.rs

@@ -1,11 +1,11 @@
 error[E0184]: the trait `Copy` cannot be implemented for this type; the type has a destructor
-  --> $DIR/exclusive-drop-and-copy.rs:3:10
+  --> $DIR/copy-drop-mutually-exclusive.rs:3:10
    |
 LL | #[derive(Copy, Clone)]
    |          ^^^^ `Copy` not allowed on types with destructors
 
 error[E0184]: the trait `Copy` cannot be implemented for this type; the type has a destructor
-  --> $DIR/exclusive-drop-and-copy.rs:10:10
+  --> $DIR/copy-drop-mutually-exclusive.rs:10:10
    |
 LL | #[derive(Copy, Clone)]
    |          ^^^^ `Copy` not allowed on types with destructors

tests/ui/exclusive-drop-and-copy.stderr renamed to tests/ui/derives/copy-drop-mutually-exclusive.stderr

@@ -0,0 +1,27 @@
+//! Test that empty type parameter list <> is equivalent to no type parameters
+//!
+//! Checks` that empty angle brackets <> are syntactically valid and equivalent
+//! to omitting type parameters entirely across various language constructs.
+
+//@ run-pass
+
+struct S<>;
+trait T<> {} //~ WARN trait `T` is never used
+enum E<> {
+    V
+}
+impl<> T<> for S<> {}
+impl T for E {}
+fn foo<>() {}
+fn bar() {}
+fn main() {
+    let _ = S;
+    let _ = S::<>;
+    let _ = E::V;
+    let _ = E::<>::V;
+    foo();
+    foo::<>();
+    // Test that we can supply <> to non-generic things
+    bar::<>();
+    let _: i32<>;
+}

tests/ui/empty-allocation-rvalue-non-null.rs

@@ -1,5 +1,5 @@
 warning: trait `T` is never used
-  --> $DIR/empty-type-parameter-list.rs:6:7
+  --> $DIR/empty-generic-brackets-equiv.rs:9:7
    |
 LL | trait T<> {}
    |       ^

tests/ui/empty-type-parameter-list.rs

@@ -1,3 +1,5 @@
+//! Test nested macro expansion with concat! macros
+
 //@ run-pass
 
 static FOO : &'static str = concat!(concat!("hel", "lo"), "world");

tests/ui/error-should-say-copy-not-pod.rs

@@ -0,0 +1,6 @@
+//! Test error handling for undefined macro calls
+
+fn main() {
+    iamnotanextensionthatexists!("");
+    //~^ ERROR cannot find macro `iamnotanextensionthatexists` in this scope
+}

tests/ui/error-should-say-copy-not-pod.stderr

@@ -0,0 +1,8 @@
+error: cannot find macro `iamnotanextensionthatexists` in this scope
+  --> $DIR/nonexistent-macro.rs:4:5
+   |
+LL |     iamnotanextensionthatexists!("");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+

tests/ui/explicit-i-suffix.rs

@@ -1,28 +1,39 @@
+//! Regression test for issue #38412: interaction between stability attributes and privacy
+//!
+//! Tests that the compiler correctly handles the interaction between feature gates
+//! and privacy/visibility rules. Specifically verifies that enabled unstable features
+//! are accessible while disabled ones are properly rejected.
+
 //@ aux-build:pub-and-stability.rs
 
-// A big point of this test is that we *enable* `unstable_declared`,
-// but do *not* enable `unstable_undeclared`. This way we can check
-// that the compiler is letting in uses of enabled feature-gated
-// stuff but still rejecting uses of disabled feature-gated stuff.
+// Enable `unstable_declared` but not `unstable_undeclared` to test
+// that the compiler allows enabled features but rejects disabled ones
 #![feature(unstable_declared)]
 
 extern crate pub_and_stability;
 use pub_and_stability::{Record, Trait, Tuple};
 
 fn main() {
-    // Okay
+    // Test struct field access patterns
     let Record { .. } = Record::new();
 
-    // Okay
-    let Record { a_stable_pub: _, a_unstable_declared_pub: _, .. } = Record::new();
+    let Record {
+        a_stable_pub: _,
+        a_unstable_declared_pub: _,
+        ..
+    } = Record::new();
 
-    let Record { a_stable_pub: _, a_unstable_declared_pub: _, a_unstable_undeclared_pub: _, .. } =
-        Record::new();
-    //~^^ ERROR use of unstable library feature `unstable_undeclared`
+    let Record {
+        a_stable_pub: _,
+        a_unstable_declared_pub: _,
+        a_unstable_undeclared_pub: _,  //~ ERROR use of unstable library feature `unstable_undeclared`
+        ..
+    } = Record::new();
 
     let r = Record::new();
     let t = Tuple::new();
 
+    // Test field access with different stability/privacy combinations
     r.a_stable_pub;
     r.a_unstable_declared_pub;
     r.a_unstable_undeclared_pub; //~ ERROR use of unstable library feature
@@ -37,10 +48,12 @@ fn main() {
     t.4;                         //~ ERROR is private
     t.5;                         //~ ERROR is private
 
+    // Test trait method access
     r.stable_trait_method();
     r.unstable_declared_trait_method();
     r.unstable_undeclared_trait_method(); //~ ERROR use of unstable library feature
 
+    // Test inherent method access
     r.stable();
     r.unstable_declared();
     r.unstable_undeclared();              //~ ERROR use of unstable library feature
@@ -49,6 +62,7 @@ fn main() {
     r.pub_mod();                          //~ ERROR `pub_mod` is private
     r.private();                          //~ ERROR `private` is private
 
+    // Repeat tests for tuple struct
     let t = Tuple::new();
     t.stable_trait_method();
     t.unstable_declared_trait_method();