Sema: Add some missing checks for where clauses on non-generic declarations

Access control, availability and exportability checking missed these
because of a baked-in assumption that getGenericParams() == nullptr
rules out the presence of a trailing where clause.

Author: slavapestov

lib/Sema/TypeCheckAccess.cpp

@@ -323,11 +323,10 @@ void AccessControlCheckerBase::checkGenericParamAccess(
     const Decl *ownerDecl,
     AccessScope accessScope,
     AccessLevel contextAccess) {
-  auto params = ownerCtx->getGenericParams();
-  if (!params)
+  if (!ownerCtx->isGenericContext())
     return;
 
-  // This must stay in sync with diag::generic_param_access.
+ // This must stay in sync with diag::generic_param_access.
   enum class ACEK {
     Parameter = 0,
     Requirement
@@ -355,20 +354,25 @@ void AccessControlCheckerBase::checkGenericParamAccess(
 
   auto *DC = ownerDecl->getDeclContext();
 
-  for (auto param : *params) {
-    if (param->getInherited().empty())
-      continue;
-    assert(param->getInherited().size() == 1);
-    checkTypeAccessImpl(param->getInherited().front().getType(),
-                        param->getInherited().front().getTypeRepr(),
-                        accessScope, DC, /*mayBeInferred*/false,
-                        callback);
+  if (auto params = ownerCtx->getGenericParams()) {
+    for (auto param : *params) {
+      if (param->getInherited().empty())
+        continue;
+      assert(param->getInherited().size() == 1);
+      checkTypeAccessImpl(param->getInherited().front().getType(),
+                          param->getInherited().front().getTypeRepr(),
+                          accessScope, DC, /*mayBeInferred*/false,
+                          callback);
+    }
   }
+
   callbackACEK = ACEK::Requirement;
 
-  checkRequirementAccess(WhereClauseOwner(
-                           const_cast<GenericContext *>(ownerCtx)),
-                         accessScope, DC, callback);
+  if (ownerCtx->getTrailingWhereClause()) {
+    checkRequirementAccess(WhereClauseOwner(
+                             const_cast<GenericContext *>(ownerCtx)),
+                           accessScope, DC, callback);
+  }
 
   if (minAccessScope.isPublic())
     return;
@@ -1624,23 +1628,26 @@ class ExportabilityChecker : public DeclVisitor<ExportabilityChecker> {
 
   void checkGenericParams(const GenericContext *ownerCtx,
                           const ValueDecl *ownerDecl) {
-    const auto params = ownerCtx->getGenericParams();
-    if (!params)
+    if (!ownerCtx->isGenericContext())
       return;
 
-    for (auto param : *params) {
-      if (param->getInherited().empty())
-        continue;
-      assert(param->getInherited().size() == 1);
-      checkType(param->getInherited().front(), ownerDecl,
-                getDiagnoser(ownerDecl));
+    if (auto params = ownerCtx->getGenericParams()) {
+      for (auto param : *params) {
+        if (param->getInherited().empty())
+          continue;
+        assert(param->getInherited().size() == 1);
+        checkType(param->getInherited().front(), ownerDecl,
+                  getDiagnoser(ownerDecl));
+      }
     }
 
-    forAllRequirementTypes(WhereClauseOwner(
-                             const_cast<GenericContext *>(ownerCtx)),
-                           [&](Type type, TypeRepr *typeRepr) {
-      checkType(type, typeRepr, ownerDecl, getDiagnoser(ownerDecl));
-    });
+    if (ownerCtx->getTrailingWhereClause()) {
+      forAllRequirementTypes(WhereClauseOwner(
+                               const_cast<GenericContext *>(ownerCtx)),
+                             [&](Type type, TypeRepr *typeRepr) {
+        checkType(type, typeRepr, ownerDecl, getDiagnoser(ownerDecl));
+      });
+    }
   }
 
   // This enum must be kept in sync with
@@ -2076,24 +2083,26 @@ class DeclAvailabilityChecker : public DeclVisitor<DeclAvailabilityChecker> {
 
   void checkGenericParams(const GenericContext *ownerCtx,
                           const ValueDecl *ownerDecl) {
-    // FIXME: What if we have a where clause and no generic params?
-    const auto params = ownerCtx->getGenericParams();
-    if (!params)
+    if (!ownerCtx->isGenericContext())
       return;
 
-    for (auto param : *params) {
-      if (param->getInherited().empty())
-        continue;
-      assert(param->getInherited().size() == 1);
-      auto inherited = param->getInherited().front();
-      checkType(inherited.getType(), inherited.getTypeRepr(), ownerDecl);
+    if (auto params = ownerCtx->getGenericParams()) {
+      for (auto param : *params) {
+        if (param->getInherited().empty())
+          continue;
+        assert(param->getInherited().size() == 1);
+        auto inherited = param->getInherited().front();
+        checkType(inherited.getType(), inherited.getTypeRepr(), ownerDecl);
+      }
     }
 
-    forAllRequirementTypes(WhereClauseOwner(
-                             const_cast<GenericContext *>(ownerCtx)),
-                           [&](Type type, TypeRepr *typeRepr) {
-      checkType(type, typeRepr, ownerDecl);
-    });
+    if (ownerCtx->getTrailingWhereClause()) {
+      forAllRequirementTypes(WhereClauseOwner(
+                               const_cast<GenericContext *>(ownerCtx)),
+                             [&](Type type, TypeRepr *typeRepr) {
+        checkType(type, typeRepr, ownerDecl);
+      });
+    }
   }
 
 public:

test/Sema/accessibility_where.swift

@@ -87,3 +87,12 @@ protocol Protocol7 : BaseProtocol where T == (PrivateStruct) -> Void {
   associatedtype X : BaseProtocol where X.T == (PrivateStruct) -> Void
   // expected-error@-1 {{associated type in an internal protocol uses a private type in its requirement}}
 }
+
+private protocol PrivateProtocol {} // expected-note 2{{type declared here}}
+
+struct GenericStruct<T> {
+  struct Inner where T : PrivateProtocol {}
+  // expected-error@-1 {{struct must be declared private because its generic requirement uses a private type}}
+  func nonGenericWhereClause() where T : PrivateProtocol {}
+  // expected-error@-1 {{instance method must be declared private because its generic requirement uses a private type}}
+}

test/Sema/availability_versions.swift

@@ -928,6 +928,14 @@ func GenericSignature<T : ProtocolAvailableOn10_51>(_ t: T) { // expected-error
       // expected-note@-1 * {{add @available attribute to enclosing global function}}
 }
 
+struct GenericType<T> { // expected-note {{add @available attribute to enclosing generic struct}}
+  func nonGenericWhereClause() where T : ProtocolAvailableOn10_51 {} // expected-error {{'ProtocolAvailableOn10_51' is only available in macOS 10.51 or newer}}
+  // expected-note@-1 {{add @available attribute to enclosing instance method}}
+
+  struct NestedType where T : ProtocolAvailableOn10_51 {} // expected-error {{'ProtocolAvailableOn10_51' is only available in macOS 10.51 or newer}}
+  // expected-note@-1 2{{add @available attribute to enclosing struct}}
+}
+
 // Extensions
 
 extension ClassAvailableOn10_51 { } // expected-error {{'ClassAvailableOn10_51' is only available in macOS 10.51 or newer}}

test/Sema/implementation-only-import-in-decls.swift

@@ -21,6 +21,11 @@ public struct TestGenericParams<T: BadProto> {} // expected-error {{cannot use p
 
 public struct TestGenericParamsWhereClause<T> where T: BadProto {} // expected-error {{cannot use protocol 'BadProto' here; 'BADLibrary' has been imported as implementation-only}}
 
+public struct TestGenericParamsWithOuter<T> {
+  public func nonGenericWhereClause() where T : BadProto {} // expected-error {{cannot use protocol 'BadProto' here; 'BADLibrary' has been imported as implementation-only}}
+  public struct Inner where T : BadProto {} // expected-error {{cannot use protocol 'BadProto' here; 'BADLibrary' has been imported as implementation-only}}
+}
+
 public enum TestCase {
   case x(BadStruct) // expected-error {{cannot use struct 'BadStruct' here; 'BADLibrary' has been imported as implementation-only}}
   case y(Int, BadStruct) // expected-error {{cannot use struct 'BadStruct' here; 'BADLibrary' has been imported as implementation-only}}

test/attr/attr_usableFromInline.swift

@@ -155,3 +155,11 @@ public struct TestGenericSubscripts {
 
 @usableFromInline typealias TestGenericAlias<T: InternalProtocol> = T // expected-warning {{type referenced from a generic parameter of a '@usableFromInline' type alias should be '@usableFromInline' or public}}
 @usableFromInline typealias TestGenericAliasWhereClause<T> = T where T: InternalProtocol // expected-warning {{type referenced from a generic requirement of a '@usableFromInline' type alias should be '@usableFromInline' or public}}
+
+@usableFromInline struct GenericStruct<T> {
+  @usableFromInline struct Nested where T : InternalProtocol {}
+  // expected-error@-1 {{type referenced from a generic requirement of a '@usableFromInline' struct must be '@usableFromInline' or public}}
+
+  @usableFromInline func nonGenericWhereClause() where T : InternalProtocol {}
+  // expected-error@-1 {{type referenced from a generic requirement of a '@usableFromInline' instance method must be '@usableFromInline' or public}}
+}