[CSSimplify] Detect and diagnose Swift -> C pointer conversion failures

Detect and diagnose situations when Swift -> C pointer conversion
is unsupported due to method not being imported from C header.

Author: xedin

lib/Sema/CSSimplify.cpp

@@ -5894,7 +5894,8 @@ ConstraintSystem::matchTypes(Type type1, Type type2, ConstraintKind kind,
             //
             // Do some light verification before recording restriction to
             // avoid allocating constraints for obviously invalid cases.
-            if (type1IsPointer && !type1IsOptional && !type2IsOptional) {
+            if (type1IsPointer && !type1IsOptional && !type2IsOptional &&
+                (shouldAttemptFixes() || isArgumentOfImportedDecl(locator))) {
               // UnsafeRawPointer -> UnsafePointer<[U]Int8>
               if (type1PointerKind == PTK_UnsafeRawPointer &&
                   pointerKind == PTK_UnsafePointer) {
@@ -11384,42 +11385,59 @@ ConstraintSystem::SolutionKind
 ConstraintSystem::simplifyPointerToCPointerRestriction(
     Type type1, Type type2, TypeMatchOptions flags,
     ConstraintLocatorBuilder locator) {
-  // If this is not an imported function, let's not proceed with this
-  // conversion.
-  if (!isArgumentOfImportedDecl(locator)) {
-    return SolutionKind::Error;
-  }
+  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 this is not an imported function, let's not proceed with
+    // the conversion, unless in diagnostic mode.
+    if (!shouldAttemptFixes())
+      return SolutionKind::Error;
 
-  // Make sure that solutions with implicit pointer conversions
-  // are always worse than the ones without them.
-  increaseScore(SK_ImplicitValueConversion);
+    // Let's attempt to convert the types and record a tailored
+    // fix if that succeeds.
+  }
 
   auto &ctx = getASTContext();
 
   PointerTypeKind swiftPtrKind, cPtrKind;
 
-  auto swiftPtr =
-      type1->lookThroughAllOptionalTypes()->getAnyPointerElementType(
-          swiftPtrKind);
+  auto swiftPtr = type1->getAnyPointerElementType(swiftPtrKind);
+  auto cPtr = type2->getAnyPointerElementType(cPtrKind);
+
+  assert(swiftPtr);
+  assert(cPtr);
+
+  auto markSupported = [&]() -> SolutionKind {
+    if (inCorrectPosition)
+      return SolutionKind::Solved;
 
-  auto cPtr =
-      type2->lookThroughAllOptionalTypes()->getAnyPointerElementType(cPtrKind);
+    // If conversion cannot be allowed on account of declaration,
+    // let's add a tailored fix.
+    auto *fix = AllowSwiftToCPointerConversion::create(
+        *this, getConstraintLocator(locator));
+
+    return recordFix(fix) ? SolutionKind::Error : SolutionKind::Solved;
+  };
 
   // Unsafe[Mutable]RawPointer -> Unsafe[Mutable]Pointer<[U]Int8>
   if (swiftPtrKind == PTK_UnsafeRawPointer ||
       swiftPtrKind == PTK_UnsafeMutableRawPointer) {
     // Since it's a C pointer on parameter side it would always
     // be fully resolved.
     if (cPtr->isInt8() || cPtr->isUInt8())
-      return SolutionKind::Solved;
+      return markSupported();
   } else {
     // Unsafe[Mutable]Pointer<T> -> Unsafe[Mutable]Pointer<[U]Int8>
     if (cPtr->isInt8() || cPtr->isUInt8()) {
       // <T> can default to the type of C pointer.
       addConstraint(
           ConstraintKind::Defaultable, swiftPtr, cPtr,
           locator.withPathElement(LocatorPathElt::GenericArgument(0)));
-      return SolutionKind::Solved;
+      return markSupported();
     }
 
     auto elementLoc =
@@ -11432,42 +11450,50 @@ ConstraintSystem::simplifyPointerToCPointerRestriction(
       addConstraint(ConstraintKind::Equal, cPtr,
                     swiftPtr->isUInt() ? ctx.getIntType() : ctx.getUIntType(),
                     elementLoc);
-      return SolutionKind::Solved;
+      return markSupported();
     }
 
     if (swiftPtr->isInt8() || swiftPtr->isUInt8()) {
       addConstraint(ConstraintKind::Equal, cPtr,
                     swiftPtr->isUInt8() ? ctx.getInt8Type()
                                         : ctx.getUInt8Type(),
                     elementLoc);
-      return SolutionKind::Solved;
+      return markSupported();
     }
 
     if (swiftPtr->isInt16() || swiftPtr->isUInt16()) {
       addConstraint(ConstraintKind::Equal, cPtr,
                     swiftPtr->isUInt16() ? ctx.getInt16Type()
                                          : ctx.getUInt16Type(),
                     elementLoc);
-      return SolutionKind::Solved;
+      return markSupported();
     }
 
     if (swiftPtr->isInt32() || swiftPtr->isUInt32()) {
       addConstraint(ConstraintKind::Equal, cPtr,
                     swiftPtr->isUInt32() ? ctx.getInt32Type()
                                          : ctx.getUInt32Type(),
                     elementLoc);
-      return SolutionKind::Solved;
+      return markSupported();
     }
 
     if (swiftPtr->isInt64() || swiftPtr->isUInt64()) {
       addConstraint(ConstraintKind::Equal, cPtr,
                     swiftPtr->isUInt64() ? ctx.getInt64Type()
                                          : ctx.getUInt64Type(),
                     elementLoc);
-      return SolutionKind::Solved;
+      return markSupported();
     }
   }
 
+  // If the conversion is unsupported, let's record a generic argument mismatch.
+  if (shouldAttemptFixes() && !inCorrectPosition) {
+    auto *fix = AllowArgumentMismatch::create(*this, type1, type2,
+                                              getConstraintLocator(locator));
+    return recordFix(fix, /*impact=*/2) ? SolutionKind::Error
+                                        : SolutionKind::Solved;
+  }
+
   return SolutionKind::Error;
 }
 

test/Constraints/swift_to_c_pointer_conversions.swift.gyb

@@ -243,3 +243,29 @@ func test_overloaded_ref_is_not_ambiguous() {
   const_char_ptr_func(overloaded_func()) // Ok
   const_opt_char_ptr_func(overloaded_func()) // Ok
 }
+
+func test_tailored_diagnostic(ptr: UnsafeRawPointer, tptr: UnsafePointer<Int8>) {
+  func swift_uint8_func(_: UnsafePointer<UInt8>) {}
+  func swift_int8_func(_: UnsafePointer<Int8>) {}
+  func opt_arg_func(_: UnsafePointer<Int8>?) {}
+
+  swift_uint8_func(ptr)
+  // expected-error@-1 {{cannot convert value of type 'UnsafeRawPointer' to expected argument type 'UnsafePointer<UInt8>' because local function 'swift_uint8_func' was not imported from C header}}
+  swift_uint8_func(tptr)
+  // expected-error@-1 {{cannot convert value of type 'UnsafePointer<Int8>' to expected argument type 'UnsafePointer<UInt8>' because local function 'swift_uint8_func' was not imported from C header}}
+
+  swift_int8_func(ptr)
+  // expected-error@-1 {{cannot convert value of type 'UnsafeRawPointer' to expected argument type 'UnsafePointer<Int8>' because local function 'swift_int8_func' was not imported from C header}}
+  swift_int8_func(tptr) // Ok
+
+  opt_arg_func(ptr)
+  // expected-error@-1 {{cannot convert value of type 'UnsafeRawPointer' to expected argument type 'UnsafePointer<Int8>?' because local function 'opt_arg_func' was not imported from C header}}
+  opt_arg_func(tptr) // Ok
+
+  let optrS8: UnsafePointer<Int8>? = nil
+  let optrU8: UnsafePointer<UInt8>? = nil
+
+  opt_arg_func(optrS8) // Ok
+  opt_arg_func(optrU8)
+  // expected-error@-1 {{cannot convert value of type 'UnsafePointer<UInt8>?' to expected argument type 'UnsafePointer<Int8>?' because local function 'opt_arg_func' was not imported from C header}}
+}

test/stdlib/UnsafePointerDiagnostics.swift

@@ -79,12 +79,12 @@ func unsafePointerConversionAvailability(
   _ = UnsafeMutablePointer<Int>(rp) // expected-error {{cannot convert value of type 'UnsafeRawPointer' to expected argument type 'UnsafeMutablePointer<Int>'}}
   _ = UnsafeMutablePointer<Int>(mrp) // expected-error {{cannot convert value of type 'UnsafeMutableRawPointer' to expected argument type 'UnsafeMutablePointer<Int>'}}
   _ = UnsafeMutablePointer<Int>(orp) // expected-error {{cannot convert value of type 'UnsafeRawPointer?' to expected argument type 'UnsafeMutablePointer<Int>'}}
-  _ = UnsafeMutablePointer<Int>(omrp) // expected-error {{cannot convert value of type 'UnsafeMutableRawPointer?' to expected argument type 'UnsafeMutablePointer<Int>'}}
+  _ = UnsafeMutablePointer<Int>(omrp) // expected-error {{cannot convert value of type 'UnsafeMutableRawPointer' to expected argument type 'UnsafeMutablePointer<Int>'}}
 
   _ = UnsafePointer<Int>(rp)  // expected-error {{cannot convert value of type 'UnsafeRawPointer' to expected argument type 'UnsafePointer<Int>'}}
   _ = UnsafePointer<Int>(mrp) // expected-error {{cannot convert value of type 'UnsafeMutableRawPointer' to expected argument type 'UnsafePointer<Int>'}}
-  _ = UnsafePointer<Int>(orp)  // expected-error {{cannot convert value of type 'UnsafeRawPointer?' to expected argument type 'UnsafePointer<Int>'}}
-  _ = UnsafePointer<Int>(omrp) // expected-error {{cannot convert value of type 'UnsafeMutableRawPointer?' to expected argument type 'UnsafePointer<Int>'}}
+  _ = UnsafePointer<Int>(orp)  // expected-error {{cannot convert value of type 'UnsafeRawPointer' to expected argument type 'UnsafePointer<Int>'}}
+  _ = UnsafePointer<Int>(omrp) // expected-error {{cannot convert value of type 'UnsafeMutableRawPointer' to expected argument type 'UnsafePointer<Int>'}}
 
   _ = UnsafePointer<Int>(ups) // expected-error {{cannot convert value of type 'UnsafePointer<String>' to expected argument type 'UnsafePointer<Int>'}}
   // expected-note@-1 {{arguments to generic parameter 'Pointee' ('String' and 'Int') are expected to be equal}}