[CSSimplify] Implement ArrayToCPointer conversion

Extends implementation to support conversions between arrays
and pointers that are allowed by the SE-0324 proposal.

Resolved: rdar://99089335

Author: xedin

lib/Sema/CSSimplify.cpp

@@ -7389,6 +7389,14 @@ ConstraintSystem::matchTypes(Type type1, Type type2, ConstraintKind kind,
                 if (type1->isArrayType()) {
                   conversionsOrFixes.push_back(
                       ConversionRestrictionKind::ArrayToPointer);
+
+                  // If regular array-to-pointer conversion doesn't work,
+                  // let's try C pointer conversion that has special semantics
+                  // for imported declarations.
+                  if (isArgumentOfImportedDecl(locator)) {
+                    conversionsOrFixes.push_back(
+                        ConversionRestrictionKind::ArrayToCPointer);
+                  }
                 }
 
                 // The pointer can be converted from a string, if the element
@@ -13436,8 +13444,30 @@ ConstraintSystem::simplifyRestrictedConstraintImpl(
   case ConversionRestrictionKind::PointerToCPointer:
     return simplifyPointerToCPointerRestriction(type1, type2, flags, locator);
 
-  case ConversionRestrictionKind::ArrayToCPointer:
-    llvm_unreachable("not yet implemented");
+  case ConversionRestrictionKind::ArrayToCPointer: {
+    auto ptr2 = type2->getDesugaredType()->lookThroughAllOptionalTypes();
+
+    PointerTypeKind pointerKind;
+    auto cPtr = ptr2->getAnyPointerElementType(pointerKind);
+
+    // If the parameter is a raw pointer or its element type is not a
+    // supported (un-)signed integer it implies a regular ArrayToPointer
+    // conversion.
+    if (isRawPointerKind(pointerKind) ||
+        !(cPtr->isInt()   || cPtr->isUInt()   ||
+          cPtr->isInt8()  || cPtr->isUInt8()  ||
+          cPtr->isInt16() || cPtr->isUInt16() ||
+          cPtr->isInt32() || cPtr->isUInt32() ||
+          cPtr->isInt64() || cPtr->isUInt64())) {
+      return SolutionKind::Error;
+    }
+
+    increaseScore(SK_ValueToPointerConversion);
+
+    type1 = getFixedTypeRecursive(type1->getInOutObjectType()->isArrayType(),
+                                  /*wantRValue=*/false);
+    LLVM_FALLTHROUGH;
+  }
 
   case ConversionRestrictionKind::InoutToCPointer: {
     SmallVector<Type, 2> optionals;
@@ -13702,12 +13732,7 @@ ConstraintSystem::simplifyPointerToCPointerRestriction(
     Type type1, Type type2, TypeMatchOptions flags,
     ConstraintLocatorBuilder locator) {
   bool inCorrectPosition = isArgumentOfImportedDecl(locator);
-
-  if (inCorrectPosition) {
-    // Make sure that solutions with implicit pointer conversions
-    // are always worse than the ones without them.
-    increaseScore(SK_ImplicitValueConversion);
-  } else {
+  if (!inCorrectPosition) {
     // If this is not an imported function, let's not proceed with
     // the conversion, unless in diagnostic mode.
     if (!shouldAttemptFixes())
@@ -13728,6 +13753,10 @@ ConstraintSystem::simplifyPointerToCPointerRestriction(
   assert(cPtr);
 
   auto markSupported = [&]() -> SolutionKind {
+    // Make sure that solutions with implicit pointer conversions
+    // are always worse than the ones without them.
+    increaseScore(SK_ImplicitValueConversion);
+
     if (inCorrectPosition)
       return SolutionKind::Solved;
 
@@ -13739,6 +13768,10 @@ ConstraintSystem::simplifyPointerToCPointerRestriction(
     return recordFix(fix) ? SolutionKind::Error : SolutionKind::Solved;
   };
 
+  // If pointers have the same element type there is nothing to do.
+  if (swiftPtr->isEqual(cPtr))
+    return markSupported();
+
   // Unsafe[Mutable]RawPointer -> Unsafe[Mutable]Pointer<[U]Int8>
   if (swiftPtrKind == PTK_UnsafeRawPointer ||
       swiftPtrKind == PTK_UnsafeMutableRawPointer) {
@@ -13761,7 +13794,6 @@ ConstraintSystem::simplifyPointerToCPointerRestriction(
 
     // Unsafe[Mutable]Pointer<Int{8, 16, ...}> <->
     // Unsafe[Mutable]Pointer<UInt{8, 16, ...}>
-
     if (swiftPtr->isInt() || swiftPtr->isUInt()) {
       addConstraint(ConstraintKind::Equal, cPtr,
                     swiftPtr->isUInt() ? ctx.getIntType() : ctx.getUIntType(),

test/Constraints/swift_to_c_pointer_conversions.swift.gyb

@@ -296,3 +296,37 @@ func test_inout_to_pointer_conversion() {
   const_opt_uint_${Size}_ptr_func(&x${Size}) // OK
 % end
 }
+
+func test_array_to_pointer_conversion() {
+% for Size in ['16', '32', '64']:
+  var x${Size}: [Int${Size}] = []
+
+  void_ptr_func(&x${Size}) // Ok
+  const_void_ptr_func(x${Size}) // Ok
+  opt_void_ptr_func(x${Size})
+  // expected-error@-1 {{cannot convert value of type '[Int${Size}]' to expected argument type 'UnsafeMutableRawPointer?'}}
+
+  char_ptr_func(x${Size})
+  // expected-error@-1 {{cannot convert value of type '[Int${Size}]' to expected argument type 'UnsafeMutablePointer<CChar>' (aka 'UnsafeMutablePointer<Int8>')}}
+  opt_char_ptr_func(x${Size})
+  // expected-error@-1 {{cannot convert value of type '[Int${Size}]' to expected argument type 'UnsafeMutablePointer<CChar>?' (aka 'Optional<UnsafeMutablePointer<Int8>>')}}
+
+  const_char_ptr_func(x${Size}) // Ok
+  const_opt_char_ptr_func(x${Size}) // Ok
+
+  int_${Size}_ptr_func(x${Size})
+  // expected-error@-1 {{cannot convert value of type '[Int${Size}]' to expected argument type 'UnsafeMutablePointer<Int${Size}>'}}
+  uint_${Size}_ptr_func(x${Size})
+  // expected-error@-1 {{cannot convert value of type '[Int${Size}]' to expected argument type 'UnsafeMutablePointer<UInt${Size}>'}}
+
+  opt_int_${Size}_ptr_func(x${Size})
+  // expected-error@-1 {{cannot convert value of type '[Int${Size}]' to expected argument type 'UnsafeMutablePointer<Int${Size}>?'}}
+  opt_uint_${Size}_ptr_func(x${Size})
+  // expected-error@-1 {{cannot convert value of type '[Int${Size}]' to expected argument type 'UnsafeMutablePointer<UInt${Size}>?'}}
+
+  const_int_${Size}_ptr_func(x${Size}) // OK
+  const_uint_${Size}_ptr_func(x${Size}) // OK
+  const_opt_int_${Size}_ptr_func(x${Size}) // OK
+  const_opt_uint_${Size}_ptr_func(x${Size}) // OK
+% end
+}

test/SILGen/diagnose_implicit_raw_conversion_unsupported.swift

@@ -40,44 +40,25 @@ func test_unsupported<T>(arg: T) {
                           // expected-note@-1 {{arguments to generic parameter 'Pointee' ('UInt8' and 'Int8') are expected to be equal}}
 }
 
-// These implicit casts should work according to
-// [SE-0324: Relax diagnostics for pointer arguments to C functions]
-// (https://github.com/apple/swift-evolution/blob/main/proposals/0324-c-lang-pointer-arg-conversion.md)
-// They currently raise a "cannot convert value" error because of
-// the `UInt8` vs. `Int8` mismatch.
-//
-// If we decide to support these as bug-fixes for SE-0324, then the
-// implicit inout-to-raw conversion should also accept them.
-func test_se0324_accept() {
+// Array<T> to C pointer conversion is supported under SE-0324
+func test_array_to_c_pointer_concrete() {
     let constIntArray: [Int8] = [0]
-    read_uchar(constIntArray) // expected-error {{cannot convert value of type 'UnsafePointer<Int8>' to expected argument type 'UnsafePointer<UInt8>'}}
-                              // expected-note@-1 {{arguments to generic parameter 'Pointee' ('Int8' and 'UInt8') are expected to be equal}}
+    read_uchar(constIntArray)
 
     let constUIntArray: [UInt8] = [0]
-    read_char(constUIntArray) // expected-error {{cannot convert value of type 'UnsafePointer<UInt8>' to expected argument type 'UnsafePointer<CChar>' (aka 'UnsafePointer<Int8>')}}
-                              // expected-note@-1 {{arguments to generic parameter 'Pointee' ('UInt8' and 'CChar' (aka 'Int8')) are expected to be equal}}
+    read_char(constUIntArray)
 
-    var intArray: [Int8] = [0]
-    read_uchar(intArray) // expected-error {{cannot convert value of type 'UnsafePointer<Int8>' to expected argument type 'UnsafePointer<UInt8>'}}
-                         // expected-note@-1 {{arguments to generic parameter 'Pointee' ('Int8' and 'UInt8') are expected to be equal}}
+    var intArray: [Int8] = [0] // expected-warning {{variable 'intArray' was never mutated; consider changing to 'let' constant}}
+    read_uchar(intArray)
 
-    var uintArray: [UInt8] = [0]
-    read_char(uintArray) // expected-error {{cannot convert value of type 'UnsafePointer<UInt8>' to expected argument type 'UnsafePointer<CChar>' (aka 'UnsafePointer<Int8>')}}
-                         // expected-note@-1 {{arguments to generic parameter 'Pointee' ('UInt8' and 'CChar' (aka 'Int8')) are expected to be equal}}
+    var uintArray: [UInt8] = [0] // expected-warning {{variable 'uintArray' was never mutated; consider changing to 'let' constant}}
+    read_char(uintArray)
 
 }
 
-// These implicit casts should work according to
-// SE-0324: Relax diagnostics for pointer arguments to C functions]
-// They currently raise a "cannot convert value" error because of
-// the `UInt8` vs. `Int8` mismatch.
-//
-// If we decide to support these as bug-fixes for SE-0324, then the
-// implicit inout-to-raw conversion should issue a warning instead.
-func test_se0324_error<T>(arg: T) {
+// Array<T> to C pointer conversion is supported under SE-0324
+func test_array_to_c_pointer_generic<T>(arg: T) {
     let constArray: [T] = [arg]
-    read_char(constArray) // expected-error {{cannot convert value of type 'UnsafePointer<T>' to expected argument type 'UnsafePointer<CChar>' (aka 'UnsafePointer<Int8>')}}
-                           // expected-note@-1 {{arguments to generic parameter 'Pointee' ('T' and 'CChar' (aka 'Int8')) are expected to be equal}}
-    read_uchar(constArray) // expected-error {{cannot convert value of type 'UnsafePointer<T>' to expected argument type 'UnsafePointer<UInt8>'}}
-                           // expected-note@-1 {{arguments to generic parameter 'Pointee' ('T' and 'UInt8') are expected to be equal}}
+    read_char(constArray)
+    read_uchar(constArray)
 }