[NoncopyableGenerics] fix swiftinterface

Author: kavon

include/swift/AST/InverseMarking.h

@@ -10,24 +10,25 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef SWIFT_LIB_SEMA_INVERSEMARKING_H
-#define SWIFT_LIB_SEMA_INVERSEMARKING_H
+#ifndef SWIFT_AST_INVERSEMARKING_H
+#define SWIFT_AST_INVERSEMARKING_H
 
 #include "swift/AST/KnownProtocols.h"
 #include "swift/Basic/SourceLoc.h"
 #include "swift/Basic/OptionalEnum.h"
 
 namespace swift {
 
+class NoncopyableAnnotationRequest;
+
 /// Describes the way an inverse and its corresponding positive contraint
 /// appears on a TypeDecl, i.e., the way it was marked.
 struct InverseMarking {
   enum class Kind : uint8_t {
     None,            // No inverse marking is present
     Inferred,        // Inverse is inferred based on generic parameters.
     Explicit,        // Inverse is explicitly present.
-
-    LAST = Explicit
+    LegacyExplicit,   // An equivalent, explicit legacy annotation is present.
   };
 
   // Describes what kind of mark was found, if any.
@@ -43,15 +44,18 @@ struct InverseMarking {
     Mark(Kind k, SourceLoc l = SourceLoc())
       : kind(k), loc(l) {};
 
-    // Is there an inferred or explicit marking?
-    bool isPresent() const {
-      return getKind() != Kind::None;
-    }
-    operator bool() { return isPresent(); }
-
     Kind getKind() const {
       return kind.getValueOr(Kind::None);
     }
+    bool is(Kind k) const {
+      return getKind() == k;
+    }
+
+    // Is there an inferred or explicit marking?
+    bool isPresent() const {
+      return !is(Kind::None);
+    }
+    operator bool() const { return isPresent(); }
 
     SourceLoc getLoc() const { return loc; }
 
@@ -68,34 +72,29 @@ struct InverseMarking {
     }
 
     void setIfUnset(Mark other) {
-      if (kind.hasValue())
+      if (!other.kind.hasValue())
         return;
-      kind = other.kind;
-      loc = other.loc;
+      setIfUnset(other.kind.getValue(), other.loc);
     }
 
-    Mark with(Kind k) {
-      kind = k;
-      return *this;
+    Mark with(Kind k) const {
+      return Mark(k, loc);
     }
   };
 
 private:
   Mark inverse;
   Mark positive;
+
+  // This friend initializes the marks.
+  friend NoncopyableAnnotationRequest;
 public:
 
   // Creates an empty marking.
   InverseMarking() {}
 
-  Mark &getInverse() { return inverse; }
-  Mark &getPositive() { return positive; }
-
-  // Merge the results of another marking into this one.
-  void merge(InverseMarking other) const {
-    other.inverse.setIfUnset(other.inverse);
-    other.positive.setIfUnset(other.positive);
-  }
+  Mark const& getInverse() const { return inverse; }
+  Mark const& getPositive() const { return positive; }
 
   static InverseMarking forInverse(Kind kind, SourceLoc loc = SourceLoc()) {
     InverseMarking marking;
@@ -107,4 +106,4 @@ struct InverseMarking {
 
 }
 
-#endif //SWIFT_LIB_SEMA_INVERSEMARKING_H
+#endif //SWIFT_AST_INVERSEMARKING_H

include/swift/AST/Type.h

@@ -541,6 +541,7 @@ class CanType : public Type {
   CanType getNominalParent() const; // in Types.h
   NominalTypeDecl *getAnyNominal() const;
   GenericTypeDecl *getAnyGeneric() const;
+  TypeDecl *getAnyTypeDecl() const;
 
   bool isForeignReferenceType(); // in Types.h
 

include/swift/AST/Types.h

@@ -1233,6 +1233,11 @@ class alignas(1 << TypeAlignInBits) TypeBase
   /// declaration.
   GenericTypeDecl *getAnyGeneric();
 
+  // If this a GenericType, ModuleType, or GenericTypeParamType, return the
+  // type declaration.
+  // NOTE: Will not attempt to find an AssociatedTypeDecl.
+  TypeDecl *getAnyTypeDecl();
+
   /// removeArgumentLabels -  Retrieve a version of this type with all
   /// argument labels removed.
   Type removeArgumentLabels(unsigned numArgumentLabels);
@@ -7423,9 +7428,9 @@ inline GenericTypeDecl *TypeBase::getAnyGeneric() {
   return getCanonicalType().getAnyGeneric();
 }
 
-//inline TypeDecl *TypeBase::getAnyTypeDecl() {
-//  return getCanonicalType().getAnyTypeDecl();
-//}
+inline TypeDecl *TypeBase::getAnyTypeDecl() {
+  return getCanonicalType().getAnyTypeDecl();
+}
 
 inline bool TypeBase::isBuiltinIntegerType(unsigned n) {
   if (auto intTy = dyn_cast<BuiltinIntegerType>(getCanonicalType()))

lib/AST/ASTPrinter.cpp

@@ -29,6 +29,7 @@
 #include "swift/AST/GenericEnvironment.h"
 #include "swift/AST/GenericParamList.h"
 #include "swift/AST/GenericSignature.h"
+#include "swift/AST/InverseMarking.h"
 #include "swift/AST/MacroDefinition.h"
 #include "swift/AST/Module.h"
 #include "swift/AST/NameLookup.h"
@@ -3329,33 +3330,58 @@ static bool usesFeatureFlowSensitiveConcurrencyCaptures(Decl *decl) {
   return false;
 }
 
-static bool usesFeatureMoveOnly(Decl *decl) {
+/// \param isRelevantInverse the function used to inspect a mark corresponding
+/// to an inverse to determine whether it "has" an inverse that we care about.
+static bool hasInverseCopyable(
+    Decl *decl,
+    std::function<bool(InverseMarking const&)> isRelevantInverse) {
+
   if (auto *extension = dyn_cast<ExtensionDecl>(decl)) {
     if (auto *nominal = extension->getSelfNominalTypeDecl())
-      if (nominal->canBeNoncopyable())
+      if (isRelevantInverse(nominal->getNoncopyableMarking()))
         return true;
   }
 
   if (auto typeDecl = dyn_cast<TypeDecl>(decl)) {
-    if (typeDecl->canBeNoncopyable())
+    if (isRelevantInverse(typeDecl->getNoncopyableMarking()))
       return true;
+
+    // Check the protocol's associated types too.
+    if (auto proto = dyn_cast<ProtocolDecl>(decl)) {
+      auto hasNoncopyable = llvm::any_of(proto->getAssociatedTypeMembers(),
+                                         [&](AssociatedTypeDecl *assocTyDecl) {
+                                           return isRelevantInverse(assocTyDecl->getNoncopyableMarking());
+                                         });
+      if (hasNoncopyable)
+        return true;
+    }
   }
 
   if (auto value = dyn_cast<ValueDecl>(decl)) {
-    // Check for move-only types in the types of this declaration.
+    // Check for noncopyable types in the types of this declaration.
     if (Type type = value->getInterfaceType()) {
-      bool hasMoveOnly = type.findIf([](Type type) {
-        return type->isNoncopyable();
+      bool hasNoncopyable = type.findIf([&](Type type) {
+        if (auto typeDecl = type->getAnyTypeDecl())
+          if (isRelevantInverse(typeDecl->getNoncopyableMarking()))
+            return true;
+
+        return false;
       });
 
-      if (hasMoveOnly)
+      if (hasNoncopyable)
         return true;
     }
   }
 
   return false;
 }
 
+static bool usesFeatureMoveOnly(Decl *decl) {
+  return hasInverseCopyable(decl, [](auto &marking) -> bool {
+    return marking.getInverse().is(InverseMarking::Kind::LegacyExplicit);
+  });
+}
+
 static bool usesFeatureLazyImmediate(Decl *D) { return false; }
 
 static bool usesFeatureMoveOnlyClasses(Decl *decl) {
@@ -3393,9 +3419,17 @@ static bool usesFeatureMoveOnlyPartialConsumption(Decl *decl) {
 }
 
 static bool usesFeatureNoncopyableGenerics(Decl *decl) {
-  // FIXME: need to look for suppressed entries on generic parameters or
-  // inheritance clauses!
-  return false;
+  return hasInverseCopyable(decl, [](auto &marking) -> bool {
+    switch (marking.getInverse().getKind()) {
+    case InverseMarking::Kind::None:
+    case InverseMarking::Kind::LegacyExplicit: // covered by MoveOnly
+      return false;
+
+    case InverseMarking::Kind::Explicit:
+    case InverseMarking::Kind::Inferred:
+      return true;
+    }
+  });
 }
 
 static bool usesFeatureOneWayClosureParameters(Decl *decl) {

lib/AST/Type.cpp

@@ -91,6 +91,17 @@ GenericTypeDecl *CanType::getAnyGeneric() const {
   return nullptr;
 }
 
+TypeDecl *CanType::getAnyTypeDecl() const {
+  // NOTE: there is no simple way to determine if it's an AssociatedTypeDecl.
+  if (auto genericTy = getAnyGeneric())
+    return genericTy;
+  if (auto gtpt = dyn_cast<GenericTypeParamType>(*this))
+    return gtpt->getDecl();
+  if (auto module = dyn_cast<ModuleType>(*this))
+    return module->getModule();
+  return nullptr;
+}
+
 //===----------------------------------------------------------------------===//
 // Various Type Methods.
 //===----------------------------------------------------------------------===//