Merge pull request #38457 from slavapestov/requirement-machine-archetypes

Use RequirementMachine to build archetypes when enabled

Author: slavapestov

include/swift/AST/GenericEnvironment.h

@@ -31,7 +31,6 @@
 namespace swift {
 
 class ArchetypeType;
-class GenericSignatureBuilder;
 class ASTContext;
 class GenericTypeParamType;
 class SILModule;
@@ -60,7 +59,6 @@ class QueryInterfaceTypeSubstitutions {
 class alignas(1 << DeclAlignInBits) GenericEnvironment final
         : private llvm::TrailingObjects<GenericEnvironment, Type> {
   GenericSignature Signature = GenericSignature();
-  GenericSignatureBuilder *Builder = nullptr;
 
   friend TrailingObjects;
 
@@ -79,10 +77,6 @@ class alignas(1 << DeclAlignInBits) GenericEnvironment final
   explicit GenericEnvironment(GenericSignature signature);
 
   friend ArchetypeType;
-  friend GenericSignatureBuilder;
-  
-  GenericSignatureBuilder *getGenericSignatureBuilder() const;
-
   friend QueryInterfaceTypeSubstitutions;
 
   Type getOrCreateArchetypeFromInterfaceType(Type depType);

include/swift/AST/GenericSignature.h

@@ -165,6 +165,18 @@ class GenericSignature {
 public:
   using RequiredProtocols = SmallVector<ProtocolDecl *, 2>;
 
+  /// Stores a set of requirements on a type parameter. Used by
+  /// GenericEnvironment for building archetypes.
+  struct LocalRequirements {
+    Type anchor;
+
+    Type concreteType;
+    Type superclass;
+
+    RequiredProtocols protos;
+    LayoutConstraint layout;
+  };
+
 private:
   // Direct comparison is disabled for generic signatures.  Canonicalize them
   // first, or use isEqual.
@@ -314,6 +326,10 @@ class alignas(1 << TypeAlignInBits) GenericSignatureImpl final
   /// signature.
   GenericEnvironment *getGenericEnvironment() const;
 
+  /// Collects a set of requirements on a type parameter. Used by
+  /// GenericEnvironment for building archetypes.
+  GenericSignature::LocalRequirements getLocalRequirements(Type depType) const;
+
   /// Uniquing for the ASTContext.
   void Profile(llvm::FoldingSetNodeID &ID) const {
     Profile(ID, getGenericParams(), getRequirements());

include/swift/AST/RequirementMachine.h

@@ -21,6 +21,10 @@ class raw_ostream;
 
 namespace swift {
 
+namespace rewriting {
+class RewriteContext;
+}
+
 class ASTContext;
 class AssociatedTypeDecl;
 class CanType;
@@ -40,7 +44,7 @@ class RequirementMachine final {
   ASTContext &Context;
   Implementation *Impl;
 
-  explicit RequirementMachine(ASTContext &ctx);
+  explicit RequirementMachine(rewriting::RewriteContext &rewriteCtx);
 
   RequirementMachine(const RequirementMachine &) = delete;
   RequirementMachine(RequirementMachine &&) = delete;
@@ -58,6 +62,8 @@ class RequirementMachine final {
   // Generic signature queries. Generally you shouldn't have to construct a
   // RequirementMachine instance; instead, call the corresponding methods on
   // GenericSignature, which lazily create a RequirementMachine for you.
+  GenericSignature::LocalRequirements getLocalRequirements(Type depType,
+                      TypeArrayView<GenericTypeParamType> genericParams) const;
   bool requiresClass(Type depType) const;
   LayoutConstraint getLayoutConstraint(Type depType) const;
   bool requiresProtocol(Type depType, const ProtocolDecl *proto) const;

include/swift/Basic/LangOptions.h

@@ -78,6 +78,18 @@ namespace swift {
     ErrorOnFailureRemarkOnSuccess
   };
 
+  /// Value for LangOptions::EnableRequirementMachine.
+  enum class RequirementMachineMode {
+    /// Use the GenericSignatureBuilder for all queries.
+    Disabled = 0,
+
+    /// Use the RequirementMachine for all queries.
+    Enabled = 1,
+
+    /// Use both and assert if the results do not match.
+    Verify = 2
+  };
+
   /// A collection of options that affect the language dialect and
   /// provide compiler debugging facilities.
   class LangOptions final {
@@ -446,7 +458,8 @@ namespace swift {
         ASTVerifierOverrideKind::NoOverride;
 
     /// Whether the new experimental generics implementation is enabled.
-    bool EnableRequirementMachine = false;
+    RequirementMachineMode EnableRequirementMachine =
+        RequirementMachineMode::Disabled;
 
     /// Enables debugging output from the requirement machine.
     bool DebugRequirementMachine = false;

include/swift/Option/FrontendOptions.td

@@ -277,11 +277,8 @@ def debug_constraints_on_line_EQ : Joined<["-"], "debug-constraints-on-line=">,
 def disable_named_lazy_member_loading : Flag<["-"], "disable-named-lazy-member-loading">,
   HelpText<"Disable per-name lazy member loading">;
 
-def enable_requirement_machine : Flag<["-"], "enable-requirement-machine">,
-  HelpText<"Enable experimental generics implementation">;
-
-def disable_requirement_machine : Flag<["-"], "disable-requirement-machine">,
-  HelpText<"Disable experimental generics implementation">;
+def requirement_machine_EQ : Joined<["-"], "requirement-machine=">,
+  HelpText<"Control usage of experimental generics implementation: 'on', 'off', or 'verify'">;
 
 def debug_requirement_machine : Flag<["-"], "debug-requirement-machine">,
   HelpText<"Enables debugging output from the generics implementation">;

lib/AST/ASTContext.cpp

@@ -67,6 +67,8 @@
 #include <algorithm>
 #include <memory>
 
+#include "RequirementMachine/RewriteContext.h"
+
 using namespace swift;
 
 #define DEBUG_TYPE "ASTContext"
@@ -531,6 +533,9 @@ struct ASTContext::Implementation {
   /// The scratch context used to allocate intrinsic data on behalf of \c swift::IntrinsicInfo
   std::unique_ptr<llvm::LLVMContext> IntrinsicScratchContext;
 #endif
+
+  /// Memory allocation arena for the term rewriting system.
+  std::unique_ptr<rewriting::RewriteContext> TheRewriteContext;
 };
 
 ASTContext::Implementation::Implementation()
@@ -1771,15 +1776,20 @@ static AllocationArena getArena(GenericSignature genericSig) {
   if (!genericSig)
     return AllocationArena::Permanent;
 
-  if (genericSig->hasTypeVariable())
+  if (genericSig->hasTypeVariable()) {
+    assert(false && "What's going on");
     return AllocationArena::ConstraintSolver;
+  }
 
   return AllocationArena::Permanent;
 }
 
 void ASTContext::registerGenericSignatureBuilder(
                                        GenericSignature sig,
                                        GenericSignatureBuilder &&builder) {
+  if (LangOpts.EnableRequirementMachine == RequirementMachineMode::Enabled)
+    return;
+
   auto canSig = sig.getCanonicalSignature();
   auto arena = getArena(sig);
   auto &genericSignatureBuilders =
@@ -1797,9 +1807,11 @@ void ASTContext::registerGenericSignatureBuilder(
 
 GenericSignatureBuilder *ASTContext::getOrCreateGenericSignatureBuilder(
                                                       CanGenericSignature sig) {
-  if (LangOpts.EnableRequirementMachine) {
-    (void) getOrCreateRequirementMachine(sig);
-  }
+  // We should only create GenericSignatureBuilders if the requirement machine
+  // mode is ::Disabled or ::Verify.
+  assert(LangOpts.EnableRequirementMachine != RequirementMachineMode::Enabled &&
+         "Shouldn't create GenericSignatureBuilder when RequirementMachine "
+         "is enabled");
 
   // Check whether we already have a generic signature builder for this
   // signature and module.
@@ -1883,6 +1895,12 @@ GenericSignatureBuilder *ASTContext::getOrCreateGenericSignatureBuilder(
 
 RequirementMachine *ASTContext::getOrCreateRequirementMachine(
     CanGenericSignature sig) {
+  assert(!sig->hasTypeVariable());
+
+  auto &rewriteCtx = getImpl().TheRewriteContext;
+  if (!rewriteCtx)
+    rewriteCtx.reset(new rewriting::RewriteContext(*this));
+
   // Check whether we already have a requirement machine for this
   // signature.
   auto arena = getArena(sig);
@@ -1900,12 +1918,12 @@ RequirementMachine *ASTContext::getOrCreateRequirementMachine(
     return machine;
   }
 
-  auto *machine = new RequirementMachine(*this);
+  auto *machine = new RequirementMachine(*rewriteCtx);
 
   // Store this requirement machine before adding the signature,
   // to catch re-entrant construction via addGenericSignature()
   // below.
-  machinePtr = std::unique_ptr<RequirementMachine>(machine);
+  machinePtr.reset(machine);
 
   machine->addGenericSignature(sig);
 

lib/AST/CMakeLists.txt

@@ -74,6 +74,7 @@ add_swift_host_library(swiftAST STATIC
   RawComment.cpp
   RequirementEnvironment.cpp
   RequirementMachine/EquivalenceClassMap.cpp
+  RequirementMachine/GenericSignatureQueries.cpp
   RequirementMachine/ProtocolGraph.cpp
   RequirementMachine/RequirementMachine.cpp
   RequirementMachine/RewriteContext.cpp

lib/AST/GenericEnvironment.cpp

@@ -15,11 +15,10 @@
 //===----------------------------------------------------------------------===//
 
 #include "swift/AST/GenericEnvironment.h"
+#include "swift/AST/GenericSignature.h"
 #include "swift/AST/ASTContext.h"
-#include "swift/AST/GenericSignatureBuilder.h"
 #include "swift/AST/ProtocolConformance.h"
 #include "swift/Basic/Defer.h"
-#include "GenericSignatureBuilderImpl.h"
 
 using namespace swift;
 
@@ -56,16 +55,6 @@ GenericEnvironment::GenericEnvironment(GenericSignature signature)
                           Type());
 }
 
-GenericSignatureBuilder *GenericEnvironment::getGenericSignatureBuilder() const {
-  if (Builder)
-    return Builder;
-
-  const_cast<GenericEnvironment *>(this)->Builder
-      = Signature->getGenericSignatureBuilder();
-
-  return Builder;
-}
-
 void GenericEnvironment::addMapping(GenericParamKey key,
                                     Type contextType) {
   // Find the index into the parallel arrays of generic parameters and
@@ -122,33 +111,30 @@ Type TypeBase::mapTypeOutOfContext() {
 
 Type
 GenericEnvironment::getOrCreateArchetypeFromInterfaceType(Type depType) {
-  auto &builder = *getGenericSignatureBuilder();
-  auto &ctx = builder.getASTContext();
-
-  auto resolved =
-    builder.maybeResolveEquivalenceClass(
-                                  depType,
-                                  ArchetypeResolutionKind::CompleteWellFormed,
-                                  /*wantExactPotentialArchetype=*/false);
-  if (!resolved)
-    return ErrorType::get(depType);
-
-  if (auto concrete = resolved.getAsConcreteType()) {
-    return mapTypeIntoContext(concrete,
-                              builder.getLookupConformanceFn());
+  auto genericSig = getGenericSignature();
+  LookUpConformanceInSignature conformanceLookupFn(genericSig.getPointer());
+
+  auto requirements = genericSig->getLocalRequirements(depType);
+
+  // FIXME: With the RequirementMachine, we will always have an anchor.
+  if (requirements.concreteType && !requirements.anchor) {
+    if (requirements.concreteType->is<ErrorType>())
+      return requirements.concreteType;
+
+    return mapTypeIntoContext(requirements.concreteType,
+                              conformanceLookupFn);
   }
 
-  auto *equivClass = resolved.getEquivalenceClass(builder);
+  assert(requirements.anchor && "No anchor or concrete type?");
 
-  auto genericParams = getGenericParams();
-  Type anchor = equivClass->getAnchor(builder, genericParams);
+  auto &ctx = genericSig->getASTContext();
 
   // First, write an ErrorType to the location where this type is cached,
   // to catch re-entrant lookups that might arise from an invalid generic
   // signature (eg, <X where X == Array<X>>).
   ArchetypeType *parentArchetype = nullptr;
   GenericTypeParamType *genericParam = nullptr;
-  if (auto depMemTy = anchor->getAs<DependentMemberType>()) {
+  if (auto depMemTy = requirements.anchor->getAs<DependentMemberType>()) {
     parentArchetype =
       getOrCreateArchetypeFromInterfaceType(depMemTy->getBase())
         ->getAs<ArchetypeType>();
@@ -161,7 +147,7 @@ GenericEnvironment::getOrCreateArchetypeFromInterfaceType(Type depType) {
 
     parentArchetype->registerNestedType(name, ErrorType::get(ctx));
   } else {
-    genericParam = anchor->castTo<GenericTypeParamType>();
+    genericParam = requirements.anchor->castTo<GenericTypeParamType>();
     if (auto type = getMappingIfPresent(genericParam))
       return *type;
     addMapping(genericParam, ErrorType::get(ctx));
@@ -171,42 +157,33 @@ GenericEnvironment::getOrCreateArchetypeFromInterfaceType(Type depType) {
 
   // If this equivalence class is mapped to a concrete type, produce that
   // type.
-  if (equivClass->concreteType) {
-    result = mapTypeIntoContext(equivClass->concreteType,
-                                builder.getLookupConformanceFn());
+  if (requirements.concreteType) {
+    result = mapTypeIntoContext(requirements.concreteType,
+                                conformanceLookupFn);
   } else {
     // Substitute into the superclass.
-    Type superclass = equivClass->superclass;
+    Type superclass = requirements.superclass;
     if (superclass && superclass->hasTypeParameter()) {
       superclass = mapTypeIntoContext(superclass,
-                                      builder.getLookupConformanceFn());
+                                      conformanceLookupFn);
       if (superclass->is<ErrorType>())
         superclass = Type();
     }
 
-    // Collect the protocol conformances for the archetype.
-    SmallVector<ProtocolDecl *, 4> protos;
-    for (const auto &conforms : equivClass->conformsTo) {
-      auto proto = conforms.first;
-
-      if (!equivClass->isConformanceSatisfiedBySuperclass(proto))
-        protos.push_back(proto);
-    }
-
     if (parentArchetype) {
-      auto *depMemTy = anchor->castTo<DependentMemberType>();
+      auto *depMemTy = requirements.anchor->castTo<DependentMemberType>();
       result = NestedArchetypeType::getNew(ctx, parentArchetype, depMemTy,
-                                           protos, superclass,
-                                           equivClass->layout);
+                                           requirements.protos, superclass,
+                                           requirements.layout);
     } else {
       result = PrimaryArchetypeType::getNew(ctx, this, genericParam,
-                                            protos, superclass,
-                                            equivClass->layout);
+                                            requirements.protos, superclass,
+                                            requirements.layout);
     }
   }
 
   // Cache the new archetype for future lookups.
-  if (auto depMemTy = anchor->getAs<DependentMemberType>()) {
+  if (auto depMemTy = requirements.anchor->getAs<DependentMemberType>()) {
     parentArchetype->registerNestedType(depMemTy->getName(), result);
   } else {
     addMapping(genericParam, result);