Add a concept AST node.

[massberg]

Summary

This patch adds a concept AST node (ConceptReference) and uses it at the corresponding places.

There are three objects that might have constraints via concepts:
TypeConstraint, ConceptSpecializationExpr and AutoTypeLoc.
The first two inherit from ConceptReference while the latter has
the information about a possible constraint directly stored in AutoTypeLocInfo. It would be nice if the concept information would be stored the same way in all three cases.

Moreover the current structure makes it difficult to deal with these concepts. For example in Clangd accessing the locations of constraints of a AutoTypeLoc can only be done with quite ugly hacks.

So we think that it makes sense to create a new AST node for such concepts.

In details we propose the following:

• Make ConceptReference the new AST node.
• TypeConstraint and ConceptSpecializationExpr do not longer inherit from ConceptReference but store a pointer to a ConceptReference.
• AutoTypeLoc stores a pointer to ConceptReference instead of storing the concept info in AutoTypeLocInfo.

This patch implements a first version of this idea which compiles and where the existing tests pass.
To make this patch as small as possible we keep the existing member functions to access concept data. Later these can be replaced by directly calling the corresponding functions of the ConceptReferences.

[sammccall]

clang/include/clang/AST/ASTConcept.h

222–253

FWIW clang doesn't seem to usually bother with const-correctness, so it's hardly even clear what it means.

I'd stick with ConceptLoc *getConceptLoc() const :-)

clang/lib/AST/ASTImporter.cpp

5640

better to instead import via the TC->getConceptLoc(), and have a function to wrap up the import of the individual properties

5657

the templateKWLoc should be the import of the original constraint's conceptloc's templatekwloc

clang/lib/Sema/SemaTemplate.cpp

1274

From reading the code that currently initializes ConceptReference for a TypeConstraint, this is always SourceLocation{}.

Either this is not possible at the language level, or it's just not something the AST currently tracks.

clang/lib/Serialization/ASTReaderDecl.cpp

2632

again, this is correct, at least as correct as current code.
type constraints never have the template keyword, or it's never tracked

[massberg]

AutoTypeLoc now uses ConceptLoc to store information of a concept instead of storing all information itself.

[massberg]

clang/include/clang/AST/TypeLoc.h

2158

I cannot replace this by SourceLocation() without failing tests, although this function should only be called if there are constraints.

2187

I assume that getLAngleLoc and getRAngleLoc should be moved to ConceptLoc, even if it currently only used by AutoTypeLoc?

2212–2213

I don't know why we need this here.
getArgLoc should only be called if there are constraints and in that case getConceptLoc() should be set.
However, we still run into this return. Note that ArgsInfo is only initialized in initializeLocal but never changed afterwards.

[massberg]

Initial changes to RecursiveASTVisitor to traverse ConceptLocs.

[massberg]

Add VisitConceptLoc.

[massberg]

clang/include/clang/AST/RecursiveASTVisitor.h

318

This is basically the old TraverseConceptReferenceHelper function. Is it by purpose that this isn't const in most other functions? Could the passes objects be changed in such functions?

clang/include/clang/AST/TypeLoc.h

2187

This might be accessible from `getConceptLoc()->getTemplateArgsAsWritten().

[massberg]

Add readConceptLoc and AddConceptLoc functions.

[massberg]

Code clean-up.

[massberg]

Remove LAngleLoc and RAngleLoc from AutoTypeLocInfo and access thse location directly from the template args at thestored ConceptLoc.

[massberg]

Fix typo.

[massberg]

Some code simplification.

[massberg]

@erichkeane Hi Erich, we would like to add an AST node for concepts (see description above) and we are interested in your opinion on it.
This patch is a draft of what the new AST node could look like and how it would be part of the existing infrastructure.

[massberg]

Create a patch from draft version.

[massberg]

Updated comments.

[hokein]

Thanks, this looks like in a good sharp, I left some comments.

I think it would be nice to get some high-level design input from @erichkeane before making further changes.

clang/include/clang/AST/ASTConcept.h

115

It would be nice to update this comment (for the other related classes, TypeConstraint), this is an important comment which helps reviewers easier understand the design principles of this change.

118

I'm not sure the ConceptLoc is a reasonable name for this structure.

1. In general, classes named *Loc in clang AST are tiny, and they are passed by value, so seeing the usage ConceptLoc * in the code is a bit wired and inconsistent.
2. Unlike other TemplateArgumentLoc, NestedNameSpecifierLoc, TypeLoc (where they all have TemplateArgument/TemplateArgumentLoc split), and we don't have a corresponding split for ConceptLoc.

I think 2) is probably fine, but 1) is a concern, we plan to make it a real AST node, so we will likely add it to the DynTypedNode, adding a big class there will increase the DynTypedNode a lot (from 40 bytes => 80 bytes).

One idea is to make this class ConceptLocInfo, and create a new wrapper class ConceptLoc wrapper which contains a ConceptLocInfo* pointer, and a ConceptDecl* concept.

clang/include/clang/AST/TypeLoc.h

2114

just an idea, instead storing a ConceptLoc* in AutoTypeLoc, there is another approach (not sure it was considered before), which is to have a TypeConstraint* in the AutoType (and remove the ConceptDecl*).

This gives us a model following the grammar closely. type-constrains is used in the auto grammar rule, so it seems reasonable to have TypeConstraint in AutoType. The downside is that there is a lot of indirections: AutoTypeLoc -> AutoType -> TypeConstraint -> ConceptLoc vs AutoTypeLoc -> ConceptLoc.

2116

It looks like this is not necessary now, as we can reuse the TemplateArgument in ConceptLoc, maybe we can even remove it in the future

2147

nit: if (const auto* Concept = getConcetLoc()), the same for the other places.

any reason why we need this null sanity check?

2158

is this comment still applied (you marked it done)? It seems reasonable to return a SourceLocation(), which tests were failed if we did this?

2210

which kind of tests were broken if we remove this?

[massberg]

clang/include/clang/AST/TypeLoc.h

2158

My original comment had become obsolete.

[massberg]

(removed comment)

[cor3ntin]

clang/include/clang/AST/ASTConcept.h

118

Agreed, the name change seems more confusing than anything and not really consistent with preexisting names.
It is still unclear to me what is wrong with the current name (and all these renamings obfuscate what the patch is actually trying to do)

[massberg]

Rename ConceptLoc back to ConceptReference.

[massberg]

clang/include/clang/AST/ASTConcept.h

118

I'm sorry if the renaming led to confusions. I have renamed it back to ConceptReference for now. I'm happy for any proposals for a good name (or to keep the old name).

[hokein]

adding @aaron.ballman, who might have opinion on this.

[cor3ntin]

clang/include/clang/AST/ExprConcepts.h

142–145

Should there be a getLocation() method on ConceptReference ? It seems useful. maybe even a getSourceRange() method too

clang/lib/Serialization/ASTWriter.cpp

472–484

I tink it would be better to only call AddConceptReference with non null parameters, and save in the parents whether there is a concept reference or not

[massberg]

Only call AddConceptReference if there is a concept reference.

[sammccall]

(There are still outstanding comments e.g. in ASTImport)

I think it would be useful to add to the patch description:

• the current deficiencies of ConceptReference that make it not a well-behaved AST node now
• which of these are addressed in this patch (RecursiveASTVisitor, use in all relevant places, avoiding multiple inheritance)
• which of these will be addressed in future patches (DynTypedNode, maybe text-dumper?)

clang/include/clang/AST/ASTConcept.h

116

Doc comment is out of date. Suggestion:

/// A reference to a concept and its template args, as it appears in the code.
///
/// Examples:
///   template <int X> requires is_even<X> int half = X/2;
///                             ~~~~~~~~~~ (in ConceptSpecializationExpr)
///
///   std::input_iterator auto I = Container.begin();
///   ~~~~~~~~~~~~~~~~~~~ (in AutoTypeLoc)
///
///   template <std::derives_from<Expr> T> void dump();
///             ~~~~~~~~~~~~~~~~~~~~~~~ (in TemplateTypeParmDecl)

143–144

this constructor should now be private, like other AST nodes

152

following the pattern for other AST nodes, this constructor should be private or gone. If deserialization needs to create an empty ConceptReference, provide a CreateEmpty() factory

197–204

We're not really changing this class, but I think it could use a doc comment as its relationship to ConceptReference, TemplateTypeParmType, and AutoTypeLoc wasn't all that clear. Suggestion:

/// Models the abbreviated syntax to constrain a template type parameter:
///   template <convertible_to<string> T> void print(T object);
///             ~~~~~~~~~~~~~~~~~~~~~~
/// Semantically, this adds an "immediately-declared constraint" with extra arg:
///    requires convertible_to<T, string>
///
/// In the C++ grammar, a type-constraint is also used for auto types:
///    convertible_to<string> auto X = ...;
/// We do *not* model these as TypeConstraints, but AutoType(Loc) directly.

clang/include/clang/AST/ExprConcepts.h

90

incomplete comment: "to prevent" what?

Also FWIW I don't think *all* uses should be migrated, e.g. getNamedConcept() is fundamental enough to be exposed here even if it's implemented via ConceptReference.

142–145

agree, though we actually shouldn't call ConceptReference::getLocation() method here because primary location != start location.

I think

• ConceptReference::getLocation() should return getConceptNameLoc() (just an alias)
• ConceptSpecializationExpr::getExprLoc() should return ConceptReference::getLocation()
• ConceptReference::getBeginLoc() should contain this logic, ConceptSpecializationExpr::getBeginLoc() should return it
• ditto end loc
• ConceptReference::getSourceRange() is a useful helper
• ConceptSpecializationExpr already has getSourceRange() inherited from Stmt

clang/include/clang/AST/RecursiveASTVisitor.h

318

It's somewhere between intended and awkward historical baggage: most RAVs don't mutate the nodes, but some do.

I suggest making this take a mutable pointer (rather than the more natural const reference) purely for consistency - RAV is confusing enough as it is.

2514

I think this should be guarded by if (!getDerived().shouldTraversePostOrder()), and then the opposite at the end

clang/include/clang/AST/TypeLoc.h

2114

I did look at this. Maybe it's a good idea, but it's not simple and it's mostly independent of the change in this patch.

The thing that TypeConstraint concretely adds to ConceptReference is the immediately-declared-constraint.
Today this constrains the TypeParmType and semantic analysis can treat it as a separate constraint: void foo(Iterator auto x) is equivalent to template<class T> void foo(T x) requires Iterator<T> or so.
However this formulation isn't convenient for placeholder types: Iterator auto x = ... isn't a template, there's no code processing requirements where we can tack on requires Iterator<auto>. It also doesn't clearly represent the idea that the two auto placeholders should be the same.

I agree it would be nice to follow the grammar (or if not, use different names) but I think that it's a separate change, and going from AutoTypeLoc{ConceptNameLoc etc} to AutoTypeLoc{ConceptReference{ConceptNameLocEtc}} is a useful stepping-stone to AutoTypeLoc{TypeConstraint{ConceptReference{ConceptNameLoc etc}}}

2147

Agree with the style change.

We need the check because there may be no constraining concept here: auto x = 2 should return an empty NNSLoc, not crash

2212–2213

I think this FIXME should be addressed before landing this patch.

Currently the code (apparently) stores two copies of the args: one as trailing objects here and one in the conceptreference.

Ideally we'd remove the trailing objects immediately. A FIXME to do so later is fine if needed, but if they're inconsistent then we know one of them has a bug, or we don't really understand the design.

These can lead to downstream bugs now, and also make it less likely such a FIXME will ever be cleaned up.

clang/lib/Sema/TreeTransform.h

6863

fix/remove commented-out code?

[massberg]

Resolve some of the reviewer's comments.

[massberg]

I have resolved some of the comments, but I need another round to finish all of the, Thanks to all reviewers so far!

clang/include/clang/AST/ExprConcepts.h

90

I have updated the FIXME.

clang/include/clang/AST/TypeLoc.h

2210

This is fixed now

[massberg]

clang/lib/Sema/TreeTransform.h

6834–6846

This is very ugly as I have to create the TALI and TAL arrays temporarily to use the existing transformations.
Is there a better way to do that?
Moreover, is this the correct place for the transformation? This is necessary as the passed AutoTypeLoc doesn't have an attached ConceptReference even if it is constrained. Has the ConceptReferenecof the original AutoTypeLoc be added somewhere earlier?

[sammccall]

clang/lib/Sema/TreeTransform.h

6834–6846

If I'm understanding the situation right...
the AutoTypeLoc in the template should have a ConceptReference, since the auto is constrained.
This seems like a bug to be fixed elsewhere, and then this else becomes dead.

Do you have a minimal example?

[erichkeane]

Hi! I was away on vacation, so I didn't get a chance to take a look at this. I'm currently digging my way through my 'back to work' tasks, but will keep this on my list of things to review ASAP.

[erichkeane]

So I did a quick run through, I think this is a fine idea and an improvement. However, @sammccall has given some very good feedback that I'd like to have him do the final approval.

clang/include/clang/AST/ASTConcept.h

208

Preference to name this something like ConceptRef instead of CR here.

clang/include/clang/AST/ExprConcepts.h

49

Same comment here.

152–155

What did you find that resulted in this change? What does hasExplicitTemplateArgs 'mean' when we have empty arguments, so something like:

template<UnaryConcept<> C>
void foo(const C&){}

Basically, the end loc should ALWAYS be the right-angle if it exists, right?

[massberg]

Resolved the next round of comments. There are still some left to be addressed.

[sammccall]

clang/lib/AST/TypeLoc.cpp

623–624

static

[massberg]

Resolve more of the open comments.

• add getBeginLoc(), getEndLoc() and getSourceRange() to ConceptReference and updated corresponding functions in ConceptSpecializationExpr
• additional fixed getBeginLoc() to work correctly with empty argument lists
• remove const from parameters of TraverseConceptReference() and VisitConceptReference()

still missing:

• Add tests for new location functions
• Investigation why we have to create a ConceptReference in initializeLocal() which looks not right
• Update patch description.

[sammccall]

OK, so I learned a bit about initializeLocal/trivial TypeSourceInfo. Mostly things I didn't want to know :-)
TL;DR I think the current version of the patch is right.

The crash is caused by:

1. CheckTemplateArgument calls SubstType without passing a TypeLoc, which synthesizes a trivial TypeSourceInfo to instantiate
2. the trivial TypeSourceInfo never has a ConceptReference
3. instantiating an AutoTypeLoc where the type is constrained but there's no ConceptReference is not supported

We can choose to address any of these.

Fixing #1 is tempting: the SubstType overload with no TypeLoc is deprecated and calling it ~always loses information. Cleaning up this call is an improvement, but there are ~15 calls to this overload, and probably more places that use trivial TypeSourceInfo.
So this is nice to have, but I think leaves us with an AST that will still crash in other cases. Consumers will not expect an AutoTypeLoc where the type is constrained but the loc isn't, and it's hard to know how to handle this case.

Fixing #2 is what this patch currently does. It also seems to be the pattern used by other types (their initializeLocal methods conditionally initialize structure based on the underlying type). The only possible downside is because we store the ConceptReference subobject by pointer and support replacement but not mutation, if the caller calls initializeLocal and then fills in with real data we'll waste the original ConceptReference object. Still, I don't think this is how non-trivial TSIs are generally created, and I think this is the way to go.

Fixing #3 is the previous version of the patch, again it leaves us with a bug-prone AST and some extra complexity.

clang/include/clang/AST/ASTConcept.h

180

if the qualifier is null the template KW must also be null
so this is correct, you may or may not want a comment for that! up to you

185

getTemplateArgsAsWritten() is nullable, right?

194

nit: printingpolicy by const ref, I think
(we're not totally consistent, but I think ref is more common)

[massberg]

Resolve remaining comments.

• Added tests for new location functions of ConceptReference. There is an existing bug with the end location if there are no template arguments. As it is an existing bug I have added a FIXME which will be fixed in a follow up patch.
• Additional minor changes.

[massberg]

clang/lib/Sema/TreeTransform.h

6834–6846

A minimal example:

template <typename T> concept C = true;

template<C auto M>
void foo2() {}

int main(void) {
  foo2<1>();
}

As discussed, a ConceptReference will now be created in initializeLocal so that it is guaranteed that we have it available here. I have added an assert to verify that there is an ConceptReference in case that the AutoType is constrained.
If we do not set the ConceptReference in initializeLocal then there are already several tests that fail as the assert isn't satisifed.

[sammccall]

LGTM, just nits!

The SourceRanges are actually correct :-)

clang/include/clang/AST/ASTConcept.h

119

remove protected (and private: below), we don't inherit from this

clang/include/clang/AST/ExprConcepts.h

46

while here: this is unused, remove?

48–50

while here: this class is final, so these can be private instead of protected

clang/lib/AST/TypeLoc.cpp

623–624

nit: createTrivialConceptReference?
hinting at the relationship to trivial TypeSourceInfo

maybe a comment too?

// Builds a ConceptReference where all locations point at the same token,
// for use in trivial TypeSourceInfo for constrained AutoType

clang/unittests/AST/SourceLocationTest.cpp

1025 ↗

(On Diff #554660)

why that range?
SourceRanges are generally "closed token ranges", so the endpoint is the *beginning* of the last token *in* the range.
CCC is (2, 1, 2, 1)

1073 ↗

(On Diff #554660)

as above

[massberg]

Fixed remaining nits. Thanks for the reviews and comments everyone!

clang/include/clang/AST/ASTConcept.h

 //===--- ASTConcept.h - Concepts Related AST Data Structures ----*- C++ -*-===//
 //
 // 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
 /// \brief This file provides AST data structures related to concepts.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_AST_ASTCONCEPT_H
 #define LLVM_CLANG_AST_ASTCONCEPT_H
 
+#include "clang/AST/Decl.h"
 #include "clang/AST/Expr.h"
+#include "clang/AST/PrettyPrinter.h"
 #include "clang/Basic/SourceLocation.h"
 #include "llvm/ADT/PointerUnion.h"
 #include "llvm/ADT/SmallVector.h"
 #include <utility>
 
 namespace clang {
 class ConceptDecl;
 
ASTConstraintSatisfaction(const ASTContext &C,
                             const ASTConstraintSatisfaction &Satisfaction);
 
   static ASTConstraintSatisfaction *
   Create(const ASTContext &C, const ConstraintSatisfaction &Satisfaction);
   static ASTConstraintSatisfaction *
   Rebuild(const ASTContext &C, const ASTConstraintSatisfaction &Satisfaction);
 };
 
+/*
+NOTE(massberg): This will be our new AST node.
+It is a reference to a conecpt and it template arguments.
+*/
 /// \brief Common data class for constructs that reference concepts with
 /// template arguments.
-class ConceptReference {
+class ConceptLoc {
 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)
+  ConceptLoc(NestedNameSpecifierLoc NNS, SourceLocation TemplateKWLoc,
       : NestedNameSpec(NNS), TemplateKWLoc(TemplateKWLoc),
         ConceptName(ConceptNameInfo), FoundDecl(FoundDecl),
         NamedConcept(NamedConcept), ArgsAsWritten(ArgsAsWritten) {}
 
-  ConceptReference()
+  ConceptLoc()
       : FoundDecl(nullptr), NamedConcept(nullptr), ArgsAsWritten(nullptr) {}
 
+  static ConceptLoc *Create(const ASTContext &C, NestedNameSpecifierLoc NNS,
+                            SourceLocation TemplateKWLoc,
+                            DeclarationNameInfo ConceptNameInfo,
+                            NamedDecl *FoundDecl, ConceptDecl *NamedConcept,
+                            const ASTTemplateArgumentListInfo *ArgsAsWritten) {
+    return new (C) ConceptLoc(NNS, TemplateKWLoc, ConceptNameInfo, FoundDecl,
+                              NamedConcept, ArgsAsWritten);
+  }
+
   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;
   }
+
+  void print(llvm::raw_ostream &OS, PrintingPolicy Policy) const;
 };
 
-class TypeConstraint : public ConceptReference {
+/*
+NOTE(massberg):
+A concept reference that uses abbreviated syntax to constrains a template
+type parameter:
+   template <convertible_to<string> T> void print(T object);
+
+*/
+class TypeConstraint {
   /// \brief The immediately-declared constraint expression introduced by this
   /// type-constraint.
   Expr *ImmediatelyDeclaredConstraint = nullptr;
+  ConceptLoc *Loc;
 
 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) {}
+  TypeConstraint(ConceptLoc *Loc, Expr *ImmediatelyDeclaredConstraint)
+      : ImmediatelyDeclaredConstraint(ImmediatelyDeclaredConstraint), Loc(Loc) {
+  }
 
   /// \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;
+  ConceptLoc *getConceptLoc() const { return Loc; }
+
+  // NOTE(massberg): For the first minimal prototype we keep the
+  // following functions to prevent. Later these functions should
+  // be accessed getConceptLoc().
+  ConceptDecl *getNamedConcept() const { return Loc->getNamedConcept(); }
+
+  SourceLocation getConceptNameLoc() const { return Loc->getConceptNameLoc(); }
+
+  bool hasExplicitTemplateArgs() const {
+    return Loc->hasExplicitTemplateArgs();
+  }
+
+  const ASTTemplateArgumentListInfo *getTemplateArgsAsWritten() const {
+    return Loc->getTemplateArgsAsWritten();
+  }
+
+  SourceLocation getTemplateKWLoc() const { return Loc->getTemplateKWLoc(); }
+
+  NamedDecl *getFoundDecl() const { return Loc->getFoundDecl(); }
+
+  const NestedNameSpecifierLoc &getNestedNameSpecifierLoc() const {
+    return Loc->getNestedNameSpecifierLoc();
+  }
+
+  const DeclarationNameInfo &getConceptNameInfo() const {
+    return Loc->getConceptNameInfo();
+  }
+
+  void print(llvm::raw_ostream &OS, PrintingPolicy Policy) const {
+    Loc->print(OS, Policy);
+  }
 };
 
 } // clang
 
 #endif // LLVM_CLANG_AST_ASTCONCEPT_H

clang/include/clang/AST/DeclTemplate.h

public:
 
   /// Returns the type constraint associated with this template parameter (if
   /// any).
   const TypeConstraint *getTypeConstraint() const {
     return TypeConstraintInitialized ? getTrailingObjects<TypeConstraint>() :
          nullptr;
   }
 
-  void setTypeConstraint(NestedNameSpecifierLoc NNS,
-                         DeclarationNameInfo NameInfo, NamedDecl *FoundDecl,
-                         ConceptDecl *CD,
-                         const ASTTemplateArgumentListInfo *ArgsAsWritten,
-                         Expr *ImmediatelyDeclaredConstraint);
+  void setTypeConstraint(ConceptLoc *Loc, Expr *ImmediatelyDeclaredConstraint);
 
   /// Determine whether this template parameter has a type-constraint.
   bool hasTypeConstraint() const {
     return HasTypeConstraint;
   }
 
   /// \brief Get the associated-constraints of this template parameter.
   /// This will either be the immediately-introduced constraint or empty.

clang/include/clang/AST/ExprConcepts.h

 class ASTStmtReader;
 class ASTStmtWriter;
 
 /// \brief Represents the specialization of a concept - evaluates to a prvalue
 /// of type bool.
 ///
 /// According to C++2a [expr.prim.id]p3 an id-expression that denotes the
 /// specialization of a concept results in a prvalue of type bool.
-class ConceptSpecializationExpr final : public Expr, public ConceptReference {
+class ConceptSpecializationExpr final : public Expr {
   friend class ASTReader;
   friend class ASTStmtReader;
 
 public:
   using SubstitutionDiagnostic = std::pair<SourceLocation, std::string>;
 
 protected:
+  ConceptLoc *Loc;
+
   /// \brief The Implicit Concept Specialization Decl, which holds the template
   /// arguments for this specialization.
   ImplicitConceptSpecializationDecl *SpecDecl;
 
   /// \brief Information about the satisfaction of the named concept with the
   /// given arguments. If this expression is value dependent, this is to be
   /// ignored.
   ASTConstraintSatisfaction *Satisfaction;
 
-  ConceptSpecializationExpr(const ASTContext &C, NestedNameSpecifierLoc NNS,
-                            SourceLocation TemplateKWLoc,
-                            DeclarationNameInfo ConceptNameInfo,
-                            NamedDecl *FoundDecl, ConceptDecl *NamedConcept,
-                            const ASTTemplateArgumentListInfo *ArgsAsWritten,
+  ConceptSpecializationExpr(const ASTContext &C, ConceptLoc *Loc,
                             ImplicitConceptSpecializationDecl *SpecDecl,
                             const ConstraintSatisfaction *Satisfaction);
 
-  ConceptSpecializationExpr(const ASTContext &C, ConceptDecl *NamedConcept,
-                            const ASTTemplateArgumentListInfo *ArgsAsWritten,
+  ConceptSpecializationExpr(const ASTContext &C, ConceptLoc *Loc,
                             ImplicitConceptSpecializationDecl *SpecDecl,
                             const ConstraintSatisfaction *Satisfaction,
                             bool Dependent,
                             bool ContainsUnexpandedParameterPack);
   ConceptSpecializationExpr(EmptyShell Empty);
 
 public:
   static ConceptSpecializationExpr *
-  Create(const ASTContext &C, NestedNameSpecifierLoc NNS,
-         SourceLocation TemplateKWLoc, DeclarationNameInfo ConceptNameInfo,
-         NamedDecl *FoundDecl, ConceptDecl *NamedConcept,
-         const ASTTemplateArgumentListInfo *ArgsAsWritten,
+  Create(const ASTContext &C, ConceptLoc *Loc,
          ImplicitConceptSpecializationDecl *SpecDecl,
          const ConstraintSatisfaction *Satisfaction);
 
   static ConceptSpecializationExpr *
-  Create(const ASTContext &C, ConceptDecl *NamedConcept,
-         const ASTTemplateArgumentListInfo *ArgsAsWritten,
+  Create(const ASTContext &C, ConceptLoc *Loc,
          ImplicitConceptSpecializationDecl *SpecDecl,
          const ConstraintSatisfaction *Satisfaction, bool Dependent,
          bool ContainsUnexpandedParameterPack);
 
   ArrayRef<TemplateArgument> getTemplateArguments() const {
     return SpecDecl->getTemplateArguments();
   }
 
+  const ConceptLoc *getConceptLoc() const { return Loc; }
+
+  // NOTE(massberg): For the first minimal prototype we keep the
+  // following functions to prevent. Later these functions should
+  // be accessed getConceptLoc().
+  ConceptDecl *getNamedConcept() const { return Loc->getNamedConcept(); }
+
+  bool hasExplicitTemplateArgs() const {
+    return Loc->hasExplicitTemplateArgs();
+  }
+
+  SourceLocation getConceptNameLoc() const { return Loc->getConceptNameLoc(); }
+  const ASTTemplateArgumentListInfo *getTemplateArgsAsWritten() const {
+    return Loc->getTemplateArgsAsWritten();
+  }
+
+  const NestedNameSpecifierLoc &getNestedNameSpecifierLoc() const {
+    return Loc->getNestedNameSpecifierLoc();
+  }
+
+  SourceLocation getTemplateKWLoc() const { return Loc->getTemplateKWLoc(); }
+
+  NamedDecl *getFoundDecl() const { return Loc->getFoundDecl(); }
+
+  const DeclarationNameInfo &getConceptNameInfo() const {
+    return Loc->getConceptNameInfo();
+  }
+
   const ImplicitConceptSpecializationDecl *getSpecializationDecl() const {
     assert(SpecDecl && "Template Argument Decl not initialized");
     return SpecDecl;
   }
 
   /// \brief Whether or not the concept with the given arguments was satisfied
   /// when the expression was created.
   /// The expression must not be dependent.
assert(!isValueDependent() &&
            "getSatisfaction called on dependent ConceptSpecializationExpr");
     return *Satisfaction;
   }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == ConceptSpecializationExprClass;
   }
 
   SourceLocation getBeginLoc() const LLVM_READONLY {
-    if (auto QualifierLoc = getNestedNameSpecifierLoc())
+    if (auto QualifierLoc = Loc->getNestedNameSpecifierLoc())
       return QualifierLoc.getBeginLoc();
-    return ConceptName.getBeginLoc();
+    return Loc->getConceptNameInfo().getBeginLoc();
   }
 
   SourceLocation getEndLoc() const LLVM_READONLY {
     // If the ConceptSpecializationExpr is the ImmediatelyDeclaredConstraint
     // of a TypeConstraint written syntactically as a constrained-parameter,
     // there may not be a template argument list.
-    return ArgsAsWritten->RAngleLoc.isValid() ? ArgsAsWritten->RAngleLoc
-                                              : ConceptName.getEndLoc();
+    return Loc->hasExplicitTemplateArgs() &&
+                   Loc->getTemplateArgsAsWritten()->getRAngleLoc().isValid()
+               ? Loc->getTemplateArgsAsWritten()->getRAngleLoc()
+               : Loc->getConceptNameInfo().getEndLoc();
   }
 
   // Iterators
   child_range children() {
     return child_range(child_iterator(), child_iterator());
   }
   const_child_range children() const {
     return const_child_range(const_child_iterator(), const_child_iterator());

clang/include/clang/AST/RecursiveASTVisitor.h

bool TraverseSynOrSemInitListExpr(InitListExpr *S,
                                     DataRecursionQueue *Queue = nullptr);
 
   /// Recursively visit an Objective-C protocol reference with location
   /// information.
   ///
   /// \returns false if the visitation was terminated early, true otherwise.
   bool TraverseObjCProtocolLoc(ObjCProtocolLoc ProtocolLoc);
 
+  /// Recursively visit concept reference with location information.
+  ///
+  /// \returns false if the visitation was terminated early, true otherwise.
+  bool TraverseConceptLoc(const ConceptLoc *CL);
   // ---- Methods on Attrs ----
 
   // Visit an attribute.
   bool VisitAttr(Attr *A) { return true; }
 
 // Declare Traverse* and empty Visit* for all Attr classes.
 #define ATTR_VISITOR_DECLS_ONLY
 #include "clang/AST/AttrVisitor.inc"
#undef DEF_TRAVERSE_TMPL_INST
   bool TraverseConceptExprRequirement(concepts::ExprRequirement *R);
   bool TraverseConceptNestedRequirement(concepts::NestedRequirement *R);
 
   bool dataTraverseNode(Stmt *S, DataRecursionQueue *Queue);
 
 private:
   // These are helper methods used by more than one Traverse* method.
   bool TraverseTemplateParameterListHelper(TemplateParameterList *TPL);
-  /// Traverses the qualifier, name and template arguments of a concept
-  /// reference.
-  bool TraverseConceptReferenceHelper(const ConceptReference &C);
 
   // Traverses template parameter lists of either a DeclaratorDecl or TagDecl.
   template <typename T>
   bool TraverseDeclTemplateParameterLists(T *D);
 
   bool TraverseTemplateTypeParamDeclConstraints(const TemplateTypeParmDecl *D);
 
   bool TraverseTemplateArgumentLocsHelper(const TemplateArgumentLoc *TAL,
#include "llvm/Frontend/OpenMP/OMP.inc"
 
   bool PostVisitStmt(Stmt *S);
 };
 
 template <typename Derived>
 bool RecursiveASTVisitor<Derived>::TraverseTypeConstraint(
     const TypeConstraint *C) {
   if (!getDerived().shouldVisitImplicitCode()) {
-    TRY_TO(TraverseConceptReferenceHelper(*C));
+    TRY_TO(TraverseConceptLoc(C->getConceptLoc()));
     return true;
   }
   if (Expr *IDC = C->getImmediatelyDeclaredConstraint()) {
     TRY_TO(TraverseStmt(IDC));
   } else {
-    // Avoid traversing the ConceptReference in the TypeConstraint
+    // Avoid traversing the ConceptLoc in the TypeConstraint
     // if we have an immediately-declared-constraint, otherwise
     // we'll end up visiting the concept and the arguments in
     // the TC twice.
-    TRY_TO(TraverseConceptReferenceHelper(*C));
+    TRY_TO(TraverseConceptLoc(C->getConceptLoc()));
   }
   return true;
 }
 
 template <typename Derived>
 bool RecursiveASTVisitor<Derived>::TraverseConceptRequirement(
     concepts::Requirement *R) {
   switch (R->getKind()) {
   case concepts::Requirement::RK_Type:
     return getDerived().TraverseConceptTypeRequirement(
         cast<concepts::TypeRequirement>(R));
   case concepts::Requirement::RK_Simple:
   case concepts::Requirement::RK_Compound:
     return getDerived().TraverseConceptExprRequirement(
         cast<concepts::ExprRequirement>(R));
   case concepts::Requirement::RK_Nested:
     return getDerived().TraverseConceptNestedRequirement(
         cast<concepts::NestedRequirement>(R));
   }
   llvm_unreachable("unexpected case");
 }
 
 template <typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseConceptReferenceHelper(
-    const ConceptReference &C) {
-  TRY_TO(TraverseNestedNameSpecifierLoc(C.getNestedNameSpecifierLoc()));
-  TRY_TO(TraverseDeclarationNameInfo(C.getConceptNameInfo()));
-  if (C.hasExplicitTemplateArgs())
-    TRY_TO(TraverseTemplateArgumentLocsHelper(
-        C.getTemplateArgsAsWritten()->getTemplateArgs(),
-        C.getTemplateArgsAsWritten()->NumTemplateArgs));
-  return true;
-}
-
-template <typename Derived>
 bool RecursiveASTVisitor<Derived>::dataTraverseNode(Stmt *S,
                                                     DataRecursionQueue *Queue) {
   // Top switch stmt: dispatch to TraverseFooStmt for each concrete FooStmt.
   switch (S->getStmtClass()) {
   case Stmt::NoStmtClass:
     break;
 #define ABSTRACT_STMT(STMT)
 #define STMT(CLASS, PARENT)                                                    \

 
 DEF_TRAVERSE_TYPELOC(UnaryTransformType, {
   TRY_TO(TraverseTypeLoc(TL.getUnderlyingTInfo()->getTypeLoc()));
 })
 
 DEF_TRAVERSE_TYPELOC(AutoType, {
   TRY_TO(TraverseType(TL.getTypePtr()->getDeducedType()));
   if (TL.isConstrained()) {
-    TRY_TO(TraverseNestedNameSpecifierLoc(TL.getNestedNameSpecifierLoc()));
-    TRY_TO(TraverseDeclarationNameInfo(TL.getConceptNameInfo()));
-    for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I)
-      TRY_TO(TraverseTemplateArgumentLoc(TL.getArgLoc(I)));
+    TRY_TO(TraverseConceptLoc(TL.getConceptLoc()));
   }
 })
 
 DEF_TRAVERSE_TYPELOC(DeducedTemplateSpecializationType, {
   TRY_TO(TraverseTemplateName(TL.getTypePtr()->getTemplateName()));
   TRY_TO(TraverseType(TL.getTypePtr()->getDeducedType()));
 })
 

 }
 
 template <typename Derived>
 bool RecursiveASTVisitor<Derived>::TraverseObjCProtocolLoc(
     ObjCProtocolLoc ProtocolLoc) {
   return true;
 }
 
+template <typename Derived>
+bool RecursiveASTVisitor<Derived>::TraverseConceptLoc(const ConceptLoc *CL) {
+  TRY_TO(TraverseNestedNameSpecifierLoc(CL->getNestedNameSpecifierLoc()));
+  TRY_TO(TraverseDeclarationNameInfo(CL->getConceptNameInfo()));
+  if (CL->hasExplicitTemplateArgs())
+    TRY_TO(TraverseTemplateArgumentLocsHelper(
+        CL->getTemplateArgsAsWritten()->getTemplateArgs(),
+        CL->getTemplateArgsAsWritten()->NumTemplateArgs));
+  return true;
+}
+
 // If shouldVisitImplicitCode() returns false, this method traverses only the
 // syntactic form of InitListExpr.
 // If shouldVisitImplicitCode() return true, this method is called once for
 // each pair of syntactic and semantic InitListExpr, and it traverses the
 // subtrees defined by the two forms. This may cause some of the children to be
 // visited twice, if they appear both in the syntactic and the semantic form.
 //
 // There is no guarantee about which form \p S takes when this method is called.

 DEF_TRAVERSE_STMT(CoyieldExpr, {
   if (!getDerived().shouldVisitImplicitCode()) {
     TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S->getOperand());
     ShouldVisitChildren = false;
   }
 })
 
 DEF_TRAVERSE_STMT(ConceptSpecializationExpr,
-                  { TRY_TO(TraverseConceptReferenceHelper(*S)); })
+                  { TRY_TO(TraverseConceptLoc(S->getConceptLoc())); })
 
 DEF_TRAVERSE_STMT(RequiresExpr, {
   TRY_TO(TraverseDecl(S->getBody()));
   for (ParmVarDecl *Parm : S->getLocalParameters())
     TRY_TO(TraverseDecl(Parm));
   for (concepts::Requirement *Req : S->getRequirements())
     TRY_TO(TraverseConceptRequirement(Req));
 })

clang/include/clang/AST/TypeLoc.h

 //===- TypeLoc.h - Type Source Info Wrapper ---------------------*- C++ -*-===//
 //
 // 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
 /// Defines the clang::TypeLoc interface and its subclasses.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_AST_TYPELOC_H
 #define LLVM_CLANG_AST_TYPELOC_H
 
+#include "clang/AST/ASTConcept.h"
 #include "clang/AST/DeclarationName.h"
 #include "clang/AST/NestedNameSpecifier.h"
 #include "clang/AST/TemplateBase.h"
 #include "clang/AST/Type.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/Specifiers.h"
 #include "llvm/ADT/ArrayRef.h"
public:
   void initializeLocal(ASTContext &Context, SourceLocation Loc);
 };
 
 class DeducedTypeLoc
     : public InheritingConcreteTypeLoc<TypeSpecTypeLoc, DeducedTypeLoc,
                                        DeducedType> {};
 
 struct AutoTypeLocInfo : TypeSpecLocInfo {
-  NestedNameSpecifierLoc NestedNameSpec;
-  SourceLocation TemplateKWLoc;
-  SourceLocation ConceptNameLoc;
-  NamedDecl *FoundDecl = nullptr;
   SourceLocation LAngleLoc;
   SourceLocation RAngleLoc;
 
   // For decltype(auto).
   SourceLocation RParenLoc;
 
+  SourceLocation DefaultLoc;
+  ConceptLoc *CL = nullptr;
   // Followed by a TemplateArgumentLocInfo[]
 };
 
 class AutoTypeLoc
     : public ConcreteTypeLoc<DeducedTypeLoc,
                              AutoTypeLoc,
                              AutoType,
                              AutoTypeLocInfo> {
 public:
   AutoTypeKeyword getAutoKeyword() const {
     return getTypePtr()->getKeyword();
   }
 
   bool isDecltypeAuto() const { return getTypePtr()->isDecltypeAuto(); }
   SourceLocation getRParenLoc() const { return getLocalData()->RParenLoc; }
   void setRParenLoc(SourceLocation Loc) { getLocalData()->RParenLoc = Loc; }
 
   bool isConstrained() const {
     return getTypePtr()->isConstrained();
   }
 
-  const NestedNameSpecifierLoc &getNestedNameSpecifierLoc() const {
-    return getLocalData()->NestedNameSpec;
+  void setConceptLoc(ConceptLoc *Loc) {
+    getLocalData()->CL = Loc;
+    if (Loc == nullptr)
+      return;
   }
 
-  void setNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS) {
-    getLocalData()->NestedNameSpec = NNS;
-  }
+  ConceptLoc *getConceptLoc() const { return getLocalData()->CL; }
 
-  SourceLocation getTemplateKWLoc() const {
-    return getLocalData()->TemplateKWLoc;
-  }
+  void setDefaultLoc(SourceLocation Loc) { getLocalData()->DefaultLoc = Loc; }
 
-  void setTemplateKWLoc(SourceLocation Loc) {
-    getLocalData()->TemplateKWLoc = Loc;
-  }
+  SourceLocation getDefaultLoc() const { return getLocalData()->DefaultLoc; }
 
-  SourceLocation getConceptNameLoc() const {
-    return getLocalData()->ConceptNameLoc;
+  const NestedNameSpecifierLoc getNestedNameSpecifierLoc() const {
+    if (getConceptLoc())
+      return getConceptLoc()->getNestedNameSpecifierLoc();
+    return NestedNameSpecifierLoc();
   }
 
-  void setConceptNameLoc(SourceLocation Loc) {
-    getLocalData()->ConceptNameLoc = Loc;
+  SourceLocation getTemplateKWLoc() const {
+    if (getConceptLoc())
+      return getConceptLoc()->getTemplateKWLoc();
+    return getDefaultLoc();
   }
 
-  NamedDecl *getFoundDecl() const {
-    return getLocalData()->FoundDecl;
+  SourceLocation getConceptNameLoc() const {
+    if (getConceptLoc())
+      return getConceptLoc()->getConceptNameLoc();
+    return getDefaultLoc();
   }
 
-  void setFoundDecl(NamedDecl *D) {
-    getLocalData()->FoundDecl = D;
+  NamedDecl *getFoundDecl() const {
+    if (getConceptLoc())
+      return getConceptLoc()->getFoundDecl();
+    return nullptr;
   }
 
   ConceptDecl *getNamedConcept() const {
-    return getTypePtr()->getTypeConstraintConcept();
+    if (getConceptLoc())
+      return getConceptLoc()->getNamedConcept();
+    return nullptr;
   }
 
-  DeclarationNameInfo getConceptNameInfo() const;
+  DeclarationNameInfo getConceptNameInfo() const {
+    return getConceptLoc()->getConceptNameInfo();
+  }
 
   bool hasExplicitTemplateArgs() const {
     return getLocalData()->LAngleLoc.isValid();
   }
 
   SourceLocation getLAngleLoc() const {
     return this->getLocalData()->LAngleLoc;
   }
 
   void setLAngleLoc(SourceLocation Loc) {
     this->getLocalData()->LAngleLoc = Loc;
   }
 
   SourceLocation getRAngleLoc() const {
     return this->getLocalData()->RAngleLoc;
   }
 
   void setRAngleLoc(SourceLocation Loc) {
     this->getLocalData()->RAngleLoc = Loc;
   }
 
   unsigned getNumArgs() const {
     return getTypePtr()->getTypeConstraintArguments().size();
   }
 
-  void setArgLocInfo(unsigned i, TemplateArgumentLocInfo AI) {
-    getArgInfos()[i] = AI;
-  }
-
-  TemplateArgumentLocInfo getArgLocInfo(unsigned i) const {
-    return getArgInfos()[i];
-  }
-
   TemplateArgumentLoc getArgLoc(unsigned i) const {
+    if (getConceptLoc())
+      return getConceptLoc()->getTemplateArgsAsWritten()->getTemplateArgs()[i];
+    // FIXME: Check why we still need this fallback in case that there is no
+    // ConceptLoc.
     return TemplateArgumentLoc(getTypePtr()->getTypeConstraintArguments()[i],
-                               getArgLocInfo(i));
+                               getArgInfos()[i]);
   }
 
   SourceRange getLocalSourceRange() const {
     return {isConstrained()
                 ? (getNestedNameSpecifierLoc()
                        ? getNestedNameSpecifierLoc().getBeginLoc()
                        : (getTemplateKWLoc().isValid() ? getTemplateKWLoc()
                                                        : getConceptNameLoc()))

clang/lib/AST/ASTContext.cpp

bool ASTContext::isSameTypeConstraint(const TypeConstraint *XTC,
 
   if (!XTC)
     return true;
 
   auto *NCX = XTC->getNamedConcept();
   auto *NCY = YTC->getNamedConcept();
   if (!NCX || !NCY || !isSameEntity(NCX, NCY))
     return false;
-  if (XTC->hasExplicitTemplateArgs() != YTC->hasExplicitTemplateArgs())
+  if (XTC->getConceptLoc()->hasExplicitTemplateArgs() !=
+      YTC->getConceptLoc()->hasExplicitTemplateArgs())
     return false;
-  if (XTC->hasExplicitTemplateArgs())
-    if (XTC->getTemplateArgsAsWritten()->NumTemplateArgs !=
-        YTC->getTemplateArgsAsWritten()->NumTemplateArgs)
+  if (XTC->getConceptLoc()->hasExplicitTemplateArgs())
+    if (XTC->getConceptLoc()->getTemplateArgsAsWritten()->NumTemplateArgs !=
+        YTC->getConceptLoc()->getTemplateArgsAsWritten()->NumTemplateArgs)
       return false;
 
   // Compare slowly by profiling.
   //
   // We couldn't compare the profiling result for the template
   // args here. Consider the following example in different modules:
   //
   // template <__integer_like _Tp, C<_Tp> Sentinel>

clang/lib/AST/ASTImporter.cpp

if (GetImportedOrCreateDecl(
       D->wasDeclaredWithTypename(), D->isParameterPack(),
       D->hasTypeConstraint()))
     return ToD;
 
   // Import the type-constraint
   if (const TypeConstraint *TC = D->getTypeConstraint()) {
 
     Error Err = Error::success();
     auto ToNNS = importChecked(Err, TC->getNestedNameSpecifierLoc());
     auto ToName = importChecked(Err, TC->getConceptNameInfo().getName());
     auto ToNameLoc = importChecked(Err, TC->getConceptNameInfo().getLoc());
     auto ToFoundDecl = importChecked(Err, TC->getFoundDecl());
     auto ToNamedConcept = importChecked(Err, TC->getNamedConcept());
     auto ToIDC = importChecked(Err, TC->getImmediatelyDeclaredConstraint());
     if (Err)
       return std::move(Err);
 
     TemplateArgumentListInfo ToTAInfo;
     const auto *ASTTemplateArgs = TC->getTemplateArgsAsWritten();
     if (ASTTemplateArgs)
       if (Error Err = ImportTemplateArgumentListInfo(*ASTTemplateArgs,
                                                      ToTAInfo))
         return std::move(Err);
-
-    ToD->setTypeConstraint(ToNNS, DeclarationNameInfo(ToName, ToNameLoc),
-        ToFoundDecl, ToNamedConcept,
-        ASTTemplateArgs ?
-            ASTTemplateArgumentListInfo::Create(Importer.getToContext(),
-                                                ToTAInfo) : nullptr,
-        ToIDC);
+    auto *CL = ConceptLoc::Create(
+        Importer.getToContext(), ToNNS,
+        ToNameLoc, // What is the right Loc here?
+        DeclarationNameInfo(ToName, ToNameLoc), ToFoundDecl, ToNamedConcept,
+        ASTTemplateArgs ? ASTTemplateArgumentListInfo::Create(
+                              Importer.getToContext(), ToTAInfo)
+                        : nullptr);
+    ToD->setTypeConstraint(CL, ToIDC);
   }
 
   if (D->hasDefaultArgument()) {
     Expected<TypeSourceInfo *> ToDefaultArgOrErr =
         import(D->getDefaultArgumentInfo());
     if (!ToDefaultArgOrErr)
       return ToDefaultArgOrErr.takeError();
     ToD->setDefaultArgument(*ToDefaultArgOrErr);

clang/lib/AST/DeclTemplate.cpp

 unsigned TemplateTypeParmDecl::getIndex() const {
   return getTypeForDecl()->castAs<TemplateTypeParmType>()->getIndex();
 }
 
 bool TemplateTypeParmDecl::isParameterPack() const {
   return getTypeForDecl()->castAs<TemplateTypeParmType>()->isParameterPack();
 }
 
-void TemplateTypeParmDecl::setTypeConstraint(NestedNameSpecifierLoc NNS,
-    DeclarationNameInfo NameInfo, NamedDecl *FoundDecl, ConceptDecl *CD,
-    const ASTTemplateArgumentListInfo *ArgsAsWritten,
-    Expr *ImmediatelyDeclaredConstraint) {
+void TemplateTypeParmDecl::setTypeConstraint(
+    ConceptLoc *Loc, Expr *ImmediatelyDeclaredConstraint) {
   assert(HasTypeConstraint &&
          "HasTypeConstraint=true must be passed at construction in order to "
          "call setTypeConstraint");
   assert(!TypeConstraintInitialized &&
          "TypeConstraint was already initialized!");
-  new (getTrailingObjects<TypeConstraint>()) TypeConstraint(NNS, NameInfo,
-      FoundDecl, CD, ArgsAsWritten, ImmediatelyDeclaredConstraint);
+  new (getTrailingObjects<TypeConstraint>())
+      TypeConstraint(Loc, ImmediatelyDeclaredConstraint);
   TypeConstraintInitialized = true;
 }
 
 //===----------------------------------------------------------------------===//
 // NonTypeTemplateParmDecl Method Implementations
 //===----------------------------------------------------------------------===//
 
 NonTypeTemplateParmDecl::NonTypeTemplateParmDecl(

 
 BuiltinTemplateDecl::BuiltinTemplateDecl(const ASTContext &C, DeclContext *DC,
                                          DeclarationName Name,
                                          BuiltinTemplateKind BTK)
     : TemplateDecl(BuiltinTemplate, DC, SourceLocation(), Name,
                    createBuiltinTemplateParameterList(C, DC, BTK)),
       BTK(BTK) {}
 
-void TypeConstraint::print(llvm::raw_ostream &OS, PrintingPolicy Policy) const {
+void ConceptLoc::print(llvm::raw_ostream &OS, PrintingPolicy Policy) const {
   if (NestedNameSpec)
     NestedNameSpec.getNestedNameSpecifier()->print(OS, Policy);
   ConceptName.printName(OS, Policy);
   if (hasExplicitTemplateArgs()) {
     OS << "<";
     // FIXME: Find corresponding parameter for argument
     for (auto &ArgLoc : ArgsAsWritten->arguments())
       ArgLoc.getArgument().print(Policy, OS, /*IncludeType*/ false);

clang/lib/AST/ExprConcepts.cpp

 #include "llvm/Support/TrailingObjects.h"
 #include <algorithm>
 #include <string>
 #include <utility>
 
 using namespace clang;
 
 ConceptSpecializationExpr::ConceptSpecializationExpr(
-    const ASTContext &C, NestedNameSpecifierLoc NNS,
-    SourceLocation TemplateKWLoc, DeclarationNameInfo ConceptNameInfo,
-    NamedDecl *FoundDecl, ConceptDecl *NamedConcept,
-    const ASTTemplateArgumentListInfo *ArgsAsWritten,
+    const ASTContext &C, ConceptLoc *Loc,
     ImplicitConceptSpecializationDecl *SpecDecl,
     const ConstraintSatisfaction *Satisfaction)
     : Expr(ConceptSpecializationExprClass, C.BoolTy, VK_PRValue, OK_Ordinary),
-      ConceptReference(NNS, TemplateKWLoc, ConceptNameInfo, FoundDecl,
-                       NamedConcept, ArgsAsWritten),
-      SpecDecl(SpecDecl),
+      Loc(Loc), SpecDecl(SpecDecl),
       Satisfaction(Satisfaction
                        ? ASTConstraintSatisfaction::Create(C, *Satisfaction)
                        : nullptr) {
   setDependence(computeDependence(this, /*ValueDependent=*/!Satisfaction));
 
   // Currently guaranteed by the fact concepts can only be at namespace-scope.
-  assert(!NestedNameSpec ||
-         (!NestedNameSpec.getNestedNameSpecifier()->isInstantiationDependent() &&
-          !NestedNameSpec.getNestedNameSpecifier()
+  assert(!Loc->getNestedNameSpecifierLoc() ||
+         (!Loc->getNestedNameSpecifierLoc()
+               .getNestedNameSpecifier()
+               ->isInstantiationDependent() &&
+          !Loc->getNestedNameSpecifierLoc()
+               .getNestedNameSpecifier()
                ->containsUnexpandedParameterPack()));
   assert((!isValueDependent() || isInstantiationDependent()) &&
          "should not be value-dependent");
 }
 
 ConceptSpecializationExpr::ConceptSpecializationExpr(EmptyShell Empty)
     : Expr(ConceptSpecializationExprClass, Empty) {}
 
-ConceptSpecializationExpr *ConceptSpecializationExpr::Create(
-    const ASTContext &C, NestedNameSpecifierLoc NNS,
-    SourceLocation TemplateKWLoc, DeclarationNameInfo ConceptNameInfo,
-    NamedDecl *FoundDecl, ConceptDecl *NamedConcept,
-    const ASTTemplateArgumentListInfo *ArgsAsWritten,
+ConceptSpecializationExpr *
+ConceptSpecializationExpr::Create(const ASTContext &C, ConceptLoc *Loc,
                                   ImplicitConceptSpecializationDecl *SpecDecl,
                                   const ConstraintSatisfaction *Satisfaction) {
-  return new (C) ConceptSpecializationExpr(
-      C, NNS, TemplateKWLoc, ConceptNameInfo, FoundDecl, NamedConcept,
-      ArgsAsWritten, SpecDecl, Satisfaction);
+  return new (C) ConceptSpecializationExpr(C, Loc, SpecDecl, Satisfaction);
 }
 
 ConceptSpecializationExpr::ConceptSpecializationExpr(
-    const ASTContext &C, ConceptDecl *NamedConcept,
-    const ASTTemplateArgumentListInfo *ArgsAsWritten,
+    const ASTContext &C, ConceptLoc *Loc,
     ImplicitConceptSpecializationDecl *SpecDecl,
     const ConstraintSatisfaction *Satisfaction, bool Dependent,
     bool ContainsUnexpandedParameterPack)
     : Expr(ConceptSpecializationExprClass, C.BoolTy, VK_PRValue, OK_Ordinary),
-      ConceptReference(NestedNameSpecifierLoc(), SourceLocation(),
-                       DeclarationNameInfo(), NamedConcept, NamedConcept,
-                       ArgsAsWritten),
-      SpecDecl(SpecDecl),
+      Loc(Loc), SpecDecl(SpecDecl),
       Satisfaction(Satisfaction
                        ? ASTConstraintSatisfaction::Create(C, *Satisfaction)
                        : nullptr) {
   ExprDependence D = ExprDependence::None;
   if (!Satisfaction)
     D |= ExprDependence::Value;
   if (Dependent)
     D |= ExprDependence::Instantiation;
   if (ContainsUnexpandedParameterPack)
     D |= ExprDependence::UnexpandedPack;
   setDependence(D);
 }
 
-ConceptSpecializationExpr *ConceptSpecializationExpr::Create(
-    const ASTContext &C, ConceptDecl *NamedConcept,
-    const ASTTemplateArgumentListInfo *ArgsAsWritten,
+ConceptSpecializationExpr *
+ConceptSpecializationExpr::Create(const ASTContext &C, ConceptLoc *Loc,
                                   ImplicitConceptSpecializationDecl *SpecDecl,
-    const ConstraintSatisfaction *Satisfaction, bool Dependent,
+                                  const ConstraintSatisfaction *Satisfaction,
+                                  bool Dependent,
                                   bool ContainsUnexpandedParameterPack) {
-  return new (C) ConceptSpecializationExpr(C, NamedConcept, ArgsAsWritten,
-                                           SpecDecl, Satisfaction, Dependent,
-                                           ContainsUnexpandedParameterPack);
+  return new (C)
+      ConceptSpecializationExpr(C, Loc, SpecDecl, Satisfaction, Dependent,
 }
 
 const TypeConstraint *
 concepts::ExprRequirement::ReturnTypeRequirement::getTypeConstraint() const {
   assert(isTypeConstraint());
   auto TPL =
       TypeConstraintInfo.getPointer().get<TemplateParameterList *>();
   return cast<TemplateTypeParmDecl>(TPL->getParam(0))

clang/lib/AST/TypeLoc.cpp

for (unsigned i = 0, e = Args.size(); i != e; ++i) {
     }
 
     case TemplateArgument::Pack:
       ArgInfos[i] = TemplateArgumentLocInfo();
       break;
     }
   }
 }
 
-DeclarationNameInfo AutoTypeLoc::getConceptNameInfo() const {
-  return DeclarationNameInfo(getNamedConcept()->getDeclName(),
-                             getLocalData()->ConceptNameLoc);
-}
-
 void AutoTypeLoc::initializeLocal(ASTContext &Context, SourceLocation Loc) {
-  setNestedNameSpecifierLoc(NestedNameSpecifierLoc());
-  setTemplateKWLoc(Loc);
-  setConceptNameLoc(Loc);
-  setFoundDecl(nullptr);
   setRAngleLoc(Loc);
   setLAngleLoc(Loc);
   setRParenLoc(Loc);
   TemplateSpecializationTypeLoc::initializeArgLocs(
       Context, getTypePtr()->getTypeConstraintArguments(), getArgInfos(), Loc);
   setNameLoc(Loc);
+  setConceptLoc(nullptr);
+  setDefaultLoc(Loc);
 }
 
-
 namespace {
 
   class GetContainedAutoTypeLocVisitor :
     public TypeLocVisitor<GetContainedAutoTypeLocVisitor, TypeLoc> {
   public:
     using TypeLocVisitor<GetContainedAutoTypeLocVisitor, TypeLoc>::Visit;
 
     TypeLoc VisitAutoTypeLoc(AutoTypeLoc TL) {

clang/lib/Sema/SemaTemplate.cpp

 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/AST/TemplateName.h"
 #include "clang/AST/TypeVisitor.h"
 #include "clang/Basic/Builtins.h"
 #include "clang/Basic/DiagnosticSema.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/PartialDiagnostic.h"
+#include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/Stack.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Sema/DeclSpec.h"
 #include "clang/Sema/EnterExpressionEvaluationContext.h"
 #include "clang/Sema/Initialization.h"
 #include "clang/Sema/Lookup.h"
 #include "clang/Sema/Overload.h"
 #include "clang/Sema/ParsedTemplate.h"
ExprResult ImmediatelyDeclaredConstraint =
           [&] (TemplateArgumentListInfo &ConstraintArgs) {
             if (TemplateArgs)
               for (const auto &ArgLoc : TemplateArgs->arguments())
                 ConstraintArgs.addArgument(ArgLoc);
           }, EllipsisLoc);
   if (ImmediatelyDeclaredConstraint.isInvalid())
     return true;
 
-  ConstrainedParameter->setTypeConstraint(NS, NameInfo,
-                                          /*FoundDecl=*/NamedConcept,
-                                          NamedConcept, ArgsAsWritten,
+  auto *CL = ConceptLoc::Create(Context, /*NNS=*/NS,
+                                /*TemplateKWLoc=*/SourceLocation{},
+                                /*ConceptNameInfo=*/NameInfo,
+                                /*NamedConcept=*/NamedConcept,
+                                /*ArgsWritten=*/ArgsAsWritten);
+  ConstrainedParameter->setTypeConstraint(CL,
                                           ImmediatelyDeclaredConstraint.get());
   return false;
 }
 
 bool Sema::AttachTypeConstraint(AutoTypeLoc TL,
                                 NonTypeTemplateParmDecl *NewConstrainedParm,
                                 NonTypeTemplateParmDecl *OrigConstrainedParm,
                                 SourceLocation EllipsisLoc) {
   if (NewConstrainedParm->getType() != TL.getType() ||
       TL.getAutoKeyword() != AutoTypeKeyword::Auto) {
     Diag(NewConstrainedParm->getTypeSourceInfo()->getTypeLoc().getBeginLoc(),
          diag::err_unsupported_placeholder_constraint)
         << NewConstrainedParm->getTypeSourceInfo()
                ->getTypeLoc()
                .getSourceRange();
     return true;
Sema::CheckConceptTemplateId(const CXXScopeSpec &SS,
 
   if (!AreArgsDependent &&
       CheckConstraintSatisfaction(
           NamedConcept, {NamedConcept->getConstraintExpr()}, MLTAL,
           SourceRange(SS.isSet() ? SS.getBeginLoc() : ConceptNameInfo.getLoc(),
                       TemplateArgs->getRAngleLoc()),
           Satisfaction))
     return ExprError();
-
-  return ConceptSpecializationExpr::Create(
+  auto *CL = ConceptLoc::Create(
       Context,
       SS.isSet() ? SS.getWithLocInContext(Context) : NestedNameSpecifierLoc{},
       TemplateKWLoc, ConceptNameInfo, FoundDecl, NamedConcept,
-      ASTTemplateArgumentListInfo::Create(Context, *TemplateArgs), CSD,
-      AreArgsDependent ? nullptr : &Satisfaction);
+      ASTTemplateArgumentListInfo::Create(Context, *TemplateArgs));
+  return ConceptSpecializationExpr::Create(
+      Context, CL, CSD, AreArgsDependent ? nullptr : &Satisfaction);
 }
 
 ExprResult Sema::BuildTemplateIdExpr(const CXXScopeSpec &SS,
                                      SourceLocation TemplateKWLoc,
                                      LookupResult &R,
                                      bool RequiresADL,
                                  const TemplateArgumentListInfo *TemplateArgs) {
   // FIXME: Can we do any checking at this point? I guess we could check the

clang/lib/Sema/SemaTemplateInstantiate.cpp

 bool Sema::SubstTypeConstraint(
     TemplateTypeParmDecl *Inst, const TypeConstraint *TC,
     const MultiLevelTemplateArgumentList &TemplateArgs,
     bool EvaluateConstraints) {
   const ASTTemplateArgumentListInfo *TemplArgInfo =
       TC->getTemplateArgsAsWritten();
 
   if (!EvaluateConstraints) {
-    Inst->setTypeConstraint(TC->getNestedNameSpecifierLoc(),
-                            TC->getConceptNameInfo(), TC->getNamedConcept(),
-                            TC->getNamedConcept(), TemplArgInfo,
+      Inst->setTypeConstraint(TC->getConceptLoc(),
                               TC->getImmediatelyDeclaredConstraint());
       return false;
   }
 
   TemplateArgumentListInfo InstArgs;
 
   if (TemplArgInfo) {
     InstArgs.setLAngleLoc(TemplArgInfo->LAngleLoc);
     InstArgs.setRAngleLoc(TemplArgInfo->RAngleLoc);
     if (SubstTemplateArguments(TemplArgInfo->arguments(), TemplateArgs,

clang/lib/Sema/SemaType.cpp

void VisitAutoTypeLoc(AutoTypeLoc TL) {
       TL.setNameLoc(DS.getTypeSpecTypeLoc());
       if (DS.getTypeSpecType() == TST_decltype_auto)
         TL.setRParenLoc(DS.getTypeofParensRange().getEnd());
       if (!DS.isConstrainedAuto())
         return;
       TemplateIdAnnotation *TemplateId = DS.getRepAsTemplateId();
       if (!TemplateId)
         return;
-      if (DS.getTypeSpecScope().isNotEmpty())
-        TL.setNestedNameSpecifierLoc(
-            DS.getTypeSpecScope().getWithLocInContext(Context));
-      else
-        TL.setNestedNameSpecifierLoc(NestedNameSpecifierLoc());
-      TL.setTemplateKWLoc(TemplateId->TemplateKWLoc);
-      TL.setConceptNameLoc(TemplateId->TemplateNameLoc);
-      TL.setFoundDecl(nullptr);
+
+      NestedNameSpecifierLoc NNS =
+          (DS.getTypeSpecScope().isNotEmpty()
+               ? DS.getTypeSpecScope().getWithLocInContext(Context)
+               : NestedNameSpecifierLoc());
       TL.setLAngleLoc(TemplateId->LAngleLoc);
       TL.setRAngleLoc(TemplateId->RAngleLoc);
-      if (TemplateId->NumArgs == 0)
-        return;
       TemplateArgumentListInfo TemplateArgsInfo;
+      if (TemplateId->NumArgs > 0) {
         ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(),
                                            TemplateId->NumArgs);
         SemaRef.translateTemplateArguments(TemplateArgsPtr, TemplateArgsInfo);
-      for (unsigned I = 0; I < TemplateId->NumArgs; ++I)
-        TL.setArgLocInfo(I, TemplateArgsInfo.arguments()[I].getLocInfo());
+        /*for (unsigned I = 0; I < TemplateId->NumArgs; ++I)
+          TL.setArgLocInfo(I, TemplateArgsInfo.arguments()[I].getLocInfo());*/
+      }
+      // FIXME: Move to VisitConceptLoc,
+      DeclarationNameInfo DNI = DeclarationNameInfo(
+          TL.getTypePtr()->getTypeConstraintConcept()->getDeclName(),
+          TemplateId->TemplateNameLoc);
+      auto *CL = ConceptLoc::Create(
+          Context, NNS, TemplateId->TemplateKWLoc, DNI,
+          /*FoundDecl=*/nullptr,
+          /*NamedDecl=*/TL.getTypePtr()->getTypeConstraintConcept(),
+          (TemplateId->NumArgs > 0
+               ? ASTTemplateArgumentListInfo::Create(Context, TemplateArgsInfo)
+               : nullptr));
+      TL.setConceptLoc(CL);
     }
     void VisitTagTypeLoc(TagTypeLoc TL) {
       TL.setNameLoc(DS.getTypeSpecTypeNameLoc());
     }
     void VisitAtomicTypeLoc(AtomicTypeLoc TL) {
       // An AtomicTypeLoc can come from either an _Atomic(...) type specifier
       // or an _Atomic qualifier.
       if (DS.getTypeSpecType() == DeclSpec::TST_atomic) {

clang/lib/Sema/TreeTransform.h

 #include "clang/Sema/Ownership.h"
 #include "clang/Sema/ParsedTemplate.h"
 #include "clang/Sema/ScopeInfo.h"
 #include "clang/Sema/SemaDiagnostic.h"
 #include "clang/Sema/SemaInternal.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Support/ErrorHandling.h"
 #include <algorithm>
+#include <llvm-15/llvm/Analysis/AssumptionCache.h>
 #include <optional>
 
 using namespace llvm::omp;
 
 namespace clang {
 using namespace sema;
 
 /// A semantic tree transformation that allows one to transform one
ExprResult TransformDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E,
                                                 TypeSourceInfo **RecoveryTSI);
 
   ExprResult TransformParenDependentScopeDeclRefExpr(
       ParenExpr *PE, DependentScopeDeclRefExpr *DRE, bool IsAddressOfOperand,
       TypeSourceInfo **RecoveryTSI);
 
   StmtResult TransformOMPExecutableDirective(OMPExecutableDirective *S);
 
+  // ActionResult<ConceptLoc *> TransformConceptLoc(const ConceptLoc *L);
+
 // FIXME: We use LLVM_ATTRIBUTE_NOINLINE because inlining causes a ridiculous
 // amount of stack usage with clang.
 #define STMT(Node, Parent)                        \
   LLVM_ATTRIBUTE_NOINLINE \
   StmtResult Transform##Node(Node *S);
 #define VALUESTMT(Node, Parent)                   \
   LLVM_ATTRIBUTE_NOINLINE \
   StmtResult Transform##Node(Node *S, StmtDiscardKind SDK);
ExprResult Result = getSema().CheckConceptTemplateId(SS, TemplateKWLoc,
                                                          ConceptNameInfo,
                                                          FoundDecl,
                                                          NamedConcept, TALI);
     if (Result.isInvalid())
       return ExprError();
     return Result;
   }
 
+  /* NOTE(massberg) We need probably a RebuildConceptLoc here.*/
+
   /// \brief Build a new requires expression.
   ///
   /// By default, performs semantic analysis to build the new expression.
   /// Subclasses may override this routine to provide different behavior.
   ExprResult RebuildRequiresExpr(SourceLocation RequiresKWLoc,
                                  RequiresExprBodyDecl *Body,
                                  ArrayRef<ParmVarDecl *> LocalParameters,
                                  ArrayRef<concepts::Requirement *> Requirements,
if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0),
                                                 NewTemplateArgs))
       return QualType();
 
     if (TL.getNestedNameSpecifierLoc()) {
       NewNestedNameSpec
         = getDerived().TransformNestedNameSpecifierLoc(
             TL.getNestedNameSpecifierLoc());
       if (!NewNestedNameSpec)
         return QualType();
     }
   }
 
   QualType Result = TL.getType();
   if (getDerived().AlwaysRebuild() || NewDeduced != OldDeduced ||
       T->isDependentType() || T->isConstrained()) {
     // FIXME: Maybe don't rebuild if all template arguments are the same.
     llvm::SmallVector<TemplateArgument, 4> NewArgList;
     NewArgList.reserve(NewTemplateArgs.size());
     for (const auto &ArgLoc : NewTemplateArgs.arguments())
       NewArgList.push_back(ArgLoc.getArgument());
     Result = getDerived().RebuildAutoType(NewDeduced, T->getKeyword(), NewCD,
                                           NewArgList);
     if (Result.isNull())
       return QualType();
   }
 
   AutoTypeLoc NewTL = TLB.push<AutoTypeLoc>(Result);
   NewTL.setNameLoc(TL.getNameLoc());
-  NewTL.setNestedNameSpecifierLoc(NewNestedNameSpec);
-  NewTL.setTemplateKWLoc(TL.getTemplateKWLoc());
-  NewTL.setConceptNameLoc(TL.getConceptNameLoc());
-  NewTL.setFoundDecl(TL.getFoundDecl());
   NewTL.setLAngleLoc(TL.getLAngleLoc());
   NewTL.setRAngleLoc(TL.getRAngleLoc());
   NewTL.setRParenLoc(TL.getRParenLoc());
-  for (unsigned I = 0; I < NewTL.getNumArgs(); ++I)
-    NewTL.setArgLocInfo(I, NewTemplateArgs.arguments()[I].getLocInfo());
+
+  if (T->isConstrained()) {
+    // FIXME: move to TransformConceptLoc
+    DeclarationNameInfo DNI = DeclarationNameInfo();
+    DNI.setLoc(TL.getConceptNameLoc());
+    if (T->isConstrained()) {
+      DNI.setName(TL.getTypePtr()->getTypeConstraintConcept()->getDeclName());
+      DNI.setInfo(TL.getTypePtr()->getTypeConstraintConcept()->getDeclName());
+    }
+    auto *CL = ConceptLoc::Create(
+        SemaRef.Context, NewNestedNameSpec, TL.getTemplateKWLoc(), DNI,
+        TL.getFoundDecl(),
+        (T->isConstrained() ? TL.getTypePtr()->getTypeConstraintConcept()
+                            : nullptr),
+        (NewTemplateArgs.size() > 0 ? ASTTemplateArgumentListInfo::Create(
+                                          SemaRef.Context, NewTemplateArgs)
+                                    : nullptr));
+    NewTL.setConceptLoc(CL);
+  }
 
   return Result;
 }
 
 template <typename Derived>
 QualType TreeTransform<Derived>::TransformTemplateSpecializationType(
                                                         TypeLocBuilder &TLB,
                                            TemplateSpecializationTypeLoc TL,
if (getDerived().TransformTemplateArguments(Old->getTemplateArgs(),
     return ExprError();
 
   return getDerived().RebuildConceptSpecializationExpr(
       E->getNestedNameSpecifierLoc(), E->getTemplateKWLoc(),
       E->getConceptNameInfo(), E->getFoundDecl(), E->getNamedConcept(),
       &TransArgs);
 }
 
+/*template <typename Derived>
+ExprResult
+TreeTransform<Derived>::TransformConceptLoc(const ConceptLoc *CL) {
+  const ASTTemplateArgumentListInfo *Old = CL->getTemplateArgsAsWritten();
+  TemplateArgumentListInfo TransArgs(Old->LAngleLoc, Old->RAngleLoc);
+  if (getDerived().TransformTemplateArguments(Old->getTemplateArgs(),
+                                              Old->NumTemplateArgs, TransArgs))
+    return ExprError;
+
+  return getDerived().RebuildConceptLoc(
+      CL->getNestedNameSpecifierLoc(), CL->getTemplateKWLoc(),
+      CL->getConceptNameInfo(), CL->getFoundDecl(), CL->getNamedConcept(),
+      &TransArgs);
+}*/
+
 template<typename Derived>
 ExprResult
 TreeTransform<Derived>::TransformRequiresExpr(RequiresExpr *E) {
   SmallVector<ParmVarDecl*, 4> TransParams;
   SmallVector<QualType, 4> TransParamTypes;
   Sema::ExtParameterInfoBuilder ExtParamInfos;
 
   // C++2a [expr.prim.req]p2

clang/lib/Serialization/ASTReader.cpp

void TypeLocReader::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
   TL.setLParenLoc(readSourceLocation());
   TL.setRParenLoc(readSourceLocation());
   TL.setUnderlyingTInfo(GetTypeSourceInfo());
 }
 
 void TypeLocReader::VisitAutoTypeLoc(AutoTypeLoc TL) {
   TL.setNameLoc(readSourceLocation());
   if (Reader.readBool()) {
-    TL.setNestedNameSpecifierLoc(ReadNestedNameSpecifierLoc());
-    TL.setTemplateKWLoc(readSourceLocation());
-    TL.setConceptNameLoc(readSourceLocation());
-    TL.setFoundDecl(Reader.readDeclAs<NamedDecl>());
     TL.setLAngleLoc(readSourceLocation());
     TL.setRAngleLoc(readSourceLocation());
-    for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
-      TL.setArgLocInfo(
-          i, Reader.readTemplateArgumentLocInfo(
-                 TL.getTypePtr()->getTypeConstraintArguments()[i].getKind()));
+    // FIXME: Move to VisitConceptLoc()
+    TL.setDefaultLoc(readSourceLocation());
+    if (Reader.readBool()) {
+      auto NNS = ReadNestedNameSpecifierLoc();
+      auto TemplateKWLoc = readSourceLocation();
+      auto ConceptNameLoc = Reader.readDeclarationNameInfo();
+      auto FoundDecl = Reader.readDeclAs<NamedDecl>();
+      auto NamedConcept = Reader.readDeclAs<ConceptDecl>();
+
+      auto *CL = ConceptLoc::Create(
+          Reader.getContext(), NNS, TemplateKWLoc, ConceptNameLoc, FoundDecl,
+          NamedConcept,
+          (Reader.readBool() ? Reader.readASTTemplateArgumentListInfo()
+                             : nullptr));
+      TL.setConceptLoc(CL);
+    }
   }
   if (Reader.readBool())
     TL.setRParenLoc(readSourceLocation());
 }
 
 void TypeLocReader::VisitDeducedTemplateSpecializationTypeLoc(
     DeducedTemplateSpecializationTypeLoc TL) {
   TL.setTemplateNameLoc(readSourceLocation());

clang/lib/Serialization/ASTReaderDecl.cpp

void ASTDeclReader::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
   if (Record.readBool()) {
     NestedNameSpecifierLoc NNS = Record.readNestedNameSpecifierLoc();
     DeclarationNameInfo DN = Record.readDeclarationNameInfo();
     ConceptDecl *NamedConcept = Record.readDeclAs<ConceptDecl>();
     const ASTTemplateArgumentListInfo *ArgsAsWritten = nullptr;
     if (Record.readBool())
         ArgsAsWritten = Record.readASTTemplateArgumentListInfo();
     Expr *ImmediatelyDeclaredConstraint = Record.readExpr();
-    D->setTypeConstraint(NNS, DN, /*FoundDecl=*/nullptr, NamedConcept,
-                         ArgsAsWritten, ImmediatelyDeclaredConstraint);
+    auto *CL = ConceptLoc::Create(
+        Reader.getContext(), NNS,
+        SourceLocation{}, // What is the correct value here?
+        DN, /*FoundDecl=*/nullptr, NamedConcept, ArgsAsWritten);
+
+    D->setTypeConstraint(CL, ImmediatelyDeclaredConstraint);
     if ((D->ExpandedParameterPack = Record.readInt()))
       D->NumExpanded = Record.readInt();
   }
 
   if (Record.readInt())
     D->setDefaultArgument(readTypeSourceInfo());
 }
 

clang/lib/Serialization/ASTReaderStmt.cpp

if (!Satisfaction.IsSatisfied) {
     }
   }
   return Satisfaction;
 }
 
 void ASTStmtReader::VisitConceptSpecializationExpr(
         ConceptSpecializationExpr *E) {
   VisitExpr(E);
-  E->NestedNameSpec = Record.readNestedNameSpecifierLoc();
-  E->TemplateKWLoc = Record.readSourceLocation();
-  E->ConceptName = Record.readDeclarationNameInfo();
-  E->NamedConcept = readDeclAs<ConceptDecl>();
-  E->FoundDecl = Record.readDeclAs<NamedDecl>();
+  auto NestedNameSpec = Record.readNestedNameSpecifierLoc();
+  auto TemplateKWLoc = Record.readSourceLocation();
+  auto ConceptName = Record.readDeclarationNameInfo();
+  auto NamedConcept = readDeclAs<ConceptDecl>();
+  auto FoundDecl = Record.readDeclAs<NamedDecl>();
   E->SpecDecl = Record.readDeclAs<ImplicitConceptSpecializationDecl>();
-  E->ArgsAsWritten = Record.readASTTemplateArgumentListInfo();
+  auto ArgsAsWritten = Record.readASTTemplateArgumentListInfo();
+  E->Loc =
+      ConceptLoc::Create(Record.getContext(), NestedNameSpec, TemplateKWLoc,
+                         ConceptName, FoundDecl, NamedConcept, ArgsAsWritten);
   E->Satisfaction = E->isValueDependent() ? nullptr :
       ASTConstraintSatisfaction::Create(Record.getContext(),
                                         readConstraintSatisfaction(Record));
 }
 
 static concepts::Requirement::SubstitutionDiagnostic *
 readSubstitutionDiagnostic(ASTRecordReader &Record) {
   std::string SubstitutedEntity = Record.readString();

clang/lib/Serialization/ASTWriter.cpp

 
 void TypeLocWriter::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
   addSourceLocation(TL.getKWLoc());
   addSourceLocation(TL.getLParenLoc());
   addSourceLocation(TL.getRParenLoc());
   Record.AddTypeSourceInfo(TL.getUnderlyingTInfo());
 }
 
 void TypeLocWriter::VisitAutoTypeLoc(AutoTypeLoc TL) {
   addSourceLocation(TL.getNameLoc());
   Record.push_back(TL.isConstrained());
   if (TL.isConstrained()) {
-    Record.AddNestedNameSpecifierLoc(TL.getNestedNameSpecifierLoc());
-    addSourceLocation(TL.getTemplateKWLoc());
-    addSourceLocation(TL.getConceptNameLoc());
-    Record.AddDeclRef(TL.getFoundDecl());
     addSourceLocation(TL.getLAngleLoc());
     addSourceLocation(TL.getRAngleLoc());
-    for (unsigned I = 0; I < TL.getNumArgs(); ++I)
-      Record.AddTemplateArgumentLocInfo(
-          TL.getTypePtr()->getTypeConstraintArguments()[I].getKind(),
-          TL.getArgLocInfo(I));
+    Record.AddSourceLocation(TL.getDefaultLoc());
+
+    // FIXME: Move to VisitConceptLoc()
+    auto *CL = TL.getConceptLoc();
+    Record.push_back(CL != nullptr);
+    if (CL) {
+      Record.AddNestedNameSpecifierLoc(CL->getNestedNameSpecifierLoc());
+      Record.AddSourceLocation(CL->getTemplateKWLoc());
+      Record.AddDeclarationNameInfo(CL->getConceptNameInfo());
+      Record.AddDeclRef(CL->getFoundDecl());
+      Record.AddDeclRef(CL->getNamedConcept());
+      Record.push_back(CL->getTemplateArgsAsWritten() != nullptr);
+      if (CL->getTemplateArgsAsWritten())
+        Record.AddASTTemplateArgumentListInfo(CL->getTemplateArgsAsWritten());
+    }
   }
   Record.push_back(TL.isDecltypeAuto());
   if (TL.isDecltypeAuto())
     addSourceLocation(TL.getRParenLoc());
 }
 
 void TypeLocWriter::VisitDeducedTemplateSpecializationTypeLoc(
     DeducedTemplateSpecializationTypeLoc TL) {

clang/unittests/Tooling/RecursiveASTVisitorTests/Concept.cpp

struct ConceptVisitor : ExpectedLocationVisitor<ConceptVisitor> {
   bool TraverseTypeConstraint(const TypeConstraint *C) {
     ++TypeConstraintsTraversed;
     return ExpectedLocationVisitor::TraverseTypeConstraint(C);
   }
   bool TraverseConceptRequirement(concepts::Requirement *R) {
     ++ConceptRequirementsTraversed;
     return ExpectedLocationVisitor::TraverseConceptRequirement(R);
   }
+  bool TraverseConceptLoc(const ConceptLoc *CL) {
+    ++ConceptLocsTraversed;
+    return ExpectedLocationVisitor::TraverseConceptLoc(CL);
+  }
 
   bool shouldVisitImplicitCode() { return ShouldVisitImplicitCode; }
 
   int ConceptSpecializationExprsVisited = 0;
   int TypeConstraintsTraversed = 0;
   int ConceptRequirementsTraversed = 0;
+  int ConceptLocsTraversed = 0;
   bool ShouldVisitImplicitCode = false;
 };
 
 TEST(RecursiveASTVisitor, Concepts) {
   ConceptVisitor Visitor;
   Visitor.ShouldVisitImplicitCode = true;
   EXPECT_TRUE(Visitor.runOver("template <typename T> concept Fooable = true;\n"
                               "template <Fooable T> void bar(T);",
                               ConceptVisitor::Lang_CXX2a));
   // Check that we traverse the "Fooable T" template parameter's
   // TypeConstraint's ImmediatelyDeclaredConstraint, which is a
   // ConceptSpecializationExpr.
   EXPECT_EQ(1, Visitor.ConceptSpecializationExprsVisited);
   // Also check we traversed the TypeConstraint that produced the expr.
   EXPECT_EQ(1, Visitor.TypeConstraintsTraversed);
+  EXPECT_EQ(1, Visitor.ConceptLocsTraversed);
 
   Visitor = {}; // Don't visit implicit code now.
   EXPECT_TRUE(Visitor.runOver("template <typename T> concept Fooable = true;\n"
                               "template <Fooable T> void bar(T);",
                               ConceptVisitor::Lang_CXX2a));
   // Check that we only visit the TypeConstraint, but not the implicitly
   // generated immediately declared expression.
   EXPECT_EQ(0, Visitor.ConceptSpecializationExprsVisited);
   EXPECT_EQ(1, Visitor.TypeConstraintsTraversed);
+  EXPECT_EQ(1, Visitor.ConceptLocsTraversed);
 
   Visitor = {};
   EXPECT_TRUE(Visitor.runOver("template <class T> concept A = true;\n"
                               "template <class T> struct vector {};\n"
                               "template <class T> concept B = requires(T x) {\n"
                               "  typename vector<T*>;\n"
                               "  {x} -> A;\n"
                               "  requires true;\n"
                               "};",
                               ConceptVisitor::Lang_CXX2a));
   EXPECT_EQ(3, Visitor.ConceptRequirementsTraversed);
+  EXPECT_EQ(1, Visitor.ConceptLocsTraversed);
 }
 
 struct VisitDeclOnlyOnce : ExpectedLocationVisitor<VisitDeclOnlyOnce> {
   bool VisitConceptDecl(ConceptDecl *D) {
     ++ConceptDeclsVisited;
     return true;
   }