LifetimeDependenceDiagnostics: note for unsupported closure capture

Add a note explaining that dependence on closure captures is not
supported. Otherwise, the diagnostics are very confusing:
"it depends on a closure capture; this is not yet supported"

Author: atrick

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/LifetimeDependenceDiagnostics.swift

@@ -274,7 +274,9 @@ private struct DiagnoseDependence {
     // function's source location is sufficient for argument diagnostics, but if the function has no location, don't
     // report any scope.
     if parentVar.isArgument, let argLoc = parentVar.sourceLoc ?? function.location.sourceLoc {
-      if let parentName = parentVar.name {
+      if parentVar.isClosureCapture {
+        diagnose(argLoc, .lifetime_outside_scope_capture)
+      } else if let parentName = parentVar.name {
         diagnose(argLoc, .lifetime_outside_scope_argument, parentName)
       } else {
         diagnose(argLoc, .lifetime_outside_scope_synthesized_argument, parentVar.accessorKind ?? function.name)
@@ -298,8 +300,9 @@ private struct DiagnoseDependence {
 private struct LifetimeVariable {
   var varDecl: VarDecl? = nil
   var sourceLoc: SourceLoc? = nil
-  var isArgument: Bool = false
   var isAccessScope: Bool = false
+  var isArgument: Bool = false
+  var isClosureCapture: Bool = false
   var accessorKind: String?
   var thunkKind: Function.ThunkKind = .noThunk
 
@@ -338,10 +341,11 @@ private struct LifetimeVariable {
   }
 
   private init(introducer: Value, _ context: some Context) {
-    if let arg = introducer as? Argument {
+    if let arg = introducer as? FunctionArgument {
       self.varDecl = arg.varDecl
       self.sourceLoc = arg.sourceLoc
       self.isArgument = true
+      self.isClosureCapture = arg.isClosureCapture
       return
     }
     if let varDecl = introducer.definingInstruction?.findVarDecl() {

SwiftCompilerSources/Sources/SIL/Argument.swift

@@ -61,6 +61,10 @@ final public class FunctionArgument : Argument {
     bridged.FunctionArgument_isLexical()
   }
 
+  public var isClosureCapture: Bool {
+    bridged.FunctionArgument_isClosureCapture()
+  }
+
   public var isSelf: Bool {
     parentFunction.argumentConventions.selfIndex == index
   }

include/swift/AST/DiagnosticsSIL.def

@@ -1183,6 +1183,8 @@ NOTE(lifetime_outside_scope_variable, none,
      "it depends on the lifetime of variable '%0'", (Identifier))
 NOTE(lifetime_outside_scope_value, none,
      "it depends on the lifetime of this parent value", ())
+NOTE(lifetime_outside_scope_capture, none,
+     "it depends on a closure capture; this is not yet supported", ())
 NOTE(lifetime_outside_scope_use, none,
      "this use of the lifetime-dependent value is out of scope", ())
 NOTE(lifetime_outside_scope_escape, none,

include/swift/SIL/SILBridging.h

@@ -897,6 +897,7 @@ struct BridgedArgument {
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedBasicBlock getParent() const;
   BRIDGED_INLINE bool isReborrow() const;
   BRIDGED_INLINE bool FunctionArgument_isLexical() const;
+  BRIDGED_INLINE bool FunctionArgument_isClosureCapture() const;
   BRIDGED_INLINE void setReborrow(bool reborrow) const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE OptionalBridgedDeclObj getVarDecl() const;
   BRIDGED_INLINE void copyFlags(BridgedArgument fromArgument) const;

include/swift/SIL/SILBridgingImpl.h

@@ -588,6 +588,11 @@ bool BridgedArgument::FunctionArgument_isLexical() const {
   return llvm::cast<swift::SILFunctionArgument>(getArgument())->getLifetime().isLexical();
 }
 
+bool BridgedArgument::FunctionArgument_isClosureCapture() const {
+  return llvm::cast<swift::SILFunctionArgument>(
+    getArgument())->isClosureCapture();
+}
+
 OptionalBridgedDeclObj BridgedArgument::getVarDecl() const {
   return {llvm::dyn_cast_or_null<swift::VarDecl>(getArgument()->getDecl())};
 }

test/SILOptimizer/lifetime_dependence/verify_diagnostics.swift

@@ -124,3 +124,35 @@ public struct NoncopyableImplicitAccessors : ~Copyable & ~Escapable {
     }
   }
 }
+
+struct HasMethods {
+  @lifetime(borrow self)
+  func data(index: Int) -> NEImmortal {
+    NEImmortal()
+  }
+}
+
+func testClosureCapture1(_ a: HasMethods) {
+  let fn = a.data
+  // expected-error @-1{{lifetime-dependent value escapes its scope}}
+  // expected-note  @-2{{it depends on a closure capture; this is not yet supported}}
+  // expected-note  @-3{{this use causes the lifetime-dependent value to escape}}
+  _ = consume fn
+
+  let fn2 = a.data(index:)
+  // expected-error @-1{{lifetime-dependent value escapes its scope}}
+  // expected-note  @-2{{it depends on a closure capture; this is not yet supported}}
+  // expected-note  @-3{{this use causes the lifetime-dependent value to escape}}
+  _ = consume fn2
+
+  // FIXME: rdar://150073405 ([SILGen] support synthesized _modify on top of borrowed getters with library evolution)
+  //
+  // withUnsafePointer is disabled because it generates a reabstraction thunk, which is impossible to diagenose.
+  /*
+  withUnsafePointer(to: a.data) { fptr in
+    // future-error @-1{{lifetime-dependent value escapes its scope}}
+    // future-note  @-2{{it depends on a closure capture; this is not yet supported}}
+    // future-note  @-3{{this use causes the lifetime-dependent value to escape}}
+    }
+   */
+}