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