[Sema] A small OverloadChoice constructor cleanup

This patch basically just simplifies the constructors, where in 6 out of 8 cases `isSpecialized = false`

Author: JaSpa

lib/Sema/CSGen.cpp

@@ -1024,8 +1024,8 @@ namespace {
       auto memberLocator =
         CS.getConstraintLocator(expr, ConstraintLocator::Member);
       auto tv = CS.createTypeVariable(memberLocator, TVO_CanBindToLValue);
-      
-      OverloadChoice choice(base->getType(), decl, /*isSpecialized=*/false, CS);
+
+      OverloadChoice choice(base->getType(), decl, CS);
       auto locator = CS.getConstraintLocator(expr, ConstraintLocator::Member);
       CS.addBindOverloadConstraint(tv, choice, locator);
       return tv;
@@ -1114,8 +1114,7 @@ namespace {
       // a known subscript here. This might be cleaner if we split off a new
       // UnresolvedSubscriptExpr from SubscriptExpr.
       if (decl) {
-        OverloadChoice choice(base->getType(), decl, /*isSpecialized=*/false,
-                              CS);
+        OverloadChoice choice(base->getType(), decl, CS);
         CS.addBindOverloadConstraint(fnTy, choice, subscriptMemberLocator);
       } else {
         CS.addValueMemberConstraint(baseTy, Context.Id_subscript,
@@ -1312,10 +1311,9 @@ namespace {
       // Create an overload choice referencing this declaration and immediately
       // resolve it. This records the overload for use later.
       auto tv = CS.createTypeVariable(locator, TVO_CanBindToLValue);
-      CS.resolveOverload(locator, tv,
-                         OverloadChoice(Type(), E->getDecl(),
-                                        E->isSpecialized(), CS));
-      
+      CS.resolveOverload(locator, tv, OverloadChoice(Type(), E->getDecl(), CS,
+                                                     E->isSpecialized()));
+
       if (E->getDecl()->getType() &&
           !E->getDecl()->getType()->getAs<TypeVariableType>()) {
         CS.setFavoredType(E, E->getDecl()->getType().getPointer());
@@ -1377,9 +1375,8 @@ namespace {
         if (decls[i]->isInvalid())
           continue;
 
-        choices.push_back(OverloadChoice(Type(), decls[i],
-                                         expr->isSpecialized(),
-                                         CS));
+        choices.push_back(
+            OverloadChoice(Type(), decls[i], CS, expr->isSpecialized()));
       }
 
       // If there are no valid overloads, give up.

lib/Sema/CSSimplify.cpp

@@ -2842,9 +2842,8 @@ performMemberLookup(ConstraintKind constraintKind, DeclName memberName,
           }
         }
       }
-      
-      result.addViable(OverloadChoice(baseTy, ctor,
-                                      /*isSpecialized=*/false, *this));
+
+      result.addViable(OverloadChoice(baseTy, ctor, *this));
     }
 
 
@@ -2885,9 +2884,8 @@ performMemberLookup(ConstraintKind constraintKind, DeclName memberName,
       TC.validateDecl(candidate.first, true);
       if (candidate.first->isInvalid())
         return result.markErrorAlreadyDiagnosed();
-      
-      result.addViable(OverloadChoice(baseTy, candidate.first,
-                                      /*isSpecialized=*/false));
+
+      result.addViable(OverloadChoice(baseTy, candidate.first));
     }
 
     return result;
@@ -3020,8 +3018,7 @@ performMemberLookup(ConstraintKind constraintKind, DeclName memberName,
       result.addViable(OverloadChoice::getDeclViaUnwrappedOptional(ovlBaseTy,
                                                                    cand));
     } else {
-      result.addViable(OverloadChoice(ovlBaseTy, cand,
-                                      /*isSpecialized=*/false, *this));
+      result.addViable(OverloadChoice(ovlBaseTy, cand, *this));
     }
   };
 

lib/Sema/OverloadChoice.cpp

@@ -23,11 +23,10 @@
 using namespace swift;
 using namespace constraints;
 
-OverloadChoice::OverloadChoice(
-    Type base, ValueDecl *value, bool isSpecialized, ConstraintSystem &CS)
+OverloadChoice::OverloadChoice(Type base, ValueDecl *value,
+                               ConstraintSystem &CS, bool isSpecialized)
     : BaseAndBits(base, isSpecialized ? IsSpecializedBit : 0) {
   assert((reinterpret_cast<uintptr_t>(value) & (uintptr_t)0x03) == 0 &&
          "Badly aligned decl");
-
   DeclOrKind = reinterpret_cast<uintptr_t>(value);
 }

lib/Sema/OverloadChoice.h

@@ -75,7 +75,7 @@ class OverloadChoice {
     /// optional context type, turning a "Decl" kind into
     /// "DeclViaUnwrappedOptional".
     IsUnwrappedOptionalBit = 0x04,
-    
+
     // IsBridged and IsUnwrappedOptional are mutually exclusive, so there is
     // room for another mutually exclusive OverloadChoiceKind to be packed into
     // those two bits.
@@ -95,11 +95,11 @@ class OverloadChoice {
   OverloadChoice()
       : BaseAndBits(nullptr, 0), DeclOrKind() {}
 
-  OverloadChoice(
-      Type base, ValueDecl *value, bool isSpecialized, ConstraintSystem &CS);
-  
-  OverloadChoice(Type base, TypeDecl *type, bool isSpecialized)
-    : BaseAndBits(base, isSpecialized ? IsSpecializedBit : 0) {
+  OverloadChoice(Type base, ValueDecl *value, ConstraintSystem &CS,
+                 bool isSpecialized = false);
+
+  OverloadChoice(Type base, TypeDecl *type, bool isSpecialized = false)
+      : BaseAndBits(base, isSpecialized ? IsSpecializedBit : 0) {
     assert((reinterpret_cast<uintptr_t>(type) & (uintptr_t)0x03) == 0
            && "Badly aligned decl");
     DeclOrKind = reinterpret_cast<uintptr_t>(type) | 0x01;
@@ -170,14 +170,14 @@ class OverloadChoice {
   /// \brief Determines the kind of overload choice this is.
   OverloadChoiceKind getKind() const {
     switch (DeclOrKind & 0x03) {
-    case 0x00: 
+    case 0x00:
       if (BaseAndBits.getInt() & IsBridgedBit)
         return OverloadChoiceKind::DeclViaBridge;
       if (BaseAndBits.getInt() & IsUnwrappedOptionalBit)
         return OverloadChoiceKind::DeclViaUnwrappedOptional;
 
       return OverloadChoiceKind::Decl;
-      
+
     case 0x01: return OverloadChoiceKind::TypeDecl;
     case 0x02: return OverloadChoiceKind::DeclViaDynamic;
     case 0x03: {