Propagate the "found declaration" (i.e. the using declaration instead of

the underlying/instantiated decl) through a lot of API, including "intermediate"
MemberExprs required for (e.g.) template instantiation.  This is necessary
because of the access semantics of member accesses to using declarations:
only the base class *containing the using decl* need be accessible from the
naming class.

This allows us to complete an access-controlled selfhost, if there are no
recent regressions.

llvm-svn: 99936

1 files changed, 26 insertions, 25 deletions

diff --git a/clang/lib/AST/Expr.cpp b/clang/lib/AST/Expr.cpp
index 935a2080dcc..a9b5f36a983 100644
--- a/clang/lib/AST/Expr.cpp
+++ b/clang/lib/AST/Expr.cpp
@@ -499,44 +499,45 @@ QualType CallExpr::getCallReturnType() const {
   return FnType->getResultType();
 }
 
-MemberExpr::MemberExpr(Expr *base, bool isarrow, NestedNameSpecifier *qual,
-                       SourceRange qualrange, ValueDecl *memberdecl,
-                       SourceLocation l, const TemplateArgumentListInfo *targs,
-                       QualType ty)
-  : Expr(MemberExprClass, ty,
-         base->isTypeDependent() || (qual && qual->isDependent()),
-         base->isValueDependent() || (qual && qual->isDependent())),
-    Base(base), MemberDecl(memberdecl), MemberLoc(l), IsArrow(isarrow),
-    HasQualifier(qual != 0), HasExplicitTemplateArgumentList(targs) {
-  // Initialize the qualifier, if any.
-  if (HasQualifier) {
-    NameQualifier *NQ = getMemberQualifier();
-    NQ->NNS = qual;
-    NQ->Range = qualrange;
-  }
-
-  // Initialize the explicit template argument list, if any.
-  if (targs)
-    getExplicitTemplateArgumentList()->initializeFrom(*targs);
-}
-
 MemberExpr *MemberExpr::Create(ASTContext &C, Expr *base, bool isarrow,
                                NestedNameSpecifier *qual,
                                SourceRange qualrange,
                                ValueDecl *memberdecl,
+                               NamedDecl *founddecl,
                                SourceLocation l,
                                const TemplateArgumentListInfo *targs,
                                QualType ty) {
   std::size_t Size = sizeof(MemberExpr);
-  if (qual != 0)
-    Size += sizeof(NameQualifier);
+
+  bool hasQualOrFound = (qual != 0 || founddecl != memberdecl);
+  if (hasQualOrFound)
+    Size += sizeof(MemberNameQualifier);
 
   if (targs)
     Size += ExplicitTemplateArgumentList::sizeFor(*targs);
 
   void *Mem = C.Allocate(Size, llvm::alignof<MemberExpr>());
-  return new (Mem) MemberExpr(base, isarrow, qual, qualrange, memberdecl, l,
-                              targs, ty);
+  MemberExpr *E = new (Mem) MemberExpr(base, isarrow, memberdecl, l, ty);
+
+  if (hasQualOrFound) {
+    if (qual && qual->isDependent()) {
+      E->setValueDependent(true);
+      E->setTypeDependent(true);
+    }
+    E->HasQualifierOrFoundDecl = true;
+
+    MemberNameQualifier *NQ = E->getMemberQualifier();
+    NQ->NNS = qual;
+    NQ->Range = qualrange;
+    NQ->FoundDecl = founddecl;
+  }
+
+  if (targs) {
+    E->HasExplicitTemplateArgumentList = true;
+    E->getExplicitTemplateArgumentList()->initializeFrom(*targs);
+  }
+
+  return E;
 }
 
 const char *CastExpr::getCastKindName() const {