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

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,

include/swift/Basic/LangOptions.h

@@ -211,6 +211,9 @@ namespace swift {
     /// Enable experimental operator designated types feature.
     bool EnableOperatorDesignatedTypes = false;
 
+    /// Enable SIL type lowering
+    bool EnableSubstSILFunctionTypesForFunctionValues = false;
+
     /// Enable constraint solver support for experimental
     ///        operator protocol designator feature.
     bool SolverEnableOperatorDesignatedTypes = false;

include/swift/Option/FrontendOptions.td

@@ -344,6 +344,10 @@ def enable_experimental_static_assert :
   Flag<["-"], "enable-experimental-static-assert">,
   HelpText<"Enable experimental #assert">;
 
+def enable_subst_sil_function_types_for_function_values :
+  Flag<["-"], "enable-subst-sil-function-types-for-function-values">,
+  HelpText<"Use substituted function types for SIL type lowering of function values">;
+
 def enable_deserialization_recovery :
   Flag<["-"], "enable-deserialization-recovery">,
   HelpText<"Attempt to recover from missing xrefs (etc) in swiftmodules">;

lib/AST/ASTPrinter.cpp

@@ -4006,54 +4006,79 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
     printFunctionExtInfo(T->getExtInfo(),
                          T->getWitnessMethodConformanceOrInvalid());
     printCalleeConvention(T->getCalleeConvention());
-    if (auto sig = T->getSubstGenericSignature()) {
-      printGenericSignature(sig,
-                            PrintAST::PrintParams |
-                            PrintAST::PrintRequirements);
-      Printer << " ";
-      if (T->isGenericSignatureImplied()) {
-        Printer << "in ";
-      }
+
+    // If this is a substituted function type, then its generic signature is
+    // independent of the enclosing context, and defines the parameters active
+    // in the interface params and results. Unsubstituted types use the existing
+    // environment, which may be a sil decl's generic environment.
+    //
+    // Yeah, this is fiddly. In the end, we probably want all decls to have
+    // substituted types in terms of a generic signature declared on the decl,
+    // which would make this logic more uniform.
+    TypePrinter *sub = this;
+    Optional<TypePrinter> subBuffer;
+    PrintOptions subOptions = Options;
+    if (T->getSubstitutions()) {
+      subOptions.GenericEnv = nullptr;
+      subBuffer.emplace(Printer, subOptions);
+      sub = &*subBuffer;
     }
+
+    // Capture list used here to ensure we don't print anything using `this`
+    // printer, but only the sub-Printer.
+    [T, sub, &subOptions]{
+      if (auto sig = T->getSubstGenericSignature()) {
+        sub->printGenericSignature(sig,
+                              PrintAST::PrintParams |
+                              PrintAST::PrintRequirements);
+        sub->Printer << " ";
+        if (T->isGenericSignatureImplied()) {
+          sub->Printer << "in ";
+        }
+      }
 
-    Printer << "(";
-    bool first = true;
-    for (auto param : T->getParameters()) {
-      Printer.printSeparator(first, ", ");
-      param.print(Printer, Options);
-    }
-    Printer << ") -> ";
+      sub->Printer << "(";
+      bool first = true;
+      for (auto param : T->getParameters()) {
+        sub->Printer.printSeparator(first, ", ");
+        param.print(sub->Printer, subOptions);
+      }
+      sub->Printer << ") -> ";
 
-    unsigned totalResults =
-      T->getNumYields() + T->getNumResults() + unsigned(T->hasErrorResult());
+      unsigned totalResults =
+        T->getNumYields() + T->getNumResults() + unsigned(T->hasErrorResult());
 
-    if (totalResults != 1) Printer << "(";
+      if (totalResults != 1)
+        sub->Printer << "(";
 
-    first = true;
+      first = true;
 
-    for (auto yield : T->getYields()) {
-      Printer.printSeparator(first, ", ");
-      Printer << "@yields ";
-      yield.print(Printer, Options);
-    }
+      for (auto yield : T->getYields()) {
+        sub->Printer.printSeparator(first, ", ");
+        sub->Printer << "@yields ";
+        yield.print(sub->Printer, subOptions);
+      }
 
-    for (auto result : T->getResults()) {
-      Printer.printSeparator(first, ", ");
-      result.print(Printer, Options);
-    }
+      for (auto result : T->getResults()) {
+        sub->Printer.printSeparator(first, ", ");
+        result.print(sub->Printer, subOptions);
+      }
 
-    if (T->hasErrorResult()) {
-      // The error result is implicitly @owned; don't print that.
-      assert(T->getErrorResult().getConvention() == ResultConvention::Owned);
-      Printer.printSeparator(first, ", ");
-      Printer << "@error ";
-      T->getErrorResult().getInterfaceType().print(Printer, Options);
-    }
+      if (T->hasErrorResult()) {
+        // The error result is implicitly @owned; don't print that.
+        assert(T->getErrorResult().getConvention() == ResultConvention::Owned);
+        sub->Printer.printSeparator(first, ", ");
+        sub->Printer << "@error ";
+        T->getErrorResult().getInterfaceType().print(sub->Printer, subOptions);
+      }
 
-    if (totalResults != 1) Printer << ")";
+      if (totalResults != 1)
+        sub->Printer << ")";
+    }();
 
+    // The substitution types are always in terms of the outer environment.
     if (auto substitutions = T->getSubstitutions()) {
-      Printer << " for ";
+      Printer << " for";
       printSubstitutions(substitutions);
     }
   }
@@ -4076,7 +4101,7 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
       [&sub, T]{
         if (auto sig = T->getLayout()->getGenericSignature()) {
           sub.printGenericSignature(sig,
-                            PrintAST::PrintParams | PrintAST::PrintRequirements);
+                          PrintAST::PrintParams | PrintAST::PrintRequirements);
           sub.Printer << " ";
         }
         sub.Printer << "{";

lib/Frontend/CompilerInvocation.cpp

@@ -274,6 +274,9 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
   Opts.EnableExperimentalStaticAssert |=
     Args.hasArg(OPT_enable_experimental_static_assert);
 
+  Opts.EnableSubstSILFunctionTypesForFunctionValues |=
+    Args.hasArg(OPT_enable_subst_sil_function_types_for_function_values);
+
   Opts.EnableOperatorDesignatedTypes |=
       Args.hasArg(OPT_enable_operator_designated_types);
 

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.