Merge pull request #85704 from kavon/suppressed-assoc-types-with-defaults

Sema: introduce SuppressedAssociatedTypesWithDefaults

Author: kavon

docs/Generics/chapters/basic-operation.tex

@@ -636,6 +636,16 @@ \subsection*{The Rewrite Context}
 \item \texttt{getProtocolDependencies()} evaluates the \texttt{ProtocolDependenciesRequest}.
 \end{itemize}
 
+\IndexSource{protocol inverses request}
+\apiref{ProtocolInversesRequest}{class}
+A request evaluator request which enumerates the inverse requirements written on the given protocol and its associated types.
+
+\apiref{ProtocolDecl}{class}
+See also \SecRef{src:declarations}.
+\begin{itemize}
+\item \texttt{getInverseRequirements()} evaluates the \texttt{ProtocolInversesRequest}.
+\end{itemize}
+
 \IndexSource{requirement machine}
 \apiref{rewriting::RequirementMachine}{class}
 A list of rewrite rules and a property map. See also \SecRef{src:symbols terms rules} and \SecRef{property map sourceref}. Entry points for initializing a requirement machine, called by the rewrite context and various requests:

include/swift/AST/Decl.h

@@ -5592,6 +5592,7 @@ class ProtocolDecl final : public NominalTypeDecl {
   friend class StructuralRequirementsRequest;
   friend class TypeAliasRequirementsRequest;
   friend class ProtocolDependenciesRequest;
+  friend class ProtocolInversesRequest;
   friend class RequirementSignatureRequest;
   friend class ProtocolRequiresClassRequest;
   friend class ExistentialConformsToSelfRequest;
@@ -5825,6 +5826,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:
@@ -618,6 +619,25 @@ class ProtocolDependenciesRequest :
   bool isCached() const { return true; }
 };
 
+class ProtocolInversesRequest :
+    public SimpleRequest<ProtocolInversesRequest,
+                         ArrayRef<InverseRequirement>(ProtocolDecl *),
+                         RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  ArrayRef<InverseRequirement>
+  evaluate(Evaluator &evaluator, ProtocolDecl *proto) const;
+
+public:
+  // Caching.
+  bool isCached() const { return true; }
+};
+
 /// Compute the requirements that describe a protocol.
 class RequirementSignatureRequest :
     public SimpleRequest<RequirementSignatureRequest,

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -301,14 +301,17 @@ 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,
               HasNearestLocation)
 SWIFT_REQUEST(TypeChecker, ProtocolDependenciesRequest,
               ArrayRef<ProtocolDecl *>(ProtocolDecl *), Cached,
               HasNearestLocation)
+SWIFT_REQUEST(TypeChecker, ProtocolInversesRequest,
+              ArrayRef<InverseRequirement>(ProtocolDecl *), Cached,
+              HasNearestLocation)
 SWIFT_REQUEST(TypeChecker, RequirementSignatureRequest,
               RequirementSignature(ProtocolDecl *), SeparatelyCached,
               NoLocationInfo)

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,
+    ProtocolInversesRequest{const_cast<ProtocolDecl *>(this)}, {});
 }
 
 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;