src/test/run-make-fulldeps/coverage-reports/expected_show_coverage.async.txt

   1     1|       |#![allow(unused_assignments, dead_code)]
   2     2|       |
   3     3|       |// compile-flags: --edition=2018 -C opt-level=1
   4     4|       |
   5     5|      1|async fn c(x: u8) -> u8 {
   6     6|      1|    if x == 8 {
   7     7|      1|        1
   8     8|       |    } else {
   9     9|      0|        0
  10    10|       |    }
  11    11|      1|}
  12    12|       |
  13    13|      0|async fn d() -> u8 { 1 }
  14    14|       |
  15    15|      0|async fn e() -> u8 { 1 } // unused function; executor does not block on `g()`
  16    16|       |
  17    17|      1|async fn f() -> u8 { 1 }
  18    18|       |
  19    19|      0|async fn foo() -> [bool; 10] { [false; 10] } // unused function; executor does not block on `h()`
  20    20|       |
  21    21|      1|pub async fn g(x: u8) {
  22    22|      0|    match x {
  23    23|      0|        y if e().await == y => (),
  24    24|      0|        y if f().await == y => (),
  25    25|      0|        _ => (),
  26    26|       |    }
  27    27|      0|}
  28    28|       |
  29    29|      1|async fn h(x: usize) { // The function signature is counted when called, but the body is not
  30    30|      0|                       // executed (not awaited) so the open brace has a `0` count (at least when
  31    31|      0|                       // displayed with `llvm-cov show` in color-mode).
  32    32|      0|    match x {
  33    33|      0|        y if foo().await[y] => (),
  34    34|      0|        _ => (),
  35    35|       |    }
  36    36|      0|}
  37    37|       |
  38    38|      1|async fn i(x: u8) { // line coverage is 1, but there are 2 regions:
  39    39|      1|                    // (a) the function signature, counted when the function is called; and
  40    40|      1|                    // (b) the open brace for the function body, counted once when the body is
  41    41|      1|                    // executed asynchronously.
  42    42|      1|    match x {
  43    43|      1|        y if c(x).await == y + 1 => { d().await; }
  44                       ^0                            ^0
  45    44|      1|        y if f().await == y + 1 => (),
  46                       ^0                         ^0
  47    45|      1|        _ => (),
  48    46|       |    }
  49    47|      1|}
  50    48|       |
  51    49|      1|fn j(x: u8) {
  52    50|      1|    // non-async versions of `c()`, `d()`, and `f()` to make it similar to async `i()`.
  53    51|      1|    fn c(x: u8) -> u8 {
  54    52|      1|        if x == 8 {
  55    53|      1|            1 // This line appears covered, but the 1-character expression span covering the `1`
  56                           ^0
  57    54|      1|              // is not executed. (`llvm-cov show` displays a `^0` below the `1` ). This is because
  58    55|      1|              // `fn j()` executes the open brace for the funciton body, followed by the function's
  59    56|      1|              // first executable statement, `match x`. Inner function declarations are not
  60    57|      1|              // "visible" to the MIR for `j()`, so the code region counts all lines between the
  61    58|      1|              // open brace and the first statement as executed, which is, in a sense, true.
  62    59|      1|              // `llvm-cov show` overcomes this kind of situation by showing the actual counts
  63    60|      1|              // of the enclosed coverages, (that is, the `1` expression was not executed, and
  64    61|      1|              // accurately displays a `0`).
  65    62|      1|        } else {
  66    63|      1|            0
  67    64|      1|        }
  68    65|      1|    }
  69    66|      1|    fn d() -> u8 { 1 } // inner function is defined in-line, but the function is not executed
  70                   ^0
  71    67|      1|    fn f() -> u8 { 1 }
  72    68|      1|    match x {
  73    69|      1|        y if c(x) == y + 1 => { d(); }
  74                       ^0                    ^0
  75    70|      1|        y if f() == y + 1 => (),
  76                       ^0                   ^0
  77    71|      1|        _ => (),
  78    72|       |    }
  79    73|      1|}
  80    74|       |
  81    75|      0|fn k(x: u8) { // unused function
  82    76|      0|    match x {
  83    77|      0|        1 => (),
  84    78|      0|        2 => (),
  85    79|      0|        _ => (),
  86    80|       |    }
  87    81|      0|}
  88    82|       |
  89    83|      1|fn l(x: u8) {
  90    84|      1|    match x {
  91    85|      0|        1 => (),
  92    86|      0|        2 => (),
  93    87|      1|        _ => (),
  94    88|       |    }
  95    89|      1|}
  96    90|       |
  97    91|      1|async fn m(x: u8) -> u8 { x - 1 }
  98                                       ^0
  99    92|       |
 100    93|      1|fn main() {
 101    94|      1|    let _ = g(10);
 102    95|      1|    let _ = h(9);
 103    96|      1|    let mut future = Box::pin(i(8));
 104    97|      1|    j(7);
 105    98|      1|    l(6);
 106    99|      1|    let _ = m(5);
 107   100|      1|    executor::block_on(future.as_mut());
 108   101|      1|}
 109   102|       |
 110   103|       |mod executor {
 111   104|       |    use core::{
 112   105|       |        future::Future,
 113   106|       |        pin::Pin,
 114   107|       |        task::{Context, Poll, RawWaker, RawWakerVTable, Waker},
 115   108|       |    };
 116   109|       |
 117   110|      1|    pub fn block_on<F: Future>(mut future: F) -> F::Output {
 118   111|      1|        let mut future = unsafe { Pin::new_unchecked(&mut future) };
 119   112|      1|        use std::hint::unreachable_unchecked;
 120   113|      1|        static VTABLE: RawWakerVTable = RawWakerVTable::new(
 121   114|      1|            |_| unsafe { unreachable_unchecked() }, // clone
 122                               ^0
 123   115|      1|            |_| unsafe { unreachable_unchecked() }, // wake
 124                               ^0
 125   116|      1|            |_| unsafe { unreachable_unchecked() }, // wake_by_ref
 126                               ^0
 127   117|      1|            |_| (),
 128   118|      1|        );
 129   119|      1|        let waker = unsafe { Waker::from_raw(RawWaker::new(core::ptr::null(), &VTABLE)) };
 130   120|      1|        let mut context = Context::from_waker(&waker);
 131   121|       |
 132   122|       |        loop {
 133   123|      1|            if let Poll::Ready(val) = future.as_mut().poll(&mut context) {
 134   124|      1|                break val;
 135   125|      0|            }
 136   126|       |        }
 137   127|      1|    }
 138   128|       |}
 139