[analyzer] List checker/plugin options in 3 categories: released, alpha, developer

[Szelethus]

Summary

Literally the same as D62093, but for checker/package options. Sorry for the lack of formatting at some parts -- I definitely wanted to share the code to gather feedback, as I don't have much time left to wrap this project up.

[Szelethus]

Removed the beta phase as discussed on the mailing list.

[NoQ]

Thank you. This formalization work made things a lot easier and safer to deal with.

[Szelethus]

Ooooops, committed in rC361566 with the wrong revision name.

[Szelethus]

Alright, builbots don't seem to complain just yet. Thank you so much for all the help!!! This patch concludes the analyzer configuration project for good :)

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_alpha : Flag<["-"], "analyzer-checker-option-help-alpha">,
+  HelpText<"Display the list of in development checker and package options. "
+           "These are NOT considered safe, they are unstable and will emit "
+           "incorrect reports. Enable ONLY FOR DEVELOPMENT purposes">;
+
 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=">,

include/clang/StaticAnalyzer/Checkers/CheckerBase.td

 /// requires changes in the TableGen emitter file ClangSACheckersEmitter.cpp.
 class CmdLineOptionTypeEnum<bits<2> val> {
   bits<2> Type = val;
 }
 def Integer : CmdLineOptionTypeEnum<0>;
 def String : CmdLineOptionTypeEnum<1>;
 def Boolean : CmdLineOptionTypeEnum<2>;
 
-class Type<CmdLineOptionTypeEnum val> {
-  bits<2> Type = val.Type;
+/// Describes the state of the entry. We wouldn't like to display, for example,
+/// developer only entries for a list meant for end users.
+class DevelopmentStageEnum<bits<1> val> {
+  bits<1> Val = val;
 }
 
+/// Alpha entries are under development, might be incomplet, inkorrekt and
+/// unstable.
+def InAlpha : DevelopmentStageEnum<0>;
+
+/// Released entries are stable, produce minimal, if any false positives,
+/// and emits reports that explain the occurance of the bug understandably and
+/// thoroughly.
+def Released : DevelopmentStageEnum<1>;
+
 /// 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, HiddenEnum isHidden = DontHide> {
+                    string defaultVal, DevelopmentStageEnum stage,
+                    HiddenEnum isHidden = DontHide> {
   bits<2> Type = type.Type;
   string  CmdFlag = cmdFlag;
   string  Desc = desc;
   string  DefaultVal = defaultVal;
+  bits<1> DevelopmentStage = stage.Val;
   bit     Hidden = isHidden.Val;
 }
 
 /// Describes a list of package options.
 class PackageOptions<list<CmdLineOption> opts> {
   list<CmdLineOption> PackageOptions = opts;
 }
 

include/clang/StaticAnalyzer/Checkers/Checkers.td

def Nullability : Package<"nullability">,
   PackageOptions<[
     CmdLineOption<Boolean,
                   "NoDiagnoseCallsToSystemHeaders",
                   "Suppresses warnings for violating nullability annotations "
                   "of system header functions. This is useful if you are "
                   "concerned with your custom nullability annotations more "
                   "than with following nullability specifications of system "
                   "header functions.",
-                  "false">
+                  "false",
+                  Released>
   ]>;
 
 def Cplusplus : Package<"cplusplus">;
 def CplusplusAlpha : Package<"cplusplus">, ParentPackage<Alpha>;
 def CplusplusOptIn : Package<"cplusplus">, ParentPackage<OptIn>;
 
 def Valist : Package<"valist">;
 
HelpText<"The base of several malloc() related checkers. On it's own it "
            "emits no reports, but adds valuable information to the analysis "
            "when enabled.">,
   CheckerOptions<[
     CmdLineOption<Boolean,
                   "Optimistic",
                   "If set to true, the checker assumes that all the "
                   "allocating and deallocating functions are annotated with "
                   "ownership_holds, ownership_takes and ownership_returns.",
-                  "false">
+                  "false",
+                  InAlpha>
   ]>,
   Dependencies<[CStringModeling]>,
   Documentation<NotDocumented>,
   Hidden;
 
 def MallocChecker: Checker<"Malloc">,
   HelpText<"Check for memory leaks, double free, and use-after-free problems. "
            "Traces memory managed by malloc()/free().">,
CmdLineOption<String,
                   "use-after-move is invalid. Some STL objects are known to "
                   "conform to additional contracts after move, so they are not "
                   "tracked. However, smart pointers specifically are tracked "
                   "because we can perform extra checking over them. In "
                   "aggressive mode, warn on any use-after-move because the "
                   "user has intentionally asked us to completely eliminate "
                   "use-after-move in his code. Values: \"KnownsOnly\", "
                   "\"KnownsAndLocals\", \"All\".",
-                  "KnownsAndLocals">
+                  "KnownsAndLocals",
+                  Released>
   ]>,
   Documentation<HasDocumentation>;
 
 } // end: "cplusplus"
 
 let ParentPackage = CplusplusOptIn in {
 
 def UninitializedObjectChecker: Checker<"UninitializedObject">,
   HelpText<"Reports uninitialized fields after object construction">,
   CheckerOptions<[
     CmdLineOption<Boolean,
                   "Pedantic",
                   "If set to false, the checker won't emit warnings "
                   "for objects that don't have at least one initialized "
                   "field.",
-                  "false">,
+                  "false",
+                  Released>,
     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",
+                  Released,
                   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">,
+                  "false",
+                  InAlpha>,
     CmdLineOption<String,
                   "IgnoreRecordsWithField",
                   "If supplied, the checker will not analyze "
                   "structures that have a field with a name or type name that "
                   "matches the given pattern.",
-                  "\"\"">,
+                  "\"\"",
+                  Released>,
     CmdLineOption<Boolean,
                   "IgnoreGuardedFields",
                   "If set to true, the checker will analyze _syntactically_ "
                   "whether the found uninitialized object is used without a "
                   "preceding assert call. Defaults to false.",
-                  "false">
+                  "false",
+                  InAlpha>
   ]>,
   Documentation<HasAlphaDocumentation>;
 
 def VirtualCallChecker : Checker<"VirtualCall">,
   HelpText<"Check virtual function calls during construction or destruction">,
   CheckerOptions<[
     CmdLineOption<Boolean,
                   "PureOnly",
                   "Whether to only report calls to pure virtual methods.",
-                  "false">
+                  "false",
+                  Released>
   ]>,
   Documentation<HasDocumentation>;
 
 } // end: "optin.cplusplus"
 
 let ParentPackage = CplusplusAlpha in {
 
 def DeleteWithNonVirtualDtorChecker : Checker<"DeleteWithNonVirtualDtor">,

 
 def PaddingChecker : Checker<"Padding">,
   HelpText<"Check for excessively padded structs.">,
   CheckerOptions<[
     CmdLineOption<Integer,
                   "AllowedPad",
                   "Reports are only generated if the excessive padding exceeds "
                   "'AllowedPad' in bytes.",
-                  "24">
+                  "24",
+                  Released>
   ]>,
   Documentation<NotDocumented>;
 
 } // end: "padding"
 
 //===----------------------------------------------------------------------===//
 // Security checkers.
 //===----------------------------------------------------------------------===//
def MallocOverflowSecurityChecker : Checker<"MallocOverflow">,
   Documentation<HasAlphaDocumentation>;
 
 def MmapWriteExecChecker : Checker<"MmapWriteExec">,
   HelpText<"Warn on mmap() calls that are both writable and executable">,
   CheckerOptions<[
     CmdLineOption<Integer,
                   "MmapProtExec",
                   "Specifies the value of PROT_EXEC",
-                  "0x04">,
+                  "0x04",
+                  Released>,
     CmdLineOption<Integer,
                   "MmapProtRead",
                   "Specifies the value of PROT_READ",
-                  "0x01">
+                  "0x01",
+                  Released>
   ]>,
   Documentation<HasAlphaDocumentation>;
 
 } // end "alpha.security"
 
 //===----------------------------------------------------------------------===//
 // Taint checkers.
 //===----------------------------------------------------------------------===//
def NumberObjectConversionChecker : Checker<"NumberObjectConversion">,
   HelpText<"Check for erroneous conversions of objects representing numbers "
            "into numbers">,
   CheckerOptions<[
     CmdLineOption<Boolean,
                   "Pedantic",
                   "Enables detection of more conversion patterns (which are "
                   "most likely more harmless, and therefore are more likely to "
                   "produce false positives).",
-                  "false">
+                  "false",
+                  Released>
   ]>,
   Documentation<NotDocumented>;
 
 def MacOSXAPIChecker : Checker<"API">,
   HelpText<"Check for proper uses of various Apple APIs">,
   Documentation<HasDocumentation>;
 
 def MacOSKeychainAPIChecker : Checker<"SecKeychainAPI">,
def RetainCountChecker : Checker<"RetainCount">,
   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",
+                  InAlpha,
                   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">
+                  "false",
+                  Released>
   ]>,
   Dependencies<[RetainCountBase]>,
   Documentation<HasDocumentation>;
 
 def ObjCGenericsChecker : Checker<"ObjCGenerics">,
   HelpText<"Check for type errors when using Objective-C generics">,
   Dependencies<[DynamicTypePropagation]>,
   Documentation<HasDocumentation>;
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",
+                  InAlpha,
                   Hide>
   ]>,
   Documentation<HasDocumentation>;
 
 def EmptyLocalizationContextChecker :
   Checker<"EmptyLocalizationContextChecker">,
   HelpText<"Check that NSLocalizedString macros include a comment for context">,
   Documentation<HasDocumentation>;

 
 def AnalysisOrderChecker : Checker<"AnalysisOrder">,
   HelpText<"Print callbacks that are called during analysis in order">,
   CheckerOptions<[
     CmdLineOption<Boolean,
                   "PreStmtCastExpr",
                   "",
                   "false",
+                  Released,
                   Hide>,
     CmdLineOption<Boolean,
                   "PostStmtCastExpr",
                   "",
                   "false",
+                  Released,
                   Hide>,
     CmdLineOption<Boolean,
                   "PreStmtArraySubscriptExpr",
                   "",
                   "false",
+                  Released,
                   Hide>,
     CmdLineOption<Boolean,
                   "PostStmtArraySubscriptExpr",
                   "",
                   "false",
+                  Released,
                   Hide>,
     CmdLineOption<Boolean,
                   "PreStmtCXXNewExpr",
                   "",
                   "false",
+                  Released,
                   Hide>,
     CmdLineOption<Boolean,
                   "PostStmtCXXNewExpr",
                   "",
                   "false",
+                  Released,
                   Hide>,
     CmdLineOption<Boolean,
                   "PreStmtOffsetOfExpr",
                   "",
                   "false",
+                  Released,
                   Hide>,
     CmdLineOption<Boolean,
                   "PostStmtOffsetOfExpr",
                   "",
                   "false",
+                  Released,
                   Hide>,
     CmdLineOption<Boolean,
                   "PreCall",
                   "",
                   "false",
+                  Released,
                   Hide>,
     CmdLineOption<Boolean,
                   "PostCall",
                   "",
                   "false",
+                  Released,
                   Hide>,
     CmdLineOption<Boolean,
                   "EndFunction",
                   "",
                   "false",
+                  Released,
                   Hide>,
     CmdLineOption<Boolean,
                   "NewAllocator",
                   "",
                   "false",
+                  Released,
                   Hide>,
     CmdLineOption<Boolean,
                   "Bind",
                   "",
                   "false",
+                  Released,
                   Hide>,
     CmdLineOption<Boolean,
                   "LiveSymbols",
                   "",
                   "false",
+                  Released,
                   Hide>,
     CmdLineOption<Boolean,
                   "RegionChanges",
                   "",
                   "false",
+                  Released,
                   Hide>,
     CmdLineOption<Boolean,
                   "*",
                   "Enables all callbacks.",
                   "false",
+                  Released,
                   Hide>
   ]>,
   Documentation<NotDocumented>;
 
 def DominatorsTreeDumper : Checker<"DumpDominators">,
   HelpText<"Print the dominance tree for a given CFG">,
   Documentation<NotDocumented>;
 
def CloneChecker : Checker<"CloneChecker">,
   CheckerOptions<[
     CmdLineOption<Integer,
                   "MinimumCloneComplexity",
                   "Ensures that every clone has at least the given complexity. "
                   "Complexity is here defined as the total amount of children "
                   "of a statement. This constraint assumes the first statement "
                   "in the group is representative for all other statements in "
                   "the group in terms of complexity.",
-                  "50">,
+                  "50",
+                  Released>,
     CmdLineOption<Boolean,
                   "ReportNormalClones",
                   "Report all clones, even less suspicious ones.",
-                  "true">,
+                  "true",
+                  Released>,
     CmdLineOption<String,
                   "IgnoredFilesPattern",
                   "If supplied, the checker wont analyze files with a filename "
                   "that matches the given pattern.",
-                  "\"\"">
+                  "\"\"",
+                  Released>
   ]>,
   Documentation<HasAlphaDocumentation>;
 
 } // end "clone"
 
 //===----------------------------------------------------------------------===//
 // Portability checkers.
 //===----------------------------------------------------------------------===//

include/clang/StaticAnalyzer/Core/AnalyzerOptions.h

public:
   /// This flag allows one to disable analyzer checks on the code processed by
   /// the given analysis consumer. Note, the code will get parsed and the
   /// 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 ShowCheckerOptionAlphaList : 1;
   unsigned ShowCheckerOptionDeveloperList : 1;
+
+  unsigned ShowEnabledCheckerList : 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), ShowCheckerOptionDeveloperList(false),
+        ShowCheckerOptionList(false), ShowCheckerOptionAlphaList(false),
+        ShowCheckerOptionDeveloperList(false), ShowEnabledCheckerList(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;
+    StringRef DevelopmentStatus;
     bool IsHidden;
 
     CmdLineOption(StringRef OptionType, StringRef OptionName,
-                  StringRef DefaultValStr, StringRef Description, bool IsHidden)
+                  StringRef DefaultValStr, StringRef Description,
+                  StringRef DevelopmentStatus, bool IsHidden)
         : OptionType(OptionType), OptionName(OptionName),
           DefaultValStr(DefaultValStr), Description(Description),
-          IsHidden(IsHidden) {
+          DevelopmentStatus(DevelopmentStatus), 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 "
              "parameters to the addCheckerOption or addPackageOption method?");
 
       int Tmp;
       assert((OptionType != "int" || !DefaultValStr.getAsInteger(0, Tmp)) &&
              "Invalid value for integer command line option! Maybe incorrect "
              "parameters to the addCheckerOption or addPackageOption method?");
       (void)Tmp;
+
+      assert((DevelopmentStatus == "alpha" || DevelopmentStatus == "beta" ||
+              DevelopmentStatus == "released") &&
+             "Invalid development status!");
     }
   };
 
   using CmdLineOptionList = llvm::SmallVector<CmdLineOption, 0>;
 
   struct CheckerInfo;
 
   using CheckerInfoList = std::vector<CheckerInfo>;
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, bool IsHidden = false);
+                        StringRef Description, StringRef DevelopmentStatus,
+                        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, bool IsHidden = false);
+                        StringRef Description, StringRef DevelopmentStatus,
+                         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

if (Value == NumInliningModes) {
       Opts.InliningMode = Value;
     }
   }
 
   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.ShowCheckerOptionAlphaList =
+      Args.hasArg(OPT_analyzer_checker_option_help_alpha);
   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 (AnOpts.ShowCheckerOptionList || AnOpts.ShowCheckerOptionDeveloperList) {
+  if (AnOpts.ShowCheckerOptionList || AnOpts.ShowCheckerOptionAlphaList ||
+      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, IS_HIDDEN)  \
-  addCheckerOption(TYPE, FULLNAME, CMDFLAG, DEFAULT_VAL, DESC, IS_HIDDEN);
+#define CHECKER_OPTION(TYPE, FULLNAME, CMDFLAG, DESC, DEFAULT_VAL, DEVELOPMENT_STATUS, IS_HIDDEN)  \
+  addCheckerOption(TYPE, FULLNAME, CMDFLAG, DEFAULT_VAL, DESC, DEVELOPMENT_STATUS, IS_HIDDEN);
 
 #define GET_PACKAGE_OPTIONS
-#define PACKAGE_OPTION(TYPE, FULLNAME, CMDFLAG, DESC, DEFAULT_VAL, IS_HIDDEN)  \
-  addPackageOption(TYPE, FULLNAME, CMDFLAG, DEFAULT_VAL, DESC, IS_HIDDEN);
+#define PACKAGE_OPTION(TYPE, FULLNAME, CMDFLAG, DESC, DEFAULT_VAL, DEVELOPMENT_STATUS, IS_HIDDEN)  \
+  addPackageOption(TYPE, FULLNAME, CMDFLAG, DEFAULT_VAL, DESC, DEVELOPMENT_STATUS, 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, bool IsHidden) {
+                                       StringRef Description,
+                                       StringRef DevelopmentStatus,
+                                       bool IsHidden) {
   PackageOptions.emplace_back(
       PackageFullName, CmdLineOption{OptionType, OptionName, DefaultValStr,
-                                     Description, IsHidden});
+                                     Description, DevelopmentStatus, 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, bool IsHidden) {
+                                       StringRef Description,
+                                       StringRef DevelopmentStatus,
+                                       bool IsHidden) {
   CheckerOptions.emplace_back(
       CheckerFullName, CmdLineOption{OptionType, OptionName, DefaultValStr,
-                                     Description, IsHidden});
+                                     Description, DevelopmentStatus, 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});
     }
   }
 
+  auto Print = [] (llvm::raw_ostream &Out, StringRef FullOption, StringRef Desc) {
+    AnalyzerOptions::printFormattedEntry(Out, {FullOption, Desc},
+                                         /*InitialPad*/ 2,
+                                         /*EntryWidth*/ 50,
+                                         /*MinLineWidth*/ 90);
+    Out << "\n\n";
+  };
   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";
+    // The list of these if branches is significant, we wouldn't like to
+    // display hidden alpha checker options for
+    // -analyzer-checker-option-help-alpha.
+
+    if (Option.IsHidden) {
+      if (AnOpts.ShowCheckerOptionDeveloperList)
+        Print(Out, FullOption, Desc);
+      continue;
+    }
+
+    if (Option.DevelopmentStatus == "alpha" ||
+        Entry.first.startswith("alpha")) {
+      if (AnOpts.ShowCheckerOptionAlphaList)
+        Print(Out, FullOption,
+              llvm::Twine("(Enable only for development!) " + Desc).str());
+      continue;
+    }
+
+    if (AnOpts.ShowCheckerOptionList)
+      Print(Out, FullOption, Desc);
   }
 }

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 \
+// RUN:   2>&1 | FileCheck %s -check-prefix=CHECK-STABLE
+
+// RUN: %clang_cc1 -analyzer-checker-option-help-alpha \
+// RUN:   2>&1 | FileCheck %s -check-prefix=CHECK-ALPHA
+
+// RUN: %clang_cc1 -analyzer-checker-option-help-developer \
+// RUN:   2>&1 | FileCheck %s -check-prefix=CHECK-DEVELOPER
 
 // RUN: %clang_cc1 -analyzer-checker-option-help-developer \
-// RUN:   2>&1 | FileCheck %s -check-prefix=CHECK-HIDDEN
+// RUN:   -analyzer-checker-option-help-alpha \
+// RUN:   2>&1 | FileCheck %s -check-prefix=CHECK-DEVELOPER-ALPHA
+
+// RUN: %clang_cc1 -analyzer-checker-option-help \
+// RUN:   -analyzer-checker-option-help-alpha \
+// RUN:   2>&1 | FileCheck %s -check-prefix=CHECK-STABLE-ALPHA
 
-// CHECK: OVERVIEW: Clang Static Analyzer Checker and Package Option List
+// RUN: %clang_cc1 -analyzer-checker-option-help \
+// RUN:   -analyzer-checker-option-help-developer \
+// RUN:   2>&1 | FileCheck %s -check-prefix=CHECK-STABLE-DEVELOPER
+
+// RUN: %clang_cc1 -analyzer-checker-option-help \
+// RUN:   -analyzer-checker-option-help-alpha \
+// RUN:   -analyzer-checker-option-help-developer \
+// RUN:   2>&1 | FileCheck %s -check-prefix=CHECK-STABLE-ALPHA-DEVELOPER
+
+// CHECK-STABLE: OVERVIEW: Clang Static Analyzer Checker and Package Option List
 //
-// CHECK: USAGE: -analyzer-config <OPTION1=VALUE,OPTION2=VALUE,...>
+// CHECK-STABLE: USAGE: -analyzer-config <OPTION1=VALUE,OPTION2=VALUE,...>
 //
-// CHECK:        -analyzer-config OPTION1=VALUE, -analyzer-config
-// CHECK-SAME:   OPTION2=VALUE, ...
+// CHECK-STABLE:        -analyzer-config OPTION1=VALUE, -analyzer-config
+// CHECK-STABLE-SAME:   OPTION2=VALUE, ...
 //
-// CHECK: OPTIONS:
+// CHECK-STABLE: 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-STABLE:   cplusplus.Move:WarnOn 
+// CHECK-STABLE-SAME:          (string) In non-aggressive mode, only warn
+// CHECK-STABLLE:              on use-after-move of local variables (or
+// CHECK-STABLLE:              local rvalue references) and of STL objects.
+// CHECK-STABLLE:              The former is possible because local variables
+// CHECK-STABLLE:              (or local rvalue references) are not tempting
+// CHECK-STABLLE:              their user to re-use the storage. The latter
+// CHECK-STABLLE:              is possible because STL objects are known
+// CHECK-STABLLE:              to end up in a valid but unspecified state
+// CHECK-STABLLE:              after the move and their state-reset methods
+// CHECK-STABLLE:              are also known, which allows us to predict
+// CHECK-STABLLE:              precisely when use-after-move is invalid.
+// CHECK-STABLLE:              Some STL objects are known to conform to
+// CHECK-STABLLE:              additional contracts after move, so they
+// CHECK-STABLLE:              are not tracked. However, smart pointers
+// CHECK-STABLLE:              specifically are tracked because we can
+// CHECK-STABLLE:              perform extra checking over them. In aggressive
+// CHECK-STABLLE:              mode, warn on any use-after-move because
+// CHECK-STABLLE:              the user has intentionally asked us to completely
+// CHECK-STABLLE:              eliminate use-after-move in his code. Values:
+// CHECK-STABLLE:              "KnownsOnly", "KnownsAndLocals", "All".
+// CHECK-STABLLE:              (default: KnownsAndLocals)
+
+// CHECK-STABLE-NOT: debug.AnalysisOrder:*
+// CHECK-DEVELOPER:  debug.AnalysisOrder:*
+// CHECK-ALPHA-NOT:  debug.AnalysisOrder:*
+
+// CHECK-STABLE-NOT:    optin.cplusplus.UninitializedObject:IgnoreGuardedFields
+// CHECK-DEVELOPER-NOT: optin.cplusplus.UninitializedObject:IgnoreGuardedFields
+// CHECK-ALPHA:         optin.cplusplus.UninitializedObject:IgnoreGuardedFields
+
+// CHECK-STABLE:        optin.performance.Padding:AllowedPad
+// CHECK-DEVELOPER-NOT: optin.performance.Padding:AllowedPad
+// CHECK-ALPHA-NOT:     optin.performance.Padding:AllowedPad
+
+
+// CHECK-STABLE-ALPHA-NOT: debug.AnalysisOrder:*
+// CHECK-DEVELOPER-ALPHA:  debug.AnalysisOrder:*
+// CHECK-STABLE-DEVELOPER: debug.AnalysisOrder:*
+
+// CHECK-STABLE-ALPHA:         optin.cplusplus.UninitializedObject:IgnoreGuardedFields
+// CHECK-DEVELOPER-ALPHA:      optin.cplusplus.UninitializedObject:IgnoreGuardedFields
+// CHECK-STABLE-DEVELOPER-NOT: optin.cplusplus.UninitializedObject:IgnoreGuardedFields
+
+// CHECK-STABLE-ALPHA:        optin.performance.Padding:AllowedPad
+// CHECK-DEVELOPER-ALPHA-NOT: optin.performance.Padding:AllowedPad
+// CHECK-STABLE-DEVELOPER:    optin.performance.Padding:AllowedPad
+
 
-// CHECK-NOT:     optin.cplusplus.UninitializedObject:NotesAsWarnings
-// CHECK-HIDDEN:  optin.cplusplus.UninitializedObject:NotesAsWarnings
+// CHECK-STABLE-ALPHA-DEVELOPER: debug.AnalysisOrder:*
+// CHECK-STABLE-ALPHA-DEVELOPER: optin.cplusplus.UninitializedObject:IgnoreGuardedFields
+// CHECK-STABLE-ALPHA-DEVELOPER: optin.performance.Padding:AllowedPad

test/Analysis/plugins/CheckerOptionHandling/CheckerOptionHandling.cpp

registry.addChecker(registerMyChecker, shouldRegisterMyChecker,
                       "example.MyChecker", "Example Description",
                       "example.mychecker.documentation.nonexistent.html",
                       /*isHidden*/false);
 
   registry.addCheckerOption(/*OptionType*/ "bool",
                             /*CheckerFullName*/ "example.MyChecker",
                             /*OptionName*/ "ExampleOption",
                             /*DefaultValStr*/ "false",
-                            /*Description*/ "This is an example checker opt.");
+                            /*Description*/ "This is an example checker opt.",
+                            /*DevelopmentStage*/ "released");
 }
 
 extern "C" const char clang_analyzerAPIVersionString[] =
     CLANG_ANALYZER_API_VERSION_STRING;

utils/TableGen/ClangSACheckersEmitter.cpp

if (BitsInit *BI = R.getValueAsBitsInit("Type")) {
     }
   }
   PrintFatalError(R.getLoc(),
                   "unable to parse command line option type for "
                   + getCheckerFullName(&R));
   return "";
 }
 
+static std::string getDevelopmentStage(const Record &R) {
+  if (BitsInit *BI = R.getValueAsBitsInit("DevelopmentStage")) {
+    switch(getValueFromBitsInit(BI, R)) {
+    case 0:
+      return "alpha";
+    case 1:
+      return "released";
+    }
+  }
+
+  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());
 
static void printOption(llvm::raw_ostream &OS, StringRef FullName,
   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")) << "\", ";
+  OS << '\"';
+  OS << getDevelopmentStage(R) << "\", ";
 
   if (!R.getValueAsBit("Hidden"))
     OS << "false";
   else
     OS << "true";
 }
 
 namespace clang {