AST: Refactor RequirementEnvironment and Witness to store GenericSignature instead of GenericEnvironment

Author: slavapestov

include/swift/AST/RequirementEnvironment.h

@@ -72,15 +72,14 @@ class RequirementEnvironment {
   /// The witness thunk emitted by SILGen uses the synthetic signature.
   /// Therefore one invariant we preserve is that the witness thunk is
   /// ABI compatible with the requirement's function type.
-  GenericSignature syntheticSignature = GenericSignature();
-  GenericEnvironment *syntheticEnvironment = nullptr;
+  GenericSignature syntheticSig = GenericSignature();
 
   /// The generic signature of the protocol requirement member.
   GenericSignature reqSig = GenericSignature();
 
   /// A substitution map mapping the requirement signature to the
   /// generic parameters of the synthetic signature.
-  SubstitutionMap reqToSyntheticEnvMap;
+  SubstitutionMap reqToSyntheticSigMap;
 
 public:
   /// Create a new environment for matching the given requirement within a
@@ -102,20 +101,20 @@ class RequirementEnvironment {
                          ClassDecl *covariantSelf,
                          ProtocolConformance *conformance);
 
-  /// Retrieve the synthetic generic environment.
-  GenericEnvironment *getSyntheticEnvironment() const {
-    return syntheticEnvironment;
-  }
-
   /// Retrieve the generic signature of the requirement.
   GenericSignature getRequirementSignature() const {
     return reqSig;
   }
 
+  /// Retrieve the generic signature of the witness thunk.
+  GenericSignature getSyntheticSignature() const {
+    return syntheticSig;
+  }
+
   /// Retrieve the substitution map that maps the interface types of the
-  /// requirement to the interface types of the synthetic environment.
+  /// requirement to the interface types of the synthetic signature.
   SubstitutionMap getRequirementToSyntheticMap() const {
-    return reqToSyntheticEnvMap;
+    return reqToSyntheticSigMap;
   }
 };
 

include/swift/AST/Witness.h

@@ -92,8 +92,8 @@ class Witness {
     /// The witness declaration, along with the substitutions needed to use
     /// the witness declaration from the synthetic environment.
     ConcreteDeclRef declRef;
-    GenericEnvironment *syntheticEnvironment;
-    SubstitutionMap reqToSyntheticEnvSubs;
+    GenericSignature syntheticSig;
+    SubstitutionMap reqToSyntheticSigSubs;
     /// The derivative generic signature, when the requirement is a derivative
     /// function.
     GenericSignature derivativeGenSig;
@@ -141,10 +141,10 @@ class Witness {
   /// \param substitutions The substitutions required to use the witness from
   /// the synthetic environment.
   ///
-  /// \param syntheticEnv The synthetic environment.
+  /// \param syntheticSig The synthetic signature.
   ///
-  /// \param reqToSyntheticEnvSubs The mapping from the interface types of the
-  /// requirement into the interface types of the synthetic environment.
+  /// \param reqToSyntheticSigSubs The mapping from the interface types of the
+  /// requirement into the interface types of the synthetic signature.
   ///
   /// \param derivativeGenSig The derivative generic signature, when the
   /// requirement is a derivative function.
@@ -153,8 +153,8 @@ class Witness {
   /// need to hop to before calling the witness.
   Witness(ValueDecl *decl,
           SubstitutionMap substitutions,
-          GenericEnvironment *syntheticEnv,
-          SubstitutionMap reqToSyntheticEnvSubs,
+          GenericSignature syntheticSig,
+          SubstitutionMap reqToSyntheticSigSubs,
           GenericSignature derivativeGenSig,
           Optional<ActorIsolation> enterIsolation);
 
@@ -183,18 +183,18 @@ class Witness {
     return getDeclRef().getSubstitutions();
   }
 
-  /// Retrieve the synthetic generic environment.
-  GenericEnvironment *getSyntheticEnvironment() const {
+  /// Retrieve the synthetic generic signature.
+  GenericSignature getSyntheticSignature() const {
     if (auto *storedWitness = storage.dyn_cast<StoredWitness *>())
-      return storedWitness->syntheticEnvironment;
+      return storedWitness->syntheticSig;
     return nullptr;
   }
 
   /// Retrieve the substitution map that maps the interface types of the
-  /// requirement to the interface types of the synthetic environment.
+  /// requirement to the interface types of the synthetic signature.
   SubstitutionMap getRequirementToSyntheticSubs() const {
     if (auto *storedWitness = storage.dyn_cast<StoredWitness *>())
-      return storedWitness->reqToSyntheticEnvSubs;
+      return storedWitness->reqToSyntheticSigSubs;
     return {};
   }
 

lib/AST/ProtocolConformance.cpp

@@ -42,28 +42,28 @@ STATISTIC(NumConformanceLookupTables, "# of conformance lookup tables built");
 using namespace swift;
 
 Witness::Witness(ValueDecl *decl, SubstitutionMap substitutions,
-                 GenericEnvironment *syntheticEnv,
-                 SubstitutionMap reqToSynthesizedEnvSubs,
+                 GenericSignature syntheticSig,
+                 SubstitutionMap reqToSyntheticSigSubs,
                  GenericSignature derivativeGenSig,
                  Optional<ActorIsolation> enterIsolation) {
-  if (!syntheticEnv && substitutions.empty() &&
-      reqToSynthesizedEnvSubs.empty() && !enterIsolation) {
+  if (!syntheticSig && substitutions.empty() &&
+      reqToSyntheticSigSubs.empty() && !enterIsolation) {
     storage = decl;
     return;
   }
 
   auto &ctx = decl->getASTContext();
   auto declRef = ConcreteDeclRef(decl, substitutions);
   auto storedMem = ctx.Allocate(sizeof(StoredWitness), alignof(StoredWitness));
-  auto stored = new (storedMem) StoredWitness{declRef, syntheticEnv,
-                                              reqToSynthesizedEnvSubs,
+  auto stored = new (storedMem) StoredWitness{declRef, syntheticSig,
+                                              reqToSyntheticSigSubs,
                                               derivativeGenSig, enterIsolation};
 
   storage = stored;
 }
 
 Witness Witness::withEnterIsolation(ActorIsolation enterIsolation) const {
-  return Witness(getDecl(), getSubstitutions(), getSyntheticEnvironment(),
+  return Witness(getDecl(), getSubstitutions(), getSyntheticSignature(),
                  getRequirementToSyntheticSubs(),
                  getDerivativeGenericSignature(), enterIsolation);
 }

lib/AST/RequirementEnvironment.cpp

@@ -88,7 +88,7 @@ RequirementEnvironment::RequirementEnvironment(
   auto selfType = cast<GenericTypeParamType>(
       proto->getSelfInterfaceType()->getCanonicalType());
 
-  reqToSyntheticEnvMap = SubstitutionMap::get(reqSig,
+  reqToSyntheticSigMap = SubstitutionMap::get(reqSig,
     [selfType, substConcreteType, depth, covariantSelf, &ctx]
     (SubstitutableType *type) -> Type {
       // If the conforming type is a class, the protocol 'Self' maps to
@@ -141,10 +141,7 @@ RequirementEnvironment::RequirementEnvironment(
   if (!covariantSelf &&
       reqSig.getGenericParams().size() == 1 &&
       reqSig.getRequirements().size() == 1) {
-    syntheticSignature = conformanceDC->getGenericSignatureOfContext().getCanonicalSignature();
-    syntheticEnvironment =
-      syntheticSignature.getGenericEnvironment();
-
+    syntheticSig = conformanceDC->getGenericSignatureOfContext().getCanonicalSignature();
     return;
   }
 
@@ -207,13 +204,12 @@ RequirementEnvironment::RequirementEnvironment(
   // Next, add each of the requirements (mapped from the requirement's
   // interface types into the abstract type parameters).
   for (auto &rawReq : reqSig.getRequirements()) {
-    if (auto req = rawReq.subst(reqToSyntheticEnvMap))
+    if (auto req = rawReq.subst(reqToSyntheticSigMap))
       requirements.push_back(*req);
   }
 
   // Produce the generic signature and environment.
-  syntheticSignature = buildGenericSignature(ctx, GenericSignature(),
-                                             std::move(genericParamTypes),
-                                             std::move(requirements));
-  syntheticEnvironment = syntheticSignature.getGenericEnvironment();
+  syntheticSig = buildGenericSignature(ctx, GenericSignature(),
+                                       std::move(genericParamTypes),
+                                       std::move(requirements));
 }

lib/SILGen/SILGenType.cpp

@@ -726,10 +726,8 @@ SILFunction *SILGenModule::emitProtocolWitness(
   auto reqtSubMap = witness.getRequirementToSyntheticSubs();
 
   // The generic environment for the witness thunk.
-  auto *genericEnv = witness.getSyntheticEnvironment();
-  CanGenericSignature genericSig;
-  if (genericEnv)
-    genericSig = genericEnv->getGenericSignature().getCanonicalSignature();
+  auto *genericEnv = witness.getSyntheticSignature().getGenericEnvironment();
+  auto genericSig = witness.getSyntheticSignature().getCanonicalSignature();
 
   // The type of the witness thunk.
   auto reqtSubstTy = cast<AnyFunctionType>(

lib/Sema/TypeCheckProtocol.cpp

@@ -99,9 +99,9 @@ struct swift::RequirementCheck {
 };
 
 swift::Witness RequirementMatch::getWitness(ASTContext &ctx) const {
-  auto syntheticEnv = ReqEnv->getSyntheticEnvironment();
   return swift::Witness(this->Witness, WitnessSubstitutions,
-                        syntheticEnv, ReqEnv->getRequirementToSyntheticMap(),
+                        ReqEnv->getSyntheticSignature(),
+                        ReqEnv->getRequirementToSyntheticMap(),
                         DerivativeGenSig, None);
 }
 
@@ -1077,12 +1077,13 @@ swift::matchWitness(WitnessChecker::RequirementEnvironmentCache &reqEnvCache,
     // the required type and the witness type.
     cs.emplace(dc, ConstraintSystemFlags::AllowFixes);
 
-    auto reqGenericEnv = reqEnvironment.getSyntheticEnvironment();
+    auto syntheticSig = reqEnvironment.getSyntheticSignature();
+    auto *syntheticEnv = syntheticSig.getGenericEnvironment();
     auto reqSubMap = reqEnvironment.getRequirementToSyntheticMap();
 
     Type selfTy = proto->getSelfInterfaceType().subst(reqSubMap);
-    if (reqGenericEnv)
-      selfTy = reqGenericEnv->mapTypeIntoContext(selfTy);
+    if (syntheticEnv)
+      selfTy = syntheticEnv->mapTypeIntoContext(selfTy);
 
     // Open up the type of the requirement.
     reqLocator = cs->getConstraintLocator(
@@ -1106,8 +1107,8 @@ swift::matchWitness(WitnessChecker::RequirementEnvironmentCache &reqEnvCache,
       if (replacedInReq->hasError())
         continue;
 
-      if (reqGenericEnv) {
-        replacedInReq = reqGenericEnv->mapTypeIntoContext(replacedInReq);
+      if (syntheticEnv) {
+        replacedInReq = syntheticEnv->mapTypeIntoContext(replacedInReq);
       }
 
       cs->addConstraint(ConstraintKind::Bind, replacement.second, replacedInReq,