[Swiftify] Don't create safe wrapper for autoreleasing pointers

lib/ClangImporter/ImportDecl.cpp

@@ -9192,6 +9192,14 @@ static bool SwiftifiableCAT(const clang::CountAttributedType *CAT) {
   return CAT && CountedByExpressionValidator().Visit(CAT->getCountExpr());
 }
 
+static bool SwiftifiablePointerType(Type swiftType) {
+  // don't try to transform any Swift types that _SwiftifyImport doesn't know how to handle
+  Type nonnullType = swiftType->lookThroughSingleOptionalType();
+  PointerTypeKind PTK;
+  return nonnullType->isOpaquePointer() ||
+    (nonnullType->getAnyPointerElementType(PTK) && PTK != PTK_AutoreleasingUnsafeMutablePointer);
+}
+
 void ClangImporter::Implementation::swiftify(FuncDecl *MappedDecl) {
   if (!SwiftContext.LangOpts.hasFeature(Feature::SafeInteropWrappers))
     return;
@@ -9225,10 +9233,11 @@ void ClangImporter::Implementation::swiftify(FuncDecl *MappedDecl) {
           return false;
         };
     SwiftifyInfoPrinter printer(getClangASTContext(), SwiftContext, out);
+    Type swiftReturnTy = MappedDecl->getResultInterfaceType();
     bool returnIsStdSpan = registerStdSpanTypeMapping(
-        MappedDecl->getResultInterfaceType(), ClangDecl->getReturnType());
+        swiftReturnTy, ClangDecl->getReturnType());
     auto *CAT = ClangDecl->getReturnType()->getAs<clang::CountAttributedType>();
-    if (SwiftifiableCAT(CAT)) {
+    if (SwiftifiableCAT(CAT) && SwiftifiablePointerType(swiftReturnTy)) {
       printer.printCountedBy(CAT, SwiftifyInfoPrinter::RETURN_VALUE_INDEX);
       attachMacro = true;
     }
@@ -9242,14 +9251,15 @@ void ClangImporter::Implementation::swiftify(FuncDecl *MappedDecl) {
     for (auto [index, clangParam] : llvm::enumerate(ClangDecl->parameters())) {
       auto clangParamTy = clangParam->getType();
       auto swiftParam = MappedDecl->getParameters()->get(index);
+      Type swiftParamTy = swiftParam->getInterfaceType();
       bool paramHasBoundsInfo = false;
       auto *CAT = clangParamTy->getAs<clang::CountAttributedType>();
-      if (SwiftifiableCAT(CAT)) {
+      if (SwiftifiableCAT(CAT) && SwiftifiablePointerType(swiftParamTy)) {
         printer.printCountedBy(CAT, index);
         attachMacro = paramHasBoundsInfo = true;
       }
       bool paramIsStdSpan = registerStdSpanTypeMapping(
-          swiftParam->getInterfaceType(), clangParamTy);
+          swiftParamTy, clangParamTy);
       paramHasBoundsInfo |= paramIsStdSpan;
 
       bool paramHasLifetimeInfo = false;
@@ -9260,7 +9270,7 @@ void ClangImporter::Implementation::swiftify(FuncDecl *MappedDecl) {
       if (clangParam->hasAttr<clang::LifetimeBoundAttr>()) {
         printer.printLifetimeboundReturn(
             index, !paramHasBoundsInfo &&
-                       swiftParam->getInterfaceType()->isEscapable());
+                       swiftParamTy->isEscapable());
         paramHasLifetimeInfo = true;
         returnHasLifetimeInfo = true;
       }

test/Interop/C/swiftify-import/Inputs/module.modulemap

@@ -14,4 +14,3 @@ module SizedByNoEscapeClang {
     header "sized-by-noescape.h"
     export *
 }
-

test/Interop/ObjC/lit.local.cfg

@@ -0,0 +1,2 @@
+if 'objc_interop' not in config.available_features:
+    config.unsupported = True

test/Interop/ObjC/swiftify-import/Inputs/module.modulemap

@@ -0,0 +1,4 @@
+module NoSwiftifyClang {
+    header "objc-no-swiftify.h"
+    export *
+}

test/Interop/ObjC/swiftify-import/Inputs/objc-no-swiftify.h

@@ -0,0 +1,9 @@
+#define __counted_by(x) __attribute__((__counted_by__(x)))
+
+@interface SomeClass
+- (int)numberOfSegments;
+@end
+
+void autoreleaseParam(SomeClass * __autoreleasing * __counted_by(len) p, int len); // expected-note{{declared here}}
+
+SomeClass * __autoreleasing * __counted_by(len) autoreleaseReturn(int len);

test/Interop/ObjC/swiftify-import/counted-by-in-class.swift

@@ -5,8 +5,6 @@
 // RUN: %target-swift-ide-test -plugin-path %swift-plugin-dir -I %t/Inputs -enable-experimental-feature SafeInteropWrappers -print-module -module-to-print=Method -source-filename=x | %FileCheck %s
 // RUN: %target-swift-frontend -plugin-path %swift-plugin-dir -I %t/Inputs -enable-experimental-feature SafeInteropWrappers %t/method.swift -dump-macro-expansions -typecheck -verify
 
-// REQUIRES: objc_interop
-
 // CHECK: class Foo {
 // CHECK:  func bar(_ p: UnsafeMutableBufferPointer<Float>)
 

test/Interop/ObjC/swiftify-import/objc-no-swiftify.swift

@@ -0,0 +1,22 @@
+// REQUIRES: swift_feature_SafeInteropWrappers
+
+// RUN: %target-swift-ide-test -print-module -module-to-print=NoSwiftifyClang -plugin-path %swift-plugin-dir -I %S/Inputs -source-filename=x -enable-experimental-feature SafeInteropWrappers | %FileCheck %s
+
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend -emit-module -plugin-path %swift-plugin-dir -o %t/NoSwiftify.swiftmodule -I %S/Inputs -enable-experimental-feature SafeInteropWrappers %s -verify -verify-additional-file %S/Inputs/objc-no-swiftify.h
+
+import NoSwiftifyClang
+
+// CHECK-NOT: @_alwaysEmitIntoClient public func callAutoreleaseParam
+// CHECK-NOT: @_alwaysEmitIntoClient public func callAutoreleaseReturn
+
+public func callAutoreleaseParam(_ p: UnsafeMutableBufferPointer<SomeClass>) {
+    // expected-error@+2{{missing argument for parameter #2 in call}}
+    // expected-error@+1{{cannot convert value of type 'UnsafeMutableBufferPointer<SomeClass>' to expected argument type 'AutoreleasingUnsafeMutablePointer<SomeClass?>'}}
+    autoreleaseParam(p)
+}
+
+public func callAutoreleaseReturn() {
+    // expected-error@+1{{cannot convert value of type 'AutoreleasingUnsafeMutablePointer<SomeClass?>?' to specified type 'UnsafeMutableBufferPointer<SomeClass>'}}
+    let p: UnsafeMutableBufferPointer<SomeClass> = autoreleaseReturn(10)
+}