contrib/llvm/tools/clang/include/clang/Basic/DiagnosticGroups.td

   1 //==--- DiagnosticGroups.td - Diagnostic Group Definitions ----------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 def ImplicitFunctionDeclare : DiagGroup<"implicit-function-declaration">;
  11 def ImplicitInt : DiagGroup<"implicit-int">;
  12
  13 // Aggregation warning settings.
  14 def Implicit : DiagGroup<"implicit", [
  15     ImplicitFunctionDeclare,
  16     ImplicitInt
  17 ]>;
  18
  19 // Empty DiagGroups are recognized by clang but ignored.
  20 def : DiagGroup<"abi">;
  21 def AbsoluteValue : DiagGroup<"absolute-value">;
  22 def AddressOfTemporary : DiagGroup<"address-of-temporary">;
  23 def : DiagGroup<"aggregate-return">;
  24 def GNUAlignofExpression : DiagGroup<"gnu-alignof-expression">;
  25 def AmbigMemberTemplate : DiagGroup<"ambiguous-member-template">;
  26 def GNUAnonymousStruct : DiagGroup<"gnu-anonymous-struct">;
  27 def GNUAutoType : DiagGroup<"gnu-auto-type">;
  28 def ArrayBounds : DiagGroup<"array-bounds">;
  29 def ArrayBoundsPointerArithmetic : DiagGroup<"array-bounds-pointer-arithmetic">;
  30 def Availability : DiagGroup<"availability">;
  31 def Section : DiagGroup<"section">;
  32 def AutoImport : DiagGroup<"auto-import">;
  33 def CXX14BinaryLiteral : DiagGroup<"c++14-binary-literal">;
  34 def GNUBinaryLiteral : DiagGroup<"gnu-binary-literal">;
  35 def GNUCompoundLiteralInitializer : DiagGroup<"gnu-compound-literal-initializer">;
  36 def BitFieldConstantConversion : DiagGroup<"bitfield-constant-conversion">;
  37 def BitFieldWidth : DiagGroup<"bitfield-width">;
  38 def ConstantConversion :
  39   DiagGroup<"constant-conversion", [ BitFieldConstantConversion ] >;
  40 def LiteralConversion : DiagGroup<"literal-conversion">;
  41 def StringConversion : DiagGroup<"string-conversion">;
  42 def SignConversion : DiagGroup<"sign-conversion">;
  43 def PointerBoolConversion : DiagGroup<"pointer-bool-conversion">;
  44 def UndefinedBoolConversion : DiagGroup<"undefined-bool-conversion">;
  45 def BoolConversion : DiagGroup<"bool-conversion", [PointerBoolConversion,
  46                                                    UndefinedBoolConversion]>;
  47 def IntConversion : DiagGroup<"int-conversion">;
  48 def EnumConversion : DiagGroup<"enum-conversion">;
  49
  50 def FloatOverflowConversion : DiagGroup<"float-overflow-conversion">;
  51 def FloatZeroConversion : DiagGroup<"float-zero-conversion">;
  52 def FloatConversion :
  53   DiagGroup<"float-conversion", [FloatOverflowConversion,
  54                                  FloatZeroConversion]>;
  55
  56 def DoublePromotion : DiagGroup<"double-promotion">;
  57 def EnumTooLarge : DiagGroup<"enum-too-large">;
  58 def UnsupportedNan : DiagGroup<"unsupported-nan">;
  59 def UnsupportedCB : DiagGroup<"unsupported-cb">;
  60 def NonLiteralNullConversion : DiagGroup<"non-literal-null-conversion">;
  61 def NullConversion : DiagGroup<"null-conversion">;
  62 def ImplicitConversionFloatingPointToBool :
  63   DiagGroup<"implicit-conversion-floating-point-to-bool">;
  64 def ObjCLiteralConversion : DiagGroup<"objc-literal-conversion">;
  65 def MacroRedefined : DiagGroup<"macro-redefined">;
  66 def BuiltinMacroRedefined : DiagGroup<"builtin-macro-redefined">;
  67 def BuiltinRequiresHeader : DiagGroup<"builtin-requires-header">;
  68 def C99Compat : DiagGroup<"c99-compat">;
  69 def CXXCompat: DiagGroup<"c++-compat">;
  70 def ExternCCompat : DiagGroup<"extern-c-compat">;
  71 def KeywordCompat : DiagGroup<"keyword-compat">;
  72 def GNUCaseRange : DiagGroup<"gnu-case-range">;
  73 def CastAlign : DiagGroup<"cast-align">;
  74 def CastQual : DiagGroup<"cast-qual">;
  75 def : DiagGroup<"char-align">;
  76 def Comment : DiagGroup<"comment">;
  77 def GNUComplexInteger : DiagGroup<"gnu-complex-integer">;
  78 def GNUConditionalOmittedOperand : DiagGroup<"gnu-conditional-omitted-operand">;
  79 def ConfigMacros : DiagGroup<"config-macros">;
  80 def : DiagGroup<"ctor-dtor-privacy">;
  81 def GNUDesignator : DiagGroup<"gnu-designator">;
  82 def GNUStringLiteralOperatorTemplate :
  83   DiagGroup<"gnu-string-literal-operator-template">;
  84 def UndefinedVarTemplate : DiagGroup<"undefined-var-template">;
  85 def UndefinedFuncTemplate : DiagGroup<"undefined-func-template">;
  86
  87 def DeleteIncomplete : DiagGroup<"delete-incomplete">;
  88 def DeleteNonVirtualDtor : DiagGroup<"delete-non-virtual-dtor">;
  89 def AbstractFinalClass : DiagGroup<"abstract-final-class">;
  90
  91 def CXX11CompatDeprecatedWritableStr :
  92   DiagGroup<"c++11-compat-deprecated-writable-strings">;
  93
  94 def DeprecatedAttributes : DiagGroup<"deprecated-attributes">;
  95 def DeprecatedDeclarations : DiagGroup<"deprecated-declarations">;
  96 def UnavailableDeclarations : DiagGroup<"unavailable-declarations">;
  97 def UnguardedAvailability : DiagGroup<"unguarded-availability">;
  98 // partial-availability is an alias of unguarded-availability.
  99 def : DiagGroup<"partial-availability", [UnguardedAvailability]>;
 100 def DeprecatedDynamicExceptionSpec
 101     : DiagGroup<"deprecated-dynamic-exception-spec">;
 102 def DeprecatedImplementations :DiagGroup<"deprecated-implementations">;
 103 def DeprecatedIncrementBool : DiagGroup<"deprecated-increment-bool">;
 104 def DeprecatedRegister : DiagGroup<"deprecated-register">;
 105 def DeprecatedWritableStr : DiagGroup<"deprecated-writable-strings",
 106                                       [CXX11CompatDeprecatedWritableStr]>;
 107 // FIXME: Why is DeprecatedImplementations not in this group?
 108 def Deprecated : DiagGroup<"deprecated", [DeprecatedAttributes,
 109                                           DeprecatedDeclarations,
 110                                           DeprecatedDynamicExceptionSpec,
 111                                           DeprecatedIncrementBool,
 112                                           DeprecatedRegister,
 113                                           DeprecatedWritableStr]>,
 114                  DiagCategory<"Deprecations">;
 115
 116 def DynamicExceptionSpec
 117     : DiagGroup<"dynamic-exception-spec", [DeprecatedDynamicExceptionSpec]>;
 118
 119 def LibLTO : DiagGroup<"liblto">;
 120 def : DiagGroup<"disabled-optimization">;
 121 def : DiagGroup<"discard-qual">;
 122 def DivZero : DiagGroup<"division-by-zero">;
 123 def : DiagGroup<"div-by-zero", [DivZero]>;
 124
 125 def DocumentationHTML : DiagGroup<"documentation-html">;
 126 def DocumentationUnknownCommand : DiagGroup<"documentation-unknown-command">;
 127 def DocumentationPedantic : DiagGroup<"documentation-pedantic",
 128                                       [DocumentationUnknownCommand]>;
 129 def DocumentationDeprecatedSync : DiagGroup<"documentation-deprecated-sync">;
 130 def Documentation : DiagGroup<"documentation",
 131                               [DocumentationHTML,
 132                                DocumentationDeprecatedSync]>;
 133
 134 def EmptyBody : DiagGroup<"empty-body">;
 135 def Exceptions : DiagGroup<"exceptions">;
 136
 137 def GNUEmptyInitializer : DiagGroup<"gnu-empty-initializer">;
 138 def GNUEmptyStruct : DiagGroup<"gnu-empty-struct">;
 139 def ExtraTokens : DiagGroup<"extra-tokens">;
 140 def CXX11ExtraSemi : DiagGroup<"c++11-extra-semi">;
 141 def ExtraSemi : DiagGroup<"extra-semi", [CXX11ExtraSemi]>;
 142
 143 def GNUFlexibleArrayInitializer : DiagGroup<"gnu-flexible-array-initializer">;
 144 def GNUFlexibleArrayUnionMember : DiagGroup<"gnu-flexible-array-union-member">;
 145 def GNUFoldingConstant : DiagGroup<"gnu-folding-constant">;
 146 def FormatExtraArgs : DiagGroup<"format-extra-args">;
 147 def FormatZeroLength : DiagGroup<"format-zero-length">;
 148
 149 // Warnings for C++1y code which is not compatible with prior C++ standards.
 150 def CXXPre14Compat : DiagGroup<"c++98-c++11-compat">;
 151 def CXXPre14CompatPedantic : DiagGroup<"c++98-c++11-compat-pedantic",
 152                                        [CXXPre14Compat]>;
 153 def CXXPre1zCompat : DiagGroup<"c++98-c++11-c++14-compat">;
 154 def CXXPre1zCompatPedantic : DiagGroup<"c++98-c++11-c++14-compat-pedantic",
 155                                        [CXXPre1zCompat]>;
 156
 157 def CXX98CompatBindToTemporaryCopy :
 158   DiagGroup<"c++98-compat-bind-to-temporary-copy">;
 159 def CXX98CompatLocalTypeTemplateArgs :
 160   DiagGroup<"c++98-compat-local-type-template-args">;
 161 def CXX98CompatUnnamedTypeTemplateArgs :
 162   DiagGroup<"c++98-compat-unnamed-type-template-args">;
 163
 164 def CXX98Compat : DiagGroup<"c++98-compat",
 165                             [CXX98CompatLocalTypeTemplateArgs,
 166                              CXX98CompatUnnamedTypeTemplateArgs,
 167                              CXXPre14Compat,
 168                              CXXPre1zCompat]>;
 169 // Warnings for C++11 features which are Extensions in C++98 mode.
 170 def CXX98CompatPedantic : DiagGroup<"c++98-compat-pedantic",
 171                                     [CXX98Compat,
 172                                      CXX98CompatBindToTemporaryCopy,
 173                                      CXXPre14CompatPedantic,
 174                                      CXXPre1zCompatPedantic]>;
 175
 176 def CXX11Narrowing : DiagGroup<"c++11-narrowing">;
 177
 178 def CXX11WarnOverrideMethod : DiagGroup<"inconsistent-missing-override">;
 179
 180 // Original name of this warning in Clang
 181 def : DiagGroup<"c++0x-narrowing", [CXX11Narrowing]>;
 182
 183 // Name of this warning in GCC
 184 def : DiagGroup<"narrowing", [CXX11Narrowing]>;
 185
 186 def CXX11CompatReservedUserDefinedLiteral :
 187   DiagGroup<"c++11-compat-reserved-user-defined-literal">;
 188 def ReservedUserDefinedLiteral :
 189   DiagGroup<"reserved-user-defined-literal",
 190             [CXX11CompatReservedUserDefinedLiteral]>;
 191
 192 def CXX11Compat : DiagGroup<"c++11-compat",
 193                             [CXX11Narrowing,
 194                              CXX11CompatReservedUserDefinedLiteral,
 195                              CXX11CompatDeprecatedWritableStr,
 196                              CXXPre14Compat,
 197                              CXXPre1zCompat]>;
 198 def : DiagGroup<"c++0x-compat", [CXX11Compat]>;
 199 def CXX11CompatPedantic : DiagGroup<"c++11-compat-pedantic",
 200                                     [CXXPre14CompatPedantic,
 201                                      CXXPre1zCompatPedantic]>;
 202
 203 def CXX14Compat : DiagGroup<"c++14-compat", [CXXPre1zCompat]>;
 204 def CXX14CompatPedantic : DiagGroup<"c++14-compat-pedantic",
 205                                     [CXXPre1zCompatPedantic]>;
 206
 207 def CXX1zCompat : DiagGroup<"c++1z-compat", [DeprecatedRegister,
 208                                              DeprecatedIncrementBool]>;
 209
 210 def ExitTimeDestructors : DiagGroup<"exit-time-destructors">;
 211 def FlexibleArrayExtensions : DiagGroup<"flexible-array-extensions">;
 212 def FourByteMultiChar : DiagGroup<"four-char-constants">;
 213 def GlobalConstructors : DiagGroup<"global-constructors">;
 214 def BitwiseOpParentheses: DiagGroup<"bitwise-op-parentheses">;
 215 def LogicalOpParentheses: DiagGroup<"logical-op-parentheses">;
 216 def LogicalNotParentheses: DiagGroup<"logical-not-parentheses">;
 217 def ShiftOpParentheses: DiagGroup<"shift-op-parentheses">;
 218 def OverloadedShiftOpParentheses: DiagGroup<"overloaded-shift-op-parentheses">;
 219 def DanglingElse: DiagGroup<"dangling-else">;
 220 def DanglingField : DiagGroup<"dangling-field">;
 221 def DistributedObjectModifiers : DiagGroup<"distributed-object-modifiers">;
 222 def ExpansionToDefined : DiagGroup<"expansion-to-defined">;
 223 def FlagEnum : DiagGroup<"flag-enum">;
 224 def IncrementBool : DiagGroup<"increment-bool", [DeprecatedIncrementBool]>;
 225 def InfiniteRecursion : DiagGroup<"infinite-recursion">;
 226 def GNUImaginaryConstant : DiagGroup<"gnu-imaginary-constant">;
 227 def IgnoredQualifiers : DiagGroup<"ignored-qualifiers">;
 228 def : DiagGroup<"import">;
 229 def GNUIncludeNext : DiagGroup<"gnu-include-next">;
 230 def IncompatibleMSStruct : DiagGroup<"incompatible-ms-struct">;
 231 def IncompatiblePointerTypesDiscardsQualifiers
 232   : DiagGroup<"incompatible-pointer-types-discards-qualifiers">;
 233 def IncompatibleFunctionPointerTypes
 234   : DiagGroup<"incompatible-function-pointer-types">;
 235 def IncompatiblePointerTypes
 236   : DiagGroup<"incompatible-pointer-types",
 237     [IncompatiblePointerTypesDiscardsQualifiers,
 238      IncompatibleFunctionPointerTypes]>;
 239 def IncompleteUmbrella : DiagGroup<"incomplete-umbrella">;
 240 def NonModularIncludeInFrameworkModule
 241   : DiagGroup<"non-modular-include-in-framework-module">;
 242 def NonModularIncludeInModule : DiagGroup<"non-modular-include-in-module",
 243                                           [NonModularIncludeInFrameworkModule]>;
 244 def IncompleteModule : DiagGroup<"incomplete-module",
 245     [IncompleteUmbrella, NonModularIncludeInModule]>;
 246 def PrivateModule : DiagGroup<"private-module">;
 247
 248 def CXX11InlineNamespace : DiagGroup<"c++11-inline-namespace">;
 249 def InvalidNoreturn : DiagGroup<"invalid-noreturn">;
 250 def InvalidSourceEncoding : DiagGroup<"invalid-source-encoding">;
 251 def KNRPromotedParameter : DiagGroup<"knr-promoted-parameter">;
 252 def : DiagGroup<"init-self">;
 253 def : DiagGroup<"inline">;
 254 def : DiagGroup<"invalid-pch">;
 255 def GNULabelsAsValue : DiagGroup<"gnu-label-as-value">;
 256 def LiteralRange : DiagGroup<"literal-range">;
 257 def LocalTypeTemplateArgs : DiagGroup<"local-type-template-args",
 258                                       [CXX98CompatLocalTypeTemplateArgs]>;
 259 def RangeLoopAnalysis : DiagGroup<"range-loop-analysis">;
 260 def ForLoopAnalysis : DiagGroup<"for-loop-analysis">;
 261 def LoopAnalysis : DiagGroup<"loop-analysis", [ForLoopAnalysis,
 262                                                RangeLoopAnalysis]>;
 263 def MalformedWarningCheck : DiagGroup<"malformed-warning-check">;
 264 def Main : DiagGroup<"main">;
 265 def MainReturnType : DiagGroup<"main-return-type">;
 266 def MaxUnsignedZero : DiagGroup<"max-unsigned-zero">;
 267 def MissingBraces : DiagGroup<"missing-braces">;
 268 def MissingDeclarations: DiagGroup<"missing-declarations">;
 269 def : DiagGroup<"missing-format-attribute">;
 270 def : DiagGroup<"missing-include-dirs">;
 271 def MissingNoreturn : DiagGroup<"missing-noreturn">;
 272 def MultiChar : DiagGroup<"multichar">;
 273 def : DiagGroup<"nested-externs">;
 274 def CXX11LongLong : DiagGroup<"c++11-long-long">;
 275 def LongLong : DiagGroup<"long-long", [CXX11LongLong]>;
 276 def ImplicitlyUnsignedLiteral : DiagGroup<"implicitly-unsigned-literal">;
 277 def MethodSignatures : DiagGroup<"method-signatures">;
 278 def MismatchedParameterTypes : DiagGroup<"mismatched-parameter-types">;
 279 def MismatchedReturnTypes : DiagGroup<"mismatched-return-types">;
 280 def MismatchedTags : DiagGroup<"mismatched-tags">;
 281 def MissingFieldInitializers : DiagGroup<"missing-field-initializers">;
 282 def ModuleBuild : DiagGroup<"module-build">;
 283 def ModuleConflict : DiagGroup<"module-conflict">;
 284 def ModuleFileExtension : DiagGroup<"module-file-extension">;
 285 def NewlineEOF : DiagGroup<"newline-eof">;
 286 def Nullability : DiagGroup<"nullability">;
 287 def NullabilityDeclSpec : DiagGroup<"nullability-declspec">;
 288 def NullabilityInferredOnNestedType : DiagGroup<"nullability-inferred-on-nested-type">;
 289 def NullableToNonNullConversion : DiagGroup<"nullable-to-nonnull-conversion">;
 290 def NullabilityCompletenessOnArrays : DiagGroup<"nullability-completeness-on-arrays">;
 291 def NullabilityCompleteness : DiagGroup<"nullability-completeness",
 292                                         [NullabilityCompletenessOnArrays]>;
 293 def NullArithmetic : DiagGroup<"null-arithmetic">;
 294 def NullCharacter : DiagGroup<"null-character">;
 295 def NullDereference : DiagGroup<"null-dereference">;
 296 def InitializerOverrides : DiagGroup<"initializer-overrides">;
 297 def NonNull : DiagGroup<"nonnull">;
 298 def NonPODVarargs : DiagGroup<"non-pod-varargs">;
 299 def ClassVarargs : DiagGroup<"class-varargs", [NonPODVarargs]>;
 300 def : DiagGroup<"nonportable-cfstrings">;
 301 def NonVirtualDtor : DiagGroup<"non-virtual-dtor">;
 302 def : DiagGroup<"effc++", [NonVirtualDtor]>;
 303 def OveralignedType : DiagGroup<"over-aligned">;
 304 def OldStyleCast : DiagGroup<"old-style-cast">;
 305 def : DiagGroup<"old-style-definition">;
 306 def OutOfLineDeclaration : DiagGroup<"out-of-line-declaration">;
 307 def : DiagGroup<"overflow">;
 308 def ForwardClassReceiver : DiagGroup<"receiver-forward-class">;
 309 def MethodAccess : DiagGroup<"objc-method-access">;
 310 def ObjCReceiver : DiagGroup<"receiver-expr">;
 311 def OperatorNewReturnsNull : DiagGroup<"new-returns-null">;
 312 def OverlengthStrings : DiagGroup<"overlength-strings">;
 313 def OverloadedVirtual : DiagGroup<"overloaded-virtual">;
 314 def PrivateExtern : DiagGroup<"private-extern">;
 315 def SelTypeCast : DiagGroup<"cast-of-sel-type">;
 316 def FunctionDefInObjCContainer : DiagGroup<"function-def-in-objc-container">;
 317 def BadFunctionCast : DiagGroup<"bad-function-cast">;
 318 def ObjCPropertyImpl : DiagGroup<"objc-property-implementation">;
 319 def ObjCPropertyNoAttribute : DiagGroup<"objc-property-no-attribute">;
 320 def ObjCProtocolQualifiers : DiagGroup<"objc-protocol-qualifiers">;
 321 def ObjCMissingSuperCalls : DiagGroup<"objc-missing-super-calls">;
 322 def ObjCDesignatedInit : DiagGroup<"objc-designated-initializers">;
 323 def ObjCRetainBlockProperty : DiagGroup<"objc-noncopy-retain-block-property">;
 324 def ObjCReadonlyPropertyHasSetter : DiagGroup<"objc-readonly-with-setter-property">;
 325 def ObjCInvalidIBOutletProperty : DiagGroup<"invalid-iboutlet">;
 326 def ObjCRootClass : DiagGroup<"objc-root-class">;
 327 def ObjCPointerIntrospectPerformSelector : DiagGroup<"deprecated-objc-pointer-introspection-performSelector">;
 328 def ObjCPointerIntrospect : DiagGroup<"deprecated-objc-pointer-introspection", [ObjCPointerIntrospectPerformSelector]>;
 329 def ObjCMultipleMethodNames : DiagGroup<"objc-multiple-method-names">;
 330 def OpenCLUnsupportedRGBA: DiagGroup<"opencl-unsupported-rgba">;
 331 def DeprecatedObjCIsaUsage : DiagGroup<"deprecated-objc-isa-usage">;
 332 def ExplicitInitializeCall : DiagGroup<"explicit-initialize-call">;
 333 def Packed : DiagGroup<"packed">;
 334 def Padded : DiagGroup<"padded">;
 335 def PessimizingMove : DiagGroup<"pessimizing-move">;
 336 def PointerArith : DiagGroup<"pointer-arith">;
 337 def PoundWarning : DiagGroup<"#warnings">;
 338 def PoundPragmaMessage : DiagGroup<"#pragma-messages">,
 339                          DiagCategory<"#pragma message Directive">;
 340 def : DiagGroup<"pointer-to-int-cast">;
 341 def : DiagGroup<"redundant-decls">;
 342 def RedeclaredClassMember : DiagGroup<"redeclared-class-member">;
 343 def GNURedeclaredEnum : DiagGroup<"gnu-redeclared-enum">;
 344 def RedundantMove : DiagGroup<"redundant-move">;
 345 def Register : DiagGroup<"register", [DeprecatedRegister]>;
 346 def ReturnStackAddress : DiagGroup<"return-stack-address">;
 347 def ReturnTypeCLinkage : DiagGroup<"return-type-c-linkage">;
 348 def ReturnType : DiagGroup<"return-type", [ReturnTypeCLinkage]>;
 349 def BindToTemporaryCopy : DiagGroup<"bind-to-temporary-copy",
 350                                     [CXX98CompatBindToTemporaryCopy]>;
 351 def SelfAssignmentField : DiagGroup<"self-assign-field">;
 352 def SelfAssignment : DiagGroup<"self-assign", [SelfAssignmentField]>;
 353 def SelfMove : DiagGroup<"self-move">;
 354 def SemiBeforeMethodBody : DiagGroup<"semicolon-before-method-body">;
 355 def Sentinel : DiagGroup<"sentinel">;
 356 def MissingMethodReturnType : DiagGroup<"missing-method-return-type">;
 357
 358 def ShadowFieldInConstructorModified : DiagGroup<"shadow-field-in-constructor-modified">;
 359 def ShadowFieldInConstructor : DiagGroup<"shadow-field-in-constructor",
 360                                          [ShadowFieldInConstructorModified]>;
 361 def ShadowIvar : DiagGroup<"shadow-ivar">;
 362 def ShadowUncapturedLocal : DiagGroup<"shadow-uncaptured-local">;
 363
 364 // -Wshadow-all is a catch-all for all shadowing. -Wshadow is just the
 365 // shadowing that we think is unsafe.
 366 def Shadow : DiagGroup<"shadow", [ShadowFieldInConstructorModified,
 367                                   ShadowIvar]>;
 368 def ShadowAll : DiagGroup<"shadow-all", [Shadow, ShadowFieldInConstructor,
 369                                          ShadowUncapturedLocal]>;
 370
 371 def Shorten64To32 : DiagGroup<"shorten-64-to-32">;
 372 def : DiagGroup<"sign-promo">;
 373 def SignCompare : DiagGroup<"sign-compare">;
 374 def : DiagGroup<"stack-protector">;
 375 def : DiagGroup<"switch-default">;
 376 def : DiagGroup<"synth">;
 377 def SizeofArrayArgument : DiagGroup<"sizeof-array-argument">;
 378 def SizeofArrayDecay : DiagGroup<"sizeof-array-decay">;
 379 def SizeofPointerMemaccess : DiagGroup<"sizeof-pointer-memaccess">;
 380 def StaticInInline : DiagGroup<"static-in-inline">;
 381 def StaticLocalInInline : DiagGroup<"static-local-in-inline">;
 382 def GNUStaticFloatInit : DiagGroup<"gnu-static-float-init">;
 383 def StaticFloatInit : DiagGroup<"static-float-init", [GNUStaticFloatInit]>;
 384 def GNUStatementExpression : DiagGroup<"gnu-statement-expression">;
 385 def StringCompare : DiagGroup<"string-compare">;
 386 def StringPlusInt : DiagGroup<"string-plus-int">;
 387 def StringPlusChar : DiagGroup<"string-plus-char">;
 388 def StrncatSize : DiagGroup<"strncat-size">;
 389 def TautologicalOutOfRangeCompare : DiagGroup<"tautological-constant-out-of-range-compare">;
 390 def TautologicalPointerCompare : DiagGroup<"tautological-pointer-compare">;
 391 def TautologicalOverlapCompare : DiagGroup<"tautological-overlap-compare">;
 392 def TautologicalUndefinedCompare : DiagGroup<"tautological-undefined-compare">;
 393 def TautologicalCompare : DiagGroup<"tautological-compare",
 394                                     [TautologicalOutOfRangeCompare,
 395                                      TautologicalPointerCompare,
 396                                      TautologicalOverlapCompare,
 397                                      TautologicalUndefinedCompare]>;
 398 def HeaderHygiene : DiagGroup<"header-hygiene">;
 399 def DuplicateDeclSpecifier : DiagGroup<"duplicate-decl-specifier">;
 400 def CompareDistinctPointerType : DiagGroup<"compare-distinct-pointer-types">;
 401 def GNUUnionCast : DiagGroup<"gnu-union-cast">;
 402 def GNUVariableSizedTypeNotAtEnd : DiagGroup<"gnu-variable-sized-type-not-at-end">;
 403 def Varargs : DiagGroup<"varargs">;
 404
 405 def Unsequenced : DiagGroup<"unsequenced">;
 406 // GCC name for -Wunsequenced
 407 def : DiagGroup<"sequence-point", [Unsequenced]>;
 408
 409 // Preprocessor warnings.
 410 def AmbiguousMacro : DiagGroup<"ambiguous-macro">;
 411 def KeywordAsMacro : DiagGroup<"keyword-macro">;
 412 def ReservedIdAsMacro : DiagGroup<"reserved-id-macro">;
 413
 414 // Just silence warnings about -Wstrict-aliasing for now.
 415 def : DiagGroup<"strict-aliasing=0">;
 416 def : DiagGroup<"strict-aliasing=1">;
 417 def : DiagGroup<"strict-aliasing=2">;
 418 def : DiagGroup<"strict-aliasing">;
 419
 420 // Just silence warnings about -Wstrict-overflow for now.
 421 def : DiagGroup<"strict-overflow=0">;
 422 def : DiagGroup<"strict-overflow=1">;
 423 def : DiagGroup<"strict-overflow=2">;
 424 def : DiagGroup<"strict-overflow=3">;
 425 def : DiagGroup<"strict-overflow=4">;
 426 def : DiagGroup<"strict-overflow=5">;
 427 def : DiagGroup<"strict-overflow">;
 428
 429 def InvalidOffsetof : DiagGroup<"invalid-offsetof">;
 430 def : DiagGroup<"strict-prototypes">;
 431 def StrictSelector : DiagGroup<"strict-selector-match">;
 432 def MethodDuplicate : DiagGroup<"duplicate-method-match">;
 433 def ObjCCStringFormat : DiagGroup<"cstring-format-directive">;
 434 def CoveredSwitchDefault : DiagGroup<"covered-switch-default">;
 435 def SwitchBool     : DiagGroup<"switch-bool">;
 436 def SwitchEnum     : DiagGroup<"switch-enum">;
 437 def Switch         : DiagGroup<"switch">;
 438 def ImplicitFallthroughPerFunction :
 439   DiagGroup<"implicit-fallthrough-per-function">;
 440 def ImplicitFallthrough  : DiagGroup<"implicit-fallthrough",
 441                                      [ImplicitFallthroughPerFunction]>;
 442 def InvalidPPToken : DiagGroup<"invalid-pp-token">;
 443 def Trigraphs      : DiagGroup<"trigraphs">;
 444
 445 def : DiagGroup<"type-limits">;
 446 def UndefinedReinterpretCast : DiagGroup<"undefined-reinterpret-cast">;
 447 def ReinterpretBaseClass : DiagGroup<"reinterpret-base-class">;
 448 def Unicode  : DiagGroup<"unicode">;
 449 def UninitializedMaybe : DiagGroup<"conditional-uninitialized">;
 450 def UninitializedSometimes : DiagGroup<"sometimes-uninitialized">;
 451 def UninitializedStaticSelfInit : DiagGroup<"static-self-init">;
 452 def Uninitialized  : DiagGroup<"uninitialized", [UninitializedSometimes,
 453                                                  UninitializedStaticSelfInit]>;
 454 def IgnoredPragmaIntrinsic : DiagGroup<"ignored-pragma-intrinsic">;
 455 def UnknownPragmas : DiagGroup<"unknown-pragmas">;
 456 def IgnoredPragmas : DiagGroup<"ignored-pragmas", [IgnoredPragmaIntrinsic]>;
 457 def Pragmas : DiagGroup<"pragmas", [UnknownPragmas, IgnoredPragmas]>;
 458 def UnknownWarningOption : DiagGroup<"unknown-warning-option">;
 459 def NSobjectAttribute : DiagGroup<"NSObject-attribute">;
 460 def IndependentClassAttribute : DiagGroup<"IndependentClass-attribute">;
 461 def UnknownAttributes : DiagGroup<"unknown-attributes">;
 462 def IgnoredAttributes : DiagGroup<"ignored-attributes">;
 463 def Attributes : DiagGroup<"attributes", [UnknownAttributes,
 464                                           IgnoredAttributes]>;
 465 def UnknownSanitizers : DiagGroup<"unknown-sanitizers">;
 466 def UnnamedTypeTemplateArgs : DiagGroup<"unnamed-type-template-args",
 467                                         [CXX98CompatUnnamedTypeTemplateArgs]>;
 468 def UnsupportedFriend : DiagGroup<"unsupported-friend">;
 469 def UnusedArgument : DiagGroup<"unused-argument">;
 470 def UnusedCommandLineArgument : DiagGroup<"unused-command-line-argument">;
 471 def IgnoredOptimizationArgument : DiagGroup<"ignored-optimization-argument">;
 472 def InvalidCommandLineArgument : DiagGroup<"invalid-command-line-argument",
 473                                            [IgnoredOptimizationArgument]>;
 474 def UnusedComparison : DiagGroup<"unused-comparison">;
 475 def UnusedExceptionParameter : DiagGroup<"unused-exception-parameter">;
 476 def UnneededInternalDecl : DiagGroup<"unneeded-internal-declaration">;
 477 def UnneededMemberFunction : DiagGroup<"unneeded-member-function">;
 478 def UnusedPrivateField : DiagGroup<"unused-private-field">;
 479 def UnusedFunction : DiagGroup<"unused-function", [UnneededInternalDecl]>;
 480 def UnusedMemberFunction : DiagGroup<"unused-member-function",
 481                                      [UnneededMemberFunction]>;
 482 def UnusedLabel : DiagGroup<"unused-label">;
 483 def UnusedParameter : DiagGroup<"unused-parameter">;
 484 def UnusedResult : DiagGroup<"unused-result">;
 485 def PotentiallyEvaluatedExpression : DiagGroup<"potentially-evaluated-expression">;
 486 def UnevaluatedExpression : DiagGroup<"unevaluated-expression",
 487                                       [PotentiallyEvaluatedExpression]>;
 488 def UnusedValue : DiagGroup<"unused-value", [UnusedComparison, UnusedResult,
 489                                              UnevaluatedExpression]>;
 490 def UnusedConstVariable : DiagGroup<"unused-const-variable">;
 491 def UnusedVariable : DiagGroup<"unused-variable",
 492                                [UnusedConstVariable]>;
 493 def UnusedLocalTypedef : DiagGroup<"unused-local-typedef">;
 494 def UnusedPropertyIvar :  DiagGroup<"unused-property-ivar">;
 495 def UnusedGetterReturnValue : DiagGroup<"unused-getter-return-value">;
 496 def UsedButMarkedUnused : DiagGroup<"used-but-marked-unused">;
 497 def UserDefinedLiterals : DiagGroup<"user-defined-literals">;
 498 def Reorder : DiagGroup<"reorder">;
 499 def UndeclaredSelector : DiagGroup<"undeclared-selector">;
 500 def ImplicitAtomic : DiagGroup<"implicit-atomic-properties">;
 501 def CustomAtomic : DiagGroup<"custom-atomic-properties">;
 502 def AtomicProperties : DiagGroup<"atomic-properties",
 503                                  [ImplicitAtomic, CustomAtomic]>;
 504 def ARCUnsafeRetainedAssign : DiagGroup<"arc-unsafe-retained-assign">;
 505 def ARCRetainCycles : DiagGroup<"arc-retain-cycles">;
 506 def ARCNonPodMemAccess : DiagGroup<"arc-non-pod-memaccess">;
 507 def AutomaticReferenceCounting : DiagGroup<"arc",
 508                                            [ARCUnsafeRetainedAssign,
 509                                             ARCRetainCycles,
 510                                             ARCNonPodMemAccess]>;
 511 def ARCRepeatedUseOfWeakMaybe : DiagGroup<"arc-maybe-repeated-use-of-weak">;
 512 def ARCRepeatedUseOfWeak : DiagGroup<"arc-repeated-use-of-weak",
 513                                      [ARCRepeatedUseOfWeakMaybe]>;
 514 def BlockCaptureAutoReleasing : DiagGroup<"block-capture-autoreleasing">;
 515 def ObjCBridge : DiagGroup<"bridge-cast">;
 516
 517 def DeallocInCategory:DiagGroup<"dealloc-in-category">;
 518 def SelectorTypeMismatch : DiagGroup<"selector-type-mismatch">;
 519 def Selector : DiagGroup<"selector", [SelectorTypeMismatch]>;
 520 def Protocol : DiagGroup<"protocol">;
 521 def AtProtocol : DiagGroup<"at-protocol">;
 522 def PropertyAccessDotSyntax: DiagGroup<"property-access-dot-syntax">;
 523 def PropertyAttr : DiagGroup<"property-attribute-mismatch">;
 524 def SuperSubClassMismatch : DiagGroup<"super-class-method-mismatch">;
 525 def OverridingMethodMismatch : DiagGroup<"overriding-method-mismatch">;
 526 def VariadicMacros : DiagGroup<"variadic-macros">;
 527 def VectorConversion : DiagGroup<"vector-conversion">;      // clang specific
 528 def VexingParse : DiagGroup<"vexing-parse">;
 529 def VLA : DiagGroup<"vla">;
 530 def VLAExtension : DiagGroup<"vla-extension">;
 531 def VolatileRegisterVar : DiagGroup<"volatile-register-var">;
 532 def Visibility : DiagGroup<"visibility">;
 533 def ZeroLengthArray : DiagGroup<"zero-length-array">;
 534 def GNUZeroLineDirective : DiagGroup<"gnu-zero-line-directive">;
 535 def GNUZeroVariadicMacroArguments : DiagGroup<"gnu-zero-variadic-macro-arguments">;
 536 def Fallback : DiagGroup<"fallback">;
 537
 538 // This covers both the deprecated case (in C++98)
 539 // and the extension case (in C++11 onwards).
 540 def WritableStrings : DiagGroup<"writable-strings", [DeprecatedWritableStr]>;
 541
 542 // GCC calls -Wdeprecated-writable-strings -Wwrite-strings.
 543 //
 544 // Bizarrely, this warning flag enables -fconst-strings in C. This is
 545 // GCC-compatible, but really weird.
 546 //
 547 // FIXME: Should this affect C++11 (where this is an error,
 548 //        not just deprecated) or not?
 549 def GCCWriteStrings : DiagGroup<"write-strings" , [WritableStrings]>;
 550
 551 def CharSubscript : DiagGroup<"char-subscripts">;
 552 def LargeByValueCopy : DiagGroup<"large-by-value-copy">;
 553 def DuplicateArgDecl : DiagGroup<"duplicate-method-arg">;
 554 def SignedEnumBitfield : DiagGroup<"signed-enum-bitfield">;
 555
 556 // Unreachable code warning groups.
 557 //
 558 //  The goal is make -Wunreachable-code on by default, in -Wall, or at
 559 //  least actively used, with more noisy versions of the warning covered
 560 //  under separate flags.
 561 //
 562 def UnreachableCodeLoopIncrement : DiagGroup<"unreachable-code-loop-increment">;
 563 def UnreachableCode : DiagGroup<"unreachable-code",
 564                                 [UnreachableCodeLoopIncrement]>;
 565 def UnreachableCodeBreak : DiagGroup<"unreachable-code-break">;
 566 def UnreachableCodeReturn : DiagGroup<"unreachable-code-return">;
 567 def UnreachableCodeAggressive : DiagGroup<"unreachable-code-aggressive",
 568                                     [UnreachableCode,
 569                                      UnreachableCodeBreak,
 570                                      UnreachableCodeReturn]>;
 571
 572 // Aggregation warning settings.
 573
 574 // Populate -Waddress with warnings from other groups.
 575 def : DiagGroup<"address", [PointerBoolConversion,
 576                             StringCompare,
 577                             TautologicalPointerCompare]>;
 578
 579 // -Widiomatic-parentheses contains warnings about 'idiomatic'
 580 // missing parentheses;  it is off by default.  We do not include it
 581 // in -Wparentheses because most users who use -Wparentheses explicitly
 582 // do not want these warnings.
 583 def ParenthesesOnEquality : DiagGroup<"parentheses-equality">;
 584 def Parentheses : DiagGroup<"parentheses",
 585                             [LogicalOpParentheses,
 586                              LogicalNotParentheses,
 587                              BitwiseOpParentheses,
 588                              ShiftOpParentheses,
 589                              OverloadedShiftOpParentheses,
 590                              ParenthesesOnEquality,
 591                              DanglingElse]>;
 592
 593 // -Wconversion has its own warnings, but we split a few out for
 594 // legacy reasons:
 595 //   - some people want just 64-to-32 warnings
 596 //   - conversion warnings with constant sources are on by default
 597 //   - conversion warnings for literals are on by default
 598 //   - bool-to-pointer conversion warnings are on by default
 599 //   - __null-to-integer conversion warnings are on by default
 600 def Conversion : DiagGroup<"conversion",
 601                            [BoolConversion,
 602                             ConstantConversion,
 603                             EnumConversion,
 604                             FloatConversion,
 605                             Shorten64To32,
 606                             IntConversion,
 607                             LiteralConversion,
 608                             NonLiteralNullConversion, // (1-1)->pointer (etc)
 609                             NullConversion, // NULL->non-pointer
 610                             ObjCLiteralConversion,
 611                             SignConversion,
 612                             StringConversion]>,
 613                  DiagCategory<"Value Conversion Issue">;
 614
 615 def Unused : DiagGroup<"unused",
 616                        [UnusedArgument, UnusedFunction, UnusedLabel,
 617                         // UnusedParameter, (matches GCC's behavior)
 618                         // UnusedMemberFunction, (clean-up llvm before enabling)
 619                         UnusedPrivateField, UnusedLocalTypedef,
 620                         UnusedValue, UnusedVariable, UnusedPropertyIvar]>,
 621                         DiagCategory<"Unused Entity Issue">;
 622
 623 // Format settings.
 624 def FormatInvalidSpecifier : DiagGroup<"format-invalid-specifier">;
 625 def FormatSecurity : DiagGroup<"format-security">;
 626 def FormatNonStandard : DiagGroup<"format-non-iso">;
 627 def FormatY2K : DiagGroup<"format-y2k">;
 628 def FormatPedantic : DiagGroup<"format-pedantic">;
 629 def Format : DiagGroup<"format",
 630                        [FormatExtraArgs, FormatZeroLength, NonNull,
 631                         FormatSecurity, FormatY2K, FormatInvalidSpecifier]>,
 632              DiagCategory<"Format String Issue">;
 633 def FormatNonLiteral : DiagGroup<"format-nonliteral">;
 634 def Format2 : DiagGroup<"format=2",
 635                         [FormatNonLiteral, FormatSecurity, FormatY2K]>;
 636
 637 def TypeSafety : DiagGroup<"type-safety">;
 638
 639 def IncompatibleExceptionSpec : DiagGroup<"incompatible-exception-spec">;
 640
 641 def IntToVoidPointerCast : DiagGroup<"int-to-void-pointer-cast">;
 642 def IntToPointerCast : DiagGroup<"int-to-pointer-cast",
 643                                  [IntToVoidPointerCast]>;
 644
 645 def Move : DiagGroup<"move", [PessimizingMove, RedundantMove, SelfMove]>;
 646
 647 def Extra : DiagGroup<"extra", [
 648     MissingFieldInitializers,
 649     IgnoredQualifiers,
 650     InitializerOverrides,
 651     SemiBeforeMethodBody,
 652     MissingMethodReturnType,
 653     SignCompare,
 654     UnusedParameter
 655   ]>;
 656
 657 def Most : DiagGroup<"most", [
 658     CharSubscript,
 659     Comment,
 660     DeleteNonVirtualDtor,
 661     ForLoopAnalysis,
 662     Format,
 663     Implicit,
 664     InfiniteRecursion,
 665     MismatchedTags,
 666     MissingBraces,
 667     Move,
 668     MultiChar,
 669     Reorder,
 670     ReturnType,
 671     SelfAssignment,
 672     SelfMove,
 673     SizeofArrayArgument,
 674     SizeofArrayDecay,
 675     StringPlusInt,
 676     Trigraphs,
 677     Uninitialized,
 678     UnknownPragmas,
 679     Unused,
 680     VolatileRegisterVar,
 681     ObjCMissingSuperCalls,
 682     ObjCDesignatedInit,
 683     OverloadedVirtual,
 684     PrivateExtern,
 685     SelTypeCast,
 686     ExternCCompat
 687  ]>;
 688
 689 // Thread Safety warnings
 690 def ThreadSafetyAttributes : DiagGroup<"thread-safety-attributes">;
 691 def ThreadSafetyAnalysis   : DiagGroup<"thread-safety-analysis">;
 692 def ThreadSafetyPrecise    : DiagGroup<"thread-safety-precise">;
 693 def ThreadSafetyReference  : DiagGroup<"thread-safety-reference">;
 694 def ThreadSafetyNegative   : DiagGroup<"thread-safety-negative">;
 695 def ThreadSafety : DiagGroup<"thread-safety",
 696                              [ThreadSafetyAttributes,
 697                               ThreadSafetyAnalysis,
 698                               ThreadSafetyPrecise,
 699                               ThreadSafetyReference]>;
 700 def ThreadSafetyVerbose : DiagGroup<"thread-safety-verbose">;
 701 def ThreadSafetyBeta : DiagGroup<"thread-safety-beta">;
 702
 703 // Uniqueness Analysis warnings
 704 def Consumed       : DiagGroup<"consumed">;
 705
 706 // Note that putting warnings in -Wall will not disable them by default. If a
 707 // warning should be active _only_ when -Wall is passed in, mark it as
 708 // DefaultIgnore in addition to putting it here.
 709 def All : DiagGroup<"all", [Most, Parentheses, Switch, SwitchBool]>;
 710
 711 // Warnings that should be in clang-cl /w4.
 712 def : DiagGroup<"CL4", [All, Extra]>;
 713
 714 // Warnings enabled by -pedantic.  This is magically filled in by TableGen.
 715 def Pedantic : DiagGroup<"pedantic">;
 716
 717 // Aliases.
 718 def : DiagGroup<"", [Extra]>;                   // -W = -Wextra
 719 def : DiagGroup<"endif-labels", [ExtraTokens]>; // -Wendif-labels=-Wextra-tokens
 720 def : DiagGroup<"comments", [Comment]>;         // -Wcomments = -Wcomment
 721 def : DiagGroup<"conversion-null",
 722                 [NullConversion]>; // -Wconversion-null = -Wnull-conversion
 723 def : DiagGroup<"bool-conversions",
 724                 [BoolConversion]>; // -Wbool-conversions  = -Wbool-conversion
 725 def : DiagGroup<"int-conversions",
 726                 [IntConversion]>; // -Wint-conversions = -Wint-conversion
 727 def : DiagGroup<"vector-conversions",
 728                 [VectorConversion]>; // -Wvector-conversions = -Wvector-conversion
 729 def : DiagGroup<"unused-local-typedefs", [UnusedLocalTypedef]>;
 730                 // -Wunused-local-typedefs = -Wunused-local-typedef
 731
 732 // A warning group for warnings that we want to have on by default in clang,
 733 // but which aren't on by default in GCC.
 734 def NonGCC : DiagGroup<"non-gcc",
 735     [SignCompare, Conversion, LiteralRange]>;
 736
 737 // A warning group for warnings about using C++11 features as extensions in
 738 // earlier C++ versions.
 739 def CXX11 : DiagGroup<"c++11-extensions", [CXX11ExtraSemi, CXX11InlineNamespace,
 740                                            CXX11LongLong]>;
 741
 742 // A warning group for warnings about using C++14 features as extensions in
 743 // earlier C++ versions.
 744 def CXX14 : DiagGroup<"c++14-extensions", [CXX14BinaryLiteral]>;
 745
 746 // A warning group for warnings about using C++1z features as extensions in
 747 // earlier C++ versions.
 748 def CXX1z : DiagGroup<"c++1z-extensions">;
 749
 750 def : DiagGroup<"c++0x-extensions", [CXX11]>;
 751 def : DiagGroup<"c++1y-extensions", [CXX14]>;
 752
 753 def DelegatingCtorCycles :
 754   DiagGroup<"delegating-ctor-cycles">;
 755
 756 // A warning group for warnings about using C11 features as extensions.
 757 def C11 : DiagGroup<"c11-extensions">;
 758
 759 // A warning group for warnings about using C99 features as extensions.
 760 def C99 : DiagGroup<"c99-extensions">;
 761
 762 // A warning group for warnings about GCC extensions.
 763 def GNU : DiagGroup<"gnu", [GNUAlignofExpression, GNUAnonymousStruct,
 764                             GNUAutoType,
 765                             GNUBinaryLiteral, GNUCaseRange,
 766                             GNUComplexInteger, GNUCompoundLiteralInitializer,
 767                             GNUConditionalOmittedOperand, GNUDesignator,
 768                             GNUEmptyInitializer, GNUEmptyStruct,
 769                             VLAExtension, GNUFlexibleArrayInitializer,
 770                             GNUFlexibleArrayUnionMember, GNUFoldingConstant,
 771                             GNUImaginaryConstant, GNUIncludeNext,
 772                             GNULabelsAsValue,
 773                             RedeclaredClassMember, GNURedeclaredEnum,
 774                             GNUStatementExpression, GNUStaticFloatInit,
 775                             GNUStringLiteralOperatorTemplate,
 776                             GNUUnionCast, GNUVariableSizedTypeNotAtEnd,
 777                             ZeroLengthArray, GNUZeroLineDirective,
 778                             GNUZeroVariadicMacroArguments]>;
 779 // A warning group for warnings about code that clang accepts but gcc doesn't.
 780 def GccCompat : DiagGroup<"gcc-compat">;
 781
 782 // Warnings for Microsoft extensions.
 783 def MicrosoftCharize : DiagGroup<"microsoft-charize">;
 784 def MicrosoftInclude : DiagGroup<"microsoft-include">;
 785 def MicrosoftCppMacro : DiagGroup<"microsoft-cpp-macro">;
 786 def MicrosoftFixedEnum : DiagGroup<"microsoft-fixed-enum">;
 787 def MicrosoftSealed : DiagGroup<"microsoft-sealed">;
 788 def MicrosoftUnqualifiedFriend : DiagGroup<"microsoft-unqualified-friend">;
 789 def MicrosoftExceptionSpec : DiagGroup<"microsoft-exception-spec">;
 790 def MicrosoftUsingDecl : DiagGroup<"microsoft-using-decl">;
 791 def MicrosoftMutableReference : DiagGroup<"microsoft-mutable-reference">;
 792 def MicrosoftPureDefinition : DiagGroup<"microsoft-pure-definition">;
 793 def MicrosoftUnionMemberReference : DiagGroup<
 794     "microsoft-union-member-reference">;
 795 def MicrosoftExplicitConstructorCall : DiagGroup<
 796     "microsoft-explicit-constructor-call">;
 797 def MicrosoftEnumValue : DiagGroup<"microsoft-enum-value">;
 798 def MicrosoftDefaultArgRedefinition :
 799     DiagGroup<"microsoft-default-arg-redefinition">;
 800 def MicrosoftTemplate : DiagGroup<"microsoft-template">;
 801 def MicrosoftInconsistentDllImport : DiagGroup<"inconsistent-dllimport">;
 802 def MicrosoftRedeclareStatic : DiagGroup<"microsoft-redeclare-static">;
 803 def MicrosoftEnumForwardReference :
 804     DiagGroup<"microsoft-enum-forward-reference">;
 805 def MicrosoftGoto : DiagGroup<"microsoft-goto">;
 806 def MicrosoftFlexibleArray : DiagGroup<"microsoft-flexible-array">;
 807 def MicrosoftExtraQualification : DiagGroup<"microsoft-extra-qualification">;
 808 def MicrosoftCast : DiagGroup<"microsoft-cast">;
 809 def MicrosoftConstInit : DiagGroup<"microsoft-const-init">;
 810 def MicrosoftVoidPseudoDtor : DiagGroup<"microsoft-void-pseudo-dtor">;
 811 def MicrosoftAnonTag : DiagGroup<"microsoft-anon-tag">;
 812 def MicrosoftCommentPaste : DiagGroup<"microsoft-comment-paste">;
 813 def MicrosoftEndOfFile : DiagGroup<"microsoft-end-of-file">;
 814 // Aliases.
 815 def : DiagGroup<"msvc-include", [MicrosoftInclude]>;
 816                 // -Wmsvc-include = -Wmicrosoft-include
 817
 818 // Warnings group for warnings about Microsoft extensions.
 819 def Microsoft : DiagGroup<"microsoft",
 820     [MicrosoftCharize, MicrosoftInclude, MicrosoftCppMacro, MicrosoftFixedEnum,
 821      MicrosoftSealed, MicrosoftUnqualifiedFriend, MicrosoftExceptionSpec,
 822      MicrosoftUsingDecl, MicrosoftMutableReference, MicrosoftPureDefinition,
 823      MicrosoftUnionMemberReference, MicrosoftExplicitConstructorCall,
 824      MicrosoftEnumValue, MicrosoftDefaultArgRedefinition, MicrosoftTemplate,
 825      MicrosoftRedeclareStatic, MicrosoftEnumForwardReference, MicrosoftGoto,
 826      MicrosoftFlexibleArray, MicrosoftExtraQualification, MicrosoftCast,
 827      MicrosoftConstInit, MicrosoftVoidPseudoDtor, MicrosoftAnonTag,
 828      MicrosoftCommentPaste, MicrosoftEndOfFile,
 829      MicrosoftInconsistentDllImport]>;
 830
 831 def ClangClPch : DiagGroup<"clang-cl-pch">;
 832
 833 def ObjCNonUnifiedException : DiagGroup<"objc-nonunified-exceptions">;
 834
 835 def ObjCProtocolMethodImpl : DiagGroup<"objc-protocol-method-implementation">;
 836
 837 def ObjCNoPropertyAutoSynthesis : DiagGroup<"objc-property-synthesis">;
 838
 839 // ObjC API warning groups.
 840 def ObjCRedundantLiteralUse : DiagGroup<"objc-redundant-literal-use">;
 841 def ObjCRedundantAPIUse : DiagGroup<"objc-redundant-api-use", [
 842     ObjCRedundantLiteralUse
 843   ]>;
 844
 845 def ObjCCocoaAPI : DiagGroup<"objc-cocoa-api", [
 846     ObjCRedundantAPIUse
 847   ]>;
 848
 849 def ObjCStringComparison : DiagGroup<"objc-string-compare">;
 850 def ObjCStringConcatenation : DiagGroup<"objc-string-concatenation">;
 851 def ObjCLiteralComparison : DiagGroup<"objc-literal-compare", [
 852     ObjCStringComparison
 853   ]>;
 854
 855 // Inline ASM warnings.
 856 def ASMOperandWidths : DiagGroup<"asm-operand-widths">;
 857 def ASMIgnoredQualifier : DiagGroup<"asm-ignored-qualifier">;
 858 def ASM : DiagGroup<"asm", [
 859     ASMOperandWidths, ASMIgnoredQualifier
 860   ]>;
 861
 862 // OpenMP warnings.
 863 def SourceUsesOpenMP : DiagGroup<"source-uses-openmp">;
 864 def OpenMPClauses : DiagGroup<"openmp-clauses">;
 865 def OpenMPLoopForm : DiagGroup<"openmp-loop-form">;
 866 def OpenMPTarget : DiagGroup<"openmp-target">;
 867
 868 // Backend warnings.
 869 def BackendInlineAsm : DiagGroup<"inline-asm">;
 870 def BackendFrameLargerThanEQ : DiagGroup<"frame-larger-than=">;
 871 def BackendPlugin : DiagGroup<"backend-plugin">;
 872 def RemarkBackendPlugin : DiagGroup<"remark-backend-plugin">;
 873 def BackendOptimizationRemark : DiagGroup<"pass">;
 874 def BackendOptimizationRemarkMissed : DiagGroup<"pass-missed">;
 875 def BackendOptimizationRemarkAnalysis : DiagGroup<"pass-analysis">;
 876 def BackendOptimizationFailure : DiagGroup<"pass-failed">;
 877
 878 // Instrumentation based profiling warnings.
 879 def ProfileInstrOutOfDate : DiagGroup<"profile-instr-out-of-date">;
 880 def ProfileInstrUnprofiled : DiagGroup<"profile-instr-unprofiled">;
 881
 882 // AddressSanitizer frontent instrumentation remarks.
 883 def SanitizeAddressRemarks : DiagGroup<"sanitize-address">;
 884
 885 // Issues with serialized diagnostics.
 886 def SerializedDiagnostics : DiagGroup<"serialized-diagnostics">;
 887
 888 // A warning group for warnings about code that clang accepts when
 889 // compiling CUDA C/C++ but which is not compatible with the CUDA spec.
 890 def CudaCompat : DiagGroup<"cuda-compat">;
 891
 892 // A warning group for things that will change semantics in the future.
 893 def FutureCompat : DiagGroup<"future-compat">;
 894
 895 def InvalidOrNonExistentDirectory : DiagGroup<"invalid-or-nonexistent-directory">;
 896
 897 def OptionIgnored : DiagGroup<"option-ignored">;
 898
 899 def UnknownArgument : DiagGroup<"unknown-argument">;
 900
 901 // A warning group for warnings about code that clang accepts when
 902 // compiling OpenCL C/C++ but which is not compatible with the SPIR spec.
 903 def SpirCompat : DiagGroup<"spir-compat">;