typeck.c (composite_pointer_type_r): Add SFINAE support.

2008-03-25  Douglas Gregor  <doug.gregor@gmail.com>

       * typeck.c (composite_pointer_type_r): Add SFINAE support.
       (composite_pointer_type): Ditto.
       (common_type): Fix call to composite_pointer_type.
       (cxx_sizeof_nowarn): New; used to be a macro.
       (cxx_sizeof_expr): Add SFINAE support.
       (cxx_alignof_expr): Ditto.
       (decay_conversion): Fix calls for SFINAE support.
       (rationalize_conditional_expr): Add SFINAE support.
       (build_class_member_access_expr): Ditto.
       (finish_class_member_access_expr): Ditto.
       (build_x_indirect_ref): Ditto.
       (build_indirect_ref): Original version renamed to
       cp_build_indirect_ref; new version provides a bridge from
       c-common.
       (cp_build_indirect_ref): Was build_indirect_ref; added SFINAE
       support.
       (get_member_function_from_ptrfunc): Fix calls for SFINAE support.
       (build_function_call): Original version renamed to
       cp_build_function_call; new version provides a bridge from
       c-common.
       (cp_build_function_call): Was build_function_call; added SFINAE
       support.
       (convert_arguments): Add SFINAE support.
       (build_x_binary_op): Ditto.
       (build_binary_op): Original version renamed to cp_build_binary_op;
       new version provides a bridge from c-common.
       (cp_build_binary_op): Was build_binary_op; added SFINAE support.
       (pointer_diff): Fix calls for SFINAE.
       (build_x_unary_op): Add SFINAE support.
       (condition_conversion): Fix calls for SFINAE.
       (build_unary_op): Original version renamed to cp_build_unary_op;
       new version provides a bridge from c-common.
       (cp_build_unary_op): Was build_unary_op; added SFINAE support.
       (unary_complex_lvalue): Fix calls for SFINAE.
       (build_x_conditional_expr): Add SFINAE support.
       (build_x_compound_expr_from_list): Fix calls for SFINAE.
       (build_x_compound_expr): Add SFINAE support.
       (convert_ptrmem): Fix calls for SFINAE.
       (build_static_cast_1): Add SFINAE support.
       (build_static_cast): Ditto.
       (build_reinterpret_cast_1): Ditto.
       (build_reinterpret_cast): Ditto.
       (build_const_cast_1): Ditto.
       (build_const_cast): Ditto.
       (build_c_cast): Ditto.
       (build_modify_expr): Original version renamed to
       cp_build_modify_expr; new version provides a bridge from c-common.
       (cp_build_modify_expr): Was build_modify_expr; added SFINAE
       support.
       (build_x_modify_expr): Add SFINAE support.
       (build_ptrmemfunc): Fix calls for SFINAE.
       (convert_for_assignment): Add SFINAE support.
       (convert_for_initialization): Ditto.
       (check_return_expr): Fix calls for SFINAE.
       (lvalue_or_else): Add SFINAE support.
       * init.c (perform_member_init): Fix calls for SFINAE.
       (emit_mem_initializers): Ditto.
       (expand_virtual_init): Ditto.
       (expand_cleanup_for_base): Ditto.
       (build_aggr_init): Add SFINAE support.
       (expand_default_init): Ditto.
       (expand_aggr_init_1): Fix calls for SFINAE.
       (build_offset_ref): Ditto.
       (build_new_1): Add SFINAE support.
       (build_new): Ditto.
       (build_vec_delete_1): Fix calls for SFINAE.
       (get_temp_regvar): Ditto.
       (build_vec_init): Add SFINAE support.
       (build_dtor_call): Fix calls for SFINAE.
       (build_delete): Ditto.
       (push_base_cleanups): Ditto.
       (build_vec_delete_1): Ditto.
       * class.c (build_base_path): Fix calls for SFINAE.
       (build_simple_base_path): Ditto.
       (convert_to_base_statically): Ditto.
       (build_vfn_ref): Ditto.
       (resolve_address_of_overloaded_function): Ditto.
       * decl.c (check_initializer): Fix calls for SFINAE.
       (register_dtor_fn): Ditto.
       (compute_array_index_type): Ditto.
       (finish_enum): Ditto.
       (start_preparsed_function): Ditto.
       (cxx_maybe_build_cleanup): Ditto.
       * call.c (convert_like): Add COMPLAIN argument.
       (convert_like_with_context): Ditto.
       (build_this): Fix calls for SFINAE.
       (build_user_type_conversion): Ditto.
       (resolve_args): Ditto.
       (build_new_function_call): Add SFINAE support.
       (build_operator_new_call): Fix calls for SFINAE.
       (build_object_call): Add SFINAE support.
       (build_conditional_expr): Ditto.
       (build_new_op): Ditto.
       (build_op_delete_call): Fix calls for SFINAE.
       (build_temp): Ditto.
       (convert_like_real): Add SFINAE support.
       (build_x_va_arg): Fix calls for SFINAE.
       (convert_default_arg): Ditto.
       (build_over_call): Add SFINAE support.
       (build_java_interface_fn_ref): Fix calls for SFINAE.
       (build_special_member_call): Add SFINAE support.
       (build_new_method_call): Ditto.
       (perform_implicit_conversion): Ditto.
       (perform_direct_initialization_if_possible): Ditto.
       (initialize_reference): Fix calls for SFINAE.
       * method.c (do_build_assign_ref): Fix calls for SFINAE.
       * rtti.c (build_headof): Fix calls for SFINAE.
       (get_tinfo_decl_dynamic): Ditto.
       (get_typeid): Ditto.
       (build_dynamic_cast_1): Add SFINAE support.
       (build_dynamic_cast): Ditto.
       (tinfo_base_init): Fix calls for SFINAE.
       * except.c (do_get_exception_ptr): Fix calls for SFINAE.
       (do_end_catch): Ditto.
       (initialize_handler_parm): Ditto.
       (expand_start_catch_block): Ditto.
       (do_allocate_exception): Ditto.
       (do_free_exception): Ditto.
       (build_throw): Ditto.
       * cvt.c (build_up_reference): Fix calls for SFINAE.
       (convert_to_reference): Ditto.
       (ocp_convert): Ditto.
       (convert_to_void): Add SFINAE support.
       * tree.c (build_dummy_object): Fix calls for SFINAE.
       (stabilize_expr): Ditto.
       * cp-tree.h (build_conditional_expr): Add tsubst_flags_t
       parameter.
       (build_new_method_call): Ditto.
       (build_special_member_call): Ditto.
       (build_new_op): Ditto.
       (perform_implicit_conversion): Ditto.
       (perform_direct_initialization_if_possible): Ditto.
       (convert_to_void): Ditto.
       (build_aggr_init): Ditto.
       (build_new): Ditto.
       (build_vec_init): Ditto.
       (build_dynamic_cast): Ditto.
       (finish_call_expr): Ditto
       (cxx_sizeof_or_alignof_expr): Add COMPLAIN parameter.
       (cxx_sizeof_nowarn): Remove macro; add function declaration.
       (build_class_member_access_expr): Add tsubst_flags_t parameter.
       (finish_class_member_access_expr): Ditto.
       (build_x_indirect_ref): Ditto.
       (cp_build_indirect_ref): New.
       (cp_build_function_call): Add tsubst_flags_t parameter.
       (build_x_unary_op): Ditto.
       (cp_build_unary_op): New.
       (build_x_conditional_expr): Add tsubst_flags_t parameter.
       (build_x_compound_expr): Ditto.
       (build_compound_expr): Ditto.
       (build_static_cast): Ditto.
       (build_reinterpret_cast): Ditto.
       (build_const_cast): Ditto.
       (build_c_cast): Ditto.
       (build_x_modify_expr): Ditto.
       (cp_build_modify_expr): New.
       (convert_for_initialization): Add tsubst_flags_t parameter.
       (cp_build_binary_op): Remove macro; add function declaration.
       (invalid_nonstatic_memfn_p): Add tsubst_flags_t parameter.
       (lvalue_or_else): Ditto.
       (build_functional_cast): Ditto.
       * typeck2.c (digest_init): Fix calls for SFINAE.
       (process_init_constructor_array): Ditto.
       (process_init_constructor_record): Ditto.
       (build_x_arrow): Ditto.
       (build_m_component_ref): Ditto.
       (build_functional_cast): Add SFINAE support.
       * pt.c (tsubst_copy_and_build): Add (more) SFINAE support.
       * semantics.c (simplify_loop_decl_cond): Fix calls for SFINAE.
       (finish_expr_stmt): Ditto.
       (finish_for_expr): Ditto.
       (finish_asm_stmt): Ditto.
       (finish_non_static_data_member): Ditto.
       (finish_qualified_id_expr): Ditto.
       (finish_call_expr): Add SFINAE support.
       (finish_increment_expr): Fix calls for SFINAE.
       (finish_unary_op_expr): Ditto.
       (simplify_aggr_init_expr): Ditto.
       (finish_omp_clauses): Ditto.
       (finish_omp_for): Ditto.
       (finish_omp_barrier): Ditto.
       (finish_omo_flush): Ditto.
       * decl2.c (grok_array_decl): Fix calls or SFINAE.
       (build_anon_union_vars): Ditto.
       (get_guard_cond): Ditto.
       (set_guard): Ditto.
       (one_static_initialization_or_destruction): Ditto.
       (do_static_initialization_or_destruction): Ditto.
       (generate_ctor_or_dtor_function): Ditto.
       (build_offset_ref_call_from_tree): Ditto.
       * parser.c (cp_parser_postfix_expression): Fix calls for SFINAE.
       (cp_parser_postfix_dot_deref_expression): Ditto.
       (cp_parser_unary_expression): Ditto.
       (cp_parser_new_expression): Ditto.
       (cp_parser_cast_expression): Ditto.
       (cp_parser_binary_expression): Ditto.
       (cp_parser_question_colon_clause): Ditto.
       (cp_parser_assignment_expression): Ditto.
       (cp_parser_expression): Ditto.
       (cp_parser_builtin_offsetof): Ditto.
       (cp_parser_template_argument): Ditto.
       (cp_parser_functional_cast): Ditto.

2008-03-25  Douglas Gregor  <doug.gregor@gmail.com>

       * c-common.c (c_sizeof_or_alignof_type): If we're not allowed to
       complain when we hit an error, return ERROR_MARK_NODE.

2008-03-25  Douglas Gregor  <doug.gregor@gmail.com>

       * g++.dg/template/sfinae4.C: New.
       * g++.dg/template/sfinae5.C: New.
       * g++.dg/template/sfinae6.C: New.
       * g++.dg/template/sfinae6_neg.C: New.
       * g++.dg/template/sfinae7.C: New.
       * g++.dg/template/sfinae8.C: New.
       * g++.dg/template/sfinae9.C: New.
       * g++.dg/template/sfinae10.C: New.
       * g++.dg/template/sfinae11.C: New.
       * g++.dg/template/sfinae12.C: New.
       * g++.dg/template/sfinae13.C: New.
       * g++.dg/template/sfinae14C: New.

From-SVN: r133519

1 files changed, 40 insertions, 24 deletions

diff --git a/gcc/cp/cvt.c b/gcc/cp/cvt.c
index 64a8716..fe1ed29 100644
--- a/gcc/cp/cvt.c
+++ b/gcc/cp/cvt.c
@@ -326,7 +326,7 @@ build_up_reference (tree type, tree arg, int flags, tree decl)
   /* If we had a way to wrap this up, and say, if we ever needed its
      address, transform all occurrences of the register, into a memory
      reference we could win better.  */
-  rval = build_unary_op (ADDR_EXPR, arg, 1);
+  rval = cp_build_unary_op (ADDR_EXPR, arg, 1, tf_warning_or_error);
   if (rval == error_mark_node)
     return error_mark_node;
 
@@ -470,7 +470,7 @@ convert_to_reference (tree reftype, tree expr, int convtype,
 	warning (0, "casting %qT to %qT does not dereference pointer",
 		 intype, reftype);
 
-      rval = build_unary_op (ADDR_EXPR, expr, 0);
+      rval = cp_build_unary_op (ADDR_EXPR, expr, 0, tf_warning_or_error);
       if (rval != error_mark_node)
 	rval = convert_force (build_pointer_type (TREE_TYPE (reftype)),
 			      rval, 0);
@@ -480,7 +480,8 @@ convert_to_reference (tree reftype, tree expr, int convtype,
   else
     {
       rval = convert_for_initialization (NULL_TREE, type, expr, flags,
-					 "converting", 0, 0);
+					 "converting", 0, 0,
+                                         tf_warning_or_error);
       if (rval == NULL_TREE || rval == error_mark_node)
 	return rval;
       warn_ref_binding (reftype, intype, decl);
@@ -630,7 +631,7 @@ ocp_convert (tree type, tree expr, int convtype, int flags)
 
   if (code == VOID_TYPE && (convtype & CONV_STATIC))
     {
-      e = convert_to_void (e, /*implicit=*/NULL);
+      e = convert_to_void (e, /*implicit=*/NULL, tf_warning_or_error);
       return e;
     }
 
@@ -734,7 +735,8 @@ ocp_convert (tree type, tree expr, int convtype, int flags)
 	ctor = build_special_member_call (NULL_TREE,
 					  complete_ctor_identifier,
 					  build_tree_list (NULL_TREE, ctor),
-					  type, flags);
+					  type, flags,
+                                          tf_warning_or_error);
       if (ctor)
 	return build_cplus_new (type, ctor);
     }
@@ -763,18 +765,19 @@ ocp_convert (tree type, tree expr, int convtype, int flags)
    IMPLICIT is tells us the context of an implicit void conversion.  */
 
 tree
-convert_to_void (tree expr, const char *implicit)
+convert_to_void (tree expr, const char *implicit, tsubst_flags_t complain)
 {
   if (expr == error_mark_node
       || TREE_TYPE (expr) == error_mark_node)
     return error_mark_node;
   if (!TREE_TYPE (expr))
     return expr;
-  if (invalid_nonstatic_memfn_p (expr))
+  if (invalid_nonstatic_memfn_p (expr, complain))
     return error_mark_node;
   if (TREE_CODE (expr) == PSEUDO_DTOR_EXPR)
     {
-      error ("pseudo-destructor is not called");
+      if (complain & tf_error)
+        error ("pseudo-destructor is not called");
       return error_mark_node;
     }
   if (VOID_TYPE_P (TREE_TYPE (expr)))
@@ -788,10 +791,10 @@ convert_to_void (tree expr, const char *implicit)
 	tree op2 = TREE_OPERAND (expr,2);
 	tree new_op1 = convert_to_void
 	  (op1, (implicit && !TREE_SIDE_EFFECTS (op2)
-		 ? "second operand of conditional" : NULL));
+		 ? "second operand of conditional" : NULL), complain);
 	tree new_op2 = convert_to_void
 	  (op2, (implicit && !TREE_SIDE_EFFECTS (op1)
-		 ? "third operand of conditional" : NULL));
+		 ? "third operand of conditional" : NULL), complain);
 
 	expr = build3 (COND_EXPR, TREE_TYPE (new_op1),
 		       TREE_OPERAND (expr, 0), new_op1, new_op2);
@@ -804,7 +807,7 @@ convert_to_void (tree expr, const char *implicit)
 	tree op1 = TREE_OPERAND (expr,1);
 	tree new_op1 = convert_to_void
 	  (op1, (implicit && !TREE_NO_WARNING (expr)
-		 ? "right-hand operand of comma" : NULL));
+		 ? "right-hand operand of comma" : NULL), complain);
 
 	if (new_op1 != op1)
 	  {
@@ -834,14 +837,20 @@ convert_to_void (tree expr, const char *implicit)
 
 	/* Can't load the value if we don't know the type.  */
 	if (is_volatile && !is_complete)
-	  warning (0, "object of incomplete type %qT will not be accessed in %s",
-		   type, implicit ? implicit : "void context");
+          {
+            if (complain & tf_warning)
+              warning (0, "object of incomplete type %qT will not be accessed in %s",
+                       type, implicit ? implicit : "void context");
+          }
 	/* Don't load the value if this is an implicit dereference, or if
 	   the type needs to be handled by ctors/dtors.  */
 	else if (is_volatile && (is_reference || TREE_ADDRESSABLE (type)))
-	  warning (0, "object of type %qT will not be accessed in %s",
-		   TREE_TYPE (TREE_OPERAND (expr, 0)),
-		   implicit ? implicit : "void context");
+          {
+            if (complain & tf_warning)
+              warning (0, "object of type %qT will not be accessed in %s",
+                       TREE_TYPE (TREE_OPERAND (expr, 0)),
+                       implicit ? implicit : "void context");
+          }
 	if (is_reference || !is_volatile || !is_complete || TREE_ADDRESSABLE (type))
 	  expr = TREE_OPERAND (expr, 0);
 
@@ -854,7 +863,7 @@ convert_to_void (tree expr, const char *implicit)
 	tree type = TREE_TYPE (expr);
 	int is_complete = COMPLETE_TYPE_P (complete_type (type));
 
-	if (TYPE_VOLATILE (type) && !is_complete)
+	if (TYPE_VOLATILE (type) && !is_complete && (complain & tf_warning))
 	  warning (0, "object %qE of incomplete type %qT will not be accessed in %s",
 		   expr, type, implicit ? implicit : "void context");
 	break;
@@ -892,15 +901,19 @@ convert_to_void (tree expr, const char *implicit)
       {
 	/* [over.over] enumerates the places where we can take the address
 	   of an overloaded function, and this is not one of them.  */
-	error ("%s cannot resolve address of overloaded function",
-	       implicit ? implicit : "void cast");
+	if (complain & tf_error)
+	  error ("%s cannot resolve address of overloaded function",
+		 implicit ? implicit : "void cast");
+	else
+	  return error_mark_node;
 	expr = void_zero_node;
       }
     else if (implicit && probe == expr && is_overloaded_fn (probe))
       {
 	/* Only warn when there is no &.  */
-	warning (OPT_Waddress, "%s is a reference, not call, to function %qE",
-		 implicit, expr);
+	if (complain & tf_warning)
+	  warning (OPT_Waddress, "%s is a reference, not call, to function %qE",
+		   implicit, expr);
 	if (TREE_CODE (expr) == COMPONENT_REF)
 	  expr = TREE_OPERAND (expr, 0);
       }
@@ -915,8 +928,10 @@ convert_to_void (tree expr, const char *implicit)
 	{
 	  /* The middle end does not warn about expressions that have
 	     been explicitly cast to void, so we must do so here.  */
-	  if (!TREE_SIDE_EFFECTS (expr))
-	    warning (OPT_Wunused_value, "%s has no effect", implicit);
+	  if (!TREE_SIDE_EFFECTS (expr)) {
+            if (complain & tf_warning)
+              warning (OPT_Wunused_value, "%s has no effect", implicit);
+          }
 	  else
 	    {
 	      tree e;
@@ -939,7 +954,7 @@ convert_to_void (tree expr, const char *implicit)
 
 	      code = TREE_CODE (e);
 	      class = TREE_CODE_CLASS (code);
-	      if (class == tcc_comparison
+	      if ((class == tcc_comparison
 		   || class == tcc_unary
 		   || (class == tcc_binary
 		       && !(code == MODIFY_EXPR
@@ -948,6 +963,7 @@ convert_to_void (tree expr, const char *implicit)
 			    || code == PREINCREMENT_EXPR
 			    || code == POSTDECREMENT_EXPR
 			    || code == POSTINCREMENT_EXPR)))
+                  && (complain & tf_warning))
 		warning (OPT_Wunused_value, "value computed is not used");
 	    }
 	}