[AST] Remove TypeDecl::hasInverse and move canBe{Copyable, Escapable} to NominalTypeDecl`

Author: xedin

include/swift/AST/Decl.h

@@ -3215,32 +3215,6 @@ class TypeDecl : public ValueDecl {
     };
   };
 
-  /// "Does a conformance for Copyable exist for this type declaration?"
-  ///
-  /// This doesn't mean that all instance of this type are Copyable, because
-  /// if a conditional conformance to Copyable exists, this method will return
-  /// true.
-  ///
-  /// If you need a more precise answer, ask this Decl's corresponding
-  /// Type if it `isCopyable` instead of using this.
-  CanBeInvertible::Result canBeCopyable() const;
-
-  /// "Does a conformance for Escapable exist for this type declaration?"
-  ///
-  /// This doesn't mean that all instance of this type are Escapable, because
-  /// if a conditional conformance to Escapable exists, this method will return
-  /// true.
-  ///
-  /// If you need a more precise answer, ask this Decl's corresponding
-  /// Type if it `isEscapable` instead of using this.
-  CanBeInvertible::Result canBeEscapable() const;
-
-  InverseMarking::Mark hasInverseMarking(InvertibleProtocolKind target) const;
-
-  /// Determine how the given invertible protocol was written on this TypeDecl,
-  /// if at all.
-  InverseMarking getMarking(InvertibleProtocolKind ip) const;
-
   static bool classof(const Decl *D) {
     return D->getKind() >= DeclKind::First_TypeDecl &&
            D->getKind() <= DeclKind::Last_TypeDecl;
@@ -3258,7 +3232,7 @@ class TypeDecl : public ValueDecl {
   }
 };
 
-/// A type declaration that can have generic parameters attached to it. Because
+/// A type declaration that  have generic parameters attached to it. Because
 /// it has these generic parameters, it is always a DeclContext.
 class GenericTypeDecl : public GenericContext, public TypeDecl {
 public:
@@ -4374,6 +4348,26 @@ class NominalTypeDecl : public GenericTypeDecl, public IterableDeclContext {
   /// Returns null if the type is a class, or does not have a declared `deinit`.
   DestructorDecl *getValueTypeDestructor();
 
+  /// "Does a conformance for Copyable exist for this type declaration?"
+  ///
+  /// This doesn't mean that all instance of this type are Copyable, because
+  /// if a conditional conformance to Copyable exists, this method will return
+  /// true.
+  ///
+  /// If you need a more precise answer, ask this Decl's corresponding
+  /// Type if it `isCopyable` instead of using this.
+  CanBeInvertible::Result canBeCopyable() const;
+
+  /// "Does a conformance for Escapable exist for this type declaration?"
+  ///
+  /// This doesn't mean that all instance of this type are Escapable, because
+  /// if a conditional conformance to Escapable exists, this method will return
+  /// true.
+  ///
+  /// If you need a more precise answer, ask this Decl's corresponding
+  /// Type if it `isEscapable` instead of using this.
+  CanBeInvertible::Result canBeEscapable() const;
+
   /// Determine whether this type has `: <target>` stated explicitly in
   /// its inheritance clause.
   bool hasMarking(InvertibleProtocolKind target) const;

lib/AST/Decl.cpp

@@ -4901,14 +4901,6 @@ GenericParameterReferenceInfo ValueDecl::findExistentialSelfReferences(
                                         llvm::None);
 }
 
-InverseMarking::Mark
-TypeDecl::hasInverseMarking(InvertibleProtocolKind target) const {
-  if (auto NTD = dyn_cast<NominalTypeDecl>(this))
-    return NTD->hasInverseMarking(target);
-
-  return InverseMarking::Mark(InverseMarking::Kind::None);
-}
-
 static TypeDecl::CanBeInvertible::Result
 conformanceExists(TypeDecl const *decl, InvertibleProtocolKind ip) {
   auto *proto = decl->getASTContext().getProtocol(getKnownProtocolKind(ip));
@@ -4935,7 +4927,7 @@ conformanceExists(TypeDecl const *decl, InvertibleProtocolKind ip) {
   return TypeDecl::CanBeInvertible::Always;
 }
 
-TypeDecl::CanBeInvertible::Result TypeDecl::canBeCopyable() const {
+TypeDecl::CanBeInvertible::Result NominalTypeDecl::canBeCopyable() const {
   if (!getASTContext().LangOpts.hasFeature(Feature::NoncopyableGenerics)) {
     return !hasInverseMarking(InvertibleProtocolKind::Copyable)
                ? CanBeInvertible::Always
@@ -4945,7 +4937,7 @@ TypeDecl::CanBeInvertible::Result TypeDecl::canBeCopyable() const {
   return conformanceExists(this, InvertibleProtocolKind::Copyable);
 }
 
-TypeDecl::CanBeInvertible::Result TypeDecl::canBeEscapable() const {
+TypeDecl::CanBeInvertible::Result NominalTypeDecl::canBeEscapable() const {
   if (!getASTContext().LangOpts.hasFeature(Feature::NoncopyableGenerics)) {
     return !hasInverseMarking(InvertibleProtocolKind::Escapable)
                ? CanBeInvertible::Always

lib/IRGen/GenDecl.cpp

@@ -1067,7 +1067,8 @@ void IRGenModule::addObjCClassStub(llvm::Constant *classPtr) {
 
 void IRGenModule::addRuntimeResolvableType(GenericTypeDecl *type) {
   // Collect the nominal type records we emit into a special section.
-  if (!type->canBeCopyable()) {
+  if (isa<NominalTypeDecl>(type) &&
+      !cast<NominalTypeDecl>(type)->canBeCopyable()) {
     // Older runtimes should not be allowed to discover noncopyable types, since
     // they will try to expose them dynamically as copyable types. Record
     // noncopyable type descriptors in a separate vector so that future