[Sema] Classify conversions from enum to float as narrowing

[miyuki]

Summary

According to [dcl.init.list]p7:

A narrowing conversion is an implicit conversion
- ...
- from an integer type or unscoped enumeration type to a
  floating-point type, except where the source is a constant
  expression and the actual value after conversion will fit into
  the target type and will produce the original value when
  converted back to the original type, or
- ...

Currently clang does not handle the 'unscoped enumeration' case. This
patch fixes the corresponding check.

[miyuki]

ping

[rogfer01]

I understand you're fixing the narrowing check from "unscoped enum/integer type" → float.

But you have also extended some tests which are "unscoped enum" → integer type (lines 153, 170 and 173). So I presume they were already handled correctly before your patch. Can these be submitted separatedly?

[miyuki]

Removed the changes that are unrelated to the 'enum->float' case from the test.

[miyuki]

ping

[rogfer01]

Looks good to me now. Wait a couple of days before submitting it just in case the other reviewers have more comments.

Do you plan to submit (in another change) the unscoped enum → integer type testcases? If this is not currently tested anywhere I think it may be a good thing to have them too.

[miyuki]

In D42545#1010335, @rogfer01 wrote:

Do you plan to submit (in another change) the unscoped enum → integer type testcases? If this is not currently tested anywhere I think it may be a good thing to have them too.

Yes, I'll submit them in a follow-up patch.

lib/Sema/SemaOverload.cpp

StandardConversionSequence::getNarrowingKind(ASTContext &Ctx,
   // -- from an integer type or unscoped enumeration type to a floating-point
   //    type, except where the source is a constant expression and the actual
   //    value after conversion will fit into the target type and will produce
   //    the original value when converted back to the original type, or
   case ICK_Floating_Integral:
   FloatingIntegralConversion:
     if (FromType->isRealFloatingType() && ToType->isIntegralType(Ctx)) {
       return NK_Type_Narrowing;
-    } else if (FromType->isIntegralType(Ctx) && ToType->isRealFloatingType()) {
+    } else if (FromType->isIntegralOrUnscopedEnumerationType() &&
+               ToType->isRealFloatingType()) {
       llvm::APSInt IntConstantValue;
       const Expr *Initializer = IgnoreNarrowingConversion(Converted);
       assert(Initializer && "Unknown conversion expression");
 
       // If it's value-dependent, we can't tell whether it's narrowing.
       if (Initializer->isValueDependent())
         return NK_Dependent_Narrowing;
 

test/CXX/dcl.decl/dcl.init/dcl.init.list/p7-0x.cpp

void std_example() {
   int ii = {2.0};  // expected-error {{ cannot be narrowed }} expected-note {{silence}}
   float f1 { x };  // expected-error {{ cannot be narrowed }} expected-note {{silence}}
   float f2 { 7 };  // OK: 7 can be exactly represented as a float
   int f(int);
   int a[] =
     { 2, f(2), f(2.0) };  // OK: the double-to-int conversion is not at the top level
 }
 
+enum UnscopedEnum {
+  EnumVal = 300
+};
+
 // Test each rule individually.
 
 template<typename T>
 struct Agg {
   T t;
 };
 
 template<typename T>

 
 // * from an integer type or unscoped enumeration type to a floating-point type,
 //   except where the source is a constant expression and the actual value after
 //   conversion will fit into the target type and will produce the original
 //   value when converted back to the original type, or
 void int_to_float() {
   // Not a constant expression.
   char c = 1;
+  UnscopedEnum e = EnumVal;
 
   // Variables.  Yes, even though all char's will fit into any floating type.
   Agg<float> f1 = {c};  // expected-error {{ cannot be narrowed }} expected-note {{silence}}
   Agg<double> f2 = {c};  // expected-error {{ cannot be narrowed }} expected-note {{silence}}
   Agg<long double> f3 = {c};  // expected-error {{ cannot be narrowed }} expected-note {{silence}}
 
+  Agg<float> f4 = {e};  // expected-error {{ cannot be narrowed }} expected-note {{silence}}
+  Agg<double> f5 = {e};  // expected-error {{ cannot be narrowed }} expected-note {{silence}}
+  Agg<long double> f6 = {e};  // expected-error {{ cannot be narrowed }} expected-note {{silence}}
+
   // Constants.
-  Agg<float> f4 = {12345678};  // OK (exactly fits in a float)
-  Agg<float> f5 = {123456789};  // expected-error {{ cannot be narrowed }} expected-note {{silence}}
+  Agg<float> f7 = {12345678};  // OK (exactly fits in a float)
+  Agg<float> f8 = {EnumVal};  // OK
+  Agg<float> f9 = {123456789};  // expected-error {{ cannot be narrowed }} expected-note {{silence}}
 
   Agg<float> ce1 = { Convert<int>(123456789) }; // expected-error {{constant expression evaluates to 123456789 which cannot be narrowed to type 'float'}} expected-note {{silence}}
   Agg<double> ce2 = { ConvertVar<long long>() }; // expected-error {{non-constant-expression cannot be narrowed from type 'long long' to 'double'}} expected-note {{silence}}
 }
 
 // * from an integer type or unscoped enumeration type to an integer type that
 //   cannot represent all the values of the original type, except where the
 //   source is a constant expression and the actual value after conversion will