Update all diagnostic messages in DiagnosticSemaKinds.td to use the new diffing format for types.

[rtrieu]

Summary

For applicable diagnostic messages in DiagnosticSemaKinds.td, modify the message to use the %diff format. Most messages which take two QualType arguments have been converted.

include/clang/Basic/DiagnosticSemaKinds.td

 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: %1 vs %2">;
+  "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<

 def warn_conflicting_overriding_ret_types : Warning<
   "conflicting return type in "
   "declaration of %0%diff{: $ vs $|}1,2">,
-  InGroup<OverridingMethodMismatch>, DefaultIgnore;
+  InGroup<OverridingMethodMismatch>, DefaultIgnore;
 
 def warn_conflicting_ret_types : Warning<
   "conflicting return type in "
   "implementation of %0%diff{: $ vs $|}1,2">;
-
+
 def warn_conflicting_overriding_ret_type_modifiers : Warning<
   "conflicting distributed object modifiers on return type "
 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">;
 def warn_conflicting_param_modifiers : Warning<
-  "conflicting distributed object modifiers on parameter type "
+  "conflicting distributed object modifiers on parameter type "
   "in implementation of %0">,  "anonymous %select{struct|union}0 cannot be '%select{const|volatile|"
   "restrict}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 note_overridden_virtual_function : Note<
+  "overridden virtual function is here">;
+def err_init_conversion_failed : Error<
   "cannot initialize %select{a variable|a parameter|return object|an "
   "exception object|a member subobject|an array element|a new value|a value|a "
   "base class|a constructor delegation|a vector element}0 "

   "%diff{of type $ with an %select{rvalue|lvalue}2 of type $|"
   "with an %select{rvalue|lvalue} of incompatible type}1,3"
   "%select{|: different classes%diff{ ($ vs $)|}5,6"
-  "|: different number of parameters (%5 vs %6)"
-  "|: type mismatch at %ordinal5 parameter (%6 vs %7)"
-  "|: different return type (%5 vs %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 "
-
+  "volatile and restrict|const, volatile, and restrict}5 vs "
+
 def warn_impcast_vector_scalar : Warning<
   "implicit conversion turns vector to scalar"
   "%diff{: $ to $| when converting types}0,1">,

   InGroup<DiagGroup<"conversion">>, DefaultIgnore;
 def warn_impcast_complex_scalar : Warning<
   "implicit conversion discards imaginary component"
-
+  "%diff{: $ to $| when converting types}0,1">,
+  InGroup<DiagGroup<"conversion">>, DefaultIgnore;
 def warn_impcast_float_precision : Warning<
   "implicit conversion loses floating-point precision"
-
+  "%diff{: $ to $| when converting types}0,1">,
+  InGroup<DiagGroup<"conversion">>, DefaultIgnore;
 def warn_impcast_float_integer : Warning<
   "implicit conversion turns floating-point number into integer"
-
+  "%diff{: $ to $| when converting types}0,1">,
+  InGroup<DiagGroup<"conversion">>, DefaultIgnore;
 def warn_impcast_integer_sign : Warning<
   "implicit conversion changes signedness"
-
+  "%diff{: $ to $| when converting types}0,1">,
+  InGroup<SignConversion>, DefaultIgnore;
 def warn_impcast_integer_sign_conditional : Warning<
   "operand of ? changes signedness%diff{: $ to $| when converting types}0,1">,
-  InGroup<SignConversion>, DefaultIgnore;
+  InGroup<SignConversion>, DefaultIgnore;
+def warn_impcast_integer_precision : Warning<
   "implicit conversion loses integer precision"
   "%diff{: $ to $| when converting types}0,1">,
-  InGroup<DiagGroup<"conversion">>, DefaultIgnore;
+  InGroup<DiagGroup<"conversion">>, DefaultIgnore;
 def warn_impcast_integer_64_32 : Warning<
   "implicit conversion loses integer precision"
-
+  "%diff{: $ to $| when converting types}0,1">,
+  InGroup<DiagGroup<"shorten-64-to-32">>, DefaultIgnore;
 def warn_impcast_integer_precision_constant : Warning<
   "implicit conversion %diff{from $ to $| between types}2,3 "
-
+  "changes value from %0 to %1">,
+  InGroup<ConstantConversion>;
 def warn_impcast_bitfield_precision_constant : Warning<
   "implicit truncation from %2 to bitfield changes value from %0 to %1">,
-  InGroup<ConstantConversion>;
+  InGroup<ConstantConversion>;
+def warn_impcast_literal_float_to_integer : Warning<
   "implicit conversion %diff{from $ to $|between types}0,1 "
   "changes value from %2 to %3">,
   InGroup<LiteralConversion>;
 def warn_impcast_string_literal_to_bool : Warning<
   "implicit conversion turns string literal into bool: %0 to %1">,    "suffix with parentheses to turn this into a function call">;
-
+
+def warn_cast_align : Warning<
   "cast %diff{from $ to $|between types}0,1 increases required alignment "
   "from %2 to %3">,
   InGroup<CastAlign>, DefaultIgnore;

 
 def warn_attribute_ignored_for_field_of_type : Warning<def err_attribute_cleanup_func_must_take_one_arg : Error<
   "'cleanup' function %0 must take 1 parameter">;
-def err_attribute_cleanup_func_arg_incompatible_type : Error<
+def err_attribute_cleanup_func_arg_incompatible_type : Error<
+  "'cleanup' function %0 parameter has "
   "%diff{type $ which is incompatible with type $|incompatible type}1,2">;
 def err_attribute_regparm_wrong_platform : Error<
   "'regparm' is not valid on this platform">;

 def err_attribute_regparm_invalid_number : Error<  "default argument declared here">;
 
 def ext_param_promoted_not_compatible_with_prototype : ExtWarn<
-  "promoted type %0 of K&R function parameter is not compatible with the "
-  "parameter type %1 declared in a previous prototype">,
+  "%diff{promoted type $ of K&R function parameter is not compatible with the "
+  "parameter type $|promoted type of K&R function parameter is not compatible "
   "with parameter type}0,1 declared in a previous prototype">,
   InGroup<KNRPromotedParameter>;
 

     "is the implicit copy assignment operator|"
     "is the implicit move assignment operator|"
     "is an inherited constructor}0%1"
-    "%select{| has different class (expected %3 but has %4)"
-    "| has different number of parameters (expected %3 but has %4)"
+    "%select{| has different class%diff{ (expected $ but has $)|}3,4"
+    "| has different number of parameters (expected %3 but has %4)"
+    "| has type mismatch at %ordinal3 parameter"
     "%diff{ (expected $ but has $)|}4,5"
     "| has different return type%diff{ ($ expected but has $)|}3,4"
     "| has different qualifiers (expected "

     "%select{none|const|restrict|const and restrict|volatile|const and volatile"
     "|volatile and restrict|const, volatile, and restrict}3 but found "    "couldn't infer template argument %0">;
 def note_ovl_candidate_inconsistent_deduction : Note<
-    "candidate template ignored: deduced conflicting %select{types|values|"
+    "candidate template ignored: deduced conflicting %select{types|values|"
     "templates}0 for parameter %1%diff{ ($ vs. $)|}2,3">;
-def note_ovl_candidate_explicit_arg_mismatch_named : Note<
-    "candidate template ignored: invalid explicitly-specified argument "
+def note_ovl_candidate_explicit_arg_mismatch_named : Note<
+    "candidate template ignored: invalid explicitly-specified argument "
+    "for template parameter %0">;    "function (the implicit copy assignment operator)|"
     "function (the implicit move assignment operator)|"
     "constructor (inherited)}0%1 "
     "not viable: cannot convert argument of incomplete type "

     "%diff{$ to $|to parameter type}2,3">;
 def note_ovl_candidate_bad_list_argument : Note<"candidate "
     "%select{function|function|constructor|"
-    "function |function |constructor |"    "function (the implicit copy assignment operator)|"
+    "function |function |constructor |"    "function (the implicit copy assignment operator)|"
     "function (the implicit move assignment operator)|"
     "constructor (inherited)}0%1"
     " not viable: cannot implicitly convert argument "

     "%diff{of type $ to $|type to parameter type}2,3 for "
     "%select{%ordinal5 argument|object argument}4 under ARC">;
 def note_ovl_candidate_bad_lvalue : Note<"candidate "
-    "%select{function|function|constructor|"    " %select{__device__|__global__|__host__|__host__ __device__}2 function">;
+    "%select{function|function|constructor|"    " %select{__device__|__global__|__host__|__host__ __device__}2 function">;
+
 def note_ambiguous_type_conversion: Note<
     "because of ambiguity in conversion %diff{of $ to $|between types}0,1">;
 def note_ovl_builtin_binary_candidate : Note<

     "built-in candidate %0">;
 def note_ovl_builtin_unary_candidate : Note<def err_ovl_no_viable_function_in_init : Error<
   "no matching constructor for initialization of %0">;
-def err_ovl_no_conversion_in_cast : Error<
+def err_ovl_no_conversion_in_cast : Error<
+  "cannot convert %diff{$ to $|types}1,2 without a conversion operator">;
 def err_ovl_no_viable_conversion_in_cast : Error<
   "no matching conversion for %select{|static_cast|reinterpret_cast|"
   "dynamic_cast|C-style cast|functional-style cast}0 "

   "%diff{from $ to $|between types}1,2">;
 def err_ovl_ambiguous_conversion_in_cast : Error<
   "ambiguous conversion for %select{|static_cast|reinterpret_cast|"
-  "dynamic_cast|C-style cast|functional-style cast}0 from %1 to %2">;
+  "dynamic_cast|C-style cast|functional-style cast}0 "
   "%diff{from $ to $|between types}1,2">;
 def err_ovl_deleted_conversion_in_cast : Error<
   "%select{|static_cast|reinterpret_cast|dynamic_cast|C-style cast|"

   "functional-style cast}0 %diff{from $ to $|between types}1,2 "
   "uses deleted function">;
 def err_ovl_ambiguous_init : Error<"call to constructor of %0 is ambiguous">;
-def err_ref_init_ambiguous : Error<
+def err_ref_init_ambiguous : Error<
   "reference initialization %diff{of type $ with initializer of type $"
   "|with initializer of different type}0,1 is ambiguous">;
-def err_ovl_deleted_init : Error<
+def err_ovl_deleted_init : Error<
+  "call to %select{unavailable|deleted}0 constructor of %1">;
 def err_ovl_deleted_special_init : Error<def err_ovl_ambiguous_oper_unary : Error<
   "use of overloaded operator '%0' is ambiguous (operand type %1)">;
-def err_ovl_ambiguous_oper_binary : Error<
+def err_ovl_ambiguous_oper_binary : Error<
+  "use of overloaded operator '%0' is ambiguous%diff{ (with operand types $ and $|)}1,2">;
 def err_ovl_no_viable_oper : Error<"no viable overloaded '%0'">;
 def err_ovl_deleted_oper : Error<
-  "overload resolution selected %select{unavailable|deleted}0 operator '%1'%2">; "of type %1">;
+  "overload resolution selected %select{unavailable|deleted}0 operator '%1'%2">; "of type %1">;
+def err_deduced_non_type_template_arg_type_mismatch : Error<
   "deduced non-type template argument does not have the same type as the "
   "its corresponding template parameter%diff{ ($ vs $)|}0,1">;
-def err_template_arg_not_convertible : Error<
+def err_template_arg_not_convertible : Error<
+  "non-type template argument %diff{of type $ cannot be converted to a value "
   "of type $|cannot be converted between types}0,1">;
 def warn_template_arg_negative : Warning<
   "non-type template argument with value '%0' converted to '%1' for unsigned "

   "template parameter of type %2">, InGroup<Conversion>, DefaultIgnore;  "non-type template argument value '%0' truncated to '%1' for "
   "template parameter of type %2">, InGroup<Conversion>, DefaultIgnore;
 def err_template_arg_no_ref_bind : Error<
-  "non-type template parameter of reference type %0 cannot bind to template "
+  "non-type template parameter of reference type "
   "%diff{$ cannot bind to template argument of type $"
   "|cannot bind to template of incompatible argument type}0,1">;
 def err_template_arg_ref_bind_ignores_quals : Error<

   "reference binding of non-type template parameter "
   "%diff{of type $ to template argument of type $|to template argument}0,1 "
   "ignores qualifiers">;
-def err_template_arg_not_decl_ref : Error<
+def err_template_arg_not_decl_ref : Error<
   "non-type template argument does not refer to any declaration">;
-def err_template_arg_not_object_or_func_form : Error<  "redefinition of forward class %0 of a typedef name of an object type is ignored">,
-  InGroup<DiagGroup<"objc-forward-class-redefinition">>;
+def err_template_arg_not_object_or_func_form : Error<  "redefinition of forward class %0 of a typedef name of an object type is ignored">,
+  InGroup<DiagGroup<"objc-forward-class-redefinition">>;
 def err_redefinition_different_typedef : Error<
   "%select{typedef|type alias|type alias template}0 redefinition with different types%diff{ ($ vs $)|}1,2">;
 def err_tag_reference_non_tag : Error<

   "elaborated type refers to %select{a non-tag type|a typedef|a type alias|a template|a type alias template}0">;
 def err_tag_reference_conflict : Error<  "illegal initializer (only variables can be initialized)">;
 def err_illegal_initializer_type : Error<"illegal initializer type %0">;
-def err_init_list_type_narrowing_sfinae : Error<
-  "type %0 cannot be narrowed to %1 in initializer list">;
+def err_init_list_type_narrowing_sfinae : Error<
+  "type %diff{$ cannot be narrowed to $|cannot be narrowed}0,1 "
+  "in initializer list">;
 def err_init_list_type_narrowing : ExtWarn<
-  "type %0 cannot be narrowed to %1 in initializer list">, 
-
+  "type %diff{$ cannot be narrowed to $|cannot be narrowed}0,1 "
+  "in initializer list">, 
+  InGroup<CXX11Narrowing>, DefaultError;
 def err_init_list_variable_narrowing_sfinae : Error<
   "non-constant-expression cannot be narrowed %diff{from type $ to $|}0,1, in "
   "initializer list">;

 def err_init_list_variable_narrowing : ExtWarn<
   "non-constant-expression cannot be narrowed %diff{from type $ to $|}0,1 in "
   "initializer list">, InGroup<CXX11Narrowing>, DefaultError;
-def err_init_list_constant_narrowing_sfinae : Error<
+def err_init_list_constant_narrowing_sfinae : Error<
   "constant expression evaluates to %0 which cannot be narrowed to type %1">;  "constant expression evaluates to %0 which cannot be narrowed to type %1">,
   InGroup<CXX11Narrowing>, DefaultError;
 def warn_init_list_type_narrowing : Warning<

   "type %0 cannot be narrowede to %1 in initializer list in C++11">,
   InGroup<CXX11Narrowing>, DefaultIgnore;
 def warn_init_list_variable_narrowing : Warning<
-  "non-constant-expression cannot be narrowed from type %0 to %1 in "
+  "non-constant-expression cannot be narrowed %diff{from type $ to $|}0,1 in "
+  "initializer list in C++11">,
   InGroup<CXX11Narrowing>, DefaultIgnore;
-def warn_init_list_constant_narrowing : Warning<  "synthesis of a weak-unavailable property is disallowed "
+def warn_init_list_constant_narrowing : Warning<  "synthesis of a weak-unavailable property is disallowed "
+  "because it requires synthesis of an ivar of the __weak object">;
 def err_arc_convesion_of_weak_unavailable : Error<
   "%select{implicit conversion|cast}0 of weak-unavailable object "
-  " a __weak object of type %2">;
+  "%diff{of type $ to a __weak object of type $|to a __weak object}1,2">;
 
 } // end "ARC Weak References" category
-  "the result of a delegate init call must be immediately returned "
+  "the result of a delegate init call must be immediately returned "
   "or assigned to 'self'">;
 def err_arc_mismatched_cast : Error<
   "%select{implicit conversion|cast}0 "

   "%select{%diff{of $ to $|}2,3|"
   "of a non-Objective-C pointer%diff{ type $ to $}2,3|"
   "of a block pointer to %3|"
-
+  "of an Objective-C pointer to %3|"
   "of an indirect pointer to an Objective-C pointer to %3}1"
   " is disallowed with ARC">;
-def err_arc_nolifetime_behavior : Error<
+def err_arc_nolifetime_behavior : Error<
   "explicit ownership qualifier on cast result has no effect">;
 def err_arc_objc_object_in_struct : Error<def err_arc_array_param_no_ownership : Error<
   "must explicitly describe intended ownership of an object array parameter">;

 def err_arc_pseudo_dtor_inconstant_quals : Error<
   "pseudo-destructor destroys object "
   "%diff{of type $ with inconsistently-qualified type $|"
-
-def err_arc_init_method_unrelated_result_type : Error<
+  "with inconsistently-qualified type}0,1">;
+def err_arc_init_method_unrelated_result_type : Error<
   "init methods must return a type related to the receiver type">;
 def err_arc_nonlocal_writeback : Error<let CategoryName = "ARC Casting Rules" in {
 

 def err_arc_bridge_cast_incompatible : Error<
   "incompatible types casting%diff{ $ to $|}0,1 with a %select{__bridge|"
   "__bridge_transfer|__bridge_retained}2 cast">;
-def err_arc_bridge_cast_wrong_kind : Error<
-  "cast of %select{Objective-C|block|C}0 pointer type %1 to "
-  "%select{Objective-C|block|C}2 pointer type %3 cannot use %select{__bridge|"
-  "__bridge_transfer|__bridge_retained}4">;
+def err_arc_bridge_cast_wrong_kind : Error<
+  "cast of %select{Objective-C|block|C}0 pointer type "
+  "%diff{$ to %select{Objective-C|block|C}2 pointer type $|"
+  "to %select{Objective-C|block|C}2 pointer type}1,3 "
+  "cannot use %select{__bridge|__bridge_transfer|__bridge_retained}4">;
+def err_arc_cast_requires_bridge : Error<
+  "%select{cast|implicit conversion}0 of %select{Objective-C|block|C}1 "
   "pointer type %diff{$ to %select{Objective-C|block|C}3 pointer type $|"
   "to %select{Objective-C|block|C}3 pointer type}2,4 "
   "requires a bridged cast">;

 def note_arc_bridge : Note<
   "use __bridge to convert directly (no change in ownership)">;  "member declaration does not match because "
   "it %select{is|is not}0 const qualified">;
-def note_member_def_close_param_match : Note<
-  "type of %ordinal0 parameter of member declaration does not match "
+def note_member_def_close_param_match : Note<
+  "type of %ordinal0 parameter of member declaration does not match definition"
+  "%diff{ ($ vs $)|}1,2">;
 def err_typecheck_ivar_variable_size : Error<
   "instance variables must have a constant size">;
 def err_ivar_reference_type : Error<  "array initializer must be an initializer "

   "list%select{| or string literal}0">;
 def err_array_init_different_type : Error<
   "cannot initialize array %diff{of type $ with array of type $|"
-
+  "with different type of array}0,1">;
 def err_array_init_non_constant_array : Error<
   "cannot initialize array %diff{of type $ with non-constant array of type $|"
-
-def ext_array_init_copy : Extension<
-  "initialization of an array of type %0 from a compound literal of type %1 is "
+  "with different type of array}0,1">;
+def ext_array_init_copy : Extension<
+  "initialization of an array "
+  "%diff{of type $ from a compound literal of type $|"
   "from a compound literal}0,1 is a GNU extension">, InGroup<GNU>;
 // This is intentionally not disabled by -Wno-gnu.
-def ext_array_init_parens : ExtWarn<
+def ext_array_init_parens : ExtWarn<
+  "parenthesized initialization of a member array is a GNU extension">,def note_indirection_through_null : Note<
   "consider using __builtin_trap() or qualifying pointer with 'volatile'">;
 def warn_pointer_indirection_from_incompatible_type : Warning<
   "dereference of type %diff{$ that was reinterpret_cast from type $|"

   "that was reinterpret_cast}1,0 has undefined behavior">,
   InGroup<DiagGroup<"undefined-reinterpret-cast">>, DefaultIgnore;
 
-def err_objc_object_assignment : Error<
-  "cannot assign to class object (%0 invalid)">;
+def err_objc_object_assignment : Error<
+  "cannot assign to class object (%0 invalid)">;
 def err_typecheck_invalid_operands : Error<
   "invalid operands to binary expression%diff{ ($ and $)|}0,1">;
 def err_typecheck_sub_ptr_compatible : Error<

   "%diff{$ and $ are not pointers to compatible types|"
   "pointers to incompatible types}0,1">;
 def ext_typecheck_ordered_comparison_of_pointer_integer : ExtWarn<
-  "ordered comparison between pointer and integer (%0 and %1)">;
+  "ordered comparison between pointer and integer%diff{ ($ and $)|}0,1">;
+def ext_typecheck_ordered_comparison_of_pointer_and_zero : Extension<
   "ordered comparison between pointer and zero%diff{ ($ and $)|}0,1 "
-
+  "is an extension">;
+def ext_typecheck_ordered_comparison_of_function_pointers : ExtWarn<
   "ordered comparison of function pointers%diff{ ($ and $)|}0,1">;
-def ext_typecheck_comparison_of_fptr_to_void : Extension<
-  "equality comparison between function pointer and void pointer (%0 and %1)">;
+def ext_typecheck_comparison_of_fptr_to_void : Extension<
+  "equality comparison between function pointer and void pointer"
+  "%diff{ ($ and $)|}0,1">;
 def err_typecheck_comparison_of_fptr_to_void : Error<
   "equality comparison between function pointer and void pointer"
   "%diff{ ($ and $)|}0,1">;

 def ext_typecheck_comparison_of_pointer_integer : ExtWarn<
   "comparison between pointer and integer%diff{ ($ and $)|}0,1">;
 def err_typecheck_comparison_of_pointer_integer : Error<
-  "comparison between pointer and integer (%0 and %1)">;
-def ext_typecheck_comparison_of_distinct_pointers : ExtWarn<
+  "comparison between pointer and integer%diff{ ($ and $)|}0,1">;
+def ext_typecheck_comparison_of_distinct_pointers : ExtWarn<
   "comparison of distinct pointer types%diff{ ($ and $)|}0,1">;
 def ext_typecheck_cond_incompatible_operands : ExtWarn<
   "incompatible operand types%diff{ ($ and $)|}0,1">;
 def err_cond_voidptr_arc : Error <
   "operands to conditional of types%diff{ $ and $|}0,1 are incompatible "
-
+  "in ARC mode">;
 def err_typecheck_comparison_of_distinct_pointers : Error<
-  "comparison of distinct pointer types (%0 and %1)">;
+  "comparison of distinct pointer types%diff{ ($ and $)|}0,1">;
+def ext_typecheck_comparison_of_distinct_pointers_nonstandard : ExtWarn<
   "comparison of distinct pointer types%diff{ ($ and $)|}0,1 uses "
-  "composite pointer type %2">;
+  "non-standard composite pointer type %2">;
 def err_typecheck_assign_const : Error<"read-only variable is not assignable">;
-def err_stmtexpr_file_scope : Error<
+def err_stmtexpr_file_scope : Error<
+  "statement expression not allowed at file scope">;
 def warn_mixed_sign_comparison : Warning<
-  "comparison of integers of different signs: %0 and %1">,
+  "comparison of integers of different signs%diff{: $ and $|}0,1">,
   InGroup<SignCompare>, DefaultIgnore;
-def warn_lunsigned_always_true_comparison : Warning<
+def warn_lunsigned_always_true_comparison : Warning<
+  "comparison of unsigned%select{| enum}2 expression %0 is always %1">,  "comparison of %0 unsigned%select{| enum}2 expression is always %1">,
   InGroup<TautologicalCompare>;
-def warn_comparison_of_mixed_enum_types : Warning<
+def warn_comparison_of_mixed_enum_types : Warning<
+  "comparison of two values with different enumeration types%diff{ ($ and $)|}0,1">,
   InGroup<DiagGroup<"enum-compare">>;
-def warn_null_in_arithmetic_operation : Warning<
+def warn_null_in_arithmetic_operation : Warning<
   "use of NULL in arithmetic operation">,
-def err_bad_cxx_cast_generic : Error<
+def err_bad_cxx_cast_generic : Error<
   "%select{const_cast|static_cast|reinterpret_cast|dynamic_cast|C-style cast|"
-  "functional-style cast}0 from %1 to %2 is not allowed">;
+  "functional-style cast}0%diff{ from $ to $|}1,2 is not allowed">;
 def err_bad_cxx_cast_rvalue : Error<
-  "%select{const_cast|static_cast|reinterpret_cast|dynamic_cast|C-style cast|"
+  "%select{const_cast|static_cast|reinterpret_cast|dynamic_cast|C-style cast|"
   "functional-style cast}0 from rvalue to reference type %2">;
-def err_bad_cxx_cast_qualifiers_away : Error<
+def err_bad_cxx_cast_qualifiers_away : Error<
+  "%select{const_cast|static_cast|reinterpret_cast|dynamic_cast|C-style cast|"
   "functional-style cast}0 from%diff{ $ to $|}1,2 casts away qualifiers">;
-def err_bad_const_cast_dest : Error<
+def err_bad_const_cast_dest : Error<
   "%select{const_cast||||C-style cast|functional-style cast}0 to %2, "
-  "which is not a reference, pointer-to-object, or pointer-to-data-member">;  "cannot cast from lvalue of type %1 to rvalue reference type %2; types are "
-  "not compatible">;
+  "which is not a reference, pointer-to-object, or pointer-to-data-member">;  "cannot cast from lvalue of type %1 to rvalue reference type %2; types are "
+  "not compatible">;
 def err_bad_static_cast_pointer_nonpointer : Error<
   "cannot cast from type %diff{$ to pointer type $|to pointer type}1,2">;
 def err_bad_static_cast_member_pointer_nonmp : Error<
   "cannot cast from type "
-
+  "$diff{$ to member pointer type $|to member pointer type}1,2">;
 def err_bad_cxx_cast_member_pointer_size : Error<
   "cannot %select{||reinterpret_cast||C-style cast|}0 from member pointer "
   "%diff{type $ to member pointer type $|to member pointer}1,2 "

   "of different size">;
 def err_bad_reinterpret_cast_reference : Error<
   "reinterpret_cast of a %0 to %1 needs its address which is not allowed">;
-def warn_undefined_reinterpret_cast : Warning<
+def warn_undefined_reinterpret_cast : Warning<
   "reinterpret_cast %diff{from $ to $|}0,1 has undefined behavior">,
   InGroup<DiagGroup<"undefined-reinterpret-cast">>, DefaultIgnore;
 

 // These messages don't adhere to the pattern.def err_array_size_incomplete_type : Error<
   "array size expression has incomplete class type %0">;
 def err_array_size_explicit_conversion : Error<
-  "array size expression of type %0 requires explicit conversion to type %1">;
+  "array size expression "
   "%diff{of type $ requires explicit conversion to type $|"
   "requires explicit conversion}0,1">;
 def note_array_size_conversion : Note<
   "conversion to %select{integral|enumeration}0 type %1 declared here">;
 def err_array_size_ambiguous_conversion : Error<
-  "ambiguous conversion of array size expression of type %0 to an integral or "
+  "ambiguous conversion of array size expression of type %0 to an integral or "
   "enumeration type">;
 def ext_array_size_conversion : Extension<
   "implicit conversion from array size expression "

   "%diff{of type $ to %select{integral|enumeration}1 type $|"
   "to %select{integral|enumeration}1 type}0,2 is a C++11 extension">,
   InGroup<CXX11>;
-def warn_cxx98_compat_array_size_conversion : Warning<
+def warn_cxx98_compat_array_size_conversion : Warning<
   "implicit conversion from array size expression "
-  "%select{integral|enumeration}1 type %2 is incompatible with C++98">,
+  "%diff{of type $ to %select{integral|enumeration}1 type $|"
+  "to %select{integral|enumeration}1 type}0,2 is incompatible with C++98">,
   InGroup<CXX98CompatPedantic>, DefaultIgnore;
 def err_address_space_qualified_new : Error<
-  "'new' cannot allocate objects of type %0 in address space '%1'">;  "%select{left|right}1 operand to ? is void, but %select{right|left}1 operand "
+  "'new' cannot allocate objects of type %0 in address space '%1'">;  "%select{left|right}1 operand to ? is void, but %select{right|left}1 operand "
+  "is of type %0">;
 def err_conditional_ambiguous : Error<
   "conditional expression is ambiguous; "
   "%diff{$ can be converted to $ and vice versa|"
-
+  "types can be convert to each other}0,1">;
 def err_conditional_ambiguous_ovl : Error<
   "conditional expression is ambiguous; %diff{$ and $|types}0,1 "
   "can be converted to several common types">;

 
 def err_throw_incomplete : Error<
   "cannot throw object of incomplete type %0">;  "pseudo-destructors on type void are a Microsoft extension">,
-  InGroup<Microsoft>;
+  InGroup<Microsoft>;
+def err_pseudo_dtor_type_mismatch : Error<
+  "the type of object expression "
   "%diff{($) does not match the type being destroyed ($)|"
   "does not match the type being destroyed}0,1 "
   "in pseudo-destructor expression">;
 def err_pseudo_dtor_call_with_args : Error<
   "call to pseudo-destructor cannot have any arguments">;
 def err_dtor_expr_without_call : Error<def err_typecheck_bool_condition : Error<
-  "value of type %0 is not contextually convertible to 'bool'">;
-def err_typecheck_ambiguous_condition : Error<
+  "value of type %0 is not contextually convertible to 'bool'">;
+def err_typecheck_ambiguous_condition : Error<
+  "conversion %diff{from $ to $|between types}0,1 is ambiguous">;
 def err_typecheck_nonviable_condition : Error<
   "no viable conversion%diff{ from $ to $|}0,1">;
-def err_typecheck_deleted_function : Error<
-  "conversion function from %0 to %1 invokes a deleted function">;
+def err_typecheck_deleted_function : Error<
+  "conversion function %diff{from $ to $|between types}0,1 "
+  "invokes a deleted function">;
   
 def err_expected_class_or_namespace : Error<"expected a class or namespace">;
 def err_expected_class : Error<"%0 is not a class%select{ or namespace|, "// In most of these diagnostics the %2 is a value from the

 // Sema::AssignmentAction enumeration
 def err_typecheck_convert_incompatible : Error<
   "%select{%diff{assigning to $ from incompatible type $|"
-  " %0 "
-  "%select{from incompatible type|to parameter of incompatible type|"
+  "assigning to type from incompatible type}0,1"
+  "|%diff{passing $ to parameter of incompatible type $|"
+  "passing type to parameter of incompatible type}0,1"
   "|%diff{returning $ from a function with incompatible result type $|"
-  "to incompatible type}2 %1"
-
+  "returning type from a function with incompatible result type}0,1"
+  "|%diff{converting $ to incompatible type $|"
   "converting type to incompatible type}"
   "|%diff{initializing $ with an expression of incompatible type $|"
   "initializing type with an expression of incompatible type}0,1"

   "|%diff{sending $ to parameter of incompatible type $|"
   "sending type to parameter of incompatible type}0,1"
   "|%diff{casting $ to incompatible type $|"
-
-  "%select{|; dereference with *|"
+  "casting type to incompatible type}0,1}2"
+  "%select{|; dereference with *|"
+  "; take the address with &|"
+  "; remove *|"
   "; remove &}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|"
+  "%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|"
+  "%select{none|const|restrict|const and restrict|volatile|const and volatile|"
   "volatile and restrict|const, volatile, and restrict}6)}4">;
-def err_typecheck_missing_return_type_incompatible : Error<
+def err_typecheck_missing_return_type_incompatible : Error<
+  "%diff{return type $ must match previous return type $|"
   "return type must match previous return type}0,1 when %select{block "
   "literal|lambda expression}2 has unspecified explicit return type">;
 

 def warn_incompatible_qualified_id : Warning<
   "%select{%diff{assigning to $ from incompatible type $|"
   "assigning to type from incompatible type}0,1"
-  "%select{from incompatible type|to parameter of incompatible type|"
-  "from a function with incompatible result type|to incompatible type|"
-  "with an expression of incompatible type|to parameter of incompatible type|"
-  "to incompatible type}2 %1">;
-
-
+  "|%diff{passing $ to parameter of incompatible type $|"
+  "passing type to parameter of incompatible type}0,1"
+  "|%diff{returning $ from a function with incompatible result type $|"
+  "returning type from a function with incompatible result type}0,1"
+  "|%diff{converting $ to incompatible type $|"
+  "converting type to incompatible type}"
+  "|%diff{initializing $ with an expression of incompatible type $|"
+  "initializing type with an expression of incompatible type}0,1"
+  "|%diff{sending $ to parameter of incompatible type $|"
+  "sending type to parameter of incompatible type}0,1"
+  "|%diff{casting $ to incompatible type $|"
+  "casting type to incompatible type}0,1}2">;
+def ext_typecheck_convert_pointer_int : ExtWarn<
+  "incompatible pointer to integer conversion "
   "%select{%diff{assigning to $ from $|assigning to different types}0,1"
   "|%diff{passing $ to parameter of type $|"
   "passing to parameter of different type}0,1"
   "|%diff{returning $ from a function with result type $|"
-
+  "returning from function with different return type}0,1"
   "|%diff{converting $ to type $|converting between types}0,1"
-
-
+  "|%diff{initializing $ with an expression of type $|"
+  "initializing with expression of different type}0,1"
   "|%diff{sending $ to parameter of type $|"
   "sending to parameter of different type}0,1"
   "|%diff{casting $ to type $|casting between types}0,1}2"
   "%select{|; dereference with *|"
   "; take the address with &|"
   "; remove *|"  InGroup<IntConversion>;
-def ext_typecheck_convert_int_pointer : ExtWarn<
+def ext_typecheck_convert_int_pointer : ExtWarn<
+  "incompatible integer to pointer conversion "
   "%select{%diff{assigning to $ from $|assigning to different types}0,1"
   "|%diff{passing $ to parameter of type $|"
   "passing to parameter of different type}0,1"
-  "with an expression of type|to parameter of type|to type}2 %1"
-
-
-
-
-
+  "|%diff{returning $ from a function with result type $|"
+  "returning from function with different return type}0,1"
+  "|%diff{converting $ to type $|converting between types}0,1"
+  "|%diff{initializing $ with an expression of type $|"
+  "initializing with expression of different type}0,1"
+  "|%diff{sending $ to parameter of type $|"
+  "sending to parameter of different type}0,1"
+  "|%diff{casting $ to type $|casting between types}0,1}2"
+  "%select{|; dereference with *|"
+  "; take the address with &|"
+  "; remove *|"
+  "; remove &}3">,
+  InGroup<IntConversion>;
+def ext_typecheck_convert_pointer_void_func : Extension<
   "%select{%diff{assigning to $ from $|assigning to different types}0,1"
   "|%diff{passing $ to parameter of type $|"
-  "%select{from|to parameter of type|from a function with result type|to type|"
-  "with an expression of type|to parameter of type|to type}2 %1 "
-  "converts between void pointer and function pointer">;
-
+  "passing to parameter of different type}0,1"
+  "|%diff{returning $ from a function with result type $|"
+  "returning from function with different return type}0,1"
+  "|%diff{converting $ to type $|converting between types}0,1"
+  "|%diff{initializing $ with an expression of type $|"
+  "initializing with expression of different type}0,1"
+  "|%diff{sending $ to parameter of type $|"
+  "sending to parameter of different type}0,1"
+  "|%diff{casting $ to type $|casting between types}0,1}2"
+  " converts between void pointer and function pointer">;
+def ext_typecheck_convert_incompatible_pointer_sign : ExtWarn<
   "%select{%diff{assigning to $ from $|assigning to different types}0,1"
   "|%diff{passing $ to parameter of type $|"
   "passing to parameter of different type}0,1"

   "|%diff{returning $ from a function with result type $|"
   "returning from function with different return type}0,1"
   "|%diff{converting $ to type $|converting between types}0,1"
-
-
-
-
+  "|%diff{initializing $ with an expression of type $|"
+  "initializing with expression of different type}0,1"
+  "|%diff{sending $ to parameter of type $|"
+  "sending to parameter of different type}0,1"
+  "|%diff{casting $ to type $|casting between types}0,1}2"
+  " converts between pointers to integer types with different sign">,
+  InGroup<DiagGroup<"pointer-sign">>;
+def ext_typecheck_convert_incompatible_pointer : ExtWarn<
+  "incompatible pointer types "
+  "%select{%diff{assigning to $ from $|assigning to different types}0,1"
+  "|%diff{passing $ to parameter of type $|"
   "passing to parameter of different type}0,1"
   "|%diff{returning $ from a function with result type $|"
   "returning from function with different return type}0,1"
   "|%diff{converting $ to type $|converting between types}0,1"
   "|%diff{initializing $ with an expression of type $|"
   "initializing with expression of different type}0,1"
-
-
-
-  "%select{|; dereference with *|"
-  "; take the address with &|"
+  "|%diff{sending $ to parameter of type $|"
+  "sending to parameter of different type}0,1"
+  "|%diff{casting $ to type $|casting between types}0,1}2"
+  "%select{|; dereference with *|"
+  "; take the address with &|"
+  "; remove *|"
+  "; remove &}3">,
+  InGroup<IncompatiblePointerTypes>;
+def ext_typecheck_convert_discards_qualifiers : ExtWarn<
+  "%select{%diff{assigning to $ from $|assigning to different types}0,1"
+  "|%diff{passing $ to parameter of type $|"
+  "passing to parameter of different type}0,1"
   "|%diff{returning $ from a function with result type $|"
-  "qualifiers">,
-
-
-
-
+  "returning from function with different return type}0,1"
+  "|%diff{converting $ to type $|converting between types}0,1"
+  "|%diff{initializing $ with an expression of type $|"
+  "initializing with expression of different type}0,1"
+  "|%diff{sending $ to parameter of type $|"
+  "sending to parameter of different type}0,1"
+  "|%diff{casting $ to type $|casting between types}0,1}2"
+  " discards qualifiers">,
+  InGroup<IncompatiblePointerTypes>;
+def ext_nested_pointer_qualifier_mismatch : ExtWarn<
+  "%select{%diff{assigning to $ from $|assigning to different types}0,1"
+  "|%diff{passing $ to parameter of type $|"
   "passing to parameter of different type}0,1"
   "|%diff{returning $ from a function with result type $|"
   "returning from function with different return type}0,1"
-
-
-
-
+  "|%diff{converting $ to type $|converting between types}0,1"
+  "|%diff{initializing $ with an expression of type $|"
+  "initializing with expression of different type}0,1"
+  "|%diff{sending $ to parameter of type $|"
+  "sending to parameter of different type}0,1"
+  "|%diff{casting $ to type $|casting between types}0,1}2"
+  " discards qualifiers in nested pointer types">,
+  InGroup<IncompatiblePointerTypes>;
+def warn_incompatible_vectors : Warning<
+  "incompatible vector types "
+  "%select{%diff{assigning to $ from $|assigning to different types}0,1"
   "|%diff{passing $ to parameter of type $|"
   "passing to parameter of different type}0,1"
   "|%diff{returning $ from a function with result type $|"
   "returning from function with different return type}0,1"
   "|%diff{converting $ to type $|converting between types}0,1"
   "|%diff{initializing $ with an expression of type $|"
-
-
-
-
-  InGroup<VectorConversion>, DefaultIgnore;
+  "initializing with expression of different type}0,1"
+  "|%diff{sending $ to parameter of type $|"
+  "sending to parameter of different type}0,1"
+  "|%diff{casting $ to type $|casting between types}0,1}2">,
+  InGroup<VectorConversion>, DefaultIgnore;
+def err_int_to_block_pointer : Error<
+  "invalid block pointer conversion "
+  "%select{%diff{assigning to $ from $|assigning to different types}0,1"
+  "|%diff{passing $ to parameter of type $|"
+  "passing to parameter of different type}0,1"
+  "|%diff{returning $ from a function with result type $|"
+  "returning from function with different return type}0,1"
   "|%diff{converting $ to type $|converting between types}0,1"
   "|%diff{initializing $ with an expression of type $|"
-
-
-
-
-def err_typecheck_convert_incompatible_block_pointer : Error<
+  "initializing with expression of different type}0,1"
+  "|%diff{sending $ to parameter of type $|"
+  "sending to parameter of different type}0,1"
+  "|%diff{casting $ to type $|casting between types}0,1}2">;
+def err_typecheck_convert_incompatible_block_pointer : Error<
+  "incompatible block pointer types "
+  "%select{%diff{assigning to $ from $|assigning to different types}0,1"
+  "|%diff{passing $ to parameter of type $|"
+  "passing to parameter of different type}0,1"
+  "|%diff{returning $ from a function with result type $|"
+  "returning from function with different return type}0,1"
+  "|%diff{converting $ to type $|converting between types}0,1"
   "|%diff{initializing $ with an expression of type $|"
   "initializing with expression of different type}0,1"
   "|%diff{sending $ to parameter of type $|"
-
-
-def err_typecheck_incompatible_address_space : Error<
-  "%select{assigning %1 to %0"
+  "sending to parameter of different type}0,1"
+  "|%diff{casting $ to type $|casting between types}0,1}2">;
+def err_typecheck_incompatible_address_space : Error<
+  "%select{%diff{assigning $ to $|assigning to different types}1,0"
+  "|%diff{passing $ to parameter of type $|"
+  "passing to parameter of different type}0,1"
+  "|%diff{returning $ from a function with result type $|"
+  "returning from function with different return type}0,1"
+  "|%diff{converting $ to type $|converting between types}0,1"
+  "|%diff{initializing $ with an expression of type $|"
+  "initializing with expression of different type}0,1"
   "|%diff{sending $ to parameter of type $|"
   "sending to parameter of different type}0,1"
   "|%diff{casting $ to type $|casting between types}0,1}2"
-  " changes address space of pointer">;
-def err_typecheck_incompatible_ownership : Error<
-  "%select{assigning %1 to %0"
-  "|passing %0 to parameter of type %1"
+  " changes address space of pointer">;
+def err_typecheck_incompatible_ownership : Error<
+  "%select{%diff{assigning $ to $|assigning to different types}1,0"
+  "|%diff{passing $ to parameter of type $|"
+  "passing to parameter of different type}0,1"
+  "|%diff{returning $ from a function with result type $|"
+  "returning from function with different return type}0,1"
+  "|%diff{converting $ to type $|converting between types}0,1"
+  "|%diff{initializing $ with an expression of type $|"
+  "initializing with expression of different type}0,1"
+  "|%diff{sending $ to parameter of type $|"
   "sending to parameter of different type}0,1"
   "|%diff{casting $ to type $|casting between types}0,1}2"
-  " changes retain/release properties of pointer">;
-def err_typecheck_comparison_of_distinct_blocks : Error<
-  "comparison of distinct block types (%0 and %1)">;
-
+  " changes retain/release properties of pointer">;
+def err_typecheck_comparison_of_distinct_blocks : Error<
+  "comparison of distinct block types%diff{ ($ and $)|}0,1">;
+
+def err_typecheck_array_not_modifiable_lvalue : Error<
+  "array type %0 is not assignable">;  InGroup<CXX98Compat>, DefaultIgnore;
+
+def err_typecheck_call_invalid_ordered_compare : Error<
+  "ordered compare requires two args of floating point type"
+  "%diff{ ($ and $)|}0,1">;
+def err_typecheck_call_invalid_unary_fp : Error<
   "floating point classification requires argument of floating point type "
-  "(passed in %0)">;def err_typecheck_expect_scalar_operand : Error<
-  "operand of type %0 where arithmetic or pointer type is required">;
-def err_typecheck_cond_incompatible_operands : Error<
-  "incompatible operand types (%0 and %1)">;
-def ext_typecheck_cond_incompatible_operands_nonstandard : ExtWarn<
-  "incompatible operand types (%0 and %1) use non-standard composite pointer "
-  "type %2">;
+  "(passed in %0)">;def err_typecheck_expect_scalar_operand : Error<
+  "operand of type %0 where arithmetic or pointer type is required">;
+def err_typecheck_cond_incompatible_operands : Error<
+  "incompatible operand types%diff{ ($ and $)|}0,1">;
+def ext_typecheck_cond_incompatible_operands_nonstandard : ExtWarn<
+  "incompatible operand types%diff{ ($ and $)|}0,1 use non-standard composite "
+  "pointer type %2">;
+def err_cast_selector_expr : Error<
+  "cannot type cast @selector expression">;
+def warn_typecheck_cond_incompatible_pointers : ExtWarn<
+  "pointer type mismatch%diff{ ($ and $)|}0,1">,
   InGroup<DiagGroup<"pointer-type-mismatch">>;
 def warn_typecheck_cond_pointer_integer_mismatch : ExtWarn<
-  "pointer/integer type mismatch in conditional expression (%0 and %1)">,
-
-  InGroup<DiagGroup<"conditional-type-mismatch">>;
-def err_typecheck_choose_expr_requires_constant : Error<
-  "'__builtin_choose_expr' requires a constant expression">;  def err_asm_invalid_type_in_input : Error<
-    "invalid type %0 in asm input for constraint '%1'">;
-  def err_asm_tying_incompatible_types : Error<
+  "pointer/integer type mismatch in conditional expression"
+  "%diff{ ($ and $)|}0,1">,
+  InGroup<DiagGroup<"conditional-type-mismatch">>;
+def err_typecheck_choose_expr_requires_constant : Error<
+  "'__builtin_choose_expr' requires a constant expression">;  def err_asm_invalid_type_in_input : Error<
+    "invalid type %0 in asm input for constraint '%1'">;
+  def err_asm_tying_incompatible_types : Error<
+    "unsupported inline asm: input with type "
+    "%diff{$ matching output with type $|}0,1">;
+  def err_asm_unknown_register_name : Error<"unknown register name '%0' in asm">;
+  def warn_asm_label_on_auto_decl : Warning<
     "ignored asm label '%0' on automatic variable">;let CategoryName = "Semantic Issue" in {
 
-def err_invalid_conversion_between_vectors : Error<
+def err_invalid_conversion_between_vectors : Error<
   "invalid conversion between vector type%diff{ $ and $|}0,1 of different "
   "size">;
 def err_invalid_conversion_between_vector_and_integer : Error<

   "invalid conversion between vector type "
   "%diff{$ and integer type $|and integer type}0,1 of different size">;
 
-def err_invalid_conversion_between_vector_and_scalar : Error<
+def err_invalid_conversion_between_vector_and_scalar : Error<
+  "invalid conversion between vector type "
   "%diff{$ and scalar type $|and scalar type}0,1">;
 
 // C++ member initializers.

 def err_only_constructors_take_base_inits : Error<def warn_conv_to_base_not_used : Warning<
   "conversion function converting %0 to its base class %1 will never be used">;
 def warn_conv_to_void_not_used : Warning<
-  "conversion function converting %0 to %1 will never be used">;
+  "conversion function converting %diff{$ to $|between types}0,1 will never be "
   "used">;
-
-def warn_not_compound_assign : Warning<
+
+def warn_not_compound_assign : Warning<
   "use of unary operator that may be intended as compound assignment (%0=)">;def err_assoc_type_variably_modified : Error<
   "type %0 in generic association is a variably modified type">;
 def err_assoc_compatible_types : Error<
-  "type %0 in generic association compatible with previously specified type %1">;
+  "%diff{type $ in generic association compatible with previously specified "
   "type $|type in generic association compatible with previously specified "
   "type}0,1">;
-def note_compat_assoc : Note<
+def note_compat_assoc : Note<
+  "compatible type %0 specified here">;
 def err_generic_sel_no_match : Error<def note_switch_conversion : Note<
   "conversion to %select{integral|enumeration}0 type %1">;
 def err_switch_explicit_conversion : Error<

   "switch condition %diff{type $ requires explicit conversion to $|"
   "requires explicit conversion between types}0,1">;
 def err_switch_incomplete_class_type : Error<
-  "switch condition has incomplete class type %0">;
+  "switch condition has incomplete class type %0">;
+  "collection expression type %0 may not respond to %1">;
 
 def err_invalid_conversion_between_ext_vectors : Error<
   "invalid conversion between ext-vector type%diff{ $ and $|s}0,1">;

 
 def warn_duplicate_attribute : Warning<
   "attribute %0 is already applied with different parameters">;  "attributes on method implementation and its declaration must match">,
-  InGroup<DiagGroup<"mismatched-method-attributes">>;
+  InGroup<DiagGroup<"mismatched-method-attributes">>;
+def ext_typecheck_base_super : Warning<
   "method parameter type "
-  "super class method parameter type %1">, InGroup<SuperSubClassMismatch>, DefaultIgnore;
-
+  "%diff{$ does not match super class method parameter type $|"
+  "does not match super class method parameter type}0,1">,
    InGroup<SuperSubClassMismatch>, DefaultIgnore;
 def warn_missing_method_return_type : Warning<
-  "method has no return type specified; defaults to 'id'">,
+  "method has no return type specified; defaults to 'id'">,
+  InGroup<MissingMethodReturnType>, DefaultIgnore;
 // OpenCL warnings and errors.
 def err_invalid_astype_of_different_size : Error<
   "invalid reinterpretation: sizes of %diff{$ and $|types}0,1 must match">;

 def err_static_kernel : Error<
   "kernel functions cannot be declared static">;
 def err_static_function_scope : Error<let CategoryName = "Related Result Type Issue" in {
-// Objective-C related result type compatibility
+// Objective-C related result type compatibility
+def warn_related_result_type_compatibility_class : Warning<
   "method is expected to return an instance of its class type "
   "%diff{$, but is declared to return $|"
   ", but is declared to return different type}0,1">;

 def warn_related_result_type_compatibility_protocol : Warning<
   "protocol method is expected to return an instance of the implementing "
   "class, but is declared to return %0">;
-
+
+
+
 
 
 

 
 
 
-
+
+
 
 
 

 
 
 
-
+
 
 
 

 
 
 
-
-
+
+
+
+
 
 
 

 
 
 
-
+
 
 
 

 
 
 
-
-
+
+
+
 
 
 

test/Misc/template-type-diffing/1.cpp

+// RUN: %clang_cc1 %s -fsyntax-only -verify
+//err_different_return_type_for_overriding_virtual_function
+
+template<class, class> class map{};
+
+class A {
+  public:
+  virtual map<void, void> getmap(); // expected-note{{overridden virtual function is here}}
+};
+
+class B : public A {
+  public:
+  map<int, void> getmap(); // expected-error{{virtual function 'getmap' has a different return type ('map<int, [...]>') than the function it overrides (which has return type 'map<void, [...]>')}}
+};
+

test/Misc/template-type-diffing/1.mm

+// RUN: %clang_cc1 %s -fobjc-runtime=macosx-fragile-10.5 -fsyntax-only -verify
+//err_conflicting_ivar_type
+
+template<class, class> class map{};
+
+@interface Base{
+  map<void, void> isa; // expected-note{{previous definition is here}}
+}
+@end
+
+@implementation Base {
+  map<int, void> isa;  // expected-error{{instance variable 'isa' has conflicting type: 'map<int, [...]>' vs 'map<void, [...]>'}}
+}
+@end
+

test/Misc/template-type-diffing/10.cpp

+// RUN: %clang_cc1 %s -fsyntax-only -verify
+//err_bad_cxx_cast_generic
+
+template<class, class> class map {};
+void foo() {
+  (void)reinterpret_cast<map<int, int> >(map<int, int>()); // expected-error {{reinterpret_cast from 'map<[2 * ...]>' to 'map<[2 * ...]>' is not allowed}}
+  (void)reinterpret_cast<map<int, int> >(map<int, void>()); // expected-error {{reinterpret_cast from 'map<[...], void>' to 'map<[...], int>' is not allowed}}
+}

test/Misc/template-type-diffing/11.cpp

+// RUN: %clang_cc1 %s -fsyntax-only -verify
+//err_conditional_ambiguous_ovl
+template<class, class> class map { operator int&(); operator double&(); };
+
+void foo(bool cond, map<int, int> a, map<double, int> b) {
+  (void) (cond ? a : b);  // expected-error{{conditional expression is ambiguous; 'map<int, [...]>' and 'map<double, [...]>' can be converted to several common types}}
+}
+
+//err_conditional_ambiguous
+template<class A, class B, class C> class tri { operator tri<C, B, A>(); };
+
+void bar(bool cond, tri<int, void, double> a, tri<double, void, int> b) {
+  (void) (cond ? a : b);  // expected-error{{conditional expression is ambiguous; 'tri<int, [...], double>' can be converted to 'tri<double, [...], int>' and vice versa}}
+}

test/Misc/template-type-diffing/12.cpp

+// RUN: %clang_cc1 %s -fsyntax-only -verify
+//err_typecheck_nonviable_condition
+
+template<class, class> class map { }; // expected-note {{candidate constructor (the implicit copy constructor) not viable: no known conversion from 'map<int, int>' to 'const map<int, void> &' for 1st argument}}
+template<class T> void foo(T a, T b = map<int, int>()) {} // expected-error {{no viable conversion from 'map<[...], int>' to 'map<[...], void>'}} \
+  // expected-note {{passing argument to parameter 'b' here}}
+
+void test1() {
+  foo(map<int, void>()); // expected-note{{in instantiation of default function argument expression for 'foo<map<int, void> >' required here}}
+}
+
+//err_typecheck_ambiguous_condition
+template<class A, class B, class C> struct tri {
+  operator tri<C, B, A>() const;  // expected-note {{candidate function}}
+  tri(const tri<C, B, A>&);  // expected-note {{candidate constructor}}
+  tri();
+};
+
+void bar(tri<double, long, int>);  // expected-note {{passing argument to parameter here}}
+
+void test2() {
+  tri<int, long, double> a;
+  bar(a); // expected-error {{conversion from 'tri<int, [...], double>' to 'tri<double, [...], int>' is ambiguous}}
+}

test/Misc/template-type-diffing/13.cpp

+// RUN: %clang_cc1 %s -fsyntax-only -verify -std=c++11
+
+template<class, class> struct map {
+  map();
+  template<class A, class B> map(map<A,B>) = delete; // expected-note {{function has been explicitly marked deleted here}}
+};
+
+void foo() {
+  map<int, int> m1;
+  map<int, double> m2 = m1; // expected-error {{conversion function from 'map<[...], int>' to 'map<[...], double>' invokes a deleted function}}
+}

test/Misc/template-type-diffing/14.cpp

+// RUN: %clang_cc1 %s -fsyntax-only -verify 
+//err_typecheck_convert_incompatible
+template<class, class> struct map { };
+
+void foo() {
+  void (map<int, int>::*A)();
+  void (map<double, int>::*B)();
+  A = B;  // expected-error{{assigning to 'void (map<int, int>::*)()' from incompatible type 'void (map<double, int>::*)()': different classes ('map<int, [...]>' vs 'map<double, [...]>')}}
+
+  void (*C)(map<int, int>);
+  void (*D)(map<int, double>);
+  C = D;  // expected-error{{assigning to 'void (*)(map<int, int>)' from incompatible type 'void (*)(map<int, double>)': type mismatch at 1st parameter ('map<[...], int>' vs 'map<[...], double>')}}
+
+  map<int, float> (*E)();
+  map<int, double> (*F)();
+  E = F;  // expected-error{{assigning to 'map<int, float> (*)()' from incompatible type 'map<int, double> (*)()': different return type ('map<[...], float>' vs 'map<[...], double>')}}
+}

test/Misc/template-type-diffing/15.cpp

+// RUN: %clang_cc1 %s -fsyntax-only -verify 
+//err_typecheck_cond_incompatible_operands
+
+template<class, class> struct map { };
+
+void foo(bool cond, map<int, int> a, map<int, double> b) {
+  (void)(cond ? a : b);  // expected-error {{incompatible operand types ('map<[...], int>' and 'map<[...], double>')}}
+}

test/Misc/template-type-diffing/2.cpp

+// RUN: %clang_cc1 %s -fsyntax-only -verify
+// err_init_conversion_failed
+
+template<class, class> class map{ public: void test(); };
+
+map<int, int> A() { return map<int, int>(); }
+map<int, void> (*B)() = A;  // expected-error{{cannot initialize a variable of type 'map<int, void> (*)()' with an lvalue of type 'map<int, int> ()': different return type ('map<[...], void>' vs 'map<[...], int>')}}
+
+void C(int, map<double, float>) {}
+void (*D)(int, map<double, double>) = C;  // expected-error{{cannot initialize a variable of type 'void (*)(int, map<double, double>)' with an lvalue of type 'void (int, map<double, float>)': type mismatch at 2nd parameter ('map<[...], double>' vs 'map<[...], float>')}}
+
+void (map<int, int>::*E)() = &map<int, double>::test;  // expected-error{{cannot initialize a variable of type 'void (map<int, int>::*)()' with an rvalue of type 'void (map<int, double>::*)()': different classes ('map<[...], int>' vs 'map<[...], double>')}}

test/Misc/template-type-diffing/2.mm

+// RUN: %clang_cc1 %s -Woverriding-method-mismatch -fsyntax-only -verify
+
+template<class, class> class map{};
+
+// warn_conflicting_overriding_ret_types
+@protocol Bar
+@required
+- (map<int, double>) f1; // expected-note {{previous declaration is here}}
+@end
+
+@interface Bar<Bar>
+- (map<int, float>) f1; // expected-warning {{conflicting return type in declaration of 'f1': 'map<[...], double>' vs 'map<[...], float>'}}
+@end
+
+// warn_conflicting_overriding_param_types
+@protocol Baz <Bar>
+- (void) bar : (map<int, int>)arg; // expected-note {{previous declaration is here}}
+@end
+
+@interface Foo <Baz>
+- (void) bar : (map<double, int>)arg; // expected-warning {{conflicting parameter types in declaration of 'bar:': 'map<int, [...]>' vs 'map<double, [...]>'}}
+@end
+

test/Misc/template-type-diffing/3.cpp

+// RUN: %clang_cc1 %s -fsyntax-only -verify
+// err_lvalue_reference_bind_to_unrelated
+
+template<class, class> class map{};
+
+map<int, int> A;
+map<void, int> &B = A; // expected-error{{non-const lvalue reference to type 'map<void, [...]>' cannot bind to a value of unrelated type 'map<int, [...]>'}}

test/Misc/template-type-diffing/3.mm

+// RUN: %clang_cc1 %s -fsyntax-only -verify
+// warn_conflicting_ret_types
+
+template<class, class> class map{};
+
+@interface Bar
+- (map<int, double>) f1; // expected-note{{previous definition is here}}
+@end
+
+@implementation Bar
+- (map<int, float>) f1 { // expected-warning {{conflicting return type in implementation of 'f1': 'map<[...], double>' vs 'map<[...], float>'}}
+    return map<int, float>();
+  }
+@end
+
+// warn_conflicting_param_types
+
+@interface A
+@property map<double, double> moo; // expected-note {{previous definition is here}}
+@end
+
+@implementation A
+-(map<double, double>) moo {
+  return map<double, double>();
+}
+-(void) setMoo: (map<double, int>) x { // expected-warning {{conflicting parameter types in implementation of 'setMoo:': 'map<[...], double>' vs 'map<[...], int>'}}
+}
+@end
+

test/Misc/template-type-diffing/4.cpp

+// RUN: %clang_cc1 %s -fsyntax-only -verify
+//note_ovl_candidate
+
+template<class, class> class map {};
+
+map<int, void> foo(map<int,int>); // expected-note {{candidate function has different return type ('map<[...], int>' expected but has 'map<[...], void>')}}
+map<int, int> foo(map<void, int>); // expected-note {{candidate function has type mismatch at 1st parameter (expected 'map<int, [...]>' but has 'map<void, [...]>')}}
+
+map<int,int> (*bar)(map<int, int>) = foo; // expected-error {{address of overloaded function 'foo' does not match required type 'map<int, int> (map<int, int>)'}}

test/Misc/template-type-diffing/5.cpp

+// RUN: %clang_cc1 %s -fsyntax-only -verify
+//note_ovl_candidate_inconsistent_deduction
+
+template<class, class> class map {};
+template<class T> void foo(T, T); // expected-note{{candidate template ignored: deduced conflicting types for parameter 'T' ('map<[...], int>' vs. 'map<[...], double>')}}
+
+void test(map<int, int> A, map<int, double> B) {
+  foo(A, B); // expected-error{{no matching function for call to 'foo'}}
+}
+

test/Misc/template-type-diffing/6.cpp

+// RUN: %clang_cc1 %s -fsyntax-only -verify
+// err_ovl_no_viable_conversion_in_cast
+
+template<class T, class U> class map {  // expected-note 2{{candidate constructor}}
+  void foo(T t) { 
+    (void)U(t);  // expected-error {{no matching conversion for functional-style cast from 'map<int, [...]>' to 'map<float, [...]>'}}
+  }
+};
+struct A {};
+template class map<map<int, float>, map<float,float> >; // expected-note {{in instantiation of member function}}

test/Misc/template-type-diffing/7.cpp

+// RUN: %clang_cc1 %s -fsyntax-only -verify -std=c++11
+//err_redefinition_different_typedef
+
+template<class, class> class map {};
+namespace foo {
+  using M = map<int, int>;  // expected-note {{previous definition is here}}
+  using M = map<int, double>;  // expected-error {{type alias redefinition with different types ('map<[...], double>' vs 'map<[...], int>')}}
+}

test/Misc/template-type-diffing/8.cpp

+// RUN: %clang_cc1 %s -fsyntax-only -verify
+//note_member_def_close_param_match
+
+template<class, class> class map {};
+namespace foo {
+  void f(map<int, double> F);  // expected-note {{type of 1st parameter of member declaration does not match definition ('map<[...], double>' vs 'map<[...], float>')}}
+}
+
+void foo::f(map<int, float> F) { }  // expected-error {{out-of-line definition of 'f' does not match any declaration in namespace 'foo'}}

test/Misc/template-type-diffing/9.cpp

+// RUN: %clang_cc1 %s -fsyntax-only -verify
+//err_typecheck_invalid_operands
+
+template<class, class> class map {};
+void foo() {
+  map<int, int>() + map<void, int>();  // expected-error {{invalid operands to binary expression ('map<int, [...]>' and 'map<void, [...]>')}}
+  map<int, int>() + map<int, int>();  // expected-error {{invalid operands to binary expression ('map<[2 * ...]>' and 'map<[2 * ...]>')}}
+}