Index: lib/Sema/SemaOverload.cpp
===================================================================
--- lib/Sema/SemaOverload.cpp
+++ lib/Sema/SemaOverload.cpp
@@ -108,97 +108,132 @@
 /// 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