[Frontend] Delete -print-decl-contexts

[MaskRay]

Summary

Its job is covered by -ast-dump. The option is rarely used and lacks many AST nodes which will lead to llvm_unreachable() crash.

[MaskRay]

A gentle ping :)

[rsmith]

Do we need -print-decl-contexts at all? It's not exposed by the driver, not tested, not documented, has a very strange output format (the bracketing character supplies some information about the kind of declaration, but it's not clear *what* information), and it doesn't really seem to provide any value given that we also have the maintained, tested, and actively-used -ast-dump flag, as well as programmatic interfaces to this information via libclang.

The only reason I can see to keep it would be if there's some external tool that's parsing its output, which this patch would break.

lib/Frontend/ASTConsumers.cpp

423 ↗

(On Diff #167054)

Was the change from +2 to +1 here intentional?

427–431 ↗

(On Diff #167054)

You don't need a switch for this either. if (auto *ND = dyn_cast<NamedDecl>(I)) and ND->getDeclKindName() should work fine.

498–499 ↗

(On Diff #167054)

You've lost this special case.

[MaskRay]

Delete -print-decl-contexts

[MaskRay]

.

[rsmith]

Looks good to me. Please first mail cfe-dev announcing this change and wait a day or so for anyone using this feature to speak up before committing.

test/Coverage/ast-printing.c

7 ↗

(On Diff #167837)

Please reinstate this file and only remove the one RUN: line that tests -print-decl-contexts.

test/Coverage/ast-printing.cpp

7 ↗

(On Diff #167837)

Likewise here.

[MaskRay]

Coverage/ast-printing.{c,cpp} contain other dumping tests. Don't delete them

[MaskRay]

In D52529#1251760, @rsmith wrote:

Looks good to me. Please first mail cfe-dev announcing this change and wait a day or so for anyone using this feature to speak up before committing.

Thanks! Sent out http://lists.llvm.org/pipermail/cfe-dev/2018-October/059571.html

cfe/trunk/include/clang/Driver/CC1Options.td

 def ast_dump_all : Flag<["-"], "ast-dump-all">,
   HelpText<"Build ASTs and then debug dump them, forcing deserialization">;
 def templight_dump : Flag<["-"], "templight-dump">,
   HelpText<"Dump templight information to stdout">;
 def ast_dump_lookups : Flag<["-"], "ast-dump-lookups">,
   HelpText<"Build ASTs and then debug dump their name lookup tables">;
 def ast_view : Flag<["-"], "ast-view">,
   HelpText<"Build ASTs and view them with GraphViz">;
-def print_decl_contexts : Flag<["-"], "print-decl-contexts">,
-  HelpText<"Print DeclContexts and their Decls">;
 def emit_module : Flag<["-"], "emit-module">,
   HelpText<"Generate pre-compiled module file from a module map">;
 def emit_module_interface : Flag<["-"], "emit-module-interface">,
   HelpText<"Generate pre-compiled module file from a C++ module interface">;
 def emit_header_module : Flag<["-"], "emit-header-module">,
   HelpText<"Generate pre-compiled module file from a set of header files">;
 def emit_pth : Flag<["-"], "emit-pth">,
   HelpText<"Generate pre-tokenized header file">;

cfe/trunk/include/clang/Frontend/ASTConsumers.h

 // nodes.
 std::unique_ptr<ASTConsumer> CreateASTDeclNodeLister();
 
 // Graphical AST viewer: for each function definition, creates a graph of
 // the AST and displays it with the graph viewer "dotty".  Also outputs
 // function declarations to stderr.
 std::unique_ptr<ASTConsumer> CreateASTViewer();
 
-// DeclContext printer: prints out the DeclContext tree in human-readable form
-// to stderr; this is intended for debugging.
-std::unique_ptr<ASTConsumer> CreateDeclContextPrinter();
-
 } // end clang namespace
 
 #endif

cfe/trunk/include/clang/Frontend/FrontendOptions.h

enum ActionKind {
   VerifyPCH,
 
   /// Parse and perform semantic analysis.
   ParseSyntaxOnly,
 
   /// Run a plugin action, \see ActionName.
   PluginAction,
 
-  /// Print DeclContext and their Decls.
-  PrintDeclContext,
-
   /// Print the "preamble" of the input file
   PrintPreamble,
 
   /// -E mode.
   PrintPreprocessedInput,
 
   /// Expand macros but not \#includes.
   RewriteMacros,

cfe/trunk/lib/Frontend/ASTConsumers.cpp

if (Stmt *Body = D->getBody()) {
       llvm::errs() << '\n';
     }
   }
 }
 
 std::unique_ptr<ASTConsumer> clang::CreateASTViewer() {
   return llvm::make_unique<ASTViewer>();
 }
-
-//===----------------------------------------------------------------------===//
-/// DeclContextPrinter - Decl and DeclContext Visualization
-
-namespace {
-
-class DeclContextPrinter : public ASTConsumer {
-  raw_ostream& Out;
-public:
-  DeclContextPrinter() : Out(llvm::errs()) {}
-
-  void HandleTranslationUnit(ASTContext &C) override {
-    PrintDeclContext(C.getTranslationUnitDecl(), 4);
-  }
-
-  void PrintDeclContext(const DeclContext* DC, unsigned Indentation);
-};
-}  // end anonymous namespace
-
-void DeclContextPrinter::PrintDeclContext(const DeclContext* DC,
-                                          unsigned Indentation) {
-  // Print DeclContext name.
-  switch (DC->getDeclKind()) {
-  case Decl::TranslationUnit:
-    Out << "[translation unit] " << DC;
-    break;
-  case Decl::Namespace: {
-    Out << "[namespace] ";
-    const NamespaceDecl* ND = cast<NamespaceDecl>(DC);
-    Out << *ND;
-    break;
-  }
-  case Decl::Enum: {
-    const EnumDecl* ED = cast<EnumDecl>(DC);
-    if (ED->isCompleteDefinition())
-      Out << "[enum] ";
-    else
-      Out << "<enum> ";
-    Out << *ED;
-    break;
-  }
-  case Decl::Record: {
-    const RecordDecl* RD = cast<RecordDecl>(DC);
-    if (RD->isCompleteDefinition())
-      Out << "[struct] ";
-    else
-      Out << "<struct> ";
-    Out << *RD;
-    break;
-  }
-  case Decl::CXXRecord: {
-    const CXXRecordDecl* RD = cast<CXXRecordDecl>(DC);
-    if (RD->isCompleteDefinition())
-      Out << "[class] ";
-    else
-      Out << "<class> ";
-    Out << *RD << ' ' << DC;
-    break;
-  }
-  case Decl::ObjCMethod:
-    Out << "[objc method]";
-    break;
-  case Decl::ObjCInterface:
-    Out << "[objc interface]";
-    break;
-  case Decl::ObjCCategory:
-    Out << "[objc category]";
-    break;
-  case Decl::ObjCProtocol:
-    Out << "[objc protocol]";
-    break;
-  case Decl::ObjCImplementation:
-    Out << "[objc implementation]";
-    break;
-  case Decl::ObjCCategoryImpl:
-    Out << "[objc categoryimpl]";
-    break;
-  case Decl::LinkageSpec:
-    Out << "[linkage spec]";
-    break;
-  case Decl::Block:
-    Out << "[block]";
-    break;
-  case Decl::Function: {
-    const FunctionDecl* FD = cast<FunctionDecl>(DC);
-    if (FD->doesThisDeclarationHaveABody())
-      Out << "[function] ";
-    else
-      Out << "<function> ";
-    Out << *FD;
-    // Print the parameters.
-    Out << "(";
-    bool PrintComma = false;
-    for (auto I : FD->parameters()) {
-      if (PrintComma)
-        Out << ", ";
-      else
-        PrintComma = true;
-      Out << *I;
-    }
-    Out << ")";
-    break;
-  }
-  case Decl::CXXMethod: {
-    const CXXMethodDecl* D = cast<CXXMethodDecl>(DC);
-    if (D->isOutOfLine())
-      Out << "[c++ method] ";
-    else if (D->isImplicit())
-      Out << "(c++ method) ";
-    else
-      Out << "<c++ method> ";
-    Out << *D;
-    // Print the parameters.
-    Out << "(";
-    bool PrintComma = false;
-    for (ParmVarDecl *Parameter : D->parameters()) {
-      if (PrintComma)
-        Out << ", ";
-      else
-        PrintComma = true;
-      Out << *Parameter;
-    }
-    Out << ")";
-
-    // Check the semantic DeclContext.
-    const DeclContext* SemaDC = D->getDeclContext();
-    const DeclContext* LexicalDC = D->getLexicalDeclContext();
-    if (SemaDC != LexicalDC)
-      Out << " [[" << SemaDC << "]]";
-
-    break;
-  }
-  case Decl::CXXConstructor: {
-    const CXXConstructorDecl* D = cast<CXXConstructorDecl>(DC);
-    if (D->isOutOfLine())
-      Out << "[c++ ctor] ";
-    else if (D->isImplicit())
-      Out << "(c++ ctor) ";
-    else
-      Out << "<c++ ctor> ";
-    Out << *D;
-    // Print the parameters.
-    Out << "(";
-    bool PrintComma = false;
-    for (ParmVarDecl *Parameter : D->parameters()) {
-      if (PrintComma)
-        Out << ", ";
-      else
-        PrintComma = true;
-      Out << *Parameter;
-    }
-    Out << ")";
-
-    // Check the semantic DC.
-    const DeclContext* SemaDC = D->getDeclContext();
-    const DeclContext* LexicalDC = D->getLexicalDeclContext();
-    if (SemaDC != LexicalDC)
-      Out << " [[" << SemaDC << "]]";
-    break;
-  }
-  case Decl::CXXDestructor: {
-    const CXXDestructorDecl* D = cast<CXXDestructorDecl>(DC);
-    if (D->isOutOfLine())
-      Out << "[c++ dtor] ";
-    else if (D->isImplicit())
-      Out << "(c++ dtor) ";
-    else
-      Out << "<c++ dtor> ";
-    Out << *D;
-    // Check the semantic DC.
-    const DeclContext* SemaDC = D->getDeclContext();
-    const DeclContext* LexicalDC = D->getLexicalDeclContext();
-    if (SemaDC != LexicalDC)
-      Out << " [[" << SemaDC << "]]";
-    break;
-  }
-  case Decl::CXXConversion: {
-    const CXXConversionDecl* D = cast<CXXConversionDecl>(DC);
-    if (D->isOutOfLine())
-      Out << "[c++ conversion] ";
-    else if (D->isImplicit())
-      Out << "(c++ conversion) ";
-    else
-      Out << "<c++ conversion> ";
-    Out << *D;
-    // Check the semantic DC.
-    const DeclContext* SemaDC = D->getDeclContext();
-    const DeclContext* LexicalDC = D->getLexicalDeclContext();
-    if (SemaDC != LexicalDC)
-      Out << " [[" << SemaDC << "]]";
-    break;
-  }
-
-  case Decl::ClassTemplateSpecialization: {
-    const auto *CTSD = cast<ClassTemplateSpecializationDecl>(DC);
-    if (CTSD->isCompleteDefinition())
-      Out << "[class template specialization] ";
-    else
-      Out << "<class template specialization> ";
-    Out << *CTSD;
-    break;
-  }
-
-  case Decl::ClassTemplatePartialSpecialization: {
-    const auto *CTPSD = cast<ClassTemplatePartialSpecializationDecl>(DC);
-    if (CTPSD->isCompleteDefinition())
-      Out << "[class template partial specialization] ";
-    else
-      Out << "<class template partial specialization> ";
-    Out << *CTPSD;
-    break;
-  }
-
-  default:
-    llvm_unreachable("a decl that inherits DeclContext isn't handled");
-  }
-
-  Out << "\n";
-
-  // Print decls in the DeclContext.
-  for (auto *I : DC->decls()) {
-    for (unsigned i = 0; i < Indentation; ++i)
-      Out << "  ";
-
-    Decl::Kind DK = I->getKind();
-    switch (DK) {
-    case Decl::Namespace:
-    case Decl::Enum:
-    case Decl::Record:
-    case Decl::CXXRecord:
-    case Decl::ObjCMethod:
-    case Decl::ObjCInterface:
-    case Decl::ObjCCategory:
-    case Decl::ObjCProtocol:
-    case Decl::ObjCImplementation:
-    case Decl::ObjCCategoryImpl:
-    case Decl::LinkageSpec:
-    case Decl::Block:
-    case Decl::Function:
-    case Decl::CXXMethod:
-    case Decl::CXXConstructor:
-    case Decl::CXXDestructor:
-    case Decl::CXXConversion:
-    case Decl::ClassTemplateSpecialization:
-    case Decl::ClassTemplatePartialSpecialization: {
-      DeclContext* DC = cast<DeclContext>(I);
-      PrintDeclContext(DC, Indentation+2);
-      break;
-    }
-    case Decl::IndirectField:
-      Out << "<IndirectField> " << *cast<IndirectFieldDecl>(I) << '\n';
-      break;
-    case Decl::Label:
-      Out << "<Label> " << *cast<LabelDecl>(I) << '\n';
-      break;
-    case Decl::Field:
-      Out << "<field> " << *cast<FieldDecl>(I) << '\n';
-      break;
-    case Decl::Typedef:
-    case Decl::TypeAlias:
-      Out << "<typedef> " << *cast<TypedefNameDecl>(I) << '\n';
-      break;
-    case Decl::EnumConstant:
-      Out << "<enum constant> " << *cast<EnumConstantDecl>(I) << '\n';
-      break;
-    case Decl::Var:
-      Out << "<var> " << *cast<VarDecl>(I) << '\n';
-      break;
-    case Decl::ImplicitParam:
-      Out << "<implicit parameter> " << *cast<ImplicitParamDecl>(I) << '\n';
-      break;
-    case Decl::ParmVar:
-      Out << "<parameter> " << *cast<ParmVarDecl>(I) << '\n';
-      break;
-    case Decl::ObjCProperty:
-      Out << "<objc property> " << *cast<ObjCPropertyDecl>(I) << '\n';
-      break;
-    case Decl::FunctionTemplate:
-      Out << "<function template> " << *cast<FunctionTemplateDecl>(I) << '\n';
-      break;
-    case Decl::TypeAliasTemplate:
-      Out << "<type alias template> " << *cast<TypeAliasTemplateDecl>(I)
-          << '\n';
-      break;
-    case Decl::FileScopeAsm:
-      Out << "<file-scope asm>\n";
-      break;
-    case Decl::UsingDirective:
-      Out << "<using directive>\n";
-      break;
-    case Decl::NamespaceAlias:
-      Out << "<namespace alias> " << *cast<NamespaceAliasDecl>(I) << '\n';
-      break;
-    case Decl::ClassTemplate:
-      Out << "<class template> " << *cast<ClassTemplateDecl>(I) << '\n';
-      break;
-    case Decl::OMPThreadPrivate: {
-      Out << "<omp threadprivate> " << '"' << I << "\"\n";
-      break;
-    }
-    case Decl::Friend: {
-      Out << "<friend>";
-      if (const NamedDecl *ND = cast<FriendDecl>(I)->getFriendDecl())
-        Out << ' ' << *ND;
-      Out << "\n";
-      break;
-    }
-    case Decl::Using:
-      Out << "<using> " << *cast<UsingDecl>(I) << "\n";
-      break;
-    case Decl::UsingShadow:
-      Out << "<using shadow> " << *cast<UsingShadowDecl>(I) << "\n";
-      break;
-    case Decl::UnresolvedUsingValue:
-      Out << "<unresolved using value> " << *cast<UnresolvedUsingValueDecl>(I)
-          << "\n";
-      break;
-    case Decl::Empty:
-      Out << "<empty>\n";
-      break;
-    case Decl::AccessSpec:
-      Out << "<access specifier>\n";
-      break;
-    case Decl::VarTemplate:
-      Out << "<var template> " << *cast<VarTemplateDecl>(I) << "\n";
-      break;
-    case Decl::StaticAssert:
-      Out << "<static assert>\n";
-      break;
-
-    default:
-      Out << "DeclKind: " << DK << '"' << I << "\"\n";
-      llvm_unreachable("decl unhandled");
-    }
-  }
-}
-std::unique_ptr<ASTConsumer> clang::CreateDeclContextPrinter() {
-  return llvm::make_unique<DeclContextPrinter>();
-}

cfe/trunk/lib/Frontend/CompilerInvocation.cpp

if (const Arg *A = Args.getLastArg(OPT_Action_Group)) {
     case OPT_init_only:
       Opts.ProgramAction = frontend::InitOnly; break;
     case OPT_fsyntax_only:
       Opts.ProgramAction = frontend::ParseSyntaxOnly; break;
     case OPT_module_file_info:
       Opts.ProgramAction = frontend::ModuleFileInfo; break;
     case OPT_verify_pch:
       Opts.ProgramAction = frontend::VerifyPCH; break;
-    case OPT_print_decl_contexts:
-      Opts.ProgramAction = frontend::PrintDeclContext; break;
     case OPT_print_preamble:
       Opts.ProgramAction = frontend::PrintPreamble; break;
     case OPT_E:
       Opts.ProgramAction = frontend::PrintPreprocessedInput; break;
     case OPT_templight_dump:
       Opts.ProgramAction = frontend::TemplightDump; break;
     case OPT_rewrite_macros:
       Opts.ProgramAction = frontend::RewriteMacros; break;
static bool isStrictlyPreprocessorAction(frontend::ActionKind Action) {
   case frontend::GenerateModuleInterface:
   case frontend::GenerateHeaderModule:
   case frontend::GeneratePCH:
   case frontend::GeneratePTH:
   case frontend::ParseSyntaxOnly:
   case frontend::ModuleFileInfo:
   case frontend::VerifyPCH:
   case frontend::PluginAction:
-  case frontend::PrintDeclContext:
   case frontend::RewriteObjC:
   case frontend::RewriteTest:
   case frontend::RunAnalysis:
   case frontend::TemplightDump:
   case frontend::MigrateSource:
     return false;
 
   case frontend::DumpCompilerOptions:

cfe/trunk/lib/Frontend/FrontendActions.cpp

 }
 
 std::unique_ptr<ASTConsumer>
 ASTViewAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
   return CreateASTViewer();
 }
 
 std::unique_ptr<ASTConsumer>
-DeclContextPrintAction::CreateASTConsumer(CompilerInstance &CI,
-                                          StringRef InFile) {
-  return CreateDeclContextPrinter();
-}
-
-std::unique_ptr<ASTConsumer>
 GeneratePCHAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
   std::string Sysroot;
   if (!ComputeASTConsumerArguments(CI, /*ref*/ Sysroot))
     return nullptr;
 
   std::string OutputFile;
   std::unique_ptr<raw_pwrite_stream> OS =
       CreateOutputFile(CI, InFile, /*ref*/ OutputFile);

cfe/trunk/lib/FrontendTool/ExecuteCompilerInvocation.cpp

for (FrontendPluginRegistry::iterator it =
       }
     }
 
     CI.getDiagnostics().Report(diag::err_fe_invalid_plugin_name)
       << CI.getFrontendOpts().ActionName;
     return nullptr;
   }
 
-  case PrintDeclContext:       return llvm::make_unique<DeclContextPrintAction>();
   case PrintPreamble:          return llvm::make_unique<PrintPreambleAction>();
   case PrintPreprocessedInput: {
     if (CI.getPreprocessorOutputOpts().RewriteIncludes ||
         CI.getPreprocessorOutputOpts().RewriteImports)
       return llvm::make_unique<RewriteIncludesAction>();
     return llvm::make_unique<PrintPreprocessedAction>();
   }
 

cfe/trunk/test/Coverage/ast-printing.c

 // RUN: %clang_cc1 -fsyntax-only %s
 // RUN: %clang_cc1 -ast-print %s -o %t.1.c
 // RUN: %clang_cc1 -ast-print %t.1.c -o %t.2.c
 // RUN: diff %t.1.c %t.2.c
 // RUN: %clang_cc1 -ast-dump %s
 // RUN: %clang_cc1 -ast-dump-all %s
-// RUN: %clang_cc1 -print-decl-contexts %s
 
 #include "c-language-features.inc"

cfe/trunk/test/Coverage/ast-printing.cpp

 // RUN: %clang_cc1 -std=c++14 -fsyntax-only %s
 // RUN: %clang_cc1 -std=c++14 -ast-print %s -o %t.1.cpp
 // RUN: %clang_cc1 -std=c++14 -ast-print %t.1.cpp -o %t.2.cpp
 // RUN: diff %t.1.cpp %t.2.cpp
 // RUN: %clang_cc1 -std=c++14 -ast-dump %s
 // RUN: %clang_cc1 -std=c++14 -ast-dump-all %s
-// RUN: %clang_cc1 -std=c++14 -print-decl-contexts %s
 // RUN: %clang_cc1 -std=c++14 -fdump-record-layouts %s
 
 #include "cxx-language-features.inc"