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.

rdar://135168163

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

@@ -274,9 +274,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

@@ -438,9 +438,13 @@ EXPERIMENTAL_FEATURE(Embedded, true)
 /// Enables importing the Volatile module
 EXPERIMENTAL_FEATURE(Volatile, true)
 
-// Enables ~Copyable and ~Escapable annotations on associatedtype declarations.
+// LEGACY: 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, true)
+
 /// 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

@@ -23,6 +23,7 @@
 #include "swift/AST/Module.h"
 #include "swift/AST/Types.h"
 #include "swift/Basic/Assertions.h"
+#include "RequirementMachine/RequirementLowering.h"
 
 using namespace swift;
 
@@ -364,10 +365,51 @@ 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;
+}
+
 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()});
+    }
+  };
+
+  // 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> seenRoots;
   for (auto gp : gps) {
     // Value generics never have inverses (or the positive thereof).
     if (auto gpTy = gp->getAs<GenericTypeParamType>()) {
@@ -376,11 +418,57 @@ 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);
+    seenRoots.insert(gp->getDependentMemberRoot()->getCanonicalType());
+  }
+
+  // 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: Copyable' (already done earlier)
+  // 2. Because of requirement 'T: P', infer requirement [T.A: Copyable]
+  // 4. Because of requirement 'T.A: P', infer requirement [T.A.A: Copyable]
+  // 5. Expansion stops, as no other structural requirements are relevant.
+  //    Because Copyable & Escapable don't have associated types, we're done.
+  if (ctx.LangOpts.hasFeature(Feature::SuppressedAssociatedTypesWithDefaults)) {
+    // Help avoid duplicate expansions of the same member type.
+    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();
+      auto subjectRoot = subject->getDependentMemberRoot()->getCanonicalType();
+      if (!seenRoots.contains(subjectRoot))
+        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 =
+            rewriting::stripBoundDependentMemberTypes(dmt)->getCanonicalType();
+
+        // Did we already expand for the same DMT?
+        if (dmtsExpanded.contains(cleanDMT))
+          continue;
+
+        expandFor(dmt);
+        dmtsExpanded.insert(cleanDMT);
+      }
     }
   }
 }

lib/AST/RequirementMachine/ApplyInverses.cpp

@@ -54,13 +54,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 = stripBoundDependentMemberTypes(gp)->getCanonicalType();
     representativeGPs.insert({canGP, canGP});
   }
   bool hadSameTypeConstraintInScope = false;
@@ -95,8 +96,12 @@ 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 =
+        stripBoundDependentMemberTypes(explicitReqt.req.getFirstType())
+            ->getCanonicalType();
+    auto secondTy =
+        stripBoundDependentMemberTypes(explicitReqt.req.getSecondType())
+            ->getCanonicalType();
     if (!representativeGPs.count(firstTy)
         && !representativeGPs.count(secondTy)) {
       // Same type constraint doesn't involve any in-scope generic parameters.
@@ -118,23 +123,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 +173,8 @@ 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 =
+        stripBoundDependentMemberTypes(inverse.subject)->getCanonicalType();
 
     // Inverses on associated types are experimental.
     if (!allowInverseOnAssocType && canSubject->is<DependentMemberType>()) {
@@ -244,7 +254,7 @@ void swift::rewriting::applyInverses(
     }
 
     // See if this subject is in-scope.
-    auto subject = req.getFirstType()->getCanonicalType();
+    auto subject = stripBoundDependentMemberTypes(req.getFirstType())->getCanonicalType();
     auto representative = representativeGPs.find(subject);
     if (representative == representativeGPs.end()) {
       return false;

lib/AST/RequirementMachine/ConcreteContraction.cpp

@@ -156,7 +156,7 @@ using namespace rewriting;
 /// Strip associated types from types used as keys to erase differences between
 /// resolved types coming from the parent generic signature and unresolved types
 /// coming from user-written requirements.
-static Type stripBoundDependentMemberTypes(Type t) {
+Type swift::rewriting::stripBoundDependentMemberTypes(Type t) {
   if (auto *depMemTy = t->getAs<DependentMemberType>()) {
     return DependentMemberType::get(
       stripBoundDependentMemberTypes(depMemTy->getBase()),