[AST] Replace SubstitutionList in NameAliasType with a SubstitutionMap.

Convert NameAliasType’s internal representation from tail-allocating an
array of Substitutions (to be treated as a SubstitutionList) to store a
single SubstitutionMap. Serialize using that SubstitutionMap.

Author: DougGregor

include/swift/AST/GenericSignature.h

@@ -20,7 +20,7 @@
 #include "swift/AST/PrintOptions.h"
 #include "swift/AST/Requirement.h"
 #include "swift/AST/SubstitutionList.h"
-#include "swift/AST/Types.h"
+#include "swift/AST/Type.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/FoldingSet.h"
 #include "llvm/ADT/SmallVector.h"
@@ -361,14 +361,6 @@ CanGenericSignature::CanGenericSignature(GenericSignature *Signature)
 {
   assert(!Signature || Signature->isCanonical());
 }
-  
-inline ArrayRef<CanTypeWrapper<GenericTypeParamType>>
-CanGenericSignature::getGenericParams() const{
-  auto params = Signature->getGenericParams().getOriginalArray();
-  auto base = static_cast<const CanTypeWrapper<GenericTypeParamType>*>(
-                                                                 params.data());
-  return {base, params.size()};
-}
 
 } // end namespace swift
 

include/swift/AST/Types.h

@@ -25,6 +25,7 @@
 #include "swift/AST/Requirement.h"
 #include "swift/AST/SILLayout.h"
 #include "swift/AST/SubstitutionList.h"
+#include "swift/AST/SubstitutionMap.h"
 #include "swift/AST/Type.h"
 #include "swift/AST/TypeAlignments.h"
 #include "swift/Basic/ArrayRefView.h"
@@ -373,14 +374,14 @@ class alignas(1 << TypeAlignInBits) TypeBase {
     GenericArgCount : 32
   );
 
-  SWIFT_INLINE_BITFIELD_FULL(NameAliasType, SugarType, 1+16,
+  SWIFT_INLINE_BITFIELD_FULL(NameAliasType, SugarType, 1+1,
     : NumPadBits,
 
     /// Whether we have a parent type.
     HasParent : 1,
 
-    /// The number of substitutions.
-    NumSubstitutions : 16
+    /// Whether we have a substitution map.
+    HasSubstitutionMap : 1
   );
 
   } Bits;
@@ -1592,39 +1593,28 @@ class SugarType : public TypeBase {
 /// set of substitutions to apply to make the type concrete.
 class NameAliasType final
   : public SugarType, public llvm::FoldingSetNode,
-    llvm::TrailingObjects<NameAliasType, Type, GenericSignature *,
-                          Substitution>
+    llvm::TrailingObjects<NameAliasType, Type, SubstitutionMap>
 {
   TypeAliasDecl *typealias;
 
   friend class ASTContext;
   friend TrailingObjects;
 
   NameAliasType(TypeAliasDecl *typealias, Type parent,
-                     const SubstitutionMap &substitutions, Type underlying,
-                     RecursiveTypeProperties properties);
-
-  unsigned getNumSubstitutions() const {
-    return Bits.NameAliasType.NumSubstitutions;
-  }
+                const SubstitutionMap &substitutions, Type underlying,
+                RecursiveTypeProperties properties);
 
   size_t numTrailingObjects(OverloadToken<Type>) const {
     return Bits.NameAliasType.HasParent ? 1 : 0;
   }
 
-  size_t numTrailingObjects(OverloadToken<GenericSignature *>) const {
-    return getNumSubstitutions() > 0 ? 1 : 0;
-  }
-
-  size_t numTrailingObjects(OverloadToken<Substitution>) const {
-    return getNumSubstitutions();
+  size_t numTrailingObjects(OverloadToken<SubstitutionMap>) const {
+    return Bits.NameAliasType.HasSubstitutionMap ? 1 : 0;
   }
 
   /// Retrieve the generic signature used for substitutions.
   GenericSignature *getGenericSignature() const {
-    return getNumSubstitutions() > 0
-             ? *getTrailingObjects<GenericSignature *>()
-             : nullptr;
+    return getSubstitutionMap().getGenericSignature();
   }
 
 public:
@@ -1642,18 +1632,17 @@ class NameAliasType final
   /// written before ".", if provided.
   Type getParent() const {
     return Bits.NameAliasType.HasParent ? *getTrailingObjects<Type>()
-                                             : Type();
-  }
-
-  /// Retrieve the set of substitutions to be applied to the declaration to
-  /// produce the underlying type.
-  SubstitutionList getSubstitutionList() const {
-    return {getTrailingObjects<Substitution>(), getNumSubstitutions()};
+                                        : Type();
   }
 
   /// Retrieve the substitution map applied to the declaration's underlying
   /// to produce the described type.
-  SubstitutionMap getSubstitutionMap() const;
+  SubstitutionMap getSubstitutionMap() const {
+    if (!Bits.NameAliasType.HasSubstitutionMap)
+      return SubstitutionMap();
+
+    return *getTrailingObjects<SubstitutionMap>();
+  }
 
   /// Get the innermost generic arguments, which correspond to the generic
   /// arguments that are directly applied to the typealias declaration in
@@ -5395,6 +5384,14 @@ inline bool TypeBase::hasSimpleTypeRepr() const {
   }
 }
 
+inline ArrayRef<CanTypeWrapper<GenericTypeParamType>>
+CanGenericSignature::getGenericParams() const{
+  auto params = Signature->getGenericParams().getOriginalArray();
+  auto base = static_cast<const CanTypeWrapper<GenericTypeParamType>*>(
+                                                                 params.data());
+  return {base, params.size()};
+}
+
 } // end namespace swift
 
 namespace llvm {
@@ -5421,7 +5418,6 @@ struct DenseMapInfo<swift::BuiltinIntegerWidth> {
   }
 };
 
-
 }
 
 #endif

include/swift/Serialization/ModuleFormat.h

@@ -55,7 +55,7 @@ const uint16_t VERSION_MAJOR = 0;
 /// describe what change you made. The content of this comment isn't important;
 /// it just ensures a conflict if two people change the module format.
 /// Don't worry about adhering to the 80-column limit for this line.
-const uint16_t VERSION_MINOR = 409; // Last change: standalone requirement subs
+const uint16_t VERSION_MINOR = 410; // Last change: NameAlias substitution map
 
 using DeclIDField = BCFixed<31>;
 
@@ -654,10 +654,10 @@ namespace decls_block {
 
   using NameAliasTypeLayout = BCRecordLayout<
     NAME_ALIAS_TYPE,
-    DeclIDField, // typealias decl
-    TypeIDField, // parent type
-    TypeIDField  // underlying type
-    // trailing substitutions
+    DeclIDField,      // typealias decl
+    TypeIDField,      // parent type
+    TypeIDField,      // underlying type
+    SubstitutionMapIDField // substitution map
   >;
 
   using GenericTypeParamTypeLayout = BCRecordLayout<

lib/AST/ASTContext.cpp

@@ -30,6 +30,7 @@
 #include "swift/AST/ParameterList.h"
 #include "swift/AST/ProtocolConformance.h"
 #include "swift/AST/RawComment.h"
+#include "swift/AST/SubstitutionMap.h"
 #include "swift/AST/SILLayout.h"
 #include "swift/AST/TypeCheckerDebugConsumer.h"
 #include "swift/Basic/Compiler.h"
@@ -2883,9 +2884,9 @@ StringRef ASTContext::getSwiftName(KnownFoundationEntity kind) {
 //===----------------------------------------------------------------------===//
 
 NameAliasType::NameAliasType(TypeAliasDecl *typealias, Type parent,
-                                       const SubstitutionMap &substitutions,
-                                       Type underlying,
-                                       RecursiveTypeProperties properties)
+                             const SubstitutionMap &substitutions,
+                             Type underlying,
+                             RecursiveTypeProperties properties)
     : SugarType(TypeKind::NameAlias, underlying, properties),
       typealias(typealias) {
   // Record the parent (or absence of a parent).
@@ -2898,15 +2899,10 @@ NameAliasType::NameAliasType(TypeAliasDecl *typealias, Type parent,
 
   // Record the substitutions.
   if (auto genericSig = substitutions.getGenericSignature()) {
-    SmallVector<Substitution, 4> flatSubs;
-    genericSig->getSubstitutions(substitutions, flatSubs);
-    Bits.NameAliasType.NumSubstitutions = flatSubs.size();
-    std::copy(flatSubs.begin(), flatSubs.end(),
-              getTrailingObjects<Substitution>());
-
-    *getTrailingObjects<GenericSignature *>() = genericSig;
+    Bits.NameAliasType.HasSubstitutionMap = true;
+    *getTrailingObjects<SubstitutionMap>() = substitutions;
   } else {
-    Bits.NameAliasType.NumSubstitutions = 0;
+    Bits.NameAliasType.HasSubstitutionMap = false;
   }
 }
 
@@ -2947,11 +2943,8 @@ NameAliasType *NameAliasType::get(TypeAliasDecl *typealias, Type parent,
     return result;
 
   // Build a new type.
-  unsigned numSubstitutions =
-    genericSig ? genericSig->getSubstitutionListSize() : 0;
-  auto size =
-    totalSizeToAlloc<Type, GenericSignature *, Substitution>(
-                        parent ? 1 : 0, genericSig ? 1 : 0, numSubstitutions);
+  auto size = totalSizeToAlloc<Type, SubstitutionMap>(parent ? 1 : 0,
+                                                      genericSig ? 1 : 0);
   auto mem = ctx.Allocate(size, alignof(NameAliasType), arena);
   auto result = new (mem) NameAliasType(typealias, parent, substitutions,
                                         underlying, storedProperties);

lib/AST/Type.cpp

@@ -1340,33 +1340,24 @@ Type SugarType::getSinglyDesugaredTypeSlow() {
   return UnderlyingType;
 }
 
-SubstitutionMap NameAliasType::getSubstitutionMap() const {
-  if (auto genericSig = getGenericSignature())
-    return genericSig->getSubstitutionMap(getSubstitutionList());
-
-  return SubstitutionMap();
-}
-
 SmallVector<Type, 2> NameAliasType::getInnermostGenericArgs() const {
   SmallVector<Type, 2> result;
 
   // If the typealias is not generic, there are no generic arguments
   if (!typealias->isGeneric()) return result;
 
-  auto genericSig = typealias->getGenericSignature();
-  if (!genericSig) return result;
-
-  // If the substitution list was empty, bail out.
-  if (getSubstitutionList().empty()) return result;
+  // If the substitution map is empty, bail out.
+  auto subMap = getSubstitutionMap();
+  if (subMap.empty()) return result;
 
   // Retrieve the substitutions for the generic parameters (only).
+  auto genericSig = subMap.getGenericSignature();
   unsigned numAllGenericParams = genericSig->getGenericParams().size();
-  auto genericArgSubs = getSubstitutionList().slice(0, numAllGenericParams);
-
-  // Copy the replacement types for the innermost generic arguments.
   unsigned numMyGenericParams = typealias->getGenericParams()->size();
-  for (const auto &sub : genericArgSubs.take_back(numMyGenericParams)) {
-    result.push_back(sub.getReplacement());
+  result.reserve(numMyGenericParams);
+  unsigned startIndex = numAllGenericParams - numMyGenericParams;
+  for (auto gp : genericSig->getGenericParams().slice(startIndex)) {
+    result.push_back(Type(gp).subst(subMap, SubstFlags::UseErrorType));
   }
   return result;
 }

lib/Serialization/Deserialization.cpp

@@ -4288,9 +4288,11 @@ Expected<Type> ModuleFile::getTypeChecked(TypeID TID) {
     DeclID typealiasID;
     TypeID parentTypeID;
     TypeID underlyingTypeID;
+    SubstitutionMapID substitutionsID;
     decls_block::NameAliasTypeLayout::readRecord(scratch, typealiasID,
-                                                      parentTypeID,
-                                                      underlyingTypeID);
+                                                 parentTypeID,
+                                                 underlyingTypeID,
+                                                 substitutionsID);
     auto aliasOrError = getDeclChecked(typealiasID);
     if (!aliasOrError)
       return aliasOrError.takeError();
@@ -4318,16 +4320,7 @@ Expected<Type> ModuleFile::getTypeChecked(TypeID TID) {
     Type parentType = getType(parentTypeID);
 
     // Read the substitutions.
-    SubstitutionMap subMap;
-    if (auto genericSig = alias->getGenericSignature()) {
-      SmallVector<Substitution, 4> substitutions;
-      for (unsigned i : range(genericSig->getSubstitutionListSize())) {
-        (void)i;
-        substitutions.push_back(*maybeReadSubstitution(DeclTypeCursor));
-      }
-
-      subMap = genericSig->getSubstitutionMap(substitutions);
-    }
+    SubstitutionMap subMap = getSubstitutionMap(substitutionsID);
 
     // Look through compatibility aliases that are now unavailable.
     if (alias->getAttrs().isUnavailable(ctx) &&
@@ -4337,7 +4330,7 @@ Expected<Type> ModuleFile::getTypeChecked(TypeID TID) {
     }
 
     typeOrOffset = NameAliasType::get(alias, parentType, subMap,
-                                           underlyingType);
+                                      underlyingType);
     break;
   }
   case decls_block::NOMINAL_TYPE: {

lib/Serialization/Serialization.cpp

@@ -3666,14 +3666,13 @@ void Serializer::writeType(Type ty) {
 
     unsigned abbrCode = DeclTypeAbbrCodes[NameAliasTypeLayout::Code];
     NameAliasTypeLayout::emitRecord(
-                             Out, ScratchRecord, abbrCode,
-                             addDeclRef(typeAlias,
-                                        /*forceSerialization*/false,
-                                        /*allowTypeAliasXRef*/true),
-                             addTypeRef(alias->getParent()),
-                             addTypeRef(alias->getSinglyDesugaredType()));
-    // Write the set of substitutions.
-    writeSubstitutions(alias->getSubstitutionList(), DeclTypeAbbrCodes);
+                           Out, ScratchRecord, abbrCode,
+                           addDeclRef(typeAlias,
+                                      /*forceSerialization*/false,
+                                      /*allowTypeAliasXRef*/true),
+                           addTypeRef(alias->getParent()),
+                           addTypeRef(alias->getSinglyDesugaredType()),
+                           addSubstitutionMapRef(alias->getSubstitutionMap()));
     break;
   }