Auto merge of #124208 - jieyouxu:rollup-gbgpu4u, r=jieyouxu

Rollup of 10 pull requests

Successful merges:

 - #123379 (Print note with closure signature on type mismatch)
 - #123967 (static_mut_refs: use raw pointers to remove the remaining FIXME)
 - #123976 (Use fake libc in core test)
 - #123986 (lint-docs: Add redirects for renamed lints.)
 - #124053 (coverage: Branch coverage tests for lazy boolean operators)
 - #124071 (Add llvm-bitcode-linker to build manifest)
 - #124103 (Improve std::fs::Metadata Debug representation)
 - #124132 (llvm RustWrapper: explain OpBundlesIndirect argument type)
 - #124191 (Give a name to each distinct manipulation of pretty-printer FixupContext)
 - #124196 (mir-opt tests: rename unit-test -> test-mir-pass)

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

1 files changed, 80 insertions, 0 deletions

diff --git a/tests/coverage/branch/lazy-boolean.rs b/tests/coverage/branch/lazy-boolean.rs
new file mode 100644
index 00000000000..3c73fc1a87d
--- /dev/null
+++ b/tests/coverage/branch/lazy-boolean.rs
@@ -0,0 +1,80 @@
+#![feature(coverage_attribute)]
+//@ edition: 2021
+//@ compile-flags: -Zcoverage-options=branch
+//@ llvm-cov-flags: --show-branches=count
+
+// Tests for branch coverage of the lazy boolean operators `&&` and `||`,
+// as ordinary expressions that aren't part of an `if` condition or similar.
+
+use core::hint::black_box;
+
+// Helper macro to prevent start-of-function spans from being merged into
+// spans on the lines we care about.
+macro_rules! no_merge {
+    () => {
+        for _ in 0..1 {}
+    };
+}
+
+fn branch_and(a: bool, b: bool) {
+    no_merge!();
+
+    //      |13  |18 (no branch)
+    let c = a && b;
+    black_box(c);
+}
+
+fn branch_or(a: bool, b: bool) {
+    no_merge!();
+
+    //      |13  |18 (no branch)
+    let c = a || b;
+    black_box(c);
+}
+
+// Test for chaining one operator several times.
+fn chain(x: u32) {
+    no_merge!();
+
+    //      |13      |22      |31      |40 (no branch)
+    let c = x > 1 && x > 2 && x > 4 && x > 8;
+    black_box(c);
+
+    //      |13      |22      |31      |40 (no branch)
+    let d = x < 1 || x < 2 || x < 4 || x < 8;
+    black_box(d);
+}
+
+// Test for nested combinations of different operators.
+fn nested_mixed(x: u32) {
+    no_merge!();
+
+    //       |14      |23         |35      |44 (no branch)
+    let c = (x < 4 || x >= 9) && (x < 2 || x >= 10);
+    black_box(c);
+
+    //       |14      |23        |34       |44 (no branch)
+    let d = (x < 4 && x < 1) || (x >= 8 && x >= 10);
+    black_box(d);
+}
+
+#[coverage(off)]
+fn main() {
+    // Use each set of arguments (2^n) times, so that each combination has a
+    // unique sum, and we can use those sums to verify expected control flow.
+    // 1x (false, false)
+    // 2x (false, true)
+    // 4x (true, false)
+    // 8x (true, true)
+    for a in [false, true, true, true, true] {
+        for b in [false, true, true] {
+            branch_and(a, b);
+            branch_or(a, b);
+        }
+    }
+
+    for x in 0..16 {
+        chain(x);
+        nested_mixed(x);
+    }
+}