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

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