===================================================================
@@ -1658,8 +1658,9 @@ build_expr_type_conversion (int desires, tree expr
{
error ("ambiguous default type conversion from %qT",
basetype);
- error (" candidate conversions include %qD and %qD",
- winner, cand);
+ inform (input_location,
+ " candidate conversions include %qD and %qD",
+ winner, cand);
}
return error_mark_node;
}
===================================================================
@@ -12966,14 +12966,32 @@ build_enumerator (tree name, tree value, tree enum
/* Validate and default VALUE. */
if (value != NULL_TREE)
{
- value = cxx_constant_value (value);
+ if (ENUM_UNDERLYING_TYPE (enumtype))
+ value = perform_implicit_conversion_flags
+ (ENUM_UNDERLYING_TYPE (enumtype), value, tf_warning_or_error,
+ LOOKUP_IMPLICIT | LOOKUP_NO_NARROWING);
+ else
+ {
+ tree tmp_value = build_expr_type_conversion (WANT_INT | WANT_ENUM,
+ value, true);
+ if (tmp_value)
+ value = tmp_value;
+ }
- if (TREE_CODE (value) != INTEGER_CST
- || ! INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (value)))
+ if (value == error_mark_node)
+ value = NULL_TREE;
+
+ if (value != NULL_TREE)
{
- error ("enumerator value for %qD is not an integer constant",
- name);
- value = NULL_TREE;
+ value = cxx_constant_value (value);
+
+ if (TREE_CODE (value) != INTEGER_CST
+ || ! INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (value)))
+ {
+ error ("enumerator value for %qD is not an integer constant",
+ name);
+ value = NULL_TREE;
+ }
}
}
@@ -13036,25 +13054,25 @@ incremented enumerator value is too large for %<lo
}
else
value = integer_zero_node;
- }
- /* Remove no-op casts from the value. */
- STRIP_TYPE_NOPS (value);
+ /* Remove no-op casts from the value. */
+ STRIP_TYPE_NOPS (value);
- /* If the underlying type of the enum is fixed, check whether
- the enumerator values fits in the underlying type. If it
- does not fit, the program is ill-formed [C++0x dcl.enum]. */
- if (ENUM_UNDERLYING_TYPE (enumtype)
- && value
- && TREE_CODE (value) == INTEGER_CST)
- {
- if (!int_fits_type_p (value, ENUM_UNDERLYING_TYPE (enumtype)))
- error ("enumerator value %E is outside the range of underlying "
- "type %<%T%>", value, ENUM_UNDERLYING_TYPE (enumtype));
+ /* If the underlying type of the enum is fixed, check whether
+ the enumerator values fits in the underlying type. If it
+ does not fit, the program is ill-formed [C++0x dcl.enum]. */
+ if (ENUM_UNDERLYING_TYPE (enumtype)
+ && value
+ && TREE_CODE (value) == INTEGER_CST)
+ {
+ if (!int_fits_type_p (value, ENUM_UNDERLYING_TYPE (enumtype)))
+ error ("enumerator value %E is outside the range of underlying "
+ "type %<%T%>", value, ENUM_UNDERLYING_TYPE (enumtype));
- /* Convert the value to the appropriate type. */
- value = convert (ENUM_UNDERLYING_TYPE (enumtype), value);
- }
+ /* Convert the value to the appropriate type. */
+ value = convert (ENUM_UNDERLYING_TYPE (enumtype), value);
+ }
+ }
}
/* C++ associates enums with global, function, or class declarations. */
===================================================================
@@ -1,4 +1,4 @@
// PR c++/53745
// { dg-do compile { target c++11 } }
-enum E : unsigned { e = -1 }; // { dg-error "outside the range" }
+enum E : unsigned { e = -1 }; // { dg-error "narrowing" }
===================================================================
@@ -0,0 +1,58 @@
+// PR c++/51312
+// { dg-do compile { target c++11 } }
+
+struct X0
+{
+ constexpr operator int() const { return 1; }
+};
+
+struct X1
+{
+ enum RE1 { re1 = 1 };
+ constexpr operator RE1() const { return re1; }
+};
+
+struct X2
+{
+ constexpr operator int() const { return __INT_MAX__; }
+};
+
+struct X3
+{
+ enum RE3 { re3 = __INT_MAX__ };
+ constexpr operator RE3() const { return re3; }
+};
+
+struct X4
+{
+ constexpr operator double() const { return 1.0; }
+};
+
+struct X5
+{
+ constexpr operator int() const { return __INT_MAX__; }
+ constexpr operator unsigned() const { return __INT_MAX__ * 2U + 1; }
+};
+
+enum E0 { e0 = X0() };
+enum E1 { e1 = X1() };
+enum E2 { e2 = X2() };
+enum E3 { e3 = X3() };
+enum E4 { e4 = X4() }; // { dg-error "integer constant" }
+enum E5 { e5 = X5() }; // { dg-error "ambiguous" }
+
+enum F0 : int { f0 = X0() };
+enum F1 : int { f1 = X1() };
+enum F2 : int { f2 = X2() };
+enum F3 : int { f3 = X3() };
+enum F4 : int { f4 = X4() }; // { dg-error "narrowing" }
+enum F5 : int { f5 = X5() };
+
+enum G0 : signed char { g0 = X0() };
+enum G1 : signed char { g1 = X1() };
+enum G2 : signed char { g2 = X2() }; // { dg-error "narrowing" }
+// { dg-warning "overflow" "" { target *-*-* } 53 }
+enum G3 : signed char { g3 = X3() }; // { dg-error "narrowing" }
+// { dg-warning "overflow" "" { target *-*-* } 55 }
+enum G4 : signed char { g4 = X4() }; // { dg-error "narrowing" }
+enum G5 : signed char { g5 = X5() }; // { dg-error "ambiguous" }
===================================================================
@@ -6,11 +6,13 @@ enum E1 : char { };
enum E2 : signed const short { };
enum E3 : uvlonglong { };
enum E4 : char {
- val = 500 // { dg-error "outside the range" }
+ val = 500 // { dg-error "narrowing" }
+// { dg-warning "overflow" "" { target *-*-* } 9 }
};
enum class E5 {
- val = (unsigned long long)-1 // { dg-error "outside the range" }
+ val = (unsigned long long)-1 // { dg-error "narrowing" }
+// { dg-warning "overflow" "" { target *-*-* } 14 }
};
typedef float Float;
Hi, this is a rejects valid issue with constexpr conversion operators and enums, eg: struct X0 { constexpr operator int() const { return 1; } }; enum E0 { e0 = X0() }; Given build_expr_type_conversion, we can handle the bug rather easily by using it when the enum doesn't have an underlying type, and directly perform_implicit_conversion_flags otherwise (as also suggested by Marc in the audit trail time ago). Some details: 1- Evidently, we can't just do everything with build_expr_type_conversion, similarly, eg, to finish_switch_cond, because we would not do the right thing for tests like F5 below, it would result in an ambiguous conversion. 2- I moved up, inside the value == NULL_TREE conditional, the existing code dealing with fixed underlying type enums, because now it's actually used only when we automatically compute the current value starting from the previous one (thus the tweaks to the existing testcases) 3- I'm taking the occasion to replace a pair of errors in build_expr_type_conversion with error + inform. Thanks, Paolo. //////////////////////// /cp 2014-08-07 Paolo Carlini <paolo.carlini@oracle.com> PR c++/51312 * decl.c (build_enumerator): Handle class types with conversion operators via build_expr_type_conversion. * cvt.c (build_expr_type_conversion): Replace pair of errors with error + inform. /testsuite 2014-08-07 Paolo Carlini <paolo.carlini@oracle.com> PR c++/51312 * g++.dg/cpp0x/enum29.C: New. * g++.dg/cpp0x/enum27.C: Adjust. * g++.dg/cpp0x/enum_base.C: Likewise.