Add a "lazy" lifetime inference for mutating interface methods

When type checking a .swiftinterface file, Assume that a mutating methods does
not depend on its parameters.  This is unsafe but needed because some
MutableSpan APIs snuck into the standard library interface without specifying
dependencies.

Fixes rdar://148697444 error: a mutating method with a ~Escapable 'self' requires '@Lifetime(self:
...)'

Author: atrick

lib/AST/LifetimeDependence.cpp

@@ -1069,6 +1069,13 @@ class LifetimeDependenceChecker {
       return;
     }
     if (afd->getParameters()->size() > 0) {
+      if (useLazyInference()) {
+        // Assume that a mutating method does not depend on its parameters.
+        // This is unsafe but needed because some MutableSpan APIs snuck into
+        // the standard library interface without specifying dependencies.
+        pushDeps(createDeps(selfIndex).add(selfIndex,
+                                           LifetimeDependenceKind::Inherit));
+      }
       return;
     }
     pushDeps(createDeps(selfIndex).add(selfIndex,
@@ -1115,6 +1122,17 @@ class LifetimeDependenceChecker {
                    .add(newValIdx, *kind));
       break;
     }
+    case AccessorKind::MutableAddress:
+      if (useLazyInference()) {
+        // Assume that a mutating method does not depend on its parameters.
+        // Currently only for backward interface compatibility. Even though this
+        // is the only useful dependence (a borrow of self is possible but not
+        // useful), explicit annotation is required for now to confirm that the
+        // mutated self cannot depend on anything stored at this address.
+        pushDeps(createDeps(selfIndex).add(selfIndex,
+                                           LifetimeDependenceKind::Inherit));
+      }
+      break;
     default:
       // Unknown mutating accessor.
       break;

test/Sema/Inputs/lifetime_depend_infer.swiftinterface

@@ -71,6 +71,18 @@ public struct NonEscapableSelf : ~Swift.Escapable {
   public mutating func mutatingMethodOneParamBorrow(_: Swift.Int) -> lifetime_depend_infer.NonEscapableSelf
   #endif
 }
+
+public struct NoncopyableInoutMethods : ~Swift.Copyable & ~Swift.Escapable {
+#if $LifetimeDependence
+public mutating func mutatingMethodOneParamFunctionType<E, Result>(_ body: (Swift.Int) throws(E) -> Result) throws(E) -> Result where E : Swift.Error, Result : ~Swift.Copyable
+
+public subscript(position: Swift.Int) -> Swift.Int {
+  unsafeAddress
+  unsafeMutableAddress
+}
+#endif
+}
+
 public struct EscapableTrivialSelf {
   #if compiler(>=5.3) && $NonescapableTypes && $LifetimeDependence
   @lifetime(self)