[analyzer] Implemented RangeSet::Factory::castTo function to perform promotions, truncations and conversions

[ASDenysPetrov]

Summary

Handle casts for ranges working similarly to APSIntType::apply function but for the whole range set. Support promotions, truncations and conversions.
Example:
Promotion: char [0, 42] -> short [0, 42] -> int [0, 42] -> llong [0, 42]
Truncation: llong [4295033088, 4295033130] -> int [65792, 65834] -> short [256, 298] -> char [0, 42]
Conversion: char [-42, 42] -> uint [0, 42]U[4294967254, 4294967295] -> short[-42, 42]

[vsavchenko]

OK, about the quadratic algorithm. I can think of one solution that is actually linear asymptotically, but because of the constant factor can be worse in practice (we usually have extremely small range sets). So, while I don't like it, it's probably fine.

clang/include/clang/StaticAnalyzer/Core/PathSensitive/RangedConstraintManager.h

246–247

That is a bit of a red flag because instantly my intuition tells me that there should be a linear option.

clang/lib/StaticAnalyzer/Core/RangeConstraintManager.cpp

682

We have LHS (left-hand side) and RHS (right-hand side) as a common convention for naming operands of binary operators.
The fact that you later on use it as an RHS for unite, doesn't make it a good name.

[vsavchenko]

clang/include/clang/StaticAnalyzer/Core/PathSensitive/RangedConstraintManager.h

249

If we talk about types for ranges, the interface we have is incomplete.
We should introduce something like getType for range sets, so that the user can have a more holistic picture about types and ranges.

clang/lib/StaticAnalyzer/Core/RangeConstraintManager.cpp

687

That's incorrect. uint64_t holds exactly this many values. If you count every number from 0 to UINT64_MAX, you get UINT64_MAX + 1, which is the number you are talking about.
Maybe you want to talk about the maximum stored value?

691–720

I think we should have a shortcut for widening casts, where we don't need to go and unite them. We just literally need to convert every range from one type to another and be done with it.

clang/unittests/StaticAnalyzer/RangeSetTest.cpp

137–149

I don't really understand what's going on here.

651–652

Yes, please.

700

Test cases don't belong in RangeSetTest.

Each piece of code like this should be a separate test case.

[ASDenysPetrov]

@vsavchenko Repled in inlines. Preparing an update.

clang/include/clang/StaticAnalyzer/Core/PathSensitive/RangedConstraintManager.h

246–247

Unfortunately, castTo is N^2 because technically we can call unite(which is N) inside it N times.

249

+1. Is there any place where we can put tasks as tech debt or just keep noting with FIXME/TODO's?

clang/lib/StaticAnalyzer/Core/RangeConstraintManager.cpp

682

What about Tmp?

687

Maybe you want to talk about the maximum stored value?

Yes. I should rephrase the comment.
E.g.: 128 is an amount of all possible values of char and we can't keep it inside char.

691–720

we don't need to go and unite them.

Um, yes. 'unite' only needed for truncated range sets which have more then one range. I'll try to refactor this.
That will help make the algorithm linear for most cases.

clang/unittests/StaticAnalyzer/RangeSetTest.cpp

137–149

This is a generalized version of from function. But this one you can use independently from which type the current test case uses. You can set a custom type to get a range set for a given type. This allows to get range sets based on different types (e.g. char and int) in a single test case.
Previously from produced range sets only for the type specified by a test case.

[ASDenysPetrov]

clang/include/clang/StaticAnalyzer/Core/PathSensitive/RangedConstraintManager.h

246–247

Corrected.
Unfortunately, castTo is N^2 because technically we can call unite(which is N+M) inside it N times.

[vsavchenko]

clang/include/clang/StaticAnalyzer/Core/PathSensitive/RangedConstraintManager.h

246–247

Unfortunately, castTo is N^2 because technically we can call unite(which is N) inside it N times.

I know why you put N^2, and what I meant was that there is probably a better algorithm than that.

And as I said there is a linear algorithm:
If you have a smaller type that is, let's say, 8 times smaller than the larger type. We can split the original range set into 8 range sets and unite them.
This difference between type sizes is limited (because we don't support integer types of arbitrary bit width) aka is a constant. However, IRL the size of range sets is very small, and this constant factor can make it much slower than your N^2 algorithm.

But it doesn't mean that there is no better algorithm and that you HAVE TO call unite in a loop N times.

[vsavchenko]

clang/lib/StaticAnalyzer/Core/RangeConstraintManager.cpp

682

Maybe something like Dummy or Intermediate.

clang/unittests/StaticAnalyzer/RangeSetTest.cpp

137–149

OK then, if you make this from templated, make all of them templated and you won't need to duplicate the logic with sizeof * 8 everywhere.

[ASDenysPetrov]

Made changes according to comments. Optimized castTo function for each cast case. Simplified unit test.

[vsavchenko]

clang/lib/StaticAnalyzer/Core/RangeConstraintManager.cpp

356–366

We should add assert(!isEmpty()); in all three

702–733

Maybe we can extract this into something like truncateTo and the next if to convertTo private methods?

clang/unittests/StaticAnalyzer/RangeSetTest.cpp

121–122

Great, that works too!

124

Default to BaseType?

127

Default to BaseType?

131–132

Default to BaseType?

132

Unused parameter?

726–804

If loop and promotion share the same test case, why should we split them into two groups?

[ASDenysPetrov]

I'll update tommorow.

clang/unittests/StaticAnalyzer/RangeSetTest.cpp

124

It's implicitly deduced. I think it is not necessary.

132

Oh... :-)

726–804

Yes, the tests are identical but they use different testing::Types in the suites. Also I don't want to mix them to make problem localizing easier if occurs. But still I haven't strong preferences on that.

[ASDenysPetrov]

Added assertions. Added two helper functions for castTo method. Moved some distinct code to them. Fixed clang-tidy complaints.

[ASDenysPetrov]

Rebased

[ASDenysPetrov]

Rebased.

[ASDenysPetrov]

Rebased.

[ASDenysPetrov]

Fixed missed part during rebasing in the unit test.

[ASDenysPetrov]

Ping.

[martong]

In D103094#3403075, @ASDenysPetrov wrote:

Ping.

I am still interested in this! I am sorry for being inactive with it lately, I hope I'll have time soon to continue the review of this patch stack.

[martong]

Thanks for you patience Denys! Finally I had some time for the review. Nice work!

clang/include/clang/StaticAnalyzer/Core/PathSensitive/RangedConstraintManager.h

242

clang/lib/StaticAnalyzer/Core/RangeConstraintManager.cpp

358

Probably it is unrelated to this patch, but
Could it happen that (++begin())->From().isUnsigned() gives a different signedness? Or we had a separate assertion when we added the second Range? The same question applies to the below two functions as well. Seems like in unite we don't have such validity check...

687

Could you please explain why do we need the || !What.isUnsigned() part of the condition?

This would make much more sense to me:

if (IsConversion && !IsPromotion)
    return makePersistent(convertTo(What, Ty));

690

This comment is confusing, since we can get here also if
isConversion is false and
isPromotion is false

690–711

I think it would be more consistent with the other operations (truncate and convert) if we had this logic in its own separate function: promoteTo. And this function should be called only if isPromotion is set (?)

740–741

?

773

We could certainly have a better name for this. E.g. SecondHalf. (And FirstHalf instead of Result?)

774–791

I think this comment would be better positioned as a header comment for the entire function.

792

Why not -> Range?

802

Would it be a better name:LastConvertedInt? The naming From is confusing because that suggests the value we cast from, however, this variable refers to the casted to values, isn't it?

812–814

I think this case (wrap) deserves a comment.

clang/unittests/StaticAnalyzer/RangeSetTest.cpp

731

It doesn't matter, becasue T and F are equal here, but for consistency with the other tests.

830

I am getting lost. Why don't you check against ToMIN and ToMAX here? Could you explain e.g. with int16->int8?

It is confusing that at many places you test against MIN, MAX, A, ... and the conversion is happening automatically by the checkCastTo template. Would it be more explicit to use everywhere ToMIN, ToA, ToB, ... and check against them?

877–882

Could you please elaborate what do we test here?

[ASDenysPetrov]

clang/lib/StaticAnalyzer/Core/RangeConstraintManager.cpp

358

Or we had a separate assertion when we added the second Range?

I didn't find any assertion while adding.
Moreover, I'm not sure if there can happen APSInts of different types in a single Range. We only have assert(From < To) in a ctor.

Seems like in unite we don't have such validity check...

Not only unite doesn't have such, but all the rest don't as well. We rely on a fact that the caller garantees the validity of RangeSet by using AdjustmentType.
But, yes, it's worth to make some checks.

687

Look. Here we handle 2 cases:

• IsConversion && !IsPromotion. In this case we handle changing a sign with same bitwidth: char -> uchar, uint -> int. Here we convert negatives to positives and positives which is out of range to negatives. We use convertTo function for that.
• IsConversion && IsPromotion && !What.isUnsigned(). In this case we handle changing a sign from signeds to unsigneds with higher bitwidth: char -> uint, int-> uint64. The point is that we also need convert negatives to positives and use convertTo function as well. For example, we don't need such a convertion when converting unsigned to signed with higher bitwidth, because all the values of unsigned is valid for the such signed.

690

Nothing confusing is here.
We have 7 main cases:
NOOP: u -> u, s -> s
Conversion: u -> s, s -> u
Truncation: U-> u, S -> s
Promotion: u->U, s -> S
Truncation + Conversion: U -> s, S -> u
Promotion + Conversion: s -> U, u -> S

As you can see, we've handled all the bolds above this line .
So only promotions from unsigneds left. That means, isPromotion never should be false here. We could add an assertion here if you want.

690–711

That makes sense. I'll do.

792

Because Range requires from < to in its contract. But I need to store the values after conversions. You can see a check if (NewBounds.first > NewBounds.second) on line #812.

clang/unittests/StaticAnalyzer/RangeSetTest.cpp

830

We can't use ToMIN, ToMAX, ... everywhere. That would be incorrect:
int16(-32768, 32767) -> int8(-128, 127), aka (MIN, MAX) -> (ToMIN, ToMAX) // OK.
int16(-32768, -32768) -> int8(-128, -128), aka (MIN, MIN) -> (ToMIN, ToMIN) // NOK.
int16(-32768,-32768) -> int8(0, 0), aka (MIN, MIN) -> ((int8)MIN, (int8)MIN) // OK.

877–882

E.g.

                 RangeA                   U                   RangeB
(0000'1111'0000'0100, 0000'1111'0000'0111)U(1111'0000'0000'0100, 1111'0000'0000'0111)
truncates to
                 RangeC                   U                   RangeC
(          0000'0100,           0000'0111)U(          0000'0100,           0000'0111)
As you can see, we got two equal truncated ranges.
                           RangeC
Then unite them to (0000'0100, 0000'0111).

[ASDenysPetrov]

Updated according to suggestions.
@martong thank you for the review.

[martong]

Thanks, LGTM! With minor revisions.

clang/lib/StaticAnalyzer/Core/RangeConstraintManager.cpp

687

Ok, makes sense. Could you please attach your explanation as a comment then into the code?

690

So only promotions from unsigneds left. That means, isPromotion never should be false here. We could add an assertion here if you want.

Yeah, I think that would be useful, to enforce that the precondition for promoteTo holds all the time (even after future changes).

749

clang/unittests/StaticAnalyzer/RangeSetTest.cpp

830

Okay makes sense, thanks for the explanation. Nevertheless, I think this explanatory comment would be useful to have in the code.

877–882

Ok.

[ASDenysPetrov]

Loaded with comment updateds according to the remarks.
@martong thank you for your time for the review!

clang/include/clang/StaticAnalyzer/Core/PathSensitive/APSIntType.h

 namespace ento {
 
 /// A record of the "type" of an APSInt, used for conversions.
 class APSIntType {
   uint32_t BitWidth;
   bool IsUnsigned;
 
 public:
-  APSIntType(uint32_t Width, bool Unsigned)
+  constexpr APSIntType(uint32_t Width, bool Unsigned)
       : BitWidth(Width), IsUnsigned(Unsigned) {}
 
   /* implicit */ APSIntType(const llvm::APSInt &Value)
     : BitWidth(Value.getBitWidth()), IsUnsigned(Value.isUnsigned()) {}
 
   uint32_t getBitWidth() const { return BitWidth; }
   bool isUnsigned() const { return IsUnsigned; }
 
   /// Convert a given APSInt, in place, to match this type.

clang/include/clang/StaticAnalyzer/Core/PathSensitive/RangedConstraintManager.h

public:
     /// Negate restores disrupted ranges on bounds,
     /// e.g. [MIN, B] => [MIN, MIN] U [-B, MAX] => [MIN, B].
     ///
     /// Negate is a self-inverse function, i.e. negate(negate(R)) == R.
     ///
     /// Complexity: O(N)
     ///             where N = size(What)
     RangeSet negate(RangeSet What);
+    /// Performs promotions, truncations and conversions of the given set.
+    ///
+    /// This function is optimized for each of the six cast cases:
+    /// - noop
+    /// - conversion
+    /// - truncation
+    /// - truncation-conversion
+    /// - promotion
+    /// - promotion-conversion
+    ///
+    /// NOTE: This function is NOT self-inverse for truncations, because of
+    ///       the higher bits loss:
+    ///     - castTo(castTo(OrigRangeOfInt, char), int) != OrigRangeOfInt.
+    ///     - castTo(castTo(OrigRangeOfChar, int), char) == OrigRangeOfChar.
+    ///       But it is self-inverse for all the rest casts.
+    ///
+    /// Complexity:
+    ///     - Noop                               O(1);
+    ///     - Truncation                         O(N^2);
+    ///     - Another case                       O(N);
+    ///     where N = size(What)
+    RangeSet castTo(RangeSet What, APSIntType Ty);
+    RangeSet castTo(RangeSet What, QualType T);
 
     /// Return associated value factory.
     BasicValueFactory &getValueFactory() const { return ValueFactory; }
 
   private:
     /// Return a persistent version of the given container.
     RangeSet makePersistent(ContainerType &&From);
     /// Construct a new persistent version of the given container.
     ContainerType *construct(ContainerType &&From);
 
     RangeSet intersect(const ContainerType &LHS, const ContainerType &RHS);
     /// NOTE: This function relies on the fact that all values in the
     /// containers are persistent (created via BasicValueFactory::getValue).
     ContainerType unite(const ContainerType &LHS, const ContainerType &RHS);
 
+    /// This is a helper function for `castTo` method. Implies not to be used
+    /// separately.
+    /// Performs a truncation case of a cast operation.
+    ContainerType truncateTo(RangeSet What, APSIntType Ty);
+
+    /// This is a helper function for `castTo` method. Implies not to be used
+    /// separately.
+    /// Performs a conversion case and a promotion-conversion case for signeds
+    /// of a cast operation.
+    ContainerType convertTo(RangeSet What, APSIntType Ty);
+
+    /// This is a helper function for `castTo` method. Implies not to be used
+    /// separately.
+    /// Performs a promotion for unsigneds only.
+    ContainerType promoteTo(RangeSet What, APSIntType Ty);
+
     // Many operations include producing new APSInt values and that's why
     // we need this factory.
     BasicValueFactory &ValueFactory;
     // Allocator for all the created containers.
     // Containers might own their own memory and that's why it is specific
     // for the type, so it calls container destructors upon deletion.
     llvm::SpecificBumpPtrAllocator<ContainerType> Arena;
     // Usually we deal with the same ranges and range sets over and over.
public:
   ///
   /// Complexity: O(1)
   const llvm::APSInt &getMinValue() const;
   /// Get the maximal value covered by the ranges in the set.
   ///
   /// Complexity: O(1)
   const llvm::APSInt &getMaxValue() const;
 
+  bool isUnsigned() const;
+  uint32_t getBitWidth() const;
+  APSIntType getAPSIntType() const;
+
   /// Test whether the given point is contained by any of the ranges.
   ///
   /// Complexity: O(logN)
   ///             where N = size(this)
   bool contains(llvm::APSInt Point) const { return containsImpl(Point); }
 
   bool containsZero() const {
     APSIntType T{getMinValue()};

clang/lib/StaticAnalyzer/Core/RangeConstraintManager.cpp

const llvm::APSInt &RangeSet::getMinValue() const {
   return begin()->From();
 }
 
 const llvm::APSInt &RangeSet::getMaxValue() const {
   assert(!isEmpty());
   return std::prev(end())->To();
 }
 
+bool clang::ento::RangeSet::isUnsigned() const {
+  assert(!isEmpty());
+  return begin()->From().isUnsigned();
+}
+
+uint32_t clang::ento::RangeSet::getBitWidth() const {
+  assert(!isEmpty());
+  return begin()->From().getBitWidth();
+}
+
+APSIntType clang::ento::RangeSet::getAPSIntType() const {
+  assert(!isEmpty());
+  return APSIntType(begin()->From());
+}
+
 bool RangeSet::containsImpl(llvm::APSInt &Point) const {
   if (isEmpty() || !pin(Point))
     return false;
 
   Range Dummy(Point);
   const_iterator It = llvm::upper_bound(*this, Dummy);
   if (It == begin())
     return false;
for (; It != End; ++It) {
     // Add a negated range.
     Result.emplace_back(NewFrom, NewTo);
   }
 
   llvm::sort(Result);
   return makePersistent(std::move(Result));
 }
 
+// Convert range set to the given integral type using truncation and promotion.
+// This works similar to APSIntType::apply function but for the range set.
+RangeSet RangeSet::Factory::castTo(RangeSet What, APSIntType Ty) {
+  // Set is empty or NOOP (aka cast to the same type).
+  if (What.isEmpty() || What.getAPSIntType() == Ty)
+    return What;
+
+  const bool IsConversion = What.isUnsigned() != Ty.isUnsigned();
+  const bool IsTruncation = What.getBitWidth() > Ty.getBitWidth();
+  const bool IsPromotion = What.getBitWidth() < Ty.getBitWidth();
+
+  if (IsTruncation)
+    return makePersistent(truncateTo(What, Ty));
+
+  if (IsConversion && (!IsPromotion || !What.isUnsigned()))
+    return makePersistent(convertTo(What, Ty));
+
+  return makePersistent(promoteTo(What, Ty));
+}
+
+RangeSet RangeSet::Factory::castTo(RangeSet What, QualType T) {
+  assert(T->isIntegralOrEnumerationType() && "T shall be an integral type.");
+  return castTo(What, ValueFactory.getAPSIntType(T));
+}
+
+RangeSet::ContainerType RangeSet::Factory::truncateTo(RangeSet What,
+                                                      APSIntType Ty) {
+  using llvm::APInt;
+  using llvm::APSInt;
+  ContainerType Result;
+  ContainerType Dummy;
+  // CastRangeSize is an amount of all possible values of cast type.
+  // Example: `char` has 256 values; `short` has 65536 values.
+  // But in fact we use `amount of values` - 1, because
+  // we can't keep `amount of values of UINT64` inside uint64_t.
+  // E.g. 256 is an amount of all possible values of `char` and we can't keep
+  // it inside `char`.
+  // And it's OK, it's enough to do correct calculations.
+  uint64_t CastRangeSize = APInt::getMaxValue(Ty.getBitWidth()).getZExtValue();
+  for (const Range &R : What) {
+    // Get bounds of the given range.
+    APSInt FromInt = R.From();
+    APSInt ToInt = R.To();
+    // CurrentRangeSize is an amount of all possible values of the current
+    // range minus one.
+    uint64_t CurrentRangeSize = (ToInt - FromInt).getZExtValue();
+    // This is an optimization for a specific case when this Range covers
+    // the whole range of the target type.
+    Dummy.clear();
+    if (CurrentRangeSize >= CastRangeSize) {
+      Dummy.emplace_back(ValueFactory.getMinValue(Ty),
+                         ValueFactory.getMaxValue(Ty));
+      Result = std::move(Dummy);
+      break;
+    }
+    // Cast the bounds.
+    Ty.apply(FromInt);
+    Ty.apply(ToInt);
+    const APSInt &PersistentFrom = ValueFactory.getValue(FromInt);
+    const APSInt &PersistentTo = ValueFactory.getValue(ToInt);
+    if (FromInt > ToInt) {
+      Dummy.emplace_back(ValueFactory.getMinValue(Ty), PersistentTo);
+      Dummy.emplace_back(PersistentFrom, ValueFactory.getMaxValue(Ty));
+    } else
+      Dummy.emplace_back(PersistentFrom, PersistentTo);
+    // Every range retrieved after truncation potentialy has garbage values.
+    // So, we have to unite every next range with the previouses.
+    Result = unite(Result, Dummy);
+  }
+
+  return Result;
+}
+
+// Divide the convertion into two phases (presented as loops here).
+// First phase(loop) works when casted values go in ascending order.
+// E.g. char{1,3,5,127} -> uint{1,3,5,127}
+// Interrupt the first phase and go to second one when casted values start
+// go in descending order. That means that we crossed over the middle of
+// the type value set (aka 0 for signeds and MAX/2+1 for unsigneds).
+// For instance:
+// 1: uchar{1,3,5,128,255} -> char{1,3,5,-128,-1}
+//    Here we put {1,3,5} to one array and {-128, -1} to another
+// 2: char{-128,-127,-1,0,1,2} -> uchar{128,129,255,0,1,3}
+//    Here we put {128,129,255} to one array and {0,1,3} to another.
+// After that we unite both arrays.
+// NOTE: We don't just concatenate the arrays, because they may have
+// adjacent ranges, e.g.:
+// 1: char(-128, 127) -> uchar -> arr1(128, 255), arr2(0, 127) ->
+//    unite -> uchar(0, 255)
+// 2: uchar(0, 1)U(254, 255) -> char -> arr1(0, 1), arr2(-2, -1) ->
+//    unite -> uchar(-2, 1)
+RangeSet::ContainerType RangeSet::Factory::convertTo(RangeSet What,
+                                                     APSIntType Ty) {
+  using llvm::APInt;
+  using llvm::APSInt;
+  using Bounds = std::pair<const APSInt &, const APSInt &>;
+  ContainerType AscendArray;
+  ContainerType DescendArray;
+  auto CastRange = [Ty, &VF = ValueFactory](const Range &R) -> Bounds {
+    // Get bounds of the given range.
+    APSInt FromInt = R.From();
+    APSInt ToInt = R.To();
+    // Cast the bounds.
+    Ty.apply(FromInt);
+    Ty.apply(ToInt);
+    return {VF.getValue(FromInt), VF.getValue(ToInt)};
+  };
+  // Phase 1. Fill the first array.
+  APSInt LastConvertedInt = Ty.getMinValue();
+  const auto *It = What.begin();
+  const auto *E = What.end();
+  while (It != E) {
+    Bounds NewBounds = CastRange(*(It++));
+    // If values stop going acsending order, go to the second phase(loop).
+    if (NewBounds.first < LastConvertedInt) {
+      DescendArray.emplace_back(NewBounds.first, NewBounds.second);
+      break;
+    }
+    // If the range contains a midpoint, then split the range.
+    // E.g. char(-5, 5) -> uchar(251, 5)
+    // Here we shall add a range (251, 255) to the first array and (0, 5) to the
+    // second one.
+    if (NewBounds.first > NewBounds.second) {
+      DescendArray.emplace_back(ValueFactory.getMinValue(Ty), NewBounds.second);
+      AscendArray.emplace_back(NewBounds.first, ValueFactory.getMaxValue(Ty));
+    } else
+      // Values are going acsending order.
+      AscendArray.emplace_back(NewBounds.first, NewBounds.second);
+    LastConvertedInt = NewBounds.first;
+  }
+  // Phase 2. Fill the second array.
+  while (It != E) {
+    Bounds NewBounds = CastRange(*(It++));
+    DescendArray.emplace_back(NewBounds.first, NewBounds.second);
+  }
+  // Unite both arrays.
+  return unite(AscendArray, DescendArray);
+}
+
+/// Promotion from unsigneds to signeds/unsigneds left.
+RangeSet::ContainerType RangeSet::Factory::promoteTo(RangeSet What,
+                                                     APSIntType Ty) {
+  ContainerType Result;
+  // We definitely know the size of the result set.
+  Result.reserve(What.size());
+
+  // Each unsigned value fits every larger type without any changes,
+  // whether the larger type is signed or unsigned. So just promote and push
+  // back each range one by one.
+  for (const Range &R : What) {
+    // Get bounds of the given range.
+    llvm::APSInt FromInt = R.From();
+    llvm::APSInt ToInt = R.To();
+    // Cast the bounds.
+    Ty.apply(FromInt);
+    Ty.apply(ToInt);
+    Result.emplace_back(ValueFactory.getValue(FromInt),
+                        ValueFactory.getValue(ToInt));
+  }
+  return Result;
+}
+
 RangeSet RangeSet::Factory::deletePoint(RangeSet From,
                                         const llvm::APSInt &Point) {
   if (!From.contains(Point))
     return From;
 
   llvm::APSInt Upper = Point;
   llvm::APSInt Lower = Point;
 

clang/unittests/StaticAnalyzer/RangeSetTest.cpp

LLVM_ATTRIBUTE_UNUSED static std::ostream &operator<<(std::ostream &OS,
                                                       const RangeSet &Set) {
   return OS << toString(Set);
 }
 // We need it here for better fail diagnostics from gtest.
 LLVM_ATTRIBUTE_UNUSED static std::ostream &operator<<(std::ostream &OS,
                                                       const Range &R) {
   return OS << toString(R);
 }
+LLVM_ATTRIBUTE_UNUSED static std::ostream &operator<<(std::ostream &OS,
+                                                      APSIntType Ty) {
+  return OS << (Ty.isUnsigned() ? "u" : "s") << Ty.getBitWidth();
+}
 
 } // namespace ento
 } // namespace clang
 
 namespace {
 
+template <class T> constexpr bool is_signed_v = std::is_signed<T>::value;
+
 template <typename T> struct TestValues {
   static constexpr T MIN = std::numeric_limits<T>::min();
   static constexpr T MAX = std::numeric_limits<T>::max();
   // MID is a value in the middle of the range
   // which unary minus does not affect on,
   // e.g. int8/int32(0), uint8(128), uint32(2147483648).
   static constexpr T MID =
-      std::is_signed<T>::value ? 0 : ~(static_cast<T>(-1) / static_cast<T>(2));
+      is_signed_v<T> ? 0 : ~(static_cast<T>(-1) / static_cast<T>(2));
   static constexpr T A = MID - (MAX - MID) / 3 * 2;
   static constexpr T B = MID - (MAX - MID) / 3;
   static constexpr T C = -B;
   static constexpr T D = -A;
 
   static_assert(MIN < A && A < B && B < MID && MID < C && C < D && D < MAX,
                 "Values shall be in an ascending order");
+  // Clear bits in low bytes by the given amount.
+  template <T Value, size_t Bytes>
+  static constexpr T ClearLowBytes =
+      static_cast<T>(static_cast<uint64_t>(Value)
+                     << ((Bytes >= CHAR_BIT) ? 0 : Bytes) * CHAR_BIT);
+
+  template <T Value, typename Base>
+  static constexpr T TruncZeroOf = ClearLowBytes<Value + 1, sizeof(Base)>;
+
+  // Random number with active bits in every byte. 0xAAAA'AAAA
+  static constexpr T XAAA = static_cast<T>(
+      0b10101010'10101010'10101010'10101010'10101010'10101010'10101010'10101010);
+  template <typename Base>
+  static constexpr T XAAATruncZeroOf = TruncZeroOf<XAAA, Base>; // 0xAAAA'AB00
+
+  // Random number with active bits in every byte. 0x5555'5555
+  static constexpr T X555 = static_cast<T>(
+      0b01010101'01010101'01010101'01010101'01010101'01010101'01010101'01010101);
+  template <typename Base>
+  static constexpr T X555TruncZeroOf = TruncZeroOf<X555, Base>; // 0x5555'5600
+
+  // Numbers for ranges with the same bits in the lowest byte.
+  // 0xAAAA'AA2A
+  static constexpr T FromA = ClearLowBytes<XAAA, sizeof(T) - 1> + 42;
+  static constexpr T ToA = FromA + 2; // 0xAAAA'AA2C
+  // 0x5555'552A
+  static constexpr T FromB = ClearLowBytes<X555, sizeof(T) - 1> + 42;
+  static constexpr T ToB = FromB + 2; // 0x5555'552C
 };
 
+template <typename T>
+static constexpr APSIntType APSIntTy =
+    APSIntType(sizeof(T) * CHAR_BIT, !is_signed_v<T>);
+
 template <typename BaseType> class RangeSetTest : public testing::Test {
 public:
   // Init block
   std::unique_ptr<ASTUnit> AST = tooling::buildASTFromCode("struct foo;");
   ASTContext &Context = AST->getASTContext();
   llvm::BumpPtrAllocator Arena;
   BasicValueFactory BVF{Context, Arena};
   RangeSet::Factory F{BVF};
   // End init block
 
   using Self = RangeSetTest<BaseType>;
-  using RawRange = std::pair<BaseType, BaseType>;
-  using RawRangeSet = std::initializer_list<RawRange>;
-
-  const llvm::APSInt &from(BaseType X) {
-    static llvm::APSInt Base{sizeof(BaseType) * CHAR_BIT,
-                             std::is_unsigned<BaseType>::value};
-    Base = X;
-    return BVF.getValue(Base);
+  template <typename T> using RawRangeT = std::pair<T, T>;
+  template <typename T>
+  using RawRangeSetT = std::initializer_list<RawRangeT<T>>;
+  using RawRange = RawRangeT<BaseType>;
+  using RawRangeSet = RawRangeSetT<BaseType>;
+
+  template <typename T> const llvm::APSInt &from(T X) {
+    static llvm::APSInt Int = APSIntTy<T>.getZeroValue();
+    Int = X;
+    return BVF.getValue(Int);
   }
 
-  Range from(const RawRange &Init) {
+  template <typename T> Range from(const RawRangeT<T> &Init) {
     return Range(from(Init.first), from(Init.second));
   }
 
-  RangeSet from(const RawRangeSet &Init) {
+  template <typename T>
+  RangeSet from(RawRangeSetT<T> Init, APSIntType Ty = APSIntTy<BaseType>) {
     RangeSet RangeSet = F.getEmptySet();
     for (const auto &Raw : Init) {
       RangeSet = F.add(RangeSet, from(Raw));
     }
     return RangeSet;
   }
 
   template <class F, class... RawArgTypes>
   void wrap(F ActualFunction, RawArgTypes &&... Args) {
     (this->*ActualFunction)(from(std::forward<RawArgTypes>(Args))...);
   }
 
   void checkNegateImpl(RangeSet Original, RangeSet Expected) {
     RangeSet NegatedFromOriginal = F.negate(Original);
     EXPECT_EQ(NegatedFromOriginal, Expected);
     // Negate negated back and check with original.
     RangeSet NegatedBackward = F.negate(NegatedFromOriginal);
     EXPECT_EQ(NegatedBackward, Original);
   }
 
   void checkNegate(RawRangeSet RawOriginal, RawRangeSet RawExpected) {
     wrap(&Self::checkNegateImpl, RawOriginal, RawExpected);
   }
 
   template <class PointOrSet>
void checkDeleteImpl(const llvm::APSInt &Point, RangeSet From,
     EXPECT_EQ(Result, Expected)
         << "while deleting " << toString(Point) << " from " << toString(From);
   }
 
   void checkDelete(BaseType Point, RawRangeSet RawFrom,
                    RawRangeSet RawExpected) {
     wrap(&Self::checkDeleteImpl, Point, RawFrom, RawExpected);
   }
-};
 
-} // namespace
+  void checkCastToImpl(RangeSet What, APSIntType Ty, RangeSet Expected) {
+    RangeSet Result = F.castTo(What, Ty);
+    EXPECT_EQ(Result, Expected)
+        << "while casting " << toString(What) << " to " << Ty;
+  }
+
+  template <typename From, typename To>
+  void checkCastTo(RawRangeSetT<From> What, RawRangeSetT<To> Expected) {
+    static constexpr APSIntType FromTy = APSIntTy<From>;
+    static constexpr APSIntType ToTy = APSIntTy<To>;
+    this->checkCastToImpl(from(What, FromTy), ToTy, from(Expected, ToTy));
+  }
+};
 
 using IntTypes = ::testing::Types<int8_t, uint8_t, int16_t, uint16_t, int32_t,
                                   uint32_t, int64_t, uint64_t>;
 TYPED_TEST_SUITE(RangeSetTest, IntTypes, );
 
 TYPED_TEST(RangeSetTest, RangeSetNegateTest) {
   using TV = TestValues<TypeParam>;
   constexpr auto MIN = TV::MIN;
TYPED_TEST(RangeSetTest, RangeSetUniteTest) {
   //
   // RSLT =>     ___________   _____   __
   //        _/\_/___________\_/_____\_/__\_
   this->checkUnite({{MIN, MIN}, {B, MID}, {MID + 1, C}, {C + 4, D - 1}},
                    {{A, B - 1}, {B + 1, C - 1}, {C + 2, D}, {MAX - 1, MAX}},
                    {{MIN, MIN}, {A, C}, {C + 2, D}, {MAX - 1, MAX}});
   // clang-format on
 }
+
+template <typename From, typename To> struct CastType {
+  using FromType = From;
+  using ToType = To;
+};
+
+template <typename Type>
+class RangeSetCastToNoopTest : public RangeSetTest<typename Type::FromType> {};
+template <typename Type>
+class RangeSetCastToPromotionTest
+    : public RangeSetTest<typename Type::FromType> {};
+template <typename Type>
+class RangeSetCastToTruncationTest
+    : public RangeSetTest<typename Type::FromType> {};
+template <typename Type>
+class RangeSetCastToConversionTest
+    : public RangeSetTest<typename Type::FromType> {};
+template <typename Type>
+class RangeSetCastToPromotionConversionTest
+    : public RangeSetTest<typename Type::FromType> {};
+template <typename Type>
+class RangeSetCastToTruncationConversionTest
+    : public RangeSetTest<typename Type::FromType> {};
+
+using NoopCastTypes =
+    ::testing::Types<CastType<int8_t, int8_t>, CastType<uint8_t, uint8_t>,
+                     CastType<int16_t, int16_t>, CastType<uint16_t, uint16_t>,
+                     CastType<int32_t, int32_t>, CastType<uint32_t, uint32_t>,
+                     CastType<int64_t, int64_t>, CastType<uint64_t, uint64_t>>;
+
+using PromotionCastTypes =
+    ::testing::Types<CastType<int8_t, int16_t>, CastType<int8_t, int32_t>,
+                     CastType<int8_t, int64_t>, CastType<uint8_t, uint16_t>,
+                     CastType<uint8_t, uint32_t>, CastType<uint8_t, uint64_t>,
+                     CastType<int16_t, int32_t>, CastType<int16_t, int64_t>,
+                     CastType<uint16_t, uint32_t>, CastType<uint16_t, uint64_t>,
+                     CastType<int32_t, int64_t>, CastType<uint32_t, uint64_t>>;
+
+using TruncationCastTypes =
+    ::testing::Types<CastType<int16_t, int8_t>, CastType<uint16_t, uint8_t>,
+                     CastType<int32_t, int16_t>, CastType<int32_t, int8_t>,
+                     CastType<uint32_t, uint16_t>, CastType<uint32_t, uint8_t>,
+                     CastType<int64_t, int32_t>, CastType<int64_t, int16_t>,
+                     CastType<int64_t, int8_t>, CastType<uint64_t, uint32_t>,
+                     CastType<uint64_t, uint16_t>, CastType<uint64_t, uint8_t>>;
+
+using ConversionCastTypes =
+    ::testing::Types<CastType<int8_t, uint8_t>, CastType<uint8_t, int8_t>,
+                     CastType<int16_t, uint16_t>, CastType<uint16_t, int16_t>,
+                     CastType<int32_t, uint32_t>, CastType<uint32_t, int32_t>,
+                     CastType<int64_t, uint64_t>, CastType<uint64_t, int64_t>>;
+
+using PromotionConversionCastTypes =
+    ::testing::Types<CastType<int8_t, uint16_t>, CastType<int8_t, uint32_t>,
+                     CastType<int8_t, uint64_t>, CastType<uint8_t, int16_t>,
+                     CastType<uint8_t, int32_t>, CastType<uint8_t, int64_t>,
+                     CastType<int16_t, uint32_t>, CastType<int16_t, uint64_t>,
+                     CastType<uint16_t, int32_t>, CastType<uint16_t, int64_t>,
+                     CastType<int32_t, uint64_t>, CastType<uint32_t, int64_t>>;
+
+using TruncationConversionCastTypes =
+    ::testing::Types<CastType<int16_t, uint8_t>, CastType<uint16_t, int8_t>,
+                     CastType<int32_t, uint16_t>, CastType<int32_t, uint8_t>,
+                     CastType<uint32_t, int16_t>, CastType<uint32_t, int8_t>,
+                     CastType<int64_t, uint32_t>, CastType<int64_t, uint16_t>,
+                     CastType<int64_t, uint8_t>, CastType<uint64_t, int32_t>,
+                     CastType<uint64_t, int16_t>, CastType<uint64_t, int8_t>>;
+
+TYPED_TEST_SUITE(RangeSetCastToNoopTest, NoopCastTypes);
+TYPED_TEST_SUITE(RangeSetCastToPromotionTest, PromotionCastTypes);
+TYPED_TEST_SUITE(RangeSetCastToTruncationTest, TruncationCastTypes);
+TYPED_TEST_SUITE(RangeSetCastToConversionTest, ConversionCastTypes);
+TYPED_TEST_SUITE(RangeSetCastToPromotionConversionTest,
+                 PromotionConversionCastTypes);
+TYPED_TEST_SUITE(RangeSetCastToTruncationConversionTest,
+                 TruncationConversionCastTypes);
+
+TYPED_TEST(RangeSetCastToNoopTest, RangeSetCastToNoopTest) {
+  // Just to reduce the verbosity.
+  using F = typename TypeParam::FromType; // From
+  using T = typename TypeParam::ToType;   // To
+
+  using TV = TestValues<F>;
+  constexpr auto MIN = TV::MIN;
+  constexpr auto MAX = TV::MAX;
+  constexpr auto MID = TV::MID;
+  constexpr auto B = TV::B;
+  constexpr auto C = TV::C;
+  // One point
+  this->template checkCastTo<F, T>({{MIN, MIN}}, {{MIN, MIN}});
+  this->template checkCastTo<F, T>({{MAX, MAX}}, {{MAX, MAX}});
+  this->template checkCastTo<F, T>({{MID, MID}}, {{MID, MID}});
+  this->template checkCastTo<F, T>({{B, B}}, {{B, B}});
+  this->template checkCastTo<F, T>({{C, C}}, {{C, C}});
+  // Two points
+  this->template checkCastTo<F, T>({{MIN, MIN}, {MAX, MAX}},
+                                   {{MIN, MIN}, {MAX, MAX}});
+  this->template checkCastTo<F, T>({{MIN, MIN}, {B, B}}, {{MIN, MIN}, {B, B}});
+  this->template checkCastTo<F, T>({{MID, MID}, {MAX, MAX}},
+                                   {{MID, MID}, {MAX, MAX}});
+  this->template checkCastTo<F, T>({{C, C}, {MAX, MAX}}, {{C, C}, {MAX, MAX}});
+  this->template checkCastTo<F, T>({{MID, MID}, {C, C}}, {{MID, MID}, {C, C}});
+  this->template checkCastTo<F, T>({{B, B}, {MID, MID}}, {{B, B}, {MID, MID}});
+  this->template checkCastTo<F, T>({{B, B}, {C, C}}, {{B, B}, {C, C}});
+  // One range
+  this->template checkCastTo<F, T>({{MIN, MAX}}, {{MIN, MAX}});
+  this->template checkCastTo<F, T>({{MIN, MID}}, {{MIN, MID}});
+  this->template checkCastTo<F, T>({{MID, MAX}}, {{MID, MAX}});
+  this->template checkCastTo<F, T>({{B, MAX}}, {{B, MAX}});
+  this->template checkCastTo<F, T>({{C, MAX}}, {{C, MAX}});
+  this->template checkCastTo<F, T>({{MIN, C}}, {{MIN, C}});
+  this->template checkCastTo<F, T>({{MIN, B}}, {{MIN, B}});
+  this->template checkCastTo<F, T>({{B, C}}, {{B, C}});
+  // Two ranges
+  this->template checkCastTo<F, T>({{MIN, B}, {C, MAX}}, {{MIN, B}, {C, MAX}});
+  this->template checkCastTo<F, T>({{B, MID}, {C, MAX}}, {{B, MID}, {C, MAX}});
+  this->template checkCastTo<F, T>({{MIN, B}, {MID, C}}, {{MIN, B}, {MID, C}});
+}
+
+TYPED_TEST(RangeSetCastToPromotionTest, Test) {
+  // Just to reduce the verbosity.
+  using F = typename TypeParam::FromType; // From
+  using T = typename TypeParam::ToType;   // To
+
+  using TV = TestValues<F>;
+  constexpr auto MIN = TV::MIN;
+  constexpr auto MAX = TV::MAX;
+  constexpr auto MID = TV::MID;
+  constexpr auto B = TV::B;
+  constexpr auto C = TV::C;
+  // One point
+  this->template checkCastTo<F, T>({{MIN, MIN}}, {{MIN, MIN}});
+  this->template checkCastTo<F, T>({{MAX, MAX}}, {{MAX, MAX}});
+  this->template checkCastTo<F, T>({{MID, MID}}, {{MID, MID}});
+  this->template checkCastTo<F, T>({{B, B}}, {{B, B}});
+  this->template checkCastTo<F, T>({{C, C}}, {{C, C}});
+  // Two points
+  this->template checkCastTo<F, T>({{MIN, MIN}, {MAX, MAX}},
+                                   {{MIN, MIN}, {MAX, MAX}});
+  this->template checkCastTo<F, T>({{MIN, MIN}, {B, B}}, {{MIN, MIN}, {B, B}});
+  this->template checkCastTo<F, T>({{MID, MID}, {MAX, MAX}},
+                                   {{MID, MID}, {MAX, MAX}});
+  this->template checkCastTo<F, T>({{C, C}, {MAX, MAX}}, {{C, C}, {MAX, MAX}});
+  this->template checkCastTo<F, T>({{MID, MID}, {C, C}}, {{MID, MID}, {C, C}});
+  this->template checkCastTo<F, T>({{B, B}, {MID, MID}}, {{B, B}, {MID, MID}});
+  this->template checkCastTo<F, T>({{B, B}, {C, C}}, {{B, B}, {C, C}});
+  // One range
+  this->template checkCastTo<F, T>({{MIN, MAX}}, {{MIN, MAX}});
+  this->template checkCastTo<F, T>({{MIN, MID}}, {{MIN, MID}});
+  this->template checkCastTo<F, T>({{MID, MAX}}, {{MID, MAX}});
+  this->template checkCastTo<F, T>({{B, MAX}}, {{B, MAX}});
+  this->template checkCastTo<F, T>({{C, MAX}}, {{C, MAX}});
+  this->template checkCastTo<F, T>({{MIN, C}}, {{MIN, C}});
+  this->template checkCastTo<F, T>({{MIN, B}}, {{MIN, B}});
+  this->template checkCastTo<F, T>({{B, C}}, {{B, C}});
+  // Two ranges
+  this->template checkCastTo<F, T>({{MIN, B}, {C, MAX}}, {{MIN, B}, {C, MAX}});
+  this->template checkCastTo<F, T>({{B, MID}, {C, MAX}}, {{B, MID}, {C, MAX}});
+  this->template checkCastTo<F, T>({{MIN, B}, {MID, C}}, {{MIN, B}, {MID, C}});
+}
+
+TYPED_TEST(RangeSetCastToTruncationTest, Test) {
+  // Just to reduce the verbosity.
+  using F = typename TypeParam::FromType; // From
+  using T = typename TypeParam::ToType;   // To
+
+  using TV = TestValues<F>;
+  constexpr auto MIN = TV::MIN;
+  constexpr auto MAX = TV::MAX;
+  constexpr auto MID = TV::MID;
+  constexpr auto B = TV::B;
+  constexpr auto C = TV::C;
+  // One point
+  this->template checkCastTo<F, T>({{MIN, MIN}}, {{MIN, MIN}});
+  this->template checkCastTo<F, T>({{MAX, MAX}}, {{MAX, MAX}});
+  this->template checkCastTo<F, T>({{MID, MID}}, {{MID, MID}});
+  this->template checkCastTo<F, T>({{B, B}}, {{B, B}});
+  this->template checkCastTo<F, T>({{C, C}}, {{C, C}});
+  // Two points
+  // Use `if constexpr` here.
+  if (is_signed_v<F>) {
+    this->template checkCastTo<F, T>({{MIN, MIN}, {MAX, MAX}}, {{MAX, MIN}});
+    this->template checkCastTo<F, T>({{MID, MID}, {MAX, MAX}}, {{MAX, MID}});
+  } else {
+    this->template checkCastTo<F, T>({{MIN, MIN}, {MAX, MAX}},
+                                     {{MIN, MIN}, {MAX, MAX}});
+    this->template checkCastTo<F, T>({{MID, MID}, {MAX, MAX}},
+                                     {{MID, MID}, {MAX, MAX}});
+  }
+  this->template checkCastTo<F, T>({{MIN, MIN}, {B, B}}, {{MIN, MIN}, {B, B}});
+  this->template checkCastTo<F, T>({{C, C}, {MAX, MAX}}, {{C, C}, {MAX, MAX}});
+  this->template checkCastTo<F, T>({{MID, MID}, {C, C}}, {{MID, MID}, {C, C}});
+  this->template checkCastTo<F, T>({{B, B}, {MID, MID}}, {{B, B}, {MID, MID}});
+  this->template checkCastTo<F, T>({{B, B}, {C, C}}, {{B, B}, {C, C}});
+  // One range
+  constexpr auto ToMIN = TestValues<T>::MIN;
+  constexpr auto ToMAX = TestValues<T>::MAX;
+  this->template checkCastTo<F, T>({{MIN, MAX}}, {{ToMIN, ToMAX}});
+  this->template checkCastTo<F, T>({{MIN, MID}}, {{ToMIN, ToMAX}});
+  this->template checkCastTo<F, T>({{MID, MAX}}, {{ToMIN, ToMAX}});
+  this->template checkCastTo<F, T>({{B, MAX}}, {{ToMIN, ToMAX}});
+  this->template checkCastTo<F, T>({{C, MAX}}, {{ToMIN, ToMAX}});
+  this->template checkCastTo<F, T>({{MIN, C}}, {{ToMIN, ToMAX}});
+  this->template checkCastTo<F, T>({{MIN, B}}, {{ToMIN, ToMAX}});
+  this->template checkCastTo<F, T>({{B, C}}, {{ToMIN, ToMAX}});
+  // Two ranges
+  this->template checkCastTo<F, T>({{MIN, B}, {C, MAX}}, {{ToMIN, ToMAX}});
+  this->template checkCastTo<F, T>({{B, MID}, {C, MAX}}, {{ToMIN, ToMAX}});
+  this->template checkCastTo<F, T>({{MIN, B}, {MID, C}}, {{ToMIN, ToMAX}});
+  constexpr auto XAAA = TV::XAAA;
+  constexpr auto X555 = TV::X555;
+  constexpr auto ZA = TV::template XAAATruncZeroOf<T>;
+  constexpr auto Z5 = TV::template X555TruncZeroOf<T>;
+  this->template checkCastTo<F, T>({{XAAA, ZA}, {X555, Z5}},
+                                   {{ToMIN, 0}, {X555, ToMAX}});
+  // Use `if constexpr` here.
+  if (is_signed_v<F>) {
+    // One range
+    this->template checkCastTo<F, T>({{XAAA, ZA}}, {{XAAA, 0}});
+    // Two ranges
+    this->template checkCastTo<F, T>({{XAAA, ZA}, {1, 42}}, {{XAAA, 42}});
+  } else {
+    // One range
+    this->template checkCastTo<F, T>({{XAAA, ZA}}, {{0, 0}, {XAAA, ToMAX}});
+    // Two ranges
+    this->template checkCastTo<F, T>({{1, 42}, {XAAA, ZA}},
+                                     {{0, 42}, {XAAA, ToMAX}});
+  }
+  constexpr auto FromA = TV::FromA;
+  constexpr auto ToA = TV::ToA;
+  constexpr auto FromB = TV::FromB;
+  constexpr auto ToB = TV::ToB;
+  this->template checkCastTo<F, T>({{FromA, ToA}, {FromB, ToB}},
+                                   {{FromA, ToA}});
+}
+
+TYPED_TEST(RangeSetCastToConversionTest, Test) {
+  // Just to reduce the verbosity.
+  using F = typename TypeParam::FromType; // From
+  using T = typename TypeParam::ToType;   // To
+
+  using TV = TestValues<F>;
+  constexpr auto MIN = TV::MIN;
+  constexpr auto MAX = TV::MAX;
+  constexpr auto MID = TV::MID;
+  constexpr auto B = TV::B;
+  constexpr auto C = TV::C;
+  // One point
+  this->template checkCastTo<F, T>({{MIN, MIN}}, {{MIN, MIN}});
+  this->template checkCastTo<F, T>({{MAX, MAX}}, {{MAX, MAX}});
+  this->template checkCastTo<F, T>({{MID, MID}}, {{MID, MID}});
+  this->template checkCastTo<F, T>({{B, B}}, {{B, B}});
+  this->template checkCastTo<F, T>({{C, C}}, {{C, C}});
+  // Two points
+  this->template checkCastTo<F, T>({{MIN, MIN}, {MAX, MAX}}, {{MAX, MIN}});
+  this->template checkCastTo<F, T>({{MID, MID}, {MAX, MAX}},
+                                   {{MID, MID}, {MAX, MAX}});
+  this->template checkCastTo<F, T>({{MIN, MIN}, {B, B}}, {{MIN, MIN}, {B, B}});
+  this->template checkCastTo<F, T>({{C, C}, {MAX, MAX}}, {{C, C}, {MAX, MAX}});
+  this->template checkCastTo<F, T>({{MID, MID}, {C, C}}, {{MID, MID}, {C, C}});
+  this->template checkCastTo<F, T>({{B, B}, {MID, MID}}, {{B, B}, {MID, MID}});
+  this->template checkCastTo<F, T>({{B, B}, {C, C}}, {{B, B}, {C, C}});
+  // One range
+  constexpr auto ToMIN = TestValues<T>::MIN;
+  constexpr auto ToMAX = TestValues<T>::MAX;
+  this->template checkCastTo<F, T>({{MIN, MAX}}, {{ToMIN, ToMAX}});
+  this->template checkCastTo<F, T>({{MIN, MID}},
+                                   {{ToMIN, ToMIN}, {MIN, ToMAX}});
+  this->template checkCastTo<F, T>({{MID, MAX}}, {{MID, MAX}});
+  this->template checkCastTo<F, T>({{B, MAX}}, {{ToMIN, MAX}, {B, ToMAX}});
+  this->template checkCastTo<F, T>({{C, MAX}}, {{C, MAX}});
+  this->template checkCastTo<F, T>({{MIN, C}}, {{ToMIN, C}, {MIN, ToMAX}});
+  this->template checkCastTo<F, T>({{MIN, B}}, {{MIN, B}});
+  this->template checkCastTo<F, T>({{B, C}}, {{ToMIN, C}, {B, ToMAX}});
+  // Two ranges
+  this->template checkCastTo<F, T>({{MIN, B}, {C, MAX}}, {{C, B}});
+  this->template checkCastTo<F, T>({{B, MID}, {C, MAX}},
+                                   {{MID, MID}, {C, MAX}, {B, ToMAX}});
+  this->template checkCastTo<F, T>({{MIN, B}, {MID, C}}, {{MID, C}, {MIN, B}});
+}
+
+TYPED_TEST(RangeSetCastToPromotionConversionTest, Test) {
+  // Just to reduce the verbosity.
+  using F = typename TypeParam::FromType; // From
+  using T = typename TypeParam::ToType;   // To
+
+  using TV = TestValues<F>;
+  constexpr auto MIN = TV::MIN;
+  constexpr auto MAX = TV::MAX;
+  constexpr auto MID = TV::MID;
+  constexpr auto B = TV::B;
+  constexpr auto C = TV::C;
+  // One point
+  this->template checkCastTo<F, T>({{MIN, MIN}}, {{MIN, MIN}});
+  this->template checkCastTo<F, T>({{MAX, MAX}}, {{MAX, MAX}});
+  this->template checkCastTo<F, T>({{MID, MID}}, {{MID, MID}});
+  this->template checkCastTo<F, T>({{B, B}}, {{B, B}});
+  this->template checkCastTo<F, T>({{C, C}}, {{C, C}});
+  // Two points
+  this->template checkCastTo<F, T>({{MIN, MIN}, {MAX, MAX}},
+                                   {{MAX, MAX}, {MIN, MIN}});
+  this->template checkCastTo<F, T>({{MIN, MIN}, {B, B}}, {{MIN, MIN}, {B, B}});
+  this->template checkCastTo<F, T>({{MID, MID}, {MAX, MAX}},
+                                   {{MID, MID}, {MAX, MAX}});
+  this->template checkCastTo<F, T>({{C, C}, {MAX, MAX}}, {{C, C}, {MAX, MAX}});
+  this->template checkCastTo<F, T>({{MID, MID}, {C, C}}, {{MID, MID}, {C, C}});
+  this->template checkCastTo<F, T>({{B, B}, {MID, MID}}, {{B, B}, {MID, MID}});
+  this->template checkCastTo<F, T>({{B, B}, {C, C}}, {{B, B}, {C, C}});
+
+  // Use `if constexpr` here.
+  if (is_signed_v<F>) {
+    // One range
+    this->template checkCastTo<F, T>({{MIN, MAX}}, {{0, MAX}, {MIN, -1}});
+    this->template checkCastTo<F, T>({{MIN, MID}}, {{0, 0}, {MIN, -1}});
+    this->template checkCastTo<F, T>({{MID, MAX}}, {{0, MAX}});
+    this->template checkCastTo<F, T>({{B, MAX}}, {{0, MAX}, {B, -1}});
+    this->template checkCastTo<F, T>({{C, MAX}}, {{C, MAX}});
+    this->template checkCastTo<F, T>({{MIN, C}}, {{0, C}, {MIN, -1}});
+    this->template checkCastTo<F, T>({{MIN, B}}, {{MIN, B}});
+    this->template checkCastTo<F, T>({{B, C}}, {{0, C}, {B, -1}});
+    // Two ranges
+    this->template checkCastTo<F, T>({{MIN, B}, {C, MAX}},
+                                     {{C, MAX}, {MIN, B}});
+    this->template checkCastTo<F, T>({{B, MID}, {C, MAX}},
+                                     {{0, 0}, {C, MAX}, {B, -1}});
+    this->template checkCastTo<F, T>({{MIN, B}, {MID, C}}, {{0, C}, {MIN, B}});
+  } else {
+    // One range
+    this->template checkCastTo<F, T>({{MIN, MAX}}, {{MIN, MAX}});
+    this->template checkCastTo<F, T>({{MIN, MID}}, {{MIN, MID}});
+    this->template checkCastTo<F, T>({{MID, MAX}}, {{MID, MAX}});
+    this->template checkCastTo<F, T>({{B, MAX}}, {{B, MAX}});
+    this->template checkCastTo<F, T>({{C, MAX}}, {{C, MAX}});
+    this->template checkCastTo<F, T>({{MIN, C}}, {{MIN, C}});
+    this->template checkCastTo<F, T>({{MIN, B}}, {{MIN, B}});
+    this->template checkCastTo<F, T>({{B, C}}, {{B, C}});
+    // Two ranges
+    this->template checkCastTo<F, T>({{MIN, B}, {C, MAX}},
+                                     {{MIN, B}, {C, MAX}});
+    this->template checkCastTo<F, T>({{B, MID}, {C, MAX}},
+                                     {{B, MID}, {C, MAX}});
+    this->template checkCastTo<F, T>({{MIN, B}, {MID, C}},
+                                     {{MIN, B}, {MID, C}});
+  }
+}
+
+TYPED_TEST(RangeSetCastToTruncationConversionTest, Test) {
+  // Just to reduce the verbosity.
+  using F = typename TypeParam::FromType; // From
+  using T = typename TypeParam::ToType;   // To
+
+  using TV = TestValues<F>;
+  constexpr auto MIN = TV::MIN;
+  constexpr auto MAX = TV::MAX;
+  constexpr auto MID = TV::MID;
+  constexpr auto B = TV::B;
+  constexpr auto C = TV::C;
+  // One point
+  this->template checkCastTo<F, T>({{MIN, MIN}}, {{MIN, MIN}});
+  this->template checkCastTo<F, T>({{MAX, MAX}}, {{MAX, MAX}});
+  this->template checkCastTo<F, T>({{MID, MID}}, {{MID, MID}});
+  this->template checkCastTo<F, T>({{B, B}}, {{B, B}});
+  this->template checkCastTo<F, T>({{C, C}}, {{C, C}});
+  // Two points
+  // Use `if constexpr` here.
+  if (is_signed_v<F>) {
+    this->template checkCastTo<F, T>({{MIN, MIN}, {MAX, MAX}},
+                                     {{MIN, MIN}, {MAX, MAX}});
+    this->template checkCastTo<F, T>({{MID, MID}, {MAX, MAX}},
+                                     {{MID, MID}, {MAX, MAX}});
+  } else {
+    this->template checkCastTo<F, T>({{MIN, MIN}, {MAX, MAX}}, {{MAX, MIN}});
+    this->template checkCastTo<F, T>({{MID, MID}, {MAX, MAX}}, {{MAX, MIN}});
+  }
+  this->template checkCastTo<F, T>({{MIN, MIN}, {B, B}}, {{MIN, MIN}, {B, B}});
+  this->template checkCastTo<F, T>({{C, C}, {MAX, MAX}}, {{C, C}, {MAX, MAX}});
+  this->template checkCastTo<F, T>({{MID, MID}, {C, C}}, {{MID, MID}, {C, C}});
+  this->template checkCastTo<F, T>({{B, B}, {MID, MID}}, {{B, B}, {MID, MID}});
+  this->template checkCastTo<F, T>({{B, B}, {C, C}}, {{B, B}, {C, C}});
+  // One range
+  constexpr auto ToMIN = TestValues<T>::MIN;
+  constexpr auto ToMAX = TestValues<T>::MAX;
+  this->template checkCastTo<F, T>({{MIN, MAX}}, {{ToMIN, ToMAX}});
+  this->template checkCastTo<F, T>({{MIN, MID}}, {{ToMIN, ToMAX}});
+  this->template checkCastTo<F, T>({{MID, MAX}}, {{ToMIN, ToMAX}});
+  this->template checkCastTo<F, T>({{B, MAX}}, {{ToMIN, ToMAX}});
+  this->template checkCastTo<F, T>({{C, MAX}}, {{ToMIN, ToMAX}});
+  this->template checkCastTo<F, T>({{MIN, C}}, {{ToMIN, ToMAX}});
+  this->template checkCastTo<F, T>({{MIN, B}}, {{ToMIN, ToMAX}});
+  this->template checkCastTo<F, T>({{B, C}}, {{ToMIN, ToMAX}});
+  // Two ranges
+  this->template checkCastTo<F, T>({{MIN, B}, {C, MAX}}, {{ToMIN, ToMAX}});
+  this->template checkCastTo<F, T>({{B, MID}, {C, MAX}}, {{ToMIN, ToMAX}});
+  this->template checkCastTo<F, T>({{MIN, B}, {MID, C}}, {{ToMIN, ToMAX}});
+  constexpr auto XAAA = TV::XAAA;
+  constexpr auto X555 = TV::X555;
+  constexpr auto ZA = TV::template XAAATruncZeroOf<T>;
+  constexpr auto Z5 = TV::template X555TruncZeroOf<T>;
+  this->template checkCastTo<F, T>({{XAAA, ZA}, {X555, Z5}},
+                                   {{ToMIN, 0}, {X555, ToMAX}});
+  // Use `if constexpr` here.
+  if (is_signed_v<F>) {
+    // One range
+    this->template checkCastTo<F, T>({{XAAA, ZA}}, {{0, 0}, {XAAA, ToMAX}});
+    // Two ranges
+    this->template checkCastTo<F, T>({{XAAA, ZA}, {1, 42}},
+                                     {{0, 42}, {XAAA, ToMAX}});
+  } else {
+    // One range
+    this->template checkCastTo<F, T>({{XAAA, ZA}}, {{XAAA, 0}});
+    // Two ranges
+    this->template checkCastTo<F, T>({{1, 42}, {XAAA, ZA}}, {{XAAA, 42}});
+  }
+  constexpr auto FromA = TV::FromA;
+  constexpr auto ToA = TV::ToA;
+  constexpr auto FromB = TV::FromB;
+  constexpr auto ToB = TV::ToB;
+  this->template checkCastTo<F, T>({{FromA, ToA}, {FromB, ToB}},
+                                   {{FromA, ToA}});
+}
+
+} // namespace