RequirementMachine: Plumb through the ModuleDecl used for requirement inference

Author: slavapestov

lib/AST/RequirementMachine/RequirementLowering.cpp

@@ -186,7 +186,7 @@ swift::rewriting::desugarRequirement(Requirement req,
 //
 
 static void realizeTypeRequirement(Type subjectType, Type constraintType,
-                                   SourceLoc loc, bool wasInferred,
+                                   SourceLoc loc,
                                    SmallVectorImpl<StructuralRequirement> &result) {
   // Check whether we have a reasonable constraint type at all.
   if (!constraintType->isExistentialType() &&
@@ -207,7 +207,7 @@ static void realizeTypeRequirement(Type subjectType, Type constraintType,
 
   // Add source location information.
   for (auto req : reqs)
-    result.push_back({req, loc, wasInferred});
+    result.push_back({req, loc, /*wasInferred=*/false});
 }
 
 /// Infer requirements from applications of BoundGenericTypes to type
@@ -218,21 +218,22 @@ static void realizeTypeRequirement(Type subjectType, Type constraintType,
 /// We automatically infer 'T : Hashable' from the fact that 'struct Set'
 /// declares a Hashable requirement on its generic parameter.
 void swift::rewriting::inferRequirements(
-    Type type, SourceLoc loc,
+    Type type, SourceLoc loc, ModuleDecl *module,
     SmallVectorImpl<StructuralRequirement> &result) {
   // FIXME: Implement
 }
 
 /// Desugar a requirement and perform requirement inference if requested
 /// to obtain zero or more structural requirements.
 void swift::rewriting::realizeRequirement(
-    Requirement req, RequirementRepr *reqRepr, bool infer,
+    Requirement req, RequirementRepr *reqRepr,
+    ModuleDecl *moduleForInference,
     SmallVectorImpl<StructuralRequirement> &result) {
   auto firstType = req.getFirstType();
-  if (infer) {
+  if (moduleForInference) {
     auto firstLoc = (reqRepr ? reqRepr->getFirstTypeRepr()->getStartLoc()
                              : SourceLoc());
-    inferRequirements(firstType, firstLoc, result);
+    inferRequirements(firstType, firstLoc, moduleForInference, result);
   }
 
   auto loc = (reqRepr ? reqRepr->getSeparatorLoc() : SourceLoc());
@@ -241,14 +242,13 @@ void swift::rewriting::realizeRequirement(
   case RequirementKind::Superclass:
   case RequirementKind::Conformance: {
     auto secondType = req.getSecondType();
-    if (infer) {
+    if (moduleForInference) {
       auto secondLoc = (reqRepr ? reqRepr->getSecondTypeRepr()->getStartLoc()
                                 : SourceLoc());
-      inferRequirements(secondType, secondLoc, result);
+      inferRequirements(secondType, secondLoc, moduleForInference, result);
     }
 
-    realizeTypeRequirement(firstType, secondType, loc, /*wasInferred=*/false,
-                           result);
+    realizeTypeRequirement(firstType, secondType, loc, result);
     break;
   }
 
@@ -264,10 +264,10 @@ void swift::rewriting::realizeRequirement(
 
   case RequirementKind::SameType: {
     auto secondType = req.getSecondType();
-    if (infer) {
+    if (moduleForInference) {
       auto secondLoc = (reqRepr ? reqRepr->getSecondTypeRepr()->getStartLoc()
                                 : SourceLoc());
-      inferRequirements(secondType, secondLoc, result);
+      inferRequirements(secondType, secondLoc, moduleForInference, result);
     }
 
     SmallVector<Requirement, 2> reqs;
@@ -283,7 +283,7 @@ void swift::rewriting::realizeRequirement(
 /// Collect structural requirements written in the inheritance clause of an
 /// AssociatedTypeDecl or GenericTypeParamDecl.
 void swift::rewriting::realizeInheritedRequirements(
-    TypeDecl *decl, Type type, bool infer,
+    TypeDecl *decl, Type type, ModuleDecl *moduleForInference,
     SmallVectorImpl<StructuralRequirement> &result) {
   auto &ctx = decl->getASTContext();
   auto inheritedTypes = decl->getInherited();
@@ -298,12 +298,11 @@ void swift::rewriting::realizeInheritedRequirements(
 
     auto *typeRepr = inheritedTypes[index].getTypeRepr();
     SourceLoc loc = (typeRepr ? typeRepr->getStartLoc() : SourceLoc());
-    if (infer) {
-      inferRequirements(inheritedType, loc, result);
+    if (moduleForInference) {
+      inferRequirements(inheritedType, loc, moduleForInference, result);
     }
 
-    realizeTypeRequirement(type, inheritedType, loc, /*wasInferred=*/false,
-                           result);
+    realizeTypeRequirement(type, inheritedType, loc, result);
   }
 }
 
@@ -319,12 +318,13 @@ StructuralRequirementsRequest::evaluate(Evaluator &evaluator,
   auto selfTy = proto->getSelfInterfaceType();
 
   realizeInheritedRequirements(proto, selfTy,
-                               /*infer=*/false, result);
+                               /*moduleForInference=*/nullptr, result);
 
   // Add requirements from the protocol's own 'where' clause.
   WhereClauseOwner(proto).visitRequirements(TypeResolutionStage::Structural,
       [&](const Requirement &req, RequirementRepr *reqRepr) {
-        realizeRequirement(req, reqRepr, /*infer=*/false, result);
+        realizeRequirement(req, reqRepr,
+                           /*moduleForInference=*/nullptr, result);
         return false;
       });
 
@@ -343,14 +343,17 @@ StructuralRequirementsRequest::evaluate(Evaluator &evaluator,
   for (auto assocTypeDecl : proto->getAssociatedTypeMembers()) {
     // Add requirements placed directly on this associated type.
     auto assocType = assocTypeDecl->getDeclaredInterfaceType();
-    realizeInheritedRequirements(assocTypeDecl, assocType, /*infer=*/false,
+    realizeInheritedRequirements(assocTypeDecl, assocType,
+                                 /*moduleForInference=*/nullptr,
                                  result);
 
     // Add requirements from this associated type's where clause.
     WhereClauseOwner(assocTypeDecl).visitRequirements(
         TypeResolutionStage::Structural,
         [&](const Requirement &req, RequirementRepr *reqRepr) {
-          realizeRequirement(req, reqRepr, /*infer=*/false, result);
+          realizeRequirement(req, reqRepr,
+                             /*moduleForInference=*/nullptr,
+                             result);
           return false;
         });
   }

lib/AST/RequirementMachine/RequirementLowering.h

@@ -41,13 +41,15 @@ namespace rewriting {
 
 void desugarRequirement(Requirement req, SmallVectorImpl<Requirement> &result);
 
-void inferRequirements(Type type, SourceLoc loc,
+void inferRequirements(Type type, SourceLoc loc, ModuleDecl *module,
                        SmallVectorImpl<StructuralRequirement> &result);
 
-void realizeRequirement(Requirement req, RequirementRepr *reqRepr, bool infer,
+void realizeRequirement(Requirement req, RequirementRepr *reqRepr,
+                        ModuleDecl *moduleForInference,
                         SmallVectorImpl<StructuralRequirement> &result);
 
-void realizeInheritedRequirements(TypeDecl *decl, Type type, bool infer,
+void realizeInheritedRequirements(TypeDecl *decl, Type type,
+                                  ModuleDecl *moduleForInference,
                                   SmallVectorImpl<StructuralRequirement> &result);
 
 /// A utility class for bulding rewrite rules from the top-level requirements

lib/AST/RequirementMachine/RequirementMachineRequests.cpp

@@ -373,6 +373,8 @@ InferredGenericSignatureRequestRQM::evaluate(
         bool allowConcreteGenericParams) const {
   GenericSignature parentSig(parentSigImpl);
 
+  auto &ctx = parentModule->getASTContext();
+
   SmallVector<GenericTypeParamType *, 4> genericParams(
       parentSig.getGenericParams().begin(),
       parentSig.getGenericParams().end());
@@ -383,7 +385,7 @@ InferredGenericSignatureRequestRQM::evaluate(
 
   const auto visitRequirement = [&](const Requirement &req,
                                     RequirementRepr *reqRepr) {
-    realizeRequirement(req, reqRepr, /*infer=*/true, requirements);
+    realizeRequirement(req, reqRepr, parentModule, requirements);
     return false;
   };
 
@@ -411,7 +413,7 @@ InferredGenericSignatureRequestRQM::evaluate(
                              ->castTo<GenericTypeParamType>();
         genericParams.push_back(gpType);
 
-        realizeInheritedRequirements(gpDecl, gpType, /*infer=*/true,
+        realizeInheritedRequirements(gpDecl, gpType, parentModule,
                                      requirements);
       }
 
@@ -438,7 +440,7 @@ InferredGenericSignatureRequestRQM::evaluate(
     auto *typeRepr = sourcePair.getTypeRepr();
     auto loc = typeRepr ? typeRepr->getStartLoc() : SourceLoc();
 
-    inferRequirements(sourcePair.getType(), loc, requirements);
+    inferRequirements(sourcePair.getType(), loc, parentModule, requirements);
   }
 
   // Finish by adding any remaining requirements. This is used to introduce
@@ -449,7 +451,7 @@ InferredGenericSignatureRequestRQM::evaluate(
 
   // Heap-allocate the requirement machine to save stack space.
   std::unique_ptr<RequirementMachine> machine(new RequirementMachine(
-      parentModule->getASTContext().getRewriteContext()));
+      ctx.getRewriteContext()));
 
   machine->initWithWrittenRequirements(genericParams, requirements);