<table border="1" cellspacing="0" cellpadding="8">
    <tr>
        <th>Issue</th>
        <td>
            <a href=https://github.com/llvm/llvm-project/issues/135508>135508</a>
        </td>
    </tr>

    <tr>
        <th>Summary</th>
        <td>
            [clang-tidy] Check request: bugprone-union-inactive-member-access
        </td>
    </tr>

    <tr>
      <th>Labels</th>
      <td>
            clang-tidy
      </td>
    </tr>

    <tr>
      <th>Assignees</th>
      <td>
      </td>
    </tr>

    <tr>
      <th>Reporter</th>
      <td>
          denzor200
      </td>
    </tr>
</table>

<pre>
    
Needs a check that will find a reading of a union's field which was executed after another field has been written which remains active.

EXAMPLE:
```
union SimpleUnion {
    int x;
    double y;
};

void process() {
 SimpleUnion u;

    u.x = 10;
    std::cout << "x = " << u.x << std::endl; // OK

    u.y = 3.14;
    std::cout << "y = " << u.x << std::endl; // BAD - looks like a typo, are you meaning `std::cout << "y = " << u.y`??
}
```

In the case when the union's trick used for obtaining a value of another type by reinterpreting the representation of an object, the check will suggest to use `std::memcpy` or even `std::bit_cast` if it's available. The efficiency would remain the same - compilers know how to optimize both of them.

BEFORE:
```
template<typename T>
T perform_type_punning(std::ptrdiff_t offset)
{
    union {
        T memptr;
        std::ptrdiff_t offset_;
    };
    offset_ = offset;
 return memptr;
}
```

AFTER:
```
template<typename T>
T perform_type_punning(std::ptrdiff_t offset)
{
    T memptr;
 std::memcpy(&memptr, &offset, sizeof(offset));
    return memptr;
}
```

AFTER(C++20):
```
template<typename T>
T perform_type_punning(std::ptrdiff_t offset)
{
    return std::bit_cast<T>(offset);
}
```

</pre>
<img width="1" height="1" alt="" src="http://email.email.llvm.org/o/eJy8VU1v4zYQ_TX0ZWCDIv150EF2YqDoxxbbFOgtoKSRxYYiVXJkr_LrC9JKnKRbFNvDCgJEijPz5g3fkCoEfbKIOVvt2epupgZqnc9rtM_OC85npavHnPHiF8Q6gIKqxeoJqFUEF20MNNrWoMCjqrU9gWtAwWC1s0xsAjQaTQ2XVlctXFQA_ILVQFiDagg9KOuoRT-ZtSpAiWjh4jVR_CY_j53SNoCqSJ9xwXjBeHH_R_Hzrz_dMxknbM2nlxcJG37TXW_w9zRmmz3jBQCAtgRfmHyZ1m4oDcJ4_cM2d9OAF2ena-i9qzAEJrZM7F6ivA08vNrHaMPiCzB5Bxm_IQSqY4ayqNxAwOSByQMwIa6WTIiXf1fnNHz1QVsbJvfAxJGJI3z68S3WmCLIRbb8b7Txf6DtizuYg3HuKYDRTwgKaOwdEwdQHmF0A3SobNxytubfgDzGbZLH-F5r_n77GC9-sEAtQqUCwqXF6-wmKfK6eoIhYA2N8-BKUjrloeCszIBJgpOuaOwRyhE8akvoe48ULWNAj73HgJYUxb1MTuDKP7GiSDJlkKSeVB6G0wkDAbmI_I5yh13VR1bgPOAZ7bvVUtNjpQLFdd2ApsRBnZU2qjS4gIcWAZtGVxptNcLFDaaeJJ-SCKpDmEPlul4b9AGerLtA6y4xF9eT7vQzQumojRyoxW7qkP398dPnrzQIYdcbRcjkIZbHxvgPTN4zXjxAj75xvnuMK4_9YGNhmdi-0unJ17ppHglc0wQkJnZpG18kOHzouPg8QIddT_4m1Hdi_Rjy8Wb32pJxMq0mRU3g1zWPNHj7DuSruiqOD_efv3M9PnD_KJp4tKwnCxE7Zv0S5gBBP6NrmNjeIovdrRzfxlpsD0zsmdgLnqJ81yJMqf6zJ-QhYbyl-C9EZnUu653cqRnm2Wa5XO5265WctXmWbQXu1ktcYbnbrlYKq1LWm3qpdtv1hq9nOhdcrPgyE0Jmy0wuNqtsK6XgGVdlJrdbtuSx28zCmHO3cP400yEMmGdyteLbmVElmpCuRyEqo-xpTroemRDxuvR59JqXwymwJTc6ULjFIU0mXaxv3FZ3cEjHise_Bow1KKAcTr13Fuepe-baXm-6eYddiX6uqngNzQZv8paoD7GI6ZA-aWqHclG5joljRJ0-89676zl2TFQCE8eJzTkXfwcAAP__ERpjdg">