Merge pull request #28580 from varungandhi-apple/vg-fix-borked-isCanonical-calc

isCanonical should take the Clang function type into account only if UseClangFunctionTypes is enabled.

Author: xedin

lib/AST/ASTContext.cpp

@@ -3008,8 +3008,12 @@ FunctionType *FunctionType::get(ArrayRef<AnyFunctionType::Param> params,
   void *mem = ctx.Allocate(allocSize, alignof(FunctionType), arena);
 
   bool isCanonical = isFunctionTypeCanonical(params, result);
-  if (uncommon.hasValue())
-    isCanonical &= uncommon->ClangFunctionType->isCanonicalUnqualified();
+  if (uncommon.hasValue()) {
+    if (ctx.LangOpts.UseClangFunctionTypes)
+      isCanonical &= uncommon->ClangFunctionType->isCanonicalUnqualified();
+    else
+      isCanonical = false;
+  }
 
   auto funcTy = new (mem) FunctionType(params, result, info,
                                        isCanonical ? &ctx : nullptr,

test/Sema/clang_types_in_ast.swift

@@ -5,6 +5,9 @@
 // RUN: %target-swift-frontend %s -typecheck -DNOCRASH2 -sdk %clang-importer-sdk -use-clang-function-types
 // RUN: %target-swift-frontend %s -DAUXMODULE -module-name Foo -emit-module -o %t
 
+// rdar://problem/57644243 : We shouldn't crash if -use-clang-function-types is not enabled.
+// RUN: %target-swift-frontend %s -typecheck -DNOCRASH3 -I %t
+
 // FIXME: [clang-function-type-serialization] This should stop crashing once we
 // start serializing clang function types.
 // RUN: not --crash %target-swift-frontend %s -typecheck -DCRASH -I %t -use-clang-function-types
@@ -25,12 +28,38 @@ func f() {
 #endif
 
 #if AUXMODULE
-public var DUMMY_SIGNAL : Optional<@convention(c) (Int32) -> Void> = .none
+public var DUMMY_SIGNAL1 : Optional<@convention(c) (Int32) -> ()> = .none
+public var DUMMY_SIGNAL2 : Optional<@convention(c) (Int32) -> Void> = .none
+#endif
+
+#if NOCRASH3
+import Foo
+public func my_signal1() -> Optional<@convention(c) (Int32) -> ()> {
+  return Foo.DUMMY_SIGNAL1
+}
+public func my_signal2() -> Optional<@convention(c) (Int32) -> Void> {
+  return Foo.DUMMY_SIGNAL1
+}
+public func my_signal3() -> Optional<@convention(c) (Int32) -> ()> {
+  return Foo.DUMMY_SIGNAL2
+}
+public func my_signal4() -> Optional<@convention(c) (Int32) -> Void> {
+  return Foo.DUMMY_SIGNAL2
+}
 #endif
 
 #if CRASH
 import Foo
-public func my_signal() -> Optional<@convention(c) (Int32) -> Void> {
-  return Foo.DUMMY_SIGNAL
+public func my_signal1() -> Optional<@convention(c) (Int32) -> ()> {
+  return Foo.DUMMY_SIGNAL1
+}
+public func my_signal2() -> Optional<@convention(c) (Int32) -> Void> {
+  return Foo.DUMMY_SIGNAL1
+}
+public func my_signal3() -> Optional<@convention(c) (Int32) -> ()> {
+  return Foo.DUMMY_SIGNAL2
+}
+public func my_signal4() -> Optional<@convention(c) (Int32) -> Void> {
+  return Foo.DUMMY_SIGNAL2
 }
 #endif