Merge pull request #25986 from slavapestov/partially-checked-conformances

Remove PartiallyCheckedConformances list

Author: slavapestov

include/swift/AST/Decl.h

@@ -70,7 +70,6 @@ namespace swift {
   class GenericSignature;
   class GenericTypeParamDecl;
   class GenericTypeParamType;
-  class LazyResolver;
   class ModuleDecl;
   class EnumCaseDecl;
   class EnumElementDecl;
@@ -3956,10 +3955,7 @@ class ClassDecl final : public NominalTypeDecl {
 
   /// Determine whether this class inherits the convenience initializers
   /// from its superclass.
-  ///
-  /// \param resolver Used to resolve the signatures of initializers, which is
-  /// required for name lookup.
-  bool inheritsSuperclassInitializers(LazyResolver *resolver);
+  bool inheritsSuperclassInitializers();
 
   /// Marks that this class inherits convenience initializers from its
   /// superclass.
@@ -4143,7 +4139,7 @@ class ProtocolDecl final : public NominalTypeDecl {
 
   bool existentialConformsToSelfSlow();
 
-  bool existentialTypeSupportedSlow(LazyResolver *resolver);
+  bool existentialTypeSupportedSlow();
 
   ArrayRef<ProtocolDecl *> getInheritedProtocolsSlow();
 
@@ -4269,12 +4265,12 @@ class ProtocolDecl final : public NominalTypeDecl {
   /// conforming to this protocol. This is only permitted if the types of
   /// all the members do not contain any associated types, and do not
   /// contain 'Self' in 'parameter' or 'other' position.
-  bool existentialTypeSupported(LazyResolver *resolver) const {
+  bool existentialTypeSupported() const {
     if (Bits.ProtocolDecl.ExistentialTypeSupportedValid)
       return Bits.ProtocolDecl.ExistentialTypeSupported;
 
     return const_cast<ProtocolDecl *>(this)
-             ->existentialTypeSupportedSlow(resolver);
+             ->existentialTypeSupportedSlow();
   }
 
   /// Explicitly set the existentialTypeSupported flag, without computing

include/swift/AST/ProtocolConformance.h

@@ -148,19 +148,16 @@ class alignas(1 << DeclAlignInBits) ProtocolConformance {
 
   /// Return true if the conformance has a witness for the given associated
   /// type.
-  bool hasTypeWitness(AssociatedTypeDecl *assocType,
-                      LazyResolver *resolver = nullptr) const;
+  bool hasTypeWitness(AssociatedTypeDecl *assocType) const;
 
   /// Retrieve the type witness for the given associated type.
   Type getTypeWitness(AssociatedTypeDecl *assocType,
-                      LazyResolver *resolver,
                       SubstOptions options = None) const;
 
   /// Retrieve the type witness and type decl (if one exists)
   /// for the given associated type.
   std::pair<Type, TypeDecl *>
   getTypeWitnessAndDecl(AssociatedTypeDecl *assocType,
-                        LazyResolver *resolver,
                         SubstOptions options = None) const;
 
   /// Apply the given function object to each type witness within this
@@ -173,17 +170,17 @@ class alignas(1 << DeclAlignInBits) ProtocolConformance {
   ///
   /// \returns true if the function ever returned true
   template<typename F>
-  bool forEachTypeWitness(LazyResolver *resolver, F f) const {
+  bool forEachTypeWitness(F f, bool useResolver=false) const {
     const ProtocolDecl *protocol = getProtocol();
     for (auto assocTypeReq : protocol->getAssociatedTypeMembers()) {
       if (assocTypeReq->isInvalid())
         continue;
 
       // If we don't have and cannot resolve witnesses, skip it.
-      if (!resolver && !hasTypeWitness(assocTypeReq))
+      if (!useResolver && !hasTypeWitness(assocTypeReq))
         continue;
 
-      const auto &TWInfo = getTypeWitnessAndDecl(assocTypeReq, resolver);
+      const auto &TWInfo = getTypeWitnessAndDecl(assocTypeReq);
       if (f(assocTypeReq, TWInfo.first, TWInfo.second))
         return true;
     }
@@ -193,13 +190,11 @@ class alignas(1 << DeclAlignInBits) ProtocolConformance {
 
   /// Retrieve the value witness declaration corresponding to the given
   /// requirement.
-  ValueDecl *getWitnessDecl(ValueDecl *requirement,
-                            LazyResolver *resolver) const;
+  ValueDecl *getWitnessDecl(ValueDecl *requirement) const;
 
   /// Retrieve the witness corresponding to the given value requirement.
   /// TODO: maybe this should return a Witness?
-  ConcreteDeclRef getWitnessDeclRef(ValueDecl *requirement,
-                                    LazyResolver *resolver) const;
+  ConcreteDeclRef getWitnessDeclRef(ValueDecl *requirement) const;
 
 private:
   /// Determine whether we have a witness for the given requirement.
@@ -211,7 +206,7 @@ class alignas(1 << DeclAlignInBits) ProtocolConformance {
   ///
   /// The function object should accept a \c ValueDecl* for the requirement.
   template<typename F>
-  void forEachNonWitnessedRequirement(LazyResolver *Resolver, F f) const {
+  void forEachNonWitnessedRequirement(F f) const {
     const ProtocolDecl *protocol = getProtocol();
     for (auto req : protocol->getMembers()) {
       auto valueReq = dyn_cast<ValueDecl>(req);
@@ -220,7 +215,7 @@ class alignas(1 << DeclAlignInBits) ProtocolConformance {
 
       if (auto assocTypeReq = dyn_cast<AssociatedTypeDecl>(req)) {
         // If we don't have witness for the associated type, apply the function.
-        if (getTypeWitness(assocTypeReq, Resolver)->hasError()) {
+        if (getTypeWitness(assocTypeReq)->hasError()) {
           f(valueReq);
         }
         continue;
@@ -241,15 +236,13 @@ class alignas(1 << DeclAlignInBits) ProtocolConformance {
 
   /// Given a dependent type expressed in terms of the self parameter,
   /// map it into the context of this conformance.
-  Type getAssociatedType(Type assocType,
-                         LazyResolver *resolver = nullptr) const;
+  Type getAssociatedType(Type assocType) const;
 
   /// Given that the requirement signature of the protocol directly states
   /// that the given dependent type must conform to the given protocol,
   /// return its associated conformance.
   ProtocolConformanceRef
-  getAssociatedConformance(Type assocType, ProtocolDecl *protocol,
-                           LazyResolver *resolver = nullptr) const;
+  getAssociatedConformance(Type assocType, ProtocolDecl *protocol) const;
 
   /// Get the generic parameters open on the conforming type.
   GenericEnvironment *getGenericEnvironment() const;
@@ -353,12 +346,11 @@ class RootProtocolConformance : public ProtocolConformance {
                       AvailabilityContext fromContext) const;
 
   bool hasWitness(ValueDecl *requirement) const;
-  Witness getWitness(ValueDecl *requirement, LazyResolver *resolver) const;
+  Witness getWitness(ValueDecl *requirement) const;
 
   /// Retrieve the witness corresponding to the given value requirement.
   /// TODO: maybe this should return a Witness?
-  ConcreteDeclRef getWitnessDeclRef(ValueDecl *requirement,
-                                    LazyResolver *resolver) const;
+  ConcreteDeclRef getWitnessDeclRef(ValueDecl *requirement) const;
 
   /// Apply the given function object to each value witness within this
   /// protocol conformance.
@@ -368,7 +360,7 @@ class RootProtocolConformance : public ProtocolConformance {
   /// witness will only be specialized if the conformance came from the current
   /// file.
   template<typename F>
-  void forEachValueWitness(LazyResolver *resolver, F f) const {
+  void forEachValueWitness(F f, bool useResolver=false) const {
     const ProtocolDecl *protocol = getProtocol();
     for (auto req : protocol->getMembers()) {
       auto valueReq = dyn_cast<ValueDecl>(req);
@@ -380,10 +372,10 @@ class RootProtocolConformance : public ProtocolConformance {
         continue;
 
       // If we don't have and cannot resolve witnesses, skip it.
-      if (!resolver && !hasWitness(valueReq))
+      if (!useResolver && !hasWitness(valueReq))
         continue;
 
-      f(valueReq, getWitness(valueReq, resolver));
+      f(valueReq, getWitness(valueReq));
     }
   }
 
@@ -597,13 +589,11 @@ class NormalProtocolConformance : public RootProtocolConformance,
   /// for the given associated type.
   std::pair<Type, TypeDecl *>
   getTypeWitnessAndDecl(AssociatedTypeDecl *assocType,
-                        LazyResolver *resolver,
                         SubstOptions options = None) const;
 
   /// Determine whether the protocol conformance has a type witness for the
   /// given associated type.
-  bool hasTypeWitness(AssociatedTypeDecl *assocType,
-                      LazyResolver *resolver = nullptr) const;
+  bool hasTypeWitness(AssociatedTypeDecl *assocType) const;
 
   /// Set the type witness for the given associated type.
   /// \param typeDecl the type decl the witness type came from, if one exists.
@@ -614,11 +604,10 @@ class NormalProtocolConformance : public RootProtocolConformance,
   /// that the given dependent type must conform to the given protocol,
   /// return its associated conformance.
   ProtocolConformanceRef
-  getAssociatedConformance(Type assocType, ProtocolDecl *protocol,
-                           LazyResolver *resolver = nullptr) const;
+  getAssociatedConformance(Type assocType, ProtocolDecl *protocol) const;
 
   /// Retrieve the value witness corresponding to the given requirement.
-  Witness getWitness(ValueDecl *requirement, LazyResolver *resolver) const;
+  Witness getWitness(ValueDecl *requirement) const;
 
   /// Determine whether the protocol conformance has a witness for the given
   /// requirement.
@@ -644,20 +633,14 @@ class NormalProtocolConformance : public RootProtocolConformance,
   /// the normal conformance.
   void setSignatureConformances(ArrayRef<ProtocolConformanceRef> conformances);
 
-  /// Retrieves a function object that should be called with each of the
-  /// conformances required by the requirement signature.
-  ///
-  /// This can be used to iteratively build up the signature conformances in
-  /// the type checker (rather than emitting them in a batch via
-  /// \c setSignatureConformances). The callee is responsible for calling
-  /// the returned function object with protocol conformances that line up
-  /// with the conformance requirements in the requirement signature (in order).
-  std::function<void(ProtocolConformanceRef)> populateSignatureConformances();
+  /// Populate the signature conformances without checking if they satisfy
+  /// requirements. Can only be used with parsed or imported conformances.
+  void finishSignatureConformances();
 
   /// Determine whether the witness for the given type requirement
   /// is the default definition.
   bool usesDefaultDefinition(AssociatedTypeDecl *requirement) const {
-    TypeDecl *witnessDecl = getTypeWitnessAndDecl(requirement, nullptr).second;
+    TypeDecl *witnessDecl = getTypeWitnessAndDecl(requirement).second;
     if (witnessDecl)
       return witnessDecl->isImplicit();
     // Conservatively assume it does not.
@@ -725,20 +708,17 @@ class SelfProtocolConformance : public RootProtocolConformance {
     llvm_unreachable("never an implied conformance");
   }
 
-  bool hasTypeWitness(AssociatedTypeDecl *assocType,
-                      LazyResolver *resolver) const {
+  bool hasTypeWitness(AssociatedTypeDecl *assocType) const {
     llvm_unreachable("self-conformances never have associated types");
   }
 
   std::pair<Type, TypeDecl *>
   getTypeWitnessAndDecl(AssociatedTypeDecl *assocType,
-                        LazyResolver *resolver,
                         SubstOptions options) const {
     llvm_unreachable("self-conformances never have associated types");
   }
 
   Type getTypeWitness(AssociatedTypeDecl *assocType,
-                      LazyResolver *resolver,
                       SubstOptions options) const {
     llvm_unreachable("self-conformances never have associated types");
   }
@@ -748,15 +728,14 @@ class SelfProtocolConformance : public RootProtocolConformance {
   }
 
   ProtocolConformanceRef getAssociatedConformance(Type assocType,
-                                                  ProtocolDecl *protocol,
-                                                  LazyResolver *resolver) const{
+                                                  ProtocolDecl *protocol) const{
     llvm_unreachable("self-conformances never have associated types");
   }
 
   bool hasWitness(ValueDecl *requirement) const {
     return true;
   }
-  Witness getWitness(ValueDecl *requirement, LazyResolver *resolver) const;
+  Witness getWitness(ValueDecl *requirement) const;
 
   Optional<ArrayRef<Requirement>> getConditionalRequirementsIfAvailable() const{
     return ArrayRef<Requirement>();
@@ -875,26 +854,22 @@ class SpecializedProtocolConformance : public ProtocolConformance,
     return GenericConformance->getImplyingConformance();
   }
 
-  bool hasTypeWitness(AssociatedTypeDecl *assocType,
-                      LazyResolver *resolver = nullptr) const;
+  bool hasTypeWitness(AssociatedTypeDecl *assocType) const;
 
   /// Retrieve the type witness and type decl (if one exists)
   /// for the given associated type.
   std::pair<Type, TypeDecl *>
   getTypeWitnessAndDecl(AssociatedTypeDecl *assocType,
-                        LazyResolver *resolver,
                         SubstOptions options = None) const;
 
   /// Given that the requirement signature of the protocol directly states
   /// that the given dependent type must conform to the given protocol,
   /// return its associated conformance.
   ProtocolConformanceRef
-  getAssociatedConformance(Type assocType, ProtocolDecl *protocol,
-                           LazyResolver *resolver = nullptr) const;
+  getAssociatedConformance(Type assocType, ProtocolDecl *protocol) const;
 
   /// Retrieve the witness corresponding to the given value requirement.
-  ConcreteDeclRef getWitnessDeclRef(ValueDecl *requirement,
-                                    LazyResolver *resolver) const;
+  ConcreteDeclRef getWitnessDeclRef(ValueDecl *requirement) const;
 
   /// Determine whether the witness for the given requirement
   /// is either the default definition or was otherwise deduced.
@@ -989,31 +964,26 @@ class InheritedProtocolConformance : public ProtocolConformance,
   /// Get the protocol conformance which implied this implied conformance.
   NormalProtocolConformance *getImplyingConformance() const { return nullptr; }
 
-  bool hasTypeWitness(AssociatedTypeDecl *assocType,
-                      LazyResolver *resolver = nullptr) const {
-    return InheritedConformance->hasTypeWitness(assocType, resolver);
+  bool hasTypeWitness(AssociatedTypeDecl *assocType) const {
+    return InheritedConformance->hasTypeWitness(assocType);
   }
 
   /// Retrieve the type witness and type decl (if one exists)
   /// for the given associated type.
   std::pair<Type, TypeDecl *>
   getTypeWitnessAndDecl(AssociatedTypeDecl *assocType,
-                        LazyResolver *resolver,
                         SubstOptions options = None) const {
-    return InheritedConformance->getTypeWitnessAndDecl(assocType, resolver,
-                                                       options);
+    return InheritedConformance->getTypeWitnessAndDecl(assocType, options);
   }
 
   /// Given that the requirement signature of the protocol directly states
   /// that the given dependent type must conform to the given protocol,
   /// return its associated conformance.
   ProtocolConformanceRef
-  getAssociatedConformance(Type assocType, ProtocolDecl *protocol,
-                           LazyResolver *resolver = nullptr) const;
+  getAssociatedConformance(Type assocType, ProtocolDecl *protocol) const;
 
   /// Retrieve the witness corresponding to the given value requirement.
-  ConcreteDeclRef getWitnessDeclRef(ValueDecl *requirement,
-                                    LazyResolver *resolver) const;
+  ConcreteDeclRef getWitnessDeclRef(ValueDecl *requirement) const;
 
   /// Determine whether the witness for the given requirement
   /// is either the default definition or was otherwise deduced.

include/swift/AST/ProtocolConformanceRef.h

@@ -110,17 +110,18 @@ class ProtocolConformanceRef {
                                LookupConformanceFn conformances,
                                SubstOptions options = None) const;
 
+  /// Map contextual types to interface types in the conformance.
+  ProtocolConformanceRef mapConformanceOutOfContext() const;
+
   /// Given a dependent type (expressed in terms of this conformance's
   /// protocol), follow it from the conforming type.
-  Type getAssociatedType(Type origType, Type dependentType,
-                         LazyResolver *resolver = nullptr) const;
+  Type getAssociatedType(Type origType, Type dependentType) const;
 
   /// Given a dependent type (expressed in terms of this conformance's
   /// protocol) and conformance, follow it from the conforming type.
   ProtocolConformanceRef
   getAssociatedConformance(Type origType, Type dependentType,
-                           ProtocolDecl *requirement,
-                           LazyResolver *resolver = nullptr) const;
+                           ProtocolDecl *requirement) const;
 
   void dump() const;
   void dump(llvm::raw_ostream &out, unsigned indent = 0) const;

include/swift/AST/Type.h

@@ -38,7 +38,6 @@ class ClassDecl;
 class CanType;
 class EnumDecl;
 class GenericSignature;
-class LazyResolver;
 class ModuleDecl;
 class NominalTypeDecl;
 class GenericTypeDecl;

include/swift/AST/Types.h

@@ -5112,9 +5112,7 @@ class DependentMemberType : public TypeBase {
   /// Substitute the base type, looking up our associated type in it if it is
   /// non-dependent. Returns null if the member could not be found in the new
   /// base.
-  Type substBaseType(ModuleDecl *M,
-                     Type base,
-                     LazyResolver *resolver = nullptr);
+  Type substBaseType(ModuleDecl *M, Type base);
 
   /// Substitute the base type, looking up our associated type in it if it is
   /// non-dependent. Returns null if the member could not be found in the new

include/swift/Sema/IDETypeChecking.h

@@ -27,7 +27,6 @@ namespace swift {
   class AbstractFunctionDecl;
   class Decl;
   class Expr;
-  class LazyResolver;
   class ExtensionDecl;
   class ProtocolDecl;
   class Type;

include/swift/Serialization/SerializedModuleLoader.h

@@ -19,6 +19,7 @@
 
 namespace swift {
 class ModuleFile;
+class LazyResolver;
 
 /// Spceifies how to load modules when both a parseable interface and serialized
 /// AST are present, or whether to disallow one format or the other altogether.