[AST] Eliminate OverloadedMemberRefExpr.

This expression kind was introduced in exactly one place, and only
with one member. That place can use MemberRefExpr instead.

Author: DougGregor

include/swift/AST/Expr.h

@@ -246,14 +246,6 @@ class alignas(8) Expr {
   enum { NumOverloadSetRefExprBits = NumExprBits };
   static_assert(NumOverloadSetRefExprBits <= 32, "fits in an unsigned");
 
-  class OverloadedMemberRefExprBitfields {
-    friend class OverloadedMemberRefExpr;
-    unsigned : NumOverloadSetRefExprBits;
-    unsigned Semantics : 2; // an AccessSemantics
-  };
-  enum { NumOverloadedMemberRefExprBits = NumOverloadSetRefExprBits + 2 };
-  static_assert(NumOverloadedMemberRefExprBits <= 32, "fits in an unsigned");
-
   class BooleanLiteralExprBitfields {
     friend class BooleanLiteralExpr;
     unsigned : NumLiteralExprBits;
@@ -412,7 +404,6 @@ class alignas(8) Expr {
     DynamicSubscriptExprBitfields DynamicSubscriptExprBits;
     UnresolvedMemberExprBitfields UnresolvedMemberExprBits;
     OverloadSetRefExprBitfields OverloadSetRefExprBits;
-    OverloadedMemberRefExprBitfields OverloadedMemberRefExprBits;
     BooleanLiteralExprBitfields BooleanLiteralExprBits;
     MagicIdentifierLiteralExprBitfields MagicIdentifierLiteralExprBits;
     ObjectLiteralExprBitfields ObjectLiteralExprBits;
@@ -1422,45 +1413,6 @@ class OverloadedDeclRefExpr : public OverloadSetRefExpr {
   }
 };
 
-/// OverloadedMemberRefExpr - A reference to an overloaded name that is a
-/// member, relative to some base expression, that will eventually be
-/// resolved to some kind of member-reference expression.
-class OverloadedMemberRefExpr : public OverloadSetRefExpr {
-  Expr *SubExpr;
-  SourceLoc DotLoc;
-  DeclNameLoc MemberLoc;
-  
-public:
-  OverloadedMemberRefExpr(Expr *SubExpr, SourceLoc DotLoc,
-                          ArrayRef<ValueDecl *> Decls, DeclNameLoc MemberLoc,
-                          bool Implicit, Type Ty = Type(),
-                          AccessSemantics semantics = AccessSemantics::Ordinary)
-    : OverloadSetRefExpr(ExprKind::OverloadedMemberRef, Decls, Implicit, Ty),
-      SubExpr(SubExpr), DotLoc(DotLoc), MemberLoc(MemberLoc) {
-    OverloadedMemberRefExprBits.Semantics = unsigned(semantics);
-  }
-
-  SourceLoc getDotLoc() const { return DotLoc; }
-  DeclNameLoc getMemberLoc() const { return MemberLoc; }
-  Expr *getBase() const { return SubExpr; }
-  void setBase(Expr *E) { SubExpr = E; }
-  
-  SourceLoc getLoc() const { return MemberLoc.getBaseNameLoc(); }
-  SourceLoc getStartLoc() const {
-    return DotLoc.isValid()? SubExpr->getStartLoc()
-                           : MemberLoc.getBaseNameLoc();
-  }
-  SourceLoc getEndLoc() const { return MemberLoc.getSourceRange().End; }
-
-  AccessSemantics getAccessSemantics() const {
-    return AccessSemantics(OverloadedMemberRefExprBits.Semantics);
-  }
-
-  static bool classof(const Expr *E) {
-  return E->getKind() == ExprKind::OverloadedMemberRef;
-  }
-};
-
 /// UnresolvedDeclRefExpr - This represents use of an undeclared identifier,
 /// which may ultimately be a use of something that hasn't been defined yet, it
 /// may be a use of something that got imported (which will be resolved during

include/swift/AST/ExprNodes.def

@@ -67,8 +67,7 @@ EXPR(OtherConstructorDeclRef, Expr)
 EXPR(DotSyntaxBaseIgnored, Expr)
 ABSTRACT_EXPR(OverloadSetRef, Expr)
   UNCHECKED_EXPR(OverloadedDeclRef, OverloadSetRefExpr)
-  UNCHECKED_EXPR(OverloadedMemberRef, OverloadSetRefExpr)
-  EXPR_RANGE(OverloadSetRef, OverloadedDeclRef, OverloadedMemberRef)
+  EXPR_RANGE(OverloadSetRef, OverloadedDeclRef, OverloadedDeclRef)
 UNCHECKED_EXPR(UnresolvedDeclRef, Expr)
 EXPR(MemberRef, Expr)
 ABSTRACT_EXPR(DynamicLookup, Expr)

lib/AST/ASTDumper.cpp

@@ -1730,18 +1730,6 @@ class PrintExpr : public ExprVisitor<PrintExpr> {
     }
     OS << ')';
   }
-  void visitOverloadedMemberRefExpr(OverloadedMemberRefExpr *E) {
-    printCommon(E, "overloaded_member_ref_expr")
-      << " name=" << E->getDecls()[0]->getName()
-      << " #decls=" << E->getDecls().size() << "\n";
-    printRec(E->getBase());
-    for (ValueDecl *D : E->getDecls()) {
-      OS << '\n';
-      OS.indent(Indent);
-      D->dumpRef(OS);
-    }
-    OS << ')';
-  }
   void visitUnresolvedDeclRefExpr(UnresolvedDeclRefExpr *E) {
     printCommon(E, "unresolved_decl_ref_expr")
       << " name=" << E->getName()

lib/AST/ASTWalker.cpp

@@ -359,14 +359,6 @@ class Traversal : public ASTVisitor<Traversal, Expr*, Stmt*,
   }
 
   Expr *visitOverloadedDeclRefExpr(OverloadedDeclRefExpr *E) { return E; }
-  Expr *visitOverloadedMemberRefExpr(OverloadedMemberRefExpr *E) {
-    if (auto base = doIt(E->getBase())) {
-      E->setBase(base);
-      return E;
-    }
-
-    return nullptr;
-  }
   Expr *visitUnresolvedDeclRefExpr(UnresolvedDeclRefExpr *E) { return E; }
 
   Expr *visitUnresolvedMemberExpr(UnresolvedMemberExpr *E) { 

lib/AST/Expr.cpp

@@ -387,7 +387,6 @@ ConcreteDeclRef Expr::getReferencedDecl() const {
 
   // FIXME: Return multiple results?
   case ExprKind::OverloadedDeclRef:
-  case ExprKind::OverloadedMemberRef:
     return ConcreteDeclRef();
 
   NO_REFERENCE(UnresolvedDeclRef);
@@ -674,9 +673,6 @@ bool Expr::canAppendCallParentheses() const {
     return !overloadedExpr->getDecls().front()->getName().isOperator();
   }
 
-  case ExprKind::OverloadedMemberRef:
-    return true;
-
   case ExprKind::UnresolvedDeclRef:
     return cast<UnresolvedDeclRefExpr>(this)->getName().isOperator();
 
@@ -1306,9 +1302,6 @@ MemberRefExpr::MemberRefExpr(Expr *base, SourceLoc dotLoc,
 Type OverloadSetRefExpr::getBaseType() const {
   if (isa<OverloadedDeclRefExpr>(this))
     return Type();
-  if (auto *DRE = dyn_cast<OverloadedMemberRefExpr>(this)) {
-    return DRE->getBase()->getType()->getRValueType();
-  }
 
   llvm_unreachable("Unhandled overloaded set reference expression");
 }

lib/Sema/CSApply.cpp

@@ -2275,23 +2275,6 @@ namespace {
                           AccessSemantics::Ordinary);
     }
 
-    Expr *visitOverloadedMemberRefExpr(OverloadedMemberRefExpr *expr) {
-      auto memberLocator = cs.getConstraintLocator(expr,
-                                                   ConstraintLocator::Member);
-      auto selected = getOverloadChoice(memberLocator);
-      bool isDynamic = selected.choice.getKind()
-                         == OverloadChoiceKind::DeclViaDynamic;
-      return buildMemberRef(expr->getBase(),
-                            selected.openedFullType,
-                            expr->getDotLoc(),
-                            selected.choice.getDecl(), expr->getMemberLoc(),
-                            selected.openedType,
-                            cs.getConstraintLocator(expr),
-                            memberLocator,
-                            expr->isImplicit(), expr->getAccessSemantics(),
-                            isDynamic);
-    }
-
     Expr *visitUnresolvedDeclRefExpr(UnresolvedDeclRefExpr *expr) {
       // FIXME: We should have generated an overload set from this, in which
       // case we can emit a typo-correction error here but recover well.
@@ -3856,7 +3839,6 @@ resolveLocatorToDecl(ConstraintSystem &cs, ConstraintLocator *locator,
     return ctorRef->getDeclRef();
 
   if (isa<OverloadedDeclRefExpr>(anchor) ||
-      isa<OverloadedMemberRefExpr>(anchor) ||
       isa<UnresolvedDeclRefExpr>(anchor)) {
     // Overloaded and unresolved cases: find the resolved overload.
     auto anchorLocator = cs.getConstraintLocator(anchor);

lib/Sema/CSDiag.cpp

@@ -3136,8 +3136,7 @@ typeCheckChildIndependently(Expr *subExpr, Type convertType,
   // which is the most specialized) even then all the constraints are being
   // fulfilled by UnresolvedType, which doesn't tell us anything.
   if (convertTypePurpose == CTP_Unused &&
-      (isa<OverloadedDeclRefExpr>(subExpr->getValueProvidingExpr()) ||
-       isa<OverloadedMemberRefExpr>(subExpr->getValueProvidingExpr()))) {
+      (isa<OverloadedDeclRefExpr>(subExpr->getValueProvidingExpr()))) {
     return subExpr;
   }
 

lib/Sema/CSGen.cpp

@@ -1391,38 +1391,6 @@ namespace {
       return tv;
     }
 
-    Type visitOverloadedMemberRefExpr(OverloadedMemberRefExpr *expr) {
-      // For a reference to an overloaded declaration, we create a type variable
-      // that will be bound to different types depending on which overload
-      // is selected.
-      auto tv = CS.createTypeVariable(CS.getConstraintLocator(expr),
-                                      TVO_CanBindToLValue);
-      ArrayRef<ValueDecl*> decls = expr->getDecls();
-      SmallVector<OverloadChoice, 4> choices;
-      auto baseTy = expr->getBase()->getType();
-      for (unsigned i = 0, n = decls.size(); i != n; ++i) {
-        // If the result is invalid, skip it.
-        // FIXME: Note this as invalid, in case we don't find a solution,
-        // so we don't let errors cascade further.
-        CS.getTypeChecker().validateDecl(decls[i], true);
-        if (decls[i]->isInvalid())
-          continue;
-
-        choices.push_back(OverloadChoice(baseTy, decls[i],
-                                         /*isSpecialized=*/false,
-                                         CS));
-      }
-
-      // If there are no valid overloads, give up.
-      if (choices.empty())
-        return nullptr;
-
-      // Record this overload set.
-      auto locator = CS.getConstraintLocator(expr, ConstraintLocator::Member);
-      CS.addOverloadSet(tv, choices, locator);
-      return tv;
-    }
-    
     Type visitUnresolvedDeclRefExpr(UnresolvedDeclRefExpr *expr) {
       // This is an error case, where we're trying to use type inference
       // to help us determine which declaration the user meant to refer to.
@@ -2755,11 +2723,9 @@ namespace {
         DeclNameLoc memberLoc;
         if (auto member = findReferencedDecl(dotCall->getFn(), memberLoc)) {
           auto base = skipImplicitConversions(dotCall->getArg());
-          auto members
-            = TC.Context.AllocateCopy(ArrayRef<ValueDecl *>(&member, 1));
-          return new (TC.Context) OverloadedMemberRefExpr(base,
-                                   dotCall->getDotLoc(), members, memberLoc,
-                                   expr->isImplicit());
+          return new (TC.Context) MemberRefExpr(base,
+                                    dotCall->getDotLoc(), member, memberLoc,
+                                    expr->isImplicit());
         }
       }
 
@@ -2771,10 +2737,8 @@ namespace {
         DeclNameLoc memberLoc;
         if (auto member = findReferencedDecl(dotIgnored->getRHS(), memberLoc)) {
           auto base = skipImplicitConversions(dotIgnored->getLHS());
-          auto members
-            = TC.Context.AllocateCopy(ArrayRef<ValueDecl *>(&member, 1));
-          return new (TC.Context) OverloadedMemberRefExpr(base,
-                                    dotIgnored->getDotLoc(), members,
+          return new (TC.Context) MemberRefExpr(base,
+                                    dotIgnored->getDotLoc(), member,
                                     memberLoc, expr->isImplicit());
         }
       }