[Diagnostics] Don't store contextual type in missing argument fix/diagnostic

Instead of storing contextual function type in the fix/diagnostic,
let's fetch it from context (solution and/or locator) because it's
only used when it is a trailing closure missing some arguments anyway.

Author: xedin

lib/Sema/CSDiag.cpp

@@ -4092,7 +4092,7 @@ bool FailureDiagnosis::diagnoseClosureExpr(
       }
 
       MissingArgumentsFailure failure(
-          expr, CS, fnType, inferredArgCount - actualArgCount,
+          expr, CS, inferredArgCount - actualArgCount,
           CS.getConstraintLocator(CE, LocatorPathElt::ContextualType()));
       return failure.diagnoseAsError();
     }

lib/Sema/CSDiagnostics.cpp

@@ -3511,7 +3511,20 @@ bool MissingArgumentsFailure::diagnoseAsError() {
 }
 
 bool MissingArgumentsFailure::diagnoseTrailingClosure(ClosureExpr *closure) {
-  auto diff = Fn->getNumParams() - NumSynthesized;
+  auto &cs = getConstraintSystem();
+  FunctionType *funcType = nullptr;
+
+  auto *locator = getLocator();
+  if (locator->isForContextualType()) {
+    funcType = cs.getContextualType()->getAs<FunctionType>();
+  } else if (auto info = getFunctionArgApplyInfo(locator)) {
+    funcType = info->getParamType()->getAs<FunctionType>();
+  }
+
+  if (!funcType)
+    return false;
+
+  auto diff = funcType->getNumParams() - NumSynthesized;
 
   // If the closure didn't specify any arguments and it is in a context that
   // needs some, produce a fixit to turn "{...}" into "{ _,_ in ...}".
@@ -3521,10 +3534,10 @@ bool MissingArgumentsFailure::diagnoseTrailingClosure(ClosureExpr *closure) {
                        diag::closure_argument_list_missing, NumSynthesized);
 
     std::string fixText; // Let's provide fixits for up to 10 args.
-    if (Fn->getNumParams() <= 10) {
+    if (funcType->getNumParams() <= 10) {
       fixText += " ";
       interleave(
-          Fn->getParams(),
+          funcType->getParams(),
           [&fixText](const AnyFunctionType::Param &param) { fixText += '_'; },
           [&fixText] { fixText += ','; });
       fixText += " in ";
@@ -3550,9 +3563,9 @@ bool MissingArgumentsFailure::diagnoseTrailingClosure(ClosureExpr *closure) {
       std::all_of(params->begin(), params->end(),
                   [](ParamDecl *param) { return !param->hasName(); });
 
-  auto diag =
-      emitDiagnostic(params->getStartLoc(), diag::closure_argument_list_tuple,
-                     resolveType(Fn), Fn->getNumParams(), diff, diff == 1);
+  auto diag = emitDiagnostic(
+      params->getStartLoc(), diag::closure_argument_list_tuple,
+      resolveType(funcType), funcType->getNumParams(), diff, diff == 1);
 
   // If the number of parameters is less than number of inferred
   // let's try to suggest a fix-it with the rest of the missing parameters.

lib/Sema/CSDiagnostics.h

@@ -1182,16 +1182,12 @@ class ImplicitInitOnNonConstMetatypeFailure final
 class MissingArgumentsFailure final : public FailureDiagnostic {
   using Param = AnyFunctionType::Param;
 
-  FunctionType *Fn;
   unsigned NumSynthesized;
 
 public:
   MissingArgumentsFailure(Expr *root, ConstraintSystem &cs,
-                          FunctionType *funcType,
-                          unsigned numSynthesized,
-                          ConstraintLocator *locator)
-      : FailureDiagnostic(root, cs, locator), Fn(funcType),
-        NumSynthesized(numSynthesized) {}
+                          unsigned numSynthesized, ConstraintLocator *locator)
+      : FailureDiagnostic(root, cs, locator), NumSynthesized(numSynthesized) {}
 
   bool diagnoseAsError() override;
 

lib/Sema/CSFix.cpp

@@ -477,18 +477,18 @@ AllowClosureParamDestructuring::create(ConstraintSystem &cs,
 }
 
 bool AddMissingArguments::diagnose(Expr *root, bool asNote) const {
-  MissingArgumentsFailure failure(root, getConstraintSystem(), Fn,
-                                  NumSynthesized, getLocator());
+  auto &cs = getConstraintSystem();
+  MissingArgumentsFailure failure(root, cs, NumSynthesized, getLocator());
   return failure.diagnose(asNote);
 }
 
 AddMissingArguments *
-AddMissingArguments::create(ConstraintSystem &cs, FunctionType *funcType,
+AddMissingArguments::create(ConstraintSystem &cs,
                             llvm::ArrayRef<Param> synthesizedArgs,
                             ConstraintLocator *locator) {
   unsigned size = totalSizeToAlloc<Param>(synthesizedArgs.size());
   void *mem = cs.getAllocator().Allocate(size, alignof(AddMissingArguments));
-  return new (mem) AddMissingArguments(cs, funcType, synthesizedArgs, locator);
+  return new (mem) AddMissingArguments(cs, synthesizedArgs, locator);
 }
 
 bool MoveOutOfOrderArgument::diagnose(Expr *root, bool asNote) const {

lib/Sema/CSFix.h

@@ -1001,13 +1001,12 @@ class AddMissingArguments final
 
   using Param = AnyFunctionType::Param;
 
-  FunctionType *Fn;
   unsigned NumSynthesized;
 
-  AddMissingArguments(ConstraintSystem &cs, FunctionType *funcType,
-                      llvm::ArrayRef<AnyFunctionType::Param> synthesizedArgs,
+  AddMissingArguments(ConstraintSystem &cs,
+                      llvm::ArrayRef<Param> synthesizedArgs,
                       ConstraintLocator *locator)
-      : ConstraintFix(cs, FixKind::AddMissingArguments, locator), Fn(funcType),
+      : ConstraintFix(cs, FixKind::AddMissingArguments, locator),
         NumSynthesized(synthesizedArgs.size()) {
     std::uninitialized_copy(synthesizedArgs.begin(), synthesizedArgs.end(),
                             getSynthesizedArgumentsBuf().begin());
@@ -1022,7 +1021,7 @@ class AddMissingArguments final
 
   bool diagnose(Expr *root, bool asNote = false) const override;
 
-  static AddMissingArguments *create(ConstraintSystem &cs, FunctionType *fnType,
+  static AddMissingArguments *create(ConstraintSystem &cs,
                                      llvm::ArrayRef<Param> synthesizedArgs,
                                      ConstraintLocator *locator);
 

lib/Sema/CSSimplify.cpp

@@ -1167,9 +1167,8 @@ static ConstraintFix *fixRequirementFailure(ConstraintSystem &cs, Type type1,
 /// Attempt to fix missing arguments by introducing type variables
 /// and inferring their types from parameters.
 static bool fixMissingArguments(ConstraintSystem &cs, Expr *anchor,
-                                FunctionType *funcType,
                                 SmallVectorImpl<AnyFunctionType::Param> &args,
-                                SmallVectorImpl<AnyFunctionType::Param> &params,
+                                ArrayRef<AnyFunctionType::Param> params,
                                 unsigned numMissing,
                                 ConstraintLocatorBuilder locator) {
   assert(args.size() < params.size());
@@ -1219,9 +1218,8 @@ static bool fixMissingArguments(ConstraintSystem &cs, Expr *anchor,
   }
 
   ArrayRef<AnyFunctionType::Param> argsRef(args);
-  auto *fix =
-      AddMissingArguments::create(cs, funcType, argsRef.take_back(numMissing),
-                                  cs.getConstraintLocator(locator));
+  auto *fix = AddMissingArguments::create(cs, argsRef.take_back(numMissing),
+                                          cs.getConstraintLocator(locator));
 
   if (cs.recordFix(fix))
     return true;
@@ -1459,7 +1457,7 @@ ConstraintSystem::matchFunctionTypes(FunctionType *func1, FunctionType *func2,
     // If there are missing arguments, let's add them
     // using parameter as a template.
     if (diff < 0) {
-      if (fixMissingArguments(*this, anchor, func2, func1Params, func2Params,
+      if (fixMissingArguments(*this, anchor, func1Params, func2Params,
                               abs(diff), locator))
         return getTypeMatchFailure(argumentLocator);
     } else {
@@ -2662,11 +2660,9 @@ bool ConstraintSystem::repairFailures(
     // But if `T.Element` didn't get resolved to `Void` we'd like
     // to diagnose this as a missing argument which can't be ignored.
     if (arg != getTypeVariables().end()) {
-      auto fnType = FunctionType::get({FunctionType::Param(lhs)},
-                                      getASTContext().TheEmptyTupleType);
-      conversionsOrFixes.push_back(AddMissingArguments::create(
-          *this, fnType, {FunctionType::Param(*arg)},
-          getConstraintLocator(anchor, path)));
+      conversionsOrFixes.push_back(
+          AddMissingArguments::create(*this, {FunctionType::Param(*arg)},
+                                      getConstraintLocator(anchor, path)));
     }
 
     if ((lhs->is<InOutType>() && !rhs->is<InOutType>()) ||