Adjust for inout diagnostics and fall back to original mutation strategy

phausler · phausler · commit 51fec5bda7d1 · 2021-01-12T10:58:53.000-08:00
diff --git a/include/swift/AST/DiagnosticsSema.def b/include/swift/AST/DiagnosticsSema.def
@@ -4054,6 +4054,8 @@ NOTE(because_rethrows_argument_throws,none,
 NOTE(because_rethrows_default_argument_throws,none,
      "call is to 'rethrows' function, but a defaulted argument function"
      " can throw", ())
+NOTE(because_rethrows_default_conformance_throws,none,
+     "call is to 'rethrows' function, but a conformance can throw", ())
 
 ERROR(throwing_call_in_nonthrowing_autoclosure,none,
       "call can throw, but it is executed in a non-throwing "
diff --git a/lib/IRGen/IRGenSIL.cpp b/lib/IRGen/IRGenSIL.cpp
@@ -4360,7 +4360,7 @@ void IRGenSILFunction::visitDebugValueAddrInst(DebugValueAddrInst *i) {
         break;
     }
     assert(llvm::isa<llvm::Argument>(Storage) &&
-           "arg expected to be load from inside %swift.context");
+           "arg expected to be load from inside swift.context");
 #endif
     Indirection = CoroIndirectValue;
   }
diff --git a/lib/Sema/TypeCheckConcurrency.cpp b/lib/Sema/TypeCheckConcurrency.cpp
@@ -965,6 +965,8 @@ namespace {
 
       Expr *subArg = arg->getSubExpr();
       ValueDecl *valueDecl = nullptr;
+      if (auto binding = dyn_cast<BindOptionalExpr>(subArg))
+        subArg = binding->getSubExpr();
       if (LookupExpr *baseArg = dyn_cast<LookupExpr>(subArg)) {
         while (LookupExpr *nextLayer = dyn_cast<LookupExpr>(baseArg->getBase()))
           baseArg = nextLayer;
diff --git a/lib/Sema/TypeCheckEffects.cpp b/lib/Sema/TypeCheckEffects.cpp
@@ -309,6 +309,10 @@ class PotentialThrowReason {
     /// The function is 'rethrows', and it was passed a default
     /// argument that was not rethrowing-only in this context.
     CallRethrowsWithDefaultThrowingArgument,
+
+    /// The the function is 'rethrows', and it is a member that
+    /// is a conformance to a rethrowing protocol.
+    CallRethrowsWithConformance,
   };
 
   static StringRef kindToString(Kind k) {
@@ -320,6 +324,8 @@ class PotentialThrowReason {
         return "CallRethrowsWithExplicitThrowingArgument";
       case Kind::CallRethrowsWithDefaultThrowingArgument: 
         return "CallRethrowsWithDefaultThrowingArgument";
+      case Kind::CallRethrowsWithConformance:
+        return "CallRethrowsWithConformance";
     }
   }
 
@@ -337,6 +343,11 @@ class PotentialThrowReason {
   static PotentialThrowReason forDefaultArgument() {
     return PotentialThrowReason(Kind::CallRethrowsWithDefaultThrowingArgument);
   }
+  static PotentialThrowReason forRethrowsConformance(Expr *E) {
+    PotentialThrowReason result(Kind::CallRethrowsWithConformance);
+    result.TheExpression = E;
+    return result;
+  }
   static PotentialThrowReason forThrowingApply() {
     return PotentialThrowReason(Kind::CallThrows);
   }
@@ -353,7 +364,8 @@ class PotentialThrowReason {
   bool isThrow() const { return getKind() == Kind::Throw; }
   bool isRethrowsCall() const {
     return (getKind() == Kind::CallRethrowsWithExplicitThrowingArgument ||
-            getKind() == Kind::CallRethrowsWithDefaultThrowingArgument);
+            getKind() == Kind::CallRethrowsWithDefaultThrowingArgument ||
+            getKind() == Kind::CallRethrowsWithConformance);
   }
 
   /// If this was built with forRethrowsArgument, return the expression.
@@ -576,7 +588,7 @@ class ApplyClassifier {
       auto substitutions = fnRef.getDeclRef().getSubstitutions();
       if (classifyWitnessAsThrows(fnRef.getModuleContext(), substitutions)) {
         return Classification::forRethrowingOnly(
-          PotentialThrowReason::forThrowingApply(), isAsync);
+          PotentialThrowReason::forRethrowsConformance(E), isAsync);
       }
     } else if (fnRef.isBodyRethrows() && 
                fnRef.getRethrowingKind() == FunctionRethrowingKind::Throws) {
@@ -1256,6 +1268,9 @@ class Context {
     case PotentialThrowReason::Kind::CallRethrowsWithDefaultThrowingArgument:
       Diags.diagnose(loc, diag::because_rethrows_default_argument_throws);
       return;
+    case PotentialThrowReason::Kind::CallRethrowsWithConformance:
+      Diags.diagnose(loc, diag::because_rethrows_default_conformance_throws);
+      return;
     }
     llvm_unreachable("bad reason kind");
   }
diff --git a/stdlib/public/Concurrency/AsyncCompactMapSequence.swift b/stdlib/public/Concurrency/AsyncCompactMapSequence.swift
@@ -27,17 +27,17 @@ public struct AsyncCompactMapSequence<Upstream, ElementOfResult>: AsyncSequence
   public typealias AsyncIterator = Iterator
   
   public struct Iterator: AsyncIteratorProtocol {
-    var upstreamIterator: Upstream.AsyncIterator?
+    var upstreamIterator: _OptionalAsyncIterator<Upstream.AsyncIterator>
     let transform: (Upstream.Element) async -> ElementOfResult?
     
     init(_ upstreamIterator: Upstream.AsyncIterator, transform: @escaping (Upstream.Element) async -> ElementOfResult?) {
-      self.upstreamIterator = upstreamIterator
+      self.upstreamIterator = _OptionalAsyncIterator(upstreamIterator)
       self.transform = transform
     }
     
     public mutating func next() async rethrows -> ElementOfResult? {
       while true {
-        guard let item = try await upstreamIterator?.next() else {
+        guard let item = try await upstreamIterator.next() else {
           return nil
         }
         if let transformed = await transform(item) {
@@ -47,8 +47,7 @@ public struct AsyncCompactMapSequence<Upstream, ElementOfResult>: AsyncSequence
     }
     
     public mutating func cancel() {
-      upstreamIterator?.cancel()
-      upstreamIterator = nil
+      upstreamIterator.cancel()
     }
   }
   
@@ -70,34 +69,32 @@ public struct AsyncTryCompactMapSequence<Upstream, ElementOfResult>: AsyncSequen
   public typealias AsyncIterator = Iterator
   
   public struct Iterator: AsyncIteratorProtocol {
-    var upstreamIterator: Upstream.AsyncIterator?
+    var upstreamIterator: _OptionalAsyncIterator<Upstream.AsyncIterator>
     let transform: (Upstream.Element) async throws -> ElementOfResult?
     
     init(_ upstreamIterator: Upstream.AsyncIterator, transform: @escaping (Upstream.Element) async throws -> ElementOfResult?) {
-      self.upstreamIterator = upstreamIterator
+      self.upstreamIterator = _OptionalAsyncIterator(upstreamIterator)
       self.transform = transform
     }
     
     public mutating func next() async throws -> ElementOfResult? {
       while true {
-        guard let item = try await upstreamIterator?.next() else {
+        guard let item = try await upstreamIterator.next() else {
           return nil
         }
         do {
           if let transformed = try await transform(item) {
             return transformed
           }
         } catch {
-          upstreamIterator?.cancel()
-          upstreamIterator = nil
+          upstreamIterator.cancel()
           throw error
         }
       }
     }
     
     public mutating func cancel() {
-      upstreamIterator?.cancel()
-      upstreamIterator = nil
+      upstreamIterator.cancel()
     }
   }
   
diff --git a/stdlib/public/Concurrency/AsyncConcatSequence.swift b/stdlib/public/Concurrency/AsyncConcatSequence.swift
@@ -27,27 +27,25 @@ public struct AsyncConcatSequence<Prefix, Suffix>: AsyncSequence where Prefix: A
   public typealias AsyncIterator = Iterator
   
   public struct Iterator: AsyncIteratorProtocol {
-    var prefixIterator: Prefix.AsyncIterator?
-    var suffixIterator: Suffix.AsyncIterator?
+    var prefixIterator: _OptionalAsyncIterator<Prefix.AsyncIterator>
+    var suffixIterator: _OptionalAsyncIterator<Suffix.AsyncIterator>
     
     init(_ prefixIterator: Prefix.AsyncIterator, _ suffixIterator: Suffix.AsyncIterator) {
-      self.prefixIterator = prefixIterator
-      self.suffixIterator = suffixIterator
+      self.prefixIterator = _OptionalAsyncIterator(prefixIterator)
+      self.suffixIterator = _OptionalAsyncIterator(suffixIterator)
     }
     
     public mutating func next() async rethrows -> Prefix.Element? {
-      if let item = try await prefixIterator?.next() {
+      if let item = try await prefixIterator.next() {
         return item
       }
-      prefixIterator = nil
-      return try await suffixIterator?.next()
+      prefixIterator = .none
+      return try await suffixIterator.next()
     }
     
     public mutating func cancel() {
-      prefixIterator?.cancel()
-      prefixIterator = nil
-      suffixIterator?.cancel()
-      suffixIterator = nil
+      prefixIterator.cancel()
+      suffixIterator.cancel()
     }
   }
   
diff --git a/stdlib/public/Concurrency/AsyncDropWhileSequence.swift b/stdlib/public/Concurrency/AsyncDropWhileSequence.swift
@@ -27,17 +27,17 @@ public struct AsyncDropWhileSequence<Upstream>: AsyncSequence where Upstream: As
   public typealias AsyncIterator = Iterator
   
   public struct Iterator: AsyncIteratorProtocol {
-    var upstreamIterator: Upstream.AsyncIterator?
+    var upstreamIterator: _OptionalAsyncIterator<Upstream.AsyncIterator>
     var predicate: ((Element) async -> Bool)?
     
     init(_ upstreamIterator: Upstream.AsyncIterator, predicate: @escaping (Element) async -> Bool) {
-      self.upstreamIterator = upstreamIterator
+      self.upstreamIterator = _OptionalAsyncIterator(upstreamIterator)
       self.predicate = predicate
     }
     
     public mutating func next() async rethrows -> Upstream.Element? {
       while true {
-        guard let item = try await upstreamIterator?.next() else {
+        guard let item = try await upstreamIterator.next() else {
           return nil
         }
         if let predicate = self.predicate {
@@ -52,8 +52,7 @@ public struct AsyncDropWhileSequence<Upstream>: AsyncSequence where Upstream: As
     }
     
     public mutating func cancel() {
-      upstreamIterator?.cancel()
-      upstreamIterator = nil
+      upstreamIterator.cancel()
     }
   }
   
@@ -75,17 +74,17 @@ public struct AsyncTryDropWhileSequence<Upstream>: AsyncSequence where Upstream:
   public typealias AsyncIterator = Iterator
   
   public struct Iterator: AsyncIteratorProtocol {
-    var upstreamIterator: Upstream.AsyncIterator?
+    var upstreamIterator: _OptionalAsyncIterator<Upstream.AsyncIterator>
     var predicate: ((Element) async throws -> Bool)?
     
     init(_ upstreamIterator: Upstream.AsyncIterator, predicate: @escaping (Element) async throws -> Bool) {
-      self.upstreamIterator = upstreamIterator
+      self.upstreamIterator = _OptionalAsyncIterator(upstreamIterator)
       self.predicate = predicate
     }
     
     public mutating func next() async throws -> Upstream.Element? {
       while true {
-        guard let item = try await upstreamIterator?.next() else {
+        guard let item = try await upstreamIterator.next() else {
           return nil
         }
         if let predicate = self.predicate {
@@ -95,8 +94,7 @@ public struct AsyncTryDropWhileSequence<Upstream>: AsyncSequence where Upstream:
               return item
             }
           } catch {
-            upstreamIterator?.cancel()
-            upstreamIterator = nil
+            upstreamIterator.cancel()
             throw error
           }
         } else {
@@ -106,8 +104,7 @@ public struct AsyncTryDropWhileSequence<Upstream>: AsyncSequence where Upstream:
     }
     
     public mutating func cancel() {
-      upstreamIterator?.cancel()
-      upstreamIterator = nil
+      upstreamIterator.cancel()
     }
   }
   
diff --git a/stdlib/public/Concurrency/AsyncFilterSequence.swift b/stdlib/public/Concurrency/AsyncFilterSequence.swift
@@ -30,31 +30,29 @@ public struct AsyncFilterSequence<Upstream>: AsyncSequence where Upstream: Async
   public let predicate: (Element) async -> Bool
   
   public struct Iterator: AsyncIteratorProtocol {
-    var upstreamIterator: Upstream.AsyncIterator?
+    var upstreamIterator: _OptionalAsyncIterator<Upstream.AsyncIterator>
     let predicate: (Element) async -> Bool
     
     init(_ upstreamIterator: Upstream.AsyncIterator,
          predicate: @escaping (Element) async -> Bool
     ) {
-      self.upstreamIterator = upstreamIterator
+      self.upstreamIterator = _OptionalAsyncIterator(upstreamIterator)
       self.predicate = predicate
     }
     
     public mutating func next() async rethrows -> Upstream.Element? {
-      guard let item = try await upstreamIterator?.next() else {
+      guard let item = try await upstreamIterator.next() else {
         return nil
       }
       guard await predicate(item) else {
-      upstreamIterator?.cancel()
-      upstreamIterator = nil
-      return nil
+        upstreamIterator.cancel()
+        return nil
       }
       return item
     }
     
     public mutating func cancel() {
-      upstreamIterator?.cancel()
-      upstreamIterator = nil
+      upstreamIterator.cancel()
     }
   }
   
@@ -76,31 +74,29 @@ public struct AsyncTryFilterSequence<Upstream>: AsyncSequence where Upstream: As
   public let predicate: (Element) async throws -> Bool
   
   public struct Iterator: AsyncIteratorProtocol {
-    var upstreamIterator: Upstream.AsyncIterator?
+    var upstreamIterator: _OptionalAsyncIterator<Upstream.AsyncIterator>
     let predicate: (Element) async throws -> Bool
     
     init(_ upstreamIterator: Upstream.AsyncIterator,
          predicate: @escaping (Element) async throws -> Bool
     ) {
-      self.upstreamIterator = upstreamIterator
+      self.upstreamIterator = _OptionalAsyncIterator(upstreamIterator)
       self.predicate = predicate
     }
     
     public mutating func next() async throws -> Upstream.Element? {
-      guard let item = try await upstreamIterator?.next() else {
+      guard let item = try await upstreamIterator.next() else {
         return nil
       }
       guard try await predicate(item) else {
-      upstreamIterator?.cancel()
-      upstreamIterator = nil
-      return nil
+        upstreamIterator.cancel()
+        return nil
       }
       return item
     }
     
     public mutating func cancel() {
-      upstreamIterator?.cancel()
-      upstreamIterator = nil
+      upstreamIterator.cancel()
     }
   }
   
diff --git a/stdlib/public/Concurrency/AsyncFlatMapSequence.swift b/stdlib/public/Concurrency/AsyncFlatMapSequence.swift
diff --git a/stdlib/public/Concurrency/AsyncIteratorProtocol.swift b/stdlib/public/Concurrency/AsyncIteratorProtocol.swift
diff --git a/stdlib/public/Concurrency/AsyncMapSequence.swift b/stdlib/public/Concurrency/AsyncMapSequence.swift
diff --git a/stdlib/public/Concurrency/AsyncPrefixWhileSequence.swift b/stdlib/public/Concurrency/AsyncPrefixWhileSequence.swift

Original file line number	Diff line number	Diff line change
`@@ -4360,7 +4360,7 @@ void IRGenSILFunction::visitDebugValueAddrInst(DebugValueAddrInst *i) {`
`4360`	`4360`	`break;`
`4361`	`4361`	`}`
`4362`	`4362`	`assert(llvm::isa<llvm::Argument>(Storage) &&`
`4363`		`- "arg expected to be load from inside %swift.context");`
	`4363`	`+ "arg expected to be load from inside swift.context");`
`4364`	`4364`	`#endif`
`4365`	`4365`	`Indirection = CoroIndirectValue;`
`4366`	`4366`	`}`
Original file line number	Diff line number	Diff line change
`@@ -27,17 +27,17 @@ public struct AsyncCompactMapSequence<Upstream, ElementOfResult>: AsyncSequence`
`27`	`27`	`public typealias AsyncIterator = Iterator`
`28`	`28`
`29`	`29`	`public struct Iterator: AsyncIteratorProtocol {`
`30`		`- var upstreamIterator: Upstream.AsyncIterator?`
	`30`	`+ var upstreamIterator: _OptionalAsyncIterator<Upstream.AsyncIterator>`
`31`	`31`	`let transform: (Upstream.Element) async -> ElementOfResult?`
`32`	`32`
`33`	`33`	`init(_ upstreamIterator: Upstream.AsyncIterator, transform: @escaping (Upstream.Element) async -> ElementOfResult?) {`
`34`		`- self.upstreamIterator = upstreamIterator`
	`34`	`+ self.upstreamIterator = _OptionalAsyncIterator(upstreamIterator)`
`35`	`35`	`self.transform = transform`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`public mutating func next() async rethrows -> ElementOfResult? {`
`39`	`39`	`while true {`
`40`		`- guard let item = try await upstreamIterator?.next() else {`
	`40`	`+ guard let item = try await upstreamIterator.next() else {`
`41`	`41`	`return nil`
`42`	`42`	`}`
`43`	`43`	`if let transformed = await transform(item) {`
`@@ -47,8 +47,7 @@ public struct AsyncCompactMapSequence<Upstream, ElementOfResult>: AsyncSequence`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`public mutating func cancel() {`
`50`		`- upstreamIterator?.cancel()`
`51`		`- upstreamIterator = nil`
	`50`	`+ upstreamIterator.cancel()`
`52`	`51`	`}`
`53`	`52`	`}`
`54`	`53`
`@@ -70,34 +69,32 @@ public struct AsyncTryCompactMapSequence<Upstream, ElementOfResult>: AsyncSequen`
`70`	`69`	`public typealias AsyncIterator = Iterator`
`71`	`70`
`72`	`71`	`public struct Iterator: AsyncIteratorProtocol {`
`73`		`- var upstreamIterator: Upstream.AsyncIterator?`
	`72`	`+ var upstreamIterator: _OptionalAsyncIterator<Upstream.AsyncIterator>`
`74`	`73`	`let transform: (Upstream.Element) async throws -> ElementOfResult?`
`75`	`74`
`76`	`75`	`init(_ upstreamIterator: Upstream.AsyncIterator, transform: @escaping (Upstream.Element) async throws -> ElementOfResult?) {`
`77`		`- self.upstreamIterator = upstreamIterator`
	`76`	`+ self.upstreamIterator = _OptionalAsyncIterator(upstreamIterator)`
`78`	`77`	`self.transform = transform`
`79`	`78`	`}`
`80`	`79`
`81`	`80`	`public mutating func next() async throws -> ElementOfResult? {`
`82`	`81`	`while true {`
`83`		`- guard let item = try await upstreamIterator?.next() else {`
	`82`	`+ guard let item = try await upstreamIterator.next() else {`
`84`	`83`	`return nil`
`85`	`84`	`}`
`86`	`85`	`do {`
`87`	`86`	`if let transformed = try await transform(item) {`
`88`	`87`	`return transformed`
`89`	`88`	`}`
`90`	`89`	`} catch {`
`91`		`- upstreamIterator?.cancel()`
`92`		`- upstreamIterator = nil`
	`90`	`+ upstreamIterator.cancel()`
`93`	`91`	`throw error`
`94`	`92`	`}`
`95`	`93`	`}`
`96`	`94`	`}`
`97`	`95`
`98`	`96`	`public mutating func cancel() {`
`99`		`- upstreamIterator?.cancel()`
`100`		`- upstreamIterator = nil`
	`97`	`+ upstreamIterator.cancel()`
`101`	`98`	`}`
`102`	`99`	`}`
`103`	`100`