Sema: introduce SuppressedAssociatedTypesWithDefaults

This is similar to SuppressedAssociatedTypes, but infers
default requirements when primary associated types of
protocols are suppressed. This defaulting for the primary
associated types happens in extensions of the protocol,
along with generic parameters, whenever a source-written
requirement states a conformance requirement for the protocol.

Thus, the current scheme for this defaulting is a simplistic,
driven by source-written requirements, rather than facts
that are inferred while building generic signatures.

Defaults are not expanded for infinitely many associated types.

Other changes include...

Sema: adjust protocol extension signature hack

With SuppressedAssociatedTypesWithDefaults,
we can have associated types that are missing
invertible conformance requirements, so we need
to try re-building the signature for the extension
of the protocol. Otherwise, we won't infer the new
default(s) for those associated types.

This previous hack was only trying to shortcut
the rebuilding if it saw Self is lacking a conformance
requirement. Now it'll check if any inverses were written
in source for that protocol.

Author: kavon

include/swift/AST/Decl.h

@@ -5811,6 +5811,11 @@ class ProtocolDecl final : public NominalTypeDecl {
   /// instead.
   ArrayRef<StructuralRequirement> getStructuralRequirements() const;
 
+  /// Retrieves the original inverse requirements written in source.
+  ///
+  /// The structural requirements already have had these applied to them.
+  ArrayRef<InverseRequirement> getInverseRequirements() const;
+
   /// Retrieve same-type requirements implied by protocol typealiases with the
   /// same name as associated types, and diagnose cases that are better expressed
   /// via a 'where' clause.

include/swift/AST/Requirement.h

@@ -24,6 +24,7 @@
 #include "swift/Basic/Debug.h"
 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/PointerIntPair.h"
+#include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/Support/ErrorHandling.h"
 
 namespace swift {
@@ -274,9 +275,16 @@ struct InverseRequirement {
 
   /// Appends additional requirements corresponding to defaults for the given
   /// generic parameters.
+  /// \param gps the generic parameters for which start expanding defaults.
+  /// \param existingReqs The source-written requirements prior to expansion.
+  /// \param result The vector to append new default requirements into.
+  /// \param expandedGPs The subjects for which defaults were expanded,
+  ///                    which may be different and more Type's than 'gps'
   static void expandDefaults(ASTContext &ctx,
                              ArrayRef<Type> gps,
-                             SmallVectorImpl<StructuralRequirement> &result);
+                             ArrayRef<StructuralRequirement> existingReqs,
+                             SmallVectorImpl<StructuralRequirement> &result,
+                             SmallVectorImpl<Type> &expandedGPs);
 
   void print(raw_ostream &os, const PrintOptions &opts, bool forInherited=false) const;
 };

include/swift/AST/TypeCheckRequests.h

@@ -561,18 +561,19 @@ class IsDynamicRequest :
   void cacheResult(bool value) const;
 };
 
-class StructuralRequirementsRequest :
-    public SimpleRequest<StructuralRequirementsRequest,
-                         ArrayRef<StructuralRequirement>(ProtocolDecl *),
-                         RequestFlags::Cached> {
+class StructuralRequirementsRequest
+    : public SimpleRequest<StructuralRequirementsRequest,
+                       std::pair<ArrayRef<StructuralRequirement>,
+                                 ArrayRef<InverseRequirement>>(ProtocolDecl *),
+                       RequestFlags::Cached> {
 public:
   using SimpleRequest::SimpleRequest;
 
 private:
   friend SimpleRequest;
 
   // Evaluation.
-  ArrayRef<StructuralRequirement>
+  std::pair<ArrayRef<StructuralRequirement>, ArrayRef<InverseRequirement>>
   evaluate(Evaluator &evaluator, ProtocolDecl *proto) const;
 
 public:

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -301,7 +301,7 @@ SWIFT_REQUEST(TypeChecker, RequirementRequest,
               Requirement(WhereClauseOwner, unsigned, TypeResolutionStage),
               Cached, HasNearestLocation)
 SWIFT_REQUEST(TypeChecker, StructuralRequirementsRequest,
-              ArrayRef<StructuralRequirement>(ProtocolDecl *), Cached,
+              (std::pair<ArrayRef<StructuralRequirement>, ArrayRef<InverseRequirement>>(ProtocolDecl *)), Cached,
               HasNearestLocation)
 SWIFT_REQUEST(TypeChecker, TypeAliasRequirementsRequest,
               ArrayRef<Requirement>(ProtocolDecl *), Cached,

include/swift/Basic/Features.def

@@ -441,6 +441,10 @@ EXPERIMENTAL_FEATURE(Volatile, true)
 // Enables ~Copyable and ~Escapable annotations on associatedtype declarations.
 EXPERIMENTAL_FEATURE(SuppressedAssociatedTypes, true)
 
+// Enables ~Copyable and ~Escapable annotations on associatedtype declarations,
+// and infers defaults for them.
+EXPERIMENTAL_FEATURE(SuppressedAssociatedTypesWithDefaults, false)
+
 /// Allow destructuring stored `let` bindings in structs.
 EXPERIMENTAL_FEATURE(StructLetDestructuring, true)
 

lib/AST/Decl.cpp

@@ -7472,7 +7472,14 @@ ArrayRef<StructuralRequirement>
 ProtocolDecl::getStructuralRequirements() const {
   return evaluateOrDefault(
       getASTContext().evaluator,
-      StructuralRequirementsRequest{const_cast<ProtocolDecl *>(this)}, {});
+      StructuralRequirementsRequest{const_cast<ProtocolDecl *>(this)}, {}).first;
+}
+
+ArrayRef<InverseRequirement>
+ProtocolDecl::getInverseRequirements() const {
+  return evaluateOrDefault(
+      getASTContext().evaluator,
+      StructuralRequirementsRequest{const_cast<ProtocolDecl *>(this)}, {}).second;
 }
 
 ArrayRef<Requirement>

lib/AST/FeatureSet.cpp

@@ -121,6 +121,7 @@ UNINTERESTING_FEATURE(RawLayout)
 UNINTERESTING_FEATURE(Embedded)
 UNINTERESTING_FEATURE(Volatile)
 UNINTERESTING_FEATURE(SuppressedAssociatedTypes)
+UNINTERESTING_FEATURE(SuppressedAssociatedTypesWithDefaults)
 UNINTERESTING_FEATURE(StructLetDestructuring)
 UNINTERESTING_FEATURE(MacrosOnImports)
 UNINTERESTING_FEATURE(NonisolatedNonsendingByDefault)

lib/AST/Requirement.cpp

@@ -364,10 +364,64 @@ InvertibleProtocolKind InverseRequirement::getKind() const {
   return *getInvertibleProtocolKind(*(protocol->getKnownProtocolKind()));
 }
 
+/// Do these two ArrayRefs alias any of the same memory?
+template<typename T>
+bool arrayrefs_overlap(ArrayRef<T> A, ArrayRef<T> B) {
+  if (A.empty() || B.empty())
+    return false;
+
+  const T *ABegin = A.data();
+  const T *AEnd = ABegin + A.size();
+  const T *BBegin = B.data();
+  const T *BEnd = BBegin + B.size();
+
+  return ABegin < BEnd && BBegin < AEnd;
+}
+
+static CanType cleanSubject(Type ty) {
+  if (auto dmt = ty->getAs<DependentMemberType>()) {
+    auto canBase = cleanSubject(dmt->getBase());
+    ty = DependentMemberType::get(canBase, dmt->getName());
+  }
+  return ty->getCanonicalType();
+}
+
 void InverseRequirement::expandDefaults(
     ASTContext &ctx,
     ArrayRef<Type> gps,
-    SmallVectorImpl<StructuralRequirement> &result) {
+    ArrayRef<StructuralRequirement> existingReqs,
+    SmallVectorImpl<StructuralRequirement> &result,
+    SmallVectorImpl<Type> &expandedGPs) {
+  // If there are no subjects, there's nothing to expand.
+  if (gps.empty())
+    return;
+
+  // Vectors can reallocate, so we mustn't be looking at an ArrayRef pointing
+  // into the same span of memory that we're also mutating!
+  ASSERT(!arrayrefs_overlap(existingReqs, {result.data(), result.size()}) &&
+         "requirements are aliasing!");
+  ASSERT(!arrayrefs_overlap(gps, {expandedGPs.data(), expandedGPs.size()}) &&
+         "types are aliasing!");
+
+  auto expandFor = [&](Type gp) {
+    expandedGPs.push_back(gp);
+    for (auto ip : InvertibleProtocolSet::allKnown()) {
+      auto proto = ctx.getProtocol(getKnownProtocolKind(ip));
+
+      result.push_back({{RequirementKind::Conformance, gp,
+                         proto->getDeclaredInterfaceType()},
+                         SourceLoc()});
+    }
+  };
+
+  // Find the root generic parameter, looking through any DMT's.
+  auto getRoot = [](Type gp) -> CanType {
+    return gp->getDependentMemberRoot()->getCanonicalType();
+  };
+
+  // Used for further expansion of defaults for dependent type members of gps.
+  // Contains the root generic parameters of the ones we were asked to expand.
+  llvm::SmallSetVector<CanType, 8> seenGPs;
   for (auto gp : gps) {
     // Value generics never have inverses (or the positive thereof).
     if (auto gpTy = gp->getAs<GenericTypeParamType>()) {
@@ -376,11 +430,56 @@ void InverseRequirement::expandDefaults(
       }
     }
 
-    for (auto ip : InvertibleProtocolSet::allKnown()) {
-      auto proto = ctx.getProtocol(getKnownProtocolKind(ip));
-      result.push_back({{RequirementKind::Conformance, gp,
-                         proto->getDeclaredInterfaceType()},
-                         SourceLoc()});
+    // Each generic parameter is inferred to have a conformance requirement
+    // to all invertible protocols, regardless of what other requirements exist.
+    // We later cancel them out in applyInverses.
+    expandFor(gp);
+    seenGPs.insert(getRoot(gp));
+  }
+
+  // Look for structural requirements stating type parameter G conforms to P.
+  // If P has a primary associatedtype P.A, infer default requirements for G.A
+  // For example, given protocol,
+  //
+  //    protocol P<A>: ~Copyable { associatedtype A: ~Copyable }
+  //
+  // For an initial gp [T] and structural requirements [T: P, T.A: P],
+  // we proceed with one pass over the original structural requirements:
+  //
+  // 1. Expand new requirement 'T: Copy' (already done earlier)
+  // 2. Because of original requirement 'T: P', infer requirement [T.A: Copy]
+  // 4. Because of original requirement 'T.A: P', infer requirement [T.A.A: Copy]
+  // 5. Expansion stops, as there are no more requirements.
+  //
+  // Because Copyable & Escapable don't have associated types, we're done.
+  if (ctx.LangOpts.hasFeature(Feature::SuppressedAssociatedTypesWithDefaults)) {
+    // Help avoid duplicate expansions of the same DMT.
+    llvm::SmallSetVector<CanType, 8> dmtsExpanded;
+
+    for (auto const& sreq : existingReqs) {
+      auto &req = sreq.req;
+      if (req.getKind() != RequirementKind::Conformance)
+        continue;
+
+      // Is this subject rooted in one we did expand defaults for?
+      auto subject = req.getFirstType();
+      if (!seenGPs.contains(getRoot(subject)))
+        continue;
+
+      // Given a structural requirement `Subject: P`,
+      // for each primary associated type A of P, expand defaults for Subject.A
+      auto *proto = req.getProtocolDecl();
+      for (auto *ATD : proto->getPrimaryAssociatedTypes()) {
+        auto dmt = DependentMemberType::get(subject, ATD);
+        auto cleanDMT = cleanSubject(dmt);
+
+        // Did we already expand for the same DMT?
+        if (dmtsExpanded.contains(cleanDMT))
+          continue;
+
+        expandFor(dmt);
+        dmtsExpanded.insert(cleanDMT);
+      }
     }
   }
 }

lib/AST/RequirementMachine/ApplyInverses.cpp

@@ -40,6 +40,31 @@
 using namespace swift;
 using namespace rewriting;
 
+// Wipes-out the AssociatedTypeDecl's from DependentMemberTypes, leaving them
+// with just their names. This ensures the DMT's compare equal in applyInverses.
+//
+// This "cleaning" is needed because InverseRequirement subjects look
+// like this, where the DMT is only by-name and not resolved to a particular
+// AssociatedTypeDecl:
+//
+//   (dependent_member_type name="Iterator"
+//     (base=generic_type_param_type depth=0 index=0 param_kind=type))
+//
+// whereas the ones from 'gps' may have the AssociatedTypeDecl inside them:
+//
+//  (dependent_member_type assoc_type="...Test.Iterator..."
+//    (base=generic_type_param_type depth=0 index=0 name="Self" param_kind=type))
+//
+// and they will NOT compare equal, even after being converted to a CanType,
+// unless if the AssociatedTypeDecl is replaced with just its name.
+static CanType cleanSubject(Type ty) {
+  if (auto dmt = ty->getAs<DependentMemberType>()) {
+    auto canBase = cleanSubject(dmt->getBase());
+    ty = DependentMemberType::get(canBase, dmt->getName());
+  }
+  return ty->getCanonicalType();
+}
+
 void swift::rewriting::applyInverses(
     ASTContext &ctx,
     ArrayRef<Type> gps,
@@ -54,13 +79,14 @@ void swift::rewriting::applyInverses(
   }
 
   const bool allowInverseOnAssocType =
-      ctx.LangOpts.hasFeature(Feature::SuppressedAssociatedTypes);
+      ctx.LangOpts.hasFeature(Feature::SuppressedAssociatedTypes) ||
+      ctx.LangOpts.hasFeature(Feature::SuppressedAssociatedTypesWithDefaults);
 
   llvm::DenseMap<CanType, CanType> representativeGPs;
 
   // Start with an identity mapping.
   for (auto gp : gps) {
-    auto canGP = gp->getCanonicalType();
+    auto canGP = cleanSubject(gp);
     representativeGPs.insert({canGP, canGP});
   }
   bool hadSameTypeConstraintInScope = false;
@@ -95,8 +121,8 @@ void swift::rewriting::applyInverses(
     // If one end of the same-type requirement is in scope, and the other is
     // a concrete type or out-of-scope generic parameter, then the other
     // parameter is also effectively out of scope.
-    auto firstTy = explicitReqt.req.getFirstType()->getCanonicalType();
-    auto secondTy = explicitReqt.req.getSecondType()->getCanonicalType();
+    auto firstTy = cleanSubject(explicitReqt.req.getFirstType());
+    auto secondTy = cleanSubject(explicitReqt.req.getSecondType());
     if (!representativeGPs.count(firstTy)
         && !representativeGPs.count(secondTy)) {
       // Same type constraint doesn't involve any in-scope generic parameters.
@@ -118,23 +144,27 @@ void swift::rewriting::applyInverses(
       typeOutOfScope = firstTy;
     } else {
       // Otherwise, both ends of the same-type constraint are in scope.
-      // Fold the lexicographically-greater parameter with the lesser.
-      auto firstGP = cast<GenericTypeParamType>(firstTy);
-      auto secondGP = cast<GenericTypeParamType>(secondTy);
-      
-      if (firstGP == secondGP) {
+
+      // Choose one parameter to be the representative for the other, using
+      // a notion of "order" where we prefer the lexicographically smaller
+      // type to be the representative for the larger one.
+      const int sign = compareDependentTypes(firstTy, secondTy);
+      if (sign == 0) {
         // `T == T` has no effect.
         continue;
       }
-      
-      if (firstGP->getDepth() > secondGP->getDepth()
-          || (firstGP->getDepth() == secondGP->getDepth()
-              && firstGP->getIndex() > secondGP->getIndex())) {
-        std::swap(firstGP, secondGP);
+
+      CanType smaller, larger;
+      if (sign < 0) {
+        smaller = firstTy;
+        larger = secondTy;
+      } else {
+        smaller = secondTy;
+        larger = firstTy;
       }
 
       hadSameTypeConstraintInScope = true;
-      representativeGPs.insert_or_assign(secondGP, representativeGPFor(firstGP));
+      representativeGPs.insert_or_assign(larger, representativeGPFor(smaller));
       continue;
     }
 
@@ -164,7 +194,7 @@ void swift::rewriting::applyInverses(
   // Summarize the inverses and diagnose ones that are incorrect.
   llvm::DenseMap<CanType, InvertibleProtocolSet> inverses;
   for (auto inverse : inverseList) {
-    auto canSubject = inverse.subject->getCanonicalType();
+    auto canSubject = cleanSubject(inverse.subject);
 
     // Inverses on associated types are experimental.
     if (!allowInverseOnAssocType && canSubject->is<DependentMemberType>()) {
@@ -244,7 +274,7 @@ void swift::rewriting::applyInverses(
     }
 
     // See if this subject is in-scope.
-    auto subject = req.getFirstType()->getCanonicalType();
+    auto subject = cleanSubject(req.getFirstType());
     auto representative = representativeGPs.find(subject);
     if (representative == representativeGPs.end()) {
       return false;