SIL: Remove SILType::isAddressOnly()/isLoadable() overloads that take a SILModule

Finally we can remove the old overloads.

Author: slavapestov

include/swift/SIL/SILType.h

@@ -252,46 +252,25 @@ class SILType {
 
   /// True if the type, or the referenced type of an address type, is loadable.
   /// This is the opposite of isAddressOnly.
-  bool isLoadable(SILModule &M) const {
-    return !isAddressOnly(M);
-  }
-
-  /// Like isLoadable(SILModule), but specific to a function.
-  ///
-  /// This takes the resilience expansion of the function into account. If the
-  /// type is not loadable in general (because it's resilient), it still might
-  /// be loadable inside a resilient function in the module.
-  /// In other words: isLoadable(SILModule) is the conservative default, whereas
-  /// isLoadable(SILFunction) might give a more optimistic result.
   bool isLoadable(const SILFunction &F) const {
     return !isAddressOnly(F);
   }
 
   /// True if either:
   /// 1) The type, or the referenced type of an address type, is loadable.
   /// 2) The SIL Module conventions uses lowered addresses
-  bool isLoadableOrOpaque(SILModule &M) const;
-
-  /// Like isLoadableOrOpaque(SILModule), but takes the resilience expansion of
-  /// \p F into account (see isLoadable(SILFunction)).
   bool isLoadableOrOpaque(const SILFunction &F) const;
 
   /// True if the type, or the referenced type of an address type, is
   /// address-only. This is the opposite of isLoadable.
-  bool isAddressOnly(SILModule &M) const;
-
-  /// Like isAddressOnly(SILModule), but takes the resilience expansion of
-  /// \p F into account (see isLoadable(SILFunction)).
   bool isAddressOnly(const SILFunction &F) const;
 
   /// True if the type, or the referenced type of an address type, is trivial,
   /// meaning it is loadable and can be trivially copied, moved or detroyed.
   bool isTrivial(const SILFunction &F) const;
 
   /// True if the type, or the referenced type of an address type, is known to
-  /// be a scalar reference-counted type. If this is false, then some part of
-  /// the type may be opaque. It may become reference counted later after
-  /// specialization.
+  /// be a scalar reference-counted type.
   bool isReferenceCounted(SILModule &M) const;
 
   /// Returns true if the referenced type is a function type that never

lib/SIL/SILType.cpp

@@ -175,28 +175,13 @@ SILType SILType::getEnumElementType(EnumElementDecl *elt, SILModule &M) const {
   return SILType(loweredTy, getCategory());
 }
 
-bool SILType::isLoadableOrOpaque(SILModule &M) const {
-  return isLoadable(M) || !SILModuleConventions(M).useLoweredAddresses();
-}
-
 bool SILType::isLoadableOrOpaque(const SILFunction &F) const {
   SILModule &M = F.getModule();
-  return isLoadable(F) ||
-         !SILModuleConventions(M).useLoweredAddresses();
-}
-
-/// True if the type, or the referenced type of an address type, is
-/// address-only. For example, it could be a resilient struct or something of
-/// unknown size.
-bool SILType::isAddressOnly(SILModule &M) const {
-  return M.Types.getTypeLowering(*this, ResilienceExpansion::Minimal)
-    .isAddressOnly();
+  return isLoadable(F) || !SILModuleConventions(M).useLoweredAddresses();
 }
 
 bool SILType::isAddressOnly(const SILFunction &F) const {
-  // FIXME: Should just call F.getTypeLowering()
-  return F.getModule().Types.getTypeLowering(*this,
-                                   F.getResilienceExpansion()).isAddressOnly();
+  return F.getTypeLowering(*this).isAddressOnly();
 }
 
 SILType SILType::substGenericArgs(SILModule &M,