Merge pull request #7976 from slavapestov/kill-gather-all-substitutions

Kill TypeBase::gatherAllSubstitutions()

Author: slavapestov

include/swift/AST/ASTContext.h

@@ -724,18 +724,9 @@ class ASTContext {
   InheritedProtocolConformance *
   getInheritedConformance(Type type, ProtocolConformance *inherited);
 
-  /// \brief Create trivial substitutions for the given bound generic type.
-  Optional<SubstitutionList>
-  createTrivialSubstitutions(BoundGenericType *BGT,
-                             DeclContext *gpContext) const;
-
   /// Record compiler-known protocol information in the AST.
   void recordKnownProtocols(ModuleDecl *Stdlib);
 
-  /// \brief Retrieve the substitutions for a bound generic type, if known.
-  Optional<SubstitutionList>
-  getSubstitutions(TypeBase *type, DeclContext *gpContext) const;
-
   /// Get the lazy data for the given declaration.
   ///
   /// \param lazyLoader If non-null, the lazy loader to use when creating the
@@ -852,12 +843,6 @@ class ASTContext {
   void setBriefComment(const Decl *D, StringRef Comment);
 
   friend TypeBase;
-
-  /// \brief Set the substitutions for the given bound generic type.
-  void setSubstitutions(TypeBase *type,
-                        DeclContext *gpContext,
-                        SubstitutionList Subs) const;
-
   friend ArchetypeType;
 
   /// Provide context-level uniquing for SIL lowered type layouts and boxes.

include/swift/AST/GenericSignature.h

@@ -214,12 +214,6 @@ class alignas(1 << TypeAlignInBits) GenericSignature final
                         LookupConformanceFn lookupConformance,
                         SmallVectorImpl<Substitution> &result) const;
 
-  /// Build an array of substitutions from an interface type substitution map,
-  /// using the given function to look up conformances.
-  void getSubstitutions(const TypeSubstitutionMap &subMap,
-                        LookupConformanceFn lookupConformance,
-                        SmallVectorImpl<Substitution> &result) const;
-
   /// Build an array of substitutions from an interface type substitution map,
   /// using the given function to look up conformances.
   void getSubstitutions(const SubstitutionMap &subMap,

include/swift/AST/SubstitutionMap.h

@@ -45,6 +45,11 @@ class SubstitutableType;
 template<class Type> class CanTypeWrapper;
 typedef CanTypeWrapper<SubstitutableType> CanSubstitutableType;
 
+enum class CombineSubstitutionMaps {
+  AtDepth,
+  AtIndex
+};
+
 class SubstitutionMap {
   using ParentType = std::pair<CanType, AssociatedTypeDecl *>;
 
@@ -131,19 +136,23 @@ class SubstitutionMap {
 
   /// Combine two substitution maps as follows.
   ///
-  /// The result is written in terms of the generic parameters of 'baseSig'.
+  /// The result is written in terms of the generic parameters of 'genericSig'.
+  ///
+  /// Generic parameters with a depth or index less than 'firstDepthOrIndex'
+  /// come from 'firstSubMap'.
   ///
-  /// Generic parameters with a depth less than 'baseDepth' come from
-  /// 'baseSubs'.
+  /// Generic parameters with a depth greater than 'firstDepthOrIndex' come
+  /// from 'secondSubMap', but are looked up starting with a depth or index of
+  /// 'secondDepthOrIndex'.
   ///
-  /// Generic parameters with a depth greater than 'baseDepth' come from
-  /// 'origSubs', but are looked up starting with a depth of 'origDepth'.
+  /// The 'how' parameter determines if we're looking at the depth or index.
   static SubstitutionMap
-  combineSubstitutionMaps(const SubstitutionMap &baseSubMap,
-                          const SubstitutionMap &origSubMap,
-                          unsigned baseDepth,
-                          unsigned origDepth,
-                          GenericSignature *baseSig);
+  combineSubstitutionMaps(const SubstitutionMap &firstSubMap,
+                          const SubstitutionMap &secondSubMap,
+                          CombineSubstitutionMaps how,
+                          unsigned baseDepthOrIndex,
+                          unsigned origDepthOrIndex,
+                          GenericSignature *genericSig);
 
   /// Dump the contents of this substitution map for debugging purposes.
   void dump(llvm::raw_ostream &out) const;

include/swift/AST/Types.h

@@ -516,6 +516,9 @@ class alignas(1 << TypeAlignInBits) TypeBase {
     return getRecursiveProperties().hasTypeParameter();
   }
 
+  /// Return the root generic parameter of this type parameter type.
+  GenericTypeParamType *getRootGenericParam();
+
   /// Determines whether this type is an lvalue. This includes both straight
   /// lvalue types as well as tuples or optionals of lvalues.
   bool isLValueType() {
@@ -597,15 +600,6 @@ class alignas(1 << TypeAlignInBits) TypeBase {
   /// specialized, but the type Vector is not.
   bool isSpecialized();
 
-  /// Gather all of the substitutions used to produce the given specialized type
-  /// from its unspecialized type.
-  ///
-  /// \returns ASTContext-allocated substitutions.
-  SubstitutionList gatherAllSubstitutions(
-                           ModuleDecl *module,
-                           LazyResolver *resolver,
-                           DeclContext *gpContext = nullptr);
-
   /// \brief Determine whether this type is a legal, lowered SIL type.
   ///
   /// A type is SIL-illegal if it is:
@@ -866,11 +860,17 @@ class alignas(1 << TypeAlignInBits) TypeBase {
   /// the context of the extension above will produce substitutions T
   /// -> Int and U -> String suitable for mapping the type of
   /// \c SomeArray.
+  ///
+  /// \param genericEnv If non-null and the type is nested inside of a
+  /// generic function, generic parameters of the outer context are
+  /// mapped to context archetypes of this generic environment.
   SubstitutionMap getContextSubstitutionMap(ModuleDecl *module,
-                                            const DeclContext *dc);
+                                            const DeclContext *dc,
+                                            GenericEnvironment *genericEnv=nullptr);
 
   /// Deprecated version of the above.
-  TypeSubstitutionMap getContextSubstitutions(const DeclContext *dc);
+  TypeSubstitutionMap getContextSubstitutions(const DeclContext *dc,
+                                              GenericEnvironment *genericEnv=nullptr);
 
   /// Get the substitutions to apply to the type of the given member as seen
   /// from this base type.
@@ -4370,6 +4370,15 @@ inline bool TypeBase::isTypeParameter() {
   return false;
 }
 
+inline GenericTypeParamType *TypeBase::getRootGenericParam() {
+  Type t(this);
+
+  while (auto *memberTy = t->getAs<DependentMemberType>())
+    t = memberTy->getBase();
+
+  return t->castTo<GenericTypeParamType>();
+}
+
 inline bool TypeBase::isExistentialType() {
   return getCanonicalType().isExistentialType();
 }

include/swift/SIL/SILInstruction.h

@@ -3876,12 +3876,6 @@ class WitnessMethodInst final
 
   ProtocolConformanceRef getConformance() const { return Conformance; }
 
-  /// Get a representation of the lookup type as a substitution of the
-  /// protocol's Self archetype.
-  Substitution getSelfSubstitution() const {
-    return Substitution{getLookupType(), Conformance};
-  }
-
   ArrayRef<Operand> getAllOperands() const {
     return { getTrailingObjects<Operand>(), NumOperands };
   }

include/swift/SIL/SILType.h

@@ -423,6 +423,13 @@ class SILType {
   SILType substGenericArgs(SILModule &M,
                            SubstitutionList Subs) const;
 
+  /// Transform the function type SILType by replacing all of its interface
+  /// generic args with the appropriate item from the substitution.
+  ///
+  /// Only call this with function types!
+  SILType substGenericArgs(SILModule &M,
+                           const SubstitutionMap &SubMap) const;
+
   /// If the original type is generic, pass the signature as genericSig.
   ///
   /// If the replacement types are generic, you must push a generic context
@@ -434,10 +441,6 @@ class SILType {
 
   SILType subst(SILModule &silModule, const SubstitutionMap &subs) const;
 
-  /// If this is a specialized generic type, return all substitutions used to
-  /// generate it.
-  SubstitutionList gatherAllSubstitutions(SILModule &M);
-
   /// Return true if this type references a "ref" type that has a single pointer
   /// representation. Class existentials do not always qualify.
   bool isHeapObjectReferenceType() const;

lib/AST/ASTContext.cpp

@@ -262,10 +262,6 @@ struct ASTContext::Implementation {
     llvm::FoldingSet<ProtocolType> ProtocolTypes;
     llvm::FoldingSet<LayoutConstraintInfo> LayoutConstraints;
 
-    llvm::DenseMap<std::pair<TypeBase *, DeclContext *>,
-                   SubstitutionList>
-      BoundGenericSubstitutions;
-
     /// The set of normal protocol conformances.
     llvm::FoldingSet<NormalProtocolConformance> NormalConformances;
 
@@ -1101,52 +1097,6 @@ static AllocationArena getArena(RecursiveTypeProperties properties) {
                         : AllocationArena::Permanent;
 }
 
-Optional<SubstitutionList>
-ASTContext::createTrivialSubstitutions(BoundGenericType *BGT,
-                                       DeclContext *gpContext) const {
-  assert(gpContext && "No generic parameter context");
-  assert(gpContext->getGenericEnvironmentOfContext() != nullptr &&
-         "Not type-checked yet");
-  assert(BGT->getGenericArgs().size() == 1);
-  Substitution Subst(BGT->getGenericArgs()[0], {});
-  auto Substitutions = AllocateCopy(llvm::makeArrayRef(Subst));
-  auto arena = getArena(BGT->getRecursiveProperties());
-  Impl.getArena(arena).BoundGenericSubstitutions
-    .insert(std::make_pair(std::make_pair(BGT, gpContext), Substitutions));
-  return Substitutions;
-}
-
-Optional<SubstitutionList>
-ASTContext::getSubstitutions(TypeBase *type,
-                             DeclContext *gpContext) const {
-  assert(gpContext && "Missing generic parameter context");
-  auto arena = getArena(type->getRecursiveProperties());
-  auto &boundGenericSubstitutions
-    = Impl.getArena(arena).BoundGenericSubstitutions;
-  auto known = boundGenericSubstitutions.find({type, gpContext});
-  if (known != boundGenericSubstitutions.end())
-    return known->second;
-
-  // We can trivially create substitutions for Array and Optional.
-  if (auto bound = dyn_cast<BoundGenericType>(type))
-    if (bound->getDecl() == getArrayDecl() ||
-        bound->getDecl() == getOptionalDecl())
-      return createTrivialSubstitutions(bound, gpContext);
-
-  return None;
-}
-
-void ASTContext::setSubstitutions(TypeBase* type,
-                                  DeclContext *gpContext,
-                                  SubstitutionList Subs) const {
-  auto arena = getArena(type->getRecursiveProperties());
-  auto &boundGenericSubstitutions
-    = Impl.getArena(arena).BoundGenericSubstitutions;
-  assert(boundGenericSubstitutions.count({type, gpContext}) == 0 &&
-         "Already have substitutions?");
-  boundGenericSubstitutions[{type, gpContext}] = Subs;
-}
-
 void ASTContext::addSearchPath(StringRef searchPath, bool isFramework,
                                bool isSystem) {
   OptionSet<SearchPathKind> &loaded = Impl.SearchPathsSet[searchPath];
@@ -1609,13 +1559,12 @@ size_t ASTContext::Implementation::Arena::getTotalMemory() const {
     llvm::capacity_in_bytes(LValueTypes) +
     llvm::capacity_in_bytes(InOutTypes) +
     llvm::capacity_in_bytes(DependentMemberTypes) +
-    llvm::capacity_in_bytes(DynamicSelfTypes) +
+    llvm::capacity_in_bytes(DynamicSelfTypes);
     // EnumTypes ?
     // StructTypes ?
     // ClassTypes ?
     // UnboundGenericTypes ?
     // BoundGenericTypes ?
-    llvm::capacity_in_bytes(BoundGenericSubstitutions);
     // NormalConformances ?
     // SpecializedConformances ?
     // InheritedConformances ?

lib/AST/ASTMangler.cpp

@@ -1468,12 +1468,10 @@ static bool isMethodDecl(const Decl *decl) {
 }
 
 static bool genericParamIsBelowDepth(Type type, unsigned methodDepth) {
-  if (auto gp = type->getAs<GenericTypeParamType>()) {
+  if (type->isTypeParameter()) {
+    auto gp = type->getRootGenericParam();
     return gp->getDepth() >= methodDepth;
   }
-  if (auto dm = type->getAs<DependentMemberType>()) {
-    return genericParamIsBelowDepth(dm->getBase(), methodDepth);
-  }
   // Non-dependent types in a same-type requirement don't affect whether we
   // mangle the requirement.
   return false;

lib/AST/Decl.cpp

@@ -2914,10 +2914,7 @@ findProtocolSelfReferences(const ProtocolDecl *proto, Type type,
 
   // Special handling for associated types.
   if (!skipAssocTypes && type->is<DependentMemberType>()) {
-    while (auto depMemTy = type->getAs<DependentMemberType>()) {
-      type = depMemTy->getBase();
-    }
-
+    type = type->getRootGenericParam();
     if (proto->getProtocolSelfType()->isEqual(type))
       return SelfReferenceKind::Other();
   }

lib/AST/GenericSignature.cpp

@@ -461,14 +461,6 @@ getSubstitutionMap(TypeSubstitutionFn subs,
   return subMap;
 }
 
-void GenericSignature::
-getSubstitutions(const TypeSubstitutionMap &subs,
-                 GenericSignature::LookupConformanceFn lookupConformance,
-                 SmallVectorImpl<Substitution> &result) const {
-  getSubstitutions(QueryTypeSubstitutionMap{subs}, lookupConformance,
-                   result);
-}
-
 void GenericSignature::
 getSubstitutions(TypeSubstitutionFn subs,
                  GenericSignature::LookupConformanceFn lookupConformance,