Merge pull request swiftlang#28671 from jckarter/subst-function-type-basics

SIL: Parsing and serialization support for subst function types

Author: jckarter

include/swift/AST/ASTMangler.h

@@ -245,6 +245,9 @@ class ASTMangler : public Mangler {
   unsigned appendBoundGenericArgs(DeclContext *dc,
                                   SubstitutionMap subs,
                                   bool &isFirstArgList);
+  
+  /// Append the bound generic arguments as a flat list, disregarding depth.
+  void appendFlatGenericArgs(SubstitutionMap subs);
 
   /// Append any retroactive conformances.
   void appendRetroactiveConformances(Type type);

include/swift/AST/DiagnosticsParse.def

@@ -803,6 +803,12 @@ ERROR(sil_box_expected_r_brace,none,
 ERROR(sil_box_expected_r_angle,none,
       "expected '>' to complete SIL box generic argument list", ())
 
+// SIL function types
+ERROR(sil_function_subst_expected_l_angle,none,
+      "expected '<' to begin SIL function type substitution list after 'for'", ())
+ERROR(sil_function_subst_expected_r_angle,none,
+      "expected '>' to begin SIL function type substitution list after 'for'", ())
+
 // Opaque types
 ERROR(opaque_mid_composition,none,
       "'some' should appear at the beginning of a composition", ())

include/swift/AST/TypeRepr.h

@@ -471,10 +471,12 @@ inline IdentTypeRepr::ComponentRange IdentTypeRepr::getComponentRange() {
 ///   (x: Foo, y: Bar) -> Baz
 /// \endcode
 class FunctionTypeRepr : public TypeRepr {
-  // These three are only used in SIL mode, which is the only time
-  // we can have polymorphic function values.
+  // These fields are only used in SIL mode, which is the only time
+  // we can have polymorphic and substituted function values.
   GenericParamList *GenericParams;
   GenericEnvironment *GenericEnv;
+  bool GenericParamsAreImplied;
+  ArrayRef<TypeRepr *> GenericSubs;
 
   TupleTypeRepr *ArgsTy;
   TypeRepr *RetTy;
@@ -483,16 +485,22 @@ class FunctionTypeRepr : public TypeRepr {
 
 public:
   FunctionTypeRepr(GenericParamList *genericParams, TupleTypeRepr *argsTy,
-                   SourceLoc throwsLoc, SourceLoc arrowLoc, TypeRepr *retTy)
+                   SourceLoc throwsLoc, SourceLoc arrowLoc, TypeRepr *retTy,
+                   bool GenericParamsAreImplied = false,
+                   ArrayRef<TypeRepr *> GenericSubs = {})
     : TypeRepr(TypeReprKind::Function),
       GenericParams(genericParams),
       GenericEnv(nullptr),
+      GenericParamsAreImplied(GenericParamsAreImplied),
+      GenericSubs(GenericSubs),
       ArgsTy(argsTy), RetTy(retTy),
       ArrowLoc(arrowLoc), ThrowsLoc(throwsLoc) {
   }
 
   GenericParamList *getGenericParams() const { return GenericParams; }
   GenericEnvironment *getGenericEnvironment() const { return GenericEnv; }
+  bool areGenericParamsImplied() const { return GenericParamsAreImplied; }
+  ArrayRef<TypeRepr*> getSubstitutions() const { return GenericSubs; }
 
   void setGenericEnvironment(GenericEnvironment *genericEnv) {
     assert(GenericEnv == nullptr);

include/swift/Demangling/DemangleNodes.def

@@ -113,6 +113,8 @@ NODE(ImplEscaping)
 NODE(ImplConvention)
 NODE(ImplFunctionAttribute)
 NODE(ImplFunctionType)
+NODE(ImplImpliedSubstitutions)
+NODE(ImplSubstitutions)
 CONTEXT_NODE(ImplicitClosure)
 NODE(ImplParameter)
 NODE(ImplResult)

include/swift/SIL/TypeLowering.h

@@ -967,23 +967,27 @@ class TypeConverter {
   enum class ABIDifference : uint8_t {
     // Types have compatible calling conventions and representations, so can
     // be trivially bitcast.
+    //
+    // Furthermore, if two function types have
+    // arguments of function type that differ only in
+    // `CompatibleRepresentation`, those outer function types are transitively
+    // `CompatibleRepresentation`. (In all other cases, the outer function types
+    // would fall into the `NeedsThunk` case, because a thunk would be needed
+    // to change the representation of the function argument.)
     CompatibleRepresentation,
 
-    // No convention differences, function can be cast via `convert_function`
-    // without a thunk.
-    //
-    // There may still be a representation difference between values of the
-    // compared function types. This means that, if two function types
-    // have a matching argument or return of function type with
-    // `SameCallingConvention`, then the outer function types may not themselves
-    // have the `SameCallingConvention` because they need a thunk to convert
-    // the inner function value representation.
+    // No convention differences, but there may still be a representation
+    // difference between values of the compared function types, such as a
+    // different ptrauth discriminator. The conversion can be performed by a
+    // `convert_function` instruction.
     CompatibleCallingConvention,
 
-    // Representation difference requires thin-to-thick conversion.
+    // Representation difference requires thin-to-thick conversion with a
+    // `thin_to_thick_function` conversion.
     CompatibleRepresentation_ThinToThick,
-    // Function types have the `SameCallingConvention` but additionally need
-    // a thin-to-thick conversion.
+    // Function types have `CompatibleCallingConvention` but additionally need
+    // a thin-to-thick conversion, so a `convert_function` followed by a
+    // `thin_to_thick_function` sequence is necessary to convert.
     CompatibleCallingConvention_ThinToThick,
 
     // Non-trivial difference requires thunk.

lib/AST/ASTMangler.cpp

@@ -1201,6 +1201,16 @@ void ASTMangler::bindGenericParameters(const DeclContext *DC) {
     bindGenericParameters(sig->getCanonicalSignature());
 }
 
+void ASTMangler::appendFlatGenericArgs(SubstitutionMap subs) {
+  appendOperator("y");
+
+  for (auto replacement : subs.getReplacementTypes()) {
+    if (replacement->hasArchetype())
+      replacement = replacement->mapTypeOutOfContext();
+    appendType(replacement);
+  }
+}
+
 unsigned ASTMangler::appendBoundGenericArgs(DeclContext *dc,
                                             SubstitutionMap subs,
                                             bool &isFirstArgList) {
@@ -1429,6 +1439,13 @@ void ASTMangler::appendImplFunctionType(SILFunctionType *fn) {
 
   llvm::SmallVector<char, 32> OpArgs;
 
+  if (fn->getSubstitutions()) {
+    OpArgs.push_back('s');
+    if (!fn->isGenericSignatureImplied()) {
+      OpArgs.push_back('i');
+    }
+  }
+  
   if (fn->isPolymorphic() && fn->isPseudogeneric())
     OpArgs.push_back('P');
 
@@ -1465,7 +1482,7 @@ void ASTMangler::appendImplFunctionType(SILFunctionType *fn) {
       OpArgs.push_back('W');
       break;
   }
-
+  
   // Mangle the parameters.
   for (auto param : fn->getParameters()) {
     OpArgs.push_back(getParamConvention(param.getConvention()));
@@ -1485,8 +1502,13 @@ void ASTMangler::appendImplFunctionType(SILFunctionType *fn) {
     OpArgs.push_back(getResultConvention(error.getConvention()));
     appendType(error.getInterfaceType());
   }
-  if (fn->isPolymorphic())
-    appendGenericSignature(fn->getSubstGenericSignature());
+  if (auto sig = fn->getSubstGenericSignature()) {
+    appendGenericSignature(sig);
+  }
+  if (auto subs = fn->getSubstitutions()) {
+    appendFlatGenericArgs(subs);
+    appendRetroactiveConformances(subs, Mod);
+  }
 
   OpArgs.push_back('_');
 

lib/AST/Type.cpp

@@ -3559,8 +3559,8 @@ static Type substType(Type derivedType,
            "should not be doing AST type-substitution on a lowered SIL type;"
            "use SILType::subst");
 
-    // Special-case handle SILBoxTypes; we want to structurally substitute the
-    // substitutions.
+    // Special-case handle SILBoxTypes and substituted SILFunctionTypes;
+    // we want to structurally substitute the substitutions.
     if (auto boxTy = dyn_cast<SILBoxType>(type)) {
       auto subMap = boxTy->getSubstitutions();
       auto newSubMap = subMap.subst(substitutions, lookupConformances);
@@ -3569,6 +3569,14 @@ static Type substType(Type derivedType,
                              boxTy->getLayout(),
                              newSubMap);
     }
+    
+    if (auto silFnTy = dyn_cast<SILFunctionType>(type)) {
+      if (auto subs = silFnTy->getSubstitutions()) {
+        auto newSubs = subs.subst(substitutions, lookupConformances);
+        return silFnTy->withSubstitutions(newSubs);
+      }
+    }
+    
 
     // Special-case TypeAliasType; we need to substitute conformances.
     if (auto aliasTy = dyn_cast<TypeAliasType>(type)) {
@@ -4835,3 +4843,14 @@ CanType swift::substOpaqueTypesWithUnderlyingTypes(CanType ty,
         SubstFlags::SubstituteOpaqueArchetypes | SubstFlags::AllowLoweredTypes;
   return ty.subst(replacer, replacer, flags)->getCanonicalType();
 }
+
+CanSILFunctionType
+SILFunctionType::withSubstitutions(SubstitutionMap subs) const {
+  return SILFunctionType::get(getSubstGenericSignature(),
+                          getExtInfo(), getCoroutineKind(),
+                          getCalleeConvention(),
+                          getParameters(), getYields(), getResults(),
+                          getOptionalErrorResult(),
+                          subs, isGenericSignatureImplied(),
+                          const_cast<SILFunctionType*>(this)->getASTContext());
+}

lib/Demangling/Demangler.cpp

@@ -1733,6 +1733,24 @@ NodePointer Demangler::demangleImplResultConvention(Node::Kind ConvKind) {
 NodePointer Demangler::demangleImplFunctionType() {
   NodePointer type = createNode(Node::Kind::ImplFunctionType);
 
+  if (nextIf('s')) {
+    Vector<NodePointer> Substitutions;
+    NodePointer SubstitutionRetroConformances;
+    if (!demangleBoundGenerics(Substitutions, SubstitutionRetroConformances))
+      return nullptr;
+    
+    bool isImplied = !nextIf('i');
+    
+    auto subsNode = createNode(isImplied
+                               ? Node::Kind::ImplImpliedSubstitutions
+                               : Node::Kind::ImplSubstitutions);
+    assert(Substitutions.size() == 1);
+    subsNode->addChild(Substitutions[0], *this);
+    if (SubstitutionRetroConformances)
+      subsNode->addChild(SubstitutionRetroConformances, *this);
+    type->addChild(subsNode, *this);
+  }
+  
   NodePointer GenSig = popNode(Node::Kind::DependentGenericSignature);
   if (GenSig && nextIf('P'))
     GenSig = changeKind(GenSig, Node::Kind::DependentPseudogenericSignature);
@@ -1794,6 +1812,7 @@ NodePointer Demangler::demangleImplFunctionType() {
       return nullptr;
     type->getChild(type->getNumChildren() - Idx - 1)->addChild(ConvTy, *this);
   }
+  
   return createType(type);
 }
 

lib/Demangling/NodePrinter.cpp

@@ -390,6 +390,8 @@ class NodePrinter {
     case Node::Kind::ImplConvention:
     case Node::Kind::ImplFunctionAttribute:
     case Node::Kind::ImplFunctionType:
+    case Node::Kind::ImplImpliedSubstitutions:
+    case Node::Kind::ImplSubstitutions:
     case Node::Kind::ImplicitClosure:
     case Node::Kind::ImplParameter:
     case Node::Kind::ImplResult:
@@ -979,7 +981,7 @@ static bool needSpaceBeforeType(NodePointer Type) {
 }
 
 NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
-  switch (Node->getKind()) {
+  switch (auto kind = Node->getKind()) {
   case Node::Kind::Static:
     Printer << "static ";
     print(Node->getChild(0));
@@ -2016,6 +2018,14 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
   case Node::Kind::ImplFunctionType:
     printImplFunctionType(Node);
     return nullptr;
+  case Node::Kind::ImplSubstitutions:
+  case Node::Kind::ImplImpliedSubstitutions:
+    Printer << "for <";
+    printChildren(Node->getChild(0), ", ");
+    Printer << '>';
+    if (kind == Node::Kind::ImplImpliedSubstitutions)
+      Printer << " in";
+    return nullptr;
   case Node::Kind::ErrorType:
     Printer << "<ERROR TYPE>";
     return nullptr;

lib/Demangling/OldRemangler.cpp

@@ -1252,6 +1252,14 @@ void Remangler::mangleImplEscaping(Node *node) {
   // The old mangler does not encode escaping.
 }
 
+void Remangler::mangleImplSubstitutions(Node *node) {
+  // The old mangler does not encode substituted function types.
+}
+
+void Remangler::mangleImplImpliedSubstitutions(Node *node) {
+  // The old mangler does not encode substituted function types.
+}
+
 void Remangler::mangleImplConvention(Node *node) {
   assert(node->getKind() == Node::Kind::ImplConvention);
   StringRef text = node->getText();