Pull out conversion on LHS of -> and . into its own function. This happens

implicitly in LookupMemberExpr and explicitly in cases where template
instantiation doesn't redo the lookup.

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@143046 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/clang/Sema/Sema.h b/include/clang/Sema/Sema.h
index 2b33392e6b3c9fab38be2830eab9f84db48f0898..acfdf7a5833cadcce47ebf645d8afbc3009e9a37 100644 (file)
--- a/include/clang/Sema/Sema.h
+++ b/include/clang/Sema/Sema.h
@@ -2443,6 +2443,7 @@ public:
                                  const TemplateArgumentListInfo *TemplateArgs,
                                       bool SuppressQualifierCheck = false);
 
+  ExprResult PerformMemberExprBaseConversion(Expr *Base, bool IsArrow);
   ExprResult LookupMemberExpr(LookupResult &R, ExprResult &Base,
                               bool &IsArrow, SourceLocation OpLoc,
                               CXXScopeSpec &SS,

diff --git a/lib/Sema/SemaExprMember.cpp b/lib/Sema/SemaExprMember.cpp
index 25d3c2a42547ee7c2c83de6fece807f63dc28496..5696e2386d56f5fa271d5c501ed47fb797439cd0 100644 (file)
--- a/lib/Sema/SemaExprMember.cpp
+++ b/lib/Sema/SemaExprMember.cpp
@@ -970,6 +970,17 @@ static bool isPointerToRecordType(QualType T) {
   return false;
 }
 
+/// Perform conversions on the LHS of a member access expression.
+ExprResult
+Sema::PerformMemberExprBaseConversion(Expr *Base, bool IsArrow) {
+  ExprResult BaseResult = DefaultFunctionArrayConversion(Base);
+
+  if (!BaseResult.isInvalid() && IsArrow)
+    BaseResult = DefaultLvalueConversion(BaseResult.take());
+
+  return BaseResult;
+}
+
 /// Look up the given member of the given non-type-dependent
 /// expression.  This can return in one of two ways:
 ///  * If it returns a sentinel null-but-valid result, the caller will
@@ -988,16 +999,10 @@ Sema::LookupMemberExpr(LookupResult &R, ExprResult &BaseExpr,
   assert(BaseExpr.get() && "no base expression");
 
   // Perform default conversions.
-  BaseExpr = DefaultFunctionArrayConversion(BaseExpr.take());
+  BaseExpr = PerformMemberExprBaseConversion(BaseExpr.take(), IsArrow);
   if (BaseExpr.isInvalid())
     return ExprError();
 
-  if (IsArrow) {
-    BaseExpr = DefaultLvalueConversion(BaseExpr.take());
-    if (BaseExpr.isInvalid())
-      return ExprError();
-  }
-
   QualType BaseType = BaseExpr.get()->getType();
   assert(!BaseType->isDependentType());
 

diff --git a/lib/Sema/TreeTransform.h b/lib/Sema/TreeTransform.h
index 6fb1315c2ed2186cc6dc16eaa9424e347b5f3639..5596a9a6caaef5578211b22cf2a27bb0f1f0a9bd 100644 (file)
--- a/lib/Sema/TreeTransform.h
+++ b/lib/Sema/TreeTransform.h
@@ -1468,6 +1468,8 @@ public:
                                NamedDecl *FoundDecl,
                         const TemplateArgumentListInfo *ExplicitTemplateArgs,
                                NamedDecl *FirstQualifierInScope) {
+    ExprResult BaseResult = getSema().PerformMemberExprBaseConversion(Base,
+                                                                      isArrow);
     if (!Member->getDeclName()) {
       // We have a reference to an unnamed field.  This is always the
       // base of an anonymous struct/union member access, i.e. the
@@ -1476,17 +1478,12 @@ public:
       assert(Member->getType()->isRecordType() &&
              "unnamed member not of record type?");
 
-      ExprResult BaseResult =
-        getSema().PerformObjectMemberConversion(Base, 
+      BaseResult =
+        getSema().PerformObjectMemberConversion(BaseResult.take(),
                                                 QualifierLoc.getNestedNameSpecifier(),
                                                 FoundDecl, Member);
       if (BaseResult.isInvalid())
         return ExprError();
-      if (isArrow) {
-        BaseResult = getSema().DefaultLvalueConversion(BaseResult.take());
-        if (BaseResult.isInvalid())
-          return ExprError();
-      }
       Base = BaseResult.take();
       ExprValueKind VK = isArrow ? VK_LValue : Base->getValueKind();
       MemberExpr *ME =
@@ -1500,14 +1497,6 @@ public:
     CXXScopeSpec SS;
     SS.Adopt(QualifierLoc);
 
-    ExprResult BaseResult = getSema().DefaultFunctionArrayConversion(Base);
-    if (BaseResult.isInvalid())
-      return ExprError();
-    if (isArrow) {
-      BaseResult = getSema().DefaultLvalueConversion(BaseResult.get());
-      if (BaseResult.isInvalid())
-        return ExprError();
-    }
     Base = BaseResult.take();
     QualType BaseType = Base->getType();
 
@@ -2134,30 +2123,16 @@ public:
   ///
   /// By default, performs semantic analysis to build the new expression.
   /// Subclasses may override this routine to provide different behavior.
-  ExprResult RebuildUnresolvedMemberExpr(Expr *BaseE,
-                                               QualType BaseType,
-                                               SourceLocation OperatorLoc,
-                                               bool IsArrow,
-                                           NestedNameSpecifierLoc QualifierLoc,
-                                               NamedDecl *FirstQualifierInScope,
-                                               LookupResult &R,
+  ExprResult RebuildUnresolvedMemberExpr(Expr *BaseE, QualType BaseType,
+                                         SourceLocation OperatorLoc,
+                                         bool IsArrow,
+                                         NestedNameSpecifierLoc QualifierLoc,
+                                         NamedDecl *FirstQualifierInScope,
+                                         LookupResult &R,
                                 const TemplateArgumentListInfo *TemplateArgs) {
     CXXScopeSpec SS;
     SS.Adopt(QualifierLoc);
 
-    if (BaseE) {
-      ExprResult BaseResult = getSema().DefaultFunctionArrayConversion(BaseE);
-      if (BaseResult.isInvalid())
-        return ExprError();
-      if (IsArrow) {
-        BaseResult = getSema().DefaultLvalueConversion(BaseResult.take());
-        if (BaseResult.isInvalid())
-          return ExprError();
-      }
-      BaseE = BaseResult.take();
-      BaseType = BaseE->getType();
-    }
-
     return SemaRef.BuildMemberReferenceExpr(BaseE, BaseType,
                                             OperatorLoc, IsArrow,
                                             SS, FirstQualifierInScope,
@@ -7707,6 +7682,11 @@ TreeTransform<Derived>::TransformUnresolvedMemberExpr(UnresolvedMemberExpr *Old)
     Base = getDerived().TransformExpr(Old->getBase());
     if (Base.isInvalid())
       return ExprError();
+    Base = getSema().PerformMemberExprBaseConversion(Base.take(),
+                                                     Old->isArrow());
+    if (Base.isInvalid())
+      return ExprError();
+    BaseType = Base.get()->getType();
   } else {
     BaseType = getDerived().TransformType(Old->getBaseType());
   }