gcc/cp/pt.c

18 You should have received a copy of the GNU General Public License
64    instantiations have been deferred, either because their definitions
364    Both A<T>::B<int> and A<int>::B<U> have depth one, if
732 /* Any template <>'s that we have seen thus far are not referring to a
942 		  /* We already have a full specialization of this partial
972 	     have one level of template argument for the innermost
1017 	  /* It is possible to have a template that is not a member
1024 	     not have template information.  The optimized lookup relies
1428 		 situation can occur if we have implicitly
1449 	      /* The call to duplicate_decls will have applied
1509 	   specialization would have used it.  */
1994 	     full specialization of a constructor will have a VTT
2014 	     to make this specialization a friend, and we have already done
2092       /* We have:
2104 	 specialized.  However, we, also have:
2152   /* We have one, and exactly one, match.  */
2312       /* You're supposed to have one `template <...>' for every
2323 	/* If CTYPE does not have template information of any
2354       // Namespace-scope variable templates should have a template header.
2609 	       but the error will already have been flagged by
2638 	  /* Find the list of functions in ctype that have the same
2695 		       with those we already have.  */
2847 	     have been set incorrectly.  For example, in:
2854 	     we will have set the DECL_CONTEXT for the friend
2875 	  /* A 'structor should already have clones.  */
2949   /* Determine if we have a non-type template parameter pack.  */
3001   /* The parameter pack and its pack arguments have the same
3163   /* Set of AST nodes that have been visited by the traversal.  */
3463 /* Checks T for any "bare" parameter packs, which have not yet been
3466    statement, "if" condition, etc.), because we could have expressions like:
4005 	 Consider the level of the parms of TT; T and U both have
4010 	 have level 1. Instead, let's create a dummy vector as the
4194      or some such would have been OK.  */
4520     /* You can't have a function template declaration in a local
4530     /* A lambda doesn't have an explicit declaration; don't complain
4563          subsequent template-parameters shall have a default
4586                      there should have been a default argument.  */
4602 		  /* A primary class template can only have one
4626        there, as we have in [temp.class.spec]:
4814 		error ("member template %qD may not have virt-specifiers", decl);
4835 		 have two or more parameters.  */
4862      declaration that have not been expanded.  */
4877                packs. We have already complained about this in the
5116      ARGS may only have the innermost set of arguments.  Add the missing
5261 	  /* We have in [temp.param]:
5534 		   "because %qD does not have external linkage",
5630 	    "  types %qT and %qT have incompatible cv-qualifiers",
5722 unify_arity (bool explain_p, int have, int wanted, bool least_p = false)
5730 		  wanted, have);
5735 		  wanted, have);
5741 unify_too_many_arguments (bool explain_p, int have, int wanted)
5743   return unify_arity (explain_p, have, wanted);
5747 unify_too_few_arguments (bool explain_p, int have, int wanted,
5750   return unify_arity (explain_p, have, wanted, least_p);
5872      have a syntactic, rather than semantic, form.  For example, EXPR
6090 		       "because %qD does not have external linkage",
6154 		       "because a reference variable does not have a constant "
6189       /* If the argument is a template-id, we might not have enough
6411   /* Determine whether we have a parameter pack at the end of the
6490    routine can only be called after all template arguments have been
6903 	  /* We don't know how many args we have yet, just
6923 	  /* Once we've packed as many args as we have types, stop.  */
6927 	    /* We don't know how many args we have yet, just
7161 	      /* We don't know how many args we have yet, just use the
7209               /* We don't know how many args we have yet, just
7238            parameter list itself (which we would already have
7283    outermost ones are supposed to have been coerced already.
7793       /* Now we should have enough arguments.  */
7804 	  /* We have multiple levels of arguments to coerce, at once.  */
7823 		/* Outer levels should have already been coerced.  */
7877       /* If we already have this specialization, return it.  */
8261       /* Since we're not going to walk subtrees, we have to do this
8668        function declaration.  Now, we have to figure out what
8701      the language.  For example, we might have had:
8788 	     instantiation of `f' will have DECL_TI_ARGS corresponding
8826 		  /* We should have called reregister_specialization in
9457 		     pushtag calling push_template_decl.  We don't have to do
9458 		     this for enums because it will already have been done in
9577 			 such a thing will already have been added to the field
9667 		 We don't have to do anything in these cases.  */
9731 	     that may have been added during instantiation of the op().  */
9779      method, however, finish_struct_1 will already have added TYPE to
9906     to wait for when we have enough arguments to really perform the
10104 	       have the wrong value for a recursive call.  */
10180 	     packs don't have a level.  */
10192       /* Types need no adjustment, nor does sizeof..., and if we still have
10201   /* We cannot expand this expansion expression, because we don't have
10206 	 have values for all the packs.  So remember these until then.  */
10233 	 case of recursive unification) might have bindings that we don't
10296    have the same DECL_PARM_INDEX.  */
10780 	/* We might already have an instance of this template.
10799 	   tsubst might not have changed anything.  */
10898 	    /* If T is not dependent, just return it.  We have to
10919 	    /* Check to see if we already have this specialization.  */
10938 	       want to generate, but we'll have enough arguments for
10970 	    /* This special case arises when we have something like this:
11022 	/* OpenMP UDRs have the only argument a reference to the declared
11336 	    /* We don't have to set DECL_CONTEXT here; it is set by
11404 	    /* If this is the canonical decl, we don't have to
11416 	/* Check to see if we already have the specialization we
11422 	       We have to substitute into namespace-scope variables
11476 	/* If we already have the specialization we need, there is
11710            have been parsed.  This can happen for a nested template
11972    but indicate that it should have failed, and allow our caller to
12050 	  /* We don't have an instantiation yet, so drop the typedef.  */
12266 	     unify.  This means that we don't yet have any information
12276 	/* If we get here, we must have been looking at a parm for a
12304 		  /* We have reduced the level of the template
12599 	       have complete type in order to allow things like:
12603 	       But, such constructs have already been resolved by this
12604 	       point, so here CTX really should have complete type, unless
12968   /* Expressions do not generally have reference type.  */
13247 	     have to substitute this with one having context `D<int>'.  */
13566       /* We shouldn't have built any of these during initial template
14102 			/* For __PRETTY_FUNCTION__ we have to adjust the
14236 	   will have no binding.  */
14321 	     way we don't have to deal with pushing out of one local class
14830 	       will have also added such an indirect ref.  */
15244 	       Note that we can also have an IDENTIFIER_NODE if the earlier
15493             /* We have pack expansions, so expand those and
15912 	/* Now that we know visibility, instantiate the type so we have a
16102       /* Use DECL_ABSTRACT_ORIGIN because only FUNCTION_DECLs have
16113       /* We should always have found the clone by now.  */
16121   /* Check to see if we already have this specialization.  */
16155      parameters and return types have to be checked.  However this
16158      deferring all checks until we have the FUNCTION_DECL.  */
16254    functions and variables have sufficient context established by the
16380   /* In C++0x, it's possible to have a function template whose type depends
16473               /* We have some incomplete argument packs.  */
16487 	 instantiate_template and they might have the wrong
16549   /* Now that we have bindings for all of the template arguments,
16551      parameters have compatible template parameter lists.  We cannot
16552      check this property before we have deduced all template
16581      When all template arguments have been deduced, all uses of
16616      for an exact match if we have dependent template arguments;
16618      that we have two candidates that will provide the actual type.  */
16960        we have historically checked for convertibility in order to shortcut
17137   /* Fail if parms are left and they don't have default values and
17183 	     a type parameter, try another pass; its type may have been
17537   /* We don't copy orig_targs for this because if we have already deduced
17617      already know that we must have `f<0, 0, 0>'.  But, even though
17813   /* Loop through all of the arguments that have not yet been
17938              now we have a complete set of arguments.  */
18058        have const qualified pointers leading up to the inner type which
18304 	       rather than the whole TREE_VEC since they can have
18363 	  /* If PARM is `const T' and ARG is only `int', we don't have
18556       /* We have already checked cv-qualification at the top of the
18606         /* If we don't have enough arguments to satisfy the parameters
18607            (not counting the pack expression at the end), or we have
18774 	 an integral constant, in which case, it whould have been
18873     /* The TREE_PUBLIC flag for function declarations will have been
18877   /* This might have been set by an earlier implicit instantiation.  */
18945    The arguments used in deduction have reference and top level cv
18951    deduction, after all the arguments have been deduced in this way,
19162         /* We have already processed all of the arguments in our
19170   /* "In most cases, all template parameters must have values in order for
19328    For example, suppose we have:
19389   /* Now that we have bindings for all of the template arguments,
19391      parameters have compatible template parameter lists.  See the use
19997        instantiated, we have here:
20007        we don't have any arguments for them.  Note that the standard
20044    instantiate_template, the resulting DECL will have no name for the
20182   while (/* An instantiation cannot have a definition, so we need a
20301    DEFER_OK is nonzero, then we don't have to actually do the
20302    instantiation now; we just have to do it sometime.  Normally it is
20372     /* We should already have the extra args.  */
20397        outside the class, we may have too many arguments.  Drop the
20448   /* Defer all other templates, unless we have been explicitly
20522       /* ??? Historically, we have instantiated inline functions, even
20589 	 we have a chance to determine linkage.  */
20967    is the instantiation (which should have been created with
21167      type-dependent, then it should already been have resolved.  */
21234   /* If the type is NULL, we have not computed a type for the entity
21243   /* If we have not already computed the appropriate value for TYPE,
21319           Note that a non-dependent parenthesized initializer will have
21520    expression with type-dependent subexpressions to have no type, so
21521    this function doesn't have to be fully recursive.  */
21621      can have different bounds.  */
21721       /* We don't have to worry about decltype currently because decltype
22019   /* So are names that have not been looked up.  */
22142   /* If the SCOPE is a template type parameter, we have no way of
22153   /* If SCOPE isn't the template itself, it will not have a valid
22268   /* Preserve THROW_EXPRs -- all throw-expressions have type "void".
22459 	    /* If type is error_mark_node a diagnostic must have been