Merge pull request #63149 from Vespen/fix-non-api-wrapper-parameter

[Sema] Fix for non-API level property wrappers with closure.

Author: xedin

lib/Sema/CSApply.cpp

@@ -1087,7 +1087,7 @@ namespace {
                                 locator);
 
         auto *const calleeParamDecl = calleeParamList->get(idx);
-        if (calleeParamDecl->hasAttachedPropertyWrapper()) {
+        if (calleeParamDecl->hasExternalPropertyWrapper()) {
           // Rewrite the parameter ref to the backing wrapper initialization
           // expression.
           auto &appliedWrapper = appliedPropertyWrappers[appliedWrapperIndex++];

lib/Sema/CSGen.cpp

@@ -4771,7 +4771,6 @@ ConstraintSystem::applyPropertyWrapperToParameter(
     return getTypeMatchSuccess();
   }
 
-  PropertyWrapperInitKind initKind;
   if (argLabel.hasDollarPrefix()) {
     Type projectionType = computeProjectedValueType(param, wrapperType);
     addConstraint(matchKind, paramType, projectionType, locator);
@@ -4782,15 +4781,17 @@ ConstraintSystem::applyPropertyWrapperToParameter(
       setType(param->getPropertyWrapperProjectionVar(), projectionType);
     }
 
-    initKind = PropertyWrapperInitKind::ProjectedValue;
-  } else {
+    appliedPropertyWrappers[anchor].push_back({ wrapperType, PropertyWrapperInitKind::ProjectedValue });
+  } else if (param->hasExternalPropertyWrapper()) {
     Type wrappedValueType = computeWrappedValueType(param, wrapperType);
     addConstraint(matchKind, paramType, wrappedValueType, locator);
-    initKind = PropertyWrapperInitKind::WrappedValue;
     setType(param->getPropertyWrapperWrappedValueVar(), wrappedValueType);
+
+    appliedPropertyWrappers[anchor].push_back({ wrapperType, PropertyWrapperInitKind::WrappedValue });
+  } else {
+    return getTypeMatchFailure(locator);
   }
 
-  appliedPropertyWrappers[anchor].push_back({ wrapperType, initKind });
   return getTypeMatchSuccess();
 }
 

test/Sema/property_wrapper_parameter.swift

@@ -21,6 +21,15 @@ struct Wrapper<T> {
   }
 }
 
+@propertyWrapper
+struct ImplementationDetailWrapper<T> {
+  var wrappedValue: T
+
+  init(wrappedValue: T) {
+    self.wrappedValue = wrappedValue
+  }
+}
+
 func globalFunc(@Wrapper arg: Int) {
   let _: Int = arg
   let _: Projection<Int> = $arg
@@ -36,6 +45,17 @@ func testGlobalFunc(value: Int, projection: Projection<Int>) {
   let _: (Projection<Int>) -> Void = globalFunc($arg:)
 }
 
+func globalFuncWithImplementationDetailWrapper(@ImplementationDetailWrapper arg: Int) {
+  let _: Int = arg
+  let _: ImplementationDetailWrapper<Int> = _arg
+}
+
+func testGlobalFuncWithImplementationDetailWrapper(value: Int) {
+  globalFuncWithImplementationDetailWrapper(arg: value)
+
+  let _: (Int) -> Void = globalFuncWithImplementationDetailWrapper
+  let _: (Int) -> Void = globalFuncWithImplementationDetailWrapper(arg:)
+}
 
 struct S<Value> {
   func method(@Wrapper arg: Value) {
@@ -44,11 +64,21 @@ struct S<Value> {
     let _: Wrapper<Value> = _arg
   }
 
+  func methodWithImplementationDetailWrapper(@ImplementationDetailWrapper arg: Value) {
+    let _: Value = arg
+    let _: ImplementationDetailWrapper<Value> = _arg
+  }
+
   static func staticMethod(@Wrapper arg: Value) {
     let _: Value = arg
     let _: Projection<Value> = $arg
     let _: Wrapper<Value> = _arg
   }
+
+  static func staticMethodWithImplementationDetailWrapper(@ImplementationDetailWrapper arg: Value) {
+    let _: Value = arg
+    let _: ImplementationDetailWrapper<Value> = _arg
+  }
 }
 
 func testMethods(instance: S<String>, Metatype: S<String>.Type,
@@ -76,6 +106,22 @@ func testMethods(instance: S<String>, Metatype: S<String>.Type,
   let _: (S) -> (Projection<String>) -> Void = Metatype.method($arg:)
 }
 
+func testMethodsWithImplementationDetailWrapper(instance: S<String>, Metatype: S<String>.Type,
+                                                @ImplementationDetailWrapper value: String) {
+  Metatype.staticMethodWithImplementationDetailWrapper(arg: value)
+
+  instance.methodWithImplementationDetailWrapper(arg: value)
+
+  let _: (String) -> Void = Metatype.staticMethodWithImplementationDetailWrapper
+  let _: (String) -> Void = Metatype.staticMethodWithImplementationDetailWrapper(arg:)
+
+  let _: (String) -> Void = instance.methodWithImplementationDetailWrapper
+  let _: (String) -> Void = instance.methodWithImplementationDetailWrapper(arg:)
+
+  let _: (S) -> (String) -> Void = Metatype.methodWithImplementationDetailWrapper
+  let _: (S) -> (String) -> Void = Metatype.methodWithImplementationDetailWrapper(arg:)
+}
+
 func testClosures() {
   typealias PropertyWrapperTuple = (Wrapper<Int>, Int, Projection<Int>)
 
@@ -88,6 +134,12 @@ func testClosures() {
   }
 }
 
+func testClosuresWithImplementationDetailWrapper() {
+  let _: (Int) -> (ImplementationDetailWrapper<Int>, Int) = { (@ImplementationDetailWrapper value) in
+    (_value, value)
+  }
+}
+
 func projectionPlaceholder<T>(@Wrapper _ value: T) {}
 
 func testOmittedProjectionLabel(value: Int) {