AST: Add allowInverses flag to AbstractGenericSignatureRequest

slavapestov · slavapestov · commit af50d7e6b8e8 · 2024-02-05T18:43:06.000-05:00
diff --git a/include/swift/AST/GenericSignature.h b/include/swift/AST/GenericSignature.h
@@ -572,7 +572,8 @@ GenericSignature buildGenericSignature(
     ASTContext &ctx,
     GenericSignature baseSignature,
     SmallVector<GenericTypeParamType *, 2> addedParameters,
-    SmallVector<Requirement, 2> addedRequirements);
+    SmallVector<Requirement, 2> addedRequirements,
+    bool allowInverses);
 
 /// Summary of error conditions detected by the Requirement Machine.
 enum class GenericSignatureErrorFlags {
diff --git a/include/swift/AST/TypeCheckRequests.h b/include/swift/AST/TypeCheckRequests.h
@@ -1975,7 +1975,8 @@ class AbstractGenericSignatureRequest :
     public SimpleRequest<AbstractGenericSignatureRequest,
                          GenericSignatureWithError (const GenericSignatureImpl *,
                                                     SmallVector<GenericTypeParamType *, 2>,
-                                                    SmallVector<Requirement, 2>),
+                                                    SmallVector<Requirement, 2>,
+                                                    bool),
                          RequestFlags::Cached> {
 public:
   using SimpleRequest::SimpleRequest;
@@ -1988,7 +1989,8 @@ class AbstractGenericSignatureRequest :
   evaluate(Evaluator &evaluator,
            const GenericSignatureImpl *baseSignature,
            SmallVector<GenericTypeParamType *, 2> addedParameters,
-           SmallVector<Requirement, 2> addedRequirements) const;
+           SmallVector<Requirement, 2> addedRequirements,
+           bool allowInverses) const;
 
 public:
   // Separate caching.
diff --git a/include/swift/AST/TypeCheckerTypeIDZone.def b/include/swift/AST/TypeCheckerTypeIDZone.def
@@ -18,7 +18,8 @@
 SWIFT_REQUEST(TypeChecker, AbstractGenericSignatureRequest,
               GenericSignatureWithError (const GenericSignatureImpl *,
                                          SmallVector<GenericTypeParamType *, 2>,
-                                         SmallVector<Requirement, 2>),
+                                         SmallVector<Requirement, 2>,
+                                         bool),
               Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, ApplyAccessNoteRequest,
               evaluator::SideEffect(ValueDecl *), Cached, NoLocationInfo)
@@ -196,7 +197,7 @@ SWIFT_REQUEST(TypeChecker, InferredGenericSignatureRequest,
                                          GenericParamList *,
                                          WhereClauseOwner,
                                          SmallVector<Requirement, 2>,
-                                         SmallVector<TypeLoc, 2>, bool),
+                                         SmallVector<TypeLoc, 2>, bool, bool),
               Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, DistributedModuleIsAvailableRequest,
               bool(ModuleDecl *), Cached, NoLocationInfo)
diff --git a/lib/AST/ASTContext.cpp b/lib/AST/ASTContext.cpp
@@ -5973,7 +5973,8 @@ ASTContext::getOpenedExistentialSignature(Type type, GenericSignature parentSig)
                           constraint);
   auto genericSig = buildGenericSignature(
       *this, canParentSig,
-      {genericParam}, {requirement});
+      {genericParam}, {requirement},
+      /*allowInverses=*/true);
 
   CanGenericSignature canGenericSig(genericSig);
 
@@ -6085,8 +6086,8 @@ ASTContext::getOpenedElementSignature(CanGenericSignature baseGenericSig,
   }
 
   auto elementSig = buildGenericSignature(
-      *this, GenericSignature(), genericParams, requirements)
-          .getCanonicalSignature();
+      *this, GenericSignature(), genericParams, requirements,
+      /*allowInverses=*/false).getCanonicalSignature();
   sigs[key] = elementSig;
   return elementSig;
 }
@@ -6159,7 +6160,8 @@ ASTContext::getOverrideGenericSignature(const NominalTypeDecl *baseNominal,
 
   auto genericSig = buildGenericSignature(*this, derivedNominalSig,
                                           std::move(addedGenericParams),
-                                          std::move(addedRequirements));
+                                          std::move(addedRequirements),
+                                          /*allowInverses=*/false);
   getImpl().overrideSigCache.insert(std::make_pair(key, genericSig));
   return genericSig;
 }
diff --git a/lib/AST/ASTDemangler.cpp b/lib/AST/ASTDemangler.cpp
@@ -1093,7 +1093,8 @@ CanGenericSignature ASTBuilder::demangleGenericSignature(
   decodeRequirement<BuiltType, BuiltRequirement, BuiltLayoutConstraint,
                     ASTBuilder>(node, requirements, *this);
 
-  return buildGenericSignature(Ctx, baseGenericSig, {}, std::move(requirements))
+  return buildGenericSignature(Ctx, baseGenericSig, {}, std::move(requirements),
+                               /*allowInverses=*/true)
       .getCanonicalSignature();
 }
 
diff --git a/lib/AST/AutoDiff.cpp b/lib/AST/AutoDiff.cpp
@@ -374,7 +374,8 @@ GenericSignature autodiff::getConstrainedDerivativeGenericSignature(
 
   return buildGenericSignature(ctx, derivativeGenSig,
                                /*addedGenericParams*/ {},
-                               std::move(requirements));
+                               std::move(requirements),
+                               /*allowInverses=*/true);
 }
 
 // Given the rest of a `Builtin.applyDerivative_{jvp|vjp}` or
diff --git a/lib/AST/Builtins.cpp b/lib/AST/Builtins.cpp
@@ -310,10 +310,13 @@ synthesizeGenericSignature(SynthesisContext &SC,
   CollectGenericParams collector(SC);
   list.Params.visit(collector);
 
+  // FIXME: Change allowInverses to false and add Copyable/Escapable explicitly
+  // to those builtins that need it.
   return buildGenericSignature(SC.Context,
                                GenericSignature(),
                                std::move(collector.GenericParamTypes),
-                               std::move(collector.AddedRequirements));
+                               std::move(collector.AddedRequirements),
+                               /*allowInverses=*/true);
 }
 
 /// Build a builtin function declaration.
@@ -732,10 +735,13 @@ namespace {
     }
 
     FuncDecl *build(Identifier name) {
+      // FIXME: Change allowInverses to false and add Copyable/Escapable
+      // explicitly to those builtins that need it.
       auto GenericSig = buildGenericSignature(
           Context, GenericSignature(),
           std::move(genericParamTypes),
-          std::move(addedRequirements));
+          std::move(addedRequirements),
+          /*allowInverses=*/true);
       return getBuiltinGenericFunction(name, InterfaceParams,
                                        InterfaceResult,
                                        TheGenericParamList, GenericSig,
diff --git a/lib/AST/ExistentialGeneralization.cpp b/lib/AST/ExistentialGeneralization.cpp
@@ -56,7 +56,8 @@ class Generalizer : public CanTypeVisitor<Generalizer, Type> {
     // Finish the signature.
     auto sig = buildGenericSignature(ctx, GenericSignature(),
                                      addedParameters,
-                                     addedRequirements);
+                                     addedRequirements,
+                                     /*allowInverses=*/false);
 
     // TODO: minimize the signature by removing redundant generic
     // parameters.
diff --git a/lib/AST/GenericSignature.cpp b/lib/AST/GenericSignature.cpp
@@ -547,7 +547,8 @@ GenericSignature GenericSignature::typeErased(ArrayRef<Type> typeErasedParams) c
     return buildGenericSignature(
         Ptr->getASTContext(), GenericSignature(),
         SmallVector<GenericTypeParamType *>(getGenericParams()),
-        requirementsErased);
+        requirementsErased,
+        /*allowInverses=*/false);
   }
 
   return *this;
@@ -1159,7 +1160,8 @@ void swift::validateGenericSignature(ASTContext &context,
         AbstractGenericSignatureRequest{
             nullptr,
             genericParams,
-            requirements},
+            requirements,
+            /*allowInverses=*/false},
         GenericSignatureWithError());
 
     // If there were any errors, the signature was invalid.
@@ -1195,7 +1197,8 @@ void swift::validateGenericSignature(ASTContext &context,
         AbstractGenericSignatureRequest{
           nullptr,
           genericParams,
-          newRequirements},
+          newRequirements,
+          /*allowInverses=*/false},
         GenericSignatureWithError());
 
     // If there were any errors, we formed an invalid signature, so
@@ -1252,13 +1255,15 @@ GenericSignature
 swift::buildGenericSignature(ASTContext &ctx,
                              GenericSignature baseSignature,
                              SmallVector<GenericTypeParamType *, 2> addedParameters,
-                             SmallVector<Requirement, 2> addedRequirements) {
+                             SmallVector<Requirement, 2> addedRequirements,
+                             bool allowInverses) {
   return evaluateOrDefault(
       ctx.evaluator,
       AbstractGenericSignatureRequest{
         baseSignature.getPointer(),
         addedParameters,
-        addedRequirements},
+        addedRequirements,
+        allowInverses},
       GenericSignatureWithError()).getPointer();
 }
 
diff --git a/lib/AST/RequirementEnvironment.cpp b/lib/AST/RequirementEnvironment.cpp
@@ -218,5 +218,6 @@ RequirementEnvironment::RequirementEnvironment(
 
   witnessThunkSig = buildGenericSignature(ctx, GenericSignature(),
                                           std::move(genericParamTypes),
-                                          std::move(requirements));
+                                          std::move(requirements),
+                                          /*allowInverses=*/false);
 }
diff --git a/lib/AST/RequirementMachine/RequirementMachineRequests.cpp b/lib/AST/RequirementMachine/RequirementMachineRequests.cpp
@@ -544,7 +544,8 @@ AbstractGenericSignatureRequest::evaluate(
          Evaluator &evaluator,
          const GenericSignatureImpl *baseSignatureImpl,
          SmallVector<GenericTypeParamType *, 2> addedParameters,
-         SmallVector<Requirement, 2> addedRequirements) const {
+         SmallVector<Requirement, 2> addedRequirements,
+         bool allowInverses) const {
   GenericSignature baseSignature = GenericSignature{baseSignatureImpl};
   // If nothing is added to the base signature, just return the base
   // signature.
@@ -594,7 +595,8 @@ AbstractGenericSignatureRequest::evaluate(
         ctx.evaluator,
         AbstractGenericSignatureRequest{
           canBaseSignature.getPointer(), std::move(canAddedParameters),
-          std::move(canAddedRequirements)},
+          std::move(canAddedRequirements),
+          allowInverses},
         GenericSignatureWithError());
     if (!canSignatureResult.getPointer())
       return GenericSignatureWithError();
@@ -660,8 +662,10 @@ AbstractGenericSignatureRequest::evaluate(
 
   /// Next, we need to expand default requirements and then apply inverses.
   SmallVector<Type, 2> paramsAsTypes;
-  for (auto *gtpt : addedParameters)
-    paramsAsTypes.push_back(gtpt);
+  if (allowInverses) {
+    for (auto *gtpt : addedParameters)
+      paramsAsTypes.push_back(gtpt);
+  }
 
   InverseRequirement::expandDefaults(ctx, paramsAsTypes, requirements);
   applyInverses(ctx, paramsAsTypes, inverses, requirements, errors);
diff --git a/lib/AST/Type.cpp b/lib/AST/Type.cpp
@@ -2416,7 +2416,8 @@ class IsBindableVisitor
         upperBoundGenericSig = buildGenericSignature(decl->getASTContext(),
                                                      upperBoundGenericSig,
                                                      /*genericParams=*/{ },
-                                                     std::move(addedRequirements));
+                                                     std::move(addedRequirements),
+                                                     /*allowInverses=*/false);
 
         upperBoundSubstMap = SubstitutionMap::get(upperBoundGenericSig,
           [&](SubstitutableType *t) -> Type {
diff --git a/lib/AST/TypeSubstitution.cpp b/lib/AST/TypeSubstitution.cpp
@@ -367,7 +367,8 @@ static Type substGenericFunctionType(GenericFunctionType *genericFnType,
     // signature.
     ASTContext &ctx = genericFnType->getASTContext();
     genericSig = buildGenericSignature(ctx, GenericSignature(),
-                                       genericParams, requirements);
+                                       genericParams, requirements,
+                                       /*allowInverses=*/false);
   } else {
     // Use the mapped generic signature.
     genericSig = GenericSignature::get(genericParams, requirements);
diff --git a/lib/ClangImporter/ImportDecl.cpp b/lib/ClangImporter/ImportDecl.cpp
@@ -8865,7 +8865,8 @@ GenericSignature ClangImporter::Implementation::buildGenericSignature(
   return swift::buildGenericSignature(
       SwiftContext, GenericSignature(),
       std::move(genericParamTypes),
-      std::move(requirements));
+      std::move(requirements),
+      /*allowInverses=*/true);
 }
 
 Decl *
diff --git a/lib/IRGen/GenDistributed.cpp b/lib/IRGen/GenDistributed.cpp
@@ -286,8 +286,9 @@ static CanSILFunctionType getAccessorType(IRGenModule &IGM,
     genericParams.push_back(actorTypeParam);
 
     signature = buildGenericSignature(Context, GenericSignature(),
-                          std::move(genericParams),
-                          std::move(genericRequirements));
+                                      std::move(genericParams),
+                                      std::move(genericRequirements),
+                                      /*allowInverses=*/true);
   }
 
   auto accessorTy = GenericFunctionType::get(
diff --git a/lib/SIL/IR/AbstractionPattern.cpp b/lib/SIL/IR/AbstractionPattern.cpp
@@ -2691,7 +2691,8 @@ const {
 
   auto substSig = buildGenericSignature(TC.Context, GenericSignature(),
                                         std::move(visitor.substGenericParams),
-                                        std::move(visitor.substRequirements))
+                                        std::move(visitor.substRequirements),
+                                        /*allowInverses=*/false)
     .getCanonicalSignature();
   
   auto subMap = SubstitutionMap::get(substSig,
diff --git a/lib/SIL/IR/SILFunctionType.cpp b/lib/SIL/IR/SILFunctionType.cpp
@@ -439,7 +439,8 @@ static CanGenericSignature buildDifferentiableGenericSignature(CanGenericSignatu
     });
   }
 
-  return buildGenericSignature(ctx, sig, {}, reqs).getCanonicalSignature();
+  return buildGenericSignature(ctx, sig, {}, reqs, /*allowInverses=*/false)
+      .getCanonicalSignature();
 }
 
 /// Given an original type, computes its tangent type for the purpose of
@@ -2993,7 +2994,8 @@ buildThunkSignature(SILFunction *fn,
 
   auto genericSig = buildGenericSignature(ctx, baseGenericSig,
                                           collector.Params,
-                                          collector.Requirements);
+                                          collector.Requirements,
+                                          /*allowInverses=*/false);
   genericEnv = genericSig.getGenericEnvironment();
 
   // Map the local archetypes to their new parameter types.
diff --git a/lib/SIL/Parser/ParseSIL.cpp b/lib/SIL/Parser/ParseSIL.cpp
@@ -2150,7 +2150,8 @@ static bool parseSILDifferentiabilityWitnessConfigAndFunction(
     witnessGenSig = buildGenericSignature(
         P.Context, origGenSig,
         /*addedGenericParams=*/{},
-        std::move(witnessRequirements));
+        std::move(witnessRequirements),
+        /*allowInverses=*/false);
   }
   auto origFnType = resultOrigFn->getLoweredFunctionType();
   auto *parameterIndices = IndexSubset::get(
@@ -7156,7 +7157,8 @@ bool SILParserState::parseDeclSIL(Parser &P) {
             auto genericSig = buildGenericSignature(P.Context,
                                                     fenv->getGenericSignature(),
                                                     /*addedGenericParams=*/{ },
-                                                    std::move(requirements));
+                                                    std::move(requirements),
+                                                    /*allowInverses=*/false);
             FunctionState.F->addSpecializeAttr(SILSpecializeAttr::create(
                 FunctionState.F->getModule(), genericSig, typeErasedParams, Attr.exported,
                 Attr.kind, Attr.target, Attr.spiGroupID, Attr.spiModule, Attr.availability));
diff --git a/lib/SILGen/ResultPlan.cpp b/lib/SILGen/ResultPlan.cpp
@@ -119,7 +119,8 @@ mapTypeOutOfOpenedExistentialContext(CanType t) {
   }
 
   const auto mappedSubs = SubstitutionMap::get(
-      swift::buildGenericSignature(ctx, nullptr, params, requirements),
+      swift::buildGenericSignature(ctx, nullptr, params, requirements,
+                                   /*allowInverses=*/false),
       [&](SubstitutableType *t) -> Type {
         return openedTypes[cast<GenericTypeParamType>(t)->getIndex()];
       },
diff --git a/lib/SILOptimizer/FunctionSignatureTransforms/ExistentialTransform.cpp b/lib/SILOptimizer/FunctionSignatureTransforms/ExistentialTransform.cpp
@@ -330,7 +330,8 @@ ExistentialTransform::createExistentialSpecializedFunctionType() {
   /// Compute the updated generic signature.
   NewGenericSig = buildGenericSignature(Ctx, OrigGenericSig,
                                         std::move(GenericParams),
-                                        std::move(Requirements));
+                                        std::move(Requirements),
+                                        /*allowInverses=*/true);
 
   /// Original list of parameters
   SmallVector<SILParameterInfo, 4> params;
diff --git a/lib/SILOptimizer/Utils/Generics.cpp b/lib/SILOptimizer/Utils/Generics.cpp
@@ -1101,7 +1101,8 @@ getGenericEnvironmentAndSignatureWithRequirements(
 
   auto NewGenSig = buildGenericSignature(M.getASTContext(),
                                          OrigGenSig, { },
-                                         std::move(RequirementsCopy));
+                                         std::move(RequirementsCopy),
+                                         /*allowInverses=*/false);
   auto NewGenEnv = NewGenSig.getGenericEnvironment();
   return { NewGenEnv, NewGenSig };
 }
@@ -1776,7 +1777,8 @@ FunctionSignaturePartialSpecializer::
 
   // Finalize the archetype builder.
   auto GenSig = buildGenericSignature(Ctx, GenericSignature(),
-                                      AllGenericParams, AllRequirements);
+                                      AllGenericParams, AllRequirements,
+                                      /*allowInverses=*/false);
   auto *GenEnv = GenSig.getGenericEnvironment();
   return { GenEnv, GenSig };
 }
diff --git a/lib/Sema/CodeSynthesisDistributedActor.cpp b/lib/Sema/CodeSynthesisDistributedActor.cpp
@@ -695,10 +695,7 @@ static FuncDecl *createDistributedThunkFunction(FuncDecl *func) {
     genericParamList = genericParams->clone(DC);
   }
 
-  GenericSignature baseSignature =
-      buildGenericSignature(C, func->getGenericSignature(),
-                            /*addedParameters=*/{},
-                            /*addedRequirements=*/{});
+  GenericSignature baseSignature = func->getGenericSignature();
 
   // --- Prepare parameters
   auto funcParams = func->getParameters();
diff --git a/lib/Sema/DerivedConformanceDistributedActor.cpp b/lib/Sema/DerivedConformanceDistributedActor.cpp
@@ -251,7 +251,8 @@ static FuncDecl* createLocalFunc_doInvokeOnReturn(
       buildGenericSignature(C, parentFunc->getGenericSignature(),
                             {resultGenericParamDecl->getDeclaredInterfaceType()
                                  ->castTo<GenericTypeParamType>()},
-                            std::move(requirements));
+                            std::move(requirements),
+                            /*allowInverses=*/true);
 
   FuncDecl *doInvokeOnReturnFunc = FuncDecl::createImplicit(
       C, swift::StaticSpellingKind::None,
diff --git a/lib/Sema/TypeCheckGeneric.cpp b/lib/Sema/TypeCheckGeneric.cpp
@@ -204,7 +204,8 @@ OpaqueResultTypeRequest::evaluate(Evaluator &evaluator,
 
     interfaceSignature = buildGenericSignature(ctx, outerGenericSignature,
                                                genericParamTypes,
-                                               std::move(requirements));
+                                               std::move(requirements),
+                                               /*allowInverses=*/true);
     genericParams = originatingGenericContext
         ? originatingGenericContext->getGenericParams()
         : nullptr;
diff --git a/lib/Sema/TypeCheckInvertible.cpp b/lib/Sema/TypeCheckInvertible.cpp
diff --git a/unittests/AST/ASTDumperTests.cpp b/unittests/AST/ASTDumperTests.cpp

Original file line number	Diff line number	Diff line change
`@@ -1093,7 +1093,8 @@ CanGenericSignature ASTBuilder::demangleGenericSignature(`
`1093`	`1093`	`decodeRequirement<BuiltType, BuiltRequirement, BuiltLayoutConstraint,`
`1094`	`1094`	`ASTBuilder>(node, requirements, *this);`
`1095`	`1095`
`1096`		`- return buildGenericSignature(Ctx, baseGenericSig, {}, std::move(requirements))`
	`1096`	`+ return buildGenericSignature(Ctx, baseGenericSig, {}, std::move(requirements),`
	`1097`	`+ /allowInverses=/true)`
`1097`	`1098`	`.getCanonicalSignature();`
`1098`	`1099`	`}`
`1099`	`1100`
Original file line number	Diff line number	Diff line change
`@@ -374,7 +374,8 @@ GenericSignature autodiff::getConstrainedDerivativeGenericSignature(`
`374`	`374`
`375`	`375`	`return buildGenericSignature(ctx, derivativeGenSig,`
`376`	`376`	`/addedGenericParams/ {},`
`377`		`- std::move(requirements));`
	`377`	`+ std::move(requirements),`
	`378`	`+ /allowInverses=/true);`
`378`	`379`	`}`
`379`	`380`
`380`	`381`	// Given the rest of a `Builtin.applyDerivative_{jvp\|vjp}` or
Original file line number	Diff line number	Diff line change
`@@ -218,5 +218,6 @@ RequirementEnvironment::RequirementEnvironment(`
`218`	`218`
`219`	`219`	`witnessThunkSig = buildGenericSignature(ctx, GenericSignature(),`
`220`	`220`	`std::move(genericParamTypes),`
`221`		`- std::move(requirements));`
	`221`	`+ std::move(requirements),`
	`222`	`+ /allowInverses=/false);`
`222`	`223`	`}`