AST: Replace one-off predicates with SubstitutionMap::getRecursiveProperties()

slavapestov · slavapestov · commit ae77d6f0c166 · 2024-08-21T13:19:10.000-04:00
diff --git a/include/swift/AST/SubstitutionMap.h b/include/swift/AST/SubstitutionMap.h
@@ -34,6 +34,7 @@ namespace swift {
 
 class GenericEnvironment;
 class GenericParamList;
+class RecursiveTypeProperties;
 class SubstitutableType;
 typedef CanTypeWrapper<GenericTypeParamType> CanGenericTypeParamType;
 
@@ -150,19 +151,7 @@ class SubstitutionMap {
   /// parameters.
   ArrayRef<Type> getInnermostReplacementTypes() const;
 
-  /// Query whether any replacement types in the map contain archetypes.
-  bool hasArchetypes() const;
-
-  /// Query whether any replacement types in the map contain an opened
-  /// existential or opened element.
-  bool hasLocalArchetypes() const;
-
-  /// Query whether any replacement types in the map contain an opaque
-  /// return type.
-  bool hasOpaqueArchetypes() const;
-
-  /// Query whether any replacement types in the map contain dynamic Self.
-  bool hasDynamicSelf() const;
+  RecursiveTypeProperties getRecursiveProperties() const;
 
   /// Whether the replacement types are all canonical.
   bool isCanonical() const;
diff --git a/include/swift/AST/Types.h b/include/swift/AST/Types.h
@@ -246,6 +246,11 @@ class RecursiveTypeProperties {
   /// they have a type variable originator.
   bool isSolverAllocated() const { return Bits & SolverAllocated; }
 
+  /// Determine whether the type involves a primary, pack or local archetype.
+  bool hasArchetype() const {
+    return hasPrimaryArchetype() || hasLocalArchetype();
+  }
+
   /// Does a type with these properties structurally contain a local
   /// archetype?
   bool hasLocalArchetype() const {
@@ -720,10 +725,8 @@ class alignas(1 << TypeAlignInBits) TypeBase
   }
 
   /// Determine whether the type involves a primary, pack or local archetype.
-  ///
-  /// FIXME: Replace all remaining callers with a more precise check.
   bool hasArchetype() const {
-    return hasPrimaryArchetype() || hasLocalArchetype();
+    return getRecursiveProperties().hasArchetype();
   }
   
   /// Determine whether the type involves an opened existential archetype.
diff --git a/include/swift/SIL/SILCloner.h b/include/swift/SIL/SILCloner.h
@@ -520,13 +520,13 @@ class SILCloner : protected SILInstructionVisitor<ImplClass> {
 
   SubstitutionMap remapSubstitutionMap(SubstitutionMap Subs) {
     // If we have local archetypes to substitute, do so now.
-    if (Subs.hasLocalArchetypes() || Functor.SubsMap)
+    if (Subs.getRecursiveProperties().hasLocalArchetype() || Functor.SubsMap)
       Subs = Subs.subst(Functor, Functor);
 
     if (asImpl().shouldSubstOpaqueArchetypes()) {
       auto context = getBuilder().getTypeExpansionContext();
 
-      if (!Subs.hasOpaqueArchetypes() ||
+      if (!Subs.getRecursiveProperties().hasOpaqueArchetype() ||
           !context.shouldLookThroughOpaqueTypeArchetypes())
         return Subs;
 
diff --git a/include/swift/SIL/TypeSubstCloner.h b/include/swift/SIL/TypeSubstCloner.h
@@ -366,7 +366,7 @@ class TypeSubstCloner : public SILClonerWithScopes<ImplClass> {
     if (!RemappedSig || !OriginalEnvironment)
       return ParentFunction;
 
-    if (SubsMap.hasArchetypes())
+    if (SubsMap.getRecursiveProperties().hasPrimaryArchetype())
       SubsMap = SubsMap.mapReplacementTypesOutOfContext();
 
     // One abstract function in the debug info can only have one set of variables
@@ -379,7 +379,7 @@ class TypeSubstCloner : public SILClonerWithScopes<ImplClass> {
     // Note that mapReplacementTypesOutOfContext() can't do anything for
     // opened existentials, and since archetypes can't be mangled, ignore
     // this case for now.
-    if (SubsMap.hasArchetypes())
+    if (SubsMap.getRecursiveProperties().hasLocalArchetype())
       return ParentFunction;
 
     // Clone the function with the substituted type for the debug info.
diff --git a/lib/AST/ASTContext.cpp b/lib/AST/ASTContext.cpp
@@ -3322,9 +3322,7 @@ TypeAliasType *TypeAliasType::get(TypeAliasDecl *typealias, Type parent,
   auto properties = underlying->getRecursiveProperties();
   if (parent)
     properties |= parent->getRecursiveProperties();
-
-  for (auto substGP : substitutions.getReplacementTypes())
-    properties |= substGP->getRecursiveProperties();
+  properties |= substitutions.getRecursiveProperties();
 
   // Figure out which arena this type will go into.
   auto &ctx = underlying->getASTContext();
@@ -4936,7 +4934,7 @@ SILFunctionType::SILFunctionType(
     }
 
     if (genericSig && patternSubs) {
-      assert(!patternSubs.hasArchetypes()
+      assert(!patternSubs.getRecursiveProperties().hasArchetype()
              && "pattern substitutions should not contain context archetypes");
     }
   }
@@ -5093,9 +5091,7 @@ CanSILFunctionType SILFunctionType::get(
   }
 
   auto outerSubs = genericSig ? invocationSubs : patternSubs;
-  for (auto replacement : outerSubs.getReplacementTypes()) {
-    properties |= replacement->getRecursiveProperties();
-  }
+  properties |= outerSubs.getRecursiveProperties();
 
   auto fnType =
       new (mem) SILFunctionType(genericSig, ext, coroutineKind, callee,
@@ -5282,15 +5278,9 @@ DependentMemberType *DependentMemberType::get(Type base,
 /// Compute the recursive type properties of an opaque type archetype.
 static RecursiveTypeProperties getOpaqueTypeArchetypeProperties(
     SubstitutionMap subs) {
-  // An opaque type isn't contextually dependent like other archetypes, so
-  // by itself, it doesn't impose the "Has Archetype" recursive property,
-  // but the substituted types might. A disjoint "Has Opaque Archetype" tracks
-  // the presence of opaque archetypes.
   RecursiveTypeProperties properties =
     RecursiveTypeProperties::HasOpaqueArchetype;
-  for (auto type : subs.getReplacementTypes()) {
-    properties |= type->getRecursiveProperties();
-  }
+  properties |= subs.getRecursiveProperties();
   return properties;
 }
 
@@ -5317,17 +5307,11 @@ Type OpaqueTypeArchetypeType::get(
   return env->getOrCreateArchetypeFromInterfaceType(interfaceType);
 }
 
-/// Compute the recursive type properties of an opaque type archetype.
+/// Compute the recursive type properties of an opened existential archetype.
 static RecursiveTypeProperties getOpenedArchetypeProperties(SubstitutionMap subs) {
-  // An opaque type isn't contextually dependent like other archetypes, so
-  // by itself, it doesn't impose the "Has Archetype" recursive property,
-  // but the substituted types might. A disjoint "Has Opaque Archetype" tracks
-  // the presence of opaque archetypes.
   RecursiveTypeProperties properties =
     RecursiveTypeProperties::HasOpenedExistential;
-  for (auto type : subs.getReplacementTypes()) {
-    properties |= type->getRecursiveProperties();
-  }
+  properties |= subs.getRecursiveProperties();
   return properties;
 }
 
diff --git a/lib/AST/SubstitutionMap.cpp b/lib/AST/SubstitutionMap.cpp
@@ -102,36 +102,11 @@ bool SubstitutionMap::hasAnySubstitutableParams() const {
   return !genericSig->areAllParamsConcrete();
 }
 
-bool SubstitutionMap::hasArchetypes() const {
-  for (Type replacementTy : getReplacementTypes()) {
-    if (replacementTy->hasArchetype())
-      return true;
-  }
-  return false;
-}
-
-bool SubstitutionMap::hasLocalArchetypes() const {
-  for (Type replacementTy : getReplacementTypes()) {
-    if (replacementTy->hasLocalArchetype())
-      return true;
-  }
-  return false;
-}
-
-bool SubstitutionMap::hasOpaqueArchetypes() const {
-  for (Type replacementTy : getReplacementTypes()) {
-    if (replacementTy->hasOpaqueArchetype())
-      return true;
-  }
-  return false;
-}
-
-bool SubstitutionMap::hasDynamicSelf() const {
-  for (Type replacementTy : getReplacementTypes()) {
-    if (replacementTy->hasDynamicSelfType())
-      return true;
-  }
-  return false;
+RecursiveTypeProperties SubstitutionMap::getRecursiveProperties() const {
+  RecursiveTypeProperties properties;
+  for (auto replacementTy : getReplacementTypes())
+    properties |= replacementTy->getRecursiveProperties();
+  return properties;
 }
 
 bool SubstitutionMap::isCanonical() const {
diff --git a/lib/SILGen/SILGenExpr.cpp b/lib/SILGen/SILGenExpr.cpp
@@ -4215,11 +4215,12 @@ SILGenModule::emitKeyPathComponentForDecl(SILLocation loc,
     // Map the substitutions out of context.
     if (!subs.empty()) {
       externalSubs = subs;
-      // If any of the substitutions involve local archetypes, then the
+      // If any of the substitutions involve primary archetypes, then the
       // key path pattern needs to capture the generic context, and we need
       // to map the pattern substitutions out of this context.
-      if (externalSubs.hasArchetypes()) {
+      if (externalSubs.getRecursiveProperties().hasArchetype()) {
         needsGenericContext = true;
+        // FIXME: This doesn't do anything for local archetypes!
         externalSubs = externalSubs.mapReplacementTypesOutOfContext();
       }
     }
diff --git a/lib/SILOptimizer/IPO/CapturePropagation.cpp b/lib/SILOptimizer/IPO/CapturePropagation.cpp
@@ -256,7 +256,7 @@ CanSILFunctionType getPartialApplyInterfaceResultType(PartialApplyInst *PAI) {
   // return signature.
   auto FTy = PAI->getType().castTo<SILFunctionType>();
   assert(!PAI->hasSubstitutions() ||
-         !PAI->getSubstitutionMap().hasArchetypes());
+         !PAI->getSubstitutionMap().getRecursiveProperties().hasArchetype());
   FTy = cast<SILFunctionType>(
     FTy->mapTypeOutOfContext()->getCanonicalType());
   auto NewFTy = FTy;
@@ -512,7 +512,8 @@ bool CapturePropagation::optimizePartialApply(PartialApplyInst *PAI) {
   if (SubstF->isExternalDeclaration())
     return false;
 
-  if (PAI->hasSubstitutions() && PAI->getSubstitutionMap().hasArchetypes()) {
+  if (PAI->hasSubstitutions() &&
+      PAI->getSubstitutionMap().getRecursiveProperties().hasArchetype()) {
     LLVM_DEBUG(llvm::dbgs()
                  << "CapturePropagation: cannot handle partial specialization "
                     "of partial_apply:\n";
diff --git a/lib/SILOptimizer/IPO/CrossModuleOptimization.cpp b/lib/SILOptimizer/IPO/CrossModuleOptimization.cpp
@@ -164,7 +164,7 @@ class InstructionVisitor : public SILCloner<InstructionVisitor> {
   }
 
   SubstitutionMap remapSubstitutionMap(SubstitutionMap Subs) {
-    if (Subs.hasLocalArchetypes())
+    if (Subs.getRecursiveProperties().hasLocalArchetype())
       Subs = Subs.subst(Functor, Functor);
 
     CMS.makeSubstUsableFromInline(Subs);
diff --git a/lib/SILOptimizer/IPO/UsePrespecialized.cpp b/lib/SILOptimizer/IPO/UsePrespecialized.cpp
@@ -85,10 +85,12 @@ bool UsePrespecialized::replaceByPrespecialized(SILFunction &F) {
 
     SubstitutionMap Subs = AI.getSubstitutionMap();
 
-    // Bail if any generic type parameters are unbound.
+    // Bail if the replacement types depend on the callee's generic
+    // environment.
+    //
     // TODO: Remove this limitation once public partial specializations
     // are supported and can be provided by other modules.
-    if (Subs.hasArchetypes())
+    if (Subs.getRecursiveProperties().hasArchetype())
       continue;
 
     ReabstractionInfo ReInfo(M.getSwiftModule(), M.isWholeModule(), AI,
diff --git a/lib/SILOptimizer/Transforms/PerformanceInliner.cpp b/lib/SILOptimizer/Transforms/PerformanceInliner.cpp
@@ -858,7 +858,7 @@ static std::optional<bool> shouldInlineGeneric(FullApplySite AI,
   // If all substitutions are concrete, then there is no need to perform the
   // generic inlining. Let the generic specializer create a specialized
   // function and then decide if it is beneficial to inline it.
-  if (!AI.getSubstitutionMap().hasArchetypes())
+  if (!AI.getSubstitutionMap().getRecursiveProperties().hasArchetype())
     return false;
 
   if (Callee->getLoweredFunctionType()->getCoroutineKind() !=
diff --git a/lib/SILOptimizer/Utils/Generics.cpp b/lib/SILOptimizer/Utils/Generics.cpp
@@ -473,16 +473,18 @@ bool ReabstractionInfo::prepareAndCheck(ApplySite Apply, SILFunction *Callee,
   // Get the original substitution map.
   CalleeParamSubMap = ParamSubs;
 
+  auto Props = CalleeParamSubMap.getRecursiveProperties();
+
   using namespace OptRemark;
   // We do not support partial specialization.
-  if (!EnablePartialSpecialization && CalleeParamSubMap.hasArchetypes()) {
+  if (!EnablePartialSpecialization && Props.hasArchetype()) {
     LLVM_DEBUG(llvm::dbgs() <<"    Partial specialization is not supported.\n");
     LLVM_DEBUG(ParamSubs.dump(llvm::dbgs()));
     return false;
   }
 
   // Perform some checks to see if we need to bail.
-  if (CalleeParamSubMap.hasDynamicSelf()) {
+  if (Props.hasDynamicSelf()) {
     REMARK_OR_DEBUG(ORE, [&]() {
       return RemarkMissed("DynamicSelf", *Apply.getInstruction())
              << IndentDebug(4) << "Cannot specialize with dynamic self";
@@ -709,11 +711,11 @@ bool ReabstractionInfo::canBeSpecialized() const {
 }
 
 bool ReabstractionInfo::isFullSpecialization() const {
-  return !getCalleeParamSubstitutionMap().hasArchetypes();
+  return !getCalleeParamSubstitutionMap().getRecursiveProperties().hasArchetype();
 }
 
 bool ReabstractionInfo::isPartialSpecialization() const {
-  return getCalleeParamSubstitutionMap().hasArchetypes();
+  return getCalleeParamSubstitutionMap().getRecursiveProperties().hasArchetype();
 }
 
 void ReabstractionInfo::createSubstitutedAndSpecializedTypes() {
@@ -2819,7 +2821,7 @@ static bool createPrespecialized(StringRef UnspecializedName,
 /// @_semantics("prespecialize.X") attributes.
 static bool createPrespecializations(ApplySite Apply, SILFunction *ProxyFunc,
                                      SILOptFunctionBuilder &FuncBuilder) {
-  if (Apply.getSubstitutionMap().hasArchetypes())
+  if (Apply.getSubstitutionMap().getRecursiveProperties().hasArchetype())
     return false;
 
   SILModule &M = FuncBuilder.getModule();
diff --git a/lib/Sema/CodeSynthesis.cpp b/lib/Sema/CodeSynthesis.cpp
@@ -768,7 +768,7 @@ createDesignatedInitOverride(ClassDecl *classDecl,
   auto genericSig = ctx.getOverrideGenericSignature(
       superclassDecl, classDecl, superclassCtorSig, genericParams);
 
-  assert(!subMap.hasArchetypes());
+  assert(!subMap.getRecursiveProperties().hasArchetype());
 
   if (superclassCtorSig) {
     auto *genericEnv = genericSig.getGenericEnvironment();
diff --git a/lib/Sema/MiscDiagnostics.cpp b/lib/Sema/MiscDiagnostics.cpp
@@ -3693,7 +3693,7 @@ class OpaqueUnderlyingTypeChecker : public ASTWalker {
         return Action::Stop();
       }
 
-      if (subMap.hasDynamicSelf()) {
+      if (subMap.getRecursiveProperties().hasDynamicSelf()) {
         Ctx.Diags.diagnose(E->getLoc(),
                            diag::opaque_type_cannot_contain_dynamic_self);
         HasInvalidReturn = true;
diff --git a/lib/Serialization/Serialization.cpp b/lib/Serialization/Serialization.cpp
@@ -1800,9 +1800,9 @@ void Serializer::writeLocalNormalProtocolConformance(
       // Map archetypes to type parameters, since we always substitute them
       // away. Note that in a merge-modules pass, we're serializing conformances
       // that we deserialized, so they will already have their replacement types
-      // in terms of interface types; hence the hasArchetypes() check is
+      // in terms of interface types; hence the hasPrimaryArchetype() check is
       // necessary for correctness, not just as a fast path.
-      if (subs.hasArchetypes())
+      if (subs.getRecursiveProperties().hasPrimaryArchetype())
         subs = subs.mapReplacementTypesOutOfContext();
 
       data.push_back(addSubstitutionMapRef(subs));

Original file line number	Diff line number	Diff line change
`@@ -164,7 +164,7 @@ class InstructionVisitor : public SILCloner<InstructionVisitor> {`
`164`	`164`	`}`
`165`	`165`
`166`	`166`	`SubstitutionMap remapSubstitutionMap(SubstitutionMap Subs) {`
`167`		`- if (Subs.hasLocalArchetypes())`
	`167`	`+ if (Subs.getRecursiveProperties().hasLocalArchetype())`
`168`	`168`	`Subs = Subs.subst(Functor, Functor);`
`169`	`169`
`170`	`170`	`CMS.makeSubstUsableFromInline(Subs);`