Merge pull request #60152 from slavapestov/witness-cleanup

slavapestov · web-flow · commit 1c2976469e4f · 2022-07-20T19:08:35.000-04:00
Fix some job security in the witness representation
diff --git a/include/swift/AST/Decl.h b/include/swift/AST/Decl.h
@@ -35,7 +35,6 @@
 #include "swift/AST/TypeAlignments.h"
 #include "swift/AST/TypeWalker.h"
 #include "swift/AST/Types.h"
-#include "swift/AST/Witness.h"
 #include "swift/Basic/ArrayRefView.h"
 #include "swift/Basic/Compiler.h"
 #include "swift/Basic/Debug.h"
@@ -105,6 +104,7 @@ namespace swift {
   class ValueDecl;
   class VarDecl;
   class OpaqueReturnTypeRepr;
+  class Witness;
 
   namespace ast_scope {
   class AbstractPatternEntryScope;
diff --git a/include/swift/AST/RequirementEnvironment.h b/include/swift/AST/RequirementEnvironment.h
@@ -35,7 +35,7 @@ namespace swift {
 /// environment are the type parameters of the conformance context
 /// (\c conformanceDC) with another (deeper) level of type parameters for
 /// generic requirements. See the \c Witness class for more information about
-/// this synthetic environment.
+/// the witness thunk signature.
 class RequirementEnvironment {
   /// A generic signature that combines the generic parameters of the
   /// concrete conforming type with the generic parameters of the
@@ -52,7 +52,7 @@ class RequirementEnvironment {
   /// <Self : P, T>
   /// <A, B, T>
   ///
-  /// The synthetic signature in this case is just the witness signature.
+  /// The witness thunk signature in this case is just the witness signature.
   ///
   /// It may be that the witness is more generic than the requirement,
   /// for example:
@@ -65,22 +65,21 @@ class RequirementEnvironment {
   /// <Self : P>
   /// <A, B, T>
   ///
-  /// The synthetic signature is just:
+  /// The witness thunk signature is just:
   ///
   /// <A, B>
   ///
-  /// The witness thunk emitted by SILGen uses the synthetic signature.
+  /// The witness thunk emitted by SILGen uses the witness thunk 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 witnessThunkSig = 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;
+  /// generic parameters of the witness thunk signature.
+  SubstitutionMap reqToWitnessThunkSigMap;
 
 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 getWitnessThunkSignature() const {
+    return witnessThunkSig;
+  }
+
   /// Retrieve the substitution map that maps the interface types of the
-  /// requirement to the interface types of the synthetic environment.
-  SubstitutionMap getRequirementToSyntheticMap() const {
-    return reqToSyntheticEnvMap;
+  /// requirement to the interface types of the witness thunk signature.
+  SubstitutionMap getRequirementToWitnessThunkSubs() const {
+    return reqToWitnessThunkSigMap;
   }
 };
 
diff --git a/include/swift/AST/Witness.h b/include/swift/AST/Witness.h
@@ -72,7 +72,7 @@ class ValueDecl;
 /// The witness for \c R.foo(x:) is \c X<U, V>.foo(x:), but the generic
 /// functions that describe the generic requirement in \c R and the generic
 /// method in \c X have very different signatures. To handle this case, the
-/// \c Witness class produces a "synthetic" environment that pulls together
+/// \c Witness class produces a witness thunk signature that pulls together
 /// all of the information needed to map from the requirement to the witness.
 /// It is a generic environment that combines the constraints of the
 /// requirement with the constraints from the context of the protocol
@@ -81,19 +81,19 @@ class ValueDecl;
 /// environment are those of the context of the protocol conformance (\c U
 /// and \c V, in the example above) and the innermost generic parameters are
 /// those of the generic requirement (\c T, in the example above). The
-/// \c Witness class contains this synthetic environment (both its generic
+/// \c Witness class contains this witness thunk signature (both its generic
 /// signature and a generic environment providing archetypes), a substitution
 /// map that allows one to map the interface types of the requirement into
-/// the interface types of the synthetic domain, and the set of substitutions
-/// required to use the witness from the synthetic domain (e.g., how one would
+/// the interface types of the witness thunk domain, and the set of substitutions
+/// required to use the witness from the witness thunk domain (e.g., how one would
 /// call the witness from the witness thunk).
 class Witness {
   struct StoredWitness {
     /// The witness declaration, along with the substitutions needed to use
-    /// the witness declaration from the synthetic environment.
+    /// the witness declaration from the witness thunk signature.
     ConcreteDeclRef declRef;
-    GenericEnvironment *syntheticEnvironment;
-    SubstitutionMap reqToSyntheticEnvSubs;
+    GenericSignature witnessThunkSig;
+    SubstitutionMap reqToWitnessThunkSigSubs;
     /// The derivative generic signature, when the requirement is a derivative
     /// function.
     GenericSignature derivativeGenSig;
@@ -124,7 +124,7 @@ class Witness {
 
   /// Create a witness for the given requirement.
   ///
-  /// Deserialized witnesses do not have a synthetic environment.
+  /// Deserialized witnesses do not have a witness thunk signature.
   static Witness forDeserialized(ValueDecl *decl,
                                  SubstitutionMap substitutions,
                                  Optional<ActorIsolation> enterIsolation) {
@@ -139,12 +139,12 @@ class Witness {
   /// \param decl The declaration for the witness.
   ///
   /// \param substitutions The substitutions required to use the witness from
-  /// the synthetic environment.
+  /// the witness thunk signature.
   ///
-  /// \param syntheticEnv The synthetic environment.
+  /// \param witnessThunkSig The witness thunk signature.
   ///
-  /// \param reqToSyntheticEnvSubs The mapping from the interface types of the
-  /// requirement into the interface types of the synthetic environment.
+  /// \param reqToWitnessThunkSigSubs The mapping from the interface types of the
+  /// requirement into the interface types of the witness thunk signature.
   ///
   /// \param derivativeGenSig The derivative generic signature, when the
   /// requirement is a derivative function.
@@ -153,13 +153,13 @@ class Witness {
   /// need to hop to before calling the witness.
   Witness(ValueDecl *decl,
           SubstitutionMap substitutions,
-          GenericEnvironment *syntheticEnv,
-          SubstitutionMap reqToSyntheticEnvSubs,
+          GenericSignature witnessThunkSig,
+          SubstitutionMap reqToWitnessThunkSigSubs,
           GenericSignature derivativeGenSig,
           Optional<ActorIsolation> enterIsolation);
 
   /// Retrieve the witness declaration reference, which includes the
-  /// substitutions needed to use the witness from the synthetic environment
+  /// substitutions needed to use the witness from the witness thunk signature
   /// (if any).
   ConcreteDeclRef getDeclRef() const {
     if (auto stored = storage.dyn_cast<StoredWitness *>())
@@ -175,26 +175,23 @@ class Witness {
   explicit operator bool() const { return !storage.isNull(); }
 
   /// Retrieve the substitutions required to use this witness from the
-  /// synthetic environment.
-  ///
-  /// The substitutions are substitutions for the witness, providing interface
-  /// types from the synthetic environment.
+  /// witness thunk signature.
   SubstitutionMap getSubstitutions() const {
     return getDeclRef().getSubstitutions();
   }
 
-  /// Retrieve the synthetic generic environment.
-  GenericEnvironment *getSyntheticEnvironment() const {
+  /// Retrieve the witness thunk generic signature.
+  GenericSignature getWitnessThunkSignature() const {
     if (auto *storedWitness = storage.dyn_cast<StoredWitness *>())
-      return storedWitness->syntheticEnvironment;
+      return storedWitness->witnessThunkSig;
     return nullptr;
   }
 
   /// Retrieve the substitution map that maps the interface types of the
-  /// requirement to the interface types of the synthetic environment.
-  SubstitutionMap getRequirementToSyntheticSubs() const {
+  /// requirement to the interface types of the witness thunk signature.
+  SubstitutionMap getRequirementToWitnessThunkSubs() const {
     if (auto *storedWitness = storage.dyn_cast<StoredWitness *>())
-      return storedWitness->reqToSyntheticEnvSubs;
+      return storedWitness->reqToWitnessThunkSigSubs;
     return {};
   }
 
diff --git a/lib/AST/ASTVerifier.cpp b/lib/AST/ASTVerifier.cpp
@@ -2716,21 +2716,6 @@ class Verifier : public ASTWalker {
             abort();
           }
 
-          // Check the witness substitutions.
-          const auto &witness = normal->getWitnessUncached(req);
-
-          if (auto *genericEnv = witness.getSyntheticEnvironment())
-            Generics.push_back(genericEnv->getGenericSignature());
-
-          verifyChecked(witness.getRequirementToSyntheticSubs());
-          verifyChecked(witness.getSubstitutions());
-
-          if (auto *genericEnv = witness.getSyntheticEnvironment()) {
-            assert(Generics.back().get<GenericSignature>().getPointer()
-                   == genericEnv->getGenericSignature().getPointer());
-            Generics.pop_back();
-          }
-
           continue;
         }
       }
diff --git a/lib/AST/ProtocolConformance.cpp b/lib/AST/ProtocolConformance.cpp
@@ -42,29 +42,29 @@ STATISTIC(NumConformanceLookupTables, "# of conformance lookup tables built");
 using namespace swift;
 
 Witness::Witness(ValueDecl *decl, SubstitutionMap substitutions,
-                 GenericEnvironment *syntheticEnv,
-                 SubstitutionMap reqToSynthesizedEnvSubs,
+                 GenericSignature witnessThunkSig,
+                 SubstitutionMap reqToWitnessThunkSigSubs,
                  GenericSignature derivativeGenSig,
                  Optional<ActorIsolation> enterIsolation) {
-  if (!syntheticEnv && substitutions.empty() &&
-      reqToSynthesizedEnvSubs.empty() && !enterIsolation) {
+  if (!witnessThunkSig && substitutions.empty() &&
+      reqToWitnessThunkSigSubs.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, witnessThunkSig,
+                                              reqToWitnessThunkSigSubs,
                                               derivativeGenSig, enterIsolation};
 
   storage = stored;
 }
 
 Witness Witness::withEnterIsolation(ActorIsolation enterIsolation) const {
-  return Witness(getDecl(), getSubstitutions(), getSyntheticEnvironment(),
-                 getRequirementToSyntheticSubs(),
+  return Witness(getDecl(), getSubstitutions(), getWitnessThunkSignature(),
+                 getRequirementToWitnessThunkSubs(),
                  getDerivativeGenericSignature(), enterIsolation);
 }
 
@@ -919,13 +919,13 @@ RootProtocolConformance::getWitnessDeclRef(ValueDecl *requirement) const {
     auto *witnessDecl = witness.getDecl();
 
     // If the witness is generic, you have to call getWitness() and build
-    // your own substitutions in terms of the synthetic environment.
+    // your own substitutions in terms of the witness thunk signature.
     if (auto *witnessDC = dyn_cast<DeclContext>(witnessDecl))
       assert(!witnessDC->isInnermostContextGeneric());
 
     // If the witness is not generic, use type substitutions from the
     // witness's parent. Don't use witness.getSubstitutions(), which
-    // are written in terms of the synthetic environment.
+    // are written in terms of the witness thunk signature.
     auto subs =
       getType()->getContextSubstitutionMap(getDeclContext()->getParentModule(),
                                            witnessDecl->getDeclContext());
diff --git a/lib/AST/RequirementEnvironment.cpp b/lib/AST/RequirementEnvironment.cpp
@@ -44,7 +44,7 @@ RequirementEnvironment::RequirementEnvironment(
   auto conformanceSig = conformanceDC->getGenericSignatureOfContext();
 
   // This is a substitution function from the generic parameters of the
-  // conforming type to the synthetic environment.
+  // conforming type to the witness thunk environment.
   //
   // For structs, enums and protocols, this is a 1:1 mapping; for classes,
   // we increase the depth of each generic parameter by 1 so that we can
@@ -53,7 +53,7 @@ RequirementEnvironment::RequirementEnvironment(
   // This is a raw function rather than a substitution map because we need to
   // keep generic parameters as generic, even if the conformanceSig (the best
   // way to create the substitution map) equates them to concrete types.
-  auto conformanceToSyntheticTypeFn = [&](SubstitutableType *type) {
+  auto conformanceToWitnessThunkTypeFn = [&](SubstitutableType *type) {
     auto *genericParam = cast<GenericTypeParamType>(type);
     if (covariantSelf) {
       return GenericTypeParamType::get(genericParam->isTypeSequence(),
@@ -65,14 +65,14 @@ RequirementEnvironment::RequirementEnvironment(
                                      genericParam->getDepth(),
                                      genericParam->getIndex(), ctx);
   };
-  auto conformanceToSyntheticConformanceFn =
+  auto conformanceToWitnessThunkConformanceFn =
       MakeAbstractConformanceForGenericType();
 
   auto substConcreteType = concreteType.subst(
-      conformanceToSyntheticTypeFn, conformanceToSyntheticConformanceFn);
+      conformanceToWitnessThunkTypeFn, conformanceToWitnessThunkConformanceFn);
 
   // Calculate the depth at which the requirement's generic parameters
-  // appear in the synthetic signature.
+  // appear in the witness thunk signature.
   unsigned depth = 0;
   if (covariantSelf) {
     ++depth;
@@ -88,7 +88,7 @@ RequirementEnvironment::RequirementEnvironment(
   auto selfType = cast<GenericTypeParamType>(
       proto->getSelfInterfaceType()->getCanonicalType());
 
-  reqToSyntheticEnvMap = SubstitutionMap::get(reqSig,
+  reqToWitnessThunkSigMap = SubstitutionMap::get(reqSig,
     [selfType, substConcreteType, depth, covariantSelf, &ctx]
     (SubstitutableType *type) -> Type {
       // If the conforming type is a class, the protocol 'Self' maps to
@@ -136,15 +136,13 @@ RequirementEnvironment::RequirementEnvironment(
       return ProtocolConformanceRef(proto);
     });
 
-  // If the requirement itself is non-generic, the synthetic signature
+  // If the requirement itself is non-generic, the witness thunk signature
   // is that of the conformance context.
   if (!covariantSelf &&
       reqSig.getGenericParams().size() == 1 &&
       reqSig.getRequirements().size() == 1) {
-    syntheticSignature = conformanceDC->getGenericSignatureOfContext().getCanonicalSignature();
-    syntheticEnvironment =
-      syntheticSignature.getGenericEnvironment();
-
+    witnessThunkSig = conformanceDC->getGenericSignatureOfContext()
+        .getCanonicalSignature();
     return;
   }
 
@@ -164,8 +162,8 @@ RequirementEnvironment::RequirementEnvironment(
   // Now, add all generic parameters from the conforming type.
   if (conformanceSig) {
     for (auto param : conformanceSig.getGenericParams()) {
-      auto substParam = Type(param).subst(conformanceToSyntheticTypeFn,
-                                          conformanceToSyntheticConformanceFn);
+      auto substParam = Type(param).subst(conformanceToWitnessThunkTypeFn,
+                                          conformanceToWitnessThunkConformanceFn);
       genericParamTypes.push_back(substParam->castTo<GenericTypeParamType>());
     }
   }
@@ -181,8 +179,8 @@ RequirementEnvironment::RequirementEnvironment(
 
   if (conformanceSig) {
     for (auto &rawReq : conformanceSig.getRequirements()) {
-      if (auto req = rawReq.subst(conformanceToSyntheticTypeFn,
-                                  conformanceToSyntheticConformanceFn))
+      if (auto req = rawReq.subst(conformanceToWitnessThunkTypeFn,
+                                  conformanceToWitnessThunkConformanceFn))
         requirements.push_back(*req);
     }
   }
@@ -207,13 +205,11 @@ 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(reqToWitnessThunkSigMap))
       requirements.push_back(*req);
   }
 
-  // Produce the generic signature and environment.
-  syntheticSignature = buildGenericSignature(ctx, GenericSignature(),
-                                             std::move(genericParamTypes),
-                                             std::move(requirements));
-  syntheticEnvironment = syntheticSignature.getGenericEnvironment();
+  witnessThunkSig = buildGenericSignature(ctx, GenericSignature(),
+                                          std::move(genericParamTypes),
+                                          std::move(requirements));
 }
diff --git a/lib/SILGen/SILGenType.cpp b/lib/SILGen/SILGenType.cpp
@@ -723,13 +723,11 @@ SILFunction *SILGenModule::emitProtocolWitness(
 
   // Mapping from the requirement's generic signature to the witness
   // thunk's generic signature.
-  auto reqtSubMap = witness.getRequirementToSyntheticSubs();
+  auto reqtSubMap = witness.getRequirementToWitnessThunkSubs();
 
   // The generic environment for the witness thunk.
-  auto *genericEnv = witness.getSyntheticEnvironment();
-  CanGenericSignature genericSig;
-  if (genericEnv)
-    genericSig = genericEnv->getGenericSignature().getCanonicalSignature();
+  auto *genericEnv = witness.getWitnessThunkSignature().getGenericEnvironment();
+  auto genericSig = witness.getWitnessThunkSignature().getCanonicalSignature();
 
   // The type of the witness thunk.
   auto reqtSubstTy = cast<AnyFunctionType>(
diff --git a/lib/Sema/TypeCheckProtocol.cpp b/lib/Sema/TypeCheckProtocol.cpp
