git
/
gcc
mirror of git://gcc.gnu.org/git/gcc.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

decl.c (cp_finish_decl): Tidy. 

* decl.c (cp_finish_decl): Tidy.
	* typeck.c (finish_class_member_access_expr): Use
	type_dependent_expression_p.
	* semantics.c (finish_id_expression): Use
	type_dependent_expression_p.  Don't build_qualified_name for a
	decl in non-dependent scope.
	* pt.c (type_dependent_expression_p): A TEMPLATE_ID_EXPR of an
	identifier is dependent.  Remove variable_template_p check.

From-SVN: r226652
This commit is contained in:
Jason Merrill 2015-08-05 21:33:27 -04:00 committed by Jason Merrill
parent d8835b4d85
commit a2b4cfaa89
5 changed files with 29 additions and 89 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
gcc/cp/ChangeLog
View File

@ -1,5 +1,14 @@
2015-08-05 Jason Merrill <jason@redhat.com>
* decl.c (cp_finish_decl): Tidy.
* typeck.c (finish_class_member_access_expr): Use
type_dependent_expression_p.
* semantics.c (finish_id_expression): Use
type_dependent_expression_p. Don't build_qualified_name for a
decl in non-dependent scope.
* pt.c (type_dependent_expression_p): A TEMPLATE_ID_EXPR of an
identifier is dependent. Remove variable_template_p check.
PR c++/66260
PR c++/66596
PR c++/66649

3
gcc/cp/decl.c
View File

@ -6525,11 +6525,10 @@ cp_finish_decl (tree decl, tree init, bool init_const_expr_p,
then it can be used in future constant expressions, so its value
must be available. */
if (!VAR_P (decl) || dependent_type_p (type))
if (!VAR_P (decl) || type_dependent_p)
/* We can't do anything if the decl has dependent type. */;
else if (init
&& init_const_expr_p
&& !type_dependent_p
&& TREE_CODE (type) != REFERENCE_TYPE
&& decl_maybe_constant_var_p (decl)
&& !type_dependent_init_p (init)

5
gcc/cp/pt.c
View File

@ -21671,11 +21671,10 @@ type_dependent_expression_p (tree expression)
(TREE_OPERAND (expression, 1)))
return true;
expression = TREE_OPERAND (expression, 0);
if (identifier_p (expression))
return true;
}
if (variable_template_p (expression))
return dependent_type_p (TREE_TYPE (expression));
gcc_assert (TREE_CODE (expression) == OVERLOAD
|| TREE_CODE (expression) == FUNCTION_DECL);

94
gcc/cp/semantics.c
View File

@ -3362,7 +3362,7 @@ finish_id_expression (tree id_expression,
}
else
{
bool dependent_p;
bool dependent_p = type_dependent_expression_p (decl);
/* If the declaration was explicitly qualified indicate
that. The semantics of `A::f(3)' are different than
@ -3371,79 +3371,25 @@ finish_id_expression (tree id_expression,
? CP_ID_KIND_QUALIFIED
: (TREE_CODE (decl) == TEMPLATE_ID_EXPR
? CP_ID_KIND_TEMPLATE_ID
: CP_ID_KIND_UNQUALIFIED));
/* [temp.dep.expr]
An id-expression is type-dependent if it contains an
identifier that was declared with a dependent type.
The standard is not very specific about an id-expression that
names a set of overloaded functions. What if some of them
have dependent types and some of them do not? Presumably,
such a name should be treated as a dependent name. */
/* Assume the name is not dependent. */
dependent_p = false;
if (!processing_template_decl)
/* No names are dependent outside a template. */
;
else if (TREE_CODE (decl) == CONST_DECL)
/* We don't want to treat enumerators as dependent. */
;
/* A template-id where the name of the template was not resolved
is definitely dependent. */
else if (TREE_CODE (decl) == TEMPLATE_ID_EXPR
&& (identifier_p (TREE_OPERAND (decl, 0))))
dependent_p = true;
/* For anything except an overloaded function, just check its
type. */
else if (!is_overloaded_fn (decl))
dependent_p
= dependent_type_p (TREE_TYPE (decl));
/* For a set of overloaded functions, check each of the
functions. */
else
{
tree fns = decl;
if (BASELINK_P (fns))
fns = BASELINK_FUNCTIONS (fns);
/* For a template-id, check to see if the template
arguments are dependent. */
if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
{
tree args = TREE_OPERAND (fns, 1);
dependent_p = any_dependent_template_arguments_p (args);
/* The functions are those referred to by the
template-id. */
fns = TREE_OPERAND (fns, 0);
}
/* If there are no dependent template arguments, go through
the overloaded functions. */
while (fns && !dependent_p)
{
tree fn = OVL_CURRENT (fns);
/* Member functions of dependent classes are
dependent. */
if (TREE_CODE (fn) == FUNCTION_DECL
&& type_dependent_expression_p (fn))
dependent_p = true;
else if (TREE_CODE (fn) == TEMPLATE_DECL
&& dependent_template_p (fn))
dependent_p = true;
fns = OVL_NEXT (fns);
}
}
: (dependent_p
? CP_ID_KIND_UNQUALIFIED_DEPENDENT
: CP_ID_KIND_UNQUALIFIED)));
/* If the name was dependent on a template parameter, we will
resolve the name at instantiation time. */
if (dependent_p)
{
/* If we found a variable, then name lookup during the
instantiation will always resolve to the same VAR_DECL
(or an instantiation thereof). */
if (VAR_P (decl)
|| TREE_CODE (decl) == CONST_DECL
|| TREE_CODE (decl) == PARM_DECL)
{
mark_used (decl);
return convert_from_reference (decl);
}
/* Create a SCOPE_REF for qualified names, if the scope is
dependent. */
if (scope)
@ -3475,16 +3421,6 @@ finish_id_expression (tree id_expression,
need. */
if (TREE_CODE (id_expression) == TEMPLATE_ID_EXPR)
return id_expression;
*idk = CP_ID_KIND_UNQUALIFIED_DEPENDENT;
/* If we found a variable, then name lookup during the
instantiation will always resolve to the same VAR_DECL
(or an instantiation thereof). */
if (VAR_P (decl)
|| TREE_CODE (decl) == PARM_DECL)
{
mark_used (decl);
return convert_from_reference (decl);
}
/* The same is true for FIELD_DECL, but we also need to
make sure that the syntax is correct. */
else if (TREE_CODE (decl) == FIELD_DECL)

7
gcc/cp/typeck.c
View File

@ -2636,11 +2636,8 @@ finish_class_member_access_expr (tree object, tree name, bool template_p,
if (processing_template_decl)
{
if (/* If OBJECT_TYPE is dependent, so is OBJECT.NAME. */
dependent_type_p (object_type)
/* If NAME is just an IDENTIFIER_NODE, then the expression
is dependent. */
|| identifier_p (object)
if (/* If OBJECT is dependent, so is OBJECT.NAME. */
type_dependent_expression_p (object)
/* If NAME is "f<args>", where either 'f' or 'args' is
dependent, then the expression is dependent. */
|| (TREE_CODE (name) == TEMPLATE_ID_EXPR