Sema: Clean up InferredGenericSignatureRequest

- It's wasteful to cache because each invocation is unique
- Inference sources only need to be Types and not TypeLocs
- We can pass in an explicit SourceLoc for diagnostics

(cherry picked from commit 4e39dac206dd8e0818ca509f5f09f93425a48c62)

Author: slavapestov

include/swift/AST/TypeCheckRequests.h

@@ -2008,9 +2008,9 @@ class InferredGenericSignatureRequest :
                                                     GenericParamList *,
                                                     WhereClauseOwner,
                                                     SmallVector<Requirement, 2>,
-                                                    SmallVector<TypeLoc, 2>,
-                                                    bool, bool),
-                         RequestFlags::Cached> {
+                                                    SmallVector<TypeBase *, 2>,
+                                                    SourceLoc, bool, bool),
+                         RequestFlags::Uncached> {
 public:
   using SimpleRequest::SimpleRequest;
 
@@ -2024,13 +2024,10 @@ class InferredGenericSignatureRequest :
            GenericParamList *genericParams,
            WhereClauseOwner whereClause,
            SmallVector<Requirement, 2> addedRequirements,
-           SmallVector<TypeLoc, 2> inferenceSources,
-           bool isExtension, bool allowInverses) const;
+           SmallVector<TypeBase *, 2> inferenceSources,
+           SourceLoc loc, bool isExtension, bool allowInverses) const;
 
 public:
-  // Separate caching.
-  bool isCached() const { return true; }
-
   /// Inferred generic signature requests don't have source-location info.
   SourceLoc getNearestLoc() const {
     return SourceLoc();

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -197,8 +197,9 @@ SWIFT_REQUEST(TypeChecker, InferredGenericSignatureRequest,
                                          GenericParamList *,
                                          WhereClauseOwner,
                                          SmallVector<Requirement, 2>,
-                                         SmallVector<TypeLoc, 2>, bool, bool),
-              Cached, NoLocationInfo)
+                                         SmallVector<TypeBase *, 2>,
+                                         SourceLoc, bool, bool),
+              Uncached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, DistributedModuleIsAvailableRequest,
               bool(ModuleDecl *), Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, InheritedTypeRequest,

lib/AST/RequirementMachine/RequirementLowering.cpp

@@ -676,8 +676,7 @@ struct InferRequirementsWalker : public TypeWalker {
 /// 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,
-    ModuleDecl *module, DeclContext *dc,
+    Type type, ModuleDecl *module, DeclContext *dc,
     SmallVectorImpl<StructuralRequirement> &result) {
   if (!type)
     return;
@@ -707,13 +706,8 @@ void swift::rewriting::realizeRequirement(
     auto secondType = req.getSecondType();
 
     if (shouldInferRequirements) {
-      auto firstLoc = (reqRepr ? reqRepr->getSubjectRepr()->getStartLoc()
-                               : SourceLoc());
-      inferRequirements(firstType, firstLoc, moduleForInference, dc, result);
-
-      auto secondLoc = (reqRepr ? reqRepr->getConstraintRepr()->getStartLoc()
-                                : SourceLoc());
-      inferRequirements(secondType, secondLoc, moduleForInference, dc, result);
+      inferRequirements(firstType, moduleForInference, dc, result);
+      inferRequirements(secondType, moduleForInference, dc, result);
     }
 
     realizeTypeRequirement(dc, firstType, secondType, loc, result, errors);
@@ -723,9 +717,7 @@ void swift::rewriting::realizeRequirement(
   case RequirementKind::Layout: {
     if (shouldInferRequirements) {
       auto firstType = req.getFirstType();
-      auto firstLoc = (reqRepr ? reqRepr->getSubjectRepr()->getStartLoc()
-                               : SourceLoc());
-      inferRequirements(firstType, firstLoc, moduleForInference, dc, result);
+      inferRequirements(firstType, moduleForInference, dc, result);
     }
 
     result.push_back({req, loc});
@@ -735,14 +727,10 @@ void swift::rewriting::realizeRequirement(
   case RequirementKind::SameType: {
     if (shouldInferRequirements) {
       auto firstType = req.getFirstType();
-      auto firstLoc = (reqRepr ? reqRepr->getFirstTypeRepr()->getStartLoc()
-                               : SourceLoc());
-      inferRequirements(firstType, firstLoc, moduleForInference, dc, result);
+      inferRequirements(firstType, moduleForInference, dc, result);
 
       auto secondType = req.getSecondType();
-      auto secondLoc = (reqRepr ? reqRepr->getSecondTypeRepr()->getStartLoc()
-                                : SourceLoc());
-      inferRequirements(secondType, secondLoc, moduleForInference, dc, result);
+      inferRequirements(secondType, moduleForInference, dc, result);
     }
 
     result.push_back({req, loc});
@@ -843,14 +831,14 @@ void swift::rewriting::realizeInheritedRequirements(
 
     if (!inheritedType) continue;
 
-    auto *typeRepr = inheritedTypes.getTypeRepr(index);
-    SourceLoc loc = (typeRepr ? typeRepr->getStartLoc() : SourceLoc());
-
     if (shouldInferRequirements) {
-      inferRequirements(inheritedType, loc, moduleForInference,
+      inferRequirements(inheritedType, moduleForInference,
                         decl->getInnermostDeclContext(), result);
     }
 
+    auto *typeRepr = inheritedTypes.getTypeRepr(index);
+    SourceLoc loc = (typeRepr ? typeRepr->getStartLoc() : SourceLoc());
+
     realizeTypeRequirement(dc, type, inheritedType, loc, result, errors);
   }
 

lib/AST/RequirementMachine/RequirementLowering.h

@@ -47,8 +47,7 @@ void desugarRequirement(Requirement req, SourceLoc loc,
                         SmallVectorImpl<InverseRequirement> &inverses,
                         SmallVectorImpl<RequirementError> &errors);
 
-void inferRequirements(Type type, SourceLoc loc,
-                       ModuleDecl *module, DeclContext *dc,
+void inferRequirements(Type type, ModuleDecl *module, DeclContext *dc,
                        SmallVectorImpl<StructuralRequirement> &result);
 
 void realizeRequirement(DeclContext *dc,

lib/AST/RequirementMachine/RequirementMachineRequests.cpp

@@ -753,8 +753,8 @@ InferredGenericSignatureRequest::evaluate(
         GenericParamList *genericParamList,
         WhereClauseOwner whereClause,
         SmallVector<Requirement, 2> addedRequirements,
-        SmallVector<TypeLoc, 2> inferenceSources,
-        bool isExtension, bool allowInverses) const {
+        SmallVector<TypeBase *, 2> inferenceSources,
+        SourceLoc loc, bool isExtension, bool allowInverses) const {
   GenericSignature parentSig(parentSigImpl);
 
   SmallVector<GenericTypeParamType *, 4> genericParams(
@@ -771,26 +771,6 @@ InferredGenericSignatureRequest::evaluate(
   SmallVector<RequirementError, 2> errors;
   SmallVector<InverseRequirement, 2> inverses;
 
-  SourceLoc loc = [&]() {
-    if (genericParamList) {
-      auto loc = genericParamList->getLAngleLoc();
-      if (loc.isValid())
-        return loc;
-    }
-    if (whereClause) {
-      auto loc = whereClause.getLoc();
-      if (loc.isValid())
-        return loc;
-    }
-    for (auto sourcePair : inferenceSources) {
-      auto *typeRepr = sourcePair.getTypeRepr();
-      auto loc = typeRepr ? typeRepr->getStartLoc() : SourceLoc();
-      if (loc.isValid())
-        return loc;
-    }
-    return SourceLoc();
-  }();
-
   for (const auto &req : parentSig.getRequirements())
     requirements.push_back({req, loc});
 
@@ -861,12 +841,8 @@ InferredGenericSignatureRequest::evaluate(
 
   // Perform requirement inference from function parameter and result
   // types and such.
-  for (auto sourcePair : inferenceSources) {
-    auto *typeRepr = sourcePair.getTypeRepr();
-    auto typeLoc = typeRepr ? typeRepr->getStartLoc() : SourceLoc();
-
-    inferRequirements(sourcePair.getType(), typeLoc, moduleForInference,
-                      lookupDC, requirements);
+  for (auto source : inferenceSources) {
+    inferRequirements(source, moduleForInference, lookupDC, requirements);
   }
 
   // Finish by adding any remaining requirements. This is used to introduce

lib/Sema/TypeCheckAttr.cpp

@@ -3070,6 +3070,7 @@ SerializeAttrGenericSignatureRequest::evaluate(Evaluator &evaluator,
       WhereClauseOwner(const_cast<AbstractFunctionDecl *>(FD), attr),
       /*addedRequirements=*/{},
       /*inferenceSources=*/{},
+      attr->getLocation(),
       /*isExtension=*/false,
       /*allowInverses=*/true};
 
@@ -5593,6 +5594,7 @@ bool resolveDifferentiableAttrDerivativeGenericSignature(
         WhereClauseOwner(original, attr),
         /*addedRequirements=*/{},
         /*inferenceSources=*/{},
+        attr->getLocation(),
         /*isExtension=*/false,
         /*allowInverses=*/true};
 

lib/Sema/TypeCheckGeneric.cpp

@@ -118,6 +118,7 @@ OpaqueResultTypeRequest::evaluate(Evaluator &evaluator,
         WhereClauseOwner(),
         /*addedRequirements=*/{},
         /*inferenceSources=*/{},
+        repr->getLoc(),
         /*isExtension=*/false,
         /*allowInverses=*/true};
 
@@ -681,9 +682,13 @@ GenericSignatureRequest::evaluate(Evaluator &evaluator,
   }
 
   GenericSignature parentSig;
-  SmallVector<TypeLoc, 2> inferenceSources;
+  SmallVector<TypeBase *, 2> inferenceSources;
   SmallVector<Requirement, 2> extraReqs;
+  SourceLoc loc;
+
   if (auto VD = dyn_cast<ValueDecl>(GC->getAsDecl())) {
+    loc = VD->getLoc();
+
     parentSig = GC->getParentForLookup()->getGenericSignatureOfContext();
 
     auto func = dyn_cast<AbstractFunctionDecl>(VD);
@@ -728,7 +733,7 @@ GenericSignatureRequest::evaluate(Evaluator &evaluator,
         const auto type =
             resolution.withOptions(paramOptions).resolveType(typeRepr);
 
-        inferenceSources.emplace_back(typeRepr, type);
+        inferenceSources.push_back(type.getPointer());
       }
 
       // Handle the thrown error type.
@@ -743,7 +748,7 @@ GenericSignatureRequest::evaluate(Evaluator &evaluator,
               .resolveType(thrownTypeRepr);
 
           // Add this type as an inference source.
-          inferenceSources.emplace_back(thrownTypeRepr, thrownType);
+          inferenceSources.push_back(thrownType.getPointer());
 
           // Add conformance of this type to the Error protocol.
           if (auto errorProtocol = ctx.getErrorDecl()) {
@@ -771,10 +776,12 @@ GenericSignatureRequest::evaluate(Evaluator &evaluator,
             resolution.withOptions(TypeResolverContext::FunctionResult)
                 .resolveType(resultTypeRepr);
 
-        inferenceSources.emplace_back(resultTypeRepr, resultType);
+        inferenceSources.push_back(resultType.getPointer());
       }
     }
   } else if (auto *ext = dyn_cast<ExtensionDecl>(GC)) {
+    loc = ext->getLoc();
+
     collectAdditionalExtensionRequirements(ext->getExtendedType(), extraReqs);
 
     auto *extendedNominal = ext->getExtendedNominal();
@@ -804,7 +811,7 @@ GenericSignatureRequest::evaluate(Evaluator &evaluator,
   auto request = InferredGenericSignatureRequest{
       parentSig.getPointer(),
       genericParams, WhereClauseOwner(GC),
-      extraReqs, inferenceSources,
+      extraReqs, inferenceSources, loc,
       /*isExtension=*/isa<ExtensionDecl>(GC),
       /*allowInverses=*/true};
   return evaluateOrDefault(ctx.evaluator, request,

lib/Sema/TypeChecker.cpp

@@ -529,7 +529,7 @@ swift::handleSILGenericParams(GenericParamList *genericParams,
   auto request = InferredGenericSignatureRequest{
       /*parentSig=*/nullptr,
       nestedList.back(), WhereClauseOwner(),
-      {}, {},
+      {}, {}, genericParams->getLAngleLoc(),
       /*isExtension=*/false,
       allowInverses};
   return evaluateOrDefault(DC->getASTContext().evaluator, request,