SIL: Kill off GenericContextScope

Author: slavapestov

include/swift/SIL/SILFunction.h

@@ -591,6 +591,10 @@ class SILFunction
   /// therefore contain context archetypes, to an interface type.
   Type mapTypeOutOfContext(Type type) const;
 
+  /// Map the given type, which is based on a contextual SILFunctionType and may
+  /// therefore contain context archetypes, to an interface type.
+  SILType mapTypeOutOfContext(SILType type) const;
+
   /// Converts the given function definition to a declaration.
   void convertToDeclaration();
 

include/swift/SIL/SILType.h

@@ -128,7 +128,8 @@ class SILType {
 
   ///  Apply a substitution to the type to produce another lowered SIL type.
   static SILType substType(SILModule &silModule, ModuleDecl *astModule,
-                           const TypeSubstitutionMap &subs, SILType SrcTy);
+                           const TypeSubstitutionMap &subs, SILType SrcTy,
+                           CanGenericSignature genericSig=CanGenericSignature());
 
   ///  Apply a substitution to the function type.
   static CanSILFunctionType substFuncType(SILModule &silModule,
@@ -448,7 +449,8 @@ class SILType {
                            ArrayRef<Substitution> Subs) const;
 
   SILType subst(SILModule &silModule, ModuleDecl *astModule,
-                const TypeSubstitutionMap &subs) const;
+                const TypeSubstitutionMap &subs,
+                CanGenericSignature genericSig=CanGenericSignature()) const;
 
   /// If this is a specialized generic type, return all substitutions used to
   /// generate it.
@@ -548,6 +550,7 @@ NON_SIL_TYPE(LValue)
 CanSILFunctionType getNativeSILFunctionType(SILModule &M,
                         Lowering::AbstractionPattern orig,
                         CanAnyFunctionType substInterface,
+                        CanGenericSignature genericSig,
                         Optional<SILDeclRef> constant = None,
                         SILDeclRef::Kind kind = SILDeclRef::Kind::Func);
 

include/swift/SIL/TypeLowering.h

@@ -85,13 +85,6 @@ inline CanSILFunctionType adjustFunctionType(CanSILFunctionType t,
 }
 
 
-/// Flag used to place context-dependent TypeLowerings in their own arena which
-/// can be disposed when a generic context is exited.
-enum IsDependent_t : unsigned {
-  IsNotDependent = false,
-  IsDependent = true
-};
-  
 /// Extended type information used by SIL.
 class TypeLowering {
 public:
@@ -335,10 +328,8 @@ class TypeLowering {
   }
 
   /// Allocate a new TypeLowering using the TypeConverter's allocator.
-  void *operator new(size_t size, TypeConverter &tc,
-                     IsDependent_t dependent);
-  void *operator new[](size_t size, TypeConverter &tc,
-                       IsDependent_t dependent);
+  void *operator new(size_t size, TypeConverter &tc);
+  void *operator new[](size_t size, TypeConverter &tc);
 
   // Forbid 'new FooTypeLowering' and try to forbid 'delete tl'.
   // The latter is made challenging because the existence of the
@@ -399,9 +390,6 @@ class TypeConverter {
   friend class TypeLowering;
 
   llvm::BumpPtrAllocator IndependentBPA;
-  /// BumpPtrAllocator for types dependent on contextual generic parameters,
-  /// which is reset when the generic context is popped.
-  llvm::BumpPtrAllocator DependentBPA;
 
   enum : unsigned {
     /// There is a unique entry with this uncurry level in the
@@ -411,15 +399,17 @@ class TypeConverter {
   };
 
   struct CachingTypeKey {
-    GenericSignature *Sig;
+    GenericSignature *OrigSig;
     AbstractionPattern::CachingKey OrigType;
+    GenericSignature *SubstSig;
     CanType SubstType;
     unsigned UncurryLevel;
 
     friend bool operator==(const CachingTypeKey &lhs,
                            const CachingTypeKey &rhs) {
-      return lhs.Sig == rhs.Sig
+      return lhs.OrigSig == rhs.OrigSig
           && lhs.OrigType == rhs.OrigType
+          && lhs.SubstSig == rhs.SubstSig
           && lhs.SubstType == rhs.SubstType
           && lhs.UncurryLevel == rhs.UncurryLevel;
     }
@@ -433,6 +423,10 @@ class TypeConverter {
     /// An unsubstituted version of a type, dictating its abstraction patterns.
     AbstractionPattern OrigType;
 
+    /// The generic signature describing dependent types in the substituted
+    /// type.
+    CanGenericSignature SubstSig;
+
     /// The substituted version of the type, dictating the types that
     /// should be used in the lowered type.
     CanType SubstType;
@@ -446,26 +440,23 @@ class TypeConverter {
                    ? OrigType.getGenericSignature()
                    : nullptr),
                OrigType.getCachingKey(),
+               SubstSig,
                SubstType,
                UncurryLevel };
     }
 
     bool isCacheable() const {
       return OrigType.hasCachingKey();
     }
-    
-    IsDependent_t isDependent() const {
-      if (SubstType->hasTypeParameter())
-        return IsDependent;
-      return IsNotDependent;
-    }
   };
 
   friend struct llvm::DenseMapInfo<CachingTypeKey>;
 
-  TypeKey getTypeKey(AbstractionPattern origTy, CanType substTy,
+  TypeKey getTypeKey(AbstractionPattern origTy,
+                     CanGenericSignature substSig,
+                     CanType substTy,
                      unsigned uncurryLevel) {
-    return {origTy, substTy, uncurryLevel};
+    return {origTy, substSig, substTy, uncurryLevel};
   }
 
   struct OverrideKey {
@@ -491,12 +482,7 @@ class TypeConverter {
   /// Insert a mapping into the cache.
   void insert(TypeKey k, const TypeLowering *tl);
 
-  /// Mapping for types independent on contextual generic parameters, which is
-  /// cleared when the generic context is popped.
   llvm::DenseMap<CachingTypeKey, const TypeLowering *> IndependentTypes;
-  /// Mapping for types dependent on contextual generic parameters, which is
-  /// cleared when the generic context is popped.
-  llvm::DenseMap<CachingTypeKey, const TypeLowering *> DependentTypes;
 
   llvm::DenseMap<SILDeclRef, SILConstantInfo> ConstantTypes;
 
@@ -577,31 +563,42 @@ class TypeConverter {
 
   /// Lowers a Swift type to a SILType, and returns the SIL TypeLowering
   /// for that type.
-  const TypeLowering &getTypeLowering(Type t, unsigned uncurryLevel = 0) {
-    AbstractionPattern pattern(CurGenericContext, t->getCanonicalType());
-    return getTypeLowering(pattern, t, uncurryLevel);
+  const TypeLowering &getTypeLowering(Type t, unsigned uncurryLevel = 0,
+                                      CanGenericSignature genericSig
+                                          = CanGenericSignature()) {
+    if (!genericSig)
+      genericSig = CurGenericContext;
+    AbstractionPattern pattern(genericSig, t->getCanonicalType());
+    return getTypeLowering(pattern, t, uncurryLevel, genericSig);
   }
 
   /// Lowers a Swift type to a SILType according to the abstraction
   /// patterns of the given original type.
   const TypeLowering &getTypeLowering(AbstractionPattern origType,
                                       Type substType,
-                                      unsigned uncurryLevel = 0);
+                                      unsigned uncurryLevel = 0,
+                                      CanGenericSignature genericSig
+                                          = CanGenericSignature());
 
   /// Returns the SIL TypeLowering for an already lowered SILType. If the
   /// SILType is an address, returns the TypeLowering for the pointed-to
   /// type.
   const TypeLowering &getTypeLowering(SILType t);
 
   // Returns the lowered SIL type for a Swift type.
-  SILType getLoweredType(Type t, unsigned uncurryLevel = 0) {
-    return getTypeLowering(t, uncurryLevel).getLoweredType();
+  SILType getLoweredType(Type t, unsigned uncurryLevel = 0,
+                         CanGenericSignature genericSig
+                             = CanGenericSignature()) {
+    return getTypeLowering(t, uncurryLevel, genericSig).getLoweredType();
   }
 
   // Returns the lowered SIL type for a Swift type.
   SILType getLoweredType(AbstractionPattern origType, Type substType,
-                         unsigned uncurryLevel = 0) {
-    return getTypeLowering(origType, substType, uncurryLevel).getLoweredType();
+                         unsigned uncurryLevel = 0,
+                         CanGenericSignature genericSig
+                            = CanGenericSignature()) {
+    return getTypeLowering(origType, substType, uncurryLevel, genericSig)
+        .getLoweredType();
   }
 
   SILType getLoweredLoadableType(Type t, unsigned uncurryLevel = 0) {
@@ -736,24 +733,6 @@ class TypeConverter {
   CanGenericSignature getEffectiveGenericSignature(AnyFunctionRef fn,
                                                    CaptureInfo captureInfo);
 
-  /// Push a generic function context. See GenericContextScope for an RAII
-  /// interface to this function.
-  ///
-  /// Types containing generic parameter references must be lowered in a generic
-  /// context. There can be at most one level of generic context active at any
-  /// point in time.
-  void pushGenericContext(CanGenericSignature sig);
-
-  /// Return the current generic context.  This should only be used in
-  /// the type-conversion routines.
-  CanGenericSignature getCurGenericContext() const {
-    return CurGenericContext;
-  }
-  
-  /// Pop a generic function context. See GenericContextScope for an RAII
-  /// interface to this function. There must be an active generic context.
-  void popGenericContext(CanGenericSignature sig);
-  
   /// Known types for bridging.
 #define BRIDGING_KNOWN_TYPE(BridgedModule,BridgedType) \
   CanType get##BridgedType##Type();
@@ -797,7 +776,8 @@ class TypeConverter {
                                   CanAnyFunctionType origInterfaceType);
 private:
   CanType getLoweredRValueType(AbstractionPattern origType, CanType substType,
-                               unsigned uncurryLevel);
+                               unsigned uncurryLevel,
+                               CanGenericSignature genericSig);
 
   Type getLoweredCBridgedType(AbstractionPattern pattern, Type t,
                               bool canBridgeBool,
@@ -826,26 +806,6 @@ TypeLowering::getSemanticTypeLowering(TypeConverter &TC) const {
   return *this;
 }
 
-/// RAII interface to push a generic context.
-class GenericContextScope {
-  TypeConverter &TC;
-  CanGenericSignature Sig;
-public:
-  GenericContextScope(TypeConverter &TC, CanGenericSignature sig)
-    : TC(TC), Sig(sig)
-  {
-    TC.pushGenericContext(sig);
-  }
-  
-  ~GenericContextScope() {
-    TC.popGenericContext(Sig);
-  }
-  
-private:
-  GenericContextScope(const GenericContextScope&) = delete;
-  GenericContextScope &operator=(const GenericContextScope&) = delete;
-};
-  
 } // namespace Lowering
 } // namespace swift
 
@@ -860,19 +820,22 @@ namespace llvm {
 
     // Use the second field because the first field can validly be null.
     static CachingTypeKey getEmptyKey() {
-      return {nullptr, APCachingKey(), CanTypeInfo::getEmptyKey(), 0};
+      return {nullptr, APCachingKey(), nullptr, CanTypeInfo::getEmptyKey(), 0};
     }
     static CachingTypeKey getTombstoneKey() {
-      return {nullptr, APCachingKey(), CanTypeInfo::getTombstoneKey(), 0};
+      return {nullptr, APCachingKey(), nullptr, CanTypeInfo::getTombstoneKey(), 0};
     }
     static unsigned getHashValue(CachingTypeKey val) {
-      auto hashSig =
-        DenseMapInfo<swift::GenericSignature *>::getHashValue(val.Sig);
+      auto hashOrigSig =
+        DenseMapInfo<swift::GenericSignature *>::getHashValue(val.OrigSig);
       auto hashOrig =
         CachingKeyInfo::getHashValue(val.OrigType);
       auto hashSubst =
         DenseMapInfo<swift::CanType>::getHashValue(val.SubstType);
-      return hash_combine(hashSig, hashOrig, hashSubst, val.UncurryLevel);
+      auto hashSubstSig =
+        DenseMapInfo<swift::GenericSignature *>::getHashValue(val.SubstSig);
+      return hash_combine(hashOrigSig, hashOrig, hashSubstSig, hashSubst,
+                          val.UncurryLevel);
     }
     static bool isEqual(CachingTypeKey LHS, CachingTypeKey RHS) {
       return LHS == RHS;

lib/AST/GenericEnvironment.cpp

@@ -58,13 +58,14 @@ void *GenericEnvironment::operator new(size_t bytes, const ASTContext &ctx) {
 }
 
 Type GenericEnvironment::mapTypeOutOfContext(ModuleDecl *M, Type type) const {
+  // FIXME: Nuke AllowLoweredTypes
   type = type.subst(M, ArchetypeToInterfaceMap, SubstFlags::AllowLoweredTypes);
   assert(!type->hasArchetype() && "not fully substituted");
   return type;
 }
 
 Type GenericEnvironment::mapTypeIntoContext(ModuleDecl *M, Type type) const {
-  type = type.subst(M, InterfaceToArchetypeMap, SubstFlags::AllowLoweredTypes);
+  type = type.subst(M, InterfaceToArchetypeMap);
   assert((!type->hasTypeParameter() || type->hasError()) &&
          "not fully substituted");
   return type;

lib/IRGen/GenProto.cpp

@@ -448,6 +448,8 @@ class EmitPolymorphicParameters : public PolymorphicConvention {
 private:
   CanType getTypeInContext(CanType type) const;
 
+  SILType getTypeInContext(SILType type) const;
+
   CanType getArgTypeInContext(unsigned paramIndex) const;
 
   /// Fulfill local type data from any extra information associated with
@@ -476,8 +478,13 @@ CanType EmitPolymorphicParameters::getTypeInContext(CanType type) const {
   return Fn.mapTypeIntoContext(type)->getCanonicalType();
 }
 
+SILType EmitPolymorphicParameters::getTypeInContext(SILType type) const {
+  return Fn.mapTypeIntoContext(type);
+}
+
 CanType EmitPolymorphicParameters::getArgTypeInContext(unsigned paramIndex) const {
-  return getTypeInContext(FnType->getParameters()[paramIndex].getType());
+  return getTypeInContext(FnType->getParameters()[paramIndex].getSILType())
+      .getSwiftRValueType();
 }
 
 void EmitPolymorphicParameters::bindExtraSource(const MetadataSource &source,

lib/IRGen/GenReflection.cpp

@@ -706,22 +706,21 @@ class CaptureDescriptorBuilder : public ReflectionMetadataBuilder {
     std::vector<CanType> CaptureTypes;
 
     for (auto ElementType : getElementTypes()) {
-      auto SwiftType = ElementType.getSwiftRValueType();
+      auto InterfaceType = Caller.mapTypeOutOfContext(ElementType);
+      auto SwiftType = InterfaceType.getSwiftRValueType();
 
       // Erase pseudogeneric captures down to AnyObject.
       if (OrigCalleeType->isPseudogeneric()) {
         SwiftType = SwiftType.transform([&](Type t) -> Type {
-          if (auto *archetype = t->getAs<ArchetypeType>()) {
-            assert(archetype->requiresClass() && "don't know what to do");
+          if (t->is<GenericTypeParamType>()) {
             return IGM.Context.getProtocol(KnownProtocolKind::AnyObject)
                 ->getDeclaredType();
           }
           return t;
         })->getCanonicalType();
       }
 
-      auto InterfaceType = Caller.mapTypeOutOfContext(SwiftType);
-      CaptureTypes.push_back(InterfaceType->getCanonicalType());
+      CaptureTypes.push_back(SwiftType);
     }
 
     return CaptureTypes;

lib/IRGen/GenType.cpp

@@ -660,27 +660,23 @@ TypeConverter::~TypeConverter() {
 void TypeConverter::pushGenericContext(CanGenericSignature signature) {
   if (!signature)
     return;
-  
-  // Push the generic context down to the SIL TypeConverter, so we can share
-  // archetypes with SIL.
-  IGM.getSILTypes().pushGenericContext(signature);
+  assert(!CurGenericContext);
+  CurGenericContext = signature;
 }
 
 void TypeConverter::popGenericContext(CanGenericSignature signature) {
   if (!signature)
     return;
-
-  // Pop the SIL TypeConverter's generic context too.
-  IGM.getSILTypes().popGenericContext(signature);
-  
+  assert(signature == CurGenericContext);
+  CurGenericContext = CanGenericSignature();
   Types.DependentCache.clear();
 }
 
 ArchetypeBuilder &TypeConverter::getArchetypes() {
+  assert(CurGenericContext);
   auto moduleDecl = IGM.getSwiftModule();
-  auto genericSig = IGM.getSILTypes().getCurGenericContext();
   return *moduleDecl->getASTContext()
-      .getOrCreateArchetypeBuilder(genericSig, moduleDecl);
+      .getOrCreateArchetypeBuilder(CurGenericContext, moduleDecl);
 }
 
 ArchetypeBuilder &IRGenModule::getContextArchetypes() {