re PR c++/48535 ([C++0x][SFINAE] Hard errors during list-value-initialization)

	PR c++/48535
	* semantics.c (finish_compound_literal): Take complain parm.
	(build_lambda_object): Adjust.
	* cp-tree.h: Adjust.
	* call.c (convert_like_real): Adjust.
	* decl.c (check_initializer): Adjust.
	* parser.c (cp_parser_postfix_expression): Adjust.
	(cp_parser_functional_cast): Adjust.
	* pt.c (tsubst_copy_and_build): Adjust.
	* typeck2.c (process_init_constructor_record): Adjust.

From-SVN: r172285

diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index 69aa170..6732794 100644 (file)
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,5 +1,16 @@
 2011-04-11  Jason Merrill  <jason@redhat.com>
 
+       PR c++/48535
+       * semantics.c (finish_compound_literal): Take complain parm.
+       (build_lambda_object): Adjust.
+       * cp-tree.h: Adjust.
+       * call.c (convert_like_real): Adjust.
+       * decl.c (check_initializer): Adjust.
+       * parser.c (cp_parser_postfix_expression): Adjust.
+       (cp_parser_functional_cast): Adjust.
+       * pt.c (tsubst_copy_and_build): Adjust.
+       * typeck2.c (process_init_constructor_record): Adjust.
+
        PR c++/48534
        * cvt.c (ocp_convert): Use build_nop to convert to underlying type
        of scoped enum.

diff --git a/gcc/cp/call.c b/gcc/cp/call.c
index 4d03646..78104b1 100644 (file)
--- a/gcc/cp/call.c
+++ b/gcc/cp/call.c
@@ -5495,7 +5495,7 @@ convert_like_real (conversion *convs, tree expr, tree fn, int argnum,
        elttype = cp_build_qualified_type
          (elttype, cp_type_quals (elttype) | TYPE_QUAL_CONST);
        array = build_array_of_n_type (elttype, len);
-       array = finish_compound_literal (array, new_ctor);
+       array = finish_compound_literal (array, new_ctor, complain);
 
        /* Build up the initializer_list object.  */
        totype = complete_type (totype);

diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index 885b31c..44a20ea 100644 (file)
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -5297,7 +5297,7 @@ extern tree finish_increment_expr         (tree, enum tree_code);
 extern tree finish_this_expr                   (void);
 extern tree finish_pseudo_destructor_expr       (tree, tree, tree);
 extern tree finish_unary_op_expr               (enum tree_code, tree);
-extern tree finish_compound_literal            (tree, tree);
+extern tree finish_compound_literal            (tree, tree, tsubst_flags_t);
 extern tree finish_fname                       (tree);
 extern void finish_translation_unit            (void);
 extern tree finish_template_type_parm          (tree, tree);

diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c
index 55ae173..a541402 100644 (file)
--- a/gcc/cp/decl.c
+++ b/gcc/cp/decl.c
@@ -5397,7 +5397,8 @@ check_initializer (tree decl, tree init, int flags, tree *cleanup)
                 init appropriately so we can pass it into store_init_value
                 for the error.  */
              if (init && BRACE_ENCLOSED_INITIALIZER_P (init))
-               init = finish_compound_literal (type, init);
+               init = finish_compound_literal (type, init,
+                                               tf_warning_or_error);
              else if (CLASS_TYPE_P (type)
                       && (!init || TREE_CODE (init) == TREE_LIST))
                {

diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c
index 607e9b8..8414ab8 100644 (file)
--- a/gcc/cp/parser.c
+++ b/gcc/cp/parser.c
@@ -4897,7 +4897,8 @@ cp_parser_postfix_expression (cp_parser *parser, bool address_p, bool cast_p,
                postfix_expression
                  = (finish_compound_literal
                     (type, build_constructor (init_list_type_node,
-                                              initializer_list)));
+                                              initializer_list),
+                     tf_warning_or_error));
                break;
              }
          }
@@ -19936,7 +19937,8 @@ cp_parser_functional_cast (cp_parser* parser, tree type)
       CONSTRUCTOR_IS_DIRECT_INIT (expression_list) = 1;
       if (TREE_CODE (type) == TYPE_DECL)
        type = TREE_TYPE (type);
-      return finish_compound_literal (type, expression_list);
+      return finish_compound_literal (type, expression_list,
+                                     tf_warning_or_error);
     }
 
 

diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c
index 86274e9..208ff2b 100644 (file)
--- a/gcc/cp/pt.c
+++ b/gcc/cp/pt.c
@@ -13262,7 +13262,7 @@ tsubst_copy_and_build (tree t,
        CONSTRUCTOR_IS_DIRECT_INIT (r) = CONSTRUCTOR_IS_DIRECT_INIT (t);
 
        if (TREE_HAS_CONSTRUCTOR (t))
-         return finish_compound_literal (type, r);
+         return finish_compound_literal (type, r, complain);
 
        TREE_TYPE (r) = type;
        return r;

diff --git a/gcc/cp/semantics.c b/gcc/cp/semantics.c
index 0b4d1ec..e08ddb3 100644 (file)
--- a/gcc/cp/semantics.c
+++ b/gcc/cp/semantics.c
@@ -2309,14 +2309,16 @@ finish_unary_op_expr (enum tree_code code, tree expr)
    the CONSTRUCTOR in COMPOUND_LITERAL is being cast.  */
 
 tree
-finish_compound_literal (tree type, tree compound_literal)
+finish_compound_literal (tree type, tree compound_literal,
+                        tsubst_flags_t complain)
 {
   if (type == error_mark_node)
     return error_mark_node;
 
   if (!TYPE_OBJ_P (type))
     {
-      error ("compound literal of non-object type %qT", type);
+      if (complain & tf_error)
+       error ("compound literal of non-object type %qT", type);
       return error_mark_node;
     }
 
@@ -2338,7 +2340,7 @@ finish_compound_literal (tree type, tree compound_literal)
         that it came from T{} rather than T({}).  */
       CONSTRUCTOR_IS_DIRECT_INIT (compound_literal) = 1;
       compound_literal = build_tree_list (NULL_TREE, compound_literal);
-      return build_functional_cast (type, compound_literal, tf_error);
+      return build_functional_cast (type, compound_literal, complain);
     }
 
   if (TREE_CODE (type) == ARRAY_TYPE
@@ -7928,7 +7930,7 @@ build_lambda_object (tree lambda_expr)
      But we briefly treat it as an aggregate to make this simpler.  */
   type = TREE_TYPE (lambda_expr);
   CLASSTYPE_NON_AGGREGATE (type) = 0;
-  expr = finish_compound_literal (type, expr);
+  expr = finish_compound_literal (type, expr, tf_warning_or_error);
   CLASSTYPE_NON_AGGREGATE (type) = 1;
 
  out:

diff --git a/gcc/cp/typeck2.c b/gcc/cp/typeck2.c
index f67073b..20b47d5 100644 (file)
--- a/gcc/cp/typeck2.c
+++ b/gcc/cp/typeck2.c
@@ -1126,7 +1126,8 @@ process_init_constructor_record (tree type, tree init)
          next = build_constructor (init_list_type_node, NULL);
          if (MAYBE_CLASS_TYPE_P (TREE_TYPE (field)))
            {
-             next = finish_compound_literal (TREE_TYPE (field), next);
+             next = finish_compound_literal (TREE_TYPE (field), next,
+                                             tf_warning_or_error);
              /* direct-initialize the target. No temporary is going
                  to be involved.  */
              if (TREE_CODE (next) == TARGET_EXPR)