Sema: Check conformance availability when ranking solutions

This completes the work on <rdar://problem/35158274>, and also
adds a test case for <rdar://problem/50627401>.

Author: slavapestov

include/swift/Sema/ConstraintSystem.h

@@ -3134,10 +3134,16 @@ class ConstraintSystem {
         });
   }
 
-  /// Determine whether given declaration is unavailable in the current context.
+  /// Determine whether the given declaration is unavailable from the
+  /// current context.
   bool isDeclUnavailable(const Decl *D,
                          ConstraintLocator *locator = nullptr) const;
 
+  /// Determine whether the given conformance is unavailable from the
+  /// current context.
+  bool isConformanceUnavailable(ProtocolConformanceRef conformance,
+                                ConstraintLocator *locator = nullptr) const;
+
 public:
 
   /// Whether we should attempt to fix problems.

lib/Sema/CSSimplify.cpp

@@ -5612,11 +5612,16 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyConformsToConstraint(
     return SolutionKind::Unsolved;
   }
 
+  auto *loc = getConstraintLocator(locator);
+
   /// Record the given conformance as the result, adding any conditional
   /// requirements if necessary.
   auto recordConformance = [&](ProtocolConformanceRef conformance) {
     // Record the conformance.
-    CheckedConformances.push_back({getConstraintLocator(locator), conformance});
+    CheckedConformances.push_back({loc, conformance});
+
+    if (isConformanceUnavailable(conformance, loc))
+      increaseScore(SK_Unavailable);
 
     // This conformance may be conditional, in which case we need to consider
     // those requirements as constraints too.
@@ -5664,7 +5669,7 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyConformsToConstraint(
   auto protocolTy = protocol->getDeclaredInterfaceType();
 
   // If this conformance has been fixed already, let's just consider this done.
-  if (isFixedRequirement(getConstraintLocator(locator), protocolTy))
+  if (isFixedRequirement(loc, protocolTy))
     return SolutionKind::Solved;
 
   // If this is a generic requirement let's try to record that
@@ -5711,7 +5716,7 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyConformsToConstraint(
       auto dstType = getType(assignment->getDest());
 
       auto *fix = IgnoreAssignmentDestinationType::create(
-          *this, srcType, dstType, getConstraintLocator(locator));
+          *this, srcType, dstType, loc);
       return recordFix(fix) ? SolutionKind::Error : SolutionKind::Solved;
     }
 
@@ -5722,8 +5727,7 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyConformsToConstraint(
     // let's record it as a "contextual mismatch" because diagnostic
     // is going to be dependent on other contextual information.
     if (path.back().is<LocatorPathElt::ContextualType>()) {
-      auto *fix = ContextualMismatch::create(*this, type, protocolTy,
-                                             getConstraintLocator(locator));
+      auto *fix = ContextualMismatch::create(*this, type, protocolTy, loc);
       return recordFix(fix) ? SolutionKind::Error : SolutionKind::Solved;
     }
 
@@ -5761,7 +5765,6 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyConformsToConstraint(
     // If this is an implicit Hashable conformance check generated for each
     // index argument of the keypath subscript component, we could just treat
     // it as though it conforms.
-    auto *loc = getConstraintLocator(locator);
     if (loc->isResultOfKeyPathDynamicMemberLookup() ||
         loc->isKeyPathSubscriptComponent()) {
       if (protocol ==

lib/Sema/ConstraintSystem.cpp

@@ -22,6 +22,7 @@
 #include "swift/AST/Initializer.h"
 #include "swift/AST/GenericEnvironment.h"
 #include "swift/AST/ParameterList.h"
+#include "swift/AST/ProtocolConformance.h"
 #include "swift/AST/TypeCheckRequests.h"
 #include "swift/Basic/Statistic.h"
 #include "swift/Sema/CSFix.h"
@@ -5088,6 +5089,37 @@ bool ConstraintSystem::isDeclUnavailable(const Decl *D,
   return result.hasValue();
 }
 
+bool ConstraintSystem::isConformanceUnavailable(ProtocolConformanceRef conformance,
+                                                ConstraintLocator *locator) const {
+  if (!conformance.isConcrete())
+    return false;
+
+  auto *concrete = conformance.getConcrete();
+  auto *rootConf = concrete->getRootConformance();
+  auto *ext = dyn_cast<ExtensionDecl>(rootConf->getDeclContext());
+  if (ext == nullptr)
+    return false;
+
+  auto &ctx = getASTContext();
+
+  // First check whether this declaration is universally unavailable.
+  if (ext->getAttrs().isUnavailable(ctx))
+    return true;
+
+  SourceLoc loc;
+
+  if (locator) {
+    if (auto anchor = locator->getAnchor())
+      loc = getLoc(anchor);
+  }
+
+  // If not, let's check contextual unavailability.
+  ExportContext where = ExportContext::forFunctionBody(DC, loc);
+  auto result = TypeChecker::checkConformanceAvailability(
+      rootConf, ext, where);
+  return result.hasValue();
+}
+
 /// If we aren't certain that we've emitted a diagnostic, emit a fallback
 /// diagnostic.
 void ConstraintSystem::maybeProduceFallbackDiagnostic(

test/Sema/conformance_availability.swift

@@ -259,4 +259,66 @@ struct AssocConformanceAvailable4 {}
 @available(macOS 100, *)
 extension AssocConformanceAvailable4 : Rider {
 	typealias H = HasAvailableConformance1
-}
+}
+
+// Solution ranking should down-rank solutions involving unavailable conformances
+protocol First {}
+extension First {
+	func doStuff<T>(_: T) -> Bool {}
+}
+
+protocol Second {}
+extension Second {
+	func doStuff(_: Int) -> Int {}
+}
+
+struct ConformingType1 {}
+
+extension ConformingType1 : First {}
+
+@available(macOS 100, *)
+extension ConformingType1 : Second {}
+
+func usesConformingType1(_ c: ConformingType1) {
+  // We should pick First.doStuff() here, since Second.doStuff() is unavailable
+	let result = c.doStuff(123)
+	let _: Bool = result
+}
+
+@available(macOS 100, *)
+func usesConformingType1a(_ c: ConformingType1) {
+  // We should pick Second.doStuff() here, since it is more specialized than
+  // First.doStuff()
+	let result = c.doStuff(123)
+	let _: Int = result
+}
+
+// Same as above but unconditionally unavailable
+struct ConformingType2 {}
+
+extension ConformingType2 : First {}
+
+@available(*, unavailable)
+extension ConformingType2 : Second {}
+
+func usesConformingType2(_ c: ConformingType2) {
+  // We should pick First.doStuff() here, since Second.doStuff() is unavailable
+	let result = c.doStuff(123)
+	let _: Bool = result
+}
+
+// Make sure this also works for synthesized conformances
+struct UnavailableHashable {
+	let x: Int
+	let y: Int
+}
+
+@available(macOS 100, *)
+extension UnavailableHashable : Hashable {}
+
+func usesUnavailableHashable(_ c: UnavailableHashable) {
+  // expected-note@-1 2 {{add @available attribute to enclosing global function}}
+	_ = Set([c])
+	// expected-error@-1 2 {{conformance of 'UnavailableHashable' to 'Hashable' is only available in macOS 100 or newer}}
+	// expected-note@-2 2 {{add 'if #available' version check}}
+}