[silgen] Add support for correctly calling imported throwing methods on imported objc classes that are imported with a non-null NSError.

This for some time has been crashing in IRGen in non-asserts builds and hitting
assertions in asserts builds. I think we were missing test coverage here and
that is why this basic-ish thing has been broken.

Basically at a high level, the actual expected ABI here is that the NSError is
marked non-nullable which is different from the expected ABI.

rdar://92755102

Author: gottesmm

lib/SILGen/ResultPlan.cpp

@@ -758,6 +758,23 @@ class ForeignErrorInitializationPlan final : public ResultPlan {
 
     auto errorType =
         CanType(unwrappedPtrType->getAnyPointerElementType(ptrKind));
+
+    // In cases when from swift, we call objc imported methods written like so:
+    //
+    // (1) - (BOOL)submit:(NSError *_Nonnull __autoreleasing *_Nullable)errorOut;
+    //
+    // the clang importer will successfully import the given method as having a
+    // non-null NSError. This doesn't follow the normal convention where we
+    // expect the NSError to be Optional<NSError>. In order to preserve source
+    // compatibility, we want to allow SILGen to handle this behavior. Luckily
+    // in this case, NSError and Optional<NSError> are layout compatible, so we
+    // can just pass in the Optional<NSError> and everything works.
+    if (auto nsErrorTy = SGF.getASTContext().getNSErrorType()->getCanonicalType()) {
+      if (errorType == nsErrorTy) {
+        errorType = errorType.wrapInOptionalType();
+      }
+    }
+
     auto &errorTL = SGF.getTypeLowering(errorType);
 
     // Allocate a temporary.

test/ClangImporter/Inputs/throwing-mismarked-nonnullable-error.h

@@ -0,0 +1,8 @@
+@import Foundation;
+
+@interface MyClass : NSObject {
+}
+
+- (BOOL)submit:(NSError *_Nonnull __autoreleasing *_Nullable)errorOut;
+
+@end

test/ClangImporter/throwing-mismarked-nonnullable-error.swift

@@ -0,0 +1,28 @@
+// RUN: %target-swift-frontend -import-objc-header %S/Inputs/throwing-mismarked-nonnullable-error.h %s -emit-sil | %FileCheck %s
+
+// Make sure that we do not crash when importing a non-null NSError as
+// throwing. We really just shouldn't expect this at all. I filed: rdar://94656178
+// to track that work.
+
+// CHECK-LABEL: sil hidden @$s4main1fyyF : $@convention(thin) () -> () {
+// CHECK: [[STACK:%.*]] = alloc_stack [dynamic_lifetime] $Optional<NSError>
+// CHECK: inject_enum_addr [[STACK]] : $*Optional<NSError>, #Optional.none!enumelt
+// CHECK: [[FN:%.*]] = objc_method {{%[0-9]+}} : $MyClass, #MyClass.submit!foreign : (MyClass) -> () throws -> (), $@convention(objc_method) (Optional<AutoreleasingUnsafeMutablePointer<NSError>>, MyClass) -> ObjCBool
+// CHECK: [[NEXT_STACK:%.*]] = alloc_stack $@sil_unmanaged Optional<NSError>
+// CHECK: [[VAL:%.*]] = load [[STACK]] : $*Optional<NSError>
+// CHECK: [[UNMANAGED:%.*]] = ref_to_unmanaged [[VAL]]
+// CHECK: store [[UNMANAGED]] to [[NEXT_STACK]]
+// CHECK: [[PTR:%.*]] = address_to_pointer [[NEXT_STACK]]
+// CHECK: [[AUMP:%.*]] = struct $AutoreleasingUnsafeMutablePointer<NSError> ([[PTR]] :
+// CHECK: [[OPT_AUMP:%.*]] = enum $Optional<AutoreleasingUnsafeMutablePointer<NSError>>, #Optional.some!enumelt, [[AUMP]] : $AutoreleasingUnsafeMutablePointer<NSError>
+// CHECK: apply {{%.*}}([[OPT_AUMP]],
+// CHECK: } // end sil function '$s4main1fyyF'
+
+func f() {
+  let c = MyClass()
+  do {
+    try c.submit()
+  } catch {}
+}
+
+f()