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