AST: AbstractGenericSignatureRequest and InferredGenericSignatureRequest return the HadAnyError bit

slavapestov · slavapestov · commit ee5a3fe9afdf · 2021-10-30T00:35:59.000-04:00
For now I'm going to use this in -verify-generic-signatures, but
it could be useful in other places too.
diff --git a/include/swift/AST/GenericSignatureBuilder.h b/include/swift/AST/GenericSignatureBuilder.h
@@ -608,6 +608,8 @@ class GenericSignatureBuilder {
                       bool allowConcreteGenericParams,
                       const ProtocolDecl *requirementSignatureSelfProto) &&;
 
+  bool hadAnyError() const;
+
   /// Finalize the set of requirements and compute the generic
   /// signature.
   ///
@@ -617,9 +619,6 @@ class GenericSignatureBuilder {
                       bool allowConcreteGenericParams = false,
                       const ProtocolDecl *requirementSignatureSelfProto = nullptr) &&;
 
-  /// Compute the requirement signature for the given protocol.
-  static GenericSignature computeRequirementSignature(ProtocolDecl *proto);
-
 private:
   /// Finalize the set of requirements, performing any remaining checking
   /// required before generating archetypes.
diff --git a/include/swift/AST/TypeCheckRequests.h b/include/swift/AST/TypeCheckRequests.h
@@ -1411,11 +1411,17 @@ class ClassAncestryFlagsRequest :
 
 void simple_display(llvm::raw_ostream &out, AncestryFlags value);
 
+/// AbstractGenericSignatureRequest and InferredGenericSignatureRequest
+/// return this type, which stores a GenericSignature together with a bit
+/// indicating if there were any errors detected in the original
+/// requirements.
+using GenericSignatureWithError = llvm::PointerIntPair<GenericSignature, 1>;
+
 class AbstractGenericSignatureRequest :
     public SimpleRequest<AbstractGenericSignatureRequest,
-                         GenericSignature (const GenericSignatureImpl *,
-                                           SmallVector<GenericTypeParamType *, 2>,
-                                           SmallVector<Requirement, 2>),
+                         GenericSignatureWithError (const GenericSignatureImpl *,
+                                                    SmallVector<GenericTypeParamType *, 2>,
+                                                    SmallVector<Requirement, 2>),
                          RequestFlags::Cached> {
 public:
   using SimpleRequest::SimpleRequest;
@@ -1424,7 +1430,7 @@ class AbstractGenericSignatureRequest :
   friend SimpleRequest;
 
   // Evaluation.
-  GenericSignature
+  GenericSignatureWithError
   evaluate(Evaluator &evaluator,
            const GenericSignatureImpl *baseSignature,
            SmallVector<GenericTypeParamType *, 2> addedParameters,
@@ -1442,13 +1448,13 @@ class AbstractGenericSignatureRequest :
 
 class InferredGenericSignatureRequest :
     public SimpleRequest<InferredGenericSignatureRequest,
-                         GenericSignature (ModuleDecl *,
-                                           const GenericSignatureImpl *,
-                                           GenericParamList *,
-                                           WhereClauseOwner,
-                                           SmallVector<Requirement, 2>,
-                                           SmallVector<TypeLoc, 2>,
-                                           bool),
+                         GenericSignatureWithError (ModuleDecl *,
+                                                    const GenericSignatureImpl *,
+                                                    GenericParamList *,
+                                                    WhereClauseOwner,
+                                                    SmallVector<Requirement, 2>,
+                                                    SmallVector<TypeLoc, 2>,
+                                                    bool),
                          RequestFlags::Cached> {
 public:
   using SimpleRequest::SimpleRequest;
@@ -1457,7 +1463,7 @@ class InferredGenericSignatureRequest :
   friend SimpleRequest;
 
   // Evaluation.
-  GenericSignature
+  GenericSignatureWithError
   evaluate(Evaluator &evaluator,
            ModuleDecl *parentModule,
            const GenericSignatureImpl *baseSignature,
diff --git a/include/swift/AST/TypeCheckerTypeIDZone.def b/include/swift/AST/TypeCheckerTypeIDZone.def
@@ -16,9 +16,9 @@
 //===----------------------------------------------------------------------===//
 
 SWIFT_REQUEST(TypeChecker, AbstractGenericSignatureRequest,
-              GenericSignature (const GenericSignatureImpl *,
-                                SmallVector<GenericTypeParamType *, 2>,
-                                SmallVector<Requirement, 2>),
+              GenericSignatureWithError (const GenericSignatureImpl *,
+                                         SmallVector<GenericTypeParamType *, 2>,
+                                         SmallVector<Requirement, 2>),
               Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, ApplyAccessNoteRequest,
               evaluator::SideEffect(ValueDecl *), Cached, NoLocationInfo)
@@ -131,12 +131,12 @@ SWIFT_REQUEST(TypeChecker, HasImplementationOnlyImportsRequest,
 SWIFT_REQUEST(TypeChecker, ModuleLibraryLevelRequest,
               LibraryLevel(ModuleDecl *), Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, InferredGenericSignatureRequest,
-              GenericSignature (ModuleDecl *,
-                                const GenericSignatureImpl *,
-                                GenericParamList *,
-                                WhereClauseOwner,
-                                SmallVector<Requirement, 2>,
-                                SmallVector<TypeLoc, 2>, bool),
+              GenericSignatureWithError (ModuleDecl *,
+                                         const GenericSignatureImpl *,
+                                         GenericParamList *,
+                                         WhereClauseOwner,
+                                         SmallVector<Requirement, 2>,
+                                         SmallVector<TypeLoc, 2>, bool),
               Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, DistributedModuleIsAvailableRequest,
               bool(ModuleDecl *), Cached, NoLocationInfo)
diff --git a/lib/AST/GenericSignature.cpp b/lib/AST/GenericSignature.cpp
@@ -1749,5 +1749,5 @@ swift::buildGenericSignature(ASTContext &ctx,
         baseSignature.getPointer(),
         addedParameters,
         addedRequirements},
-      GenericSignature());
+      GenericSignatureWithError()).getPointer();
 }
diff --git a/lib/AST/GenericSignatureBuilder.cpp b/lib/AST/GenericSignatureBuilder.cpp
@@ -8342,6 +8342,10 @@ GenericSignature GenericSignatureBuilder::rebuildSignatureWithoutRedundantRequir
       requirementSignatureSelfProto);
 }
 
+bool GenericSignatureBuilder::hadAnyError() const {
+  return Impl->HadAnyError;
+}
+
 GenericSignature GenericSignatureBuilder::computeGenericSignature(
                                           bool allowConcreteGenericParams,
                                           const ProtocolDecl *requirementSignatureSelfProto) && {
@@ -8577,7 +8581,7 @@ static bool isCanonicalRequest(GenericSignature baseSignature,
   return true;
 }
 
-GenericSignature
+GenericSignatureWithError
 AbstractGenericSignatureRequest::evaluate(
          Evaluator &evaluator,
          const GenericSignatureImpl *baseSignatureImpl,
@@ -8587,7 +8591,7 @@ AbstractGenericSignatureRequest::evaluate(
   // If nothing is added to the base signature, just return the base
   // signature.
   if (addedParameters.empty() && addedRequirements.empty())
-    return baseSignature;
+    return GenericSignatureWithError(baseSignature, /*hadError=*/false);
 
   ASTContext &ctx = addedParameters.empty()
       ? addedRequirements.front().getFirstType()->getASTContext()
@@ -8600,8 +8604,9 @@ AbstractGenericSignatureRequest::evaluate(
                            baseSignature.getGenericParams().begin(),
                            baseSignature.getGenericParams().end());
 
-    return GenericSignature::get(addedParameters,
-                                 baseSignature.getRequirements());
+    auto result = GenericSignature::get(addedParameters,
+                                        baseSignature.getRequirements());
+    return GenericSignatureWithError(result, /*hadError=*/false);
   }
 
   // If the request is non-canonical, we won't need to build our own
@@ -8624,16 +8629,18 @@ AbstractGenericSignatureRequest::evaluate(
     }
 
     // Build the canonical signature.
-    auto canSignatureResult = evaluator(
+    auto canSignatureResult = evaluateOrDefault(
+        ctx.evaluator,
         AbstractGenericSignatureRequest{
           canBaseSignature.getPointer(), std::move(canAddedParameters),
-          std::move(canAddedRequirements)});
-    if (!canSignatureResult || !*canSignatureResult)
-      return GenericSignature();
+          std::move(canAddedRequirements)},
+        GenericSignatureWithError());
+    if (!canSignatureResult.getPointer())
+      return GenericSignatureWithError();
 
     // Substitute in the original generic parameters to form the sugared
     // result the original request wanted.
-    auto canSignature = *canSignatureResult;
+    auto canSignature = canSignatureResult.getPointer();
     SmallVector<GenericTypeParamType *, 2> resugaredParameters;
     resugaredParameters.reserve(canSignature.getGenericParams().size());
     if (baseSignature) {
@@ -8660,7 +8667,9 @@ AbstractGenericSignatureRequest::evaluate(
       resugaredRequirements.push_back(*resugaredReq);
     }
 
-    return GenericSignature::get(resugaredParameters, resugaredRequirements);
+    return GenericSignatureWithError(
+        GenericSignature::get(resugaredParameters, resugaredRequirements),
+        canSignatureResult.getInt());
   }
 
   // Create a generic signature that will form the signature.
@@ -8677,11 +8686,13 @@ AbstractGenericSignatureRequest::evaluate(
   for (const auto &req : addedRequirements)
     builder.addRequirement(req, source, nullptr);
 
-  return std::move(builder).computeGenericSignature(
+  bool hadError = builder.hadAnyError();
+  auto result = std::move(builder).computeGenericSignature(
       /*allowConcreteGenericParams=*/true);
+  return GenericSignatureWithError(result, hadError);
 }
 
-GenericSignature
+GenericSignatureWithError
 InferredGenericSignatureRequest::evaluate(
         Evaluator &evaluator,
         ModuleDecl *parentModule,
@@ -8801,7 +8812,9 @@ InferredGenericSignatureRequest::evaluate(
       
   for (const auto &req : addedRequirements)
     builder.addRequirement(req, source, parentModule);
-  
-  return std::move(builder).computeGenericSignature(
+
+  bool hadError = builder.hadAnyError();
+  auto result = std::move(builder).computeGenericSignature(
       allowConcreteGenericParams);
+  return GenericSignatureWithError(result, hadError);
 }
diff --git a/lib/Sema/TypeCheckAttr.cpp b/lib/Sema/TypeCheckAttr.cpp
@@ -2286,7 +2286,8 @@ void AttributeChecker::visitSpecializeAttr(SpecializeAttr *attr) {
       /*allowConcreteGenericParams=*/true};
 
   auto specializedSig = evaluateOrDefault(Ctx.evaluator, request,
-                                          GenericSignature());
+                                          GenericSignatureWithError())
+      .getPointer();
 
   // Check the validity of provided requirements.
   checkSpecializeAttrRequirements(attr, genericSig, specializedSig, Ctx);
@@ -4349,7 +4350,8 @@ bool resolveDifferentiableAttrDerivativeGenericSignature(
 
     // Compute generic signature for derivative functions.
     derivativeGenSig = evaluateOrDefault(ctx.evaluator, request,
-                                         GenericSignature());
+                                         GenericSignatureWithError())
+        .getPointer();
 
     bool hadInvalidRequirements = false;
     for (auto req : derivativeGenSig.requirementsNotSatisfiedBy(originalGenSig)) {
diff --git a/lib/Sema/TypeCheckGeneric.cpp b/lib/Sema/TypeCheckGeneric.cpp
@@ -770,8 +770,8 @@ GenericSignatureRequest::evaluate(Evaluator &evaluator,
       GC->getGenericParams(), WhereClauseOwner(GC),
       sameTypeReqs, inferenceSources,
       allowConcreteGenericParams};
-  auto sig = evaluateOrDefault(ctx.evaluator,
-                               request, nullptr);
+  auto sig = evaluateOrDefault(ctx.evaluator, request,
+                               GenericSignatureWithError()).getPointer();
 
   // Debugging of the generic signature builder and generic signature
   // generation.
diff --git a/lib/Sema/TypeChecker.cpp b/lib/Sema/TypeChecker.cpp
@@ -441,8 +441,8 @@ swift::handleSILGenericParams(GenericParamList *genericParams,
       DC->getParentModule(), /*parentSig=*/nullptr,
       nestedList.back(), WhereClauseOwner(),
       {}, {}, /*allowConcreteGenericParams=*/true};
-  auto sig = evaluateOrDefault(DC->getASTContext().evaluator,
-                               request, GenericSignature());
+  auto sig = evaluateOrDefault(DC->getASTContext().evaluator, request,
+                               GenericSignatureWithError()).getPointer();
 
   return sig.getGenericEnvironment();
 }

Original file line number	Diff line number	Diff line change
`@@ -1749,5 +1749,5 @@ swift::buildGenericSignature(ASTContext &ctx,`
`1749`	`1749`	`baseSignature.getPointer(),`
`1750`	`1750`	`addedParameters,`
`1751`	`1751`	`addedRequirements},`
`1752`		`- GenericSignature());`
	`1752`	`+ GenericSignatureWithError()).getPointer();`
`1753`	`1753`	`}`