Merge pull request #11160 from CodaFi/youre-gonna-like-the-way-you-invoke

Author: swift-ci

lib/SIL/SILFunctionType.cpp

@@ -477,8 +477,8 @@ enum class ConventionsKind : uint8_t {
       }
     }
 
-    void visitSelfType(AbstractionPattern origType, CanType substType,
-                       SILFunctionTypeRepresentation rep) {
+    void visitSharedType(AbstractionPattern origType, CanType substType,
+                         SILFunctionTypeRepresentation rep) {
       NextOrigParamIndex++;
 
       auto &substTL =
@@ -548,16 +548,29 @@ enum class ConventionsKind : uint8_t {
                                                    /*canonicalVararg*/true)
                         ->getCanonicalType();
         CanTupleType tty = dyn_cast<TupleType>(ty);
-        if (!tty || (origType.isTypeParameter() && !tty->hasInOutElement())) {
-          visit(origType, ty);
-          return;
-        }
-        
         // If the abstraction pattern is opaque, and the tuple type is
         // materializable -- if it doesn't contain an l-value type -- then it's
         // a valid target for substitution and we should not expand it.
+        if (!tty || (origType.isTypeParameter() && !tty->hasInOutElement())) {
+          auto flags = (params.size() == 1)
+                     ? params.front().getParameterFlags()
+                     : ParameterTypeFlags();
+          if (flags.isShared()) {
+            visitSharedType(origType, ty, extInfo.getSILRepresentation());
+          } else {
+            visit(origType, ty);
+          }
+          return;
+        }
+
         for (auto i : indices(tty.getElementTypes())) {
-          visit(origType.getTupleElementType(i), tty.getElementType(i));
+          if (tty->getElement(i).getParameterFlags().isShared()) {
+            visitSharedType(origType.getTupleElementType(i),
+                            tty.getElementType(i),
+                            extInfo.getSILRepresentation());
+          } else {
+            visit(origType.getTupleElementType(i), tty.getElementType(i));
+          }
         }
         return;
       }
@@ -569,15 +582,19 @@ enum class ConventionsKind : uint8_t {
         CanType ty =  params[i].getType();
         CanTupleType tty = dyn_cast<TupleType>(ty);
         AbstractionPattern eltPattern = origType.getTupleElementType(i);
+        // If the abstraction pattern is opaque, and the tuple type is
+        // materializable -- if it doesn't contain an l-value type -- then it's
+        // a valid target for substitution and we should not expand it.
         if (!tty || (eltPattern.isTypeParameter() && !tty->hasInOutElement())) {
-          visit(eltPattern, ty);
+          if (params[i].getParameterFlags().isShared()) {
+            visitSharedType(eltPattern, ty, extInfo.getSILRepresentation());
+          } else {
+            visit(eltPattern, ty);
+          }
           continue;
         }
 
         assert(eltPattern.isTuple());
-        // If the abstraction pattern is opaque, and the tuple type is
-        // materializable -- if it doesn't contain an l-value type -- then it's
-        // a valid target for substitution and we should not expand it.
         for (unsigned j = 0; j < eltPattern.getNumTupleElements(); ++j) {
           visit(eltPattern.getTupleElementType(j), tty.getElementType(j));
         }
@@ -586,9 +603,9 @@ enum class ConventionsKind : uint8_t {
       // Process the self parameter.  Note that we implicitly drop self
       // if this is a static foreign-self import.
       if (!Foreign.Self.isImportAsMember()) {
-        visitSelfType(origType.getTupleElementType(numNonSelfParams),
-                      params[numNonSelfParams].getType(),
-                      extInfo.getSILRepresentation());
+        visitSharedType(origType.getTupleElementType(numNonSelfParams),
+                        params[numNonSelfParams].getType(),
+                        extInfo.getSILRepresentation());
       }
 
       // Clear the foreign-self handler for safety.

lib/SIL/TypeLowering.cpp

@@ -118,8 +118,9 @@ CaptureKind TypeConverter::getDeclCaptureKind(CapturedValue capture) {
       // If this is a non-address-only stored 'let' constant, we can capture it
       // by value.  If it is address-only, then we can't load it, so capture it
       // by its address (like a var) instead.
-      if (var->isLet() && (!SILModuleConventions(M).useLoweredAddresses() ||
-                           !getTypeLowering(var->getType()).isAddressOnly()))
+      if ((var->isLet() || var->isShared())
+          && (!SILModuleConventions(M).useLoweredAddresses() ||
+              !getTypeLowering(var->getType()).isAddressOnly()))
         return CaptureKind::Constant;
 
       // In-out parameters are captured by address.

test/Constraints/closures.swift

@@ -29,6 +29,25 @@ struct X2 {
 
 _ = f0(X2(), {$0.g()})
 
+// Closures with inout arguments and '__shared' conversions.
+
+func inoutToSharedConversions() {
+  func fooOW<T, U>(_ f : (__owned T) -> U) {}
+  fooOW({ (x : Int) in return Int(5) }) // '__owned'-to-'__owned' allowed
+  fooOW({ (x : __shared Int) in return Int(5) }) // '__shared'-to-'__owned' allowed
+  fooOW({ (x : inout Int) in return Int(5) }) // expected-error {{cannot convert value of type '(inout Int) -> Int' to expected argument type '(_) -> _'}}
+  
+  func fooIO<T, U>(_ f : (inout T) -> U) {}
+  fooIO({ (x : inout Int) in return Int(5) }) // 'inout'-to-'inout' allowed
+  fooIO({ (x : __shared Int) in return Int(5) }) // expected-error {{cannot convert value of type '(__shared Int) -> Int' to expected argument type '(inout _) -> _'}}
+  fooIO({ (x : Int) in return Int(5) }) // expected-error {{cannot convert value of type '(inout Int) -> Int' to expected argument type '(inout _) -> _'}}
+
+  func fooSH<T, U>(_ f : (__shared T) -> U) {}
+  fooSH({ (x : __shared Int) in return Int(5) }) // '__shared'-to-'__shared' allowed
+  fooSH({ (x : inout Int) in return Int(5) }) // expected-error {{cannot convert value of type '(inout Int) -> Int' to expected argument type '(__shared _) -> _'}}
+  fooSH({ (x : Int) in return Int(5) }) // '__owned'-to-'__shared' allowed
+}
+
 // Autoclosure
 func f1(f: @autoclosure () -> Int) { }
 func f2() -> Int { }