[analyzer] Remove HasAlphaDocumentation tablegen enum value

[steakhal]

Summary

D121387 simplified the doc url generation process, so we no longer need
the HasAlphaDocumentation enum entry. This patch removes that.

[martong]

Hahh, indeed. IMHO, it does not make sense to write an "alpha" documentation, either write it properly or do not write anything.

clang/include/clang/StaticAnalyzer/Checkers/CheckerBase.td

 ///   def CoreBuiltin : Package<"builtin">, ParentPackage<Core>;
 class ParentPackage<Package P> { Package ParentPackage = P; }
 
 /// A description. May be displayed to the user when clang is invoked with
 /// a '-help'-like command line option.
 class HelpText<string text> { string HelpText = text; }
 
 /// Describes what kind of documentation exists for the checker.
-class DocumentationEnum<bits<2> val> {
-  bits<2> Documentation = val;
+class DocumentationEnum<bits<1> val> {
+  bits<1> Documentation = val;
 }
 def NotDocumented : DocumentationEnum<0>;
 def HasDocumentation : DocumentationEnum<1>;
-def HasAlphaDocumentation : DocumentationEnum<2>;
 
 class Documentation<DocumentationEnum val> {
-  bits<2> Documentation = val.Documentation;
+  bits<1> Documentation = val.Documentation;
 }
 
 /// Describes a checker. Every builtin checker has to be registered with the use
 /// of this class (out-of-trunk checkers loaded from plugins obviously don't).
 /// Note that a checker has a name (e.g.: 'NullDereference'), and a fullname,
 /// that is autogenerated with the help of the ParentPackage field, that also
 /// includes package names (e.g.: 'core.NullDereference').
 /// Example:
 ///   def DereferenceChecker : Checker<"NullDereference">,
 ///     HelpText<"Check for dereferences of null pointers">;
 class Checker<string name = ""> {
   string              CheckerName = name;
   string              HelpText;
   // This field is optional.
   list<CmdLineOption> CheckerOptions;
   // This field is optional.
   list<Checker>       Dependencies;
   // This field is optional.
   list<Checker>       WeakDependencies;
-  bits<2>             Documentation;
+  bits<1>             Documentation;
   Package             ParentPackage;
   bit                 Hidden = 0;
 }
 
 /// Describes a list of checker options.
 class CheckerOptions<list<CmdLineOption> opts> {
   list<CmdLineOption> CheckerOptions = opts;
 }

clang/include/clang/StaticAnalyzer/Checkers/Checkers.td

def NonnullGlobalConstantsChecker: Checker<"NonnilStringConstants">,
   Hidden;
 
 } // end "core"
 
 let ParentPackage = CoreAlpha in {
 
 def BoolAssignmentChecker : Checker<"BoolAssignment">,
   HelpText<"Warn about assigning non-{0,1} values to Boolean variables">,
-  Documentation<HasAlphaDocumentation>;
+  Documentation<HasDocumentation>;
 
 def CastSizeChecker : Checker<"CastSize">,
   HelpText<"Check when casting a malloc'ed type T, whether the size is a "
            "multiple of the size of T">,
-  Documentation<HasAlphaDocumentation>;
+  Documentation<HasDocumentation>;
 
 def CastToStructChecker : Checker<"CastToStruct">,
   HelpText<"Check for cast from non-struct pointer to struct pointer">,
-  Documentation<HasAlphaDocumentation>;
+  Documentation<HasDocumentation>;
 
 def ConversionChecker : Checker<"Conversion">,
   HelpText<"Loss of sign/precision in implicit conversions">,
-  Documentation<HasAlphaDocumentation>;
+  Documentation<HasDocumentation>;
 
 def IdenticalExprChecker : Checker<"IdenticalExpr">,
   HelpText<"Warn about unintended use of identical expressions in operators">,
-  Documentation<HasAlphaDocumentation>;
+  Documentation<HasDocumentation>;
 
 def FixedAddressChecker : Checker<"FixedAddr">,
   HelpText<"Check for assignment of a fixed address to a pointer">,
-  Documentation<HasAlphaDocumentation>;
+  Documentation<HasDocumentation>;
 
 def PointerArithChecker : Checker<"PointerArithm">,
   HelpText<"Check for pointer arithmetic on locations other than array "
            "elements">,
-  Documentation<HasAlphaDocumentation>;
+  Documentation<HasDocumentation>;
 
 def PointerSubChecker : Checker<"PointerSub">,
   HelpText<"Check for pointer subtractions on two pointers pointing to "
            "different memory chunks">,
-  Documentation<HasAlphaDocumentation>;
+  Documentation<HasDocumentation>;
 
 def SizeofPointerChecker : Checker<"SizeofPtr">,
   HelpText<"Warn about unintended use of sizeof() on pointer expressions">,
-  Documentation<HasAlphaDocumentation>;
+  Documentation<HasDocumentation>;
 
 def TestAfterDivZeroChecker : Checker<"TestAfterDivZero">,
   HelpText<"Check for division by variable that is later compared against 0. "
            "Either the comparison is useless or there is division by zero.">,
-  Documentation<HasAlphaDocumentation>;
+  Documentation<HasDocumentation>;
 
 def DynamicTypeChecker : Checker<"DynamicTypeChecker">,
   HelpText<"Check for cases where the dynamic and the static type of an object "
            "are unrelated.">,
-  Documentation<HasAlphaDocumentation>;
+  Documentation<HasDocumentation>;
 
 def StackAddrAsyncEscapeChecker : Checker<"StackAddressAsyncEscape">,
   HelpText<"Check that addresses to stack memory do not escape the function">,
   Dependencies<[StackAddrEscapeBase]>,
-  Documentation<HasAlphaDocumentation>;
+  Documentation<HasDocumentation>;
 
 def PthreadLockBase : Checker<"PthreadLockBase">,
   HelpText<"Helper registering multiple checks.">,
   Documentation<NotDocumented>,
   Hidden;
 
 def C11LockChecker : Checker<"C11Lock">,
   HelpText<"Simple lock -> unlock checker">,
   Dependencies<[PthreadLockBase]>,
-  Documentation<HasAlphaDocumentation>;
+  Documentation<HasDocumentation>;
 
 } // end "alpha.core"
 
 //===----------------------------------------------------------------------===//
 // Nullability checkers.
 //===----------------------------------------------------------------------===//
 
 let ParentPackage = Nullability in {

 
 } // end "unix.cstring"
 
 let ParentPackage = CStringAlpha in {
 
 def CStringOutOfBounds : Checker<"OutOfBounds">,
   HelpText<"Check for out-of-bounds access in string functions">,
   Dependencies<[CStringModeling]>,
-  Documentation<HasAlphaDocumentation>;
+  Documentation<HasDocumentation>;
 
 def CStringBufferOverlap : Checker<"BufferOverlap">,
   HelpText<"Checks for overlap in two buffer arguments">,
   Dependencies<[CStringModeling]>,
-  Documentation<HasAlphaDocumentation>;
+  Documentation<HasDocumentation>;
 
 def CStringNotNullTerm : Checker<"NotNullTerminated">,
   HelpText<"Check for arguments which are not null-terminating strings">,
   Dependencies<[CStringModeling]>,
-  Documentation<HasAlphaDocumentation>;
+  Documentation<HasDocumentation>;
  
 def CStringUninitializedRead : Checker<"UninitializedRead">,
   HelpText<"Checks if the string manipulation function would read uninitialized bytes">,
   Dependencies<[CStringModeling]>,
-  Documentation<HasAlphaDocumentation>;
+  Documentation<HasDocumentation>;
   
 } // end "alpha.unix.cstring"
 
 let ParentPackage = Unix in {
 
 def UnixAPIMisuseChecker : Checker<"API">,
   HelpText<"Check calls to various UNIX/Posix functions">,
   Documentation<HasDocumentation>;
def VforkChecker : Checker<"Vfork">,
   Documentation<HasDocumentation>;
 
 } // end "unix"
 
 let ParentPackage = UnixAlpha in {
 
 def ChrootChecker : Checker<"Chroot">,
   HelpText<"Check improper use of chroot">,
-  Documentation<HasAlphaDocumentation>;
+  Documentation<HasDocumentation>;
 
 def PthreadLockChecker : Checker<"PthreadLock">,
   HelpText<"Simple lock -> unlock checker">,
   Dependencies<[PthreadLockBase]>,
-  Documentation<HasAlphaDocumentation>;
+  Documentation<HasDocumentation>;
 
 def StreamChecker : Checker<"Stream">,
   HelpText<"Check stream handling functions">,
-  Documentation<HasAlphaDocumentation>;
+  Documentation<HasDocumentation>;
 
 def SimpleStreamChecker : Checker<"SimpleStream">,
   HelpText<"Check for misuses of stream APIs">,
-  Documentation<HasAlphaDocumentation>;
+  Documentation<HasDocumentation>;
 
 def BlockInCriticalSectionChecker : Checker<"BlockInCriticalSection">,
   HelpText<"Check for calls to blocking functions inside a critical section">,
-  Documentation<HasAlphaDocumentation>;
+  Documentation<HasDocumentation>;
 
 def StdCLibraryFunctionArgsChecker : Checker<"StdCLibraryFunctionArgs">,
   HelpText<"Check constraints of arguments of C standard library functions, "
            "such as whether the parameter of isalpha is in the range [0, 255] "
            "or is EOF.">,
   Dependencies<[StdCLibraryFunctionsChecker]>,
   WeakDependencies<[CallAndMessageChecker, NonNullParamChecker, StreamChecker]>,
-  Documentation<HasAlphaDocumentation>;
+  Documentation<HasDocumentation>;
 
 } // end "alpha.unix"
 
 //===----------------------------------------------------------------------===//
 // C++ checkers.
 //===----------------------------------------------------------------------===//
 
 let ParentPackage = Cplusplus in {
CheckerOptions<[
     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",
                   InAlpha>
   ]>,
-  Documentation<HasAlphaDocumentation>;
+  Documentation<HasDocumentation>;
 
 def VirtualCallChecker : Checker<"VirtualCall">,
   HelpText<"Check virtual function calls during construction/destruction">,
   CheckerOptions<[
     CmdLineOption<Boolean,
                   "ShowFixIts",
                   "Enable fix-it hints for this checker",
                   "false",

 def ContainerModeling : Checker<"ContainerModeling">,
   HelpText<"Models C++ containers">,
   Documentation<NotDocumented>,
   Hidden;
 
 def DeleteWithNonVirtualDtorChecker : Checker<"DeleteWithNonVirtualDtor">,
   HelpText<"Reports destructions of polymorphic objects with a non-virtual "
            "destructor in their base class">,
-  Documentation<HasAlphaDocumentation>;
+  Documentation<HasDocumentation>;
 
 def EnumCastOutOfRangeChecker : Checker<"EnumCastOutOfRange">,
   HelpText<"Check integer to enumeration casts for out of range values">,
-  Documentation<HasAlphaDocumentation>;
+  Documentation<HasDocumentation>;
 
 def IteratorModeling : Checker<"IteratorModeling">,
   HelpText<"Models iterators of C++ containers">,
   Dependencies<[ContainerModeling]>,
   Documentation<NotDocumented>,
   Hidden;
 
 def STLAlgorithmModeling : Checker<"STLAlgorithmModeling">,
   HelpText<"Models the algorithm library of the C++ STL.">,
   CheckerOptions<[
     CmdLineOption<Boolean,
                   "AggressiveStdFindModeling",
                   "Enables exploration of the failure branch in std::find-like "
                   "functions.",
                   "false",
                   Released>
   ]>,
   Dependencies<[ContainerModeling]>,
   Documentation<NotDocumented>;
 
 def InvalidatedIteratorChecker : Checker<"InvalidatedIterator">,
   HelpText<"Check for use of invalidated iterators">,
   Dependencies<[IteratorModeling]>,
-  Documentation<HasAlphaDocumentation>;
+  Documentation<HasDocumentation>;
 
 def IteratorRangeChecker : Checker<"IteratorRange">,
   HelpText<"Check for iterators used outside their valid ranges">,
   Dependencies<[IteratorModeling]>,
-  Documentation<HasAlphaDocumentation>;
+  Documentation<HasDocumentation>;
 
 def MismatchedIteratorChecker : Checker<"MismatchedIterator">,
   HelpText<"Check for use of iterators of different containers where iterators "
            "of the same container are expected">,
   Dependencies<[IteratorModeling]>,
-  Documentation<HasAlphaDocumentation>;
+  Documentation<HasDocumentation>;
 
 def SmartPtrChecker: Checker<"SmartPtr">,
   HelpText<"Find the dereference of null SmrtPtr">,
   Dependencies<[SmartPtrModeling]>,
-  Documentation<HasAlphaDocumentation>;
+  Documentation<HasDocumentation>;
 
 } // end: "alpha.cplusplus"
 
 
 //===----------------------------------------------------------------------===//
 // Valist checkers.
 //===----------------------------------------------------------------------===//
 
def DeadStoresChecker : Checker<"DeadStores">,
   Documentation<HasDocumentation>;
 
 } // end DeadCode
 
 let ParentPackage = DeadCodeAlpha in {
 
 def UnreachableCodeChecker : Checker<"UnreachableCode">,
   HelpText<"Check unreachable code">,
-  Documentation<HasAlphaDocumentation>;
+  Documentation<HasDocumentation>;
 
 } // end "alpha.deadcode"
 
 //===----------------------------------------------------------------------===//
 // Performance checkers.
 //===----------------------------------------------------------------------===//
 
 let ParentPackage = Performance in {
let ParentPackage = ENV in {
   Documentation<HasDocumentation>;
 
 } // end "alpha.cert.env"
 
 let ParentPackage = SecurityAlpha in {
 
 def ArrayBoundChecker : Checker<"ArrayBound">,
   HelpText<"Warn about buffer overflows (older checker)">,
-  Documentation<HasAlphaDocumentation>;
+  Documentation<HasDocumentation>;
 
 def ArrayBoundCheckerV2 : Checker<"ArrayBoundV2">,
   HelpText<"Warn about buffer overflows (newer checker)">,
-  Documentation<HasAlphaDocumentation>;
+  Documentation<HasDocumentation>;
 
 def ReturnPointerRangeChecker : Checker<"ReturnPtrRange">,
   HelpText<"Check for an out-of-bound pointer being returned to callers">,
-  Documentation<HasAlphaDocumentation>;
+  Documentation<HasDocumentation>;
 
 def MallocOverflowSecurityChecker : Checker<"MallocOverflow">,
   HelpText<"Check for overflows in the arguments to malloc()">,
-  Documentation<HasAlphaDocumentation>;
+  Documentation<HasDocumentation>;
 
 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",
                   Released>,
     CmdLineOption<Integer,
                   "MmapProtRead",
                   "Specifies the value of PROT_READ",
                   "0x01",
                   Released>
   ]>,
-  Documentation<HasAlphaDocumentation>;
+  Documentation<HasDocumentation>;
 
 } // end "alpha.security"
 
 //===----------------------------------------------------------------------===//
 // Taint checkers.
 //===----------------------------------------------------------------------===//
 
 let ParentPackage = Taint in {
 
 def GenericTaintChecker : Checker<"TaintPropagation">,
   HelpText<"Generate taint information used by other checkers">,
   CheckerOptions<[
     CmdLineOption<String,
                   "Config",
                   "Specifies the name of the configuration file.",
                   "",
                   InAlpha>,
   ]>,
-  Documentation<HasAlphaDocumentation>;
+  Documentation<HasDocumentation>;
 
 } // end "alpha.security.taint"
 
 //===----------------------------------------------------------------------===//
 // Mac OS X, Cocoa, and Core Foundation checkers.
 //===----------------------------------------------------------------------===//
 
 let ParentPackage = Cocoa in {
HelpText<"Gathers information for annotation driven invalidation checking "
            "'objc_instance_variable_invalidator'">,
   Documentation<NotDocumented>,
   Hidden;
 
 def InstanceVariableInvalidation : Checker<"InstanceVariableInvalidation">,
   HelpText<"Check that the invalidatable instance variables are invalidated in "
            "the methods annotated with objc_instance_variable_invalidator">,
   Dependencies<[IvarInvalidationModeling]>,
-  Documentation<HasAlphaDocumentation>;
+  Documentation<HasDocumentation>;
 
 def MissingInvalidationMethod : Checker<"MissingInvalidationMethod">,
   HelpText<"Check that the invalidation methods are present in classes that "
            "contain invalidatable instance variables">,
   Dependencies<[IvarInvalidationModeling]>,
-  Documentation<HasAlphaDocumentation>;
+  Documentation<HasDocumentation>;
 
 def DirectIvarAssignment : Checker<"DirectIvarAssignment">,
   HelpText<"Check for direct assignments to instance variables">,
   CheckerOptions<[
     CmdLineOption<Boolean,
                   "AnnotatedFunctions",
                   "Check for direct assignments to instance variables in the "
                   "methods annotated with "
                   "objc_no_direct_instance_variable_assignment",
                   "false",
                   InAlpha>
   ]>,
-  Documentation<HasAlphaDocumentation>;
+  Documentation<HasDocumentation>;
 
 } // end "alpha.osx.cocoa"
 
 let ParentPackage = CoreFoundation in {
 
 def CFNumberChecker : Checker<"CFNumber">,
   HelpText<"Check for proper uses of CFNumber APIs">,
   Documentation<HasDocumentation>;

 
 } // end "optin.osx.cocoa.localizability"
 
 let ParentPackage = LocalizabilityAlpha in {
 
 def PluralMisuseChecker : Checker<"PluralMisuseChecker">,
   HelpText<"Warns against using one vs. many plural pattern in code when "
            "generating localized strings.">,
-  Documentation<HasAlphaDocumentation>;
+  Documentation<HasDocumentation>;
 
 } // end "alpha.osx.cocoa.localizability"
 
 let ParentPackage = MPI in {
 
 def MPIChecker : Checker<"MPI-Checker">,
   HelpText<"Checks MPI code">,
   Documentation<HasDocumentation>;
 
 } // end "optin.mpi"
 
 //===----------------------------------------------------------------------===//
 // Checkers for LLVM development.
 //===----------------------------------------------------------------------===//
 
 let ParentPackage = LLVMAlpha in {
 
 def LLVMConventionsChecker : Checker<"Conventions">,
   HelpText<"Check code for LLVM codebase conventions">,
-  Documentation<HasAlphaDocumentation>;
+  Documentation<HasDocumentation>;
 
 } // end "llvm"
 
 let ParentPackage = LLVMAPIModeling in {
 
 def CastValueChecker : Checker<"CastValue">,
   HelpText<"Model implementation of custom RTTIs">,
   Documentation<NotDocumented>;
CmdLineOption<Boolean,
                   Released>,
     CmdLineOption<String,
                   "IgnoredFilesPattern",
                   "If supplied, the checker wont analyze files with a filename "
                   "that matches the given pattern.",
                   "\"\"",
                   Released>
   ]>,
-  Documentation<HasAlphaDocumentation>;
+  Documentation<HasDocumentation>;
 
 } // end "clone"
 
 //===----------------------------------------------------------------------===//
 // Portability checkers.
 //===----------------------------------------------------------------------===//
 
 let ParentPackage = PortabilityOptIn in {