[clang] Prevent that Decl::dump on a CXXRecordDecl deserialises further declarations.

[teemperor]

Summary

Decl::dump is primarily used for debugging to visualise the current state of a declaration. Usually
Decl::dump just displays the current state of the Decl and doesn't actually change any of its
state, however since commit 457226e02a6e8533eaaa864a3fd7c8eeccd2bf58 the method
actually started loading additional declarations from the ExternalASTSource. This causes that
calling Decl::dump during a debugging session now actually does permanent changes to the
AST and will cause the debugged program run to deviate from the original run.

The change that caused this behaviour is the addition of hasConstexprDestructor
(which is called from the TextNodeDumper) which performs a lookup into the current
CXXRecordDecl to find the destructor. All other similar methods just return their
respective bit in the DefinitionData (which obviously doesn't have such side effects).

This just changes the node printer to emit "unknown_constexpr" in case a CXXRecordDecl
is dumped that could potentially call into the ExternalASTSource instead of the
usually empty string/"constexpr". For CXXRecordDecls that can safely be dumped the
old behaviour is preserved

[bruno]

Neat unit test! LGTM (one minor suggestion below).

clang/lib/AST/TextNodeDumper.cpp

1700

How about maybe_constexpr?

[teemperor]

• rename to maybe_constexpr
• Update some dump output tests

[riccibruno]

And what if deserialization is forced?

[teemperor]

In D80878#2258942, @riccibruno wrote:

And what if deserialization is forced?

That's a good point. That should indeed continue to work with the ASTDumper and now (potentially) doesn't. I'll revert.

[teemperor]

• Respect forced deserialisation.

[aprantl]

@teemperor is there a reason why the fixed patch never landed? This looks a good improvement to have.

[teemperor]

This is technically in the "Waiting on Review" queue, that's why I also added another reviewer :). The original revision got accepted and then I reverted and updated the patch/test to honor the Deserialize value (which was broken in the first version). I guess the fact that this got reviewed, landed, reverted and back into review caused some confusion

Also obligatory "friendly ping" on this :)

[vsapsai]

clang/lib/AST/ASTDumper.cpp

199 ↗

(On Diff #301577)

It is possible it will complicate the implementation too much but what if P.setDeserialize(Deserialize); is responsible for propagating Deserialize to its NodeDelegate?

[teemperor]

• Make setter propagate 'deserialize' to the node dumper (thanks Volodymyr!)

[vsapsai]

As long as JSON dumper still compiles, it looks good to me. Just have a few small nits.

clang/include/clang/AST/TextNodeDumper.h

47 ↗

(On Diff #364385)

Would it be better to make the default value the same as in ASTNodeTraverser? I.e.,

/// Indicates whether we should trigger deserialization of nodes that had
/// not already been loaded.
bool Deserialize = false;

clang/lib/AST/TextNodeDumper.cpp

1698–1701

The inconsistency that visually single-statement "if" branch has curly braces but "else" branch doesn't is grating. I understand a macro can expand into multiple statements but visually it looks like a single statement. Probably I would add braces to "else" as well.

clang/lib/AST/TextNodeDumper.cpp

AddChild([=] {
         ColorScope Color(OS, ShowColors, DeclKindNameColor);
         OS << "Destructor";
       }
       FLAG(hasSimpleDestructor, simple);
       FLAG(hasIrrelevantDestructor, irrelevant);
       FLAG(hasTrivialDestructor, trivial);
       FLAG(hasNonTrivialDestructor, non_trivial);
       FLAG(hasUserDeclaredDestructor, user_declared);
+      // Avoid calls to the external source.
+      if (!D->hasExternalVisibleStorage()) {
         FLAG(hasConstexprDestructor, constexpr);
+      } else
+        OS << "unknown_constexpr";
       FLAG(needsImplicitDestructor, needs_implicit);
       FLAG(needsOverloadResolutionForDestructor, needs_overload_resolution);
       if (!D->needsOverloadResolutionForDestructor())
         FLAG(defaultedDestructorIsDeleted, defaulted_is_deleted);
     });
   });
 
   for (const auto &I : D->bases()) {
     AddChild([=] {

clang/unittests/AST/ASTDumpTest.cpp

+//===- unittests/AST/ASTDumpTest.cpp --- Declaration 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Tests Decl::dump().
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang/AST/ASTContext.h"
+#include "clang/AST/DeclCXX.h"
+#include "clang/AST/DeclObjC.h"
+#include "clang/Basic/Builtins.h"
+#include "clang/Basic/FileManager.h"
+#include "clang/Basic/SourceManager.h"
+#include "gtest/gtest.h"
+
+using namespace clang;
+
+namespace clang {
+namespace ast {
+
+namespace {
+/// An ExternalASTSource that asserts if it is queried for information about
+/// any declaration.
+class TrappingExternalASTSource : public ExternalASTSource {
+  ~TrappingExternalASTSource() override = default;
+  bool FindExternalVisibleDeclsByName(const DeclContext *,
+                                      DeclarationName) override {
+    assert(false && "Unexpected call to FindExternalVisibleDeclsByName");
+    return true;
+  }
+
+  void FindExternalLexicalDecls(const DeclContext *,
+                                llvm::function_ref<bool(Decl::Kind)>,
+                                SmallVectorImpl<Decl *> &) override {
+    assert(false && "Unexpected call to FindExternalLexicalDecls");
+  }
+
+  void completeVisibleDeclsMap(const DeclContext *) override {
+    assert(false && "Unexpected call to completeVisibleDeclsMap");
+  }
+
+  void CompleteRedeclChain(const Decl *) override {
+    assert(false && "Unexpected call to CompleteRedeclChain");
+  }
+
+  void CompleteType(TagDecl *) override {
+    assert(false && "Unexpected call to CompleteType(Tag Decl*)");
+  }
+
+  void CompleteType(ObjCInterfaceDecl *) override {
+    assert(false && "Unexpected call to CompleteType(ObjCInterfaceDecl *)");
+  }
+};
+
+/// Tests that Decl::dump doesn't load additional declarations from the
+/// ExternalASTSource.
+class ExternalASTSourceDumpTest : public ::testing::Test {
+protected:
+  ExternalASTSourceDumpTest()
+      : FileMgr(FileMgrOpts), DiagID(new DiagnosticIDs()),
+        Diags(DiagID, new DiagnosticOptions, new IgnoringDiagConsumer()),
+        SourceMgr(Diags, FileMgr), Idents(LangOpts, nullptr),
+        Ctxt(LangOpts, SourceMgr, Idents, Sels, Builtins) {
+    Ctxt.setExternalSource(new TrappingExternalASTSource());
+  }
+
+  FileSystemOptions FileMgrOpts;
+  FileManager FileMgr;
+  IntrusiveRefCntPtr<DiagnosticIDs> DiagID;
+  DiagnosticsEngine Diags;
+  SourceManager SourceMgr;
+  LangOptions LangOpts;
+  IdentifierTable Idents;
+  SelectorTable Sels;
+  Builtin::Context Builtins;
+  ASTContext Ctxt;
+};
+} // unnamed namespace
+
+/// Set all flags that activate queries to the ExternalASTSource.
+static void setExternalStorageFlags(DeclContext *DC) {
+  DC->setHasExternalLexicalStorage();
+  DC->setHasExternalVisibleStorage();
+  DC->setMustBuildLookupTable();
+}
+
+/// Dumps the given Decl.
+static void dumpDecl(Decl *D) {
+  // Try dumping the decl which shouldn't trigger any calls to the
+  // ExternalASTSource.
+
+  std::string Out;
+  llvm::raw_string_ostream OS(Out);
+  D->dump(OS);
+}
+
+TEST_F(ExternalASTSourceDumpTest, DumpObjCInterfaceDecl) {
+  // Define an Objective-C interface.
+  ObjCInterfaceDecl *I = ObjCInterfaceDecl::Create(
+      Ctxt, Ctxt.getTranslationUnitDecl(), SourceLocation(),
+      &Ctxt.Idents.get("c"), nullptr, nullptr);
+  Ctxt.getTranslationUnitDecl()->addDecl(I);
+
+  setExternalStorageFlags(I);
+  dumpDecl(I);
+}
+
+TEST_F(ExternalASTSourceDumpTest, DumpRecordDecl) {
+  // Define a struct.
+  RecordDecl *R = RecordDecl::Create(
+      Ctxt, TagDecl::TagKind::TTK_Class, Ctxt.getTranslationUnitDecl(),
+      SourceLocation(), SourceLocation(), &Ctxt.Idents.get("c"));
+  R->startDefinition();
+  R->completeDefinition();
+  Ctxt.getTranslationUnitDecl()->addDecl(R);
+
+  setExternalStorageFlags(R);
+  dumpDecl(R);
+}
+
+TEST_F(ExternalASTSourceDumpTest, DumpCXXRecordDecl) {
+  // Define a class.
+  CXXRecordDecl *R = CXXRecordDecl::Create(
+      Ctxt, TagDecl::TagKind::TTK_Class, Ctxt.getTranslationUnitDecl(),
+      SourceLocation(), SourceLocation(), &Ctxt.Idents.get("c"));
+  R->startDefinition();
+  R->completeDefinition();
+  Ctxt.getTranslationUnitDecl()->addDecl(R);
+
+  setExternalStorageFlags(R);
+  dumpDecl(R);
+}
+
+} // end namespace ast
+} // end namespace clang

clang/unittests/AST/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   FrontendOpenMP
   Support
   )
 
 if (MSVC)
   set_source_files_properties(ASTImporterTest.cpp PROPERTIES COMPILE_FLAGS /bigobj)
 endif()
 
 add_clang_unittest(ASTTests
   ASTContextParentMapTest.cpp
+  ASTDumpTest.cpp
   ASTImporterFixtures.cpp
   ASTImporterTest.cpp
   ASTImporterGenericRedeclTest.cpp
   ASTImporterODRStrategiesTest.cpp
   ASTImporterVisibilityTest.cpp
   ASTTraverserTest.cpp
   ASTTypeTraitsTest.cpp
   ASTTraverserTest.cpp