Add some tests

Author: amanjeev

tests/ui/consts/auxiliary/const_mut_refs_crate.rs

@@ -0,0 +1,19 @@
+// This is a support file for ../const-mut-refs-crate.rs
+
+// This is to test that static inners from an external
+// crate like this one, still preserves the alloc.
+// That is, the address from the standpoint of rustc+llvm
+// is the same.
+// The need for this test originated from the GH issue
+// https://github.com/rust-lang/rust/issues/57349
+
+// See also ../const-mut-refs-crate.rs for more details
+// about this test.
+
+pub static FOO: &'static i32 = &42;
+pub static BAR: &'static i32 = FOO;
+
+pub mod inner {
+    pub static INNER_MOD_FOO: &'static i32 = &43;
+    pub static INNER_MOD_BAR: &'static i32 = INNER_MOD_FOO;
+}

tests/ui/consts/const-mut-refs-crate.rs

@@ -0,0 +1,31 @@
+// run-pass
+// aux-build:const_mut_refs_crate.rs
+
+//! Regression test for https://github.com/rust-lang/rust/issues/79738
+//! Show how we are duplicationg allocations, even though static items that
+//! copy their value from another static should not also be duplicating
+//! memory behind references.
+
+extern crate const_mut_refs_crate as other;
+
+use other::{
+    inner::{INNER_MOD_BAR, INNER_MOD_FOO},
+    BAR, FOO,
+};
+
+pub static LOCAL_FOO: &'static i32 = &41;
+pub static LOCAL_BAR: &'static i32 = LOCAL_FOO;
+pub static COPY_OF_REMOTE_FOO: &'static i32 = FOO;
+
+static DOUBLE_REF: &&i32 = &&99;
+static ONE_STEP_ABOVE: &i32 = *DOUBLE_REF;
+
+pub fn main() {
+    assert_eq!(FOO as *const i32, BAR as *const i32);
+    assert_eq!(INNER_MOD_FOO as *const i32, INNER_MOD_BAR as *const i32);
+    assert_eq!(LOCAL_FOO as *const i32, LOCAL_BAR as *const i32);
+    assert_eq!(*DOUBLE_REF as *const i32, ONE_STEP_ABOVE as *const i32);
+
+    // bug!
+    assert_ne!(FOO as *const i32, COPY_OF_REMOTE_FOO as *const i32);
+}

tests/ui/statics/recursive_interior_mut.rs

@@ -0,0 +1,20 @@
+// check-pass
+
+use std::cell::Cell;
+use std::ptr::NonNull;
+
+struct ChunkFooter {
+    prev: Cell<NonNull<ChunkFooter>>,
+}
+
+struct EmptyChunkFooter(ChunkFooter);
+
+unsafe impl Sync for EmptyChunkFooter {}
+
+static EMPTY_CHUNK: EmptyChunkFooter = EmptyChunkFooter(ChunkFooter {
+    prev: Cell::new(unsafe {
+        NonNull::new_unchecked(&EMPTY_CHUNK as *const EmptyChunkFooter as *mut ChunkFooter)
+    }),
+});
+
+fn main() {}