SIL: Plumb abstraction patterns through type lowering.

Lowering a SIL type should be a pure function of the formal type of a value and the
abstraction pattern it's being lowered against, but we historically did not carry
enough information in abstraction patterns to lower generic parameter types, so we
relied on a generic context signature that would be pushed and popped before lowering
interface types. This patch largely eliminates the necessity for that, by making it
so that `TypeClassifierBase` and its subclasses now take an `AbstractionPattern`
all the way down, and fixing up the visitor logic so that it derives appropriate
abstraction patterns for tuple elements, function arguments, and aggregate fields too.
This makes it so that type lowering is independent of the current generic context.
(Unfortunately, there are still places scattered across the code where we use the
current generic context in order to build abstraction patterns that we then feed
into type lowering, so we can't yet completely eliminate the concept.)

This then enables us to integrate substituted function type construction into type
lowering as well, since we can now lower a generic parameter type against an
abstraction pattern without that generic parameter having to be tied to the same
generic signature (or any generic signature at all, which in the case of a
substituted function type hasn't necessarily even been finalized yet.)

Author: jckarter

include/swift/SIL/AbstractionPattern.h

@@ -409,7 +409,13 @@ class AbstractionPattern {
     assert(hasGenericSignature());
     return CanGenericSignature(GenericSig);
   }
-  
+
+  CanGenericSignature getGenericSignatureOrNull() const {
+    if (!hasGenericSignature())
+      return CanGenericSignature();
+    return CanGenericSignature(GenericSig);
+  }
+
   /// Return an open-coded abstraction pattern for a tuple.  The
   /// caller is responsible for ensuring that the storage for the
   /// tuple elements is valid for as long as the abstraction pattern is.
@@ -513,6 +519,15 @@ class AbstractionPattern {
     return pattern;
   }
 
+  /// Return an abstraction pattern for the type of the given struct field or enum case
+  /// substituted in `this` type.
+  ///
+  /// Note that, for most purposes, you should lower a field's type against its
+  /// *unsubstituted* interface type.
+  AbstractionPattern
+  unsafeGetSubstFieldType(ValueDecl *member,
+                          CanType origMemberType = CanType()) const;
+  
 private:
   /// Return an abstraction pattern for the curried type of an
   /// Objective-C method.
@@ -648,11 +663,34 @@ class AbstractionPattern {
     return getKind() != Kind::Invalid;
   }
 
+  bool isTypeParameterOrOpaqueArchetype() const {
+    switch (getKind()) {
+    case Kind::Opaque:
+      return true;
+    case Kind::Type:
+    case Kind::ClangType:
+    case Kind::Discard: {
+      auto type = getType();
+      if (isa<DependentMemberType>(type) ||
+          isa<GenericTypeParamType>(type)) {
+        return true;
+      }
+      if (auto archetype = dyn_cast<ArchetypeType>(type)) {
+        return true;
+      }
+      return false;
+    }
+    default:
+      return false;
+    }
+  }
+
   bool isTypeParameter() const {
     switch (getKind()) {
     case Kind::Opaque:
       return true;
     case Kind::Type:
+    case Kind::ClangType:
     case Kind::Discard: {
       auto type = getType();
       if (isa<DependentMemberType>(type) ||
@@ -668,12 +706,13 @@ class AbstractionPattern {
       return false;
     }
   }
-
+  
   /// Is this an interface type that is subject to a concrete
   /// same-type constraint?
   bool isConcreteType() const;
 
-  bool requiresClass();
+  bool requiresClass() const;
+  LayoutConstraint getLayoutConstraint() const;
 
   /// Return the Swift type which provides structure for this
   /// abstraction pattern.

include/swift/SIL/SILType.h

@@ -242,7 +242,8 @@ class SILType {
   ///
   /// This is equivalent to, but possibly faster than, calling
   /// tc.getTypeLowering(type).isAddressOnly().
-  static bool isAddressOnly(CanType type, Lowering::TypeConverter &tc,
+  static bool isAddressOnly(CanType type,
+                            Lowering::TypeConverter &tc,
                             CanGenericSignature sig,
                             TypeExpansionContext expansion);
 

include/swift/SIL/TypeLowering.h

@@ -93,13 +93,6 @@ adjustFunctionType(CanSILFunctionType t, SILFunctionType::Representation rep,
                             witnessMethodConformance);
 }
 
-/// 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
-};
-
 /// Is a lowered SIL type trivial?  That is, are copies ultimately just
 /// bit-copies, and it takes no work to destroy a value?
 enum IsTrivial_t : bool {
@@ -182,6 +175,10 @@ class TypeLowering {
               (isFixedABI ? 0U : NonFixedABIFlag) |
               (isAddressOnly ? AddressOnlyFlag : 0U) |
               (isResilient ? ResilientFlag : 0U)) {}
+    
+    constexpr bool operator==(RecursiveProperties p) const {
+      return Flags == p.Flags;
+    }
 
     static constexpr RecursiveProperties forTrivial() {
       return {IsTrivial, IsFixedABI, IsNotAddressOnly, IsNotResilient};
@@ -502,10 +499,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
@@ -573,7 +568,7 @@ enum class CaptureKind {
 class TypeConverter {
   friend class TypeLowering;
 
-  llvm::BumpPtrAllocator IndependentBPA;
+  llvm::BumpPtrAllocator TypeLoweringBPA;
 
   struct CachingTypeKey {
     CanGenericSignature Sig;
@@ -617,11 +612,6 @@ class TypeConverter {
       return OrigType.hasCachingKey();
     }
 
-    IsDependent_t isDependent() const {
-      if (SubstType->hasTypeParameter())
-        return IsDependent;
-      return IsNotDependent;
-    }
     TypeKey getKeyForMinimalExpansion() const {
       return {OrigType, SubstType, TypeExpansionContext::minimal()};
     }
@@ -662,13 +652,10 @@ class TypeConverter {
 #endif
 
   /// Mapping for types independent on contextual generic parameters.
-  llvm::DenseMap<CachingTypeKey, const TypeLowering *> IndependentTypes;
+  llvm::DenseMap<CachingTypeKey, const TypeLowering *> LoweredTypes;
 
   struct DependentTypeState {
-    llvm::BumpPtrAllocator BPA;
     CanGenericSignature Sig;
-    llvm::DenseMap<TypeConverter::CachingTypeKey,
-                   const TypeLowering *> Map;
 
     explicit DependentTypeState(CanGenericSignature sig) : Sig(sig) {}
 
@@ -703,7 +690,8 @@ class TypeConverter {
 #include "swift/SIL/BridgedTypes.def"
 
   const TypeLowering &
-  getTypeLoweringForLoweredType(TypeKey key,
+  getTypeLoweringForLoweredType(AbstractionPattern origType,
+                                CanType loweredType,
                                 TypeExpansionContext forExpansion,
                                 bool origHadOpaqueTypeArchetype);
 
@@ -772,11 +760,14 @@ class TypeConverter {
     return isIndirectPlusZeroSelfParameter(T.getASTType());
   }
 
-  /// Lowers a Swift type to a SILType, and returns the SIL TypeLowering
+  /// Lowers a context-independent Swift type to a SILType, and returns the SIL TypeLowering
   /// for that type.
+  ///
+  /// If `t` contains generic parameters, then the overload that also takes an
+  /// `AbstractionPattern` must be used.
   const TypeLowering &
   getTypeLowering(Type t, TypeExpansionContext forExpansion) {
-    AbstractionPattern pattern(getCurGenericContext(), t->getCanonicalType());
+    AbstractionPattern pattern(t->getCanonicalType());
     return getTypeLowering(pattern, t, forExpansion);
   }
 
@@ -789,8 +780,18 @@ class TypeConverter {
   /// Returns the SIL TypeLowering for an already lowered SILType. If the
   /// SILType is an address, returns the TypeLowering for the pointed-to
   /// type.
+  ///
+  /// If `t` contains type parameters, then the generic signature for its context
+  /// must be provided.
+  const TypeLowering &
+  getTypeLowering(SILType t, TypeExpansionContext forExpansion,
+                  CanGenericSignature signature = nullptr);
+
+  /// Returns the SIL TypeLowering for an already lowered SILType. If the
+  /// SILType is an address, returns the TypeLowering for the pointed-to
+  /// type in the context of the given SILFunction.
   const TypeLowering &
-  getTypeLowering(SILType t, TypeExpansionContext forExpansion);
+  getTypeLowering(SILType t, SILFunction &F);
 
   // Returns the lowered SIL type for a Swift type.
   SILType getLoweredType(Type t, TypeExpansionContext forExpansion) {

lib/IRGen/GenKeyPath.cpp

@@ -695,11 +695,12 @@ emitKeyPathComponent(IRGenModule &IGM,
          && "must be 32-bit-aligned here");
 
   SILType loweredBaseTy;
+  loweredBaseTy = IGM.getLoweredType(AbstractionPattern::getOpaque(),
+                                     baseTy->getWithoutSpecifierType());
+  // TODO: Eliminate GenericContextScope entirely
   GenericContextScope scope(IGM,
          genericEnv ? genericEnv->getGenericSignature()->getCanonicalSignature()
                     : nullptr);
-  loweredBaseTy = IGM.getLoweredType(AbstractionPattern::getOpaque(),
-                                     baseTy->getWithoutSpecifierType());
   switch (auto kind = component.getKind()) {
   case KeyPathPatternComponent::Kind::StoredProperty: {
     auto property = cast<VarDecl>(component.getStoredPropertyDecl());
@@ -1103,7 +1104,8 @@ emitKeyPathComponent(IRGenModule &IGM,
   case KeyPathPatternComponent::Kind::TupleElement:
     assert(baseTy->is<TupleType>() && "not a tuple");
 
-    SILType loweredTy = IGM.getLoweredType(baseTy);
+    SILType loweredTy = IGM.getLoweredType(AbstractionPattern::getOpaque(),
+                                           baseTy);
 
     // Tuple with fixed layout
     //
@@ -1112,7 +1114,8 @@ emitKeyPathComponent(IRGenModule &IGM,
     // the compiler knows that the tuple element is always at offset 0.
     // TODO: If this is behavior is not desired we should find a way to skip to
     // the next section of code e.g. check if baseTy has archetypes?
-    if (auto offset = getFixedTupleElementOffset(IGM, loweredTy, component.getTupleIndex())) {
+    if (auto offset = getFixedTupleElementOffset(IGM, loweredTy,
+                                                 component.getTupleIndex())) {
       auto header = KeyPathComponentHeader
                       ::forStructComponentWithInlineOffset(/*isLet*/ false,
                                                            offset->getValue());

lib/SIL/AbstractionPattern.cpp

@@ -203,28 +203,57 @@ bool AbstractionPattern::isConcreteType() const {
           GenericSig->isConcreteType(getType()));
 }
 
-bool AbstractionPattern::requiresClass() {
+bool AbstractionPattern::requiresClass() const {
   switch (getKind()) {
   case Kind::Opaque:
     return false;
   case Kind::Type:
-  case Kind::Discard: {
+  case Kind::Discard:
+  case Kind::ClangType: {
     auto type = getType();
     if (auto archetype = dyn_cast<ArchetypeType>(type))
       return archetype->requiresClass();
-    else if (isa<DependentMemberType>(type) ||
-             isa<GenericTypeParamType>(type)) {
+    if (isa<DependentMemberType>(type) ||
+        isa<GenericTypeParamType>(type)) {
+      if (getKind() == Kind::ClangType) {
+        // ObjC generics are always class constrained.
+        return true;
+      }
+      
       assert(GenericSig &&
              "Dependent type in pattern without generic signature?");
       return GenericSig->requiresClass(type);
     }
     return false;
   }
+    
   default:
     return false;
   }
 }
 
+LayoutConstraint AbstractionPattern::getLayoutConstraint() const {
+  switch (getKind()) {
+  case Kind::Opaque:
+    return LayoutConstraint();
+  case Kind::Type:
+  case Kind::Discard: {
+    auto type = getType();
+    if (auto archetype = dyn_cast<ArchetypeType>(type))
+      return archetype->getLayoutConstraint();
+    else if (isa<DependentMemberType>(type) ||
+             isa<GenericTypeParamType>(type)) {
+      assert(GenericSig &&
+             "Dependent type in pattern without generic signature?");
+      return GenericSig->getLayoutConstraint(type);
+    }
+    return LayoutConstraint();
+  }
+  default:
+    return LayoutConstraint();
+  }
+}
+
 bool AbstractionPattern::matchesTuple(CanTupleType substType) {
   switch (getKind()) {
   case Kind::Invalid:
@@ -391,7 +420,7 @@ AbstractionPattern AbstractionPattern::getFunctionResultType() const {
   case Kind::Opaque:
     return *this;
   case Kind::Type:
-    if (isTypeParameter())
+    if (isTypeParameterOrOpaqueArchetype())
       return AbstractionPattern::getOpaque();
     return AbstractionPattern(getGenericSignatureForFunctionComponent(),
                               getResultType(getType()));
@@ -440,7 +469,7 @@ AbstractionPattern::getFunctionParamType(unsigned index) const {
   case Kind::Opaque:
     return *this;
   case Kind::Type: {
-    if (isTypeParameter())
+    if (isTypeParameterOrOpaqueArchetype())
       return AbstractionPattern::getOpaque();
     auto params = cast<AnyFunctionType>(getType()).getParams();
     return AbstractionPattern(getGenericSignatureForFunctionComponent(),
@@ -699,6 +728,9 @@ void AbstractionPattern::print(raw_ostream &out) const {
             getKind() == Kind::PartialCurriedCXXMethodType
               ? "AP::PartialCurriedCXXMethodType("
               : "AP::PartialCurriedCFunctionAsMethodType(");
+    if (auto sig = getGenericSignature()) {
+      sig->print(out);
+    }
     getType().dump(out);
     out << ", ";
     // It would be better to use print, but we need a PrintingPolicy
@@ -796,3 +828,47 @@ bool AbstractionPattern::hasSameBasicTypeStructure(CanType l, CanType r) {
   // Otherwise, the structure is similar enough.
   return true;
 }
+
+AbstractionPattern
+AbstractionPattern::unsafeGetSubstFieldType(ValueDecl *member,
+                                            CanType origMemberInterfaceType)
+const {
+  if (isTypeParameterOrOpaqueArchetype()) {
+    // Fall back to the generic abstraction pattern for the member.
+    auto sig = member->getDeclContext()->getGenericSignatureOfContext();
+    CanType memberTy = origMemberInterfaceType
+      ? origMemberInterfaceType
+      : member->getInterfaceType()->getCanonicalType(sig);
+      
+    return AbstractionPattern(sig ? sig->getCanonicalSignature()
+                                  : CanGenericSignature(),
+                              memberTy);
+  }
+
+  switch (getKind()) {
+  case Kind::Opaque:
+    llvm_unreachable("should be handled by isTypeParameter");
+  case Kind::Invalid:
+    llvm_unreachable("called on invalid abstraction pattern");
+  case Kind::Tuple:
+    llvm_unreachable("should not have a tuple pattern matching a struct/enum "
+                     "type");
+  case Kind::PartialCurriedObjCMethodType:
+  case Kind::CurriedObjCMethodType:
+  case Kind::PartialCurriedCFunctionAsMethodType:
+  case Kind::CurriedCFunctionAsMethodType:
+  case Kind::CFunctionAsMethodType:
+  case Kind::ObjCMethodType:
+  case Kind::CXXMethodType:
+  case Kind::CurriedCXXMethodType:
+  case Kind::PartialCurriedCXXMethodType:
+  case Kind::ClangType:
+  case Kind::Type:
+  case Kind::Discard:
+    auto memberTy = getType()->getTypeOfMember(member->getModuleContext(),
+                                      member, origMemberInterfaceType)
+                             ->getCanonicalType(getGenericSignature());
+      
+    return AbstractionPattern(getGenericSignature(), memberTy);
+  }
+}

lib/SIL/SILFunction.cpp

@@ -258,7 +258,7 @@ SILType SILFunction::getLoweredLoadableType(Type t) const {
 }
 
 const TypeLowering &SILFunction::getTypeLowering(SILType type) const {
-  return getModule().Types.getTypeLowering(type, TypeExpansionContext(*this));
+  return getModule().Types.getTypeLowering(type, *this);
 }
 
 SILType SILFunction::getLoweredType(SILType t) const {