[SemanticTypedef] Provide a semantic typedef class and operators

[greened]

Summary

A semanic typedef is a kind of "strong typedef" that prevents implicit
conversion between itself and its underlying type. But rather than a
straight typedef of the base type with all operators available, a
semantic typedef allows the new type to choose the operators available
to it, increasing type safety.

An example:

// It doesn't make sense to add two CacheLineSize objects together, so
// don't define add-assignment.
struct CacheLineSize : public SemanticTypedef<CacheLineSize, unsigned>,
                     : public EqualityCompare<CacheLineSize>,
  		       : public LessThanCompare<CacheLineSize> {
  using SemanticTypedef::SemanticTypedef;
};

CacheLineSize ASize(32);
CacheLineSize BSize(64);

assert(ASize < BSize);

static_assert(!std::is_convertible<decltype(ASize),
                                   UnderlyingType<decltype(ASize)>>::value,
              "Converted CacheLineSize to its underlying type!");

static_assert(!std::is_convertible<UnderlyingType<decltype(ASize)>,
                                   decltype(ASize)>::value,
              "Converted underlying type to CacheLineSize!");

This commit defines the basic SemanticTypedef class along with classes
to make the most common operators available: ==, <, >=, =, +=, &&, ||,
!, << (output streaming).

[nliber]

A strong motivation for using this over enum class should be provided. The default behavior is too minimalistic.

In my experience, the reason people use bool, int, string, etc. is because they provide a rich set of operations out of the box: assignment, comparison, implicit conversions, etc. enum class also provides most of those operations (other than implicit conversion) and has two benefits: it introduces a new type, and it makes it easy to name constants. SemanticTypedef, on the other hand, provides almost no operations without a lot more declaration.

If you use derivation (as opposed to using/typedef), you don't even get the converting constructor without an extra declaration. While derivation does have a benefit (you don't have to invent a tag type), it has a fairly high cost. Also, public derivation is used (not strictly necessary for introducing friend functions but necessary for everything else) even though this does not model an is-a relationship. The idea for using CRTP for this has been here for over two decades (e.g. Boost.Operators is one of the oldest Boost libraries) and yet, for the most part, hasn't caught on.

It is rare to have a value type that does not have assignment or equality comparisons (and hashing, as that goes along with equality comparisons). The default should minimally provide this behavior.

llvm/include/llvm/ADT/SemanticTypedef.h

112

This line gives you copy construction. Because there are no other declarations for copy/move constructor/assignment operator or destructor, you also get copy assignment but move construction/assignment is effectively deleted. Also deriving from Assign<Typedef> does not change this.

Recommendation: remove this line of code.

126

This needs an exception specification.

184

The downside to using macros here is that it makes it harder for users to debug code going through these macros. It doesn't seem worth writing eight macros just to write six classes.

207

Why the casts?

239

This is not true in general. The canonical example is floating point NaNs. See std;:optional for how comparisons when wrapping a single value should work when comparing the underlying value.

[labath]

llvm/include/llvm/ADT/SemanticTypedef.h

2

I know this has been discussed on the thread, but I feel obligated to point out that there is already precedent for using the term "strong typedef" for this kind of thing: LLVM_YAML_STRONG_TYPEDEF. Might not matter if the goal is to eventually replace LLVM_YAML_STRONG_TYPEDEF with this, but otherwise, it would be nice to maintain consistent naming within the project.

[greened]

In D66148#1628669, @nliber wrote:

A strong motivation for using this over enum class should be provided. The default behavior is too minimalistic.

There will be follow-on commits that add types with rich semantics. A StrongBoolean is one of them. This is just the bare minimum to get feedback and set the foundation. Doing this in a modular way provides the most flexibility which in my mind is what you want from foundation classes.

In my experience, the reason people use bool, int, string, etc. is because they provide a rich set of operations out of the box: assignment, comparison, implicit conversions, etc.

I don't think we want implicit conversions in the base SemanticTypedef class. We can add flexibility to interoperate with other types later on. I have prototyped almost all of this.

enum class also provides most of those operations (other than implicit conversion) and has two benefits: it introduces a new type, and it makes it easy to name constants. SemanticTypedef, on the other hand, provides almost no operations without a lot more declaration.

enum class is certainly useful in many situations where this would be an inferior solution. SemanticTypedef is useful in places where enum class is less so. For example, enum class won't work with any non-integral type.

If you use derivation (as opposed to using/typedef), you don't even get the converting constructor without an extra declaration. While derivation does have a benefit (you don't have to invent a tag type), it has a fairly high cost.

Can you elaborate on what you see as the high cost? I'm just trying to understand your perspective. As noted in the comments, nothing here precludes making use of using aliases rather than CRTP, though you lose some type safety. I find CRTP much more convenient.

Also, public derivation is used (not strictly necessary for introducing friend functions but necessary for everything else) even though this does not model an is-a relationship.

I agree this is one area where the model isn't great. One can't state that the mixins should always be inherited privately because assignment, for example, requires the operator to be a member of the class and not just a friend.

The idea for using CRTP for this has been here for over two decades (e.g. Boost.Operators is one of the oldest Boost libraries) and yet, for the most part, hasn't caught on.

Boost.Operators is overkill for this kind of thing and I suspect the same is true for other use-cases. With Boost.Operators you still have to define what the base operators do. For SemanticTypedef we know we want to operators to forward to the operators for the underlying type, so the client has no need to provide definitions of the operators.

It is rare to have a value type that does not have assignment or equality comparisons (and hashing, as that goes along with equality comparisons). The default should minimally provide this behavior.

I disagree. Boolean flags, for example, often don't need any of that.

Can you sketch out what you'd like to see in a strong typedef facility?

[greened]

llvm/include/llvm/ADT/SemanticTypedef.h

2

I'm totally fine changing the name. Other people objected to "strong typedef" and "semantic typedef" seemed the best proposed option to me.

The C++ committee also rejected the same "strong typdef," opting for "opaque typedef" for reasons that are not entirely clear to me. I didn't want to name this OpaqueTypedef to avoid confusion with the language proposal of that name.

112

Deriving from Assign<Typedef> works. It's in the unit tests. Perhaps I've missed something.

I can add a move constructor. That was an oversight, thanks for pointing it out!

126

What should it be? is_nothrow_swappable is only available in C++ 17. Mkaing it unconditionally noexcept would be wrong.

184

If people feel strongly about it, I'm fine not using macros. It will be a lot more code, though.

207

That's a mistake. Will fix.

239

Good point. Will fix.

[mehdi_amini]

llvm/include/llvm/ADT/SemanticTypedef.h

28

The problem exposed above is compelling, but I have hard time connecting the explanation that follows to the problem statement. Can you provide the final solution for expressing the original API void foo(bool Feature1, bool Feature2); and how it compares to an enum class?

[greened]

llvm/include/llvm/ADT/SemanticTypedef.h

28

For booleans enum class may be better in some cases, so perhaps I should restate the problem. Assuming a StrongBoolean is available:

cl::opt<bool> EnableFeature1("enable-feature1", cl::init(false), cl::desc(...));
cl::opt<bool> EnableFeature2("enable-feature2", cl::init(false), cl::desc(...));

struct Feature1Flag : public StrongBoolean<Feature1Flag> {
  using StrongBoolean::StrongBoolean;
};
struct Feature2Flag : public StrongBoolean<Feature2Flag> {
  using StrongBoolean::StrongBoolean;
};

void foo(Feature1Flag Feature1, Feature2Flag Feature2);

Feature1Flag F1(EnableFeature1);
Feature2Flag F2(EnableFeature2);

foo(F1, F2);

Using enum class:

enum class Feature1Flag : bool {
  Disabled = false,
  Enabled = true
};
enum class Feature2Flag : bool {
  Disabled = false,
  Enabled = true
}

cl::opt<Feature1Flag> EnableFeature1(
  cl::values(
    clEnumValN("enable-feature1", Feature1Flag::Enabled, "..."),
   clEnumValN("disable-feature1", Feature1Flag::Disabled, "...")));

cl::opt<Feature2Flag> EnableFeature2(
  cl::values(
    clEnumValN("enable-feature2", Feature2Flag::Enabled , "..."),
   clEnumValN("disable-feature2", Feature2Flag::Disabled, "...")));

void foo(Feature1Flag Feature1, Feature2Flag Feature2);

Feature1Flag F1(EnableFeature1);
Feature2Flag F2(EnableFeature2);

foo(F1, F2);

At least I think that's right. It's a bit more burdensome to create cl::opt flags with enum class.

Of course many Booleans won't use a cl::opt. Still, SemanticTypedef may be easier than enum class:

template<typename Tag>
struct MyFeatureFlags : public StrongBoolean<Tag> {
  using StrongBoolean<Tag>::StrongBoolean;
};

struct Feature1Flag : public MyFeatureFlags<Feature1Flag> {
  using MyFeatureFlags::MyFeatureFlags;
};
struct Feature2Flag : public MyFeatureFlags<Feature2Flag> {
  using MyFeatureFlags::MyFeatureFlags;
};

void foo(Feature1Flag Feature1, Feature2Flag Feature2) {
  if (Feature1 || Feature2) {
    ...
  }
}

Here, I'm assuming the ability to have "related" typedefs interoperate, so that logical disjunction between types with the same wrapper template but different tags can be allowed. I have prototyped this. It involves some complicated SFINAE magic and may not be worth the effort. But it is possible.

We could instead do:

// Feature1 and Feature2 declared as originally

void foo(Feature1Flag Feature1, Feature2Flag Feature2) {
  if (Feature1.isTrue() || Feature2.isTrue()) {
    ...
  }
}

Then we wouldn't need the messy SFINAE stuff but it's slightly less type-safe. The tradeoff is probably fine, though.

With enum class:

// Feature1 and Feature2 declared as before

void foo(Feature1Flag Feature1, Feature2Flag Feature2) {
  if (bool(Feature1) || bool(Feature2)) {
    ...
  }
}

Not that much of a win for SemanticTypedef but it is a bit cleaner.

One use for SemanticTypedef that would be helpful and not as conveniently achieved with enum class:

template<typename Tag, typename Int = unsigned>
struct Bits : StrongInteger<Tag, Int> {
  using SemanticTypedef<Tag, Int>::SemanticTypedef;
  Int toBytes() { return Int(*this) / 8; }
};

template<typename Tag, typename Int = unsigned>
struct Bytests : StrongInteger<Tag, Int> {
  using SemanticTypedef<Tag, Int>::SemanticTypedef;
  Int toBits() { return Int(*this) * 8; }
};

Then the interfaces that take/return bits/bytes would instead take/return these types and we'd reduce the number of bits-or-bytes errors in the code.

[greened]

llvm/include/llvm/ADT/SemanticTypedef.h

112

Ok, I think I see. I misunderstood what you were getting at. Deriving from Assign doesn't provide move construction. It does provide move assignment though. Wouldn't adding a move constructor fix the issue?

[greened]

llvm/include/llvm/ADT/SemanticTypedef.h

112

After thinking about this some more, I think you are right. I will delete the default copy constructor and also the Assign operator since it's hidden by the default assignment operator anyway.

[greened]

Removed casts, default constructors, added all operators where it makes sense (unary *, ->, ->*, unary &, comma, [] and () not added because a default return type is not obvious), placed operators in their own namespace to avoid collisions, rewrote example, updated tests.

[greened]

llvm/include/llvm/ADT/SemanticTypedef.h

184

As a data point, I build with gcc 8.1 and errors were pretty easy to track down, even through the macros.

[greened]

Ping.

[greened]

Ping?

[nliber]

[Sorry it took so long to get back to this...]

• Consider putting swap into a separate "operator" class (it isn't really an operator, but it is close...), which would be inherited like everything else.
• Move construction, move assignment and swap are the three which really need noexcept on them, and you already get it for free with move construction/assignment because you are applying the "Rule of Zero". As was pointed out, is_nothrow_swappable didn't show up until C++17. However, I do not believe its implementation relies on anything in C++17. Consider implementing the trait yourself and using it (or equivalent) on swap.
• Instead of default construction," copy the value" construction and "moving the value" construction, consider having a templated constructor which does emplace construction into Value. Not only does this cover the three construction methods already mentioned, it can be more efficient if you do not have the value constructed already, and it also enables wrapping of non-copyable non-moveable types (such as atomic<T>). It would look something like (caution: untested):

template<typename... Us, typename = std::enable_if_t<std::is_constructible<T, Us...>::value>>
constexpr SemanticTypedef(Us&&... us)
noexcept(noexcept(T(std::forward<Us>(us)...)))
: Value(std::forward<Us>(us)...)
{}

Note: even if you don't want to constrain it to is_constructible, you still need to constrain it so that non-const instances of SemanticTypedef bind to the copy constructor instead of this templated constructor. IIRC this doesn't cover std::initializer_list constructors, so you would need to make forward constructors if you wished to support forwarding those.

• Consider adding a named getter member function (such as .get() or .ref()) that returns a (const) reference as well as the conversion operator. It is useful to have a short name when you need access to the underlying value.
• Consider adding a typedef (such as value_type) inside SemanticTypedef for the underlying type (and I would have a tag_type for good measure). You know what it is, and users shouldn't have to go through hoops to get it. Heck, UnderlyingType and TagType shouldn't have to go through hoops to get it.
• Consider eliminating Sortable. Types which only define operator< are weird, and we shouldn't be encouraging weird types.
• Consider adding heterogeneous operations with SemanticTypedef<Tag, T> and T (in either order). For instance, one shouldn't have to construct a SemanticTypedef<Tag, string> if they just want to compare a string with a SemanticTypedef<Tag, string>.
• Consider defining all operators except assignment as friends. Anthony Williams's blog post on hidden friends explains why.

llvm/include/llvm/ADT/SemanticTypedef.h

+//===-- SemanticTypedef.h - Typedefs for a type-safe world ------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+/// \file
+/// This file provides utilities for creating semantic typedefs.
+///
+/// Semantic typedefs are useful when one wants to distinguish between types
+/// that otherwise would have the same signature.  For example:
+///
+///   void foo(int Size, int Alignment);
+///
+/// It is easy to forget the order of arguments.  It would be safer to have
+/// something like:
+///
+///   void frobnicate(SizeType Size, AlignmentType Alignment);
+///
+/// But we can do even better.  Are Size and Alignment specified in bits or
+/// bytes?  We could make it explicit:
+///
+/// void frobnicate(BitSizeType Size, ByteAlignmentType Alignment);
+///
+/// However, defining BitSizeSizeType and BytesAlignmentType (and ByteDistance
+/// and VectorElementLength and...)  is tedious, cumbersome and error-prone.
+/// The semantic typedef utilites here make this at least a little bit easier.
+///
+/// Typical use is as follows:
+///
+///   class MyInt : public SemanticTypedef<MyInt, int> {
+///     using SemanticTypedef<MyInt, int>::SemanticTypedef;
+///   };
+///
+///   MyInt a(10);
+///
+///   int A = int(MyInt);
+///
+/// It is not required that SemanticTypedef be used with CRTP, but it is often
+/// most conveninent.  One may use any type as a SemanticTypedef tag:
+///
+///   struct MyIntTag {};
+///   using MyInt = SemanticTypedef<MyIntTag, int>;
+///
+/// A large downside to not using CRTP is that it's not possible to use the
+/// pre-defined mixin classes to add operators.  One has to define each operator
+/// specially for the new type.
+///
+/// Using the same tag again will make a second alias interoperate with the first
+/// but still prevent implicit conversions to the underlying type:
+///
+///   using MyOtherInt = SemanticTypedef<MyIntTag, int>;
+///
+/// Of course this removes some safety:
+///
+///   void foo(MyInt expected);
+///
+///   MyOtherInt maybeWrong(10);
+///   foo(maybeWrong);  // Oops?
+///
+/// Metafunctions exist to obtain the underlying type and tag of a typedef:
+///
+///   using Underlying = UnderlyingType<MyInt>;
+///   using Tag        = TagType<MyInt>;
+///
+/// The base SemanticTypedef class does not provide any functionality other than
+/// explicit conversion between it and its underlying type along with defaulted
+/// constructors and assignment operators.  Mixins are used to imbue objects
+/// with additional features:
+///
+///   class MyInt : public SemanticTypedef<MyInt, int>,
+///                 public LeCmp<MyInt>  {
+///     using SemanticTypedef::SemanticTypedef;
+///   };
+///
+///   MyInt a(10);
+///   MyInt b(20);
+///
+///   bool LtTrue  = a < b;
+///   bool GeTrue  = b >= a;
+///   bool LtFalse = b < a;
+///   bool GeFalse = a >= b;
+///
+/// Inspired by Jonathan Mueller's post on strong typedef:
+///
+/// https://foonathan.net/blog/2016/10/19/strong-typedefs.html
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ADT_SEMANTICTYPEDEF_H
+#define LLVM_ADT_SEMANTICTYPEDEF_H
+
+#include "llvm/Support/raw_ostream.h"
+
+#include <type_traits>
+#include <utility>
+
+namespace llvm {
+
+////////////////////////////////////////////////////////////////////////////////
+// Define SemanticTypedef.
+////////////////////////////////////////////////////////////////////////////////
+
+/// This is the basic SemanticTypedef template, providing only explicit
+/// conversion between itself and its underlying type.
+template<typename Tag, typename T>
+class SemanticTypedef {
+  T Value;
+
+public:
+  constexpr SemanticTypedef() : Value() {}
+  explicit SemanticTypedef(const T &V)
+      noexcept(std::is_nothrow_copy_constructible<T>::value) :
+      Value(V) {}
+  explicit SemanticTypedef(T &&V)
+      noexcept(std::is_nothrow_move_constructible<T>::value) :
+      Value(std::move(V)) {}
+
+  explicit operator T &() noexcept {
+    return Value;
+  }
+
+  explicit operator const T &() const noexcept {
+    return Value;
+  }
+
+  friend void swap(SemanticTypedef &A, SemanticTypedef &B) {
+    using std::swap;
+    swap(static_cast<T&>(A), static_cast<T&>(B));
+  }
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// Internal utilities.
+////////////////////////////////////////////////////////////////////////////////
+
+namespace detail {
+/// Implementation of UnderlyingType.
+template<typename Tag, typename T>
+T UnderlyingTypeImpl(const SemanticTypedef<Tag, T> &);
+
+/// Implementation of TagType.
+template<typename Tag, typename T>
+Tag TagTypeImpl(const SemanticTypedef<Tag, T> &);
+}  // end namespace detail
+
+/// Get the underlying type of a semantic typedef.
+template<typename T>
+using UnderlyingType = decltype(detail::UnderlyingTypeImpl(std::declval<T>()));
+
+/// Get the tag of a semantic typedef.
+template<typename T>
+using TagType = decltype(detail::TagTypeImpl(std::declval<T>()));
+
+namespace detail {
+/// Implmentation of getValue.
+template<typename Tag, typename T>
+T &getValue(SemanticTypedef<Tag, T> &V) {
+  return static_cast<T &>(V);
+}
+
+/// Get the wrapped value of a semantic typedef object.
+template<typename Tag, typename T>
+const T &getValue(const SemanticTypedef<Tag, T> &V) {
+  return static_cast<const T &>(V);
+}
+}  // end namespace detail
+
+////////////////////////////////////////////////////////////////////////////////
+// Define mixins to add functionality to typedefs.
+////////////////////////////////////////////////////////////////////////////////
+
+// The operators shouldn't take a SemanticTypedef<Tag, T> because then any
+// SemanticTypedef would match and we want to restrict these to the specific
+// typedef that opted into them.  In order to do that, we define them as friends
+// within the mixin class.  This makes them accessible only by ADL from the type
+// that defined them (i.e. the typedef subclass).  See the referenced blog post
+// above.
+//
+// Define unary operators.
+
+// Operator(Typedef)
+
+/// Define a macro to create unary operators.
+#define TYPEDEF_UNARY_OP(Op)                                    \
+  friend ResultType operator Op(const Typedef &O) {             \
+    return ResultType(                                          \
+        Op detail::getValue(O));                                \
+  }
+
+/// Define a macro to declare binary operators and the base class.
+#define MAKE_TYPEDEF_UNARY_OP(Name, Op, Result)                 \
+  /* Operator(Typedef) */                                       \
+  template<typename Typedef, typename ResultType = Result>      \
+  struct Name {                                                 \
+    TYPEDEF_UNARY_OP(Op)                                        \
+  };
+
+// Define binary operators.
+
+// Operator(Typedef, Typedef)
+
+/// Define a macro to create straightforward binary operators.
+#define TYPEDEF_TYPEDEF_BINARY_OP(Op)                           \
+  friend ResultType operator Op(const Typedef &LHS,             \
+                                const Typedef &RHS) {           \
+    return ResultType(                                          \
+        detail::getValue(LHS) Op detail::getValue(RHS));        \
+  }
+
+/// Define a macro to create binary operators that modify and return the LHS.
+#define TYPEDEF_TYPEDEF_BINARY_OPEQ(Op)                         \
+  friend Typedef &operator Op(Typedef &LHS,                     \
+                              const Typedef &RHS) {             \
+    detail::getValue(LHS) Op detail::getValue(RHS);             \
+    return LHS;                                                 \
+  }
+
+/// Define a macro to declare binary operators and the base class.
+#define MAKE_TYPEDEF_TYPEDEF_BINARY_OP(Name, Op, Result)                \
+  /* Operator(Typedef, Typedef) */                                      \
+  template<typename Typedef, typename ResultType = Result>              \
+  struct Name {                                                         \
+    TYPEDEF_TYPEDEF_BINARY_OP(Op)                                       \
+  };
+
+/// Define a macro to declare binary operators and the base class.
+#define MAKE_TYPEDEF_TYPEDEF_OPEQ(Name, Op)                             \
+  /* Operator(Typedef, Typedef) */                                      \
+  template<typename Typedef>                                            \
+  struct Name {                                                         \
+    TYPEDEF_TYPEDEF_BINARY_OPEQ(Op)                                     \
+  };
+
+// Define operators
+namespace typedef_operators {
+MAKE_TYPEDEF_UNARY_OP(LogNot, !, bool)
+MAKE_TYPEDEF_UNARY_OP(BitNot, ~, Typedef)
+MAKE_TYPEDEF_UNARY_OP(Pos, +, Typedef)
+MAKE_TYPEDEF_UNARY_OP(Neg, -, Typedef)
+
+MAKE_TYPEDEF_TYPEDEF_BINARY_OP(LtCmp, <, bool)
+MAKE_TYPEDEF_TYPEDEF_BINARY_OP(LeCmp, <=, bool)
+MAKE_TYPEDEF_TYPEDEF_BINARY_OP(EqCmp, ==, bool)
+MAKE_TYPEDEF_TYPEDEF_BINARY_OP(NeCmp, !=, bool)
+MAKE_TYPEDEF_TYPEDEF_BINARY_OP(GeCmp, >=, bool)
+MAKE_TYPEDEF_TYPEDEF_BINARY_OP(GtCmp, >, bool)
+
+// Note: Not short-circuiting!
+MAKE_TYPEDEF_TYPEDEF_BINARY_OP(LogAnd, &&, bool)
+MAKE_TYPEDEF_TYPEDEF_BINARY_OP(LogOr, ||, bool)
+
+MAKE_TYPEDEF_TYPEDEF_BINARY_OP(BitAnd, &, Typedef)
+MAKE_TYPEDEF_TYPEDEF_BINARY_OP(BitOr, |, Typedef)
+MAKE_TYPEDEF_TYPEDEF_BINARY_OP(BitXor, ^, Typedef)
+MAKE_TYPEDEF_TYPEDEF_BINARY_OP(BitShl, <<, Typedef)
+MAKE_TYPEDEF_TYPEDEF_BINARY_OP(BitShr, >>, Typedef)
+
+MAKE_TYPEDEF_TYPEDEF_BINARY_OP(Add, +, Typedef)
+MAKE_TYPEDEF_TYPEDEF_BINARY_OP(Sub, -, Typedef)
+MAKE_TYPEDEF_TYPEDEF_BINARY_OP(Mul, *, Typedef)
+MAKE_TYPEDEF_TYPEDEF_BINARY_OP(Div, /, Typedef)
+MAKE_TYPEDEF_TYPEDEF_BINARY_OP(Mod, %, Typedef)
+
+/// Provide add-assignment operators to semantic typedefs.
+MAKE_TYPEDEF_TYPEDEF_OPEQ(AddAssign, +=)
+MAKE_TYPEDEF_TYPEDEF_OPEQ(SubAssign, -=)
+MAKE_TYPEDEF_TYPEDEF_OPEQ(MulAssign, *=)
+MAKE_TYPEDEF_TYPEDEF_OPEQ(DivAssign, /=)
+MAKE_TYPEDEF_TYPEDEF_OPEQ(ModAssign, %=)
+MAKE_TYPEDEF_TYPEDEF_OPEQ(BitAndAssign, &=)
+MAKE_TYPEDEF_TYPEDEF_OPEQ(BitOrAssign, |=)
+MAKE_TYPEDEF_TYPEDEF_OPEQ(BitXorAssign, ^=)
+MAKE_TYPEDEF_TYPEDEF_OPEQ(BitShlAssign, <<=)
+MAKE_TYPEDEF_TYPEDEF_OPEQ(BitShrAssign, >>=)
+
+/// Provide increment operators to semantic typedefs.
+template<typename Typedef>
+struct Increment {
+  Typedef &operator++() {
+    ++detail::getValue(static_cast<Typedef &>(*this));
+    return static_cast<Typedef &>(*this);
+  }
+
+  Typedef operator++(int) {
+    Typedef ReturnValue(static_cast<Typedef &>(*this));
+    ++*this;
+    return ReturnValue;
+  }
+};
+
+/// Provide decrement operators to semantic typedefs.
+template<typename Typedef>
+struct Decrement {
+  Typedef &operator--() {
+    --detail::getValue(static_cast<Typedef &>(*this));
+    return static_cast<Typedef &>(*this);
+  }
+
+  Typedef operator--(int) {
+    Typedef ReturnValue(static_cast<Typedef &>(*this));
+    --*this;
+    return ReturnValue;
+  }
+};
+
+/// Provide streaming operators to semantic typedefs.
+template<typename Typedef>
+struct StreamOutput {
+  friend llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
+                                       const Typedef &V) {
+    return OS << detail::getValue(V);
+  }
+};
+
+/// Provide arithmetic to semantic typedefs.
+template<typename Typedef>
+struct Arithmetic : private Pos<Typedef>,
+                    private Neg<Typedef>,
+                    private Add<Typedef>,
+                    private Sub<Typedef>,
+                    private Mul<Typedef>,
+                    private Div<Typedef>,
+                    private Mod<Typedef> {};
+
+/// Provide arithmetic-assign operators to semantic typedefs.
+template<typename Typedef>
+struct ArithmeticAssign : private AddAssign<Typedef>,
+                          private SubAssign<Typedef>,
+                          private MulAssign<Typedef>,
+                          private DivAssign<Typedef>,
+                          private ModAssign<Typedef> {};
+
+/// Provide increment and decrement to semantic typedefs.
+template<typename Typedef>
+struct IncDec : public Increment<Typedef>,
+                public Decrement<Typedef> {};
+
+/// Provide bitwise operators to semantic typedefs.
+template<typename Typedef>
+struct Bitwise : private BitNot<Typedef>,
+                 private BitAnd<Typedef>,
+                 private BitOr<Typedef>,
+                 private BitXor<Typedef>,
+                 private BitShl<Typedef>,
+                 private BitShr<Typedef> {};
+
+/// Provide bitwise-assign operators to semantic typedefs.
+template<typename Typedef>
+struct BitwiseAssign : private BitAndAssign<Typedef>,
+                       private BitOrAssign<Typedef>,
+                       private BitXorAssign<Typedef>,
+                       private BitShlAssign<Typedef>,
+                       private BitShrAssign<Typedef> {};
+
+/// Provide logical operators to semantic typedefs.
+template<typename Typedef>
+struct Logical : private LogNot<Typedef>,
+                 private LogAnd<Typedef>,
+                 private LogOr<Typedef> {};
+
+/// Provide operators useful for sorting to semantic typedefs.
+template<typename Typedef>
+struct Sortable : private LtCmp<Typedef> {};
+
+/// Provide compare operators to semantic typedefs.
+template<typename Typedef>
+struct Compare : private Sortable<Typedef>,
+                 private LeCmp<Typedef>,
+                 private EqCmp<Typedef>,
+                 private NeCmp<Typedef>,
+                 private GeCmp<Typedef>,
+                 private GtCmp<Typedef> {};
+}  // end namespace typedef_operators
+
+#undef TYPEDEF_UNARY_OP
+#undef MAKE_TYPEDEFUNARY_OP
+#undef TYPEDEF_TYPEDEF_BINARY_OP
+#undef TYPEDEF_TYPEDEF_BINARY_OP_ALT
+#undef TYPEDEF_TYPEDEF_BINARY_OPEQ
+#undef MAKE_TYPEDEF_TYPEDEF_BINARY_OP
+#undef MAKE_TYPEDEF_TYPEDEF_OPEQ
+
+}  // end namespace llvm
+
+#endif

llvm/unittests/ADT/CMakeLists.txt

add_llvm_unittest(ADTTests
   PointerSumTypeTest.cpp
   PointerUnionTest.cpp
   PostOrderIteratorTest.cpp
   PriorityWorklistTest.cpp
   RangeAdapterTest.cpp
   SCCIteratorTest.cpp
   STLExtrasTest.cpp
   ScopeExitTest.cpp
+  SemanticTypedef.cpp
   SequenceTest.cpp
   SetVectorTest.cpp
   SimpleIListTest.cpp
   SmallPtrSetTest.cpp
   SmallSetTest.cpp
   SmallStringTest.cpp
   SmallVectorTest.cpp
   SparseBitVectorTest.cpp

llvm/unittests/ADT/SemanticTypedef.cpp

+//===- unittests/ADT/SemanticTypedef.cpp - Semantic typedef tests ---------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ADT/SemanticTypedef.h"
+#include "llvm/ADT/SmallString.h"
+
+#include "gtest/gtest.h"
+
+#include <cstdint>
+#include <type_traits>
+
+using namespace llvm;
+
+namespace {
+using namespace typedef_operators;
+
+class SemanticTypedefTest : public testing::Test {
+public:
+  // Interoperates with MyInt.
+  class MyInt : public SemanticTypedef<MyInt, int>,
+                private Arithmetic<MyInt>,
+                private ArithmeticAssign<MyInt>,
+                public IncDec<MyInt>,
+                private Bitwise<MyInt>,
+                private BitwiseAssign<MyInt>,
+                private Compare<MyInt>,
+                private StreamOutput<MyInt> {
+  public:
+    using SemanticTypedef<MyInt, int>::SemanticTypedef;
+  };
+
+  class MyOtherInt : public SemanticTypedef<MyOtherInt, int>,
+                     private Arithmetic<MyOtherInt>,
+                     private ArithmeticAssign<MyOtherInt>,
+                     public IncDec<MyOtherInt>,
+                     private Bitwise<MyOtherInt>,
+                     private BitwiseAssign<MyOtherInt>,
+                     private Compare<MyOtherInt>,
+                     private StreamOutput<MyOtherInt> {
+  public:
+    using SemanticTypedef<MyOtherInt, int>::SemanticTypedef;
+  };
+
+  struct NonCRTPInt {};
+  using MyNonCRTPInt = SemanticTypedef<NonCRTPInt, int>;
+
+  using IntBaseType = UnderlyingType<MyInt>;
+
+  // Interoperates with MyBool.
+  class MyBool : public SemanticTypedef<MyBool, bool>,
+                 private EqCmp<MyBool>,
+                 private Logical<MyBool>,
+                 StreamOutput<MyBool> {
+  public:
+    using SemanticTypedef<MyBool, bool>::SemanticTypedef;
+  };
+
+  using BoolBaseType = UnderlyingType<MyBool>;
+
+  SemanticTypedefTest() {}
+
+  // Test copy constructor.
+  MyInt foo(MyInt a) {
+    return a;
+  }
+
+  MyNonCRTPInt foo(MyNonCRTPInt a) {
+    return a;
+  }
+};
+
+TEST_F(SemanticTypedefTest, Conversions) {
+  MyInt a(10);
+  MyOtherInt b(20);
+  MyNonCRTPInt c(30);
+
+  EXPECT_EQ(IntBaseType(a), 10);
+  EXPECT_EQ(IntBaseType(b), 20);
+
+  bool aToUnderlying = std::is_convertible<decltype(a),
+                                           UnderlyingType<decltype(a)>>::value;
+  bool underlyingToa = std::is_convertible<UnderlyingType<decltype(a)>,
+                                           decltype(a)>::value;
+
+  EXPECT_FALSE(aToUnderlying);
+  EXPECT_FALSE(underlyingToa);
+
+  bool aTob = std::is_convertible<decltype(a), decltype(b)>::value;
+  bool bToa = std::is_convertible<decltype(b), decltype(a)>::value;
+
+  EXPECT_FALSE(aTob);
+  EXPECT_FALSE(bToa);
+
+  bool aToc = std::is_convertible<decltype(a), decltype(c)>::value;
+  bool cToa = std::is_convertible<decltype(c), decltype(a)>::value;
+
+  EXPECT_FALSE(aToc);
+  EXPECT_FALSE(cToa);
+}
+
+TEST_F(SemanticTypedefTest, Copy) {
+  int aValue = 10;
+  int bValue = 20;
+
+  MyInt a(aValue);
+  MyNonCRTPInt b(bValue);
+
+  MyInt c(foo(a));
+  MyNonCRTPInt d(foo(b));
+
+  EXPECT_EQ(IntBaseType(c), aValue);
+  EXPECT_EQ(IntBaseType(d), bValue);
+}
+
+TEST_F(SemanticTypedefTest, Assign) {
+  int aValue = 10;
+  int bValue = 20;
+
+  MyInt a(10);
+  MyInt b(20);
+
+  aValue = bValue;
+  a = b;
+
+  EXPECT_EQ(IntBaseType(a), aValue);
+}
+
+TEST_F(SemanticTypedefTest, Swap) {
+  int aValue = 10;
+  int bValue = 20;
+
+  MyInt a(aValue);
+  MyInt b(bValue);
+
+  std::swap(aValue, bValue);
+  swap(a, b);
+
+  EXPECT_EQ(IntBaseType(a), aValue);
+  EXPECT_EQ(IntBaseType(b), bValue);
+}
+
+TEST_F(SemanticTypedefTest, Arithmetic) {
+  int aValue = 10;
+  int bValue = 20;
+
+  MyInt a(aValue);
+  MyInt b(bValue);
+
+  EXPECT_EQ(IntBaseType(+a), aValue);
+  EXPECT_EQ(IntBaseType(-a), -aValue);
+  EXPECT_EQ(IntBaseType(a + b), aValue + bValue);
+  EXPECT_EQ(IntBaseType(a - b), aValue - bValue);
+  EXPECT_EQ(IntBaseType(a * b), aValue * bValue);
+  EXPECT_EQ(IntBaseType(a % b), aValue % bValue);
+
+  a += b;
+  aValue += bValue;
+  EXPECT_EQ(IntBaseType(a), aValue);
+
+  a -= b;
+  aValue -= bValue;
+  EXPECT_EQ(IntBaseType(a), aValue);
+
+  a *= b;
+  aValue *= bValue;
+  EXPECT_EQ(IntBaseType(a), aValue);
+
+  a /= b;
+  aValue /= bValue;
+  EXPECT_EQ(IntBaseType(a), aValue);
+
+  a %= b;
+  aValue %= bValue;
+  EXPECT_EQ(IntBaseType(a), aValue);
+}
+
+TEST_F(SemanticTypedefTest, IncDec) {
+  MyInt a(0);
+
+  ASSERT_EQ(++a, MyInt(1));
+  ASSERT_EQ(a++, MyInt(1));
+  ASSERT_EQ(a, MyInt(2));
+
+  ASSERT_EQ(--a, MyInt(1));
+  ASSERT_EQ(a--, MyInt(1));
+  ASSERT_EQ(a, MyInt(0));
+}
+
+TEST_F(SemanticTypedefTest, Bitwise) {
+  int aValue = 10;
+  int bValue = 20;
+
+  MyInt a(aValue);
+  MyInt b(bValue);
+
+  EXPECT_EQ(IntBaseType(~a), ~aValue);
+  EXPECT_EQ(IntBaseType(a & b), aValue & bValue);
+  EXPECT_EQ(IntBaseType(a | b), aValue | bValue);
+  EXPECT_EQ(IntBaseType(a ^ b), aValue ^ bValue);
+  EXPECT_EQ(IntBaseType(a << b), aValue << bValue);
+  EXPECT_EQ(IntBaseType(a >> b), aValue >> bValue);
+
+  a &= b;
+  aValue &= bValue;
+  EXPECT_EQ(IntBaseType(a), aValue);
+
+  a |= b;
+  aValue |= bValue;
+  EXPECT_EQ(IntBaseType(a), aValue);
+
+  a ^= b;
+  aValue ^= bValue;
+  EXPECT_EQ(IntBaseType(a), aValue);
+
+  a <<= b;
+  aValue <<= bValue;
+  EXPECT_EQ(IntBaseType(a), aValue);
+
+  a >>= b;
+  aValue >>= bValue;
+  EXPECT_EQ(IntBaseType(a), aValue);
+}
+
+TEST_F(SemanticTypedefTest, Compare) {
+  int aValue = 10;
+  int bValue = 20;
+
+  MyInt a(aValue);
+  MyInt b(bValue);
+
+  EXPECT_EQ(IntBaseType(a < b), aValue < bValue);
+  EXPECT_EQ(IntBaseType(a <= b), aValue <= bValue);
+  EXPECT_EQ(IntBaseType(a == b), aValue == bValue);
+  EXPECT_EQ(IntBaseType(a != b), aValue != bValue);
+  EXPECT_EQ(IntBaseType(a >= b), aValue >= bValue);
+  EXPECT_EQ(IntBaseType(a > b), aValue > bValue);
+}
+
+TEST_F(SemanticTypedefTest, LessThan) {
+  MyInt a(10);
+  MyInt b(20);
+
+  EXPECT_TRUE(a < b);
+  EXPECT_FALSE(b < a);
+  EXPECT_FALSE(a < a);
+  EXPECT_FALSE(a >= b);
+  EXPECT_TRUE(b >= a);
+  EXPECT_TRUE(a >= a);
+}
+
+TEST_F(SemanticTypedefTest, IntStreamOutput) {
+  int aValue = 10;
+  MyInt a(aValue);
+
+  SmallString<5> aValueOutput;
+  SmallString<5> aOutput;
+
+  raw_svector_ostream aValueOS(aOutput);
+  raw_svector_ostream aOS(aOutput);
+
+  aValueOS << aValue;
+  aOS << a;
+
+  ASSERT_EQ(aOS.str(), aValueOS.str());
+}
+
+TEST_F(SemanticTypedefTest, Logical) {
+  bool aValue = true;
+  bool bValue = true;
+
+  MyBool a(aValue);
+  MyBool b(bValue);
+
+  EXPECT_EQ(a && a, aValue && aValue);
+  EXPECT_EQ(a && b, aValue && bValue);
+  EXPECT_EQ(b && a, bValue && aValue);
+  EXPECT_EQ(b && b, bValue && bValue);
+
+  EXPECT_EQ(a || a, aValue || aValue);
+  EXPECT_EQ(a || b, aValue || bValue);
+  EXPECT_EQ(b || a, bValue || aValue);
+  EXPECT_EQ(b || b, bValue || bValue);
+
+  EXPECT_EQ(!a, !aValue);
+  EXPECT_EQ(!b, !bValue);
+}
+
+TEST_F(SemanticTypedefTest, BoolStreamOutput) {
+  bool aValue = true;
+  bool bValue = true;
+
+  MyBool a(aValue);
+  MyBool b(bValue);
+
+  SmallString<5> aValueOutput;
+  SmallString<5> aOutput;
+  SmallString<5> bValueOutput;
+  SmallString<5> bOutput;
+
+  raw_svector_ostream aValueOS(aOutput);
+  raw_svector_ostream aOS(aOutput);
+  raw_svector_ostream bValueOS(bOutput);
+  raw_svector_ostream bOS(bOutput);
+
+  aValueOS << aValue;
+  aOS << a;
+  bValueOS << bValue;
+  bOS << b;
+
+  ASSERT_EQ(aOS.str(), aValueOS.str());
+  ASSERT_EQ(bOS.str(), bValueOS.str());
+}
+}  // end anonymous namespace