[Constraint solver] Address feedback from Pavel and Slava.

Author: DougGregor

lib/Sema/CSSimplify.cpp

@@ -4801,13 +4801,11 @@ ConstraintSystem::simplifyKeyPathApplicationConstraint(
 }
 
 Type ConstraintSystem::simplifyAppliedOverloads(
-                                Type fnType,
+                                TypeVariableType *fnTypeVar,
                                 const FunctionType *argFnType,
                                 Optional<ArgumentLabelState> argumentLabels,
                                 ConstraintLocatorBuilder locator) {
-  auto fnTypeVar = fnType->getAs<TypeVariableType>();
-  if (!fnTypeVar)
-    return fnType;
+  Type fnType(fnTypeVar);
 
   // Always work on the representation.
   fnTypeVar = getRepresentative(fnTypeVar);
@@ -4850,25 +4848,12 @@ Type ConstraintSystem::simplifyAppliedOverloads(
 
   // Consider each of the constraints in the disjunction.
 retry_after_fail:
-  bool skippedAnyConstraints = false;
+  bool hasUnhandledConstraints = false;
   bool labelMismatch = false;
   auto filterResult =
-      filterDisjunctions(disjunction, /*restoreOnFail=*/shouldAttemptFixes(),
+      filterDisjunction(disjunction, /*restoreOnFail=*/shouldAttemptFixes(),
                          [&](Constraint *constraint) {
-        // We must have bind-overload constraints.
-        // FIXME: This isn't entirely true.
-        if (constraint->getKind() != ConstraintKind::BindOverload) {
-          skippedAnyConstraints = true;
-          return true;
-        }
-
-        // We must be binding the type variable (or a type variable
-        // equivalent to it).
-        auto boundTypeVar = constraint->getFirstType()->getAs<TypeVariableType>();
-        if (!boundTypeVar || getRepresentative(boundTypeVar) != fnTypeVar) {
-          skippedAnyConstraints = true;
-          return true;
-        }
+        assert(constraint->getKind() == ConstraintKind::BindOverload);
 
         auto choice = constraint->getOverloadChoice();
 
@@ -4887,7 +4872,7 @@ Type ConstraintSystem::simplifyAppliedOverloads(
             getEffectiveOverloadType(choice, /*allowMembers=*/true,
                                      constraint->getOverloadUseDC());
         if (!choiceType) {
-          skippedAnyConstraints = true;
+          hasUnhandledConstraints = true;
           return true;
         }
 
@@ -4917,7 +4902,7 @@ Type ConstraintSystem::simplifyAppliedOverloads(
 
   // If there was a constraint that we couldn't reason about, don't use the
   // results of any common-type computations.
-  if (skippedAnyConstraints)
+  if (hasUnhandledConstraints)
     return fnType;
 
   // If we have a common result type, bind the expected result type to it.
@@ -4997,7 +4982,7 @@ ConstraintSystem::simplifyApplicableFnConstraint(
   if (auto typeVar = desugar2->getAs<TypeVariableType>()) {
     auto argumentLabels = getArgumentLabels(*this, locator);
     Type newType2 =
-        simplifyAppliedOverloads(type2, func1, argumentLabels, locator);
+        simplifyAppliedOverloads(typeVar, func1, argumentLabels, locator);
     if (!newType2)
       return SolutionKind::Error;
 

lib/Sema/CSSolver.cpp

@@ -1292,7 +1292,7 @@ void ConstraintSystem::collectDisjunctions(
 }
 
 ConstraintSystem::SolutionKind
-ConstraintSystem::filterDisjunctions(
+ConstraintSystem::filterDisjunction(
     Constraint *disjunction, bool restoreOnFail,
     llvm::function_ref<bool(Constraint *)> pred) {
   assert(disjunction->getKind() == ConstraintKind::Disjunction);
@@ -1656,10 +1656,19 @@ Constraint *ConstraintSystem::getUnboundBindOverloadDisjunction(
   llvm::SetVector<Constraint *> disjunctions;
   getConstraintGraph().gatherConstraints(
       rep, disjunctions, ConstraintGraph::GatheringKind::EquivalenceClass,
-      [](Constraint *match) {
-        return match->getKind() == ConstraintKind::Disjunction &&
-               match->getNestedConstraints().front()->getKind() ==
-                   ConstraintKind::BindOverload;
+      [this, rep](Constraint *match) {
+        if (match->getKind() != ConstraintKind::Disjunction ||
+            match->getNestedConstraints().front()->getKind() !=
+                   ConstraintKind::BindOverload)
+          return false;
+
+        auto lhsTypeVar =
+            match->getNestedConstraints().front()->getFirstType()
+              ->getAs<TypeVariableType>();
+        if (!lhsTypeVar)
+          return false;
+
+        return getRepresentative(lhsTypeVar) == rep;
       });
 
   if (disjunctions.empty())

lib/Sema/ConstraintSystem.cpp

@@ -1534,7 +1534,7 @@ Type ConstraintSystem::getEffectiveOverloadType(const OverloadChoice &overload,
                        ->castTo<AnyFunctionType>()->getParams();
       type = FunctionType::get(indices, elementTy);
     } else if (auto var = dyn_cast<VarDecl>(decl)) {
-      type = var->getInterfaceType();
+      type = var->getValueInterfaceType();
       if (doesStorageProduceLValue(var, overload.getBaseType(), useDC))
         type = LValueType::get(type);
     } else if (isa<FuncDecl>(decl) || isa<EnumElementDecl>(decl)) {

lib/Sema/ConstraintSystem.h

@@ -2353,9 +2353,8 @@ class ConstraintSystem {
   /// Attempt to simplify the set of overloads corresponding to a given
   /// function application constraint.
   ///
-  /// \param fnType The type that describes the function being applied.
-  /// When there is a set of overloads, this will generally be a type
-  /// variable that can be used to find the set of overloads.
+  /// \param fnTypeVar The type variable that describes the set of
+  /// overloads for the function.
   ///
   /// \param argFnType The call signature, which includes the call arguments
   /// (as the function parameters) and the expected result type of the
@@ -2367,7 +2366,7 @@ class ConstraintSystem {
   /// \returns \c fnType, or some simplified form of it if this function
   /// was able to find a single overload or derive some common structure
   /// among the overloads.
-  Type simplifyAppliedOverloads(Type fnType,
+  Type simplifyAppliedOverloads(TypeVariableType *fnTypeVar,
                                 const FunctionType *argFnType,
                                 Optional<ArgumentLabelState> argumentLabels,
                                 ConstraintLocatorBuilder locator);
@@ -3129,7 +3128,7 @@ class ConstraintSystem {
   /// \returns One of \c Solved (only a single term remained),
   /// \c Unsolved (more than one disjunction terms remain), or
   /// \c Error (all terms were filtered out).
-  SolutionKind filterDisjunctions(Constraint *disjunction,
+  SolutionKind filterDisjunction(Constraint *disjunction,
                                   bool restoreOnFail,
                                   llvm::function_ref<bool(Constraint *)> pred);