SIL parser support for substituted function types

Author: jckarter

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);

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)) {

lib/Parse/ParseType.cpp

@@ -374,12 +374,15 @@ ParserResult<TypeRepr> Parser::parseType(Diag<> MessageID,
 
   // Parse generic parameters in SIL mode.
   GenericParamList *generics = nullptr;
+  bool isImplied = false;
   if (isInSILMode()) {
     // If this is part of a sil function decl, generic parameters are visible in
     // the function body; otherwise, they are visible when parsing the type.
     if (!IsSILFuncDecl)
       GenericsScope.emplace(this, ScopeKind::Generics);
     generics = maybeParseGenericParams().getPtrOrNull();
+    
+    isImplied = consumeIf(tok::kw_in);
   }
 
   // In SIL mode, parse box types { ... }.
@@ -477,9 +480,42 @@ ParserResult<TypeRepr> Parser::parseType(Diag<> MessageID,
                                         tyR->getSourceRange());
       }
     }
+    
+    // Parse substitutions for substituted SIL types.
+    SourceLoc SubsLAngleLoc, SubsRAngleLoc;
+    MutableArrayRef<TypeRepr *> SubsTypes;
+    if (isInSILMode() && consumeIf(tok::kw_for)) {
+      if (!Tok.isContextualPunctuator("<")) {
+        diagnose(Tok, diag::sil_function_subst_expected_l_angle);
+        return makeParserError();
+      }
+      
+      SubsLAngleLoc = consumeToken();
+
+      SmallVector<TypeRepr*, 4> SubsTypesVec;
+      for (;;) {
+        auto argTy = parseType();
+        if (!argTy.getPtrOrNull())
+          return makeParserError();
+        SubsTypesVec.push_back(argTy.get());
+        if (consumeIf(tok::comma))
+          continue;
+        break;
+      }
+      if (!Tok.isContextualPunctuator(">")) {
+        diagnose(Tok, diag::sil_function_subst_expected_r_angle);
+        return makeParserError();
+      }
+      
+      SubsRAngleLoc = consumeToken();
+
+      SubsTypes = Context.AllocateCopy(SubsTypesVec);
+    }
 
     tyR = new (Context) FunctionTypeRepr(generics, argsTyR, throwsLoc, arrowLoc,
-                                         SecondHalf.get());
+                                         SecondHalf.get(),
+                                         isImplied,
+                                         SubsTypes);
   } else if (generics) {
     // Only function types may be generic.
     auto brackets = generics->getSourceRange();

lib/Sema/TypeCheckType.cpp

@@ -2731,6 +2731,21 @@ Type TypeResolver::resolveSILFunctionType(FunctionTypeRepr *repr,
       }
     }
   } // restore generic type resolution
+  
+  // Resolve substitutions if we have them.
+  SubstitutionMap subs;
+  if (!repr->getSubstitutions().empty()) {
+    auto sig = repr->getGenericEnvironment()->getGenericSignature()
+                   ->getCanonicalSignature();
+    TypeSubstitutionMap subsMap;
+    auto params = sig->getGenericParams();
+    for (unsigned i : indices(repr->getSubstitutions())) {
+      auto resolved = resolveType(repr->getSubstitutions()[i], options);
+      subsMap.insert({params[i], resolved->getCanonicalType()});
+    }
+    subs = SubstitutionMap::get(sig, QueryTypeSubstitutionMap{subsMap},
+                                TypeChecker::LookUpConformance(DC));
+  }
 
   if (hasError) {
     return ErrorType::get(Context);
@@ -2803,7 +2818,8 @@ Type TypeResolver::resolveSILFunctionType(FunctionTypeRepr *repr,
                               callee,
                               interfaceParams, interfaceYields,
                               interfaceResults, interfaceErrorResult,
-                              SubstitutionMap(), false,
+                              subs,
+                              repr->areGenericParamsImplied(),
                               Context, witnessMethodConformance);
 }
 

test/SIL/Parser/subst_function_type.sil

@@ -0,0 +1,17 @@
+// RUN: %target-swift-emit-silgen %s | %FileCheck %s
+
+sil_stage raw
+
+import Swift
+
+// CHECK-LABEL: sil @test : $@convention(thin) (@guaranteed @callee_guaranteed <τ_0_0, τ_0_1> in (@in τ_0_0, @in τ_0_1) -> () for <Int, String>) -> ()
+sil @test : $@convention(thin) (@guaranteed @callee_guaranteed <A, B> in (@in A, @in B) -> () for <Int, String>) -> () {
+entry(%0 : $@callee_guaranteed <C, D> in (@in C, @in D) -> () for <Int, String>):
+  return undef : $()
+}
+
+// CHECK-LABEL: sil @test_generic_context : $@convention(thin) <X, Y> (@guaranteed @callee_guaranteed <τ_0_0, τ_0_1> in (@in τ_0_0, @in τ_0_1) -> () for <X, Y>) -> ()
+sil @test_generic_context : $@convention(thin) <X, Y> (@guaranteed @callee_guaranteed <A, B> in (@in A, @in B) -> () for <X, Y>) -> () {
+entry(%0 : $@callee_guaranteed <C, D> in (@in C, @in D) -> () for <X, Y>):
+  return undef : $()
+}