[test] Migrate from trybuild to ui-test

Cargo.toml

@@ -10,8 +10,13 @@
 # paths that are stable regardless of the path to the repository root. This
 # avoids issues like:
 # https://github.com/dtolnay/trybuild/issues/207#issuecomment-131227.594
-[workspace]
+[[test]]
+name = "ui"
+path = "tests/ui.rs"
+harness = false
 
+[workspace]
+members = []
 [package]
 edition = "2021"
 name = "zerocopy"
@@ -128,10 +133,6 @@ rand = { version = "0.8.5", default-features = false, features = ["small_rng"] }
 rustversion = "1.0"
 static_assertions = "1.1"
 testutil = { path = "testutil" }
-# Pinned to a specific version so that the version used for local development
-# and the version used in CI are guaranteed to be the same. Future versions
-# sometimes change the output format slightly, so a version mismatch can cause
-# CI test failures.
-trybuild = { version = "=1.0.89", features = ["diff"] }
 # In tests, unlike in production, zerocopy-derive is not optional
 zerocopy-derive = { version = "=0.8.38", path = "zerocopy-derive" }
+zerocopy = { path = ".", features = ["derive"] }

ci/check_fmt.sh

@@ -15,4 +15,11 @@ if [[ -z $files ]]
 then
 	exit 1
 fi
-./cargo.sh +nightly fmt --check -- $files >&2
+
+if [[ "$1" == "--fix" ]]; then
+    FMT_FLAGS=""
+else
+    FMT_FLAGS="--check"
+fi
+
+./cargo.sh +nightly fmt $FMT_FLAGS -- $files >&2

ci/check_stale_stderr.sh

@@ -23,8 +23,16 @@ for dir in "${DIRS[@]}"; do
 
     # Find all .stderr files
     while IFS= read -r -d '' stderr_file; do
+        # Strip .stderr extension
+        base="${stderr_file%.stderr}"
+
+        # Strip toolchain suffixes
+        base="${base%.msrv}"
+        base="${base%.stable}"
+        base="${base%.nightly}"
+
         # Construct the corresponding .rs file path
-        rs_file="${stderr_file%.stderr}.rs"
+        rs_file="${base}.rs"
 
         # Check if the .rs file exists. The `-e` flag checks if file exists:
         # It returns true for regular files and valid symlinks, and false for

src/doctests.rs

@@ -149,3 +149,20 @@ enum TransmuteRefMutDstOffsetNotMultiple {}
 /// let _: &mut SliceDst<(), [u8; 2]> = zerocopy::transmute_mut!(src);
 /// ```
 enum TransmuteRefMutDstElemSizeNotMultiple {}
+
+/// ```compile_fail,E0277
+/// use zerocopy::*;
+///
+/// #[derive(FromBytes, IntoBytes, Unaligned)]
+/// #[repr(transparent)]
+/// struct Foo<T>(T);
+///
+/// const _: () = unsafe {
+///     impl_or_verify!(T => TryFromBytes for Foo<T>);
+///     impl_or_verify!(T => FromZeros for Foo<T>);
+///     impl_or_verify!(T => FromBytes for Foo<T>);
+///     impl_or_verify!(T => IntoBytes for Foo<T>);
+///     impl_or_verify!(T => Unaligned for Foo<T>);
+/// };
+/// ```
+enum InvalidImplOrVerify {}

src/util/macros.rs

@@ -322,6 +322,9 @@ macro_rules! opt_unsafe_fn {
     ($($args:ident),* -> $ret:ident) => { Option<unsafe fn($($args),*) -> $ret> };
 }
 
+// This `allow` is needed because, when testing, we export this macro so it can
+// be used in `doctests`.
+#[allow(rustdoc::private_intra_doc_links)]
 /// Implements trait(s) for a type or verifies the given implementation by
 /// referencing an existing (derived) implementation.
 ///
@@ -342,8 +345,7 @@ macro_rules! opt_unsafe_fn {
 /// `const _: () = unsafe` macro). The reason for this restriction is that,
 /// while `impl_or_verify!` can guarantee that the provided impl is sound when
 /// it is compiled with the appropriate cfgs, there is no way to guarantee that
-/// it is
-/// ever compiled with those cfgs. In particular, it would be possible to
+/// it is ever compiled with those cfgs. In particular, it would be possible to
 /// accidentally place an `impl_or_verify!` call in a context that is only ever
 /// compiled when the `derive` feature is disabled. If that were to happen,
 /// there would be nothing to prevent an unsound trait impl from being emitted.
@@ -372,6 +374,7 @@ macro_rules! opt_unsafe_fn {
 ///     impl_or_verify!(T: Unaligned => Unaligned for Wrapper<T>);
 /// }
 /// ```
+#[cfg_attr(__ZEROCOPY_INTERNAL_USE_ONLY_DEV_MODE, macro_export)] // Used in `doctests.rs`
 macro_rules! impl_or_verify {
     // The following two match arms follow the same pattern as their
     // counterparts in `unsafe_impl!`; see the documentation on those arms for