Allow importing pointer-returning methods as throwing. (#2420)

Leftover bits of SE-0055. Now that pointer nullability is reflected
in the type system, we can properly import throwing methods with
non-object pointer return types.

Note that Swift still won't let you declare them. That's coming next.

Author: jrose-apple

lib/ClangImporter/ClangImporter.cpp

@@ -1544,27 +1544,8 @@ static bool canImportAsOptional(clang::ASTContext &ctx, clang::QualType type) {
   // Objective-C object pointers.
   if (type->getAs<clang::ObjCObjectPointerType>()) return true;
 
-  // Block and function pointers.
-  if (type->isBlockPointerType() || type->isFunctionPointerType()) return true;
-
-  // CF types.
-  do {
-    // Check whether we have a typedef that refers to a CoreFoundation type.
-    if (auto typedefType = dyn_cast<clang::TypedefType>(type.getTypePtr())) {
-      if (ClangImporter::Implementation::isCFTypeDecl(typedefType->getDecl()))
-        return true;
-
-      type = typedefType->getDecl()->getUnderlyingType();
-      continue;
-    }
-
-    // Try to desugar one level...
-    clang::QualType desugared = type.getSingleStepDesugaredType(ctx);
-    if (desugared.getTypePtr() == type.getTypePtr())
-      break;
-
-    type = desugared;
-  } while (!type.isNull());
+  // Block and C pointers, including CF types.
+  if (type->isBlockPointerType() || type->isPointerType()) return true;
 
   return false;
 }

test/IDE/Inputs/swift_name_objc.h

@@ -67,8 +67,15 @@ SWIFT_NAME(SomeProtocol)
 @interface NSErrorImports : NSObject
 - (nullable NSObject *)methodAndReturnError:(NSError **)error;
 - (BOOL)methodWithFloat:(float)value error:(NSError **)error;
+- (nullable void *)pointerMethodAndReturnError:(NSError **)error;
+- (nullable SEL)selectorMethodAndReturnError:(NSError **)error;
+- (nullable void (*)(void))functionPointerMethodAndReturnError:(NSError **)error;
+- (nullable void (^)(void))blockMethodAndReturnError:(NSError **)error;
+
 - (nullable instancetype)initAndReturnError:(NSError **)error;
 - (nullable instancetype)initWithFloat:(float)value error:(NSError **)error;
+
+- (nonnull void *)badPointerMethodAndReturnError:(NSError **)error;
 @end
 
 typedef const void *CFTypeRef __attribute__((objc_bridge(id)));

test/IDE/dump_swift_lookup_tables_objc.swift

@@ -50,6 +50,10 @@
 // CHECK-NEXT:     TU: __swift
 // CHECK-NEXT:   accessibilityFloat:
 // CHECK-NEXT:     NSAccessibility: -[NSAccessibility accessibilityFloat]
+// CHECK-NEXT:   badPointerMethodAndReturnError:
+// CHECK-NEXT:     NSErrorImports: -[NSErrorImports badPointerMethodAndReturnError:]
+// CHECK-NEXT:   blockMethod:
+// CHECK-NEXT:     NSErrorImports: -[NSErrorImports blockMethodAndReturnError:]
 // CHECK-NEXT:   categoryMethodWith:
 // CHECK-NEXT:     SNSomeClass: -[SNSomeClass categoryMethodWithX:y:], -[SNSomeClass categoryMethodWithX:y:z:]
 // CHECK:        doubleProperty:
@@ -58,6 +62,8 @@
 // CHECK-NEXT:     SNSomeClass: -[SNSomeClass extensionMethodWithX:y:]
 // CHECK:        floatProperty:
 // CHECK-NEXT:     SNSomeClass: SNSomeClass.floatProperty
+// CHECK-NEXT:   functionPointerMethod:
+// CHECK-NEXT:     NSErrorImports: -[NSErrorImports functionPointerMethodAndReturnError:]
 // CHECK-NEXT:   init:
 // CHECK-NEXT:     SNSomeClass: -[SNSomeClass initWithFloat:], -[SNSomeClass initWithDefault], +[SNSomeClass someClassWithDouble:], +[SNSomeClass someClassWithTry:], +[SNSomeClass buildWithUnsignedChar:]
 // CHECK-NEXT:     UIActionSheet: -[UIActionSheet initWithTitle:delegate:cancelButtonTitle:destructiveButtonTitle:otherButtonTitles:]
@@ -70,10 +76,14 @@
 // CHECK-NEXT:     SNSomeClass: -[SNSomeClass objectAtIndexedSubscript:]
 // CHECK-NEXT:   optSetter:
 // CHECK-NEXT:     SNCollision: SNCollision.optSetter
+// CHECK-NEXT:   pointerMethod:
+// CHECK-NEXT:     NSErrorImports: -[NSErrorImports pointerMethodAndReturnError:]
 // CHECK-NEXT:   protoInstanceMethodWith:
 // CHECK-NEXT:     SNSomeProtocol: -[SNSomeProtocol protoInstanceMethodWithX:y:]
 // CHECK:        reqSetter:
 // CHECK-NEXT:     SNCollision: SNCollision.reqSetter
+// CHECK-NEXT:   selectorMethod:
+// CHECK-NEXT:     NSErrorImports: -[NSErrorImports selectorMethodAndReturnError:]
 // CHECK-NEXT:   setAccessibilityFloat:
 // CHECK-NEXT:     NSAccessibility: -[NSAccessibility setAccessibilityFloat:]
 // CHECK-NEXT:   subscript:

test/Interpreter/Inputs/ObjCClasses/ObjCClasses.h

@@ -14,9 +14,10 @@ NS_ASSUME_NONNULL_BEGIN
 @property NSInteger t;
 @end
 
-/* This class has a method that doesn't fill in the error properly. */
-@interface NilError : NSObject
-+ (BOOL) throwIt: (NSError**) error;
+@interface TestingNSError : NSObject
++ (BOOL)throwNilError:(NSError**)error;
++ (nullable void *)maybeThrow:(BOOL)shouldThrow error:(NSError **)error;
++ (nullable void (^)(void))blockThrowError:(NSError **)error;
 @end
 
 @interface Container<C> : NSObject

test/Interpreter/Inputs/ObjCClasses/ObjCClasses.m

@@ -1,4 +1,5 @@
-#include "ObjCClasses.h"
+#import "ObjCClasses.h"
+#import <Foundation/NSError.h>
 #include <stdio.h>
 
 @implementation HasHiddenIvars
@@ -8,10 +9,24 @@ @implementation HasHiddenIvars
 @synthesize t;
 @end
 
-@implementation NilError
-+ (BOOL) throwIt: (NSError**) error {
+@implementation TestingNSError
++ (BOOL)throwNilError:(NSError **)error {
   return 0;
 }
+
++ (nullable void *)maybeThrow:(BOOL)shouldThrow error:(NSError **)error {
+  if (shouldThrow) {
+    *error = [NSError errorWithDomain:@"pointer error" code:0 userInfo:nil];
+    return 0;
+  }
+  return (void *)42;
+}
+
++ (nullable void (^)(void))blockThrowError:(NSError **)error {
+  *error = [NSError errorWithDomain:@"block error" code:0 userInfo:nil];
+  return 0;
+}
+
 @end
 
 @implementation Container

test/Interpreter/errors_imported.swift

@@ -0,0 +1,54 @@
+// RUN: rm -rf %t && mkdir -p %t
+//
+// RUN: %target-clang -fobjc-arc %S/Inputs/ObjCClasses/ObjCClasses.m -c -o %t/ObjCClasses.o
+// RUN: %target-build-swift -I %S/Inputs/ObjCClasses/ %t/ObjCClasses.o %s -o %t/a.out
+// RUN: %target-run %t/a.out
+
+// REQUIRES: executable_test
+// REQUIRES: objc_interop
+
+import ObjCClasses
+import Foundation
+import StdlibUnittest
+
+var ErrorHandlingTests = TestSuite("ErrorHandling")
+
+ErrorHandlingTests.test("nil") {
+  do {
+    try TestingNSError.throwNilError()
+    expectUnreachable()
+  } catch {
+    expectEqual("Foundation._GenericObjCError.nilError", String(reflecting: error))
+  }
+}
+
+ErrorHandlingTests.test("pointerFailure") {
+  do {
+    _ = try TestingNSError.maybeThrow(true)
+    expectUnreachable()
+  } catch let error as NSError {
+    expectEqual("pointer error", error.domain)
+  }
+}
+
+ErrorHandlingTests.test("pointerSuccess") {
+  do {
+    var pointer = try TestingNSError.maybeThrow(false)
+    expectType(UnsafeMutablePointer<Void>.self, &pointer)
+    expectEqual(UnsafeMutablePointer(bitPattern: 42)!, pointer)
+  } catch {
+    expectUnreachableCatch(error)
+  }
+}
+
+ErrorHandlingTests.test("blockFailure") {
+  do {
+    _ = try TestingNSError.blockThrowError()
+    expectUnreachable()
+  } catch let error as NSError {
+    expectEqual("block error", error.domain)
+  }
+}
+
+runAllTests()
+