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