[ConstraintSystem] Add a new locator element - argument attribute

`ArgumentAttribute` points to a particular attribute associated
with one of the arguments e.g. `inout` or its type e.g. `@escaping`.

This is very useful when dealing with argument-to-parameter
failures because it allows to express in the locator kind
of a problem.

Author: xedin

lib/Sema/ConstraintLocator.cpp

@@ -57,6 +57,7 @@ void ConstraintLocator::Profile(llvm::FoldingSetNodeID &id, ASTNode anchor,
       id.AddPointer(elt.castTo<LocatorPathElt::PatternMatch>().getPattern());
       break;
 
+    case ArgumentAttribute:
     case GenericArgument:
     case NamedTupleElement:
     case TupleElement:
@@ -125,6 +126,7 @@ unsigned LocatorPathElt::getNewSummaryFlags() const {
   case ConstraintLocator::ImplicitCallAsFunction:
   case ConstraintLocator::TernaryBranch:
   case ConstraintLocator::PatternMatch:
+  case ConstraintLocator::ArgumentAttribute:
     return 0;
 
   case ConstraintLocator::FunctionArgument:
@@ -500,6 +502,25 @@ void ConstraintLocator::dump(SourceManager *sm, raw_ostream &out) const {
     case PatternMatch:
       out << "pattern match";
       break;
+
+    case ArgumentAttribute: {
+      using AttrLoc = LocatorPathElt::ArgumentAttribute;
+
+      auto attrElt = elt.castTo<AttrLoc>();
+      out << "argument attribute: ";
+
+      switch (attrElt.getAttr()) {
+      case AttrLoc::Attribute::InOut:
+        out << "inout";
+        break;
+
+      case AttrLoc::Attribute::Escaping:
+        out << "@escaping";
+        break;
+      }
+
+      break;
+    }
     }
   }
   out << ']';

lib/Sema/ConstraintLocator.h

@@ -86,6 +86,7 @@ class ConstraintLocator : public llvm::FoldingSetNode {
     case SynthesizedArgument:
     case KeyPathDynamicMember:
     case TernaryBranch:
+    case ArgumentAttribute:
       return 1;
 
     case TypeParameterRequirement:
@@ -847,6 +848,31 @@ class LocatorPathElt::PatternMatch final : public LocatorPathElt {
   }
 };
 
+class LocatorPathElt::ArgumentAttribute final : public LocatorPathElt {
+public:
+  enum Attribute : uint8_t { InOut, Escaping };
+
+private:
+  ArgumentAttribute(Attribute attr)
+      : LocatorPathElt(ConstraintLocator::ArgumentAttribute,
+                       static_cast<uint8_t>(attr)) {}
+
+public:
+  Attribute getAttr() const { return static_cast<Attribute>(getValue(0)); }
+
+  static ArgumentAttribute forInOut() {
+    return ArgumentAttribute(Attribute::InOut);
+  }
+
+  static ArgumentAttribute forEscaping() {
+    return ArgumentAttribute(Attribute::Escaping);
+  }
+
+  static bool classof(const LocatorPathElt *elt) {
+    return elt->getKind() == ConstraintLocator::ArgumentAttribute;
+  }
+};
+
 /// A simple stack-only builder object that constructs a
 /// constraint locator without allocating memory.
 ///

lib/Sema/ConstraintLocatorPathElts.def

@@ -181,6 +181,14 @@ CUSTOM_LOCATOR_PATH_ELT(TernaryBranch)
 /// Performing a pattern patch.
 CUSTOM_LOCATOR_PATH_ELT(PatternMatch)
 
+/// Points to a particular attribute associated with one of
+/// the arguments e.g. `inout` or its type e.g. `@escaping`.
+///
+/// This is very useful when dealing with argument-to-parameter
+/// failures because it allows to express in the locator kind
+/// of a problem.
+CUSTOM_LOCATOR_PATH_ELT(ArgumentAttribute)
+
 #undef LOCATOR_PATH_ELT
 #undef CUSTOM_LOCATOR_PATH_ELT
 #undef SIMPLE_LOCATOR_PATH_ELT