[clang] Provide a better pretty-printed name for unnamed parameters, lambda classes and lambda captures.

[riccibruno]

Summary

As a follow up to D84658:

For an unnamed parameter: (unnamed variable at {{.*}}:<line>:<col> of type <type>) -> (unnamed parameter at {{.*}}:<line>:<col> of type <type>).

For a lambda class: (unnamed class at {{.*}}:<line>:<col>) -> (lambda at {{.*}}:<line>:<col>).

For an unnamed field representing a capture: (unnamed field at {{.*}}:<line>:<col> of type <type>) -> pretty-printed name of the captured variable (except for now in the uncommon case of a captured VLA bound; see the comment).

Additionally add some unit tests for the changes in this patch and in the previous D84658.

[riccibruno]

Make the unit tests in NamedDeclPrinterTest.cpp more robust.

[riccibruno]

Add -fno-delayed-template-parsing to the new unit tests to also pass on Windows.

[riccibruno]

Don't forget to increment the field iterator in the loop of maybePrintFieldForLambdaCapture, and modify the tests to test this.

[aaron.ballman]

LGTM aside from a minor nit.

clang/lib/AST/Decl.cpp

2129

Rather than isa<> followed by a cast<>, how about:

if (const auto *FD = dyn_cast<FieldDecl>(DD)) {
  if (maybePrintFieldForLambdaCapture(...)
    return;
}

Alternatively, you could sink the dyn_cast<> down into maybePrintFieldForLambdaCapture() since that already has to handle case where it's not printing a field capture.

clang/lib/AST/Decl.cpp

static void printUnnamedTag(raw_ostream &OS, const ASTContext &Ctx,
   // 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 ")
+  OS << Policy.getOpenDelimiterForUnnamedEntity();
+
+  if (isa<RecordDecl>(TD) && cast<RecordDecl>(TD)->isLambda()) {
+    OS << "lambda";
+  } else {
+    OS << (IsAnonymousStructOrUnion ? "anonymous " : "unnamed ")
        << TD->getKindName();
+  }
 
   if (Policy.AnonymousTagLocations)
     printPresumedLocationAt(OS, Ctx.getSourceManager(), Policy,
                             TD->getLocation());
 
   OS << Policy.getCloseDelimiterForUnnamedEntity();
 }
 
+/// If \p FD is an unnamed field corresponding to a lambda capture print
+/// the pretty-printed name of the capture and return true. Return false
+/// otherwise.
+static bool maybePrintFieldForLambdaCapture(raw_ostream &OS,
+                                            const PrintingPolicy &Policy,
+                                            const FieldDecl *FD) {
+  assert(FD && "missing field decl!");
+  struct Result {
+    LambdaCaptureKind LCK;
+    const VarDecl *VD;
+  };
+  auto getVarForLambdaField =
+      [](const FieldDecl *FD) -> llvm::Optional<Result> {
+    if (const auto *CXXRD = dyn_cast<CXXRecordDecl>(FD->getParent())) {
+      if (CXXRD->isLambda()) {
+        // For a simple-capture, refer to the captured variable.
+        // For an init-capture, refer to the introduced variable.
+        //
+        // The captures and the fields are in 1-to-1 correspondance.
+        // Look at the fields until we find the corresponding capture.
+        RecordDecl::field_iterator Field = CXXRD->field_begin();
+        for (const LambdaCapture &C : CXXRD->captures()) {
+          if (*Field == FD)
+            return Result{C.getCaptureKind(),
+                          C.capturesVariable() ? C.getCapturedVar() : nullptr};
+        }
+      }
+    }
+    return llvm::None;
+  };
+
+  llvm::Optional<Result> VarForLambdaField = getVarForLambdaField(FD);
+  if (VarForLambdaField) {
+    switch (VarForLambdaField->LCK) {
+    case LCK_This:
+      OS << "this";
+      return true;
+    case LCK_StarThis:
+      OS << "*this";
+      return true;
+    case LCK_ByCopy:
+    case LCK_ByRef:
+      VarForLambdaField->VD->getNameForDiagnostic(OS, Policy,
+                                                  /*Qualified=*/false);
+      return true;
+    case LCK_VLAType:
+      // FIXME: The captured VLA is not stored in the LambdaCapture, so fall
+      // back to displaying (unnamed field at ...).
+      return false;
+    }
+    llvm_unreachable("unexpected LambdaCaptureKind!");
+  }
+
+  return false;
+}
+
 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();
 
+  // The field in a lambda class for a capture is formally unnamed. However if
+  // this field correspond to a capture (either implicit or explicit) we can use
+  // the pretty-printed name of the capture instead.
+  if (isa<FieldDecl>(DD) &&
+      maybePrintFieldForLambdaCapture(OS, Policy, cast<FieldDecl>(DD)))
+    return;
+
   OS << Policy.getOpenDelimiterForUnnamedEntity() << "unnamed "
-     << (isa<FieldDecl>(DD) ? "field" : "variable");
+     << (isa<FieldDecl>(DD) ? "field"
+                            : isa<ParmVarDecl>(DD) ? "parameter" : "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();
   }

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": "~(unnamed class at {{.*}}:4:29)",
+// CHECK-NEXT:    "name": "~(lambda 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": "~(unnamed class at {{.*}}:5:26)",
+// CHECK-NEXT:    "name": "~(lambda 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 parameter '\(unnamed variable at .*:23:30 of type S\)'$}}}}
+  clang_analyzer_explain(conjure_S());   // expected-warning-re{{{{^lazily frozen compound value of parameter '\(unnamed parameter 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/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=(unnamed variable at {{.*}}:9:19 of type int):9:19 (Definition
+// CHECK: Keyword: "int" [9:16 - 9:19] ParmDecl=(unnamed parameter 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=(unnamed variable at {{.*}}:23:25 of type X *):23:25 (Definition)
+// CHECK: Punctuation: "*" [23:24 - 23:25] ParmDecl=(unnamed parameter 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=(unnamed variable at {{.*}}:28:25 of type X *):28:25 (Definition)
+// CHECK: Punctuation: "*" [28:24 - 28:25] ParmDecl=(unnamed parameter 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/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=(unnamed variable at {{.*}}:12:22 of type int):12:22 (Definition)linkage=NoLinkage
+// CHECK: ParmDecl=(unnamed parameter 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=(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]
+// CHECK: load-decls.c:9:21: ParmDecl=(unnamed parameter at {{.*}}:9:21 of type void (*)(int)):9:21 (Definition) Extent=[9:14 - 9:27]
+// CHECK: load-decls.c:9:26: ParmDecl=(unnamed parameter at {{.*}}:9:26 of type int):9:26 (Definition) Extent=[9:23 - 9:26]
+// CHECK: load-decls.c:9:34: ParmDecl=(unnamed parameter 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=(unnamed variable at {{.*}}:19:12 of type int):19:12 (Definition) Extent=[19:9 - 19:12]
+// CHECK: load-namespaces.cpp:19:12: ParmDecl=(unnamed parameter 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=(unnamed variable at {{.*}}:8:15 of type int):8:15 (Definition) Extent=[8:12 - 8:15]
+// CHECK: preamble.c:8:15: ParmDecl=(unnamed parameter 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-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=(unnamed variable at {{.*}}:3:62 of type int):3:62 (Definition) [type=int] [typekind=Int] [isPOD=1]
+// CHECK: ParmDecl=(unnamed parameter 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]

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=(unnamed variable at {{.*}}:36:11 of type int):36:11 (Definition) [type=int] [typekind=Int] [isPOD=1]
+// CHECK: ParmDecl=(unnamed parameter 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=(unnamed variable at {{.*}}:39:11 of type int *):39:11 (Definition) [type=int [5]] [typekind=ConstantArray] [isPOD=1]
+// CHECK: ParmDecl=(unnamed parameter 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=(unnamed variable at {{.*}}:42:11 of type int *):42:11 (Definition) [type=int [size]] [typekind=DependentSizedArray] [isPOD=0]
+// CHECK: ParmDecl=(unnamed parameter 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]

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=(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: Keyword: "const" [7:14 - 7:19] ParmDecl=(unnamed parameter at {{.*}}:7:26 of type const void *):7:26 (Definition)
+// CHECK-tokens: Keyword: "void" [7:20 - 7:24] ParmDecl=(unnamed parameter at {{.*}}:7:26 of type const void *):7:26 (Definition)
+// CHECK-tokens: Punctuation: "*" [7:25 - 7:26] ParmDecl=(unnamed parameter 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=(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: Keyword: "const" [7:28 - 7:33] ParmDecl=(unnamed parameter at {{.*}}:7:40 of type const void *):7:40 (Definition)
+// CHECK-tokens: Keyword: "void" [7:34 - 7:38] ParmDecl=(unnamed parameter at {{.*}}:7:40 of type const void *):7:40 (Definition)
+// CHECK-tokens: Punctuation: "*" [7:39 - 7:40] ParmDecl=(unnamed parameter 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=(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: Keyword: "const" [8:17 - 8:22] ParmDecl=(unnamed parameter at {{.*}}:8:29 of type const char *):8:29 (Definition)
+// CHECK-tokens: Keyword: "char" [8:23 - 8:27] ParmDecl=(unnamed parameter at {{.*}}:8:29 of type const char *):8:29 (Definition)
+// CHECK-tokens: Punctuation: "*" [8:28 - 8:29] ParmDecl=(unnamed parameter 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=(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:26: ParmDecl=(unnamed parameter at {{.*}}:7:26 of type const void *):7:26 (Definition) Extent=[7:14 - 7:26]
+// CHECK: 7:40: ParmDecl=(unnamed parameter at {{.*}}:7:40 of type const void *):7:40 (Definition) Extent=[7:28 - 7:40]
+// CHECK: 7:48: ParmDecl=(unnamed parameter 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=(unnamed variable at {{.*}}:8:29 of type const char *):8:29 (Definition) Extent=[8:17 - 8:29]
+// CHECK: 8:29: ParmDecl=(unnamed parameter 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/usrs.m

 // 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=(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:72:15: ParmDecl=(unnamed parameter at {{.*}}:72:15 of type int):72:15 (Definition) Extent=[72:12 - 72:15]
+// CHECK-source: usrs.m:72:20: ParmDecl=(unnamed parameter at {{.*}}:72:20 of type int):72:20 (Definition) Extent=[72:17 - 72:20]
+// CHECK-source: usrs.m:72:25: ParmDecl=(unnamed parameter 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-re {{parameter '(unnamed variable at {{.*}}:89:42 of type int)' cannot be declared __module_private__}}
+void param_private(__module_private__ int) {} // expected-error-re {{parameter '(unnamed parameter 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/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 {{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}}
+                      // expected-cxx14-error-re@-1 {{call to implicitly-deleted copy constructor of '(lambda at {{.*}}:122:15)'}}
+                      // expected-cxx14-note-re@-2 {{copy constructor of '(lambda at {{.*}}:122:15)' is implicitly deleted because field 'p' has a deleted copy constructor}}
 
     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}}
+                      // expected-note-re@-1 {{destructor of '(lambda at {{.*}}:126:15)' is implicitly deleted because field '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-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}}
+    a = a;                                         // expected-error-re {{object of type '(lambda at {{.*}}:129: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 {{.*}}:129: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-re {{'(unnamed variable of type (anonymous union at {{.*}}:658:3))' declared here}}
+  union { // expected-note-re {{'(unnamed variable of type (anonymous union at {{.*}}:657:3))' declared here}}
     int i;
   };
-  [] { 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}}
+  [] { return i; }; // expected-error-re {{variable '(unnamed variable of type (anonymous union at {{.*}}:657:3))' cannot be implicitly captured in a lambda with no capture-default specified}}
                     // expected-note@-1 {{lambda expression begins here}}
 }
-};
+} // namespace captured_name

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-re {{'(unnamed variable at {{.*}}:19:29 of type rdar8548050::S101)' is a large (101 bytes) pass-by-value argument}}
+void f101_no_param_name(S101) {} // expected-warning-re {{'(unnamed parameter 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-re@-1 {{'(unnamed variable at {{.*}}:24:35 of type rdar8548050::S101)' is a large (101 bytes) pass-by-value argument}}
+                                                       // expected-warning-re@-1 {{'(unnamed parameter 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/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: (unnamed variable at {{.*}}:64:16 of type int)(int)
+  // CHECK-NEXT: ParmVarDecl: (unnamed parameter 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 '~(unnamed class at input.cc:9:3)'
+| `-CXXDestructorDecl '~(lambda at input.cc:9:3)'
 |-ImplicitCastExpr
 | `-DeclRefExpr 'a'
 |-DeclRefExpr 'b'
 |-ImplicitCastExpr
 | `-DeclRefExpr 'd'
 |-DeclRefExpr 'f'
 `-CompoundStmt
 )cpp";

clang/unittests/AST/NamedDeclPrinterTest.cpp

 //===- unittests/AST/NamedDeclPrinterTest.cpp --- NamedDecl printer tests -===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
-// This file contains tests for NamedDecl::printQualifiedName().
+// This file contains tests for NamedDecl::printName()
+// and NamedDecl::printQualifiedName().
 //
 // These tests have a coding convention:
 // * declaration to be printed is named 'A' unless it should have some special
 // name (e.g., 'operator+');
 // * additional helper declarations are 'Z', 'Y', 'X' and so on.
 //
 //===----------------------------------------------------------------------===//
 
::testing::AssertionResult PrintedDeclMatches(
   if (Printer.getPrinted() != ExpectedPrinted)
     return ::testing::AssertionFailure()
         << "Expected \"" << ExpectedPrinted.str() << "\", "
            "got \"" << Printer.getPrinted().str() << "\"";
 
   return ::testing::AssertionSuccess();
 }
 
-::testing::AssertionResult
-PrintedNamedDeclMatches(StringRef Code, const std::vector<std::string> &Args,
-                        bool SuppressUnwrittenScope,
-                        const DeclarationMatcher &NodeMatch,
-                        StringRef ExpectedPrinted, StringRef FileName) {
+::testing::AssertionResult PrintedQualifiedNamedDeclMatches(
+    StringRef Code, const std::vector<std::string> &Args,
+    bool SuppressUnwrittenScope, const DeclarationMatcher &NodeMatch,
   return PrintedDeclMatches(Code, Args, NodeMatch, ExpectedPrinted, FileName,
                             [=](llvm::raw_ostream &Out, const NamedDecl *ND) {
                               auto Policy =
                                   ND->getASTContext().getPrintingPolicy();
                               Policy.SuppressUnwrittenScope =
                                   SuppressUnwrittenScope;
                               ND->printQualifiedName(Out, Policy);
                             });
 }
 
+::testing::AssertionResult PrintedUnqualifiedNamedDeclMatches(
+    StringRef Code, const std::vector<std::string> &Args,
+    const DeclarationMatcher &NodeMatch, StringRef ExpectedPrinted,
+    StringRef FileName) {
+  return PrintedDeclMatches(
+      Code, Args, NodeMatch, ExpectedPrinted, FileName,
+      [=](llvm::raw_ostream &Out, const NamedDecl *ND) { ND->printName(Out); });
+}
+
 ::testing::AssertionResult
-PrintedNamedDeclCXX98Matches(StringRef Code, StringRef DeclName,
+PrintedQualifiedNamedDeclCXX98Matches(StringRef Code, StringRef DeclName,
                                       StringRef ExpectedPrinted) {
   std::vector<std::string> Args(1, "-std=c++98");
-  return PrintedNamedDeclMatches(Code, Args,
-                                 /*SuppressUnwrittenScope*/ false,
-                                 namedDecl(hasName(DeclName)).bind("id"),
-                                 ExpectedPrinted, "input.cc");
+  return PrintedQualifiedNamedDeclMatches(
+      Code, Args,
+      /*SuppressUnwrittenScope*/ false, namedDecl(hasName(DeclName)).bind("id"),
 }
 
 ::testing::AssertionResult
-PrintedWrittenNamedDeclCXX11Matches(StringRef Code, StringRef DeclName,
+PrintedWrittenQualifiedNamedDeclCXX11Matches(StringRef Code, StringRef DeclName,
                                              StringRef ExpectedPrinted) {
   std::vector<std::string> Args(1, "-std=c++11");
-  return PrintedNamedDeclMatches(Code, Args,
-                                 /*SuppressUnwrittenScope*/ true,
-                                 namedDecl(hasName(DeclName)).bind("id"),
-                                 ExpectedPrinted, "input.cc");
+  return PrintedQualifiedNamedDeclMatches(
+      Code, Args,
+      /*SuppressUnwrittenScope*/ true, namedDecl(hasName(DeclName)).bind("id"),
 }
 
-::testing::AssertionResult
-PrintedWrittenPropertyDeclObjCMatches(StringRef Code, StringRef DeclName,
-                                   StringRef ExpectedPrinted) {
+::testing::AssertionResult PrintedWrittenQualifiedPropertyDeclObjCMatches(
+    StringRef Code, StringRef DeclName, StringRef ExpectedPrinted) {
   std::vector<std::string> Args{"-std=c++11", "-xobjective-c++"};
-  return PrintedNamedDeclMatches(Code, Args,
-                                 /*SuppressUnwrittenScope*/ true,
-                                 objcPropertyDecl(hasName(DeclName)).bind("id"),
-                                 ExpectedPrinted, "input.m");
+  return PrintedQualifiedNamedDeclMatches(
+      Code, Args,
+      objcPropertyDecl(hasName(DeclName)).bind("id"), ExpectedPrinted,
+      "input.m");
 }
 
 ::testing::AssertionResult
 PrintedNestedNameSpecifierMatches(StringRef Code, StringRef DeclName,
                                   StringRef ExpectedPrinted) {
   std::vector<std::string> Args{"-std=c++11"};
   return PrintedDeclMatches(Code, Args, namedDecl(hasName(DeclName)).bind("id"),
                             ExpectedPrinted, "input.cc",
                             [](llvm::raw_ostream &Out, const NamedDecl *D) {
                               D->printNestedNameSpecifier(Out);
                             });
 }
 
+::testing::AssertionResult
+PrintedUnqualifiedNamedDeclCXX20Matches(StringRef Code,
+                                        const DeclarationMatcher &NodeMatcher,
+                                        StringRef ExpectedPrinted) {
+  std::vector<std::string> Args(1, "-std=c++20");
+  return PrintedUnqualifiedNamedDeclMatches(Code, Args, NodeMatcher,
+                                            ExpectedPrinted, "input.cc");
+}
+
 } // unnamed namespace
 
 TEST(NamedDeclPrinter, TestNamespace1) {
-  ASSERT_TRUE(PrintedNamedDeclCXX98Matches(
-    "namespace { int A; }",
-    "A",
-    "(anonymous namespace)::A"));
+  ASSERT_TRUE(PrintedQualifiedNamedDeclCXX98Matches(
+      "namespace { int A; }", "A", "(anonymous namespace)::A"));
 }
 
 TEST(NamedDeclPrinter, TestNamespace2) {
-  ASSERT_TRUE(PrintedWrittenNamedDeclCXX11Matches(
-    "inline namespace Z { namespace { int A; } }",
-    "A",
-    "A"));
+  ASSERT_TRUE(PrintedWrittenQualifiedNamedDeclCXX11Matches(
+      "inline namespace Z { namespace { int A; } }", "A", "A"));
 }
 
 TEST(NamedDeclPrinter, TestUnscopedUnnamedEnum) {
-  ASSERT_TRUE(PrintedWrittenNamedDeclCXX11Matches(
-    "enum { A };",
-    "A",
-    "A"));
+  ASSERT_TRUE(
+      PrintedWrittenQualifiedNamedDeclCXX11Matches("enum { A };", "A", "A"));
 }
 
 TEST(NamedDeclPrinter, TestNamedEnum) {
-  ASSERT_TRUE(PrintedWrittenNamedDeclCXX11Matches(
-    "enum X { A };",
-    "A",
-    "A"));
+  ASSERT_TRUE(
+      PrintedWrittenQualifiedNamedDeclCXX11Matches("enum X { A };", "A", "A"));
 }
 
 TEST(NamedDeclPrinter, TestScopedNamedEnum) {
-  ASSERT_TRUE(PrintedWrittenNamedDeclCXX11Matches(
-    "enum class X { A };",
-    "A",
-    "X::A"));
+  ASSERT_TRUE(PrintedWrittenQualifiedNamedDeclCXX11Matches(
+      "enum class X { A };", "A", "X::A"));
 }
 
 TEST(NamedDeclPrinter, TestClassWithUnscopedUnnamedEnum) {
-  ASSERT_TRUE(PrintedWrittenNamedDeclCXX11Matches(
-    "class X { enum { A }; };",
-    "A",
-    "X::A"));
+  ASSERT_TRUE(PrintedWrittenQualifiedNamedDeclCXX11Matches(
+      "class X { enum { A }; };", "A", "X::A"));
 }
 
 TEST(NamedDeclPrinter, TestClassWithUnscopedNamedEnum) {
-  ASSERT_TRUE(PrintedWrittenNamedDeclCXX11Matches(
-    "class X { enum Y { A }; };",
-    "A",
-    "X::A"));
+  ASSERT_TRUE(PrintedWrittenQualifiedNamedDeclCXX11Matches(
+      "class X { enum Y { A }; };", "A", "X::A"));
 }
 
 TEST(NamedDeclPrinter, TestClassWithScopedNamedEnum) {
-  ASSERT_TRUE(PrintedWrittenNamedDeclCXX11Matches(
-    "class X { enum class Y { A }; };",
-    "A",
-    "X::Y::A"));
+  ASSERT_TRUE(PrintedWrittenQualifiedNamedDeclCXX11Matches(
+      "class X { enum class Y { A }; };", "A", "X::Y::A"));
 }
 
 TEST(NamedDeclPrinter, TestLinkageInNamespace) {
-  ASSERT_TRUE(PrintedWrittenNamedDeclCXX11Matches(
-    "namespace X { extern \"C\" { int A; } }",
-    "A",
-    "X::A"));
+  ASSERT_TRUE(PrintedWrittenQualifiedNamedDeclCXX11Matches(
+      "namespace X { extern \"C\" { int A; } }", "A", "X::A"));
 }
 
 TEST(NamedDeclPrinter, TestObjCClassExtension) {
   const char *Code =
 R"(
   @interface Obj
   @end
 
   @interface Obj ()
   @property(nonatomic) int property;
   @end
 )";
-  ASSERT_TRUE(PrintedWrittenPropertyDeclObjCMatches(
-    Code,
-    "property",
+  ASSERT_TRUE(PrintedWrittenQualifiedPropertyDeclObjCMatches(Code, "property",
                                                              "Obj::property"));
 }
 
 TEST(NamedDeclPrinter, TestInstanceObjCClassExtension) {
   const char *Code =
 R"(
 @interface ObjC
 @end
 @interface ObjC () {
   char data; // legal with non-fragile ABI.
 }
 @end
 )";
 
   std::vector<std::string> Args{
       "-std=c++11", "-xobjective-c++",
       "-fobjc-runtime=macosx" /*force to use non-fragile ABI*/};
-  ASSERT_TRUE(PrintedNamedDeclMatches(Code, Args,
-                                      /*SuppressUnwrittenScope*/ true,
-                                      namedDecl(hasName("data")).bind("id"),
-                                      // not "::data"
-                                      "ObjC::data", "input.mm"));
+  ASSERT_TRUE(PrintedQualifiedNamedDeclMatches(
+      Code, Args,
+      /*SuppressUnwrittenScope*/ true, namedDecl(hasName("data")).bind("id"),
 }
 
 TEST(NamedDeclPrinter, TestObjCClassExtensionWithGetter) {
   const char *Code =
 R"(
   @interface Obj
   @end
 
   @interface Obj ()
   @property(nonatomic, getter=myPropertyGetter) int property;
   @end
 )";
-  ASSERT_TRUE(PrintedWrittenPropertyDeclObjCMatches(
-    Code,
-    "property",
+  ASSERT_TRUE(PrintedWrittenQualifiedPropertyDeclObjCMatches(Code, "property",
                                                              "Obj::property"));
 }
 
 TEST(NamedDeclPrinter, NestedNameSpecifierSimple) {
   const char *Code =
       R"(
   namespace foo { namespace bar { void func(); }  }
 )";
   ASSERT_TRUE(PrintedNestedNameSpecifierMatches(Code, "func", "foo::bar::"));
 }
 
 TEST(NamedDeclPrinter, NestedNameSpecifierTemplateArgs) {
   const char *Code =
       R"(
         template <class T> struct vector;
         template <> struct vector<int> { int method(); };
 )";
   ASSERT_TRUE(
       PrintedNestedNameSpecifierMatches(Code, "method", "vector<int>::"));
 }
+
+TEST(NamedDeclPrinter, TestLambdaImplicitCapture1) {
+  ASSERT_TRUE(PrintedUnqualifiedNamedDeclCXX20Matches(
+      "void Test() { int A; [=] { return A; }; }",
+      fieldDecl(allOf(isImplicit(), hasParent(cxxRecordDecl(isLambda()))))
+          .bind("id"),
+      "A"));
+}
+
+TEST(NamedDeclPrinter, TestLambdaImplicitCapture2) {
+  ASSERT_TRUE(PrintedUnqualifiedNamedDeclCXX20Matches(
+      "void Test() { int A; [&] { return A; }; }",
+      fieldDecl(allOf(isImplicit(), hasParent(cxxRecordDecl(isLambda()))))
+          .bind("id"),
+      "A"));
+}
+
+TEST(NamedDeclPrinter, TestLambdaImplicitCapture3) {
+  ASSERT_TRUE(PrintedUnqualifiedNamedDeclCXX20Matches(
+      "struct X { int A; void Test() const; };"
+      "void X::Test() const { [=] { return A; }; }",
+      fieldDecl(allOf(isImplicit(), hasParent(cxxRecordDecl(isLambda()))))
+          .bind("id"),
+      "this"));
+}
+
+TEST(NamedDeclPrinter, TestLambdaImplicitCapture4) {
+  ASSERT_TRUE(PrintedUnqualifiedNamedDeclCXX20Matches(
+      "struct X { int A; void Test() const; };"
+      "void X::Test() const { [&] { return A; }; }",
+      fieldDecl(allOf(isImplicit(), hasParent(cxxRecordDecl(isLambda()))))
+          .bind("id"),
+      "this"));
+}
+
+TEST(NamedDeclPrinter, TestLambdaExplicitCapture1) {
+  ASSERT_TRUE(PrintedUnqualifiedNamedDeclCXX20Matches(
+      "void Test() { int A; [A] { return A; }; }",
+      fieldDecl(allOf(isImplicit(), hasParent(cxxRecordDecl(isLambda()))))
+          .bind("id"),
+      "A"));
+}
+
+TEST(NamedDeclPrinter, TestLambdaExplicitCapture2) {
+  ASSERT_TRUE(PrintedUnqualifiedNamedDeclCXX20Matches(
+      "void Test() { int A; [&A] { return A; }; }",
+      fieldDecl(allOf(isImplicit(), hasParent(cxxRecordDecl(isLambda()))))
+          .bind("id"),
+      "A"));
+}
+
+TEST(NamedDeclPrinter, TestLambdaExplicitCapture3) {
+  ASSERT_TRUE(PrintedUnqualifiedNamedDeclCXX20Matches(
+      "struct X { int A; void Test() const; };"
+      "void X::Test() const { [this] { return A; }; }",
+      fieldDecl(allOf(isImplicit(), hasParent(cxxRecordDecl(isLambda()))))
+          .bind("id"),
+      "this"));
+}
+
+TEST(NamedDeclPrinter, TestLambdaExplicitCapture4) {
+  ASSERT_TRUE(PrintedUnqualifiedNamedDeclCXX20Matches(
+      "struct X { int A; void Test() const; };"
+      "void X::Test() const { [*this] { return A; }; }",
+      fieldDecl(allOf(isImplicit(), hasParent(cxxRecordDecl(isLambda()))))
+          .bind("id"),
+      "*this"));
+}
+
+TEST(NamedDeclPrinter, TestLambdaInitCapture1) {
+  ASSERT_TRUE(PrintedUnqualifiedNamedDeclCXX20Matches(
+      "void Test() { int X; [A=X] { return A; }; }",
+      fieldDecl(allOf(isImplicit(), hasParent(cxxRecordDecl(isLambda()))))
+          .bind("id"),
+      "A"));
+}
+
+TEST(NamedDeclPrinter, TestLambdaInitCapture2) {
+  ASSERT_TRUE(PrintedUnqualifiedNamedDeclCXX20Matches(
+      "void Test() { int X; [&A=X] { return A; }; }",
+      fieldDecl(allOf(isImplicit(), hasParent(cxxRecordDecl(isLambda()))))
+          .bind("id"),
+      "A"));
+}
+
+TEST(NamedDeclPrinter, TestLambdaVLA) {
+  ASSERT_TRUE(PrintedUnqualifiedNamedDeclCXX20Matches(
+      "void Test(int n) { int X[n]; [&X] { return X[0]; }; }",
+      fieldDecl(allOf(isImplicit(), hasType(references(variableArrayType()))))
+          .bind("id"),
+      "(unnamed field at input.cc:1:32 of type int (&)[n])"));
+}
+
+TEST(NamedDeclPrinter, TestLambdaPack1) {
+  ASSERT_TRUE(PrintedUnqualifiedNamedDeclCXX20Matches(
+      "template <typename... Ts> void Test(Ts... ts) {"
+      "[ts...] { return (ts + ...); }; }",
+      fieldDecl(allOf(isImplicit(), hasParent(cxxRecordDecl(isLambda()))))
+          .bind("id"),
+      "ts"));
+}
+
+TEST(NamedDeclPrinter, TestLambdaPack2) {
+  ASSERT_TRUE(PrintedUnqualifiedNamedDeclCXX20Matches(
+      "template <typename... Ts> void Test(Ts... ts) {"
+      "[&ts...] { return (ts + ...); }; }",
+      fieldDecl(allOf(isImplicit(), hasParent(cxxRecordDecl(isLambda()))))
+          .bind("id"),
+      "ts"));
+}
+
+TEST(NamedDeclPrinter, TestLambdaPack3) {
+  ASSERT_TRUE(PrintedUnqualifiedNamedDeclCXX20Matches(
+      "template <typename... Ts> void Test(Ts... ts) {"
+      "[...vs=ts] { return (vs + ...); }; }",
+      fieldDecl(allOf(isImplicit(), hasParent(cxxRecordDecl(isLambda()))))
+          .bind("id"),
+      "vs"));
+}
+
+TEST(NamedDeclPrinter, TestLambdaPack4) {
+  ASSERT_TRUE(PrintedUnqualifiedNamedDeclCXX20Matches(
+      "template <typename... Ts> void Test(Ts... ts) {"
+      "[&...vs=ts] { return (vs + ...); }; }",
+      fieldDecl(allOf(isImplicit(), hasParent(cxxRecordDecl(isLambda()))))
+          .bind("id"),
+      "vs"));
+}
+
+TEST(NamedDeclPrinter, TestUnnamedParameter1) {
+  ASSERT_TRUE(PrintedUnqualifiedNamedDeclCXX20Matches(
+      "void Test(int, float);",
+      functionDecl(
+          allOf(hasName("Test"), hasParameter(1, varDecl().bind("id")))),
+      "(unnamed parameter at input.cc:1:21 of type float)"));
+}
+
+TEST(NamedDeclPrinter, TestUnnamedParameter2) {
+  ASSERT_TRUE(PrintedUnqualifiedNamedDeclCXX20Matches(
+      "struct {} x;"
+      "void Test(decltype(x) &);",
+      functionDecl(
+          allOf(hasName("Test"), hasParameter(0, varDecl().bind("id")))),
+      "(unnamed parameter at input.cc:1:36 of type decltype(x) &)"));
+}
+
+TEST(NamedDeclPrinter, TestAnonymousUnion) {
+  ASSERT_TRUE(PrintedUnqualifiedNamedDeclCXX20Matches(
+      "void Test() { union { int i; }; }",
+      varDecl(hasType(recordType(hasDeclaration(tagDecl(isUnion())))))
+          .bind("id"),
+      "(unnamed variable of type (anonymous union at input.cc:1:15))"));
+}
+
+TEST(NamedDeclPrinter, TestUnnamedStruct) {
+  ASSERT_TRUE(PrintedUnqualifiedNamedDeclCXX20Matches(
+      "void Test() { struct { int i; } s; }",
+      cxxRecordDecl(has(fieldDecl(hasName("i")))).bind("id"),
+      "(unnamed struct at input.cc:1:15)"));
+}
+
+TEST(NamedDeclPrinter, TestLambdaClass) {
+  ASSERT_TRUE(PrintedUnqualifiedNamedDeclCXX20Matches(
+      "void Test() { [] {}; }", cxxRecordDecl(isLambda()).bind("id"),
+      "(lambda at input.cc:1:15)"));
+}
+
+TEST(NamedDeclPrinter, TestUnnamedField) {
+  ASSERT_TRUE(PrintedUnqualifiedNamedDeclCXX20Matches(
+      "struct X { struct { int A; }; };",
+      cxxRecordDecl(has(fieldDecl(hasType(recordType())).bind("id"))),
+      "(unnamed field of type X::(anonymous struct at input.cc:1:12))"));
+}