[Diagnostics] Produce a tailored diagnostic for multiple missing arguments

Author: xedin

include/swift/AST/DiagnosticsSema.def

@@ -1116,6 +1116,8 @@ ERROR(missing_argument_named,none,
       "missing argument for parameter %0 in call", (Identifier))
 ERROR(missing_argument_positional,none,
       "missing argument for parameter #%0 in call", (unsigned))
+ERROR(missing_arguments_in_call,none,
+      "missing arguments for parameters %0 in call", (StringRef))
 ERROR(extra_argument_named,none,
       "extra argument %0 in call", (Identifier))
 ERROR(extra_argument_positional,none,

lib/Sema/CSDiagnostics.cpp

@@ -3623,17 +3623,75 @@ bool MissingArgumentsFailure::diagnoseAsError() {
   if (diagnoseInvalidTupleDestructuring())
     return true;
 
-  if (diagnoseSingleMissingArgument())
-    return true;
+  if (SynthesizedArgs.size() == 1)
+    return diagnoseSingleMissingArgument();
 
-  return false;
+  // At this point we know that this is a situation when
+  // there are multiple arguments missing, so let's produce
+  // a diagnostic which lists all of them and a fix-it
+  // to add arguments at appropriate positions.
+
+  SmallString<32> diagnostic;
+  llvm::raw_svector_ostream arguments(diagnostic);
+
+  interleave(
+      SynthesizedArgs,
+      [&](const AnyFunctionType::Param &arg) {
+        if (arg.hasLabel()) {
+          arguments << "'" << arg.getLabel().str() << "'";
+        } else {
+          auto *typeVar = arg.getPlainType()->castTo<TypeVariableType>();
+          auto *locator = typeVar->getImpl().getLocator();
+          auto paramIdx = locator->findLast<LocatorPathElt::ApplyArgToParam>()
+                              ->getParamIdx();
+
+          arguments << "#" << (paramIdx + 1);
+        }
+      },
+      [&] { arguments << ", "; });
+
+  auto diag = emitDiagnostic(anchor->getLoc(), diag::missing_arguments_in_call,
+                             arguments.str());
+
+  Expr *fnExpr = nullptr;
+  Expr *argExpr = nullptr;
+  unsigned numArguments = 0;
+  bool hasTrailingClosure = false;
+
+  std::tie(fnExpr, argExpr, numArguments, hasTrailingClosure) =
+      getCallInfo(getRawAnchor());
+
+  // TODO(diagnostics): We should be able to suggest this fix-it
+  // unconditionally.
+  if (argExpr && numArguments == 0) {
+    SmallString<32> scratch;
+    llvm::raw_svector_ostream fixIt(scratch);
+    interleave(
+        SynthesizedArgs,
+        [&](const AnyFunctionType::Param &arg) { forFixIt(fixIt, arg); },
+        [&] { fixIt << ", "; });
+
+    auto *tuple = cast<TupleExpr>(argExpr);
+    diag.fixItInsertAfter(tuple->getLParenLoc(), fixIt.str());
+  }
+
+  diag.flush();
+
+  if (auto selectedOverload = getChoiceFor(locator)) {
+    if (auto *decl = selectedOverload->choice.getDeclOrNull()) {
+      emitDiagnostic(decl, diag::decl_declared_here, decl->getFullName());
+    }
+  }
+
+  return true;
 }
 
 bool MissingArgumentsFailure::diagnoseSingleMissingArgument() const {
   auto &ctx = getASTContext();
 
   auto *anchor = getRawAnchor();
-  if (!(isa<CallExpr>(anchor) || isa<SubscriptExpr>(anchor)))
+  if (!(isa<CallExpr>(anchor) || isa<SubscriptExpr>(anchor) ||
+        isa<UnresolvedMemberExpr>(anchor)))
     return false;
 
   if (SynthesizedArgs.size() != 1)
@@ -3652,37 +3710,21 @@ bool MissingArgumentsFailure::diagnoseSingleMissingArgument() const {
   if (position != 0)
     insertText << ", ";
 
-  if (!label.empty())
-    insertText << label.str() << ": ";
+  forFixIt(insertText, argument);
 
-  // Explode inout type.
-  if (argument.isInOut())
-    insertText << "&";
+  Expr *fnExpr = nullptr;
+  Expr *argExpr = nullptr;
+  unsigned insertableEndIdx = 0;
+  bool hasTrailingClosure = false;
 
-  auto resolvedType = resolveType(argType);
-  // @autoclosure; the type should be the result type.
-  if (argument.isAutoClosure())
-    resolvedType = resolvedType->castTo<FunctionType>()->getResult();
+  std::tie(fnExpr, argExpr, insertableEndIdx, hasTrailingClosure) =
+      getCallInfo(anchor);
 
-  insertText << "<#" << resolvedType << "#>";
+  if (!argExpr)
+    return false;
 
-  unsigned insertableEndIdx = 0;
-  Expr *fnExpr = nullptr;
-  Expr *argExpr = nullptr;
-  if (auto *callExpr = dyn_cast<CallExpr>(anchor)) {
-    fnExpr = callExpr->getFn();
-    argExpr = callExpr->getArg();
-    insertableEndIdx = callExpr->getNumArguments();
-    if (callExpr->hasTrailingClosure())
-      insertableEndIdx -= 1;
-  } else {
-    auto *SE = cast<SubscriptExpr>(anchor);
-    fnExpr = SE;
-    argExpr = SE->getIndex();
-    insertableEndIdx = SE->getNumArguments();
-    if (SE->hasTrailingClosure())
-      insertableEndIdx -= 1;
-  }
+  if (hasTrailingClosure)
+    insertableEndIdx -= 1;
 
   if (position == 0 && insertableEndIdx != 0)
     insertText << ", ";
@@ -3969,6 +4011,40 @@ bool MissingArgumentsFailure::isMisplacedMissingArgument(
   return TC.isConvertibleTo(argType, paramType, cs.DC);
 }
 
+std::tuple<Expr *, Expr *, unsigned, bool>
+MissingArgumentsFailure::getCallInfo(Expr *anchor) const {
+  if (auto *call = dyn_cast<CallExpr>(anchor)) {
+    return std::make_tuple(call->getFn(), call->getArg(),
+                           call->getNumArguments(), call->hasTrailingClosure());
+  } else if (auto *UME = dyn_cast<UnresolvedMemberExpr>(anchor)) {
+    return std::make_tuple(UME, UME->getArgument(), UME->getNumArguments(),
+                           UME->hasTrailingClosure());
+  } else if (auto *SE = dyn_cast<SubscriptExpr>(anchor)) {
+    return std::make_tuple(SE, SE->getIndex(), SE->getNumArguments(),
+                           SE->hasTrailingClosure());
+  }
+
+  return std::make_tuple(nullptr, nullptr, 0, false);
+}
+
+void MissingArgumentsFailure::forFixIt(
+    llvm::raw_svector_ostream &out,
+    const AnyFunctionType::Param &argument) const {
+  if (argument.hasLabel())
+    out << argument.getLabel().str() << ": ";
+
+  // Explode inout type.
+  if (argument.isInOut())
+    out << "&";
+
+  auto resolvedType = resolveType(argument.getPlainType());
+  // @autoclosure; the type should be the result type.
+  if (argument.isAutoClosure())
+    resolvedType = resolvedType->castTo<FunctionType>()->getResult();
+
+  out << "<#" << resolvedType << "#>";
+}
+
 bool ClosureParamDestructuringFailure::diagnoseAsError() {
   auto *closure = cast<ClosureExpr>(getAnchor());
   auto params = closure->getParameters();

lib/Sema/CSDiagnostics.h

@@ -1193,7 +1193,9 @@ class MissingArgumentsFailure final : public FailureDiagnostic {
                           ArrayRef<Param> synthesizedArgs,
                           ConstraintLocator *locator)
       : FailureDiagnostic(root, cs, locator),
-        SynthesizedArgs(synthesizedArgs.begin(), synthesizedArgs.end()) {}
+        SynthesizedArgs(synthesizedArgs.begin(), synthesizedArgs.end()) {
+    assert(!SynthesizedArgs.empty() && "No missing arguments?!");
+  }
 
   bool diagnoseAsError() override;
 
@@ -1213,6 +1215,16 @@ class MissingArgumentsFailure final : public FailureDiagnostic {
   /// `@Foo(answer: 42) var question = "ultimate question"`
   bool isPropertyWrapperInitialization() const;
 
+  /// Gather informatioin associated with expression that represents
+  /// a call - function, arguments, # of arguments and whether it has
+  /// a trailing closure.
+  std::tuple<Expr *, Expr *, unsigned, bool> getCallInfo(Expr *anchor) const;
+
+  /// Transform given argument into format suitable for a fix-it
+  /// text e.g. `[<label>:]? <#<type#>`
+  void forFixIt(llvm::raw_svector_ostream &out,
+                const AnyFunctionType::Param &argument) const;
+
 public:
   /// Due to the fact that `matchCallArgument` can't and
   /// doesn't take types into consideration while matching