Have ArgumentMismatchFailure store FunctionArgApplyInfo

And define members in order to allow the easy
access of relevant information about the failure.

Author: hamishknight

lib/Sema/CSDiagnostics.cpp

@@ -5037,8 +5037,8 @@ bool ArgumentMismatchFailure::diagnoseAsNote() {
   auto argToParam = locator->findFirst<LocatorPathElt::ApplyArgToParam>();
   assert(argToParam);
 
-  if (auto *decl = getDecl()) {
-    emitDiagnostic(decl, diag::candidate_has_invalid_argument_at_position,
+  if (auto *callee = getCallee()) {
+    emitDiagnostic(callee, diag::candidate_has_invalid_argument_at_position,
                    getToType(), argToParam->getParamIdx());
     return true;
   }
@@ -5066,11 +5066,10 @@ bool ArgumentMismatchFailure::diagnoseUseOfReferenceEqualityOperator() const {
   // one would cover both arguments.
   if (getAnchor() == rhs && rhsType->is<FunctionType>()) {
     auto &cs = getConstraintSystem();
-    auto info = getFunctionArgApplyInfo(locator);
-    if (info && cs.hasFixFor(cs.getConstraintLocator(
-                    binaryOp, {ConstraintLocator::ApplyArgument,
-                               LocatorPathElt::ApplyArgToParam(
-                                   0, 0, info->getParameterFlagsAtIndex(0))})))
+    if (cs.hasFixFor(cs.getConstraintLocator(
+            binaryOp, {ConstraintLocator::ApplyArgument,
+                       LocatorPathElt::ApplyArgToParam(
+                           0, 0, getParameterFlagsAtIndex(0))})))
       return true;
   }
 
@@ -5228,14 +5227,12 @@ bool ArgumentMismatchFailure::diagnoseMisplacedMissingArgument() const {
   if (!MissingArgumentsFailure::isMisplacedMissingArgument(cs, locator))
     return false;
 
-  auto info = *getFunctionArgApplyInfo(locator);
-
   auto *argType = cs.createTypeVariable(
       cs.getConstraintLocator(locator, LocatorPathElt::SynthesizedArgument(1)),
       /*flags=*/0);
 
   // Assign new type variable to a type of a parameter.
-  auto *fnType = info.getFnType();
+  auto *fnType = getFnType();
   const auto &param = fnType->getParams()[0];
   cs.assignFixedType(argType, param.getOldType());
 

lib/Sema/CSDiagnostics.h

@@ -1752,10 +1752,17 @@ class FunctionArgApplyInfo {
 /// func bar(_ v: Int) { foo(v) } // `Int` is not convertible to `String`
 /// ```
 class ArgumentMismatchFailure : public ContextualFailure {
+  // FIXME: Currently ArgumentMismatchFailure can be used from CSDiag, in which
+  // case it's possible we're not able to resolve the arg apply info. Once
+  // the CSDiag logic has been removed, we should be able to store Info
+  // unwrapped.
+  Optional<FunctionArgApplyInfo> Info;
+
 public:
   ArgumentMismatchFailure(Expr *root, ConstraintSystem &cs, Type argType,
                           Type paramType, ConstraintLocator *locator)
-      : ContextualFailure(root, cs, argType, paramType, locator) {}
+      : ContextualFailure(root, cs, argType, paramType, locator),
+        Info(getFunctionArgApplyInfo(getLocator())) {}
 
   bool diagnoseAsError() override;
   bool diagnoseAsNote() override;
@@ -1772,6 +1779,84 @@ class ArgumentMismatchFailure : public ContextualFailure {
   bool diagnoseUseOfReferenceEqualityOperator() const;
 
 protected:
+  /// \returns The position of the argument being diagnosed, starting at 1.
+  unsigned getArgPosition() const { return Info->getArgPosition(); }
+
+  /// \returns The position of the parameter being diagnosed, starting at 1.
+  unsigned getParamPosition() const { return Info->getParamPosition(); }
+
+  /// Returns the argument expression being diagnosed.
+  ///
+  /// Note this may differ from \c getAnchor(), which will return a smaller
+  /// sub-expression if the failed constraint is for a sub-expression within
+  /// an argument. For example, in an argument conversion from (T, U) to (U, U),
+  /// the conversion from T to U may fail. In this case, \c getArgExpr() will
+  /// return the (T, U) expression, whereas \c getAnchor() will return the T
+  /// expression.
+  Expr *getArgExpr() const { return Info->getArgExpr(); }
+
+  /// Returns the argument type for the conversion being diagnosed.
+  ///
+  /// \param withSpecifier Whether to keep the inout or @lvalue specifier of
+  /// the argument, if any.
+  ///
+  /// Note this may differ from \c getFromType(), which will give the source
+  /// type of a failed constraint for the argument conversion. For example in
+  /// an argument conversion from T? to U?, the conversion from T to U may fail.
+  /// In this case, \c getArgType() will return T?, whereas \c getFromType()
+  /// will return T.
+  Type getArgType(bool withSpecifier = false) const {
+    return Info->getArgType(withSpecifier);
+  }
+
+  /// \returns The interface type for the function being applied.
+  Type getFnInterfaceType() const { return Info->getFnInterfaceType(); }
+
+  /// \returns The function type being applied, including any generic
+  /// substitutions.
+  FunctionType *getFnType() const { return Info->getFnType(); }
+
+  /// \returns The callee for the argument conversion, if any.
+  const ValueDecl *getCallee() const {
+    return Info ? Info->getCallee() : nullptr;
+  }
+
+  /// \returns The full name of the callee, or a null decl name if there is no
+  /// callee.
+  DeclName getCalleeFullName() const {
+    return getCallee() ? getCallee()->getFullName() : DeclName();
+  }
+
+  /// Returns the type of the parameter involved in the mismatch, including any
+  /// generic substitutions.
+  ///
+  /// \param lookThroughAutoclosure Whether an @autoclosure () -> T parameter
+  /// should be treated as being of type T.
+  ///
+  /// Note this may differ from \c getToType(), see the note on \c getArgType().
+  Type getParamType(bool lookThroughAutoclosure = true) const {
+    return Info->getParamType(lookThroughAutoclosure);
+  }
+
+  /// Returns the type of the parameter involved in the mismatch.
+  ///
+  /// \param lookThroughAutoclosure Whether an @autoclosure () -> T parameter
+  /// should be treated as being of type T.
+  ///
+  /// Note this may differ from \c getToType(), see the note on \c getArgType().
+  Type getParamInterfaceType(bool lookThroughAutoclosure = true) const {
+    return Info->getParamInterfaceType(lookThroughAutoclosure);
+  }
+
+  /// \returns The flags of the parameter involved in the mismatch.
+  ParameterTypeFlags getParameterFlags() const {
+    return Info->getParameterFlags();
+  }
+
+  /// \returns The flags of a parameter at a given index.
+  ParameterTypeFlags getParameterFlagsAtIndex(unsigned idx) const {
+    return Info->getParameterFlagsAtIndex(idx);
+  }
 
   /// Situations like this:
   ///
@@ -1783,15 +1868,6 @@ class ArgumentMismatchFailure : public ContextualFailure {
   bool diagnoseMisplacedMissingArgument() const;
 
   SourceLoc getLoc() const { return getAnchor()->getLoc(); }
-
-  ValueDecl *getDecl() const {
-    auto selectedOverload = getChoiceFor(getLocator());
-    if (!selectedOverload)
-      return nullptr;
-
-    auto choice = selectedOverload->choice;
-    return choice.getDeclOrNull();
-  }
 };
 
 } // end namespace constraints