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