Implement DR1601 - Promotion of enumeration with fixed underlying type

[ismailp]

Summary

Essentially, clang will accept the following in C++11 and forth:

enum B : bool { b };
enum C : char { c };

int &func(bool);
double &func(char);
void func(unsigned);
void func(long);

void g() {
  int &r = func(b);
  double &d = func(c);
}

[rsmith]

lib/Sema/SemaOverload.cpp

3850–3853

This should probably go after all the standard orderings.

3872

I don't think it makes sense to condition this on C++11 mode: we support fixed underlying types for enums in C++98 as an extension, and they should get this behavior too.

3874–3879

This does not check that the "other" conversion converts to the promoted underlying type. It looks like this would (incorrectly) also order a case like:

enum A : char { a };
void f(char);
void f(const char&);
void g() { f(a); }

lib/Sema/SemaOverload.cpp

if (SCS1.BindsImplicitObjectArgumentWithoutRefQualifier ||
     return false;
 
   return (!SCS1.IsLvalueReference && SCS1.BindsToRvalue &&
           SCS2.IsLvalueReference) ||
          (SCS1.IsLvalueReference && SCS1.BindsToFunctionLvalue &&
           !SCS2.IsLvalueReference && SCS2.BindsToFunctionLvalue);
 }
 
+/// \brief Returns whether given standard conversion sequence is converting an
+/// unscoped enumeration, whose underlying type is fixed, to its underlying
+/// type.
+static bool
+isEnumConversionToUnderlyingType(const ASTContext &Context,
+                                 const StandardConversionSequence &SCS) {
+  QualType FromType = SCS.getFromType();
+
+  const EnumType *FromEnumType = FromType->getAs<EnumType>();
+  if (!FromEnumType || FromEnumType->getDecl()->isScoped() ||
+      !FromEnumType->getDecl()->isFixed())
+    return false;
+
+  QualType ToType = SCS.getToType(1);
+  QualType Underlying = FromEnumType->getDecl()->getIntegerType();
+  return Context.hasSameUnqualifiedType(Underlying, ToType);
+}
+
 /// CompareStandardConversionSequences - Compare two standard
 /// conversion sequences to determine whether one is better than the
 /// other or if they are indistinguishable (C++ 13.3.3.2p3).
 static ImplicitConversionSequence::CompareKind
 CompareStandardConversionSequences(Sema &S, SourceLocation Loc,
                                    const StandardConversionSequence& SCS1,
                                    const StandardConversionSequence& SCS2)
 {
if (UnqualT1 == UnqualT2) {
         T2 = S.Context.getQualifiedType(UnqualT2, T2Quals);
       if (T2.isMoreQualifiedThan(T1))
         return ImplicitConversionSequence::Better;
       else if (T1.isMoreQualifiedThan(T2))
         return ImplicitConversionSequence::Worse;      
     }
   }
 
   // In Microsoft mode, prefer an integral conversion to a
   // floating-to-integral conversion if the integral conversion
   // is between types of the same size.
   // For example:
   // void f(float);
   // void f(int);
   // int main {
   //    long a;
   //    f(a);
   // }
   // Here, MSVC will call f(int) instead of generating a compile error
   // as clang will do in standard mode.
   if (S.getLangOpts().MSVCCompat && SCS1.Second == ICK_Integral_Conversion &&
       SCS2.Second == ICK_Floating_Integral &&
       S.Context.getTypeSize(SCS1.getFromType()) ==
           S.Context.getTypeSize(SCS1.getToType(2)))
     return ImplicitConversionSequence::Better;
 
+  // Per DR1601, which is included in C++14; 13.3.3.2p4b2
+  //  -- A conversion that promotes an enumeration whose underlying type is
+  //     fixed to its underlying type is better than one that promotes to the
+  //     promoted underlying type, if the two are different.
+  if (S.getLangOpts().CPlusPlus11 &&
+      (SCS1.getToType(1).getTypePtr() != SCS2.getToType(1).getTypePtr())) {
+    bool S1ConvResult = isEnumConversionToUnderlyingType(S.Context, SCS1);
+    bool S2ConvResult = isEnumConversionToUnderlyingType(S.Context, SCS2);
+    if (S1ConvResult && !S2ConvResult)
+      return ImplicitConversionSequence::Better;
+    else if (!S1ConvResult && S2ConvResult)
+      return ImplicitConversionSequence::Worse;
+  }
   return ImplicitConversionSequence::Indistinguishable;
 }
 
 /// CompareQualificationConversions - Compares two standard conversion
 /// sequences to determine whether they can be ranked based on their
 /// qualification conversions (C++ 13.3.3.2p3 bullet 3).
 static ImplicitConversionSequence::CompareKind
 CompareQualificationConversions(Sema &S,

test/CXX/drs/dr16xx.cpp

 // RUN: %clang_cc1 -std=c++98 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++11 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++14 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 // RUN: %clang_cc1 -std=c++1z -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
 
+namespace dr1601 {
+#if __cplusplus >= 201103L
+  enum B : bool { b };
+  enum C : char { c };
+  enum E { e };
+
+  int &func(bool);      // expected-note{{candidate function}}
+  double &func(char);   // expected-note{{candidate function}}
+  void func(unsigned);  // expected-note{{candidate function}}
+  void func(long);      // expected-note{{candidate function}}
+
+  void g() {
+    int &r = func(b);
+    double &d = func(c);
+    func(e);  // expected-error {{call to 'func' is ambiguous}}
+  }
+#endif
+}
+
 namespace dr1611 { // dr1611: dup 1658
   struct A { A(int); };
   struct B : virtual A { virtual void f() = 0; };
   struct C : B { C() : A(0) {} void f(); };
   C c;
 }
 
 namespace dr1684 { // dr1684: 3.6