[WIP] DiagnoseLifetimeDependence pass

Prototype diagnostic pass to bootstrap lifetime-dependence
infrastructure in Swifty SIL.

Author: atrick

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/CMakeLists.txt

@@ -13,6 +13,7 @@ swift_compiler_sources(Optimizer
   ComputeEscapeEffects.swift
   ComputeSideEffects.swift
   DeadStoreElimination.swift
+  DiagnoseLifetimeDependence.swift
   InitializeStaticGlobals.swift
   LetPropertyLowering.swift
   ObjectOutliner.swift

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/DiagnoseLifetimeDependence.swift

@@ -88,6 +88,7 @@ private func registerSwiftPasses() {
   registerPass(deadStoreElimination, { deadStoreElimination.run($0) })
   registerPass(redundantLoadElimination, { redundantLoadElimination.run($0) })
   registerPass(earlyRedundantLoadElimination, { earlyRedundantLoadElimination.run($0) })
+  registerPass(diagnoseLifetimeDependencePass, { diagnoseLifetimeDependencePass.run($0) })
 
   // Instruction passes
   registerForSILCombine(BeginCOWMutationInst.self, { run(BeginCOWMutationInst.self, $0) })

SwiftCompilerSources/Sources/Optimizer/PassManager/PassRegistration.swift

@@ -10,6 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+import AST
 import SIL
 import OptimizerBridging
 

SwiftCompilerSources/Sources/Optimizer/Utilities/OptUtils.swift

@@ -884,5 +884,16 @@ WARNING(call_site_consumption_yields_race, none,
 NOTE(possible_racy_access_site, none,
      "access here could race", ())
 
+ERROR(lifetime_value_outside_scope, none,
+      "lifetime-dependent value escapes its scope", ())
+ERROR(lifetime_variable_outside_scope, none,
+      "lifetime-dependent variable '%0' escapes its scope", (Identifier))
+NOTE(lifetime_outside_scope_parent, none,
+     "it depends on the lifetime of this parent value", ())
+NOTE(lifetime_outside_scope_use, none,
+     "this use of the lifetime-dependent value is out of scope", ())
+NOTE(lifetime_outside_scope_escape, none,
+     "this use causes the lifetime-dependent value to escape", ())
+
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

include/swift/AST/DiagnosticsSIL.def

@@ -192,6 +192,8 @@ PASS(DiagnoseInfiniteRecursion, "diagnose-infinite-recursion",
      "Diagnose Infinitely-Recursive Code")
 PASS(DiagnoseInvalidEscapingCaptures, "diagnose-invalid-escaping-captures",
      "Diagnose Invalid Escaping Captures")
+SWIFT_FUNCTION_PASS(DiagnoseLifetimeDependence, "diagnose-lifetime-dependence",
+     "Diagnose Lifetime Dependence")
 PASS(DiagnoseLifetimeIssues, "diagnose-lifetime-issues",
      "Diagnose Lifetime Issues")
 PASS(DiagnoseStaticExclusivity, "diagnose-static-exclusivity",

include/swift/SILOptimizer/PassManager/Passes.def

@@ -117,6 +117,7 @@ static void addDefiniteInitialization(SILPassPipelinePlan &P) {
 static void addMandatoryDiagnosticOptPipeline(SILPassPipelinePlan &P) {
   P.startPipeline("Mandatory Diagnostic Passes + Enabling Optimization Passes");
   P.addDiagnoseInvalidEscapingCaptures();
+  P.addDiagnoseLifetimeDependence();
   P.addReferenceBindingTransform();
   P.addDiagnoseStaticExclusivity();
   P.addNestedSemanticFunctionCheck();

lib/SILOptimizer/PassManager/PassPipeline.cpp

@@ -0,0 +1,92 @@
+// RUN: %target-swift-frontend -module-name test -emit-sil %s -o /dev/null -verify
+
+public class C {
+  public let i: Int64
+
+  init() {
+    self.i = 0
+  }
+}
+
+@_nonEscapable public struct NoEscStructI {
+  public let i: Int64
+
+  @_unsafeNonEscapableResult
+  init() {
+    self.i = 0
+  }
+
+  @_unsafeNonEscapableResult
+  static func make() -> NoEscStructI {
+    return NoEscStructI()
+  }
+}
+
+@_nonEscapable public struct NoEscStructC {
+  public let c: C
+
+  // FIXME: resultDependsOn
+  @_unsafeNonEscapableResult
+  init(c: C) {
+    self.c = c
+  }
+}
+
+@_nonEscapable public class NoEscClass {
+  @_unsafeNonEscapableResult
+  init() {}
+}
+
+// =============================================================================
+// Expected Pass
+
+// -----------------------------------------------------------------------------
+// NonEscapingScope.orphan
+
+// Returns trivial 'nes.i', which is not an escape.
+//
+// ### Diagnosing lifetime dependence on scope: orphan(  %2 = apply %1(%0) : $@convention(method) (@thin NES.Type) -> NES
+func createNoEscStructI() -> Int64 {
+  let nes = NoEscStructI.make()
+  return nes.i
+}
+
+// -----------------------------------------------------------------------------
+// NonEscapingScope.caller
+
+// Returns a nontrivial member, which is an escape.
+//
+func createArgNoEscStructCArg(c: C) -> C {
+  let nes = NoEscStructC(c: c)
+  return nes.c
+}
+
+func passNoEscStructI(nes: NoEscStructI) -> Int64 {
+  return nes.i
+}
+
+func passNoEscStructILet(nes: NoEscStructI) -> Int64 {
+  let nes = nes
+  return nes.i
+}
+
+// =============================================================================
+// Expected Fail
+
+// -----------------------------------------------------------------------------
+// NonEscapingScope.orphan
+
+// Escapes a new non-escapable orphan.
+//
+func createNoEscStructIReturn() -> NoEscStructI {
+  return NoEscStructI.make() // expected-error {{lifetime-dependent value escapes its scope}}
+  // expcted-note @-1 {{this use of the lifetime-dependent value is out of scope}}
+}
+
+// Escapes a new non-escapable orphan.
+//
+// FIXME: diagnostic should be escapes its scope
+func createNoEscStructILetReturn() -> NoEscStructI {
+  let nes = NoEscStructI.make() 
+  return nes
+}

test/SILOptimizer/diagnose_lifetime_dependence.swift

@@ -0,0 +1,117 @@
+// RUN: %target-swift-frontend -module-name test -emit-sil %s -o /dev/null -verify
+
+// REQUIRES: diagnose_lifetime_dependence
+
+public class C {
+  public let i: Int64
+
+  init() {
+    self.i = 0
+  }
+}
+
+@_nonEscapable public struct NoEscStructI {
+  public let i: Int64
+
+  @_unsafeNonEscapableResult
+  init() {
+    self.i = 0
+  }
+
+  @_unsafeNonEscapableResult
+  static func make() -> NoEscStructI {
+    return NoEscStructI()
+  }
+}
+
+@_nonEscapable public struct NoEscStructC {
+  public let c: C
+
+  // FIXME: resultDependsOn
+  @_unsafeNonEscapableResult
+  init(c: C) {
+    self.c = c
+  }
+}
+
+@_nonEscapable public class NoEscClass {
+  @_unsafeNonEscapableResult
+  init() {}
+}
+
+// =============================================================================
+// Unexpected Pass
+
+// -----------------------------------------------------------------------------
+// NonEscapingScope.caller
+
+func passNoEscStructIReturn(nes: NoEscStructI) -> NoEscStructI {
+  return nes
+}
+
+// =============================================================================
+// Expected Fail - Incorrect Diagnostic
+
+// FIXME: do not consider the assigns escapes. Only the return escapes.
+func createNoEscStructIVarReturn() -> NoEscStructI {
+  var nes = NoEscStructI.make() // expected-error {{lifetime-dependent value escapes its scope}}
+  // expcted-note @-1 {{this use causes the lifetime-dependent value to escape}}
+  nes = NoEscStructI.make() // expected-error {{lifetime-dependent value escapes its scope}}
+  // expcted-note @-1 {{this use causes the lifetime-dependent value to escape}}
+  return nes
+}
+
+// =============================================================================
+// Unexpected Fail
+
+// -----------------------------------------------------------------------------
+// NonEscapingScope.orphan
+
+// Returns trivial 'nes.i', which is not an escape.
+//
+// FIXME: do not consider the assigns escapes
+func createNoEscStructIVar() -> Int64 {
+  var nes = NoEscStructI.make()
+  nes = NoEscStructI.make()
+  return nes.i
+}
+
+// -----------------------------------------------------------------------------
+// NonEscapingScope.caller
+
+// FIXME: do not consider the assigns escapes
+func passNoEscStructIVar(nes: inout NoEscStructI) -> Int64 {
+  nes = NoEscStructI.make()
+  return nes.i
+}
+
+// -----------------------------------------------------------------------------
+// NonEscapingScope.owned
+
+// 'c' is an owned scope.
+// 'nes.c' is used within 'c'.
+//
+// FIXME: nec.c.i should not be an escaping use.
+func createNewNoEscStructC() -> Int64 {
+  let c = C()
+  let nes = NoEscStructC(c: c)
+  return nes.c.i
+}
+
+// 'c' is an owned scope.
+// 'nes.c' escapes via return.
+func createNewNoEscStructCReturn() -> C {
+  let c = C()
+  let nes = NoEscStructC(c: c)
+  return nes.c
+}
+
+// -----------------------------------------------------------------------------
+// NonEscapingScope.scoped
+
+func createNoEscStructCAccess() -> C {
+  var c = C()
+  _ = { c = C() }
+  let nes = NoEscStructC(c: c)
+  return nes.c
+}