gcc/cp/pt.c

74    this to pass the statement expression node from the STMT_EXPR
1165        the default argument expression is not substituted for in an
2758      A partially specialized non-type argument expression shall not
2760      when the argument expression is a simple identifier.
2773 	  /* This next line is the `argument expression is not just a
3432 /* Simplify EXPR if it is a non-dependent expression.  Returns the
3433    (possibly simplified) expression.  */
3467 /* EXPR is an expression which is used in a constant-expression context.
3469    Extract the innest constant expression.
3638 		 "because it is a non-constant expression", expr, type);
3643 	 because we already know that the expression is of integral
3666 	    expressed as "& id-expression" where the & is optional if the name
5077       /* If there's no type, then this thing must be some expression
6367   /* The default argument expression may cause implicitly defined
7847    type of the expression on the left-hand side of the "." or "->"
7911    true if the qualified-id will be a postfix-expression in-and-of
7912    itself; false if more of the postfix-expression follows the
7947      are just trying to simplify a non-dependent expression.  In that
8029    template parms; to finish processing the resultant expression, use
8591 	/* A DECL_EXPR can also be used as an expression, in the condition
8852 /* T is a postfix-expression that is not being used in a function
8996 		   "enumeration type cannot appear in a constant-expression");
9100 	     non-dependent expression from the parser.  Trying to do
9124 	/* TREE_NO_WARNING must be set if either the expression was
9170 	/* When we parsed the expression,  we determined whether or
9531 	    error ("integral expression %qE is not constant", t);
10088        -- but the deduction does not succeed because the expression is
10121    ADDR_P is true if the expression for which deduction is being
10623 	 template-parameter is used in an expression in the function
10631 	/* Template-parameter dependent expression.  Just accept it for now.
10953       /* We must be looking at an expression.  This can happen with
10966 	     the template-arguments is an expression that references
12063      case that an expression refers to the value of the variable --
12064      if the variable has a constant value the referring expression can
12726 	size is specified by a constant expression that is
12744 	an expression that is type-dependent or value-dependent.  */
12751      expression is not type-dependent, then it should already been
12817 dependent_scope_ref_p (tree expression, bool criterion (tree))
12822   gcc_assert (TREE_CODE (expression) == SCOPE_REF);
12824   if (!TYPE_P (TREE_OPERAND (expression, 0)))
12827   scope = TREE_OPERAND (expression, 0);
12828   name = TREE_OPERAND (expression, 1);
12832      An id-expression is type-dependent if it contains a
12850    expression.  */
12853 value_dependent_expression_p (tree expression)
12859   if (DECL_P (expression) && type_dependent_expression_p (expression))
12862   switch (TREE_CODE (expression))
12874       if (DECL_TEMPLATE_PARM_P (expression))
12880 	  with an expression that is value-dependent.  */
12881       if (DECL_INITIAL (expression)
12882 	  && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (expression))
12883 	  && value_dependent_expression_p (DECL_INITIAL (expression)))
12893 	 the cast occurs is dependent or the expression being casted
12896 	tree type = TREE_TYPE (expression);
12902 	expression = TREE_OPERAND (expression, 0);
12903 	if (!expression)
12905 	    /* If there are no operands, it must be an expression such
12913 	if (TREE_CODE (expression) == TREE_LIST)
12914 	  return any_value_dependent_elements_p (expression);
12916 	return value_dependent_expression_p (expression);
12921       /* A `sizeof' expression is value-dependent if the operand is
12923       expression = TREE_OPERAND (expression, 0);
12924       if (TYPE_P (expression))
12925 	return dependent_type_p (expression);
12926       return type_dependent_expression_p (expression);
12929       return dependent_scope_ref_p (expression, value_dependent_expression_p);
12932       return (value_dependent_expression_p (TREE_OPERAND (expression, 0))
12933 	      || value_dependent_expression_p (TREE_OPERAND (expression, 1)));
12936       /* A CALL_EXPR may appear in a constant expression if it is a
12942       return ((value_dependent_expression_p (TREE_OPERAND (expression, 0)))
12943 	      || (value_dependent_expression_p (TREE_OPERAND (expression, 2))));
12946       /* A constant expression is value-dependent if any subexpression is
12948       switch (TREE_CODE_CLASS (TREE_CODE (expression)))
12953 		  (TREE_OPERAND (expression, 0)));
12958 		   (TREE_OPERAND (expression, 0)))
12960 		      (TREE_OPERAND (expression, 1))));
12965 	    for (i = 0; i < TREE_CODE_LENGTH (TREE_CODE (expression)); ++i)
12969 		 make the expression dependent.  */
12970 	      if (TREE_OPERAND (expression, i)
12972 		      (TREE_OPERAND (expression, i))))
12982   /* The expression is not value-dependent.  */
12990 type_dependent_expression_p (tree expression)
12995   if (expression == error_mark_node)
12999   if (TREE_CODE (expression) == IDENTIFIER_NODE
13000       || TREE_CODE (expression) == USING_DECL)
13003   /* Some expression forms are never type-dependent.  */
13004   if (TREE_CODE (expression) == PSEUDO_DTOR_EXPR
13005       || TREE_CODE (expression) == SIZEOF_EXPR
13006       || TREE_CODE (expression) == ALIGNOF_EXPR
13007       || TREE_CODE (expression) == TYPEID_EXPR
13008       || TREE_CODE (expression) == DELETE_EXPR
13009       || TREE_CODE (expression) == VEC_DELETE_EXPR
13010       || TREE_CODE (expression) == THROW_EXPR)
13015   if (TREE_CODE (expression) == DYNAMIC_CAST_EXPR
13016       || TREE_CODE (expression) == STATIC_CAST_EXPR
13017       || TREE_CODE (expression) == CONST_CAST_EXPR
13018       || TREE_CODE (expression) == REINTERPRET_CAST_EXPR
13019       || TREE_CODE (expression) == CAST_EXPR)
13020     return dependent_type_p (TREE_TYPE (expression));
13023      by the expression.  */
13024   if (TREE_CODE (expression) == NEW_EXPR
13025       || TREE_CODE (expression) == VEC_NEW_EXPR)
13030       tree type = TREE_OPERAND (expression, 1);
13041   if (TREE_CODE (expression) == SCOPE_REF
13042       && dependent_scope_ref_p (expression,
13046   if (TREE_CODE (expression) == FUNCTION_DECL
13047       && DECL_LANG_SPECIFIC (expression)
13048       && DECL_TEMPLATE_INFO (expression)
13050 	  (INNERMOST_TEMPLATE_ARGS (DECL_TI_ARGS (expression)))))
13053   if (TREE_CODE (expression) == TEMPLATE_DECL
13054       && !DECL_TEMPLATE_TEMPLATE_PARM_P (expression))
13057   if (TREE_TYPE (expression) == unknown_type_node)
13059       if (TREE_CODE (expression) == ADDR_EXPR)
13060 	return type_dependent_expression_p (TREE_OPERAND (expression, 0));
13061       if (TREE_CODE (expression) == COMPONENT_REF
13062 	  || TREE_CODE (expression) == OFFSET_REF)
13064 	  if (type_dependent_expression_p (TREE_OPERAND (expression, 0)))
13066 	  expression = TREE_OPERAND (expression, 1);
13067 	  if (TREE_CODE (expression) == IDENTIFIER_NODE)
13071       if (TREE_CODE (expression) == SCOPE_REF)
13074       if (TREE_CODE (expression) == BASELINK)
13075 	expression = BASELINK_FUNCTIONS (expression);
13077       if (TREE_CODE (expression) == TEMPLATE_ID_EXPR)
13080 	      (TREE_OPERAND (expression, 1)))
13082 	  expression = TREE_OPERAND (expression, 0);
13084       gcc_assert (TREE_CODE (expression) == OVERLOAD
13085 		  || TREE_CODE (expression) == FUNCTION_DECL);
13087       while (expression)
13089 	  if (type_dependent_expression_p (OVL_CURRENT (expression)))
13091 	  expression = OVL_NEXT (expression);
13096   gcc_assert (TREE_CODE (expression) != TYPE_DECL);
13098   return (dependent_type_p (TREE_TYPE (expression)));
13102    contains a type-dependent expression.  */
13292 /* EXPR is an expression which is not type-dependent.  Return a proxy
13329      particular expression is a throw-expression: when checking a ?:
13330      expression, there are special rules if the second or third
13331      argument is a throw-expression.  */
13361      In the body of "f", the expression for "g" will have
13364      the expression so that mangling (say) "f<g>" inside the body of