| //==--- DiagnosticSemaKinds.td - libsema diagnostics ----------------------===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| //===----------------------------------------------------------------------===// |
| // Semantic Analysis |
| //===----------------------------------------------------------------------===// |
| |
| let Component = "Sema" in { |
| let CategoryName = "Semantic Issue" in { |
| |
| def note_previous_decl : Note<"%0 declared here">; |
| def note_entity_declared_at : Note<"%0 declared here">; |
| def note_callee_decl : Note<"%0 declared here">; |
| def note_defined_here : Note<"%0 defined here">; |
| |
| // For loop analysis |
| def warn_variables_not_in_loop_body : Warning< |
| "variable%select{s| %1|s %1 and %2|s %1, %2, and %3|s %1, %2, %3, and %4}0 " |
| "used in loop condition not modified in loop body">, |
| InGroup<ForLoopAnalysis>, DefaultIgnore; |
| def warn_redundant_loop_iteration : Warning< |
| "variable %0 is %select{decremented|incremented}1 both in the loop header " |
| "and in the loop body">, |
| InGroup<ForLoopAnalysis>, DefaultIgnore; |
| def note_loop_iteration_here : Note<"%select{decremented|incremented}0 here">; |
| |
| def warn_duplicate_enum_values : Warning< |
| "element %0 has been implicitly assigned %1 which another element has " |
| "been assigned">, InGroup<DiagGroup<"duplicate-enum">>, DefaultIgnore; |
| def note_duplicate_element : Note<"element %0 also has value %1">; |
| |
| // Absolute value functions |
| def warn_unsigned_abs : Warning< |
| "taking the absolute value of unsigned type %0 has no effect">, |
| InGroup<AbsoluteValue>; |
| def note_remove_abs : Note< |
| "remove the call to '%0' since unsigned values cannot be negative">; |
| def warn_abs_too_small : Warning< |
| "absolute value function %0 given an argument of type %1 but has parameter " |
| "of type %2 which may cause truncation of value">, InGroup<AbsoluteValue>; |
| def warn_wrong_absolute_value_type : Warning< |
| "using %select{integer|floating point|complex}1 absolute value function %0 " |
| "when argument is of %select{integer|floating point|complex}2 type">, |
| InGroup<AbsoluteValue>; |
| def note_replace_abs_function : Note<"use function '%0' instead">; |
| def warn_pointer_abs : Warning< |
| "taking the absolute value of %select{pointer|function|array}0 type %1 is suspicious">, |
| InGroup<AbsoluteValue>; |
| |
| def warn_max_unsigned_zero : Warning< |
| "taking the max of " |
| "%select{a value and unsigned zero|unsigned zero and a value}0 " |
| "is always equal to the other value">, |
| InGroup<MaxUnsignedZero>; |
| def note_remove_max_call : Note< |
| "remove call to max function and unsigned zero argument">; |
| |
| def warn_infinite_recursive_function : Warning< |
| "all paths through this function will call itself">, |
| InGroup<InfiniteRecursion>, DefaultIgnore; |
| |
| def warn_comma_operator : Warning<"possible misuse of comma operator here">, |
| InGroup<DiagGroup<"comma">>, DefaultIgnore; |
| def note_cast_to_void : Note<"cast expression to void to silence warning">; |
| |
| // Constant expressions |
| def err_expr_not_ice : Error< |
| "expression is not an %select{integer|integral}0 constant expression">; |
| def ext_expr_not_ice : Extension< |
| "expression is not an %select{integer|integral}0 constant expression; " |
| "folding it to a constant is a GNU extension">, InGroup<GNUFoldingConstant>; |
| def err_typecheck_converted_constant_expression : Error< |
| "value of type %0 is not implicitly convertible to %1">; |
| def err_typecheck_converted_constant_expression_disallowed : Error< |
| "conversion from %0 to %1 is not allowed in a converted constant expression">; |
| def err_typecheck_converted_constant_expression_indirect : Error< |
| "conversion from %0 to %1 in converted constant expression would " |
| "bind reference to a temporary">; |
| def err_expr_not_cce : Error< |
| "%select{case value|enumerator value|non-type template argument|" |
| "array size|constexpr if condition}0 " |
| "is not a constant expression">; |
| def ext_cce_narrowing : ExtWarn< |
| "%select{case value|enumerator value|non-type template argument|" |
| "array size|constexpr if condition}0 " |
| "%select{cannot be narrowed from type %2 to %3|" |
| "evaluates to %2, which cannot be narrowed to type %3}1">, |
| InGroup<CXX11Narrowing>, DefaultError, SFINAEFailure; |
| def err_ice_not_integral : Error< |
| "integral constant expression must have integral or unscoped enumeration " |
| "type, not %0">; |
| def err_ice_incomplete_type : Error< |
| "integral constant expression has incomplete class type %0">; |
| def err_ice_explicit_conversion : Error< |
| "integral constant expression requires explicit conversion from %0 to %1">; |
| def note_ice_conversion_here : Note< |
| "conversion to %select{integral|enumeration}0 type %1 declared here">; |
| def err_ice_ambiguous_conversion : Error< |
| "ambiguous conversion from type %0 to an integral or unscoped " |
| "enumeration type">; |
| def err_ice_too_large : Error< |
| "integer constant expression evaluates to value %0 that cannot be " |
| "represented in a %1-bit %select{signed|unsigned}2 integer type">; |
| def err_expr_not_string_literal : Error<"expression is not a string literal">; |
| |
| // Semantic analysis of constant literals. |
| def ext_predef_outside_function : Warning< |
| "predefined identifier is only valid inside function">, |
| InGroup<DiagGroup<"predefined-identifier-outside-function">>; |
| def warn_float_overflow : Warning< |
| "magnitude of floating-point constant too large for type %0; maximum is %1">, |
| InGroup<LiteralRange>; |
| def warn_float_underflow : Warning< |
| "magnitude of floating-point constant too small for type %0; minimum is %1">, |
| InGroup<LiteralRange>; |
| def warn_double_const_requires_fp64 : Warning< |
| "double precision constant requires cl_khr_fp64, casting to single precision">; |
| def err_half_const_requires_fp16 : Error< |
| "half precision constant requires cl_khr_fp16">; |
| |
| // C99 variable-length arrays |
| def ext_vla : Extension<"variable length arrays are a C99 feature">, |
| InGroup<VLAExtension>; |
| def warn_vla_used : Warning<"variable length array used">, |
| InGroup<VLA>, DefaultIgnore; |
| def err_vla_in_sfinae : Error< |
| "variable length array cannot be formed during template argument deduction">; |
| def err_array_star_in_function_definition : Error< |
| "variable length array must be bound in function definition">; |
| def err_vla_decl_in_file_scope : Error< |
| "variable length array declaration not allowed at file scope">; |
| def err_vla_decl_has_static_storage : Error< |
| "variable length array declaration cannot have 'static' storage duration">; |
| def err_vla_decl_has_extern_linkage : Error< |
| "variable length array declaration cannot have 'extern' linkage">; |
| def ext_vla_folded_to_constant : Extension< |
| "variable length array folded to constant array as an extension">, InGroup<GNUFoldingConstant>; |
| def err_vla_unsupported : Error< |
| "variable length arrays are not supported for the current target">; |
| def note_vla_unsupported : Note< |
| "variable length arrays are not supported for the current target">; |
| |
| // C99 variably modified types |
| def err_variably_modified_template_arg : Error< |
| "variably modified type %0 cannot be used as a template argument">; |
| def err_variably_modified_nontype_template_param : Error< |
| "non-type template parameter of variably modified type %0">; |
| def err_variably_modified_new_type : Error< |
| "'new' cannot allocate object of variably modified type %0">; |
| |
| // C99 Designated Initializers |
| def ext_designated_init : Extension< |
| "designated initializers are a C99 feature">, InGroup<C99>; |
| def err_array_designator_negative : Error< |
| "array designator value '%0' is negative">; |
| def err_array_designator_empty_range : Error< |
| "array designator range [%0, %1] is empty">; |
| def err_array_designator_non_array : Error< |
| "array designator cannot initialize non-array type %0">; |
| def err_array_designator_too_large : Error< |
| "array designator index (%0) exceeds array bounds (%1)">; |
| def err_field_designator_non_aggr : Error< |
| "field designator cannot initialize a " |
| "%select{non-struct, non-union|non-class}0 type %1">; |
| def err_field_designator_unknown : Error< |
| "field designator %0 does not refer to any field in type %1">; |
| def err_field_designator_nonfield : Error< |
| "field designator %0 does not refer to a non-static data member">; |
| def note_field_designator_found : Note<"field designator refers here">; |
| def err_designator_for_scalar_init : Error< |
| "designator in initializer for scalar type %0">; |
| def warn_subobject_initializer_overrides : Warning< |
| "subobject initialization overrides initialization of other fields " |
| "within its enclosing subobject">, InGroup<InitializerOverrides>; |
| def warn_initializer_overrides : Warning< |
| "initializer overrides prior initialization of this subobject">, |
| InGroup<InitializerOverrides>; |
| def note_previous_initializer : Note< |
| "previous initialization %select{|with side effects }0is here" |
| "%select{| (side effects may not occur at run time)}0">; |
| def err_designator_into_flexible_array_member : Error< |
| "designator into flexible array member subobject">; |
| def note_flexible_array_member : Note< |
| "initialized flexible array member %0 is here">; |
| def ext_flexible_array_init : Extension< |
| "flexible array initialization is a GNU extension">, InGroup<GNUFlexibleArrayInitializer>; |
| |
| // Declarations. |
| def ext_duplicate_declspec : ExtWarn<"duplicate '%0' declaration specifier">, |
| InGroup<DuplicateDeclSpecifier>; |
| def warn_duplicate_declspec : Warning<"duplicate '%0' declaration specifier">, |
| InGroup<DuplicateDeclSpecifier>; |
| def ext_plain_complex : ExtWarn< |
| "plain '_Complex' requires a type specifier; assuming '_Complex double'">; |
| def ext_imaginary_constant : Extension< |
| "imaginary constants are a GNU extension">, InGroup<GNUImaginaryConstant>; |
| def ext_integer_complex : Extension< |
| "complex integer types are a GNU extension">, InGroup<GNUComplexInteger>; |
| |
| def err_invalid_saturation_spec : Error<"'_Sat' specifier is only valid on " |
| "'_Fract' or '_Accum', not '%0'">; |
| def err_invalid_sign_spec : Error<"'%0' cannot be signed or unsigned">; |
| def err_invalid_width_spec : Error< |
| "'%select{|short|long|long long}0 %1' is invalid">; |
| def err_invalid_complex_spec : Error<"'_Complex %0' is invalid">; |
| def err_friend_decl_spec : Error<"'%0' is invalid in friend declarations">; |
| |
| def ext_auto_type_specifier : ExtWarn< |
| "'auto' type specifier is a C++11 extension">, InGroup<CXX11>; |
| def warn_auto_storage_class : Warning< |
| "'auto' storage class specifier is redundant and incompatible with C++11">, |
| InGroup<CXX11Compat>, DefaultIgnore; |
| |
| def warn_deprecated_register : Warning< |
| "'register' storage class specifier is deprecated " |
| "and incompatible with C++17">, InGroup<DeprecatedRegister>; |
| def ext_register_storage_class : ExtWarn< |
| "ISO C++17 does not allow 'register' storage class specifier">, |
| DefaultError, InGroup<Register>; |
| |
| def err_invalid_decl_spec_combination : Error< |
| "cannot combine with previous '%0' declaration specifier">; |
| def err_invalid_vector_decl_spec_combination : Error< |
| "cannot combine with previous '%0' declaration specifier. " |
| "'__vector' must be first">; |
| def err_invalid_pixel_decl_spec_combination : Error< |
| "'__pixel' must be preceded by '__vector'. " |
| "'%0' declaration specifier not allowed here">; |
| def err_invalid_vector_bool_decl_spec : Error< |
| "cannot use '%0' with '__vector bool'">; |
| def err_invalid_vector_long_decl_spec : Error< |
| "cannot use 'long' with '__vector'">; |
| def err_invalid_vector_float_decl_spec : Error< |
| "cannot use 'float' with '__vector'">; |
| def err_invalid_vector_double_decl_spec : Error < |
| "use of 'double' with '__vector' requires VSX support to be enabled " |
| "(available on POWER7 or later)">; |
| def err_invalid_vector_long_long_decl_spec : Error < |
| "use of 'long long' with '__vector bool' requires VSX support (available on " |
| "POWER7 or later) or extended Altivec support (available on POWER8 or later) " |
| "to be enabled">; |
| def err_invalid_vector_long_double_decl_spec : Error< |
| "cannot use 'long double' with '__vector'">; |
| def warn_vector_long_decl_spec_combination : Warning< |
| "Use of 'long' with '__vector' is deprecated">, InGroup<Deprecated>; |
| |
| def err_use_of_tag_name_without_tag : Error< |
| "must use '%1' tag to refer to type %0%select{| in this scope}2">; |
| |
| def err_redeclaration_different_type : Error< |
| "redeclaration of %0 with a different type%diff{: $ vs $|}1,2">; |
| def err_bad_variable_name : Error< |
| "%0 cannot be the name of a variable or data member">; |
| def err_bad_parameter_name : Error< |
| "%0 cannot be the name of a parameter">; |
| def err_parameter_name_omitted : Error<"parameter name omitted">; |
| def err_anyx86_interrupt_attribute : Error< |
| "%select{x86|x86-64}0 'interrupt' attribute only applies to functions that " |
| "have %select{a 'void' return type|" |
| "only a pointer parameter optionally followed by an integer parameter|" |
| "a pointer as the first parameter|a %2 type as the second parameter}1">; |
| def err_anyx86_interrupt_called : Error< |
| "interrupt service routine cannot be called directly">; |
| def warn_arm_interrupt_calling_convention : Warning< |
| "call to function without interrupt attribute could clobber interruptee's VFP registers">, |
| InGroup<Extra>; |
| def warn_mips_interrupt_attribute : Warning< |
| "MIPS 'interrupt' attribute only applies to functions that have " |
| "%select{no parameters|a 'void' return type}0">, |
| InGroup<IgnoredAttributes>; |
| def warn_riscv_repeated_interrupt_attribute : Warning< |
| "repeated RISC-V 'interrupt' attribute">, InGroup<IgnoredAttributes>; |
| def note_riscv_repeated_interrupt_attribute : Note< |
| "repeated RISC-V 'interrupt' attribute is here">; |
| def warn_riscv_interrupt_attribute : Warning< |
| "RISC-V 'interrupt' attribute only applies to functions that have " |
| "%select{no parameters|a 'void' return type}0">, |
| InGroup<IgnoredAttributes>; |
| def warn_unused_parameter : Warning<"unused parameter %0">, |
| InGroup<UnusedParameter>, DefaultIgnore; |
| def warn_unused_variable : Warning<"unused variable %0">, |
| InGroup<UnusedVariable>, DefaultIgnore; |
| def warn_unused_local_typedef : Warning< |
| "unused %select{typedef|type alias}0 %1">, |
| InGroup<UnusedLocalTypedef>, DefaultIgnore; |
| def warn_unused_property_backing_ivar : |
| Warning<"ivar %0 which backs the property is not " |
| "referenced in this property's accessor">, |
| InGroup<UnusedPropertyIvar>, DefaultIgnore; |
| def warn_unused_const_variable : Warning<"unused variable %0">, |
| InGroup<UnusedConstVariable>, DefaultIgnore; |
| def warn_unused_exception_param : Warning<"unused exception parameter %0">, |
| InGroup<UnusedExceptionParameter>, DefaultIgnore; |
| def warn_decl_in_param_list : Warning< |
| "declaration of %0 will not be visible outside of this function">, |
| InGroup<Visibility>; |
| def warn_redefinition_in_param_list : Warning< |
| "redefinition of %0 will not be visible outside of this function">, |
| InGroup<Visibility>; |
| def warn_empty_parens_are_function_decl : Warning< |
| "empty parentheses interpreted as a function declaration">, |
| InGroup<VexingParse>; |
| def warn_parens_disambiguated_as_function_declaration : Warning< |
| "parentheses were disambiguated as a function declaration">, |
| InGroup<VexingParse>; |
| def warn_parens_disambiguated_as_variable_declaration : Warning< |
| "parentheses were disambiguated as redundant parentheses around declaration " |
| "of variable named %0">, InGroup<VexingParse>; |
| def warn_redundant_parens_around_declarator : Warning< |
| "redundant parentheses surrounding declarator">, |
| InGroup<DiagGroup<"redundant-parens">>, DefaultIgnore; |
| def note_additional_parens_for_variable_declaration : Note< |
| "add a pair of parentheses to declare a variable">; |
| def note_raii_guard_add_name : Note< |
| "add a variable name to declare a %0 initialized with %1">; |
| def note_function_style_cast_add_parentheses : Note< |
| "add enclosing parentheses to perform a function-style cast">; |
| def note_remove_parens_for_variable_declaration : Note< |
| "remove parentheses to silence this warning">; |
| def note_empty_parens_function_call : Note< |
| "change this ',' to a ';' to call %0">; |
| def note_empty_parens_default_ctor : Note< |
| "remove parentheses to declare a variable">; |
| def note_empty_parens_zero_initialize : Note< |
| "replace parentheses with an initializer to declare a variable">; |
| def warn_unused_function : Warning<"unused function %0">, |
| InGroup<UnusedFunction>, DefaultIgnore; |
| def warn_unused_template : Warning<"unused %select{function|variable}0 template %1">, |
| InGroup<UnusedTemplate>, DefaultIgnore; |
| def warn_unused_member_function : Warning<"unused member function %0">, |
| InGroup<UnusedMemberFunction>, DefaultIgnore; |
| def warn_used_but_marked_unused: Warning<"%0 was marked unused but was used">, |
| InGroup<UsedButMarkedUnused>, DefaultIgnore; |
| def warn_unneeded_internal_decl : Warning< |
| "%select{function|variable}0 %1 is not needed and will not be emitted">, |
| InGroup<UnneededInternalDecl>, DefaultIgnore; |
| def warn_unneeded_static_internal_decl : Warning< |
| "'static' function %0 declared in header file " |
| "should be declared 'static inline'">, |
| InGroup<UnneededInternalDecl>, DefaultIgnore; |
| def warn_unneeded_member_function : Warning< |
| "member function %0 is not needed and will not be emitted">, |
| InGroup<UnneededMemberFunction>, DefaultIgnore; |
| def warn_unused_private_field: Warning<"private field %0 is not used">, |
| InGroup<UnusedPrivateField>, DefaultIgnore; |
| def warn_unused_lambda_capture: Warning<"lambda capture %0 is not " |
| "%select{used|required to be captured for this use}1">, |
| InGroup<UnusedLambdaCapture>, DefaultIgnore; |
| |
| def warn_parameter_size: Warning< |
| "%0 is a large (%1 bytes) pass-by-value argument; " |
| "pass it by reference instead ?">, InGroup<LargeByValueCopy>; |
| def warn_return_value_size: Warning< |
| "return value of %0 is a large (%1 bytes) pass-by-value object; " |
| "pass it by reference instead ?">, InGroup<LargeByValueCopy>; |
| def warn_return_value_udt: Warning< |
| "%0 has C-linkage specified, but returns user-defined type %1 which is " |
| "incompatible with C">, InGroup<ReturnTypeCLinkage>; |
| def warn_return_value_udt_incomplete: Warning< |
| "%0 has C-linkage specified, but returns incomplete type %1 which could be " |
| "incompatible with C">, InGroup<ReturnTypeCLinkage>; |
| def warn_implicit_function_decl : Warning< |
| "implicit declaration of function %0">, |
| InGroup<ImplicitFunctionDeclare>, DefaultIgnore; |
| def ext_implicit_function_decl : ExtWarn< |
| "implicit declaration of function %0 is invalid in %select{C99|OpenCL}1">, |
| InGroup<ImplicitFunctionDeclare>; |
| def note_function_suggestion : Note<"did you mean %0?">; |
| |
| def err_ellipsis_first_param : Error< |
| "ISO C requires a named parameter before '...'">; |
| def err_declarator_need_ident : Error<"declarator requires an identifier">; |
| def err_language_linkage_spec_unknown : Error<"unknown linkage language">; |
| def err_language_linkage_spec_not_ascii : Error< |
| "string literal in language linkage specifier cannot have an " |
| "encoding-prefix">; |
| def ext_use_out_of_scope_declaration : ExtWarn< |
| "use of out-of-scope declaration of %0%select{| whose type is not " |
| "compatible with that of an implicit declaration}1">, |
| InGroup<DiagGroup<"out-of-scope-function">>; |
| def err_inline_non_function : Error< |
| "'inline' can only appear on functions%select{| and non-local variables}0">; |
| def err_noreturn_non_function : Error< |
| "'_Noreturn' can only appear on functions">; |
| def warn_qual_return_type : Warning< |
| "'%0' type qualifier%s1 on return type %plural{1:has|:have}1 no effect">, |
| InGroup<IgnoredQualifiers>, DefaultIgnore; |
| def warn_deprecated_redundant_constexpr_static_def : Warning< |
| "out-of-line definition of constexpr static data member is redundant " |
| "in C++17 and is deprecated">, |
| InGroup<Deprecated>, DefaultIgnore; |
| |
| def warn_decl_shadow : |
| Warning<"declaration shadows a %select{" |
| "local variable|" |
| "variable in %2|" |
| "static data member of %2|" |
| "field of %2|" |
| "typedef in %2|" |
| "type alias in %2}1">, |
| InGroup<Shadow>, DefaultIgnore; |
| def warn_decl_shadow_uncaptured_local : |
| Warning<warn_decl_shadow.Text>, |
| InGroup<ShadowUncapturedLocal>, DefaultIgnore; |
| def warn_ctor_parm_shadows_field: |
| Warning<"constructor parameter %0 shadows the field %1 of %2">, |
| InGroup<ShadowFieldInConstructor>, DefaultIgnore; |
| def warn_modifying_shadowing_decl : |
| Warning<"modifying constructor parameter %0 that shadows a " |
| "field of %1">, |
| InGroup<ShadowFieldInConstructorModified>, DefaultIgnore; |
| |
| // C++ decomposition declarations |
| def err_decomp_decl_context : Error< |
| "decomposition declaration not permitted in this context">; |
| def warn_cxx14_compat_decomp_decl : Warning< |
| "decomposition declarations are incompatible with " |
| "C++ standards before C++17">, DefaultIgnore, InGroup<CXXPre17Compat>; |
| def ext_decomp_decl : ExtWarn< |
| "decomposition declarations are a C++17 extension">, InGroup<CXX17>; |
| def ext_decomp_decl_cond : ExtWarn< |
| "ISO C++17 does not permit structured binding declaration in a condition">, |
| InGroup<DiagGroup<"binding-in-condition">>; |
| def err_decomp_decl_spec : Error< |
| "decomposition declaration cannot be declared " |
| "%plural{1:'%1'|:with '%1' specifiers}0">; |
| def err_decomp_decl_type : Error< |
| "decomposition declaration cannot be declared with type %0; " |
| "declared type must be 'auto' or reference to 'auto'">; |
| def err_decomp_decl_parens : Error< |
| "decomposition declaration cannot be declared with parentheses">; |
| def err_decomp_decl_template : Error< |
| "decomposition declaration template not supported">; |
| def err_decomp_decl_not_alone : Error< |
| "decomposition declaration must be the only declaration in its group">; |
| def err_decomp_decl_requires_init : Error< |
| "decomposition declaration %0 requires an initializer">; |
| def err_decomp_decl_wrong_number_bindings : Error< |
| "type %0 decomposes into %2 elements, but %select{only |}3%1 " |
| "names were provided">; |
| def err_decomp_decl_unbindable_type : Error< |
| "cannot decompose %select{union|non-class, non-array}1 type %2">; |
| def err_decomp_decl_multiple_bases_with_members : Error< |
| "cannot decompose class type %1: " |
| "%select{its base classes %2 and|both it and its base class}0 %3 " |
| "have non-static data members">; |
| def err_decomp_decl_ambiguous_base : Error< |
| "cannot decompose members of ambiguous base class %1 of %0:%2">; |
| def err_decomp_decl_non_public_base : Error< |
| "cannot decompose members of non-public base class %1 of %0">; |
| def err_decomp_decl_non_public_member : Error< |
| "cannot decompose non-public member %0 of %1">; |
| def err_decomp_decl_anon_union_member : Error< |
| "cannot decompose class type %0 because it has an anonymous " |
| "%select{struct|union}1 member">; |
| def err_decomp_decl_std_tuple_element_not_specialized : Error< |
| "cannot decompose this type; 'std::tuple_element<%0>::type' " |
| "does not name a type">; |
| def err_decomp_decl_std_tuple_size_not_constant : Error< |
| "cannot decompose this type; 'std::tuple_size<%0>::value' " |
| "is not a valid integral constant expression">; |
| def note_in_binding_decl_init : Note< |
| "in implicit initialization of binding declaration %0">; |
| |
| def err_std_type_trait_not_class_template : Error< |
| "unsupported standard library implementation: " |
| "'std::%0' is not a class template">; |
| |
| // C++ using declarations |
| def err_using_requires_qualname : Error< |
| "using declaration requires a qualified name">; |
| def err_using_typename_non_type : Error< |
| "'typename' keyword used on a non-type">; |
| def err_using_dependent_value_is_type : Error< |
| "dependent using declaration resolved to type without 'typename'">; |
| def err_using_decl_nested_name_specifier_is_not_class : Error< |
| "using declaration in class refers into '%0', which is not a class">; |
| def err_using_decl_nested_name_specifier_is_current_class : Error< |
| "using declaration refers to its own class">; |
| def err_using_decl_nested_name_specifier_is_not_base_class : Error< |
| "using declaration refers into '%0', which is not a base class of %1">; |
| def err_using_decl_constructor_not_in_direct_base : Error< |
| "%0 is not a direct base of %1, cannot inherit constructors">; |
| def err_using_decl_can_not_refer_to_class_member : Error< |
| "using declaration cannot refer to class member">; |
| def err_ambiguous_inherited_constructor : Error< |
| "constructor of %0 inherited from multiple base class subobjects">; |
| def note_ambiguous_inherited_constructor_using : Note< |
| "inherited from base class %0 here">; |
| def note_using_decl_class_member_workaround : Note< |
| "use %select{an alias declaration|a typedef declaration|a reference|" |
| "a const variable|a constexpr variable}0 instead">; |
| def err_using_decl_can_not_refer_to_namespace : Error< |
| "using declaration cannot refer to a namespace">; |
| def err_using_decl_can_not_refer_to_scoped_enum : Error< |
| "using declaration cannot refer to a scoped enumerator">; |
| def err_using_decl_constructor : Error< |
| "using declaration cannot refer to a constructor">; |
| def warn_cxx98_compat_using_decl_constructor : Warning< |
| "inheriting constructors are incompatible with C++98">, |
| InGroup<CXX98Compat>, DefaultIgnore; |
| def err_using_decl_destructor : Error< |
| "using declaration cannot refer to a destructor">; |
| def err_using_decl_template_id : Error< |
| "using declaration cannot refer to a template specialization">; |
| def note_using_decl_target : Note<"target of using declaration">; |
| def note_using_decl_conflict : Note<"conflicting declaration">; |
| def err_using_decl_redeclaration : Error<"redeclaration of using declaration">; |
| def err_using_decl_conflict : Error< |
| "target of using declaration conflicts with declaration already in scope">; |
| def err_using_decl_conflict_reverse : Error< |
| "declaration conflicts with target of using declaration already in scope">; |
| def note_using_decl : Note<"%select{|previous }0using declaration">; |
| def err_using_decl_redeclaration_expansion : Error< |
| "using declaration pack expansion at block scope produces multiple values">; |
| |
| def warn_access_decl_deprecated : Warning< |
| "access declarations are deprecated; use using declarations instead">, |
| InGroup<Deprecated>; |
| def err_access_decl : Error< |
| "ISO C++11 does not allow access declarations; " |
| "use using declarations instead">; |
| def ext_dynamic_exception_spec : ExtWarn< |
| "ISO C++17 does not allow dynamic exception specifications">, |
| InGroup<DynamicExceptionSpec>, DefaultError; |
| def warn_exception_spec_deprecated : Warning< |
| "dynamic exception specifications are deprecated">, |
| InGroup<DeprecatedDynamicExceptionSpec>, DefaultIgnore; |
| def note_exception_spec_deprecated : Note<"use '%0' instead">; |
| def warn_deprecated_copy_operation : Warning< |
| "definition of implicit copy %select{constructor|assignment operator}1 " |
| "for %0 is deprecated because it has a user-declared " |
| "%select{copy %select{assignment operator|constructor}1|destructor}2">, |
| InGroup<Deprecated>, DefaultIgnore; |
| def warn_cxx17_compat_exception_spec_in_signature : Warning< |
| "mangled name of %0 will change in C++17 due to non-throwing exception " |
| "specification in function signature">, InGroup<CXX17CompatMangling>; |
| |
| def warn_global_constructor : Warning< |
| "declaration requires a global constructor">, |
| InGroup<GlobalConstructors>, DefaultIgnore; |
| def warn_global_destructor : Warning< |
| "declaration requires a global destructor">, |
| InGroup<GlobalConstructors>, DefaultIgnore; |
| def warn_exit_time_destructor : Warning< |
| "declaration requires an exit-time destructor">, |
| InGroup<ExitTimeDestructors>, DefaultIgnore; |
| |
| def err_invalid_thread : Error< |
| "'%0' is only allowed on variable declarations">; |
| def err_thread_non_global : Error< |
| "'%0' variables must have global storage">; |
| def err_thread_unsupported : Error< |
| "thread-local storage is not supported for the current target">; |
| |
| def warn_maybe_falloff_nonvoid_function : Warning< |
| "control may reach end of non-void function">, |
| InGroup<ReturnType>; |
| def warn_falloff_nonvoid_function : Warning< |
| "control reaches end of non-void function">, |
| InGroup<ReturnType>; |
| def err_maybe_falloff_nonvoid_block : Error< |
| "control may reach end of non-void block">; |
| def err_falloff_nonvoid_block : Error< |
| "control reaches end of non-void block">; |
| def warn_maybe_falloff_nonvoid_coroutine : Warning< |
| "control may reach end of coroutine; which is undefined behavior because the promise type %0 does not declare 'return_void()'">, |
| InGroup<ReturnType>; |
| def warn_falloff_nonvoid_coroutine : Warning< |
| "control reaches end of coroutine; which is undefined behavior because the promise type %0 does not declare 'return_void()'">, |
| InGroup<ReturnType>; |
| def warn_suggest_noreturn_function : Warning< |
| "%select{function|method}0 %1 could be declared with attribute 'noreturn'">, |
| InGroup<MissingNoreturn>, DefaultIgnore; |
| def warn_suggest_noreturn_block : Warning< |
| "block could be declared with attribute 'noreturn'">, |
| InGroup<MissingNoreturn>, DefaultIgnore; |
| |
| // Unreachable code. |
| def warn_unreachable : Warning< |
| "code will never be executed">, |
| InGroup<UnreachableCode>, DefaultIgnore; |
| def warn_unreachable_break : Warning< |
| "'break' will never be executed">, |
| InGroup<UnreachableCodeBreak>, DefaultIgnore; |
| def warn_unreachable_return : Warning< |
| "'return' will never be executed">, |
| InGroup<UnreachableCodeReturn>, DefaultIgnore; |
| def warn_unreachable_loop_increment : Warning< |
| "loop will run at most once (loop increment never executed)">, |
| InGroup<UnreachableCodeLoopIncrement>, DefaultIgnore; |
| def note_unreachable_silence : Note< |
| "silence by adding parentheses to mark code as explicitly dead">; |
| |
| /// Built-in functions. |
| def ext_implicit_lib_function_decl : ExtWarn< |
| "implicitly declaring library function '%0' with type %1">, |
| InGroup<ImplicitFunctionDeclare>; |
| def note_include_header_or_declare : Note< |
| "include the header <%0> or explicitly provide a declaration for '%1'">; |
| def note_previous_builtin_declaration : Note<"%0 is a builtin with type %1">; |
| def warn_implicit_decl_requires_sysheader : Warning< |
| "declaration of built-in function '%1' requires inclusion of the header <%0>">, |
| InGroup<BuiltinRequiresHeader>; |
| def warn_redecl_library_builtin : Warning< |
| "incompatible redeclaration of library function %0">, |
| InGroup<DiagGroup<"incompatible-library-redeclaration">>; |
| def err_builtin_definition : Error<"definition of builtin function %0">; |
| def err_builtin_redeclare : Error<"cannot redeclare builtin function %0">; |
| def err_arm_invalid_specialreg : Error<"invalid special register for builtin">; |
| def err_invalid_cpu_supports : Error<"invalid cpu feature string for builtin">; |
| def err_invalid_cpu_is : Error<"invalid cpu name for builtin">; |
| def err_invalid_cpu_specific_dispatch_value : Error< |
| "invalid option '%0' for %select{cpu_specific|cpu_dispatch}1">; |
| def err_builtin_needs_feature : Error<"%0 needs target feature %1">; |
| def err_function_needs_feature |
| : Error<"always_inline function %1 requires target feature '%2', but would " |
| "be inlined into function %0 that is compiled without support for " |
| "'%2'">; |
| def warn_builtin_unknown : Warning<"use of unknown builtin %0">, |
| InGroup<ImplicitFunctionDeclare>, DefaultError; |
| def warn_cstruct_memaccess : Warning< |
| "%select{destination for|source of|first operand of|second operand of}0 this " |
| "%1 call is a pointer to record %2 that is not trivial to " |
| "%select{primitive-default-initialize|primitive-copy}3">, |
| InGroup<NonTrivialMemaccess>; |
| def note_nontrivial_field : Note< |
| "field is non-trivial to %select{copy|default-initialize}0">; |
| def warn_dyn_class_memaccess : Warning< |
| "%select{destination for|source of|first operand of|second operand of}0 this " |
| "%1 call is a pointer to %select{|class containing a }2dynamic class %3; " |
| "vtable pointer will be %select{overwritten|copied|moved|compared}4">, |
| InGroup<DynamicClassMemaccess>; |
| def note_bad_memaccess_silence : Note< |
| "explicitly cast the pointer to silence this warning">; |
| def warn_sizeof_pointer_expr_memaccess : Warning< |
| "'%0' call operates on objects of type %1 while the size is based on a " |
| "different type %2">, |
| InGroup<SizeofPointerMemaccess>; |
| def warn_sizeof_pointer_expr_memaccess_note : Note< |
| "did you mean to %select{dereference the argument to 'sizeof' (and multiply " |
| "it by the number of elements)|remove the addressof in the argument to " |
| "'sizeof' (and multiply it by the number of elements)|provide an explicit " |
| "length}0?">; |
| def warn_sizeof_pointer_type_memaccess : Warning< |
| "argument to 'sizeof' in %0 call is the same pointer type %1 as the " |
| "%select{destination|source}2; expected %3 or an explicit length">, |
| InGroup<SizeofPointerMemaccess>; |
| def warn_strlcpycat_wrong_size : Warning< |
| "size argument in %0 call appears to be size of the source; " |
| "expected the size of the destination">, |
| InGroup<DiagGroup<"strlcpy-strlcat-size">>; |
| def note_strlcpycat_wrong_size : Note< |
| "change size argument to be the size of the destination">; |
| def warn_memsize_comparison : Warning< |
| "size argument in %0 call is a comparison">, |
| InGroup<DiagGroup<"memsize-comparison">>; |
| def note_memsize_comparison_paren : Note< |
| "did you mean to compare the result of %0 instead?">; |
| def note_memsize_comparison_cast_silence : Note< |
| "explicitly cast the argument to size_t to silence this warning">; |
| def warn_suspicious_sizeof_memset : Warning< |
| "%select{'size' argument to memset is '0'|" |
| "setting buffer to a 'sizeof' expression}0" |
| "; did you mean to transpose the last two arguments?">, |
| InGroup<MemsetTransposedArgs>; |
| def note_suspicious_sizeof_memset_silence : Note< |
| "%select{parenthesize the third argument|" |
| "cast the second argument to 'int'}0 to silence">; |
| def warn_suspicious_bzero_size : Warning<"'size' argument to bzero is '0'">, |
| InGroup<SuspiciousBzero>; |
| def note_suspicious_bzero_size_silence : Note< |
| "parenthesize the second argument to silence">; |
| |
| def warn_strncat_large_size : Warning< |
| "the value of the size argument in 'strncat' is too large, might lead to a " |
| "buffer overflow">, InGroup<StrncatSize>; |
| def warn_strncat_src_size : Warning<"size argument in 'strncat' call appears " |
| "to be size of the source">, InGroup<StrncatSize>; |
| def warn_strncat_wrong_size : Warning< |
| "the value of the size argument to 'strncat' is wrong">, InGroup<StrncatSize>; |
| def note_strncat_wrong_size : Note< |
| "change the argument to be the free space in the destination buffer minus " |
| "the terminating null byte">; |
| |
| def warn_assume_side_effects : Warning< |
| "the argument to %0 has side effects that will be discarded">, |
| InGroup<DiagGroup<"assume">>; |
| |
| def warn_memcpy_chk_overflow : Warning< |
| "%0 will always overflow destination buffer">, |
| InGroup<DiagGroup<"builtin-memcpy-chk-size">>; |
| |
| /// main() |
| // static main() is not an error in C, just in C++. |
| def warn_static_main : Warning<"'main' should not be declared static">, |
| InGroup<Main>; |
| def err_static_main : Error<"'main' is not allowed to be declared static">; |
| def err_inline_main : Error<"'main' is not allowed to be declared inline">; |
| def ext_variadic_main : ExtWarn< |
| "'main' is not allowed to be declared variadic">, InGroup<Main>; |
| def ext_noreturn_main : ExtWarn< |
| "'main' is not allowed to be declared _Noreturn">, InGroup<Main>; |
| def note_main_remove_noreturn : Note<"remove '_Noreturn'">; |
| def err_constexpr_main : Error< |
| "'main' is not allowed to be declared constexpr">; |
| def err_deleted_main : Error<"'main' is not allowed to be deleted">; |
| def err_mainlike_template_decl : Error<"%0 cannot be a template">; |
| def err_main_returns_nonint : Error<"'main' must return 'int'">; |
| def ext_main_returns_nonint : ExtWarn<"return type of 'main' is not 'int'">, |
| InGroup<MainReturnType>; |
| def note_main_change_return_type : Note<"change return type to 'int'">; |
| def err_main_surplus_args : Error<"too many parameters (%0) for 'main': " |
| "must be 0, 2, or 3">; |
| def warn_main_one_arg : Warning<"only one parameter on 'main' declaration">, |
| InGroup<Main>; |
| def err_main_arg_wrong : Error<"%select{first|second|third|fourth}0 " |
| "parameter of 'main' (%select{argument count|argument array|environment|" |
| "platform-specific data}0) must be of type %1">; |
| def warn_main_returns_bool_literal : Warning<"bool literal returned from " |
| "'main'">, InGroup<Main>; |
| def err_main_global_variable : |
| Error<"main cannot be declared as global variable">; |
| def warn_main_redefined : Warning<"variable named 'main' with external linkage " |
| "has undefined behavior">, InGroup<Main>; |
| def ext_main_used : Extension< |
| "ISO C++ does not allow 'main' to be used by a program">, InGroup<Main>; |
| |
| /// parser diagnostics |
| def ext_no_declarators : ExtWarn<"declaration does not declare anything">, |
| InGroup<MissingDeclarations>; |
| def ext_typedef_without_a_name : ExtWarn<"typedef requires a name">, |
| InGroup<MissingDeclarations>; |
| def err_typedef_not_identifier : Error<"typedef name must be an identifier">; |
| def err_typedef_changes_linkage : Error<"unsupported: typedef changes linkage" |
| " of anonymous type, but linkage was already computed">; |
| def note_typedef_changes_linkage : Note<"use a tag name here to establish " |
| "linkage prior to definition">; |
| def err_statically_allocated_object : Error< |
| "interface type cannot be statically allocated">; |
| def err_object_cannot_be_passed_returned_by_value : Error< |
| "interface type %1 cannot be %select{returned|passed}0 by value" |
| "; did you forget * in %1?">; |
| def err_parameters_retval_cannot_have_fp16_type : Error< |
| "%select{parameters|function return value}0 cannot have __fp16 type; did you forget * ?">; |
| def err_opencl_half_load_store : Error< |
| "%select{loading directly from|assigning directly to}0 pointer to type %1 requires " |
| "cl_khr_fp16. Use vector data %select{load|store}0 builtin functions instead">; |
| def err_opencl_cast_to_half : Error<"casting to type %0 is not allowed">; |
| def err_opencl_half_declaration : Error< |
| "declaring variable of type %0 is not allowed">; |
| def err_opencl_half_param : Error< |
| "declaring function parameter of type %0 is not allowed; did you forget * ?">; |
| def err_opencl_invalid_return : Error< |
| "declaring function return value of type %0 is not allowed %select{; did you forget * ?|}1">; |
| def warn_enum_value_overflow : Warning<"overflow in enumeration value">; |
| def warn_pragma_options_align_reset_failed : Warning< |
| "#pragma options align=reset failed: %0">, |
| InGroup<IgnoredPragmas>; |
| def err_pragma_options_align_mac68k_target_unsupported : Error< |
| "mac68k alignment pragma is not supported on this target">; |
| def warn_pragma_pack_invalid_alignment : Warning< |
| "expected #pragma pack parameter to be '1', '2', '4', '8', or '16'">, |
| InGroup<IgnoredPragmas>; |
| def warn_pragma_pack_non_default_at_include : Warning< |
| "non-default #pragma pack value changes the alignment of struct or union " |
| "members in the included file">, InGroup<PragmaPackSuspiciousInclude>, |
| DefaultIgnore; |
| def warn_pragma_pack_modified_after_include : Warning< |
| "the current #pragma pack aligment value is modified in the included " |
| "file">, InGroup<PragmaPack>; |
| def warn_pragma_pack_no_pop_eof : Warning<"unterminated " |
| "'#pragma pack (push, ...)' at end of file">, InGroup<PragmaPack>; |
| def note_pragma_pack_here : Note< |
| "previous '#pragma pack' directive that modifies alignment is here">; |
| def note_pragma_pack_pop_instead_reset : Note< |
| "did you intend to use '#pragma pack (pop)' instead of '#pragma pack()'?">; |
| // Follow the Microsoft implementation. |
| def warn_pragma_pack_show : Warning<"value of #pragma pack(show) == %0">; |
| def warn_pragma_pack_pop_identifier_and_alignment : Warning< |
| "specifying both a name and alignment to 'pop' is undefined">; |
| def warn_pragma_pop_failed : Warning<"#pragma %0(pop, ...) failed: %1">, |
| InGroup<IgnoredPragmas>; |
| def warn_cxx_ms_struct : |
| Warning<"ms_struct may not produce Microsoft-compatible layouts for classes " |
| "with base classes or virtual functions">, |
| DefaultError, InGroup<IncompatibleMSStruct>; |
| def warn_npot_ms_struct : |
| Warning<"ms_struct may not produce Microsoft-compatible layouts with fundamental " |
| "data types with sizes that aren't a power of two">, |
| DefaultError, InGroup<IncompatibleMSStruct>; |
| def err_section_conflict : Error<"%0 causes a section type conflict with %1">; |
| def err_no_base_classes : Error<"invalid use of '__super', %0 has no base classes">; |
| def err_invalid_super_scope : Error<"invalid use of '__super', " |
| "this keyword can only be used inside class or member function scope">; |
| def err_super_in_lambda_unsupported : Error< |
| "use of '__super' inside a lambda is unsupported">; |
| |
| def warn_pragma_unused_undeclared_var : Warning< |
| "undeclared variable %0 used as an argument for '#pragma unused'">, |
| InGroup<IgnoredPragmas>; |
| def warn_atl_uuid_deprecated : Warning< |
| "specifying 'uuid' as an ATL attribute is deprecated; use __declspec instead">, |
| InGroup<DeprecatedDeclarations>; |
| def warn_pragma_unused_expected_var_arg : Warning< |
| "only variables can be arguments to '#pragma unused'">, |
| InGroup<IgnoredPragmas>; |
| def err_pragma_push_visibility_mismatch : Error< |
| "#pragma visibility push with no matching #pragma visibility pop">; |
| def note_surrounding_namespace_ends_here : Note< |
| "surrounding namespace with visibility attribute ends here">; |
| def err_pragma_pop_visibility_mismatch : Error< |
| "#pragma visibility pop with no matching #pragma visibility push">; |
| def note_surrounding_namespace_starts_here : Note< |
| "surrounding namespace with visibility attribute starts here">; |
| def err_pragma_loop_invalid_argument_type : Error< |
| "invalid argument of type %0; expected an integer type">; |
| def err_pragma_loop_invalid_argument_value : Error< |
| "%select{invalid value '%0'; must be positive|value '%0' is too large}1">; |
| def err_pragma_loop_compatibility : Error< |
| "%select{incompatible|duplicate}0 directives '%1' and '%2'">; |
| def err_pragma_loop_precedes_nonloop : Error< |
| "expected a for, while, or do-while loop to follow '%0'">; |
| |
| def err_pragma_attribute_matcher_subrule_contradicts_rule : Error< |
| "redundant attribute subject matcher sub-rule '%0'; '%1' already matches " |
| "those declarations">; |
| def err_pragma_attribute_matcher_negated_subrule_contradicts_subrule : Error< |
| "negated attribute subject matcher sub-rule '%0' contradicts sub-rule '%1'">; |
| def err_pragma_attribute_invalid_matchers : Error< |
| "attribute %0 can't be applied to %1">; |
| def err_pragma_attribute_stack_mismatch : Error< |
| "'#pragma clang attribute pop' with no matching '#pragma clang attribute push'">; |
| def warn_pragma_attribute_unused : Warning< |
| "unused attribute %0 in '#pragma clang attribute push' region">, |
| InGroup<PragmaClangAttribute>; |
| def note_pragma_attribute_region_ends_here : Note< |
| "'#pragma clang attribute push' regions ends here">; |
| def err_pragma_attribute_no_pop_eof : Error<"unterminated " |
| "'#pragma clang attribute push' at end of file">; |
| def note_pragma_attribute_applied_decl_here : Note< |
| "when applied to this declaration">; |
| |
| /// Objective-C parser diagnostics |
| def err_duplicate_class_def : Error< |
| "duplicate interface definition for class %0">; |
| def err_undef_superclass : Error< |
| "cannot find interface declaration for %0, superclass of %1">; |
| def err_forward_superclass : Error< |
| "attempting to use the forward class %0 as superclass of %1">; |
| def err_no_nsconstant_string_class : Error< |
| "cannot find interface declaration for %0">; |
| def err_recursive_superclass : Error< |
| "trying to recursively use %0 as superclass of %1">; |
| def err_conflicting_aliasing_type : Error<"conflicting types for alias %0">; |
| def warn_undef_interface : Warning<"cannot find interface declaration for %0">; |
| def warn_duplicate_protocol_def : Warning< |
| "duplicate protocol definition of %0 is ignored">, |
| InGroup<DiagGroup<"duplicate-protocol">>; |
| def err_protocol_has_circular_dependency : Error< |
| "protocol has circular dependency">; |
| def err_undeclared_protocol : Error<"cannot find protocol declaration for %0">; |
| def warn_undef_protocolref : Warning<"cannot find protocol definition for %0">; |
| def warn_atprotocol_protocol : Warning< |
| "@protocol is using a forward protocol declaration of %0">, InGroup<AtProtocol>; |
| def warn_readonly_property : Warning< |
| "attribute 'readonly' of property %0 restricts attribute " |
| "'readwrite' of property inherited from %1">, |
| InGroup<PropertyAttr>; |
| |
| def warn_property_attribute : Warning< |
| "'%1' attribute on property %0 does not match the property inherited from %2">, |
| InGroup<PropertyAttr>; |
| def warn_property_types_are_incompatible : Warning< |
| "property type %0 is incompatible with type %1 inherited from %2">, |
| InGroup<DiagGroup<"incompatible-property-type">>; |
| def warn_protocol_property_mismatch : Warning< |
| "property %select{of type %1|with attribute '%1'|without attribute '%1'|with " |
| "getter %1|with setter %1}0 was selected for synthesis">, |
| InGroup<DiagGroup<"protocol-property-synthesis-ambiguity">>; |
| def err_protocol_property_mismatch: Error<warn_protocol_property_mismatch.Text>; |
| def err_undef_interface : Error<"cannot find interface declaration for %0">; |
| def err_category_forward_interface : Error< |
| "cannot define %select{category|class extension}0 for undefined class %1">; |
| def err_class_extension_after_impl : Error< |
| "cannot declare class extension for %0 after class implementation">; |
| def note_implementation_declared : Note< |
| "class implementation is declared here">; |
| def note_while_in_implementation : Note< |
| "detected while default synthesizing properties in class implementation">; |
| def note_class_declared : Note< |
| "class is declared here">; |
| def note_receiver_class_declared : Note< |
| "receiver is instance of class declared here">; |
| def note_receiver_expr_here : Note< |
| "receiver expression is here">; |
| def note_receiver_is_id : Note< |
| "receiver is treated with 'id' type for purpose of method lookup">; |
| def note_suppressed_class_declare : Note< |
| "class with specified objc_requires_property_definitions attribute is declared here">; |
| def err_objc_root_class_subclass : Error< |
| "objc_root_class attribute may only be specified on a root class declaration">; |
| def err_restricted_superclass_mismatch : Error< |
| "cannot subclass a class that was declared with the " |
| "'objc_subclassing_restricted' attribute">; |
| def warn_objc_root_class_missing : Warning< |
| "class %0 defined without specifying a base class">, |
| InGroup<ObjCRootClass>; |
| def err_objc_runtime_visible_category : Error< |
| "cannot implement a category for class %0 that is only visible via the " |
| "Objective-C runtime">; |
| def err_objc_runtime_visible_subclass : Error< |
| "cannot implement subclass %0 of a superclass %1 that is only visible via the " |
| "Objective-C runtime">; |
| def note_objc_needs_superclass : Note< |
| "add a super class to fix this problem">; |
| def warn_dup_category_def : Warning< |
| "duplicate definition of category %1 on interface %0">; |
| def err_conflicting_super_class : Error<"conflicting super class name %0">; |
| def err_dup_implementation_class : Error<"reimplementation of class %0">; |
| def err_dup_implementation_category : Error< |
| "reimplementation of category %1 for class %0">; |
| def err_conflicting_ivar_type : Error< |
| "instance variable %0 has conflicting type%diff{: $ vs $|}1,2">; |
| def err_duplicate_ivar_declaration : Error< |
| "instance variable is already declared">; |
| def warn_on_superclass_use : Warning< |
| "class implementation may not have super class">; |
| def err_conflicting_ivar_bitwidth : Error< |
| "instance variable %0 has conflicting bit-field width">; |
| def err_conflicting_ivar_name : Error< |
| "conflicting instance variable names: %0 vs %1">; |
| def err_inconsistent_ivar_count : Error< |
| "inconsistent number of instance variables specified">; |
| def warn_undef_method_impl : Warning<"method definition for %0 not found">, |
| InGroup<DiagGroup<"incomplete-implementation">>; |
| |
| def warn_conflicting_overriding_ret_types : Warning< |
| "conflicting return type in " |
| "declaration of %0%diff{: $ vs $|}1,2">, |
| InGroup<OverridingMethodMismatch>, DefaultIgnore; |
| |
| def warn_conflicting_ret_types : Warning< |
| "conflicting return type in " |
| "implementation of %0%diff{: $ vs $|}1,2">, |
| InGroup<MismatchedReturnTypes>; |
| |
| def warn_conflicting_overriding_ret_type_modifiers : Warning< |
| "conflicting distributed object modifiers on return type " |
| "in declaration of %0">, |
| InGroup<OverridingMethodMismatch>, DefaultIgnore; |
| |
| def warn_conflicting_ret_type_modifiers : Warning< |
| "conflicting distributed object modifiers on return type " |
| "in implementation of %0">, |
| InGroup<DistributedObjectModifiers>; |
| |
| def warn_non_covariant_overriding_ret_types : Warning< |
| "conflicting return type in " |
| "declaration of %0: %1 vs %2">, |
| InGroup<OverridingMethodMismatch>, DefaultIgnore; |
| |
| def warn_non_covariant_ret_types : Warning< |
| "conflicting return type in " |
| "implementation of %0: %1 vs %2">, |
| InGroup<MethodSignatures>, DefaultIgnore; |
| |
| def warn_conflicting_overriding_param_types : Warning< |
| "conflicting parameter types in " |
| "declaration of %0%diff{: $ vs $|}1,2">, |
| InGroup<OverridingMethodMismatch>, DefaultIgnore; |
| |
| def warn_conflicting_param_types : Warning< |
| "conflicting parameter types in " |
| "implementation of %0%diff{: $ vs $|}1,2">, |
| InGroup<MismatchedParameterTypes>; |
| |
| def warn_conflicting_param_modifiers : Warning< |
| "conflicting distributed object modifiers on parameter type " |
| "in implementation of %0">, |
| InGroup<DistributedObjectModifiers>; |
| |
| def warn_conflicting_overriding_param_modifiers : Warning< |
| "conflicting distributed object modifiers on parameter type " |
| "in declaration of %0">, |
| InGroup<OverridingMethodMismatch>, DefaultIgnore; |
| |
| def warn_non_contravariant_overriding_param_types : Warning< |
| "conflicting parameter types in " |
| "declaration of %0: %1 vs %2">, |
| InGroup<OverridingMethodMismatch>, DefaultIgnore; |
| |
| def warn_non_contravariant_param_types : Warning< |
| "conflicting parameter types in " |
| "implementation of %0: %1 vs %2">, |
| InGroup<MethodSignatures>, DefaultIgnore; |
| |
| def warn_conflicting_overriding_variadic :Warning< |
| "conflicting variadic declaration of method and its " |
| "implementation">, |
| InGroup<OverridingMethodMismatch>, DefaultIgnore; |
| |
| def warn_conflicting_variadic :Warning< |
| "conflicting variadic declaration of method and its " |
| "implementation">; |
| |
| def warn_category_method_impl_match:Warning< |
| "category is implementing a method which will also be implemented" |
| " by its primary class">, InGroup<ObjCProtocolMethodImpl>; |
| |
| def warn_implements_nscopying : Warning< |
| "default assign attribute on property %0 which implements " |
| "NSCopying protocol is not appropriate with -fobjc-gc[-only]">; |
| |
| def warn_multiple_method_decl : Warning<"multiple methods named %0 found">, |
| InGroup<ObjCMultipleMethodNames>; |
| def warn_strict_multiple_method_decl : Warning< |
| "multiple methods named %0 found">, InGroup<StrictSelector>, DefaultIgnore; |
| def warn_accessor_property_type_mismatch : Warning< |
| "type of property %0 does not match type of accessor %1">; |
| def note_conv_function_declared_at : Note<"type conversion function declared here">; |
| def note_method_declared_at : Note<"method %0 declared here">; |
| def note_property_attribute : Note<"property %0 is declared " |
| "%select{deprecated|unavailable|partial}1 here">; |
| def err_setter_type_void : Error<"type of setter must be void">; |
| def err_duplicate_method_decl : Error<"duplicate declaration of method %0">; |
| def warn_duplicate_method_decl : |
| Warning<"multiple declarations of method %0 found and ignored">, |
| InGroup<MethodDuplicate>, DefaultIgnore; |
| def warn_objc_cdirective_format_string : |
| Warning<"using %0 directive in %select{NSString|CFString}1 " |
| "which is being passed as a formatting argument to the formatting " |
| "%select{method|CFfunction}2">, |
| InGroup<ObjCCStringFormat>, DefaultIgnore; |
| def err_objc_var_decl_inclass : |
| Error<"cannot declare variable inside @interface or @protocol">; |
| def err_missing_method_context : Error< |
| "missing context for method declaration">; |
| def err_objc_property_attr_mutually_exclusive : Error< |
| "property attributes '%0' and '%1' are mutually exclusive">; |
| def err_objc_property_requires_object : Error< |
| "property with '%0' attribute must be of object type">; |
| def warn_objc_property_no_assignment_attribute : Warning< |
| "no 'assign', 'retain', or 'copy' attribute is specified - " |
| "'assign' is assumed">, |
| InGroup<ObjCPropertyNoAttribute>; |
| def warn_objc_isa_use : Warning< |
| "direct access to Objective-C's isa is deprecated in favor of " |
| "object_getClass()">, InGroup<DeprecatedObjCIsaUsage>; |
| def warn_objc_isa_assign : Warning< |
| "assignment to Objective-C's isa is deprecated in favor of " |
| "object_setClass()">, InGroup<DeprecatedObjCIsaUsage>; |
| def warn_objc_pointer_masking : Warning< |
| "bitmasking for introspection of Objective-C object pointers is strongly " |
| "discouraged">, |
| InGroup<ObjCPointerIntrospect>; |
| def warn_objc_pointer_masking_performSelector : Warning<warn_objc_pointer_masking.Text>, |
| InGroup<ObjCPointerIntrospectPerformSelector>; |
| def warn_objc_property_default_assign_on_object : Warning< |
| "default property attribute 'assign' not appropriate for object">, |
| InGroup<ObjCPropertyNoAttribute>; |
| def warn_property_attr_mismatch : Warning< |
| "property attribute in class extension does not match the primary class">, |
| InGroup<PropertyAttr>; |
| def warn_property_implicitly_mismatched : Warning < |
| "primary property declaration is implicitly strong while redeclaration " |
| "in class extension is weak">, |
| InGroup<DiagGroup<"objc-property-implicit-mismatch">>; |
| def warn_objc_property_copy_missing_on_block : Warning< |
| "'copy' attribute must be specified for the block property " |
| "when -fobjc-gc-only is specified">; |
| def warn_objc_property_retain_of_block : Warning< |
| "retain'ed block property does not copy the block " |
| "- use copy attribute instead">, InGroup<ObjCRetainBlockProperty>; |
| def warn_objc_readonly_property_has_setter : Warning< |
| "setter cannot be specified for a readonly property">, |
| InGroup<ObjCReadonlyPropertyHasSetter>; |
| def warn_atomic_property_rule : Warning< |
| "writable atomic property %0 cannot pair a synthesized %select{getter|setter}1 " |
| "with a user defined %select{getter|setter}2">, |
| InGroup<DiagGroup<"atomic-property-with-user-defined-accessor">>; |
| def note_atomic_property_fixup_suggest : Note<"setter and getter must both be " |
| "synthesized, or both be user defined,or the property must be nonatomic">; |
| def err_atomic_property_nontrivial_assign_op : Error< |
| "atomic property of reference type %0 cannot have non-trivial assignment" |
| " operator">; |
| def warn_cocoa_naming_owned_rule : Warning< |
| "property follows Cocoa naming" |
| " convention for returning 'owned' objects">, |
| InGroup<DiagGroup<"objc-property-matches-cocoa-ownership-rule">>; |
| def err_cocoa_naming_owned_rule : Error< |
| "property follows Cocoa naming" |
| " convention for returning 'owned' objects">; |
| def note_cocoa_naming_declare_family : Note< |
| "explicitly declare getter %objcinstance0 with '%1' to return an 'unowned' " |
| "object">; |
| def warn_auto_synthesizing_protocol_property :Warning< |
| "auto property synthesis will not synthesize property %0" |
| " declared in protocol %1">, |
| InGroup<DiagGroup<"objc-protocol-property-synthesis">>; |
| def note_add_synthesize_directive : Note< |
| "add a '@synthesize' directive">; |
| def warn_no_autosynthesis_shared_ivar_property : Warning < |
| "auto property synthesis will not synthesize property " |
| "%0 because it cannot share an ivar with another synthesized property">, |
| InGroup<ObjCNoPropertyAutoSynthesis>; |
| def warn_no_autosynthesis_property : Warning< |
| "auto property synthesis will not synthesize property " |
| "%0 because it is 'readwrite' but it will be synthesized 'readonly' " |
| "via another property">, |
| InGroup<ObjCNoPropertyAutoSynthesis>; |
| def warn_autosynthesis_property_in_superclass : Warning< |
| "auto property synthesis will not synthesize property " |
| "%0; it will be implemented by its superclass, use @dynamic to " |
| "acknowledge intention">, |
| InGroup<ObjCNoPropertyAutoSynthesis>; |
| def warn_autosynthesis_property_ivar_match :Warning< |
| "autosynthesized property %0 will use %select{|synthesized}1 instance variable " |
| "%2, not existing instance variable %3">, |
| InGroup<DiagGroup<"objc-autosynthesis-property-ivar-name-match">>; |
| def warn_missing_explicit_synthesis : Warning < |
| "auto property synthesis is synthesizing property not explicitly synthesized">, |
| InGroup<DiagGroup<"objc-missing-property-synthesis">>, DefaultIgnore; |
| def warn_property_getter_owning_mismatch : Warning< |
| "property declared as returning non-retained objects" |
| "; getter returning retained objects">; |
| def warn_property_redecl_getter_mismatch : Warning< |
| "getter name mismatch between property redeclaration (%1) and its original " |
| "declaration (%0)">, InGroup<PropertyAttr>; |
| def err_property_setter_ambiguous_use : Error< |
| "synthesized properties %0 and %1 both claim setter %2 -" |
| " use of this setter will cause unexpected behavior">; |
| def warn_default_atomic_custom_getter_setter : Warning< |
| "atomic by default property %0 has a user defined %select{getter|setter}1 " |
| "(property should be marked 'atomic' if this is intended)">, |
| InGroup<CustomAtomic>, DefaultIgnore; |
| def err_use_continuation_class : Error< |
| "illegal redeclaration of property in class extension %0" |
| " (attribute must be 'readwrite', while its primary must be 'readonly')">; |
| def err_type_mismatch_continuation_class : Error< |
| "type of property %0 in class extension does not match " |
| "property type in primary class">; |
| def err_use_continuation_class_redeclaration_readwrite : Error< |
| "illegal redeclaration of 'readwrite' property in class extension %0" |
| " (perhaps you intended this to be a 'readwrite' redeclaration of a " |
| "'readonly' public property?)">; |
| def err_continuation_class : Error<"class extension has no primary class">; |
| def err_property_type : Error<"property cannot have array or function type %0">; |
| def err_missing_property_context : Error< |
| "missing context for property implementation declaration">; |
| def err_bad_property_decl : Error< |
| "property implementation must have its declaration in interface %0 or one of " |
| "its extensions">; |
| def err_category_property : Error< |
| "property declared in category %0 cannot be implemented in " |
| "class implementation">; |
| def note_property_declare : Note< |
| "property declared here">; |
| def note_protocol_property_declare : Note< |
| "it could also be property " |
| "%select{of type %1|without attribute '%1'|with attribute '%1'|with getter " |
| "%1|with setter %1}0 declared here">; |
| def note_property_synthesize : Note< |
| "property synthesized here">; |
| def err_synthesize_category_decl : Error< |
| "@synthesize not allowed in a category's implementation">; |
| def err_synthesize_on_class_property : Error< |
| "@synthesize not allowed on a class property %0">; |
| def err_missing_property_interface : Error< |
| "property implementation in a category with no category declaration">; |
| def err_bad_category_property_decl : Error< |
| "property implementation must have its declaration in the category %0">; |
| def err_bad_property_context : Error< |
| "property implementation must be in a class or category implementation">; |
| def err_missing_property_ivar_decl : Error< |
| "synthesized property %0 must either be named the same as a compatible" |
| " instance variable or must explicitly name an instance variable">; |
| def err_arc_perform_selector_retains : Error< |
| "performSelector names a selector which retains the object">; |
| def warn_arc_perform_selector_leaks : Warning< |
| "performSelector may cause a leak because its selector is unknown">, |
| InGroup<DiagGroup<"arc-performSelector-leaks">>; |
| def warn_dealloc_in_category : Warning< |
| "-dealloc is being overridden in a category">, |
| InGroup<DeallocInCategory>; |
| def err_gc_weak_property_strong_type : Error< |
| "weak attribute declared on a __strong type property in GC mode">; |
| def warn_arc_repeated_use_of_weak : Warning < |
| "weak %select{variable|property|implicit property|instance variable}0 %1 is " |
| "accessed multiple times in this %select{function|method|block|lambda}2 " |
| "but may be unpredictably set to nil; assign to a strong variable to keep " |
| "the object alive">, |
| InGroup<ARCRepeatedUseOfWeak>, DefaultIgnore; |
| def warn_implicitly_retains_self : Warning < |
| "block implicitly retains 'self'; explicitly mention 'self' to indicate " |
| "this is intended behavior">, |
| InGroup<DiagGroup<"implicit-retain-self">>, DefaultIgnore; |
| def warn_arc_possible_repeated_use_of_weak : Warning < |
| "weak %select{variable|property|implicit property|instance variable}0 %1 may " |
| "be accessed multiple times in this %select{function|method|block|lambda}2 " |
| "and may be unpredictably set to nil; assign to a strong variable to keep " |
| "the object alive">, |
| InGroup<ARCRepeatedUseOfWeakMaybe>, DefaultIgnore; |
| def note_arc_weak_also_accessed_here : Note< |
| "also accessed here">; |
| def err_incomplete_synthesized_property : Error< |
| "cannot synthesize property %0 with incomplete type %1">; |
| |
| def err_property_ivar_type : Error< |
| "type of property %0 (%1) does not match type of instance variable %2 (%3)">; |
| def err_property_accessor_type : Error< |
| "type of property %0 (%1) does not match type of accessor %2 (%3)">; |
| def err_ivar_in_superclass_use : Error< |
| "property %0 attempting to use instance variable %1 declared in super class %2">; |
| def err_weak_property : Error< |
| "existing instance variable %1 for __weak property %0 must be __weak">; |
| def err_strong_property : Error< |
| "existing instance variable %1 for strong property %0 may not be __weak">; |
| def err_dynamic_property_ivar_decl : Error< |
| "dynamic property cannot have instance variable specification">; |
| def err_duplicate_ivar_use : Error< |
| "synthesized properties %0 and %1 both claim instance variable %2">; |
| def err_property_implemented : Error<"property %0 is already implemented">; |
| def warn_objc_missing_super_call : Warning< |
| "method possibly missing a [super %0] call">, |
| InGroup<ObjCMissingSuperCalls>; |
| def err_dealloc_bad_result_type : Error< |
| "dealloc return type must be correctly specified as 'void' under ARC, " |
| "instead of %0">; |
| def warn_undeclared_selector : Warning< |
| "undeclared selector %0">, InGroup<UndeclaredSelector>, DefaultIgnore; |
| def warn_undeclared_selector_with_typo : Warning< |
| "undeclared selector %0; did you mean %1?">, |
| InGroup<UndeclaredSelector>, DefaultIgnore; |
| def warn_implicit_atomic_property : Warning< |
| "property is assumed atomic by default">, InGroup<ImplicitAtomic>, DefaultIgnore; |
| def note_auto_readonly_iboutlet_fixup_suggest : Note< |
| "property should be changed to be readwrite">; |
| def warn_auto_readonly_iboutlet_property : Warning< |
| "readonly IBOutlet property %0 when auto-synthesized may " |
| "not work correctly with 'nib' loader">, |
| InGroup<DiagGroup<"readonly-iboutlet-property">>; |
| def warn_auto_implicit_atomic_property : Warning< |
| "property is assumed atomic when auto-synthesizing the property">, |
| InGroup<ImplicitAtomic>, DefaultIgnore; |
| def warn_unimplemented_selector: Warning< |
| "no method with selector %0 is implemented in this translation unit">, |
| InGroup<Selector>, DefaultIgnore; |
| def warn_unimplemented_protocol_method : Warning< |
| "method %0 in protocol %1 not implemented">, InGroup<Protocol>; |
| def warn_multiple_selectors: Warning< |
| "several methods with selector %0 of mismatched types are found " |
| "for the @selector expression">, |
| InGroup<SelectorTypeMismatch>, DefaultIgnore; |
| |
| def err_objc_kindof_nonobject : Error< |
| "'__kindof' specifier cannot be applied to non-object type %0">; |
| def err_objc_kindof_wrong_position : Error< |
| "'__kindof' type specifier must precede the declarator">; |
| |
| def err_objc_method_unsupported_param_ret_type : Error< |
| "%0 %select{parameter|return}1 type is unsupported; " |
| "support for vector types for this target is introduced in %2">; |
| |
| def warn_messaging_unqualified_id : Warning< |
| "messaging unqualified id">, DefaultIgnore, |
| InGroup<DiagGroup<"objc-messaging-id">>; |
| |
| // C++ declarations |
| def err_static_assert_expression_is_not_constant : Error< |
| "static_assert expression is not an integral constant expression">; |
| def err_static_assert_failed : Error<"static_assert failed%select{ %1|}0">; |
| def err_static_assert_requirement_failed : Error< |
| "static_assert failed due to requirement '%0'%select{ %2|}1">; |
| def ext_static_assert_no_message : ExtWarn< |
| "static_assert with no message is a C++17 extension">, InGroup<CXX17>; |
| def warn_cxx14_compat_static_assert_no_message : Warning< |
| "static_assert with no message is incompatible with C++ standards before C++17">, |
| DefaultIgnore, InGroup<CXXPre17Compat>; |
| |
| def ext_inline_variable : ExtWarn< |
| "inline variables are a C++17 extension">, InGroup<CXX17>; |
| def warn_cxx14_compat_inline_variable : Warning< |
| "inline variables are incompatible with C++ standards before C++17">, |
| DefaultIgnore, InGroup<CXXPre17Compat>; |
| |
| def warn_inline_namespace_reopened_noninline : Warning< |
| "inline namespace reopened as a non-inline namespace">; |
| def err_inline_namespace_mismatch : Error< |
| "non-inline namespace cannot be reopened as inline">; |
| |
| def err_unexpected_friend : Error< |
| "friends can only be classes or functions">; |
| def ext_enum_friend : ExtWarn< |
| "befriending enumeration type %0 is a C++11 extension">, InGroup<CXX11>; |
| def warn_cxx98_compat_enum_friend : Warning< |
| "befriending enumeration type %0 is incompatible with C++98">, |
| InGroup<CXX98Compat>, DefaultIgnore; |
| def ext_nonclass_type_friend : ExtWarn< |
| "non-class friend type %0 is a C++11 extension">, InGroup<CXX11>; |
| def warn_cxx98_compat_nonclass_type_friend : Warning< |
| "non-class friend type %0 is incompatible with C++98">, |
| InGroup<CXX98Compat>, DefaultIgnore; |
| def err_friend_is_member : Error< |
| "friends cannot be members of the declaring class">; |
| def warn_cxx98_compat_friend_is_member : Warning< |
| "friend declaration naming a member of the declaring class is incompatible " |
| "with C++98">, InGroup<CXX98Compat>, DefaultIgnore; |
| def ext_unelaborated_friend_type : ExtWarn< |
| "unelaborated friend declaration is a C++11 extension; specify " |
| "'%select{struct|interface|union|class|enum}0' to befriend %1">, |
| InGroup<CXX11>; |
| def warn_cxx98_compat_unelaborated_friend_type : Warning< |
| "befriending %1 without '%select{struct|interface|union|class|enum}0' " |
| "keyword is incompatible with C++98">, InGroup<CXX98Compat>, DefaultIgnore; |
| def err_qualified_friend_not_found : Error< |
| "no function named %0 with type %1 was found in the specified scope">; |
| def err_introducing_special_friend : Error< |
| "%plural{[0,2]:must use a qualified name when declaring|3:cannot declare}0" |
| " a %select{constructor|destructor|conversion operator|deduction guide}0 " |
| "as a friend">; |
| def err_tagless_friend_type_template : Error< |
| "friend type templates must use an elaborated type">; |
| def err_no_matching_local_friend : Error< |
| "no matching function found in local scope">; |
| def err_no_matching_local_friend_suggest : Error< |
| "no matching function %0 found in local scope; did you mean %3?">; |
| def err_partial_specialization_friend : Error< |
| "partial specialization cannot be declared as a friend">; |
| def err_qualified_friend_def : Error< |
| "friend function definition cannot be qualified with '%0'">; |
| def err_friend_def_in_local_class : Error< |
| "friend function cannot be defined in a local class">; |
| def err_friend_not_first_in_declaration : Error< |
| "'friend' must appear first in a non-function declaration">; |
| def err_using_decl_friend : Error< |
| "cannot befriend target of using declaration">; |
| def warn_template_qualified_friend_unsupported : Warning< |
| "dependent nested name specifier '%0' for friend class declaration is " |
| "not supported; turning off access control for %1">, |
| InGroup<UnsupportedFriend>; |
| def warn_template_qualified_friend_ignored : Warning< |
| "dependent nested name specifier '%0' for friend template declaration is " |
| "not supported; ignoring this friend declaration">, |
| InGroup<UnsupportedFriend>; |
| def ext_friend_tag_redecl_outside_namespace : ExtWarn< |
| "unqualified friend declaration referring to type outside of the nearest " |
| "enclosing namespace is a Microsoft extension; add a nested name specifier">, |
| InGroup<MicrosoftUnqualifiedFriend>; |
| def err_pure_friend : Error<"friend declaration cannot have a pure-specifier">; |
| |
| def err_invalid_member_in_interface : Error< |
| "%select{data member |non-public member function |static member function |" |
| "user-declared constructor|user-declared destructor|operator |" |
| "nested class }0%1 is not permitted within an interface type">; |
| def err_invalid_base_in_interface : Error< |
| "interface type cannot inherit from " |
| "%select{struct|non-public interface|class}0 %1">; |
| |
| def err_abstract_type_in_decl : Error< |
| "%select{return|parameter|variable|field|instance variable|" |
| "synthesized instance variable}0 type %1 is an abstract class">; |
| def err_allocation_of_abstract_type : Error< |
| "allocating an object of abstract class type %0">; |
| def err_throw_abstract_type : Error< |
| "cannot throw an object of abstract type %0">; |
| def err_array_of_abstract_type : Error<"array of abstract class type %0">; |
| def err_capture_of_abstract_type : Error< |
| "by-copy capture of value of abstract type %0">; |
| def err_capture_of_incomplete_type : Error< |
| "by-copy capture of variable %0 with incomplete type %1">; |
| def err_capture_default_non_local : Error< |
| "non-local lambda expression cannot have a capture-default">; |
| |
| def err_multiple_final_overriders : Error< |
| "virtual function %q0 has more than one final overrider in %1">; |
| def note_final_overrider : Note<"final overrider of %q0 in %1">; |
| |
| def err_type_defined_in_type_specifier : Error< |
| "%0 cannot be defined in a type specifier">; |
| def err_type_defined_in_result_type : Error< |
| "%0 cannot be defined in the result type of a function">; |
| def err_type_defined_in_param_type : Error< |
| "%0 cannot be defined in a parameter type">; |
| def err_type_defined_in_alias_template : Error< |
| "%0 cannot be defined in a type alias template">; |
| def err_type_defined_in_condition : Error< |
| "%0 cannot be defined in a condition">; |
| def err_type_defined_in_enum : Error< |
| "%0 cannot be defined in an enumeration">; |
| |
| def note_pure_virtual_function : Note< |
| "unimplemented pure virtual method %0 in %1">; |
| |
| def note_pure_qualified_call_kext : Note< |
| "qualified call to %0::%1 is treated as a virtual call to %1 due to -fapple-kext">; |
| |
| def err_deleted_decl_not_first : Error< |
| "deleted definition must be first declaration">; |
| |
| def err_deleted_override : Error< |
| "deleted function %0 cannot override a non-deleted function">; |
| |
| def err_non_deleted_override : Error< |
| "non-deleted function %0 cannot override a deleted function">; |
| |
| def warn_weak_vtable : Warning< |
| "%0 has no out-of-line virtual method definitions; its vtable will be " |
| "emitted in every translation unit">, |
| InGroup<DiagGroup<"weak-vtables">>, DefaultIgnore; |
| def warn_weak_template_vtable : Warning< |
| "explicit template instantiation %0 will emit a vtable in every " |
| "translation unit">, |
| InGroup<DiagGroup<"weak-template-vtables">>, DefaultIgnore; |
| |
| def ext_using_undefined_std : ExtWarn< |
| "using directive refers to implicitly-defined namespace 'std'">; |
| |
| // C++ exception specifications |
| def err_exception_spec_in_typedef : Error< |
| "exception specifications are not allowed in %select{typedefs|type aliases}0">; |
| def err_distant_exception_spec : Error< |
| "exception specifications are not allowed beyond a single level " |
| "of indirection">; |
| def err_incomplete_in_exception_spec : Error< |
| "%select{|pointer to |reference to }0incomplete type %1 is not allowed " |
| "in exception specification">; |
| def ext_incomplete_in_exception_spec : ExtWarn<err_incomplete_in_exception_spec.Text>, |
| InGroup<MicrosoftExceptionSpec>; |
| def err_rref_in_exception_spec : Error< |
| "rvalue reference type %0 is not allowed in exception specification">; |
| def err_mismatched_exception_spec : Error< |
| "exception specification in declaration does not match previous declaration">; |
| def ext_mismatched_exception_spec : ExtWarn<err_mismatched_exception_spec.Text>, |
| InGroup<MicrosoftExceptionSpec>; |
| def err_override_exception_spec : Error< |
| "exception specification of overriding function is more lax than " |
| "base version">; |
| def ext_override_exception_spec : ExtWarn<err_override_exception_spec.Text>, |
| InGroup<MicrosoftExceptionSpec>; |
| def err_incompatible_exception_specs : Error< |
| "target exception specification is not superset of source">; |
| def warn_incompatible_exception_specs : Warning< |
| err_incompatible_exception_specs.Text>, InGroup<IncompatibleExceptionSpec>; |
| def err_deep_exception_specs_differ : Error< |
| "exception specifications of %select{return|argument}0 types differ">; |
| def warn_deep_exception_specs_differ : Warning< |
| err_deep_exception_specs_differ.Text>, InGroup<IncompatibleExceptionSpec>; |
| def err_missing_exception_specification : Error< |
| "%0 is missing exception specification '%1'">; |
| def ext_missing_exception_specification : ExtWarn< |
| err_missing_exception_specification.Text>, |
| InGroup<DiagGroup<"missing-exception-spec">>; |
| def ext_ms_missing_exception_specification : ExtWarn< |
| err_missing_exception_specification.Text>, |
| InGroup<MicrosoftExceptionSpec>; |
| def err_noexcept_needs_constant_expression : Error< |
| "argument to noexcept specifier must be a constant expression">; |
| def err_exception_spec_not_parsed : Error< |
| "exception specification is not available until end of class definition">; |
| |
| // C++ access checking |
| def err_class_redeclared_with_different_access : Error< |
| "%0 redeclared with '%1' access">; |
| def err_access : Error< |
| "%1 is a %select{private|protected}0 member of %3">, AccessControl; |
| def ext_ms_using_declaration_inaccessible : ExtWarn< |
| "using declaration referring to inaccessible member '%0' (which refers " |
| "to accessible member '%1') is a Microsoft compatibility extension">, |
| AccessControl, InGroup<MicrosoftUsingDecl>; |
| def err_access_ctor : Error< |
| "calling a %select{private|protected}0 constructor of class %2">, |
| AccessControl; |
| def ext_rvalue_to_reference_access_ctor : Extension< |
| "C++98 requires an accessible copy constructor for class %2 when binding " |
| "a reference to a temporary; was %select{private|protected}0">, |
| AccessControl, InGroup<BindToTemporaryCopy>; |
| def err_access_base_ctor : Error< |
| // The ERRORs represent other special members that aren't constructors, in |
| // hopes that someone will bother noticing and reporting if they appear |
| "%select{base class|inherited virtual base class}0 %1 has %select{private|" |
| "protected}3 %select{default |copy |move |*ERROR* |*ERROR* " |
| "|*ERROR*|}2constructor">, AccessControl; |
| def err_access_field_ctor : Error< |
| // The ERRORs represent other special members that aren't constructors, in |
| // hopes that someone will bother noticing and reporting if they appear |
| "field of type %0 has %select{private|protected}2 " |
| "%select{default |copy |move |*ERROR* |*ERROR* |*ERROR* |}1constructor">, |
| AccessControl; |
| def err_access_friend_function : Error< |
| "friend function %1 is a %select{private|protected}0 member of %3">, |
| AccessControl; |
| |
| def err_access_dtor : Error< |
| "calling a %select{private|protected}1 destructor of class %0">, |
| AccessControl; |
| def err_access_dtor_base : |
| Error<"base class %0 has %select{private|protected}1 destructor">, |
| AccessControl; |
| def err_access_dtor_vbase : |
| Error<"inherited virtual base class %1 has " |
| "%select{private|protected}2 destructor">, |
| AccessControl; |
| def err_access_dtor_temp : |
| Error<"temporary of type %0 has %select{private|protected}1 destructor">, |
| AccessControl; |
| def err_access_dtor_exception : |
| Error<"exception object of type %0 has %select{private|protected}1 " |
| "destructor">, AccessControl; |
| def err_access_dtor_field : |
| Error<"field of type %1 has %select{private|protected}2 destructor">, |
| AccessControl; |
| def err_access_dtor_var : |
| Error<"variable of type %1 has %select{private|protected}2 destructor">, |
| AccessControl; |
| def err_access_dtor_ivar : |
| Error<"instance variable of type %0 has %select{private|protected}1 " |
| "destructor">, |
| AccessControl; |
| def note_previous_access_declaration : Note< |
| "previously declared '%1' here">; |
| def note_access_natural : Note< |
| "%select{|implicitly }1declared %select{private|protected}0 here">; |
| def note_access_constrained_by_path : Note< |
| "constrained by %select{|implicitly }1%select{private|protected}0" |
| " inheritance here">; |
| def note_access_protected_restricted_noobject : Note< |
| "must name member using the type of the current context %0">; |
| def note_access_protected_restricted_ctordtor : Note< |
| "protected %select{constructor|destructor}0 can only be used to " |
| "%select{construct|destroy}0 a base class subobject">; |
| def note_access_protected_restricted_object : Note< |
| "can only access this member on an object of type %0">; |
| def warn_cxx98_compat_sfinae_access_control : Warning< |
| "substitution failure due to access control is incompatible with C++98">, |
| InGroup<CXX98Compat>, DefaultIgnore, NoSFINAE; |
| |
| // C++ name lookup |
| def err_incomplete_nested_name_spec : Error< |
| "incomplete type %0 named in nested name specifier">; |
| def err_dependent_nested_name_spec : Error< |
| "nested name specifier for a declaration cannot depend on a template " |
| "parameter">; |
| def err_nested_name_member_ref_lookup_ambiguous : Error< |
| "lookup of %0 in member access expression is ambiguous">; |
| def ext_nested_name_member_ref_lookup_ambiguous : ExtWarn< |
| "lookup of %0 in member access expression is ambiguous; using member of %1">, |
| InGroup<AmbigMemberTemplate>; |
| def note_ambig_member_ref_object_type : Note< |
| "lookup in the object type %0 refers here">; |
| def note_ambig_member_ref_scope : Note< |
| "lookup from the current scope refers here">; |
| def err_qualified_member_nonclass : Error< |
| "qualified member access refers to a member in %0">; |
| def err_incomplete_member_access : Error< |
| "member access into incomplete type %0">; |
| def err_incomplete_type : Error< |
| "incomplete type %0 where a complete type is required">; |
| def warn_cxx98_compat_enum_nested_name_spec : Warning< |
| "enumeration type in nested name specifier is incompatible with C++98">, |
| InGroup<CXX98Compat>, DefaultIgnore; |
| def err_nested_name_spec_is_not_class : Error< |
| "%0 cannot appear before '::' because it is not a class" |
| "%select{ or namespace|, namespace, or enumeration}1; did you mean ':'?">; |
| def ext_nested_name_spec_is_enum : ExtWarn< |
| "use of enumeration in a nested name specifier is a C++11 extension">, |
| InGroup<CXX11>; |
| def err_out_of_line_qualified_id_type_names_constructor : Error< |
| "qualified reference to %0 is a constructor name rather than a " |
| "%select{template name|type}1 in this context">; |
| def ext_out_of_line_qualified_id_type_names_constructor : ExtWarn< |
| "ISO C++ specifies that " |
| "qualified reference to %0 is a constructor name rather than a " |
| "%select{template name|type}1 in this context, despite preceding " |
| "%select{'typename'|'template'}2 keyword">, SFINAEFailure, |
| InGroup<DiagGroup<"injected-class-name">>; |
| |
| // C++ class members |
| def err_storageclass_invalid_for_member : Error< |
| "storage class specified for a member declaration">; |
| def err_mutable_function : Error<"'mutable' cannot be applied to functions">; |
| def err_mutable_reference : Error<"'mutable' cannot be applied to references">; |
| def ext_mutable_reference : ExtWarn< |
| "'mutable' on a reference type is a Microsoft extension">, |
| InGroup<MicrosoftMutableReference>; |
| def err_mutable_const : Error<"'mutable' and 'const' cannot be mixed">; |
| def err_mutable_nonmember : Error< |
| "'mutable' can only be applied to member variables">; |
| def err_virtual_in_union : Error< |
| "unions cannot have virtual functions">; |
| def err_virtual_non_function : Error< |
| "'virtual' can only appear on non-static member functions">; |
| def err_virtual_out_of_class : Error< |
| "'virtual' can only be specified inside the class definition">; |
| def err_virtual_member_function_template : Error< |
| "'virtual' cannot be specified on member function templates">; |
| def err_static_overrides_virtual : Error< |
| "'static' member function %0 overrides a virtual function in a base class">; |
| def err_explicit_non_function : Error< |
| "'explicit' can only appear on non-static member functions">; |
| def err_explicit_out_of_class : Error< |
| "'explicit' can only be specified inside the class definition">; |
| def err_explicit_non_ctor_or_conv_function : Error< |
| "'explicit' can only be applied to a constructor or conversion function">; |
| def err_static_not_bitfield : Error<"static member %0 cannot be a bit-field">; |
| def err_static_out_of_line : Error< |
| "'static' can only be specified inside the class definition">; |
| def err_storage_class_for_static_member : Error< |
| "static data member definition cannot specify a storage class">; |
| def err_typedef_not_bitfield : Error<"typedef member %0 cannot be a bit-field">; |
| def err_not_integral_type_bitfield : Error< |
| "bit-field %0 has non-integral type %1">; |
| def err_not_integral_type_anon_bitfield : Error< |
| "anonymous bit-field has non-integral type %0">; |
| def err_anon_bitfield_qualifiers : Error< |
| "anonymous bit-field cannot have qualifiers">; |
| def err_member_function_initialization : Error< |
| "initializer on function does not look like a pure-specifier">; |
| def err_non_virtual_pure : Error< |
| "%0 is not virtual and cannot be declared pure">; |
| def ext_pure_function_definition : ExtWarn< |
| "function definition with pure-specifier is a Microsoft extension">, |
| InGroup<MicrosoftPureDefinition>; |
| def err_qualified_member_of_unrelated : Error< |
| "%q0 is not a member of class %1">; |
| |
| def err_member_function_call_bad_cvr : Error< |
| "'this' argument to member function %0 has type %1, but function is not marked " |
| "%select{const|restrict|const or restrict|volatile|const or volatile|" |
| "volatile or restrict|const, volatile, or restrict}2">; |
| def err_member_function_call_bad_ref : Error< |
| "'this' argument to member function %0 is an %select{lvalue|rvalue}1, " |
| "but function has %select{non-const lvalue|rvalue}2 ref-qualifier">; |
| def err_member_function_call_bad_type : Error< |
| "cannot initialize object parameter of type %0 with an expression " |
| "of type %1">; |
| |
| def warn_call_to_pure_virtual_member_function_from_ctor_dtor : Warning< |
| "call to pure virtual member function %0 has undefined behavior; " |
| "overrides of %0 in subclasses are not available in the " |
| "%select{constructor|destructor}1 of %2">; |
| |
| def select_special_member_kind : TextSubstitution< |
| "%select{default constructor|copy constructor|move constructor|" |
| "copy assignment operator|move assignment operator|destructor}0">; |
| |
| def note_member_declared_at : Note<"member is declared here">; |
| def note_ivar_decl : Note<"instance variable is declared here">; |
| def note_bitfield_decl : Note<"bit-field is declared here">; |
| def note_implicit_param_decl : Note<"%0 is an implicit parameter">; |
| def note_member_synthesized_at : Note< |
| "in implicit %sub{select_special_member_kind}0 for %1 " |
| "first required here">; |
| def err_missing_default_ctor : Error< |
| "%select{constructor for %1 must explicitly initialize the|" |
| "implicit default constructor for %1 must explicitly initialize the|" |
| "cannot use constructor inherited from base class %4;}0 " |
| "%select{base class|member}2 %3 %select{which|which|of %1}0 " |
| "does not have a default constructor">; |
| def note_due_to_dllexported_class : Note< |
| "due to %0 being dllexported%select{|; try compiling in C++11 mode}1">; |
| |
| def err_illegal_union_or_anon_struct_member : Error< |
| "%select{anonymous struct|union}0 member %1 has a non-trivial " |
| "%sub{select_special_member_kind}2">; |
| def warn_cxx98_compat_nontrivial_union_or_anon_struct_member : Warning< |
| "%select{anonymous struct|union}0 member %1 with a non-trivial " |
| "%sub{select_special_member_kind}2 is incompatible with C++98">, |
| InGroup<CXX98Compat>, DefaultIgnore; |
| |
| def note_nontrivial_virtual_dtor : Note< |
| "destructor for %0 is not trivial because it is virtual">; |
| def note_nontrivial_has_virtual : Note< |
| "because type %0 has a virtual %select{member function|base class}1">; |
| def note_nontrivial_no_def_ctor : Note< |
| "because %select{base class of |field of |}0type %1 has no " |
| "default constructor">; |
| def note_user_declared_ctor : Note< |
| "implicit default constructor suppressed by user-declared constructor">; |
| def note_nontrivial_no_copy : Note< |
| "because no %select{<<ERROR>>|constructor|constructor|assignment operator|" |
| "assignment operator|<<ERROR>>}2 can be used to " |
| "%select{<<ERROR>>|copy|move|copy|move|<<ERROR>>}2 " |
| "%select{base class|field|an object}0 of type %3">; |
| def note_nontrivial_user_provided : Note< |
| "because %select{base class of |field of |}0type %1 has a user-provided " |
| "%sub{select_special_member_kind}2">; |
| def note_nontrivial_in_class_init : Note< |
| "because field %0 has an initializer">; |
| def note_nontrivial_param_type : Note< |
| "because its parameter is %diff{of type $, not $|of the wrong type}2,3">; |
| def note_nontrivial_default_arg : Note<"because it has a default argument">; |
| def note_nontrivial_variadic : Note<"because it is a variadic function">; |
| def note_nontrivial_subobject : Note< |
| "because the function selected to %select{construct|copy|move|copy|move|" |
| "destroy}2 %select{base class|field}0 of type %1 is not trivial">; |
| def note_nontrivial_objc_ownership : Note< |
| "because type %0 has a member with %select{no|no|__strong|__weak|" |
| "__autoreleasing}1 ownership">; |
| |
| def err_static_data_member_not_allowed_in_anon_struct : Error< |
| "static data member %0 not allowed in anonymous struct">; |
| def ext_static_data_member_in_union : ExtWarn< |
| "static data member %0 in union is a C++11 extension">, InGroup<CXX11>; |
| def warn_cxx98_compat_static_data_member_in_union : Warning< |
| "static data member %0 in union is incompatible with C++98">, |
| InGroup<CXX98Compat>, DefaultIgnore; |
| def ext_union_member_of_reference_type : ExtWarn< |
| "union member %0 has reference type %1, which is a Microsoft extension">, |
| InGroup<MicrosoftUnionMemberReference>; |
| def err_union_member_of_reference_type : Error< |
| "union member %0 has reference type %1">; |
| def ext_anonymous_struct_union_qualified : Extension< |
| "anonymous %select{struct|union}0 cannot be '%1'">; |
| def err_different_return_type_for_overriding_virtual_function : Error< |
| "virtual function %0 has a different return type " |
| "%diff{($) than the function it overrides (which has return type $)|" |
| "than the function it overrides}1,2">; |
| def note_overridden_virtual_function : Note< |
| "overridden virtual function is here">; |
| def err_conflicting_overriding_cc_attributes : Error< |
| "virtual function %0 has different calling convention attributes " |
| "%diff{($) than the function it overrides (which has calling convention $)|" |
| "than the function it overrides}1,2">; |
| def warn_overriding_method_missing_noescape : Warning< |
| "parameter of overriding method should be annotated with " |
| "__attribute__((noescape))">, InGroup<MissingNoEscape>; |
| def note_overridden_marked_noescape : Note< |
| "parameter of overridden method is annotated with __attribute__((noescape))">; |
| def note_cat_conform_to_noescape_prot : Note< |
| "%select{category|class extension}0 conforms to protocol %1 which defines method %2">; |
| |
| def err_covariant_return_inaccessible_base : Error< |
| "invalid covariant return for virtual function: %1 is a " |
| "%select{private|protected}2 base class of %0">, AccessControl; |
| def err_covariant_return_ambiguous_derived_to_base_conv : Error< |
| "return type of virtual function %3 is not covariant with the return type of " |
| "the function it overrides (ambiguous conversion from derived class " |
| "%0 to base class %1:%2)">; |
| def err_covariant_return_not_derived : Error< |
| "return type of virtual function %0 is not covariant with the return type of " |
| "the function it overrides (%1 is not derived from %2)">; |
| def err_covariant_return_incomplete : Error< |
| "return type of virtual function %0 is not covariant with the return type of " |
| "the function it overrides (%1 is incomplete)">; |
| def err_covariant_return_type_different_qualifications : Error< |
| "return type of virtual function %0 is not covariant with the return type of " |
| "the function it overrides (%1 has different qualifiers than %2)">; |
| def err_covariant_return_type_class_type_more_qualified : Error< |
| "return type of virtual function %0 is not covariant with the return type of " |
| "the function it overrides (class type %1 is more qualified than class " |
| "type %2">; |
| |
| // C++ implicit special member functions |
| def note_in_declaration_of_implicit_special_member : Note< |
| "while declaring the implicit %sub{select_special_member_kind}1" |
| " for %0">; |
| |
| // C++ constructors |
| def err_constructor_cannot_be : Error<"constructor cannot be declared '%0'">; |
| def err_invalid_qualified_constructor : Error< |
| "'%0' qualifier is not allowed on a constructor">; |
| def err_ref_qualifier_constructor : Error< |
| "ref-qualifier '%select{&&|&}0' is not allowed on a constructor">; |
| |
| def err_constructor_return_type : Error< |
| "constructor cannot have a return type">; |
| def err_constructor_redeclared : Error<"constructor cannot be redeclared">; |
| def err_constructor_byvalue_arg : Error< |
| "copy constructor must pass its first argument by reference">; |
| def warn_no_constructor_for_refconst : Warning< |
| "%select{struct|interface|union|class|enum}0 %1 does not declare any " |
| "constructor to initialize its non-modifiable members">; |
| def note_refconst_member_not_initialized : Note< |
| "%select{const|reference}0 member %1 will never be initialized">; |
| def ext_ms_explicit_constructor_call : ExtWarn< |
| "explicit constructor calls are a Microsoft extension">, |
| InGroup<MicrosoftExplicitConstructorCall>; |
| |
| // C++ destructors |
| def err_destructor_not_member : Error< |
| "destructor must be a non-static member function">; |
| def err_destructor_cannot_be : Error<"destructor cannot be declared '%0'">; |
| def err_invalid_qualified_destructor : Error< |
| "'%0' qualifier is not allowed on a destructor">; |
| def err_ref_qualifier_destructor : Error< |
| "ref-qualifier '%select{&&|&}0' is not allowed on a destructor">; |
| def err_destructor_return_type : Error<"destructor cannot have a return type">; |
| def err_destructor_redeclared : Error<"destructor cannot be redeclared">; |
| def err_destructor_with_params : Error<"destructor cannot have any parameters">; |
| def err_destructor_variadic : Error<"destructor cannot be variadic">; |
| def err_destructor_typedef_name : Error< |
| "destructor cannot be declared using a %select{typedef|type alias}1 %0 of the class name">; |
| def err_destructor_name : Error< |
| "expected the class name after '~' to name the enclosing class">; |
| def err_destructor_class_name : Error< |
| "expected the class name after '~' to name a destructor">; |
| def err_ident_in_dtor_not_a_type : Error< |
| "identifier %0 in object destruction expression does not name a type">; |
| def err_destructor_expr_type_mismatch : Error< |
| "destructor type %0 in object destruction expression does not match the " |
| "type %1 of the object being destroyed">; |
| def note_destructor_type_here : Note< |
| "type %0 is declared here">; |
| |
| def err_destructor_template : Error< |
| "destructor cannot be declared as a template">; |
| |
| // C++ initialization |
| def err_init_conversion_failed : Error< |
| "cannot initialize %select{a variable|a parameter|return object|" |
| "statement expression result|an " |
| "exception object|a member subobject|an array element|a new value|a value|a " |
| "base class|a constructor delegation|a vector element|a block element|a " |
| "block element|a complex element|a lambda capture|a compound literal " |
| "initializer|a related result|a parameter of CF audited function}0 " |
| "%diff{of type $ with an %select{rvalue|lvalue}2 of type $|" |
| "with an %select{rvalue|lvalue}2 of incompatible type}1,3" |
| "%select{|: different classes%diff{ ($ vs $)|}5,6" |
| "|: different number of parameters (%5 vs %6)" |
| "|: type mismatch at %ordinal5 parameter%diff{ ($ vs $)|}6,7" |
| "|: different return type%diff{ ($ vs $)|}5,6" |
| "|: different qualifiers (" |
| "%select{none|const|restrict|const and restrict|volatile|const and volatile|" |
| "volatile and restrict|const, volatile, and restrict}5 vs " |
| "%select{none|const|restrict|const and restrict|volatile|const and volatile|" |
| "volatile and restrict|const, volatile, and restrict}6)" |
| "|: different exception specifications}4">; |
| |
| def err_lvalue_to_rvalue_ref : Error<"rvalue reference %diff{to type $ cannot " |
| "bind to lvalue of type $|cannot bind to incompatible lvalue}0,1">; |
| def err_lvalue_reference_bind_to_initlist : Error< |
| "%select{non-const|volatile}0 lvalue reference to type %1 cannot bind to an " |
| "initializer list temporary">; |
| def err_lvalue_reference_bind_to_temporary : Error< |
| "%select{non-const|volatile}0 lvalue reference %diff{to type $ cannot bind " |
| "to a temporary of type $|cannot bind to incompatible temporary}1,2">; |
| def err_lvalue_reference_bind_to_unrelated : Error< |
| "%select{non-const|volatile}0 lvalue reference " |
| "%diff{to type $ cannot bind to a value of unrelated type $|" |
| "cannot bind to a value of unrelated type}1,2">; |
| def err_reference_bind_drops_quals : Error< |
| "binding value %diff{of type $ to reference to type $|to reference}0,1 " |
| "drops %select{<<ERROR>>|'const'|'restrict'|'const' and 'restrict'|" |
| "'volatile'|'const' and 'volatile'|'restrict' and 'volatile'|" |
| "'const', 'restrict', and 'volatile'}2 qualifier%plural{1:|2:|4:|:s}2">; |
| def err_reference_bind_failed : Error< |
| "reference %diff{to type $ could not bind to an %select{rvalue|lvalue}1 of " |
| "type $|could not bind to %select{rvalue|lvalue}1 of incompatible type}0,2">; |
| def err_reference_bind_init_list : Error< |
| "reference to type %0 cannot bind to an initializer list">; |
| def err_init_list_bad_dest_type : Error< |
| "%select{|non-aggregate }0type %1 cannot be initialized with an initializer " |
| "list">; |
| |
| def err_reference_bind_to_bitfield : Error< |
| "%select{non-const|volatile}0 reference cannot bind to " |
| "bit-field%select{| %1}2">; |
| def err_reference_bind_to_vector_element : Error< |
| "%select{non-const|volatile}0 reference cannot bind to vector element">; |
| def err_reference_var_requires_init : Error< |
| "declaration of reference variable %0 requires an initializer">; |
| def err_reference_without_init : Error< |
| "reference to type %0 requires an initializer">; |
| def note_value_initialization_here : Note< |
| "in value-initialization of type %0 here">; |
| def err_reference_has_multiple_inits : Error< |
| "reference cannot be initialized with multiple values">; |
| def err_init_non_aggr_init_list : Error< |
| "initialization of non-aggregate type %0 with an initializer list">; |
| def err_init_reference_member_uninitialized : Error< |
| "reference member of type %0 uninitialized">; |
| def note_uninit_reference_member : Note< |
| "uninitialized reference member is here">; |
| def warn_field_is_uninit : Warning<"field %0 is uninitialized when used here">, |
| InGroup<Uninitialized>; |
| def warn_base_class_is_uninit : Warning< |
| "base class %0 is uninitialized when used here to access %q1">, |
| InGroup<Uninitialized>; |
| def warn_reference_field_is_uninit : Warning< |
| "reference %0 is not yet bound to a value when used here">, |
| InGroup<Uninitialized>; |
| def note_uninit_in_this_constructor : Note< |
| "during field initialization in %select{this|the implicit default}0 " |
| "constructor">; |
| def warn_static_self_reference_in_init : Warning< |
| "static variable %0 is suspiciously used within its own initialization">, |
| InGroup<UninitializedStaticSelfInit>; |
| def warn_uninit_self_reference_in_init : Warning< |
| "variable %0 is uninitialized when used within its own initialization">, |
| InGroup<Uninitialized>; |
| def warn_uninit_self_reference_in_reference_init : Warning< |
| "reference %0 is not yet bound to a value when used within its own" |
| " initialization">, |
| InGroup<Uninitialized>; |
| def warn_uninit_var : Warning< |
| "variable %0 is uninitialized when %select{used here|captured by block}1">, |
| InGroup<Uninitialized>, DefaultIgnore; |
| def warn_sometimes_uninit_var : Warning< |
| "variable %0 is %select{used|captured}1 uninitialized whenever " |
| "%select{'%3' condition is %select{true|false}4|" |
| "'%3' loop %select{is entered|exits because its condition is false}4|" |
| "'%3' loop %select{condition is true|exits because its condition is false}4|" |
| "switch %3 is taken|" |
| "its declaration is reached|" |
| "%3 is called}2">, |
| InGroup<UninitializedSometimes>, DefaultIgnore; |
| def warn_maybe_uninit_var : Warning< |
| "variable %0 may be uninitialized when " |
| "%select{used here|captured by block}1">, |
| InGroup<UninitializedMaybe>, DefaultIgnore; |
| def note_var_declared_here : Note<"variable %0 is declared here">; |
| def note_uninit_var_use : Note< |
| "%select{uninitialized use occurs|variable is captured by block}0 here">; |
| def warn_uninit_byref_blockvar_captured_by_block : Warning< |
| "block pointer variable %0 is uninitialized when captured by block">, |
| InGroup<Uninitialized>, DefaultIgnore; |
| def note_block_var_fixit_add_initialization : Note< |
| "did you mean to use __block %0?">; |
| def note_in_omitted_aggregate_initializer : Note< |
| "in implicit initialization of %select{" |
| "array element %1 with omitted initializer|" |
| "field %1 with omitted initializer|" |
| "trailing array elements in runtime-sized array new}0">; |
| def note_in_reference_temporary_list_initializer : Note< |
| "in initialization of temporary of type %0 created to " |
| "list-initialize this reference">; |
| def note_var_fixit_add_initialization : Note< |
| "initialize the variable %0 to silence this warning">; |
| def note_uninit_fixit_remove_cond : Note< |
| "remove the %select{'%1' if its condition|condition if it}0 " |
| "is always %select{false|true}2">; |
| def err_init_incomplete_type : Error<"initialization of incomplete type %0">; |
| def err_list_init_in_parens : Error< |
| "cannot initialize %select{non-class|reference}0 type %1 with a " |
| "parenthesized initializer list">; |
| |
| def warn_unsequenced_mod_mod : Warning< |
| "multiple unsequenced modifications to %0">, InGroup<Unsequenced>; |
| def warn_unsequenced_mod_use : Warning< |
| "unsequenced modification and access to %0">, InGroup<Unsequenced>; |
| |
| def select_initialized_entity_kind : TextSubstitution< |
| "%select{copying variable|copying parameter|" |
| "returning object|initializing statement expression result|" |
| "throwing object|copying member subobject|copying array element|" |
| "allocating object|copying temporary|initializing base subobject|" |
| "initializing vector element|capturing value}0">; |
| |
| def err_temp_copy_no_viable : Error< |
| "no viable constructor %sub{select_initialized_entity_kind}0 of type %1">; |
| def ext_rvalue_to_reference_temp_copy_no_viable : Extension< |
| "no viable constructor %sub{select_initialized_entity_kind}0 of type %1; " |
| "C++98 requires a copy constructor when binding a reference to a temporary">, |
| InGroup<BindToTemporaryCopy>; |
| def err_temp_copy_ambiguous : Error< |
| "ambiguous constructor call when %sub{select_initialized_entity_kind}0 " |
| "of type %1">; |
| def err_temp_copy_deleted : Error< |
| "%sub{select_initialized_entity_kind}0 of type %1 " |
| "invokes deleted constructor">; |
| def err_temp_copy_incomplete : Error< |
| "copying a temporary object of incomplete type %0">; |
| def warn_cxx98_compat_temp_copy : Warning< |
| "%sub{select_initialized_entity_kind}1 " |
| "of type %2 when binding a reference to a temporary would %select{invoke " |
| "an inaccessible constructor|find no viable constructor|find ambiguous " |
| "constructors|invoke a deleted constructor}0 in C++98">, |
| InGroup<CXX98CompatBindToTemporaryCopy>, DefaultIgnore; |
| def err_selected_explicit_constructor : Error< |
| "chosen constructor is explicit in copy-initialization">; |
| def note_explicit_ctor_deduction_guide_here : Note< |
| "explicit %select{constructor|deduction guide}0 declared here">; |
| |
| // C++11 decltype |
| def err_decltype_in_declarator : Error< |
| "'decltype' cannot be used to name a declaration">; |
| |
| // C++11 auto |
| def warn_cxx98_compat_auto_type_specifier : Warning< |
| "'auto' type specifier is incompatible with C++98">, |
| InGroup<CXX98Compat>, DefaultIgnore; |
| def err_auto_variable_cannot_appear_in_own_initializer : Error< |
| "variable %0 declared with deduced type %1 " |
| "cannot appear in its own initializer">; |
| def err_binding_cannot_appear_in_own_initializer : Error< |
| "binding %0 cannot appear in the initializer of its own " |
| "decomposition declaration">; |
| def err_illegal_decl_array_of_auto : Error< |
| "'%0' declared as array of %1">; |
| def err_new_array_of_auto : Error< |
| "cannot allocate array of 'auto'">; |
| def err_auto_not_allowed : Error< |
| "%select{'auto'|'decltype(auto)'|'__auto_type'|" |
| "use of " |
| "%select{class template|function template|variable template|alias template|" |
| "template template parameter|template}2 %3 requires template arguments; " |
| "argument deduction}0 not allowed " |
| "%select{in function prototype" |
| "|in non-static struct member|in struct member" |
| "|in non-static union member|in union member" |
| "|in non-static class member|in interface member" |
| "|in exception declaration|in template parameter until C++17|in block literal" |
| "|in template argument|in typedef|in type alias|in function return type" |
| "|in conversion function type|here|in lambda parameter" |
| "|in type allocated by 'new'|in K&R-style function parameter" |
| "|in template parameter|in friend declaration}1">; |
| def err_dependent_deduced_tst : Error< |
| "typename specifier refers to " |
| "%select{class template|function template|variable template|alias template|" |
| "template template parameter|template}0 member in %1; " |
| "argument deduction not allowed here">; |
| def err_auto_not_allowed_var_inst : Error< |
| "'auto' variable template instantiation is not allowed">; |
| def err_auto_var_requires_init : Error< |
| "declaration of variable %0 with deduced type %1 requires an initializer">; |
| def err_auto_new_requires_ctor_arg : Error< |
| "new expression for type %0 requires a constructor argument">; |
| def ext_auto_new_list_init : Extension< |
| "ISO C++ standards before C++17 do not allow new expression for " |
| "type %0 to use list-initialization">, InGroup<CXX17>; |
| def err_auto_var_init_no_expression : Error< |
| "initializer for variable %0 with type %1 is empty">; |
| def err_auto_var_init_multiple_expressions : Error< |
| "initializer for variable %0 with type %1 contains multiple expressions">; |
| def err_auto_var_init_paren_braces : Error< |
| "cannot deduce type for variable %1 with type %2 from " |
| "%select{parenthesized|nested}0 initializer list">; |
| def err_auto_new_ctor_multiple_expressions : Error< |
| "new expression for type %0 contains multiple constructor arguments">; |
| def err_auto_missing_trailing_return : Error< |
| "'auto' return without trailing return type; deduced return types are a " |
| "C++14 extension">; |
| def err_deduced_return_type : Error< |
| "deduced return types are a C++14 extension">; |
| def err_trailing_return_without_auto : Error< |
| "function with trailing return type must specify return type 'auto', not %0">; |
| def err_trailing_return_in_parens : Error< |
| "trailing return type may not be nested within parentheses">; |
| def err_auto_var_deduction_failure : Error< |
| "variable %0 with type %1 has incompatible initializer of type %2">; |
| def err_auto_var_deduction_failure_from_init_list : Error< |
| "cannot deduce actual type for variable %0 with type %1 from initializer list">; |
| def err_auto_new_deduction_failure : Error< |
| "new expression for type %0 has incompatible constructor argument of type %1">; |
| def err_auto_inconsistent_deduction : Error< |
| "deduced conflicting types %diff{($ vs $) |}0,1" |
| "for initializer list element type">; |
| def err_auto_different_deductions : Error< |
| "%select{'auto'|'decltype(auto)'|'__auto_type'|template arguments}0 " |
| "deduced as %1 in declaration of %2 and " |
| "deduced as %3 in declaration of %4">; |
| def err_auto_non_deduced_not_alone : Error< |
| "%select{function with deduced return type|" |
| "declaration with trailing return type}0 " |
| "must be the only declaration in its group">; |
| def err_implied_std_initializer_list_not_found : Error< |
| "cannot deduce type of initializer list because std::initializer_list was " |
| "not found; include <initializer_list>">; |
| def err_malformed_std_initializer_list : Error< |
| "std::initializer_list must be a class template with a single type parameter">; |
| def err_auto_init_list_from_c : Error< |
| "cannot use __auto_type with initializer list in C">; |
| def err_auto_bitfield : Error< |
| "cannot pass bit-field as __auto_type initializer in C">; |
| |
| // C++1y decltype(auto) type |
| def err_decltype_auto_invalid : Error< |
| "'decltype(auto)' not allowed here">; |
| def err_decltype_auto_cannot_be_combined : Error< |
| "'decltype(auto)' cannot be combined with other type specifiers">; |
| def err_decltype_auto_function_declarator_not_declaration : Error< |
| "'decltype(auto)' can only be used as a return type " |
| "in a function declaration">; |
| def err_decltype_auto_compound_type : Error< |
| "cannot form %select{pointer to|reference to|array of}0 'decltype(auto)'">; |
| def err_decltype_auto_initializer_list : Error< |
| "cannot deduce 'decltype(auto)' from initializer list">; |
| |
| // C++17 deduced class template specialization types |
| def err_deduced_class_template_compound_type : Error< |
| "cannot %select{form pointer to|form reference to|form array of|" |
| "form function returning|use parentheses when declaring variable with}0 " |
| "deduced class template specialization type">; |
| def err_deduced_non_class_template_specialization_type : Error< |
| "%select{<error>|function template|variable template|alias template|" |
| "template template parameter|template}0 %1 requires template arguments; " |
| "argument deduction only allowed for class templates">; |
| def err_deduced_class_template_ctor_ambiguous : Error< |
| "ambiguous deduction for template arguments of %0">; |
| def err_deduced_class_template_ctor_no_viable : Error< |
| "no viable constructor or deduction guide for deduction of " |
| "template arguments of %0">; |
| def err_deduced_class_template_incomplete : Error< |
| "template %0 has no definition and no %select{|viable }1deduction guides " |
| "for deduction of template arguments">; |
| def err_deduced_class_template_deleted : Error< |
| "class template argument deduction for %0 selected a deleted constructor">; |
| def err_deduced_class_template_explicit : Error< |
| "class template argument deduction for %0 selected an explicit " |
| "%select{constructor|deduction guide}1 for copy-list-initialization">; |
| def err_deduction_guide_no_trailing_return_type : Error< |
| "deduction guide declaration without trailing return type">; |
| def err_deduction_guide_bad_trailing_return_type : Error< |
| "deduced type %1 of deduction guide is not %select{|written as }2" |
| "a specialization of template %0">; |
| def err_deduction_guide_with_complex_decl : Error< |
| "cannot specify any part of a return type in the " |
| "declaration of a deduction guide">; |
| def err_deduction_guide_invalid_specifier : Error< |
| "deduction guide cannot be declared '%0'">; |
| def err_deduction_guide_name_not_class_template : Error< |
| "cannot specify deduction guide for " |
| "%select{<error>|function template|variable template|alias template|" |
| "template template parameter|dependent template name}0 %1">; |
| def err_deduction_guide_wrong_scope : Error< |
| "deduction guide must be declared in the same scope as template %q0">; |
| def err_deduction_guide_defines_function : Error< |
| "deduction guide cannot have a function definition">; |
| def err_deduction_guide_explicit_mismatch : Error< |
| "deduction guide is %select{not |}0declared 'explicit' but " |
| "previous declaration was%select{ not|}0">; |
| def err_deduction_guide_specialized : Error<"deduction guide cannot be " |
| "%select{explicitly instantiated|explicitly specialized}0">; |
| def err_deduction_guide_template_not_deducible : Error< |
| "deduction guide template contains " |
| "%select{a template parameter|template parameters}0 that cannot be " |
| "deduced">; |
| def err_deduction_guide_wrong_access : Error< |
| "deduction guide has different access from the corresponding " |
| "member template">; |
| def note_deduction_guide_template_access : Note< |
| "member template declared %0 here">; |
| def note_deduction_guide_access : Note< |
| "deduction guide declared %0 by intervening access specifier">; |
| |
| // C++1y deduced return types |
| def err_auto_fn_deduction_failure : Error< |
| "cannot deduce return type %0 from returned value of type %1">; |
| def err_auto_fn_different_deductions : Error< |
| "'%select{auto|decltype(auto)}0' in return type deduced as %1 here but " |
| "deduced as %2 in earlier return statement">; |
| def err_auto_fn_used_before_defined : Error< |
| "function %0 with deduced return type cannot be used before it is defined">; |
| def err_auto_fn_no_return_but_not_auto : Error< |
| "cannot deduce return type %0 for function with no return statements">; |
| def err_auto_fn_return_void_but_not_auto : Error< |
| "cannot deduce return type %0 from omitted return expression">; |
| def err_auto_fn_return_init_list : Error< |
| "cannot deduce return type from initializer list">; |
| def err_auto_fn_virtual : Error< |
| "function with deduced return type cannot be virtual">; |
| |
| // C++11 override control |
| def override_keyword_only_allowed_on_virtual_member_functions : Error< |
| "only virtual member functions can be marked '%0'">; |
| def override_keyword_hides_virtual_member_function : Error< |
| "non-virtual member function marked '%0' hides virtual member " |
| "%select{function|functions}1">; |
| def err_function_marked_override_not_overriding : Error< |
| "%0 marked 'override' but does not override any member functions">; |
| def warn_destructor_marked_not_override_overriding : Warning < |
| "%0 overrides a destructor but is not marked 'override'">, |
| InGroup<CXX11WarnOverrideDestructor>, DefaultIgnore; |
| def warn_function_marked_not_override_overriding : Warning < |
| "%0 overrides a member function but is not marked 'override'">, |
| InGroup<CXX11WarnOverrideMethod>; |
| def err_class_marked_final_used_as_base : Error< |
| "base %0 is marked '%select{final|sealed}1'">; |
| def warn_abstract_final_class : Warning< |
| "abstract class is marked '%select{final|sealed}0'">, InGroup<AbstractFinalClass>; |
| |
| // C++11 attributes |
| def err_repeat_attribute : Error<"%0 attribute cannot be repeated">; |
| |
| // C++11 final |
| def err_final_function_overridden : Error< |
| "declaration of %0 overrides a '%select{final|sealed}1' function">; |
| |
| // C++11 scoped enumerations |
| def err_enum_invalid_underlying : Error< |
| "non-integral type %0 is an invalid underlying type">; |
| def err_enumerator_too_large : Error< |
| "enumerator value is not representable in the underlying type %0">; |
| def ext_enumerator_too_large : Extension< |
| "enumerator value is not representable in the underlying type %0">, |
| InGroup<MicrosoftEnumValue>; |
| def err_enumerator_wrapped : Error< |
| "enumerator value %0 is not representable in the underlying type %1">; |
| def err_enum_redeclare_type_mismatch : Error< |
| "enumeration redeclared with different underlying type %0 (was %1)">; |
| def err_enum_redeclare_fixed_mismatch : Error< |
| "enumeration previously declared with %select{non|}0fixed underlying type">; |
| def err_enum_redeclare_scoped_mismatch : Error< |
| "enumeration previously declared as %select{un|}0scoped">; |
| def err_enum_class_reference : Error< |
| "reference to %select{|scoped }0enumeration must use 'enum' " |
| "not 'enum class'">; |
| def err_only_enums_have_underlying_types : Error< |
| "only enumeration types have underlying types">; |
| def err_underlying_type_of_incomplete_enum : Error< |
| "cannot determine underlying type of incomplete enumeration type %0">; |
| |
| // C++11 delegating constructors |
| def err_delegating_ctor : Error< |
| "delegating constructors are permitted only in C++11">; |
| def warn_cxx98_compat_delegating_ctor : Warning< |
| "delegating constructors are incompatible with C++98">, |
| InGroup<CXX98Compat>, DefaultIgnore; |
| def err_delegating_initializer_alone : Error< |
| "an initializer for a delegating constructor must appear alone">; |
| def warn_delegating_ctor_cycle : Warning< |
| "constructor for %0 creates a delegation cycle">, DefaultError, |
| InGroup<DelegatingCtorCycles>; |
| def note_it_delegates_to : Note<"it delegates to">; |
| def note_which_delegates_to : Note<"which delegates to">; |
| |
| // C++11 range-based for loop |
| def err_for_range_decl_must_be_var : Error< |
| "for range declaration must declare a variable">; |
| def err_for_range_storage_class : Error< |
| "loop variable %0 may not be declared %select{'extern'|'static'|" |
| "'__private_extern__'|'auto'|'register'|'constexpr'}1">; |
| def err_type_defined_in_for_range : Error< |
| "types may not be defined in a for range declaration">; |
| def err_for_range_deduction_failure : Error< |
| "cannot use type %0 as a range">; |
| def err_for_range_incomplete_type : Error< |
| "cannot use incomplete type %0 as a range">; |
| def err_for_range_iter_deduction_failure : Error< |
| "cannot use type %0 as an iterator">; |
| def err_for_range_member_begin_end_mismatch : Error< |
| "range type %0 has '%select{begin|end}1' member but no '%select{end|begin}1' member">; |
| def ext_for_range_begin_end_types_differ : ExtWarn< |
| "'begin' and 'end' returning different types (%0 and %1) is a C++17 extension">, |
| InGroup<CXX17>; |
| def warn_for_range_begin_end_types_differ : Warning< |
| "'begin' and 'end' returning different types (%0 and %1) is incompatible " |
| "with C++ standards before C++17">, InGroup<CXXPre17Compat>, DefaultIgnore; |
| def note_in_for_range: Note< |
| "when looking up '%select{begin|end}0' function for range expression " |
| "of type %1">; |
| def err_for_range_invalid: Error< |
| "invalid range expression of type %0; no viable '%select{begin|end}1' " |
| "function available">; |
| def err_range_on_array_parameter : Error< |
| "cannot build range expression with array function parameter %0 since " |
| "parameter with array type %1 is treated as pointer type %2">; |
| def err_for_range_dereference : Error< |
| "invalid range expression of type %0; did you mean to dereference it " |
| "with '*'?">; |
| def note_for_range_invalid_iterator : Note < |
| "in implicit call to 'operator%select{!=|*|++}0' for iterator of type %1">; |
| def note_for_range_begin_end : Note< |
| "selected '%select{begin|end}0' %select{function|template }1%2 with iterator type %3">; |
| def warn_for_range_const_reference_copy : Warning< |
| "loop variable %0 " |
| "%diff{has type $ but is initialized with type $" |
| "| is initialized with a value of a different type}1,2 resulting in a copy">, |
| InGroup<RangeLoopAnalysis>, DefaultIgnore; |
| def note_use_type_or_non_reference : Note< |
| "use non-reference type %0 to keep the copy or type %1 to prevent copying">; |
| def warn_for_range_variable_always_copy : Warning< |
| "loop variable %0 is always a copy because the range of type %1 does not " |
| "return a reference">, |
| InGroup<RangeLoopAnalysis>, DefaultIgnore; |
| def note_use_non_reference_type : Note<"use non-reference type %0">; |
| def warn_for_range_copy : Warning< |
| "loop variable %0 of type %1 creates a copy from type %2">, |
| InGroup<RangeLoopAnalysis>, DefaultIgnore; |
| def note_use_reference_type : Note<"use reference type %0 to prevent copying">; |
| |
| // C++11 constexpr |
| def warn_cxx98_compat_constexpr : Warning< |
| "'constexpr' specifier is incompatible with C++98">, |
| InGroup<CXX98Compat>, DefaultIgnore; |
| // FIXME: Maybe this should also go in -Wc++14-compat? |
| def warn_cxx14_compat_constexpr_not_const : Warning< |
| "'constexpr' non-static member function will not be implicitly 'const' " |
| "in C++14; add 'const' to avoid a change in behavior">, |
| InGroup<DiagGroup<"constexpr-not-const">>; |
| def err_invalid_constexpr : Error< |
| "%select{function parameter|typedef|non-static data member}0 " |
| "cannot be constexpr">; |
| def err_invalid_constexpr_member : Error<"non-static data member cannot be " |
| "constexpr%select{; did you intend to make it %select{const|static}0?|}1">; |
| def err_constexpr_tag : Error< |
| "%select{class|struct|interface|union|enum}0 cannot be marked constexpr">; |
| def err_constexpr_dtor : Error<"destructor cannot be marked constexpr">; |
| def err_constexpr_no_declarators : Error< |
| "constexpr can only be used in variable and function declarations">; |
| def err_invalid_constexpr_var_decl : Error< |
| "constexpr variable declaration must be a definition">; |
| def err_constexpr_static_mem_var_requires_init : Error< |
| "declaration of constexpr static data member %0 requires an initializer">; |
| def err_constexpr_var_non_literal : Error< |
| "constexpr variable cannot have non-literal type %0">; |
| def err_constexpr_var_requires_const_init : Error< |
| "constexpr variable %0 must be initialized by a constant expression">; |
| def err_constexpr_redecl_mismatch : Error< |
| "%select{non-constexpr declaration of %0 follows constexpr declaration" |
| "|constexpr declaration of %0 follows non-constexpr declaration}1">; |
| def err_constexpr_virtual : Error<"virtual function cannot be constexpr">; |
| def err_constexpr_virtual_base : Error< |
| "constexpr %select{member function|constructor}0 not allowed in " |
| "%select{struct|interface|class}1 with virtual base " |
| "%plural{1:class|:classes}2">; |
| def note_non_literal_incomplete : Note< |
| "incomplete type %0 is not a literal type">; |
| def note_non_literal_virtual_base : Note<"%select{struct|interface|class}0 " |
| "with virtual base %plural{1:class|:classes}1 is not a literal type">; |
| def note_constexpr_virtual_base_here : Note<"virtual base class declared here">; |
| def err_constexpr_non_literal_return : Error< |
| "constexpr function's return type %0 is not a literal type">; |
| def err_constexpr_non_literal_param : Error< |
| "constexpr %select{function|constructor}1's %ordinal0 parameter type %2 is " |
| "not a literal type">; |
| def err_constexpr_body_invalid_stmt : Error< |
| "statement not allowed in constexpr %select{function|constructor}0">; |
| def ext_constexpr_body_invalid_stmt : ExtWarn< |
| "use of this statement in a constexpr %select{function|constructor}0 " |
| "is a C++14 extension">, InGroup<CXX14>; |
| def warn_cxx11_compat_constexpr_body_invalid_stmt : Warning< |
| "use of this statement in a constexpr %select{function|constructor}0 " |
| "is incompatible with C++ standards before C++14">, |
| InGroup<CXXPre14Compat>, DefaultIgnore; |
| def ext_constexpr_type_definition : ExtWarn< |
| "type definition in a constexpr %select{function|constructor}0 " |
| "is a C++14 extension">, InGroup<CXX14>; |
| def warn_cxx11_compat_constexpr_type_definition : Warning< |
| "type definition in a constexpr %select{function|constructor}0 " |
| "is incompatible with C++ standards before C++14">, |
| InGroup<CXXPre14Compat>, DefaultIgnore; |
| def err_constexpr_vla : Error< |
| "variably-modified type %0 cannot be used in a constexpr " |
| "%select{function|constructor}1">; |
| def ext_constexpr_local_var : ExtWarn< |
| "variable declaration in a constexpr %select{function|constructor}0 " |
| "is a C++14 extension">, InGroup<CXX14>; |
| def warn_cxx11_compat_constexpr_local_var : Warning< |
| "variable declaration in a constexpr %select{function|constructor}0 " |
| "is incompatible with C++ standards before C++14">, |
| InGroup<CXXPre14Compat>, DefaultIgnore; |
| def err_constexpr_local_var_static : Error< |
| "%select{static|thread_local}1 variable not permitted in a constexpr " |
| "%select{function|constructor}0">; |
| def err_constexpr_local_var_non_literal_type : Error< |
| "variable of non-literal type %1 cannot be defined in a constexpr " |
| "%select{function|constructor}0">; |
| def err_constexpr_local_var_no_init : Error< |
| "variables defined in a constexpr %select{function|constructor}0 must be " |
| "initialized">; |
| def ext_constexpr_function_never_constant_expr : ExtWarn< |
| "constexpr %select{function|constructor}0 never produces a " |
| "constant expression">, InGroup<DiagGroup<"invalid-constexpr">>, DefaultError; |
| def err_attr_cond_never_constant_expr : Error< |
| "%0 attribute expression never produces a constant expression">; |
| def err_diagnose_if_invalid_diagnostic_type : Error< |
| "invalid diagnostic type for 'diagnose_if'; use \"error\" or \"warning\" " |
| "instead">; |
| def err_constexpr_body_no_return : Error< |
| "no return statement in constexpr function">; |
| def err_constexpr_return_missing_expr : Error< |
| "non-void constexpr function %0 should return a value">; |
| def warn_cxx11_compat_constexpr_body_no_return : Warning< |
| "constexpr function with no return statements is incompatible with C++ " |
| "standards before C++14">, InGroup<CXXPre14Compat>, DefaultIgnore; |
| def ext_constexpr_body_multiple_return : ExtWarn< |
| "multiple return statements in constexpr function is a C++14 extension">, |
| InGroup<CXX14>; |
| def warn_cxx11_compat_constexpr_body_multiple_return : Warning< |
| "multiple return statements in constexpr function " |
| "is incompatible with C++ standards before C++14">, |
| InGroup<CXXPre14Compat>, DefaultIgnore; |
| def note_constexpr_body_previous_return : Note< |
| "previous return statement is here">; |
| def err_constexpr_function_try_block : Error< |
| "function try block not allowed in constexpr %select{function|constructor}0">; |
| def err_constexpr_union_ctor_no_init : Error< |
| "constexpr union constructor does not initialize any member">; |
| def err_constexpr_ctor_missing_init : Error< |
| "constexpr constructor must initialize all members">; |
| def note_constexpr_ctor_missing_init : Note< |
| "member not initialized by constructor">; |
| def note_non_literal_no_constexpr_ctors : Note< |
| "%0 is not literal because it is not an aggregate and has no constexpr " |
| "constructors other than copy or move constructors">; |
| def note_non_literal_base_class : Note< |
| "%0 is not literal because it has base class %1 of non-literal type">; |
| def note_non_literal_field : Note< |
| "%0 is not literal because it has data member %1 of " |
| "%select{non-literal|volatile}3 type %2">; |
| def note_non_literal_user_provided_dtor : Note< |
| "%0 is not literal because it has a user-provided destructor">; |
| def note_non_literal_nontrivial_dtor : Note< |
| "%0 is not literal because it has a non-trivial destructor">; |
| def note_non_literal_lambda : Note< |
| "lambda closure types are non-literal types before C++17">; |
| def warn_private_extern : Warning< |
| "use of __private_extern__ on a declaration may not produce external symbol " |
| "private to the linkage unit and is deprecated">, InGroup<PrivateExtern>; |
| def note_private_extern : Note< |
| "use __attribute__((visibility(\"hidden\"))) attribute instead">; |
| |
| // C++ Concepts TS |
| def err_concept_wrong_decl_kind : Error< |
| "'concept' can only appear on the definition of a function template or variable template">; |
| def err_concept_decls_may_only_appear_in_namespace_scope : Error< |
| "concept declarations may only appear in namespace scope">; |
| def err_function_concept_not_defined : Error< |
| "function concept declaration must be a definition">; |
| def err_var_concept_not_initialized : Error< |
| "variable concept declaration must be initialized">; |
| def err_function_concept_exception_spec : Error< |
| "function concept cannot have exception specification">; |
| def err_concept_decl_invalid_specifiers : Error< |
| "%select{variable|function}0 concept cannot be declared " |
| "'%select{thread_local|inline|friend|constexpr}1'">; |
| def err_function_concept_with_params : Error< |
| "function concept cannot have any parameters">; |
| def err_function_concept_bool_ret : Error< |
| "declared return type of function concept must be 'bool'">; |
| def err_variable_concept_bool_decl : Error< |
| "declared type of variable concept must be 'bool'">; |
| def err_concept_specified_specialization : Error< |
| "'concept' cannot be applied on an " |
| "%select{explicit instantiation|explicit specialization|partial specialization}0">; |
| def err_concept_specialized : Error< |
| "%select{function|variable}0 concept cannot be " |
| "%select{explicitly instantiated|explicitly specialized|partially specialized}1">; |
| |
| def err_template_different_associated_constraints : Error< |
| "associated constraints differ in template redeclaration">; |
| |
| // C++11 char16_t/char32_t |
| def warn_cxx98_compat_unicode_type : Warning< |
| "'%0' type specifier is incompatible with C++98">, |
| InGroup<CXX98Compat>, DefaultIgnore; |
| def warn_cxx17_compat_unicode_type : Warning< |
| "'char8_t' type specifier is incompatible with C++ standards before C++20">, |
| InGroup<CXXPre2aCompat>, DefaultIgnore; |
| |
| // __make_integer_seq |
| def err_integer_sequence_negative_length : Error< |
| "integer sequences must have non-negative sequence length">; |
| def err_integer_sequence_integral_element_type : Error< |
| "integer sequences must have integral element type">; |
| |
| // __type_pack_element |
| def err_type_pack_element_out_of_bounds : Error< |
| "a parameter pack may not be accessed at an out of bounds index">; |
| |
| // Objective-C++ |
| def err_objc_decls_may_only_appear_in_global_scope : Error< |
| "Objective-C declarations may only appear in global scope">; |
| def warn_auto_var_is_id : Warning< |
| "'auto' deduced as 'id' in declaration of %0">, |
| InGroup<DiagGroup<"auto-var-id">>; |
| |
| // Attributes |
| def err_nsobject_attribute : Error< |
| "'NSObject' attribute is for pointer types only">; |
| def err_attributes_are_not_compatible : Error< |
| "%0 and %1 attributes are not compatible">; |
| def err_attribute_wrong_number_arguments : Error< |
| "%0 attribute %plural{0:takes no arguments|1:takes one argument|" |
| ":requires exactly %1 arguments}1">; |
| def err_attribute_too_many_arguments : Error< |
| "%0 attribute takes no more than %1 argument%s1">; |
| def err_attribute_too_few_arguments : Error< |
| "%0 attribute takes at least %1 argument%s1">; |
| def err_attribute_invalid_vector_type : Error<"invalid vector element type %0">; |
| def err_attribute_bad_neon_vector_size : Error< |
| "Neon vector size must be 64 or 128 bits">; |
| def err_attribute_requires_positive_integer : Error< |
| "%0 attribute requires a positive integral compile time constant expression">; |
| def err_attribute_requires_opencl_version : Error< |
| "%0 attribute requires OpenCL version %1%select{| or above}2">; |
| def warn_unsupported_target_attribute |
| : Warning<"%select{unsupported|duplicate}0%select{| architecture}1 '%2' in" |
| " the 'target' attribute string; 'target' attribute ignored">, |
| InGroup<IgnoredAttributes>; |
| def err_attribute_unsupported |
| : Error<"%0 attribute is not supported for this target">; |
| // The err_*_attribute_argument_not_int are separate because they're used by |
| // VerifyIntegerConstantExpression. |
| def err_aligned_attribute_argument_not_int : Error< |
| "'aligned' attribute requires integer constant">; |
| def err_align_value_attribute_argument_not_int : Error< |
| "'align_value' attribute requires integer constant">; |
| def err_alignas_attribute_wrong_decl_type : Error< |
| "%0 attribute cannot be applied to a %select{function parameter|" |
| "variable with 'register' storage class|'catch' variable|bit-field}1">; |
| def err_alignas_missing_on_definition : Error< |
| "%0 must be specified on definition if it is specified on any declaration">; |
| def note_alignas_on_declaration : Note<"declared with %0 attribute here">; |
| def err_alignas_mismatch : Error< |
| "redeclaration has different alignment requirement (%1 vs %0)">; |
| def err_alignas_underaligned : Error< |
| "requested alignment is less than minimum alignment of %1 for type %0">; |
| def err_attribute_argument_n_type : Error< |
| "%0 attribute requires parameter %1 to be %select{int or bool|an integer " |
| "constant|a string|an identifier}2">; |
| def err_attribute_argument_type : Error< |
| "%0 attribute requires %select{int or bool|an integer " |
| "constant|a string|an identifier}1">; |
| def err_attribute_argument_outof_range : Error< |
| "%0 attribute requires integer constant between %1 and %2 inclusive">; |
| def err_init_priority_object_attr : Error< |
| "can only use 'init_priority' attribute on file-scope definitions " |
| "of objects of class type">; |
| def err_attribute_argument_vec_type_hint : Error< |
| "invalid attribute argument %0 - expecting a vector or vectorizable scalar type">; |
| def err_attribute_argument_out_of_bounds : Error< |
| "%0 attribute parameter %1 is out of bounds">; |
| def err_attribute_only_once_per_parameter : Error< |
| "%0 attribute can only be applied once per parameter">; |
| def err_attribute_uuid_malformed_guid : Error< |
| "uuid attribute contains a malformed GUID">; |
| def err_mismatched_uuid : Error<"uuid does not match previous declaration">; |
| def note_previous_uuid : Note<"previous uuid specified here">; |
| def warn_attribute_pointers_only : Warning< |
| "%0 attribute only applies to%select{| constant}1 pointer arguments">, |
| InGroup<IgnoredAttributes>; |
| def err_attribute_pointers_only : Error<warn_attribute_pointers_only.Text>; |
| def err_attribute_integers_only : Error< |
| "%0 attribute argument may only refer to a function parameter of integer " |
| "type">; |
| def warn_attribute_return_pointers_only : Warning< |
| "%0 attribute only applies to return values that are pointers">, |
| InGroup<IgnoredAttributes>; |
| def warn_attribute_return_pointers_refs_only : Warning< |
| "%0 attribute only applies to return values that are pointers or references">, |
| InGroup<IgnoredAttributes>; |
| def warn_attribute_pointer_or_reference_only : Warning< |
| "%0 attribute only applies to a pointer or reference (%1 is invalid)">, |
| InGroup<IgnoredAttributes>; |
| def err_attribute_no_member_pointers : Error< |
| "%0 attribute cannot be used with pointers to members">; |
| def err_attribute_invalid_implicit_this_argument : Error< |
| "%0 attribute is invalid for the implicit this argument">; |
| def err_ownership_type : Error< |
| "%0 attribute only applies to %select{pointer|integer}1 arguments">; |
| def err_ownership_returns_index_mismatch : Error< |
| "'ownership_returns' attribute index does not match; here it is %0">; |
| def note_ownership_returns_index_mismatch : Note< |
| "declared with index %0 here">; |
| def err_format_strftime_third_parameter : Error< |
| "strftime format attribute requires 3rd parameter to be 0">; |
| def err_format_attribute_requires_variadic : Error< |
| "format attribute requires variadic function">; |
| def err_format_attribute_not : Error<"format argument not %0">; |
| def err_format_attribute_result_not : Error<"function does not return %0">; |
| def err_format_attribute_implicit_this_format_string : Error< |
| "format attribute cannot specify the implicit this argument as the format " |
| "string">; |
| def err_init_method_bad_return_type : Error< |
| "init methods must return an object pointer type, not %0">; |
| def err_attribute_invalid_size : Error< |
| "vector size not an integral multiple of component size">; |
| def err_attribute_zero_size : Error<"zero vector size">; |
| def err_attribute_size_too_large : Error<"vector size too large">; |
| def err_typecheck_vector_not_convertable_implict_truncation : Error< |
| "cannot convert between %select{scalar|vector}0 type %1 and vector type" |
| " %2 as implicit conversion would cause truncation">; |
| def err_typecheck_vector_not_convertable : Error< |
| "cannot convert between vector values of different size (%0 and %1)">; |
| def err_typecheck_vector_not_convertable_non_scalar : Error< |
| "cannot convert between vector and non-scalar values (%0 and %1)">; |
| def err_typecheck_vector_lengths_not_equal : Error< |
| "vector operands do not have the same number of elements (%0 and %1)">; |
| def warn_typecheck_vector_element_sizes_not_equal : Warning< |
| "vector operands do not have the same elements sizes (%0 and %1)">, |
| InGroup<DiagGroup<"vec-elem-size">>, DefaultError; |
| def err_ext_vector_component_exceeds_length : Error< |
| "vector component access exceeds type %0">; |
| def err_ext_vector_component_name_illegal : Error< |
| "illegal vector component name '%0'">; |
| def err_attribute_address_space_negative : Error< |
| "address space is negative">; |
| def err_attribute_address_space_too_high : Error< |
| "address space is larger than the maximum supported (%0)">; |
| def err_attribute_address_multiple_qualifiers : Error< |
| "multiple address spaces specified for type">; |
| def warn_attribute_address_multiple_identical_qualifiers : Warning< |
| "multiple identical address spaces specified for type">, |
| InGroup<DuplicateDeclSpecifier>; |
| def err_attribute_address_function_type : Error< |
| "function type may not be qualified with an address space">; |
| def err_as_qualified_auto_decl : Error< |
| "automatic variable qualified with an%select{| invalid}0 address space">; |
| def err_arg_with_address_space : Error< |
| "parameter may not be qualified with an address space">; |
| def err_field_with_address_space : Error< |
| "field may not be qualified with an address space">; |
| def err_attr_objc_ownership_redundant : Error< |
| "the type %0 is already explicitly ownership-qualified">; |
| def err_invalid_nsnumber_type : Error< |
| "%0 is not a valid literal type for NSNumber">; |
| def err_objc_illegal_boxed_expression_type : Error< |
| "illegal type %0 used in a boxed expression">; |
| def err_objc_non_trivially_copyable_boxed_expression_type : Error< |
| "non-trivially copyable type %0 cannot be used in a boxed expression">; |
| def err_objc_incomplete_boxed_expression_type : Error< |
| "incomplete type %0 used in a boxed expression">; |
| def err_undeclared_objc_literal_class : Error< |
| "definition of class %0 must be available to use Objective-C " |
| "%select{array literals|dictionary literals|numeric literals|boxed expressions|" |
| "string literals}1">; |
| def err_undeclared_boxing_method : Error< |
| "declaration of %0 is missing in %1 class">; |
| def err_objc_literal_method_sig : Error< |
| "literal construction method %0 has incompatible signature">; |
| def note_objc_literal_method_param : Note< |
| "%select{first|second|third}0 parameter has unexpected type %1 " |
| "(should be %2)">; |
| def note_objc_literal_method_return : Note< |
| "method returns unexpected type %0 (should be an object type)">; |
| def err_invalid_collection_element : Error< |
| "collection element of type %0 is not an Objective-C object">; |
| def err_box_literal_collection : Error< |
| "%select{string|character|boolean|numeric}0 literal must be prefixed by '@' " |
| "in a collection">; |
| def warn_objc_literal_comparison : Warning< |
| "direct comparison of %select{an array literal|a dictionary literal|" |
| "a numeric literal|a boxed expression|}0 has undefined behavior">, |
| InGroup<ObjCLiteralComparison>; |
| def err_missing_atsign_prefix : Error< |
| "string literal must be prefixed by '@' ">; |
| def warn_objc_string_literal_comparison : Warning< |
| "direct comparison of a string literal has undefined behavior">, |
| InGroup<ObjCStringComparison>; |
| def warn_concatenated_nsarray_literal : Warning< |
| "concatenated NSString literal for an NSArray expression - " |
| "possibly missing a comma">, |
| InGroup<ObjCStringConcatenation>; |
| def note_objc_literal_comparison_isequal : Note< |
| "use 'isEqual:' instead">; |
| def warn_objc_collection_literal_element : Warning< |
| "object of type %0 is not compatible with " |
| "%select{array element type|dictionary key type|dictionary value type}1 %2">, |
| InGroup<ObjCLiteralConversion>; |
| def err_swift_param_attr_not_swiftcall : Error< |
| "'%0' parameter can only be used with swiftcall calling convention">; |
| def err_swift_indirect_result_not_first : Error< |
| "'swift_indirect_result' parameters must be first parameters of function">; |
| def err_swift_error_result_not_after_swift_context : Error< |
| "'swift_error_result' parameter must follow 'swift_context' parameter">; |
| def err_swift_abi_parameter_wrong_type : Error< |
| "'%0' parameter must have pointer%select{| to unqualified pointer}1 type; " |
| "type here is %2">; |
| |
| def err_attribute_argument_invalid : Error< |
| "%0 attribute argument is invalid: %select{max must be 0 since min is 0|" |
| "min must not be greater than max}1">; |
| def err_attribute_argument_is_zero : Error< |
| "%0 attribute must be greater than 0">; |
| def warn_attribute_argument_n_negative : Warning< |
| "%0 attribute parameter %1 is negative and will be ignored">, |
| InGroup<CudaCompat>; |
| def err_property_function_in_objc_container : Error< |
| "use of Objective-C property in function nested in Objective-C " |
| "container not supported, move function outside its container">; |
| |
| let CategoryName = "Cocoa API Issue" in { |
| def warn_objc_redundant_literal_use : Warning< |
| "using %0 with a literal is redundant">, InGroup<ObjCRedundantLiteralUse>; |
| } |
| |
| def err_attr_tlsmodel_arg : Error<"tls_model must be \"global-dynamic\", " |
| "\"local-dynamic\", \"initial-exec\" or \"local-exec\"">; |
| |
| def err_tls_var_aligned_over_maximum : Error< |
| "alignment (%0) of thread-local variable %1 is greater than the maximum supported " |
| "alignment (%2) for a thread-local variable on this target">; |
| |
| def err_only_annotate_after_access_spec : Error< |
| "access specifier can only have annotation attributes">; |
| |
| def err_attribute_section_invalid_for_target : Error< |
| "argument to %select{'code_seg'|'section'}1 attribute is not valid for this target: %0">; |
| def warn_mismatched_section : Warning< |
| "%select{codeseg|section}0 does not match previous declaration">, InGroup<Section>; |
| def warn_attribute_section_on_redeclaration : Warning< |
| "section attribute is specified on redeclared variable">, InGroup<Section>; |
| def err_mismatched_code_seg_base : Error< |
| "derived class must specify the same code segment as its base classes">; |
| def err_mismatched_code_seg_override : Error< |
| "overriding virtual function must specify the same code segment as its overridden function">; |
| def err_conflicting_codeseg_attribute : Error< |
| "conflicting code segment specifiers">; |
| def warn_duplicate_codeseg_attribute : Warning< |
| "duplicate code segment specifiers">, InGroup<Section>; |
| |
| def err_anonymous_property: Error< |
| "anonymous property is not supported">; |
| def err_property_is_variably_modified : Error< |
| "property %0 has a variably modified type">; |
| def err_no_accessor_for_property : Error< |
| "no %select{getter|setter}0 defined for property %1">; |
| def err_cannot_find_suitable_accessor : Error< |
| "cannot find suitable %select{getter|setter}0 for property %1">; |
| |
| def warn_alloca_align_alignof : Warning< |
| "second argument to __builtin_alloca_with_align is supposed to be in bits">, |
| InGroup<DiagGroup<"alloca-with-align-alignof">>; |
| |
| def err_alignment_too_small : Error< |
| "requested alignment must be %0 or greater">; |
| def err_alignment_too_big : Error< |
| "requested alignment must be %0 or smaller">; |
| def err_alignment_not_power_of_two : Error< |
| "requested alignment is not a power of 2">; |
| def err_alignment_dependent_typedef_name : Error< |
| "requested alignment is dependent but declaration is not dependent">; |
| |
| def err_attribute_aligned_too_great : Error< |
| "requested alignment must be %0 bytes or smaller">; |
| def warn_redeclaration_without_attribute_prev_attribute_ignored : Warning< |
| "%q0 redeclared without %1 attribute: previous %1 ignored">, |
| InGroup<MicrosoftInconsistentDllImport>; |
| def warn_redeclaration_without_import_attribute : Warning< |
| "%q0 redeclared without 'dllimport' attribute: 'dllexport' attribute added">, |
| InGroup<MicrosoftInconsistentDllImport>; |
| def warn_dllimport_dropped_from_inline_function : Warning< |
| "%q0 redeclared inline; %1 attribute ignored">, |
| InGroup<IgnoredAttributes>; |
| def warn_attribute_ignored : Warning<"%0 attribute ignored">, |
| InGroup<IgnoredAttributes>; |
| def warn_attribute_ignored_on_inline : |
| Warning<"%0 attribute ignored on inline function">, |
| InGroup<IgnoredAttributes>; |
| def warn_nocf_check_attribute_ignored : |
| Warning<"'nocf_check' attribute ignored; use -fcf-protection to enable the attribute">, |
| InGroup<IgnoredAttributes>; |
| def warn_attribute_after_definition_ignored : Warning< |
| "attribute %0 after definition is ignored">, |
| InGroup<IgnoredAttributes>; |
| def warn_unknown_attribute_ignored : Warning< |
| "unknown attribute %0 ignored">, InGroup<UnknownAttributes>; |
| def warn_cxx11_gnu_attribute_on_type : Warning< |
| "attribute %0 ignored, because it cannot be applied to a type">, |
| InGroup<IgnoredAttributes>; |
| def warn_unhandled_ms_attribute_ignored : Warning< |
| "__declspec attribute %0 is not supported">, |
| InGroup<IgnoredAttributes>; |
| def err_decl_attribute_invalid_on_stmt : Error< |
| "%0 attribute cannot be applied to a statement">; |
| def err_stmt_attribute_invalid_on_decl : Error< |
| "%0 attribute cannot be applied to a declaration">; |
| def warn_declspec_attribute_ignored : Warning< |
| "attribute %0 is ignored, place it after " |
| "\"%select{class|struct|interface|union|enum}1\" to apply attribute to " |
| "type declaration">, InGroup<IgnoredAttributes>; |
| def warn_attribute_precede_definition : Warning< |
| "attribute declaration must precede definition">, |
| InGroup<IgnoredAttributes>; |
| def warn_attribute_void_function_method : Warning< |
| "attribute %0 cannot be applied to " |
| "%select{functions|Objective-C method}1 without return value">, |
| InGroup<IgnoredAttributes>; |
| def warn_attribute_weak_on_field : Warning< |
| "__weak attribute cannot be specified on a field declaration">, |
| InGroup<IgnoredAttributes>; |
| def warn_gc_attribute_weak_on_local : Warning< |
| "Objective-C GC does not allow weak variables on the stack">, |
| InGroup<IgnoredAttributes>; |
| def warn_nsobject_attribute : Warning< |
| "'NSObject' attribute may be put on a typedef only; attribute is ignored">, |
| InGroup<NSobjectAttribute>; |
| def warn_independentclass_attribute : Warning< |
| "'objc_independent_class' attribute may be put on a typedef only; " |
| "attribute is ignored">, |
| InGroup<IndependentClassAttribute>; |
| def warn_ptr_independentclass_attribute : Warning< |
| "'objc_independent_class' attribute may be put on Objective-C object " |
| "pointer type only; attribute is ignored">, |
| InGroup<IndependentClassAttribute>; |
| def warn_attribute_weak_on_local : Warning< |
| "__weak attribute cannot be specified on an automatic variable when ARC " |
| "is not enabled">, |
| InGroup<IgnoredAttributes>; |
| def warn_weak_identifier_undeclared : Warning< |
| "weak identifier %0 never declared">; |
| def err_attribute_weak_static : Error< |
| "weak declaration cannot have internal linkage">; |
| def err_attribute_selectany_non_extern_data : Error< |
| "'selectany' can only be applied to data items with external linkage">; |
| def err_declspec_thread_on_thread_variable : Error< |
| "'__declspec(thread)' applied to variable that already has a " |
| "thread-local storage specifier">; |
| def err_attribute_dll_not_extern : Error< |
| "%q0 must have external linkage when declared %q1">; |
| def err_attribute_dll_thread_local : Error< |
| "%q0 cannot be thread local when declared %q1">; |
| def err_attribute_dll_lambda : Error< |
| "lambda cannot be declared %0">; |
| def warn_attribute_invalid_on_definition : Warning< |
| "'%0' attribute cannot be specified on a definition">, |
| InGroup<IgnoredAttributes>; |
| def err_attribute_dll_redeclaration : Error< |
| "redeclaration of %q0 cannot add %q1 attribute">; |
| def warn_attribute_dll_redeclaration : Warning< |
| "redeclaration of %q0 should not add %q1 attribute">, |
| InGroup<DiagGroup<"dll-attribute-on-redeclaration">>; |
| def err_attribute_dllimport_function_definition : Error< |
| "dllimport cannot be applied to non-inline function definition">; |
| def err_attribute_dll_deleted : Error< |
| "attribute %q0 cannot be applied to a deleted function">; |
| def err_attribute_dllimport_data_definition : Error< |
| "definition of dllimport data">; |
| def err_attribute_dllimport_static_field_definition : Error< |
| "definition of dllimport static field not allowed">; |
| def warn_attribute_dllimport_static_field_definition : Warning< |
| "definition of dllimport static field">, |
| InGroup<DiagGroup<"dllimport-static-field-def">>; |
| def warn_attribute_dllexport_explicit_instantiation_decl : Warning< |
| "explicit instantiation declaration should not be 'dllexport'">, |
| InGroup<DiagGroup<"dllexport-explicit-instantiation-decl">>; |
| def warn_invalid_initializer_from_system_header : Warning< |
| "invalid constructor form class in system header, should not be explicit">, |
| InGroup<DiagGroup<"invalid-initializer-from-system-header">>; |
| def note_used_in_initialization_here : Note<"used in initialization here">; |
| def err_attribute_dll_member_of_dll_class : Error< |
| "attribute %q0 cannot be applied to member of %q1 class">; |
| def warn_attribute_dll_instantiated_base_class : Warning< |
| "propagating dll attribute to %select{already instantiated|explicitly specialized}0 " |
| "base class template without dll attribute is not supported">, |
| InGroup<DiagGroup<"unsupported-dll-base-class-template">>, DefaultIgnore; |
| def err_attribute_dll_ambiguous_default_ctor : Error< |
| "'__declspec(dllexport)' cannot be applied to more than one default constructor in %0">; |
| def err_attribute_weakref_not_static : Error< |
| "weakref declaration must have internal linkage">; |
| def err_attribute_weakref_not_global_context : Error< |
| "weakref declaration of %0 must be in a global context">; |
| def err_attribute_weakref_without_alias : Error< |
| "weakref declaration of %0 must also have an alias attribute">; |
| def err_alias_not_supported_on_darwin : Error < |
| "aliases are not supported on darwin">; |
| def err_alias_to_undefined : Error< |
| "%select{alias|ifunc}0 must point to a defined %select{variable or |}1function">; |
| def warn_alias_to_weak_alias : Warning< |
| "%select{alias|ifunc}2 will always resolve to %0 even if weak definition of %1 is overridden">, |
| InGroup<IgnoredAttributes>; |
| def warn_alias_with_section : Warning< |
| "%select{alias|ifunc}1 will not be in section '%0' but in the same section as the %select{aliasee|resolver}2">, |
| InGroup<IgnoredAttributes>; |
| def err_duplicate_mangled_name : Error< |
| "definition with same mangled name '%0' as another definition">; |
| def err_cyclic_alias : Error< |
| "%select{alias|ifunc}0 definition is part of a cycle">; |
| def err_ifunc_resolver_return : Error< |
| "ifunc resolver function must return a pointer">; |
| def warn_attribute_wrong_decl_type_str : Warning< |
| "%0 attribute only applies to %1">, InGroup<IgnoredAttributes>; |
| def err_attribute_wrong_decl_type_str : Error< |
| warn_attribute_wrong_decl_type_str.Text>; |
| def warn_attribute_wrong_decl_type : Warning< |
| "%0 attribute only applies to %select{" |
| "functions" |
| "|unions" |
| "|variables and functions" |
| "|functions and methods" |
| "|functions, methods and blocks" |
| "|functions, methods, and parameters" |
| "|variables" |
| "|variables and fields" |
| "|variables, data members and tag types" |
| "|types and namespaces" |
| "|variables, functions and classes" |
| "|kernel functions" |
| "|non-K&R-style functions}1">, |
| InGroup<IgnoredAttributes>; |
| def err_attribute_wrong_decl_type : Error<warn_attribute_wrong_decl_type.Text>; |
| def warn_type_attribute_wrong_type : Warning< |
| "'%0' only applies to %select{function|pointer|" |
| "Objective-C object or block pointer}1 types; type here is %2">, |
| InGroup<IgnoredAttributes>; |
| def warn_incomplete_encoded_type : Warning< |
| "encoding of %0 type is incomplete because %1 component has unknown encoding">, |
| InGroup<DiagGroup<"encode-type">>; |
| def warn_gnu_inline_attribute_requires_inline : Warning< |
| "'gnu_inline' attribute requires function to be marked 'inline'," |
| " attribute ignored">, |
| InGroup<IgnoredAttributes>; |
| def err_attribute_vecreturn_only_vector_member : Error< |
| "the vecreturn attribute can only be used on a class or structure with one member, which must be a vector">; |
| def err_attribute_vecreturn_only_pod_record : Error< |
| "the vecreturn attribute can only be used on a POD (plain old data) class or structure (i.e. no virtual functions)">; |
| def err_cconv_change : Error< |
| "function declared '%0' here was previously declared " |
| "%select{'%2'|without calling convention}1">; |
| def warn_cconv_ignored : Warning< |
| "calling convention %0 ignored for this target">, InGroup<IgnoredAttributes>; |
| def err_cconv_knr : Error< |
| "function with no prototype cannot use the %0 calling convention">; |
| def warn_cconv_knr : Warning< |
| err_cconv_knr.Text>, |
| InGroup<DiagGroup<"missing-prototype-for-cc">>; |
| def err_cconv_varargs : Error< |
| "variadic function cannot use %0 calling convention">; |
| def warn_cconv_varargs : Warning< |
| "%0 calling convention ignored on variadic function">, |
| InGroup<IgnoredAttributes>; |
| def warn_cconv_structors : Warning< |
| "%0 calling convention ignored on constructor/destructor">, |
| InGroup<IgnoredAttributes>; |
| def err_regparm_mismatch : Error<"function declared with regparm(%0) " |
| "attribute was previously declared " |
| "%plural{0:without the regparm|:with the regparm(%1)}1 attribute">; |
| def err_function_attribute_mismatch : Error< |
| "function declared with %0 attribute " |
| "was previously declared without the %0 attribute">; |
| def err_objc_precise_lifetime_bad_type : Error< |
| "objc_precise_lifetime only applies to retainable types; type here is %0">; |
| def warn_objc_precise_lifetime_meaningless : Error< |
| "objc_precise_lifetime is not meaningful for " |
| "%select{__unsafe_unretained|__autoreleasing}0 objects">; |
| def err_invalid_pcs : Error<"invalid PCS type">; |
| def warn_attribute_not_on_decl : Warning< |
| "%0 attribute ignored when parsing type">, InGroup<IgnoredAttributes>; |
| def err_base_specifier_attribute : Error< |
| "%0 attribute cannot be applied to a base specifier">; |
| def err_invalid_attribute_on_virtual_function : Error< |
| "%0 attribute cannot be applied to virtual functions">; |
| |
| def ext_cannot_use_trivial_abi : ExtWarn< |
| "'trivial_abi' cannot be applied to %0">, InGroup<IgnoredAttributes>; |
| |
| // Availability attribute |
|
