[Sema] factor out the StorageVisitor pattern

This visitor is generally useful for other kinds of marker protocols
like `Copyable` that require structural checking over the storage of the
struct or enum.

Author: kavon

lib/AST/Decl.cpp

@@ -4836,6 +4836,9 @@ GenericParameterReferenceInfo ValueDecl::findExistentialSelfReferences(
 }
 
 bool TypeDecl::isNoncopyable() const {
+  assert(!getASTContext().LangOpts.hasFeature(Feature::NoncopyableGenerics)
+  && "TypeDecl::isNoncopyable() is not compatible with NoncopyableGenerics");
+
   return evaluateOrDefault(getASTContext().evaluator,
                            IsNoncopyableRequest{const_cast<TypeDecl *>(this)},
                            true); // default to true for safety

lib/AST/Type.cpp

@@ -158,7 +158,9 @@ bool TypeBase::isMarkerExistential() {
 }
 
 bool TypeBase::isNoncopyable() {
-  // FIXME: we need to support the full spectrum of TypeDecls here.
+  assert(!getASTContext().LangOpts.hasFeature(Feature::NoncopyableGenerics)
+  && "TypeBase::isNoncopyable() is not compatible with NoncopyableGenerics");
+
   if (auto *nom = getAnyNominal())
     return nom->isNoncopyable();
 

lib/Sema/MiscDiagnostics.cpp

@@ -6248,6 +6248,10 @@ bool swift::diagnoseUnhandledThrowsInAsyncContext(DeclContext *dc,
 
 void swift::diagnoseCopyableTypeContainingMoveOnlyType(
     NominalTypeDecl *copyableNominalType) {
+  auto &ctx = copyableNominalType->getASTContext();
+  if (ctx.LangOpts.hasFeature(Feature::NoncopyableGenerics))
+    return; // taken care of in conformance checking
+
   // If we already have a move only type, just bail, we have no further work to
   // do.
   if (copyableNominalType->isNoncopyable())

lib/Sema/TypeCheckConcurrency.cpp

@@ -15,6 +15,7 @@
 //===----------------------------------------------------------------------===//
 #include "TypeCheckConcurrency.h"
 #include "TypeCheckDistributed.h"
+#include "TypeCheckInvertible.h"
 #include "TypeChecker.h"
 #include "TypeCheckType.h"
 #include "swift/Strings.h"
@@ -1113,10 +1114,6 @@ void swift::diagnoseMissingSendableConformance(
 }
 
 namespace {
-  template<typename Visitor>
-  bool visitInstanceStorage(
-      NominalTypeDecl *nominal, DeclContext *dc, Visitor &visitor);
-
   /// Infer Sendable from the instance storage of the given nominal type.
   /// \returns \c llvm::None if there is no way to make the type \c Sendable,
   /// \c true if \c Sendable needs to be @unchecked, \c false if it can be
@@ -1131,20 +1128,22 @@ namespace {
       }
     }
 
-    struct Visitor {
+    class Visitor: public StorageVisitor {
+    public:
       NominalTypeDecl *nominal;
       SmallVectorImpl<Requirement> &requirements;
       bool isUnchecked = false;
       ProtocolDecl *sendableProto = nullptr;
 
       Visitor(
           NominalTypeDecl *nominal, SmallVectorImpl<Requirement> &requirements
-      ) : nominal(nominal), requirements(requirements) {
+      ) : StorageVisitor(),
+        nominal(nominal), requirements(requirements) {
         ASTContext &ctx = nominal->getASTContext();
         sendableProto = ctx.getProtocol(KnownProtocolKind::Sendable);
       }
 
-      bool operator()(VarDecl *var, Type propertyType) {
+      bool operator()(VarDecl *var, Type propertyType) override {
         // If we have a class with mutable state, only an @unchecked
         // conformance will work.
         if (isa<ClassDecl>(nominal) && var->supportsMutation())
@@ -1153,7 +1152,7 @@ namespace {
         return checkType(propertyType);
       }
 
-      bool operator()(EnumElementDecl *element, Type elementType) {
+      bool operator()(EnumElementDecl *element, Type elementType) override {
         return checkType(elementType);
       }
 
@@ -1195,7 +1194,7 @@ namespace {
       }
     } visitor(nominal, requirements);
 
-    return visitInstanceStorage(nominal, nominal, visitor);
+    return visitor.visit(nominal, nominal);
   }
 }
 
@@ -4823,53 +4822,6 @@ bool swift::contextRequiresStrictConcurrencyChecking(
   return false;
 }
 
-namespace {
-  /// Visit the instance storage of the given nominal type as seen through
-  /// the given declaration context.
-  ///
-  /// \param visitor Called with each (stored property, property type) pair
-  /// for classes/structs and with each (enum element, associated value type)
-  /// pair for enums.
-  ///
-  /// \returns \c true if any call to the \c visitor returns \c true, and
-  /// \c false otherwise.
-  template<typename Visitor>
-  bool visitInstanceStorage(
-      NominalTypeDecl *nominal, DeclContext *dc, Visitor &visitor) {
-    // Walk the stored properties of classes and structs.
-    if (isa<StructDecl>(nominal) || isa<ClassDecl>(nominal)) {
-      for (auto property : nominal->getStoredProperties()) {
-        auto propertyType = dc->mapTypeIntoContext(property->getInterfaceType())
-            ->getRValueType()->getReferenceStorageReferent();
-        if (visitor(property, propertyType))
-          return true;
-      }
-
-      return false;
-    }
-
-    // Walk the enum elements that have associated values.
-    if (auto enumDecl = dyn_cast<EnumDecl>(nominal)) {
-      for (auto caseDecl : enumDecl->getAllCases()) {
-        for (auto element : caseDecl->getElements()) {
-          if (!element->hasAssociatedValues())
-            continue;
-
-          // Check that the associated value type is Sendable.
-          auto elementType = dc->mapTypeIntoContext(
-              element->getArgumentInterfaceType());
-          if (visitor(element, elementType))
-            return true;
-        }
-      }
-
-      return false;
-    }
-
-    return false;
-  }
-}
-
 /// Check the instance storage of the given nominal type to verify whether
 /// it is comprised only of Sendable instance storage.
 static bool checkSendableInstanceStorage(
@@ -4891,19 +4843,20 @@ static bool checkSendableInstanceStorage(
 
   // Stored properties of structs and classes must have
   // Sendable-conforming types.
-  struct Visitor {
+  class Visitor: public StorageVisitor {
+  public:
     bool invalid = false;
     NominalTypeDecl *nominal;
     DeclContext *dc;
     SendableCheck check;
     const LangOptions &langOpts;
 
     Visitor(NominalTypeDecl *nominal, DeclContext *dc, SendableCheck check)
-      : nominal(nominal), dc(dc), check(check),
+      : StorageVisitor(), nominal(nominal), dc(dc), check(check),
         langOpts(nominal->getASTContext().LangOpts) { }
 
     /// Handle a stored property.
-    bool operator()(VarDecl *property, Type propertyType) {
+    bool operator()(VarDecl *property, Type propertyType) override {
       // Classes with mutable properties are not Sendable.
       if (property->supportsMutation() && isa<ClassDecl>(nominal)) {
         if (isImplicitSendableCheck(check)) {
@@ -4958,7 +4911,7 @@ static bool checkSendableInstanceStorage(
     }
 
     /// Handle an enum associated value.
-    bool operator()(EnumElementDecl *element, Type elementType) {
+    bool operator()(EnumElementDecl *element, Type elementType) override {
       diagnoseNonSendableTypes(
           elementType, SendableCheckContext(dc, check), element->getLoc(),
           [&](Type type, DiagnosticBehavior behavior) {
@@ -4993,7 +4946,7 @@ static bool checkSendableInstanceStorage(
     }
   } visitor(nominal, dc, check);
 
-  return visitInstanceStorage(nominal, dc, visitor) || visitor.invalid;
+  return visitor.visit(nominal, dc) || visitor.invalid;
 }
 
 bool swift::checkSendableConformance(

lib/Sema/TypeCheckInvertible.cpp

@@ -23,26 +23,42 @@
 
 namespace swift {
 
-//static bool hasConformanceRequirement(ArrayRef<Requirement> reqs,
-//                                      KnownProtocolKind query) {
-//  for (auto req : reqs) {
-//    if (req.getKind() == RequirementKind::Conformance)
-//      if (auto kp = req.getSecondType()->getKnownProtocol())
-//        if (*kp == query)
-//          return true;
-//  }
-//  return false;
-//}
-
-//static const GenericContext *findGenericContext(DeclContext *dc) {
-//  do {
-//    if (auto decl = dc->getAsDecl())
-//      if (auto GC = decl->getAsGenericContext())
-//        return GC;
-//  } while ((dc = dc->getParent()));
-//
-//  return nullptr;
-//}
+
+/// Visit the instance storage of the given nominal type as seen through
+/// the given declaration context.
+bool StorageVisitor::visit(NominalTypeDecl *nominal, DeclContext *dc) {
+  // Walk the stored properties of classes and structs.
+  if (isa<StructDecl>(nominal) || isa<ClassDecl>(nominal)) {
+    for (auto property : nominal->getStoredProperties()) {
+      auto propertyType = dc->mapTypeIntoContext(property->getInterfaceType())
+          ->getRValueType()->getReferenceStorageReferent();
+      if ((*this)(property, propertyType))
+        return true;
+    }
+
+    return false;
+  }
+
+  // Walk the enum elements that have associated values.
+  if (auto enumDecl = dyn_cast<EnumDecl>(nominal)) {
+    for (auto caseDecl : enumDecl->getAllCases()) {
+      for (auto element : caseDecl->getElements()) {
+        if (!element->hasAssociatedValues())
+          continue;
+
+        // Check that the associated value type is Sendable.
+        auto elementType = dc->mapTypeIntoContext(
+            element->getArgumentInterfaceType());
+        if ((*this)(element, elementType))
+          return true;
+      }
+    }
+
+    return false;
+  }
+
+  return false;
+}
 
 bool canBeNoncopyable(Type type) {
   auto &ctx = type->getASTContext();
@@ -75,6 +91,29 @@ bool isCopyable(Type type, DeclContext *dc) {
                                               module, false);
 }
 
+/// \returns true iff the given nominal meets the requirements of Copyable>
+bool checkCopyableConformance(Evaluator &evaluator,
+                              NominalTypeDecl *nom) {
+  // All classes can store noncopyable values.
+  if (isa<ClassDecl>(nom))
+    return true;
+
+  // Protocols do not directly define any storage.
+  if (isa<ProtocolDecl>(nom))
+    return true;
+
+  if (isa<BuiltinTupleDecl>(nom))
+    llvm_unreachable("unexpected BuiltinTupleDecl");
+
+  if (auto strct = dyn_cast<StructDecl>(nom)) {
+    for (auto stored : strct->getStoredProperties()) {
+//      stored->getInterfaceType()
+//      ImplicitKnownProtocolConformanceRequest
+    }
+  }
+
+}
+
 ProtocolConformance *deriveConformanceForInvertible(Evaluator &evaluator,
                                                     NominalTypeDecl *nominal,
                                                     KnownProtocolKind kp) {
@@ -86,6 +125,10 @@ ProtocolConformance *deriveConformanceForInvertible(Evaluator &evaluator,
     if (evaluateOrDefault(evaluator, IsNoncopyableRequest{nominal}, false))
       return nullptr; // it's not Copyable.
 
+    // Otherwise, verify Copyable conformance.
+
+
+
     // form a full unconditional conformance to Copyable.
     auto conformance = ctx.getNormalConformance(
         nominal->getDeclaredInterfaceType(), proto, nominal->getLoc(),

lib/Sema/TypeCheckInvertible.h

@@ -6,6 +6,29 @@
 
 namespace swift {
 
+class StorageVisitor {
+public:
+  /// Visit the instance storage of the given nominal type as seen through
+  /// the given declaration context.
+  ///
+  /// The `this` instance is invoked with each (stored property, property type)
+  /// pair for classes/structs and with each (enum elem, associated value type)
+  /// pair for enums.
+  ///
+  /// Thus, the requirements of your `VisitorImpl` must match up with this
+  /// public interface.
+  ///
+  /// \returns \c true if any call to the \c visitor returns \c true, and
+  /// \c false otherwise.
+  bool visit(NominalTypeDecl *nominal, DeclContext *dc);
+
+  /// Handle a stored property.
+  virtual bool operator()(VarDecl *property, Type propertyType) = 0;
+
+  /// Handle an enum associated value.
+  virtual bool operator()(EnumElementDecl *element, Type elementType) = 0;
+};
+
 
 // Is this type copyable in the given decl context?
 bool isCopyable(Type type, DeclContext *dc);