Sema: Check associated conformance availability

This replaces the old exportability check with a call into the
new general conformance availability check entry point.

Part of <rdar://problem/35158274>.

Author: slavapestov

lib/Sema/TypeCheckAvailability.cpp

@@ -222,6 +222,17 @@ ExportContext ExportContext::forFunctionBody(DeclContext *DC, SourceLoc loc) {
                        unavailablePlatformKind);
 }
 
+ExportContext ExportContext::forConformance(DeclContext *DC,
+                                            ProtocolDecl *proto) {
+  assert(isa<ExtensionDecl>(DC) || isa<NominalTypeDecl>(DC));
+  auto where = forDeclSignature(DC->getInnermostDeclarationDeclContext());
+
+  where.Exported &= proto->getFormalAccessScope(
+      DC, /*usableFromInlineAsPublic*/true).isPublic();
+
+  return where;
+}
+
 ExportContext ExportContext::withReason(ExportabilityReason reason) const {
   auto copy = *this;
   copy.Reason = unsigned(reason);
@@ -2172,20 +2183,19 @@ void TypeChecker::diagnoseIfDeprecated(SourceRange ReferenceRange,
   }
 }
 
-void TypeChecker::diagnoseIfDeprecated(
-    SourceLoc loc,
-    const RootProtocolConformance *rootConf,
-    const ExtensionDecl *ext,
-    const ExportContext &where) {
+bool TypeChecker::diagnoseIfDeprecated(SourceLoc loc,
+                                       const RootProtocolConformance *rootConf,
+                                       const ExtensionDecl *ext,
+                                       const ExportContext &where) {
   const AvailableAttr *attr = TypeChecker::getDeprecated(ext);
   if (!attr)
-    return;
+    return false;
 
   // We match the behavior of clang to not report deprecation warnings
   // inside declarations that are themselves deprecated on all deployment
   // targets.
   if (where.isDeprecated()) {
-    return;
+    return false;
   }
 
   auto *dc = where.getDeclContext();
@@ -2196,7 +2206,7 @@ void TypeChecker::diagnoseIfDeprecated(
       // Suppress a deprecation warning if the availability checking machinery
       // thinks the reference program location will not execute on any
       // deployment target for the current platform.
-      return;
+      return false;
     }
   }
 
@@ -2215,7 +2225,7 @@ void TypeChecker::diagnoseIfDeprecated(
              attr->Deprecated.hasValue(), deprecatedVersion,
              /*message*/ StringRef())
         .highlight(attr->getRange());
-    return;
+    return true;
   }
 
   EncodedDiagnosticMessage encodedMessage(attr->Message);
@@ -2225,6 +2235,7 @@ void TypeChecker::diagnoseIfDeprecated(
       attr->Deprecated.hasValue(), deprecatedVersion,
       encodedMessage.Message)
     .highlight(attr->getRange());
+  return true;
 }
 
 void swift::diagnoseUnavailableOverride(ValueDecl *override,
@@ -3374,7 +3385,8 @@ void swift::diagnoseTypeAvailability(const TypeRepr *TR, Type T, SourceLoc loc,
 bool
 swift::diagnoseConformanceAvailability(SourceLoc loc,
                                        ProtocolConformanceRef conformance,
-                                       const ExportContext &where) {
+                                       const ExportContext &where,
+                                       Type depTy, Type replacementTy) {
   assert(!where.isImplicit());
 
   if (!conformance.isConcrete())
@@ -3385,29 +3397,55 @@ swift::diagnoseConformanceAvailability(SourceLoc loc,
 
   auto *DC = where.getDeclContext();
 
+  auto maybeEmitAssociatedTypeNote = [&]() {
+    if (!depTy && !replacementTy)
+      return;
+
+    Type selfTy = rootConf->getProtocol()->getProtocolSelfType();
+    if (!depTy->isEqual(selfTy)) {
+      auto &ctx = DC->getASTContext();
+      ctx.Diags.diagnose(
+          loc,
+          diag::assoc_conformance_from_implementation_only_module,
+          depTy, replacementTy->getCanonicalType());
+    }
+  };
+
   if (auto *ext = dyn_cast<ExtensionDecl>(rootConf->getDeclContext())) {
-    if (TypeChecker::diagnoseConformanceExportability(loc, rootConf, ext, where))
+    if (TypeChecker::diagnoseConformanceExportability(loc, rootConf, ext, where)) {
+      maybeEmitAssociatedTypeNote();
       return true;
+    }
 
-    if (diagnoseExplicitUnavailability(loc, rootConf, ext, where))
+    if (diagnoseExplicitUnavailability(loc, rootConf, ext, where)) {
+      maybeEmitAssociatedTypeNote();
       return true;
-
-    // Diagnose for deprecation
-    TypeChecker::diagnoseIfDeprecated(loc, rootConf, ext, where);
+    }
 
     // Diagnose (and possibly signal) for potential unavailability
     auto maybeUnavail = TypeChecker::checkConformanceAvailability(
         rootConf, ext, where);
     if (maybeUnavail.hasValue()) {
       TypeChecker::diagnosePotentialUnavailability(rootConf, ext, loc, DC,
                                                    maybeUnavail.getValue());
+      maybeEmitAssociatedTypeNote();
+      return true;
+    }
+
+    // Diagnose for deprecation
+    if (TypeChecker::diagnoseIfDeprecated(loc, rootConf, ext, where)) {
+      maybeEmitAssociatedTypeNote();
+
+      // Deprecation is just a warning, so keep going with checking the
+      // substitution map below.
     }
   }
 
   // Now, check associated conformances.
   SubstitutionMap subConformanceSubs =
       concreteConf->getSubstitutions(DC->getParentModule());
-  if (diagnoseSubstitutionMapAvailability(loc, subConformanceSubs, where))
+  if (diagnoseSubstitutionMapAvailability(loc, subConformanceSubs, where,
+                                          depTy, replacementTy))
     return true;
 
   return false;
@@ -3416,10 +3454,12 @@ swift::diagnoseConformanceAvailability(SourceLoc loc,
 bool
 swift::diagnoseSubstitutionMapAvailability(SourceLoc loc,
                                            SubstitutionMap subs,
-                                           const ExportContext &where) {
+                                           const ExportContext &where,
+                                           Type depTy, Type replacementTy) {
   bool hadAnyIssues = false;
   for (ProtocolConformanceRef conformance : subs.getConformances()) {
-    if (diagnoseConformanceAvailability(loc, conformance, where))
+    if (diagnoseConformanceAvailability(loc, conformance, where,
+                                        depTy, replacementTy))
       hadAnyIssues = true;
   }
   return hadAnyIssues;

lib/Sema/TypeCheckAvailability.h

@@ -129,6 +129,11 @@ class ExportContext {
   /// it can reference anything.
   static ExportContext forFunctionBody(DeclContext *DC, SourceLoc loc);
 
+  /// Create an instance describing associated conformances that can be
+  /// referenced from the the conformance defined by the given DeclContext,
+  /// which must be a NominalTypeDecl or ExtensionDecl.
+  static ExportContext forConformance(DeclContext *DC, ProtocolDecl *proto);
+
   /// Produce a new context with the same properties as this one, except
   /// changing the ExportabilityReason. This only affects diagnostics.
   ExportContext withReason(ExportabilityReason reason) const;
@@ -212,12 +217,16 @@ void diagnoseTypeAvailability(const TypeRepr *TR, Type T, SourceLoc loc,
 bool
 diagnoseConformanceAvailability(SourceLoc loc,
                                 ProtocolConformanceRef conformance,
-                                const ExportContext &context);
+                                const ExportContext &context,
+                                Type depTy=Type(),
+                                Type replacementTy=Type());
 
 bool
 diagnoseSubstitutionMapAvailability(SourceLoc loc,
                                     SubstitutionMap subs,
-                                    const ExportContext &context);
+                                    const ExportContext &context,
+                                    Type depTy=Type(),
+                                    Type replacementTy=Type());
 
 /// Diagnose uses of unavailable declarations. Returns true if a diagnostic
 /// was emitted.

lib/Sema/TypeCheckProtocol.cpp

@@ -4308,54 +4308,6 @@ ResolveWitnessResult ConformanceChecker::resolveTypeWitnessViaLookup(
   return ResolveWitnessResult::ExplicitFailed;
 }
 
-static void checkExportability(Type depTy, Type replacementTy,
-                               const ProtocolConformance *conformance,
-                               NormalProtocolConformance *conformanceBeingChecked,
-                               DeclContext *DC) {
-  SourceFile *SF = DC->getParentSourceFile();
-  if (!SF)
-    return;
-
-  SubstitutionMap subs =
-      conformance->getSubstitutions(SF->getParentModule());
-  for (auto &subConformance : subs.getConformances()) {
-    if (!subConformance.isConcrete())
-      continue;
-    checkExportability(depTy, replacementTy, subConformance.getConcrete(),
-                       conformanceBeingChecked, DC);
-  }
-
-  const RootProtocolConformance *rootConformance =
-      conformance->getRootConformance();
-  ModuleDecl *M = rootConformance->getDeclContext()->getParentModule();
-
-  auto where = ExportContext::forDeclSignature(
-      DC->getInnermostDeclarationDeclContext());
-  auto originKind = getDisallowedOriginKind(
-      rootConformance->getDeclContext()->getAsDecl(),
-      where);
-  if (originKind == DisallowedOriginKind::None)
-    return;
-
-  ASTContext &ctx = SF->getASTContext();
-
-  Type selfTy = rootConformance->getProtocol()->getProtocolSelfType();
-
-  ctx.Diags.diagnose(
-      conformanceBeingChecked->getLoc(),
-      diag::conformance_from_implementation_only_module,
-      rootConformance->getType(),
-      rootConformance->getProtocol()->getName(), 0, M->getName(),
-      static_cast<unsigned>(originKind));
-
-  if (!depTy->isEqual(selfTy)) {
-    ctx.Diags.diagnose(
-        conformanceBeingChecked->getLoc(),
-        diag::assoc_conformance_from_implementation_only_module,
-        depTy, replacementTy->getCanonicalType());
-  }
-}
-
 void ConformanceChecker::ensureRequirementsAreSatisfied() {
   Conformance->finishSignatureConformances();
   auto proto = Conformance->getProtocol();
@@ -4401,18 +4353,21 @@ void ConformanceChecker::ensureRequirementsAreSatisfied() {
 
   // Now check that our associated conformances are at least as visible as
   // the conformance itself.
-  if (getRequiredAccessScope().isPublic() || isUsableFromInlineRequired()) {
-    for (auto req : proto->getRequirementSignature()) {
-      if (req.getKind() == RequirementKind::Conformance) {
-        auto depTy = req.getFirstType();
-        auto *proto = req.getSecondType()->castTo<ProtocolType>()->getDecl();
-        auto conformance = Conformance->getAssociatedConformance(depTy, proto);
-        if (conformance.isConcrete()) {
-          auto *concrete = conformance.getConcrete();
-          auto replacementTy = DC->mapTypeIntoContext(concrete->getType());
-          checkExportability(depTy, replacementTy, concrete,
-                             Conformance, DC);
-        }
+  auto where = ExportContext::forConformance(DC, proto);
+  if (where.isImplicit())
+    return;
+
+  for (auto req : proto->getRequirementSignature()) {
+    if (req.getKind() == RequirementKind::Conformance) {
+      auto depTy = req.getFirstType();
+      auto *proto = req.getSecondType()->castTo<ProtocolType>()->getDecl();
+      auto conformance = Conformance->getAssociatedConformance(depTy, proto);
+      if (conformance.isConcrete()) {
+        auto *concrete = conformance.getConcrete();
+        auto replacementTy = DC->mapTypeIntoContext(concrete->getType());
+        diagnoseConformanceAvailability(Conformance->getLoc(),
+                                        conformance, where,
+                                        depTy, replacementTy);
       }
     }
   }

lib/Sema/TypeChecker.h

@@ -1066,10 +1066,10 @@ void diagnoseIfDeprecated(SourceRange SourceRange,
                           const ApplyExpr *Call);
 
 /// Emits a diagnostic for a reference to a conformnace that is deprecated.
-void diagnoseIfDeprecated(SourceLoc Loc,
-                          const RootProtocolConformance *DeprecatedConf,
-                          const ExtensionDecl *Ext,
-                          const ExportContext &Where);
+bool diagnoseIfDeprecated(SourceLoc loc,
+                          const RootProtocolConformance *rootConf,
+                          const ExtensionDecl *ext,
+                          const ExportContext &where);
 /// @}
 
 /// If LangOptions::DebugForbidTypecheckPrefix is set and the given decl

test/Sema/conformance_availability.swift

@@ -16,7 +16,7 @@ public struct HasUnavailableConformance1 {}
 
 @available(*, unavailable)
 extension HasUnavailableConformance1 : Horse {}
-// expected-note@-1 6{{conformance of 'HasUnavailableConformance1' to 'Horse' has been explicitly marked unavailable here}}
+// expected-note@-1 7{{conformance of 'HasUnavailableConformance1' to 'Horse' has been explicitly marked unavailable here}}
 
 func passUnavailableConformance1(x: HasUnavailableConformance1) {
   takesHorse(x) // expected-error {{conformance of 'HasUnavailableConformance1' to 'Horse' is unavailable}}
@@ -212,4 +212,52 @@ func passAvailableConformance1a(x: HasAvailableConformance1) {
   takesHorse(x)
   x.giddyUp()
   _ = UsesHorse<HasAvailableConformance1>.self
+}
+
+// Associated conformance with unavailability
+protocol Rider {
+	associatedtype H : Horse
+}
+
+struct AssocConformanceUnavailable : Rider {
+// expected-error@-1 {{conformance of 'HasUnavailableConformance1' to 'Horse' is unavailable}}
+// expected-note@-2 {{in associated type 'Self.H' (inferred as 'HasUnavailableConformance1')}}
+	typealias H = HasUnavailableConformance1
+}
+
+// Associated conformance with deprecation
+struct AssocConformanceDeprecated : Rider {
+// expected-warning@-1 {{conformance of 'HasDeprecatedConformance1' to 'Horse' is deprecated}}
+// expected-note@-2 {{in associated type 'Self.H' (inferred as 'HasDeprecatedConformance1')}}
+	typealias H = HasDeprecatedConformance1
+}
+
+// Associated conformance with availability
+struct AssocConformanceAvailable1 : Rider {
+// expected-error@-1 {{conformance of 'HasAvailableConformance1' to 'Horse' is only available in macOS 100 or newer}}
+// expected-note@-2 {{in associated type 'Self.H' (inferred as 'HasAvailableConformance1')}}
+// FIXME expected-note@-3 {{add @available attribute to enclosing initializer}}
+// expected-note@-4 {{add @available attribute to enclosing struct}}
+	typealias H = HasAvailableConformance1
+}
+
+@available(macOS 100, *)
+struct AssocConformanceAvailable2 : Rider {
+	typealias H = HasAvailableConformance1
+}
+
+struct AssocConformanceAvailable3 {}
+
+extension AssocConformanceAvailable3 : Rider {
+// expected-error@-1 {{conformance of 'HasAvailableConformance1' to 'Horse' is only available in macOS 100 or newer}}
+// expected-note@-2 {{in associated type 'Self.H' (inferred as 'HasAvailableConformance1')}}
+// expected-note@-3 {{add @available attribute to enclosing extension}}
+	typealias H = HasAvailableConformance1
+}
+
+struct AssocConformanceAvailable4 {}
+
+@available(macOS 100, *)
+extension AssocConformanceAvailable4 : Rider {
+	typealias H = HasAvailableConformance1
 }