Merge pull request #38967 from slavapestov/clean-up-merged-assoc-types

RequirementMachine: Clean up merged associated type processing

Author: slavapestov

include/swift/Basic/LangOptions.h

@@ -459,12 +459,15 @@ namespace swift {
     RequirementMachineMode EnableRequirementMachine =
         RequirementMachineMode::Disabled;
 
-    /// Enables debugging output from the requirement machine.
-    bool DebugRequirementMachine = false;
+    /// Enables dumping rewrite systems from the requirement machine.
+    bool DumpRequirementMachine = false;
 
     /// 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

@@ -273,8 +273,11 @@ def debug_constraints_on_line_EQ : Joined<["-"], "debug-constraints-on-line=">,
 def disable_named_lazy_member_loading : Flag<["-"], "disable-named-lazy-member-loading">,
   HelpText<"Disable per-name lazy member loading">;
 
-def debug_requirement_machine : Flag<["-"], "debug-requirement-machine">,
-  HelpText<"Enables debugging output from the generics implementation">;
+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]>,

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/RequirementMachine.cpp

@@ -30,7 +30,7 @@ namespace {
 /// transitively-referenced protocols.
 struct RewriteSystemBuilder {
   RewriteContext &Context;
-  bool Debug;
+  bool Dump;
 
   ProtocolGraph Protocols;
   std::vector<std::pair<MutableTerm, MutableTerm>> Rules;
@@ -39,8 +39,8 @@ struct RewriteSystemBuilder {
                                         const ProtocolDecl *proto,
                                         SmallVectorImpl<Term> &result);
 
-  RewriteSystemBuilder(RewriteContext &ctx, bool debug)
-    : Context(ctx), Debug(debug) {}
+  RewriteSystemBuilder(RewriteContext &ctx, bool dump)
+    : Context(ctx), Dump(dump) {}
   void addGenericSignature(CanGenericSignature sig);
   void addAssociatedType(const AssociatedTypeDecl *type,
                          const ProtocolDecl *proto);
@@ -86,7 +86,7 @@ void RewriteSystemBuilder::addGenericSignature(CanGenericSignature sig) {
 
   // Add rewrite rules for each protocol.
   for (auto *proto : Protocols.getProtocols()) {
-    if (Debug) {
+    if (Dump) {
       llvm::dbgs() << "protocol " << proto->getName() << " {\n";
     }
 
@@ -101,7 +101,7 @@ void RewriteSystemBuilder::addGenericSignature(CanGenericSignature sig) {
     for (auto req : info.Requirements)
       addRequirement(req.getCanonical(), proto);
 
-    if (Debug) {
+    if (Dump) {
       llvm::dbgs() << "}\n";
     }
   }
@@ -140,7 +140,7 @@ void RewriteSystemBuilder::addAssociatedType(const AssociatedTypeDecl *type,
 /// protocol symbol.
 void RewriteSystemBuilder::addRequirement(const Requirement &req,
                                           const ProtocolDecl *proto) {
-  if (Debug) {
+  if (Dump) {
     llvm::dbgs() << "+ ";
     req.dump(llvm::dbgs());
     llvm::dbgs() << "\n";
@@ -310,7 +310,7 @@ void RequirementMachine::dump(llvm::raw_ostream &out) const {
 RequirementMachine::RequirementMachine(RewriteContext &ctx)
     : Context(ctx), System(ctx), Map(ctx, System.getProtocols()) {
   auto &langOpts = ctx.getASTContext().LangOpts;
-  Debug = langOpts.DebugRequirementMachine;
+  Dump = langOpts.DumpRequirementMachine;
   RequirementMachineStepLimit = langOpts.RequirementMachineStepLimit;
   RequirementMachineDepthLimit = langOpts.RequirementMachineDepthLimit;
   Stats = ctx.getASTContext().Stats;
@@ -331,14 +331,14 @@ void RequirementMachine::addGenericSignature(CanGenericSignature sig) {
 
   FrontendStatsTracer tracer(Stats, "build-rewrite-system");
 
-  if (Debug) {
+  if (Dump) {
     llvm::dbgs() << "Adding generic signature " << sig << " {\n";
   }
 
 
   // Collect the top-level requirements, and all transtively-referenced
   // protocol requirement signatures.
-  RewriteSystemBuilder builder(Context, Debug);
+  RewriteSystemBuilder builder(Context, Dump);
   builder.addGenericSignature(sig);
 
   // Add the initial set of rewrite rules to the rewrite system, also
@@ -348,7 +348,7 @@ void RequirementMachine::addGenericSignature(CanGenericSignature sig) {
 
   computeCompletion();
 
-  if (Debug) {
+  if (Dump) {
     llvm::dbgs() << "}\n";
   }
 }
@@ -413,7 +413,7 @@ void RequirementMachine::computeCompletion() {
       break;
   }
 
-  if (Debug) {
+  if (Dump) {
     dump(llvm::dbgs());
   }
 

lib/AST/RequirementMachine/RequirementMachine.h

@@ -52,7 +52,7 @@ class RequirementMachine final {
   RewriteSystem System;
   PropertyMap Map;
 
-  bool Debug = false;
+  bool Dump = false;
   bool Complete = false;
   unsigned RequirementMachineStepLimit;
   unsigned RequirementMachineDepthLimit;

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"
@@ -48,13 +49,18 @@ class RewriteContext final {
   /// Cache for associated type declarations.
   llvm::DenseMap<Symbol, AssociatedTypeDecl *> AssocTypes;
 
+  /// 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;
@@ -69,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,
@@ -91,6 +99,9 @@ class RewriteContext final {
   AssociatedTypeDecl *getAssociatedTypeForSymbol(Symbol symbol,
                                                  const ProtocolGraph &protos);
 
+  Symbol mergeAssociatedTypes(Symbol lhs, Symbol rhs,
+                              const ProtocolGraph &protos);
+
   ~RewriteContext();
 };