[ADT] Fix a bug in EquivalenceClasses::erase (#161121)
This patch fixes a bug in EquivalenceClasses::erase, where we lose a
leader bit in a certain scenario.
Here is some background. In EquivalenceClasses, each equivalence
class is maintained as a singly linked list over its members. When we
join two classes, we concatenate the two singly linked lists. To
support path compression, each member points to the leader (through
lazy updates). This is implemented with the two members:
class ECValue {
mutable const ECValue *Leader, *Next;
:
};
Each member stores its leader in Leader and its sibling in Next. Now,
the leader uses the Leader field to to point the last element of the
singly linked list to accommodate the list concatenation. We use the
LSB of the Next field to indicate whether a given member is a leader
or not.
Now, imagine we have an equivalence class:
Elem 1 -> Elem 2 -> nullptr
Leader
and wish to remove Elem 2. We would like to end up with:
Elem 1 -> nullptr
Leader
but we mistakenly drop the leader bit when we update the Next field of
Elem 1 with:
Pre->Next = nullptr;
This makes Elem 1 the end of the singly linked list, as intended, but
mistakenly clears its leader bit stored in the LSB of Next, so we end
up with an equivalence class with no leader.
This patch fixes the problem by preserving the leader bit:
Pre->Next = reinterpret_cast<const ECValue *>(
static_cast<intptr_t>(Pre->isLeader()));
The unit test closely follows the scenario above.
