Sema/SILGen: Move invalid @convention(c) conversion check to SILGen

This removes a bit of global state from the TypeChecker class, and
allows C function pointers to be formed to closures that capture
local functions, but have no transitive captures.

Author: slavapestov

Diff for: include/swift/AST/DiagnosticsSIL.def

@@ -113,6 +113,12 @@ ERROR(unsupported_c_function_pointer_conversion,none,
       "C function pointer signature %0 is not compatible with expected type %1",
       (Type, Type))
 
+ERROR(c_function_pointer_from_function_with_context,none,
+      "a C function pointer cannot be formed from a "
+      "%select{local function|closure}0 that captures "
+      "%select{context|generic parameters|dynamic Self type|<<error>}1",
+      (bool, unsigned))
+
 ERROR(objc_selector_malformed,none,"the type ObjectiveC.Selector is malformed",
       ())
 

Diff for: include/swift/AST/DiagnosticsSema.def

@@ -1121,11 +1121,6 @@ ERROR(c_function_pointer_from_method,none,
 ERROR(c_function_pointer_from_generic_function,none,
       "a C function pointer cannot be formed from a reference to a generic "
       "function", ())
-ERROR(c_function_pointer_from_function_with_context,none,
-      "a C function pointer cannot be formed from a "
-      "%select{local function|closure}0 that captures "
-      "%select{context|generic parameters|dynamic Self type|<<error>}1",
-      (bool, unsigned))
 ERROR(invalid_autoclosure_forwarding,none,
       "add () to forward @autoclosure parameter", ())
 

Diff for: lib/SILGen/SILGenExpr.cpp

@@ -1537,9 +1537,34 @@ ManagedValue emitCFunctionPointer(SILGenFunction &SGF,
   }
 
   // Produce a reference to the C-compatible entry point for the function.
-  SILDeclRef constant(loc, /*uncurryLevel*/ 0, /*foreign*/ true);
+  SILDeclRef constant(loc, /*curried*/ false, /*foreign*/ true);
   SILConstantInfo constantInfo = SGF.getConstantInfo(constant);
 
+  // C function pointers cannot capture anything from their context.
+  auto captures = SGF.SGM.Types.getLoweredLocalCaptures(
+    *constant.getAnyFunctionRef());
+
+  if (captures.hasGenericParamCaptures() ||
+      captures.hasDynamicSelfCapture() ||
+      captures.hasLocalCaptures() ||
+      captures.hasOpaqueValueCapture()) {
+    unsigned kind;
+    if (captures.hasLocalCaptures())
+      kind = 0;
+    else if (captures.hasGenericParamCaptures())
+      kind = 1;
+    else if (captures.hasLocalCaptures())
+      kind = 2;
+    else
+      kind = 3;
+    SGF.SGM.diagnose(expr->getLoc(),
+                     diag::c_function_pointer_from_function_with_context,
+                     /*closure*/ constant.hasClosureExpr(),
+                     kind);
+
+    return SGF.emitUndef(constantInfo.getSILType());
+  }
+
   return convertCFunctionSignature(
                     SGF, conversionExpr,
                     constantInfo.getSILType(),

Diff for: lib/Sema/CSApply.cpp

@@ -5795,8 +5795,6 @@ maybeDiagnoseUnsupportedFunctionConversion(ConstraintSystem &cs, Expr *expr,
       } else if (fn->getGenericParams()) {
         tc.diagnose(expr->getLoc(),
                     diag::c_function_pointer_from_generic_function);
-      } else {
-        tc.maybeDiagnoseCaptures(expr, fn);
       }
     };
 
@@ -5817,10 +5815,8 @@ maybeDiagnoseUnsupportedFunctionConversion(ConstraintSystem &cs, Expr *expr,
       semanticExpr = capture->getClosureBody();
 
     // Can convert a literal closure that doesn't capture context.
-    if (auto closure = dyn_cast<ClosureExpr>(semanticExpr)) {
-      tc.maybeDiagnoseCaptures(expr, closure);
+    if (auto closure = dyn_cast<ClosureExpr>(semanticExpr))
       return;
-    }
 
     tc.diagnose(expr->getLoc(),
                 diag::invalid_c_function_pointer_conversion_expr);

Diff for: lib/Sema/TypeCheckCaptures.cpp

@@ -590,35 +590,6 @@ class FindCapturedVars : public ASTWalker {
 
 } // end anonymous namespace
 
-void TypeChecker::maybeDiagnoseCaptures(Expr *E, AnyFunctionRef AFR) {
-  if (!AFR.getCaptureInfo().hasBeenComputed()) {
-    // The capture list is not always initialized by the point we reference
-    // it. Remember we formed a C function pointer so we can diagnose later
-    // if necessary.
-    LocalCFunctionPointers[AFR].push_back(E);
-    return;
-  }
-
-  if (AFR.getCaptureInfo().hasGenericParamCaptures() ||
-      AFR.getCaptureInfo().hasDynamicSelfCapture() ||
-      AFR.getCaptureInfo().hasLocalCaptures() ||
-      AFR.getCaptureInfo().hasOpaqueValueCapture()) {
-    unsigned kind;
-    if (AFR.getCaptureInfo().hasLocalCaptures())
-      kind = 0;
-    else if (AFR.getCaptureInfo().hasGenericParamCaptures())
-      kind = 1;
-    else if (AFR.getCaptureInfo().hasLocalCaptures())
-      kind = 2;
-    else
-      kind = 3;
-    diagnose(E->getLoc(),
-             diag::c_function_pointer_from_function_with_context,
-             /*closure*/ AFR.getAbstractClosureExpr() != nullptr,
-             kind);
-  }
-}
-
 void TypeChecker::computeCaptures(AnyFunctionRef AFR) {
   if (AFR.getCaptureInfo().hasBeenComputed())
     return;
@@ -671,13 +642,6 @@ void TypeChecker::computeCaptures(AnyFunctionRef AFR) {
       }
     }
   }
-
-  // Diagnose if we have local captures and there were C pointers formed to
-  // this function before we computed captures.
-  auto cFunctionPointers = LocalCFunctionPointers.find(AFR);
-  if (cFunctionPointers != LocalCFunctionPointers.end())
-    for (auto *expr : cFunctionPointers->second)
-      maybeDiagnoseCaptures(expr, AFR);
 }
 
 void TypeChecker::checkPatternBindingCaptures(NominalTypeDecl *typeDecl) {

Diff for: lib/Sema/TypeChecker.h

@@ -569,13 +569,6 @@ class TypeChecker final : public LazyResolver {
   /// will need to compute captures for.
   std::vector<AbstractClosureExpr *> ClosuresWithUncomputedCaptures;
 
-  /// A set of local functions from which C function pointers are derived.
-  ///
-  /// This is used to diagnose the use of local functions with captured context
-  /// as C function pointers when the function's captures have not yet been
-  /// computed.
-  llvm::DenseMap<AnyFunctionRef, std::vector<Expr*>> LocalCFunctionPointers;
-
 private:
   /// The # of times we have performed typo correction.
   unsigned NumTypoCorrections = 0;
@@ -1434,10 +1427,6 @@ class TypeChecker final : public LazyResolver {
   /// Type-check a for-each loop's pattern binding and sequence together.
   bool typeCheckForEachBinding(DeclContext *dc, ForEachStmt *stmt);
 
-  /// Lazily diagnose conversions to C function pointers of closures
-  /// with captures.
-  void maybeDiagnoseCaptures(Expr *E, AnyFunctionRef AFR);
-
   /// Compute the set of captures for the given function or closure.
   void computeCaptures(AnyFunctionRef AFR);
 

Diff for: test/Parse/c_function_pointers.swift

@@ -11,20 +11,13 @@ class C {
 }
 
 if true {
-  var x = 0
   func local() -> Int { return 0 }
-  func localWithContext() -> Int { return x }
 
   let a: @convention(c) () -> Int = global
   let _: @convention(c) () -> Int = main.global
   let _: @convention(c) () -> Int = { 0 }
   let _: @convention(c) () -> Int = local
 
-  // Can't convert a closure with context to a C function pointer
-  let _: @convention(c) () -> Int = { x } // expected-error{{cannot be formed from a closure that captures context}}
-  let _: @convention(c) () -> Int = { [x] in x } // expected-error{{cannot be formed from a closure that captures context}}
-  let _: @convention(c) () -> Int = localWithContext // expected-error{{cannot be formed from a local function that captures context}}
-
   // Can't convert a closure value to a C function pointer
   let global2 = global
   let _: @convention(c) () -> Int = global2 // expected-error{{can only be formed from a reference to a 'func' or a literal closure}}
@@ -51,14 +44,6 @@ if true {
   handler(iuo_global) // expected-error{{a C function pointer can only be formed from a reference to a 'func' or a literal closure}}
 }
 
-class Generic<X : C> {
-  func f<Y : C>(_ y: Y) {
-    let _: @convention(c) () -> Int = { return 0 }
-    let _: @convention(c) () -> Int = { return X.staticMethod() } // expected-error{{cannot be formed from a closure that captures generic parameters}}
-    let _: @convention(c) () -> Int = { return Y.staticMethod() } // expected-error{{cannot be formed from a closure that captures generic parameters}}
-  }
-}
-
 func genericFunc<T>(_ t: T) -> T { return t }
 
 let f: @convention(c) (Int) -> Int = genericFunc // expected-error{{cannot be formed from a reference to a generic function}}

Diff for: test/SILGen/c_function_pointers.swift

@@ -1,5 +1,33 @@
 // RUN: %target-swift-emit-silgen -verify %s | %FileCheck %s
 
+if true {
+  var x = 0
+  func local() -> Int { return 0 }
+  func localWithContext() -> Int { return x }
+  func transitiveWithoutContext() -> Int { return local() }
+
+  // Can't convert a closure with context to a C function pointer
+  let _: @convention(c) () -> Int = { x } // expected-error{{cannot be formed from a closure that captures context}}
+  let _: @convention(c) () -> Int = { [x] in x } // expected-error{{cannot be formed from a closure that captures context}}
+  let _: @convention(c) () -> Int = localWithContext // expected-error{{cannot be formed from a local function that captures context}}
+
+  let _: @convention(c) () -> Int = local
+  let _: @convention(c) () -> Int = transitiveWithoutContext
+}
+
+class C {
+  static func staticMethod() -> Int { return 0 }
+  class func classMethod() -> Int { return 0 }
+}
+
+class Generic<X : C> {
+  func f<Y : C>(_ y: Y) {
+    let _: @convention(c) () -> Int = { return 0 }
+    let _: @convention(c) () -> Int = { return X.staticMethod() } // expected-error{{cannot be formed from a closure that captures generic parameters}}
+    let _: @convention(c) () -> Int = { return Y.staticMethod() } // expected-error{{cannot be formed from a closure that captures generic parameters}}
+  }
+}
+
 func values(_ arg: @escaping @convention(c) (Int) -> Int) -> @convention(c) (Int) -> Int {
   return arg
 }