Merge pull request #41800 from slavapestov/rqm-assorted-validation-test-fixes

RequirementMachine: Cleanups and fixes to make more validation-tests pass with inferred-signatures=verify

Author: slavapestov

include/swift/AST/Decl.h

@@ -4389,6 +4389,7 @@ class ProtocolDecl final : public NominalTypeDecl {
   friend class ProtocolDependenciesRequest;
   friend class RequirementSignatureRequest;
   friend class RequirementSignatureRequestRQM;
+  friend class RequirementSignatureRequestGSB;
   friend class ProtocolRequiresClassRequest;
   friend class ExistentialConformsToSelfRequest;
   friend class ExistentialRequiresAnyRequest;

include/swift/AST/GenericSignature.h

@@ -529,6 +529,29 @@ GenericSignature buildGenericSignature(
     SmallVector<GenericTypeParamType *, 2> addedParameters,
     SmallVector<Requirement, 2> addedRequirements);
 
+/// Summary of error conditions detected by the Requirement Machine.
+enum class GenericSignatureErrorFlags {
+  /// The original requirements referenced a non-existent type parameter.
+  HasUnresolvedType = (1<<0),
+
+  /// The original requirements were in conflict with each other, meaning
+  /// there are no possible concrete substitutions which statisfy the
+  /// generic signature.
+  HasConflict = (1<<1),
+
+  /// The Knuth-Bendix completion procedure failed to construct a confluent
+  /// rewrite system.
+  CompletionFailed = (1<<2)
+};
+
+using GenericSignatureErrors = OptionSet<GenericSignatureErrorFlags>;
+
+/// AbstractGenericSignatureRequest and InferredGenericSignatureRequest
+/// return this type, which stores a GenericSignature together with the
+/// above set of error flags.
+using GenericSignatureWithError = llvm::PointerIntPair<GenericSignature, 3,
+                                                       GenericSignatureErrors>;
+
 } // end namespace swift
 
 namespace llvm {

include/swift/AST/RequirementSignature.h

@@ -17,6 +17,7 @@
 #ifndef SWIFT_AST_REQUIREMENT_SIGNATURE_H
 #define SWIFT_AST_REQUIREMENT_SIGNATURE_H
 
+#include "swift/AST/GenericSignature.h"
 #include "swift/AST/Type.h"
 
 namespace swift {
@@ -42,13 +43,16 @@ class ProtocolTypeAlias final {
 class RequirementSignature final {
   ArrayRef<Requirement> Requirements;
   ArrayRef<ProtocolTypeAlias> TypeAliases;
+  GenericSignatureErrors Errors;
 
 public:
-  RequirementSignature() = default;
+  RequirementSignature(GenericSignatureErrors errors = GenericSignatureErrors())
+    : Errors(errors) {}
 
   RequirementSignature(ArrayRef<Requirement> requirements,
-                       ArrayRef<ProtocolTypeAlias> typeAliases)
-    : Requirements(requirements), TypeAliases(typeAliases) {}
+                       ArrayRef<ProtocolTypeAlias> typeAliases,
+                       GenericSignatureErrors errors = GenericSignatureErrors())
+    : Requirements(requirements), TypeAliases(typeAliases), Errors(errors) {}
 
   /// The requirements including any inherited protocols and conformances for
   /// associated types that are introduced in this protocol.
@@ -65,6 +69,10 @@ class RequirementSignature final {
   ArrayRef<ProtocolTypeAlias> getTypeAliases() const {
     return TypeAliases;
   }
+
+  GenericSignatureErrors getErrors() const {
+    return Errors;
+  }
 };
 
 } // end namespace swift

include/swift/AST/TypeCheckRequests.h

@@ -493,6 +493,27 @@ class RequirementSignatureRequestRQM :
   bool isCached() const { return true; }
 };
 
+/// Compute a protocol's requirement signature using the GenericSignatureBuilder.
+/// This is temporary; once the GenericSignatureBuilder goes away this will
+/// be removed.
+class RequirementSignatureRequestGSB :
+    public SimpleRequest<RequirementSignatureRequestGSB,
+                         RequirementSignature(ProtocolDecl *),
+                         RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  RequirementSignature
+  evaluate(Evaluator &evaluator, ProtocolDecl *proto) const;
+
+public:
+  bool isCached() const { return true; }
+};
+
 /// Compute the requirements that describe a protocol.
 class RequirementSignatureRequest :
     public SimpleRequest<RequirementSignatureRequest,
@@ -1726,12 +1747,6 @@ 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,
                          GenericSignatureWithError (const GenericSignatureImpl *,
@@ -1793,6 +1808,37 @@ class AbstractGenericSignatureRequestRQM :
   }
 };
 
+/// Build a generic signature using the GenericSignatureBuilder. This is temporary;
+/// once the GenericSignatureBuilder goes away this will be removed.
+class AbstractGenericSignatureRequestGSB :
+    public SimpleRequest<AbstractGenericSignatureRequestGSB,
+                         GenericSignatureWithError (const GenericSignatureImpl *,
+                                                    SmallVector<GenericTypeParamType *, 2>,
+                                                    SmallVector<Requirement, 2>),
+                         RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  GenericSignatureWithError
+  evaluate(Evaluator &evaluator,
+           const GenericSignatureImpl *baseSignature,
+           SmallVector<GenericTypeParamType *, 2> addedParameters,
+           SmallVector<Requirement, 2> addedRequirements) const;
+
+public:
+  // Separate caching.
+  bool isCached() const { return true; }
+
+  /// Abstract generic signature requests never have source-location info.
+  SourceLoc getNearestLoc() const {
+    return SourceLoc();
+  }
+};
+
 class InferredGenericSignatureRequest :
     public SimpleRequest<InferredGenericSignatureRequest,
                          GenericSignatureWithError (ModuleDecl *,
@@ -1876,6 +1922,48 @@ class InferredGenericSignatureRequestRQM :
   void noteCycleStep(DiagnosticEngine &diags) const;
 };
 
+/// Build a generic signature using the GenericSignatureBuilder. This is temporary;
+/// once the GenericSignatureBuilder goes away this will be removed.
+class InferredGenericSignatureRequestGSB :
+    public SimpleRequest<InferredGenericSignatureRequestGSB,
+                         GenericSignatureWithError (ModuleDecl *,
+                                                    const GenericSignatureImpl *,
+                                                    GenericParamList *,
+                                                    WhereClauseOwner,
+                                                    SmallVector<Requirement, 2>,
+                                                    SmallVector<TypeLoc, 2>,
+                                                    bool),
+                         RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  GenericSignatureWithError
+  evaluate(Evaluator &evaluator,
+           ModuleDecl *parentModule,
+           const GenericSignatureImpl *baseSignature,
+           GenericParamList *genericParams,
+           WhereClauseOwner whereClause,
+           SmallVector<Requirement, 2> addedRequirements,
+           SmallVector<TypeLoc, 2> inferenceSources,
+           bool allowConcreteGenericParams) const;
+
+public:
+  // Separate caching.
+  bool isCached() const { return true; }
+
+  /// Inferred generic signature requests don't have source-location info.
+  SourceLoc getNearestLoc() const {
+    return SourceLoc();
+  }
+
+  // Cycle handling.
+  void noteCycleStep(DiagnosticEngine &diags) const;
+};
+
 void simple_display(llvm::raw_ostream &out, const TypeLoc source);
 
 class ExtendedTypeRequest

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -25,6 +25,11 @@ SWIFT_REQUEST(TypeChecker, AbstractGenericSignatureRequestRQM,
                                          SmallVector<GenericTypeParamType *, 2>,
                                          SmallVector<Requirement, 2>),
               Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, AbstractGenericSignatureRequestGSB,
+              GenericSignatureWithError (const GenericSignatureImpl *,
+                                         SmallVector<GenericTypeParamType *, 2>,
+                                         SmallVector<Requirement, 2>),
+              Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, ApplyAccessNoteRequest,
               evaluator::SideEffect(ValueDecl *), Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, AttachedResultBuilderRequest,
@@ -192,6 +197,14 @@ SWIFT_REQUEST(TypeChecker, InferredGenericSignatureRequestRQM,
                                          SmallVector<Requirement, 2>,
                                          SmallVector<TypeLoc, 2>, bool),
               Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, InferredGenericSignatureRequestGSB,
+              GenericSignatureWithError (ModuleDecl *,
+                                         const GenericSignatureImpl *,
+                                         GenericParamList *,
+                                         WhereClauseOwner,
+                                         SmallVector<Requirement, 2>,
+                                         SmallVector<TypeLoc, 2>, bool),
+              Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, DistributedModuleIsAvailableRequest,
               bool(ModuleDecl *), Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, InheritedTypeRequest,
@@ -288,6 +301,9 @@ SWIFT_REQUEST(TypeChecker, ProtocolDependenciesRequest,
 SWIFT_REQUEST(TypeChecker, RequirementSignatureRequestRQM,
               RequirementSignature(ProtocolDecl *), Cached,
               NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, RequirementSignatureRequestGSB,
+              RequirementSignature(ProtocolDecl *), Cached,
+              NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, RequirementSignatureRequest,
               RequirementSignature(ProtocolDecl *), SeparatelyCached,
               NoLocationInfo)

lib/AST/CMakeLists.txt

@@ -87,6 +87,7 @@ add_swift_host_library(swiftAST STATIC
   RequirementMachine/PropertyMap.cpp
   RequirementMachine/PropertyRelations.cpp
   RequirementMachine/PropertyUnification.cpp
+  RequirementMachine/RequirementBuilder.cpp
   RequirementMachine/RequirementLowering.cpp
   RequirementMachine/RequirementMachine.cpp
   RequirementMachine/RequirementMachineRequests.cpp