gcc/cp/pt.c

165 /* Make the current scope suitable for access checking when we are
191 /* Restore the scope set up by push_access_scope.  T is the node we
517   /* We use a non-tag-transparent scope here, which causes pushtag to
518      put tags in this scope, rather than in the enclosing class or
519      namespace scope.  This is the right thing, since we want
522      TEMPLATE_DECL into top-level scope.  For a nested template class,
544   tree scope = current_scope ();
555   if (scope && TREE_CODE (scope) != NAMESPACE_DECL)
557       error ("explicit specialization in non-namespace scope %qD", scope);
564      template or a member template that appears in namespace scope,
1967 		 must be at namespace scope.  */
1998 	    /* A specialization in class scope.  This is invalid,
2005 		 class scope, e.g.:
2131 		     injected into namespace scope), then there will
2278    scope (including nested scopes).  */
2867        scope, nor you can you define a member of a class template in a
2868        local scope.  */
2874       /* If this is either a friend defined in the scope of the class
2882 	 the scope of the class.  */
2887        was defined in class scope, but we're processing it's body now
3413 	     by two different declarations in the same scope.  */
3569      SCOPE_REF refers.  Preserving the qualifying scope is necessary
4452 /* Within the scope of a template class S<T>, the name S gets bound
4478    If ENTERING_SCOPE is nonzero, we are about to enter the scope of
4718       /* In the scope of a template class, explicit references to the
4743 	      /* We're not in the scope of the class, so the
5328       /* Friend functions are looked up in the containing namespace scope.
5329 	 We must enter that scope, to avoid finding member functions of the
5601      Here, in the scope of (say) S<int>, `S' is bound to a TYPE_DECL
5632 	 injection of this template into the global scope.  */
5647       /* Inject this template into the global scope.  */
5797       /* We must enter the scope containing the type, as that is where
5830   /* Now that our base classes are set up, enter the scope of the
5886 		  /* Now, we call pushtag to put this NEWTAG into the scope of
6032 		     from namespace scope directly, bypassing any name that
6354      we must be careful to do name lookup in the scope of S<T>,
6899 	    /* T is a static data member or namespace-scope entity.
6900 	       We have to substitute into namespace-scope variables
6955 	    /* Even if the original location is out of scope, the
7922   tree scope;
7946   /* Substitute into the qualifying scope.  When there are no ARGS, we
7948      case the qualifying scope may be dependent, and, in any case,
7950   scope = TREE_OPERAND (qualified_id, 0);
7953       scope = tsubst (scope, args, complain, in_decl);
7959   if (dependent_type_p (scope))
7961 				 scope, expr,
7971 	expr = lookup_qualified_name (scope, expr, /*is_type_p=*/0, false);
7988 					   scope);
7996 	qualified_name_lookup_error (scope,
8006     qualified_name_lookup_error (scope, TREE_OPERAND (qualified_id, 1),
8008   else if (TYPE_P (scope))
8011 	      (expr, scope, current_class_type));
8013 	      (scope, expr, done, address_p,
8058 	/* There is no need to substitute into namespace-scope
8542 	    tree scope = USING_DECL_SCOPE (decl);
8546 	    scope = RECUR (scope);
8547 	    decl = lookup_qualified_name (scope, name,
8551 	      qualified_name_lookup_error (scope, name, decl);
8553 	      do_local_using_decl (decl, scope, name);
9324 	       scope is.  */
9495 	     of a class or enumeration declared in a local scope)
12305       /* Enter the scope of D so that access-checking works correctly.  */
12683   tree scope;
12767   scope = TYPE_CONTEXT (type);
12768   if (scope && TYPE_P (scope))
12769     return dependent_type_p (scope);
12770   else if (scope && TREE_CODE (scope) == FUNCTION_DECL)
12771     return type_dependent_expression_p (scope);
12783   /* If there are no template parameters in scope, then there can't be
12819   tree scope;
12827   scope = TREE_OPERAND (expression, 0);
12839       && currently_open_class (scope)
12842   if (dependent_type_p (scope))
13223   tree scope;
13231   scope = TYPE_CONTEXT (type);
13236   if (TREE_CODE (scope) == TYPENAME_TYPE)
13237     scope = resolve_typename_type (scope, only_current_p);
13240   if (scope == error_mark_node || TREE_CODE (scope) == TYPENAME_TYPE)
13244   if (TREE_CODE (scope) == TEMPLATE_TYPE_PARM)
13248   if (only_current_p && !currently_open_class (scope))
13252   scope = CLASSTYPE_PRIMARY_TEMPLATE_TYPE (scope);
13256   pushed_scope = push_scope (scope);
13258   decl = lookup_member (scope, name, /*protect=*/0, /*want_type=*/true);