[Clang] Refactor "Designators" into a unified implementation [NFC]

[void]

Summary

The interfaces for designators (i.e. C99 designated initializers) was
done in two slightly different ways. This was rather wasteful as the
differences could be combined into one.

[void]

Friendly ping.

[rsmith]

clang/include/clang/AST/Designator.h

88–93

This looks very odd -- these two index fields represent completely different kinds of information, one of which is specific to an implementation detail of InitListExpr / DesignatedInitExpr. Perhaps this class could be templated over its representation of an expression, instead of having both cases be possibilities here, and having the user of this class keep track of whether they're using the kind of designator that stores an expression pointer or the kind that stores an expression index? (We'd end up storing two different indexes for array range designators this way, but that seems like it should not be problematic.)

99

Does this really need to be mutable? The AST version shouldn't be exposing a way to mutate this field! It seems like we should have a non-const overload of Designation::getDesignator for Sema to use if it really needs to modify this field.

314–320

AST classes shouldn't reference Sema. But these functions do nothing; can they be removed?

341–347

AST classes shouldn't reference Sema. But these functions do nothing; can they be removed?

[void]

Combine the array designator internals and templatize them. It should make this a bit simpler.

[void]

clang/include/clang/AST/Designator.h

314–320

Looks like they're dead. Removed.

[aaron.ballman]

Drive by comment (I'll give a more thorough review when I have a moment): precommit CI seems to have found an issue to address.

Assertion failed: false && "Invalid accessor", file C:\ws\w5\llvm-project\premerge-checks\clang\include\clang/AST/Designator.h, line 276

[void]

Put assert in correct place.

[void]

In D140584#4029607, @aaron.ballman wrote:

Drive by comment (I'll give a more thorough review when I have a moment): precommit CI seems to have found an issue to address.

Assertion failed: false && "Invalid accessor", file C:\ws\w5\llvm-project\premerge-checks\clang\include\clang/AST/Designator.h, line 276

doh! I did a think-o. Easy fix.

[void]

BTW, the naming of the enums sucks. Feel free to offer alternatives. :-)

[rsmith]

clang/include/clang/AST/Designator.h

89

Can we move the templating out from here to the whole Designator and Designation classes? It shouldn't be possible to mix the two kinds in the same Designation.

[void]

clang/include/clang/AST/Designator.h

89

Grr...My previous comment was eaten.

I'll give it a shot.

However, I'm a bit surprised at how designators are handled by Clang. I expected that a Designation would be an Expr with the Designators being L-values (e.g. MemberExprs / ArraySubscriptExprs), but instead the Designation exists just long enough to be turned into an explicit initialization list. Is there a reason to do it that way instead of using expressions?

[void]

clang/include/clang/AST/Designator.h

89

So it looks like moving the template outside of the class won't work. The ability to switch between Expr and unsigned while retaining the same overall type is hardwired into things like the ASTImporter.

This is kind of a massive mess. Maybe we shouldn't even allow them to use both Expr and unsigned but instead require them to use one or the other? Maybe we could require unsigned with the understanding that the Expr can be converted into a constant?

[void]

Use EllipsisLoc instead of one of the Brackets.

[void]

Sonar ping. :-)

[void]

Friendly ping!

BTW, I'm planning on future changes to designated initializers. This is the first step. I hope to get rid of the template stuff in the followup.

[void]

@rsmith Ping. This is blocking some patches I'd like to submit afterwards. :-)

[rsmith]

clang/include/clang/AST/Designator.h

89

I'm not understanding something. Currently the ASTImporter only deals with DesignatedInitExpr::Designators , which only ever store integer indexes.

Basically, today, we have two different classes:

• A class that's specific to DesignatedInitExpr, and tracks array index expressions by storing the index of the expression within the DesignatedInitExpr's list of children; this is also what ASTImporter can import, because it's the one that's used in the AST's representation.
• A class that's specific to Sema's processing that tracks array index expressions as Expr* instead.

You want to refactor them to share code, which makes sense, because they are basically the same other than how they refer to expressions. (Not quite: DesignatedInitExpr can apparently refer to a field either as an IdentifierInfo* or as a FieldDecl*, whereas the Sema version always uses the IdentifierInfo* representation.)

Each current user of one of these two classes uses only one of the two, which means they're either exclusively using integers to refer to expressions or exclusively using Expr*. So it seems to me that you should be able to update each user to use either Designator<unsigned> or Designator<Expr*>, depending on which class they used before.

What am I missing?

[void]

clang/include/clang/AST/Designator.h

89

I'm still allowing them to use a Designator<unsigned> / Designator<Expr*> as they see fit, only it's hidden from them via the Create methods. I personally find the use of two different versions (one using unsigned and one using Expr*) completely baffling. Why can't they all use Expr*? Also the ASTImporter only outputs the start of an array init range, which is at the very least counter-intuitive. That's one of the issues I'd like to tackle with follow-up patches, hopefully getting rid of the need for this template all together. This does mean that in the interim a non-array range designator will have extra End & EllisisLoc fields that aren't used, but that shouldn't be too horrible, given that they'd be there anyway because of the union.

[rsmith]

clang/include/clang/AST/Designator.h

89

The reason that's jumping out at me for having separate integer / Expr* implementations here is space-efficiency -- we get to make array range designators (and hence designators overall) be only 16 bytes rather than the 32 bytes they occupy in this patch (assuming 64-bit pointers) by storing indexes instead of pointers.

If your eventual plan is to remove the children list from DesignatedInitExpr, and store the pointers only in the designators, that seems to cost 8 bytes per designator in the two common cases:

• For a field designator: 32 bytes (with 16 bytes of padding) versus 16 bytes + 8 bytes for the child pointer today
• For an array designator: 32 bytes (with 16 bytes of padding) versus 16 bytes + 8 bytes for the child pointer today
• For an array range designator: 32 bytes (4 bytes of padding) versus 16 bytes + 16 bytes for two child pointers today

... plus it'll presumably be painful to make the Stmt child iterator be able to handle this.

If you don't remove the separate children list from DesignatedInitExpr, then it seems like this approach will cost 16 bytes per designator in all cases, and we'll need to be careful in AST serialization / deserialization that we don't accidentally duplicate the Exprs that now have two pointers pointing to them instead of one, and likewise anywhere else that assumes each Expr is only reachable by one path through the AST (eg, TreeTransform, the recursive AST visitor).

I think some more visibility into the eventual plan would help.

[void]

clang/include/clang/AST/Designator.h

89

The plan isn't detailed, but I basically want to address several of the points you mentioned here. In particular, I think the structure of DesignatedInitExpr is backwards from how every other Expr is handled in Clang. For instance, the Expr for something like s.t.u is a MemberExpr with a MemberExpr as its sub-expression and so on. DesignatedInitExpr on the other hand basically has a list of maybe expressions, maybe integers that refer to parts of the structure / array. It seems cleaner to me to use the MemberExpr / ArraySubscriptExpr way of referring to the member being initialized rather than using a specialized list that has to be handled differently from other Expr's.

The first step in my evil plot is to do this simple refactoring, so that there's no initial functionality change, before I do the more invasive changes that may break things.

I'm doing this because I'm working on a feature that uses the DIE syntax, and it would be much simpler to have it be a MemberExpr.

Am I completely off base here?

[rsmith]

I think this is fine as a short-term stepping stone to a different representation.

clang/include/clang/AST/Designator.h

89

Thanks, that's really helpful.

OK, so the end design would be something like (just building out some details here so I can think about this better; I'm not expecting you would necessarily do exactly this!):

• DesignatedInitExpr becomes a base class with derived classes for member designators, array designators, and array range designators (And maybe also there's a different representation for unresolved versus resolved member designators.)
• These work much like MemberExpr / ArraySubscriptExpr, except that they don't have a "base" object (and instead store an initializer for the nominated field / array element(s)), and are "inside-out": for .t.u = x we want the top-level expression to be a DesignatedInitMemberExpr that names t and whose initializer is a DesignatedInitMemberExpr that names u and whose initializer is x, whereas for s.t.u the top-level expression is a MemberExpr that names u and its base subexpression is a MemberExpr that names t. That is, while we model s.t.u = x as ((s.t).u) = x, we model .t.u = x more like .t = (.u = x)
• We use the same representation both in DesignatedInitExpr and in Sema (and everywhere else that looks at the syntactic form of an initializer list).
• Designation and Designator are removed entirely.

If something like that is the plan, then yes, I think that's completely reasonable, and seems like a nice improvement -- and I think it's fine if the intermediate state increases the AST size for designated initializers, as this patch does, especially if you're aiming for this to be completed within a single release cycle.

(Just quickly checking the size of the representation: a single-field DesignatedInitExpr is currently 40 bytes + 16 bytes for the Designator array, and I think could easily be 40 bytes *total* with the new representation; with two fields, it's currently 40 + 32 and could be 40 + 40 with the new representation. I think that's going to be a win essentially always.)

[void]

clang/include/clang/AST/Designator.h

89

Thanks! I'm going to dig into the DIE stuff more and will have a much more detailed plan that I can give you to see what you think before I go too far down the wrong path. :-)

[shafik]

I think these two bug reports: https://github.com/llvm/llvm-project/issues/46132 and https://github.com/llvm/llvm-project/issues/61118 may be related to this change.

clang-tools-extra/clangd/FindTarget.cpp

struct Visitor : public ConstStmtVisitor<Visitor> {
       }
       void VisitSizeOfPackExpr(const SizeOfPackExpr *SE) {
         Outer.add(SE->getPack(), Flags);
       }
       void VisitCXXConstructExpr(const CXXConstructExpr *CCE) {
         Outer.add(CCE->getConstructor(), Flags);
       }
       void VisitDesignatedInitExpr(const DesignatedInitExpr *DIE) {
-        for (const DesignatedInitExpr::Designator &D :
-             llvm::reverse(DIE->designators()))
+        for (const Designator &D : llvm::reverse(DIE->designators()))
           if (D.isFieldDesignator()) {
             Outer.add(D.getField(), Flags);
             // We don't know which designator was intended, we assume the outer.
             break;
           }
       }
       void VisitGotoStmt(const GotoStmt *Goto) {
         if (auto *LabelDecl = Goto->getLabel())
void VisitObjCMessageExpr(const ObjCMessageExpr *E) {
       // The name may have several tokens, we can only report the first.
       Refs.push_back(ReferenceLoc{NestedNameSpecifierLoc(),
                                   E->getSelectorStartLoc(),
                                   /*IsDecl=*/false,
                                   {E->getMethodDecl()}});
     }
 
     void VisitDesignatedInitExpr(const DesignatedInitExpr *DIE) {
-      for (const DesignatedInitExpr::Designator &D : DIE->designators()) {
+      for (const Designator &D : DIE->designators()) {
         if (!D.isFieldDesignator())
           continue;
 
         Refs.push_back(ReferenceLoc{NestedNameSpecifierLoc(),
                                     D.getFieldLoc(),
                                     /*IsDecl=*/false,
                                     {D.getField()}});
       }

clang/include/clang/AST/Designator.h

+//===--- Designator.h - Initialization Designator ---------------*- 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines interfaces used to represent designators (i.e. C99
+// designated initializers) during parsing and sema.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_AST_DESIGNATOR_H
+#define LLVM_CLANG_AST_DESIGNATOR_H
+
+#include "clang/Basic/SourceLocation.h"
+#include "llvm/ADT/SmallVector.h"
+
+namespace clang {
+
+class Expr;
+class FieldDecl;
+class IdentifierInfo;
+class Sema;
+
+/// Designator - A designator in a C99 designated initializer.
+///
+/// This class is a discriminated union which holds the various
+/// different sorts of designators possible. A Designation is an array of
+/// these.  An example of a designator are things like this:
+///
+///      [8] .field [47]        // C99 designation: 3 designators
+///      [8 ... 47]  field:     // GNU extensions: 2 designators
+///
+/// These occur in initializers, e.g.:
+///
+///      int a[10] = {2, 4, [8]=9, 10};
+///
+class Designator {
+  enum DesignatorKind {
+    FieldDesignator,
+    ArrayDesignatorExpr,
+    ArrayDesignatorInt,
+    ArrayRangeDesignatorExpr,
+    ArrayRangeDesignatorInt,
+  };
+
+  DesignatorKind Kind;
+
+  /// A field designator, e.g., ".x = 42".
+  class FieldDesignatorInfo {
+    /// Refers to the field that is being initialized. The low bit of this
+    /// field determines whether this is actually a pointer to an
+    /// IdentifierInfo (if 1) or a FieldDecl (if 0). When initially
+    /// constructed, a field designator will store an IdentifierInfo*. After
+    /// semantic analysis has resolved that name, the field designator will
+    /// instead store a FieldDecl*.
+    uintptr_t NameOrField;
+
+  public:
+    /// The location of the '.' in the designated initializer.
+    SourceLocation DotLoc;
+
+    /// The location of the field name in the designated initializer.
+    SourceLocation NameLoc;
+
+    FieldDesignatorInfo(const IdentifierInfo *II, SourceLocation DotLoc,
+                        SourceLocation NameLoc)
+        : NameOrField(reinterpret_cast<uintptr_t>(II) | 0x01), DotLoc(DotLoc),
+          NameLoc(NameLoc) {}
+
+    FieldDecl *getFieldDecl() const {
+      if (NameOrField & 0x01)
+        return nullptr;
+      return reinterpret_cast<FieldDecl *>(NameOrField);
+    }
+    const IdentifierInfo *getIdentifierInfo() const {
+      if (NameOrField & 0x01)
+        return reinterpret_cast<const IdentifierInfo *>(NameOrField & ~0x1);
+      return nullptr;
+    }
+
+    void set(FieldDecl *FD) { NameOrField = reinterpret_cast<uintptr_t>(FD); }
+  };
+
+  /// An array designator, e.g., "[42] = 0" and "[42 ... 50] = 1".
+  template <typename Ty> struct ArrayDesignatorInfo {
+    /// Location of the first and last index expression within the designated
+    /// initializer expression's list of subexpressions.
+    Ty Start;
+    Ty End;
+
+    /// The location of the '[' starting the array designator.
+    SourceLocation LBracketLoc;
+
+    /// The location of the ellipsis separating the start and end indices.
+    /// Only valid for GNU array-range designators.
+    SourceLocation EllipsisLoc;
+
+    /// The location of the ']' terminating the array designator.
+    SourceLocation RBracketLoc;
+
+    ArrayDesignatorInfo(Ty Start, Ty End, SourceLocation LBracketLoc,
+                        SourceLocation EllipsisLoc, SourceLocation RBracketLoc)
+        : Start(Start), End(End), LBracketLoc(LBracketLoc),
+          EllipsisLoc(EllipsisLoc), RBracketLoc(RBracketLoc) {}
+
+    Ty getStart() const { return Start; }
+    Ty getEnd() const { return End; }
+  };
+
+  union {
+    FieldDesignatorInfo FieldInfo;
+    ArrayDesignatorInfo<Expr *> ArrayInfoExpr;
+    ArrayDesignatorInfo<unsigned> ArrayInfoInt;
+  };
+
+  Designator(DesignatorKind Kind) : Kind(Kind) {}
+
+public:
+  Designator() {}
+
+  bool isFieldDesignator() const { return Kind == FieldDesignator; }
+  bool isArrayDesignator() const {
+    return Kind == ArrayDesignatorExpr || Kind == ArrayDesignatorInt;
+  }
+  bool isArrayRangeDesignator() const {
+    return Kind == ArrayRangeDesignatorExpr || Kind == ArrayRangeDesignatorInt;
+  }
+
+  /// FieldDesignatorInfo:
+  static Designator CreateFieldDesignator(const IdentifierInfo *FieldName,
+                                          SourceLocation DotLoc,
+                                          SourceLocation NameLoc) {
+    Designator D(FieldDesignator);
+    new (&D.FieldInfo) FieldDesignatorInfo(FieldName, DotLoc, NameLoc);
+    return D;
+  }
+
+  const IdentifierInfo *getFieldName() const;
+
+  FieldDecl *getField() const {
+    assert(isFieldDesignator() && "Invalid accessor");
+    return FieldInfo.getFieldDecl();
+  }
+
+  void setField(FieldDecl *FD) {
+    assert(isFieldDesignator() && "Invalid accessor");
+    FieldInfo.set(FD);
+  }
+
+  SourceLocation getDotLoc() const {
+    assert(isFieldDesignator() && "Invalid accessor");
+    return FieldInfo.DotLoc;
+  }
+
+  SourceLocation getFieldLoc() const {
+    assert(isFieldDesignator() && "Invalid accessor");
+    return FieldInfo.NameLoc;
+  }
+
+  /// ArrayDesignatorInfo:
+  static Designator
+  CreateArrayDesignator(Expr *Start, SourceLocation LBracketLoc,
+                        SourceLocation RBracketLoc = SourceLocation()) {
+    Designator D(ArrayDesignatorExpr);
+    new (&D.ArrayInfoExpr) ArrayDesignatorInfo<Expr *>(
+        Start, nullptr, LBracketLoc, SourceLocation(), RBracketLoc);
+    return D;
+  }
+  static Designator
+  CreateArrayDesignator(unsigned Start, SourceLocation LBracketLoc,
+                        SourceLocation RBracketLoc = SourceLocation()) {
+    Designator D(ArrayDesignatorInt);
+    new (&D.ArrayInfoInt) ArrayDesignatorInfo<unsigned>(
+        Start, 0, LBracketLoc, SourceLocation(), RBracketLoc);
+    return D;
+  }
+
+  template <typename Ty = Expr *> Ty getArrayIndex() const {
+    assert(isArrayDesignator() && "Invalid accessor");
+    return ArrayInfoExpr.getStart();
+  }
+
+  /// ArrayRangeDesignatorInfo:
+  static Designator
+  CreateArrayRangeDesignator(Expr *Start, Expr *End, SourceLocation LBracketLoc,
+                             SourceLocation EllipsisLoc,
+                             SourceLocation RBracketLoc = SourceLocation()) {
+    Designator D(ArrayRangeDesignatorExpr);
+    new (&D.ArrayInfoExpr) ArrayDesignatorInfo<Expr *>(
+        Start, End, LBracketLoc, EllipsisLoc, RBracketLoc);
+    return D;
+  }
+  static Designator
+  CreateArrayRangeDesignator(unsigned Index, SourceLocation LBracketLoc,
+                             SourceLocation EllipsisLoc,
+                             SourceLocation RBracketLoc = SourceLocation()) {
+    Designator D(ArrayRangeDesignatorInt);
+    new (&D.ArrayInfoInt) ArrayDesignatorInfo<unsigned>(
+        Index, 0, LBracketLoc, EllipsisLoc, RBracketLoc);
+    return D;
+  }
+
+  Expr *getArrayRangeStart() const {
+    assert(isArrayRangeDesignator() && "Invalid accessor");
+    return ArrayInfoExpr.getStart();
+  }
+
+  Expr *getArrayRangeEnd() const {
+    assert(isArrayRangeDesignator() && "Invalid accessor");
+    return ArrayInfoExpr.getEnd();
+  }
+
+  SourceLocation getLBracketLoc() const {
+    switch (Kind) {
+    default:
+      break;
+    case ArrayDesignatorExpr:
+    case ArrayRangeDesignatorExpr:
+      return ArrayInfoExpr.LBracketLoc;
+    case ArrayDesignatorInt:
+    case ArrayRangeDesignatorInt:
+      return ArrayInfoInt.LBracketLoc;
+    }
+
+    assert(false && "Invalid accessor");
+    return SourceLocation();
+  }
+
+  SourceLocation getEllipsisLoc() const {
+    switch (Kind) {
+    default:
+      break;
+    case ArrayRangeDesignatorExpr:
+      return ArrayInfoExpr.EllipsisLoc;
+    case ArrayRangeDesignatorInt:
+      return ArrayInfoInt.EllipsisLoc;
+    }
+
+    assert(false && "Invalid accessor");
+    return SourceLocation();
+  }
+
+  SourceLocation getRBracketLoc() const {
+    switch (Kind) {
+    default:
+      break;
+    case ArrayDesignatorExpr:
+    case ArrayRangeDesignatorExpr:
+      return ArrayInfoExpr.RBracketLoc;
+    case ArrayDesignatorInt:
+    case ArrayRangeDesignatorInt:
+      return ArrayInfoInt.RBracketLoc;
+    }
+
+    assert(false && "Invalid accessor");
+    return SourceLocation();
+  }
+
+  void setRBracketLoc(SourceLocation RBracketLoc) {
+    switch (Kind) {
+    default:
+      assert(false && "Invalid accessor");
+      break;
+    case ArrayDesignatorExpr:
+    case ArrayRangeDesignatorExpr:
+      ArrayInfoExpr.RBracketLoc = RBracketLoc;
+      break;
+    case ArrayDesignatorInt:
+    case ArrayRangeDesignatorInt:
+      ArrayInfoInt.RBracketLoc = RBracketLoc;
+      break;
+    }
+  }
+
+  unsigned getFirstExprIndex() const {
+    if (Kind == ArrayDesignatorInt || Kind == ArrayRangeDesignatorInt)
+      return ArrayInfoInt.getStart();
+
+    assert(false && "Invalid accessor");
+    return 0;
+  }
+
+  /// Source location accessors.
+  SourceLocation getBeginLoc() const LLVM_READONLY {
+    if (isFieldDesignator())
+      return getDotLoc().isInvalid() ? getFieldLoc() : getDotLoc();
+    return getLBracketLoc();
+  }
+  SourceLocation getEndLoc() const LLVM_READONLY {
+    return isFieldDesignator() ? getFieldLoc() : getRBracketLoc();
+  }
+  SourceRange getSourceRange() const LLVM_READONLY {
+    return SourceRange(getBeginLoc(), getEndLoc());
+  }
+};
+
+/// Designation - Represent a full designation, which is a sequence of
+/// designators.  This class is mostly a helper for InitListDesignations.
+class Designation {
+  /// Designators - The actual designators for this initializer.
+  SmallVector<Designator, 2> Designators;
+
+public:
+  /// AddDesignator - Add a designator to the end of this list.
+  void AddDesignator(Designator D) { Designators.push_back(D); }
+
+  bool empty() const { return Designators.empty(); }
+
+  unsigned getNumDesignators() const { return Designators.size(); }
+
+  const Designator &getDesignator(unsigned Idx) const {
+    assert(Idx < getNumDesignators());
+    return Designators[Idx];
+  }
+  Designator &getDesignator(unsigned Idx) {
+    assert(Idx < getNumDesignators());
+    return Designators[Idx];
+  }
+};
+
+} // end namespace clang
+
+#endif

clang/include/clang/AST/Expr.h

 #define LLVM_CLANG_AST_EXPR_H
 
 #include "clang/AST/APValue.h"
 #include "clang/AST/ASTVector.h"
 #include "clang/AST/ComputeDependence.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclAccessPair.h"
 #include "clang/AST/DependenceFlags.h"
+#include "clang/AST/Designator.h"
 #include "clang/AST/OperationKinds.h"
 #include "clang/AST/Stmt.h"
 #include "clang/AST/TemplateBase.h"
 #include "clang/AST/Type.h"
 #include "clang/Basic/CharInfo.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/SyncScope.h"
 #include "clang/Basic/TypeTraits.h"

 ///
 /// The InitListExpr contains three DesignatedInitExprs, the first of
 /// which covers @c [2].y=1.0. This DesignatedInitExpr will have two
 /// designators, one array designator for @c [2] followed by one field
 /// designator for @c .y. The initialization expression will be 1.0.
 class DesignatedInitExpr final
     : public Expr,
       private llvm::TrailingObjects<DesignatedInitExpr, Stmt *> {
-public:
-  /// Forward declaration of the Designator class.
-  class Designator;
-
 private:
   /// The location of the '=' or ':' prior to the actual initializer
   /// expression.
   SourceLocation EqualOrColonLoc;
 
   /// Whether this designated initializer used the GNU deprecated
   /// syntax rather than the C99 '=' syntax.
   unsigned GNUSyntax : 1;
DesignatedInitExpr(const ASTContext &C, QualType Ty,
                      SourceLocation EqualOrColonLoc, bool GNUSyntax,
                      ArrayRef<Expr *> IndexExprs, Expr *Init);
 
   explicit DesignatedInitExpr(unsigned NumSubExprs)
     : Expr(DesignatedInitExprClass, EmptyShell()),
       NumDesignators(0), NumSubExprs(NumSubExprs), Designators(nullptr) { }
 
 public:
-  /// A field designator, e.g., ".x".
-  struct FieldDesignator {
-    /// Refers to the field that is being initialized. The low bit
-    /// of this field determines whether this is actually a pointer
-    /// to an IdentifierInfo (if 1) or a FieldDecl (if 0). When
-    /// initially constructed, a field designator will store an
-    /// IdentifierInfo*. After semantic analysis has resolved that
-    /// name, the field designator will instead store a FieldDecl*.
-    uintptr_t NameOrField;
-
-    /// The location of the '.' in the designated initializer.
-    SourceLocation DotLoc;
-
-    /// The location of the field name in the designated initializer.
-    SourceLocation FieldLoc;
-  };
-
-  /// An array or GNU array-range designator, e.g., "[9]" or "[10..15]".
-  struct ArrayOrRangeDesignator {
-    /// Location of the first index expression within the designated
-    /// initializer expression's list of subexpressions.
-    unsigned Index;
-    /// The location of the '[' starting the array range designator.
-    SourceLocation LBracketLoc;
-    /// The location of the ellipsis separating the start and end
-    /// indices. Only valid for GNU array-range designators.
-    SourceLocation EllipsisLoc;
-    /// The location of the ']' terminating the array range designator.
-    SourceLocation RBracketLoc;
-  };
-
-  /// Represents a single C99 designator.
-  ///
-  /// @todo This class is infuriatingly similar to clang::Designator,
-  /// but minor differences (storing indices vs. storing pointers)
-  /// keep us from reusing it. Try harder, later, to rectify these
-  /// differences.
-  class Designator {
-    /// The kind of designator this describes.
-    enum {
-      FieldDesignator,
-      ArrayDesignator,
-      ArrayRangeDesignator
-    } Kind;
-
-    union {
-      /// A field designator, e.g., ".x".
-      struct FieldDesignator Field;
-      /// An array or GNU array-range designator, e.g., "[9]" or "[10..15]".
-      struct ArrayOrRangeDesignator ArrayOrRange;
-    };
-    friend class DesignatedInitExpr;
-
-  public:
-    Designator() {}
-
-    /// Initializes a field designator.
-    Designator(const IdentifierInfo *FieldName, SourceLocation DotLoc,
-               SourceLocation FieldLoc)
-      : Kind(FieldDesignator) {
-      new (&Field) DesignatedInitExpr::FieldDesignator;
-      Field.NameOrField = reinterpret_cast<uintptr_t>(FieldName) | 0x01;
-      Field.DotLoc = DotLoc;
-      Field.FieldLoc = FieldLoc;
-    }
-
-    /// Initializes an array designator.
-    Designator(unsigned Index, SourceLocation LBracketLoc,
-               SourceLocation RBracketLoc)
-      : Kind(ArrayDesignator) {
-      new (&ArrayOrRange) DesignatedInitExpr::ArrayOrRangeDesignator;
-      ArrayOrRange.Index = Index;
-      ArrayOrRange.LBracketLoc = LBracketLoc;
-      ArrayOrRange.EllipsisLoc = SourceLocation();
-      ArrayOrRange.RBracketLoc = RBracketLoc;
-    }
-
-    /// Initializes a GNU array-range designator.
-    Designator(unsigned Index, SourceLocation LBracketLoc,
-               SourceLocation EllipsisLoc, SourceLocation RBracketLoc)
-      : Kind(ArrayRangeDesignator) {
-      new (&ArrayOrRange) DesignatedInitExpr::ArrayOrRangeDesignator;
-      ArrayOrRange.Index = Index;
-      ArrayOrRange.LBracketLoc = LBracketLoc;
-      ArrayOrRange.EllipsisLoc = EllipsisLoc;
-      ArrayOrRange.RBracketLoc = RBracketLoc;
-    }
-
-    bool isFieldDesignator() const { return Kind == FieldDesignator; }
-    bool isArrayDesignator() const { return Kind == ArrayDesignator; }
-    bool isArrayRangeDesignator() const { return Kind == ArrayRangeDesignator; }
-
-    IdentifierInfo *getFieldName() const;
-
-    FieldDecl *getField() const {
-      assert(Kind == FieldDesignator && "Only valid on a field designator");
-      if (Field.NameOrField & 0x01)
-        return nullptr;
-      else
-        return reinterpret_cast<FieldDecl *>(Field.NameOrField);
-    }
-
-    void setField(FieldDecl *FD) {
-      assert(Kind == FieldDesignator && "Only valid on a field designator");
-      Field.NameOrField = reinterpret_cast<uintptr_t>(FD);
-    }
-
-    SourceLocation getDotLoc() const {
-      assert(Kind == FieldDesignator && "Only valid on a field designator");
-      return Field.DotLoc;
-    }
-
-    SourceLocation getFieldLoc() const {
-      assert(Kind == FieldDesignator && "Only valid on a field designator");
-      return Field.FieldLoc;
-    }
-
-    SourceLocation getLBracketLoc() const {
-      assert((Kind == ArrayDesignator || Kind == ArrayRangeDesignator) &&
-             "Only valid on an array or array-range designator");
-      return ArrayOrRange.LBracketLoc;
-    }
-
-    SourceLocation getRBracketLoc() const {
-      assert((Kind == ArrayDesignator || Kind == ArrayRangeDesignator) &&
-             "Only valid on an array or array-range designator");
-      return ArrayOrRange.RBracketLoc;
-    }
-
-    SourceLocation getEllipsisLoc() const {
-      assert(Kind == ArrayRangeDesignator &&
-             "Only valid on an array-range designator");
-      return ArrayOrRange.EllipsisLoc;
-    }
-
-    unsigned getFirstExprIndex() const {
-      assert((Kind == ArrayDesignator || Kind == ArrayRangeDesignator) &&
-             "Only valid on an array or array-range designator");
-      return ArrayOrRange.Index;
-    }
-
-    SourceLocation getBeginLoc() const LLVM_READONLY {
-      if (Kind == FieldDesignator)
-        return getDotLoc().isInvalid()? getFieldLoc() : getDotLoc();
-      else
-        return getLBracketLoc();
-    }
-    SourceLocation getEndLoc() const LLVM_READONLY {
-      return Kind == FieldDesignator ? getFieldLoc() : getRBracketLoc();
-    }
-    SourceRange getSourceRange() const LLVM_READONLY {
-      return SourceRange(getBeginLoc(), getEndLoc());
-    }
-  };
-
   static DesignatedInitExpr *Create(const ASTContext &C,
                                     llvm::ArrayRef<Designator> Designators,
                                     ArrayRef<Expr*> IndexExprs,
                                     SourceLocation EqualOrColonLoc,
                                     bool GNUSyntax, Expr *Init);
 
   static DesignatedInitExpr *CreateEmpty(const ASTContext &C,
                                          unsigned NumIndexExprs);

clang/include/clang/Sema/Designator.h

-//===--- Designator.h - Initialization Designator ---------------*- 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
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines interfaces used to represent designators (a la
-// C99 designated initializers) during parsing.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_CLANG_SEMA_DESIGNATOR_H
-#define LLVM_CLANG_SEMA_DESIGNATOR_H
-
-#include "clang/Basic/SourceLocation.h"
-#include "llvm/ADT/SmallVector.h"
-
-namespace clang {
-
-class Expr;
-class IdentifierInfo;
-class Sema;
-
-/// Designator - A designator in a C99 designated initializer.
-///
-/// This class is a discriminated union which holds the various
-/// different sorts of designators possible.  A Designation is an array of
-/// these.  An example of a designator are things like this:
-///     [8] .field [47]        // C99 designation: 3 designators
-///     [8 ... 47]  field:     // GNU extensions: 2 designators
-/// These occur in initializers, e.g.:
-///  int a[10] = {2, 4, [8]=9, 10};
-///
-class Designator {
-public:
-  enum DesignatorKind {
-    FieldDesignator, ArrayDesignator, ArrayRangeDesignator
-  };
-private:
-  Designator() {};
-
-  DesignatorKind Kind;
-
-  struct FieldDesignatorInfo {
-    const IdentifierInfo *II;
-    SourceLocation DotLoc;
-    SourceLocation NameLoc;
-  };
-  struct ArrayDesignatorInfo {
-    Expr *Index;
-    SourceLocation LBracketLoc;
-    mutable SourceLocation RBracketLoc;
-  };
-  struct ArrayRangeDesignatorInfo {
-    Expr *Start, *End;
-    SourceLocation LBracketLoc, EllipsisLoc;
-    mutable SourceLocation RBracketLoc;
-  };
-
-  union {
-    FieldDesignatorInfo FieldInfo;
-    ArrayDesignatorInfo ArrayInfo;
-    ArrayRangeDesignatorInfo ArrayRangeInfo;
-  };
-
-public:
-
-  DesignatorKind getKind() const { return Kind; }
-  bool isFieldDesignator() const { return Kind == FieldDesignator; }
-  bool isArrayDesignator() const { return Kind == ArrayDesignator; }
-  bool isArrayRangeDesignator() const { return Kind == ArrayRangeDesignator; }
-
-  const IdentifierInfo *getField() const {
-    assert(isFieldDesignator() && "Invalid accessor");
-    return FieldInfo.II;
-  }
-
-  SourceLocation getDotLoc() const {
-    assert(isFieldDesignator() && "Invalid accessor");
-    return FieldInfo.DotLoc;
-  }
-
-  SourceLocation getFieldLoc() const {
-    assert(isFieldDesignator() && "Invalid accessor");
-    return FieldInfo.NameLoc;
-  }
-
-  Expr *getArrayIndex() const {
-    assert(isArrayDesignator() && "Invalid accessor");
-    return ArrayInfo.Index;
-  }
-
-  Expr *getArrayRangeStart() const {
-    assert(isArrayRangeDesignator() && "Invalid accessor");
-    return ArrayRangeInfo.Start;
-  }
-  Expr *getArrayRangeEnd() const {
-    assert(isArrayRangeDesignator() && "Invalid accessor");
-    return ArrayRangeInfo.End;
-  }
-
-  SourceLocation getLBracketLoc() const {
-    assert((isArrayDesignator() || isArrayRangeDesignator()) &&
-           "Invalid accessor");
-    if (isArrayDesignator())
-      return ArrayInfo.LBracketLoc;
-    else
-      return ArrayRangeInfo.LBracketLoc;
-  }
-
-  SourceLocation getRBracketLoc() const {
-    assert((isArrayDesignator() || isArrayRangeDesignator()) &&
-           "Invalid accessor");
-    if (isArrayDesignator())
-      return ArrayInfo.RBracketLoc;
-    else
-      return ArrayRangeInfo.RBracketLoc;
-  }
-
-  SourceLocation getEllipsisLoc() const {
-    assert(isArrayRangeDesignator() && "Invalid accessor");
-    return ArrayRangeInfo.EllipsisLoc;
-  }
-
-  static Designator getField(const IdentifierInfo *II, SourceLocation DotLoc,
-                             SourceLocation NameLoc) {
-    Designator D;
-    D.Kind = FieldDesignator;
-    new (&D.FieldInfo) FieldDesignatorInfo;
-    D.FieldInfo.II = II;
-    D.FieldInfo.DotLoc = DotLoc;
-    D.FieldInfo.NameLoc = NameLoc;
-    return D;
-  }
-
-  static Designator getArray(Expr *Index,
-                             SourceLocation LBracketLoc) {
-    Designator D;
-    D.Kind = ArrayDesignator;
-    new (&D.ArrayInfo) ArrayDesignatorInfo;
-    D.ArrayInfo.Index = Index;
-    D.ArrayInfo.LBracketLoc = LBracketLoc;
-    D.ArrayInfo.RBracketLoc = SourceLocation();
-    return D;
-  }
-
-  static Designator getArrayRange(Expr *Start,
-                                  Expr *End,
-                                  SourceLocation LBracketLoc,
-                                  SourceLocation EllipsisLoc) {
-    Designator D;
-    D.Kind = ArrayRangeDesignator;
-    new (&D.ArrayRangeInfo) ArrayRangeDesignatorInfo;
-    D.ArrayRangeInfo.Start = Start;
-    D.ArrayRangeInfo.End = End;
-    D.ArrayRangeInfo.LBracketLoc = LBracketLoc;
-    D.ArrayRangeInfo.EllipsisLoc = EllipsisLoc;
-    D.ArrayRangeInfo.RBracketLoc = SourceLocation();
-    return D;
-  }
-
-  void setRBracketLoc(SourceLocation RBracketLoc) const {
-    assert((isArrayDesignator() || isArrayRangeDesignator()) &&
-           "Invalid accessor");
-    if (isArrayDesignator())
-      ArrayInfo.RBracketLoc = RBracketLoc;
-    else
-      ArrayRangeInfo.RBracketLoc = RBracketLoc;
-  }
-
-  /// ClearExprs - Null out any expression references, which prevents
-  /// them from being 'delete'd later.
-  void ClearExprs(Sema &Actions) {}
-
-  /// FreeExprs - Release any unclaimed memory for the expressions in
-  /// this designator.
-  void FreeExprs(Sema &Actions) {}
-};
-
-
-/// Designation - Represent a full designation, which is a sequence of
-/// designators.  This class is mostly a helper for InitListDesignations.
-class Designation {
-  /// Designators - The actual designators for this initializer.
-  SmallVector<Designator, 2> Designators;
-
-public:
-  /// AddDesignator - Add a designator to the end of this list.
-  void AddDesignator(Designator D) {
-    Designators.push_back(D);
-  }
-
-  bool empty() const { return Designators.empty(); }
-
-  unsigned getNumDesignators() const { return Designators.size(); }
-  const Designator &getDesignator(unsigned Idx) const {
-    assert(Idx < Designators.size());
-    return Designators[Idx];
-  }
-
-  /// ClearExprs - Null out any expression references, which prevents them from
-  /// being 'delete'd later.
-  void ClearExprs(Sema &Actions) {}
-
-  /// FreeExprs - Release any unclaimed memory for the expressions in this
-  /// designation.
-  void FreeExprs(Sema &Actions) {}
-};
-
-} // end namespace clang
-
-#endif

clang/include/clang/Tooling/Refactoring/RecursiveSymbolVisitor.h

if (NNS) {
       const NamespaceDecl *ND = NNS.getNestedNameSpecifier()->getAsNamespace();
       if (!visit(ND, NNS.getLocalBeginLoc(), NNS.getLocalEndLoc()))
         return false;
     }
     return BaseType::TraverseNestedNameSpecifierLoc(NNS);
   }
 
   bool VisitDesignatedInitExpr(const DesignatedInitExpr *E) {
-    for (const DesignatedInitExpr::Designator &D : E->designators()) {
+    for (const Designator &D : E->designators()) {
       if (D.isFieldDesignator() && D.getField()) {
         const FieldDecl *Decl = D.getField();
         if (!visit(Decl, D.getFieldLoc(), D.getFieldLoc()))
           return false;
       }
     }
     return true;
   }

clang/lib/AST/ASTImporter.cpp

 #include "clang/AST/DeclBase.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclFriend.h"
 #include "clang/AST/DeclGroup.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/DeclVisitor.h"
 #include "clang/AST/DeclarationName.h"
+#include "clang/AST/Designator.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/ExprObjC.h"
 #include "clang/AST/ExternalASTSource.h"
 #include "clang/AST/LambdaCapture.h"
 #include "clang/AST/NestedNameSpecifier.h"
 #include "clang/AST/OperationKinds.h"
 #include "clang/AST/Stmt.h"
public:
     Error ImportDeclContext(DeclContext *FromDC, bool ForceImport = false);
     Error ImportDeclContext(
         Decl *From, DeclContext *&ToDC, DeclContext *&ToLexicalDC);
     Error ImportImplicitMethods(const CXXRecordDecl *From, CXXRecordDecl *To);
 
     Expected<CXXCastPath> ImportCastPath(CastExpr *E);
     Expected<APValue> ImportAPValue(const APValue &FromValue);
 
-    using Designator = DesignatedInitExpr::Designator;
-
     /// What we should import from the definition.
     enum ImportDefinitionKind {
       /// Import the default subset of the definition, which might be
       /// nothing (if minimal import is set) or might be everything (if minimal
       /// import is not set).
       IDK_Default,
       /// Import everything.
       IDK_Everything,
for (Decl *FromD : DG) {
     else
       return ToDOrErr.takeError();
   }
   return DeclGroupRef::Create(Importer.getToContext(),
                               ToDecls.begin(),
                               NumDecls);
 }
 
-template <>
-Expected<ASTNodeImporter::Designator>
-ASTNodeImporter::import(const Designator &D) {
+template <> Expected<Designator> ASTNodeImporter::import(const Designator &D) {
   if (D.isFieldDesignator()) {
     IdentifierInfo *ToFieldName = Importer.Import(D.getFieldName());
 
     ExpectedSLoc ToDotLocOrErr = import(D.getDotLoc());
     if (!ToDotLocOrErr)
       return ToDotLocOrErr.takeError();
 
     ExpectedSLoc ToFieldLocOrErr = import(D.getFieldLoc());
     if (!ToFieldLocOrErr)
       return ToFieldLocOrErr.takeError();
 
-    return Designator(ToFieldName, *ToDotLocOrErr, *ToFieldLocOrErr);
+    return Designator::CreateFieldDesignator(ToFieldName, *ToDotLocOrErr,
+                                             *ToFieldLocOrErr);
   }
 
   ExpectedSLoc ToLBracketLocOrErr = import(D.getLBracketLoc());
   if (!ToLBracketLocOrErr)
     return ToLBracketLocOrErr.takeError();
 
   ExpectedSLoc ToRBracketLocOrErr = import(D.getRBracketLoc());
   if (!ToRBracketLocOrErr)
     return ToRBracketLocOrErr.takeError();
 
   if (D.isArrayDesignator())
-    return Designator(D.getFirstExprIndex(),
-                      *ToLBracketLocOrErr, *ToRBracketLocOrErr);
+    return Designator::CreateArrayDesignator(
+        D.getFirstExprIndex(), *ToLBracketLocOrErr, *ToRBracketLocOrErr);
 
   ExpectedSLoc ToEllipsisLocOrErr = import(D.getEllipsisLoc());
   if (!ToEllipsisLocOrErr)
     return ToEllipsisLocOrErr.takeError();
 
   assert(D.isArrayRangeDesignator());
-  return Designator(
+  return Designator::CreateArrayRangeDesignator(
       D.getFirstExprIndex(), *ToLBracketLocOrErr, *ToEllipsisLocOrErr,
       *ToRBracketLocOrErr);
 }
 
 template <>
 Expected<LambdaCapture> ASTNodeImporter::import(const LambdaCapture &From) {
   ValueDecl *Var = nullptr;
   if (From.capturesVariable()) {

clang/lib/AST/Expr.cpp

void *Mem = Context.Allocate(
       alignof(GenericSelectionExpr));
   return new (Mem) GenericSelectionExpr(EmptyShell(), NumAssocs);
 }
 
 //===----------------------------------------------------------------------===//
 //  DesignatedInitExpr
 //===----------------------------------------------------------------------===//
 
-IdentifierInfo *DesignatedInitExpr::Designator::getFieldName() const {
-  assert(Kind == FieldDesignator && "Only valid on a field designator");
-  if (Field.NameOrField & 0x01)
-    return reinterpret_cast<IdentifierInfo *>(Field.NameOrField & ~0x01);
-  return getField()->getIdentifier();
+const IdentifierInfo *Designator::getFieldName() const {
+  assert(isFieldDesignator() && "Invalid accessor");
+  if (auto *II = FieldInfo.getIdentifierInfo())
+    return II;
+  return FieldInfo.getFieldDecl()->getIdentifier();
 }
 
 DesignatedInitExpr::DesignatedInitExpr(const ASTContext &C, QualType Ty,
                                        llvm::ArrayRef<Designator> Designators,
                                        SourceLocation EqualOrColonLoc,
                                        bool GNUSyntax,
                                        ArrayRef<Expr *> IndexExprs, Expr *Init)
     : Expr(DesignatedInitExprClass, Ty, Init->getValueKind(),
SourceRange DesignatedInitExpr::getDesignatorsSourceRange() const {
   DesignatedInitExpr *DIE = const_cast<DesignatedInitExpr*>(this);
   if (size() == 1)
     return DIE->getDesignator(0)->getSourceRange();
   return SourceRange(DIE->getDesignator(0)->getBeginLoc(),
                      DIE->getDesignator(size() - 1)->getEndLoc());
 }
 
 SourceLocation DesignatedInitExpr::getBeginLoc() const {
-  SourceLocation StartLoc;
   auto *DIE = const_cast<DesignatedInitExpr *>(this);
   Designator &First = *DIE->getDesignator(0);
-  if (First.isFieldDesignator())
-    StartLoc = GNUSyntax ? First.Field.FieldLoc : First.Field.DotLoc;
-  else
-    StartLoc = First.ArrayOrRange.LBracketLoc;
-  return StartLoc;
+  return First.getBeginLoc();
 }
 
 SourceLocation DesignatedInitExpr::getEndLoc() const {
   return getInit()->getEndLoc();
 }
 
 Expr *DesignatedInitExpr::getArrayIndex(const Designator& D) const {
-  assert(D.Kind == Designator::ArrayDesignator && "Requires array designator");
-  return getSubExpr(D.ArrayOrRange.Index + 1);
+  assert(D.isArrayDesignator() && "Requires array designator");
+  return getSubExpr(D.getFirstExprIndex() + 1);
 }
 
 Expr *DesignatedInitExpr::getArrayRangeStart(const Designator &D) const {
-  assert(D.Kind == Designator::ArrayRangeDesignator &&
-         "Requires array range designator");
-  return getSubExpr(D.ArrayOrRange.Index + 1);
+  assert(D.isArrayRangeDesignator() && "Requires array range designator");
+  return getSubExpr(D.getFirstExprIndex() + 1);
 }
 
 Expr *DesignatedInitExpr::getArrayRangeEnd(const Designator &D) const {
-  assert(D.Kind == Designator::ArrayRangeDesignator &&
-         "Requires array range designator");
-  return getSubExpr(D.ArrayOrRange.Index + 2);
+  assert(D.isArrayRangeDesignator() && "Requires array range designator");
+  return getSubExpr(D.getFirstExprIndex() + 2);
 }
 
 /// Replaces the designator at index @p Idx with the series
 /// of designators in [First, Last).
 void DesignatedInitExpr::ExpandDesignator(const ASTContext &C, unsigned Idx,
                                           const Designator *First,
                                           const Designator *Last) {
   unsigned NumNewDesignators = Last - First;

clang/lib/AST/StmtPrinter.cpp

for (unsigned i = 0, e = Node->getNumExprs(); i != e; ++i) {
     if (i) OS << ", ";
     PrintExpr(Node->getExpr(i));
   }
   OS << ")";
 }
 
 void StmtPrinter::VisitDesignatedInitExpr(DesignatedInitExpr *Node) {
   bool NeedsEquals = true;
-  for (const DesignatedInitExpr::Designator &D : Node->designators()) {
+  for (const Designator &D : Node->designators()) {
     if (D.isFieldDesignator()) {
       if (D.getDotLoc().isInvalid()) {
-        if (IdentifierInfo *II = D.getFieldName()) {
+        if (const IdentifierInfo *II = D.getFieldName()) {
           OS << II->getName() << ":";
           NeedsEquals = false;
         }
       } else {
         OS << "." << D.getFieldName()->getName();
       }
     } else {
       OS << "[";

clang/lib/AST/StmtProfile.cpp

void StmtProfiler::VisitInitListExpr(const InitListExpr *S) {
   }
 
   VisitExpr(S);
 }
 
 void StmtProfiler::VisitDesignatedInitExpr(const DesignatedInitExpr *S) {
   VisitExpr(S);
   ID.AddBoolean(S->usesGNUSyntax());
-  for (const DesignatedInitExpr::Designator &D : S->designators()) {
+  for (const Designator &D : S->designators()) {
     if (D.isFieldDesignator()) {
       ID.AddInteger(0);
       VisitName(D.getFieldName());
       continue;
     }
 
     if (D.isArrayDesignator()) {
       ID.AddInteger(1);

clang/lib/Index/IndexBody.cpp

bool VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
     const DeclarationNameInfo &Info = E->getNameInfo();
     const NestedNameSpecifier *NNS = E->getQualifier();
     return indexDependentReference(
         E, NNS->getAsType(), Info,
         [](const NamedDecl *D) { return !D->isCXXInstanceMember(); });
   }
 
   bool VisitDesignatedInitExpr(DesignatedInitExpr *E) {
-    for (DesignatedInitExpr::Designator &D : llvm::reverse(E->designators())) {
+    for (Designator &D : llvm::reverse(E->designators())) {
       if (D.isFieldDesignator() && D.getField())
         return IndexCtx.handleReference(D.getField(), D.getFieldLoc(), Parent,
                                         ParentDC, SymbolRoleSet(), {}, E);
     }
     return true;
   }
 
   bool VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
auto visitForm = [&](InitListExpr *Form) {
       for (Stmt *SubStmt : Form->children()) {
         if (!TraverseStmt(SubStmt, Q))
           return false;
       }
       return true;
     };
 
     auto visitSyntacticDesignatedInitExpr = [&](DesignatedInitExpr *E) -> bool {
-      for (DesignatedInitExpr::Designator &D : llvm::reverse(E->designators())) {
+      for (Designator &D : llvm::reverse(E->designators())) {
         if (D.isFieldDesignator() && D.getField())
           return IndexCtx.handleReference(D.getField(), D.getFieldLoc(),
                                           Parent, ParentDC, SymbolRoleSet(),
                                           {}, E);
       }
       return true;
     };
 

clang/lib/Parse/ParseInit.cpp

 //===--- ParseInit.cpp - Initializer Parsing ------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements initializer parsing as specified by C99 6.7.8.
 //
 //===----------------------------------------------------------------------===//
 
+#include "clang/AST/Designator.h"
 #include "clang/Basic/TokenKinds.h"
 #include "clang/Parse/ParseDiagnostic.h"
 #include "clang/Parse/Parser.h"
 #include "clang/Parse/RAIIObjectsForParser.h"
-#include "clang/Sema/Designator.h"
 #include "clang/Sema/Ownership.h"
 #include "clang/Sema/Scope.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallString.h"
 using namespace clang;
 
 
 /// MayBeDesignationStart - Return true if the current token might be the start
if (Tok.is(tok::identifier)) {
     assert(Tok.is(tok::colon) && "MayBeDesignationStart not working properly!");
     SourceLocation ColonLoc = ConsumeToken();
 
     Diag(NameLoc, diag::ext_gnu_old_style_field_designator)
       << FixItHint::CreateReplacement(SourceRange(NameLoc, ColonLoc),
                                       NewSyntax);
 
     Designation D;
-    D.AddDesignator(Designator::getField(FieldName, SourceLocation(), NameLoc));
+    D.AddDesignator(Designator::CreateFieldDesignator(
+        FieldName, SourceLocation(), NameLoc));
     PreferredType.enterDesignatedInitializer(
         Tok.getLocation(), DesignatorCompletion.PreferredBaseType, D);
     return Actions.ActOnDesignatedInitializer(D, ColonLoc, true,
                                               ParseInitializer());
   }
 
   // Desig - This is initialized when we see our first designator.  We may have
   // an objc message send with no designator, so we don't want to create this
if (Tok.is(tok::period)) {
                                        DesignatorCompletion.InitExprs, Desig);
         return ExprError();
       }
       if (Tok.isNot(tok::identifier)) {
         Diag(Tok.getLocation(), diag::err_expected_field_designator);
         return ExprError();
       }
 
-      Desig.AddDesignator(Designator::getField(Tok.getIdentifierInfo(), DotLoc,
-                                               Tok.getLocation()));
+      Desig.AddDesignator(Designator::CreateFieldDesignator(
+          Tok.getIdentifierInfo(), DotLoc, Tok.getLocation()));
       ConsumeToken(); // Eat the identifier.
       continue;
     }
 
     // We must have either an array designator now or an objc message send.
     assert(Tok.is(tok::l_square) && "Unexpected token!");
 
     // Handle the two forms of array designator:
if (getLangOpts().ObjC && Tok.isNot(tok::ellipsis) &&
         Tok.isNot(tok::r_square)) {
       CheckArrayDesignatorSyntax(*this, Tok.getLocation(), Desig);
       return ParseAssignmentExprWithObjCMessageExprStart(
           StartLoc, SourceLocation(), nullptr, Idx.get());
     }
 
     // If this is a normal array designator, remember it.
     if (Tok.isNot(tok::ellipsis)) {
-      Desig.AddDesignator(Designator::getArray(Idx.get(), StartLoc));
+      Desig.AddDesignator(
+          Designator::CreateArrayDesignator(Idx.get(), StartLoc));
     } else {
       // Handle the gnu array range extension.
       Diag(Tok, diag::ext_gnu_array_range);
       SourceLocation EllipsisLoc = ConsumeToken();
 
       ExprResult RHS(ParseConstantExpression());
       if (RHS.isInvalid()) {
         SkipUntil(tok::r_square, StopAtSemi);
         return RHS;
       }
-      Desig.AddDesignator(Designator::getArrayRange(Idx.get(),
-                                                    RHS.get(),
-                                                    StartLoc, EllipsisLoc));
+      Desig.AddDesignator(Designator::CreateArrayRangeDesignator(
+          Idx.get(), RHS.get(), StartLoc, EllipsisLoc));
     }
 
     T.consumeClose();
     Desig.getDesignator(Desig.getNumDesignators() - 1).setRBracketLoc(
                                                         T.getCloseLocation());
   }
 
   // Okay, we're done with the designator sequence.  We know that there must be

clang/lib/Sema/SemaCodeComplete.cpp

 //
 //===----------------------------------------------------------------------===//
 #include "clang/AST/ASTConcept.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclBase.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/DeclTemplate.h"
+#include "clang/AST/Designator.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/ExprConcepts.h"
 #include "clang/AST/ExprObjC.h"
 #include "clang/AST/NestedNameSpecifier.h"
 #include "clang/AST/QualTypeNames.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/AST/Type.h"
 #include "clang/Basic/AttributeCommonInfo.h"
 #include "clang/Basic/CharInfo.h"
 #include "clang/Basic/OperatorKinds.h"
 #include "clang/Basic/Specifiers.h"
 #include "clang/Lex/HeaderSearch.h"
 #include "clang/Lex/MacroInfo.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Sema/CodeCompleteConsumer.h"
 #include "clang/Sema/DeclSpec.h"
-#include "clang/Sema/Designator.h"
 #include "clang/Sema/Lookup.h"
 #include "clang/Sema/Overload.h"
 #include "clang/Sema/ParsedAttr.h"
 #include "clang/Sema/ParsedTemplate.h"
 #include "clang/Sema/Scope.h"
 #include "clang/Sema/ScopeInfo.h"
 #include "clang/Sema/Sema.h"
 #include "clang/Sema/SemaInternal.h"

 static std::optional<unsigned>
 getNextAggregateIndexAfterDesignatedInit(const ResultCandidate &Aggregate,
                                          ArrayRef<Expr *> Args) {
   static constexpr unsigned Invalid = std::numeric_limits<unsigned>::max();
   assert(Aggregate.getKind() == ResultCandidate::CK_Aggregate);
 
   // Look for designated initializers.
   // They're in their syntactic form, not yet resolved to fields.
-  IdentifierInfo *DesignatedFieldName = nullptr;
+  const IdentifierInfo *DesignatedFieldName = nullptr;
   unsigned ArgsAfterDesignator = 0;
   for (const Expr *Arg : Args) {
     if (const auto *DIE = dyn_cast<DesignatedInitExpr>(Arg)) {
       if (DIE->size() == 1 && DIE->getDesignator(0)->isFieldDesignator()) {
         DesignatedFieldName = DIE->getDesignator(0)->getFieldName();
         ArgsAfterDesignator = 0;
       } else {
         return Invalid; // Complicated designator.
for (unsigned I = 0; I < Desig.getNumDesignators(); ++I) {
     const auto &D = Desig.getDesignator(I);
     if (D.isArrayDesignator() || D.isArrayRangeDesignator()) {
       if (BaseType->isArrayType())
         NextType = BaseType->getAsArrayTypeUnsafe()->getElementType();
     } else {
       assert(D.isFieldDesignator());
       auto *RD = getAsRecordDecl(BaseType);
       if (RD && RD->isCompleteDefinition()) {
-        for (const auto *Member : RD->lookup(D.getField()))
+        for (const auto *Member : RD->lookup(D.getFieldName()))
           if (const FieldDecl *FD = llvm::dyn_cast<FieldDecl>(Member)) {
             NextType = FD->getType();
             break;
           }
       }
     }
     BaseType = NextType;
   }

clang/lib/Sema/SemaExpr.cpp

 #include "UsedDeclVisitor.h"
 #include "clang/AST/ASTConsumer.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTLambda.h"
 #include "clang/AST/ASTMutationListener.h"
 #include "clang/AST/CXXInheritance.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/DeclTemplate.h"
+#include "clang/AST/Designator.h"
 #include "clang/AST/EvaluatedExprVisitor.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/ExprObjC.h"
 #include "clang/AST/ExprOpenMP.h"
 #include "clang/AST/OperationKinds.h"
 #include "clang/AST/ParentMapContext.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/AST/Type.h"
 #include "clang/AST/TypeLoc.h"
 #include "clang/Basic/Builtins.h"
 #include "clang/Basic/DiagnosticSema.h"
 #include "clang/Basic/PartialDiagnostic.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/Specifiers.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Lex/LiteralSupport.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Sema/AnalysisBasedWarnings.h"
 #include "clang/Sema/DeclSpec.h"
 #include "clang/Sema/DelayedDiagnostic.h"
-#include "clang/Sema/Designator.h"
 #include "clang/Sema/Initialization.h"
 #include "clang/Sema/Lookup.h"
 #include "clang/Sema/Overload.h"
 #include "clang/Sema/ParsedTemplate.h"
 #include "clang/Sema/Scope.h"
 #include "clang/Sema/ScopeInfo.h"
 #include "clang/Sema/SemaFixItUtils.h"
 #include "clang/Sema/SemaInternal.h"

clang/lib/Sema/SemaInit.cpp

 //===--- SemaInit.cpp - Semantic Analysis for Initializers ----------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements semantic analysis for initializers.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/DeclObjC.h"
+#include "clang/AST/Designator.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/ExprObjC.h"
 #include "clang/AST/ExprOpenMP.h"
 #include "clang/AST/TypeLoc.h"
 #include "clang/Basic/CharInfo.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/TargetInfo.h"
-#include "clang/Sema/Designator.h"
 #include "clang/Sema/Initialization.h"
 #include "clang/Sema/Lookup.h"
 #include "clang/Sema/SemaInternal.h"
 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"

 /// Expand a field designator that refers to a member of an
 /// anonymous struct or union into a series of field designators that
 /// refers to the field within the appropriate subobject.
 ///
 static void ExpandAnonymousFieldDesignator(Sema &SemaRef,
                                            DesignatedInitExpr *DIE,
                                            unsigned DesigIdx,
                                            IndirectFieldDecl *IndirectField) {
-  typedef DesignatedInitExpr::Designator Designator;
-
   // Build the replacement designators.
   SmallVector<Designator, 4> Replacements;
   for (IndirectFieldDecl::chain_iterator PI = IndirectField->chain_begin(),
        PE = IndirectField->chain_end(); PI != PE; ++PI) {
     if (PI + 1 == PE)
-      Replacements.push_back(Designator((IdentifierInfo *)nullptr,
-                                    DIE->getDesignator(DesigIdx)->getDotLoc(),
-                                DIE->getDesignator(DesigIdx)->getFieldLoc()));
+      Replacements.push_back(Designator::CreateFieldDesignator(
+          nullptr, DIE->getDesignator(DesigIdx)->getDotLoc(),
     else
-      Replacements.push_back(Designator((IdentifierInfo *)nullptr,
-                                        SourceLocation(), SourceLocation()));
+      Replacements.push_back(Designator::CreateFieldDesignator(
+          nullptr, SourceLocation(), SourceLocation()));
     assert(isa<FieldDecl>(*PI));
     Replacements.back().setField(cast<FieldDecl>(*PI));
   }
 
   // Expand the current designator into the set of replacement
   // designators, so we have a full subobject path down to where the
   // member of the anonymous struct/union is actually stored.
   DIE->ExpandDesignator(SemaRef.Context, DesigIdx, &Replacements[0],
if (DesigIdx == DIE->size()) {
     // form of the initializer list.
     if (IList->getInit(OldIndex) != DIE->getInit())
       DIE->setInit(IList->getInit(OldIndex));
     IList->setInit(OldIndex, DIE);
 
     return hadError && !prevHadError;
   }
 
-  DesignatedInitExpr::Designator *D = DIE->getDesignator(DesigIdx);
+  Designator *D = DIE->getDesignator(DesigIdx);
   bool IsFirstDesignator = (DesigIdx == 0);
   if (IsFirstDesignator ? FullyStructuredList : StructuredList) {
     // Determine the structural initializer list that corresponds to the
     // current subobject.
     if (IsFirstDesignator)
       StructuredList = FullyStructuredList;
     else {
       Expr *ExistingInit = StructuredIndex < StructuredList->getNumInits() ?
if (!RT) {
         SemaRef.Diag(Loc, diag::err_field_designator_non_aggr)
           << SemaRef.getLangOpts().CPlusPlus << CurrentObjectType;
       ++Index;
       return true;
     }
 
     FieldDecl *KnownField = D->getField();
     if (!KnownField) {
-      IdentifierInfo *FieldName = D->getFieldName();
+      const IdentifierInfo *FieldName = D->getFieldName();
       DeclContext::lookup_result Lookup = RT->getDecl()->lookup(FieldName);
       for (NamedDecl *ND : Lookup) {
         if (auto *FD = dyn_cast<FieldDecl>(ND)) {
           KnownField = FD;
           break;
         }
         if (auto *IFD = dyn_cast<IndirectFieldDecl>(ND)) {
           // In verify mode, don't modify the original.
if (D->isFieldDesignator()) {
 
     // This designator names a flexible array member.
     if (Field->getType()->isIncompleteArrayType()) {
       bool Invalid = false;
       if ((DesigIdx + 1) != DIE->size()) {
         // We can't designate an object within the flexible array
         // member (because GCC doesn't allow it).
         if (!VerifyOnly) {
-          DesignatedInitExpr::Designator *NextD
-            = DIE->getDesignator(DesigIdx + 1);
+          Designator *NextD = DIE->getDesignator(DesigIdx + 1);
           SemaRef.Diag(NextD->getBeginLoc(),
                        diag::err_designator_into_flexible_array_member)
               << SourceRange(NextD->getBeginLoc(), DIE->getEndLoc());
           SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member)
             << *Field;
         }
         Invalid = true;
       }
return S.Diag(Loc, diag::err_array_designator_negative)
            << toString(Value, 10) << Index->getSourceRange();
 
   Value.setIsUnsigned(true);
   return Result;
 }
 
 ExprResult Sema::ActOnDesignatedInitializer(Designation &Desig,
                                             SourceLocation EqualOrColonLoc,
-                                            bool GNUSyntax,
-                                            ExprResult Init) {
-  typedef DesignatedInitExpr::Designator ASTDesignator;
-
+                                            bool GNUSyntax, ExprResult Init) {
   bool Invalid = false;
-  SmallVector<ASTDesignator, 32> Designators;
+  SmallVector<Designator, 32> Designators;
   SmallVector<Expr *, 32> InitExpressions;
 
   // Build designators and check array designator expressions.
   for (unsigned Idx = 0; Idx < Desig.getNumDesignators(); ++Idx) {
     const Designator &D = Desig.getDesignator(Idx);
-    switch (D.getKind()) {
-    case Designator::FieldDesignator:
-      Designators.push_back(ASTDesignator(D.getField(), D.getDotLoc(),
-                                          D.getFieldLoc()));
-      break;
 
-    case Designator::ArrayDesignator: {
+    if (D.isFieldDesignator()) {
+      Designators.push_back(Designator::CreateFieldDesignator(
+          D.getFieldName(), D.getDotLoc(), D.getFieldLoc()));
+    } else if (D.isArrayDesignator()) {
       Expr *Index = static_cast<Expr *>(D.getArrayIndex());
       llvm::APSInt IndexValue;
+
       if (!Index->isTypeDependent() && !Index->isValueDependent())
         Index = CheckArrayDesignatorExpr(*this, Index, IndexValue).get();
       if (!Index)
         Invalid = true;
       else {
-        Designators.push_back(ASTDesignator(InitExpressions.size(),
-                                            D.getLBracketLoc(),
-                                            D.getRBracketLoc()));
+        Designators.push_back(Designator::CreateArrayDesignator(
+            InitExpressions.size(), D.getLBracketLoc(), D.getRBracketLoc()));
         InitExpressions.push_back(Index);
       }
-      break;
-    }
-
-    case Designator::ArrayRangeDesignator: {
+    } else if (D.isArrayRangeDesignator()) {
       Expr *StartIndex = static_cast<Expr *>(D.getArrayRangeStart());
       Expr *EndIndex = static_cast<Expr *>(D.getArrayRangeEnd());
       llvm::APSInt StartValue;
       llvm::APSInt EndValue;
       bool StartDependent = StartIndex->isTypeDependent() ||
                             StartIndex->isValueDependent();
       bool EndDependent = EndIndex->isTypeDependent() ||
                           EndIndex->isValueDependent();
+
       if (!StartDependent)
         StartIndex =
             CheckArrayDesignatorExpr(*this, StartIndex, StartValue).get();
+
       if (!EndDependent)
         EndIndex = CheckArrayDesignatorExpr(*this, EndIndex, EndValue).get();
 
       if (!StartIndex || !EndIndex)
         Invalid = true;
       else {
         // Make sure we're comparing values with the same bit width.
         if (StartDependent || EndDependent) {
           // Nothing to compute.
         } else if (StartValue.getBitWidth() > EndValue.getBitWidth())
           EndValue = EndValue.extend(StartValue.getBitWidth());
         else if (StartValue.getBitWidth() < EndValue.getBitWidth())
           StartValue = StartValue.extend(EndValue.getBitWidth());
 
         if (!StartDependent && !EndDependent && EndValue < StartValue) {
           Diag(D.getEllipsisLoc(), diag::err_array_designator_empty_range)
             << toString(StartValue, 10) << toString(EndValue, 10)
             << StartIndex->getSourceRange() << EndIndex->getSourceRange();
           Invalid = true;
         } else {
-          Designators.push_back(ASTDesignator(InitExpressions.size(),
-                                              D.getLBracketLoc(),
-                                              D.getEllipsisLoc(),
-                                              D.getRBracketLoc()));
+          Designators.push_back(Designator::CreateArrayRangeDesignator(
+              InitExpressions.size(), D.getLBracketLoc(), D.getEllipsisLoc(),
           InitExpressions.push_back(StartIndex);
           InitExpressions.push_back(EndIndex);
         }
       }
-      break;
-    }
     }
   }
 
   if (Invalid || Init.isInvalid())
     return ExprError();
 
-  // Clear out the expressions within the designation.
-  Desig.ClearExprs(*this);
-
   return DesignatedInitExpr::Create(Context, Designators, InitExpressions,
                                     EqualOrColonLoc, GNUSyntax,
                                     Init.getAs<Expr>());
 }
 
 //===----------------------------------------------------------------------===//
 // Initialization entity
 //===----------------------------------------------------------------------===//

clang/lib/Sema/TreeTransform.h

 #ifndef LLVM_CLANG_LIB_SEMA_TREETRANSFORM_H
 #define LLVM_CLANG_LIB_SEMA_TREETRANSFORM_H
 
 #include "CoroutineStmtBuilder.h"
 #include "TypeLocBuilder.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/DeclTemplate.h"
+#include "clang/AST/Designator.h"
 #include "clang/AST/Expr.h"
-#include "clang/AST/ExprConcepts.h"
 #include "clang/AST/ExprCXX.h"
+#include "clang/AST/ExprConcepts.h"
 #include "clang/AST/ExprObjC.h"
 #include "clang/AST/ExprOpenMP.h"
 #include "clang/AST/OpenMPClause.h"
 #include "clang/AST/Stmt.h"
 #include "clang/AST/StmtCXX.h"
 #include "clang/AST/StmtObjC.h"
 #include "clang/AST/StmtOpenMP.h"
 #include "clang/Basic/DiagnosticParse.h"
 #include "clang/Basic/OpenMPKinds.h"
-#include "clang/Sema/Designator.h"
 #include "clang/Sema/Lookup.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"
TreeTransform<Derived>::TransformDesignatedInitExpr(DesignatedInitExpr *E) {
   // transform the initializer value
   ExprResult Init = getDerived().TransformExpr(E->getInit());
   if (Init.isInvalid())
     return ExprError();
 
   // transform the designators.
   SmallVector<Expr*, 4> ArrayExprs;
   bool ExprChanged = false;
-  for (const DesignatedInitExpr::Designator &D : E->designators()) {
+  for (const Designator &D : E->designators()) {
     if (D.isFieldDesignator()) {
-      Desig.AddDesignator(Designator::getField(D.getFieldName(),
-                                               D.getDotLoc(),
-                                               D.getFieldLoc()));
+      Desig.AddDesignator(Designator::CreateFieldDesignator(
+          D.getFieldName(), D.getDotLoc(), D.getFieldLoc()));
       if (D.getField()) {
         FieldDecl *Field = cast_or_null<FieldDecl>(
             getDerived().TransformDecl(D.getFieldLoc(), D.getField()));
         if (Field != D.getField())
           // Rebuild the expression when the transformed FieldDecl is
           // different to the already assigned FieldDecl.
           ExprChanged = true;
       } else {
         // Ensure that the designator expression is rebuilt when there isn't
         // a resolved FieldDecl in the designator as we don't want to assign
         // a FieldDecl to a pattern designator that will be instantiated again.
         ExprChanged = true;
       }
       continue;
     }
 
     if (D.isArrayDesignator()) {
       ExprResult Index = getDerived().TransformExpr(E->getArrayIndex(D));
       if (Index.isInvalid())
         return ExprError();
 
       Desig.AddDesignator(
-          Designator::getArray(Index.get(), D.getLBracketLoc()));
+          Designator::CreateArrayDesignator(Index.get(), D.getLBracketLoc()));
 
       ExprChanged = ExprChanged || Init.get() != E->getArrayIndex(D);
       ArrayExprs.push_back(Index.get());
       continue;
     }
 
     assert(D.isArrayRangeDesignator() && "New kind of designator?");
     ExprResult Start
       = getDerived().TransformExpr(E->getArrayRangeStart(D));
     if (Start.isInvalid())
       return ExprError();
 
     ExprResult End = getDerived().TransformExpr(E->getArrayRangeEnd(D));
     if (End.isInvalid())
       return ExprError();
 
-    Desig.AddDesignator(Designator::getArrayRange(Start.get(),
-                                                  End.get(),
-                                                  D.getLBracketLoc(),
-                                                  D.getEllipsisLoc()));
+    Desig.AddDesignator(Designator::CreateArrayRangeDesignator(
+        Start.get(), End.get(), D.getLBracketLoc(), D.getEllipsisLoc()));
 
     ExprChanged = ExprChanged || Start.get() != E->getArrayRangeStart(D) ||
                   End.get() != E->getArrayRangeEnd(D);
 
     ArrayExprs.push_back(Start.get());
     ArrayExprs.push_back(End.get());
   }
 

clang/lib/Serialization/ASTReaderStmt.cpp

if (isArrayFiller) {
     }
   } else {
     for (unsigned I = 0; I != NumInits; ++I)
       E->updateInit(Record.getContext(), I, Record.readSubExpr());
   }
 }
 
 void ASTStmtReader::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
-  using Designator = DesignatedInitExpr::Designator;
-
   VisitExpr(E);
   unsigned NumSubExprs = Record.readInt();
   assert(NumSubExprs == E->getNumSubExprs() && "Wrong number of subexprs");
   for (unsigned I = 0; I != NumSubExprs; ++I)
     E->setSubExpr(I, Record.readSubExpr());
   E->setEqualOrColonLoc(readSourceLocation());
   E->setGNUSyntax(Record.readInt());
 
   SmallVector<Designator, 4> Designators;
   while (Record.getIdx() < Record.size()) {
     switch ((DesignatorTypes)Record.readInt()) {
     case DESIG_FIELD_DECL: {
       auto *Field = readDeclAs<FieldDecl>();
       SourceLocation DotLoc = readSourceLocation();
       SourceLocation FieldLoc = readSourceLocation();
-      Designators.push_back(Designator(Field->getIdentifier(), DotLoc,
-                                       FieldLoc));
+      Designators.push_back(Designator::CreateFieldDesignator(
+          Field->getIdentifier(), DotLoc, FieldLoc));
       Designators.back().setField(Field);
       break;
     }
 
     case DESIG_FIELD_NAME: {
       const IdentifierInfo *Name = Record.readIdentifier();
       SourceLocation DotLoc = readSourceLocation();
       SourceLocation FieldLoc = readSourceLocation();
-      Designators.push_back(Designator(Name, DotLoc, FieldLoc));
+      Designators.push_back(
+          Designator::CreateFieldDesignator(Name, DotLoc, FieldLoc));
       break;
     }
 
     case DESIG_ARRAY: {
       unsigned Index = Record.readInt();
       SourceLocation LBracketLoc = readSourceLocation();
       SourceLocation RBracketLoc = readSourceLocation();
-      Designators.push_back(Designator(Index, LBracketLoc, RBracketLoc));
+      Designators.push_back(
+          Designator::CreateArrayDesignator(Index, LBracketLoc, RBracketLoc));
       break;
     }
 
     case DESIG_ARRAY_RANGE: {
       unsigned Index = Record.readInt();
       SourceLocation LBracketLoc = readSourceLocation();
       SourceLocation EllipsisLoc = readSourceLocation();
       SourceLocation RBracketLoc = readSourceLocation();
-      Designators.push_back(Designator(Index, LBracketLoc, EllipsisLoc,
-                                       RBracketLoc));
+      Designators.push_back(Designator::CreateArrayRangeDesignator(
+          Index, LBracketLoc, EllipsisLoc, RBracketLoc));
       break;
     }
     }
   }
   E->setDesignators(Record.getContext(),
                     Designators.data(), Designators.size());
 }
 

clang/lib/Serialization/ASTWriterStmt.cpp

 
 void ASTStmtWriter::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
   VisitExpr(E);
   Record.push_back(E->getNumSubExprs());
   for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I)
     Record.AddStmt(E->getSubExpr(I));
   Record.AddSourceLocation(E->getEqualOrColonLoc());
   Record.push_back(E->usesGNUSyntax());
-  for (const DesignatedInitExpr::Designator &D : E->designators()) {
+  for (const Designator &D : E->designators()) {
     if (D.isFieldDesignator()) {
       if (FieldDecl *Field = D.getField()) {
         Record.push_back(serialization::DESIG_FIELD_DECL);
         Record.AddDeclRef(Field);
       } else {
         Record.push_back(serialization::DESIG_FIELD_NAME);
         Record.AddIdentifierRef(D.getFieldName());
       }

clang/lib/Tooling/Refactoring/Rename/USRLocFinder.cpp

if (isInUSRSet(Decl)) {
                             /*Context=*/nullptr,
                             /*Specifier=*/nullptr,
                             /*IgnorePrefixQualifiers=*/true});
     }
     return true;
   }
 
   bool VisitDesignatedInitExpr(const DesignatedInitExpr *E) {
-    for (const DesignatedInitExpr::Designator &D : E->designators()) {
+    for (const Designator &D : E->designators()) {
       if (D.isFieldDesignator() && D.getField()) {
         const FieldDecl *Decl = D.getField();
         if (isInUSRSet(Decl)) {
           auto StartLoc = D.getFieldLoc();
           auto EndLoc = D.getFieldLoc();
           RenameInfos.push_back({StartLoc, EndLoc,
                                  /*FromDecl=*/nullptr,
                                  /*Context=*/nullptr,

clang/tools/libclang/CIndex.cpp

if (size == WL.size())
     return;
   // Now reverse the entries we just added.  This will match the DFS
   // ordering performed by the worklist.
   VisitorWorkList::iterator I = WL.begin() + size, E = WL.end();
   std::reverse(I, E);
 }
 void EnqueueVisitor::VisitDesignatedInitExpr(const DesignatedInitExpr *E) {
   AddStmt(E->getInit());
-  for (const DesignatedInitExpr::Designator &D :
-       llvm::reverse(E->designators())) {
+  for (const Designator &D : llvm::reverse(E->designators())) {
     if (D.isFieldDesignator()) {
       if (FieldDecl *Field = D.getField())
         AddMemberRef(Field, D.getFieldLoc());
       continue;
     }
     if (D.isArrayDesignator()) {
       AddStmt(E->getArrayIndex(D));
       continue;