Merge pull request #12357 from DougGregor/module-free-gsb

Author: swift-ci

include/swift/AST/ASTContext.h

@@ -862,22 +862,20 @@ class ASTContext {
   /// generic signature builder for the given signature, if we don't already
   /// have one.
   void registerGenericSignatureBuilder(GenericSignature *sig,
-                                       ModuleDecl &module,
                                        GenericSignatureBuilder &&builder);
   friend class GenericSignatureBuilder;
 
 public:
   /// Retrieve or create the stored generic signature builder for the given
   /// canonical generic signature and module.
-  GenericSignatureBuilder *getOrCreateGenericSignatureBuilder(CanGenericSignature sig,
-                                                ModuleDecl *mod);
+  GenericSignatureBuilder *getOrCreateGenericSignatureBuilder(
+                                                     CanGenericSignature sig);
 
   /// Retrieve or create the canonical generic environment of a canonical
   /// generic signature builder.
   GenericEnvironment *getOrCreateCanonicalGenericEnvironment(
                                        GenericSignatureBuilder *builder,
-                                       GenericSignature *sig,
-                                       ModuleDecl &module);
+                                       GenericSignature *sig);
 
   /// Retrieve the inherited name set for the given class.
   const InheritedNameSet *getAllPropertyNames(ClassDecl *classDecl,

include/swift/AST/Decl.h

@@ -27,7 +27,6 @@
 #include "swift/AST/GenericParamKey.h"
 #include "swift/AST/IfConfigClause.h"
 #include "swift/AST/LayoutConstraint.h"
-#include "swift/AST/LazyResolver.h"
 #include "swift/AST/TypeAlignments.h"
 #include "swift/AST/TypeWalker.h"
 #include "swift/AST/Witness.h"
@@ -62,6 +61,7 @@ namespace swift {
   class GenericSignature;
   class GenericTypeParamDecl;
   class GenericTypeParamType;
+  class LazyResolver;
   class ModuleDecl;
   class NameAliasType;
   class EnumCaseDecl;

include/swift/AST/GenericSignature.h

@@ -132,7 +132,7 @@ class alignas(1 << TypeAlignInBits) GenericSignature final
                                    ArrayRef<Requirement> requirements);
 
   /// Retrieve the generic signature builder for the given generic signature.
-  GenericSignatureBuilder *getGenericSignatureBuilder(ModuleDecl &mod);
+  GenericSignatureBuilder *getGenericSignatureBuilder();
 
   friend class ArchetypeType;
 
@@ -256,54 +256,55 @@ class alignas(1 << TypeAlignInBits) GenericSignature final
   /// Create a new generic environment that provides fresh contextual types
   /// (archetypes) that correspond to the interface types in this generic
   /// signature.
-  GenericEnvironment *createGenericEnvironment(ModuleDecl &mod);
+  GenericEnvironment *createGenericEnvironment();
 
   /// Uniquing for the ASTContext.
   void Profile(llvm::FoldingSetNodeID &ID) {
     Profile(ID, getGenericParams(), getRequirements());
   }
 
   /// Determine whether the given dependent type is required to be a class.
-  bool requiresClass(Type type, ModuleDecl &mod);
+  bool requiresClass(Type type);
 
   /// Determine the superclass bound on the given dependent type.
-  Type getSuperclassBound(Type type, ModuleDecl &mod);
+  Type getSuperclassBound(Type type);
 
   using ConformsToArray = SmallVector<ProtocolDecl *, 2>;
   /// Determine the set of protocols to which the given dependent type
   /// must conform.
-  ConformsToArray getConformsTo(Type type, ModuleDecl &mod);
+  ConformsToArray getConformsTo(Type type);
 
   /// Determine whether the given dependent type conforms to this protocol.
-  bool conformsToProtocol(Type type, ProtocolDecl *proto, ModuleDecl &mod);
+  bool conformsToProtocol(Type type, ProtocolDecl *proto);
 
   /// Determine whether the given dependent type is equal to a concrete type.
-  bool isConcreteType(Type type, ModuleDecl &mod);
+  bool isConcreteType(Type type);
 
   /// Return the concrete type that the given dependent type is constrained to,
   /// or the null Type if it is not the subject of a concrete same-type
   /// constraint.
-  Type getConcreteType(Type type, ModuleDecl &mod);
+  Type getConcreteType(Type type);
 
   /// Return the layout constraint that the given dependent type is constrained
   /// to, or the null LayoutConstraint if it is not the subject of layout
   /// constraint.
-  LayoutConstraint getLayoutConstraint(Type type, ModuleDecl &mod);
+  LayoutConstraint getLayoutConstraint(Type type);
 
   /// Return whether two type parameters represent the same type under this
   /// generic signature.
   ///
   /// The type parameters must be known to not be concrete within the context.
-  bool areSameTypeParameterInContext(Type type1, Type type2, ModuleDecl &mod);
+  bool areSameTypeParameterInContext(Type type1, Type type2);
 
   /// Return the canonical version of the given type under this generic
   /// signature.
-  CanType getCanonicalTypeInContext(Type type, ModuleDecl &mod);
-  bool isCanonicalTypeInContext(Type type, ModuleDecl &mod);
+  CanType getCanonicalTypeInContext(Type type);
+  bool isCanonicalTypeInContext(Type type);
 
   /// Return the canonical version of the given type under this generic
   /// signature.
-  CanType getCanonicalTypeInContext(Type type, GenericSignatureBuilder &builder);
+  CanType getCanonicalTypeInContext(Type type,
+                                    GenericSignatureBuilder &builder);
   bool isCanonicalTypeInContext(Type type, GenericSignatureBuilder &builder);
 
   /// Retrieve the conformance access path used to extract the conformance of
@@ -319,8 +320,7 @@ class alignas(1 << TypeAlignInBits) GenericSignature final
   ///
   /// \seealso ConformanceAccessPath
   ConformanceAccessPath getConformanceAccessPath(Type type,
-                                                 ProtocolDecl *protocol,
-                                                 ModuleDecl &mod);
+                                                 ProtocolDecl *protocol);
 
   static void Profile(llvm::FoldingSetNodeID &ID,
                       ArrayRef<GenericTypeParamType *> genericParams,

include/swift/AST/GenericSignatureBuilder.h

@@ -475,20 +475,40 @@ class GenericSignatureBuilder {
 
 public:
   /// Construct a new generic signature builder.
-  ///
-  /// \param lookupConformance Conformance-lookup routine that will be used
-  /// to satisfy conformance requirements for concrete types.
-  explicit GenericSignatureBuilder(ASTContext &ctx,
-                            std::function<GenericFunction> lookupConformance);
-
+  explicit GenericSignatureBuilder(ASTContext &ctx);
   GenericSignatureBuilder(GenericSignatureBuilder &&);
   ~GenericSignatureBuilder();
 
   /// Retrieve the AST context.
   ASTContext &getASTContext() const { return Context; }
 
-  /// Retrieve the conformance-lookup function used by this generic signature builder.
-  std::function<GenericFunction> getLookupConformanceFn() const;
+  /// Functor class suitable for use as a \c LookupConformanceFn to look up a
+  /// conformance in a generic signature builder.
+  class LookUpConformanceInBuilder {
+    GenericSignatureBuilder *builder;
+  public:
+    explicit LookUpConformanceInBuilder(GenericSignatureBuilder *builder)
+      : builder(builder) {}
+
+    Optional<ProtocolConformanceRef>
+    operator()(CanType dependentType,
+               Type conformingReplacementType,
+               ProtocolType *conformedProtocol) const {
+      return builder->lookupConformance(dependentType,
+                                        conformingReplacementType,
+                                        conformedProtocol);
+    }
+  };
+
+  /// Retrieve a function that can perform conformance lookup for this
+  /// builder.
+  LookUpConformanceInBuilder getLookupConformanceFn();
+
+  /// Lookup a protocol conformance in a module-agnostic manner.
+  Optional<ProtocolConformanceRef>
+  lookupConformance(CanType dependentType, Type conformingReplacementType,
+                    ProtocolType *conformedProtocol);
+
 
   /// Retrieve the lazy resolver, if there is one.
   LazyResolver *getLazyResolver() const;
@@ -593,7 +613,6 @@ class GenericSignatureBuilder {
   /// After this point, one cannot introduce new requirements, and the
   /// generic signature builder no longer has valid state.
   GenericSignature *computeGenericSignature(
-                      ModuleDecl &module,
                       SourceLoc loc,
                       bool allowConcreteGenericParams = false,
                       bool allowBuilderToMove = true) &&;

include/swift/AST/LazyResolver.h

@@ -17,6 +17,7 @@
 #ifndef SWIFT_AST_LAZYRESOLVER_H
 #define SWIFT_AST_LAZYRESOLVER_H
 
+#include "swift/AST/ProtocolConformanceRef.h"
 #include "swift/AST/TypeLoc.h"
 #include "llvm/ADT/PointerEmbeddedInt.h"
 
@@ -102,6 +103,10 @@ class LazyResolver {
   /// is usable for the given type.
   virtual bool isProtocolExtensionUsable(DeclContext *dc, Type type,
                                          ExtensionDecl *protocolExtension) = 0;
+
+  /// Mark the given conformance as "used" from the given declaration context.
+  virtual void markConformanceUsed(ProtocolConformanceRef conformance,
+                                   DeclContext *dc) = 0;
 };
 
 /// An implementation of LazyResolver that delegates to another.
@@ -171,6 +176,11 @@ class DelegatingLazyResolver : public LazyResolver {
                                  ExtensionDecl *protocolExtension) override {
     return Principal.isProtocolExtensionUsable(dc, type, protocolExtension);
   }
+
+  void markConformanceUsed(ProtocolConformanceRef conformance,
+                           DeclContext *dc) override {
+    return Principal.markConformanceUsed(conformance, dc);
+  }
 };
 
 class LazyMemberLoader;

include/swift/AST/Type.h

@@ -577,7 +577,7 @@ class CanGenericSignature {
 
   /// Retrieve the canonical generic environment associated with this
   /// generic signature.
-  GenericEnvironment *getGenericEnvironment(ModuleDecl &module) const;
+  GenericEnvironment *getGenericEnvironment() const;
 
   GenericSignature *operator->() const {
     return Signature;

include/swift/AST/Types.h

@@ -393,7 +393,7 @@ class alignas(1 << TypeAlignInBits) TypeBase {
 
   /// getCanonicalType - Stronger canonicalization which folds away equivalent
   /// associated types, or type parameters that have been made concrete.
-  CanType getCanonicalType(GenericSignature *sig, ModuleDecl &mod);
+  CanType getCanonicalType(GenericSignature *sig);
 
   /// Reconstitute type sugar, e.g., for array types, dictionary
   /// types, optionals, etc.
@@ -3523,7 +3523,7 @@ class SILFunctionType final : public TypeBase, public llvm::FoldingSetNode,
   /// If this is a @convention(witness_method) function with a protocol
   /// constrained self parameter, return the protocol constraint for
   /// the Self type.
-  ProtocolDecl *getDefaultWitnessMethodProtocol(ModuleDecl &M) const;
+  ProtocolDecl *getDefaultWitnessMethodProtocol() const;
 
   /// If this is a @convention(witness_method) function with a class
   /// constrained self parameter, return the class constraint for the

include/swift/SIL/AbstractionPattern.h

@@ -705,14 +705,14 @@ class AbstractionPattern {
 
   /// Is this an interface type that is subject to a concrete
   /// same-type constraint?
-  bool isConcreteType(ModuleDecl &module) const {
+  bool isConcreteType() const {
     assert(isTypeParameter());
     return (getKind() != Kind::Opaque &&
             GenericSig != nullptr &&
-            GenericSig->isConcreteType(getType(), module));
+            GenericSig->isConcreteType(getType()));
   }
 
-  bool requiresClass(ModuleDecl &module) {
+  bool requiresClass() {
     switch (getKind()) {
     case Kind::Opaque:
       return false;
@@ -725,7 +725,7 @@ class AbstractionPattern {
                isa<GenericTypeParamType>(type)) {
         assert(GenericSig &&
                "Dependent type in pattern without generic signature?");
-        return GenericSig->requiresClass(type, module);
+        return GenericSig->requiresClass(type);
       }
       return false;
     }

lib/AST/ASTContext.cpp

@@ -252,8 +252,7 @@ FOR_KNOWN_FOUNDATION_TYPES(CACHE_FOUNDATION_DECL)
   llvm::DenseMap<const DeclContext *, LazyContextData *> LazyContexts;
 
   /// Stored generic signature builders for canonical generic signatures.
-  llvm::DenseMap<std::pair<GenericSignature *, ModuleDecl *>,
-                 std::unique_ptr<GenericSignatureBuilder>>
+  llvm::DenseMap<GenericSignature *, std::unique_ptr<GenericSignatureBuilder>>
     GenericSignatureBuilders;
 
   /// Canonical generic environments for canonical generic signatures.
@@ -1436,35 +1435,32 @@ void ASTContext::getVisibleTopLevelClangModules(
 
 void ASTContext::registerGenericSignatureBuilder(
                                        GenericSignature *sig,
-                                       ModuleDecl &module,
                                        GenericSignatureBuilder &&builder) {
   auto canSig = sig->getCanonicalSignature();
-  auto known = Impl.GenericSignatureBuilders.find({canSig, &module});
+  auto known = Impl.GenericSignatureBuilders.find(canSig);
   if (known != Impl.GenericSignatureBuilders.end()) {
     ++NumRegisteredGenericSignatureBuildersAlready;
     return;
   }
 
   ++NumRegisteredGenericSignatureBuilders;
-  Impl.GenericSignatureBuilders[{canSig, &module}] =
+  Impl.GenericSignatureBuilders[canSig] =
     llvm::make_unique<GenericSignatureBuilder>(std::move(builder));
 }
 
 GenericSignatureBuilder *ASTContext::getOrCreateGenericSignatureBuilder(
-                                                      CanGenericSignature sig,
-                                                      ModuleDecl *mod) {
+                                                      CanGenericSignature sig) {
   // Check whether we already have a generic signature builder for this
   // signature and module.
-  auto known = Impl.GenericSignatureBuilders.find({sig, mod});
+  auto known = Impl.GenericSignatureBuilders.find(sig);
   if (known != Impl.GenericSignatureBuilders.end())
     return known->second.get();
 
   // Create a new generic signature builder with the given signature.
-  auto builder =
-    new GenericSignatureBuilder(*this, LookUpConformanceInModule(mod));
+  auto builder = new GenericSignatureBuilder(*this);
 
   // Store this generic signature builder (no generic environment yet).
-  Impl.GenericSignatureBuilders[{sig, mod}] =
+  Impl.GenericSignatureBuilders[sig] =
     std::unique_ptr<GenericSignatureBuilder>(builder);
 
   builder->addGenericSignature(sig);
@@ -1534,13 +1530,12 @@ GenericSignatureBuilder *ASTContext::getOrCreateGenericSignatureBuilder(
 
 GenericEnvironment *ASTContext::getOrCreateCanonicalGenericEnvironment(
                                               GenericSignatureBuilder *builder,
-                                              GenericSignature *sig,
-                                              ModuleDecl &module) {
+                                              GenericSignature *sig) {
   auto known = Impl.CanonicalGenericEnvironments.find(builder);
   if (known != Impl.CanonicalGenericEnvironments.end())
     return known->second;
 
-  auto env = sig->createGenericEnvironment(module);
+  auto env = sig->createGenericEnvironment();
   Impl.CanonicalGenericEnvironments[builder] = env;
   return env;
 }
@@ -3637,12 +3632,10 @@ GenericFunctionType::get(GenericSignature *sig,
   // it's canonical.  Unfortunately, isCanonicalTypeInContext can cause
   // new GenericFunctionTypes to be created and thus invalidate our insertion
   // point.
-  auto &moduleForCanonicality = *ctx.TheBuiltinModule;
   bool isCanonical = sig->isCanonical()
     && isCanonicalFunctionInputType(input)
-    && sig->isCanonicalTypeInContext(unwrapParenType(input),
-                                     moduleForCanonicality)
-    && sig->isCanonicalTypeInContext(output, moduleForCanonicality);
+    && sig->isCanonicalTypeInContext(unwrapParenType(input))
+    && sig->isCanonicalTypeInContext(output);
 
   if (auto result
         = ctx.Impl.GenericFunctionTypes.FindNodeOrInsertPos(id, insertPos)) {
@@ -4725,7 +4718,7 @@ CanGenericSignature ASTContext::getExistentialSignature(CanType existential,
 
   assert(existential.isExistentialType());
 
-  GenericSignatureBuilder builder(*this, LookUpConformanceInModule(mod));
+  GenericSignatureBuilder builder(*this);
 
   auto genericParam = GenericTypeParamType::get(0, 0, *this);
   builder.addGenericParameter(genericParam);
@@ -4736,7 +4729,7 @@ CanGenericSignature ASTContext::getExistentialSignature(CanType existential,
     GenericSignatureBuilder::FloatingRequirementSource::forAbstract();
   builder.addRequirement(requirement, source, nullptr);
 
-  CanGenericSignature genericSig(std::move(builder).computeGenericSignature(*mod, SourceLoc()));
+  CanGenericSignature genericSig(std::move(builder).computeGenericSignature(SourceLoc()));
 
   auto result = Impl.ExistentialSignatures.insert(
     std::make_pair(existential, genericSig));

lib/AST/ASTMangler.cpp

@@ -1680,8 +1680,8 @@ void ASTMangler::appendAssociatedTypeName(DependentMemberType *dmt) {
   // dependent type, but can't yet. Shouldn't need this side channel.
 
   appendIdentifier(assocTy->getName().str());
-  if (!OptimizeProtocolNames || !CurGenericSignature || !Mod
-      || CurGenericSignature->getConformsTo(dmt->getBase(), *Mod).size() > 1) {
+  if (!OptimizeProtocolNames || !CurGenericSignature
+      || CurGenericSignature->getConformsTo(dmt->getBase()).size() > 1) {
     appendAnyGenericType(assocTy->getProtocol());
   }
 }

lib/AST/ASTScope.cpp

@@ -20,6 +20,7 @@
 #include "swift/AST/Decl.h"
 #include "swift/AST/Expr.h"
 #include "swift/AST/Initializer.h"
+#include "swift/AST/LazyResolver.h"
 #include "swift/AST/Module.h"
 #include "swift/AST/ParameterList.h"
 #include "swift/AST/Pattern.h"