[Diagnostics] NFC: Rename UncurriedCandidate -> OverloadCandidate

Author: xedin

lib/Sema/CSDiag.cpp

@@ -4146,7 +4146,7 @@ static bool diagnoseRawRepresentableMismatch(CalleeCandidateInfo &CCI,
   auto arguments = decomposeArgType(argType, argLabels);
 
   auto bestMatchKind = RawRepresentableMismatch::NotApplicable;
-  const UncurriedCandidate *bestMatchCandidate = nullptr;
+  const OverloadCandidate *bestMatchCandidate = nullptr;
   KnownProtocolKind bestMatchProtocol;
   size_t bestMatchIndex;
 
@@ -4341,7 +4341,7 @@ bool FailureDiagnosis::diagnoseSubscriptErrors(SubscriptExpr *SE,
     auto decomposedBaseType = decomposeArgType(baseType, {Identifier()});
     auto decomposedIndexType = decomposeArgType(indexType, argLabels);
     calleeInfo.filterList(
-        [&](UncurriedCandidate cand) -> CalleeCandidateInfo::ClosenessResultTy {
+        [&](OverloadCandidate cand) -> CalleeCandidateInfo::ClosenessResultTy {
           // Classify how close this match is.  Non-subscript decls don't match.
           auto subscriptDecl = dyn_cast_or_null<SubscriptDecl>(cand.getDecl());
           if (!subscriptDecl ||
@@ -4402,7 +4402,7 @@ bool FailureDiagnosis::diagnoseSubscriptErrors(SubscriptExpr *SE,
         // and more concrete expected type for this subscript decl, in order
         // to diagnose a better error.
         if (baseType && indexType->hasUnresolvedType()) {
-          UncurriedCandidate cand = calleeInfo.candidates[0];
+          auto cand = calleeInfo.candidates[0];
           auto candType = baseType->getTypeOfMember(CS.DC->getParentModule(),
                                                     cand.getDecl(), nullptr);
           if (auto *candFunc = candType->getAs<FunctionType>()) {
@@ -5125,7 +5125,7 @@ bool FailureDiagnosis::diagnoseSubscriptMisuse(ApplyExpr *callExpr) {
   auto params = decomposeArgType(CS.getType(argExpr), argLabels);
   using ClosenessPair = CalleeCandidateInfo::ClosenessResultTy;
 
-  candidateInfo.filterList([&](UncurriedCandidate cand) -> ClosenessPair {
+  candidateInfo.filterList([&](OverloadCandidate cand) -> ClosenessPair {
     auto candFuncType = cand.getUncurriedFunctionType();
     if (!candFuncType)
       return {CC_GeneralMismatch, {}};
@@ -5443,7 +5443,7 @@ bool FailureDiagnosis::visitApplyExpr(ApplyExpr *callExpr) {
   if (auto fn = fnType->getAs<AnyFunctionType>()) {
     using Closeness = CalleeCandidateInfo::ClosenessResultTy;
 
-    calleeInfo.filterList([&](UncurriedCandidate candidate) -> Closeness {
+    calleeInfo.filterList([&](OverloadCandidate candidate) -> Closeness {
       auto resultType = candidate.getResultType();
       if (!resultType)
         return {CC_GeneralMismatch, {}};

lib/Sema/CalleeCandidateInfo.cpp

@@ -56,8 +56,8 @@ static bool isSubstitutableFor(Type type, ArchetypeType *archetype,
   return true;
 }
 
-UncurriedCandidate::UncurriedCandidate(ValueDecl *decl, bool skipCurriedSelf)
-: declOrExpr(decl), skipCurriedSelf(skipCurriedSelf), substituted(false) {
+OverloadCandidate::OverloadCandidate(ValueDecl *decl, bool skipCurriedSelf)
+    : declOrExpr(decl), skipCurriedSelf(skipCurriedSelf), substituted(false) {
 
   if (auto *PD = dyn_cast<ParamDecl>(decl)) {
     if (PD->hasValidSignature())
@@ -89,8 +89,8 @@ UncurriedCandidate::UncurriedCandidate(ValueDecl *decl, bool skipCurriedSelf)
   }
 }
 
-ArrayRef<Identifier> UncurriedCandidate::getArgumentLabels(
-                                       SmallVectorImpl<Identifier> &scratch) {
+ArrayRef<Identifier>
+OverloadCandidate::getArgumentLabels(SmallVectorImpl<Identifier> &scratch) {
   scratch.clear();
   if (auto decl = getDecl()) {
     if (auto func = dyn_cast<AbstractFunctionDecl>(decl)) {
@@ -136,7 +136,7 @@ ArrayRef<Identifier> UncurriedCandidate::getArgumentLabels(
   return scratch;
 }
 
-void UncurriedCandidate::dump() const {
+void OverloadCandidate::dump() const {
   if (auto decl = getDecl())
     decl->dumpRef(llvm::errs());
   else
@@ -309,9 +309,8 @@ static bool findGenericSubstitutions(DeclContext *dc, Type paramType,
 /// Determine how close an argument list is to an already decomposed argument
 /// list.  If the closeness is a miss by a single argument, then this returns
 /// information about that failure.
-CalleeCandidateInfo::ClosenessResultTy
-CalleeCandidateInfo::evaluateCloseness(UncurriedCandidate candidate,
-                                       ArrayRef<AnyFunctionType::Param> actualArgs) {
+CalleeCandidateInfo::ClosenessResultTy CalleeCandidateInfo::evaluateCloseness(
+    OverloadCandidate candidate, ArrayRef<AnyFunctionType::Param> actualArgs) {
   auto *dc = candidate.getDecl()
   ? candidate.getDecl()->getInnermostDeclContext()
   : nullptr;
@@ -787,7 +786,7 @@ void CalleeCandidateInfo::collectCalleeCandidates(Expr *fn,
 void CalleeCandidateInfo::filterListArgs(ArrayRef<AnyFunctionType::Param> actualArgs) {
   // Now that we have the candidate list, figure out what the best matches from
   // the candidate list are, and remove all the ones that aren't at that level.
-  filterList([&](UncurriedCandidate candidate) -> ClosenessResultTy {
+  filterList([&](OverloadCandidate candidate) -> ClosenessResultTy {
     // If this isn't a function or isn't valid at this uncurry level, treat it
     // as a general mismatch.
     if (!candidate.hasParameters())
@@ -801,7 +800,7 @@ void CalleeCandidateInfo::filterContextualMemberList(Expr *argExpr) {
 
   // If the argument is not present then we expect members without arguments.
   if (!argExpr) {
-    return filterList([&](UncurriedCandidate candidate) -> ClosenessResultTy {
+    return filterList([&](OverloadCandidate candidate) -> ClosenessResultTy {
       // If this candidate has no arguments, then we're a match.
       if (!candidate.hasParameters())
         return {CC_ExactMatch, {}};

lib/Sema/CalleeCandidateInfo.h

@@ -45,19 +45,17 @@ namespace swift {
     CC_GeneralMismatch          ///< Something else is wrong.
   };
 
-  /// This is a candidate for a callee, along with an uncurry level.
+  /// This is a candidate for a callee.
   ///
-  /// The uncurry level specifies how far much of a curried value has already
-  /// been applied.  For example, in a funcdecl of:
-  ///     func f(a:Int)(b:Double) -> Int
-  /// Uncurry level of 0 indicates that we're looking at the "a" argument, an
-  /// uncurry level of 1 indicates that we're looking at the "b" argument.
+  /// `skipCurriedSelf` specifies that function type associated with this
+  /// candidate might have a curried self parameter which needs to be
+  /// skipped.
   ///
-  /// entityType specifies a specific type to use for this decl/expr that may be
-  /// more resolved than the concrete type.  For example, it may have generic
+  /// `entityType` specifies a specific type to use for this decl/expr that may
+  /// be more resolved than the concrete type.  For example, it may have generic
   /// arguments substituted in.
   ///
-  struct UncurriedCandidate {
+  struct OverloadCandidate {
     PointerUnion<ValueDecl *, Expr*> declOrExpr;
     bool skipCurriedSelf;
     Type entityType;
@@ -70,12 +68,12 @@ namespace swift {
     //
     // FIXME: Clean this up.
     bool substituted;
-    
-    UncurriedCandidate(ValueDecl *decl, bool skipCurriedSelf);
-    UncurriedCandidate(Expr *expr, Type type)
-    : declOrExpr(expr), skipCurriedSelf(false), entityType(type),
-      substituted(true) {}
-    
+
+    OverloadCandidate(ValueDecl *decl, bool skipCurriedSelf);
+    OverloadCandidate(Expr *expr, Type type)
+        : declOrExpr(expr), skipCurriedSelf(false), entityType(type),
+          substituted(true) {}
+
     ValueDecl *getDecl() const {
       return declOrExpr.dyn_cast<ValueDecl*>();
     }
@@ -150,8 +148,8 @@ namespace swift {
     bool hasTrailingClosure;
 
     /// This is the list of candidates identified.
-    SmallVector<UncurriedCandidate, 4> candidates;
-    
+    SmallVector<OverloadCandidate, 4> candidates;
+
     /// This tracks how close the candidates are, after filtering.
     CandidateCloseness closeness = CC_GeneralMismatch;
 
@@ -196,25 +194,23 @@ namespace swift {
 
     using ClosenessResultTy = std::pair<CandidateCloseness, FailedArgumentInfo>;
     using ClosenessPredicate =
-        const std::function<ClosenessResultTy(UncurriedCandidate)> &;
+        const std::function<ClosenessResultTy(OverloadCandidate)> &;
 
     /// After the candidate list is formed, it can be filtered down to discard
     /// obviously mismatching candidates and compute a "closeness" for the
     /// resultant set.
     ClosenessResultTy
-    evaluateCloseness(UncurriedCandidate candidate,
+    evaluateCloseness(OverloadCandidate candidate,
                       ArrayRef<AnyFunctionType::Param> actualArgs);
-    
+
     void filterListArgs(ArrayRef<AnyFunctionType::Param> actualArgs);
     void filterList(ClosenessPredicate predicate);
     void filterContextualMemberList(Expr *argExpr);
 
     bool empty() const { return candidates.empty(); }
     unsigned size() const { return candidates.size(); }
-    UncurriedCandidate operator[](unsigned i) const {
-      return candidates[i];
-    }
-    
+    OverloadCandidate operator[](unsigned i) const { return candidates[i]; }
+
     /// Given a set of parameter lists from an overload group, and a list of
     /// arguments, emit a diagnostic indicating any partially matching
     /// overloads.