In discussion of core issue 1586 at the Bristol meeting, someone
suggested that we should remove ~decltype(expr) and instead allow ~auto.
This patch implements that, currently limited to C++1y mode.
Tested x86_64-pc-linux-gnu, applying to trunk.
commit 37c8b2edbc39b6b6278afc08f7b74ace79743c5d
Author: Jason Merrill <ja...@redhat.com>
Date: Tue Apr 16 22:33:08 2013 +0100
Core 1586
* parser.c (cp_parser_unqualified_id): Handle ~auto.
(cp_parser_pseudo_destructor_name): Likewise.
(cp_parser_postfix_dot_deref_expression): Adjust.
(cp_lexer_nth_token_is_keyword): New.
* semantics.c (finish_pseudo_destructor_expr): Handle ~auto.
* typeck.c (lookup_destructor): Handle ~auto.
diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c
index 1fbc9bd..0456dd2 100644
--- a/gcc/cp/parser.c
+++ b/gcc/cp/parser.c
@@ -866,6 +866,12 @@ cp_lexer_next_token_is_keyword (cp_lexer* lexer, enum rid keyword)
return cp_lexer_peek_token (lexer)->keyword == keyword;
}
+static inline bool
+cp_lexer_nth_token_is_keyword (cp_lexer* lexer, size_t n, enum rid keyword)
+{
+ return cp_lexer_peek_nth_token (lexer, n)->keyword == keyword;
+}
+
/* Return true if the next token is not the indicated KEYWORD. */
static inline bool
@@ -1860,7 +1866,7 @@ static vec<tree, va_gc> *cp_parser_parenthesized_expression_list
/* Values for the second parameter of cp_parser_parenthesized_expression_list. */
enum { non_attr = 0, normal_attr = 1, id_attr = 2 };
static void cp_parser_pseudo_destructor_name
- (cp_parser *, tree *, tree *);
+ (cp_parser *, tree, tree *, tree *);
static tree cp_parser_unary_expression
(cp_parser *, bool, bool, cp_id_kind *);
static enum tree_code cp_parser_unary_operator
@@ -4821,6 +4827,17 @@ cp_parser_unqualified_id (cp_parser* parser,
return build_nt (BIT_NOT_EXPR, scope);
}
+ /* ~auto means the destructor of whatever the object is. */
+ if (cp_parser_is_keyword (token, RID_AUTO))
+ {
+ if (cxx_dialect < cxx1y)
+ pedwarn (input_location, 0,
+ "%<~auto%> only available with "
+ "-std=c++1y or -std=gnu++1y");
+ cp_lexer_consume_token (parser->lexer);
+ return build_nt (BIT_NOT_EXPR, make_auto ());
+ }
+
/* If there was an explicit qualification (S::~T), first look
in the scope given by the qualification (i.e., S).
@@ -6171,18 +6188,18 @@ cp_parser_postfix_dot_deref_expression (cp_parser *parser,
cp_parser_parse_tentatively (parser);
/* Parse the pseudo-destructor-name. */
s = NULL_TREE;
- cp_parser_pseudo_destructor_name (parser, &s, &type);
+ cp_parser_pseudo_destructor_name (parser, postfix_expression,
+ &s, &type);
if (dependent_p
&& (cp_parser_error_occurred (parser)
- || TREE_CODE (type) != TYPE_DECL
- || !SCALAR_TYPE_P (TREE_TYPE (type))))
+ || !SCALAR_TYPE_P (type)))
cp_parser_abort_tentative_parse (parser);
else if (cp_parser_parse_definitely (parser))
{
pseudo_destructor_p = true;
postfix_expression
= finish_pseudo_destructor_expr (postfix_expression,
- s, TREE_TYPE (type));
+ s, type);
}
}
@@ -6443,11 +6460,28 @@ cp_parser_parenthesized_expression_list (cp_parser* parser,
static void
cp_parser_pseudo_destructor_name (cp_parser* parser,
+ tree object,
tree* scope,
tree* type)
{
bool nested_name_specifier_p;
+ /* Handle ~auto. */
+ if (cp_lexer_next_token_is (parser->lexer, CPP_COMPL)
+ && cp_lexer_nth_token_is_keyword (parser->lexer, 2, RID_AUTO)
+ && !type_dependent_expression_p (object))
+ {
+ if (cxx_dialect < cxx1y)
+ pedwarn (input_location, 0,
+ "%<~auto%> only available with "
+ "-std=c++1y or -std=gnu++1y");
+ cp_lexer_consume_token (parser->lexer);
+ cp_lexer_consume_token (parser->lexer);
+ *scope = NULL_TREE;
+ *type = TREE_TYPE (object);
+ return;
+ }
+
/* Assume that things will not work out. */
*type = error_mark_node;
@@ -6515,7 +6549,7 @@ cp_parser_pseudo_destructor_name (cp_parser* parser,
/* Look for the type-name again. We are not responsible for
checking that it matches the first type-name. */
- *type = cp_parser_nonclass_name (parser);
+ *type = TREE_TYPE (cp_parser_nonclass_name (parser));
}
/* Parse a unary-expression.
diff --git a/gcc/cp/semantics.c b/gcc/cp/semantics.c
index 2b8ceb2..d4f0f82 100644
--- a/gcc/cp/semantics.c
+++ b/gcc/cp/semantics.c
@@ -2373,6 +2373,8 @@ finish_pseudo_destructor_expr (tree object, tree scope, tree destructor)
error ("invalid qualifying scope in pseudo-destructor name");
return error_mark_node;
}
+ if (is_auto (destructor))
+ destructor = TREE_TYPE (object);
if (scope && TYPE_P (scope) && !check_dtor_name (scope, destructor))
{
error ("qualified type %qT does not match destructor name ~%qT",
diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c
index 50405c3..c0696e0 100644
--- a/gcc/cp/typeck.c
+++ b/gcc/cp/typeck.c
@@ -2483,7 +2483,9 @@ lookup_destructor (tree object, tree scope, tree dtor_name,
scope, dtor_type);
return error_mark_node;
}
- if (identifier_p (dtor_type))
+ if (is_auto (dtor_type))
+ dtor_type = object_type;
+ else if (identifier_p (dtor_type))
{
/* In a template, names we can't find a match for are still accepted
destructor names, and we check them here. */
diff --git a/gcc/testsuite/g++.dg/cpp1y/auto-dtor1.C b/gcc/testsuite/g++.dg/cpp1y/auto-dtor1.C
new file mode 100644
index 0000000..7105095
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp1y/auto-dtor1.C
@@ -0,0 +1,22 @@
+// DR 1586
+// { dg-options "-std=c++1y" }
+// { dg-do run }
+
+template <class T>
+void f (T* p)
+{
+ p->~auto();
+}
+
+int d;
+struct A { ~A() { ++d; } };
+
+int main()
+{
+ f(new int(42));
+ f(new A);
+ if (d != 1)
+ throw;
+
+ (new int)->~auto();
+}
