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

diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index e0075e0e9813dab5727709609dfcb3c530e9c55c..502dc20430289aeebd7c2d764542469746f49a6f 100644 (file)
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -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

diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c
index 52584c51f1e2f0fcbc91f0bf7ec0792b9a1013d9..208173a8dfa0db8a757de804e3639c23b9765595 100644 (file)
--- a/gcc/cp/decl.c
+++ b/gcc/cp/decl.c
@@ -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)

diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c
index f8c123c1313e2240d085cf2c6a270cbd7cfc1785..5f28f1b563761be39393ae9eeb48e8c396c91369 100644 (file)
--- a/gcc/cp/pt.c
+++ b/gcc/cp/pt.c
@@ -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);
 

diff --git a/gcc/cp/semantics.c b/gcc/cp/semantics.c
index d42838e78ccf3a9e33eae0801edf52f13186042c..17b0a1457b4b99ade72d51613f745a1ebaf27a59 100644 (file)
--- a/gcc/cp/semantics.c
+++ b/gcc/cp/semantics.c
@@ -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)

diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c
index a7a884486fe31b373e8049c1c59a6961bafca565..5d754f1228a997c0e55bfbeeb45ae6b00a2b38df 100644 (file)
--- a/gcc/cp/typeck.c
+++ b/gcc/cp/typeck.c
@@ -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