Introduce a new class between TypeDecl and NominalTypeDecl named GenericTypeDecl.

This factors the DeclContext and generic signature behavior out of NTD, allowing
it to be reused in the future.  NFC.

Author: lattner

include/swift/AST/Decl.h

@@ -2328,23 +2328,86 @@ class TypeDecl : public ValueDecl {
   }
 };
 
+/// A type declaration that can have generic parameters attached to it.  Because
+/// it has these generic parameters, it is always a DeclContext.
+class GenericTypeDecl : public TypeDecl, public DeclContext {
+  GenericParamList *GenericParams = nullptr;
+
+  /// \brief The generic signature of this type.
+  ///
+  /// This is the semantic representation of a generic parameters and the
+  /// requirements placed on them.
+  ///
+  /// FIXME: The generic parameters here are also derivable from
+  /// \c GenericParams. However, we likely want to make \c GenericParams
+  /// the parsed representation, and not part of the module file.
+  GenericSignature *GenericSig = nullptr;
+  //friend class DeclContext;
+
+public:
+  GenericTypeDecl(DeclKind K, DeclContext *DC,
+                  Identifier name, SourceLoc nameLoc,
+                  MutableArrayRef<TypeLoc> inherited,
+                  GenericParamList *GenericParams);
+
+  GenericParamList *getGenericParams() const { return GenericParams; }
+
+  /// Provide the set of parameters to a generic type, or null if
+  /// this function is not generic.
+  void setGenericParams(GenericParamList *params);
+
+  /// Set the generic signature of this type.
+  void setGenericSignature(GenericSignature *sig);
+
+  /// Retrieve the innermost generic parameter types.
+  ArrayRef<GenericTypeParamType *> getInnermostGenericParamTypes() const {
+    if (!GenericSig)
+      return { };
+
+    return GenericSig->getInnermostGenericParams();
+  }
+
+  /// Retrieve the generic requirements.
+  ArrayRef<Requirement> getGenericRequirements() const {
+    if (!GenericSig)
+      return { };
+
+    return GenericSig->getRequirements();
+  }
+
+  /// Retrieve the generic signature.
+  GenericSignature *getGenericSignature() const {
+    return GenericSig;
+  }
+
+  // Resolve ambiguity due to multiple base classes.
+  using TypeDecl::getASTContext;
+  using DeclContext::operator new;
+  using TypeDecl::getDeclaredInterfaceType;
+
+  static bool classof(const DeclContext *C) {
+    return C->getContextKind() == DeclContextKind::GenericTypeDecl;
+  }
+};
+
+
+
 /// TypeAliasDecl - This is a declaration of a typealias, for example:
 ///
-///    typealias foo = int
+///    typealias Foo = Int
 ///
 /// TypeAliasDecl's always have 'MetatypeType' type.
 ///
 class TypeAliasDecl : public TypeDecl {
   /// The type that represents this (sugared) name alias.
   mutable NameAliasType *AliasTy;
 
-  SourceLoc TypeAliasLoc; // The location of the 'typealias' keyword
+  SourceLoc TypeAliasLoc;           // The location of the 'typealias' keyword
   TypeLoc UnderlyingTy;
 
 public:
   TypeAliasDecl(SourceLoc TypeAliasLoc, Identifier Name,
-                SourceLoc NameLoc, TypeLoc UnderlyingTy,
-                DeclContext *DC);
+                SourceLoc NameLoc, TypeLoc UnderlyingTy, DeclContext *DC);
 
   SourceLoc getStartLoc() const { return TypeAliasLoc; }
   SourceRange getSourceRange() const;
@@ -2581,29 +2644,15 @@ enum PointerTypeKind : unsigned {
 /// These are not added to their enclosing type unless forced.
 typedef std::function<void(SmallVectorImpl<Decl *> &)> DelayedDecl;
 
-/// NominalTypeDecl - a declaration of a nominal type, like a struct.  This
-/// decl is always a DeclContext.
-class NominalTypeDecl : public TypeDecl, public DeclContext,
-                        public IterableDeclContext {
+/// NominalTypeDecl - a declaration of a nominal type, like a struct.
+class NominalTypeDecl : public GenericTypeDecl, public IterableDeclContext {
   SourceRange Braces;
 
   /// \brief The set of implicit members and protocols added to imported enum
   /// types.  These members and protocols are added to the NominalDecl only if
   /// the nominal type is directly or indirectly referenced.
   std::unique_ptr<DelayedDecl> DelayedMembers;
 
-  GenericParamList *GenericParams;
-
-  /// \brief The generic signature of this type.
-  ///
-  /// This is the semantic representation of a generic parameters and the
-  /// requirements placed on them.
-  ///
-  /// FIXME: The generic parameters here are also derivable from
-  /// \c GenericParams. However, we likely want to make \c GenericParams
-  /// the parsed representation, and not part of the module file.
-  GenericSignature *GenericSig = nullptr;
-
   /// \brief The first extension of this type.
   ExtensionDecl *FirstExtension = nullptr;
 
@@ -2693,10 +2742,9 @@ class NominalTypeDecl : public TypeDecl, public DeclContext,
                   SourceLoc NameLoc,
                   MutableArrayRef<TypeLoc> inherited,
                   GenericParamList *GenericParams) :
-    TypeDecl(K, DC, name, NameLoc, inherited),
-    DeclContext(DeclContextKind::NominalTypeDecl, DC),
+    GenericTypeDecl(K, DC, name, NameLoc, inherited, GenericParams),
     IterableDeclContext(IterableDeclContextKind::NominalTypeDecl),
-    GenericParams(nullptr), DeclaredTy(nullptr)
+    DeclaredTy(nullptr)
   {
     setGenericParams(GenericParams);
     NominalTypeDeclBits.HasDelayedMembers = false;
@@ -2711,8 +2759,6 @@ class NominalTypeDecl : public TypeDecl, public DeclContext,
   friend class ProtocolType;
 
 public:
-  using TypeDecl::getASTContext;
-
   DeclRange getMembers(bool forceDelayedMembers = true) const;
   SourceRange getBraces() const { return Braces; }
 
@@ -2778,36 +2824,6 @@ class NominalTypeDecl : public TypeDecl, public DeclContext,
     return SearchedForFailableInits;
   }
 
-  GenericParamList *getGenericParams() const { return GenericParams; }
-
-  /// Provide the set of parameters to a generic type, or null if
-  /// this function is not generic.
-  void setGenericParams(GenericParamList *params);
-  
-  /// Set the generic signature of this type.
-  void setGenericSignature(GenericSignature *sig);
-
-  /// Retrieve the innermost generic parameter types.
-  ArrayRef<GenericTypeParamType *> getInnermostGenericParamTypes() const {
-    if (!GenericSig)
-      return { };
-
-    return GenericSig->getInnermostGenericParams();
-  }
-
-  /// Retrieve the generic requirements.
-  ArrayRef<Requirement> getGenericRequirements() const {
-    if (!GenericSig)
-      return { };
-
-    return GenericSig->getRequirements();
-  }
-  
-  /// Retrieve the generic signature.
-  GenericSignature *getGenericSignature() const {
-    return GenericSig;
-  }
-
   /// getDeclaredType - Retrieve the type declared by this entity.
   Type getDeclaredType() const { return DeclaredTy; }
 
@@ -2895,8 +2911,6 @@ class NominalTypeDecl : public TypeDecl, public DeclContext,
 
   void setConformanceLoader(LazyMemberLoader *resolver, uint64_t contextData);
 
-  using TypeDecl::getDeclaredInterfaceType;
-
   /// classifyAsOptionalType - Decide whether this declaration is one
   /// of the library-intrinsic Optional<T> or ImplicitlyUnwrappedOptional<T> types.
   OptionalTypeKind classifyAsOptionalType() const;
@@ -2936,17 +2950,21 @@ class NominalTypeDecl : public TypeDecl, public DeclContext,
     return D->getKind() >= DeclKind::First_NominalTypeDecl &&
            D->getKind() <= DeclKind::Last_NominalTypeDecl;
   }
+  static bool classof(const GenericTypeDecl *D) {
+    return D->getKind() >= DeclKind::First_NominalTypeDecl &&
+           D->getKind() <= DeclKind::Last_NominalTypeDecl;
+  }
+
   static bool classof(const DeclContext *C) {
-    return C->getContextKind() == DeclContextKind::NominalTypeDecl;
+    auto GTD = dyn_cast<GenericTypeDecl>(C);
+    return GTD && classof(GTD);
   }
   static bool classof(const IterableDeclContext *C) {
     return C->getIterableContextKind()
              == IterableDeclContextKind::NominalTypeDecl;
   }
   static bool classof(const NominalTypeDecl *D) { return true; }
   static bool classof(const ExtensionDecl *D) { return false; }
-
-  using DeclContext::operator new;
 };
 
 /// \brief This is the declaration of an enum.
@@ -2960,8 +2978,8 @@ class NominalTypeDecl : public TypeDecl, public DeclContext,
 ///    }
 ///
 ///    enum Optional<T> {
-///      case None
-///      case Some(T)
+///      case none
+///      case some(T)
 ///    }
 /// \endcode
 ///
@@ -3027,14 +3045,19 @@ class EnumDecl : public NominalTypeDecl {
   static bool classof(const Decl *D) {
     return D->getKind() == DeclKind::Enum;
   }
+  static bool classof(const GenericTypeDecl *D) {
+    return D->getKind() == DeclKind::Enum;
+  }
   static bool classof(const NominalTypeDecl *D) {
     return D->getKind() == DeclKind::Enum;
   }
   static bool classof(const DeclContext *C) {
-    return isa<NominalTypeDecl>(C) && classof(cast<NominalTypeDecl>(C));
+    auto GTD = dyn_cast<GenericTypeDecl>(C);
+    return GTD && classof(static_cast<const Decl*>(GTD));
   }
   static bool classof(const IterableDeclContext *C) {
-    return isa<NominalTypeDecl>(C) && classof(cast<NominalTypeDecl>(C));
+    auto NTD = dyn_cast<NominalTypeDecl>(C);
+    return NTD && classof(NTD);
   }
 
   /// Determine whether this enum declares a raw type in its inheritance clause.
@@ -3086,14 +3109,19 @@ class StructDecl : public NominalTypeDecl {
   static bool classof(const Decl *D) {
     return D->getKind() == DeclKind::Struct;
   }
+  static bool classof(const GenericTypeDecl *D) {
+    return D->getKind() == DeclKind::Struct;
+  }
   static bool classof(const NominalTypeDecl *D) {
     return D->getKind() == DeclKind::Struct;
   }
   static bool classof(const DeclContext *C) {
-    return isa<NominalTypeDecl>(C) && classof(cast<NominalTypeDecl>(C));
+    auto GTD = dyn_cast<GenericTypeDecl>(C);
+    return GTD && classof(static_cast<const Decl*>(GTD));
   }
   static bool classof(const IterableDeclContext *C) {
-    return isa<NominalTypeDecl>(C) && classof(cast<NominalTypeDecl>(C));
+    auto NTD = dyn_cast<NominalTypeDecl>(C);
+    return NTD && classof(NTD);
   }
 
   /// Does this struct contain unreferenceable storage, such as C fields that
@@ -3282,14 +3310,19 @@ class ClassDecl : public NominalTypeDecl {
   static bool classof(const Decl *D) {
     return D->getKind() == DeclKind::Class;
   }
+  static bool classof(const GenericTypeDecl *D) {
+    return D->getKind() == DeclKind::Class;
+  }
   static bool classof(const NominalTypeDecl *D) {
     return D->getKind() == DeclKind::Class;
   }
   static bool classof(const DeclContext *C) {
-    return isa<NominalTypeDecl>(C) && classof(cast<NominalTypeDecl>(C));
+    auto GTD = dyn_cast<GenericTypeDecl>(C);
+    return GTD && classof(static_cast<const Decl*>(GTD));
   }
   static bool classof(const IterableDeclContext *C) {
-    return isa<NominalTypeDecl>(C) && classof(cast<NominalTypeDecl>(C));
+    auto NTD = dyn_cast<NominalTypeDecl>(C);
+    return NTD && classof(NTD);
   }
 };
 
@@ -3544,14 +3577,19 @@ class ProtocolDecl : public NominalTypeDecl {
   static bool classof(const Decl *D) {
     return D->getKind() == DeclKind::Protocol;
   }
+  static bool classof(const GenericTypeDecl *D) {
+    return D->getKind() == DeclKind::Protocol;
+  }
   static bool classof(const NominalTypeDecl *D) {
     return D->getKind() == DeclKind::Protocol;
   }
   static bool classof(const DeclContext *C) {
-    return isa<NominalTypeDecl>(C) && classof(cast<NominalTypeDecl>(C));
+    auto GTD = dyn_cast<GenericTypeDecl>(C);
+    return GTD && classof(static_cast<const Decl*>(GTD));
   }
   static bool classof(const IterableDeclContext *C) {
-    return isa<NominalTypeDecl>(C) && classof(cast<NominalTypeDecl>(C));
+    auto NTD = dyn_cast<NominalTypeDecl>(C);
+    return NTD && classof(NTD);
   }
 };
 

include/swift/AST/DeclContext.h

@@ -73,7 +73,7 @@ enum class DeclContextKind : uint8_t {
 
   Module,
   FileUnit,
-  NominalTypeDecl,
+  GenericTypeDecl,
   ExtensionDecl,
   Last_DeclContextKind = ExtensionDecl
 };
@@ -229,7 +229,7 @@ class alignas(1 << DeclContextAlignInBits) DeclContext {
   /// \returns true if this is a type context, e.g., a struct, a class, an
   /// enum, a protocol, or an extension.
   bool isTypeContext() const {
-    return getContextKind() == DeclContextKind::NominalTypeDecl ||
+    return getContextKind() == DeclContextKind::GenericTypeDecl ||
            getContextKind() == DeclContextKind::ExtensionDecl;
   }
 

lib/AST/ASTDumper.cpp

@@ -1076,8 +1076,8 @@ static void printContext(raw_ostream &os, DeclContext *dc) {
     break;
   }
 
-  case DeclContextKind::NominalTypeDecl:
-    printName(os, cast<NominalTypeDecl>(dc)->getName());
+  case DeclContextKind::GenericTypeDecl:
+    printName(os, cast<GenericTypeDecl>(dc)->getName());
     break;
 
   case DeclContextKind::ExtensionDecl:

lib/AST/ASTPrinter.cpp

@@ -2794,8 +2794,8 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
       // FIXME: print closures somehow.
       return;
 
-    case DeclContextKind::NominalTypeDecl:
-      visit(cast<NominalTypeDecl>(DC)->getType());
+    case DeclContextKind::GenericTypeDecl:
+      visit(cast<GenericTypeDecl>(DC)->getType());
       return;
 
     case DeclContextKind::ExtensionDecl:

lib/AST/ASTVerifier.cpp

@@ -520,8 +520,8 @@ struct ASTNodeBase {};
       case DeclContextKind::AbstractFunctionDecl:
         return cast<AbstractFunctionDecl>(dc)->getGenericParams();
 
-      case DeclContextKind::NominalTypeDecl:
-        return cast<NominalTypeDecl>(dc)->getGenericParams();
+      case DeclContextKind::GenericTypeDecl:
+        return cast<GenericTypeDecl>(dc)->getGenericParams();
 
       case DeclContextKind::ExtensionDecl:
         return cast<ExtensionDecl>(dc)->getGenericParams();
@@ -1598,7 +1598,7 @@ struct ASTNodeBase {};
         return false;
 
       case DeclContextKind::Initializer:
-      case DeclContextKind::NominalTypeDecl:
+      case DeclContextKind::GenericTypeDecl:
       case DeclContextKind::ExtensionDecl:
       case DeclContextKind::SubscriptDecl:
         return hasEnclosingFunctionContext(dc->getParent());