[Clang][NFC] Rename methods/vars to reflect their real usage

[void]

Summary

The "getField" method is a bit confusing considering we also have a
"getFieldName" method. Instead, use "getFieldDecl" rather than
"getField".

[void]

Fix compilation issue.

[void]

Friendly ping.

[void]

Reformat.

[aaron.ballman]

LGTM!

[shafik]

clang/lib/Index/IndexBody.cpp

426

nit

[void]

Add comment.

clang-tools-extra/clangd/FindTarget.cpp

struct Visitor : public ConstStmtVisitor<Visitor> {
       }
       void VisitCXXConstructExpr(const CXXConstructExpr *CCE) {
         Outer.add(CCE->getConstructor(), Flags);
       }
       void VisitDesignatedInitExpr(const DesignatedInitExpr *DIE) {
         for (const DesignatedInitExpr::Designator &D :
              llvm::reverse(DIE->designators()))
           if (D.isFieldDesignator()) {
-            Outer.add(D.getField(), Flags);
+            Outer.add(D.getFieldDecl(), Flags);
             // We don't know which designator was intended, we assume the outer.
             break;
           }
       }
       void VisitGotoStmt(const GotoStmt *Goto) {
         if (auto *LabelDecl = Goto->getLabel())
           Outer.add(LabelDecl, Flags);
       }
struct Visitor : ConstStmtVisitor<Visitor> {
     void VisitDesignatedInitExpr(const DesignatedInitExpr *DIE) {
       for (const DesignatedInitExpr::Designator &D : DIE->designators()) {
         if (!D.isFieldDesignator())
           continue;
 
         Refs.push_back(ReferenceLoc{NestedNameSpecifierLoc(),
                                     D.getFieldLoc(),
                                     /*IsDecl=*/false,
-                                    {D.getField()}});
+                                    {D.getFieldDecl()}});
       }
     }
 
     void VisitGotoStmt(const GotoStmt *GS) {
       Refs.push_back(ReferenceLoc{NestedNameSpecifierLoc(),
                                   GS->getLabelLoc(),
                                   /*IsDecl=*/false,
                                   {GS->getLabel()}});

clang-tools-extra/clangd/XRefs.cpp

struct Visitor : ConstStmtVisitor<Visitor, QualType> {
       QualType VisitCoyieldExpr(const CoyieldExpr *S) {
         return type(S->getOperand());
       }
       // Treat a designated initializer like a reference to the field.
       QualType VisitDesignatedInitExpr(const DesignatedInitExpr *S) {
         // In .foo.bar we want to jump to bar's type, so find *last* field.
         for (auto &D : llvm::reverse(S->designators()))
           if (D.isFieldDesignator())
-            if (const auto *FD = D.getField())
+            if (const auto *FD = D.getFieldDecl())
               return FD->getType();
         return QualType();
       }
 
       // Control flow statements that operate on data: use the data type.
       QualType VisitSwitchStmt(const SwitchStmt *S) {
         return type(S->getCond());
       }

clang/include/clang/AST/Expr.h

public:
 
     bool isFieldDesignator() const { return Kind == FieldDesignator; }
     bool isArrayDesignator() const { return Kind == ArrayDesignator; }
     bool isArrayRangeDesignator() const { return Kind == ArrayRangeDesignator; }
 
     //===------------------------------------------------------------------===//
     // FieldDesignatorInfo
 
-    /// Initializes a field designator.
+    /// Creates a field designator.
     static Designator CreateFieldDesignator(const IdentifierInfo *FieldName,
                                             SourceLocation DotLoc,
                                             SourceLocation FieldLoc) {
       Designator D(FieldDesignator);
       new (&D.FieldInfo) FieldDesignatorInfo(FieldName, DotLoc, FieldLoc);
       return D;
     }
 
     const IdentifierInfo *getFieldName() const;
 
-    FieldDecl *getField() const {
+    FieldDecl *getFieldDecl() const {
       assert(isFieldDesignator() && "Only valid on a field designator");
       if (FieldInfo.NameOrField & 0x01)
         return nullptr;
-      else
-        return reinterpret_cast<FieldDecl *>(FieldInfo.NameOrField);
     }
 
-    void setField(FieldDecl *FD) {
+    void setFieldDecl(FieldDecl *FD) {
       assert(isFieldDesignator() && "Only valid on a field designator");
       FieldInfo.NameOrField = reinterpret_cast<uintptr_t>(FD);
     }
 
     SourceLocation getDotLoc() const {
       assert(isFieldDesignator() && "Only valid on a field designator");
       return FieldInfo.DotLoc;
     }
 
     SourceLocation getFieldLoc() const {
       assert(isFieldDesignator() && "Only valid on a field designator");
       return FieldInfo.FieldLoc;
     }
 
     //===------------------------------------------------------------------===//
     // ArrayOrRangeDesignator
 
-    /// Initializes an array designator.
+    /// Creates an array designator.
     static Designator CreateArrayDesignator(unsigned Index,
                                             SourceLocation LBracketLoc,
                                             SourceLocation RBracketLoc) {
       Designator D(ArrayDesignator);
       new (&D.ArrayOrRangeInfo) ArrayOrRangeDesignatorInfo(Index, LBracketLoc,
                                                            RBracketLoc);
       return D;
     }
 
-    /// Initializes a GNU array-range designator.
+    /// Creates a GNU array-range designator.
     static Designator CreateArrayRangeDesignator(unsigned Index,
                                                  SourceLocation LBracketLoc,
                                                  SourceLocation EllipsisLoc,
                                                  SourceLocation RBracketLoc) {
       Designator D(ArrayRangeDesignator);
       new (&D.ArrayOrRangeInfo) ArrayOrRangeDesignatorInfo(Index, LBracketLoc,
                                                            EllipsisLoc,
                                                            RBracketLoc);
public:
     }
 
     SourceLocation getRBracketLoc() const {
       assert((isArrayDesignator() || isArrayRangeDesignator()) &&
              "Only valid on an array or array-range designator");
       return ArrayOrRangeInfo.RBracketLoc;
     }
 
-    unsigned xgetFirstExprIndex() const {
-      assert((isArrayDesignator() || isArrayRangeDesignator()) &&
-             "Only valid on an array or array-range designator");
-      return ArrayOrRangeInfo.Index;
-    }
-
     SourceLocation getBeginLoc() const LLVM_READONLY {
       if (isFieldDesignator())
         return getDotLoc().isInvalid() ? getFieldLoc() : getDotLoc();
       return getLBracketLoc();
     }
 
     SourceLocation getEndLoc() const LLVM_READONLY {
       return isFieldDesignator() ? getFieldLoc() : getRBracketLoc();

clang/include/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 {
   /// A field designator, e.g., ".x = 42".
   struct FieldDesignatorInfo {
     /// Refers to the field being initialized.
-    const IdentifierInfo *II;
+    const IdentifierInfo *FieldName;
 
     /// The location of the '.' in the designated initializer.
     SourceLocation DotLoc;
 
     /// The location of the field name in the designated initializer.
-    SourceLocation NameLoc;
+    SourceLocation FieldLoc;
 
-    FieldDesignatorInfo(const IdentifierInfo *II, SourceLocation DotLoc,
-                        SourceLocation NameLoc)
-        : II(II), DotLoc(DotLoc), NameLoc(NameLoc) {}
+    FieldDesignatorInfo(const IdentifierInfo *FieldName, SourceLocation DotLoc,
+                        SourceLocation FieldLoc)
+        : FieldName(FieldName), DotLoc(DotLoc), FieldLoc(FieldLoc) {}
   };
 
   /// An array designator, e.g., "[42] = 0".
   struct ArrayDesignatorInfo {
     Expr *Index;
 
     // The location of the '[' in the designated initializer.
     SourceLocation LBracketLoc;

 public:
   bool isFieldDesignator() const { return Kind == FieldDesignator; }
   bool isArrayDesignator() const { return Kind == ArrayDesignator; }
   bool isArrayRangeDesignator() const { return Kind == ArrayRangeDesignator; }
 
   //===--------------------------------------------------------------------===//
   // FieldDesignatorInfo
 
-  static Designator CreateFieldDesignator(const IdentifierInfo *II,
+  /// Creates a field designator.
+  static Designator CreateFieldDesignator(const IdentifierInfo *FieldName,
                                           SourceLocation DotLoc,
-                                          SourceLocation NameLoc) {
+                                          SourceLocation FieldLoc) {
     Designator D(FieldDesignator);
-    new (&D.FieldInfo) FieldDesignatorInfo(II, DotLoc, NameLoc);
+    new (&D.FieldInfo) FieldDesignatorInfo(FieldName, DotLoc, FieldLoc);
     return D;
   }
 
-  const IdentifierInfo *getField() const {
+  const IdentifierInfo *getFieldDecl() const {
     assert(isFieldDesignator() && "Invalid accessor");
-    return FieldInfo.II;
+    return FieldInfo.FieldName;
   }
 
   SourceLocation getDotLoc() const {
     assert(isFieldDesignator() && "Invalid accessor");
     return FieldInfo.DotLoc;
   }
 
   SourceLocation getFieldLoc() const {
     assert(isFieldDesignator() && "Invalid accessor");
-    return FieldInfo.NameLoc;
+    return FieldInfo.FieldLoc;
   }
 
   //===--------------------------------------------------------------------===//
   // ArrayDesignatorInfo:
 
+  /// Creates an array designator.
   static Designator CreateArrayDesignator(Expr *Index,
                                           SourceLocation LBracketLoc) {
     Designator D(ArrayDesignator);
     new (&D.ArrayInfo) ArrayDesignatorInfo(Index, LBracketLoc);
     return D;
   }
 
   Expr *getArrayIndex() const {
assert((isArrayDesignator() || isArrayRangeDesignator()) &&
            "Invalid accessor");
     return isArrayDesignator() ? ArrayInfo.RBracketLoc
                                : ArrayRangeInfo.RBracketLoc;
   }
 
   //===--------------------------------------------------------------------===//
   // ArrayRangeDesignatorInfo:
 
+  /// Creates a GNU array-range designator.
   static Designator CreateArrayRangeDesignator(Expr *Start, Expr *End,
                                                SourceLocation LBracketLoc,
                                                SourceLocation EllipsisLoc) {
     Designator D(ArrayRangeDesignator);
     new (&D.ArrayRangeInfo)
         ArrayRangeDesignatorInfo(Start, End, LBracketLoc, EllipsisLoc);
     return D;
   }

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

if (NNS) {
       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()) {
-      if (D.isFieldDesignator() && D.getField()) {
-        const FieldDecl *Decl = D.getField();
+      if (D.isFieldDesignator()) {
+        if (const FieldDecl *Decl = D.getFieldDecl()) {
           if (!visit(Decl, D.getFieldLoc(), D.getFieldLoc()))
             return false;
         }
       }
+    }
     return true;
   }
 
 private:
   const SourceManager &SM;
   const LangOptions &LangOpts;
 
   bool visit(const NamedDecl *ND, SourceLocation BeginLoc,

clang/lib/AST/Expr.cpp

 //===----------------------------------------------------------------------===//
 //  DesignatedInitExpr
 //===----------------------------------------------------------------------===//
 
 const IdentifierInfo *DesignatedInitExpr::Designator::getFieldName() const {
   assert(isFieldDesignator() && "Only valid on a field designator");
   if (FieldInfo.NameOrField & 0x01)
     return reinterpret_cast<IdentifierInfo *>(FieldInfo.NameOrField & ~0x01);
-  return getField()->getIdentifier();
+  return 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(),

clang/lib/Index/IndexBody.cpp

bool VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
     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())) {
-      if (D.isFieldDesignator() && D.getField())
-        return IndexCtx.handleReference(D.getField(), D.getFieldLoc(), Parent,
+      if (D.isFieldDesignator()) {
+        if (const FieldDecl *FD = D.getFieldDecl()) {
+          return IndexCtx.handleReference(FD, D.getFieldLoc(), Parent,
                                           ParentDC, SymbolRoleSet(), {}, E);
         }
+      }
+    }
     return true;
   }
 
   bool VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
     SmallVector<SymbolRelation, 4> Relations;
     SymbolRoleSet Roles = getRolesForRef(E, Relations);
     return IndexCtx.handleReference(E->getDecl(), E->getLocation(),
                                     Parent, ParentDC, Roles, Relations, E);
auto visitForm = [&](InitListExpr *Form) {
         if (!TraverseStmt(SubStmt, Q))
           return false;
       }
       return true;
     };
 
     auto visitSyntacticDesignatedInitExpr = [&](DesignatedInitExpr *E) -> bool {
       for (DesignatedInitExpr::Designator &D : llvm::reverse(E->designators())) {
-        if (D.isFieldDesignator() && D.getField())
-          return IndexCtx.handleReference(D.getField(), D.getFieldLoc(),
-                                          Parent, ParentDC, SymbolRoleSet(),
-                                          {}, E);
+        if (D.isFieldDesignator()) {
+          if (const FieldDecl *FD = D.getFieldDecl()) {
+            return IndexCtx.handleReference(FD, D.getFieldLoc(), Parent,
+                                            ParentDC, SymbolRoleSet(),
+                                            /*Relations=*/{}, E);
+          }
+        }
       }
       return true;
     };
 
     InitListExpr *SemaForm = S->isSemanticForm() ? S : S->getSemanticForm();
     InitListExpr *SyntaxForm = S->isSemanticForm() ? S->getSyntacticForm() : S;
 
     if (SemaForm) {

clang/lib/Sema/SemaCodeComplete.cpp

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.getFieldDecl()))
           if (const FieldDecl *FD = llvm::dyn_cast<FieldDecl>(Member)) {
             NextType = FD->getType();
             break;
           }
       }
     }
     BaseType = NextType;
   }

clang/lib/Sema/SemaInit.cpp

for (IndirectFieldDecl::chain_iterator PI = IndirectField->chain_begin(),
     if (PI + 1 == PE)
       Replacements.push_back(Designator::CreateFieldDesignator(
           (IdentifierInfo *)nullptr, DIE->getDesignator(DesigIdx)->getDotLoc(),
           DIE->getDesignator(DesigIdx)->getFieldLoc()));
     else
       Replacements.push_back(Designator::CreateFieldDesignator(
           (IdentifierInfo *)nullptr, SourceLocation(), SourceLocation()));
     assert(isa<FieldDecl>(*PI));
-    Replacements.back().setField(cast<FieldDecl>(*PI));
+    Replacements.back().setFieldDecl(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],
                         &Replacements[0] + Replacements.size());
 }
if (!RT) {
         Loc = D->getFieldLoc();
       if (!VerifyOnly)
         SemaRef.Diag(Loc, diag::err_field_designator_non_aggr)
           << SemaRef.getLangOpts().CPlusPlus << CurrentObjectType;
       ++Index;
       return true;
     }
 
-    FieldDecl *KnownField = D->getField();
+    FieldDecl *KnownField = D->getFieldDecl();
     if (!KnownField) {
       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 (IsFirstDesignator && !VerifyOnly && SemaRef.getLangOpts().CPlusPlus &&
           }
         }
       }
     }
 
 
     // Update the designator with the field declaration.
     if (!VerifyOnly)
-      D->setField(*Field);
+      D->setFieldDecl(*Field);
 
     // Make sure that our non-designated initializer list has space
     // for a subobject corresponding to this field.
     if (StructuredList && FieldIndex >= StructuredList->getNumInits())
       StructuredList->resizeInits(SemaRef.Context, FieldIndex + 1);
 
     // This designator names a flexible array member.
     if (Field->getType()->isIncompleteArrayType()) {
ExprResult Sema::ActOnDesignatedInitializer(Designation &Desig,
   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);
 
     if (D.isFieldDesignator()) {
       Designators.push_back(ASTDesignator::CreateFieldDesignator(
-          D.getField(), D.getDotLoc(), D.getFieldLoc()));
+          D.getFieldDecl(), 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 {

clang/lib/Sema/TreeTransform.h

TreeTransform<Derived>::TransformDesignatedInitExpr(DesignatedInitExpr *E) {
 
   // transform the designators.
   SmallVector<Expr*, 4> ArrayExprs;
   bool ExprChanged = false;
   for (const DesignatedInitExpr::Designator &D : E->designators()) {
     if (D.isFieldDesignator()) {
       Desig.AddDesignator(Designator::CreateFieldDesignator(
           D.getFieldName(), D.getDotLoc(), D.getFieldLoc()));
-      if (D.getField()) {
+      if (D.getFieldDecl()) {
         FieldDecl *Field = cast_or_null<FieldDecl>(
-            getDerived().TransformDecl(D.getFieldLoc(), D.getField()));
-        if (Field != D.getField())
+            getDerived().TransformDecl(D.getFieldLoc(), D.getFieldDecl()));
+        if (Field != D.getFieldDecl())
           // 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;

clang/lib/Serialization/ASTReaderStmt.cpp

void ASTStmtReader::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
   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::CreateFieldDesignator(
           Field->getIdentifier(), DotLoc, FieldLoc));
-      Designators.back().setField(Field);
+      Designators.back().setFieldDecl(Field);
       break;
     }
 
     case DESIG_FIELD_NAME: {
       const IdentifierInfo *Name = Record.readIdentifier();
       SourceLocation DotLoc = readSourceLocation();
       SourceLocation FieldLoc = readSourceLocation();
       Designators.push_back(Designator::CreateFieldDesignator(Name, DotLoc,

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()) {
     if (D.isFieldDesignator()) {
-      if (FieldDecl *Field = D.getField()) {
+      if (FieldDecl *Field = D.getFieldDecl()) {
         Record.push_back(serialization::DESIG_FIELD_DECL);
         Record.AddDeclRef(Field);
       } else {
         Record.push_back(serialization::DESIG_FIELD_NAME);
         Record.AddIdentifierRef(D.getFieldName());
       }
       Record.AddSourceLocation(D.getDotLoc());
       Record.AddSourceLocation(D.getFieldLoc());

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

if (isInUSRSet(Decl)) {
                             /*Specifier=*/nullptr,
                             /*IgnorePrefixQualifiers=*/true});
     }
     return true;
   }
 
   bool VisitDesignatedInitExpr(const DesignatedInitExpr *E) {
     for (const DesignatedInitExpr::Designator &D : E->designators()) {
-      if (D.isFieldDesignator() && D.getField()) {
-        const FieldDecl *Decl = D.getField();
+      if (D.isFieldDesignator()) {
+        if (const FieldDecl *Decl = D.getFieldDecl()) {
           if (isInUSRSet(Decl)) {
             auto StartLoc = D.getFieldLoc();
             auto EndLoc = D.getFieldLoc();
             RenameInfos.push_back({StartLoc, EndLoc,
                                    /*FromDecl=*/nullptr,
                                    /*Context=*/nullptr,
                                    /*Specifier=*/nullptr,
                                    /*IgnorePrefixQualifiers=*/true});
           }
         }
       }
+    }
     return true;
   }
 
   bool VisitCXXConstructorDecl(const CXXConstructorDecl *CD) {
     // Fix the constructor initializer when renaming class members.
     for (const auto *Initializer : CD->inits()) {
       // Ignore implicit initializers.
       if (!Initializer->isWritten())

clang/tools/libclang/CIndex.cpp

void EnqueueVisitor::VisitDeclStmt(const DeclStmt *S) {
   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())) {
     if (D.isFieldDesignator()) {
-      if (FieldDecl *Field = D.getField())
+      if (const FieldDecl *Field = D.getFieldDecl())
         AddMemberRef(Field, D.getFieldLoc());
       continue;
     }
     if (D.isArrayDesignator()) {
       AddStmt(E->getArrayIndex(D));
       continue;
     }
     assert(D.isArrayRangeDesignator() && "Unknown designator kind");