[analyzer] Hide developer-only checker/package options by default

[Szelethus]

Summary

Followup to D60925, this time, for checker options. Non-checker configurations should receive the same treatment eventually.

The patch is marked WIP, because I am not really confident about osx checkers, and I can see valid uses for the rest of the options, but I might not be strict enough on this. Also, @NoQ suggested that hidden checker's options should be hidden by default, but I'm kind of hesitant about it, as described in D57858#1499414.

Also, the TableGen code is very ugly, I might want to have another attempt at making it nicer.

[NoQ]

In D57858#1499414, @Szelethus wrote:

Checker options are a different kind of animal entirely. I think we should definitely let the user fine-tune some modeling checkers, for instance, unix.DynamicMemoryModeling:Optimistic, despite us not really wanting to let anyone (even developers really) mess around whether unix.DynamicMemoryModeling should be enabled.

Hmm, great point!

In D57858#1499414, @Szelethus wrote:

I am not really confident about osx checkers

Let's hide CheckOSObject and unhide the rest. Hmm, Devin also mentioned that some help texts are also not user-friendly-enough (eg., the localization checker help with SymRegions and stuff), let's also hide this one.

In D57858#1499414, @Szelethus wrote:

I can see valid uses for the rest of the options, but I might not be strict enough on this

I think debug.AnalysisOrder options are worth hiding. Let's also hide the Optimistic Malloc Checker, it's clearly alpha. Probably hide alpha checker options if we hide alpha checkers (i.e., Clone Checker).

[Szelethus]

• Hide several more checkers
• Rename -analyzer-checker-option-help-hidden to -analyzer-checker-option-help-developer

[NoQ]

Next!

include/clang/Driver/CC1Options.td

def analyzer_list_enabled_checkers : Flag<["-"], "analyzer-list-enabled-checkers">,
   HelpText<"Display the list of enabled analyzer checkers">;
 
 def analyzer_config : Separate<["-"], "analyzer-config">,
   HelpText<"Choose analyzer options to enable">;
 
 def analyzer_checker_option_help : Flag<["-"], "analyzer-checker-option-help">,
   HelpText<"Display the list of checker and package options">;
 
+def analyzer_checker_option_help_developer : Flag<["-"], "analyzer-checker-option-help-developer">,
+  HelpText<"Display the list of checker and package options meant for "
+           "development purposes only">;
+
 def analyzer_config_compatibility_mode : Separate<["-"], "analyzer-config-compatibility-mode">,
   HelpText<"Don't emit errors on invalid analyzer-config inputs">;
 
 def analyzer_config_compatibility_mode_EQ : Joined<["-"], "analyzer-config-compatibility-mode=">,
   Alias<analyzer_config_compatibility_mode>;
 
 //===----------------------------------------------------------------------===//
 // Migrator Options

include/clang/StaticAnalyzer/Checkers/CheckerBase.td

 def Integer : CmdLineOptionTypeEnum<0>;
 def String : CmdLineOptionTypeEnum<1>;
 def Boolean : CmdLineOptionTypeEnum<2>;
 
 class Type<CmdLineOptionTypeEnum val> {
   bits<2> Type = val.Type;
 }
 
+/// Marks the entry hidden. Hidden entries won't be displayed in
+/// -analyzer-checker-option-help.
+class HiddenEnum<bit val> {
+  bit Val = val;
+}
+def DontHide : HiddenEnum<0>;
+def Hide : HiddenEnum<1>;
+
 /// Describes an option for a checker or a package.
 class CmdLineOption<CmdLineOptionTypeEnum type, string cmdFlag, string desc,
-                    string defaultVal> {
+                    string defaultVal, HiddenEnum isHidden = DontHide> {
   bits<2> Type = type.Type;
-  string CmdFlag = cmdFlag;
-  string Desc = desc;
-  string DefaultVal = defaultVal;
+  string  CmdFlag = cmdFlag;
+  string  Desc = desc;
+  string  DefaultVal = defaultVal;
+  bit     Hidden = isHidden.Val;
 }
 
 /// Describes a list of package options.
 class PackageOptions<list<CmdLineOption> opts> {
   list<CmdLineOption> PackageOptions = opts;
 }
 
 /// Describes a package. Every checker is a part of a package, for example,

include/clang/StaticAnalyzer/Checkers/Checkers.td

CmdLineOption<Boolean,
                   "field.",
                   "false">,
     CmdLineOption<Boolean,
                   "NotesAsWarnings",
                   "If set to true, the checker will emit a warning "
                   "for each uninitalized field, as opposed to emitting one "
                   "warning per constructor call, and listing the uninitialized "
                   "fields that belongs to it in notes.",
-                  "false">,
+                  "false",
+                  Hide>,
     CmdLineOption<Boolean,
                   "CheckPointeeInitialization",
                   "If set to false, the checker will not analyze "
                   "the pointee of pointer/reference fields, and will only "
                   "check whether the object itself is initialized.",
                   "false">,
     CmdLineOption<String,
                   "IgnoreRecordsWithField",
def RetainCountChecker : Checker<"RetainCount">,
   HelpText<"Check for leaks and improper reference count management">,
   CheckerOptions<[
     CmdLineOption<Boolean,
                   "CheckOSObject",
                   "Find violations of retain-release rules applied to XNU "
                   "OSObject instances. By default, the checker only checks "
                   "retain-release rules for Objective-C NSObject instances "
                   "and CoreFoundation objects.",
-                  "true">,
+                  "true",
+                  Hide>,
     CmdLineOption<Boolean,
                   "TrackNSCFStartParam",
                   "Check not only that the code follows retain-release rules "
                   "with respect to objects it allocates or borrows from "
                   "elsewhere, but also that it fulfills its own retain count "
                   "specification with respect to objects that it receives as "
                   "arguments.",
                   "false">
CheckerOptions<[
     CmdLineOption<Boolean,
                   "AggressiveReport",
                   "Marks a string being returned by any call as localized if "
                   "it is in LocStringFunctions (LSF) or the function is "
                   "annotated. Otherwise, we mark it as NonLocalized "
                   "(Aggressive) or NonLocalized only if it is not backed by a "
                   "SymRegion (Non-Aggressive), basically leaving only string "
                   "literals as NonLocalized.",
-                  "false">
+                  "false",
+                  Hide>
   ]>,
   Documentation<HasDocumentation>;
 
 def EmptyLocalizationContextChecker :
   Checker<"EmptyLocalizationContextChecker">,
   HelpText<"Check that NSLocalizedString macros include a comment for context">,
   Documentation<HasDocumentation>;
 

 let ParentPackage = Debug in {
 
 def AnalysisOrderChecker : Checker<"AnalysisOrder">,
   HelpText<"Print callbacks that are called during analysis in order">,
   CheckerOptions<[
     CmdLineOption<Boolean,
                   "PreStmtCastExpr",
                   "",
-                  "false">,
+                  "false",
+                  Hide>,
     CmdLineOption<Boolean,
                   "PostStmtCastExpr",
                   "",
-                  "false">,
+                  "false",
+                  Hide>,
     CmdLineOption<Boolean,
                   "PreStmtArraySubscriptExpr",
                   "",
-                  "false">,
+                  "false",
+                  Hide>,
     CmdLineOption<Boolean,
                   "PostStmtArraySubscriptExpr",
                   "",
-                  "false">,
+                  "false",
+                  Hide>,
     CmdLineOption<Boolean,
                   "PreStmtCXXNewExpr",
                   "",
-                  "false">,
+                  "false",
+                  Hide>,
     CmdLineOption<Boolean,
                   "PostStmtCXXNewExpr",
                   "",
-                  "false">,
+                  "false",
+                  Hide>,
     CmdLineOption<Boolean,
                   "PreStmtOffsetOfExpr",
                   "",
-                  "false">,
+                  "false",
+                  Hide>,
     CmdLineOption<Boolean,
                   "PostStmtOffsetOfExpr",
                   "",
-                  "false">,
+                  "false",
+                  Hide>,
     CmdLineOption<Boolean,
                   "PreCall",
                   "",
-                  "false">,
+                  "false",
+                  Hide>,
     CmdLineOption<Boolean,
                   "PostCall",
                   "",
-                  "false">,
+                  "false",
+                  Hide>,
     CmdLineOption<Boolean,
                   "EndFunction",
                   "",
-                  "false">,
+                  "false",
+                  Hide>,
     CmdLineOption<Boolean,
                   "NewAllocator",
                   "",
-                  "false">,
+                  "false",
+                  Hide>,
     CmdLineOption<Boolean,
                   "Bind",
                   "",
-                  "false">,
+                  "false",
+                  Hide>,
     CmdLineOption<Boolean,
                   "LiveSymbols",
                   "",
-                  "false">,
+                  "false",
+                  Hide>,
     CmdLineOption<Boolean,
                   "RegionChanges",
                   "",
-                  "false">,
+                  "false",
+                  Hide>,
     CmdLineOption<Boolean,
                   "*",
                   "Enables all callbacks.",
-                  "false">
+                  "false",
+                  Hide>
   ]>,
   Documentation<NotDocumented>;
 
 def DominatorsTreeDumper : Checker<"DumpDominators">,
   HelpText<"Print the dominance tree for a given CFG">,
   Documentation<NotDocumented>;
 
 def LiveVariablesDumper : Checker<"DumpLiveVars">,

include/clang/StaticAnalyzer/Core/AnalyzerOptions.h

public:
   /// command-line options will get checked.
   unsigned DisableAllChecks : 1;
 
   unsigned ShowCheckerHelp : 1;
   unsigned ShowCheckerHelpAlpha : 1;
   unsigned ShowCheckerHelpDeveloper : 1;
   unsigned ShowEnabledCheckerList : 1;
   unsigned ShowCheckerOptionList : 1;
+  unsigned ShowCheckerOptionDeveloperList : 1;
   unsigned ShowConfigOptionsList : 1;
   unsigned ShouldEmitErrorsOnInvalidConfigValue : 1;
   unsigned AnalyzeAll : 1;
   unsigned AnalyzerDisplayProgress : 1;
   unsigned AnalyzeNestedBlocks : 1;
 
   unsigned eagerlyAssumeBinOpBifurcation : 1;
 
bool isUnknownAnalyzerConfig(StringRef Name) const {
 
     return !std::binary_search(AnalyzerConfigCmdFlags.begin(),
                                AnalyzerConfigCmdFlags.end(), Name);
   }
 
   AnalyzerOptions()
       : DisableAllChecks(false), ShowCheckerHelp(false),
         ShowCheckerHelpAlpha(false), ShowCheckerHelpDeveloper(false),
-        ShowEnabledCheckerList(false), ShowCheckerOptionList(false),
+        ShowEnabledCheckerList(false),
+        ShowCheckerOptionList(false), ShowCheckerOptionDeveloperList(false),
         ShowConfigOptionsList(false), AnalyzeAll(false),
         AnalyzerDisplayProgress(false), AnalyzeNestedBlocks(false),
         eagerlyAssumeBinOpBifurcation(false), TrimGraph(false),
         visualizeExplodedGraphWithGraphViz(false), UnoptimizedCFG(false),
         PrintStats(false), NoRetryExhausted(false) {
     llvm::sort(AnalyzerConfigCmdFlags);
   }
 

include/clang/StaticAnalyzer/Frontend/CheckerRegistry.h

public:
 
   /// Specifies a command line option. It may either belong to a checker or a
   /// package.
   struct CmdLineOption {
     StringRef OptionType;
     StringRef OptionName;
     StringRef DefaultValStr;
     StringRef Description;
+    bool IsHidden;
 
     CmdLineOption(StringRef OptionType, StringRef OptionName,
-                  StringRef DefaultValStr, StringRef Description)
+                  StringRef DefaultValStr, StringRef Description, bool IsHidden)
         : OptionType(OptionType), OptionName(OptionName),
-          DefaultValStr(DefaultValStr), Description(Description) {
+          DefaultValStr(DefaultValStr), Description(Description),
+          IsHidden(IsHidden) {
 
       assert((OptionType == "bool" || OptionType == "string" ||
               OptionType == "int") &&
              "Unknown command line option type!");
 
       assert((OptionType != "bool" ||
               (DefaultValStr == "true" || DefaultValStr == "false")) &&
              "Invalid value for boolean command line option! Maybe incorrect "
public:
   /// And can be specified from the command line like this:
   ///   -analyzer-config CheckerFullName:OptionName=Value
   ///
   /// Options for unknown checkers, or unknown options for a given checker, or
   /// invalid value types for that given option are reported as an error in
   /// non-compatibility mode.
   void addCheckerOption(StringRef OptionType, StringRef CheckerFullName,
                         StringRef OptionName, StringRef DefaultValStr,
-                        StringRef Description);
+                        StringRef Description, bool IsHidden = false);
 
   /// Adds a package to the registry.
   void addPackage(StringRef FullName);
 
   /// Registers an option to a given package. A package option will always have
   /// the following format:
   ///   PackageFullName:OptionName=Value
   /// And can be specified from the command line like this:
   ///   -analyzer-config PackageFullName:OptionName=Value
   ///
   /// Options for unknown packages, or unknown options for a given package, or
   /// invalid value types for that given option are reported as an error in
   /// non-compatibility mode.
   void addPackageOption(StringRef OptionType, StringRef PackageFullName,
                         StringRef OptionName, StringRef DefaultValStr,
-                        StringRef Description);
+                        StringRef Description, bool IsHidden = false);
 
   // FIXME: This *really* should be added to the frontend flag descriptions.
   /// Initializes a CheckerManager by calling the initialization functions for
   /// all checkers specified by the given CheckerOptInfo list. The order of this
   /// list is significant; later options can be used to reverse earlier ones.
   /// This can be used to exclude certain checkers in an included package.
   void initializeManager(CheckerManager &CheckerMgr) const;
 

lib/Frontend/CompilerInvocation.cpp

#include "clang/StaticAnalyzer/Core/Analyses.def"
     }
   }
 
   Opts.ShowCheckerHelp = Args.hasArg(OPT_analyzer_checker_help);
   Opts.ShowCheckerHelpAlpha = Args.hasArg(OPT_analyzer_checker_help_alpha);
   Opts.ShowCheckerHelpDeveloper =
       Args.hasArg(OPT_analyzer_checker_help_developer);
   Opts.ShowCheckerOptionList = Args.hasArg(OPT_analyzer_checker_option_help);
+  Opts.ShowCheckerOptionDeveloperList =
+      Args.hasArg(OPT_analyzer_checker_option_help_developer);
   Opts.ShowConfigOptionsList = Args.hasArg(OPT_analyzer_config_help);
   Opts.ShowEnabledCheckerList = Args.hasArg(OPT_analyzer_list_enabled_checkers);
   Opts.ShouldEmitErrorsOnInvalidConfigValue =
       /* negated */!llvm::StringSwitch<bool>(
                    Args.getLastArgValue(OPT_analyzer_config_compatibility_mode))
         .Case("true", true)
         .Case("false", false)
         .Default(false);

lib/FrontendTool/ExecuteCompilerInvocation.cpp

ento::printCheckerHelp(llvm::outs(),
                            Clang->getFrontendOpts().Plugins,
                            AnOpts,
                            Clang->getDiagnostics(),
                            Clang->getLangOpts());
     return true;
   }
 
   // Honor -analyzer-checker-option-help.
-  if (Clang->getAnalyzerOpts()->ShowCheckerOptionList) {
+  if (AnOpts.ShowCheckerOptionList || AnOpts.ShowCheckerOptionDeveloperList) {
     ento::printCheckerConfigList(llvm::outs(),
                                  Clang->getFrontendOpts().Plugins,
                                  *Clang->getAnalyzerOpts(),
                                  Clang->getDiagnostics(),
                                  Clang->getLangOpts());
     return true;
   }
 

lib/StaticAnalyzer/Frontend/CheckerRegistry.cpp

#undef GET_PACKAGES
   llvm::sort(Checkers, CheckerNameLT{});
 
 #define GET_CHECKER_DEPENDENCIES
 
 #define CHECKER_DEPENDENCY(FULLNAME, DEPENDENCY)                               \
   addDependency(FULLNAME, DEPENDENCY);
 
 #define GET_CHECKER_OPTIONS
-#define CHECKER_OPTION(TYPE, FULLNAME, CMDFLAG, DESC, DEFAULT_VAL)             \
-  addCheckerOption(TYPE, FULLNAME, CMDFLAG, DEFAULT_VAL, DESC);
+#define CHECKER_OPTION(TYPE, FULLNAME, CMDFLAG, DESC, DEFAULT_VAL, IS_HIDDEN)  \
+  addCheckerOption(TYPE, FULLNAME, CMDFLAG, DEFAULT_VAL, DESC, IS_HIDDEN);
 
 #define GET_PACKAGE_OPTIONS
-#define PACKAGE_OPTION(TYPE, FULLNAME, CMDFLAG, DESC, DEFAULT_VAL)             \
-  addPackageOption(TYPE, FULLNAME, CMDFLAG, DEFAULT_VAL, DESC);
+#define PACKAGE_OPTION(TYPE, FULLNAME, CMDFLAG, DESC, DEFAULT_VAL, IS_HIDDEN)  \
+  addPackageOption(TYPE, FULLNAME, CMDFLAG, DEFAULT_VAL, DESC, IS_HIDDEN);
 
 #include "clang/StaticAnalyzer/Checkers/Checkers.inc"
 #undef CHECKER_DEPENDENCY
 #undef GET_CHECKER_DEPENDENCIES
 #undef CHECKER_OPTION
 #undef GET_CHECKER_OPTIONS
 #undef PACKAGE_OPTION
 #undef GET_PACKAGE_OPTIONS

 void CheckerRegistry::addPackage(StringRef FullName) {
   Packages.emplace_back(PackageInfo(FullName));
 }
 
 void CheckerRegistry::addPackageOption(StringRef OptionType,
                                        StringRef PackageFullName,
                                        StringRef OptionName,
                                        StringRef DefaultValStr,
-                                       StringRef Description) {
+                                       StringRef Description, bool IsHidden) {
   PackageOptions.emplace_back(
-      PackageFullName,
-      CmdLineOption{OptionType, OptionName, DefaultValStr, Description});
+      PackageFullName, CmdLineOption{OptionType, OptionName, DefaultValStr,
+                                     Description, IsHidden});
 }
 
 void CheckerRegistry::addChecker(InitializationFunction Rfn,
                                  ShouldRegisterFunction Sfn, StringRef Name,
                                  StringRef Desc, StringRef DocsUri,
                                  bool IsHidden) {
   Checkers.emplace_back(Rfn, Sfn, Name, Desc, DocsUri, IsHidden);
 
   // Record the presence of the checker in its packages.
   StringRef PackageName, LeafName;
   std::tie(PackageName, LeafName) = Name.rsplit(PackageSeparator);
   while (!LeafName.empty()) {
     PackageSizes[PackageName] += 1;
     std::tie(PackageName, LeafName) = PackageName.rsplit(PackageSeparator);
   }
 }
 
 void CheckerRegistry::addCheckerOption(StringRef OptionType,
                                        StringRef CheckerFullName,
                                        StringRef OptionName,
                                        StringRef DefaultValStr,
-                                       StringRef Description) {
+                                       StringRef Description, bool IsHidden) {
   CheckerOptions.emplace_back(
-      CheckerFullName,
-      CmdLineOption{OptionType, OptionName, DefaultValStr, Description});
+      CheckerFullName, CmdLineOption{OptionType, OptionName, DefaultValStr,
+                                     Description, IsHidden});
 }
 
 void CheckerRegistry::initializeManager(CheckerManager &CheckerMgr) const {
   // Collect checkers enabled by the options.
   CheckerInfoSet enabledCheckers = getEnabledCheckers();
 
   // Initialize the CheckerManager with all enabled checkers.
   for (const auto *Checker : enabledCheckers) {
void CheckerRegistry::printCheckerOptionList(raw_ostream &Out) const {
 
   for (const PackageInfo &Package : Packages) {
     for (const CmdLineOption &Option : Package.CmdLineOptions) {
       OptionMap.insert({Package.FullName, Option});
     }
   }
 
   for (const std::pair<StringRef, const CmdLineOption &> &Entry : OptionMap) {
+    if (!AnOpts.ShowCheckerOptionDeveloperList && Entry.second.IsHidden)
+      continue;
+
     const CmdLineOption &Option = Entry.second;
     std::string FullOption = (Entry.first + ":" + Option.OptionName).str();
 
     std::string Desc =
         ("(" + Option.OptionType + ") " + Option.Description + " (default: " +
          (Option.DefaultValStr.empty() ? "\"\"" : Option.DefaultValStr) + ")")
             .str();
 
     AnalyzerOptions::printFormattedEntry(Out, {FullOption, Desc},
                                          /*InitialPad*/ 2,
                                          /*EntryWidth*/ 50,
                                          /*MinLineWidth*/ 90);
     Out << "\n\n";
   }
 }

test/Analysis/analyzer-checker-option-help.c

 // RUN: %clang_cc1 -analyzer-checker-option-help 2>&1 | FileCheck %s
 
+// RUN: %clang_cc1 -analyzer-checker-option-help-developer \
+// RUN:   2>&1 | FileCheck %s -check-prefix=CHECK-HIDDEN
+
 // CHECK: OVERVIEW: Clang Static Analyzer Checker and Package Option List
 //
 // CHECK: USAGE: -analyzer-config <OPTION1=VALUE,OPTION2=VALUE,...>
 //
 // CHECK:        -analyzer-config OPTION1=VALUE, -analyzer-config
 // CHECK-SAME:   OPTION2=VALUE, ...
 //
 // CHECK: OPTIONS:
 //
 // CHECK:   alpha.clone.CloneChecker:MinimumCloneComplexity
 // CHECK-SAME:   (int) Ensures that every clone has at least
 // CHECK:        the given complexity. Complexity is here
 // CHECK:        defined as the total amount of children
 // CHECK:        of a statement. This constraint assumes
 // CHECK:        the first statement in the group is representative
 // CHECK:        for all other statements in the group in
 // CHECK:        terms of complexity. (default: 50)
+
+// CHECK-NOT:     optin.cplusplus.UninitializedObject:NotesAsWarnings
+// CHECK-HIDDEN:  optin.cplusplus.UninitializedObject:NotesAsWarnings

utils/TableGen/ClangSACheckersEmitter.cpp

PrintFatalError(R.getLoc(),
                   "unable to parse command line option type for "
                   + getCheckerFullName(&R));
   return "";
 }
 
 static bool isHidden(const Record *R) {
   if (R->getValueAsBit("Hidden"))
     return true;
+
   // Not declared as hidden, check the parent package if it is hidden.
   if (DefInit *DI = dyn_cast<DefInit>(R->getValueInit("ParentPackage")))
     return isHidden(DI->getDef());
 
   return false;
 }
 
 static void printChecker(llvm::raw_ostream &OS, const Record &R) {
-    OS << "CHECKER(" << "\"";
-    OS.write_escaped(getCheckerFullName(&R)) << "\", ";
-    OS << R.getName() << ", ";
-    OS << "\"";
-    OS.write_escaped(getStringValue(R, "HelpText")) << "\", ";
-    OS << "\"";
-    OS.write_escaped(getCheckerDocs(R));
-    OS << "\", ";
 
-    if (!isHidden(&R))
-      OS << "false";
-    else
-      OS << "true";
 
-    OS << ")\n";
 }
 
+static void printOption(llvm::raw_ostream &OS, StringRef FullName,
+                        const Record &R) {
+  OS << "\"";
+  OS.write_escaped(getCheckerOptionType(R)) << "\", \"";
+  OS.write_escaped(FullName) << "\", ";
+  OS << '\"' << getStringValue(R, "CmdFlag") << "\", ";
+  OS << '\"';
+  OS.write_escaped(getStringValue(R, "Desc")) << "\", ";
+  OS << '\"';
+  OS.write_escaped(getStringValue(R, "DefaultVal")) << "\", ";
+
+  if (!R.getValueAsBit("Hidden"))
+    OS << "false";
+  else
+    OS << "true";
+}
+
 namespace clang {
 void EmitClangSACheckers(RecordKeeper &Records, raw_ostream &OS) {
   std::vector<Record*> checkers = Records.getAllDerivedDefinitions("Checker");
   std::vector<Record*> packages = Records.getAllDerivedDefinitions("Package");
 
   using SortedRecords = llvm::StringMap<const Record *>;
 
   OS << "// This file is automatically generated. Do not edit this file by "
void EmitClangSACheckers(RecordKeeper &Records, raw_ostream &OS) {
   for (const Record *Package : packages) {
 
     if (Package->isValueUnset("PackageOptions"))
       continue;
 
     std::vector<Record *> PackageOptions = Package
                                        ->getValueAsListOfDefs("PackageOptions");
     for (Record *PackageOpt : PackageOptions) {
-      OS << "PACKAGE_OPTION(\"";
-      OS.write_escaped(getCheckerOptionType(*PackageOpt)) << "\", \"";
-      OS.write_escaped(getPackageFullName(Package)) << "\", ";
-      OS << '\"' << getStringValue(*PackageOpt, "CmdFlag") << "\", ";
-      OS << '\"';
-      OS.write_escaped(getStringValue(*PackageOpt, "Desc")) << "\", ";
-      OS << '\"';
-      OS.write_escaped(getStringValue(*PackageOpt, "DefaultVal")) << "\"";
+      OS << "PACKAGE_OPTION(";
+      printOption(OS, getPackageFullName(Package), *PackageOpt);
       OS << ")\n";
     }
   }
   OS << "#endif // GET_PACKAGE_OPTIONS\n"
         "\n";
 
   // Emit checkers.
   //
void EmitClangSACheckers(RecordKeeper &Records, raw_ostream &OS) {
   for (const Record *Checker : checkers) {
 
     if (Checker->isValueUnset("CheckerOptions"))
       continue;
 
     std::vector<Record *> CheckerOptions = Checker
                                        ->getValueAsListOfDefs("CheckerOptions");
     for (Record *CheckerOpt : CheckerOptions) {
-      OS << "CHECKER_OPTION(\"";
-      OS << getCheckerOptionType(*CheckerOpt) << "\", \"";
-      OS.write_escaped(getCheckerFullName(Checker)) << "\", ";
-      OS << '\"' << getStringValue(*CheckerOpt, "CmdFlag") << "\", ";
-      OS << '\"';
-      OS.write_escaped(getStringValue(*CheckerOpt, "Desc")) << "\", ";
-      OS << '\"';
-      OS.write_escaped(getStringValue(*CheckerOpt, "DefaultVal")) << "\"";
-      OS << ")";
-      OS << '\n';
+      OS << "CHECKER_OPTION(";
+      printOption(OS, getCheckerFullName(Checker), *CheckerOpt);
+      OS << ")\n";
     }
   }
   OS << "#endif // GET_CHECKER_OPTIONS\n"
         "\n";
 }
 } // end namespace clang