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

jckarter · jckarter · commit 1a9ebbd4e91f · 2019-11-04T14:45:31.000-08:00
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&lt;T&gt;(x: (T, T) -&gt; ())` calls
`bar&lt;T, U&gt;(x: (T, U) -&gt; ())` 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 `&lt;A, B&gt; (A, B) -&gt; ()` with different substitutions.
diff --git a/lib/SIL/SILFunctionType.cpp b/lib/SIL/SILFunctionType.cpp
@@ -1059,11 +1059,122 @@ 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);
+        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 AnyObject constraint, if any, on the archetype in the
+        // generic signature.
+        if (archetype->requiresClass()) {
+          substRequirements.push_back(Requirement(RequirementKind::Layout,param,
+           LayoutConstraint::getLayoutConstraint(LayoutConstraintKind::Class)));
+        }
+        
+        return param;
+      }
+      
+      // LookupConformanceFn
+      Optional<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);
 }
 
@@ -3056,7 +3167,7 @@ SILFunctionType::withSubstitutions(SubstitutionMap subs) const {
                           getExtInfo(), getCoroutineKind(),
                           getCalleeConvention(),
                           getParameters(), getYields(), getResults(),
-                          getErrorResult(),
+                          getOptionalErrorResult(),
                           subs, isGenericSignatureImplied(),
                           const_cast<SILFunctionType*>(this)->getASTContext());
 }
diff --git a/lib/SIL/TypeLowering.cpp b/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.
diff --git a/test/SILGen/function_type_lowering.swift b/test/SILGen/function_type_lowering.swift
@@ -0,0 +1,118 @@
+// RUN: %target-swift-emit-silgen -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 : AnyObject> 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 : AnyObject> 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 : AnyObject, τ_0_1 : AnyObject> 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 : AnyObject, τ_0_1 : AnyObject> 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 : AnyObject> 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 : AnyObject> 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 : AnyObject, τ_0_1 : AnyObject> 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 : AnyObject, τ_0_1 : AnyObject> 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 : AnyObject> in (@guaranteed τ_0_0) -> @out τ_0_1 for <T, T.A>) -> ()
+func n<T: P & PC>(_ x: (T) -> T.A) {}
+
+
+// Superclass constraints
+
+class Base {}
+
+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 : AnyObject> 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 : AnyObject> 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 : AnyObject, τ_0_1 : AnyObject> 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 : AnyObject, τ_0_3 : AnyObject> 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 : AnyObject, τ_0_3 : AnyObject> 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 : AnyObject> in (@guaranteed τ_0_0) -> () for <V>) -> ()
+func x<T, U, V: C<T, U>>(_: (V) -> Void) {}
