Add some diagnostics related to lifetime dependence and function types

include/swift/AST/DiagnosticsSema.def

@@ -7994,6 +7994,9 @@ ERROR(lifetime_dependence_cannot_infer_ambiguous_candidate, none,
        ())
 ERROR(lifetime_dependence_immortal_conflict_name, none,
       "conflict between the parameter name and immortal keyword", ())
+ERROR(lifetime_dependence_function_type, none,
+      "lifetime dependencies on function types are not supported",
+      ())
 
 //===----------------------------------------------------------------------===//
 //                             MARK: Sending

lib/Sema/CSSimplify.cpp

@@ -3248,6 +3248,10 @@ ConstraintSystem::matchFunctionTypes(FunctionType *func1, FunctionType *func2,
   if (!matchFunctionIsolations(func1, func2, kind, flags, locator))
     return getTypeMatchFailure(locator);
 
+  if (func1->getLifetimeDependenceInfo() != func2->getLifetimeDependenceInfo()) {
+    return getTypeMatchFailure(locator);
+  }
+
   // To contextual type increase the score to avoid ambiguity when solver can
   // find more than one viable binding different only in representation e.g.
   //   let _: (@convention(block) () -> Void)? = Bool.random() ? nil : {}

lib/Sema/TypeCheckType.cpp

@@ -3961,6 +3961,12 @@ NeverNullType TypeResolver::resolveASTFunctionType(
     }
   }
 
+  if (auto *lifetimeRepr = dyn_cast_or_null<LifetimeDependentReturnTypeRepr>(
+          repr->getResultTypeRepr())) {
+    diagnoseInvalid(lifetimeRepr, lifetimeRepr->getLoc(),
+                    diag::lifetime_dependence_function_type);
+  }
+
   auto resultOptions = options.withoutContext();
   resultOptions.setContext(TypeResolverContext::FunctionResult);
   auto outputTy = resolveType(repr->getResultTypeRepr(), resultOptions);

test/Sema/lifetime_dependence_functype.swift

@@ -0,0 +1,47 @@
+// RUN: %target-typecheck-verify-swift -enable-experimental-feature NonescapableTypes
+ // REQUIRES: asserts
+
+ struct NC: ~Copyable {
+   var ne: NE {
+     NE()
+   }
+ }
+
+ struct NE: ~Escapable {
+   @_unsafeNonescapableResult
+   init() {}
+ }
+
+ func transfer(_ ne: NE) -> NE {
+   ne
+ }
+
+ func applyAnnotatedTransfer(ne: NE, transfer: (NE) -> dependsOn(0) NE) -> NE { // expected-error{{lifetime dependencies on function types are not supported}}
+   transfer(ne)
+ }
+
+ func applyTransfer(ne: NE, transfer: (NE) ->  NE) -> NE {
+   transfer(ne)
+ }
+
+ func testTransfer(nc: consuming NC) {
+   let transferred = applyTransfer(ne: nc.ne, transfer: transfer) // expected-error{{cannot convert value of type '(NE) -> _inherit(0)  NE' to expected argument type '(NE) -> NE'}}
+
+   _ = consume nc
+   _ = transfer(transferred)
+ }
+
+ func borrow(_ nc: borrowing NC) -> NE {
+   nc.ne
+ }
+
+ func applyBorrow(nc: borrowing NC, borrow: (borrowing NC) -> NE) -> NE {
+   borrow(nc)
+ }
+
+ func testBorrow(nc: consuming NC) {
+   let borrowed = applyBorrow(nc: nc, borrow: borrow) // expected-error{{cannot convert value of type '(borrowing NC) -> _scope(0)  NE' to expected argument type '(borrowing NC) -> NE}}
+   _ = consume nc
+   _ = transfer(borrowed)
+ }
+