[Typed throws] Perform access control and availability checking on thrown errors

Author: DougGregor

include/swift/AST/DiagnosticsSema.def

@@ -2264,10 +2264,10 @@ ERROR(function_type_access,none,
       "%select{private|fileprivate|internal|package|%error|%error}1|private or fileprivate}2"
       "|cannot be declared "
       "%select{in this context|fileprivate|internal|package|public|open}1}0 "
-      "because its %select{parameter|result}5 uses "
+      "because its %select{parameter|thrown error|result}5 uses "
       "%select{a private|a fileprivate|an internal|a package|an '@_spi'|an '@_spi'}3"
       "%select{| API wrapper}6 type",
-      (bool, AccessLevel, bool, AccessLevel, unsigned, bool, bool))
+      (bool, AccessLevel, bool, AccessLevel, unsigned, unsigned, bool))
 ERROR(function_type_spi,none,
       "%select{function|method|initializer}0 "
       "cannot be declared '@_spi' "
@@ -2279,10 +2279,10 @@ WARNING(function_type_access_warn,none,
         "%select{function|method|initializer}4 "
         "%select{should be declared %select{private|fileprivate|internal|package|%error|%error}1"
         "|should not be declared %select{in this context|fileprivate|internal|package|public|open}1}0 "
-        "because its %select{parameter|result}5 uses "
+        "because its %select{parameter|thrown error|result}5 uses "
         "%select{a private|a fileprivate|an internal|a package|%error|%error}3 "
         "%select{|API wrapper}6 type",
-        (bool, AccessLevel, bool, AccessLevel, unsigned, bool, bool))
+        (bool, AccessLevel, bool, AccessLevel, unsigned, unsigned, bool))
 ERROR(function_type_usable_from_inline,none,
       "the %select{parameter|result}1%select{| API wrapper}2 of a "
       "'@usableFromInline' %select{function|method|initializer}0 "

lib/Sema/TypeCheckAccess.cpp

@@ -1040,10 +1040,18 @@ class AccessControlChecker : public AccessControlCheckerBase,
       FK_Initializer
     };
 
+    // This must stay in sync with diag::function_type_access
+    enum {
+      EK_Parameter = 0,
+      EK_ThrownError,
+      EK_Result
+    };
+
     auto minAccessScope = AccessScope::getPublic();
     const TypeRepr *complainRepr = nullptr;
     auto downgradeToWarning = DowngradeToWarning::No;
     ImportAccessLevel minImportLimit = llvm::None;
+    unsigned entityKind = EK_Parameter;
 
     bool hasInaccessibleParameterWrapper = false;
     for (auto *P : *fn->getParameters()) {
@@ -1085,7 +1093,25 @@ class AccessControlChecker : public AccessControlCheckerBase,
           });
     }
 
-    bool problemIsResult = false;
+    if (auto thrownTypeRepr = fn->getThrownTypeRepr()) {
+      checkTypeAccess(
+        fn->getThrownInterfaceType(), thrownTypeRepr, fn,
+        /*mayBeInferred*/ false,
+        [&](AccessScope typeAccessScope, const TypeRepr *thisComplainRepr,
+            DowngradeToWarning downgradeDiag, ImportAccessLevel importLimit) {
+          if (typeAccessScope.isChildOf(minAccessScope) ||
+              (!complainRepr &&
+               typeAccessScope.hasEqualDeclContextWith(minAccessScope))) {
+            minAccessScope = typeAccessScope;
+            complainRepr = thisComplainRepr;
+            downgradeToWarning = downgradeDiag;
+            minImportLimit = importLimit;
+            entityKind = EK_ThrownError;
+          }
+      });
+    }
+
+
     if (auto FD = dyn_cast<FuncDecl>(fn)) {
       checkTypeAccess(FD->getResultInterfaceType(), FD->getResultTypeRepr(),
                       FD, /*mayBeInferred*/false,
@@ -1100,7 +1126,7 @@ class AccessControlChecker : public AccessControlCheckerBase,
           complainRepr = thisComplainRepr;
           downgradeToWarning = downgradeDiag;
           minImportLimit = importLimit;
-          problemIsResult = true;
+          entityKind = EK_Result;
         }
       });
     }
@@ -1122,7 +1148,7 @@ class AccessControlChecker : public AccessControlCheckerBase,
         diagID = diag::function_type_access_warn;
       auto diag = fn->diagnose(diagID, isExplicit, fnAccess,
                                isa<FileUnit>(fn->getDeclContext()), minAccess,
-                               functionKind, problemIsResult,
+                               functionKind, entityKind,
                                hasInaccessibleParameterWrapper);
       highlightOffendingType(diag, complainRepr);
       noteLimitingImport(fn->getASTContext(), minImportLimit, complainRepr);
@@ -2174,6 +2200,10 @@ class DeclAvailabilityChecker : public DeclVisitor<DeclAvailabilityChecker> {
 
       checkType(P->getInterfaceType(), P->getTypeRepr(), fn);
     }
+
+    if (auto thrownTypeRepr = fn->getThrownTypeRepr()) {
+      checkType(fn->getThrownInterfaceType(), thrownTypeRepr, fn);
+    }
   }
 
   void visitFuncDecl(FuncDecl *FD) {

test/attr/typed_throws_availability_osx.swift

@@ -0,0 +1,15 @@
+// RUN: %swift -typecheck -verify -target x86_64-apple-macosx10.10 %s -enable-experimental-feature TypedThrows
+
+// REQUIRES: OS=macosx
+
+@available(macOS 12, *)
+enum MyError: Error {
+  case fail
+}
+
+@available(macOS 11, *)
+func throwMyErrorBadly() throws(MyError) { }
+// expected-error@-1{{'MyError' is only available in macOS 12 or newer}}
+
+
+

test/decl/func/typed_throws.swift

@@ -1,5 +1,6 @@
 // RUN: %target-typecheck-verify-swift -swift-version 5 -module-name test -enable-experimental-feature TypedThrows
 
+// expected-note@+1{{type declared here}}
 enum MyError: Error {
   case fail
 }
@@ -60,3 +61,6 @@ func testThrowingInFunction(cond: Bool, cond2: Bool) throws(MyError) {
     // expected-error@-1{{thrown expression type 'MyBadError' cannot be converted to error type 'MyError'}}
   }
 }
+
+public func testThrowingInternal() throws(MyError) { }
+// expected-error@-1{{function cannot be declared public because its thrown error uses an internal type}}