AST: Refactor ASTPrinter to use getRequirementsWithInverses()

slavapestov · slavapestov · commit 45f31b451638 · 2024-01-31T18:40:35.000-05:00
diff --git a/include/swift/AST/PrintOptions.h b/include/swift/AST/PrintOptions.h
@@ -329,6 +329,11 @@ struct PrintOptions {
   /// Whether to print generic requirements in a where clause.
   bool PrintGenericRequirements = true;
 
+  /// Whether to print generic signatures with inverse requirements (ie,
+  /// ~Copyable noting the absence of Copyable) or the internal desugared form
+  /// (where the implicit Copyable conformance is spelled explicitly).
+  bool PrintInverseRequirements = false;
+
   /// Whether to print the internal layout name instead of AnyObject, etc.
   bool PrintInternalLayoutName = false;
 
diff --git a/lib/AST/ASTPrinter.cpp b/lib/AST/ASTPrinter.cpp
@@ -943,7 +943,7 @@ class PrintAST : public ASTVisitor<PrintAST> {
     InnermostOnly = 4,
     SwapSelfAndDependentMemberType = 8,
     PrintInherited = 16,
-    CollapseDefaultReqs = 32,
+    PrintInverseRequirements = 32,
   };
 
   void printInheritedFromRequirementSignature(ProtocolDecl *proto,
@@ -953,11 +953,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 +1455,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 +1575,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 +1596,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 +1636,27 @@ 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;
+
+  if (flags & PrintInverseRequirements) {
+    genericSig->getRequirementsWithInverses(requirements, inverses);
+  } else {
+    requirements.append(genericSig.getRequirements().begin(),
+                        genericSig.getRequirements().end());
+  }
 
   if (flags & InnermostOnly) {
     auto genericParams = genericSig.getInnermostGenericParams();
@@ -1741,34 +1692,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 +1736,6 @@ void PrintAST::printSingleDepthOfGenericSignature(
   bool printInherited = (flags & PrintInherited);
   bool swapSelfAndDependentMemberType =
     (flags & SwapSelfAndDependentMemberType);
-  const bool collapseDefaults = (flags & CollapseDefaultReqs);
 
   unsigned typeContextDepth = 0;
   SubstitutionMap subMap;
@@ -1884,17 +1827,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 +2614,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 +2633,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 | PrintInverseRequirements,
                         [parentSig](const Requirement &req) {
                           if (parentSig)
                             return !parentSig->isRequirementSatisfied(req);
@@ -2961,12 +2893,8 @@ 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,
+                            PrintRequirements | PrintInverseRequirements,
                             [baseGenericSig](const Requirement &req) -> bool {
         // Only include constraints that are not satisfied by the base type.
         return !baseGenericSig->isRequirementSatisfied(req);
@@ -7216,12 +7144,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 +7165,11 @@ 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::PrintInverseRequirements);
     Printer << " ";
 
    visitAnyFunctionTypeParams(T->getParams(), /*printLabels*/true);
@@ -7327,11 +7245,11 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
     printFunctionExtInfo(T);
     printCalleeConvention(T->getCalleeConvention());
 
-    if (auto sig = T->getInvocationGenericSignature()) {
+    if (GenericSignature sig = T->getInvocationGenericSignature()) {
       printGenericSignature(sig,
-                            /*inverses=*/{},
                             PrintAST::PrintParams |
-                            PrintAST::PrintRequirements);
+                            PrintAST::PrintRequirements |
+                            PrintAST::PrintInverseRequirements);
       Printer << " ";
     }
 
@@ -7351,11 +7269,13 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
       subBuffer.emplace(Printer, subOptions);
       sub = &*subBuffer;
 
+      GenericSignature sig = substitutions.getGenericSignature();
+
       sub->Printer << "@substituted ";
-      sub->printGenericSignature(substitutions.getGenericSignature(),
-                                 /*inverses=*/{},
+      sub->printGenericSignature(sig,
                                  PrintAST::PrintParams |
-                                 PrintAST::PrintRequirements);
+                                 PrintAST::PrintRequirements |
+                                 PrintAST::PrintInverseRequirements);
       sub->Printer << " ";
     }
 
@@ -7465,8 +7385,10 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
       // printer, but only the sub-Printer.
       [&sub, T]{
         if (auto sig = T->getLayout()->getGenericSignature()) {
-          sub.printGenericSignature(sig, /*inverses=*/{},
-                          PrintAST::PrintParams | PrintAST::PrintRequirements);
+          sub.printGenericSignature(sig,
+                          PrintAST::PrintParams |
+                          PrintAST::PrintRequirements |
+                          PrintAST::PrintInverseRequirements);
           sub.Printer << " ";
         }
         sub.Printer << "{";
@@ -8020,10 +7942,11 @@ void GenericSignature::print(ASTPrinter &Printer,
     Printer << "<null>";
     return;
   }
-  PrintAST(Printer, Opts).printGenericSignature(*this,
-                                                /*inverses=*/{},
-                                                PrintAST::PrintParams |
-                                                PrintAST::PrintRequirements);
+
+  auto flags = PrintAST::PrintParams | PrintAST::PrintRequirements;
+  if (Opts.PrintInverseRequirements)
+    flags |=  PrintAST::PrintInverseRequirements;
+  PrintAST(Printer, Opts).printGenericSignature(*this, flags);
 }
 
 void Requirement::print(raw_ostream &os, const PrintOptions &opts) const {
@@ -8221,9 +8144,10 @@ void ProtocolConformance::printName(llvm::raw_ostream &os,
       StreamPrinter sPrinter(os);
       TypePrinter typePrinter(sPrinter, PO);
       typePrinter
-          .printGenericSignature(genericSig, /*inverses=*/{},
+          .printGenericSignature(genericSig,
                                  PrintAST::PrintParams |
-                                 PrintAST::PrintRequirements);
+                                 PrintAST::PrintRequirements |
+                                 PrintAST::PrintInverseRequirements);
       os << ' ';
     }
   }
diff --git a/lib/SIL/IR/SILPrinter.cpp b/lib/SIL/IR/SILPrinter.cpp
@@ -2845,7 +2845,9 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
     auto pattern = KPI->getPattern();
     
     if (pattern->getGenericSignature()) {
-      pattern->getGenericSignature()->print(PrintState.OS);
+      PrintOptions Opts;
+      Opts.PrintInverseRequirements = true;
+      pattern->getGenericSignature()->print(PrintState.OS, Opts);
       *this << ' ';
     }
     
@@ -3777,7 +3779,6 @@ static void printFileIDMap(SILPrintContext &Ctx, const FileIDMap map) {
 }
 
 void SILProperty::print(SILPrintContext &Ctx) const {
-  PrintOptions Options = PrintOptions::printSIL(&Ctx);
 
   auto &OS = Ctx.OS();
   OS << "sil_property ";
@@ -3788,6 +3789,8 @@ void SILProperty::print(SILPrintContext &Ctx) const {
   printValueDecl(getDecl(), OS);
   if (auto sig = getDecl()->getInnermostDeclContext()
                           ->getGenericSignatureOfContext()) {
+    PrintOptions Options = PrintOptions::printSIL(&Ctx);
+    Options.PrintInverseRequirements = true;
     sig.getCanonicalSignature()->print(OS, Options);
   }
   OS << " (";
diff --git a/test/SILGen/typelowering_inverses.swift b/test/SILGen/typelowering_inverses.swift
