[clang] Overload NamedDecl::printName to provide a user-friendly name for unnamed entities

[riccibruno]

Summary

See D84656 for the background on NamedDecl::printName.

This patch overloads NamedDecl::printName for VarDecl, FieldDecl ,RecordDecl and EnumDecl to provide a more user-friendly name in diagnostics for unnamed entities. We try to only use the term "anonymous" when we have an anonymous struct or union; otherwise we use the term "unnamed".

There is one little tweak we need to make to Sema::BuildAnonymousStructOrUnion: we mark the record as being anonymous as early as possible. This is to ensure that diagnostics emitted here will use the term "anonymous".

[erichkeane]

This seems like a strict improvement as well. That said, there are two opportunities to clean up the code that I suggest evaluating.

clang/lib/AST/Decl.cpp

2032

This pattern is happening a bunch too.... Does it deserve some function? Perhaps a function that either takes Policy, or a member of Policy to get the formatting open-tick or close-tick?

2074

It seems this entire block can be pulled out of these two functions. This is probably worth while?

It seems that in this function, it would be:

if (!SuppressLocation)

printLocation(....);

And in the other, just a call to PrintLocation(....).

[riccibruno]

clang/lib/AST/Decl.cpp

2032

Do you mean a member function of PrintingPolicy, something like getOpenTick and getCloseTick?

2074

Good point yes. I will do so.

[erichkeane]

clang/lib/AST/Decl.cpp

2032

Yeah, exactly, something like that. "Delimiter" is perhaps better than 'tick', but I'm not attached to either.

[riccibruno]

clang/lib/AST/Decl.cpp

2032

"Delimiter" sounds good to me. Thanks for the suggestion!

[aaron.ballman]

I think these changes are going in the right direction (and I agree with the feedback from Erich). Thank you for looking into this!

[riccibruno]

Address Erich's comments.

[riccibruno]

clang/lib/AST/Decl.cpp

2032

I will fix the other instances of this pattern elsewhere as a follow-up.

[riccibruno]

Note that I am planning two improvements as a follow-up to this patch:

• For a parameter (unnamed variable at {{.*}}:<line>:<col> of type <type>) -> (unnamed parameter at {{.*}}:<line>:<col> of type <type>)
• For a lambda:
  • (unnamed class at {{.*}}:<line>:<col>) -> (lambda at {{.*}}:<line>:<col>)
  • For a captured field in the lambda class: (unnamed field at {{.*}}:<line>:<col> of type <type>) -> something which refers to the captured entity instead of the unnamed field.

[aaron.ballman]

clang/include/clang/AST/PrettyPrinter.h

78

These names a bit too generic: open/close delimiter for *what* (there's a lot of paired delimiters to consider when pretty printing). Perhaps getUnnamedIdentOpenDelimiter() or something to make it more clear that this isn't, say, an attribute delimiter?

[riccibruno]

Use a less generic name instead of get{Open,Close}Delimiter. I went with get{Open,Close}DelimiterForUnnamedEntity but I am happy to change it.

[riccibruno]

Add the forgotten context.

[aaron.ballman]

LGTM, thanks!

[shafik]

It looks like some of these changes made it through different PRs but a lot of this is not in. It would be nice to get a updated version of this change.

clang/include/clang/AST/Decl.h

static VarDecl *Create(ASTContext &C, DeclContext *DC,
                          SourceLocation StartLoc, SourceLocation IdLoc,
                          IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo,
                          StorageClass S);
 
   static VarDecl *CreateDeserialized(ASTContext &C, unsigned ID);
 
   SourceRange getSourceRange() const override LLVM_READONLY;
 
+  void printName(raw_ostream &OS) const override;
+
   /// Returns the storage class as written in the source. For the
   /// computed linkage of symbol, see getLinkage.
   StorageClass getStorageClass() const {
     return (StorageClass) VarDeclBits.SClass;
   }
   void setStorageClass(StorageClass SC);
 
   void setTSCSpec(ThreadStorageClassSpecifier TSC) {
public:
   }
 
   RecordDecl *getParent() {
     return dyn_cast<RecordDecl>(getDeclContext());
   }
 
   SourceRange getSourceRange() const override LLVM_READONLY;
 
+  void printName(raw_ostream &OS) const override;
+
   /// Retrieves the canonical declaration of this field.
   FieldDecl *getCanonicalDecl() override { return getFirstDecl(); }
   const FieldDecl *getCanonicalDecl() const { return getFirstDecl(); }
 
   // Implement isa/cast/dyncast/etc.
   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
   static bool classofKind(Kind K) { return K >= firstField && K <= lastField; }
 };
public:
 
   static EnumDecl *Create(ASTContext &C, DeclContext *DC,
                           SourceLocation StartLoc, SourceLocation IdLoc,
                           IdentifierInfo *Id, EnumDecl *PrevDecl,
                           bool IsScoped, bool IsScopedUsingClassTag,
                           bool IsFixed);
   static EnumDecl *CreateDeserialized(ASTContext &C, unsigned ID);
 
+  void printName(raw_ostream &OS) const override;
+
   /// When created, the EnumDecl corresponds to a
   /// forward-declared enum. This method is used to mark the
   /// declaration as being defined; its enumerators have already been
   /// added (via DeclContext::addDecl). NewType is the new underlying
   /// type of the enumeration type.
   void completeDefinition(QualType NewType,
                           QualType PromotionType,
                           unsigned NumPositiveBits,
RecordDecl(Kind DK, TagKind TK, const ASTContext &C, DeclContext *DC,
              IdentifierInfo *Id, RecordDecl *PrevDecl);
 
 public:
   static RecordDecl *Create(const ASTContext &C, TagKind TK, DeclContext *DC,
                             SourceLocation StartLoc, SourceLocation IdLoc,
                             IdentifierInfo *Id, RecordDecl* PrevDecl = nullptr);
   static RecordDecl *CreateDeserialized(const ASTContext &C, unsigned ID);
 
+  void printName(raw_ostream &OS) const override;
+
   RecordDecl *getPreviousDecl() {
     return cast_or_null<RecordDecl>(
             static_cast<TagDecl *>(this)->getPreviousDecl());
   }
   const RecordDecl *getPreviousDecl() const {
     return const_cast<RecordDecl*>(this)->getPreviousDecl();
   }
 

clang/include/clang/AST/PrettyPrinter.h

struct PrintingPolicy {
   /// construct). This should not be used if a real LangOptions object is
   /// available.
   void adjustForCPlusPlus() {
     SuppressTagKeyword = true;
     Bool = true;
     UseVoidForZeroParams = false;
   }
 
+  /// The open and close delimiter to use when pretty-printing an unnamed entity
+  /// such as an unnamed variable or an anonymous union.
+  char getOpenDelimiterForUnnamedEntity() const {
+    return MSVCFormatting ? '`' : '(';
+  }
+  char getCloseDelimiterForUnnamedEntity() const {
+    return MSVCFormatting ? '\'' : ')';
+  }
+
   /// The number of spaces to use to indent each line.
   unsigned Indentation : 8;
 
   /// Whether we should suppress printing of the actual specifiers for
   /// the given type or declaration.
   ///
   /// This flag is only used when we are printing declarators beyond
   /// the first declarator within a declaration group. For example, given:

clang/lib/AST/Decl.cpp

if (const Expr *Init = getInit()) {
     // If Init is implicit, ignore its source range and fallback on
     // DeclaratorDecl::getSourceRange() to handle postfix elements.
     if (InitEnd.isValid() && InitEnd != getLocation())
       return SourceRange(getOuterLocStart(), InitEnd);
   }
   return DeclaratorDecl::getSourceRange();
 }
 
+static void printPresumedLocationAt(raw_ostream &OS, const SourceManager &SM,
+                                    const PrintingPolicy &Policy,
+                                    SourceLocation Loc) {
+  PresumedLoc PLoc = SM.getPresumedLoc(Loc);
+  if (PLoc.isValid()) {
+    OS << " at ";
+    StringRef File = PLoc.getFilename();
+    if (Policy.Callbacks)
+      OS << Policy.Callbacks->remapPath(File);
+    else
+      OS << File;
+    OS << ':' << PLoc.getLine() << ':' << PLoc.getColumn();
+  }
+}
+
+static void printUnnamedTag(raw_ostream &OS, const ASTContext &Ctx,
+                            const TagDecl *TD, bool IsAnonymousStructOrUnion) {
+  assert(TD && "missing TagDecl!");
+  assert(!TD->getDeclName() && "expected an unnamed declaration!");
+  const PrintingPolicy &Policy = Ctx.getPrintingPolicy();
+
+  // The following mirrors the code in TypePrinter::printTag.
+  //
+  // Note that we try to be precise with the terms "anonymous" and "unnamed".
+  // We may however issue a diagnostic for an anonymous record before actually
+  // knowning that it is an anonymous record. In this case the term "unnamed"
+  // will be mistakenly used (since the default is to assume that the record
+  // is not anonymous). This is a relatively uncommon case and therefore the
+  // additional complexity needed to prevent this is not worthwhile.
+  OS << Policy.getOpenDelimiterForUnnamedEntity()
+     << (IsAnonymousStructOrUnion ? "anonymous " : "unnamed ")
+     << TD->getKindName();
+
+  if (Policy.AnonymousTagLocations)
+    printPresumedLocationAt(OS, Ctx.getSourceManager(), Policy,
+                            TD->getLocation());
+
+  OS << Policy.getCloseDelimiterForUnnamedEntity();
+}
+
+static void printUnnamedDeclarator(raw_ostream &OS, const ASTContext &Ctx,
+                                   const DeclaratorDecl *DD) {
+  assert(DD && "missing DeclaratorDecl!");
+  assert(!DD->getDeclName() && "expected an unnamed declaration!");
+  assert(isa<FieldDecl>(DD) ||
+         isa<VarDecl>(DD) && "expected a field or variable declaration!");
+  const PrintingPolicy &Policy = Ctx.getPrintingPolicy();
+
+  OS << Policy.getOpenDelimiterForUnnamedEntity() << "unnamed "
+     << (isa<FieldDecl>(DD) ? "field" : "variable");
+
+  // Don't print the location of anonymous records twice.
+  bool SuppressLocation = false;
+  if (const auto *TagTy = DD->getType()->getAs<TagType>()) {
+    const TagDecl *TD = TagTy->getDecl();
+    SuppressLocation =
+        !TD->getDeclName() && DD->getLocation() == DD->getTypeSpecStartLoc();
+  }
+
+  // FIXME: For now we are using PrintingPolicy::AnonymousTagLocations but
+  // perhaps we should add another flag.
+  if (Policy.AnonymousTagLocations && !SuppressLocation)
+    printPresumedLocationAt(OS, Ctx.getSourceManager(), Policy,
+                            DD->getLocation());
+
+  OS << " of type ";
+  DD->getType().print(OS, Policy);
+
+  OS << Policy.getCloseDelimiterForUnnamedEntity();
+}
+
+void VarDecl::printName(raw_ostream &OS) const {
+  if (!getDeclName())
+    return printUnnamedDeclarator(OS, getASTContext(), this);
+
+  DeclaratorDecl::printName(OS);
+}
+
 template<typename T>
 static LanguageLinkage getDeclLanguageLinkage(const T &D) {
   // C++ [dcl.link]p1: All function types, function names with external linkage,
   // and variable names with external linkage have a language linkage.
   if (!D.hasExternalFormalLinkage())
     return NoLanguageLinkage;
 
   // Language linkage is a C++ concept, but saying that everything else in C has
SourceRange FieldDecl::getSourceRange() const {
   const Expr *FinalExpr = getInClassInitializer();
   if (!FinalExpr)
     FinalExpr = getBitWidth();
   if (FinalExpr)
     return SourceRange(getInnerLocStart(), FinalExpr->getEndLoc());
   return DeclaratorDecl::getSourceRange();
 }
 
+void FieldDecl::printName(raw_ostream &OS) const {
+  if (!getDeclName())
+    return printUnnamedDeclarator(OS, getASTContext(), this);
+
+  DeclaratorDecl::printName(OS);
+}
+
 void FieldDecl::setCapturedVLAType(const VariableArrayType *VLAType) {
   assert((getParent()->isLambda() || getParent()->isCapturedRecord()) &&
          "capturing type in non-lambda or captured record.");
   assert(InitStorage.getInt() == ISK_NoInit &&
          InitStorage.getPointer() == nullptr &&
          "bit width, initializer or captured type already set");
   InitStorage.setPointerAndInt(const_cast<VariableArrayType *>(VLAType),
                                ISK_CapturedVLAType);

 EnumDecl *EnumDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
   EnumDecl *Enum =
       new (C, ID) EnumDecl(C, nullptr, SourceLocation(), SourceLocation(),
                            nullptr, nullptr, false, false, false);
   Enum->setMayHaveOutOfDateDef(C.getLangOpts().Modules);
   return Enum;
 }
 
+void EnumDecl::printName(raw_ostream &OS) const {
+  if (!getDeclName())
+    return printUnnamedTag(OS, getASTContext(), this,
+                           /*IsAnonymousStructOrUnion=*/false);
+
+  TagDecl::printName(OS);
+}
+
 SourceRange EnumDecl::getIntegerTypeRange() const {
   if (const TypeSourceInfo *TI = getIntegerTypeSourceInfo())
     return TI->getTypeLoc().getSourceRange();
   return SourceRange();
 }
 
 void EnumDecl::completeDefinition(QualType NewType,
                                   QualType NewPromotionType,

 RecordDecl *RecordDecl::CreateDeserialized(const ASTContext &C, unsigned ID) {
   RecordDecl *R =
       new (C, ID) RecordDecl(Record, TTK_Struct, C, nullptr, SourceLocation(),
                              SourceLocation(), nullptr, nullptr);
   R->setMayHaveOutOfDateDef(C.getLangOpts().Modules);
   return R;
 }
 
+void RecordDecl::printName(raw_ostream &OS) const {
+  if (!getDeclName())
+    return printUnnamedTag(OS, getASTContext(), this,
+                           isAnonymousStructOrUnion());
+
+  TagDecl::printName(OS);
+}
+
 bool RecordDecl::isInjectedClassName() const {
   return isImplicit() && getDeclName() && getDeclContext()->isRecord() &&
     cast<RecordDecl>(getDeclContext())->getDeclName() == getDeclName();
 }
 
 bool RecordDecl::isLambda() const {
   if (auto RD = dyn_cast<CXXRecordDecl>(this))
     return RD->isLambda();

clang/lib/Sema/SemaDecl.cpp

 /// (C++ [class.union]) and a C11 feature; anonymous structures
 /// are a C11 feature and GNU C++ extension.
 Decl *Sema::BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS,
                                         AccessSpecifier AS,
                                         RecordDecl *Record,
                                         const PrintingPolicy &Policy) {
   DeclContext *Owner = Record->getDeclContext();
 
+  // Mark this as an anonymous struct/union type.
+  Record->setAnonymousStructOrUnion(true);
+
   // Diagnose whether this anonymous struct/union is an extension.
   if (Record->isUnion() && !getLangOpts().CPlusPlus && !getLangOpts().C11)
     Diag(Record->getLocation(), diag::ext_anonymous_union);
   else if (!Record->isUnion() && getLangOpts().CPlusPlus)
     Diag(Record->getLocation(), diag::ext_gnu_anonymous_struct);
   else if (!Record->isUnion() && !getLangOpts().C11)
     Diag(Record->getLocation(), diag::ext_c11_anonymous_struct);
 
if (RecordDecl *OwningClass = dyn_cast<RecordDecl>(Owner)) {
     // Default-initialize the implicit variable. This initialization will be
     // trivial in almost all cases, except if a union member has an in-class
     // initializer:
     //   union { int n = 0; };
     ActOnUninitializedDecl(Anon);
   }
   Anon->setImplicit();
 
-  // Mark this as an anonymous struct/union type.
-  Record->setAnonymousStructOrUnion(true);
-
   // Add the anonymous struct/union object to the current
   // context. We'll be referencing this object when we refer to one of
   // its members.
   Owner->addDecl(Anon);
 
   // Inject the members of the anonymous struct/union into the owning
   // context and into the identifier resolver chain for name lookup
   // purposes.

clang/test/AST/ast-dump-APValue-anon-union.cpp

void Test() {
   // CHECK-NEXT:  |   | `-field: Union .i Int 42
 
   constexpr U0 u0a{};
   // CHECK:  | `-VarDecl {{.*}} <col:{{.*}}, col:{{.*}}> col:{{.*}} u0a 'const U0' constexpr listinit
   // CHECK-NEXT:  |   |-value: Union None
 
   constexpr U0 u0b{3.1415f};
   // CHECK:  | `-VarDecl {{.*}} <col:{{.*}}, col:{{.*}}> col:{{.*}} u0b 'const U0' constexpr listinit
-  // CHECK-NEXT:  |   |-value: Union . Union .f Float 3.141500e+00
+  // CHECK-NEXT:  |   |-value: Union .(unnamed field of type U0::(anonymous union at {{.*}}:20:3)) Union .f Float 3.141500e+00
 
   constexpr U1 u1a{};
   // CHECK:  | `-VarDecl {{.*}} <col:{{.*}}, col:{{.*}}> col:{{.*}} u1a 'const U1' constexpr listinit
-  // CHECK-NEXT:  |   |-value: Union . Union .f Float 0.000000e+00
+  // CHECK-NEXT:  |   |-value: Union .(unnamed field of type U1::(anonymous union at {{.*}}:26:3)) Union .f Float 0.000000e+00
 
   constexpr U1 u1b{3.1415f};
   // CHECK:    `-VarDecl {{.*}} <col:{{.*}}, col:{{.*}}> col:{{.*}} u1b 'const U1' constexpr listinit
-  // CHECK-NEXT:      |-value: Union . Union .f Float 3.141500e+00
+  // CHECK-NEXT:      |-value: Union .(unnamed field of type U1::(anonymous union at {{.*}}:26:3)) Union .f Float 3.141500e+00
 }

clang/test/AST/ast-dump-record-definition-data-json.cpp

 // CHECK-NEXT:     "end": {
 // CHECK-NEXT:      "offset": 157,
 // CHECK-NEXT:      "col": 29,
 // CHECK-NEXT:      "tokLen": 1
 // CHECK-NEXT:     }
 // CHECK-NEXT:    },
 // CHECK-NEXT:    "isImplicit": true,
 // CHECK-NEXT:    "isReferenced": true,
-// CHECK-NEXT:    "name": "~",
+// CHECK-NEXT:    "name": "~(unnamed class at {{.*}}:4:29)",
 // CHECK-NEXT:    "mangledName": "_ZZ1fvEN3$_0D1Ev",
 // CHECK-NEXT:    "type": {
 // CHECK-NEXT:     "qualType": "void () noexcept"
 // CHECK-NEXT:    },
 // CHECK-NEXT:    "inline": true,
 // CHECK-NEXT:    "explicitlyDefaulted": "default"
 // CHECK-NEXT:   }
 // CHECK-NEXT:  ]

 // CHECK-NEXT:     "end": {
 // CHECK-NEXT:      "offset": 190,
 // CHECK-NEXT:      "col": 26,
 // CHECK-NEXT:      "tokLen": 1
 // CHECK-NEXT:     }
 // CHECK-NEXT:    },
 // CHECK-NEXT:    "isImplicit": true,
 // CHECK-NEXT:    "isReferenced": true,
-// CHECK-NEXT:    "name": "~",
+// CHECK-NEXT:    "name": "~(unnamed class at {{.*}}:5:26)",
 // CHECK-NEXT:    "mangledName": "_ZZ1fvEN3$_1D1Ev",
 // CHECK-NEXT:    "type": {
 // CHECK-NEXT:     "qualType": "void () noexcept"
 // CHECK-NEXT:    },
 // CHECK-NEXT:    "inline": true,
 // CHECK-NEXT:    "explicitlyDefaulted": "default"
 // CHECK-NEXT:   }
 // CHECK-NEXT:  ]

clang/test/Analysis/explain-svals.cpp

void test_5(int i) {
     clang_analyzer_explain(this); // expected-warning-re{{{{^pointer to 'this' object$}}}}
     clang_analyzer_explain(&x[i]); // expected-warning-re{{{{^pointer to element of type 'int' with index 'argument 'i'' of field 'x' of 'this' object$}}}}
     clang_analyzer_explain(__builtin_alloca(i)); // expected-warning-re{{{{^pointer to region allocated by '__builtin_alloca\(i\)'$}}}}
   }
 };
 } // end of anonymous namespace
 
 void test_6() {
-  clang_analyzer_explain(conjure_S()); // expected-warning-re{{{{^lazily frozen compound value of 1st parameter of function 'clang_analyzer_explain\(\)'$}}}}
+  clang_analyzer_explain(conjure_S());   // expected-warning-re{{{{^lazily frozen compound value of parameter '\(unnamed variable at .*:23:30 of type S\)'$}}}}
   clang_analyzer_explain(conjure_S().z); // expected-warning-re{{{{^value derived from \(symbol of type 'int' conjured at statement 'conjure_S\(\)'\) for field 'z' of temporary object constructed at statement 'conjure_S\(\)'$}}}}
 }
 
 class C_top_level {
 public:
   C_top_level(int param) {
     clang_analyzer_explain(&param); // expected-warning-re{{{{^pointer to parameter 'param'$}}}}
   }

clang/test/CXX/special/class.dtor/p5-0x.cpp

 B3 b3; // expected-error {{deleted function}}
 struct B4 {
   B4();
   InaccessibleDtor a[4]; // expected-note {{because field 'a' has an inaccessible destructor}}
 };
 B4 b4; // expected-error {{deleted function}}
 union B5 {
   B5();
-  // FIXME: Describe the anonymous union member better than ''.
-  union { // expected-note {{because field '' has a deleted destructor}}
-    DeletedDtor a; // expected-note {{because field 'a' has a deleted destructor}}
+  union {          // expected-note-re {{because field '(unnamed field of type B5::(anonymous union at {{.*}}:66:3))' has a deleted destructor}}
+    DeletedDtor a; // expected-note-re {{destructor of '(anonymous union at {{.*}}:66:3)' is implicitly deleted because field 'a' has a deleted destructor}}
   };
 };
 B5 b5; // expected-error {{deleted function}}
 union B6 {
   B6();
-  union { // expected-note {{because field '' has a deleted destructor}}
-    InaccessibleDtor a; // expected-note {{because field 'a' has an inaccessible destructor}}
+  union {               // expected-note-re {{because field '(unnamed field of type B6::(anonymous union at {{.*}}:73:3))' has a deleted destructor}}
+    InaccessibleDtor a; // expected-note-re {{destructor of '(anonymous union at {{.*}}:73:3)' is implicitly deleted because field 'a' has an inaccessible destructor}}
   };
 };
 B6 b6; // expected-error {{deleted function}}
 
 // -- any direct or virtual base class has a deleted or inaccessible destructor.
 struct C1 : DeletedDtor { C1(); } c1; // expected-error {{deleted function}} expected-note {{base class 'DeletedDtor' has a deleted destructor}}
 struct C2 : InaccessibleDtor { C2(); } c2; // expected-error {{deleted function}} expected-note {{base class 'InaccessibleDtor' has an inaccessible destructor}}
 struct C3 : virtual DeletedDtor { C3(); } c3; // expected-error {{deleted function}} expected-note {{base class 'DeletedDtor' has a deleted destructor}}

clang/test/Index/annotate-comments-typedef.m

 // CHECK: TypedefDecl=E_T:[[@LINE-2]]:16 (Definition) FullCommentAsHTML=[<p class="para-brief"> Documentation for E </p>] FullCommentAsXML=[<Typedef file="{{[^"]+}}annotate-comments-typedef.m" line="[[@LINE-2]]" column="16"><Name>E</Name><USR>c:@E@E</USR><Declaration>typedef enum E E_T</Declaration><Abstract><Para> Documentation for E </Para></Abstract></Typedef>]
 
 
 /** Comment about Foo */
 typedef struct {
          int iii;
         } Foo;
 // CHECK: TypedefDecl=Foo:[[@LINE-1]]:11 (Definition) {{.*}} FullCommentAsHTML=[<p class="para-brief"> Comment about Foo </p>] FullCommentAsXML=[<Typedef file="{{[^"]+}}annotate-comments-typedef.m" line="[[@LINE-1]]" column="11"><Name>Foo</Name><USR>c:@T@Foo</USR><Declaration>typedef struct Foo Foo</Declaration><Abstract><Para> Comment about Foo </Para></Abstract></Typedef>]
-// CHECK: StructDecl=:[[@LINE-4]]:9 (Definition) {{.*}} BriefComment=[Comment about Foo] FullCommentAsHTML=[<p class="para-brief"> Comment about Foo </p>] FullCommentAsXML=[<Class file="{{[^"]+}}annotate-comments-typedef.m" line="[[@LINE-4]]" column="9"><Name>&lt;anonymous&gt;</Name><USR>c:@SA@Foo</USR><Declaration>struct {}</Declaration><Abstract><Para> Comment about Foo </Para></Abstract></Class>]
+// CHECK: StructDecl=(unnamed struct at {{.*}}:[[@LINE-4]]:9):[[@LINE-4]]:9 (Definition) {{.*}} BriefComment=[Comment about Foo] FullCommentAsHTML=[<p class="para-brief"> Comment about Foo </p>] FullCommentAsXML=[<Class file="{{[^"]+}}annotate-comments-typedef.m" line="[[@LINE-4]]" column="9"><Name>&lt;anonymous&gt;</Name><USR>c:@SA@Foo</USR><Declaration>struct {}</Declaration><Abstract><Para> Comment about Foo </Para></Abstract></Class>]
 
 
 struct Foo1 {
   int iii;
 };
 /** About Foo1T */
 typedef struct Foo1 Foo1T;
 // FIXME: we don't attach this comment to 'struct Foo1'
 // CHECK: TypedefDecl=Foo1T:[[@LINE-2]]:21 (Definition) {{.*}} FullCommentAsHTML=[<p class="para-brief"> About Foo1T </p>] FullCommentAsXML=[<Typedef file="{{[^"]+}}annotate-comments-typedef.m" line="[[@LINE-2]]" column="21"><Name>Foo1T</Name><USR>c:annotate-comments-typedef.m@T@Foo1T</USR><Declaration>typedef struct Foo1 Foo1T</Declaration><Abstract><Para> About Foo1T </Para></Abstract></Typedef>]
 

clang/test/Index/annotate-tokens.cpp

 // CHECK: Punctuation: "++" [8:13 - 8:15] CXXMethod=operator++:8:5
 // CHECK: Punctuation: "(" [8:15 - 8:16] CXXMethod=operator++:8:5
 // CHECK: Punctuation: ")" [8:16 - 8:17] CXXMethod=operator++:8:5
 // CHECK: Punctuation: ";" [8:17 - 8:18] StructDecl=X:7:8 (Definition)
 // CHECK: Identifier: "X" [9:3 - 9:4] TypeRef=struct X:7:8
 // CHECK: Keyword: "operator" [9:5 - 9:13] CXXMethod=operator++:9:5
 // CHECK: Punctuation: "++" [9:13 - 9:15] CXXMethod=operator++:9:5
 // CHECK: Punctuation: "(" [9:15 - 9:16] CXXMethod=operator++:9:5
-// CHECK: Keyword: "int" [9:16 - 9:19] ParmDecl=:9:19 (Definition
+// CHECK: Keyword: "int" [9:16 - 9:19] ParmDecl=(unnamed variable at {{.*}}:9:19 of type int):9:19 (Definition
 // CHECK: Punctuation: ")" [9:19 - 9:20] CXXMethod=operator++:9:5
 // CHECK: Punctuation: ";" [9:20 - 9:21] StructDecl=X:7:8 (Definition)
 // CHECK: Punctuation: "}" [10:1 - 10:2] StructDecl=X:7:8 (Definition)
 // CHECK: Punctuation: ";" [10:2 - 10:3]
 // CHECK: Keyword: "void" [11:1 - 11:5] FunctionDecl=test2:11:6 (Definition)
 // CHECK: Identifier: "test2" [11:6 - 11:11] FunctionDecl=test2:11:6 (Definition)
 // CHECK: Punctuation: "(" [11:11 - 11:12] FunctionDecl=test2:11:6 (Definition)
 // CHECK: Identifier: "X" [11:12 - 11:13] TypeRef=struct X:7:8

 // CHECK: Punctuation: "<" [23:10 - 23:11] ClassTemplate=TS:24:8 (Definition)
 // CHECK: Keyword: "bool" [23:11 - 23:15] NonTypeTemplateParameter=tfn:23:18 (Definition)
 // CHECK: Punctuation: "(" [23:16 - 23:17] NonTypeTemplateParameter=tfn:23:18 (Definition)
 // CHECK: Punctuation: "*" [23:17 - 23:18] NonTypeTemplateParameter=tfn:23:18 (Definition)
 // CHECK: Identifier: "tfn" [23:18 - 23:21] NonTypeTemplateParameter=tfn:23:18 (Definition)
 // CHECK: Punctuation: ")" [23:21 - 23:22] NonTypeTemplateParameter=tfn:23:18 (Definition)
 // CHECK: Punctuation: "(" [23:22 - 23:23] NonTypeTemplateParameter=tfn:23:18 (Definition)
 // CHECK: Identifier: "X" [23:23 - 23:24] TypeRef=struct X:7:8
-// CHECK: Punctuation: "*" [23:24 - 23:25] ParmDecl=:23:25 (Definition)
+// CHECK: Punctuation: "*" [23:24 - 23:25] ParmDecl=(unnamed variable at {{.*}}:23:25 of type X *):23:25 (Definition)
 // CHECK: Punctuation: ")" [23:25 - 23:26] NonTypeTemplateParameter=tfn:23:18 (Definition)
 // CHECK: Punctuation: ">" [23:26 - 23:27] ClassTemplate=TS:24:8 (Definition)
 // CHECK: Keyword: "struct" [24:1 - 24:7] ClassTemplate=TS:24:8 (Definition)
 // CHECK: Identifier: "TS" [24:8 - 24:10] ClassTemplate=TS:24:8 (Definition)
 // CHECK: Punctuation: "{" [24:11 - 24:12] ClassTemplate=TS:24:8 (Definition)
 // CHECK: Keyword: "void" [25:3 - 25:7] CXXMethod=foo:25:8
 // CHECK: Identifier: "foo" [25:8 - 25:11] CXXMethod=foo:25:8
 // CHECK: Punctuation: "(" [25:11 - 25:12] CXXMethod=foo:25:8
 // CHECK: Punctuation: ")" [25:12 - 25:13] CXXMethod=foo:25:8
 // CHECK: Punctuation: ";" [25:13 - 25:14] ClassTemplate=TS:24:8 (Definition)
 // CHECK: Punctuation: "}" [26:1 - 26:2] ClassTemplate=TS:24:8 (Definition)
 // CHECK: Punctuation: ";" [26:2 - 26:3]
 // CHECK: Keyword: "template" [28:1 - 28:9] CXXMethod=foo:29:15 (Definition)
 // CHECK: Punctuation: "<" [28:10 - 28:11] CXXMethod=foo:29:15 (Definition)
 // CHECK: Keyword: "bool" [28:11 - 28:15] NonTypeTemplateParameter=tfn:28:18 (Definition)
 // CHECK: Punctuation: "(" [28:16 - 28:17] NonTypeTemplateParameter=tfn:28:18 (Definition)
 // CHECK: Punctuation: "*" [28:17 - 28:18] NonTypeTemplateParameter=tfn:28:18 (Definition)
 // CHECK: Identifier: "tfn" [28:18 - 28:21] NonTypeTemplateParameter=tfn:28:18 (Definition)
 // CHECK: Punctuation: ")" [28:21 - 28:22] NonTypeTemplateParameter=tfn:28:18 (Definition)
 // CHECK: Punctuation: "(" [28:22 - 28:23] NonTypeTemplateParameter=tfn:28:18 (Definition)
 // CHECK: Identifier: "X" [28:23 - 28:24] TypeRef=struct X:7:8
-// CHECK: Punctuation: "*" [28:24 - 28:25] ParmDecl=:28:25 (Definition)
+// CHECK: Punctuation: "*" [28:24 - 28:25] ParmDecl=(unnamed variable at {{.*}}:28:25 of type X *):28:25 (Definition)
 // CHECK: Punctuation: ")" [28:25 - 28:26] NonTypeTemplateParameter=tfn:28:18 (Definition)
 // CHECK: Punctuation: ">" [28:26 - 28:27] CXXMethod=foo:29:15 (Definition)
 // CHECK: Keyword: "void" [29:1 - 29:5] CXXMethod=foo:29:15 (Definition)
 // CHECK: Identifier: "TS" [29:6 - 29:8] TemplateRef=TS:24:8
 // CHECK: Punctuation: "<" [29:8 - 29:9] CXXMethod=foo:29:15 (Definition)
 // CHECK: Identifier: "tfn" [29:9 - 29:12] DeclRefExpr=tfn:28:18
 // CHECK: Punctuation: ">" [29:12 - 29:13] CXXMethod=foo:29:15 (Definition)
 // CHECK: Punctuation: "::" [29:13 - 29:15] CXXMethod=foo:29:15 (Definition)

clang/test/Index/c-index-api-loadTU-test.m

 // CHECK: c-index-api-loadTU-test.m:29:17: ObjCProtocolRef=Proto:25:11 Extent=[29:17 - 29:22]
 // CHECK: c-index-api-loadTU-test.m:30:3: ObjCInstanceMethodDecl=spMethod:30:3 Extent=[30:1 - 30:12]
 // CHECK: c-index-api-loadTU-test.m:33:12: ObjCInterfaceDecl=Baz:33:12 Extent=[33:1 - 40:5]
 // CHECK: c-index-api-loadTU-test.m:33:18: ObjCSuperClassRef=Bar:14:12 Extent=[33:18 - 33:21]
 // CHECK: c-index-api-loadTU-test.m:33:23: ObjCProtocolRef=SubP:29:11 Extent=[33:23 - 33:27]
 // CHECK: c-index-api-loadTU-test.m:35:9: ObjCIvarDecl=_anIVar:35:9 (Definition) Extent=[35:5 - 35:16]
 // CHECK: c-index-api-loadTU-test.m:38:11: ObjCInstanceMethodDecl=bazMethod:38:11 Extent=[38:1 - 38:21]
 // CHECK: c-index-api-loadTU-test.m:38:4: ObjCClassRef=Foo:4:12 Extent=[38:4 - 38:7]
-// CHECK: c-index-api-loadTU-test.m:42:1: EnumDecl=:42:1 (Definition) Extent=[42:1 - 44:2]
+// CHECK: c-index-api-loadTU-test.m:42:1: EnumDecl=(unnamed enum at {{.*}}:42:1):42:1 (Definition) Extent=[42:1 - 44:2]
 // CHECK: c-index-api-loadTU-test.m:43:3: EnumConstantDecl=someEnum:43:3 (Definition) Extent=[43:3 - 43:11]
 // CHECK: c-index-api-loadTU-test.m:46:5: FunctionDecl=main:46:5 (Definition) Extent=[46:1 - 55:2]
 // CHECK: c-index-api-loadTU-test.m:46:15: ParmDecl=argc:46:15 (Definition) Extent=[46:11 - 46:19]
 // CHECK: c-index-api-loadTU-test.m:46:34: ParmDecl=argv:46:34 (Definition) Extent=[46:21 - 46:40]
 // CHECK: c-index-api-loadTU-test.m:46:42: CompoundStmt= Extent=[46:42 - 55:2]
 // CHECK: c-index-api-loadTU-test.m:47:2: DeclStmt= Extent=[47:2 - 47:12]
 // CHECK: c-index-api-loadTU-test.m:47:8: VarDecl=bee:47:8 (Definition) Extent=[47:2 - 47:11]
 // CHECK: c-index-api-loadTU-test.m:47:2: ObjCClassRef=Baz:33:12 Extent=[47:2 - 47:5]

clang/test/Index/c-index-getCursor-test.m

 // CHECK: [31:27 - 33:5] ObjCInterfaceDecl=Baz:31:12
 // CHECK: [33:5 - 33:16] ObjCIvarDecl=_anIVar:33:9 (Definition)
 // CHECK: [33:16 - 36:1] ObjCInterfaceDecl=Baz:31:12
 // CHECK: [36:1 - 36:4] ObjCInstanceMethodDecl=bazMethod:36:1
 // CHECK: [36:4 - 36:7] ObjCClassRef=Foo:3:12
 // CHECK: [36:7 - 36:21] ObjCInstanceMethodDecl=bazMethod:36:1
 // CHECK: [36:21 - 38:5] ObjCInterfaceDecl=Baz:31:12
 // CHECK: [38:5 - 40:1] Invalid Cursor => NoDeclFound
-// CHECK: [40:1 - 41:3] EnumDecl=:40:1 (Definition)
+// CHECK: [40:1 - 41:3] EnumDecl=(unnamed enum at {{.*}}:40:1):40:1 (Definition)
 // CHECK: [41:3 - 41:11] EnumConstantDecl=someEnum:41:3 (Definition)
-// CHECK: [41:11 - 42:2] EnumDecl=:40:1 (Definition)
+// CHECK: [41:11 - 42:2] EnumDecl=(unnamed enum at {{.*}}:40:1):40:1 (Definition)
 // CHECK: [42:2 - 44:1] Invalid Cursor => NoDeclFound
 // CHECK: [44:1 - 44:11] FunctionDecl=main:44:5 (Definition)
 // CHECK: [44:11 - 44:19] ParmDecl=argc:44:15 (Definition)
 // CHECK: [44:19 - 44:21] FunctionDecl=main:44:5 (Definition)
 // CHECK: [44:21 - 44:40] ParmDecl=argv:44:34 (Definition)
 // CHECK: [44:40 - 44:42] FunctionDecl=main:44:5 (Definition)
 // CHECK: [44:42 - 45:2] CompoundStmt=
 // CHECK: [45:2 - 45:5] ObjCClassRef=Baz:31:12

clang/test/Index/linkage.c

 // CHECK: FunctionDecl=foo:5:6linkage=External
 // CHECK: VarDecl=w:6:12linkage=Internal
 // CHECK: FunctionDecl=bar:7:6 (Definition)linkage=External
 // CHECK: ParmDecl=y:7:14 (Definition)linkage=NoLinkage
 // CHECK: VarDecl=z:8:14 (Definition)linkage=NoLinkage
 // CHECK: VarDecl=k:9:7 (Definition)linkage=NoLinkage
 // CHECK: VarDecl=n:11:12linkage=External
 // CHECK: FunctionDecl=wibble:12:12linkage=Internal
-// CHECK: ParmDecl=:12:22 (Definition)linkage=NoLinkage
+// CHECK: ParmDecl=(unnamed variable at {{.*}}:12:22 of type int):12:22 (Definition)linkage=NoLinkage
 // CHECK: FunctionDecl=ena:14:6linkage=External
 // CHECK: ParmDecl=dio:14:16 (Definition)linkage=NoLinkage
 // CHECK: ParmDecl=tria:14:25 (Definition)linkage=NoLinkage
 // CHECK: VarDecl=test2{{.*}}linkage=Internal
 // CHECK: VarDecl=test2{{.*}}linkage=Internal

clang/test/Index/load-decls.c

 // CHECK: load-decls.c:1:6: EnumDecl=Color:1:6 (Definition) Extent=[1:1 - 7:2]
 // CHECK: load-decls.c:2:3: EnumConstantDecl=Red:2:3 (Definition) Extent=[2:3 - 2:6]
 // CHECK: load-decls.c:3:3: EnumConstantDecl=Green:3:3 (Definition) Extent=[3:3 - 3:8]
 // CHECK: load-decls.c:4:3: EnumConstantDecl=Blue:4:3 (Definition) Extent=[4:3 - 4:7]
 // CHECK: load-decls.c:6:3: EnumConstantDecl=Rouge:6:3 (Definition) Extent=[6:3 - 6:14]
 // CHECK: load-decls.c:6:11: DeclRefExpr=Red:2:3 Extent=[6:11 - 6:14]
 //
 // CHECK: load-decls.c:9:6: FunctionDecl=PR17970:9:6 Extent=[9:1 - 9:35]
-// CHECK: load-decls.c:9:21: ParmDecl=:9:21 (Definition) Extent=[9:14 - 9:27]
-// CHECK: load-decls.c:9:26: ParmDecl=:9:26 (Definition) Extent=[9:23 - 9:26]
-// CHECK: load-decls.c:9:34: ParmDecl=:9:34 (Definition) Extent=[9:29 - 9:34]
+// CHECK: load-decls.c:9:21: ParmDecl=(unnamed variable at {{.*}}:9:21 of type void (*)(int)):9:21 (Definition) Extent=[9:14 - 9:27]
+// CHECK: load-decls.c:9:26: ParmDecl=(unnamed variable at {{.*}}:9:26 of type int):9:26 (Definition) Extent=[9:23 - 9:26]
+// CHECK: load-decls.c:9:34: ParmDecl=(unnamed variable at {{.*}}:9:34 of type float):9:34 (Definition) Extent=[9:29 - 9:34]

clang/test/Index/load-namespaces.cpp

 // CHECK: load-namespaces.cpp:13:11: NamespaceAlias=std98:13:11 Extent=[13:1 - 13:22]
 // CHECK: load-namespaces.cpp:13:19: NamespaceRef=std:3:11 Extent=[13:19 - 13:22]
 // CHECK: load-namespaces.cpp:14:11: NamespaceAlias=std0x:14:11 Extent=[14:1 - 14:24]
 // CHECK: load-namespaces.cpp:14:19: NamespaceRef=std98:13:11 Extent=[14:19 - 14:24]
 // CHECK: load-namespaces.cpp:16:17: UsingDirective=:16:17 Extent=[16:1 - 16:22]
 // CHECK: load-namespaces.cpp:16:17: NamespaceRef=std0x:14:11 Extent=[16:17 - 16:22]
 // CHECK: load-namespaces.cpp:18:11: Namespace=std:18:11 (Definition) Extent=[18:1 - 20:2]
 // CHECK: load-namespaces.cpp:19:7: FunctionDecl=g:19:7 Extent=[19:3 - 19:13]
-// CHECK: load-namespaces.cpp:19:12: ParmDecl=:19:12 (Definition) Extent=[19:9 - 19:12]
+// CHECK: load-namespaces.cpp:19:12: ParmDecl=(unnamed variable at {{.*}}:19:12 of type int):19:12 (Definition) Extent=[19:9 - 19:12]
 // CHECK: load-namespaces.cpp:22:12: UsingDeclaration=g[19:7, 10:8] Extent=[22:1 - 22:13]
 // CHECK: load-namespaces.cpp:22:7: NamespaceRef=std:18:11 Extent=[22:7 - 22:10]
 // CHECK: load-namespaces.cpp:24:11: FunctionDecl=g:24:11 (Definition) Extent=[24:1 - 25:2]
 // CHECK: load-namespaces.cpp:24:6: NamespaceRef=std:18:11 Extent=[24:6 - 24:9]
 // CHECK: load-namespaces.cpp:27:11: NamespaceAlias=my_rel_ops:27:11 Extent=[27:1 - 27:36]
 // CHECK: load-namespaces.cpp:27:24: NamespaceRef=std:18:11 Extent=[27:24 - 27:27]
 // CHECK: load-namespaces.cpp:27:29: NamespaceRef=rel_ops:4:13 Extent=[27:29 - 27:36]

clang/test/Index/preamble.c

 // RUN: FileCheck -check-prefix CHECK-DIAG %s < %t.stderr.txt
 // CHECK: preamble.h:1:12: FunctionDecl=bar:1:12 (Definition) Extent=[1:1 - 6:2]
 // CHECK: preamble.h:4:3: BinaryOperator= Extent=[4:3 - 4:13]
 // CHECK: preamble.h:4:3: DeclRefExpr=ptr:2:8 Extent=[4:3 - 4:6]
 // CHECK: preamble.h:4:9: UnexposedExpr=ptr1:3:10 Extent=[4:9 - 4:13]
 // CHECK: preamble.h:4:9: DeclRefExpr=ptr1:3:10 Extent=[4:9 - 4:13]
 // CHECK: preamble.h:5:10: IntegerLiteral= Extent=[5:10 - 5:11]
 // CHECK: preamble.c:8:5: FunctionDecl=wibble:8:5 Extent=[8:1 - 8:16]
-// CHECK: preamble.c:8:15: ParmDecl=:8:15 (Definition) Extent=[8:12 - 8:15]
+// CHECK: preamble.c:8:15: ParmDecl=(unnamed variable at {{.*}}:8:15 of type int):8:15 (Definition) Extent=[8:12 - 8:15]
 // CHECK-DIAG: preamble.h:4:7:{4:9-4:13}: warning: incompatible pointer types assigning to 'int *' from 'float *'
 // FIXME: Should see:
 //     preamble.c:5:9: warning: macro is not used
 // CHECK-DIAG-NOT: preamble.c:6:9: warning: macro is not used
 // RUN: env CINDEXTEST_EDITING=1 c-index-test -code-completion-at=%s:11:1 -I %S/Inputs -include %t %s 2> %t.stderr.txt | FileCheck -check-prefix CHECK-CC %s
 // CHECK-CC: FunctionDecl:{ResultType int}{TypedText bar}{LeftParen (}{Placeholder int i}{RightParen )} (50)
 // CHECK-CC: FunctionDecl:{ResultType void}{TypedText f}{LeftParen (}{Placeholder int x}{RightParen )} (50)
 // CHECK-CC: FunctionDecl:{ResultType int}{TypedText foo}{LeftParen (}{Placeholder int}{RightParen )} (50)
 // CHECK-CC: FunctionDecl:{ResultType int}{TypedText wibble}{LeftParen (}{Placeholder int}{RightParen )} (50)

clang/test/Index/print-bitwidth.c

struct X {
   unsigned light : 1;
   unsigned toaster : 1;
   int count;
   union S stat;
 };
 
 // RUN: c-index-test -test-print-bitwidth %s | FileCheck %s
 // CHECK: FieldDecl=ac:2:12 (Definition) bitwidth=4
-// CHECK: FieldDecl=:3:3 (Definition) bitwidth=4
+// CHECK: FieldDecl=(unnamed field at {{.*}}:3:3 of type unsigned int):3:3 (Definition) bitwidth=4
 // CHECK: FieldDecl=clock:4:12 (Definition) bitwidth=1
-// CHECK: FieldDecl=:5:3 (Definition) bitwidth=0
+// CHECK: FieldDecl=(unnamed field at {{.*}}:5:3 of type unsigned int):5:3 (Definition) bitwidth=0
 // CHECK: FieldDecl=flag:6:12 (Definition) bitwidth=1
 // CHECK: FieldDecl=light:10:12 (Definition) bitwidth=1
 // CHECK: FieldDecl=toaster:11:12 (Definition) bitwidth=1
 // CHECK-NOT: count
 // CHECK-NOT: stat

clang/test/Index/print-type.c

 // CHECK: FunctionDecl=f:3:6 (Definition) [type=int *(int *, char *, FooType, int *, void (*)(int))] [typekind=FunctionProto] [canonicaltype=int *(int *, char *, int, int *, void (*)(int))] [canonicaltypekind=FunctionProto] [resulttype=int *] [resulttypekind=Pointer] [args= [int *] [Pointer] [char *] [Pointer] [FooType] [Typedef] [int [5]] [ConstantArray] [void (*)(int)] [Pointer]] [isPOD=0]
 // CHECK: ParmDecl=p:3:13 (Definition) [type=int *] [typekind=Pointer] [isPOD=1] [pointeetype=int] [pointeekind=Int]
 // CHECK: ParmDecl=x:3:22 (Definition) [type=char *] [typekind=Pointer] [isPOD=1] [pointeetype=char] [pointeekind=Char_{{[US]}}]
 // CHECK: ParmDecl=z:3:33 (Definition) [type=FooType] [typekind=Typedef] [canonicaltype=int] [canonicaltypekind=Int] [isPOD=1]
 // CHECK: TypeRef=FooType:1:13 [type=FooType] [typekind=Typedef] [canonicaltype=int] [canonicaltypekind=Int] [isPOD=1]
 // CHECK: ParmDecl=arr:3:40 (Definition) [type=int [5]] [typekind=ConstantArray] [isPOD=1]
 // CHECK: IntegerLiteral= [type=int] [typekind=Int] [isPOD=1]
 // CHECK: ParmDecl=fn:3:55 (Definition) [type=void (*)(int)] [typekind=Pointer] [canonicaltype=void (*)(int)] [canonicaltypekind=Pointer] [isPOD=1] [pointeetype=void (int)] [pointeekind=FunctionProto]
-// CHECK: ParmDecl=:3:62 (Definition) [type=int] [typekind=Int] [isPOD=1]
+// CHECK: ParmDecl=(unnamed variable at {{.*}}:3:62 of type int):3:62 (Definition) [type=int] [typekind=Int] [isPOD=1]
 // CHECK: CompoundStmt= [type=] [typekind=Invalid] [isPOD=0]
 // CHECK: CallExpr=fn:3:55 [type=void] [typekind=Void] [args= [int] [Int]] [isPOD=0]
 // CHECK: DeclRefExpr=fn:3:55 [type=void (*)(int)] [typekind=Pointer] [canonicaltype=void (*)(int)] [canonicaltypekind=Pointer] [isPOD=1] [pointeetype=void (int)] [pointeekind=FunctionProto]
 // CHECK: UnaryOperator= [type=int] [typekind=Int] [isPOD=1]
 // CHECK: DeclRefExpr=p:3:13 [type=int *] [typekind=Pointer] [isPOD=1] [pointeetype=int] [pointeekind=Int]
 // CHECK: DeclStmt= [type=] [typekind=Invalid] [isPOD=0]
 // CHECK: VarDecl=w:5:17 (Definition) [type=const FooType] [typekind=Typedef] const [canonicaltype=const int] [canonicaltypekind=Int] [isPOD=1]
 // CHECK: TypeRef=FooType:1:13 [type=FooType] [typekind=Typedef] [canonicaltype=int] [canonicaltypekind=Int] [isPOD=1]

 // CHECK: VarDecl=x:10:38 [type=__attribute__((__vector_size__(4 * sizeof(int)))) int] [typekind=Vector] [isPOD=1]
 // CHECK: TypedefDecl=int4_t:11:46 (Definition) [type=int4_t] [typekind=Typedef] [canonicaltype=__attribute__((__vector_size__(4 * sizeof(int)))) int] [canonicaltypekind=Vector] [isPOD=1]
 // CHECK: ParmDecl=incompletearray:13:12 (Definition) [type=int []] [typekind=IncompleteArray] [isPOD=1]
 // CHECK: FunctionDecl=elaboratedEnumType:15:25 [type=enum Enum ()] [typekind=FunctionNoProto] [canonicaltype=enum Enum ()] [canonicaltypekind=FunctionNoProto] [resulttype=enum Enum] [resulttypekind=Elaborated] [isPOD=0]
 // CHECK: TypeRef=enum Enum:15:6 [type=enum Enum] [typekind=Enum] [isPOD=1]
 // CHECK: StructDecl=Struct:16:8 (Definition) [type=struct Struct] [typekind=Record] [isPOD=1]
 // CHECK: FunctionDecl=elaboratedStructType:16:32 [type=struct Struct ()] [typekind=FunctionNoProto] [canonicaltype=struct Struct ()] [canonicaltypekind=FunctionNoProto] [resulttype=struct Struct] [resulttypekind=Elaborated] [isPOD=0]
 // CHECK: TypeRef=struct Struct:16:8 [type=struct Struct] [typekind=Record] [isPOD=1]
-// CHECK: StructDecl=:18:1 (Definition) [type=struct (anonymous at {{.*}}print-type.c:18:1)] [typekind=Record] [isPOD=1] [nbFields=2] [isAnon=1] [isAnonRecDecl=0]
-// CHECK: StructDecl=:23:1 (Definition) [type=struct (anonymous at {{.*}}print-type.c:23:1)] [typekind=Record] [isPOD=1] [nbFields=1] [isAnon=1] [isAnonRecDecl=0]
-// CHECK: StructDecl=:24:3 (Definition) [type=struct (anonymous at {{.*}}print-type.c:24:3)] [typekind=Record] [isPOD=1] [nbFields=2] [isAnon=1] [isAnonRecDecl=1]
+// CHECK: StructDecl=(unnamed struct at {{.*}}:18:1):18:1 (Definition) [type=struct (anonymous at {{.*}}print-type.c:18:1)] [typekind=Record] [isPOD=1] [nbFields=2] [isAnon=1] [isAnonRecDecl=0]
+// CHECK: StructDecl=(unnamed struct at {{.*}}:23:1):23:1 (Definition) [type=struct (anonymous at {{.*}}print-type.c:23:1)] [typekind=Record] [isPOD=1] [nbFields=1] [isAnon=1] [isAnonRecDecl=0]
+// CHECK: StructDecl=(anonymous struct at {{.*}}:24:3):24:3 (Definition) [type=struct (anonymous at {{.*}}print-type.c:24:3)] [typekind=Record] [isPOD=1] [nbFields=2] [isAnon=1] [isAnonRecDecl=1]
 // CHECK: FieldDecl=x:25:17 (Definition) [type=_Atomic(int)] [typekind=Atomic] [valuetype=int] [valuetypekind=Int] [isPOD=0] [isAnonRecDecl=0]
 // CHECK: FieldDecl=y:26:9 (Definition) [type=int] [typekind=Int] [isPOD=1] [isAnonRecDecl=0]
-// CHECK: StructDecl=:30:10 (Definition) [type=struct (anonymous at {{.*}}print-type.c:30:10)] [typekind=Record] [isPOD=1] [nbFields=2] [isAnon=1] [isAnonRecDecl=0]
+// CHECK: StructDecl=(unnamed struct at {{.*}}:30:10):30:10 (Definition) [type=struct (anonymous at {{.*}}print-type.c:30:10)] [typekind=Record] [isPOD=1] [nbFields=2] [isAnon=1] [isAnonRecDecl=0]
 // CHECK: VarDecl=aul:32:24 [type=_Atomic(unsigned long)] [typekind=Atomic] [valuetype=unsigned long] [valuetypekind=ULong] [isPOD=0] [isAnonRecDecl=0]

clang/test/Index/print-type.cpp

 // CHECK: IntegerLiteral= [type=int] [typekind=Int] [isPOD=1]
 // CHECK: TemplateRef=Foo:4:8 [type=] [typekind=Invalid] [isPOD=0]
 // CHECK: FieldDecl=qux:29:38 (Definition) [type=Qux<int, char *, Foo<int>, outer::inner::Bar::FooType>] [typekind=Unexposed] [templateargs/4= [type=int] [typekind=Int] [type=char *] [typekind=Pointer] [type=Foo<int>] [typekind=Unexposed] [type=outer::inner::Bar::FooType] [typekind=Typedef]] [canonicaltype=outer::Qux<int, char *, outer::Foo<int>, int>] [canonicaltypekind=Record] [canonicaltemplateargs/4= [type=int] [typekind=Int] [type=char *] [typekind=Pointer] [type=outer::Foo<int>] [typekind=Record] [type=int] [typekind=Int]] [isPOD=1]
 // CHECK: TemplateRef=Qux:12:8 [type=] [typekind=Invalid] [isPOD=0]
 // CHECK: TemplateRef=Foo:4:8 [type=] [typekind=Invalid] [isPOD=0]
 // CHECK: FunctionTemplate=tbar:36:3 [type=T (int)] [typekind=FunctionProto] [canonicaltype=type-parameter-0-0 (int)] [canonicaltypekind=FunctionProto] [resulttype=T] [resulttypekind=Unexposed] [isPOD=0]
 // CHECK: TemplateTypeParameter=T:35:20 (Definition) [type=T] [typekind=Unexposed] [canonicaltype=type-parameter-0-0] [canonicaltypekind=Unexposed] [isPOD=0]
 // CHECK: TypeRef=T:35:20 [type=T] [typekind=Unexposed] [canonicaltype=type-parameter-0-0] [canonicaltypekind=Unexposed] [isPOD=0]
-// CHECK: ParmDecl=:36:11 (Definition) [type=int] [typekind=Int] [isPOD=1]
+// CHECK: ParmDecl=(unnamed variable at {{.*}}:36:11 of type int):36:11 (Definition) [type=int] [typekind=Int] [isPOD=1]
 // CHECK: FunctionTemplate=tbar:39:3 [type=T (int *)] [typekind=FunctionProto] [canonicaltype=type-parameter-0-0 (int *)] [canonicaltypekind=FunctionProto] [resulttype=T] [resulttypekind=Unexposed] [isPOD=0]
 // CHECK: TemplateTypeParameter=T:38:20 (Definition) [type=T] [typekind=Unexposed] [canonicaltype=type-parameter-0-0] [canonicaltypekind=Unexposed] [isPOD=0]
 // CHECK: TypeRef=T:38:20 [type=T] [typekind=Unexposed] [canonicaltype=type-parameter-0-0] [canonicaltypekind=Unexposed] [isPOD=0]
-// CHECK: ParmDecl=:39:11 (Definition) [type=int [5]] [typekind=ConstantArray] [isPOD=1]
+// CHECK: ParmDecl=(unnamed variable at {{.*}}:39:11 of type int *):39:11 (Definition) [type=int [5]] [typekind=ConstantArray] [isPOD=1]
 // CHECK: IntegerLiteral= [type=int] [typekind=Int] [isPOD=1]
 // CHECK: FunctionTemplate=tbar:42:3 [type=T (int *)] [typekind=FunctionProto] [canonicaltype=type-parameter-0-0 (int *)] [canonicaltypekind=FunctionProto] [resulttype=T] [resulttypekind=Unexposed] [isPOD=0]
 // CHECK: TemplateTypeParameter=T:41:20 (Definition) [type=T] [typekind=Unexposed] [canonicaltype=type-parameter-0-0] [canonicaltypekind=Unexposed] [isPOD=0]
 // CHECK: NonTypeTemplateParameter=size:41:27 (Definition) [type=int] [typekind=Int] [isPOD=1]
 // CHECK: TypeRef=T:41:20 [type=T] [typekind=Unexposed] [canonicaltype=type-parameter-0-0] [canonicaltypekind=Unexposed] [isPOD=0]
-// CHECK: ParmDecl=:42:11 (Definition) [type=int [size]] [typekind=DependentSizedArray] [isPOD=0]
+// CHECK: ParmDecl=(unnamed variable at {{.*}}:42:11 of type int *):42:11 (Definition) [type=int [size]] [typekind=DependentSizedArray] [isPOD=0]
 // CHECK: DeclRefExpr=size:41:27 [type=int] [typekind=Int] [isPOD=1]
 // CHECK: FunctionDecl=foo:44:6 (Definition) [type=void (int, int *)] [typekind=FunctionProto] [canonicaltype=void (int, int *)] [canonicaltypekind=FunctionProto] [resulttype=void] [resulttypekind=Void] [args= [int] [Int] [int []] [IncompleteArray]] [isPOD=0]
 // CHECK: ParmDecl=i:44:14 (Definition) [type=int] [typekind=Int] [isPOD=1]
 // CHECK: ParmDecl=incomplete_array:44:21 (Definition) [type=int []] [typekind=IncompleteArray] [isPOD=1]
 // CHECK: CompoundStmt= [type=] [typekind=Invalid] [isPOD=0]
 // CHECK: DeclStmt= [type=] [typekind=Invalid] [isPOD=0]
 // CHECK: VarDecl=variable_array:44:47 (Definition) [type=int [i]] [typekind=VariableArray] [isPOD=1]
 // CHECK: DeclRefExpr=i:44:14 [type=int] [typekind=Int] [isPOD=1]

 // CHECK: TemplateRef=Specialization:66:8 [type=] [typekind=Invalid] [isPOD=0]
 // CHECK: CallExpr=Specialization:66:8 [type=Specialization<Specialization<bool> &>] [typekind=Unexposed] [templateargs/1= [type=Specialization<bool> &] [typekind=LValueReference]] [canonicaltype=Specialization<Specialization<bool> &>] [canonicaltypekind=Record] [canonicaltemplateargs/1= [type=Specialization<bool> &] [typekind=LValueReference]] [isPOD=1]
 // CHECK: VarDecl=autoTemplRefParam:72:6 (Definition) [type=Specialization<Specialization<bool> &>] [typekind=Auto] [templateargs/1= [type=Specialization<bool> &] [typekind=LValueReference]] [canonicaltype=Specialization<Specialization<bool> &>] [canonicaltypekind=Record] [canonicaltemplateargs/1= [type=Specialization<bool> &] [typekind=LValueReference]] [isPOD=1]
 // CHECK: UnexposedExpr=templRefParam:71:40 [type=const Specialization<Specialization<bool> &>] [typekind=Record] const [templateargs/1= [type=Specialization<bool> &] [typekind=LValueReference]] [isPOD=1]
 // CHECK: DeclRefExpr=templRefParam:71:40 [type=Specialization<Specialization<bool> &>] [typekind=Unexposed] [templateargs/1= [type=Specialization<bool> &] [typekind=LValueReference]] [canonicaltype=Specialization<Specialization<bool> &>] [canonicaltypekind=Record] [canonicaltemplateargs/1= [type=Specialization<bool> &] [typekind=LValueReference]] [isPOD=1]
 // CHECK: TypeAliasDecl=baz:76:7 (Definition) [type=baz] [typekind=Typedef] [templateargs/1= [type=A<void>] [typekind=Unexposed]] [canonicaltype=A<void>] [canonicaltypekind=Record] [canonicaltemplateargs/1= [type=void] [typekind=Void]] [isPOD=0]
 // CHECK: VarDecl=autoTemplPointer:78:6 (Definition) [type=Specialization<Specialization<bool> &> *] [typekind=Auto] [canonicaltype=Specialization<Specialization<bool> &> *] [canonicaltypekind=Pointer] [isPOD=1] [pointeetype=Specialization<Specialization<bool> &>] [pointeekind=Record]
 // CHECK: CallExpr=Bar:17:3 [type=outer::inner::Bar] [typekind=Elaborated] [canonicaltype=outer::inner::Bar] [canonicaltypekind=Record] [args= [outer::Foo<bool> *] [Pointer]] [isPOD=0] [nbFields=3]
-// CHECK: StructDecl=:84:3 (Definition) [type=X::(anonymous struct at {{.*}}print-type.cpp:84:3)] [typekind=Record] [isPOD=1] [nbFields=1] [isAnon=1]
-// CHECK: ClassDecl=:85:3 (Definition) [type=X::(anonymous class at {{.*}}print-type.cpp:85:3)] [typekind=Record] [isPOD=1] [nbFields=1] [isAnon=1]
-// CHECK: UnionDecl=:86:3 (Definition) [type=X::(anonymous union at {{.*}}print-type.cpp:86:3)] [typekind=Record] [isPOD=1] [nbFields=2] [isAnon=1]
-// CHECK: EnumDecl=:87:3 (Definition) [type=X::(anonymous enum at {{.*}}print-type.cpp:87:3)] [typekind=Enum] [isPOD=1] [isAnon=1]
+// CHECK: StructDecl=(anonymous struct at {{.*}}:84:3):84:3 (Definition) [type=X::(anonymous struct at {{.*}}print-type.cpp:84:3)] [typekind=Record] [isPOD=1] [nbFields=1] [isAnon=1]
+// CHECK: ClassDecl=(anonymous class at {{.*}}:85:3):85:3 (Definition) [type=X::(anonymous class at {{.*}}print-type.cpp:85:3)] [typekind=Record] [isPOD=1] [nbFields=1] [isAnon=1]
+// CHECK: UnionDecl=(anonymous union at {{.*}}:86:3):86:3 (Definition) [type=X::(anonymous union at {{.*}}print-type.cpp:86:3)] [typekind=Record] [isPOD=1] [nbFields=2] [isAnon=1]
+// CHECK: EnumDecl=(unnamed enum at {{.*}}:87:3):87:3 (Definition) [type=X::(anonymous enum at {{.*}}print-type.cpp:87:3)] [typekind=Enum] [isPOD=1] [isAnon=1]
 // CHECK: Namespace=:90:11 (Definition) [type=] [typekind=Invalid] [isPOD=0] [isAnon=1]
 // CHECK: Namespace=InlineNS:94:18 (Definition) [type=] [typekind=Invalid] [isPOD=0] [isAnonRecDecl=0] [isInlineNamespace=1]

clang/test/Index/recursive-cxx-member-calls.cpp

 // CHECK-tokens: Punctuation: ";" [4:64 - 4:65] Namespace=std:3:11 (Definition)
 // CHECK-tokens: Punctuation: "}" [5:1 - 5:2] Namespace=std:3:11 (Definition)
 // CHECK-tokens: Keyword: "extern" [6:1 - 6:7]
 // CHECK-tokens: Literal: ""C"" [6:8 - 6:11] UnexposedDecl=:6:8 (Definition)
 // CHECK-tokens: Punctuation: "{" [6:12 - 6:13] UnexposedDecl=:6:8 (Definition)
 // CHECK-tokens: Keyword: "int" [7:3 - 7:6] FunctionDecl=memcmp:7:7
 // CHECK-tokens: Identifier: "memcmp" [7:7 - 7:13] FunctionDecl=memcmp:7:7
 // CHECK-tokens: Punctuation: "(" [7:13 - 7:14] FunctionDecl=memcmp:7:7
-// CHECK-tokens: Keyword: "const" [7:14 - 7:19] ParmDecl=:7:26 (Definition)
-// CHECK-tokens: Keyword: "void" [7:20 - 7:24] ParmDecl=:7:26 (Definition)
-// CHECK-tokens: Punctuation: "*" [7:25 - 7:26] ParmDecl=:7:26 (Definition)
+// CHECK-tokens: Keyword: "const" [7:14 - 7:19] ParmDecl=(unnamed variable at {{.*}}:7:26 of type const void *):7:26 (Definition)
+// CHECK-tokens: Keyword: "void" [7:20 - 7:24] ParmDecl=(unnamed variable at {{.*}}:7:26 of type const void *):7:26 (Definition)
+// CHECK-tokens: Punctuation: "*" [7:25 - 7:26] ParmDecl=(unnamed variable at {{.*}}:7:26 of type const void *):7:26 (Definition)
 // CHECK-tokens: Punctuation: "," [7:26 - 7:27] FunctionDecl=memcmp:7:7
-// CHECK-tokens: Keyword: "const" [7:28 - 7:33] ParmDecl=:7:40 (Definition)
-// CHECK-tokens: Keyword: "void" [7:34 - 7:38] ParmDecl=:7:40 (Definition)
-// CHECK-tokens: Punctuation: "*" [7:39 - 7:40] ParmDecl=:7:40 (Definition)
+// CHECK-tokens: Keyword: "const" [7:28 - 7:33] ParmDecl=(unnamed variable at {{.*}}:7:40 of type const void *):7:40 (Definition)
+// CHECK-tokens: Keyword: "void" [7:34 - 7:38] ParmDecl=(unnamed variable at {{.*}}:7:40 of type const void *):7:40 (Definition)
+// CHECK-tokens: Punctuation: "*" [7:39 - 7:40] ParmDecl=(unnamed variable at {{.*}}:7:40 of type const void *):7:40 (Definition)
 // CHECK-tokens: Punctuation: "," [7:40 - 7:41] FunctionDecl=memcmp:7:7
 // CHECK-tokens: Identifier: "size_t" [7:42 - 7:48] TypeRef=size_t:2:25
 // CHECK-tokens: Punctuation: ")" [7:48 - 7:49] FunctionDecl=memcmp:7:7
 // CHECK-tokens: Punctuation: ";" [7:49 - 7:50] UnexposedDecl=:6:8 (Definition)
 // CHECK-tokens: Identifier: "size_t" [8:3 - 8:9] TypeRef=size_t:2:25
 // CHECK-tokens: Identifier: "strlen" [8:10 - 8:16] FunctionDecl=strlen:8:10
 // CHECK-tokens: Punctuation: "(" [8:16 - 8:17] FunctionDecl=strlen:8:10
-// CHECK-tokens: Keyword: "const" [8:17 - 8:22] ParmDecl=:8:29 (Definition)
-// CHECK-tokens: Keyword: "char" [8:23 - 8:27] ParmDecl=:8:29 (Definition)
-// CHECK-tokens: Punctuation: "*" [8:28 - 8:29] ParmDecl=:8:29 (Definition)
+// CHECK-tokens: Keyword: "const" [8:17 - 8:22] ParmDecl=(unnamed variable at {{.*}}:8:29 of type const char *):8:29 (Definition)
+// CHECK-tokens: Keyword: "char" [8:23 - 8:27] ParmDecl=(unnamed variable at {{.*}}:8:29 of type const char *):8:29 (Definition)
+// CHECK-tokens: Punctuation: "*" [8:28 - 8:29] ParmDecl=(unnamed variable at {{.*}}:8:29 of type const char *):8:29 (Definition)
 // CHECK-tokens: Punctuation: ")" [8:29 - 8:30] FunctionDecl=strlen:8:10
 // CHECK-tokens: Punctuation: ";" [8:30 - 8:31]
 // CHECK-tokens: Punctuation: "}" [9:1 - 9:2]
 // CHECK-tokens: Keyword: "namespace" [10:1 - 10:10]
 // CHECK-tokens: Identifier: "clang" [10:17 - 10:22] Namespace=clang:10:17 (Definition)
 // CHECK-tokens: Punctuation: "{" [10:23 - 10:24] Namespace=clang:10:17 (Definition)
 // CHECK-tokens: Keyword: "class" [11:3 - 11:8] ClassDecl=IdentifierInfo:11:9
 // CHECK-tokens: Identifier: "IdentifierInfo" [11:9 - 11:23] ClassDecl=IdentifierInfo:11:9

 // CHECK: 2:9: TypeRef=__darwin_size_t:1:27 Extent=[2:9 - 2:24]
 // CHECK: 3:11: Namespace=std:3:11 (Definition) Extent=[3:1 - 5:2]
 // CHECK: 4:44: ClassTemplate=pair:4:44 (Definition) Extent=[4:3 - 4:64]
 // CHECK: 4:20: TemplateTypeParameter=_T1:4:20 (Definition) Extent=[4:14 - 4:23]
 // CHECK: 4:31: TemplateTypeParameter=_T2:4:31 (Definition) Extent=[4:25 - 4:34]
 // CHECK: 4:55: FieldDecl=second:4:55 (Definition) Extent=[4:51 - 4:61]
 // CHECK: 6:8: UnexposedDecl=:6:8 (Definition) Extent=[6:1 - 9:2]
 // CHECK: 7:7: FunctionDecl=memcmp:7:7 Extent=[7:3 - 7:49]
-// CHECK: 7:26: ParmDecl=:7:26 (Definition) Extent=[7:14 - 7:26]
-// CHECK: 7:40: ParmDecl=:7:40 (Definition) Extent=[7:28 - 7:40]
-// CHECK: 7:48: ParmDecl=:7:48 (Definition) Extent=[7:42 - 7:48]
+// CHECK: 7:26: ParmDecl=(unnamed variable at {{.*}}:7:26 of type const void *):7:26 (Definition) Extent=[7:14 - 7:26]
+// CHECK: 7:40: ParmDecl=(unnamed variable at {{.*}}:7:40 of type const void *):7:40 (Definition) Extent=[7:28 - 7:40]
+// CHECK: 7:48: ParmDecl=(unnamed variable at {{.*}}:7:48 of type size_t):7:48 (Definition) Extent=[7:42 - 7:48]
 // CHECK: 7:42: TypeRef=size_t:2:25 Extent=[7:42 - 7:48]
 // CHECK: 8:10: FunctionDecl=strlen:8:10 Extent=[8:3 - 8:30]
 // CHECK: 8:3: TypeRef=size_t:2:25 Extent=[8:3 - 8:9]
-// CHECK: 8:29: ParmDecl=:8:29 (Definition) Extent=[8:17 - 8:29]
+// CHECK: 8:29: ParmDecl=(unnamed variable at {{.*}}:8:29 of type const char *):8:29 (Definition) Extent=[8:17 - 8:29]
 // CHECK: 10:17: Namespace=clang:10:17 (Definition) Extent=[10:1 - 35:2]
 // CHECK: 11:9: ClassDecl=IdentifierInfo:11:9 Extent=[11:3 - 11:23]
 // CHECK: 12:9: ClassDecl=AttributeList:12:9 (Definition) Extent=[12:3 - 34:4]
 // CHECK: 13:10: EnumDecl=Kind:13:10 (Definition) Extent=[13:5 - 32:6]
 // CHECK: 14:7: EnumConstantDecl=AT_IBAction:14:7 (Definition) Extent=[14:7 - 14:18]
 // CHECK: 14:20: EnumConstantDecl=AT_IBOutlet:14:20 (Definition) Extent=[14:20 - 14:31]
 // CHECK: 14:33: EnumConstantDecl=AT_IBOutletCollection:14:33 (Definition) Extent=[14:33 - 14:54]
 // CHECK: 15:7: EnumConstantDecl=AT_address_space:15:7 (Definition) Extent=[15:7 - 15:23]

clang/test/Index/targeted-annotation.c

 // RUN:   c-index-test -test-annotate-tokens=%S/targeted-fields.h:1:1:4:1 %s -include %t.h \
 // RUN:    -Xclang -error-on-deserialized-decl=PreambleVar  \
 // RUN:    -Xclang -error-on-deserialized-decl=NestedVar1  \
 // RUN:    -Xclang -error-on-deserialized-decl=TopVar  \
 // RUN:  | FileCheck %s -check-prefix=FIELD
 
 // FIELD: Keyword: "int" [2:3 - 2:6] FieldDecl=z:2:7 (Definition)
 // FIELD: Identifier: "z" [2:7 - 2:8] FieldDecl=z:2:7 (Definition)
-// FIELD: Punctuation: ";" [2:8 - 2:9] StructDecl=:13:9 (Definition)
+// FIELD: Punctuation: ";" [2:8 - 2:9] StructDecl=(unnamed struct at {{.*}}targeted-top.h:13:9):13:9 (Definition)
 // FIELD: Keyword: "int" [3:3 - 3:6] FieldDecl=w:3:7 (Definition)
 // FIELD: Identifier: "w" [3:7 - 3:8] FieldDecl=w:3:7 (Definition)
-// FIELD: Punctuation: ";" [3:8 - 3:9] StructDecl=:13:9 (Definition)
+// FIELD: Punctuation: ";" [3:8 - 3:9] StructDecl=(unnamed struct at {{.*}}targeted-top.h:13:9):13:9 (Definition)
 
 // RUN: env CINDEXTEST_FAILONERROR=1 c-index-test -test-annotate-tokens=%S/targeted-nested1.h:1:1:3:1 %s -include %t.h \
 // RUN:    -Xclang -error-on-deserialized-decl=TopVar  \
 // RUN:  | FileCheck %s -check-prefix=NESTED
 
 // RUN: env CINDEXTEST_FAILONERROR=1 CINDEXTEST_EDITING=1 CINDEXTEST_COMPLETION_NO_CACHING=1 \
 // RUN:   c-index-test -test-annotate-tokens=%S/targeted-nested1.h:1:1:3:1 %s -include %t.h \
 // RUN:    -Xclang -error-on-deserialized-decl=PreambleVar  \

 // TOP: Identifier: "ifndef" [2:2 - 2:8] preprocessing directive=
 // TOP: Identifier: "TARGETED_TOP_H" [2:9 - 2:23] preprocessing directive=
 // TOP: Punctuation: "#" [3:1 - 3:2] preprocessing directive=
 // TOP: Identifier: "define" [3:2 - 3:8] preprocessing directive=
 // TOP: Identifier: "TARGETED_TOP_H" [3:9 - 3:23] macro definition=TARGETED_TOP_H
 // TOP: Punctuation: "#" [5:1 - 5:2] inclusion directive=targeted-nested1.h
 // TOP: Identifier: "include" [5:2 - 5:9] inclusion directive=targeted-nested1.h
 // TOP: Literal: ""targeted-nested1.h"" [5:10 - 5:30] inclusion directive=targeted-nested1.h
-// TOP: Keyword: "enum" [7:1 - 7:5] EnumDecl=:7:1 (Definition)
-// TOP: Punctuation: "{" [7:6 - 7:7] EnumDecl=:7:1 (Definition)
+// TOP: Keyword: "enum" [7:1 - 7:5] EnumDecl=(unnamed enum at {{.*}}targeted-top.h:7:1):7:1 (Definition)
+// TOP: Punctuation: "{" [7:6 - 7:7] EnumDecl=(unnamed enum at {{.*}}targeted-top.h:7:1):7:1 (Definition)
 // TOP: Identifier: "VALUE" [8:3 - 8:8] EnumConstantDecl=VALUE:8:3 (Definition)
 // TOP: Punctuation: "=" [8:9 - 8:10] EnumConstantDecl=VALUE:8:3 (Definition)
 // TOP: Literal: "3" [8:11 - 8:12] IntegerLiteral=
-// TOP: Punctuation: "}" [9:1 - 9:2] EnumDecl=:7:1 (Definition)
+// TOP: Punctuation: "}" [9:1 - 9:2] EnumDecl=(unnamed enum at {{.*}}targeted-top.h:7:1):7:1 (Definition)
 // TOP: Punctuation: ";" [9:2 - 9:3]
 // TOP: Keyword: "extern" [11:1 - 11:7]
 // TOP: Keyword: "int" [11:8 - 11:11] VarDecl=TopVar:11:12
 // TOP: Identifier: "TopVar" [11:12 - 11:18] VarDecl=TopVar:11:12
 // TOP: Punctuation: ";" [11:18 - 11:19]

clang/test/Index/targeted-cursor.c

 // RUN:  | FileCheck %s -check-prefix=PREAMBLE-CURSOR1
 
 // LOCAL-CURSOR1: VarDecl=LocalVar1:5:5
 // TOP-CURSOR1: VarDecl=TopVar:11:12
 // NESTED-CURSOR1: VarDecl=NestedVar1:2:12
 // PREAMBLE-CURSOR1: VarDecl=PreambleVar:2:12
 
 // FIELD-CURSOR1: FieldDecl=z:2:7 (Definition)
-// FIELD-CURSOR2: StructDecl=:13:9 (Definition)
+// FIELD-CURSOR2: StructDecl=(unnamed struct at {{.*}}targeted-top.h:13:9):13:9 (Definition)

clang/test/Index/usrs.m

 // CHECK-source: usrs.m:3:19: FunctionDecl=my_helper:3:19 (Definition) Extent=[3:1 - 3:60]
 // CHECK-source: usrs.m:3:33: ParmDecl=x:3:33 (Definition) Extent=[3:29 - 3:34]
 // CHECK-source: usrs.m:3:40: ParmDecl=y:3:40 (Definition) Extent=[3:36 - 3:41]
 // CHECK-source: usrs.m:3:43: CompoundStmt= Extent=[3:43 - 3:60]
 // CHECK-source: usrs.m:3:45: ReturnStmt= Extent=[3:45 - 3:57]
 // CHECK-source: usrs.m:3:52: BinaryOperator= Extent=[3:52 - 3:57]
 // CHECK-source: usrs.m:3:52: DeclRefExpr=x:3:33 Extent=[3:52 - 3:53]
 // CHECK-source: usrs.m:3:56: DeclRefExpr=y:3:40 Extent=[3:56 - 3:57]
-// CHECK-source: usrs.m:5:1: EnumDecl=:5:1 (Definition) Extent=[5:1 - 8:2]
+// CHECK-source: usrs.m:5:1: EnumDecl=(unnamed enum at {{.*}}:5:1):5:1 (Definition) Extent=[5:1 - 8:2]
 // CHECK-source: usrs.m:6:3: EnumConstantDecl=ABA:6:3 (Definition) Extent=[6:3 - 6:6]
 // CHECK-source: usrs.m:7:3: EnumConstantDecl=CADABA:7:3 (Definition) Extent=[7:3 - 7:9]
-// CHECK-source: usrs.m:10:1: EnumDecl=:10:1 (Definition) Extent=[10:1 - 13:2]
+// CHECK-source: usrs.m:10:1: EnumDecl=(unnamed enum at {{.*}}:10:1):10:1 (Definition) Extent=[10:1 - 13:2]
 // CHECK-source: usrs.m:11:3: EnumConstantDecl=FOO:11:3 (Definition) Extent=[11:3 - 11:6]
 // CHECK-source: usrs.m:12:3: EnumConstantDecl=BAR:12:3 (Definition) Extent=[12:3 - 12:6]
 // CHECK-source: usrs.m:18:3: TypedefDecl=MyStruct:18:3 (Definition) Extent=[15:1 - 18:11]
-// CHECK-source: usrs.m:15:9: StructDecl=:15:9 (Definition) Extent=[15:9 - 18:2]
+// CHECK-source: usrs.m:15:9: StructDecl=(unnamed struct at {{.*}}:15:9):15:9 (Definition) Extent=[15:9 - 18:2]
 // CHECK-source: usrs.m:16:7: FieldDecl=wa:16:7 (Definition) Extent=[16:3 - 16:9]
 // CHECK-source: usrs.m:17:7: FieldDecl=moo:17:7 (Definition) Extent=[17:3 - 17:10]
 // CHECK-source: usrs.m:20:6: EnumDecl=Pizza:20:6 (Definition) Extent=[20:1 - 23:2]
 // CHECK-source: usrs.m:21:3: EnumConstantDecl=CHEESE:21:3 (Definition) Extent=[21:3 - 21:9]
 // CHECK-source: usrs.m:22:3: EnumConstantDecl=MUSHROOMS:22:3 (Definition) Extent=[22:3 - 22:12]
 // CHECK-source: usrs.m:25:12: ObjCInterfaceDecl=Foo:25:12 Extent=[25:1 - 32:5]
 // CHECK-source: usrs.m:26:6: ObjCIvarDecl=x:26:6 (Definition) Extent=[26:3 - 26:7]
 // CHECK-source: usrs.m:26:3: TypeRef=id:0:0 Extent=[26:3 - 26:5]

 // CHECK-source: usrs.m:68:17: ObjCClassRef=CWithExt:51:12 Extent=[68:17 - 68:25]
 // CHECK-source: usrs.m:69:8: ObjCInstanceMethodDecl=meth4:69:8 (Definition) Extent=[69:1 - 69:27]
 // CHECK-source: usrs.m:69:4: TypeRef=id:0:0 Extent=[69:4 - 69:6]
 // CHECK-source: usrs.m:69:14: CompoundStmt= Extent=[69:14 - 69:27]
 // CHECK-source: usrs.m:69:16: ReturnStmt= Extent=[69:16 - 69:24]
 // CHECK-source: usrs.m:69:23: UnexposedExpr= Extent=[69:23 - 69:24]
 // CHECK-source: usrs.m:69:23: IntegerLiteral= Extent=[69:23 - 69:24]
 // CHECK-source: usrs.m:72:6: FunctionDecl=aux_1:72:6 Extent=[72:1 - 72:26]
-// CHECK-source: usrs.m:72:15: ParmDecl=:72:15 (Definition) Extent=[72:12 - 72:15]
-// CHECK-source: usrs.m:72:20: ParmDecl=:72:20 (Definition) Extent=[72:17 - 72:20]
-// CHECK-source: usrs.m:72:25: ParmDecl=:72:25 (Definition) Extent=[72:22 - 72:25]
+// CHECK-source: usrs.m:72:15: ParmDecl=(unnamed variable at {{.*}}:72:15 of type int):72:15 (Definition) Extent=[72:12 - 72:15]
+// CHECK-source: usrs.m:72:20: ParmDecl=(unnamed variable at {{.*}}:72:20 of type int):72:20 (Definition) Extent=[72:17 - 72:20]
+// CHECK-source: usrs.m:72:25: ParmDecl=(unnamed variable at {{.*}}:72:25 of type int):72:25 (Definition) Extent=[72:22 - 72:25]
 // CHECK-source: usrs.m:73:5: FunctionDecl=test_multi_declaration:73:5 (Definition) Extent=[73:1 - 77:2]
 // CHECK-source: usrs.m:73:34: CompoundStmt= Extent=[73:34 - 77:2]
 // CHECK-source: usrs.m:74:3: DeclStmt= Extent=[74:3 - 74:33]
 // CHECK-source: usrs.m:74:7: VarDecl=foo:74:7 (Definition) Extent=[74:3 - 74:14]
 // CHECK-source: usrs.m:74:13: IntegerLiteral= Extent=[74:13 - 74:14]
 // CHECK-source: usrs.m:74:16: VarDecl=bar:74:16 Extent=[74:16 - 74:23]
 // CHECK-source: usrs.m:74:22: IntegerLiteral= Extent=[74:22 - 74:23]
 // CHECK-source: usrs.m:74:25: VarDecl=baz:74:25 Extent=[74:25 - 74:32]

clang/test/Modules/module-private.cpp

void local_var_private(__module_private__ int param) { // expected-error{{parameter 'param' cannot be declared __module_private__}}
 
   __module_private__ auto [x, y] = local; // expected-error {{local variable '[x, y]' cannot be declared __module_private__}}
 
   __module_private__ struct OtherLocal { int x; }; // expected-error{{local struct cannot be declared __module_private__}}
 
   typedef __module_private__ int local_typedef; // expected-error{{typedef 'local_typedef' cannot be declared __module_private__}}
 }
 
-void param_private(__module_private__ int) {} // expected-error {{parameter '' cannot be declared __module_private}}
+void param_private(__module_private__ int) {} // expected-error-re {{parameter '(unnamed variable at {{.*}}:89:42 of type int)' cannot be declared __module_private__}}
 
 // Check struct size
 struct LikeVisibleStruct {
   int field;
   virtual void setField(int f);
 };
 
 int check_struct_size[sizeof(VisibleStruct) == sizeof(LikeVisibleStruct)? 1 : -1];

clang/test/Sema/address-packed.c

 struct S4 {
   char c;
   struct __attribute__((packed)) {
     int i;
   } inner;
 };
 
 int *g4(struct S4 *s4) {
-  return &s4->inner.i; // expected-warning {{packed member 'i' of class or structure 'S4::(anonymous)'}}
+  return &s4->inner.i;
+  // expected-warning-re@-1 {{packed member 'i' of class or structure 'S4::(unnamed struct at {{.*}}:133:3)'}}
 }
 
 struct S5 {
   char c;
   struct {
     char c1;
     int i __attribute__((packed));
   } inner;
 };
 
 int *g5(struct S5 *s5) {
-  return &s5->inner.i; // expected-warning {{packed member 'i' of class or structure 'S5::(anonymous)'}}
+  return &s5->inner.i;
+  // expected-warning-re@-1 {{packed member 'i' of class or structure 'S5::(unnamed struct at {{.*}}:145:3)'}}
 }
 
 struct __attribute__((packed, aligned(2))) AlignedTo2 {
   int x;
 };
 
 char *g6(struct AlignedTo2 *s) {
   return (char *)&s->x; // no-warning

 struct S6 {
   union {
     char c;
     int x;
   } __attribute__((packed));
 };
 
 int *anonymousInnerUnion(struct S6 *s) {
-  return &s->x; // expected-warning {{packed member 'x' of class or structure 'S6::(anonymous)'}}
+  return &s->x;
+  // expected-warning-re@-1 {{packed member 'x' of class or structure 'S6::(anonymous union at {{.*}}:198:3)'}}
 }
 
 struct S6a {
     int a;
     int _;
     int c;
     char __;
     int d;

clang/test/Sema/attr-flag-enum.c

 // RUN: %clang_cc1 -triple %itanium_abi_triple -verify -fsyntax-only -std=c11 -Wassign-enum %s
 
 enum __attribute__((flag_enum)) flag {
   ea = 0x1,
   eb = 0x2,
   ec = 0x8,
 };
 
 enum __attribute__((flag_enum)) {
-  g = 0x7,  // expected-warning {{enumeration value 'g' is out of range of flags in enumeration type ''}}
+  g = 0x7, // expected-warning-re {{enumeration value 'g' is out of range of flags in enumeration type '(unnamed enum at {{.*}}:9:1)'}}
 };
 
 enum __attribute__((flag_enum)) flag2 {
   ga = 0x1,
   gb = 0x4,
 
   gc = 0x5, // no-warning
   gd = 0x7, // expected-warning {{enumeration value 'gd' is out of range}}

clang/test/Sema/transparent-union.c

union pr15134 {
   // alignment than required by the first field of the transparent union.
 } __attribute__((transparent_union));
 
 union pr15134v2 {
   struct { // expected-note {{alignment of first field is 32 bits}}
     unsigned int u1;
     unsigned int u2;
   };
-  struct {  // expected-warning {{alignment of field '' (64 bits) does not match the alignment of the first field in transparent union; transparent_union attribute ignored}}
+  struct { // expected-warning-re {{alignment of field '(unnamed field of type struct pr15134v2::(anonymous at {{.*}}:127:3))' (64 bits) does not match the alignment of the first field in transparent union; transparent_union attribute ignored}}
     unsigned int u3;
   } __attribute__((aligned(8)));
 } __attribute__((transparent_union));
 
 union pr30520v { void b; } __attribute__((transparent_union)); // expected-error {{field has incomplete type 'void'}}
 
 union pr30520a { int b[]; } __attribute__((transparent_union)); // expected-error {{flexible array member 'b' in a union is not allowed}}
 

clang/test/SemaCXX/attr-unused.cpp

 // RUN: %clang_cc1 -verify -Wunused -Wused-but-marked-unused -fsyntax-only %s
 
 namespace ns_unused { typedef int Int_unused __attribute__((unused)); }
 namespace ns_not_unused { typedef int Int_not_unused; }
 
 template <typename T> class C;
 template <> class __attribute__((unused)) C<int> {};
 
 void f() {
   ns_not_unused::Int_not_unused i1; // expected-warning {{unused variable}}
   ns_unused::Int_unused i0; // expected-warning {{'Int_unused' was marked unused but was used}}
 
-  union __attribute__((unused)) { // expected-warning {{'' was marked unused but was used}}
+  union __attribute__((unused)) {
+    // expected-warning-re@-1 {{'(anonymous union at {{.*}}:13:3)' was marked unused but was used}}
     int i;
   };
   (void) i;
 
   C<int>(); // expected-warning {{'C<int>' was marked unused but was used}}
 }

clang/test/SemaCXX/cxx0x-nontrivial-union.cpp

union {
       struct {
         X x;
       };
     };
   };
 
   template<typename T> struct Test2 {
     union {
-      struct {  // expected-note {{default constructor of 'Test2<pr16061::X>' is implicitly deleted because variant field '' has a non-trivial default constructor}}
+      struct { // expected-note-re {{default constructor of 'Test2<pr16061::X>' is implicitly deleted because variant field '(unnamed field of type struct (anonymous struct at {{.*}}:139:7))' has a non-trivial default constructor}}
         T x;
       };
     };
   };
 
   Test2<X> t2x;  // expected-error {{call to implicitly-deleted default constructor of 'Test2<pr16061::X>'}}
 }

clang/test/SemaCXX/lambda-expressions.cpp

namespace SpecialMembers {
   struct R {
     R(const R&) = default;
     R(R&&) = delete;
     R &operator=(const R&) = delete;
     R &operator=(R&&) = delete;
   };
   void g(P &p, Q &q, R &r) {
     // FIXME: The note attached to the second error here is just amazingly bad.
-    auto pp = [p]{}; // expected-error {{deleted constructor}} expected-cxx14-error {{deleted copy constructor of '(lambda}}
-    // expected-cxx14-note@-1 {{copy constructor of '' is implicitly deleted because field '' has a deleted copy constructor}}
-    auto qq = [q]{}; // expected-error {{deleted function}} expected-note {{because}}
+    auto pp = [p] {}; // expected-error {{call to deleted constructor of 'SpecialMembers::P'}}
+                      // expected-cxx14-error-re@-1 {{call to implicitly-deleted copy constructor of '(lambda at {{.*}}:123:15)'}}
+                      // expected-cxx14-note-re@-2 {{copy constructor of '(unnamed class at {{.*}}:123:15)' is implicitly deleted because field '(unnamed field at {{.*}}:123:16 of type SpecialMembers::P)' has a deleted copy constructor}}
 
-    auto a = [r]{}; // expected-note 2{{here}}
+    auto qq = [q] {}; // expected-error {{attempt to use a deleted function}}
+                      // expected-note-re@-1 {{destructor of '(unnamed class at {{.*}}:127:15)' is implicitly deleted because field '(unnamed field at {{.*}}:127:16 of type SpecialMembers::Q)' has a deleted destructor}}
+
+    auto a = [r] {}; // expected-note 2{{lambda expression begins here}}
     decltype(a) b = a;
     decltype(a) c = static_cast<decltype(a)&&>(a); // ok, copies R
-    a = a; // expected-error {{copy assignment operator is implicitly deleted}}
-    a = static_cast<decltype(a)&&>(a); // expected-error {{copy assignment operator is implicitly deleted}}
+    a = a;                                         // expected-error-re {{object of type '(lambda at {{.*}}:130:14)' cannot be assigned because its copy assignment operator is implicitly deleted}}
+    a = static_cast<decltype(a) &&>(a);            // expected-error-re {{object of type '(lambda at {{.*}}:130:14)' cannot be assigned because its copy assignment operator is implicitly deleted}}
   }
 }
 
 namespace PR12031 {
   struct X {
     template<typename T>
     X(const T&);
     ~X();

 }
 
 void operator_parens() {
   [&](int x){ operator()(); }(0); // expected-error {{undeclared 'operator()'}}
 }
 
 namespace captured_name {
 void Test() {
-  union {           // expected-note {{'' declared here}}
+  union { // expected-note-re {{'(unnamed variable of type (anonymous union at {{.*}}:658:3))' declared here}}
     int i;
   };
-  [] { return i; }; // expected-error {{variable '' cannot be implicitly captured in a lambda with no capture-default specified}}
+  [] { return i; }; // expected-error-re {{variable '(unnamed variable of type (anonymous union at {{.*}}:658:3))' cannot be implicitly captured in a lambda with no capture-default specified}}
                     // expected-note@-1 {{lambda expression begins here}}
-
 }
 };

clang/test/SemaCXX/ms-interface.cpp

 // RUN: %clang_cc1 %s -fsyntax-only -verify -fms-extensions -Wno-microsoft -std=c++11
 
 __interface I1 {
   // expected-error@+1 {{user-declared constructor is not permitted within an interface type}}
   I1();
   // expected-error@+1 {{user-declared destructor is not permitted within an interface type}}
   ~I1();
   virtual void fn1() const;
   // expected-error@+1 {{operator 'operator!' is not permitted within an interface type}}
   bool operator!();
   // expected-error@+1 {{operator 'operator int' is not permitted within an interface type}}
   operator int();
-  // expected-error@+1 {{nested class I1::(anonymous) is not permitted within an interface type}}
+  // expected-error-re@+1 {{nested class I1::(unnamed struct at {{.*}}:14:3) is not permitted within an interface type}}
   struct { int a; };
   void fn2() {
     struct A { }; // should be ignored: not a nested class
   }
 protected: // expected-error {{interface types cannot specify 'protected' access}}
   typedef void void_t;
   using int_t = int;
 private:   // expected-error {{interface types cannot specify 'private' access}}

clang/test/SemaCXX/warn-large-by-value-copy.cpp

struct S101 {
     char x[101];
 };
 
 S100 f100(S100 s) { return s; }
 
 S101 f101(S101 s) { return s; } // expected-warning {{return value of 'f101' is a large (101 bytes) pass-by-value object}} \
                                 // expected-warning {{'s' is a large (101 bytes) pass-by-value argument}}
 
-void f101_no_param_name(S101) {} // expected-warning {{'' is a large (101 bytes) pass-by-value argument}}
+void f101_no_param_name(S101) {} // expected-warning-re {{'(unnamed variable at {{.*}}:19:29 of type rdar8548050::S101)' is a large (101 bytes) pass-by-value argument}}
 
 // FIXME: Don't warn when when the return value is subject to (N)RVO.
 
 template <typename T> T foo_template(T);
 template <> S101 foo_template(S101) { return S101(); } // expected-warning {{return value of 'foo_template<rdar8548050::S101>' is a large}}
-                                                       // expected-warning@-1 {{'' is a large (101 bytes) pass-by-value argument}}
+                                                       // expected-warning-re@-1 {{'(unnamed variable at {{.*}}:24:35 of type rdar8548050::S101)' is a large (101 bytes) pass-by-value argument}}
 
 typedef int Arr[200];
 void farr(Arr a) { }
 
 struct NonPOD {
   char x[200];
   virtual void m();
 };

clang/test/SemaObjCXX/arc-0x.mm

union U3 {
     U3 & operator=(const U3 &);
     U3 & operator=(U3 &&);
   };
 
   // ObjC pointer fields in anonymous union fields delete the defaulted special
   // functions of the containing class.
   struct S0 {
     union {
-      id f0; // expected-note 6 {{'' is implicitly deleted because variant field 'f0' is an ObjC pointer}}
+      id f0; // expected-note-re 6 {{of '(anonymous union at {{.*}}:156:5)' is implicitly deleted because variant field 'f0' is an ObjC pointer}}
       char f1;
     };
   };
 
   struct S1 {
     union {
-      union { // expected-note {{copy constructor of 'S1' is implicitly deleted because field '' has a deleted copy constructor}} expected-note {{copy assignment operator of 'S1' is implicitly deleted because field '' has a deleted copy assignment operator}} expected-note 4 {{'S1' is implicitly deleted because field '' has a deleted}}
-        id f0; // expected-note 2 {{'' is implicitly deleted because variant field 'f0' is an ObjC pointer}}
+      union {  // expected-note-re {{copy constructor of 'S1' is implicitly deleted because field '(unnamed field of type test_union::S1::(anonymous union at {{.*}}:164:7))' has a deleted copy constructor}}
+               // expected-note-re@-1 {{copy assignment operator of 'S1' is implicitly deleted because field '(unnamed field of type test_union::S1::(anonymous union at{{.*}}:164:7))' has a deleted copy assignment operator}}
+               // expected-note-re@-2 4{{'S1' is implicitly deleted because field '(unnamed field of type test_union::S1::(anonymous union at {{.*}}:164:7))' has a deleted}}
+        id f0; // expected-note-re 2 {{of '(anonymous union at {{.*}}:164:7)' is implicitly deleted because variant field 'f0' is an ObjC pointer}}
         char f1;
       };
       int f2;
     };
   };
 
   struct S2 {
     union {
       // FIXME: the note should say 'f0' is causing the special functions to be deleted.
-      struct { // expected-note 6 {{'S2' is implicitly deleted because variant field '' has a non-trivial}}
+      struct { // expected-note-re 6 {{of 'S2' is implicitly deleted because variant field '(unnamed field of type test_union::S2::(anonymous struct at {{.*}}:177:7))' has a non-trivial}}
         id f0;
         int f1;
       };
       int f2;
     };
     int f3;
   };
 
   U0 *x0;
   U1 *x1;
   U2 *x2;
   U3 *x3;
   S0 *x4;
   S1 *x5;
   S2 *x6;
 
   static union { // expected-error {{call to implicitly-deleted default constructor of}}
-    id g0; // expected-note {{default constructor of '' is implicitly deleted because variant field 'g0' is an ObjC pointer}}
+    id g0;       // expected-note-re {{default constructor of '(anonymous union at {{.*}}:194:10)' is implicitly deleted because variant field 'g0' is an ObjC pointer}}
   };
 
   static union { // expected-error {{call to implicitly-deleted default constructor of}}
-    union { // expected-note {{default constructor of '' is implicitly deleted because field '' has a deleted default constructor}}
-      union { // expected-note {{default constructor of '' is implicitly deleted because field '' has a deleted default constructor}}
-        __weak id g1; // expected-note {{default constructor of '' is implicitly deleted because variant field 'g1' is an ObjC pointer}}
+    union {      // expected-note-re {{default constructor of '(anonymous union at {{.*}}:198:10)' is implicitly deleted because field '(unnamed field of type test_union::(anonymous union at {{.*}}:199:5))' has a deleted default constructor}}
+      union {    // expected-note-re {{default constructor of '(anonymous union at {{.*}}:199:5)' is implicitly deleted because field '(unnamed field of type test_union::(anonymous union at {{.*}}:200:7))' has a deleted default constructor}}
+        __weak id g1; // expected-note-re {{default constructor of '(anonymous union at {{.*}}:200:7)' is implicitly deleted because variant field 'g1' is an ObjC pointer}}
         int g2;
       };
       int g3;
     };
     int g4;
   };
 
   void testDefaultConstructor() {

clang/test/Tooling/clang-diff-ast.cpp

const char *foo(int i) {
     return 0;
   }
 
   // CHECK: AccessSpecDecl: public(
 public:
   int not_initialized;
   // CHECK: CXXConstructorDecl: :X(void (char, int){{( __attribute__\(\(thiscall\)\))?}})(
   // CHECK-NEXT: ParmVarDecl: s(char)
-  // CHECK-NEXT: ParmVarDecl: (int)
+  // CHECK-NEXT: ParmVarDecl: (unnamed variable at {{.*}}:64:16 of type int)(int)
   // CHECK-NEXT: CXXCtorInitializer: Base
   // CHECK-NEXT: CXXConstructExpr
   // CHECK-NEXT: CXXCtorInitializer: m
   // CHECK-NEXT: IntegerLiteral: 0
   X(char s, int) : Base(), m(0) {
     // CHECK-NEXT: CompoundStmt
     // CHECK: MemberExpr: :m(
     int x = m;

clang/unittests/AST/ASTTraverserTest.cpp

 | | |-ParmVarDecl 'g'
 | | |-ParmVarDecl 'h'
 | | | `-IntegerLiteral
 | | `-CompoundStmt
 | |-FieldDecl ''
 | |-FieldDecl ''
 | |-FieldDecl ''
 | |-FieldDecl ''
-| `-CXXDestructorDecl '~'
+| `-CXXDestructorDecl '~(unnamed class at input.cc:9:3)'
 |-ImplicitCastExpr
 | `-DeclRefExpr 'a'
 |-DeclRefExpr 'b'
 |-ImplicitCastExpr
 | `-DeclRefExpr 'd'
 |-DeclRefExpr 'f'
 `-CompoundStmt
 )cpp";