SIL: Build substitution signature without expanding defaults or applying inverses

Author: slavapestov

include/swift/AST/TypeCheckRequests.h

@@ -2007,7 +2007,7 @@ class InferredGenericSignatureRequest :
                                                     WhereClauseOwner,
                                                     SmallVector<Requirement, 2>,
                                                     SmallVector<TypeLoc, 2>,
-                                                    bool),
+                                                    bool, bool),
                          RequestFlags::Cached> {
 public:
   using SimpleRequest::SimpleRequest;
@@ -2023,7 +2023,7 @@ class InferredGenericSignatureRequest :
            WhereClauseOwner whereClause,
            SmallVector<Requirement, 2> addedRequirements,
            SmallVector<TypeLoc, 2> inferenceSources,
-           bool allowConcreteGenericParams) const;
+           bool isExtension, bool allowInverses) const;
 
 public:
   // Separate caching.

include/swift/Subsystems.h

@@ -190,7 +190,8 @@ namespace swift {
 
   /// Expose TypeChecker's handling of GenericParamList to SIL parsing.
   GenericSignature handleSILGenericParams(GenericParamList *genericParams,
-                                          DeclContext *DC);
+                                          DeclContext *DC,
+                                          bool allowInverses=true);
 
   /// Turn the given module into SIL IR.
   ///

lib/AST/RequirementMachine/RequirementMachineRequests.cpp

@@ -748,13 +748,19 @@ InferredGenericSignatureRequest::evaluate(
         WhereClauseOwner whereClause,
         SmallVector<Requirement, 2> addedRequirements,
         SmallVector<TypeLoc, 2> inferenceSources,
-        bool allowConcreteGenericParams) const {
+        bool isExtension, bool allowInverses) const {
   GenericSignature parentSig(parentSigImpl);
 
   SmallVector<GenericTypeParamType *, 4> genericParams(
       parentSig.getGenericParams().begin(),
       parentSig.getGenericParams().end());
 
+  unsigned numOuterParams = genericParams.size();
+  if (isExtension) {
+    assert(allowInverses);
+    numOuterParams = 0;
+  }
+
   SmallVector<StructuralRequirement, 2> requirements;
   SmallVector<RequirementError, 2> errors;
   SmallVector<InverseRequirement, 2> inverses;
@@ -791,12 +797,9 @@ InferredGenericSignatureRequest::evaluate(
     return false;
   };
 
-  // "Local" generic parameters to which we apply default Copyable and
-  // Escapable.
-  SmallVector<Type, 4> paramTypes;
-
   if (genericParamList) {
-    // Extensions never have a parent signature.
+    // If we have multiple parameter lists, we're in SIL mode, and there's
+    // no parent signature from context.
     assert(genericParamList->getOuterParameters() == nullptr || !parentSig);
 
     // Collect all outer generic parameter lists.
@@ -811,10 +814,6 @@ InferredGenericSignatureRequest::evaluate(
     // We walk them backwards to order outer parameters before inner
     // parameters.
     for (auto *gpList : llvm::reverse(gpLists)) {
-      for (auto *gpDecl : *gpList) {
-        paramTypes.push_back(gpDecl->getDeclaredInterfaceType());
-      }
-
       assert(gpList->size() > 0 &&
              "Parsed an empty generic parameter list?");
 
@@ -872,14 +871,13 @@ InferredGenericSignatureRequest::evaluate(
 
   desugarRequirements(requirements, inverses, errors);
 
-  if (!genericParamList && allowConcreteGenericParams) {
-    for (auto paramTy : genericParams) {
-      paramTypes.push_back(paramTy);
-    }
-  }
-
   // After realizing requirements, expand default requirements only for local
   // generic parameters, as the outer parameters have already been expanded.
+  SmallVector<Type, 4> paramTypes;
+  if (allowInverses) {
+    paramTypes.append(genericParams.begin() + numOuterParams, genericParams.end());
+  }
+
   InverseRequirement::expandDefaults(ctx, paramTypes, requirements);
   applyInverses(ctx, paramTypes, inverses, requirements, errors);
 
@@ -947,7 +945,7 @@ InferredGenericSignatureRequest::evaluate(
     if (attempt == 0) {
       machine->computeRequirementDiagnostics(errors, inverses, loc);
       diagnoseRequirementErrors(ctx, errors,
-                                (allowConcreteGenericParams || !genericParamList)
+                                (isExtension || !genericParamList)
                                 ? AllowConcreteTypePolicy::All
                                 : AllowConcreteTypePolicy::AssocTypes);
     }
@@ -978,7 +976,7 @@ InferredGenericSignatureRequest::evaluate(
                                            std::move(machine));
     }
 
-    if (genericParamList && !allowConcreteGenericParams) {
+    if (genericParamList && !isExtension) {
       for (auto genericParam : result.getInnermostGenericParams()) {
         auto reduced = result.getReducedType(genericParam);
 

lib/SIL/Parser/ParseSIL.cpp

@@ -1075,7 +1075,8 @@ void SILParser::bindSILGenericParams(TypeRepr *TyR) {
         }
 
         if (auto *genericParams = fnType->getPatternGenericParams()) {
-          auto sig = handleSILGenericParams(genericParams, SF);
+          auto sig = handleSILGenericParams(genericParams, SF,
+                                            /*allowInverses=*/false);
           fnType->setPatternGenericSignature(sig);
         }
       }

lib/Sema/TypeCheckAttr.cpp

@@ -3073,7 +3073,8 @@ SerializeAttrGenericSignatureRequest::evaluate(Evaluator &evaluator,
       WhereClauseOwner(const_cast<AbstractFunctionDecl *>(FD), attr),
       /*addedRequirements=*/{},
       /*inferenceSources=*/{},
-      /*allowConcreteGenericParams=*/false};
+      /*isExtension=*/false,
+      /*allowInverses=*/true};
 
   auto specializedSig = evaluateOrDefault(Ctx.evaluator, request,
                                           GenericSignatureWithError())
@@ -5595,7 +5596,8 @@ bool resolveDifferentiableAttrDerivativeGenericSignature(
         WhereClauseOwner(original, attr),
         /*addedRequirements=*/{},
         /*inferenceSources=*/{},
-        /*allowConcreteParams=*/true};
+        /*isExtension=*/false,
+        /*allowInverses=*/true};
 
     // Compute generic signature for derivative functions.
     derivativeGenSig = evaluateOrDefault(ctx.evaluator, request,

lib/Sema/TypeCheckGeneric.cpp

@@ -118,7 +118,8 @@ OpaqueResultTypeRequest::evaluate(Evaluator &evaluator,
         WhereClauseOwner(),
         /*addedRequirements=*/{},
         /*inferenceSources=*/{},
-        /*allowConcreteGenericParams=*/false};
+        /*isExtension=*/false,
+        /*allowInverses=*/true};
 
     interfaceSignature = evaluateOrDefault(
         ctx.evaluator, request, GenericSignatureWithError())
@@ -650,7 +651,6 @@ GenericSignatureRequest::evaluate(Evaluator &evaluator,
     if (auto subscript = dyn_cast<SubscriptDecl>(accessor->getStorage()))
        return subscript->getGenericSignature();
 
-  bool allowConcreteGenericParams = false;
   auto *genericParams = GC->getGenericParams();
   const auto *where = GC->getTrailingWhereClause();
 
@@ -796,8 +796,6 @@ GenericSignatureRequest::evaluate(Evaluator &evaluator,
       return parentSig;
     }
 
-    // Extensions allow parameters to be equated with concrete types.
-    allowConcreteGenericParams = true;
   } else {
     llvm_unreachable("Unknown generic declaration kind");
   }
@@ -806,7 +804,8 @@ GenericSignatureRequest::evaluate(Evaluator &evaluator,
       parentSig.getPointer(),
       genericParams, WhereClauseOwner(GC),
       extraReqs, inferenceSources,
-      allowConcreteGenericParams};
+      /*isExtension=*/isa<ExtensionDecl>(GC),
+      /*allowInverses=*/true};
   return evaluateOrDefault(ctx.evaluator, request,
                            GenericSignatureWithError()).getPointer();
 }

lib/Sema/TypeChecker.cpp

@@ -504,7 +504,7 @@ namespace {
 /// Expose TypeChecker's handling of GenericParamList to SIL parsing.
 GenericSignature
 swift::handleSILGenericParams(GenericParamList *genericParams,
-                              DeclContext *DC) {
+                              DeclContext *DC, bool allowInverses) {
   if (genericParams == nullptr)
     return nullptr;
 
@@ -529,7 +529,9 @@ swift::handleSILGenericParams(GenericParamList *genericParams,
   auto request = InferredGenericSignatureRequest{
       /*parentSig=*/nullptr,
       nestedList.back(), WhereClauseOwner(),
-      {}, {}, /*allowConcreteGenericParams=*/true};
+      {}, {},
+      /*isExtension=*/false,
+      allowInverses};
   return evaluateOrDefault(DC->getASTContext().evaluator, request,
                            GenericSignatureWithError()).getPointer();
 }