[Request-evaluator] Add -debug-cycles flag to print cycles.

As a debugging aid, introduce a new frontend flag `-debug-cycles` that
will emit a debug dump whenever the request-evaluator encounters a cyclic
dependency, while otherwise allowing compilation to continue.

Author: DougGregor

include/swift/AST/Evaluator.h

@@ -20,6 +20,7 @@
 
 #include "swift/AST/AnyRequest.h"
 #include "swift/Basic/AnyValue.h"
+#include "swift/Basic/CycleDiagnosticKind.h"
 #include "swift/Basic/Defer.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/Optional.h"
@@ -124,7 +125,7 @@ class Evaluator {
   DiagnosticEngine &diags;
 
   /// Whether to diagnose cycles or ignore them completely.
-  bool shouldDiagnoseCycles;
+  CycleDiagnosticKind shouldDiagnoseCycles;
 
   /// A vector containing all of the active evaluation requests, which
   /// is treated as a stack and is used to detect cycles.
@@ -147,7 +148,7 @@ class Evaluator {
 public:
   /// Construct a new evaluator that can emit cyclic-dependency
   /// diagnostics through the given diagnostics engine.
-  Evaluator(DiagnosticEngine &diags, bool shouldDiagnoseCycles);
+  Evaluator(DiagnosticEngine &diags, CycleDiagnosticKind shouldDiagnoseCycles);
 
   /// Evaluate the given request and produce its result,
   /// consulting/populating the cache as required.

include/swift/Basic/CycleDiagnosticKind.h

@@ -0,0 +1,34 @@
+//===--- CycleDiagnosticKind.h - Cycle Diagnostic Kind ----------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the CycleDiagnosticKind enum.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef CycleDiagnosticKind_h
+#define CycleDiagnosticKind_h
+
+namespace swift {
+
+/// How to diagnose cycles when they are encountered during evaluation.
+enum class CycleDiagnosticKind {
+  /// Don't diagnose cycles at all.
+  NoDiagnose,
+  /// Diagnose cycles as full-fledged errors.
+  FullDiagnose,
+  /// Diagnose cycles via debugging dumps.
+  DebugDiagnose,
+};
+
+} // end namespace swift
+
+#endif /* CycleDiagnosticKind_h */

include/swift/Basic/LangOptions.h

@@ -19,6 +19,7 @@
 #define SWIFT_BASIC_LANGOPTIONS_H
 
 #include "swift/Config.h"
+#include "swift/Basic/CycleDiagnosticKind.h"
 #include "swift/Basic/LLVM.h"
 #include "swift/Basic/Version.h"
 #include "clang/Basic/VersionTuple.h"
@@ -168,6 +169,10 @@ namespace swift {
     /// This is for testing purposes.
     std::string DebugForbidTypecheckPrefix;
 
+    /// \brief How to diagnose cycles encountered
+    CycleDiagnosticKind EvaluatorCycleDiagnostics =
+        CycleDiagnosticKind::NoDiagnose;
+
     /// \brief The upper bound, in bytes, of temporary data that can be
     /// allocated by the constraint solver.
     unsigned SolverMemoryThreshold = 512 * 1024 * 1024;

include/swift/Option/FrontendOptions.td

@@ -167,6 +167,9 @@ def debug_forbid_typecheck_prefix : Separate<["-"], "debug-forbid-typecheck-pref
   HelpText<"Triggers llvm fatal_error if typechecker tries to typecheck a decl "
            "with the provided prefix name">;
 
+def debug_cycles : Flag<["-"], "debug-cycles">,
+  HelpText<"Print out debug dumps when cycles are detected in evaluation">;
+
 def debug_time_compilation : Flag<["-"], "debug-time-compilation">,
   HelpText<"Prints the time taken by each compilation phase">;
 def debug_time_function_bodies : Flag<["-"], "debug-time-function-bodies">,

lib/AST/ASTContext.cpp

@@ -463,7 +463,7 @@ ASTContext::ASTContext(LangOptions &langOpts, SearchPathOptions &SearchPathOpts,
     SearchPathOpts(SearchPathOpts),
     SourceMgr(SourceMgr),
     Diags(Diags),
-    evaluator(Diags, /*shouldDiagnoseCycles=*/false),
+    evaluator(Diags, langOpts.EvaluatorCycleDiagnostics),
     TheBuiltinModule(createBuiltinModule(*this)),
     StdlibModuleName(getIdentifier(STDLIB_NAME)),
     SwiftShimsModuleName(getIdentifier(SWIFT_SHIMS_NAME)),

lib/AST/Evaluator.cpp

@@ -32,7 +32,8 @@ std::string AnyRequest::getAsString() const {
   return result;
 }
 
-Evaluator::Evaluator(DiagnosticEngine &diags, bool shouldDiagnoseCycles)
+Evaluator::Evaluator(DiagnosticEngine &diags,
+                     CycleDiagnosticKind shouldDiagnoseCycles)
   : diags(diags), shouldDiagnoseCycles(shouldDiagnoseCycles) { }
 
 bool Evaluator::checkDependency(const AnyRequest &request) {
@@ -45,8 +46,23 @@ bool Evaluator::checkDependency(const AnyRequest &request) {
     return false;
   }
 
-  if (shouldDiagnoseCycles)
+  switch (shouldDiagnoseCycles) {
+  case CycleDiagnosticKind::NoDiagnose:
+    return true;
+
+  case CycleDiagnosticKind::DebugDiagnose: {
+    llvm::dbgs() << "===CYCLE DETECTED===\n";
+    llvm::DenseSet<AnyRequest> visited;
+    std::string prefixStr;
+    printDependencies(activeRequests.front(), llvm::dbgs(), visited,
+                      prefixStr, /*lastChild=*/true);
+    return true;
+  }
+
+  case CycleDiagnosticKind::FullDiagnose:
     diagnoseCycle(request);
+    return true;
+  }
 
   return true;
 }

lib/Frontend/CompilerInvocation.cpp

@@ -253,6 +253,10 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
     Opts.DebugForbidTypecheckPrefix = A->getValue();
   }
 
+  if (Args.getLastArg(OPT_debug_cycles)) {
+    Opts.EvaluatorCycleDiagnostics = CycleDiagnosticKind::DebugDiagnose;
+  }
+
   if (const Arg *A = Args.getLastArg(OPT_solver_memory_threshold)) {
     unsigned threshold;
     if (StringRef(A->getValue()).getAsInteger(10, threshold)) {

test/decl/class/circular_inheritance.swift

@@ -1,4 +1,6 @@
 // RUN: %target-typecheck-verify-swift
+// RUN: not %target-swift-frontend -typecheck -debug-cycles %s 2> %t.cycles
+// RUN: %FileCheck %s < %t.cycles
 
 class C : B { } // expected-error{{circular class inheritance 'C' -> 'B' -> 'A' -> 'C'}}
 class B : A { } // expected-note{{class 'B' declared here}}
@@ -37,3 +39,10 @@ class Outer3
     : Outer3.Inner<Int> {
   class Inner<T> {}
 }
+
+// CHECK: ===CYCLE DETECTED===
+// CHECK-NEXT: `--SuperclassTypeRequest
+// CHECK-NEXT:      `--InheritedTypeRequest(circular_inheritance.(file).Left@
+// CHECK-NEXT:          `--SuperclassTypeRequest
+// CHECK-NEXT:              `--InheritedTypeRequest(circular_inheritance.(file).Right@
+// CHECK-NEXT:                  `--SuperclassTypeRequest{{.*}}(cyclic dependency)

unittests/AST/ArithmeticEvaluator.cpp

@@ -200,7 +200,7 @@ TEST(ArithmeticEvaluator, Simple) {
 
   SourceManager sourceMgr;
   DiagnosticEngine diags(sourceMgr);
-  Evaluator evaluator(diags, /*shouldDiagnoseCycles=*/true);
+  Evaluator evaluator(diags, CycleDiagnosticKind::FullDiagnose);
 
   const double expectedResult = (3.14159 + 2.71828) * 42.0;
   EXPECT_EQ(evaluator(InternallyCachedEvaluationRule(product)),
@@ -320,7 +320,7 @@ TEST(ArithmeticEvaluator, Cycle) {
 
   SourceManager sourceMgr;
   DiagnosticEngine diags(sourceMgr);
-  Evaluator evaluator(diags, /*shouldDiagnoseCycles=*/true);
+  Evaluator evaluator(diags, CycleDiagnosticKind::FullDiagnose);
 
   // Evaluate when there is a cycle.
   UncachedEvaluationRule::brokeCycle = false;