[clang] ASTImporter: Fix importing of va_list types and declarations

[vabridgers]

Summary

This patch was originally submitted by @mizvekov, then reverted because
it caused crashes on Arm and AArch64. This has since been debugged as a
problem in the DontModifyStdNamespaceCheck.cpp Tidy check exposed by
Arm and AArch64 architectures defining va_list in the std namespace. The
Tidy check was fixed by excluding the implicit cases. See D136886 for
original patch and notes. This patch takes changes from D136886, adds
the fix and LIT cases to cover the fix.

Original description from @mizvekov for the base portion of this fix.

This fixes a problem where __va_list_tag was not correctly imported,
possibly leading to multiple definitions with different types.

This adds __va_list_tag to it's proper scope, so that the ASTImporter
can find it.

Crash seen in original fix, addressed by improvements.

$ clang-tidy crash.cpp -checks="cert-dcl58-cpp" --  -target arm
clang-tidy: <root>/clang-tools-extra/clang-tidy/ClangTidyDiagnosticConsumer.cpp:178:
  clang::DiagnosticBuilder clang::tidy::ClangTidyContext::diag(llvm::StringRef,
  clang::SourceLocation, llvm::StringRef, clang::DiagnosticIDs::Level):
  Assertion `Loc.isValid()' failed.

Stack dump:
0.    Program arguments: clang-tidy crash.cpp -checks=cert-dcl58-cpp -- -target arm
1.    <eof> parser at end of file
2.    ASTMatcher: Processing 'cert-dcl58-cpp' against:
      CXXRecordDecl std::__va_list : <<invalid sloc>>
--- Bound Nodes Begin ---
    decl - { CXXRecordDecl std::__va_list : <<invalid sloc>> }
    nmspc - { NamespaceDecl std : <<invalid sloc>> }
--- Bound Nodes End ---
 #0 llvm::sys::PrintStackTrace(llvm::raw_ostream&, int)
      <root>/llvm/lib/Support/Unix/Signals.inc:567:22
 #1 PrintStackTraceSignalHandler(void*)
      <root>/llvm/lib/Support/Unix/Signals.inc:641:1
 ...
 #9 clang::tidy::ClangTidyContext::diag(llvm::StringRef,
      clang::SourceLocation, llvm::StringRef, clang::DiagnosticIDs::Level)
      <root>/clang-tools-extra/clang-tidy/ClangTidyDiagnosticConsumer.cpp:179:17
      clang::DiagnosticIDs::Level)
      <root>/clang-tools-extra/clang-tidy/ClangTidyCheck.cpp:27:54
      clang::ast_matchers::MatchFinder::MatchResultconst&)
      <root>/clang-tools-extra/clang-tidy/cert/DontModifyStdNamespaceCheck.cpp:121:10

[vabridgers]

Updates per suggestion from @balazske

[vabridgers]

@DavidSpickett and/or @jrtc27 , I started with @mizvekov 's patch ( D136886) and attempted to address the problems with that patch on arm and aarch64. Is it possible for you to try testing this patch and/or commenting? Thank you. - Vince

[vabridgers]

rebase, bump review.

[DavidSpickett]

On AArch64 we have the following failures:

Failed Tests (15):
  Clang :: CXX/basic/basic.stc/basic.stc.dynamic/p2-nodef.cpp
  Clang :: CodeCompletion/ordinary-name-cxx11.cpp
  Clang :: CodeCompletion/ordinary-name.cpp
  Clang :: CodeGenCXX/cxx20-module-std-subst-2b.cpp
  Clang :: CodeGenCXX/cxx20-module-std-subst-2c.cpp
  Clang :: Index/complete-preamble.cpp
  Clang :: Index/load-namespaces.cpp
  Clang :: Modules/implicit-declared-allocation-functions.cppm
  Clang :: PCH/chain-friend-instantiation.cpp
  Clang :: PCH/cxx1z-aligned-alloc.cpp
  Clang :: SemaCXX/constructor-initializer.cpp
  Clang :: SemaCXX/using-directive.cpp
  Clang-Unit :: AST/./ASTTests/ParameterizedTests/DeclContextTest/removeDeclOfClassTemplateSpecialization/0
  Clang-Unit :: StaticAnalyzer/./StaticAnalysisTests/CallDescription/RejectOverQualifiedNames
  Clang-Unit :: StaticAnalyzer/./StaticAnalysisTests/CallDescription/SkipAnonimousNamespaces

None of which are caused by assertions but instead errors of the form:

input.cc:12:7: error: reference to 'std' is ambiguous
      std::container v;
      ^
note: candidate found by name lookup is 'std'
input.cc:3:15: note: candidate found by name lookup is 'my::std'
    namespace std {
              ^
1 error generated.

/home/david.spickett/llvm-project/clang/test/CodeGenCXX/cxx20-module-std-subst-2b.cpp:14:18: error: reference to 'std' is ambiguous
void f(str<char, std::char_traits<char>> &s) {
                 ^
/home/david.spickett/llvm-project/clang/test/CodeGenCXX/cxx20-module-std-subst-2b.cpp:7:11: note: candidate found by name lookup is 'std'
namespace std {
          ^

On Arm it's the exact same set of failures.

What would help you debug those? I don't know the background for the change but I can check specifics on the machine itself if needed.

Test log from AArch64:

tests.log57 KBDownload

[donat.nagy]

clang/test/AST/ast-dump-overloaded-operators.cpp

27

Why did a backtick disappear here and in many other locations? Is this somehow related to va_list handling?

[balazske]

I looked at some of the failing tests but can not decide how to fix the problems. The problem seems to be with the extra namespace std that was not there before. I do not know what the tests are exactly testing. A part of the tests can be fixed by adding new expect lines but these must be platform specific.

clang-tools-extra/test/clang-tidy/checkers/cert/dcl58-cpp.cpp

3

I am not sure if these platform specific should be added. A problem was discovered on this platform but this could be true for all other tests.

[donat.nagy]

In D142822#4102795, @balazske wrote:

I looked at some of the failing tests but can not decide how to fix the problems. The problem seems to be with the extra namespace std that was not there before. I do not know what the tests are exactly testing. A part of the tests can be fixed by adding new expect lines but these must be platform specific.

It seems that your change in Sema.cpp creates the std namespace (or makes it visible?) in some situations where it's not declared by the code and should not be visible. I suspect that this behavior of your commit is not compliant with the standard, and there is precedent that Clang code pays attention to avoiding this sort of thing. For example commit 87f54060 introduces the simple testcase

int *use_new(int N) {
  return new int [N];
}

int std = 17;

which ensures that the std namespace is not visible even if a reference to operator new (whose full type references std:bad_alloc) is present.

I think the commit needs to be updated to avoid "leaking" the std namespace into code that do not declare it.

[whisperity]

In D142822#4095896, @DavidSpickett wrote:

/home/david.spickett/llvm-project/clang/test/CodeGenCXX/cxx20-module-std-subst-2b.cpp:14:18: error: reference to 'std' is ambiguous
void f(str<char, std::char_traits<char>> &s) {
                 ^
/home/david.spickett/llvm-project/clang/test/CodeGenCXX/cxx20-module-std-subst-2b.cpp:7:11: note: candidate found by name lookup is 'std'
namespace std {
          ^

This looks like an ouchie of the highest order. I've been looking into Modules... 5-ish years ago, when it was still under design. There are two major concerns here, one is that we've been having a feature called "Modules" which was very Clang-specific (but a good proof-of-concept spiritual predecessor of what became the Standard Modules), and there are the standard modules. Now the file name explicitly mentions cxx20 so this is likely about Standard Modules stuff. But to be fair, I'd take this implementation with a pinch of salt. Due to the lack of build-system support for Modules (there are some murmurs these days on the CMake GitLab about very soon adding meaningful support for this...) we do not really seem to have large-scale real-world experience as to how the standard really could be made working, especially in such a weird case like touching namespace std which might not be standards-compliant in the first place. (But yeah, we are test code here in a compiler; we can cut ourselves some slack.)

The code itself in these test files is really weird; it seems the test is centred around the idea that there are:

// TU "A"
module; // Code in the *global module fragment*
namespace std { /* ... */ class basic_string; }

export module Whatever; // Code in the public module interface unit of module Whatever.
export /* ... */ using str = std::basic_string<...>;

So we have a symbol called str, which is publicly visible (to TUs importing Whatever), and the namespace std preceding Whatever in TU "A" is not visible but reachable? (The standard's way of expressing reachability is a kind of a mess, so I'd definitely try finding the people who worked in developing the actual solution that makes Standard Modules work in Clang... call the help of someone who's really expert on the Standard...) Perhaps @rsmith could help us clarify this situation.

You can't name std::basic_string<...> in the client code (because it is not visible), but you can depend on the symbol (e.g., decltype it to an alias!) because it is reachable!

And then you have

// TU "B"
import Whatever;

namespace std { /* ... */ struct char_traits {}; }

// use Sb mangling, not Ss, as this is not global-module std::char_traits
/* ... */
void f(str<..., std::char_traits<...>>)

In which there is "another" (?) namespace std, which should(??) also be part of the global module:

The global module is the collection of all global-module-fragments and all translation units that are not module units. Declarations appearing in such a context are said to be in the purview of the global module.

I believe that TU "B" is not a module unit... But the comment (which is somehow misformatted?) in it would like to say that this std is, in fact, not part of the global module.

So somehow, the changes in this patch are making both stds part of the same purview (whatever that means, really...), thus resulting in ambiguity.

• Does this only happen on non-X86? @vabridgers, you could try adding a --target= flag locally in the test file to the compiler invocation and re-running the tests to verify. (Might need an LLVM build that is capable of generating code of other architectures.)
• My other suggestion would be putting some ->dump() calls in your change, running the code and observing how the ASTs are looking in the states when execution is within the functions you're trying to change.

clang/test/AST/ast-dump-traits.cpp

55

How is this change legit? Is this FunctionDecl node just "floating"? If so, why is there a - preceding in the textual dump? Usually top-level nodes do not have such a prefix.

clang/test/AST/fixed_point.c

405

Ditto.

[balazske]

But there should be a way to make the namespace "invisible" like it is done with std::bad_alloc, the linked commit seems to contain the code to "hide" the first std definition and this may not work any more. Another question is why this architecture has a probably not standard requirement. This may be a question for the discourse forum to reach the developers that can make a working fix.

[balazske]

With this fix the std::__va_list is created at initialization of Sema, previously it was not there. Function CreateAArch64ABIBuiltinVaListDecl (ASTContext.cpp) makes the namespace std and __va_list record. This change fixes the problem with ASTImporter probably because the __va_list record exists before start of AST import, this way it is found and added to ASTImporterLookupTable at initialization (the original problem was caused because std::__va_list is missing from ASTImporterLookupTable). But I was thinking of other ways to fix the problem. My old fix for the problem may still work without any test failures:

In D136886#3892261, @balazske wrote:

ASTImporterLookupTable do not contain an entry for __va_list_tag, I do not know why it is missing. If it is added "manually" the crash disappears (without fix in VisitTypedefType). Following code was used to add VaListTagDecl:

ASTImporterLookupTable::ASTImporterLookupTable(TranslationUnitDecl &TU) {
  Builder B(*this);
  B.TraverseDecl(&TU);
  // Add __va_list_tag to the table, it is not visited by the builder.
  if (NamedDecl *D = dyn_cast_or_null<NamedDecl>(TU.getASTContext().getVaListTagDecl()))
    add(&TU, D);
}

The problem probably existed before but did not have visible effect until the new assertion was added.

It can happen (without any of the new fixes) that std::__va_list is created during the AST import process, it is created at first access. This can be the reason why it is missing from the lookup table: It is created implicitly by ASTContext code in the "to" context during import. To fix this problem, I think the above quoted code is a good solution: The va_list declaration is created at start of AST import (if it did not exist yet) (by the get function) and added to the lookup table. Probably it can be a problem that the va_list declaration and std namespace appears in a TU by just importing any code into it, but probably no tests will fail for this case. Another way to fix the problem is to add special handling of std::__va_list at least on the affected platforms to ASTImporterLookupTable but I did not check of this can be done. I do not like to change function ASTImporter::VisitTypedefType like in the very first fix of @vabridgers because it affects how every typedef is imported, and that can be incorrect. Probably some special handling of a record called __va_list at AST import can be a good fix too.

[vabridgers]

@donat.nagy , regarding the namespace leaking, there was a change -> https://reviews.llvm.org/D116774 that modified the behavior for aarch64 and arm. While not incorrect, it may offer some historical view or examples of how to address the current cases.

@whisperity , I'll try your advice and post the results.

clang/test/AST/ast-dump-overloaded-operators.cpp

27

this backspace appeared in the original patch submitted by @mizvekov in review https://reviews.llvm.org/D136886, discussed for the test case clang/test/AST/ast-dump-overloaded-operators.cpp between @aaron.ballman and @mizvekov.

Comments from that review from @mizvekov

<q>
What is happening here (and in all the other such instances) is that on the import case, this declaration stops being the last one on the TU. So the beginning of the line would match on |- instead of `-, but the non-import case this remains the last one.

So I simply relaxed the match.
</q>

[jrtc27]

clang/test/AST/ast-dump-overloaded-operators.cpp

27

Then make this abundantly clear with

{{\||`}}

or whatever the right escaping is (which, incidentally, I can't figure out how to do as inline code in Phabricator...)

[whisperity]

clang-tools-extra/test/clang-tidy/checkers/cert/dcl58-cpp.cpp

3

I agree because there might be a case that some buildbot running the tests won't have these targets. If we really need to explicitly test something related to these targets, perhaps they should go into a separate file, and have a check-prefix. Or the expectation is that things work in the same way across all three platforms?

clang/docs/ReleaseNotes.rst

63

[whisperity]

clang-tools-extra/test/clang-tidy/checkers/cert/dcl58-cpp.cpp

5–6

(Style nits.)

[vabridgers]

Changes are planned. Please do not waste any more time on this for now. This will probably be abandoned.

[balazske]

I have created the new patch D144273 that should fix the same AST import problems as this patch, without change of Sema.

clang-tools-extra/clang-tidy/altera/StructPackAlignCheck.cpp

 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include <math.h>
 
 using namespace clang::ast_matchers;
 
 namespace clang::tidy::altera {
 
 void StructPackAlignCheck::registerMatchers(MatchFinder *Finder) {
-  Finder->addMatcher(recordDecl(isStruct(), isDefinition(),
-                                unless(isExpansionInSystemHeader()))
-                         .bind("struct"),
-                     this);
+  Finder->addMatcher(
+      recordDecl(isStruct(), isDefinition(),
+                 unless(anyOf(isExpansionInSystemHeader(), isImplicit())))
 }
 
 CharUnits
 StructPackAlignCheck::computeRecommendedAlignment(CharUnits MinByteSize) {
   CharUnits NewAlign = CharUnits::fromQuantity(1);
   if (!MinByteSize.isPowerOfTwo()) {
     int MSB = (int)MinByteSize.getQuantity();
     for (; MSB > 0; MSB /= 2) {

clang-tools-extra/clang-tidy/cert/DontModifyStdNamespaceCheck.cpp

return matchesFirstInRange(InnerMatcher, Args.begin(), Args.end(), Finder,
                              Builder) != Args.end();
 }
 
 } // namespace
 
 namespace clang::tidy::cert {
 
 void DontModifyStdNamespaceCheck::registerMatchers(MatchFinder *Finder) {
-  auto HasStdParent =
-      hasDeclContext(namespaceDecl(hasAnyName("std", "posix"),
-                                   unless(hasParent(namespaceDecl())))
-                         .bind("nmspc"));
+  auto HasStdParent = hasDeclContext(
+      namespaceDecl(hasAnyName("std", "posix"),
+                    unless(anyOf(isImplicit(), hasParent(namespaceDecl()))))
   auto UserDefinedType = qualType(
       hasUnqualifiedDesugaredType(tagType(unless(hasDeclaration(tagDecl(
           hasAncestor(namespaceDecl(hasAnyName("std", "posix"),
                                     unless(hasParent(namespaceDecl()))))))))));
   auto HasNoProgramDefinedTemplateArgument = unless(
       hasAnyTemplateArgumentIncludingPack(refersToType(UserDefinedType)));
   auto InsideStdClassOrClassTemplateSpecialization = hasDeclContext(
       anyOf(cxxRecordDecl(HasStdParent),

clang-tools-extra/clang-tidy/utils/RenamerClangTidyCheck.cpp

 RenamerClangTidyCheck::~RenamerClangTidyCheck() = default;
 
 void RenamerClangTidyCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "AggressiveDependentMemberLookup",
                 AggressiveDependentMemberLookup);
 }
 
 void RenamerClangTidyCheck::registerMatchers(MatchFinder *Finder) {
-  Finder->addMatcher(namedDecl().bind("decl"), this);
+  Finder->addMatcher(
+      namedDecl(unless(anyOf(isImplicit(), hasDeclContext(isImplicit()))))
+          .bind("decl"),
+      this);
   Finder->addMatcher(usingDecl().bind("using"), this);
   Finder->addMatcher(declRefExpr().bind("declRef"), this);
   Finder->addMatcher(cxxConstructorDecl(unless(isImplicit())).bind("classRef"),
                      this);
   Finder->addMatcher(cxxDestructorDecl(unless(isImplicit())).bind("classRef"),
                      this);
   Finder->addMatcher(typeLoc().bind("typeLoc"), this);
   Finder->addMatcher(nestedNameSpecifierLoc().bind("nestedNameLoc"), this);

clang-tools-extra/test/clang-tidy/checkers/cert/dcl58-cpp.cpp

 // RUN: %check_clang_tidy -std=c++17-or-later %s cert-dcl58-cpp %t -- -- -I %clang_tidy_headers
+// RUN: %check_clang_tidy -std=c++17-or-later %s cert-dcl58-cpp %t -- -- -I %clang_tidy_headers -target aarch64
+// RUN: %check_clang_tidy -std=c++17-or-later %s cert-dcl58-cpp %t -- -- -I %clang_tidy_headers -target arm
+
+// On arm and arch64 architectures, va_list is within the std namespace.
+// D136886 exposed an issue in the cert-dcl58-cpp checker where
+// implicit namespaces were not ignored.
 
 #include "system-header-simulation.h"
 
 namespace A {
   namespace B {
     int b;
   }
 }

clang/docs/ReleaseNotes.rst

 Bug Fixes
 ---------
 - Fix crash on invalid code when looking up a destructor in a templated class
   inside a namespace. This fixes
   `Issue 59446 <https://github.com/llvm/llvm-project/issues/59446>`_.
 - Fix crash when diagnosing incorrect usage of ``_Nullable`` involving alias
   templates. This fixes
   `Issue 60344 <https://github.com/llvm/llvm-project/issues/60344>`_.
+- Fix importing of va_list types and declarations.
 
 Improvements to Clang's diagnostics
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 - We now generate a diagnostic for signed integer overflow due to unary minus
   in a non-constant expression context. This fixes
   `Issue 31643 <https://github.com/llvm/llvm-project/issues/31643>`_
 
 Non-comprehensive list of changes in this release

clang/lib/Frontend/ASTMerge.cpp

if (!Unit)
       continue;
 
     ASTImporter Importer(CI.getASTContext(), CI.getFileManager(),
                          Unit->getASTContext(), Unit->getFileManager(),
                          /*MinimalImport=*/false, SharedState);
 
     TranslationUnitDecl *TU = Unit->getASTContext().getTranslationUnitDecl();
     for (auto *D : TU->decls()) {
-      // Don't re-import __va_list_tag, __builtin_va_list.
-      if (const auto *ND = dyn_cast<NamedDecl>(D))
-        if (IdentifierInfo *II = ND->getIdentifier())
-          if (II->isStr("__va_list_tag") || II->isStr("__builtin_va_list"))
-            continue;
-
       llvm::Expected<Decl *> ToDOrError = Importer.Import(D);
 
       if (ToDOrError) {
         DeclGroupRef DGR(*ToDOrError);
         CI.getASTConsumer().HandleTopLevelDecl(DGR);
       } else {
         llvm::consumeError(ToDOrError.takeError());
       }

clang/lib/Sema/Sema.cpp

void Sema::Initialize() {
   // Tell the external Sema source about this Sema object.
   if (ExternalSemaSource *ExternalSema
       = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource()))
     ExternalSema->InitializeSema(*this);
 
   // This needs to happen after ExternalSemaSource::InitializeSema(this) or we
   // will not be able to merge any duplicate __va_list_tag decls correctly.
   VAListTagName = PP.getIdentifierInfo("__va_list_tag");
+  (void)PP.getIdentifierInfo("__va_list");
 
   if (!TUScope)
     return;
 
   // Initialize predefined 128-bit integer types, if needed.
   if (Context.getTargetInfo().hasInt128Type() ||
       (Context.getAuxTargetInfo() &&
        Context.getAuxTargetInfo()->hasInt128Type())) {
#include "clang/Basic/WebAssemblyReferenceTypes.def"
   }
 
   if (Context.getTargetInfo().hasBuiltinMSVaList()) {
     DeclarationName MSVaList = &Context.Idents.get("__builtin_ms_va_list");
     if (IdResolver.begin(MSVaList) == IdResolver.end())
       PushOnScopeChains(Context.getBuiltinMSVaListDecl(), TUScope);
   }
 
+  if (auto *ND = dyn_cast_if_present<NamedDecl>(Context.getVaListTagDecl())) {
+    if (auto *DC = ND->getLexicalDeclContext(); DC->isStdNamespace()) {
+      auto *NS = cast<NamespaceDecl>(DC);
+      if (!StdNamespace)
+        StdNamespace = NS;
+      if (!Context.getTranslationUnitDecl()->containsDecl(NS))
+        PushOnScopeChains(NS, TUScope);
+      if (!DC->containsDecl(ND)) {
+        Scope S(TUScope, Scope::DeclScope, getDiagnostics());
+        PushDeclContext(&S, DC);
+        PushOnScopeChains(ND, &S);
+        PopDeclContext();
+      }
+    } else {
+      assert(DC == Context.getTranslationUnitDecl());
+      if (!DC->containsDecl(ND))
+        PushOnScopeChains(ND, TUScope);
+    }
+  }
+
   DeclarationName BuiltinVaList = &Context.Idents.get("__builtin_va_list");
   if (IdResolver.begin(BuiltinVaList) == IdResolver.end())
     PushOnScopeChains(Context.getBuiltinVaListDecl(), TUScope);
 }
 
 Sema::~Sema() {
   assert(InstantiatingSpecializations.empty() &&
          "failed to clean up an InstantiatingTemplate?");

clang/test/AST/ast-dump-file-line-json.c

 // CHECK-NEXT:        }
 // CHECK-NEXT:       }
 // CHECK-NEXT:      ]
 // CHECK-NEXT:     }
 // CHECK-NEXT:    ]
 // CHECK-NEXT:   },
 // CHECK-NEXT:   {
 // CHECK-NEXT:    "id": "0x{{.*}}",
+// CHECK-NEXT:    "kind": "RecordDecl",
+// CHECK-NEXT:    "loc": {},
+// CHECK-NEXT:    "range": {
+// CHECK-NEXT:     "begin": {},
+// CHECK-NEXT:     "end": {}
+// CHECK-NEXT:    },
+// CHECK-NEXT:    "isImplicit": true,
+// CHECK-NEXT:    "name": "__va_list_tag",
+// CHECK-NEXT:    "tagUsed": "struct",
+// CHECK-NEXT:    "completeDefinition": true,
+// CHECK-NEXT:    "inner": [
+// CHECK-NEXT:     {
+// CHECK-NEXT:      "id": "0x{{.*}}",
+// CHECK-NEXT:      "kind": "TypeVisibilityAttr",
+// CHECK-NEXT:      "range": {
+// CHECK-NEXT:       "begin": {},
+// CHECK-NEXT:       "end": {}
+// CHECK-NEXT:      },
+// CHECK-NEXT:      "implicit": true
+// CHECK-NEXT:     },
+// CHECK-NEXT:     {
+// CHECK-NEXT:      "id": "0x{{.*}}",
+// CHECK-NEXT:      "kind": "FieldDecl",
+// CHECK-NEXT:      "loc": {},
+// CHECK-NEXT:      "range": {
+// CHECK-NEXT:       "begin": {},
+// CHECK-NEXT:       "end": {}
+// CHECK-NEXT:      },
+// CHECK-NEXT:      "name": "gp_offset",
+// CHECK-NEXT:      "type": {
+// CHECK-NEXT:       "qualType": "unsigned int"
+// CHECK-NEXT:      }
+// CHECK-NEXT:     },
+// CHECK-NEXT:     {
+// CHECK-NEXT:      "id": "0x{{.*}}",
+// CHECK-NEXT:      "kind": "FieldDecl",
+// CHECK-NEXT:      "loc": {},
+// CHECK-NEXT:      "range": {
+// CHECK-NEXT:       "begin": {},
+// CHECK-NEXT:       "end": {}
+// CHECK-NEXT:      },
+// CHECK-NEXT:      "name": "fp_offset",
+// CHECK-NEXT:      "type": {
+// CHECK-NEXT:       "qualType": "unsigned int"
+// CHECK-NEXT:      }
+// CHECK-NEXT:     },
+// CHECK-NEXT:     {
+// CHECK-NEXT:      "id": "0x{{.*}}",
+// CHECK-NEXT:      "kind": "FieldDecl",
+// CHECK-NEXT:      "loc": {},
+// CHECK-NEXT:      "range": {
+// CHECK-NEXT:       "begin": {},
+// CHECK-NEXT:       "end": {}
+// CHECK-NEXT:      },
+// CHECK-NEXT:      "name": "overflow_arg_area",
+// CHECK-NEXT:      "type": {
+// CHECK-NEXT:       "qualType": "void *"
+// CHECK-NEXT:      }
+// CHECK-NEXT:     },
+// CHECK-NEXT:     {
+// CHECK-NEXT:      "id": "0x{{.*}}",
+// CHECK-NEXT:      "kind": "FieldDecl",
+// CHECK-NEXT:      "loc": {},
+// CHECK-NEXT:      "range": {
+// CHECK-NEXT:       "begin": {},
+// CHECK-NEXT:       "end": {}
+// CHECK-NEXT:      },
+// CHECK-NEXT:      "name": "reg_save_area",
+// CHECK-NEXT:      "type": {
+// CHECK-NEXT:       "qualType": "void *"
+// CHECK-NEXT:      }
+// CHECK-NEXT:     }
+// CHECK-NEXT:    ]
+// CHECK-NEXT:   },
+// CHECK-NEXT:   {
+// CHECK-NEXT:    "id": "0x{{.*}}",
 // CHECK-NEXT:    "kind": "TypedefDecl",
 // CHECK-NEXT:    "loc": {},
 // CHECK-NEXT:    "range": {
 // CHECK-NEXT:     "begin": {},
 // CHECK-NEXT:     "end": {}
 // CHECK-NEXT:    },
 // CHECK-NEXT:    "isImplicit": true,
 // CHECK-NEXT:    "name": "__builtin_va_list",

clang/test/AST/ast-dump-overloaded-operators.cpp

 // CHECK: TranslationUnitDecl {{.*}} <<invalid sloc>> <invalid sloc>{{( <undeserialized declarations>)?}}
 // CHECK: |-EnumDecl {{.*}} <{{.*}}ast-dump-overloaded-operators.cpp:10:1, col:9> col:6{{( imported)?}} referenced E
 // CHECK-NEXT: |-FunctionDecl {{.*}} <line:11:1, col:19> col:6{{( imported)?}} used operator+ 'void (E, E)'
 // CHECK-NEXT: | |-ParmVarDecl {{.*}} <col:16> col:17{{( imported)?}} 'E'
 // CHECK-NEXT: | `-ParmVarDecl {{.*}} <col:18> col:19{{( imported)?}} 'E'
 // CHECK-NEXT: |-FunctionDecl {{.*}} <line:12:1, col:19> col:6{{( imported)?}} used operator, 'void (E, E)'
 // CHECK-NEXT: | |-ParmVarDecl {{.*}} <col:16> col:17{{( imported)?}} 'E'
 // CHECK-NEXT: | `-ParmVarDecl {{.*}} <col:18> col:19{{( imported)?}} 'E'
-// CHECK-NEXT: `-FunctionDecl {{.*}} <line:14:1, line:18:1> line:14:6{{( imported)?}} test 'void ()'
+// CHECK-NEXT:  -FunctionDecl {{.*}} <line:14:1, line:18:1> line:14:6{{( imported)?}} test 'void ()'
 // CHECK-NEXT:   `-CompoundStmt {{.*}} <col:13, line:18:1>
 // CHECK-NEXT:     |-DeclStmt {{.*}} <line:15:3, col:6>
 // CHECK-NEXT:     | `-VarDecl {{.*}} <col:3, col:5> col:5{{( imported)?}} used e 'E'
 // CHECK-NEXT:     |-CXXOperatorCallExpr {{.*}} <line:16:3, col:7> 'void' '+'
 // CHECK-NEXT:     | |-ImplicitCastExpr {{.*}} <col:5> 'void (*)(E, E)' <FunctionToPointerDecay>
 // CHECK-NEXT:     | | `-DeclRefExpr {{.*}} <col:5> 'void (E, E)' lvalue Function {{.*}} 'operator+' 'void (E, E)'
 // CHECK-NEXT:     | |-ImplicitCastExpr {{.*}} <col:3> 'E':'E' <LValueToRValue>
 // CHECK-NEXT:     | | `-DeclRefExpr {{.*}} <col:3> 'E':'E' lvalue Var {{.*}} 'e' 'E'

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

 
 // CHECK-NOT: {{^}}Dumping
 // CHECK:  "kind": "CXXRecordDecl",
 // CHECK-NEXT:  "name": "__NSConstantString_tag"
 // CHECK-NEXT: }
 
 // CHECK-NOT: {{^}}Dumping
 // CHECK:  "kind": "CXXRecordDecl",
+// CHECK-NEXT:  "loc": {},
+// CHECK-NEXT:  "range": {
+// CHECK-NEXT:   "begin": {},
+// CHECK-NEXT:   "end": {}
+// CHECK-NEXT:  },
+// CHECK-NEXT:  "isImplicit": true,
+// CHECK-NEXT:  "name": "__va_list_tag",
+// CHECK-NEXT:  "tagUsed": "struct",
+// CHECK-NEXT:  "completeDefinition": true,
+// CHECK-NEXT:  "definitionData": {
+// CHECK-NEXT:   "canPassInRegisters": true,
+// CHECK-NEXT:   "copyAssign": {
+// CHECK-NEXT:    "hasConstParam": true,
+// CHECK-NEXT:    "implicitHasConstParam": true,
+// CHECK-NEXT:    "needsImplicit": true,
+// CHECK-NEXT:    "simple": true,
+// CHECK-NEXT:    "trivial": true
+// CHECK-NEXT:   },
+// CHECK-NEXT:   "copyCtor": {
+// CHECK-NEXT:    "hasConstParam": true,
+// CHECK-NEXT:    "implicitHasConstParam": true,
+// CHECK-NEXT:    "needsImplicit": true,
+// CHECK-NEXT:    "simple": true,
+// CHECK-NEXT:    "trivial": true
+// CHECK-NEXT:   },
+// CHECK-NEXT:   "defaultCtor": {
+// CHECK-NEXT:    "exists": true,
+// CHECK-NEXT:    "needsImplicit": true,
+// CHECK-NEXT:    "trivial": true
+// CHECK-NEXT:   },
+// CHECK-NEXT:   "dtor": {
+// CHECK-NEXT:    "irrelevant": true,
+// CHECK-NEXT:    "needsImplicit": true,
+// CHECK-NEXT:    "simple": true,
+// CHECK-NEXT:    "trivial": true
+// CHECK-NEXT:   },
+// CHECK-NEXT:   "isAggregate": true,
+// CHECK-NEXT:   "isLiteral": true,
+// CHECK-NEXT:   "isPOD": true,
+// CHECK-NEXT:   "isStandardLayout": true,
+// CHECK-NEXT:   "isTrivial": true,
+// CHECK-NEXT:   "isTriviallyCopyable": true,
+// CHECK-NEXT:   "moveAssign": {
+// CHECK-NEXT:    "exists": true,
+// CHECK-NEXT:    "needsImplicit": true,
+// CHECK-NEXT:    "simple": true,
+// CHECK-NEXT:    "trivial": true
+// CHECK-NEXT:   },
+// CHECK-NEXT:   "moveCtor": {
+// CHECK-NEXT:    "exists": true,
+// CHECK-NEXT:    "needsImplicit": true,
+// CHECK-NEXT:    "simple": true,
+// CHECK-NEXT:    "trivial": true
+// CHECK-NEXT:   }
+// CHECK-NEXT:  },
+// CHECK-NEXT:  "inner": [
+// CHECK-NEXT:   {
+// CHECK-NEXT:    "id": "0x{{.*}}",
+// CHECK-NEXT:    "kind": "TypeVisibilityAttr",
+// CHECK-NEXT:    "range": {
+// CHECK-NEXT:     "begin": {},
+// CHECK-NEXT:     "end": {}
+// CHECK-NEXT:    },
+// CHECK-NEXT:    "implicit": true
+// CHECK-NEXT:   },
+// CHECK-NEXT:   {
+// CHECK-NEXT:    "id": "0x{{.*}}",
+// CHECK-NEXT:    "kind": "FieldDecl",
+// CHECK-NEXT:    "loc": {},
+// CHECK-NEXT:    "range": {
+// CHECK-NEXT:     "begin": {},
+// CHECK-NEXT:     "end": {}
+// CHECK-NEXT:    },
+// CHECK-NEXT:    "name": "gp_offset",
+// CHECK-NEXT:    "type": {
+// CHECK-NEXT:     "qualType": "unsigned int"
+// CHECK-NEXT:    }
+// CHECK-NEXT:   },
+// CHECK-NEXT:   {
+// CHECK-NEXT:    "id": "0x{{.*}}",
+// CHECK-NEXT:    "kind": "FieldDecl",
+// CHECK-NEXT:    "loc": {},
+// CHECK-NEXT:    "range": {
+// CHECK-NEXT:     "begin": {},
+// CHECK-NEXT:     "end": {}
+// CHECK-NEXT:    },
+// CHECK-NEXT:    "name": "fp_offset",
+// CHECK-NEXT:    "type": {
+// CHECK-NEXT:     "qualType": "unsigned int"
+// CHECK-NEXT:    }
+// CHECK-NEXT:   },
+// CHECK-NEXT:   {
+// CHECK-NEXT:    "id": "0x{{.*}}",
+// CHECK-NEXT:    "kind": "FieldDecl",
+// CHECK-NEXT:    "loc": {},
+// CHECK-NEXT:    "range": {
+// CHECK-NEXT:     "begin": {},
+// CHECK-NEXT:     "end": {}
+// CHECK-NEXT:    },
+// CHECK-NEXT:    "name": "overflow_arg_area",
+// CHECK-NEXT:    "type": {
+// CHECK-NEXT:     "qualType": "void *"
+// CHECK-NEXT:    }
+// CHECK-NEXT:   },
+// CHECK-NEXT:   {
+// CHECK-NEXT:    "id": "0x{{.*}}",
+// CHECK-NEXT:    "kind": "FieldDecl",
+// CHECK-NEXT:    "loc": {},
+// CHECK-NEXT:    "range": {
+// CHECK-NEXT:     "begin": {},
+// CHECK-NEXT:     "end": {}
+// CHECK-NEXT:    },
+// CHECK-NEXT:    "name": "reg_save_area",
+// CHECK-NEXT:    "type": {
+// CHECK-NEXT:     "qualType": "void *"
+// CHECK-NEXT:    }
+// CHECK-NEXT:   }
+// CHECK-NEXT:  ]
+// CHECK-NEXT: }
+
+// CHECK-NOT: {{^}}Dumping
+// CHECK:  "kind": "CXXRecordDecl",
 // CHECK-NEXT:  "name": "__va_list_tag"
 // CHECK-NEXT: }
 
 // CHECK-NOT: {{^}}Dumping
 // CHECK:  "kind": "CXXRecordDecl",
 // CHECK-NEXT:  "loc": {
 // CHECK-NEXT:   "offset": {{[0-9]+}},
 // CHECK-NEXT:   "col": 29,

clang/test/AST/ast-dump-records-json.cpp

 
 // CHECK-NOT: {{^}}Dumping
 // CHECK:  "kind": "CXXRecordDecl",
 // CHECK-NEXT:  "name": "__NSConstantString_tag"
 // CHECK-NEXT: }
 
 // CHECK-NOT: {{^}}Dumping
 // CHECK:  "kind": "CXXRecordDecl",
+// CHECK-NEXT:  "loc": {},
+// CHECK-NEXT:  "range": {
+// CHECK-NEXT:   "begin": {},
+// CHECK-NEXT:   "end": {}
+// CHECK-NEXT:  },
+// CHECK-NEXT:  "isImplicit": true,
+// CHECK-NEXT:  "name": "__va_list_tag",
+// CHECK-NEXT:  "tagUsed": "struct",
+// CHECK-NEXT:  "completeDefinition": true,
+// CHECK-NEXT:  "definitionData": {
+// CHECK-NEXT:   "canPassInRegisters": true,
+// CHECK-NEXT:   "copyAssign": {
+// CHECK-NEXT:    "hasConstParam": true,
+// CHECK-NEXT:    "implicitHasConstParam": true,
+// CHECK-NEXT:    "needsImplicit": true,
+// CHECK-NEXT:    "simple": true,
+// CHECK-NEXT:    "trivial": true
+// CHECK-NEXT:   },
+// CHECK-NEXT:   "copyCtor": {
+// CHECK-NEXT:    "hasConstParam": true,
+// CHECK-NEXT:    "implicitHasConstParam": true,
+// CHECK-NEXT:    "needsImplicit": true,
+// CHECK-NEXT:    "simple": true,
+// CHECK-NEXT:    "trivial": true
+// CHECK-NEXT:   },
+// CHECK-NEXT:   "defaultCtor": {
+// CHECK-NEXT:    "exists": true,
+// CHECK-NEXT:    "needsImplicit": true,
+// CHECK-NEXT:    "trivial": true
+// CHECK-NEXT:   },
+// CHECK-NEXT:   "dtor": {
+// CHECK-NEXT:    "irrelevant": true,
+// CHECK-NEXT:    "needsImplicit": true,
+// CHECK-NEXT:    "simple": true,
+// CHECK-NEXT:    "trivial": true
+// CHECK-NEXT:   },
+// CHECK-NEXT:   "isAggregate": true,
+// CHECK-NEXT:   "isLiteral": true,
+// CHECK-NEXT:   "isPOD": true,
+// CHECK-NEXT:   "isStandardLayout": true,
+// CHECK-NEXT:   "isTrivial": true,
+// CHECK-NEXT:   "isTriviallyCopyable": true,
+// CHECK-NEXT:   "moveAssign": {
+// CHECK-NEXT:    "exists": true,
+// CHECK-NEXT:    "needsImplicit": true,
+// CHECK-NEXT:    "simple": true,
+// CHECK-NEXT:    "trivial": true
+// CHECK-NEXT:   },
+// CHECK-NEXT:   "moveCtor": {
+// CHECK-NEXT:    "exists": true,
+// CHECK-NEXT:    "needsImplicit": true,
+// CHECK-NEXT:    "simple": true,
+// CHECK-NEXT:    "trivial": true
+// CHECK-NEXT:   }
+// CHECK-NEXT:  },
+// CHECK-NEXT:  "inner": [
+// CHECK-NEXT:   {
+// CHECK-NEXT:    "id": "0x{{.*}}",
+// CHECK-NEXT:    "kind": "TypeVisibilityAttr",
+// CHECK-NEXT:    "range": {
+// CHECK-NEXT:     "begin": {},
+// CHECK-NEXT:     "end": {}
+// CHECK-NEXT:    },
+// CHECK-NEXT:    "implicit": true
+// CHECK-NEXT:   },
+// CHECK-NEXT:   {
+// CHECK-NEXT:    "id": "0x{{.*}}",
+// CHECK-NEXT:    "kind": "FieldDecl",
+// CHECK-NEXT:    "loc": {},
+// CHECK-NEXT:    "range": {
+// CHECK-NEXT:     "begin": {},
+// CHECK-NEXT:     "end": {}
+// CHECK-NEXT:    },
+// CHECK-NEXT:    "name": "gp_offset",
+// CHECK-NEXT:    "type": {
+// CHECK-NEXT:     "qualType": "unsigned int"
+// CHECK-NEXT:    }
+// CHECK-NEXT:   },
+// CHECK-NEXT:   {
+// CHECK-NEXT:    "id": "0x{{.*}}",
+// CHECK-NEXT:    "kind": "FieldDecl",
+// CHECK-NEXT:    "loc": {},
+// CHECK-NEXT:    "range": {
+// CHECK-NEXT:     "begin": {},
+// CHECK-NEXT:     "end": {}
+// CHECK-NEXT:    },
+// CHECK-NEXT:    "name": "fp_offset",
+// CHECK-NEXT:    "type": {
+// CHECK-NEXT:     "qualType": "unsigned int"
+// CHECK-NEXT:    }
+// CHECK-NEXT:   },
+// CHECK-NEXT:   {
+// CHECK-NEXT:    "id": "0x{{.*}}",
+// CHECK-NEXT:    "kind": "FieldDecl",
+// CHECK-NEXT:    "loc": {},
+// CHECK-NEXT:    "range": {
+// CHECK-NEXT:     "begin": {},
+// CHECK-NEXT:     "end": {}
+// CHECK-NEXT:    },
+// CHECK-NEXT:    "name": "overflow_arg_area",
+// CHECK-NEXT:    "type": {
+// CHECK-NEXT:     "qualType": "void *"
+// CHECK-NEXT:    }
+// CHECK-NEXT:   },
+// CHECK-NEXT:   {
+// CHECK-NEXT:    "id": "0x{{.*}}",
+// CHECK-NEXT:    "kind": "FieldDecl",
+// CHECK-NEXT:    "loc": {},
+// CHECK-NEXT:    "range": {
+// CHECK-NEXT:     "begin": {},
+// CHECK-NEXT:     "end": {}
+// CHECK-NEXT:    },
+// CHECK-NEXT:    "name": "reg_save_area",
+// CHECK-NEXT:    "type": {
+// CHECK-NEXT:     "qualType": "void *"
+// CHECK-NEXT:    }
+// CHECK-NEXT:   }
+// CHECK-NEXT:  ]
+// CHECK-NEXT: }
+
+// CHECK-NOT: {{^}}Dumping
+// CHECK:  "kind": "CXXRecordDecl",
 // CHECK-NEXT:  "name": "__va_list_tag"
 // CHECK-NEXT: }
 
 // CHECK-NOT: {{^}}Dumping
 // CHECK:  "kind": "CXXRecordDecl",
 // CHECK-NEXT:  "loc": {
 // CHECK-NEXT:   "offset": {{[0-9]+}},
 // CHECK-NEXT:   "file": "{{.*}}",

clang/test/AST/ast-dump-records.cpp

// CHECK: |-CXXRecordDecl {{.*}} struct CheckFullExpression definition
   NonTrivial value = NonTrivial();
 // CHECK: | |-FieldDecl {{.*}} value 'NonTrivial':'NonTrivial'
 // CHECK-NEXT: | | `-ExprWithCleanups {{.*}} 'NonTrivial':'NonTrivial'
 // CHECK-NEXT: | |   `-CXXBindTemporaryExpr {{.*}} 'NonTrivial':'NonTrivial' (CXXTemporary{{.*}})
 // CHECK-NEXT: | |     `-CXXTemporaryObjectExpr {{.*}} 'NonTrivial':'NonTrivial' 'void ()'
 };
 
 struct CheckNoCleanup {
-// CHECK: `-CXXRecordDecl {{.*}} struct CheckNoCleanup definition
+// CHECK: {{.*}}-CXXRecordDecl {{.*}} struct CheckNoCleanup definition
   static constexpr char kConstant = '+';
 // CHECK: `-VarDecl {{.*}} kConstant 'const char' static inline constexpr cinit
 // CHECK-NEXT: |-value: Int 43
 // CHECK-NEXT: `-CharacterLiteral {{.*}} 'char' 43
 };

clang/test/AST/ast-dump-template-decls-json.cpp

 // CHECK-NEXT:        }
 // CHECK-NEXT:       }
 // CHECK-NEXT:      ]
 // CHECK-NEXT:     }
 // CHECK-NEXT:    ]
 // CHECK-NEXT:   },
 // CHECK-NEXT:   {
 // CHECK-NEXT:    "id": "0x{{.*}}",
+// CHECK-NEXT:    "kind": "CXXRecordDecl",
+// CHECK-NEXT:    "loc": {},
+// CHECK-NEXT:    "range": {
+// CHECK-NEXT:     "begin": {},
+// CHECK-NEXT:     "end": {}
+// CHECK-NEXT:    },
+// CHECK-NEXT:    "isImplicit": true,
+// CHECK-NEXT:    "name": "__va_list_tag",
+// CHECK-NEXT:    "tagUsed": "struct",
+// CHECK-NEXT:    "completeDefinition": true,
+// CHECK-NEXT:    "definitionData": {
+// CHECK-NEXT:     "canPassInRegisters": true,
+// CHECK-NEXT:     "copyAssign": {
+// CHECK-NEXT:      "hasConstParam": true,
+// CHECK-NEXT:      "implicitHasConstParam": true,
+// CHECK-NEXT:      "needsImplicit": true,
+// CHECK-NEXT:      "simple": true,
+// CHECK-NEXT:      "trivial": true
+// CHECK-NEXT:     },
+// CHECK-NEXT:     "copyCtor": {
+// CHECK-NEXT:      "hasConstParam": true,
+// CHECK-NEXT:      "implicitHasConstParam": true,
+// CHECK-NEXT:      "needsImplicit": true,
+// CHECK-NEXT:      "simple": true,
+// CHECK-NEXT:      "trivial": true
+// CHECK-NEXT:     },
+// CHECK-NEXT:     "defaultCtor": {
+// CHECK-NEXT:      "exists": true,
+// CHECK-NEXT:      "needsImplicit": true,
+// CHECK-NEXT:      "trivial": true
+// CHECK-NEXT:     },
+// CHECK-NEXT:     "dtor": {
+// CHECK-NEXT:      "irrelevant": true,
+// CHECK-NEXT:      "needsImplicit": true,
+// CHECK-NEXT:      "simple": true,
+// CHECK-NEXT:      "trivial": true
+// CHECK-NEXT:     },
+// CHECK-NEXT:     "isAggregate": true,
+// CHECK-NEXT:     "isLiteral": true,
+// CHECK-NEXT:     "isPOD": true,
+// CHECK-NEXT:     "isStandardLayout": true,
+// CHECK-NEXT:     "isTrivial": true,
+// CHECK-NEXT:     "isTriviallyCopyable": true,
+// CHECK-NEXT:     "moveAssign": {
+// CHECK-NEXT:      "exists": true,
+// CHECK-NEXT:      "needsImplicit": true,
+// CHECK-NEXT:      "simple": true,
+// CHECK-NEXT:      "trivial": true
+// CHECK-NEXT:     },
+// CHECK-NEXT:     "moveCtor": {
+// CHECK-NEXT:      "exists": true,
+// CHECK-NEXT:      "needsImplicit": true,
+// CHECK-NEXT:      "simple": true,
+// CHECK-NEXT:      "trivial": true
+// CHECK-NEXT:     }
+// CHECK-NEXT:    },
+// CHECK-NEXT:    "inner": [
+// CHECK-NEXT:     {
+// CHECK-NEXT:      "id": "0x{{.*}}",
+// CHECK-NEXT:      "kind": "TypeVisibilityAttr",
+// CHECK-NEXT:      "range": {
+// CHECK-NEXT:       "begin": {},
+// CHECK-NEXT:       "end": {}
+// CHECK-NEXT:      },
+// CHECK-NEXT:      "implicit": true
+// CHECK-NEXT:     },
+// CHECK-NEXT:     {
+// CHECK-NEXT:      "id": "0x{{.*}}",
+// CHECK-NEXT:      "kind": "FieldDecl",
+// CHECK-NEXT:      "loc": {},
+// CHECK-NEXT:      "range": {
+// CHECK-NEXT:       "begin": {},
+// CHECK-NEXT:       "end": {}
+// CHECK-NEXT:      },
+// CHECK-NEXT:      "name": "gp_offset",
+// CHECK-NEXT:      "type": {
+// CHECK-NEXT:       "qualType": "unsigned int"
+// CHECK-NEXT:      }
+// CHECK-NEXT:     },
+// CHECK-NEXT:     {
+// CHECK-NEXT:      "id": "0x{{.*}}",
+// CHECK-NEXT:      "kind": "FieldDecl",
+// CHECK-NEXT:      "loc": {},
+// CHECK-NEXT:      "range": {
+// CHECK-NEXT:       "begin": {},
+// CHECK-NEXT:       "end": {}
+// CHECK-NEXT:      },
+// CHECK-NEXT:      "name": "fp_offset",
+// CHECK-NEXT:      "type": {
+// CHECK-NEXT:       "qualType": "unsigned int"
+// CHECK-NEXT:      }
+// CHECK-NEXT:     },
+// CHECK-NEXT:     {
+// CHECK-NEXT:      "id": "0x{{.*}}",
+// CHECK-NEXT:      "kind": "FieldDecl",
+// CHECK-NEXT:      "loc": {},
+// CHECK-NEXT:      "range": {
+// CHECK-NEXT:       "begin": {},
+// CHECK-NEXT:       "end": {}
+// CHECK-NEXT:      },
+// CHECK-NEXT:      "name": "overflow_arg_area",
+// CHECK-NEXT:      "type": {
+// CHECK-NEXT:       "qualType": "void *"
+// CHECK-NEXT:      }
+// CHECK-NEXT:     },
+// CHECK-NEXT:     {
+// CHECK-NEXT:      "id": "0x{{.*}}",
+// CHECK-NEXT:      "kind": "FieldDecl",
+// CHECK-NEXT:      "loc": {},
+// CHECK-NEXT:      "range": {
+// CHECK-NEXT:       "begin": {},
+// CHECK-NEXT:       "end": {}
+// CHECK-NEXT:      },
+// CHECK-NEXT:      "name": "reg_save_area",
+// CHECK-NEXT:      "type": {
+// CHECK-NEXT:       "qualType": "void *"
+// CHECK-NEXT:      }
+// CHECK-NEXT:     }
+// CHECK-NEXT:    ]
+// CHECK-NEXT:   },
+// CHECK-NEXT:   {
+// CHECK-NEXT:    "id": "0x{{.*}}",
 // CHECK-NEXT:    "kind": "TypedefDecl",
 // CHECK-NEXT:    "loc": {},
 // CHECK-NEXT:    "range": {
 // CHECK-NEXT:     "begin": {},
 // CHECK-NEXT:     "end": {}
 // CHECK-NEXT:    },
 // CHECK-NEXT:    "isImplicit": true,
 // CHECK-NEXT:    "name": "__builtin_va_list",

clang/test/AST/ast-dump-traits.cpp

 // CHECK-NEXT: |-FunctionDecl {{.*}} <line:20:1, line:23:1> line:20:6{{( imported)?}} test_array_type_trait 'void ()'
 // CHECK-NEXT: | `-CompoundStmt {{.*}} <col:30, line:23:1>
 // CHECK-NEXT: |   `-CStyleCastExpr {{.*}} <line:22:3, col:34> 'void' <ToVoid>
 // CHECK-NEXT: |     `-ArrayTypeTraitExpr {{.*}} <col:10, col:34> 'unsigned long' __array_rank
 // CHECK-NEXT: |-FunctionDecl {{.*}} <line:25:1, line:28:1> line:25:6{{( imported)?}} test_expression_trait 'void ()'
 // CHECK-NEXT: | `-CompoundStmt {{.*}} <col:30, line:28:1>
 // CHECK-NEXT: |   `-CStyleCastExpr {{.*}} <line:27:3, col:28> 'void' <ToVoid>
 // CHECK-NEXT: |     `-ExpressionTraitExpr {{.*}} <col:10, col:28> 'bool' __is_lvalue_expr
-// CHECK-NEXT: `-FunctionDecl {{.*}} <line:30:1, line:35:1> line:30:6{{( imported)?}} test_unary_expr_or_type_trait 'void ()'
+// CHECK-NEXT:  -FunctionDecl {{.*}} <line:30:1, line:35:1> line:30:6{{( imported)?}} test_unary_expr_or_type_trait 'void ()'
 // CHECK-NEXT:   `-CompoundStmt {{.*}} <col:38, line:35:1>
 // CHECK-NEXT:     |-CStyleCastExpr {{.*}} <line:32:3, col:20> 'void' <ToVoid>
 // CHECK-NEXT:     | `-UnaryExprOrTypeTraitExpr {{.*}} <col:10, col:20> 'unsigned long' sizeof 'int'
 // CHECK-NEXT:     |-CStyleCastExpr {{.*}} <line:33:3, col:21> 'void' <ToVoid>
 // CHECK-NEXT:     | `-UnaryExprOrTypeTraitExpr {{.*}} <col:10, col:21> 'unsigned long' alignof 'int'
 // CHECK-NEXT:     `-CStyleCastExpr {{.*}} <line:34:3, col:23> 'void' <ToVoid>
 // CHECK-NEXT:       `-UnaryExprOrTypeTraitExpr {{.*}} <col:10, col:23> 'unsigned long' __alignof 'int'

clang/test/AST/fixed_point.c

 //CHECK-NEXT:   `-FixedPointLiteral {{.*}} 'unsigned short _Fract' 0.99609375
 //CHECK-NEXT: |-VarDecl {{.*}} u_fract_one 'unsigned _Fract' cinit
 //CHECK-NEXT:   `-FixedPointLiteral {{.*}} 'unsigned _Fract' 0.9999847412109375
 //CHECK-NEXT: |-VarDecl {{.*}} u_long_fract_one 'unsigned long _Fract' cinit
 //CHECK-NEXT:   `-FixedPointLiteral {{.*}} 'unsigned long _Fract' 0.99999999976716935634613037109375
 
 _Accum literallast = 1.0k;    // One
 
-//CHECK-NEXT: `-VarDecl {{.*}} literallast '_Accum' cinit
+//CHECK-NEXT:  -VarDecl {{.*}} literallast '_Accum' cinit
 //CHECK-NEXT:   `-FixedPointLiteral {{.*}} '_Accum' 1.0

clang/test/AST/float16.cpp

namespace {
   _Float16 f2n = 33.f16;
   _Float16 arr1n[10];
   _Float16 arr2n[] = { 1.2, 3.0, 3.e4 };
   const volatile _Float16 func1n(const _Float16 &arg) {
     return arg + f2n + arr1n[4] - arr2n[1];
   }
 }
 
-//CHECK:      |-NamespaceDecl
+//CHECK:      |-NamespaceDecl {{.*}} <{{.*}}:22:1,
 //CHECK-NEXT: | |-VarDecl {{.*}} f1n '_Float16'
 //CHECK-NEXT: | |-VarDecl {{.*}} f2n '_Float16' cinit
 //CHECK-NEXT: | | `-FloatingLiteral {{.*}} '_Float16' 3.300000e+01
 //CHECK-NEXT: | |-VarDecl {{.*}} arr1n '_Float16[10]'
 //CHECK-NEXT: | |-VarDecl {{.*}} arr2n '_Float16[3]' cinit
 //CHECK-NEXT: | | `-InitListExpr {{.*}} '_Float16[3]'
 //CHECK-NEXT: | |   |-ImplicitCastExpr {{.*}} '_Float16' <FloatingCast>
 //CHECK-NEXT: | |   | `-FloatingLiteral {{.*}} 'double' 1.200000e+00

clang/test/PCH/stmt-openmp_structured_block-bit.cpp

 // Test this without pch.
 // RUN: %clang_cc1 -std=c++11 -fopenmp -fsyntax-only -verify %s -ast-dump-all | FileCheck %s -implicit-check-not=openmp_structured_block
 
 // Test with pch. Use '-ast-dump' to force deserialization of function bodies.
 // RUN: %clang_cc1 -std=c++11 -fopenmp -emit-pch -o %t %s
 // RUN: echo "// expected-no-diagnostics" | %clang_cc1 -x c++ -std=c++11 -include-pch %t -fopenmp -fsyntax-only -verify - -ast-dump-all | FileCheck %s -implicit-check-not=openmp_structured_block
 
 void test() {
 #pragma omp parallel
   ;
 }
 
 // expected-no-diagnostics
 
 // CHECK: TranslationUnitDecl 0x{{.*}} <<invalid sloc>> <invalid sloc>
-// CHECK: `-FunctionDecl 0x{{.*}} <{{.*}}stmt-openmp_structured_block-bit.cpp:8:1, line:11:1> line:8:6 {{(test|imported test)}} 'void ()'
+// CHECK:  -FunctionDecl 0x{{.*}} <{{.*}}stmt-openmp_structured_block-bit.cpp:8:1, line:11:1> line:8:6 {{(test|imported test)}} 'void ()'
 // CHECK-NEXT:   `-CompoundStmt 0x{{.*}} <col:13, line:11:1>
 // CHECK-NEXT:     `-OMPParallelDirective 0x{{.*}} <line:9:1, col:21>
 // CHECK-NEXT:       `-CapturedStmt 0x{{.*}} <line:10:3>
 // CHECK-NEXT:         `-CapturedDecl 0x{{.*}} <<invalid sloc>> <invalid sloc> {{(nothrow|imported <undeserialized declarations> nothrow)}}
 // CHECK-NEXT:           |-NullStmt 0x{{.*}} <col:3>
 // CHECK-NEXT:           |-ImplicitParamDecl 0x{{.*}} <line:9:1> col:1 {{(implicit|imported implicit)}} .global_tid. 'const int *const __restrict'
 // CHECK-NEXT:           |-ImplicitParamDecl 0x{{.*}} <col:1> col:1 {{(implicit|imported implicit)}} .bound_tid. 'const int *const __restrict'
 // CHECK-NEXT:           `-ImplicitParamDecl 0x{{.*}} <col:1> col:1 {{(implicit|imported implicit)}} __context '(unnamed struct at {{.*}}stmt-openmp_structured_block-bit.cpp:9:1) *const __restrict'

clang/unittests/AST/ASTImporterTest.cpp

auto Code =
         R"(
         namespace x {
           template<class X> struct S1{};
           template<class X> struct S2{};
           template<class X> struct S3{};
         }
         )";
   Decl *FromTU = getTuDecl(Code, Lang_CXX03);
-  auto FromNs =
-      FirstDeclMatcher<NamespaceDecl>().match(FromTU, namespaceDecl());
+  auto FromNs = FirstDeclMatcher<NamespaceDecl>().match(
+      FromTU, namespaceDecl(hasName("x")));
   auto ToNs = cast<NamespaceDecl>(Import(FromNs, Lang_CXX03));
   ASSERT_TRUE(ToNs);
   auto From =
       FirstDeclMatcher<ClassTemplateDecl>().match(FromTU,
                                                   classTemplateDecl(
                                                       hasName("S2")));
   auto To =
       FirstDeclMatcher<ClassTemplateDecl>().match(ToNs,
TEST_P(ASTImporterOptionSpecificTestBase, ImportOfCapturedVLAType) {
   Decl *FromTU = getTuDecl(
       R"(
       void declToImport(int N) {
         int VLA[N];
         [&VLA] {}; // FieldDecl inside the lambda.
       }
       )",
       Lang_CXX14);
-  auto *FromFD = FirstDeclMatcher<FieldDecl>().match(FromTU, fieldDecl());
+
+  auto *FromF = FirstDeclMatcher<FunctionDecl>().match(
+      FromTU, functionDecl(hasName("declToImport")));
+  CXXRecordDecl *FromLambda =
+      cast<LambdaExpr>((cast<CompoundStmt>(FromF->getBody())->body_back()))
+          ->getLambdaClass();
+
+  auto *FromFD = *FromLambda->field_begin();
   ASSERT_TRUE(FromFD);
   ASSERT_TRUE(FromFD->hasCapturedVLAType());
 
   auto *ToFD = Import(FromFD, Lang_CXX14);
   EXPECT_TRUE(ToFD);
   EXPECT_TRUE(ToFD->hasCapturedVLAType());
   EXPECT_NE(FromFD->getCapturedVLAType(), ToFD->getCapturedVLAType());
 }
TEST_P(ASTImporterOptionSpecificTestBase, isNewDecl) {
 
   auto *ToBar = FirstDeclMatcher<FunctionDecl>().match(
       ToTU, functionDecl(hasName("bar")));
 
   EXPECT_TRUE(SharedStatePtr->isNewDecl(ToOther));
   EXPECT_FALSE(SharedStatePtr->isNewDecl(ToBar));
 }
 
+TEST_P(ASTImporterOptionSpecificTestBase, VaList) {
+  Decl *FromTU = getTuDecl(R"(typedef __builtin_va_list va_list;)", Lang_C99);
+
+  auto *FromVaList = FirstDeclMatcher<TypedefDecl>().match(
+      FromTU, typedefDecl(hasName("va_list")));
+  ASSERT_TRUE(FromVaList);
+
+  auto *ToVaList = Import(FromVaList, Lang_C99);
+  ASSERT_TRUE(ToVaList);
+
+  auto *ToBuiltinVaList = FirstDeclMatcher<TypedefDecl>().match(
+      ToAST->getASTContext().getTranslationUnitDecl(),
+      typedefDecl(hasName("__builtin_va_list")));
+
+  ASSERT_TRUE(ToAST->getASTContext().hasSameType(
+      ToVaList->getUnderlyingType(), ToBuiltinVaList->getUnderlyingType()));
+}
+
 INSTANTIATE_TEST_SUITE_P(ParameterizedTests, ASTImporterLookupTableTest,
                          DefaultTestValuesForRunOptions);
 
 INSTANTIATE_TEST_SUITE_P(ParameterizedTests, ImportPath,
                          ::testing::Values(std::vector<std::string>()));
 
 INSTANTIATE_TEST_SUITE_P(ParameterizedTests, ImportExpr,
                          DefaultTestValuesForRunOptions);