Merge pull request #5995 from DougGregor/decouple-archetype-builder

Author: swift-ci

include/swift/AST/ArchetypeBuilder.h

@@ -366,9 +366,9 @@ class ArchetypeBuilder::PotentialArchetype {
   llvm::MapVector<Identifier, llvm::TinyPtrVector<PotentialArchetype *>>
     NestedTypes;
 
-  /// \brief The actual archetype, once it has been assigned, or the concrete
-  /// type that the parameter was same-type constrained to.
-  ArchetypeType::NestedType ArchetypeOrConcreteType;
+  /// The concrete type to which a this potential archetype has been
+  /// constrained.
+  Type ConcreteType;
 
   /// \brief Recursively conforms to itself.
   unsigned IsRecursive : 1;
@@ -377,10 +377,6 @@ class ArchetypeBuilder::PotentialArchetype {
   /// be resolved.
   unsigned Invalid : 1;
 
-  /// Whether we are currently substituting into the concrete type of
-  /// this potential archetype.
-  unsigned SubstitutingConcreteType : 1;
-
   /// Whether we have detected recursion during the substitution of
   /// the concrete type.
   unsigned RecursiveConcreteType : 1;
@@ -403,7 +399,7 @@ class ArchetypeBuilder::PotentialArchetype {
   /// associated type.
   PotentialArchetype(PotentialArchetype *Parent, Identifier Name)
     : ParentOrParam(Parent), NameOrAssociatedType(Name), Representative(this),
-      IsRecursive(false), Invalid(false), SubstitutingConcreteType(false),
+      IsRecursive(false), Invalid(false),
       RecursiveConcreteType(false), RecursiveSuperclassType(false),
       DiagnosedRename(false)
   { 
@@ -415,7 +411,7 @@ class ArchetypeBuilder::PotentialArchetype {
   PotentialArchetype(PotentialArchetype *Parent, AssociatedTypeDecl *AssocType)
     : ParentOrParam(Parent), NameOrAssociatedType(AssocType), 
       Representative(this), IsRecursive(false), Invalid(false),
-      SubstitutingConcreteType(false), RecursiveConcreteType(false),
+      RecursiveConcreteType(false),
       RecursiveSuperclassType(false), DiagnosedRename(false)
   {
     assert(Parent != nullptr && "Not an associated type?");
@@ -426,7 +422,7 @@ class ArchetypeBuilder::PotentialArchetype {
   PotentialArchetype(PotentialArchetype *Parent, TypeAliasDecl *TypeAlias)
     : ParentOrParam(Parent), NameOrAssociatedType(TypeAlias),
       Representative(this), IsRecursive(false), Invalid(false),
-      SubstitutingConcreteType(false), RecursiveConcreteType(false),
+      RecursiveConcreteType(false),
       RecursiveSuperclassType(false), DiagnosedRename(false)
   {
     assert(Parent != nullptr && "Not an associated type?");
@@ -438,7 +434,7 @@ class ArchetypeBuilder::PotentialArchetype {
                      Identifier Name)
     : ParentOrParam(GenericParam),
       NameOrAssociatedType(Name), Representative(this), IsRecursive(false),
-      Invalid(false), SubstitutingConcreteType(false),
+      Invalid(false),
       RecursiveConcreteType(false), RecursiveSuperclassType(false),
       DiagnosedRename(false)
   {
@@ -448,6 +444,14 @@ class ArchetypeBuilder::PotentialArchetype {
   /// \brief Recursively build the full name.
   void buildFullName(bool forDebug, SmallVectorImpl<char> &result) const;
 
+  /// Retrieve the generic parameter at the root of this potential archetype.
+  GenericTypeParamType *getRootParam() const {
+    if (auto parent = getParent())
+      return parent->getRootParam();
+
+    return getGenericParam();
+  }
+
 public:
   ~PotentialArchetype();
 
@@ -466,14 +470,6 @@ class ArchetypeBuilder::PotentialArchetype {
     return ParentOrParam.dyn_cast<PotentialArchetype *>(); 
   }
 
-  /// Retrieve the generic parameter at the root of this potential archetype.
-  GenericTypeParamType *getRootParam() const {
-    if (auto parent = getParent())
-      return parent->getRootParam();
-
-    return getGenericParam();
-  }
-
   /// Retrieve the associated type to which this potential archetype
   /// has been resolved.
   AssociatedTypeDecl *getResolvedAssociatedType() const {
@@ -487,10 +483,31 @@ class ArchetypeBuilder::PotentialArchetype {
 
   /// Retrieve the generic type parameter for this potential
   /// archetype, if it corresponds to a generic parameter.
+  ///
+  /// FIXME: We should weaken this to just a depth/index key.
   GenericTypeParamType *getGenericParam() const {
     return ParentOrParam.dyn_cast<GenericTypeParamType *>(); 
   }
-  
+
+  /// Determine whether this is a generic parameter.
+  bool isGenericParam() const {
+    return ParentOrParam.is<GenericTypeParamType *>();
+  }
+
+  /// Retrieve the generic parameter key for a potential archetype that
+  /// represents this potential archetype.
+  ///
+  /// \pre \c isGenericParam()
+  GenericParamKey getGenericParamKey() const {
+    return getGenericParam();
+  }
+
+  /// Retrieve the generic parameter key for the generic parameter at the
+  /// root of this potential archetype.
+  GenericParamKey getRootGenericParamKey() const {
+    return getRootParam();
+  }
+
   /// Retrieve the type alias.
   TypeAliasDecl *getTypeAliasDecl() const {
     return NameOrAssociatedType.dyn_cast<TypeAliasDecl *>();
@@ -550,33 +567,38 @@ class ArchetypeBuilder::PotentialArchetype {
   PotentialArchetype *getNestedType(Identifier Name,
                                     ArchetypeBuilder &builder);
 
+
   /// \brief Retrieve (or build) the type corresponding to the potential
-  /// archetype.
-  ArchetypeType::NestedType getType(ArchetypeBuilder &builder);
+  /// archetype within the given generic environment.
+  ArchetypeType::NestedType getTypeInContext(ArchetypeBuilder &builder,
+                                             GenericEnvironment *genericEnv);
 
   /// Retrieve the dependent type that describes this potential
   /// archetype.
   ///
+  /// \param genericParams The set of generic parameters to use in the resulting
+  /// dependent type.
+  ///
   /// \param allowUnresolved If true, allow the result to contain
   /// \c DependentMemberType types with a name but no specific associated
   /// type.
-  Type getDependentType(bool allowUnresolved);
+  Type getDependentType(ArrayRef<GenericTypeParamType *> genericParams,
+                        bool allowUnresolved);
 
   /// True if the potential archetype has been bound by a concrete type
   /// constraint.
   bool isConcreteType() const {
     if (Representative != this)
       return Representative->isConcreteType();
 
-    return ArchetypeOrConcreteType.isConcreteType();
+    return static_cast<bool>(ConcreteType);
   }
 
   /// Get the concrete type this potential archetype is constrained to.
   Type getConcreteType() const {
-    assert(isConcreteType());
     if (Representative != this)
       return Representative->getConcreteType();
-    return ArchetypeOrConcreteType.getAsConcreteType();
+    return ConcreteType;
   }
 
   void setIsRecursive() { IsRecursive = true; }

include/swift/AST/Decl.h

@@ -24,6 +24,7 @@
 #include "swift/AST/DefaultArgumentKind.h"
 #include "swift/AST/GenericEnvironment.h"
 #include "swift/AST/GenericSignature.h"
+#include "swift/AST/GenericParamKey.h"
 #include "swift/AST/LazyResolver.h"
 #include "swift/AST/TypeAlignments.h"
 #include "swift/AST/Witness.h"
@@ -4013,6 +4014,8 @@ class AbstractStorageDecl : public ValueDecl {
     return OverriddenDecl;
   }
   void setOverriddenDecl(AbstractStorageDecl *over) {
+    // FIXME: Hack due to broken class circulatity checking.
+    if (over == this) return;
     OverriddenDecl = over;
     over->setIsOverridden();
   }
@@ -5092,6 +5095,9 @@ class FuncDecl final : public AbstractFunctionDecl,
     return OverriddenOrBehaviorParamDecl.dyn_cast<FuncDecl *>();
   }
   void setOverriddenDecl(FuncDecl *over) {
+    // FIXME: Hack due to broken class circulatity checking.
+    if (over == this) return;
+
     // A function cannot be an override if it is also a derived global decl
     // (since derived decls are at global scope).
     assert((!OverriddenOrBehaviorParamDecl
@@ -5519,6 +5525,9 @@ class ConstructorDecl : public AbstractFunctionDecl {
 
   ConstructorDecl *getOverriddenDecl() const { return OverriddenDecl; }
   void setOverriddenDecl(ConstructorDecl *over) {
+    // FIXME: Hack due to broken class circulatity checking.
+    if (over == this) return;
+
     OverriddenDecl = over;
     over->setIsOverridden();
   }
@@ -6001,6 +6010,9 @@ inline bool Decl::isPotentiallyOverridable() const {
   }
 }
 
+inline GenericParamKey::GenericParamKey(const GenericTypeParamDecl *d)
+  : Depth(d->getDepth()), Index(d->getIndex()) { }
+
 } // end namespace swift
 
 #endif

include/swift/AST/GenericEnvironment.h

@@ -18,18 +18,20 @@
 #define SWIFT_AST_GENERIC_ENVIRONMENT_H
 
 #include "swift/AST/SubstitutionMap.h"
+#include "swift/AST/GenericParamKey.h"
 #include "swift/AST/GenericSignature.h"
 
 namespace swift {
 
+class ArchetypeBuilder;
 class ASTContext;
 class GenericTypeParamType;
 class SILModule;
 class SILType;
 
 /// Describes the mapping between archetypes and interface types for the
 /// generic parameters of a DeclContext.
-class GenericEnvironment final {
+class alignas(1 << DeclAlignInBits) GenericEnvironment final {
   GenericSignature *Signature;
   TypeSubstitutionMap ArchetypeToInterfaceMap;
   TypeSubstitutionMap InterfaceToArchetypeMap;
@@ -63,7 +65,12 @@ class GenericEnvironment final {
 
   /// Add a mapping of a generic parameter to a specific type (which may be
   /// an archetype)
-  void addMapping(GenericTypeParamType *genericParam, Type contextType);
+  void addMapping(GenericParamKey key, Type contextType);
+
+  /// Retrieve the mapping for the given generic parameter, if present.
+  ///
+  /// This is only useful when lazily populating a generic environment.
+  Optional<Type> getMappingIfPresent(GenericParamKey key) const;
 
   /// Make vanilla new/delete illegal.
   void *operator new(size_t Bytes) = delete;
@@ -80,9 +87,6 @@ class GenericEnvironment final {
   Type mapTypeIntoContext(ModuleDecl *M, Type type) const;
 
   /// Map a generic parameter type to a contextual type.
-  ///
-  /// This operation will also reabstract dependent types according to the
-  /// abstraction level of their associated type requirements.
   Type mapTypeIntoContext(GenericTypeParamType *type) const;
 
   /// \brief Map the given SIL interface type to a contextual type.

include/swift/AST/GenericParamKey.h

@@ -0,0 +1,121 @@
+//===--- GenericParamKey.h - Key for generic parameters ---------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_AST_GENERICPARAMKEY_H
+#define SWIFT_AST_GENERICPARAMKEY_H
+
+#include "llvm/ADT/DenseMapInfo.h"
+#include "llvm/ADT/ArrayRef.h"
+
+namespace swift {
+
+class GenericTypeParamDecl;
+class GenericTypeParamType;
+
+/// A fully-abstracted generic type parameter key, maintaining only the depth
+/// and index of the generic parameter.
+struct GenericParamKey {
+  unsigned Depth : 16;
+  unsigned Index : 16;
+
+  GenericParamKey(unsigned depth, unsigned index)
+    : Depth(depth), Index(index) { }
+
+  GenericParamKey(const GenericTypeParamDecl *d);
+  GenericParamKey(const GenericTypeParamType *d);
+
+  friend bool operator==(GenericParamKey lhs, GenericParamKey rhs) {
+    return lhs.Depth == rhs.Depth && lhs.Index == rhs.Index;
+  }
+
+  friend bool operator!=(GenericParamKey lhs, GenericParamKey rhs) {
+    return !(lhs == rhs);
+  }
+
+  friend bool operator<(GenericParamKey lhs, GenericParamKey rhs) {
+    return lhs.Depth < rhs.Depth ||
+      (lhs.Depth == rhs.Depth && lhs.Index < rhs.Index);
+  }
+
+  friend bool operator>(GenericParamKey lhs, GenericParamKey rhs) {
+    return rhs < lhs;
+  }
+
+  friend bool operator<=(GenericParamKey lhs, GenericParamKey rhs) {
+    return !(rhs < lhs);
+  }
+
+  friend bool operator>=(GenericParamKey lhs, GenericParamKey rhs) {
+    return !(lhs < rhs);
+  }
+
+  /// Function object type that can be used to provide an ordering of
+  /// generic type parameter keys with themselves, generic type parameter
+  /// declarations, and generic type parameter types.
+  struct Ordering {
+    bool operator()(GenericParamKey lhs, GenericParamKey rhs) const {
+      return lhs < rhs;
+    }
+
+    bool operator()(GenericParamKey lhs,
+                    const GenericTypeParamDecl *rhs) const {
+      return (*this)(lhs, GenericParamKey(rhs));
+    }
+
+    bool operator()(const GenericTypeParamDecl *lhs,
+                    GenericParamKey rhs) const {
+      return (*this)(GenericParamKey(lhs), rhs);
+    }
+
+    bool operator()(GenericParamKey lhs,
+                    const GenericTypeParamType *rhs) const {
+      return (*this)(lhs, GenericParamKey(rhs));
+    }
+
+    bool operator()(const GenericTypeParamType *lhs,
+                    GenericParamKey rhs) const {
+      return (*this)(GenericParamKey(lhs), rhs);
+    }
+  };
+
+
+  /// Find the index that this key would have into an array of
+  /// generic type parameters
+  unsigned findIndexIn(
+             llvm::ArrayRef<GenericTypeParamType *> genericParams) const;
+};
+
+} // end namespace swift
+
+namespace llvm {
+
+template<>
+struct DenseMapInfo<swift::GenericParamKey> {
+  static inline swift::GenericParamKey getEmptyKey() {
+    return {0xFFFF, 0xFFFF};
+  }
+  static inline swift::GenericParamKey getTombstoneKey() {
+    return {0xFFFE, 0xFFFE};
+  }
+
+  static inline unsigned getHashValue(swift::GenericParamKey k) {
+    return DenseMapInfo<unsigned>::getHashValue(k.Depth << 16 | k.Index);
+  }
+  static bool isEqual(swift::GenericParamKey a,
+                      swift::GenericParamKey b) {
+    return a.Depth == b.Depth && a.Index == b.Index;
+  }
+};
+  
+} // end namespace llvm
+
+#endif // SWIFT_AST_GENERICPARAMKEY_H

include/swift/AST/TypeAlignments.h

@@ -34,6 +34,7 @@ namespace swift {
   class DeclContext;
   class Expr;
   class ExtensionDecl;
+  class GenericEnvironment;
   class GenericTypeParamDecl;
   class NormalProtocolConformance;
   class OperatorDecl;
@@ -97,6 +98,8 @@ LLVM_DECLARE_TYPE_ALIGNMENT(swift::Expr, swift::ExprAlignInBits)
 LLVM_DECLARE_TYPE_ALIGNMENT(swift::ProtocolConformance, swift::DeclAlignInBits)
 LLVM_DECLARE_TYPE_ALIGNMENT(swift::NormalProtocolConformance,
                             swift::DeclAlignInBits)
+LLVM_DECLARE_TYPE_ALIGNMENT(swift::GenericEnvironment,
+                            swift::DeclAlignInBits)
 
 static_assert(llvm::AlignOf<void*>::Alignment >= 2,
               "pointer alignment is too small");