Merge pull request #8112 from DougGregor/gsb-nested-types-lazier

Author: swift-ci

include/swift/AST/GenericSignatureBuilder.h

@@ -1025,13 +1025,41 @@ class GenericSignatureBuilder::PotentialArchetype {
   /// The source of the layout constraint requirement.
   const RequirementSource *LayoutSource = nullptr;
 
+  /// A stored nested type.
+  struct StoredNestedType {
+    /// The potential archetypes describing this nested type, all of which
+    /// are equivalent.
+    llvm::TinyPtrVector<PotentialArchetype *> archetypes;
+
+    typedef llvm::TinyPtrVector<PotentialArchetype *>::iterator iterator;
+    iterator begin() { return archetypes.begin(); }
+    iterator end() { return archetypes.end(); }
+
+    typedef llvm::TinyPtrVector<PotentialArchetype *>::const_iterator
+      const_iterator;
+    const_iterator begin() const { return archetypes.begin(); }
+    const_iterator end() const { return archetypes.end(); }
+
+    PotentialArchetype *front() const { return archetypes.front(); }
+    PotentialArchetype *back() const { return archetypes.back(); }
+
+    unsigned size() const { return archetypes.size(); }
+    bool empty() const { return archetypes.empty(); }
+
+    void push_back(PotentialArchetype *pa) {
+      archetypes.push_back(pa);
+    }
+  };
+
   /// \brief The set of nested types of this archetype.
   ///
   /// For a given nested type name, there may be multiple potential archetypes
   /// corresponding to different associated types (from different protocols)
   /// that share a name.
-  llvm::MapVector<Identifier, llvm::TinyPtrVector<PotentialArchetype *>>
-    NestedTypes;
+  llvm::MapVector<Identifier, StoredNestedType> NestedTypes;
+
+  /// Tracks the number of conformances that
+  unsigned numConformancesInNestedType = 0;
 
   /// Whether this is an unresolved nested type.
   unsigned isUnresolvedNestedType : 1;
@@ -1142,6 +1170,10 @@ class GenericSignatureBuilder::PotentialArchetype {
   void resolveAssociatedType(AssociatedTypeDecl *assocType,
                              GenericSignatureBuilder &builder);
 
+  /// Resolve the potential archetype to the given typealias.
+  void resolveTypeAlias(TypeAliasDecl *typealias,
+                        GenericSignatureBuilder &builder);
+
   /// Determine whether this is a generic parameter.
   bool isGenericParam() const {
     return parentOrBuilder.is<GenericSignatureBuilder *>();
@@ -1213,8 +1245,7 @@ class GenericSignatureBuilder::PotentialArchetype {
   }
 
   /// Retrieve the set of nested types.
-  const llvm::MapVector<Identifier, llvm::TinyPtrVector<PotentialArchetype *>> &
-  getNestedTypes() const{
+  const llvm::MapVector<Identifier, StoredNestedType> &getNestedTypes() const {
     return NestedTypes;
   }
 
@@ -1268,6 +1299,52 @@ class GenericSignatureBuilder::PotentialArchetype {
   PotentialArchetype *getNestedType(AssociatedTypeDecl *assocType,
                                     GenericSignatureBuilder &builder);
 
+  /// \brief Retrieve (or create) a nested type with a known typealias.
+  PotentialArchetype *getNestedType(TypeAliasDecl *typealias,
+                                    GenericSignatureBuilder &builder);
+
+  /// \brief Retrieve (or create) a nested type that is the current best
+  /// nested archetype anchor (locally) with the given name.
+  ///
+  /// When called on the archetype anchor, this will produce the named
+  /// archetype anchor.
+  PotentialArchetype *getNestedArchetypeAnchor(
+                                           Identifier name,
+                                           GenericSignatureBuilder &builder);
+
+  /// Describes the kind of update that is performed.
+  enum class NestedTypeUpdate {
+    /// Resolve an existing potential archetype, but don't create a new
+    /// one if not present.
+    ResolveExisting,
+    /// If this potential archetype is missing, create it.
+    AddIfMissing,
+    /// If this potential archetype is missing and would be a better anchor,
+    /// create it.
+    AddIfBetterAnchor,
+  };
+
+  /// Update the named nested type when we know this type conforms to the given
+  /// protocol.
+  ///
+  /// \returns the potential archetype associated with the associated
+  /// type or typealias of the given protocol, unless the \c kind implies that
+  /// a potential archetype should not be created if it's missing.
+  PotentialArchetype *updateNestedTypeForConformance(
+                      PointerUnion<AssociatedTypeDecl *, TypeAliasDecl *> type,
+                      NestedTypeUpdate kind);
+
+  /// Update the named nested type when we know this type conforms to the given
+  /// protocol.
+  ///
+  /// \returns the potential archetype associated with either an associated
+  /// type or typealias of the given protocol, unless the \c kind implies that
+  /// a potential archetype should not be created if it's missing.
+  PotentialArchetype *updateNestedTypeForConformance(
+                        Identifier name,
+                        ProtocolDecl *protocol,
+                        NestedTypeUpdate kind);
+
   /// \brief Retrieve (or build) the type corresponding to the potential
   /// archetype within the given generic environment.
   Type getTypeInContext(GenericSignatureBuilder &builder,