RequirementMachine: Initial implementation of requirement minimization

Author: slavapestov

lib/AST/RequirementMachine/Debug.h

@@ -45,7 +45,10 @@ enum class DebugFlags : unsigned {
   GeneratingConformances = (1<<7),
 
   /// Print debug output from the protocol dependency graph.
-  ProtocolDependencies = (1<<8)
+  ProtocolDependencies = (1<<8),
+
+  /// Print debug output from generic signature minimization.
+  Minimization = (1<<9),
 };
 
 using DebugOptions = OptionSet<DebugFlags>;

lib/AST/RequirementMachine/RequirementMachine.cpp

@@ -513,6 +513,74 @@ bool RequirementMachine::isComplete() const {
   return Complete;
 }
 
-void RequirementMachine::computeMinimalRequirements(const ProtocolDecl *proto) {
+void RequirementMachine::computeMinimalRequirements() {
   System.minimizeRewriteSystem();
+
+  llvm::DenseMap<const ProtocolDecl *, llvm::SmallVector<Requirement, 2>> reqs;
+
+  auto createRequirementFromRule = [&](
+      const Rule &rule,
+      TypeArrayView<GenericTypeParamType> genericParams)
+        -> Optional<Requirement> {
+    if (auto prop = rule.isPropertyRule()) {
+      auto subjectType = Context.getTypeForTerm(rule.getRHS(), genericParams,
+                                                System.getProtocols());
+
+      switch (prop->getKind()) {
+      case Symbol::Kind::Protocol:
+        return Requirement(RequirementKind::Conformance,
+                           subjectType,
+                           prop->getProtocol()->getDeclaredInterfaceType());
+
+      case Symbol::Kind::Layout:
+      case Symbol::Kind::ConcreteType:
+      case Symbol::Kind::Superclass:
+        return None;
+
+      case Symbol::Kind::Name:
+      case Symbol::Kind::AssociatedType:
+      case Symbol::Kind::GenericParam:
+        break;
+      }
+      llvm_unreachable("Invalid symbol kind");
+    } else if (rule.getLHS().back().getKind() != Symbol::Kind::Protocol) {
+      auto constraintType = Context.getTypeForTerm(rule.getLHS(), genericParams,
+                                                   System.getProtocols());
+      auto subjectType = Context.getTypeForTerm(rule.getRHS(), genericParams,
+                                                System.getProtocols());
+
+      return Requirement(RequirementKind::SameType, constraintType, subjectType);
+    }
+
+    return None;
+  };
+
+  for (const auto &rule : System.getRules()) {
+    if (rule.isPermanent())
+      continue;
+
+    if (rule.isRedundant())
+      continue;
+
+    auto domain = rule.getLHS()[0].getProtocols();
+    assert(domain.size() == 1);
+
+    const auto *proto = domain[0];
+    if (std::find(Protos.begin(), Protos.end(), proto) != Protos.end()) {
+      auto genericParams = proto->getGenericSignature().getGenericParams();
+      if (auto req = createRequirementFromRule(rule, genericParams))
+        reqs[proto].push_back(*req);
+    }
+  }
+
+  if (Context.getDebugOptions().contains(DebugFlags::Minimization)) {
+    for (const auto &pair : reqs) {
+      llvm::dbgs() << "Protocol " << pair.first->getName() << ":\n";
+      for (const auto &req : pair.second) {
+        llvm::dbgs() << "- ";
+        req.dump(llvm::dbgs());
+        llvm::dbgs() << "\n";
+      }
+    }
+  }
 }

lib/AST/RequirementMachine/RequirementMachine.h

@@ -113,7 +113,7 @@ class RequirementMachine final {
                                                  ProtocolDecl *protocol);
   TypeDecl *lookupNestedType(Type depType, Identifier name) const;
 
-  void computeMinimalRequirements(const ProtocolDecl *proto);
+  void computeMinimalRequirements();
 
   void verify(const MutableTerm &term) const;
   void dump(llvm::raw_ostream &out) const;

lib/AST/RequirementMachine/RewriteContext.cpp

@@ -38,6 +38,7 @@ static DebugOptions parseDebugFlags(StringRef debugFlags) {
       .Case("homotopy-reduction", DebugFlags::HomotopyReduction)
       .Case("generating-conformances", DebugFlags::GeneratingConformances)
       .Case("protocol-dependencies", DebugFlags::ProtocolDependencies)
+      .Case("minimization", DebugFlags::Minimization)
       .Default(None);
     if (!flag) {
       llvm::errs() << "Unknown debug flag in -debug-requirement-machine "

lib/AST/RequirementMachine/RewriteSystem.h

@@ -391,6 +391,10 @@ class RewriteSystem final {
     return (unsigned)(&rule - &*Rules.begin());
   }
 
+  ArrayRef<Rule> getRules() const {
+    return Rules;
+  }
+
   Rule &getRule(unsigned ruleID) {
     return Rules[ruleID];
   }