Remove ResilienceExpansion from substOpaqueTypes for now.

It's currently meaningless, and it'll require thought to pass the correct value when it becomes
meaningful.

Author: jckarter

include/swift/AST/ProtocolConformanceRef.h

@@ -111,8 +111,7 @@ class ProtocolConformanceRef {
 
   /// Replace opaque types in the conforming type with their underlying types,
   /// and resolve opaque conformances to their underlying conformances.
-  ProtocolConformanceRef substOpaqueTypesWithUnderlyingTypes(Type origType,
-                                           ResilienceExpansion expansion) const;
+  ProtocolConformanceRef substOpaqueTypesWithUnderlyingTypes(Type origType) const;
 
   /// Given a dependent type (expressed in terms of this conformance's
   /// protocol), follow it from the conforming type.

include/swift/AST/SubstitutionMap.h

@@ -174,8 +174,7 @@ class SubstitutionMap {
 
   /// Replace opaque types in the replacement types in the map with their
   /// underlying types. Does not change keys.
-  SubstitutionMap substOpaqueTypesWithUnderlyingTypes(
-                                           ResilienceExpansion expansion) const;
+  SubstitutionMap substOpaqueTypesWithUnderlyingTypes() const;
 
   /// Create a substitution map for a protocol conformance.
   static SubstitutionMap

include/swift/AST/Type.h

@@ -318,7 +318,7 @@ class Type {
 
   /// Replace opaque types with their underlying types when visible at the given
   /// resilience expansion.
-  Type substOpaqueTypesWithUnderlyingTypes(ResilienceExpansion expansion) const;
+  Type substOpaqueTypesWithUnderlyingTypes() const;
 
   bool isPrivateStdlibType(bool treatNonBuiltinProtocolsAsPublic = true) const;
 

include/swift/AST/Types.h

@@ -4816,11 +4816,8 @@ END_CAN_TYPE_WRAPPER(OpaqueTypeArchetypeType, ArchetypeType)
 /// archetypes with underlying types visible at a given resilience expansion
 /// to their underlying types.
 class ReplaceOpaqueTypesWithUnderlyingTypes {
-  ResilienceExpansion expansion;
-
 public:
-  ReplaceOpaqueTypesWithUnderlyingTypes(ResilienceExpansion expansion)
-    : expansion(expansion) {}
+  ReplaceOpaqueTypesWithUnderlyingTypes() {}
 
   /// TypeSubstitutionFn
   Type operator()(SubstitutableType *maybeOpaqueType) const;

include/swift/SIL/AbstractionPattern.h

@@ -304,7 +304,7 @@ class AbstractionPattern {
       OrigType = origType;
     else
       OrigType = origType
-        .substOpaqueTypesWithUnderlyingTypes(ResilienceExpansion::Minimal)
+        .substOpaqueTypesWithUnderlyingTypes()
         ->getCanonicalType();
     GenericSig = CanGenericSignature();
     if (OrigType->hasTypeParameter())

lib/AST/ASTContext.cpp

@@ -5046,7 +5046,7 @@ CanSILBoxType SILBoxType::get(ASTContext &C,
                               SubstitutionMap Substitutions) {
   // TODO: Support resilient opaque types.
   Substitutions = Substitutions
-    .substOpaqueTypesWithUnderlyingTypes(ResilienceExpansion::Minimal);
+    .substOpaqueTypesWithUnderlyingTypes();
   // Canonicalize substitutions.
   Substitutions = Substitutions.getCanonical();
 

lib/AST/ASTMangler.cpp

@@ -966,7 +966,7 @@ void ASTMangler::appendType(Type type) {
         return appendType(ErrorType::get(opaqueTy->getASTContext()));
       }
       auto underlyingType =
-        type.substOpaqueTypesWithUnderlyingTypes(ResilienceExpansion::Minimal);
+        type.substOpaqueTypesWithUnderlyingTypes();
       assert(!underlyingType->isEqual(type));
       return appendType(underlyingType->getCanonicalType());
     }

lib/AST/ProtocolConformance.cpp

@@ -142,9 +142,8 @@ ProtocolConformanceRef::subst(Type origType,
 }
 
 ProtocolConformanceRef
-ProtocolConformanceRef::substOpaqueTypesWithUnderlyingTypes(Type origType,
-                                          ResilienceExpansion expansion) const {
-  ReplaceOpaqueTypesWithUnderlyingTypes replacer(expansion);
+ProtocolConformanceRef::substOpaqueTypesWithUnderlyingTypes(Type origType) const {
+  ReplaceOpaqueTypesWithUnderlyingTypes replacer;
   return subst(origType, replacer, replacer,
                SubstFlags::SubstituteOpaqueArchetypes);
 }

lib/AST/SubstitutionMap.cpp

@@ -493,9 +493,9 @@ SubstitutionMap SubstitutionMap::subst(TypeSubstitutionFn subs,
 }
 
 SubstitutionMap
-SubstitutionMap::substOpaqueTypesWithUnderlyingTypes(ResilienceExpansion exp)
+SubstitutionMap::substOpaqueTypesWithUnderlyingTypes()
 const {
-  ReplaceOpaqueTypesWithUnderlyingTypes replacer(exp);
+  ReplaceOpaqueTypesWithUnderlyingTypes replacer;
   return subst(replacer, replacer, SubstFlags::SubstituteOpaqueArchetypes);
 }
 

lib/AST/Type.cpp

@@ -2471,7 +2471,7 @@ Type ReplaceOpaqueTypesWithUnderlyingTypes::operator()(
 
   // If the type still contains opaque types, recur.
   if (substTy->hasOpaqueArchetype()) {
-    return substTy.substOpaqueTypesWithUnderlyingTypes(expansion);
+    return substTy.substOpaqueTypesWithUnderlyingTypes();
   }
   return substTy;
 }
@@ -2509,14 +2509,13 @@ ReplaceOpaqueTypesWithUnderlyingTypes::operator()(CanType maybeOpaqueType,
 
   // If the type still contains opaque types, recur.
   if (substTy->hasOpaqueArchetype()) {
-    return substRef.substOpaqueTypesWithUnderlyingTypes(substTy, expansion);
+    return substRef.substOpaqueTypesWithUnderlyingTypes(substTy);
   }
   return substRef;
 }
 
-Type Type::substOpaqueTypesWithUnderlyingTypes(
-                                          ResilienceExpansion expansion) const {
-  ReplaceOpaqueTypesWithUnderlyingTypes replacer(expansion);
+Type Type::substOpaqueTypesWithUnderlyingTypes() const {
+  ReplaceOpaqueTypesWithUnderlyingTypes replacer;
   return subst(replacer, replacer,
                SubstFlags::SubstituteOpaqueArchetypes
                // TODO(opaque): Currently lowered types always get opaque types

lib/IRGen/GenProto.cpp

@@ -1470,12 +1470,11 @@ void WitnessTableBuilder::defineAssociatedTypeWitnessTableAccessFunction(
                                 ProtocolConformanceRef associatedConformance) {
   // Substitute out opaque types.
   auto substAssocType = associatedType
-    .substOpaqueTypesWithUnderlyingTypes(ResilienceExpansion::Minimal)
+    .substOpaqueTypesWithUnderlyingTypes()
     ->getCanonicalType();
   if (substAssocType != associatedType) {
     auto substAssocConformance = associatedConformance
-      .substOpaqueTypesWithUnderlyingTypes(associatedType,
-                                           ResilienceExpansion::Minimal);
+      .substOpaqueTypesWithUnderlyingTypes(associatedType);
 
     associatedType = substAssocType;
     associatedConformance = substAssocConformance;

lib/SIL/SILInstructions.cpp

@@ -2127,10 +2127,10 @@ KeyPathPattern::get(SILModule &M, CanGenericSignature signature,
 
   // TODO: support resilient opaque types
   rootType = rootType
-    .substOpaqueTypesWithUnderlyingTypes(ResilienceExpansion::Minimal)
+    .substOpaqueTypesWithUnderlyingTypes()
     ->getCanonicalType();
   valueType = valueType
-    .substOpaqueTypesWithUnderlyingTypes(ResilienceExpansion::Minimal)
+    .substOpaqueTypesWithUnderlyingTypes()
     ->getCanonicalType();
 
   auto newPattern = KeyPathPattern::create(M, signature, rootType, valueType,

lib/SIL/TypeLowering.cpp

@@ -1495,7 +1495,7 @@ TypeConverter::getTypeLowering(AbstractionPattern origType,
                                Type origSubstType,
                                ResilienceExpansion forExpansion) {
   CanType substType = origSubstType->getCanonicalType()
-    .substOpaqueTypesWithUnderlyingTypes(forExpansion)
+    .substOpaqueTypesWithUnderlyingTypes()
     ->getCanonicalType();
   auto key = getTypeKey(origType, substType);