Sema: Pass ValueDecl instead of ConcreteDeclRef in a few places in availability checking

The substitution map is checked elsewhere.

Author: slavapestov

lib/Sema/ResilienceDiagnostics.cpp

@@ -28,12 +28,11 @@
 using namespace swift;
 
 bool TypeChecker::diagnoseInlinableDeclRef(SourceLoc loc,
-                                           ConcreteDeclRef declRef,
+                                           const ValueDecl *D,
                                            const DeclContext *DC,
                                            FragileFunctionKind Kind) {
   assert(Kind.kind != FragileFunctionKind::None);
 
-  const ValueDecl *D = declRef.getDecl();
   // Do some important fast-path checks that apply to all cases.
 
   // Type parameters are OK.
@@ -48,7 +47,7 @@ bool TypeChecker::diagnoseInlinableDeclRef(SourceLoc loc,
   // Skip this check for accessors because the associated property or subscript
   // will also be checked, and will provide a better error message.
   if (!isa<AccessorDecl>(D))
-    if (diagnoseDeclRefExportability(loc, declRef, DC,
+    if (diagnoseDeclRefExportability(loc, D, DC,
                                      None, Kind))
       return true;
 
@@ -141,19 +140,22 @@ bool TypeChecker::diagnoseInlinableDeclRefAccess(SourceLoc loc,
   return (downgradeToWarning == DowngradeToWarning::No);
 }
 
-static bool diagnoseDeclExportability(SourceLoc loc, const ValueDecl *D,
-                                      const SourceFile &userSF,
-                                      const DeclContext *userDC,
-                                      Optional<ExportabilityReason> reason,
-                                      FragileFunctionKind fragileKind) {
+bool
+TypeChecker::diagnoseDeclRefExportability(SourceLoc loc,
+                                          const ValueDecl *D,
+                                          const DeclContext *DC,
+                                          Optional<ExportabilityReason> reason,
+                                          FragileFunctionKind fragileKind) {
   if (fragileKind.kind == FragileFunctionKind::None && !reason.hasValue())
     return false;
 
   auto definingModule = D->getModuleContext();
 
   auto downgradeToWarning = DowngradeToWarning::No;
   auto originKind = getDisallowedOriginKind(
-      D, userSF, userDC->getInnermostDeclarationDeclContext(),
+      D,
+      *DC->getParentSourceFile(),
+      DC->getInnermostDeclarationDeclContext(),
       downgradeToWarning);
   if (originKind == DisallowedOriginKind::None)
     return false;
@@ -211,20 +213,3 @@ TypeChecker::diagnoseConformanceExportability(SourceLoc loc,
                      static_cast<unsigned>(originKind));
   return true;
 }
-
-bool
-TypeChecker::diagnoseDeclRefExportability(SourceLoc loc,
-                                          ConcreteDeclRef declRef,
-                                          const DeclContext *DC,
-                                          Optional<ExportabilityReason> reason,
-                                          FragileFunctionKind fragileKind) {
-  // We're only interested in diagnosing uses from source files.
-  auto userSF = DC->getParentSourceFile();
-  if (!userSF)
-    return false;
-
-  const ValueDecl *D = declRef.getDecl();
-  if (diagnoseDeclExportability(loc, D, *userSF, DC, reason, fragileKind))
-    return true;
-  return false;
-}

lib/Sema/TypeCheckAvailability.cpp

@@ -2653,11 +2653,11 @@ AvailabilityWalker::diagAvailability(ConcreteDeclRef declRef, SourceRange R,
 
   if (FragileKind.kind != FragileFunctionKind::None) {
     if (R.isValid())
-      if (TypeChecker::diagnoseInlinableDeclRef(R.Start, declRef, DC, FragileKind))
+      if (TypeChecker::diagnoseInlinableDeclRef(R.Start, D, DC, FragileKind))
         return true;
   } else if (ExportReason.hasValue()) {
     if (R.isValid())
-      if (TypeChecker::diagnoseDeclRefExportability(R.Start, declRef, DC,
+      if (TypeChecker::diagnoseDeclRefExportability(R.Start, D, DC,
                                                     ExportReason, FragileKind))
         return true;
   }

lib/Sema/TypeChecker.h

@@ -947,7 +947,7 @@ DeclName getObjectLiteralConstructorName(ASTContext &ctx,
 ModuleDecl *getStdlibModule(const DeclContext *dc);
 
 /// \name Resilience diagnostics
-bool diagnoseInlinableDeclRef(SourceLoc loc, ConcreteDeclRef declRef,
+bool diagnoseInlinableDeclRef(SourceLoc loc, const ValueDecl *D,
                               const DeclContext *DC, FragileFunctionKind Kind);
 
 Expr *buildDefaultInitializer(Type type);
@@ -959,7 +959,8 @@ bool diagnoseInlinableDeclRefAccess(SourceLoc loc, const ValueDecl *D,
 /// Given that a declaration is used from a particular context which
 /// exposes it in the interface of the current module, diagnose if it cannot
 /// reasonably be shared.
-bool diagnoseDeclRefExportability(SourceLoc loc, ConcreteDeclRef declRef,
+bool diagnoseDeclRefExportability(SourceLoc loc,
+                                  const ValueDecl *D,
                                   const DeclContext *DC,
                                   Optional<ExportabilityReason> exportability,
                                   FragileFunctionKind fragileKind);