[SE-0404] Allow protocols to be nested in non-generic contexts

Author: karwa

include/swift/AST/DiagnosticsSema.def

@@ -2162,9 +2162,12 @@ ERROR(unsupported_type_nested_in_protocol,none,
 ERROR(unsupported_type_nested_in_protocol_extension,none,
       "type %0 cannot be nested in protocol extension of %1",
       (const NominalTypeDecl *, const ProtocolDecl *))
-ERROR(unsupported_nested_protocol,none,
-      "protocol %0 cannot be nested inside another declaration",
+ERROR(unsupported_nested_protocol_in_generic,none,
+      "protocol %0 cannot be nested in a generic context",
       (const NominalTypeDecl *))
+ERROR(unsupported_nested_protocol_in_protocol,none,
+      "protocol %0 cannot be nested in protocol %1",
+      (const NominalTypeDecl *, const NominalTypeDecl *))
 ERROR(where_nongeneric_ctx,none,
       "'where' clause on non-generic member declaration requires a "
       "generic context", ())

include/swift/AST/TypeMemberVisitor.h

@@ -37,7 +37,6 @@ class TypeMemberVisitor : public DeclVisitor<ImplClass, RetTy> {
   }
   BAD_MEMBER(Extension)
   BAD_MEMBER(Import)
-  BAD_MEMBER(Protocol)
   BAD_MEMBER(TopLevelCode)
   BAD_MEMBER(Operator)
   BAD_MEMBER(PrecedenceGroup)

lib/AST/ASTScopeLookup.cpp

@@ -191,8 +191,7 @@ void ASTScopeImpl::lookup(const NullablePtr<const ASTScopeImpl> limit,
   consumer.startingNextLookupStep();
 #endif
 
-  // Certain illegal nestings, e.g. protocol nestled inside a struct,
-  // require that lookup stop at the outer scope.
+  // Certain illegal nestings require that lookup stop at the outer scope.
   if (this == limit.getPtrOrNull()) {
 #ifndef NDEBUG
     consumer.finishingLookup("limit return");
@@ -556,13 +555,13 @@ GenericTypeOrExtensionScope::getLookupLimitForDecl() const {
 
 NullablePtr<const ASTScopeImpl>
 NominalTypeScope::getLookupLimitForDecl() const {
-  if (isa<ProtocolDecl>(decl)) {
-    // ProtocolDecl can only be legally nested in a SourceFile,
-    // so any other kind of Decl is illegal
-    return parentIfNotChildOfTopScope();
-  }
-  // AFAICT, a struct, decl, or enum can be nested inside anything
-  // but a ProtocolDecl.
+  // If a protocol is (invalidly) nested in a generic context,
+  // do not look in to those outer generic contexts,
+  // as types found there may contain implicitly inferred generic parameters.
+  if (isa<ProtocolDecl>(decl) && decl->getDeclContext()->isGenericContext())
+    return getLookupParent();
+
+  // Otherwise, nominals can be nested inside anything but a ProtocolDecl.
   return ancestorWithDeclSatisfying(
       [&](const Decl *const d) { return isa<ProtocolDecl>(d); });
 }

lib/AST/Decl.cpp

@@ -4813,11 +4813,10 @@ static Type computeNominalType(NominalTypeDecl *decl, DeclTypeKind kind) {
   // If `decl` is a nested type, find the parent type.
   Type ParentTy;
   DeclContext *dc = decl->getDeclContext();
-  bool isObjCProtocol = isa<ProtocolDecl>(decl) && decl->hasClangNode();
+  bool isUnsupportedNestedProtocol =
+    isa<ProtocolDecl>(decl) && decl->getParent()->isGenericContext();
 
-  // Objective-C protocols, unlike Swift protocols, could be nested
-  // in other types.
-  if ((isObjCProtocol || !isa<ProtocolDecl>(decl)) && dc->isTypeContext()) {
+  if (!isUnsupportedNestedProtocol && dc->isTypeContext()) {
     switch (kind) {
     case DeclTypeKind::DeclaredType: {
       if (auto *nominal = dc->getSelfNominalTypeDecl())
@@ -4854,9 +4853,9 @@ static Type computeNominalType(NominalTypeDecl *decl, DeclTypeKind kind) {
     }
 
     llvm_unreachable("Unhandled DeclTypeKind in switch.");
-  } else {
-    return NominalType::get(decl, ParentTy, ctx);
   }
+
+  return NominalType::get(decl, ParentTy, ctx);
 }
 
 Type NominalTypeDecl::getDeclaredType() const {

lib/AST/DeclContext.cpp

@@ -150,6 +150,10 @@ void DeclContext::forEachGenericContext(
       if (auto genericCtx = decl->getAsGenericContext())
         if (auto *gpList = genericCtx->getGenericParams())
           fn(gpList);
+
+      // Protocols do not capture outer generic parameters.
+      if (isa<ProtocolDecl>(decl))
+        return;
     }
   } while ((dc = dc->getParentForLookup()));
 }
@@ -277,8 +281,8 @@ DeclContext *DeclContext::getInnermostSkippedFunctionContext() {
 }
 
 DeclContext *DeclContext::getParentForLookup() const {
-  if (isa<ProtocolDecl>(this) || isa<ExtensionDecl>(this)) {
-    // If we are inside a protocol or an extension, skip directly
+  if (isa<ExtensionDecl>(this)) {
+    // If we are inside an extension, skip directly
     // to the module scope context, without looking at any (invalid)
     // outer types.
     return getModuleScopeContext();

lib/IRGen/GenDecl.cpp

@@ -5600,7 +5600,6 @@ void IRGenModule::emitNestedTypeDecls(DeclRange members) {
     switch (member->getKind()) {
     case DeclKind::Import:
     case DeclKind::TopLevelCode:
-    case DeclKind::Protocol:
     case DeclKind::Extension:
     case DeclKind::InfixOperator:
     case DeclKind::PrefixOperator:
@@ -5656,6 +5655,9 @@ void IRGenModule::emitNestedTypeDecls(DeclRange members) {
     case DeclKind::Class:
       emitClassDecl(cast<ClassDecl>(member));
       continue;
+    case DeclKind::Protocol:
+      emitProtocolDecl(cast<ProtocolDecl>(member));
+      continue;
     case DeclKind::MacroExpansion:
       // Expansion already visited as auxiliary decls.
       continue;

lib/Parse/ParseDecl.cpp

@@ -9315,7 +9315,7 @@ parseDeclProtocol(ParseDeclOptions Flags, DeclAttributes &Attributes) {
       ProtocolDecl(CurDeclContext, ProtocolLoc, NameLoc, ProtocolName,
                    Context.AllocateCopy(PrimaryAssociatedTypeNames),
                    Context.AllocateCopy(InheritedProtocols), TrailingWhere);
-  // No need to setLocalDiscriminator: protocols can't appear in local contexts.
+  recordLocalType(Proto);
 
   Proto->getAttrs() = Attributes;
   if (whereClauseHadCodeCompletion && CodeCompletionCallbacks)

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -2672,10 +2672,15 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
                     kind.getSelector());
     }
 
-    // We don't support protocols outside the top level of a file.
-    if (isa<ProtocolDecl>(NTD) &&
-        !NTD->getParent()->isModuleScopeContext()) {
-      NTD->diagnose(diag::unsupported_nested_protocol, NTD);
+    // We don't support protocols nested in generic contexts.
+    // This includes protocols nested in other protocols.
+    if (isa<ProtocolDecl>(NTD) && NTD->getParent()->isGenericContext()) {
+      if (auto *OuterPD = NTD->getParent()->getSelfProtocolDecl())
+        NTD->diagnose(diag::unsupported_nested_protocol_in_protocol, NTD,
+                      OuterPD);
+      else
+        NTD->diagnose(diag::unsupported_nested_protocol_in_generic, NTD);
+
       NTD->setInvalid();
       return;
     }
@@ -2688,6 +2693,7 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
       } else {
         NTD->diagnose(diag::unsupported_type_nested_in_protocol, NTD, proto);
       }
+      NTD->setInvalid();
     }
 
     // We don't support nested types in generic functions yet.
@@ -2700,6 +2706,7 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
         } else {
           NTD->diagnose(diag::unsupported_type_nested_in_generic_closure, NTD);
         }
+        NTD->setInvalid();
       }
     }
   }
@@ -3178,6 +3185,15 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
     if (!PD->getPrimaryAssociatedTypeNames().empty())
       (void) PD->getPrimaryAssociatedTypes();
 
+    // We cannot compute the requirement signature of a protocol
+    // in a generic context, because superclass constraints
+    // may include implicitly inferred generic arguments that are
+    // not part of the protocol's generic signature.
+    if (PD->getParent()->isGenericContext()) {
+      assert(PD->isInvalid());
+      return;
+    }
+
     // Explicitly compute the requirement signature to detect errors.
     // Do this before visiting members, to avoid a request cycle if
     // a member references another declaration whose generic signature

test/IRGen/protocol_metadata.swift

@@ -118,3 +118,60 @@ protocol Comprehensive {
 // CHECK-SAME:   %swift.protocol_requirement { i32 4, i32 0 },
 // CHECK-SAME:   %swift.protocol_requirement { i32 6, i32 0 }
 
+  struct ParentType {
+
+    // NESTED: [[NESTED_NAME:@.*]] = private constant [7 x i8] c"Nested\00"
+    // NESTED: [[NESTED_RETURNVALUE_NAME:@.*]] = private constant [12 x i8] c"ReturnValue\00"
+
+    // NESTED: @"$s17protocol_metadata10ParentTypeV6NestedMp" = hidden constant
+    // NESTED-SAME: i32 65603,
+    // NESTED-SAME: @"$s17protocol_metadata10ParentTypeVMn"
+    // NESTED-SAME: @"$s17protocol_metadata10ParentTypeV6NestedMp", i32 0, i32 1)
+    // NESTED-SAME: [7 x i8]* [[NESTED_NAME]]
+    // NESTED-SAME: @"$s17protocol_metadata10ParentTypeV6NestedMp", i32 0, i32 2)
+    // NESTED-SAME: i32 0,
+    // NESTED-SAME: i32 2,
+    // NESTED-SAME: [12 x i8]* [[NESTED_RETURNVALUE_NAME]]
+    // NESTED-SAME: @"$s17protocol_metadata10ParentTypeV6NestedMp", i32 0, i32 5)
+    // NESTED-SAME: %swift.protocol_requirement { i32 7, i32 0 },
+    // NESTED-SAME: %swift.protocol_requirement { i32 17, i32 0 }
+    protocol Nested {
+      associatedtype ReturnValue
+      func doSomething() -> ReturnValue
+    }
+  }
+
+  extension ParentType {
+
+    // NESTED: [[NESTEDVIAEXT_NAME:@.*]] = private constant [19 x i8] c"NestedViaExtension\00"
+
+    // NESTED: @"$s17protocol_metadata10ParentTypeV18NestedViaExtensionMp" = hidden constant
+    // NESTED-SAME: i32 65603,
+    // NESTED-SAME: @"$s17protocol_metadata10ParentTypeVMn"
+    // NESTED-SAME: @"$s17protocol_metadata10ParentTypeV18NestedViaExtensionMp", i32 0, i32 1)
+    // NESTED-SAME: [19 x i8]* [[NESTEDVIAEXT_NAME]]
+    // NESTED-SAME: @"$s17protocol_metadata10ParentTypeV18NestedViaExtensionMp", i32 0, i32 2)
+    // NESTED-SAME: i32 0,
+    // NESTED-SAME: i32 1,
+    // NESTED-SAME: i32 0,
+    // NESTED-SAME: %swift.protocol_requirement { i32 17, i32 0 }
+    protocol NestedViaExtension {
+      func foo()
+    }
+  }
+
+  func parentFunc() {
+    // NESTED: @"$s17protocol_metadata10parentFuncyyF6NestedL_Mp" = internal constant
+    // NESTED-SAME: i32 65603,
+    // NESTED-SAME: @"$s17protocol_metadata10parentFuncyyF6NestedL_PMXX"
+    // NESTED-SAME: @"$s17protocol_metadata10parentFuncyyF6NestedL_Mp", i32 0, i32 1)
+    // NESTED-SAME: [7 x i8]* [[NESTED_NAME]]
+    // NESTED-SAME: @"$s17protocol_metadata10parentFuncyyF6NestedL_Mp", i32 0, i32 2)
+    // NESTED-SAME: i32 0,
+    // NESTED-SAME: i32 1,
+    // NESTED-SAME: i32 0,
+    // NESTED-SAME: %swift.protocol_requirement { i32 17, i32 0 }
+    protocol Nested {
+      func foo()
+    }
+  }

test/PrintAsObjC/classes.swift

@@ -409,6 +409,12 @@ class MyObject : NSObject {}
     @objc @objcMembers class DeeperIn {}
   }
 
+  // CHECK-LABEL: SWIFT_CLASS_NAMED("CustomNameInner")
+  // CHECK-NEXT: @interface MyInnerClass
+  // CHECK-NEXT: init
+  // CHECK-NEXT: @end
+  @objc(MyInnerClass) @objcMembers class CustomNameInner {}
+
   // CHECK-LABEL: @interface AnotherInner : A1
   // CHECK-NEXT: init
   // CHECK-NEXT: @end

test/PrintAsObjC/protocols.swift

@@ -137,6 +137,26 @@ extension NSString : A, ZZZ {}
   @objc optional func f()
 }
 
+// NESTED-LABEL: @interface ParentClass
+// NESTED-NEXT: @end
+@objc class ParentClass {
+
+  // NESTED-LABEL: @protocol Nested
+  // NESTED-NEXT: @end
+  @objc protocol Nested {}
+
+  // NESTED-LABEL: SWIFT_PROTOCOL_NAMED("Nested2")
+  // NESTED-NEXT: @protocol NestedInParent
+  // NESTED-NEXT: @end
+  @objc(NestedInParent) protocol Nested2 {}
+}
+
+extension ParentClass {
+  // NESTED-LABEL: @protocol NestedInExtensionOfParent
+  // NESTED-NEXT: @end
+  @objc protocol NestedInExtensionOfParent {}
+}
+
 // NEGATIVE-NOT: @protocol PrivateProto
 @objc private protocol PrivateProto {}
 

test/Runtime/nested-protocols.swift

@@ -0,0 +1,64 @@
+// RUN: %target-run-simple-swift
+
+// REQUIRES: executable_test
+
+enum E {
+  protocol P {}
+}
+
+struct Conforms {}
+extension Conforms: E.P {}
+
+struct DoesNotConform {}
+
+struct S<T> {}
+extension S: E.P where T: E.P {}
+
+@inline(never)
+func castToNested(_ value: Any) -> (any E.P)? {
+    value as? any E.P
+}
+
+// Regular conformance.
+
+precondition(castToNested(Conforms()) != nil)
+precondition(castToNested(DoesNotConform()) == nil)
+
+// Conditional conformance.
+
+precondition(castToNested(S<Conforms>()) != nil)
+precondition(castToNested(S<DoesNotConform>()) == nil)
+
+// Verify that 'E.P' and a non-nested 'P' are different.
+
+protocol P {}
+
+@inline(never)
+func castToNonNested(_ value: Any) -> (any P)? {
+    value as? any P
+}
+
+precondition(castToNonNested(Conforms()) == nil)
+precondition(castToNonNested(S<Conforms>()) == nil)
+precondition(castToNonNested(DoesNotConform()) == nil)
+precondition(castToNonNested(S<DoesNotConform>()) == nil)
+
+// Local protocols.
+
+@inline(never)
+func f0(_ input: Any) -> (Any, inputConforms: Bool) {
+
+  protocol LocalProto { }
+  struct ConformsToLocal: LocalProto {}
+
+  if let input = input as? any LocalProto {
+    return (input, true)
+  } else {
+    return (ConformsToLocal(), false)
+  }
+}
+
+var result = f0(DoesNotConform())
+precondition(result.inputConforms == false)
+result = f0(result.0)
+precondition(result.inputConforms == true)

test/Serialization/Inputs/nested-protocols.swift

@@ -0,0 +1,11 @@
+public struct Outer {
+  public protocol Inner {
+    func foo()
+  }
+}
+
+extension Outer {
+  public protocol InnerInExtension {
+    func bar()
+  }
+}

test/Serialization/nested-protocols.swift

@@ -0,0 +1,12 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend -emit-module -module-name nestedprotocolsource -emit-module-path %t/nestedprotocolsource.swiftmodule -primary-file %S/Inputs/nested-protocols.swift
+// RUN: %target-swift-frontend -emit-sil %s -I %t | Filecheck %s
+import nestedprotocolsource
+
+// CHECK: usesNested<A>(_:)
+// CHECK-NEXT: sil @$s4main10usesNestedyyx20nestedprotocolsource5OuterV5InnerRzlF :
+public func usesNested(_ x: some Outer.Inner) {}
+
+// CHECK: usesNestedInExtension<A>(_:)
+// CHECK-NEXT: sil @$s4main21usesNestedInExtensionyyx20nestedprotocolsource5OuterV05InnerdE0RzlF :
+public func usesNestedInExtension(_ x: some Outer.InnerInExtension) {}

test/decl/inherit/initializer.swift

@@ -107,7 +107,7 @@ func testClassInGenericFunc<T>(t: T) {
   class A { init(t: T) {} } // expected-error {{type 'A' cannot be nested in generic function 'testClassInGenericFunc(t:)'}}
   class B : A {} // expected-error {{type 'B' cannot be nested in generic function 'testClassInGenericFunc(t:)'}}
 
-  _ = B(t: t)
+  _ = B(t: t) // expected-error {{'B' cannot be constructed because it has no accessible initializers}}
 }