ASTPrinter: Refactor to use getRequirementsWithInverses()

Author: slavapestov

lib/AST/ASTPrinter.cpp

@@ -943,7 +943,6 @@ class PrintAST : public ASTVisitor<PrintAST> {
     InnermostOnly = 4,
     SwapSelfAndDependentMemberType = 8,
     PrintInherited = 16,
-    CollapseDefaultReqs = 32,
   };
 
   void printInheritedFromRequirementSignature(ProtocolDecl *proto,
@@ -953,11 +952,9 @@ class PrintAST : public ASTVisitor<PrintAST> {
   void printInherited(const Decl *decl);
 
   void printGenericSignature(GenericSignature genericSig,
-                             ArrayRef<InverseRequirement> inverses,
                              unsigned flags);
   void
   printGenericSignature(GenericSignature genericSig,
-                        ArrayRef<InverseRequirement> inverses,
                         unsigned flags,
                         llvm::function_ref<bool(const Requirement &)> filter);
   void printSingleDepthOfGenericSignature(
@@ -1457,44 +1454,6 @@ static unsigned getDepthOfType(Type ty) {
   return depth;
 }
 
-/// Recomputes which inverses must have been written for the given generic
-/// signature.
-static void reconstituteInverses(GenericSignature genericSig,
-                               ArrayRef<Type> typeParams,
-                               SmallVectorImpl<InverseRequirement> &inverses) {
-  auto &ctx = genericSig->getASTContext();
-
-  if (!ctx.LangOpts.hasFeature(swift::Feature::NoncopyableGenerics))
-    return;
-
-  for (auto tp : typeParams) {
-    assert(tp);
-
-    // Any generic parameter with a superclass bound could not have an inverse.
-    if (genericSig->getSuperclassBound(tp))
-      continue;
-
-    auto defaults = InverseRequirement::expandDefault(tp);
-    for (auto ip : defaults) {
-      auto *proto = ctx.getProtocol(getKnownProtocolKind(ip));
-
-      // If the generic signature reflects the default requirement,
-      // then there was no inverse for this generic parameter.
-      if (genericSig->requiresProtocol(tp, proto))
-        continue;
-
-      inverses.push_back({tp, proto, SourceLoc()});
-    }
-  }
-}
-
-static void reconstituteInverses(GenericSignature genericSig,
-                                 ArrayRef<GenericTypeParamType *> genericParams,
-                                 SmallVectorImpl<InverseRequirement> &inverses) {
-  SmallVector<Type, 4> asType(genericParams);
-  reconstituteInverses(genericSig, asType, inverses);
-}
-
 namespace {
 struct RequirementPrintLocation {
   /// The Decl where the requirement should be attached (whether inherited or in
@@ -1615,13 +1574,9 @@ void PrintAST::printInheritedFromRequirementSignature(ProtocolDecl *proto,
   else
     llvm_unreachable("nonexhaustive");
 
-  SmallVector<InverseRequirement, 2> inverses;
-  reconstituteInverses(proto->getGenericSignature(), attachedGP, inverses);
-
   printGenericSignature(
       proto->getRequirementSignatureAsGenericSignature(),
-      inverses,
-      PrintInherited | CollapseDefaultReqs,
+      PrintInherited,
       [&](const Requirement &req) {
         // Skip the inferred 'Self : AnyObject' constraint if this is an
         // @objc protocol.
@@ -1640,12 +1595,11 @@ void PrintAST::printInheritedFromRequirementSignature(ProtocolDecl *proto,
 
 void PrintAST::printWhereClauseFromRequirementSignature(ProtocolDecl *proto,
                                                         TypeDecl *attachingTo) {
-  unsigned flags = PrintRequirements | CollapseDefaultReqs;
+  unsigned flags = PrintRequirements;
   if (isa<AssociatedTypeDecl>(attachingTo))
     flags |= SwapSelfAndDependentMemberType;
   printGenericSignature(
       proto->getRequirementSignatureAsGenericSignature(),
-      {}, // NOTE: a protocol's inverses are only printed in inheritance clause!
       flags,
       [&](const Requirement &req) {
         auto location = bestRequirementPrintLocation(proto, req);
@@ -1681,31 +1635,20 @@ static unsigned getDepthOfRequirement(const Requirement &req) {
   llvm_unreachable("bad RequirementKind");
 }
 
-static void getRequirementsAtDepth(GenericSignature genericSig,
-                                   unsigned depth,
-                                   SmallVectorImpl<Requirement> &result) {
-  for (auto reqt : genericSig.getRequirements()) {
-    unsigned currentDepth = getDepthOfRequirement(reqt);
-    assert(currentDepth != ErrorDepth);
-    if (currentDepth == depth)
-      result.push_back(reqt);
-  }
-}
-
 void PrintAST::printGenericSignature(GenericSignature genericSig,
-                                     ArrayRef<InverseRequirement> inverses,
                                      unsigned flags) {
-  printGenericSignature(genericSig, inverses, flags,
+  printGenericSignature(genericSig, flags,
                         // print everything
                         [&](const Requirement &) { return true; });
 }
 
 void PrintAST::printGenericSignature(
     GenericSignature genericSig,
-    ArrayRef<InverseRequirement> inverses,
     unsigned flags,
     llvm::function_ref<bool(const Requirement &)> filter) {
-  auto requirements = genericSig.getRequirements();
+  SmallVector<Requirement, 2> requirements;
+  SmallVector<InverseRequirement, 2> inverses;
+  genericSig->getRequirementsWithInverses(requirements, inverses);
 
   if (flags & InnermostOnly) {
     auto genericParams = genericSig.getInnermostGenericParams();
@@ -1741,34 +1684,27 @@ void PrintAST::printGenericSignature(
         genericParams.slice(paramIdx, lastParamIdx - paramIdx);
 
     SmallVector<InverseRequirement, 2> inversesAtDepth;
-    if (flags & CollapseDefaultReqs)
-      reconstituteInverses(genericSig, genericParamsAtDepth, inversesAtDepth);
+    for (auto inverseReq : inverses) {
+      if (inverseReq.subject->castTo<GenericTypeParamType>()->getDepth() == depth)
+        inversesAtDepth.push_back(inverseReq);
+    }
 
     SmallVector<Requirement, 2> requirementsAtDepth;
-    getRequirementsAtDepth(genericSig, depth, requirementsAtDepth);
+    for (auto reqt : requirements) {
+      unsigned currentDepth = getDepthOfRequirement(reqt);
+      assert(currentDepth != ErrorDepth);
+      if (currentDepth == depth)
+        requirementsAtDepth.push_back(reqt);
+    }
 
     printSingleDepthOfGenericSignature(
-        genericParamsAtDepth,
-        requirementsAtDepth, inversesAtDepth, flags, filter);
+        genericParamsAtDepth, requirementsAtDepth, inversesAtDepth,
+        flags, filter);
 
     paramIdx = lastParamIdx;
   }
 }
 
-/// \returns the invertible protocol kind iff this requirement is a conformance
-///          to an invertible protocol.
-static llvm::Optional<InvertibleProtocolKind>
-getInvertibleProtocolKind(const Requirement &req) {
-  if (req.getKind() != RequirementKind::Conformance)
-    return llvm::None;
-
-  auto constraintTy = req.getSecondType();
-  if (auto kp = constraintTy->getKnownProtocol())
-    return getInvertibleProtocolKind(*kp);
-
-  return llvm::None;
-}
-
 void PrintAST::printSingleDepthOfGenericSignature(
     ArrayRef<GenericTypeParamType *> genericParams,
     ArrayRef<Requirement> requirements,
@@ -1792,7 +1728,6 @@ void PrintAST::printSingleDepthOfGenericSignature(
   bool printInherited = (flags & PrintInherited);
   bool swapSelfAndDependentMemberType =
     (flags & SwapSelfAndDependentMemberType);
-  const bool collapseDefaults = (flags & CollapseDefaultReqs);
 
   unsigned typeContextDepth = 0;
   SubstitutionMap subMap;
@@ -1884,17 +1819,10 @@ void PrintAST::printSingleDepthOfGenericSignature(
   }
 
   if (printRequirements || printInherited) {
-    // If we're not collapsing defaults, we shouldn't also print inverses!
-    assert(collapseDefaults || inverses.empty());
-
     for (const auto &req : requirements) {
       if (!filter(req))
         continue;
 
-      /// Skip all requirements for a conformance to an invertible protocol.
-      if (collapseDefaults && getInvertibleProtocolKind(req))
-        continue;
-
       auto first = req.getFirstType();
 
       if (dependsOnOpaque(first))
@@ -2678,7 +2606,7 @@ void PrintAST::printGenericDeclGenericParams(GenericContext *decl) {
   if (decl->isGeneric())
     if (auto GenericSig = decl->getGenericSignature()) {
       Printer.printStructurePre(PrintStructureKind::DeclGenericParameterClause);
-      printGenericSignature(GenericSig, {}, PrintParams | InnermostOnly);
+      printGenericSignature(GenericSig, PrintParams | InnermostOnly);
       Printer.printStructurePost(PrintStructureKind::DeclGenericParameterClause);
     }
 }
@@ -2697,13 +2625,9 @@ void PrintAST::printDeclGenericRequirements(GenericContext *decl) {
   SmallVector<Type, 2> genericParams;
   InverseRequirement::enumerateDefaultedParams(decl, genericParams);
 
-  SmallVector<InverseRequirement, 2> inverses;
-  reconstituteInverses(genericSig, genericParams, inverses);
-
   Printer.printStructurePre(PrintStructureKind::DeclGenericParameterClause);
   printGenericSignature(genericSig,
-                        inverses,
-                        PrintRequirements | CollapseDefaultReqs,
+                        PrintRequirements,
                         [parentSig](const Requirement &req) {
                           if (parentSig)
                             return !parentSig->isRequirementSatisfied(req);
@@ -2961,11 +2885,7 @@ void PrintAST::printExtension(ExtensionDecl *decl) {
       auto baseGenericSig = decl->getExtendedNominal()->getGenericSignature();
       assert(baseGenericSig &&
              "an extension can't be generic if the base type isn't");
-      // NOTE: We do _not_ CollapseDefaultReqs for the where-clause of an
-      // extension, because conditions involving Copyable here are not
-      // automatically inferred based on the extension itself.
       printGenericSignature(genericSig,
-                            {},
                             PrintRequirements,
                             [baseGenericSig](const Requirement &req) -> bool {
         // Only include constraints that are not satisfied by the base type.
@@ -7216,12 +7136,8 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
     Printer.printStructurePost(PrintStructureKind::FunctionReturnType);
   }
 
-  void printGenericSignature(GenericSignature genericSig,
-                             ArrayRef<InverseRequirement> inverses,
-                             unsigned flags) {
-    PrintAST(Printer, Options).printGenericSignature(genericSig,
-                                                     inverses,
-                                                     flags);
+  void printGenericSignature(GenericSignature genericSig, unsigned flags) {
+    PrintAST(Printer, Options).printGenericSignature(genericSig, flags);
   }
 
   void printSubstitutions(SubstitutionMap subs) {
@@ -7241,17 +7157,10 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
       Printer.printStructurePost(PrintStructureKind::FunctionType);
     };
 
-    SmallVector<InverseRequirement, 2> inverses;
-    reconstituteInverses(T->getGenericSignature(),
-                         T->getGenericParams(),
-                         inverses);
-
     printFunctionExtInfo(T);
     printGenericSignature(T->getGenericSignature(),
-                          inverses,
                           PrintAST::PrintParams |
-                          PrintAST::PrintRequirements |
-                          PrintAST::CollapseDefaultReqs);
+                          PrintAST::PrintRequirements);
     Printer << " ";
 
    visitAnyFunctionTypeParams(T->getParams(), /*printLabels*/true);
@@ -7328,14 +7237,9 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
     printCalleeConvention(T->getCalleeConvention());
 
     if (GenericSignature sig = T->getInvocationGenericSignature()) {
-      SmallVector<InverseRequirement, 2> inverses;
-      reconstituteInverses(sig, sig.getGenericParams(), inverses);
-
       printGenericSignature(sig,
-                            inverses,
                             PrintAST::PrintParams |
-                            PrintAST::PrintRequirements |
-                            PrintAST::CollapseDefaultReqs);
+                            PrintAST::PrintRequirements);
       Printer << " ";
     }
 
@@ -7357,14 +7261,10 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
 
       GenericSignature sig = substitutions.getGenericSignature();
 
-      SmallVector<InverseRequirement, 2> inverses;
-      reconstituteInverses(sig, sig.getGenericParams(), inverses);
-
       sub->Printer << "@substituted ";
-      sub->printGenericSignature(sig, inverses,
+      sub->printGenericSignature(sig,
                                  PrintAST::PrintParams |
-                                 PrintAST::PrintRequirements |
-                                 PrintAST::CollapseDefaultReqs);
+                                 PrintAST::PrintRequirements);
       sub->Printer << " ";
     }
 
@@ -7474,7 +7374,7 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
       // printer, but only the sub-Printer.
       [&sub, T]{
         if (auto sig = T->getLayout()->getGenericSignature()) {
-          sub.printGenericSignature(sig, /*inverses=*/{},
+          sub.printGenericSignature(sig,
                           PrintAST::PrintParams | PrintAST::PrintRequirements);
           sub.Printer << " ";
         }
@@ -8029,10 +7929,9 @@ void GenericSignature::print(ASTPrinter &Printer,
     Printer << "<null>";
     return;
   }
-  PrintAST(Printer, Opts).printGenericSignature(*this,
-                                                /*inverses=*/{},
-                                                PrintAST::PrintParams |
-                                                PrintAST::PrintRequirements);
+
+  PrintAST(Printer, Opts).printGenericSignature(
+      *this, PrintAST::PrintParams | PrintAST::PrintRequirements);
 }
 
 void Requirement::print(raw_ostream &os, const PrintOptions &opts) const {
@@ -8230,7 +8129,7 @@ void ProtocolConformance::printName(llvm::raw_ostream &os,
       StreamPrinter sPrinter(os);
       TypePrinter typePrinter(sPrinter, PO);
       typePrinter
-          .printGenericSignature(genericSig, /*inverses=*/{},
+          .printGenericSignature(genericSig,
                                  PrintAST::PrintParams |
                                  PrintAST::PrintRequirements);
       os << ' ';