* cp-tree.h (FNDECL_USED_AUTO): New macro.
(LAMBDA_EXPR_DEDUCE_RETURN_TYPE_P): Remove.
(dependent_lambda_return_type_node): Remove.
(CPTI_DEPENDENT_LAMBDA_RETURN_TYPE): Remove.
(struct language_function): Add x_auto_return_pattern field.
(current_function_auto_return_pattern): New.
(enum tsubst_flags): Add tf_partial.
* decl.c (decls_match): Handle auto return comparison.
(duplicate_decls): Adjust error message for auto return.
(cxx_init_decl_processing): Remove dependent_lambda_return_type_node.
(cp_finish_decl): Don't do auto deduction for functions.
(grokdeclarator): Allow auto return without trailing return type in
C++1y mode.
(check_function_type): Defer checking of deduced return type.
(start_preparsed_function): Set current_function_auto_return_pattern.
(finish_function): Set deduced return type to void if not previously
deduced.
* decl2.c (change_return_type): Handle error_mark_node.
(mark_used): Always instantiate functions with deduced return type.
Complain about use if deduction isn't done.
* parser.c (cp_parser_lambda_declarator_opt): Use 'auto' for
initial return type.
(cp_parser_lambda_body): Don't deduce return type in a template.
(cp_parser_conversion_type_id): Allow auto in C++1y.
* pt.c (instantiate_class_template_1): Don't mess with
LAMBDA_EXPR_DEDUCE_RETURN_TYPE_P.
(tsubst_copy_and_build): Likewise.
(fn_type_unification, tsubst): Don't reduce the template parm level
of 'auto' during deduction.
(unify): Compare 'auto' specially.
(get_bindings): Change test.
(always_instantiate_p): Always instantiate functions with deduced
return type.
(do_auto_deduction): Handle error_mark_node and lambda context.
Don't check for use in initializer.
(contains_auto_r): Remove.
* search.c (lookup_conversions_r): Handle auto conversion function.
* semantics.c (lambda_return_type): Handle null return. Don't mess
with dependent_lambda_return_type_node.
(apply_deduced_return_type): Rename from apply_lambda_return_type.
* typeck.c (merge_types): Handle auto.
(check_return_expr): Do auto deduction.
* typeck2.c (add_exception_specifier): Fix complain check.
From-SVN: r185768
+2012-03-21 Jason Merrill <jason@redhat.com>
+
+ Implement return type deduction for normal functions with -std=c++1y.
+ * cp-tree.h (FNDECL_USED_AUTO): New macro.
+ (LAMBDA_EXPR_DEDUCE_RETURN_TYPE_P): Remove.
+ (dependent_lambda_return_type_node): Remove.
+ (CPTI_DEPENDENT_LAMBDA_RETURN_TYPE): Remove.
+ (struct language_function): Add x_auto_return_pattern field.
+ (current_function_auto_return_pattern): New.
+ (enum tsubst_flags): Add tf_partial.
+ * decl.c (decls_match): Handle auto return comparison.
+ (duplicate_decls): Adjust error message for auto return.
+ (cxx_init_decl_processing): Remove dependent_lambda_return_type_node.
+ (cp_finish_decl): Don't do auto deduction for functions.
+ (grokdeclarator): Allow auto return without trailing return type in
+ C++1y mode.
+ (check_function_type): Defer checking of deduced return type.
+ (start_preparsed_function): Set current_function_auto_return_pattern.
+ (finish_function): Set deduced return type to void if not previously
+ deduced.
+ * decl2.c (change_return_type): Handle error_mark_node.
+ (mark_used): Always instantiate functions with deduced return type.
+ Complain about use if deduction isn't done.
+ * parser.c (cp_parser_lambda_declarator_opt): Use 'auto' for
+ initial return type.
+ (cp_parser_lambda_body): Don't deduce return type in a template.
+ (cp_parser_conversion_type_id): Allow auto in C++1y.
+ * pt.c (instantiate_class_template_1): Don't mess with
+ LAMBDA_EXPR_DEDUCE_RETURN_TYPE_P.
+ (tsubst_copy_and_build): Likewise.
+ (fn_type_unification, tsubst): Don't reduce the template parm level
+ of 'auto' during deduction.
+ (unify): Compare 'auto' specially.
+ (get_bindings): Change test.
+ (always_instantiate_p): Always instantiate functions with deduced
+ return type.
+ (do_auto_deduction): Handle error_mark_node and lambda context.
+ Don't check for use in initializer.
+ (contains_auto_r): Remove.
+ * search.c (lookup_conversions_r): Handle auto conversion function.
+ * semantics.c (lambda_return_type): Handle null return. Don't mess
+ with dependent_lambda_return_type_node.
+ (apply_deduced_return_type): Rename from apply_lambda_return_type.
+ * typeck.c (merge_types): Handle auto.
+ (check_return_expr): Do auto deduction.
+ * typeck2.c (add_exception_specifier): Fix complain check.
+
2012-03-22 Paolo Carlini <paolo.carlini@oracle.com>
PR c++/52487
DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (in VAR_DECL)
STATEMENT_LIST_TRY_BLOCK (in STATEMENT_LIST)
TYPENAME_IS_RESOLVING_P (in TYPE_NAME_TYPE)
- LAMBDA_EXPR_DEDUCE_RETURN_TYPE_P (in LAMBDA_EXPR)
TARGET_EXPR_DIRECT_INIT_P (in TARGET_EXPR)
+ FNDECL_USED_AUTO (in FUNCTION_DECL)
3: (TREE_REFERENCE_EXPR) (in NON_LVALUE_EXPR) (commented-out).
ICS_BAD_FLAG (in _CONV)
FN_TRY_BLOCK_P (in TRY_BLOCK)
#define LAMBDA_EXPR_MUTABLE_P(NODE) \
TREE_LANG_FLAG_1 (LAMBDA_EXPR_CHECK (NODE))
-/* True iff we should try to deduce the lambda return type from any return
- statement. */
-#define LAMBDA_EXPR_DEDUCE_RETURN_TYPE_P(NODE) \
- TREE_LANG_FLAG_2 (LAMBDA_EXPR_CHECK (NODE))
-
/* The return type in the expression.
* NULL_TREE indicates that none was specified. */
#define LAMBDA_EXPR_RETURN_TYPE(NODE) \
CPTI_CLASS_TYPE,
CPTI_UNKNOWN_TYPE,
CPTI_INIT_LIST_TYPE,
- CPTI_DEPENDENT_LAMBDA_RETURN_TYPE,
CPTI_VTBL_TYPE,
CPTI_VTBL_PTR_TYPE,
CPTI_STD,
#define class_type_node cp_global_trees[CPTI_CLASS_TYPE]
#define unknown_type_node cp_global_trees[CPTI_UNKNOWN_TYPE]
#define init_list_type_node cp_global_trees[CPTI_INIT_LIST_TYPE]
-#define dependent_lambda_return_type_node cp_global_trees[CPTI_DEPENDENT_LAMBDA_RETURN_TYPE]
#define vtbl_type_node cp_global_trees[CPTI_VTBL_TYPE]
#define vtbl_ptr_type_node cp_global_trees[CPTI_VTBL_PTR_TYPE]
#define std_node cp_global_trees[CPTI_STD]
tree x_in_charge_parm;
tree x_vtt_parm;
tree x_return_value;
+ tree x_auto_return_pattern;
BOOL_BITFIELD returns_value : 1;
BOOL_BITFIELD returns_null : 1;
#define current_function_return_value \
(cp_function_chain->x_return_value)
+/* A type involving 'auto' to be used for return type deduction. */
+
+#define current_function_auto_return_pattern \
+ (cp_function_chain->x_auto_return_pattern)
+
/* True if NAME is the IDENTIFIER_NODE for an overloaded "operator
new" or "operator delete". */
#define NEW_DELETE_OPNAME_P(NAME) \
#define DECL_LOCAL_FUNCTION_P(NODE) \
DECL_LANG_FLAG_0 (FUNCTION_DECL_CHECK (NODE))
+/* True if NODE was declared with auto in its return type, but it has
+ started compilation and so the return type might have been changed by
+ return type deduction; its declared return type should be found in
+ DECL_STRUCT_FUNCTION(NODE)->language->x_auto_return_pattern. */
+#define FNDECL_USED_AUTO(NODE) \
+ TREE_LANG_FLAG_2 (FUNCTION_DECL_CHECK (NODE))
+
/* Nonzero if NODE is a DECL which we know about but which has not
been explicitly declared, such as a built-in function or a friend
declared inside a class. In the latter case DECL_HIDDEN_FRIEND_P
conversion. */
tf_no_access_control = 1 << 7, /* Do not perform access checks, even
when issuing other errors. */
+ tf_partial = 1 << 8, /* Doing initial explicit argument
+ substitution in fn_type_unification. */
/* Convenient substitution flags combinations. */
tf_warning_or_error = tf_warning | tf_error
};
extern tree lambda_return_type (tree);
extern tree lambda_proxy_type (tree);
extern tree lambda_function (tree);
-extern void apply_lambda_return_type (tree, tree);
+extern void apply_deduced_return_type (tree, tree);
extern tree add_capture (tree, tree, tree, bool, bool);
extern tree add_default_capture (tree, tree, tree);
extern tree build_capture_proxy (tree);
tree f2 = TREE_TYPE (olddecl);
tree p1 = TYPE_ARG_TYPES (f1);
tree p2 = TYPE_ARG_TYPES (f2);
+ tree r2;
/* Specializations of different templates are different functions
even if they have the same type. */
if (TREE_CODE (f1) != TREE_CODE (f2))
return 0;
- if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
+ /* A declaration with deduced return type should use its pre-deduction
+ type for declaration matching. */
+ if (FNDECL_USED_AUTO (olddecl))
+ r2 = DECL_STRUCT_FUNCTION (olddecl)->language->x_auto_return_pattern;
+ else
+ r2 = TREE_TYPE (f2);
+
+ if (same_type_p (TREE_TYPE (f1), r2))
{
if (!prototype_p (f2) && DECL_EXTERN_C_P (olddecl)
&& (DECL_BUILT_IN (olddecl)
TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
{
error ("new declaration %q#D", newdecl);
- error ("ambiguates old declaration %q+#D", olddecl);
+ if (FNDECL_USED_AUTO (olddecl))
+ error_at (DECL_SOURCE_LOCATION (olddecl), "ambiguates old "
+ "declaration with deduced return type");
+ else
+ error ("ambiguates old declaration %q+#D", olddecl);
return error_mark_node;
}
else
init_list_type_node = make_node (LANG_TYPE);
record_unknown_type (init_list_type_node, "init list");
- dependent_lambda_return_type_node = make_node (LANG_TYPE);
- record_unknown_type (dependent_lambda_return_type_node,
- "undeduced lambda return type");
-
{
/* Make sure we get a unique function type, so we can give
its pointer type a name. (This wins for gdb.) */
&& (DECL_INITIAL (decl) || init))
DECL_INITIALIZED_IN_CLASS_P (decl) = 1;
- auto_node = type_uses_auto (type);
- if (auto_node)
+ if (TREE_CODE (decl) != FUNCTION_DECL
+ && (auto_node = type_uses_auto (type)))
{
tree d_init;
if (init == NULL_TREE)
{
if (!declarator->u.function.late_return_type)
{
- error ("%qs function uses %<auto%> type specifier without"
- " trailing return type", name);
- return error_mark_node;
+ if (current_class_type
+ && LAMBDA_TYPE_P (current_class_type))
+ /* OK for C++11 lambdas. */;
+ else if (cxx_dialect < cxx1y)
+ pedwarn (input_location, 0, "%qs function uses "
+ "%<auto%> type specifier without trailing "
+ "return type", name);
}
else if (!is_auto (type))
{
}
else if (decl_context == FIELD)
{
- if (!staticp && type_uses_auto (type))
+ if (!staticp && TREE_CODE (type) != METHOD_TYPE
+ && type_uses_auto (type))
{
error ("non-static data member declared %<auto%>");
type = error_mark_node;
/* In a function definition, arg types must be complete. */
require_complete_types_for_parms (current_function_parms);
- if (dependent_type_p (return_type))
+ if (dependent_type_p (return_type)
+ || type_uses_auto (return_type))
return;
if (!COMPLETE_OR_VOID_TYPE_P (return_type)
|| (TYPE_FOR_JAVA (return_type) && MAYBE_CLASS_TYPE_P (return_type)))
/* Build the return declaration for the function. */
restype = TREE_TYPE (fntype);
+
if (DECL_RESULT (decl1) == NULL_TREE)
{
tree resdecl;
current_stmt_tree ()->stmts_are_full_exprs_p = 1;
current_binding_level = bl;
+ if (!processing_template_decl && type_uses_auto (restype))
+ {
+ FNDECL_USED_AUTO (decl1) = true;
+ current_function_auto_return_pattern = restype;
+ }
+
/* Start the statement-tree, start the tree now. */
DECL_SAVED_TREE (decl1) = push_stmt_list ();
of curly braces for a function. */
gcc_assert (stmts_are_full_exprs_p ());
+ /* If there are no return statements in a function with auto return type,
+ the return type is void. But if the declared type is something like
+ auto*, this is an error. */
+ if (!processing_template_decl && FNDECL_USED_AUTO (fndecl)
+ && TREE_TYPE (fntype) == current_function_auto_return_pattern)
+ {
+ if (!is_auto (current_function_auto_return_pattern)
+ && !current_function_returns_value && !current_function_returns_null)
+ {
+ error ("no return statements in function returning %qT",
+ current_function_auto_return_pattern);
+ inform (input_location, "only plain %<auto%> return type can be "
+ "deduced to %<void%>");
+ }
+ apply_deduced_return_type (fndecl, void_type_node);
+ }
+
/* Save constexpr function body before it gets munged by
the NRV transformation. */
maybe_save_function_definition (fndecl);
tree raises = TYPE_RAISES_EXCEPTIONS (fntype);
tree attrs = TYPE_ATTRIBUTES (fntype);
+ if (new_ret == error_mark_node)
+ return fntype;
+
if (same_type_p (new_ret, TREE_TYPE (fntype)))
return fntype;
if ((TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != FUNCTION_DECL)
|| DECL_LANG_SPECIFIC (decl) == NULL
|| DECL_THUNK_P (decl))
- return true;
+ {
+ if (!processing_template_decl && type_uses_auto (TREE_TYPE (decl)))
+ error ("use of %qD before deduction of %<auto%>", decl);
+ return true;
+ }
/* We only want to do this processing once. We don't need to keep trying
to instantiate inline templates, because unit-at-a-time will make sure
/* Normally, we can wait until instantiation-time to synthesize DECL.
However, if DECL is a static data member initialized with a constant
or a constexpr function, we need it right now because a reference to
- such a data member or a call to such function is not value-dependent. */
+ such a data member or a call to such function is not value-dependent.
+ For a function that uses auto in the return type, we need to instantiate
+ it to find out its type. */
if ((decl_maybe_constant_var_p (decl)
|| (TREE_CODE (decl) == FUNCTION_DECL
- && DECL_DECLARED_CONSTEXPR_P (decl)))
+ && (DECL_DECLARED_CONSTEXPR_P (decl)
+ || type_uses_auto (TREE_TYPE (TREE_TYPE (decl))))))
&& DECL_LANG_SPECIFIC (decl)
&& DECL_TEMPLATE_INFO (decl)
&& !uses_template_parms (DECL_TI_ARGS (decl)))
--function_depth;
}
+ if (type_uses_auto (TREE_TYPE (decl)))
+ error ("use of %qD before deduction of %<auto%>", decl);
+
/* If we don't need a value, then we don't need to synthesize DECL. */
if (cp_unevaluated_operand != 0)
return true;
if (LAMBDA_EXPR_RETURN_TYPE (lambda_expr))
return_type_specs.type = LAMBDA_EXPR_RETURN_TYPE (lambda_expr);
else
- /* Maybe we will deduce the return type later, but we can use void
- as a placeholder return type anyways. */
- return_type_specs.type = void_type_node;
+ /* Maybe we will deduce the return type later. */
+ return_type_specs.type = make_auto ();
p = obstack_alloc (&declarator_obstack, 0);
if (cp_parser_parse_definitely (parser))
{
- apply_lambda_return_type (lambda_expr, lambda_return_type (expr));
+ if (!processing_template_decl)
+ apply_deduced_return_type (fco, lambda_return_type (expr));
/* Will get error here if type not deduced yet. */
finish_return_stmt (expr);
if (!done)
{
- if (!LAMBDA_EXPR_RETURN_TYPE (lambda_expr))
- LAMBDA_EXPR_DEDUCE_RETURN_TYPE_P (lambda_expr) = true;
while (cp_lexer_next_token_is_keyword (parser->lexer, RID_LABEL))
cp_parser_label_declaration (parser);
cp_parser_statement_seq_opt (parser, NULL_TREE);
cp_parser_require (parser, CPP_CLOSE_BRACE, RT_CLOSE_BRACE);
- LAMBDA_EXPR_DEDUCE_RETURN_TYPE_P (lambda_expr) = false;
}
finish_compound_stmt (compound_stmt);
if (! cp_parser_uncommitted_to_tentative_parse_p (parser)
&& type_uses_auto (type_specified))
{
- error ("invalid use of %<auto%> in conversion operator");
- return error_mark_node;
+ if (cxx_dialect < cxx1y)
+ {
+ error ("invalid use of %<auto%> in conversion operator");
+ return error_mark_node;
+ }
+ else if (template_parm_scope_p ())
+ warning (0, "use of %<auto%> in member template "
+ "conversion operator can never be deduced");
}
return type_specified;
tree decl = lambda_function (type);
if (decl)
{
- tree lambda = CLASSTYPE_LAMBDA_EXPR (type);
- if (LAMBDA_EXPR_DEDUCE_RETURN_TYPE_P (lambda))
- {
- apply_lambda_return_type (lambda, void_type_node);
- LAMBDA_EXPR_RETURN_TYPE (lambda) = NULL_TREE;
- }
instantiate_decl (decl, false, false);
maybe_add_lambda_conv_op (type);
}
about the template parameter in question. */
return t;
+ /* Early in template argument deduction substitution, we don't
+ want to reduce the level of 'auto', or it will be confused
+ with a normal template parm in subsequent deduction. */
+ if (is_auto (t) && (complain & tf_partial))
+ return t;
+
/* If we get here, we must have been looking at a parm for a
more deeply nested template. Make a new version of this
template parameter, but with a lower level. */
= (LAMBDA_EXPR_DISCRIMINATOR (t));
LAMBDA_EXPR_EXTRA_SCOPE (r)
= RECUR (LAMBDA_EXPR_EXTRA_SCOPE (t));
- if (LAMBDA_EXPR_RETURN_TYPE (t) == dependent_lambda_return_type_node)
- {
- LAMBDA_EXPR_RETURN_TYPE (r) = dependent_lambda_return_type_node;
- LAMBDA_EXPR_DEDUCE_RETURN_TYPE_P (r) = true;
- }
- else
- LAMBDA_EXPR_RETURN_TYPE (r)
- = tsubst (LAMBDA_EXPR_RETURN_TYPE (t), args, complain, in_decl);
+ LAMBDA_EXPR_RETURN_TYPE (r)
+ = tsubst (LAMBDA_EXPR_RETURN_TYPE (t), args, complain, in_decl);
gcc_assert (LAMBDA_EXPR_THIS_CAPTURE (t) == NULL_TREE
&& LAMBDA_EXPR_PENDING_PROXIES (t) == NULL);
fntype = deduction_tsubst_fntype (fn, converted_args,
(explain_p
? tf_warning_or_error
- : tf_none));
+ : tf_none) | tf_partial);
processing_template_decl -= incomplete;
if (fntype == error_mark_node)
to see if it matches ARG. */
{
if (TREE_CODE (arg) == TREE_CODE (parm)
- && same_type_p (parm, arg))
+ && (is_auto (parm) ? is_auto (arg)
+ : same_type_p (parm, arg)))
return unify_success (explain_p);
else
return unify_type_mismatch (explain_p, parm, arg);
The call to fn_type_unification will handle substitution into the
FN. */
decl_type = TREE_TYPE (decl);
- if (explicit_args && uses_template_parms (decl_type))
+ if (explicit_args && decl == DECL_TEMPLATE_RESULT (fn))
{
tree tmpl;
tree converted_args;
that for "extern template" functions. Therefore, we check
DECL_DECLARED_INLINE_P, rather than possibly_inlined_p. */
return ((TREE_CODE (decl) == FUNCTION_DECL
- && DECL_DECLARED_INLINE_P (decl))
+ && (DECL_DECLARED_INLINE_P (decl)
+ || type_uses_auto (TREE_TYPE (TREE_TYPE (decl)))))
/* And we need to instantiate static data members so that
their initializers are available in integral constant
expressions. */
return tsubst (type, argvec, tf_warning_or_error, NULL_TREE);
}
-/* walk_tree helper for do_auto_deduction. */
-
-static tree
-contains_auto_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
- void *type)
-{
- /* Is this a variable with the type we're looking for? */
- if (DECL_P (*tp)
- && TREE_TYPE (*tp) == type)
- return *tp;
- else
- return NULL_TREE;
-}
-
/* Replace occurrences of 'auto' in TYPE with the appropriate type deduced
from INIT. AUTO_NODE is the TEMPLATE_TYPE_PARM used for 'auto' in TYPE. */
{
tree parms, tparms, targs;
tree args[1];
- tree decl;
int val;
+ if (init == error_mark_node)
+ return error_mark_node;
+
if (processing_template_decl
&& (TREE_TYPE (init) == NULL_TREE
|| BRACE_ENCLOSED_INITIALIZER_P (init)))
/* Not enough information to try this yet. */
return type;
- /* The name of the object being declared shall not appear in the
- initializer expression. */
- decl = cp_walk_tree_without_duplicates (&init, contains_auto_r, type);
- if (decl)
- {
- error ("variable %q#D with %<auto%> type used in its own "
- "initializer", decl);
- return error_mark_node;
- }
-
/* [dcl.spec.auto]: Obtain P from T by replacing the occurrences of auto
with either a new invented type template parameter U or, if the
initializer is a braced-init-list (8.5.4), with
/* If type is error_mark_node a diagnostic must have been
emitted by now. Also, having a mention to '<type error>'
in the diagnostic is not really useful to the user. */
- error ("unable to deduce %qT from %qE", type, init);
+ {
+ if (cfun && auto_node == current_function_auto_return_pattern
+ && LAMBDA_FUNCTION_P (current_function_decl))
+ error ("unable to deduce lambda return type from %qE", init);
+ else
+ error ("unable to deduce %qT from %qE", type, init);
+ }
return error_mark_node;
}
if (TREE_TYPE (auto_node)
&& !same_type_p (TREE_TYPE (auto_node), TREE_VEC_ELT (targs, 0)))
{
- error ("inconsistent deduction for %qT: %qT and then %qT",
- auto_node, TREE_TYPE (auto_node), TREE_VEC_ELT (targs, 0));
+ if (cfun && auto_node == current_function_auto_return_pattern
+ && LAMBDA_FUNCTION_P (current_function_decl))
+ error ("inconsistent types %qT and %qT deduced for "
+ "lambda return type", TREE_TYPE (auto_node),
+ TREE_VEC_ELT (targs, 0));
+ else
+ error ("inconsistent deduction for %qT: %qT and then %qT",
+ auto_node, TREE_TYPE (auto_node), TREE_VEC_ELT (targs, 0));
return error_mark_node;
}
TREE_TYPE (auto_node) = TREE_VEC_ELT (targs, 0);
if (!IDENTIFIER_MARKED (name))
{
tree type = DECL_CONV_FN_TYPE (cur);
+ if (type_uses_auto (type))
+ {
+ mark_used (cur);
+ type = DECL_CONV_FN_TYPE (cur);
+ }
if (check_hidden_convs (binfo, virtual_depth, virtualness,
type, parent_convs, other_convs))
tree
lambda_return_type (tree expr)
{
- tree type;
+ if (expr == NULL_TREE)
+ return void_type_node;
if (type_unknown_p (expr)
|| BRACE_ENCLOSED_INITIALIZER_P (expr))
{
cxx_incomplete_type_error (expr, TREE_TYPE (expr));
return void_type_node;
}
- if (type_dependent_expression_p (expr))
- type = dependent_lambda_return_type_node;
- else
- type = cv_unqualified (type_decays_to (unlowered_expr_type (expr)));
- return type;
+ gcc_checking_assert (!type_dependent_expression_p (expr));
+ return cv_unqualified (type_decays_to (unlowered_expr_type (expr)));
}
/* Given a LAMBDA_EXPR or closure type LAMBDA, return the op() of the
return type;
}
-/* Recompute the return type for LAMBDA with body of the form:
- { return EXPR ; } */
+/* Insert the deduced return type for an auto function. */
void
-apply_lambda_return_type (tree lambda, tree return_type)
+apply_deduced_return_type (tree fco, tree return_type)
{
- tree fco = lambda_function (lambda);
tree result;
- LAMBDA_EXPR_RETURN_TYPE (lambda) = return_type;
-
if (return_type == error_mark_node)
return;
- if (TREE_TYPE (TREE_TYPE (fco)) == return_type)
- return;
- /* TREE_TYPE (FUNCTION_DECL) == METHOD_TYPE
- TREE_TYPE (METHOD_TYPE) == return-type */
+ if (LAMBDA_FUNCTION_P (fco))
+ {
+ tree lambda = CLASSTYPE_LAMBDA_EXPR (current_class_type);
+ LAMBDA_EXPR_RETURN_TYPE (lambda) = return_type;
+ }
+
+ if (DECL_CONV_FN_P (fco))
+ DECL_NAME (fco) = mangle_conv_op_name_for_type (return_type);
+
TREE_TYPE (fco) = change_return_type (return_type, TREE_TYPE (fco));
result = DECL_RESULT (fco);
if (result == NULL_TREE)
return;
+ if (TREE_TYPE (result) == return_type)
+ return;
/* We already have a DECL_RESULT from start_preparsed_function.
Now we need to redo the work it and allocate_struct_function
DECL_RESULT (fco) = result;
- if (!processing_template_decl && aggregate_value_p (result, fco))
+ if (!processing_template_decl)
{
+ bool aggr = aggregate_value_p (result, fco);
#ifdef PCC_STATIC_STRUCT_RETURN
- cfun->returns_pcc_struct = 1;
+ cfun->returns_pcc_struct = aggr;
#endif
- cfun->returns_struct = 1;
+ cfun->returns_struct = aggr;
}
}
if (t2 == error_mark_node)
return t1;
+ /* Handle merging an auto redeclaration with a previous deduced
+ return type. */
+ if (is_auto (t1))
+ return t2;
+
/* Merge the attributes. */
attributes = (*targetm.merge_type_attributes) (t1, t2);
check_return_expr (tree retval, bool *no_warning)
{
tree result;
- /* The type actually returned by the function, after any
- promotions. */
+ /* The type actually returned by the function. */
tree valtype;
+ /* The type the function is declared to return, or void if
+ the declared type is incomplete. */
+ tree functype;
int fn_returns_value_p;
bool named_return_value_okay_p;
return NULL_TREE;
}
- /* As an extension, deduce lambda return type from a return statement
- anywhere in the body. */
- if (retval && LAMBDA_FUNCTION_P (current_function_decl))
- {
- tree lambda = CLASSTYPE_LAMBDA_EXPR (current_class_type);
- if (LAMBDA_EXPR_DEDUCE_RETURN_TYPE_P (lambda))
- {
- tree type = lambda_return_type (retval);
- tree oldtype = LAMBDA_EXPR_RETURN_TYPE (lambda);
-
- if (oldtype == NULL_TREE)
- apply_lambda_return_type (lambda, type);
- /* If one of the answers is type-dependent, we can't do any
- better until instantiation time. */
- else if (oldtype == dependent_lambda_return_type_node)
- /* Leave it. */;
- else if (type == dependent_lambda_return_type_node)
- apply_lambda_return_type (lambda, type);
- else if (!same_type_p (type, oldtype))
- error ("inconsistent types %qT and %qT deduced for "
- "lambda return type", type, oldtype);
- }
- }
-
if (processing_template_decl)
{
current_function_returns_value = 1;
return retval;
}
+ functype = TREE_TYPE (TREE_TYPE (current_function_decl));
+
+ /* Deduce auto return type from a return statement. */
+ if (current_function_auto_return_pattern)
+ {
+ tree auto_node;
+ tree type;
+
+ if (!retval && !is_auto (current_function_auto_return_pattern))
+ {
+ /* Give a helpful error message. */
+ error ("return-statement with no value, in function returning %qT",
+ current_function_auto_return_pattern);
+ inform (input_location, "only plain %<auto%> return type can be "
+ "deduced to %<void%>");
+ type = error_mark_node;
+ }
+ else
+ {
+ if (!retval)
+ retval = void_zero_node;
+ auto_node = type_uses_auto (current_function_auto_return_pattern);
+ type = do_auto_deduction (current_function_auto_return_pattern,
+ retval, auto_node);
+ }
+
+ if (type == error_mark_node)
+ /* Leave it. */;
+ else if (functype == current_function_auto_return_pattern)
+ apply_deduced_return_type (current_function_decl, type);
+ else
+ /* A mismatch should have been diagnosed in do_auto_deduction. */
+ gcc_assert (same_type_p (type, functype));
+ functype = type;
+ }
+
/* When no explicit return-value is given in a function with a named
return value, the named return value is used. */
result = DECL_RESULT (current_function_decl);
that's supposed to return a value. */
if (!retval && fn_returns_value_p)
{
- permerror (input_location, "return-statement with no value, in function returning %qT",
- valtype);
- /* Clear this, so finish_function won't say that we reach the
- end of a non-void function (which we don't, we gave a
- return!). */
- current_function_returns_null = 0;
+ if (functype != error_mark_node)
+ permerror (input_location, "return-statement with no value, in "
+ "function returning %qT", valtype);
+ /* Remember that this function did return. */
+ current_function_returns_value = 1;
/* And signal caller that TREE_NO_WARNING should be set on the
RETURN_EXPR to avoid control reaches end of non-void function
warnings in tree-cfg.c. */
&& DECL_CONTEXT (retval) == current_function_decl
&& ! TREE_STATIC (retval)
&& ! DECL_ANON_UNION_VAR_P (retval)
- && (DECL_ALIGN (retval)
- >= DECL_ALIGN (DECL_RESULT (current_function_decl)))
+ && (DECL_ALIGN (retval) >= DECL_ALIGN (result))
/* The cv-unqualified type of the returned value must be the
same as the cv-unqualified return type of the
function. */
&& same_type_p ((TYPE_MAIN_VARIANT (TREE_TYPE (retval))),
- (TYPE_MAIN_VARIANT
- (TREE_TYPE (TREE_TYPE (current_function_decl)))))
+ (TYPE_MAIN_VARIANT (functype)))
/* And the returned value must be non-volatile. */
&& ! TYPE_VOLATILE (TREE_TYPE (retval)));
;
else
{
- /* The type the function is declared to return. */
- tree functype = TREE_TYPE (TREE_TYPE (current_function_decl));
int flags = LOOKUP_NORMAL | LOOKUP_ONLYCONVERTING;
/* The functype's return type will have been set to void, if it
&& DECL_CONTEXT (retval) == current_function_decl
&& !TREE_STATIC (retval)
&& same_type_p ((TYPE_MAIN_VARIANT (TREE_TYPE (retval))),
- (TYPE_MAIN_VARIANT
- (TREE_TYPE (TREE_TYPE (current_function_decl)))))
+ (TYPE_MAIN_VARIANT (functype)))
/* This is only interesting for class type. */
- && CLASS_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl))))
+ && CLASS_TYPE_P (functype))
flags = flags | LOOKUP_PREFER_RVALUE;
/* First convert the value to the function's return type, then
else
diag_type = DK_ERROR; /* error */
- if (diag_type != DK_UNSPECIFIED && complain)
+ if (diag_type != DK_UNSPECIFIED
+ && (complain & tf_warning_or_error))
cxx_incomplete_type_diagnostic (NULL_TREE, core, diag_type);
return list;
+2012-03-21 Jason Merrill <jason@redhat.com>
+
+ * g++.dg/cpp0x/auto3.C: Compile with -pedantic-errors.
+ * g++.dg/cpp0x/trailing2.C: Likewise.
+ * g++.dg/warn/pr23075.C: Change dg-warning to dg-bogus.
+ * g++.dg/cpp1y/auto-fn1.C: New.
+ * g++.dg/cpp1y/auto-fn2.C: New.
+ * g++.dg/cpp1y/auto-fn3.C: New.
+ * g++.dg/cpp1y/auto-fn4.C: New.
+ * g++.dg/cpp1y/auto-fn5.C: New.
+ * g++.dg/cpp1y/auto-fn6.C: New.
+ * g++.dg/cpp1y/auto-fn7.C: New.
+ * g++.dg/cpp1y/auto-fn8.C: New.
+ * g++.dg/cpp1y/auto-fn9.C: New.
+ * g++.dg/cpp1y/auto-fn10.C: New.
+ * g++.dg/cpp1y/auto-fn11.C: New.
+
2012-03-23 Richard Guenther <rguenther@suse.de>
PR tree-optimization/52678
void f()
{
- auto val = val; // { dg-error "auto. type used in its own initializer" }
+ auto val = val; // { dg-error "auto" }
}
// Negative test for auto
-// { dg-options "-std=c++0x" }
+// { dg-do compile { target c++11 } }
#include <initializer_list>
auto i = 42, j = 42.0; // { dg-error "auto" }
// New CWG issue
-auto a[2] = { 1, 2 }; // { dg-error "initializer_list" }
+auto a[2] = { 1, 2 }; // { dg-error "auto|initializer_list" }
template<class T>
struct A { };
// PR c++/37967
// Negative test for auto
-// { dg-options "-std=c++0x" }
+// { dg-do compile { target c++11 } }
auto f1 () -> int;
auto f2 (); // { dg-error "without trailing return type" }
--- /dev/null
+// { dg-options -std=c++1y }
+
+constexpr auto f() { return (char)42; }
+#define SA(X) static_assert ((X),#X)
+SA (f() == 42);
--- /dev/null
+// A template declared with auto should be declared with auto in an
+// explicit instantiation or explicit specialization, too.
+// { dg-options -std=c++1y }
+
+template <class T>
+auto f(T t) { return t; }
+
+template<> auto f<int>(int);
+template auto f<float>(float);
+template<> auto f(int*);
+template auto f(float*);
+
+template<> short f<short>(short); // { dg-error "does not match" }
+template char f<char>(char); // { dg-error "does not match" }
+template<> short f(short*); // { dg-error "does not match" }
+template char f(char*); // { dg-error "does not match" }
--- /dev/null
+// { dg-options -std=c++1y }
+
+auto f() { return; } // OK, return type is void
+auto* g() { return; } // { dg-error "no value" }
+auto* h() { } // { dg-error "no return statements" }
--- /dev/null
+// { dg-options -std=c++1y }
+// { dg-final { scan-assembler "_ZN1AIiEcviEv" } }
+
+template <class T>
+struct A {
+ T t;
+ operator auto() { return t+1; }
+};
+
+int main()
+{
+ int i = A<int>{42};
+ return (i != 43);
+}
--- /dev/null
+// { dg-options -std=c++1y }
+
+struct A {
+ template <class T>
+ operator auto() { return T(); } // { dg-warning "auto.*template" }
+};
--- /dev/null
+// { dg-options -std=c++1y }
+
+auto f() { return f(); } // { dg-error "auto" }
--- /dev/null
+// { dg-options -std=c++1y }
+
+bool b;
+auto f()
+{
+ if (b)
+ return 42;
+ else
+ return f();
+}
--- /dev/null
+// { dg-options -std=c++1y }
+
+template <class T>
+constexpr auto f(T t) { return t+1; }
+
+#define SA(X) static_assert((X),#X)
+SA(f(1)==2);
--- /dev/null
+// { dg-options -std=c++1y }
+// { dg-do run }
+
+int i;
+auto& f() { return i; }
+
+int main()
+{
+ f() = 42;
+ return i != 42;
+}
--- /dev/null
+// { dg-options -std=c++1y }
+
+template <class T, class U> struct ST;
+template <class T> struct ST<T,T> {};
+
+int g(int);
+char& g(char);
+double&& g(double);
+
+template <class T> auto&& f(T t)
+{ return g(t); } // { dg-warning "reference to temporary" }
+
+int main()
+{
+ ST<decltype(f(1)),int&&>();
+ ST<decltype(f('\0')),char&>();
+ ST<decltype(f(1.0)),double&&>();
+}
--- /dev/null
+// { dg-options "-std=c++1y -pedantic-errors" }
+
+auto f();
+
+template <class T> auto f(T);
--- /dev/null
+// { dg-options "-std=c++1y -pedantic-errors" }
+
+auto f() { return 42; } // { dg-error "deduced return type" }
+auto f(); // OK
+int f(); // { dg-error "new declaration" }
+
+template <class T> auto f(T t) { return t; }
+template <class T> T f(T t);
+
+int main()
+{
+ f(42); // { dg-error "ambiguous" }
+}
--- /dev/null
+// { dg-options -std=c++1y }
+// { dg-final { scan-assembler "_Z1fIiERDaRKT_S1_" } }
+
+template <class T>
+auto& f(const T& t, T u) { return t; }
+
+int main()
+{
+ int i;
+ f(i,i);
+}
foo ()
{
#pragma omp parallel for
- for (auto i = i = 0; i<4; ++i) // { dg-error "incomplete|unable|invalid" }
+ for (auto i = i = 0; i<4; ++i) // { dg-error "incomplete|unable|invalid|auto" }
;
}
foo (void)
{
return; // { dg-error "with no value" }
-} // { dg-warning "no return statement" }
+} // { dg-bogus "no return statement" }
template <class T>
template <> // { dg-error "enclosing class templates|invalid explicit specialization" }
-void S<T>::f<int> () // { dg-error "does not match|invalid function declaration" }
+void S<T>::f<int> ()
{
}
projects / gcc.git / commitdiff