Address a few comments about the specialization arguments constraint.

Author: DougGregor

lib/Sema/CSGen.cpp

@@ -1645,7 +1645,9 @@ namespace {
 
     /// Given a set of specialization arguments, resolve those arguments and
     /// introduce them as an explicit generic arguments constraint.
-    void addSpecializationConstraint(
+    ///
+    /// \returns true if resolving any of the specialization types failed.
+    bool addSpecializationConstraint(
         ConstraintLocator *locator, Type boundType,
         ArrayRef<TypeRepr *> specializationArgs) {
       // Resolve each type.
@@ -1658,13 +1660,17 @@ namespace {
             // Introduce type variables for unbound generics.
             OpenUnboundGenericType(CS, locator),
             HandlePlaceholderType(CS, locator));
+        if (result->hasError())
+          return true;
+
         specializationArgTypes.push_back(result);
       }
 
       CS.addConstraint(
           ConstraintKind::ExplicitGenericArguments, boundType,
           PackType::get(CS.getASTContext(), specializationArgTypes),
           locator);
+      return false;
     }
 
     Type visitUnresolvedSpecializeExpr(UnresolvedSpecializeExpr *expr) {
@@ -3710,9 +3716,10 @@ namespace {
 
         // Add explicit generic arguments, if there were any.
         if (expr->getGenericArgsRange().isValid()) {
-          addSpecializationConstraint(
-              CS.getConstraintLocator(expr), macroRefType,
-              expr->getGenericArgs());
+          if (addSpecializationConstraint(
+                CS.getConstraintLocator(expr), macroRefType,
+                expr->getGenericArgs()))
+            return Type();
         }
 
         // For non-calls, the type variable is the result.

lib/Sema/CSSimplify.cpp

@@ -12671,30 +12671,13 @@ ConstraintSystem::simplifyExplicitGenericArgumentsConstraint(
   if (simplifiedBoundType->isTypeVariableOrMember())
     return formUnsolved();
 
-  // Determine the overload locator for this constraint.
-  ConstraintLocator *overloadLocator = nullptr;
-  if (auto anchorExpr = locator.getAnchor().dyn_cast<Expr *>()) {
-    if (auto expansion = dyn_cast<MacroExpansionExpr>(anchorExpr)) {
-      overloadLocator = getConstraintLocator(expansion);
-    } else if (auto specialize =
-                   dyn_cast<UnresolvedSpecializeExpr>(anchorExpr)) {
-      overloadLocator = getConstraintLocator(
-          specialize->getSubExpr()->getSemanticsProvidingExpr());
-    }
-  } else if (auto anchorDecl = locator.getAnchor().dyn_cast<Decl *>()) {
-    if (auto expansion = dyn_cast<MacroExpansionDecl>(anchorDecl)) {
-      overloadLocator = getConstraintLocator(expansion);
-    }
-  }
-  assert(overloadLocator && "Specialize expression has the wrong form");
-
   // If the overload hasn't been resolved, we can't simplify this constraint.
-  auto resolvedOverloadIter = getResolvedOverloads().find(overloadLocator);
-  if (resolvedOverloadIter == getResolvedOverloads().end())
+  auto overloadLocator = getCalleeLocator(getConstraintLocator(locator));
+  auto selectedOverload = findSelectedOverloadFor(overloadLocator);
+  if (!selectedOverload)
     return formUnsolved();
 
-  auto selectedOverload = resolvedOverloadIter->second;
-  auto overloadChoice = selectedOverload.choice;
+  auto overloadChoice = selectedOverload->choice;
   if (!overloadChoice.isDecl()) {
     return SolutionKind::Error;
   }