[Clang] Add __builtin_common_reference

Author: philnik777

clang/docs/LanguageExtensions.rst

@@ -1546,6 +1546,23 @@ Builtin type aliases
 
 Clang provides a few builtin aliases to improve the throughput of certain metaprogramming facilities.
 
+__builtin_common_reference
+--------------------------
+
+.. code-block:: c++
+
+  template <template <class, class, template <class> class, template <class> class> class BasicCommonReferenceT,
+            template <class... Args> CommonTypeT,
+            template <class> HasTypeMember,
+            class HasNoTypeMember,
+            class... Ts>
+  using __builtin_common_reference = ...;
+
+This alias is used for implementing ``std::common_refernce``. If ``std::common_reference`` should contain a ``type``
+member, it is an alias to ``HasTypeMember<TheCommonReference>``. Otherwse it is an alias to ``HasNoTypeMember``. The
+``CommonTypeT`` is usually ``std::common_type_t``. ``BasicCommonReferenceT`` is usually an alias template to
+``basic_common_reference<T, U, TX, UX>::type``.
+
 __builtin_common_type
 ---------------------
 

clang/include/clang/AST/ASTContext.h

@@ -419,6 +419,9 @@ class ASTContext : public RefCountedBase<ASTContext> {
   /// The identifier '__builtin_common_type'.
   mutable IdentifierInfo *BuiltinCommonTypeName = nullptr;
 
+  /// The identifier '__builtin_common_reference'.
+  mutable IdentifierInfo *BuiltinCommonReferenceName = nullptr;
+
   QualType ObjCConstantStringType;
   mutable RecordDecl *CFConstantStringTagDecl = nullptr;
   mutable TypedefDecl *CFConstantStringTypeDecl = nullptr;
@@ -627,6 +630,8 @@ class ASTContext : public RefCountedBase<ASTContext> {
   mutable BuiltinTemplateDecl *MakeIntegerSeqDecl = nullptr;
   mutable BuiltinTemplateDecl *TypePackElementDecl = nullptr;
   mutable BuiltinTemplateDecl *BuiltinCommonTypeDecl = nullptr;
+  mutable BuiltinTemplateDecl *BuiltinCommonReferenceDecl = nullptr;
+  mutable CVRefQualifyingTemplateDecl *CVRefQualifyingDecls[12] = {};
 
   /// The associated SourceManager object.
   SourceManager &SourceMgr;
@@ -1155,6 +1160,8 @@ class ASTContext : public RefCountedBase<ASTContext> {
   BuiltinTemplateDecl *getMakeIntegerSeqDecl() const;
   BuiltinTemplateDecl *getTypePackElementDecl() const;
   BuiltinTemplateDecl *getBuiltinCommonTypeDecl() const;
+  BuiltinTemplateDecl *getBuiltinCommonReferenceDecl() const;
+  CVRefQualifyingTemplateDecl *getCVRefQualifyingAliasDecl(QualType From) const;
 
   // Builtin Types.
   CanQualType VoidTy;
@@ -2072,6 +2079,12 @@ class ASTContext : public RefCountedBase<ASTContext> {
     return BuiltinCommonTypeName;
   }
 
+  IdentifierInfo *getBuiltinCommonReferenceName() const {
+    if (!BuiltinCommonReferenceName)
+      BuiltinCommonReferenceName = &Idents.get("__builtin_common_reference");
+    return BuiltinCommonReferenceName;
+  }
+
   /// Retrieve the Objective-C "instancetype" type, if already known;
   /// otherwise, returns a NULL type;
   QualType getObjCInstanceType() {

clang/include/clang/AST/ASTNodeTraverser.h

@@ -684,6 +684,10 @@ class ASTNodeTraverser
     dumpTemplateParameters(D->getTemplateParameters());
   }
 
+  void VisitCVRefQualifyingTemplateDecl(const CVRefQualifyingTemplateDecl *D) {
+    dumpTemplateParameters(D->getTemplateParameters());
+  }
+
   void
   VisitVarTemplateSpecializationDecl(const VarTemplateSpecializationDecl *D) {
     dumpTemplateArgumentList(D->getTemplateArgs());

clang/include/clang/AST/DeclID.h

@@ -86,6 +86,9 @@ enum PredefinedDeclIDs {
   /// The internal '__builtin_common_type' template.
   PREDEF_DECL_COMMON_TYPE_ID,
 
+  /// The internal '__builtin_common_reference' template.
+  PREDEF_DECL_COMMON_REFERENCE_ID,
+
   /// The number of declaration IDs that are predefined.
   NUM_PREDEF_DECL_IDS
 };

clang/include/clang/AST/DeclTemplate.h

@@ -1777,6 +1777,43 @@ class BuiltinTemplateDecl : public TemplateDecl {
   BuiltinTemplateKind getBuiltinTemplateKind() const { return BTK; }
 };
 
+class CVRefQualifyingTemplateDecl : public TemplateDecl {
+public:
+  // LValueRef and RValueRef are mutually exclusive
+  enum CVRefQuals {
+    None = 0x0,
+    Const = 0x1,
+    Volatile = 0x2,
+    LValueRef = 0x4,
+    RValueRef = 0x8,
+    LLVM_BITMASK_LARGEST_ENUMERATOR,
+  };
+
+private:
+  CVRefQuals Quals;
+
+  CVRefQualifyingTemplateDecl(const ASTContext &C, DeclContext *DC,
+                              CVRefQuals Quals);
+
+  void anchor() override;
+
+public:
+  // Implement isa/cast/dyncast support
+  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
+  static bool classofKind(Kind K) { return K == CVRefQualifyingTemplate; }
+
+  static CVRefQualifyingTemplateDecl *Create(const ASTContext &C,
+                                             DeclContext *DC, CVRefQuals Ref) {
+    return new (C, DC) CVRefQualifyingTemplateDecl(C, DC, Ref);
+  }
+
+  SourceRange getSourceRange() const override LLVM_READONLY {
+    return {};
+  }
+
+  CVRefQuals getQuals() { return Quals; }
+};
+
 /// Provides information about an explicit instantiation of a variable or class
 /// template.
 struct ExplicitInstantiationInfo {

clang/include/clang/AST/RecursiveASTVisitor.h

@@ -1960,6 +1960,10 @@ DEF_TRAVERSE_DECL(BuiltinTemplateDecl, {
   TRY_TO(TraverseTemplateParameterListHelper(D->getTemplateParameters()));
 })
 
+DEF_TRAVERSE_DECL(CVRefQualifyingTemplateDecl, {
+  TRY_TO(TraverseTemplateParameterListHelper(D->getTemplateParameters()));
+})
+
 template <typename Derived>
 bool RecursiveASTVisitor<Derived>::TraverseTemplateTypeParamDeclConstraints(
     const TemplateTypeParmDecl *D) {

clang/include/clang/Basic/Builtins.h

@@ -311,6 +311,9 @@ enum BuiltinTemplateKind : int {
 
   /// This names the __builtin_common_type BuiltinTemplateDecl.
   BTK__builtin_common_type,
+
+  /// This names the __builtin_common_reference BuiltinTemplateDecl.
+  BTK__builtin_common_reference,
 };
 
 } // end namespace clang

clang/include/clang/Basic/DeclNodes.td

@@ -71,6 +71,7 @@ def Named : DeclNode<Decl, "named declarations", 1>;
       def TypeAliasTemplate : DeclNode<RedeclarableTemplate>;
     def TemplateTemplateParm : DeclNode<Template>;
     def BuiltinTemplate : DeclNode<Template>;
+    def CVRefQualifyingTemplate : DeclNode<Template>;
     def Concept : DeclNode<Template>;
   def BaseUsing : DeclNode<Named, "", 1>;
     def Using : DeclNode<BaseUsing>;

clang/include/clang/Sema/Sema.h

@@ -14897,15 +14897,34 @@ class Sema final : public SemaBase {
   QualType BuiltinDecay(QualType BaseType, SourceLocation Loc);
   QualType BuiltinAddReference(QualType BaseType, UTTKind UKind,
                                SourceLocation Loc);
+
+  QualType BuiltinAddRValueReference(QualType BaseType, SourceLocation Loc) {
+    return BuiltinAddReference(BaseType, UnaryTransformType::AddRvalueReference,
+                               Loc);
+  }
+
+  QualType BuiltinAddLValueReference(QualType BaseType, SourceLocation Loc) {
+    return BuiltinAddReference(BaseType, UnaryTransformType::AddLvalueReference,
+                               Loc);
+  }
+
   QualType BuiltinRemoveExtent(QualType BaseType, UTTKind UKind,
                                SourceLocation Loc);
   QualType BuiltinRemoveReference(QualType BaseType, UTTKind UKind,
                                   SourceLocation Loc);
+
+  QualType BuiltinRemoveCVRef(QualType BaseType, SourceLocation Loc) {
+    return BuiltinRemoveReference(BaseType, UTTKind::RemoveCVRef, Loc);
+  }
+
   QualType BuiltinChangeCVRQualifiers(QualType BaseType, UTTKind UKind,
                                       SourceLocation Loc);
   QualType BuiltinChangeSignedness(QualType BaseType, UTTKind UKind,
                                    SourceLocation Loc);
 
+  bool BuiltinIsConvertible(QualType From, QualType To, SourceLocation Loc,
+                            bool CheckNothrow = false);
+
   /// Ensure that the type T is a literal type.
   ///
   /// This routine checks whether the type @p T is a literal type. If @p T is an

clang/lib/AST/ASTContext.cpp

@@ -1218,6 +1218,37 @@ BuiltinTemplateDecl *ASTContext::getBuiltinCommonTypeDecl() const {
   return BuiltinCommonTypeDecl;
 }
 
+BuiltinTemplateDecl *ASTContext::getBuiltinCommonReferenceDecl() const {
+  if (!BuiltinCommonReferenceDecl)
+    BuiltinCommonReferenceDecl = buildBuiltinTemplateDecl(
+        BTK__builtin_common_reference, getBuiltinCommonReferenceName());
+  return BuiltinCommonReferenceDecl;
+}
+
+CVRefQualifyingTemplateDecl *
+ASTContext::getCVRefQualifyingAliasDecl(QualType From) const {
+  using CVRefQuals = CVRefQualifyingTemplateDecl::CVRefQuals;
+
+  CVRefQuals Q = CVRefQuals::None;
+  if (From->isReferenceType()) {
+    Q |= From->isLValueReferenceType() ? CVRefQuals::LValueRef
+                                       : CVRefQuals::RValueRef;
+    From = From.getNonReferenceType();
+  }
+
+  if (From.isConstQualified())
+    Q |= CVRefQuals::Const;
+  if (From.isVolatileQualified())
+    Q |= CVRefQuals::Volatile;
+  auto *Decl = CVRefQualifyingDecls[Q];
+  if (!Decl)
+    Decl =
+        CVRefQualifyingTemplateDecl::Create(*this, getTranslationUnitDecl(), Q);
+  Decl->setImplicit();
+  getTranslationUnitDecl()->addDecl(Decl);
+  return Decl;
+}
+
 RecordDecl *ASTContext::buildImplicitRecord(StringRef Name,
                                             RecordDecl::TagKind TK) const {
   SourceLocation Loc;