[NFC] Resolved merge conflict in CSSimplify.cpp after making changes to improve error handling for composed wrapped value mismatches

Author: Strieker

include/swift/AST/DiagnosticsSema.def

@@ -5678,8 +5678,8 @@ ERROR(wrapped_value_mismatch, none,
       "property type %0 does not match 'wrappedValue' type %1",
       (Type, Type))
 ERROR(composed_property_wrapper_mismatch, none,
-      "composed wrapper type %0 does not match the type of %1.wrappedValue, which is %2",
-      (Type, Type, Type))
+      "composed wrapper type %0 does not match type of '%1.wrappedValue', which is %2",
+      (Type, StringRef, Type))
 
 ERROR(property_wrapper_type_access,none,
       "%select{%select{variable|constant}0|property}1 "

include/swift/Sema/CSFix.h

@@ -322,10 +322,11 @@ enum class FixKind : uint8_t {
   /// even though result type of the reference doesn't conform
   /// to an expected protocol.
   AllowInvalidStaticMemberRefOnProtocolMetatype,
-    
-  /// Allow the wrappedValue type of the outermost property
-  /// wrapper of a composed property wrapper to mismatch
-  /// the type of its innermost property wrapper.
+
+  /// Allow the wrappedValue type of any property wrapper that is a
+  /// part of a composed property wrapper to mismatch the type of
+  /// another property wrapper that is a part of the same composed
+  /// property wrapper.
   AllowWrappedValueMismatch,
 };
 

include/swift/Sema/ConstraintLocator.h

@@ -212,9 +212,10 @@ 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.
+  /// Determine whether this locator points to any of the
+  /// property wrappers' types for a given composed property
+  /// wrapper, with the exception of the innermost property wrapper's
+  /// type.
   bool isForWrappedValue() const;
 
   /// Determine whether this locator points to the element type of a
@@ -360,10 +361,11 @@ 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;
+
+  /// If this locator points to any of the property wrappers' types
+  /// for a given composed property wrapper, with the exception
+  /// of the innermost property wrapper's type.
+  Type getWrappedValue() const;
 
   /// Produce a profile of this locator, for use in a folding set.
   static void Profile(llvm::FoldingSetNodeID &id, ASTNode anchor,
@@ -703,13 +705,12 @@ class LocatorPathElt::GenericParameter final : public StoredPointerElement<Gener
 
 class LocatorPathElt::WrappedValue final : public StoredPointerElement<TypeBase> {
 public:
-  WrappedValue(TypeBase *type)
-      : StoredPointerElement(PathElementKind::WrappedValue, type) {
+  WrappedValue(Type type)
+      : StoredPointerElement(PathElementKind::WrappedValue, type.getPointer()) {
+    assert(type.getPointer() != nullptr);
   }
 
-  TypeBase *getType() const {
-    return getStoredPointer();
-  }
+  Type getType() const { return getStoredPointer(); }
 
   static bool classof(const LocatorPathElt *elt) {
     return elt->getKind() == PathElementKind::WrappedValue;

include/swift/Sema/ConstraintLocatorPathElts.def

@@ -96,7 +96,7 @@ 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.
+/// The wrappedValue type for a property wrapper.
 ///
 /// Must equal the property declaration's property wrapper type.
 CUSTOM_LOCATOR_PATH_ELT(WrappedValue)

lib/Sema/CSDiagnostics.cpp

@@ -350,9 +350,10 @@ bool RequirementFailure::isStaticOrInstanceMember(const ValueDecl *decl) {
 
 bool WrappedValueMismatch::diagnoseAsError() {
   auto *locator = getLocator();
-  auto elt = locator->getLastElementAs<LocatorPathElt::WrappedValue>();
+  auto elt = locator->castLastElementTo<LocatorPathElt::WrappedValue>();
 
-  emitDiagnostic(diag::composed_property_wrapper_mismatch, resolveType(getFromType()), elt->getType(), getToType());
+  emitDiagnostic(diag::composed_property_wrapper_mismatch, getFromType(),
+                 resolveType(elt.getType())->getString(), getToType());
 
   return true;
 }

lib/Sema/CSFix.cpp

@@ -374,7 +374,7 @@ ContextualMismatch *ContextualMismatch::create(ConstraintSystem &cs, Type lhs,
 
 bool AllowWrappedValueMismatch::diagnose(const Solution &solution, bool asError) const {
   WrappedValueMismatch failure(solution, getFromType(), getToType(), getLocator());
-  return(failure.diagnoseAsError());
+  return failure.diagnoseAsError();
 }
 
 AllowWrappedValueMismatch *AllowWrappedValueMismatch::create(ConstraintSystem &cs,

lib/Sema/CSGen.cpp

@@ -3613,7 +3613,7 @@ static bool generateWrappedPropertyTypeConstraints(
     } else {
       // The former wrappedValue type must be equal to the current wrapper type
       auto *locator = cs.getConstraintLocator(
-          typeExpr, LocatorPathElt::WrappedValue(wrapperType.getPointer()));
+          typeExpr, LocatorPathElt::WrappedValue(wrapperType));
       wrapperType =
           cs.replaceInferableTypesWithTypeVars(rawWrapperType, locator);
       cs.addConstraint(ConstraintKind::Equal, wrapperType, wrappedValueType, locator);

lib/Sema/CSSimplify.cpp

@@ -11260,6 +11260,7 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyFixConstraint(
   case FixKind::AllowUnsupportedRuntimeCheckedCast:
   case FixKind::AllowAlwaysSucceedCheckedCast:
   case FixKind::AllowInvalidStaticMemberRefOnProtocolMetatype:
+  case FixKind::AllowWrappedValueMismatch:
   case FixKind::RemoveExtraneousArguments: {
     return recordFix(fix) ? SolutionKind::Error : SolutionKind::Solved;
   }
@@ -11397,11 +11398,6 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyFixConstraint(
 
     return SolutionKind::Solved;
   }
-          
-  case FixKind::AllowWrappedValueMismatch: {
-    if (recordFix(fix)) return SolutionKind::Error;
-      return SolutionKind::Solved;
-  }
 
   case FixKind::UseSubscriptOperator:
   case FixKind::ExplicitlyEscaping:

lib/Sema/ConstraintLocator.cpp

@@ -223,9 +223,10 @@ GenericTypeParamType *ConstraintLocator::getGenericParameter() const {
       castLastElementTo<LocatorPathElt::GenericParameter>().getType() : nullptr;
 }
 
-TypeBase *ConstraintLocator::getWrappedValue() const {
-  return isForWrappedValue() ?
-      castLastElementTo<LocatorPathElt::WrappedValue>().getType() : nullptr;
+Type ConstraintLocator::getWrappedValue() const {
+  return isForWrappedValue()
+             ? castLastElementTo<LocatorPathElt::WrappedValue>().getType()
+             : Type();
 }
 
 void ConstraintLocator::dump(SourceManager *sm) const {
@@ -283,7 +284,7 @@ void ConstraintLocator::dump(SourceManager *sm, raw_ostream &out) const {
     case WrappedValue: {
       auto wrappedValueElt = elt.castTo<LocatorPathElt::WrappedValue>();
       out << "composed property wrapper type '"
-      << wrappedValueElt.getType()->getString(PO) << "'";
+          << wrappedValueElt.getType()->getString(PO) << "'";
       break;
     }
     case ApplyArgument:

test/decl/var/property_wrappers.swift

@@ -1097,9 +1097,9 @@ struct TestComposition {
   @WrapperD<WrapperC, Int, String> @WrapperC var p4: Int?
   @WrapperD<WrapperC, Int, String> @WrapperE var p5: Int // expected-error{{generic parameter 'Value' could not be inferred}}
     // expected-note@-1 {{explicitly specify the generic arguments to fix this issue}}
-    // expected-error@-2 {{composed wrapper type 'WrapperE<Int>' does not match the type of 'WrapperD<WrapperC<_>, Int, String>'.wrappedValue, which is 'WrapperC<Value>'}}
+    // expected-error@-2 {{composed wrapper type 'WrapperE<Int>' does not match type of 'WrapperD<WrapperC<Value>, Int, String>.wrappedValue', which is 'WrapperC<Value>'}}
 
-  @Wrapper<String> @Wrapper var value: Int // expected-error{{composed wrapper type 'Wrapper<Int>' does not match the type of 'Wrapper<String>'.wrappedValue, which is 'String'}}
+  @Wrapper<String> @Wrapper var value: Int // expected-error{{composed wrapper type 'Wrapper<Int>' does not match type of 'Wrapper<String>.wrappedValue', which is 'String'}}
 
 	func triggerErrors(d: Double) { // expected-note 6 {{mark method 'mutating' to make 'self' mutable}} {{2-2=mutating }}
 		p1 = d // expected-error{{cannot assign value of type 'Double' to type 'Int?'}} {{8-8=Int(}} {{9-9=)}}