+2009-10-01 Jason Merrill <jason@redhat.com>
+
+ * parser.c (cp_parser_lambda_expression): Compute visibility.
+ (no_linkage_lambda_type_p): Remove.
+ * cp-tree.h: Remove declaration.
+ * tree.c (no_linkage_check): Don't call it. Don't check template
+ args. Don't check TREE_PUBLIC Types.
+
2009-10-01 Gabriel Dos Reis <gdr@cse.tamu.edu>
Jason Merrill <jason@redhat.com>
VEC_pop (tree_int, lambda_scope_stack);
}
-/* We want to determine the linkage of a lambda type at pushtag time,
- before CLASSTYPE_LAMBDA_EXPR has been set. So this callback allows us
- to find out whether the current lambda mangling scope will give us
- linkage or not. */
-
-bool
-no_linkage_lambda_type_p (tree type)
-{
- tree lambda, scope;
- if (!LAMBDA_TYPE_P (type))
- return false;
-
- lambda = CLASSTYPE_LAMBDA_EXPR (type);
- if (lambda)
- scope = LAMBDA_EXPR_EXTRA_SCOPE (lambda);
- else if (CLASSTYPE_TEMPLATE_INSTANTIATION (type))
- /* We can't use lambda_scope, and CLASSTYPE_TEMPLATE_INFO won't be set
- yet either, so guess it's public for now. */
- return false;
- else
- scope = lambda_scope;
-
- return (scope == NULL_TREE);
-}
-
/* Parse a lambda expression.
lambda-expression:
record_lambda_scope (lambda_expr);
+ /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
+ determine_visibility (TYPE_NAME (type));
+
{
/* Inside the class, surrounding template-parameter-lists do not apply. */
unsigned int saved_num_template_parameter_lists
case RECORD_TYPE:
if (TYPE_PTRMEMFUNC_P (t))
goto ptrmem;
+ /* Lambda types that don't have mangling scope have no linkage. We
+ check CLASSTYPE_LAMBDA_EXPR here rather than LAMBDA_TYPE_P because
+ when we get here from pushtag none of the lambda information is
+ set up yet, so we want to assume that the lambda has linkage and
+ fix it up later if not. */
+ if (CLASSTYPE_LAMBDA_EXPR (t)
+ && LAMBDA_TYPE_EXTRA_SCOPE (t) == NULL_TREE)
+ return t;
/* Fall through. */
case UNION_TYPE:
if (!CLASS_TYPE_P (t))
return NULL_TREE;
-
- /* Check template type-arguments. I think that types with no linkage
- can't occur in non-type arguments, though that might change with
- constexpr. */
- r = CLASSTYPE_TEMPLATE_INFO (t);
- if (r)
- {
- tree args = INNERMOST_TEMPLATE_ARGS (TI_ARGS (r));
- int i;
-
- for (i = TREE_VEC_LENGTH (args); i-- > 0; )
- {
- tree elt = TREE_VEC_ELT (args, i);
- if (TYPE_P (elt)
- && (r = no_linkage_check (elt, relaxed_p), r))
- return r;
- }
- }
/* Fall through. */
case ENUMERAL_TYPE:
/* Only treat anonymous types as having no linkage if they're at
namespace scope. This doesn't have a core issue number yet. */
if (TYPE_ANONYMOUS_P (t) && TYPE_NAMESPACE_SCOPE_P (t))
return t;
- if (no_linkage_lambda_type_p (t))
- return t;
- r = CP_TYPE_CONTEXT (t);
- if (TYPE_P (r))
- return no_linkage_check (TYPE_CONTEXT (t), relaxed_p);
- else if (TREE_CODE (r) == FUNCTION_DECL)
+ for (r = CP_TYPE_CONTEXT (t); ; )
{
- if (!relaxed_p || !TREE_PUBLIC (r) || !vague_linkage_fn_p (r))
- return t;
+ /* If we're a nested type of a !TREE_PUBLIC class, we might not
+ have linkage, or we might just be in an anonymous namespace.
+ If we're in a TREE_PUBLIC class, we have linkage. */
+ if (TYPE_P (r) && !TREE_PUBLIC (TYPE_NAME (r)))
+ return no_linkage_check (TYPE_CONTEXT (t), relaxed_p);
+ else if (TREE_CODE (r) == FUNCTION_DECL)
+ {
+ if (!relaxed_p || !vague_linkage_fn_p (r))
+ return t;
+ else
+ r = CP_DECL_CONTEXT (r);
+ }
else
- return no_linkage_check (CP_DECL_CONTEXT (r), relaxed_p);
+ break;
}
return NULL_TREE;