[Concepts] Type Constraints

Add support for type-constraints in template type parameters.
Also add support for template type parameters as pack expansions (where the type constraint can now contain an unexpanded parameter pack).

Differential Revision: https://reviews.llvm.org/D44352

Author: saarraz

clang/include/clang/AST/ASTConcept.h

@@ -21,6 +21,7 @@
 #include <string>
 #include <utility>
 namespace clang {
+class ConceptDecl;
 
 /// \brief The result of a constraint satisfaction check, containing the
 /// necessary information to diagnose an unsatisfied constraint.
@@ -75,6 +76,102 @@ struct ASTConstraintSatisfaction final :
   Create(const ASTContext &C, const ConstraintSatisfaction &Satisfaction);
 };
 
+/// \brief Common data class for constructs that reference concepts with
+/// template arguments.
+class ConceptReference {
+protected:
+  // \brief The optional nested name specifier used when naming the concept.
+  NestedNameSpecifierLoc NestedNameSpec;
+
+  /// \brief The ___location of the template keyword, if specified when naming the
+  /// concept.
+  SourceLocation TemplateKWLoc;
+
+  /// \brief The concept name used.
+  DeclarationNameInfo ConceptName;
+
+  /// \brief The declaration found by name lookup when the expression was
+  /// created.
+  /// Can differ from NamedConcept when, for example, the concept was found
+  /// through a UsingShadowDecl.
+  NamedDecl *FoundDecl;
+
+  /// \brief The concept named.
+  ConceptDecl *NamedConcept;
+
+  /// \brief The template argument list source info used to specialize the
+  /// concept.
+  const ASTTemplateArgumentListInfo *ArgsAsWritten;
+
+public:
+
+  ConceptReference(NestedNameSpecifierLoc NNS, SourceLocation TemplateKWLoc,
+                   DeclarationNameInfo ConceptNameInfo, NamedDecl *FoundDecl,
+                   ConceptDecl *NamedConcept,
+                   const ASTTemplateArgumentListInfo *ArgsAsWritten) :
+      NestedNameSpec(NNS), TemplateKWLoc(TemplateKWLoc),
+      ConceptName(ConceptNameInfo), FoundDecl(FoundDecl),
+      NamedConcept(NamedConcept), ArgsAsWritten(ArgsAsWritten) {}
+
+  ConceptReference() : NestedNameSpec(), TemplateKWLoc(), ConceptName(),
+      FoundDecl(nullptr), NamedConcept(nullptr), ArgsAsWritten(nullptr) {}
+
+  const NestedNameSpecifierLoc &getNestedNameSpecifierLoc() const {
+    return NestedNameSpec;
+  }
+
+  const DeclarationNameInfo &getConceptNameInfo() const { return ConceptName; }
+
+  SourceLocation getConceptNameLoc() const {
+    return getConceptNameInfo().getLoc();
+  }
+
+  SourceLocation getTemplateKWLoc() const { return TemplateKWLoc; }
+
+  NamedDecl *getFoundDecl() const {
+    return FoundDecl;
+  }
+
+  ConceptDecl *getNamedConcept() const {
+    return NamedConcept;
+  }
+
+  const ASTTemplateArgumentListInfo *getTemplateArgsAsWritten() const {
+    return ArgsAsWritten;
+  }
+
+  /// \brief Whether or not template arguments were explicitly specified in the
+  /// concept reference (they might not be in type constraints, for example)
+  bool hasExplicitTemplateArgs() const {
+    return ArgsAsWritten != nullptr;
+  }
+};
+
+class TypeConstraint : public ConceptReference {
+  /// \brief The immediately-declared constraint expression introduced by this
+  /// type-constraint.
+  Expr *ImmediatelyDeclaredConstraint = nullptr;
+
+public:
+  TypeConstraint(NestedNameSpecifierLoc NNS,
+                 DeclarationNameInfo ConceptNameInfo, NamedDecl *FoundDecl,
+                 ConceptDecl *NamedConcept,
+                 const ASTTemplateArgumentListInfo *ArgsAsWritten,
+                 Expr *ImmediatelyDeclaredConstraint) :
+      ConceptReference(NNS, /*TemplateKWLoc=*/SourceLocation(), ConceptNameInfo,
+                       FoundDecl, NamedConcept, ArgsAsWritten),
+      ImmediatelyDeclaredConstraint(ImmediatelyDeclaredConstraint) {}
+
+  /// \brief Get the immediately-declared constraint expression introduced by
+  /// this type-constraint, that is - the constraint expression that is added to
+  /// the associated constraints of the enclosing declaration in practice.
+  Expr *getImmediatelyDeclaredConstraint() const {
+    return ImmediatelyDeclaredConstraint;
+  }
+
+  void print(llvm::raw_ostream &OS, PrintingPolicy Policy) const;
+};
+
 } // clang
 
 #endif // LLVM_CLANG_AST_ASTCONCEPT_H

clang/include/clang/AST/ASTContext.h

@@ -283,12 +283,16 @@ class ASTContext : public RefCountedBase<ASTContext> {
 
     TemplateTemplateParmDecl *getParam() const { return Parm; }
 
-    void Profile(llvm::FoldingSetNodeID &ID) { Profile(ID, Parm); }
+    void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &C) {
+      Profile(ID, C, Parm);
+    }
 
     static void Profile(llvm::FoldingSetNodeID &ID,
+                        const ASTContext &C,
                         TemplateTemplateParmDecl *Parm);
   };
-  mutable llvm::FoldingSet<CanonicalTemplateTemplateParm>
+  mutable llvm::ContextualFoldingSet<CanonicalTemplateTemplateParm,
+                                     const ASTContext&>
     CanonTemplateTemplateParms;
 
   TemplateTemplateParmDecl *

clang/include/clang/AST/ASTNodeTraverser.h

@@ -537,13 +537,19 @@ class ASTNodeTraverser
   }
 
   void VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *D) {
+    if (const auto *TC = D->getTypeConstraint())
+      if (TC->hasExplicitTemplateArgs())
+        for (const auto &ArgLoc : TC->getTemplateArgsAsWritten()->arguments())
+          dumpTemplateArgumentLoc(ArgLoc);
     if (D->hasDefaultArgument())
       Visit(D->getDefaultArgument(), SourceRange(),
             D->getDefaultArgStorage().getInheritedFrom(),
             D->defaultArgumentWasInherited() ? "inherited from" : "previous");
   }
 
   void VisitNonTypeTemplateParmDecl(const NonTypeTemplateParmDecl *D) {
+    if (const auto *TC = D->getPlaceholderTypeConstraint())
+      Visit(TC->getImmediatelyDeclaredConstraint());
     if (D->hasDefaultArgument())
       Visit(D->getDefaultArgument(), SourceRange(),
             D->getDefaultArgStorage().getInheritedFrom(),