[CSSimplify] Make sure that Swift -> C pointer conversion always waits for optionals

Wait for a value-to-optional promotion or optional-to-optional conversion
to happen before attempting Swift -> C pointer conversion.

Author: xedin

lib/Sema/CSSimplify.cpp

@@ -5889,13 +5889,12 @@ ConstraintSystem::matchTypes(Type type1, Type type2, ConstraintKind kind,
               }
             }
 
-            // If both sides are non-optional pointers let's check whether
+            // If both sides are non-optional pointers, let's check whether
             // this argument supports Swift -> C pointer conversions.
             //
             // Do some light verification before recording restriction to
             // avoid allocating constraints for obviously invalid cases.
-            if (type1IsPointer && optionalityMatches &&
-                isArgumentOfImportedDecl(locator)) {
+            if (type1IsPointer && !type1IsOptional && !type2IsOptional) {
               // UnsafeRawPointer -> UnsafePointer<[U]Int8>
               if (type1PointerKind == PTK_UnsafeRawPointer &&
                   pointerKind == PTK_UnsafePointer) {
@@ -11385,6 +11384,12 @@ 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;
+  }
+
   // Make sure that solutions with implicit pointer conversions
   // are always worse than the ones without them.
   increaseScore(SK_ImplicitValueConversion);

lib/Sema/ConstraintSystem.cpp

@@ -5001,11 +5001,29 @@ bool constraints::isArgumentOfReferenceEqualityOperator(
 
 bool ConstraintSystem::isArgumentOfImportedDecl(
     ConstraintLocatorBuilder locator) {
-  auto last = locator.last();
-  if (!(last && last->is<LocatorPathElt::ApplyArgToParam>()))
+  SmallVector<LocatorPathElt, 4> path;
+  auto anchor = locator.getLocatorParts(path);
+
+  if (path.empty())
     return false;
 
-  auto *application = getCalleeLocator(getConstraintLocator(locator));
+  while (!path.empty()) {
+    const auto &last = path.back();
+
+    // Drop all of the `optional payload` or `generic argument`
+    // locator elements at the end of the path, they came from
+    // either value-to-optional promotion or optional-to-optional
+    // conversion.
+    if (last.is<LocatorPathElt::OptionalPayload>() ||
+        last.is<LocatorPathElt::GenericArgument>()) {
+      path.pop_back();
+      continue;
+    }
+
+    break;
+  }
+
+  auto *application = getCalleeLocator(getConstraintLocator(anchor, path));
 
   auto overload = findSelectedOverloadFor(application);
   if (!(overload && overload->choice.isDecl()))