Sema: Resilience diagnostics pre-compute a few things

Author: slavapestov

lib/Sema/ResilienceDiagnostics.cpp

@@ -72,13 +72,8 @@ void TypeChecker::diagnoseInlinableLocalType(const NominalTypeDecl *NTD) {
 
 bool TypeChecker::diagnoseInlinableDeclRef(SourceLoc loc,
                                            const ValueDecl *D,
-                                           const DeclContext *DC) {
-  auto expansion = DC->getResilienceExpansion();
-
-  // Internal declarations referenced from non-inlinable contexts are OK.
-  if (expansion == ResilienceExpansion::Maximal)
-    return false;
-
+                                           const DeclContext *DC,
+                                           FragileFunctionKind Kind) {
   // Local declarations are OK.
   if (D->getDeclContext()->isLocalContext())
     return false;
@@ -89,7 +84,7 @@ bool TypeChecker::diagnoseInlinableDeclRef(SourceLoc loc,
 
   // Public declarations are OK.
   if (D->getFormalAccessScope(/*useDC=*/nullptr,
-                              /*respectVersionedAttr=*/true).isPublic())
+                              /*treatUsableFromInlineAsPublic*/true).isPublic())
     return false;
 
   // Enum cases are handled as part of their containing enum.
@@ -114,7 +109,7 @@ bool TypeChecker::diagnoseInlinableDeclRef(SourceLoc loc,
   diagnose(loc, diag::resilience_decl_unavailable,
            D->getDescriptiveKind(), D->getFullName(),
            D->getFormalAccessScope().accessLevelForDiagnostics(),
-           static_cast<unsigned>(getFragileFunctionKind(DC)));
+           static_cast<unsigned>(Kind));
 
   bool isDefaultArgument = false;
   while (DC->isLocalContext()) {

lib/Sema/TypeCheckAvailability.cpp

@@ -2233,10 +2233,16 @@ class AvailabilityWalker : public ASTWalker {
   DeclContext *DC;
   MemberAccessContext AccessContext = MemberAccessContext::Getter;
   SmallVector<const Expr *, 16> ExprStack;
+  ResilienceExpansion Expansion;
+  Optional<TypeChecker::FragileFunctionKind> FragileKind;
 
 public:
   AvailabilityWalker(
-      TypeChecker &TC, DeclContext *DC) : TC(TC), DC(DC) {}
+      TypeChecker &TC, DeclContext *DC) : TC(TC), DC(DC) {
+    Expansion = DC->getResilienceExpansion();
+    if (Expansion == ResilienceExpansion::Minimal)
+      FragileKind = TC.getFragileFunctionKind(DC);
+  }
 
   std::pair<bool, Expr *> walkToExprPre(Expr *E) override {
     ExprStack.push_back(E);
@@ -2457,9 +2463,10 @@ bool AvailabilityWalker::diagAvailability(const ValueDecl *D, SourceRange R,
       return true;
   }
 
-  if (R.isValid())
-    if (TC.diagnoseInlinableDeclRef(R.Start, D, DC))
-      return true;
+  if (FragileKind)
+    if (R.isValid())
+      if (TC.diagnoseInlinableDeclRef(R.Start, D, DC, *FragileKind))
+        return true;
 
   if (TC.diagnoseExplicitUnavailability(D, R, DC, call))
     return true;

lib/Sema/TypeChecker.h

@@ -2298,9 +2298,6 @@ class TypeChecker final : public LazyResolver {
 
   void diagnoseInlinableLocalType(const NominalTypeDecl *NTD);
 
-  bool diagnoseInlinableDeclRef(SourceLoc loc, const ValueDecl *D,
-                                const DeclContext *DC);
-
   /// Used in diagnostic %selects.
   enum class FragileFunctionKind : unsigned {
     Transparent,
@@ -2310,6 +2307,10 @@ class TypeChecker final : public LazyResolver {
     PropertyInitializer
   };
 
+  bool diagnoseInlinableDeclRef(SourceLoc loc, const ValueDecl *D,
+                                const DeclContext *DC,
+                                FragileFunctionKind Kind);
+
   /// Given that \p DC is within a fragile context for some reason, describe
   /// why.
   ///