TREE_VALUE (arg),
cand->conversion_path,
1);
+ /* Check that the base class is accessible. */
+ if (!accessible_base_p (TREE_TYPE (argtype),
+ BINFO_TYPE (cand->conversion_path)))
+ error ("`%T' is not an accessible base of `%T'",
+ BINFO_TYPE (cand->conversion_path),
+ TREE_TYPE (argtype));
/* If fn was found by a using declaration, the conversion path
will be to the derived class, not the base declaring fn. We
must convert from derived to base. */
base_binfo = lookup_base (TREE_TYPE (TREE_TYPE (converted_arg)),
TREE_TYPE (parmtype), ba_ignore, NULL);
-
converted_arg = build_base_path (PLUS_EXPR, converted_arg,
base_binfo, 1);
return found;
}
+/* Returns true if type BASE is accessible in T. (BASE is known to be
+ a base class of T.) */
+
+bool
+accessible_base_p (tree t, tree base)
+{
+ tree decl;
+
+ /* [class.access.base]
+
+ A base class is said to be accessible if an invented public
+ member of the base class is accessible. */
+ /* Rather than inventing a public member, we use the implicit
+ public typedef created in the scope of every class. */
+ decl = TYPE_FIELDS (base);
+ while (!DECL_SELF_REFERENCE_P (decl))
+ decl = TREE_CHAIN (decl);
+ while (ANON_AGGR_TYPE_P (t))
+ t = TYPE_CONTEXT (t);
+ return accessible_p (t, decl);
+}
+
/* Lookup BASE in the hierarchy dominated by T. Do access checking as
ACCESS specifies. Return the binfo we discover. If KIND_PTR is
non-NULL, fill with information about what kind of base we
break;
default:
- if (access != ba_ignore
+ if ((access & ~ba_quiet) != ba_ignore
/* If BASE is incomplete, then BASE and TYPE are probably
the same, in which case BASE is accessible. If they
are not the same, then TYPE is invalid. In that case,
there's no need to issue another error here, and
there's no implicit typedef to use in the code that
follows, so we skip the check. */
- && COMPLETE_TYPE_P (base))
+ && COMPLETE_TYPE_P (base)
+ && !accessible_base_p (t, base))
{
- tree decl;
-
- /* [class.access.base]
-
- A base class is said to be accessible if an invented public
- member of the base class is accessible. */
- /* Rather than inventing a public member, we use the implicit
- public typedef created in the scope of every class. */
- decl = TYPE_FIELDS (base);
- while (!DECL_SELF_REFERENCE_P (decl))
- decl = TREE_CHAIN (decl);
- while (ANON_AGGR_TYPE_P (t))
- t = TYPE_CONTEXT (t);
- if (!accessible_p (t, decl))
+ if (!(access & ba_quiet))
{
- if (!(access & ba_quiet))
- {
- error ("`%T' is an inaccessible base of `%T'", base, t);
- binfo = error_mark_node;
- }
- else
- binfo = NULL_TREE;
- bk = bk_inaccessible;
+ error ("`%T' is an inaccessible base of `%T'", base, t);
+ binfo = error_mark_node;
}
+ else
+ binfo = NULL_TREE;
+ bk = bk_inaccessible;
}
break;
}