* typeck.c (complete_type_or_maybe_complain): Split out from...
(complete_type_or_else): Here.
(build_class_member_access_expr): Call it.
(finish_class_member_access_expr): Likewise.
* call.c (build_special_member_call): Likewise.
* cvt.c (build_expr_type_conversion): Likewise.
* init.c (build_new): Likewise.
* typeck2.c (build_functional_cast): Likewise.
* cp-tree.h: Declare it.
* init.c (build_value_init): Add complain parm.
(build_value_init_noctor): Likewise.
(perform_member_init): Pass it.
(expand_aggr_init_1): Likewise.
(build_new_1): Likewise.
(build_vec_init): Likewise.
* pt.c (tsubst_expr): Likewise.
* typeck2.c (build_functional_cast): Likewise.
* cp-tree.h: Adjust.
* tree.c (build_target_expr_with_type): Handle error_mark_node.
From-SVN: r162953
2010-08-06 Jason Merrill <jason@redhat.com>
+ * typeck.c (complete_type_or_maybe_complain): Split out from...
+ (complete_type_or_else): Here.
+ (build_class_member_access_expr): Call it.
+ (finish_class_member_access_expr): Likewise.
+ * call.c (build_special_member_call): Likewise.
+ * cvt.c (build_expr_type_conversion): Likewise.
+ * init.c (build_new): Likewise.
+ * typeck2.c (build_functional_cast): Likewise.
+ * cp-tree.h: Declare it.
+
+ * init.c (build_value_init): Add complain parm.
+ (build_value_init_noctor): Likewise.
+ (perform_member_init): Pass it.
+ (expand_aggr_init_1): Likewise.
+ (build_new_1): Likewise.
+ (build_vec_init): Likewise.
+ * pt.c (tsubst_expr): Likewise.
+ * typeck2.c (build_functional_cast): Likewise.
+ * cp-tree.h: Adjust.
+ * tree.c (build_target_expr_with_type): Handle error_mark_node.
+
* typeck.c (decay_conversion): Any expression with type nullptr_t
decays to nullptr.
if (TYPE_P (binfo))
{
/* Resolve the name. */
- if (!complete_type_or_else (binfo, NULL_TREE))
+ if (!complete_type_or_maybe_complain (binfo, NULL_TREE, complain))
return error_mark_node;
binfo = TYPE_BINFO (binfo);
extern int is_class_type (tree, int);
extern tree get_type_value (tree);
extern tree build_zero_init (tree, tree, bool);
-extern tree build_value_init (tree);
-extern tree build_value_init_noctor (tree);
+extern tree build_value_init (tree, tsubst_flags_t);
+extern tree build_value_init_noctor (tree, tsubst_flags_t);
extern tree build_offset_ref (tree, tree, bool);
extern tree build_new (VEC(tree,gc) **, tree, tree,
VEC(tree,gc) **, int,
extern tree require_complete_type (tree);
extern tree complete_type (tree);
extern tree complete_type_or_else (tree, tree);
+extern tree complete_type_or_maybe_complain (tree, tree, tsubst_flags_t);
extern int type_unknown_p (const_tree);
enum { ce_derived, ce_normal, ce_exact };
extern bool comp_except_specs (const_tree, const_tree, int);
/* The code for conversions from class type is currently only used for
delete expressions. Other expressions are handled by build_new_op. */
- if (!complete_type_or_else (basetype, expr))
+ if (!complete_type_or_maybe_complain (basetype, expr, complain))
return error_mark_node;
if (!TYPE_HAS_CONVERSION (basetype))
return NULL_TREE;
TYPE, as described in [dcl.init]. */
tree
-build_value_init (tree type)
+build_value_init (tree type, tsubst_flags_t complain)
{
/* [dcl.init]
(type,
build_special_member_call (NULL_TREE, complete_ctor_identifier,
NULL, type, LOOKUP_NORMAL,
- tf_warning_or_error));
+ complain));
else if (TREE_CODE (type) != UNION_TYPE && TYPE_NEEDS_CONSTRUCTING (type))
{
/* This is a class that needs constructing, but doesn't have
This will be handled in simplify_aggr_init_expr. */
tree ctor = build_special_member_call
(NULL_TREE, complete_ctor_identifier,
- NULL, type, LOOKUP_NORMAL, tf_warning_or_error);
+ NULL, type, LOOKUP_NORMAL, complain);
ctor = build_aggr_init_expr (type, ctor);
AGGR_INIT_ZERO_FIRST (ctor) = 1;
return ctor;
}
}
- return build_value_init_noctor (type);
+ return build_value_init_noctor (type, complain);
}
/* Like build_value_init, but don't call the constructor for TYPE. Used
for base initializers. */
tree
-build_value_init_noctor (tree type)
+build_value_init_noctor (tree type, tsubst_flags_t complain)
{
if (CLASS_TYPE_P (type))
{
ftype = TREE_TYPE (field);
if (TREE_CODE (ftype) == REFERENCE_TYPE)
- error ("value-initialization of reference");
+ {
+ if (complain & tf_error)
+ error ("value-initialization of reference");
+ else
+ return error_mark_node;
+ }
/* We could skip vfields and fields of types with
user-defined constructors, but I think that won't improve
corresponding to base classes as well. Thus, iterating
over TYPE_FIELDs will result in correct initialization of
all of the subobjects. */
- value = build_value_init (ftype);
+ value = build_value_init (ftype, complain);
if (value)
CONSTRUCTOR_APPEND_ELT(v, field, value);
ce->index = build2 (RANGE_EXPR, sizetype, size_zero_node,
max_index);
- ce->value = build_value_init (TREE_TYPE (type));
+ ce->value = build_value_init (TREE_TYPE (type), complain);
/* The gimplifier can't deal with a RANGE_EXPR of TARGET_EXPRs. */
gcc_assert (TREE_CODE (ce->value) != TARGET_EXPR
member);
else
{
- init = build2 (INIT_EXPR, type, decl, build_value_init (type));
+ init = build2 (INIT_EXPR, type, decl,
+ build_value_init (type, tf_warning_or_error));
finish_expr_stmt (init);
}
}
then just zero out the object and we're done. */
else
{
- init = build2 (INIT_EXPR, type, exp, build_value_init_noctor (type));
+ init = build2 (INIT_EXPR, type, exp,
+ build_value_init_noctor (type, complain));
finish_expr_stmt (init);
return;
}
else if (explicit_value_init_p)
{
/* Something like `new int()'. */
- init_expr = build2 (INIT_EXPR, type,
- init_expr, build_value_init (type));
+ tree val = build_value_init (type, complain);
+ if (val == error_mark_node)
+ return error_mark_node;
+ init_expr = build2 (INIT_EXPR, type, init_expr, val);
}
else
{
/* The type allocated must be complete. If the new-type-id was
"T[N]" then we are just checking that "T" is complete here, but
that is equivalent, since the value of "N" doesn't matter. */
- if (!complete_type_or_else (type, NULL_TREE))
+ if (!complete_type_or_maybe_complain (type, NULL_TREE, complain))
return error_mark_node;
rval = build_new_1 (placement, type, nelts, init, use_global_new, complain);
0, complain);
}
else if (explicit_value_init_p)
- elt_init = build2 (INIT_EXPR, type, to,
- build_value_init (type));
+ {
+ elt_init = build_value_init (type, complain);
+ if (elt_init == error_mark_node)
+ return error_mark_node;
+ else
+ elt_init = build2 (INIT_EXPR, type, to, elt_init);
+ }
else
{
gcc_assert (TYPE_NEEDS_CONSTRUCTING (type));
pack expansion where the parameter packs
used in that expansion were of length
zero. */
- init = build_value_init (TREE_TYPE (decl));
+ init = build_value_init (TREE_TYPE (decl),
+ complain);
if (TREE_CODE (init) == AGGR_INIT_EXPR)
init = get_target_expr (init);
}
{
gcc_assert (!VOID_TYPE_P (type));
- if (TREE_CODE (init) == TARGET_EXPR)
+ if (TREE_CODE (init) == TARGET_EXPR
+ || init == error_mark_node)
return init;
else if (CLASS_TYPE_P (type) && type_has_nontrivial_copy_init (type)
&& !VOID_TYPE_P (TREE_TYPE (init))
Returns NULL_TREE if the type cannot be made complete. */
tree
-complete_type_or_else (tree type, tree value)
+complete_type_or_maybe_complain (tree type, tree value, tsubst_flags_t complain)
{
type = complete_type (type);
if (type == error_mark_node)
return NULL_TREE;
else if (!COMPLETE_TYPE_P (type))
{
- cxx_incomplete_type_diagnostic (value, type, DK_ERROR);
+ if (complain & tf_error)
+ cxx_incomplete_type_diagnostic (value, type, DK_ERROR);
return NULL_TREE;
}
else
return type;
}
+tree
+complete_type_or_else (tree type, tree value)
+{
+ return complete_type_or_maybe_complain (type, value, tf_warning_or_error);
+}
+
/* Return truthvalue of whether type of EXP is instantiated. */
int
complete type). */
object_type = TREE_TYPE (object);
if (!currently_open_class (object_type)
- && !complete_type_or_else (object_type, object))
+ && !complete_type_or_maybe_complain (object_type, object, complain))
return error_mark_node;
if (!CLASS_TYPE_P (object_type))
{
The type of the first expression shall be "class object" (of a
complete type). */
if (!currently_open_class (object_type)
- && !complete_type_or_else (object_type, object))
+ && !complete_type_or_maybe_complain (object_type, object, complain))
return error_mark_node;
if (!CLASS_TYPE_P (object_type))
{
then the slot being initialized will be filled in. */
- if (!complete_type_or_else (type, NULL_TREE))
+ if (!complete_type_or_maybe_complain (type, NULL_TREE, complain))
return error_mark_node;
if (abstract_virtuals_error (NULL_TREE, type))
return error_mark_node;
just calling the constructor, so fall through. */
&& !TYPE_HAS_USER_CONSTRUCTOR (type))
{
- exp = build_value_init (type);
+ exp = build_value_init (type, complain);
return get_target_expr (exp);
}
+2010-08-06 Jason Merrill <jason@redhat.com>
+
+ * g++.dg/cpp0x/sfinae3.C: New.
+ * g++.dg/cpp0x/sfinae4.C: New.
+
2010-08-06 Richard Guenther <rguenther@suse.de>
* gcc.dg/tree-ssa/ssa-dce-3.c: XFAIL.
--- /dev/null
+// { dg-options -std=c++0x }
+
+namespace std { template <class T> T&& declval(); }
+
+template<typename _Tp, typename... _Args>
+ class is_constructible_mini
+ {
+ typedef char __one;
+ typedef struct { char __arr[2]; } __two;
+
+ template<typename _Tp1, typename... _Args1>
+ static decltype(::new _Tp1(std::declval<_Args1>()...), __one())
+ __test(int);
+
+ template<typename, typename...>
+ static __two __test(...);
+
+ public:
+ static const bool value = sizeof(__test<_Tp, _Args...>(0)) == 1;
+ };
+
+/*
+template<typename _Tp>
+ class is_constructible_mini<_Tp>
+ {
+ typedef char __one;
+ typedef struct { char __arr[2]; } __two;
+
+ template<typename _Tp1>
+ static decltype(::new _Tp1, __one()) __test(int);
+
+ template<typename>
+ static __two __test(...);
+
+ public:
+ static const bool value
+ = sizeof(__test<typename std::remove_cv<_Tp>::type>(0)) == 1;
+ };
+*/
+
+struct A
+{
+ A(int);
+};
+
+struct B { };
+
+static_assert( is_constructible_mini<A, int>::value, "");
+static_assert( is_constructible_mini<A, A>::value, "");
+static_assert( !is_constructible_mini<A, int, double>::value, "");
+
+static_assert( !is_constructible_mini<A>::value, ""); // doesn't compile without the
+ // partial specialization
+
+static_assert( is_constructible_mini<B>::value, "");
+static_assert( is_constructible_mini<const B>::value, "");
--- /dev/null
+// { dg-options -std=c++0x }
+
+namespace std { template <class T> T&& declval(); }
+
+template<typename _Tp, typename... _Args>
+ class is_constructible_mini
+ {
+ typedef char __one;
+ typedef struct { char __arr[2]; } __two;
+
+ template<typename _Tp1, typename... _Args1>
+ static decltype(::new _Tp1(std::declval<_Args1>()...), __one())
+ __test(int);
+
+ template<typename, typename...>
+ static __two __test(...);
+
+ public:
+ static const bool value = sizeof(__test<_Tp, _Args...>(0)) == 1;
+ };
+
+static_assert( !is_constructible_mini<int[], int>::value, "");
+static_assert( !is_constructible_mini<void, int>::value, "");
projects / platform / upstream / gcc.git / commitdiff