Bugs in SemaOverload.cpp

[dbabokin]

Summary

I've noticed that GetConversionCategory(), GetConversionRank() and GetImplicitConversionName() from lib/Sema/SemaOverload.cpp have a bunch of bugs, namely:

• GetConversionCategory() is missing cases for ICK_TransparentUnionConversion, ICK_Writeback_Conversion and ICK_Zero_Event_Conversion cases (ok to not handle ICK_Num_Conversion_Kinds, though would be good to report an error);
• GetConversionRank() is missing the case for ICK_Zero_Event_Conversion;
• GetImplicitConversionName() doesn't have a comma after "Transparent Union Conversion";

I think it's better to rewrite these functions using switch, so adding new ICKs would trigger a warning or an error if it's not handled in these functions.

Except style changes and typo fix (missing comma), the changes add case for missing records, please verify that they've got correct values.

I have no commit rights, so I would appreciate if reviewer commits the patch. Thanks!

lib/Sema/SemaOverload.cpp

CompareDerivedToBaseConversions(Sema &S,
                                 const StandardConversionSequence& SCS2);
 
 
 
 /// GetConversionCategory - Retrieve the implicit conversion
 /// category corresponding to the given implicit conversion kind.
 ImplicitConversionCategory
 GetConversionCategory(ImplicitConversionKind Kind) {
-  static const ImplicitConversionCategory
-    Category[(int)ICK_Num_Conversion_Kinds] = {
-    ICC_Identity,
-    ICC_Lvalue_Transformation,
-    ICC_Lvalue_Transformation,
-    ICC_Lvalue_Transformation,
-    ICC_Identity,
-    ICC_Qualification_Adjustment,
-    ICC_Promotion,
-    ICC_Promotion,
-    ICC_Promotion,
-    ICC_Conversion,
-    ICC_Conversion,
-    ICC_Conversion,
-    ICC_Conversion,
-    ICC_Conversion,
-    ICC_Conversion,
-    ICC_Conversion,
-    ICC_Conversion,
-    ICC_Conversion,
-    ICC_Conversion,
-    ICC_Conversion,
-    ICC_Conversion,
-    ICC_Conversion
-  };
-  return Category[(int)Kind];
+  switch (Kind) {
+    case ICK_Identity:
+      return ICC_Identity;
+
+    case ICK_Lvalue_To_Rvalue:
+    case ICK_Array_To_Pointer:
+    case ICK_Function_To_Pointer:
+      return ICC_Lvalue_Transformation;
+
+    case ICK_NoReturn_Adjustment:
+      return ICC_Identity;
+
+    case ICK_Qualification:
+      return ICC_Qualification_Adjustment;
+
+    case ICK_Integral_Promotion:
+    case ICK_Floating_Promotion:
+    case ICK_Complex_Promotion:
+      return ICC_Conversion;
+
+    case ICK_Integral_Conversion:
+    case ICK_Floating_Conversion:
+    case ICK_Complex_Conversion:
+    case ICK_Floating_Integral:
+    case ICK_Pointer_Conversion:
+    case ICK_Pointer_Member:
+    case ICK_Boolean_Conversion:
+    case ICK_Compatible_Conversion:
+    case ICK_Derived_To_Base:
+    case ICK_Vector_Conversion:
+    case ICK_Vector_Splat:
+    case ICK_Complex_Real:
+    case ICK_Block_Pointer_Conversion:
+    case ICK_TransparentUnionConversion:
+    case ICK_Writeback_Conversion:
+    case ICK_Zero_Event_Conversion:
+      return ICC_Conversion;
+
+    case ICK_Num_Conversion_Kinds:
+      llvm_unreachable(
+          "GetConversionCategory(): Kind is ICK_Num_Conversion_Kinds");
+  }
 }
 
 /// GetConversionRank - Retrieve the implicit conversion rank
 /// corresponding to the given implicit conversion kind.
 ImplicitConversionRank GetConversionRank(ImplicitConversionKind Kind) {
-  static const ImplicitConversionRank
-    Rank[(int)ICK_Num_Conversion_Kinds] = {
-    ICR_Exact_Match,
-    ICR_Exact_Match,
-    ICR_Exact_Match,
-    ICR_Exact_Match,
-    ICR_Exact_Match,
-    ICR_Exact_Match,
-    ICR_Promotion,
-    ICR_Promotion,
-    ICR_Promotion,
-    ICR_Conversion,
-    ICR_Conversion,
-    ICR_Conversion,
-    ICR_Conversion,
-    ICR_Conversion,
-    ICR_Conversion,
-    ICR_Conversion,
-    ICR_Conversion,
-    ICR_Conversion,
-    ICR_Conversion,
-    ICR_Conversion,
-    ICR_Complex_Real_Conversion,
-    ICR_Conversion,
-    ICR_Conversion,
-    ICR_Writeback_Conversion
-  };
-  return Rank[(int)Kind];
+  switch (Kind) {
+    case ICK_Identity:
+    case ICK_Lvalue_To_Rvalue:
+    case ICK_Array_To_Pointer:
+    case ICK_Function_To_Pointer:
+    case ICK_NoReturn_Adjustment:
+    case ICK_Qualification:
+      return ICR_Exact_Match;
+
+    case ICK_Integral_Promotion:
+    case ICK_Floating_Promotion:
+    case ICK_Complex_Promotion:
+      return ICR_Promotion;
+
+    case ICK_Integral_Conversion:
+    case ICK_Floating_Conversion:
+    case ICK_Complex_Conversion:
+    case ICK_Floating_Integral:
+    case ICK_Pointer_Conversion:
+    case ICK_Pointer_Member:
+    case ICK_Boolean_Conversion:
+    case ICK_Compatible_Conversion:
+    case ICK_Derived_To_Base:
+    case ICK_Vector_Conversion:
+    case ICK_Vector_Splat:
+      return ICR_Conversion;
+
+    case ICK_Complex_Real:
+      return ICR_Complex_Real_Conversion;
+
+    case ICK_Block_Pointer_Conversion:
+    case ICK_TransparentUnionConversion:
+      return ICR_Conversion;
+
+    case ICK_Writeback_Conversion:
+      return ICR_Writeback_Conversion;
+
+    case ICK_Zero_Event_Conversion:
+      return ICR_Conversion;
+
+    case ICK_Num_Conversion_Kinds:
+      llvm_unreachable(
+          "GetConversionRank(): Kind is ICK_Num_Conversion_Kinds");
+  }
 }
 
 /// GetImplicitConversionName - Return the name of this kind of
 /// implicit conversion.
 const char* GetImplicitConversionName(ImplicitConversionKind Kind) {
-  static const char* const Name[(int)ICK_Num_Conversion_Kinds] = {
-    "No conversion",
-    "Lvalue-to-rvalue",
-    "Array-to-pointer",
-    "Function-to-pointer",
-    "Noreturn adjustment",
-    "Qualification",
-    "Integral promotion",
-    "Floating point promotion",
-    "Complex promotion",
-    "Integral conversion",
-    "Floating conversion",
-    "Complex conversion",
-    "Floating-integral conversion",
-    "Pointer conversion",
-    "Pointer-to-member conversion",
-    "Boolean conversion",
-    "Compatible-types conversion",
-    "Derived-to-base conversion",
-    "Vector conversion",
-    "Vector splat",
-    "Complex-real conversion",
-    "Block Pointer conversion",
-    "Transparent Union Conversion"
-    "Writeback conversion"
-  };
-  return Name[Kind];
+  switch (Kind) {
+    case ICK_Identity: return "No conversion";
+    case ICK_Lvalue_To_Rvalue: return "Lvalue-to-rvalue";
+    case ICK_Array_To_Pointer: return "Array-to-pointer";
+    case ICK_Function_To_Pointer: return "Function-to-pointer";
+    case ICK_NoReturn_Adjustment: return "Noreturn adjustment";
+    case ICK_Qualification: return "Qualification";
+    case ICK_Integral_Promotion: return "Integral promotion";
+    case ICK_Floating_Promotion: return "Floating point promotion";
+    case ICK_Complex_Promotion: return "Complex promotion";
+    case ICK_Integral_Conversion: return "Integral conversion";
+    case ICK_Floating_Conversion: return "Floating conversion";
+    case ICK_Complex_Conversion: return "Complex conversion";
+    case ICK_Floating_Integral: return "Floating-integral conversion";
+    case ICK_Pointer_Conversion: return "Pointer conversion";
+    case ICK_Pointer_Member: return "Pointer-to-member conversion";
+    case ICK_Boolean_Conversion: return "Boolean conversion";
+    case ICK_Compatible_Conversion: return "Compatible-types conversion";
+    case ICK_Derived_To_Base: return "Derived-to-base conversion";
+    case ICK_Vector_Conversion: return "Vector conversion";
+    case ICK_Vector_Splat: return "Vector splat";
+    case ICK_Complex_Real: return "Complex-real conversion";
+    case ICK_Block_Pointer_Conversion: return "Block Pointer conversion";
+    case ICK_TransparentUnionConversion: return "Transparent Union conversion";
+    case ICK_Writeback_Conversion: return "Writeback conversion";
+    case ICK_Zero_Event_Conversion: return "Zero Event conversion";
+    case ICK_Num_Conversion_Kinds:
+      llvm_unreachable(
+          "GetImplicitConversionName(): Kind is ICK_Num_Conversion_Kinds");
+  }
 }
 
 /// StandardConversionSequence - Set the standard conversion
 /// sequence to the identity conversion.
 void StandardConversionSequence::setAsIdentityConversion() {
   First = ICK_Identity;
   Second = ICK_Identity;
   Third = ICK_Identity;