Add more ptr_comparisons tests:

One that compares two non-null integer-valued pointers.
One that compares an out-of-bounds pointer with null, that cannot be null due to alignment instead of in-bounds-ness.
One that compares the one-past-the-end pointer of two statics, for which we conservatively say we don't know.

Author: zachs18

tests/ui/consts/ptr_comparisons.rs

@@ -82,6 +82,10 @@ const VTABLE_PTR_2: *const () = {
 do_test!(0 as *const u8, 0 as *const u8, Some(true));
 do_test!(0 as *const u8, 1 as *const u8, Some(false));
 
+// Integer-valued pointers can always be compared.
+do_test!(1 as *const u8, 1 as *const u8, Some(true));
+do_test!(1 as *const u8, 2 as *const u8, Some(false));
+
 // Cannot be `None`: `static`s' addresses, references, (and within and one-past-the-end of those),
 // and `fn` pointers cannot be null, and `is_null` is stable with strong guarantees, and
 // `is_null` is implemented using `guaranteed_cmp`.
@@ -93,6 +97,9 @@ do_test!(&(), 0 as *const u8, Some(false));
 do_test!(const { &() }, 0 as *const u8, Some(false));
 do_test!(FN_PTR, 0 as *const u8, Some(false));
 
+// This pointer is out-of-bounds, but still cannot be equal to 0 because of alignment.
+do_test!((&raw const A).cast::<u8>().wrapping_add(size_of::<T>() + 1), 0 as *const u8, Some(false));
+
 // aside from 0, these pointers might end up pretty much anywhere.
 do_test!(&A, align_of::<T>() as *const u8, None);
 do_test!((&raw const A).wrapping_byte_add(1), (align_of::<T>() + 1) as *const u8, None);
@@ -149,9 +156,11 @@ do_test!(&A, (&T(42) as *const T).wrapping_byte_add(1), Some(false));
 do_test!(&A, (const { &T(42) } as *const T).wrapping_byte_add(1), Some(false));
 do_test!(&A, ({ const X: T = T(42); &X } as *const T).wrapping_byte_add(1), Some(false));
 
-// We could return `Some(false)` here, as pointers to different statics can never be equal if that
-// would require the statics to overlap, even if the pointers themselves are offset out of bounds.
-// We currently only check strictly in-bounds pointers, however.
+// We could return `Some(false)` for these, as pointers to different statics can never be equal if
+// that would require the statics to overlap, even if the pointers themselves are offset out of
+// bounds or one-past-the-end. We currently only check strictly in-bounds pointers when comparing
+// pointers to different statics, however.
+do_test!((&raw const A).wrapping_add(1), (&raw const B).wrapping_add(1), None);
 do_test!(
     (&raw const LARGE_WORD_ALIGNED).cast::<usize>().wrapping_add(2),
     (&raw const MUT_LARGE_WORD_ALIGNED).cast::<usize>().wrapping_add(1),