AST: Simpler implementation of mapTypeOutOfContext()

slavapestov · slavapestov · commit 9c0de31c2257 · 2017-10-07T05:44:57.000-07:00
Now that archetypes store an interface type, GenericEnvironments
no longer need to store a reverse mapping.
diff --git a/include/swift/AST/GenericEnvironment.h b/include/swift/AST/GenericEnvironment.h
@@ -37,37 +37,17 @@ class SILType;
 /// Describes the mapping between archetypes and interface types for the
 /// generic parameters of a DeclContext.
 class alignas(1 << DeclAlignInBits) GenericEnvironment final
-        : private llvm::TrailingObjects<GenericEnvironment, Type,
-                                        std::pair<ArchetypeType *,
-                                                  GenericTypeParamType *>> {
+        : private llvm::TrailingObjects<GenericEnvironment, Type> {
   GenericSignature *Signature = nullptr;
   GenericSignatureBuilder *Builder = nullptr;
   DeclContext *OwningDC = nullptr;
 
-  // The number of generic type parameter -> context type mappings we have
-  // recorded so far. This saturates at the number of generic type parameters,
-  // at which point the archetype-to-interface trailing array is sorted.
-  unsigned NumMappingsRecorded : 16;
-
-  // The number of archetype-to-interface type mappings. This is always <=
-  // \c NumMappingsRecorded.
-  unsigned NumArchetypeToInterfaceMappings : 16;
-
   friend TrailingObjects;
 
-  /// An entry in the array mapping from archetypes to their corresponding
-  /// generic type parameters.
-  typedef std::pair<ArchetypeType *, GenericTypeParamType *>
-                                                    ArchetypeToInterfaceMapping;
-
   size_t numTrailingObjects(OverloadToken<Type>) const {
     return Signature->getGenericParams().size();
   }
 
-  size_t numTrailingObjects(OverloadToken<ArchetypeToInterfaceMapping>) const {
-    return Signature->getGenericParams().size();
-  }
-
   /// Retrieve the array containing the context types associated with the
   /// generic parameters, stored in parallel with the generic parameters of the
   /// generic signature.
@@ -84,30 +64,6 @@ class alignas(1 << DeclAlignInBits) GenericEnvironment final
                           Signature->getGenericParams().size());
   }
 
-  /// Retrieve the active set of archetype-to-interface mappings.
-  ArrayRef<ArchetypeToInterfaceMapping>
-                                getActiveArchetypeToInterfaceMappings() const {
-    return { getTrailingObjects<ArchetypeToInterfaceMapping>(),
-             NumArchetypeToInterfaceMappings };
-  }
-
-  /// Retrieve the active set of archetype-to-interface mappings.
-  MutableArrayRef<ArchetypeToInterfaceMapping>
-                                      getActiveArchetypeToInterfaceMappings() {
-    return { getTrailingObjects<ArchetypeToInterfaceMapping>(),
-             NumArchetypeToInterfaceMappings };
-  }
-
-  /// Retrieve the buffer for the archetype-to-interface mappings.
-  ///
-  /// Only the first \c NumArchetypeToInterfaceMappings elements in the buffer
-  /// are valid.
-  MutableArrayRef<ArchetypeToInterfaceMapping>
-                                      getArchetypeToInterfaceMappingsBuffer() {
-    return { getTrailingObjects<ArchetypeToInterfaceMapping>(),
-             Signature->getGenericParams().size() };
-  }
-
   GenericEnvironment(GenericSignature *signature,
                      GenericSignatureBuilder *builder);
 
@@ -129,19 +85,6 @@ class alignas(1 << DeclAlignInBits) GenericEnvironment final
   };
   friend class QueryInterfaceTypeSubstitutions;
 
-  /// Query function suitable for use as a \c TypeSubstitutionFn that queries
-  /// the mapping of archetypes back to interface types.
-  class QueryArchetypeToInterfaceSubstitutions {
-    const GenericEnvironment *self;
-
-  public:
-    QueryArchetypeToInterfaceSubstitutions(const GenericEnvironment *self)
-      : self(self) { }
-
-    Type operator()(SubstitutableType *type) const;
-  };
-  friend class QueryArchetypeToInterfaceSubstitutions;
-
 public:
   GenericSignature *getGenericSignature() const {
     return Signature;
diff --git a/lib/AST/ASTContext.cpp b/lib/AST/ASTContext.cpp
@@ -4055,8 +4055,7 @@ GenericEnvironment *GenericEnvironment::getIncomplete(
 
   // Allocate and construct the new environment.
   unsigned numGenericParams = signature->getGenericParams().size();
-  size_t bytes = totalSizeToAlloc<Type, ArchetypeToInterfaceMapping>(
-                                           numGenericParams, numGenericParams);
+  size_t bytes = totalSizeToAlloc<Type>(numGenericParams);
   void *mem = ctx.Allocate(bytes, alignof(GenericEnvironment));
   return new (mem) GenericEnvironment(signature, builder);
 }
diff --git a/lib/AST/GenericEnvironment.cpp b/lib/AST/GenericEnvironment.cpp
@@ -25,9 +25,6 @@ GenericEnvironment::GenericEnvironment(GenericSignature *signature,
                                        GenericSignatureBuilder *builder)
   : Signature(signature), Builder(builder)
 {
-  NumMappingsRecorded = 0;
-  NumArchetypeToInterfaceMappings = 0;
-
   // Clear out the memory that holds the context types.
   std::uninitialized_fill(getContextTypes().begin(), getContextTypes().end(),
                           Type());
@@ -73,55 +70,6 @@ void GenericEnvironment::addMapping(GenericParamKey key,
   // Add the mapping from the generic parameter to the context type.
   assert(getContextTypes()[index].isNull() && "Already recoded this mapping");
   getContextTypes()[index] = contextType;
-
-  // If we mapped the generic parameter to an archetype, add it to the
-  // reverse mapping.
-  if (auto *archetype = contextType->getAs<ArchetypeType>()) {
-    auto genericParam = genericParams[index];
-
-    // Check whether we've already recorded a generic parameter for this
-    // archetype. Note that we always perform a linear search, because we
-    // won't have sorted the list yet.
-    bool found = false;
-    for (auto &mapping : getActiveArchetypeToInterfaceMappings()) {
-      if (mapping.first != archetype) continue;
-
-      // Multiple generic parameters map to the same archetype. If the
-      // existing entry comes from a later generic parameter, replace it with
-      // the earlier generic parameter. This gives us a deterministic reverse
-      // mapping.
-      auto otherGP = mapping.second->castTo<GenericTypeParamType>();
-      if (GenericParamKey(genericParam) < GenericParamKey(otherGP))
-        mapping.second = genericParam;
-      found = true;
-      break;
-    }
-
-    // If we haven't recorded a generic parameter for this archetype, do so now.
-    if (!found) {
-      void *ptr = getArchetypeToInterfaceMappingsBuffer().data()
-                + NumArchetypeToInterfaceMappings;
-      new (ptr) ArchetypeToInterfaceMapping(archetype, genericParam);
-      ++NumArchetypeToInterfaceMappings;
-    }
-  }
-
-  // Note that we've recorded this mapping.
-  ++NumMappingsRecorded;
-
-  // If we've recorded all of the mappings, go ahead and sort the array of
-  // archetype-to-interface-type mappings.
-  if (NumMappingsRecorded == genericParams.size()) {
-    llvm::array_pod_sort(getActiveArchetypeToInterfaceMappings().begin(),
-                         getActiveArchetypeToInterfaceMappings().end(),
-                         [](const ArchetypeToInterfaceMapping *lhs,
-                            const ArchetypeToInterfaceMapping *rhs) -> int {
-                           std::less<ArchetypeType *> compare;
-                           if (compare(lhs->first, rhs->first)) return -1;
-                           if (compare(rhs->first, lhs->first)) return 1;
-                           return 0;
-                         });
-  }
 }
 
 Optional<Type> GenericEnvironment::getMappingIfPresent(
@@ -160,7 +108,9 @@ GenericEnvironment::mapTypeOutOfContext(GenericEnvironment *env,
 }
 
 Type GenericEnvironment::mapTypeOutOfContext(Type type) const {
-  type = type.subst(QueryArchetypeToInterfaceSubstitutions(this),
+  type = type.subst([&](SubstitutableType *t) -> Type {
+                      return cast<ArchetypeType>(t)->getInterfaceType();
+                    },
                     MakeAbstractConformanceForGenericType(),
                     SubstFlags::AllowLoweredTypes);
   assert(!type->hasArchetype() && "not fully substituted");
@@ -204,74 +154,6 @@ Type GenericEnvironment::QueryInterfaceTypeSubstitutions::operator()(
   return Type();
 }
 
-Type GenericEnvironment::QueryArchetypeToInterfaceSubstitutions::operator()(
-                                                SubstitutableType *type) const {
-  auto archetype = type->getAs<ArchetypeType>();
-  if (!archetype) return Type();
-
-  // Only top-level archetypes need to be substituted directly; nested
-  // archetypes will be handled via their root archetypes.
-  if (archetype->getParent()) return Type();
-
-  // If not all generic parameters have had their context types recorded,
-  // perform a linear search.
-  auto genericParams = self->Signature->getGenericParams();
-  unsigned numGenericParams = genericParams.size();
-  if (self->NumMappingsRecorded < numGenericParams) {
-    // Search through all of the active archetype-to-interface mappings.
-    for (auto &mapping : self->getActiveArchetypeToInterfaceMappings())
-      if (mapping.first == archetype) return mapping.second;
-
-    // We don't know if the archetype is from a different context or if we
-    // simply haven't recorded it yet. Spin through all of the generic
-    // parameters looking for one that provides this mapping.
-    for (auto gp : genericParams) {
-      // Map the generic parameter into our context. If we get back an
-      // archetype that matches, we're done.
-      auto gpArchetype = self->mapTypeIntoContext(gp)->getAs<ArchetypeType>();
-      if (gpArchetype == archetype) return gp;
-    }
-
-    // We have checked all of the generic parameters and not found anything;
-    // there is no substitution.
-    return Type();
-  }
-
-  // All generic parameters have ad their context types recorded, which means
-  // that the archetypes-to-interface-types array is sorted by address. Use a
-  // binary search.
-  struct MappingComparison {
-    bool operator()(const ArchetypeToInterfaceMapping &lhs,
-                    const ArchetypeType *rhs) const {
-      std::less<const ArchetypeType *> compare;
-
-      return compare(lhs.first, rhs);
-    }
-
-    bool operator()(const ArchetypeType *lhs,
-                    const ArchetypeToInterfaceMapping &rhs) const {
-      std::less<const ArchetypeType *> compare;
-
-      return compare(lhs, rhs.first);
-    }
-
-    bool operator()(const ArchetypeToInterfaceMapping &lhs,
-                    const ArchetypeToInterfaceMapping &rhs) const {
-      std::less<const ArchetypeType *> compare;
-
-      return compare(lhs.first, rhs.first);
-    }
-  } mappingComparison;
-
-  auto mappings = self->getActiveArchetypeToInterfaceMappings();
-  auto known = std::lower_bound(mappings.begin(), mappings.end(), archetype,
-                                mappingComparison);
-  if (known != mappings.end() && known->first == archetype)
-    return known->second;
-
-  return Type();
-}
-
 Type GenericEnvironment::mapTypeIntoContext(
                                 Type type,
                                 LookupConformanceFn lookupConformance) const {

Original file line number	Diff line number	Diff line change
`@@ -4055,8 +4055,7 @@ GenericEnvironment *GenericEnvironment::getIncomplete(`
`4055`	`4055`
`4056`	`4056`	`// Allocate and construct the new environment.`
`4057`	`4057`	`unsigned numGenericParams = signature->getGenericParams().size();`
`4058`		`- size_t bytes = totalSizeToAlloc<Type, ArchetypeToInterfaceMapping>(`
`4059`		`- numGenericParams, numGenericParams);`
	`4058`	`+ size_t bytes = totalSizeToAlloc<Type>(numGenericParams);`
`4060`	`4059`	`void *mem = ctx.Allocate(bytes, alignof(GenericEnvironment));`
`4061`	`4060`	`return new (mem) GenericEnvironment(signature, builder);`
`4062`	`4061`	`}`