[Diagnostics] Move getFunctionArgApplyInfo to Solution

Instead of relying on constraint system having solution applied
let's pass a solution directly to `getFunctionArgApplyInfo`.

Author: xedin

lib/Sema/CSDiagnostics.cpp

@@ -790,8 +790,7 @@ bool NoEscapeFuncToTypeConversionFailure::diagnoseParameterUse() const {
     // Let's check whether this is a function parameter passed
     // as an argument to another function which accepts @escaping
     // function at that position.
-    auto &cs = getConstraintSystem();
-    if (auto argApplyInfo = cs.getFunctionArgApplyInfo(getLocator())) {
+    if (auto argApplyInfo = getFunctionArgApplyInfo(getLocator())) {
       auto paramInterfaceTy = argApplyInfo->getParamInterfaceType();
       if (paramInterfaceTy->isTypeParameter()) {
         auto diagnoseGenericParamFailure = [&](GenericTypeParamDecl *decl) {
@@ -1001,8 +1000,7 @@ void MissingOptionalUnwrapFailure::offerDefaultValueUnwrapFixIt(
   if (!anchor || isa<InOutExpr>(anchor))
     return;
 
-  auto &cs = getConstraintSystem();
-  if (auto argApplyInfo = cs.getFunctionArgApplyInfo(getLocator()))
+  if (auto argApplyInfo = getFunctionArgApplyInfo(getLocator()))
     if (argApplyInfo->getParameterFlags().isInOut())
       return;
 
@@ -3815,7 +3813,7 @@ bool MissingArgumentsFailure::diagnoseAsError() {
   // foo(bar) // `() -> Void` vs. `(Int) -> Void`
   // ```
   if (locator->isLastElement<LocatorPathElt::ApplyArgToParam>()) {
-    auto info = *(cs.getFunctionArgApplyInfo(locator));
+    auto info = *(getFunctionArgApplyInfo(locator));
 
     auto *argExpr = info.getArgExpr();
     emitDiagnostic(argExpr->getLoc(), diag::cannot_convert_argument_value,
@@ -4040,13 +4038,12 @@ bool MissingArgumentsFailure::diagnoseSingleMissingArgument() const {
 }
 
 bool MissingArgumentsFailure::diagnoseClosure(ClosureExpr *closure) {
-  auto &cs = getConstraintSystem();
   FunctionType *funcType = nullptr;
 
   auto *locator = getLocator();
   if (locator->isForContextualType()) {
     funcType = getContextualType(locator->getAnchor())->getAs<FunctionType>();
-  } else if (auto info = cs.getFunctionArgApplyInfo(locator)) {
+  } else if (auto info = getFunctionArgApplyInfo(locator)) {
     auto paramType = info->getParamType();
     // Drop a single layer of optionality because argument could get injected
     // into optional and that doesn't contribute to the problem.
@@ -4781,8 +4778,7 @@ SourceLoc InvalidUseOfAddressOf::getLoc() const {
 }
 
 bool InvalidUseOfAddressOf::diagnoseAsError() {
-  auto &cs = getConstraintSystem();
-  if (auto argApplyInfo = cs.getFunctionArgApplyInfo(getLocator())) {
+  if (auto argApplyInfo = getFunctionArgApplyInfo(getLocator())) {
     if (!argApplyInfo->getParameterFlags().isInOut()) {
       auto anchor = getAnchor();
       emitDiagnostic(anchor->getLoc(), diag::extra_address_of, getToType())
@@ -5298,14 +5294,13 @@ bool ThrowingFunctionConversionFailure::diagnoseAsError() {
 }
 
 bool InOutConversionFailure::diagnoseAsError() {
-  auto &cs = getConstraintSystem();
   auto *anchor = getAnchor();
   auto *locator = getLocator();
   auto path = locator->getPath();
 
   if (!path.empty() &&
       path.back().getKind() == ConstraintLocator::FunctionArgument) {
-    if (auto argApplyInfo = cs.getFunctionArgApplyInfo(locator)) {
+    if (auto argApplyInfo = getFunctionArgApplyInfo(locator)) {
       emitDiagnostic(anchor->getLoc(), diag::cannot_convert_argument_value,
           argApplyInfo->getArgType(), argApplyInfo->getParamType());
     } else {

lib/Sema/CSDiagnostics.h

@@ -178,6 +178,11 @@ class FailureDiagnostic {
     return cs.getConstraintLocator(anchor, path);
   }
 
+  Optional<FunctionArgApplyInfo>
+  getFunctionArgApplyInfo(ConstraintLocator *locator) const {
+    return S.getFunctionArgApplyInfo(locator);
+  }
+
   /// \returns true is locator hasn't been simplified down to expression.
   bool hasComplexLocator() const { return HasComplexLocator; }
 
@@ -1717,7 +1722,7 @@ class ArgumentMismatchFailure : public ContextualFailure {
   ArgumentMismatchFailure(const Solution &solution, Type argType,
                           Type paramType, ConstraintLocator *locator)
       : ContextualFailure(solution, argType, paramType, locator),
-        Info(*cs.getFunctionArgApplyInfo(getLocator())) {}
+        Info(*getFunctionArgApplyInfo(getLocator())) {}
 
   bool diagnoseAsError() override;
   bool diagnoseAsNote() override;

lib/Sema/CSFix.cpp

@@ -268,7 +268,7 @@ getStructuralTypeContext(const Solution &solution, ConstraintLocator *locator) {
     auto exprType = cs.getType(anchor);
     return std::make_tuple(cs.getContextualTypePurpose(anchor), exprType,
                            contextualType);
-  } else if (auto argApplyInfo = cs.getFunctionArgApplyInfo(locator)) {
+  } else if (auto argApplyInfo = solution.getFunctionArgApplyInfo(locator)) {
     return std::make_tuple(CTP_CallArgument,
                            argApplyInfo->getArgType(),
                            argApplyInfo->getParamType());

lib/Sema/ConstraintSystem.cpp

@@ -3547,13 +3547,20 @@ bool constraints::isAutoClosureArgument(Expr *argExpr) {
 
 bool constraints::hasAppliedSelf(ConstraintSystem &cs,
                                  const OverloadChoice &choice) {
+  return hasAppliedSelf(choice, [&cs](Type type) -> Type {
+    return cs.getFixedTypeRecursive(type, /*wantRValue=*/true);
+  });
+}
+
+bool constraints::hasAppliedSelf(const OverloadChoice &choice,
+                                 llvm::function_ref<Type(Type)> getFixedType) {
   auto *decl = choice.getDeclOrNull();
   if (!decl)
     return false;
 
   auto baseType = choice.getBaseType();
   if (baseType)
-    baseType = cs.getFixedTypeRecursive(baseType, /*wantRValue=*/true);
+    baseType = getFixedType(baseType)->getRValueType();
 
   // In most cases where we reference a declaration with a curried self
   // parameter, it gets dropped from the type of the reference.
@@ -3715,18 +3722,16 @@ static bool shouldHaveDirectCalleeOverload(const CallExpr *callExpr) {
   return true;
 }
 
-Type ConstraintSystem::resolveInterfaceType(Type type) const {
+Type Solution::resolveInterfaceType(Type type) const {
   auto resolvedType = type.transform([&](Type type) -> Type {
     if (auto *tvt = type->getAs<TypeVariableType>()) {
       // If this type variable is for a generic parameter, return that.
       if (auto *gp = tvt->getImpl().getGenericParameter())
         return gp;
 
       // Otherwise resolve its fixed type, mapped out of context.
-      if (auto fixed = getFixedType(tvt))
-        return resolveInterfaceType(fixed->mapTypeOutOfContext());
-
-      return getRepresentative(tvt);
+      auto fixed = simplifyType(tvt);
+      return resolveInterfaceType(fixed->mapTypeOutOfContext());
     }
     if (auto *dmt = type->getAs<DependentMemberType>()) {
       // For a dependent member, first resolve the base.
@@ -3744,7 +3749,7 @@ Type ConstraintSystem::resolveInterfaceType(Type type) const {
 }
 
 Optional<FunctionArgApplyInfo>
-ConstraintSystem::getFunctionArgApplyInfo(ConstraintLocator *locator) {
+Solution::getFunctionArgApplyInfo(ConstraintLocator *locator) const {
   auto *anchor = locator->getAnchor();
   auto path = locator->getPath();
 
@@ -3764,8 +3769,7 @@ ConstraintSystem::getFunctionArgApplyInfo(ConstraintLocator *locator) {
   // Form a new locator that ends at the apply-arg-to-param element, and
   // simplify it to get the full argument expression.
   auto argPath = path.drop_back(iter - path.rbegin());
-  auto *argLocator = getConstraintLocator(
-      anchor, argPath, ConstraintLocator::getSummaryFlagsForPath(argPath));
+  auto *argLocator = getConstraintLocator(anchor, argPath);
 
   auto *argExpr = simplifyLocatorToAnchor(argLocator);
 
@@ -3777,7 +3781,7 @@ ConstraintSystem::getFunctionArgApplyInfo(ConstraintLocator *locator) {
   Optional<OverloadChoice> choice;
   Type rawFnType;
   auto *calleeLocator = getCalleeLocator(argLocator);
-  if (auto overload = findSelectedOverloadFor(calleeLocator)) {
+  if (auto overload = getOverloadChoiceIfAvailable(calleeLocator)) {
     // If we have resolved an overload for the callee, then use that to get the
     // function type and callee.
     choice = overload->choice;
@@ -3816,7 +3820,8 @@ ConstraintSystem::getFunctionArgApplyInfo(ConstraintLocator *locator) {
     fnInterfaceType = callee->getInterfaceType();
 
     // Strip off the curried self parameter if necessary.
-    if (hasAppliedSelf(*this, *choice))
+    if (hasAppliedSelf(
+            *choice, [this](Type type) -> Type { return simplifyType(type); }))
       fnInterfaceType = fnInterfaceType->castTo<AnyFunctionType>()->getResult();
 
     if (auto *fn = fnInterfaceType->getAs<AnyFunctionType>()) {
@@ -3831,9 +3836,10 @@ ConstraintSystem::getFunctionArgApplyInfo(ConstraintLocator *locator) {
   auto argIdx = applyArgElt->getArgIdx();
   auto paramIdx = applyArgElt->getParamIdx();
 
-  return FunctionArgApplyInfo(getParentExpr(argExpr), argExpr, argIdx,
-                              simplifyType(getType(argExpr)),
-                              paramIdx, fnInterfaceType, fnType, callee);
+  auto &cs = getConstraintSystem();
+  return FunctionArgApplyInfo(cs.getParentExpr(argExpr), argExpr, argIdx,
+                              simplifyType(getType(argExpr)), paramIdx,
+                              fnInterfaceType, fnType, callee);
 }
 
 bool constraints::isKnownKeyPathType(Type type) {

lib/Sema/ConstraintSystem.h

@@ -984,6 +984,17 @@ class Solution {
     return known->second;
   }
 
+  /// Resolve type variables present in the raw type, using generic parameter
+  /// types where possible.
+  Type resolveInterfaceType(Type type) const;
+
+  /// For a given locator describing a function argument conversion, or a
+  /// constraint within an argument conversion, returns information about the
+  /// application of the argument to its parameter. If the locator is not
+  /// for an argument conversion, returns \c None.
+  Optional<FunctionArgApplyInfo>
+  getFunctionArgApplyInfo(ConstraintLocator *) const;
+
   SWIFT_DEBUG_DUMP;
 
   /// Dump this solution.
@@ -2103,16 +2114,6 @@ class ConstraintSystem {
     return findSelectedOverloadFor(calleeLoc);
   }
 
-  /// Resolve type variables present in the raw type, using generic parameter
-  /// types where possible.
-  Type resolveInterfaceType(Type type) const;
-
-  /// For a given locator describing a function argument conversion, or a
-  /// constraint within an argument conversion, returns information about the
-  /// application of the argument to its parameter. If the locator is not
-  /// for an argument conversion, returns \c None.
-  Optional<FunctionArgApplyInfo> getFunctionArgApplyInfo(ConstraintLocator *);
-
 private:
   unsigned assignTypeVariableID() {
     return TypeCounter++;
@@ -4806,6 +4807,8 @@ bool isAutoClosureArgument(Expr *argExpr);
 /// parameter being applied, meaning that it's dropped from the type of the
 /// reference.
 bool hasAppliedSelf(ConstraintSystem &cs, const OverloadChoice &choice);
+bool hasAppliedSelf(const OverloadChoice &choice,
+                    llvm::function_ref<Type(Type)> getFixedType);
 
 /// Check whether type conforms to a given known protocol.
 bool conformsToKnownProtocol(ConstraintSystem &cs, Type type,