Allow protocols to be nested in non-generic nominal types and functions

Author: Karl Wagner

include/swift/AST/DiagnosticsSema.def

@@ -2061,6 +2061,12 @@ ERROR(unsupported_type_nested_in_protocol_extension,none,
 ERROR(unsupported_nested_protocol,none,
       "protocol %0 cannot be nested inside another declaration",
       (Identifier))
+ERROR(unsupported_nested_protocol_in_generic_context,none,
+      "protocol %0 cannot be nested inside a generic context",
+      (Identifier))
+ERROR(unsupported_nested_protocol_in_protocol,none,
+      "protocol %0 cannot be nested inside another protocol",
+      (Identifier))
 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)

include/swift/Basic/Features.def

@@ -208,6 +208,9 @@ EXPERIMENTAL_FEATURE(ReferenceBindings, false)
 /// Enable the explicit 'import Builtin' and allow Builtin usage.
 EXPERIMENTAL_FEATURE(BuiltinModule, true)
 
+/// Enable protocols to be nested in non-generic contexts.
+EXPERIMENTAL_FEATURE(NestedProtocols, false)
+
 #undef EXPERIMENTAL_FEATURE_EXCLUDED_FROM_MODULE_INTERFACE
 #undef EXPERIMENTAL_FEATURE
 #undef UPCOMING_FEATURE

lib/AST/ASTPrinter.cpp

@@ -3425,6 +3425,14 @@ static bool usesFeatureParameterPacks(Decl *decl) {
   return false;
 }
 
+static bool usesFeatureNestedProtocols(Decl *decl) {
+    // TODO: How do I test this?
+    if (auto *protocolDecl = dyn_cast<ProtocolDecl>(decl)) {
+        return decl->getDeclContext()->getParent()->isTypeContext();
+    }
+    return false;
+}
+
 /// Suppress the printing of a particular feature.
 static void suppressingFeature(PrintOptions &options, Feature feature,
                                llvm::function_ref<void()> action) {

lib/AST/Decl.cpp

@@ -4765,11 +4765,8 @@ 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();
 
-  // Objective-C protocols, unlike Swift protocols, could be nested
-  // in other types.
-  if ((isObjCProtocol || !isa<ProtocolDecl>(decl)) && dc->isTypeContext()) {
+  if (dc->isTypeContext()) {
     switch (kind) {
     case DeclTypeKind::DeclaredType: {
       if (auto *nominal = dc->getSelfNominalTypeDecl())

lib/IRGen/GenDecl.cpp

@@ -5589,7 +5589,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:
@@ -5645,6 +5644,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

@@ -8961,7 +8961,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

@@ -2519,12 +2519,26 @@ 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->getName());
-      NTD->setInvalid();
-      return;
+    if (isa<ProtocolDecl>(NTD)) {
+      if (NTD->getASTContext().LangOpts.hasFeature(Feature::NestedProtocols)) {
+        // Protocols may only be nested in non-generic contexts.
+        if (NTD->getParent()->isGenericContext()) {
+          if (isa<ProtocolDecl>(NTD->getParent())) {
+            NTD->diagnose(diag::unsupported_nested_protocol_in_protocol, NTD->getName());
+          } else {
+            NTD->diagnose(diag::unsupported_nested_protocol_in_generic_context, NTD->getName());
+          }
+          NTD->setInvalid();
+          return;
+        }
+      } else {
+        // We don't support protocols outside the top level of a file.
+        if (!NTD->getParent()->isModuleScopeContext()) {
+          NTD->diagnose(diag::unsupported_nested_protocol, NTD->getName());
+          NTD->setInvalid();
+          return;
+        }
+      }
     }
 
     // We don't support nested types in protocols.

test/decl/nested/protocol.swift

@@ -31,7 +31,7 @@ protocol OuterProtocol {
 struct ConformsToOuterProtocol : OuterProtocol {
   typealias Hen = Int
 
-  func f() { let _ = InnerProtocol.self } // expected-error {{use of protocol 'InnerProtocol' as a type must be written 'any InnerProtocol'}}
+  func f() { let _ = InnerProtocol.self } // expected-error {{use of protocol 'OuterProtocol.InnerProtocol' as a type must be written 'any OuterProtocol.InnerProtocol'}}
 }
 
 protocol Racoon {