AST: Remove SubstFlags::AllowLoweredTypes

Author: slavapestov

include/swift/AST/Type.h

@@ -117,27 +117,22 @@ class MakeAbstractConformanceForGenericType {
 
 /// Flags that can be passed when substituting into a type.
 enum class SubstFlags {
-  /// Allow substitutions to recurse into SILFunctionTypes. Normally,
-  /// SILType::subst() should be used for lowered types, however in special
-  /// cases where the substitution is just changing between contextual and
-  /// interface type representations, using Type::subst() is allowed.
-  AllowLoweredTypes = 0x01,
   /// Map member types to their desugared witness type.
-  DesugarMemberTypes = 0x02,
+  DesugarMemberTypes = 0x01,
   /// Allow primary archetypes to themselves be the subject of substitution.
   /// Otherwise, we map them out of context first.
-  SubstitutePrimaryArchetypes = 0x04,
+  SubstitutePrimaryArchetypes = 0x02,
   /// Allow opaque archetypes to themselves be the subject of substitution,
   /// used when erasing them to their underlying types. Otherwise, we
   /// recursively substitute their substitutions, instead, preserving the
   /// opaque archetype.
-  SubstituteOpaqueArchetypes = 0x08,
+  SubstituteOpaqueArchetypes = 0x04,
   /// Allow local archetypes to themselves be the subject of substitution.
-  SubstituteLocalArchetypes = 0x10,
+  SubstituteLocalArchetypes = 0x08,
   /// Don't increase pack expansion level for free pack references.
   /// Do not introduce new usages of this flag.
   /// FIXME: Remove this.
-  PreservePackExpansionLevel = 0x20,
+  PreservePackExpansionLevel = 0x10,
 };
 
 /// Options for performing substitutions into a type.

include/swift/AST/Types.h

@@ -4803,8 +4803,7 @@ class SILFunctionConventions;
 
 
 CanType substOpaqueTypesWithUnderlyingTypes(CanType type,
-                                            TypeExpansionContext context,
-                                            bool allowLoweredTypes = false);
+                                            TypeExpansionContext context);
 ProtocolConformanceRef
 substOpaqueTypesWithUnderlyingTypes(ProtocolConformanceRef ref, Type origType,
                                     TypeExpansionContext context);

include/swift/SIL/SILCloner.h

@@ -548,8 +548,7 @@ class SILCloner : protected SILInstructionVisitor<ImplClass> {
         return ty;
 
       // Remap types containing opaque result types in the current context.
-      return substOpaqueTypesWithUnderlyingTypes(ty, context,
-                                                 /*allowLoweredTypes=*/false);
+      return substOpaqueTypesWithUnderlyingTypes(ty, context);
     }
 
     return ty;

lib/AST/ASTMangler.cpp

@@ -699,8 +699,7 @@ static Type getTypeForDWARFMangling(Type t) {
       }
       return t->getCanonicalType();
     },
-    MakeAbstractConformanceForGenericType(),
-    SubstFlags::AllowLoweredTypes);
+    MakeAbstractConformanceForGenericType());
 }
 
 std::string ASTMangler::mangleTypeForDebugger(Type Ty, GenericSignature sig) {

lib/AST/GenericEnvironment.cpp

@@ -377,7 +377,6 @@ Type TypeBase::mapTypeOutOfContext() {
   assert(!hasTypeParameter() && "already have an interface type");
   return Type(this).subst(MapTypeOutOfContext(),
     MakeAbstractConformanceForGenericType(),
-    SubstFlags::AllowLoweredTypes |
     SubstFlags::PreservePackExpansionLevel |
     SubstFlags::SubstitutePrimaryArchetypes);
 }
@@ -580,7 +579,6 @@ Type GenericEnvironment::mapTypeIntoContext(
 
   Type result = type.subst(QueryInterfaceTypeSubstitutions(this),
                            lookupConformance,
-                           SubstFlags::AllowLoweredTypes |
                            SubstFlags::PreservePackExpansionLevel);
   assert((!result->hasTypeParameter() || result->hasError() ||
           getKind() == Kind::Opaque) &&
@@ -717,7 +715,6 @@ GenericEnvironment::mapElementTypeIntoPackContext(Type type) const {
       return archetype->getInterfaceType();
     },
     MakeAbstractConformanceForGenericType(),
-    SubstFlags::AllowLoweredTypes |
     SubstFlags::PreservePackExpansionLevel |
     SubstFlags::SubstitutePrimaryArchetypes |
     SubstFlags::SubstituteLocalArchetypes);

lib/AST/RequirementMachine/RequirementMachineRequests.cpp

@@ -629,7 +629,6 @@ AbstractGenericSignatureRequest::evaluate(
             return Type(type);
           },
           MakeAbstractConformanceForGenericType(),
-          SubstFlags::AllowLoweredTypes |
           SubstFlags::PreservePackExpansionLevel);
       resugaredRequirements.push_back(resugaredReq);
     }

lib/AST/TypeSubstitution.cpp

@@ -523,13 +523,6 @@ class TypeSubstituter : public TypeTransform<TypeSubstituter> {
 
 std::optional<Type>
 TypeSubstituter::transform(TypeBase *type, TypePosition position) {
-  // FIXME: Add SIL versions of mapTypeIntoContext() and
-  // mapTypeOutOfContext() and use them appropriately
-  assert((IFS.getOptions().contains(SubstFlags::AllowLoweredTypes) ||
-          !isa<SILFunctionType>(type)) &&
-         "should not be doing AST type-substitution on a lowered SIL type;"
-         "use SILType::subst");
-
   return std::nullopt;
 }
 
@@ -1308,8 +1301,7 @@ operator()(SubstitutableType *maybeOpaqueType) const {
 }
 
 CanType swift::substOpaqueTypesWithUnderlyingTypes(CanType ty,
-                                                   TypeExpansionContext context,
-                                                   bool allowLoweredTypes) {
+                                                   TypeExpansionContext context) {
   if (!context.shouldLookThroughOpaqueTypeArchetypes() ||
       !ty->hasOpaqueArchetype())
     return ty;
@@ -1319,8 +1311,6 @@ CanType swift::substOpaqueTypesWithUnderlyingTypes(CanType ty,
       context.isWholeModuleContext());
   SubstOptions flags = (SubstFlags::SubstituteOpaqueArchetypes |
                         SubstFlags::PreservePackExpansionLevel);
-  if (allowLoweredTypes)
-    flags |= SubstFlags::AllowLoweredTypes;
   return ty.subst(replacer, replacer, flags)->getCanonicalType();
 }
 

lib/IRGen/GenType.cpp

@@ -2015,7 +2015,6 @@ CanType TypeConverter::getExemplarType(CanType contextTy) {
         return type;
       },
       MakeAbstractConformanceForGenericType(),
-      SubstFlags::AllowLoweredTypes |
       SubstFlags::PreservePackExpansionLevel |
       SubstFlags::SubstitutePrimaryArchetypes);
     return CanType(exemplified);

lib/IRGen/MetadataRequest.cpp

@@ -531,8 +531,7 @@ CanType IRGenModule::substOpaqueTypesWithUnderlyingTypes(CanType type) {
   // assume are constant.
   if (type->hasOpaqueArchetype()) {
     auto context = getMaximalTypeExpansionContext();
-    return swift::substOpaqueTypesWithUnderlyingTypes(type, context,
-                                                      /*allowLoweredTypes=*/false);
+    return swift::substOpaqueTypesWithUnderlyingTypes(type, context);
   }
 
   return type;
@@ -545,8 +544,7 @@ SILType IRGenModule::substOpaqueTypesWithUnderlyingTypes(
   if (type.getASTType()->hasOpaqueArchetype()) {
     auto context = getMaximalTypeExpansionContext();
     return SILType::getPrimitiveType(
-      swift::substOpaqueTypesWithUnderlyingTypes(type.getASTType(), context,
-                                                 /*allowLoweredTypes=*/true),
+      swift::substOpaqueTypesWithUnderlyingTypes(type.getASTType(), context),
       type.getCategory());
   }
 
@@ -561,8 +559,7 @@ IRGenModule::substOpaqueTypesWithUnderlyingTypes(CanType type,
   if (type->hasOpaqueArchetype()) {
     auto context = getMaximalTypeExpansionContext();
     return std::make_pair(
-       swift::substOpaqueTypesWithUnderlyingTypes(type, context,
-                                                  /*allowLoweredTypes=*/false),
+       swift::substOpaqueTypesWithUnderlyingTypes(type, context),
        swift::substOpaqueTypesWithUnderlyingTypes(conformance, type, context));
   }
 

lib/SIL/IR/SILFunction.cpp

@@ -504,7 +504,6 @@ Type SILFunction::mapTypeIntoContext(Type type) const {
     // environment.
     return type.subst(MapIntoLocalArchetypeContext(GenericEnv, CapturedEnvs),
                       LookUpConformanceInModule(),
-                      SubstFlags::AllowLoweredTypes |
                       SubstFlags::PreservePackExpansionLevel);
   }