Sema: Add -enable-experimental-nested-generic-types frontend flag

Also, split up test/decl/nested.swift into several files.

Author: slavapestov

include/swift/Basic/LangOptions.h

@@ -140,6 +140,9 @@ namespace swift {
     /// \brief Enable experimental property behavior feature.
     bool EnableExperimentalPropertyBehaviors = false;
 
+    /// \brief Enable experimental nested generic types feature.
+    bool EnableExperimentalNestedGenericTypes = false;
+
     /// Should we check the target OSs of serialized modules to see that they're
     /// new enough?
     bool EnableTargetOSChecking = true;

include/swift/Option/FrontendOptions.td

@@ -223,6 +223,10 @@ def enable_experimental_property_behaviors :
   Flag<["-"], "enable-experimental-property-behaviors">,
   HelpText<"Enable experimental property behaviors">;
 
+def enable_experimental_nested_generic_types :
+  Flag<["-"], "enable-experimental-nested-generic-types">,
+  HelpText<"Enable experimental support for nested generic types">;
+
 def disable_availability_checking : Flag<["-"],
   "disable-availability-checking">,
   HelpText<"Disable checking for potentially unavailable APIs">;

lib/Frontend/CompilerInvocation.cpp

@@ -740,6 +740,9 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
   Opts.EnableExperimentalPropertyBehaviors |=
     Args.hasArg(OPT_enable_experimental_property_behaviors);
 
+  Opts.EnableExperimentalNestedGenericTypes |=
+    Args.hasArg(OPT_enable_experimental_nested_generic_types);
+
   Opts.DisableAvailabilityChecking |=
       Args.hasArg(OPT_disable_availability_checking);
 

lib/Sema/TypeCheckDecl.cpp

@@ -3546,19 +3546,21 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
     // We don't support nested types in generics yet.
     if (NTD->isGenericContext()) {
       auto DC = NTD->getDeclContext();
-      if (DC->isTypeContext()) {
-        if (NTD->getGenericParams())
-          TC.diagnose(NTD->getLoc(), diag::unsupported_generic_nested_in_type,
-                NTD->getName(),
-                DC->getDeclaredTypeOfContext());
-        else
-          TC.diagnose(NTD->getLoc(),
-                      diag::unsupported_type_nested_in_generic_type,
-                      NTD->getName(),
-                      DC->getDeclaredTypeOfContext());
-        return true;
+      if (!TC.Context.LangOpts.EnableExperimentalNestedGenericTypes) {
+        if (DC->isTypeContext()) {
+          if (NTD->getGenericParams())
+            TC.diagnose(NTD->getLoc(), diag::unsupported_generic_nested_in_type,
+                  NTD->getName(),
+                  DC->getDeclaredTypeOfContext());
+          else
+            TC.diagnose(NTD->getLoc(),
+                        diag::unsupported_type_nested_in_generic_type,
+                        NTD->getName(),
+                        DC->getDeclaredTypeOfContext());
+          return true;
+        }
       }
-      
+
       if (DC->isLocalContext() && DC->isGenericContext()) {
         // A local generic context is a generic function.
         if (auto AFD = dyn_cast<AbstractFunctionDecl>(DC)) {

test/decl/class/classes.swift

@@ -85,8 +85,3 @@ class HDerived : H {
   override func f(_ x: Int) { }
   override class func f(_ x: Int) { }
 }
-
-// Generic class locally defined in non-generic function (rdar://problem/20116710)
-func f3() {
-  class B<T> {}
-}

test/decl/nested.swift

@@ -0,0 +1,45 @@
+// RUN: %target-parse-verify-swift -parse-as-library
+
+// Protocols cannot be nested inside other types, and types cannot
+// be nested inside protocols
+
+struct OuterGeneric<D> {
+  protocol InnerProtocol { // expected-error{{declaration is only valid at file scope}}
+    associatedtype Rooster
+    func flip(_ r: Rooster)
+    func flop(_ t: D)
+  }
+}
+
+class OuterGenericClass<T> {
+  protocol InnerProtocol { // expected-error{{declaration is only valid at file scope}}
+    associatedtype Rooster
+    func flip(_ r: Rooster)
+    func flop(_ t: T)
+  }
+}
+
+protocol OuterProtocol {
+  associatedtype Hen
+  protocol InnerProtocol { // expected-error{{type not allowed here}}
+    associatedtype Rooster
+    func flip(_ r: Rooster)
+    func flop(_ h: Hen)
+  }
+}
+
+protocol Racoon {
+  associatedtype Stripes
+  class Claw<T> { // expected-error{{type not allowed here}}
+    func mangle(_ s: Stripes) {}
+  }
+  struct Fang<T> { // expected-error{{type not allowed here}}
+    func gnaw(_ s: Stripes) {}
+  }
+}
+
+enum OuterEnum {
+  protocol C {} // expected-error{{declaration is only valid at file scope}}
+  case C(C)
+}
+

test/decl/nested/protocol.swift

@@ -0,0 +1,20 @@
+// RUN: %target-parse-verify-swift
+
+struct S1 {
+  // expected-error @+4 {{type member may not be named 'Type', since it would conflict with the 'foo.Type' expression}}
+  // expected-error @+3 {{type member may not be named 'Type', since it would conflict with the 'foo.Type' expression}}
+  // expected-note @+2 {{if this name is unavoidable, use backticks to escape it}} {{8-12=`Type`}}
+  // expected-note @+1 {{if this name is unavoidable, use backticks to escape it}} {{8-12=`Type`}}
+  enum Type {
+    case A
+  }
+}
+
+struct S2 {
+  enum `Type` {
+    case A
+  }
+}
+
+let s1: S1.Type = .A // expected-error{{type of expression is ambiguous without more context}}
+let s2: S2.`Type` = .A // no-error