[NCGenerics] provide namespace for CanBeInvertible

Author: kavon

include/swift/AST/Decl.h

@@ -3191,12 +3191,14 @@ class TypeDecl : public ValueDecl {
 
   void setInherited(ArrayRef<InheritedEntry> i) { Inherited = i; }
 
-  /// Indicates how "strongly" a TypeDecl will conform to an invertible
-  /// protocol. Supports inequality comparisons and casts to bool.
-  enum CanBeInvertibleResult: unsigned {
-    CBI_Never = 0,            // Never conforms.
-    CBI_Conditionally = 1,    // Conditionally conforms.
-    CBI_Always = 2,           // Always conforms.
+  struct CanBeInvertible {
+    /// Indicates how "strongly" a TypeDecl will conform to an invertible
+    /// protocol. Supports inequality comparisons and casts to bool.
+    enum Result : unsigned {
+      Never = 0,            // Never conforms.
+      Conditionally = 1,    // Conditionally conforms.
+      Always = 2,           // Always conforms.
+    };
   };
 
   /// "Does a conformance for Copyable exist for this type declaration?"
@@ -3207,7 +3209,7 @@ class TypeDecl : public ValueDecl {
   ///
   /// If you need a more precise answer, ask this Decl's corresponding
   /// Type if it `isCopyable` instead of using this.
-  CanBeInvertibleResult canBeCopyable() const;
+  CanBeInvertible::Result canBeCopyable() const;
 
   /// "Does a conformance for Escapable exist for this type declaration?"
   ///
@@ -3217,7 +3219,7 @@ class TypeDecl : public ValueDecl {
   ///
   /// If you need a more precise answer, ask this Decl's corresponding
   /// Type if it `isEscapable` instead of using this.
-  CanBeInvertibleResult canBeEscapable() const;
+  CanBeInvertible::Result canBeEscapable() const;
 
   /// Determine how the given invertible protocol was written on this TypeDecl,
   /// if at all.

lib/AST/Decl.cpp

@@ -4930,16 +4930,16 @@ InverseMarking TypeDecl::getMarking(InvertibleProtocolKind ip) const {
   );
 }
 
-static TypeDecl::CanBeInvertibleResult
+static TypeDecl::CanBeInvertible::Result
 conformanceExists(TypeDecl const *decl, InvertibleProtocolKind ip) {
   auto *proto = decl->getASTContext().getProtocol(getKnownProtocolKind(ip));
   assert(proto);
 
   // Handle protocols specially, without building a GenericSignature.
   if (auto *protoDecl = dyn_cast<ProtocolDecl>(decl))
     return protoDecl->requiresInvertible(ip)
-         ? TypeDecl::CBI_Always
-         : TypeDecl::CBI_Never;
+         ? TypeDecl::CanBeInvertible::Always
+         : TypeDecl::CanBeInvertible::Never;
 
   Type selfTy = decl->getDeclaredInterfaceType();
   assert(selfTy);
@@ -4948,31 +4948,31 @@ conformanceExists(TypeDecl const *decl, InvertibleProtocolKind ip) {
       /*allowMissing=*/false);
 
   if (conformance.isInvalid())
-    return TypeDecl::CBI_Never;
+    return TypeDecl::CanBeInvertible::Never;
 
   if (!conformance.getConditionalRequirements().empty())
-    return TypeDecl::CBI_Conditionally;
+    return TypeDecl::CanBeInvertible::Conditionally;
 
-  return TypeDecl::CBI_Always;
+  return TypeDecl::CanBeInvertible::Always;
 }
 
-TypeDecl::CanBeInvertibleResult TypeDecl::canBeCopyable() const {
+TypeDecl::CanBeInvertible::Result TypeDecl::canBeCopyable() const {
   if (!getASTContext().LangOpts.hasFeature(Feature::NoncopyableGenerics)) {
     auto copyable = getMarking(InvertibleProtocolKind::Copyable);
     return !copyable.getInverse() || bool(copyable.getPositive())
-         ? CBI_Always
-         : CBI_Never;
+         ? CanBeInvertible::Always
+         : CanBeInvertible::Never;
   }
 
   return conformanceExists(this, InvertibleProtocolKind::Copyable);
 }
 
-TypeDecl::CanBeInvertibleResult TypeDecl::canBeEscapable() const {
+TypeDecl::CanBeInvertible::Result TypeDecl::canBeEscapable() const {
   if (!getASTContext().LangOpts.hasFeature(Feature::NoncopyableGenerics)) {
     auto escapable = getMarking(InvertibleProtocolKind::Escapable);
     return !escapable.getInverse() || bool(escapable.getPositive())
-         ? CBI_Always
-         : CBI_Never;
+         ? CanBeInvertible::Always
+         : CanBeInvertible::Never;
   }
 
   return conformanceExists(this, InvertibleProtocolKind::Escapable);

lib/SIL/IR/TypeLowering.cpp

@@ -2429,15 +2429,15 @@ namespace {
       properties =
           applyLifetimeAnnotation(D->getLifetimeAnnotation(), properties);
 
-      if (D->canBeCopyable() != TypeDecl::CBI_Always) {
+      if (D->canBeCopyable() != TypeDecl::CanBeInvertible::Always) {
         properties.setNonTrivial();
         properties.setLexical(IsLexical);
         if (properties.isAddressOnly())
           return handleMoveOnlyAddressOnly(structType, properties);
         return new (TC) MoveOnlyLoadableStructTypeLowering(
             structType, properties, Expansion);
       }
-      if (D->canBeEscapable() != TypeDecl::CBI_Always) {
+      if (D->canBeEscapable() != TypeDecl::CanBeInvertible::Always) {
         properties.setNonTrivial();
       }
       return handleAggregateByProperties<LoadableStructTypeLowering>(structType,
@@ -2526,7 +2526,7 @@ namespace {
       properties =
           applyLifetimeAnnotation(D->getLifetimeAnnotation(), properties);
 
-      if (D->canBeCopyable() != TypeDecl::CBI_Always) {
+      if (D->canBeCopyable() != TypeDecl::CanBeInvertible::Always) {
         properties.setNonTrivial();
         properties.setLexical(IsLexical);
         if (properties.isAddressOnly())
@@ -2535,7 +2535,7 @@ namespace {
             MoveOnlyLoadableEnumTypeLowering(enumType, properties, Expansion);
       }
 
-      assert(D->canBeEscapable() == TypeDecl::CBI_Always
+      assert(D->canBeEscapable() == TypeDecl::CanBeInvertible::Always
              && "missing typelowering case here!");
 
       return handleAggregateByProperties<LoadableEnumTypeLowering>(enumType,

lib/Sema/TypeCheckAttr.cpp

@@ -7319,7 +7319,7 @@ void AttributeChecker::visitStaticExclusiveOnlyAttr(
   // Can only be applied to structs.
   auto structDecl = cast<StructDecl>(D);
 
-  if (structDecl->canBeCopyable() != TypeDecl::CBI_Never) {
+  if (structDecl->canBeCopyable() != TypeDecl::CanBeInvertible::Never) {
     diagnoseAndRemoveAttr(attr, diag::attr_static_exclusive_only_noncopyable);
   }
 }

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -100,10 +100,10 @@ bool swift::isInterfaceTypeNoncopyable(Type type, GenericEnvironment *env) {
 
   // Handle types containing unbound generic parameters.
   if (auto *generic = type->getAnyGeneric())
-    return generic->canBeCopyable() != swift::TypeDecl::CBI_Always;
+    return generic->canBeCopyable() != swift::TypeDecl::CanBeInvertible::Always;
   else if (auto gtpt = type->getAs<GenericTypeParamType>())
     if (auto *gtpd = gtpt->getDecl())
-      return gtpd->canBeCopyable() != swift::TypeDecl::CBI_Always;
+      return gtpd->canBeCopyable() != swift::TypeDecl::CanBeInvertible::Always;
 
   #ifndef NDEBUG
     type->dump();