[NFC] Add pure test of pretty-printed cycle errors

This commit implements a facility to artificially cause a request cycle involving various types so we can test how circularity errors print without having to carefully craft test cases where they happen.

Author: beccadax

include/swift/AST/TypeCheckRequests.h

@@ -2956,6 +2956,31 @@ class TypeCheckCompletionHandlerAsyncAttrRequest
   bool isCached() const { return true; }
 };
 
+/// Perform a series of recursive calls with the \c first and \c rest decls that
+/// will eventually cause a cycle in the request stack.
+///
+/// This request is used to test diag::circular_reference and
+/// diag::circular_reference_through.
+class DebugIntentionallyCauseCycleRequest
+    : public SimpleRequest<
+          DebugIntentionallyCauseCycleRequest,
+          evaluator::SideEffect(Decl *, ArrayRef<Decl *>),
+          RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  evaluator::SideEffect
+  evaluate(Evaluator &evaluator, Decl *first, ArrayRef<Decl *> rest) const;
+
+public:
+  // Caching
+  bool isCached() const { return true; }
+};
+
 void simple_display(llvm::raw_ostream &out, Type value);
 void simple_display(llvm::raw_ostream &out, const TypeRepr *TyR);
 void simple_display(llvm::raw_ostream &out, ImplicitMemberAction action);

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -326,3 +326,6 @@ SWIFT_REQUEST(TypeChecker, GetImplicitSendableRequest,
 SWIFT_REQUEST(TypeChecker, TypeCheckCompletionHandlerAsyncAttrRequest,
               bool (AbstractFunctionDecl *, CompletionHandlerAsyncAttr *),
               Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, DebugIntentionallyCauseCycleRequest,
+              evaluator::SideEffect(Decl *, ArrayRef<Decl *>), Cached,
+              NoLocationInfo)

include/swift/Basic/LangOptions.h

@@ -572,6 +572,10 @@ namespace swift {
 
     /// See \ref FrontendOptions.PrintFullConvention
     bool PrintFullConvention = false;
+
+    /// Deliberately create a request cycle involving the declarations for the
+    /// types named here. Used to test the request evaluator's diagnostics.
+    std::vector<std::string> DebugCauseCycleViaDeclNames;
   };
 
   /// Options for controlling the behavior of the Clang importer.

include/swift/Option/FrontendOptions.td

@@ -271,6 +271,8 @@ def debug_emit_invalid_swiftinterface_syntax : Flag<["-"], "debug-emit-invalid-s
 
 def debug_cycles : Flag<["-"], "debug-cycles">,
   HelpText<"Print out debug dumps when cycles are detected in evaluation">;
+def debug_cause_cycle_via_decl : Separate<["-"], "debug-cause-cycle-via-decl">,
+  HelpText<"Intentially creates a request cycle involving each of the declarations passed with this flag">;
 
 def debug_time_function_bodies : Flag<["-"], "debug-time-function-bodies">,
   HelpText<"Dumps the time it takes to type-check each function body">;

lib/Frontend/CompilerInvocation.cpp

@@ -823,6 +823,10 @@ static bool ParseTypeCheckerArgs(TypeCheckerOptions &Opts, ArgList &Args,
     Opts.DebugForbidTypecheckPrefix = A->getValue();
   }
 
+  for (const Arg *A : Args.filtered(OPT_debug_cause_cycle_via_decl)) {
+    Opts.DebugCauseCycleViaDeclNames.push_back(A->getValue());
+  }
+
   if (Args.getLastArg(OPT_solver_disable_shrink))
     Opts.SolverDisableShrink = true;
 

lib/Sema/TypeChecker.cpp

@@ -350,13 +350,63 @@ void swift::performWholeModuleTypeChecking(SourceFile &SF) {
     diagnoseObjCMethodConflicts(SF);
     diagnoseObjCUnsatisfiedOptReqConflicts(SF);
     diagnoseUnintendedObjCMethodOverrides(SF);
-    return;
+    break;
   case SourceFileKind::SIL:
   case SourceFileKind::Interface:
     // SIL modules and .swiftinterface files don't benefit from whole-module
     // ObjC checking - skip it.
+    break;
+  }
+
+  // If requested, create an artificial cycle to diagnose an error at.
+  const auto &cycleViaDeclNames =
+      Ctx.TypeCheckerOpts.DebugCauseCycleViaDeclNames;
+  if (cycleViaDeclNames.empty())
     return;
+
+  SmallVector<Decl *, 4> cycleViaDecls;
+  for (const auto &fullName : cycleViaDeclNames) {
+    SmallVector<ComponentIdentTypeRepr *, 4> components;
+    StringRef rest{fullName};
+    do {
+      StringRef first;
+      std::tie(first, rest) = rest.split('.');
+
+      auto firstIdent = Ctx.getIdentifier(first);
+      components.push_back(
+         new (Ctx) SimpleIdentTypeRepr(DeclNameLoc(), DeclNameRef(firstIdent)));
+    } while (!rest.empty());
+
+    TypeRepr *repr = components.size() == 1
+                   ? static_cast<TypeRepr*>(components.front())
+                   : CompoundIdentTypeRepr::create(Ctx, components);
+    Type ty = swift::performTypeResolution(repr, Ctx, /*isSILMode=*/false,
+                                           /*isSILType=*/false,
+                                           /*GenericEnv=*/nullptr,
+                                           /*GenericParams=*/nullptr,
+                                           &SF);
+    cycleViaDecls.push_back(ty->getNominalOrBoundGenericNominal());
   }
+
+  (void)evaluateOrDefault(Ctx.evaluator, DebugIntentionallyCauseCycleRequest{
+                            cycleViaDecls.front(),
+                            makeArrayRef(cycleViaDecls).drop_front() },
+                          {});
+}
+
+evaluator::SideEffect
+DebugIntentionallyCauseCycleRequest::evaluate(Evaluator &evaluator, Decl *first,
+                                              ArrayRef<Decl *> rest) const {
+  if (rest.empty())
+    return evaluateOrDefault(evaluator, *this, {});
+
+  SmallVector<Decl *, 4> newRest;
+  llvm::append_range(newRest, rest.drop_front());
+  newRest.push_back(first);
+
+  return evaluateOrDefault(evaluator, DebugIntentionallyCauseCycleRequest{
+                               rest.front(), newRest },
+                           {});
 }
 
 bool swift::isAdditiveArithmeticConformanceDerivationEnabled(SourceFile &SF) {

test/CircularReferences/pretty_printed_decls.swift

@@ -0,0 +1,32 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend -parse-as-library -emit-module %S/Inputs/custom-modules/CircularLibrary.swift -I %S/Inputs/custom-modules -o %t/CircularLibrary.swiftmodule
+// RUN: not %target-swift-frontend -typecheck %s -I %S/Inputs/custom-modules -I %t -debug-cause-cycle-via-decl MyWholeNumber.RawValue -debug-cause-cycle-via-decl MyWholeNumber -debug-cause-cycle-via-decl MyNumberwang -debug-cycles 2>%t.txt
+// RUN: %FileCheck %s <%t.txt
+
+// REQUIRES: objc_interop
+
+import CircularLibrary
+
+// FIXME: This first failure is actually a bug! It's a purer form of the test
+//        case in test/CircularReferences/overlay_extensions.swift. (SR-14324)
+// CHECK-LABEL: {{^}}=== CYCLE DETECTED ===
+//   CHECK-NOT: error: circular reference
+//       CHECK: {{^}}==> DirectLookupRequest(directly looking up 'RawValue' on CircularLibrary.(file).MyWholeNumber with options
+//  CHECK-NEXT: {{^}}CircularLibrary.MyWholeNumber:{{[0-9]+:[0-9]+}}: error: circular reference
+//  CHECK-NEXT: {{^}}public enum MyWholeNumber : UInt32 {
+//  CHECK-NEXT: {{^}}            ^
+
+// This failure is the one the test case is actually intended to cause.
+// CHECK-LABEL: {{^}}=== CYCLE DETECTED ===
+//  CHECK-NEXT: {{^}}==> DebugIntentionallyCauseCycleRequest(Swift.(file).UInt32, {CircularLibrary.(file).MyWholeNumber, CircularLibrary.(file).MyNumberwang})
+//  CHECK-NEXT: {{^}}    DebugIntentionallyCauseCycleRequest(CircularLibrary.(file).MyWholeNumber, {CircularLibrary.(file).MyNumberwang, Swift.(file).UInt32})
+//  CHECK-NEXT: {{^}}    DebugIntentionallyCauseCycleRequest(CircularLibrary.(file).MyNumberwang, {Swift.(file).UInt32, CircularLibrary.(file).MyWholeNumber})
+//  CHECK-NEXT: {{^}}Swift.UInt32:{{[0-9]+:[0-9]+}}: error: circular reference
+//  CHECK-NEXT: {{^}}@frozen public struct UInt32 : FixedWidthInteger, UnsignedInteger, _ExpressibleByBuiltinIntegerLiteral {
+//  CHECK-NEXT: {{^}}                      ^
+//  CHECK-NEXT: {{^}}CircularLibrary.MyNumberwang:{{[0-9]+:[0-9]+}}: note: through reference here
+//  CHECK-NEXT: {{^}}open class MyNumberwang {
+//  CHECK-NEXT: {{^}}           ^
+//  CHECK-NEXT: {{^}}CircularLibrary.MyWholeNumber:{{[0-9]+:[0-9]+}}: note: through reference here
+//  CHECK-NEXT: {{^}}public enum MyWholeNumber : UInt32 {
+//  CHECK-NEXT: {{^}}            ^