RequirementMachine: Add -debug-requirement-machine= flag to control debug output

Author: slavapestov

include/swift/Basic/LangOptions.h

@@ -465,6 +465,9 @@ namespace swift {
     /// Enables statistics output from the requirement machine.
     bool AnalyzeRequirementMachine = false;
 
+    /// Enables fine-grained debug output from the requirement machine.
+    std::string DebugRequirementMachine;
+
     /// Maximum iteration count for requirement machine confluent completion
     /// algorithm.
     unsigned RequirementMachineStepLimit = 2000;

include/swift/Option/FrontendOptions.td

@@ -276,6 +276,9 @@ def disable_named_lazy_member_loading : Flag<["-"], "disable-named-lazy-member-l
 def dump_requirement_machine : Flag<["-"], "dump-requirement-machine">,
   HelpText<"Enables dumping rewrite systems from the generics implementation">;
 
+def debug_requirement_machine : Joined<["-"], "debug-requirement-machine=">,
+  HelpText<"Fine-grained debug output from the generics implementation">;
+
 def analyze_requirement_machine : Flag<["-"], "analyze-requirement-machine">,
   Flags<[FrontendOption, HelpHidden, DoesNotAffectIncrementalBuild]>,
   HelpText<"Print out requirement machine statistics at the end of the compilation job">;

lib/AST/RequirementMachine/Debug.h

@@ -0,0 +1,46 @@
+//===--- Debug.h - Requirement machine debugging flags ----------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2021 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_RQM_DEBUG_H
+#define SWIFT_RQM_DEBUG_H
+
+namespace swift {
+
+namespace rewriting {
+
+enum class DebugFlags : unsigned {
+  /// Print debug output when simplifying terms.
+  Simplify = (1<<0),
+
+  /// Print debug output when adding rules.
+  Add = (1<<1),
+
+  /// Print debug output when merging associated types.
+  Merge = (1<<2),
+
+  /// Print debug output from the Knuth-Bendix algorithm.
+  Completion = (1<<3),
+
+  /// Print debug output when unifying concrete types in the property map.
+  ConcreteUnification = (1<<4),
+
+  /// Print debug output when concretizing nested types in the property map.
+  ConcretizeNestedTypes = (1<<5)
+};
+
+using DebugOptions = OptionSet<DebugFlags>;
+
+}
+
+}
+
+#endif

lib/AST/RequirementMachine/PropertyMap.cpp

@@ -736,7 +736,7 @@ void PropertyMap::addProperty(
   assert(property.isProperty());
   auto *props = getOrCreateProperties(key);
   props->addProperty(property, Context,
-                     inducedRules, DebugConcreteUnification);
+                     inducedRules, Debug.contains(DebugFlags::ConcreteUnification));
 }
 
 /// For each fully-concrete type, find the shortest term having that concrete type.
@@ -772,7 +772,7 @@ void PropertyMap::concretizeNestedTypesFromConcreteParents(
     if (props->getConformsTo().empty())
       continue;
 
-    if (DebugConcretizeNestedTypes) {
+    if (Debug.contains(DebugFlags::ConcretizeNestedTypes)) {
       if (props->isConcreteType() ||
           props->hasSuperclassBound()) {
         llvm::dbgs() << "^ Concretizing nested types of ";
@@ -782,7 +782,7 @@ void PropertyMap::concretizeNestedTypesFromConcreteParents(
     }
 
     if (props->isConcreteType()) {
-      if (DebugConcretizeNestedTypes) {
+      if (Debug.contains(DebugFlags::ConcretizeNestedTypes)) {
         llvm::dbgs() << "- via concrete type requirement\n";
       }
 
@@ -797,7 +797,7 @@ void PropertyMap::concretizeNestedTypesFromConcreteParents(
     }
 
     if (props->hasSuperclassBound()) {
-      if (DebugConcretizeNestedTypes) {
+      if (Debug.contains(DebugFlags::ConcretizeNestedTypes)) {
         llvm::dbgs() << "- via superclass requirement\n";
       }
 
@@ -863,7 +863,7 @@ void PropertyMap::concretizeNestedTypesFromConcreteParent(
                                                  const_cast<ProtocolDecl *>(proto));
     if (conformance.isInvalid()) {
       // FIXME: Diagnose conflict
-      if (DebugConcretizeNestedTypes) {
+      if (Debug.contains(DebugFlags::ConcretizeNestedTypes)) {
         llvm::dbgs() << "^^ " << concreteType << " does not conform to "
                      << proto->getName() << "\n";
       }
@@ -886,15 +886,15 @@ void PropertyMap::concretizeNestedTypesFromConcreteParent(
       continue;
 
     for (auto *assocType : assocTypes) {
-      if (DebugConcretizeNestedTypes) {
+      if (Debug.contains(DebugFlags::ConcretizeNestedTypes)) {
         llvm::dbgs() << "^^ " << "Looking up type witness for "
                      << proto->getName() << ":" << assocType->getName()
                      << " on " << concreteType << "\n";
       }
 
       auto t = concrete->getTypeWitness(assocType);
       if (!t) {
-        if (DebugConcretizeNestedTypes) {
+        if (Debug.contains(DebugFlags::ConcretizeNestedTypes)) {
           llvm::dbgs() << "^^ " << "Type witness for " << assocType->getName()
                        << " of " << concreteType << " could not be inferred\n";
         }
@@ -904,7 +904,7 @@ void PropertyMap::concretizeNestedTypesFromConcreteParent(
 
       auto typeWitness = t->getCanonicalType();
 
-      if (DebugConcretizeNestedTypes) {
+      if (Debug.contains(DebugFlags::ConcretizeNestedTypes)) {
         llvm::dbgs() << "^^ " << "Type witness for " << assocType->getName()
                      << " of " << concreteType << " is " << typeWitness << "\n";
       }
@@ -920,7 +920,7 @@ void PropertyMap::concretizeNestedTypesFromConcreteParent(
         // FIXME: ConcreteTypeInDomainMap should support substitutions so
         // that we can remove this.
 
-        if (DebugConcretizeNestedTypes) {
+        if (Debug.contains(DebugFlags::ConcretizeNestedTypes)) {
           llvm::dbgs() << "^^ Type witness is the same as the concrete type\n";
         }
 
@@ -933,7 +933,7 @@ void PropertyMap::concretizeNestedTypesFromConcreteParent(
       }
 
       inducedRules.emplace_back(subjectType, constraintType);
-      if (DebugConcretizeNestedTypes) {
+      if (Debug.contains(DebugFlags::ConcretizeNestedTypes)) {
         llvm::dbgs() << "^^ Induced rule " << constraintType
                      << " => " << subjectType << "\n";
       }
@@ -977,7 +977,7 @@ MutableTerm PropertyMap::computeConstraintTermForTypeWitness(
     if (found != ConcreteTypeInDomainMap.end()) {
       MutableTerm result(found->second);
       if (result != subjectType) {
-        if (DebugConcretizeNestedTypes) {
+        if (Debug.contains(DebugFlags::ConcretizeNestedTypes)) {
           llvm::dbgs() << "^^ Type witness can re-use property bag of "
                        << found->second << "\n";
         }

lib/AST/RequirementMachine/PropertyMap.h

@@ -25,6 +25,7 @@
 #include <algorithm>
 #include <vector>
 
+#include "Debug.h"
 #include "ProtocolGraph.h"
 #include "RewriteContext.h"
 #include "RewriteSystem.h"
@@ -145,8 +146,7 @@ class PropertyMap {
   llvm::DenseMap<ConcreteTypeInDomain, Term> ConcreteTypeInDomainMap;
 
   const ProtocolGraph &Protos;
-  unsigned DebugConcreteUnification : 1;
-  unsigned DebugConcretizeNestedTypes : 1;
+  DebugOptions Debug;
 
   PropertyBag *getOrCreateProperties(Term key);
 
@@ -159,8 +159,7 @@ class PropertyMap {
   explicit PropertyMap(RewriteContext &ctx,
                        const ProtocolGraph &protos)
       : Context(ctx), Protos(protos) {
-    DebugConcreteUnification = false;
-    DebugConcretizeNestedTypes = false;
+    Debug = ctx.getDebugOptions();
   }
 
   ~PropertyMap();

lib/AST/RequirementMachine/RewriteContext.cpp

@@ -19,6 +19,33 @@
 using namespace swift;
 using namespace rewriting;
 
+/// Build a DebugOptions by parsing a comma-separated list of debug flags.
+static DebugOptions parseDebugFlags(StringRef debugFlags) {
+  DebugOptions result;
+
+  SmallVector<StringRef, 2> debug;
+  debugFlags.split(debug, ',');
+  for (auto flagStr : debug) {
+    auto flag = llvm::StringSwitch<Optional<DebugFlags>>(flagStr)
+      .Case("simplify", DebugFlags::Simplify)
+      .Case("add", DebugFlags::Add)
+      .Case("merge", DebugFlags::Merge)
+      .Case("completion", DebugFlags::Completion)
+      .Case("concrete-unification", DebugFlags::ConcreteUnification)
+      .Case("concretize-nested-types", DebugFlags::ConcretizeNestedTypes)
+      .Default(None);
+    if (!flag) {
+      llvm::errs() << "Unknown debug flag in -debug-requirement-machine "
+                   << flagStr << "\n";
+      abort();
+    }
+
+    result |= *flag;
+  }
+
+  return result;
+}
+
 RewriteContext::RewriteContext(ASTContext &ctx)
     : Context(ctx),
       Stats(ctx.Stats),
@@ -28,6 +55,9 @@ RewriteContext::RewriteContext(ASTContext &ctx)
       RuleTrieRootHistogram(16),
       PropertyTrieHistogram(16, /*Start=*/1),
       PropertyTrieRootHistogram(16) {
+  auto debugFlags = StringRef(ctx.LangOpts.DebugRequirementMachine);
+  if (!debugFlags.empty())
+    Debug = parseDebugFlags(debugFlags);
 }
 
 Term RewriteContext::getTermForType(CanType paramType,

lib/AST/RequirementMachine/RewriteContext.h

@@ -19,6 +19,7 @@
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/FoldingSet.h"
 #include "llvm/Support/Allocator.h"
+#include "Debug.h"
 #include "Histogram.h"
 #include "Symbol.h"
 #include "Term.h"
@@ -51,13 +52,15 @@ class RewriteContext final {
   /// Cache for merged associated type symbols.
   llvm::DenseMap<std::pair<Symbol, Symbol>, Symbol> MergedAssocTypes;
 
+  ASTContext &Context;
+
+  DebugOptions Debug;
+
   RewriteContext(const RewriteContext &) = delete;
   RewriteContext(RewriteContext &&) = delete;
   RewriteContext &operator=(const RewriteContext &) = delete;
   RewriteContext &operator=(RewriteContext &&) = delete;
 
-  ASTContext &Context;
-
 public:
   /// Statistics.
   UnifiedStatsReporter *Stats;
@@ -72,6 +75,8 @@ class RewriteContext final {
 
   explicit RewriteContext(ASTContext &ctx);
 
+  DebugOptions getDebugOptions() const { return Debug; }
+
   Term getTermForType(CanType paramType, const ProtocolDecl *proto);
 
   MutableTerm getMutableTermForType(CanType paramType,

lib/AST/RequirementMachine/RewriteSystem.cpp

@@ -24,12 +24,7 @@ using namespace swift;
 using namespace rewriting;
 
 RewriteSystem::RewriteSystem(RewriteContext &ctx)
-    : Context(ctx) {
-  DebugSimplify = false;
-  DebugAdd = false;
-  DebugMerge = false;
-  DebugCompletion = false;
-}
+    : Context(ctx), Debug(ctx.getDebugOptions()) {}
 
 RewriteSystem::~RewriteSystem() {
   Trie.updateHistograms(Context.RuleTrieHistogram,
@@ -93,7 +88,7 @@ bool RewriteSystem::addRule(MutableTerm lhs, MutableTerm rhs) {
 
   assert(lhs.compare(rhs, Protos) > 0);
 
-  if (DebugAdd) {
+  if (Debug.contains(DebugFlags::Add)) {
     llvm::dbgs() << "# Adding rule " << lhs << " => " << rhs << "\n";
   }
 
@@ -106,7 +101,7 @@ bool RewriteSystem::addRule(MutableTerm lhs, MutableTerm rhs) {
     llvm::errs() << "Old rule #" << *oldRuleID << ": ";
     oldRule.dump(llvm::errs());
     llvm::errs() << "\nTrying to replay what happened when I simplified this term:\n";
-    DebugSimplify = true;
+    Debug |= DebugFlags::Simplify;
     MutableTerm term = lhs;
     simplify(lhs);
 
@@ -135,7 +130,7 @@ bool RewriteSystem::addRule(MutableTerm lhs, MutableTerm rhs) {
 bool RewriteSystem::simplify(MutableTerm &term) const {
   bool changed = false;
 
-  if (DebugSimplify) {
+  if (Debug.contains(DebugFlags::Simplify)) {
     llvm::dbgs() << "= Term " << term << "\n";
   }
 
@@ -149,7 +144,7 @@ bool RewriteSystem::simplify(MutableTerm &term) const {
       if (ruleID) {
         const auto &rule = Rules[*ruleID];
         if (!rule.isDeleted()) {
-          if (DebugSimplify) {
+          if (Debug.contains(DebugFlags::Simplify)) {
             llvm::dbgs() << "== Rule #" << *ruleID << ": " << rule << "\n";
           }
 
@@ -158,7 +153,7 @@ bool RewriteSystem::simplify(MutableTerm &term) const {
 
           term.rewriteSubTerm(from, to, rule.getRHS());
 
-          if (DebugSimplify) {
+          if (Debug.contains(DebugFlags::Simplify)) {
             llvm::dbgs() << "=== Result " << term << "\n";
           }
 
@@ -205,7 +200,7 @@ void RewriteSystem::simplifyRewriteSystem() {
         if (Rules[*otherRuleID].isDeleted())
           continue;
 
-        if (DebugCompletion) {
+        if (Debug.contains(DebugFlags::Completion)) {
           const auto &otherRule = Rules[ruleID];
           llvm::dbgs() << "$ Deleting rule " << rule << " because "
                        << "its left hand side contains " << otherRule

lib/AST/RequirementMachine/RewriteSystem.h

@@ -15,6 +15,7 @@
 
 #include "llvm/ADT/DenseSet.h"
 
+#include "Debug.h"
 #include "ProtocolGraph.h"
 #include "Symbol.h"
 #include "Term.h"
@@ -111,11 +112,7 @@ class RewriteSystem final {
   /// Pairs of rules which have already been checked for overlap.
   llvm::DenseSet<std::pair<unsigned, unsigned>> CheckedOverlaps;
 
-  /// Set these to true to enable debugging output.
-  unsigned DebugSimplify : 1;
-  unsigned DebugAdd : 1;
-  unsigned DebugMerge : 1;
-  unsigned DebugCompletion : 1;
+  DebugOptions Debug;
 
 public:
   explicit RewriteSystem(RewriteContext &ctx);

lib/AST/RequirementMachine/RewriteSystemCompletion.cpp

@@ -219,14 +219,14 @@ void RewriteSystem::processMergedAssociatedTypes() {
     // If we have X.[P2:T] => Y.[P1:T], add a new pair of rules:
     // X.[P1:T] => X.[P1&P2:T]
     // X.[P2:T] => X.[P1&P2:T]
-    if (DebugMerge) {
+    if (Debug.contains(DebugFlags::Merge)) {
       llvm::dbgs() << "## Associated type merge candidate ";
       llvm::dbgs() << lhs << " => " << rhs << "\n";
     }
 
     auto mergedSymbol = Context.mergeAssociatedTypes(lhs.back(), rhs.back(),
                                                      Protos);
-    if (DebugMerge) {
+    if (Debug.contains(DebugFlags::Merge)) {
       llvm::dbgs() << "### Merged symbol " << mergedSymbol << "\n";
     }
 
@@ -259,7 +259,7 @@ void RewriteSystem::processMergedAssociatedTypes() {
           // or
           //
           //   [P2:T].[Q] => [P2:T]
-          if (DebugMerge) {
+          if (Debug.contains(DebugFlags::Merge)) {
             llvm::dbgs() << "### Lifting conformance rule " << otherRule << "\n";
           }
 
@@ -431,7 +431,7 @@ RewriteSystem::computeConfluentCompletion(unsigned maxIterations,
           // Try to repair the confluence violation by adding a new rule.
           resolvedCriticalPairs.push_back(computeCriticalPair(from, lhs, rhs));
 
-          if (DebugCompletion) {
+          if (Debug.contains(DebugFlags::Completion)) {
             const auto &pair = resolvedCriticalPairs.back();
 
             llvm::dbgs() << "$ Overlapping rules: (#" << i << ") ";