SIL: Type lowering for function values with substituted SIL function types.

After converting a function type to its corresponding SIL type by our usual rules, extract
the substituted generic signature and common interface type for all concrete function types
that the function could be called as. We don't currently have any use cases for distinguishing
types at finer granularity than generic class-constrained/generic unconstrained/not-generic, so
to reduce the amount of conversion noise in SIL, generate the most general generic signature
possible, by extracting every position with a dependent generic parameter or associated type thereof
into a separate generic parameter in the substituted signature, discarding all constraints except
for `AnyObject` layout constraints. This way, if `foo<T>(x: (T, T) -> ())` calls
`bar<T, U>(x: (T, U) -> ())` and forwards `x` along, the two closures that only vary in genericity
don't need a conversion even with substituted function types, because they'll both have the same
abstract lowering `<A, B> (A, B) -> ()` with different substitutions.

Author: jckarter

include/swift/AST/LayoutConstraint.h

@@ -36,9 +36,10 @@ class ASTPrinter;
 enum class LayoutConstraintKind : uint8_t {
   // It is not a known layout constraint.
   UnknownLayout,
-  // It is a layout constraint representing a trivial type of an unknown size.
+  // It is a layout constraint representing a trivial type of a known size.
   TrivialOfExactSize,
-  // It is a layout constraint representing a trivial type of an unknown size.
+  // It is a layout constraint representing a trivial type of a size known to
+  // be no larger than a given size.
   TrivialOfAtMostSize,
   // It is a layout constraint representing a trivial type of an unknown size.
   Trivial,

lib/SIL/SILFunctionType.cpp

@@ -1059,11 +1059,163 @@ static CanSILFunctionType getSILFunctionType(
     .withIsPseudogeneric(pseudogeneric)
     .withNoEscape(extInfo.isNoEscape());
 
+  // Extract the abstract generic calling convention of the function into a
+  // substituted generic signature for the function type.
+  //
+  // This signature only needs to consider the general calling convention,
+  // so it can reduce away protocol and base class constraints aside from
+  // `AnyObject`. We wanto similar-shaped generic function types to remain
+  // canonically equivalent, like `(T, U) -> ()`, `(T, T) -> ()`,
+  // `(U, T) -> ()` or `(T, T.A) -> ()` when given substitutions that produce
+  // the same function types, so we also introduce a new generic argument for
+  // each position where we see a dependent type, and canonicalize the order in
+  // which we see independent generic arguments.
+  //
+  bool impliedSignature = false;
+  SubstitutionMap substitutions;
+  if (TC.Context.LangOpts.EnableSubstSILFunctionTypesForFunctionValues
+      // We don't currently use substituted function types for generic function
+      // type lowering, though we should for generic methods on classes and
+      // protocols.
+      && !genericSig) {
+    class SubstFunctionTypeCollector {
+    public:
+      TypeConverter &TC;
+      const bool mapReplacementsOutOfContext;
+      
+      SmallVector<GenericTypeParamType *, 4> substGenericParams;
+      SmallVector<Requirement, 4> substRequirements;
+      SmallVector<Type, 4> substReplacements;
+      
+      SubstFunctionTypeCollector(TypeConverter &TC,
+                                 bool mapReplacementsOutOfContext)
+        : TC(TC), mapReplacementsOutOfContext(mapReplacementsOutOfContext) {}
+      SubstFunctionTypeCollector(const SubstFunctionTypeCollector &) = delete;
+
+      // TypeSubstitutionFn
+      Type operator()(SubstitutableType *t) {
+        ArchetypeType *archetype = dyn_cast<ArchetypeType>(t);
+        
+        // We should only substitute contextual archetypes here.
+        // Opened existential or opaque archetypes are not freely substitutable
+        // so ought to be left as is.
+        assert(isa<PrimaryArchetypeType>(archetype->getRoot()));
+        
+        if (!archetype)
+          archetype = TC.getCurGenericContext()->getGenericEnvironment()
+                                   ->mapTypeIntoContext(t)
+                                   ->castTo<ArchetypeType>();
+        
+        // Replace every dependent type we see with a fresh type variable in
+        // the substituted signature.
+        auto paramIndex = substGenericParams.size();
+        auto param = CanGenericTypeParamType::get(0, paramIndex, TC.Context);
+
+        substGenericParams.push_back(param);
+        Type replacementTy = t;
+        if (mapReplacementsOutOfContext) {
+          replacementTy = t->mapTypeOutOfContext();
+        }
+        substReplacements.push_back(replacementTy);
+        
+        // Preserve the layout constraint, if any, on the archetype in the
+        // generic signature, generalizing away some constraints that
+        // shouldn't affect ABI substitutability.
+        if (auto layout = archetype->getLayoutConstraint()) {
+          switch (layout->getKind()) {
+          // Keep these layout constraints as is.
+          case LayoutConstraintKind::RefCountedObject:
+          case LayoutConstraintKind::TrivialOfAtMostSize:
+            break;
+          
+          case LayoutConstraintKind::UnknownLayout:
+          case LayoutConstraintKind::Trivial:
+            // These constraints don't really constrain the ABI, so we can
+            // eliminate them.
+            layout = LayoutConstraint();
+            break;
+        
+          // Replace these specific constraints with one of the more general
+          // constraints above.
+          case LayoutConstraintKind::NativeClass:
+          case LayoutConstraintKind::Class:
+          case LayoutConstraintKind::NativeRefCountedObject:
+            // These can all be generalized to RefCountedObject.
+            layout = LayoutConstraint::getLayoutConstraint(
+                                       LayoutConstraintKind::RefCountedObject);
+            break;
+              
+          case LayoutConstraintKind::TrivialOfExactSize:
+            // Generalize to TrivialOfAtMostSize.
+            layout = LayoutConstraint::getLayoutConstraint(
+               LayoutConstraintKind::TrivialOfAtMostSize,
+               layout->getTrivialSizeInBits(),
+               layout->getAlignmentInBits(),
+               TC.Context);
+            break;
+          }
+          
+          if (layout)
+            substRequirements.push_back(
+                          Requirement(RequirementKind::Layout, param, layout));
+        }
+        
+        return param;
+      }
+      
+      // LookupConformanceFn
+      ProtocolConformanceRef operator()(CanType dependentType,
+                                        Type conformingReplacementType,
+                                        ProtocolDecl *conformedProtocol) {
+        // We should only substitute with other dependent types, so that an
+        // abstract conformance ref is sufficient.
+        assert(conformingReplacementType->isTypeParameter());
+        return ProtocolConformanceRef(conformedProtocol);
+      }
+    };
+    
+    SubstFunctionTypeCollector collector(TC,
+                                     substFnInterfaceType->hasTypeParameter());
+    auto contextSig = TC.getCurGenericContext();
+    
+    auto collectSubstitutions = [&](CanType t) -> CanType {
+      if (t->hasTypeParameter()) {
+        t = contextSig->getGenericEnvironment()
+                      ->mapTypeIntoContext(t)
+                      ->getCanonicalType(contextSig);
+      }
+      
+      return CanType(t.subst(collector, collector));
+    };
+    
+    for (auto &input : inputs) {
+      input = input.getWithInterfaceType(
+                               collectSubstitutions(input.getInterfaceType()));
+    }
+    for (auto &yield : yields) {
+      yield = yield.getWithInterfaceType(
+                               collectSubstitutions(yield.getInterfaceType()));
+    }
+    for (auto &result : results) {
+      result = result.getWithInterfaceType(
+                               collectSubstitutions(result.getInterfaceType()));
+    }
+    
+    if (!collector.substGenericParams.empty()) {
+      genericSig = GenericSignature::get(collector.substGenericParams,
+                                         collector.substRequirements)
+        ->getCanonicalSignature();
+      substitutions = SubstitutionMap::get(genericSig,
+                                           collector.substReplacements,
+                                           ArrayRef<ProtocolConformanceRef>());
+      impliedSignature = true;
+    }
+  }
 
   return SILFunctionType::get(genericSig, silExtInfo, coroutineKind,
                               calleeConvention, inputs, yields,
                               results, errorResult,
-                              SubstitutionMap(), false,
+                              substitutions, impliedSignature,
                               TC.Context, witnessMethodConformance);
 }
 
@@ -3049,7 +3201,7 @@ SILFunctionType::withSubstitutions(SubstitutionMap subs) const {
                           getExtInfo(), getCoroutineKind(),
                           getCalleeConvention(),
                           getParameters(), getYields(), getResults(),
-                          getErrorResult(),
+                          getOptionalErrorResult(),
                           subs, isGenericSignatureImplied(),
                           const_cast<SILFunctionType*>(this)->getASTContext());
 }

lib/SIL/TypeLowering.cpp

@@ -1547,6 +1547,8 @@ CanType TypeConverter::computeLoweredRValueType(AbstractionPattern origType,
   //   - types are turned into their unbridged equivalents, depending
   //     on the abstract CC
   //   - ownership conventions are deduced
+  //   - a minimal substituted generic signature is extracted to represent
+  //     possible ABI-compatible substitutions
   if (auto substFnType = dyn_cast<AnyFunctionType>(substType)) {
     // If the formal type uses a C convention, it is not formally
     // abstractable, and it may be subject to implicit bridging.

test/SILGen/function_type_lowering.swift

@@ -0,0 +1,129 @@
+// RUN: %target-swift-frontend -emit-silgen -disable-availability-checking -module-name main -enable-subst-sil-function-types-for-function-values %s | %FileCheck %s
+
+
+// Similarly-abstract generic signatures should share an unsubstituted type
+// even in different generic contexts
+
+// CHECK-LABEL: sil {{.*}}1a{{.*}} : $@convention(thin) <T, U> (@noescape @callee_guaranteed <τ_0_0, τ_0_1> in (@in_guaranteed τ_0_0) -> @out τ_0_1 for <T, U>) -> ()
+func a<T, U>(_ x: (T) -> U) {}
+
+// CHECK-LABEL: sil {{.*}}1b{{.*}} : $@convention(thin) <T, U> (@noescape @callee_guaranteed <τ_0_0, τ_0_1> in (@in_guaranteed τ_0_0) -> @out τ_0_1 for <U, T>) -> ()
+func b<T, U>(_ x: (U) -> T) {}
+
+// CHECK-LABEL: sil {{.*}}1c{{.*}} : $@convention(thin) <T, U, V> (@noescape @callee_guaranteed <τ_0_0, τ_0_1> in (@in_guaranteed τ_0_0) -> @out τ_0_1 for <V, T>, @in_guaranteed U) -> ()
+func c<T, U, V>(_ x: (V) -> T, _: U) {}
+
+// CHECK-LABEL: sil {{.*}}003Hca{{.*}} : $@convention(thin) <T> (@noescape @callee_guaranteed <τ_0_0, τ_0_1> in (@in_guaranteed τ_0_0) -> @out τ_0_1 for <T, T>) -> ()
+func ç<T>(_ x: (T) -> T) {}
+
+
+// ...including unconstrained associated types
+
+protocol P {
+  associatedtype A
+}
+
+// CHECK-LABEL: sil {{.*}}1d{{.*}} : $@convention(thin) <T where T : P> (@noescape @callee_guaranteed <τ_0_0, τ_0_1> in (@in_guaranteed τ_0_0) -> @out τ_0_1 for <T, T.A>) -> ()
+func d<T: P>(_ x: (T) -> T.A) {}
+
+// CHECK-LABEL: sil {{.*}}1e{{.*}} : $@convention(thin) <T where T : P> (@noescape @callee_guaranteed <τ_0_0, τ_0_1> in (@in_guaranteed τ_0_0) -> @out τ_0_1 for <T.A, T>) -> ()
+func e<T: P>(_ x: (T.A) -> T) {}
+
+
+// Preserve class constraints, because they're less abstract for layout and
+// calling convention purposes than unconstrained types
+
+// CHECK-LABEL: sil {{.*}}1f{{.*}} : $@convention(thin) <T, U where T : AnyObject> (@noescape @callee_guaranteed <τ_0_0, τ_0_1 where τ_0_0 : _RefCountedObject> in (@guaranteed τ_0_0) -> @out τ_0_1 for <T, U>) -> ()
+func f<T: AnyObject, U>(_ x: (T) -> U) {}
+
+// CHECK-LABEL: sil {{.*}}1g{{.*}} : $@convention(thin) <T, U where T : AnyObject> (@noescape @callee_guaranteed <τ_0_0, τ_0_1 where τ_0_1 : _RefCountedObject> in (@in_guaranteed τ_0_0) -> @owned τ_0_1 for <U, T>) -> ()
+func g<T: AnyObject, U>(_ x: (U) -> T) {}
+
+// CHECK-LABEL: sil {{.*}}1h{{.*}} : $@convention(thin) <T, U where T : AnyObject, U : AnyObject> (@noescape @callee_guaranteed <τ_0_0, τ_0_1 where τ_0_0 : _RefCountedObject, τ_0_1 : _RefCountedObject> in (@guaranteed τ_0_0) -> @owned τ_0_1 for <T, U>) -> ()
+func h<T: AnyObject, U: AnyObject>(_ x: (T) -> U) {}
+
+// CHECK-LABEL: sil {{.*}}1i{{.*}} : $@convention(thin) <T, U where T : AnyObject, U : AnyObject> (@noescape @callee_guaranteed <τ_0_0, τ_0_1 where τ_0_0 : _RefCountedObject, τ_0_1 : _RefCountedObject> in (@guaranteed τ_0_0) -> @owned τ_0_1 for <U, T>) -> ()
+func i<T: AnyObject, U: AnyObject>(_ x: (U) -> T) {}
+
+
+// Indirect class constraints
+
+protocol PC: AnyObject { }
+
+// CHECK-LABEL: sil {{.*}}1j{{.*}} : $@convention(thin) <T, U where T : PC> (@noescape @callee_guaranteed <τ_0_0, τ_0_1 where τ_0_0 : _RefCountedObject> in (@guaranteed τ_0_0) -> @out τ_0_1 for <T, U>) -> ()
+func j<T: PC, U>(_ x: (T) -> U) {}
+
+// CHECK-LABEL: sil {{.*}}1k{{.*}} : $@convention(thin) <T, U where T : PC> (@noescape @callee_guaranteed <τ_0_0, τ_0_1 where τ_0_1 : _RefCountedObject> in (@in_guaranteed τ_0_0) -> @owned τ_0_1 for <U, T>) -> ()
+func k<T: PC, U>(_ x: (U) -> T) {}
+
+// CHECK-LABEL: sil {{.*}}1l{{.*}} : $@convention(thin) <T, U where T : PC, U : PC> (@noescape @callee_guaranteed <τ_0_0, τ_0_1 where τ_0_0 : _RefCountedObject, τ_0_1 : _RefCountedObject> in (@guaranteed τ_0_0) -> @owned τ_0_1 for <T, U>) -> ()
+func l<T: PC, U: PC>(_ x: (T) -> U) {}
+
+// CHECK-LABEL: sil {{.*}}1m{{.*}} : $@convention(thin) <T, U where T : PC, U : PC> (@noescape @callee_guaranteed <τ_0_0, τ_0_1 where τ_0_0 : _RefCountedObject, τ_0_1 : _RefCountedObject> in (@guaranteed τ_0_0) -> @owned τ_0_1 for <U, T>) -> ()
+func m<T: PC, U: PC>(_ x: (U) -> T) {}
+
+// CHECK-LABEL: sil {{.*}}1n{{.*}} : $@convention(thin) <T where T : P, T : PC> (@noescape @callee_guaranteed <τ_0_0, τ_0_1 where τ_0_0 : _RefCountedObject> in (@guaranteed τ_0_0) -> @out τ_0_1 for <T, T.A>) -> ()
+func n<T: P & PC>(_ x: (T) -> T.A) {}
+
+
+// Superclass constraints
+
+class Base {}
+
+// CHECK-LABEL: sil {{.*}}1o{{.*}} : $@convention(thin) <T, U where T : Base> (@noescape @callee_guaranteed <τ_0_0, τ_0_1 where τ_0_0 : _RefCountedObject> in (@guaranteed τ_0_0) -> @out τ_0_1 for <T, U>) -> ()
+func o<T: Base, U> (_ x: (T) -> U) {}
+
+
+// Indirect constraints by associated type or protocol
+
+protocol PCAO: AnyObject {
+  associatedtype A
+}
+
+protocol POAC {
+  associatedtype A: AnyObject
+}
+
+protocol PCAC: AnyObject {
+  associatedtype A: AnyObject
+}
+
+// CHECK-LABEL: sil {{.*}}1p{{.*}} : $@convention(thin) <T where T : PCAO> (@noescape @callee_guaranteed <τ_0_0, τ_0_1 where τ_0_0 : _RefCountedObject> in (@guaranteed τ_0_0) -> @out τ_0_1 for <T, T.A>) -> ()
+func p<T: PCAO> (_ x: (T) -> T.A) {}
+// CHECK-LABEL: sil {{.*}}1q{{.*}} : $@convention(thin) <T where T : POAC> (@noescape @callee_guaranteed <τ_0_0, τ_0_1 where τ_0_1 : _RefCountedObject> in (@in_guaranteed τ_0_0) -> @owned τ_0_1 for <T, T.A>) -> ()
+func q<T: POAC> (_ x: (T) -> T.A) {}
+// CHECK-LABEL: sil {{.*}}1r{{.*}} : $@convention(thin) <T where T : PCAC> (@noescape @callee_guaranteed <τ_0_0, τ_0_1 where τ_0_0 : _RefCountedObject, τ_0_1 : _RefCountedObject> in (@guaranteed τ_0_0) -> @owned τ_0_1 for <T, T.A>) -> ()
+func r<T: PCAC> (_ x: (T) -> T.A) {}
+
+
+// Structural positions
+
+struct S<T, U> {}
+
+// CHECK-LABEL: sil {{.*}}1t{{.*}} : $@convention(thin) <T, U where U : AnyObject> (@noescape @callee_guaranteed <τ_0_0, τ_0_1, τ_0_2, τ_0_3 where τ_0_1 : _RefCountedObject, τ_0_3 : _RefCountedObject> in (S<τ_0_0, τ_0_1>) -> (@out τ_0_2, @owned τ_0_3) for <T, U, T, U>) -> ()
+func t<T, U: AnyObject>(_: (S<T, U>) -> (T, U)) {}
+
+// CHECK-LABEL: sil {{.*}}1u{{.*}} : $@convention(thin) <T> (@noescape @callee_guaranteed <τ_0_0, τ_0_1, τ_0_2> in (S<τ_0_0, τ_0_1>) -> @out τ_0_2 for <T, T, T>) -> ()
+func u<T>(_: (S<T, T>) -> T) {}
+
+
+class C<T, U> {}
+
+// CHECK-LABEL: sil {{.*}}1v{{.*}} : $@convention(thin) <T, U where U : AnyObject> (@noescape @callee_guaranteed <τ_0_0, τ_0_1, τ_0_2, τ_0_3 where τ_0_1 : _RefCountedObject, τ_0_3 : _RefCountedObject> in (@guaranteed C<τ_0_0, τ_0_1>) -> (@out τ_0_2, @owned τ_0_3) for <T, U, T, U>) -> ()
+func v<T, U: AnyObject>(_: (C<T, U>) -> (T, U)) {}
+
+// CHECK-LABEL: sil {{.*}}1w{{.*}} : $@convention(thin) <T> (@noescape @callee_guaranteed <τ_0_0, τ_0_1, τ_0_2> in (@guaranteed C<τ_0_0, τ_0_1>) -> @out τ_0_2 for <T, T, T>) -> ()
+func w<T>(_: (C<T, T>) -> T) {}
+
+// CHECK-LABEL: sil {{.*}}1x{{.*}} : $@convention(thin) <T, U, V where V : C<T, U>> (@noescape @callee_guaranteed <τ_0_0 where τ_0_0 : _RefCountedObject> in (@guaranteed τ_0_0) -> () for <V>) -> ()
+func x<T, U, V: C<T, U>>(_: (V) -> Void) {}
+
+
+// Opaque types should not be extracted as substituted arguments because they
+// aren't freely substitutable.
+
+dynamic func opaqueAny() -> some Any { return C<Int, String>() }
+dynamic func opaqueObject() -> some AnyObject { return C<Int, String>() }
+
+// CHECK-LABEL: sil {{.*}}1y{{.*}} : $@convention(thin) (@noescape @callee_guaranteed (@in_guaranteed @_opaqueReturnTypeOf("$s4main9opaqueAnyQryF", 0) {{.*}}) -> @owned @_opaqueReturnTypeOf("$s4main12opaqueObjectQryF", 0) {{.*}}) -> ()
+func y(_: (@_opaqueReturnTypeOf("$s4main9opaqueAnyQryF", 0) X) -> (@_opaqueReturnTypeOf("$s4main12opaqueObjectQryF", 0) X)) {}