[ConstraintSystem] Added necessary logic so that a constraint locator can recognize a composed property wrapper’s wrapped value type.

Author: Strieker

include/swift/Sema/ConstraintLocator.h

@@ -212,6 +212,11 @@ class ConstraintLocator : public llvm::FoldingSetNode {
   /// Determine whether this locator points to the generic parameter.
   bool isForGenericParameter() const;
 
+  /// Determine whether this locator points to the outer
+  /// property wrapper's type for a given composed property
+  /// wrapper.
+  bool isForWrappedValue() const;
+
   /// Determine whether this locator points to the element type of a
   /// sequence in a for ... in ... loop.
   bool isForSequenceElementType() const;
@@ -355,6 +360,10 @@ class ConstraintLocator : public llvm::FoldingSetNode {
 
   /// If this locator points to generic parameter return its type.
   GenericTypeParamType *getGenericParameter() const;
+    
+  /// If this locator points to the outer property wrapper's
+  /// type for a given composed property wrapper.
+  TypeBase *getWrappedValue() const;
 
   /// Produce a profile of this locator, for use in a folding set.
   static void Profile(llvm::FoldingSetNodeID &id, ASTNode anchor,
@@ -692,6 +701,21 @@ class LocatorPathElt::GenericParameter final : public StoredPointerElement<Gener
   }
 };
 
+class LocatorPathElt::WrappedValue final : public StoredPointerElement<TypeBase> {
+public:
+  WrappedValue(TypeBase *type)
+      : StoredPointerElement(PathElementKind::WrappedValue, type) {
+  }
+
+  TypeBase *getType() const {
+    return getStoredPointer();
+  }
+
+  static bool classof(const LocatorPathElt *elt) {
+    return elt->getKind() == PathElementKind::WrappedValue;
+  }
+};
+
 class LocatorPathElt::OpenedGeneric final : public StoredPointerElement<GenericSignatureImpl> {
 public:
   OpenedGeneric(GenericSignature sig)

include/swift/Sema/ConstraintLocatorPathElts.def

@@ -96,6 +96,11 @@ SIMPLE_LOCATOR_PATH_ELT(InstanceType)
 /// Also contains the generic parameter type itself.
 CUSTOM_LOCATOR_PATH_ELT(GenericParameter)
 
+/// The former wrappedValue type for a property wrapper.
+///
+/// Must equal the property declaration's property wrapper type.
+CUSTOM_LOCATOR_PATH_ELT(WrappedValue)
+
 /// A component of a key path.
 CUSTOM_LOCATOR_PATH_ELT(KeyPathComponent)
 

lib/Sema/ConstraintLocator.cpp

@@ -60,6 +60,7 @@ unsigned LocatorPathElt::getNewSummaryFlags() const {
   case ConstraintLocator::DynamicType:
   case ConstraintLocator::SubscriptMember:
   case ConstraintLocator::OpenedGeneric:
+  case ConstraintLocator::WrappedValue:
   case ConstraintLocator::GenericParameter:
   case ConstraintLocator::GenericArgument:
   case ConstraintLocator::NamedTupleElement:
@@ -188,6 +189,10 @@ bool ConstraintLocator::isForGenericParameter() const {
   return isLastElement<LocatorPathElt::GenericParameter>();
 }
 
+bool ConstraintLocator::isForWrappedValue() const {
+  return isLastElement<LocatorPathElt::WrappedValue>();
+}
+
 bool ConstraintLocator::isForSequenceElementType() const {
   return isLastElement<LocatorPathElt::SequenceElementType>();
 }
@@ -218,6 +223,11 @@ GenericTypeParamType *ConstraintLocator::getGenericParameter() const {
       castLastElementTo<LocatorPathElt::GenericParameter>().getType() : nullptr;
 }
 
+TypeBase *ConstraintLocator::getWrappedValue() const {
+  return isForWrappedValue() ?
+      castLastElementTo<LocatorPathElt::WrappedValue>().getType() : nullptr;
+}
+
 void ConstraintLocator::dump(SourceManager *sm) const {
   dump(sm, llvm::errs());
   llvm::errs() << "\n";
@@ -270,6 +280,12 @@ void ConstraintLocator::dump(SourceManager *sm, raw_ostream &out) const {
       out << "generic parameter '" << gpElt.getType()->getString(PO) << "'";
       break;
     }
+    case WrappedValue: {
+      auto wrappedValueElt = elt.castTo<LocatorPathElt::WrappedValue>();
+      out << "composed property wrapper type '"
+      << wrappedValueElt.getType()->getString(PO) << "'";
+      break;
+    }
     case ApplyArgument:
       out << "apply argument";
       break;