RequirementMachine: Simplify the Symbol API for removal of merged associated types

Author: slavapestov

lib/AST/RequirementMachine/ConcreteTypeWitness.cpp

@@ -200,7 +200,7 @@ void PropertyMap::concretizeNestedTypesFromConcreteParent(
 
     // We only infer conditional requirements in top-level generic signatures,
     // not in protocol requirement signatures.
-    if (key.getRootProtocols().empty())
+    if (key.getRootProtocol() == nullptr)
       inferConditionalRequirements(concrete, substitutions);
   }
 }

lib/AST/RequirementMachine/GenericSignatureQueries.cpp

@@ -227,12 +227,10 @@ RequirementMachine::getLongestValidPrefix(const MutableTerm &term) const {
 
       auto conformsTo = props->getConformsTo();
 
-      for (const auto *proto : symbol.getProtocols()) {
-        // T.[P:A] is valid iff T conforms to P.
-        if (std::find(conformsTo.begin(), conformsTo.end(), proto)
-              == conformsTo.end())
-          return prefix;
-      }
+      // T.[P:A] is valid iff T conforms to P.
+      if (std::find(conformsTo.begin(), conformsTo.end(), symbol.getProtocol())
+            == conformsTo.end())
+        return prefix;
 
       break;
     }
@@ -720,7 +718,7 @@ void RequirementMachine::verify(const MutableTerm &term) const {
         continue;
 
       case Symbol::Kind::AssociatedType:
-        erased.add(Symbol::forProtocol(symbol.getProtocols()[0], Context));
+        erased.add(Symbol::forProtocol(symbol.getProtocol(), Context));
         break;
 
       case Symbol::Kind::Name:

lib/AST/RequirementMachine/HomotopyReduction.cpp

@@ -651,10 +651,7 @@ RewriteSystem::getMinimizedProtocolRules() const {
       continue;
     }
 
-    auto domain = rule.getLHS()[0].getProtocols();
-    assert(domain.size() == 1);
-
-    const auto *proto = domain[0];
+    const auto *proto = rule.getLHS().begin()->getProtocol();
     if (std::find(Protos.begin(), Protos.end(), proto) != Protos.end())
       rules[proto].push_back(ruleID);
   }
@@ -734,7 +731,7 @@ void RewriteSystem::verifyMinimizedRules(
     const auto &rule = getRule(ruleID);
 
     // Ignore the rewrite rule if it is not part of our minimization domain.
-    if (!isInMinimizationDomain(rule.getLHS().getRootProtocols()))
+    if (!isInMinimizationDomain(rule.getLHS().getRootProtocol()))
       continue;
 
     // Note that sometimes permanent rules can be simplified, but they can never

lib/AST/RequirementMachine/InterfaceType.cpp

@@ -177,26 +177,26 @@ AssociatedTypeDecl *RewriteContext::getAssociatedTypeForSymbol(Symbol symbol) {
   // The associated type An' is then the canonical associated type
   // representative of the associated type symbol [P0&...&Pn:A].
   //
-  for (auto *proto : symbol.getProtocols()) {
-    auto checkOtherAssocType = [&](AssociatedTypeDecl *otherAssocType) {
-      otherAssocType = otherAssocType->getAssociatedTypeAnchor();
+  auto *proto = symbol.getProtocol();
 
-      if (otherAssocType->getName() == name &&
-          (assocType == nullptr ||
-           TypeDecl::compare(otherAssocType->getProtocol(),
-                             assocType->getProtocol()) < 0)) {
-        assocType = otherAssocType;
-      }
-    };
+  auto checkOtherAssocType = [&](AssociatedTypeDecl *otherAssocType) {
+    otherAssocType = otherAssocType->getAssociatedTypeAnchor();
 
-    for (auto *otherAssocType : proto->getAssociatedTypeMembers()) {
-      checkOtherAssocType(otherAssocType);
+    if (otherAssocType->getName() == name &&
+        (assocType == nullptr ||
+         TypeDecl::compare(otherAssocType->getProtocol(),
+                           assocType->getProtocol()) < 0)) {
+      assocType = otherAssocType;
     }
+  };
 
-    for (auto *inheritedProto : getInheritedProtocols(proto)) {
-      for (auto *otherAssocType : inheritedProto->getAssociatedTypeMembers()) {
-        checkOtherAssocType(otherAssocType);
-      }
+  for (auto *otherAssocType : proto->getAssociatedTypeMembers()) {
+    checkOtherAssocType(otherAssocType);
+  }
+
+  for (auto *inheritedProto : getInheritedProtocols(proto)) {
+    for (auto *otherAssocType : inheritedProto->getAssociatedTypeMembers()) {
+      checkOtherAssocType(otherAssocType);
     }
   }
 
@@ -318,8 +318,8 @@ getTypeForSymbolRange(const Symbol *begin, const Symbol *end, Type root,
 #ifndef NDEBUG
       // Ensure that the domain of the suffix contains P.
       if (iter + 1 < end) {
-        auto protos = (iter + 1)->getProtocols();
-        assert(std::find(protos.begin(), protos.end(), symbol.getProtocol()));
+        auto proto = (iter + 1)->getProtocol();
+        assert(proto == symbol.getProtocol());
       }
 #endif
       continue;
@@ -350,10 +350,9 @@ getTypeForSymbolRange(const Symbol *begin, const Symbol *end, Type root,
       // of protocols that the prefix conforms to.
   #ifndef NDEBUG
       auto conformsTo = props->getConformsTo();
-      for (auto *otherProto : symbol.getProtocols()) {
-        assert(std::find(conformsTo.begin(), conformsTo.end(), otherProto)
-               != conformsTo.end());
-      }
+      assert(std::find(conformsTo.begin(), conformsTo.end(),
+                       symbol.getProtocol())
+             != conformsTo.end());
   #endif
 
       assocType = props->getAssociatedType(symbol.getName());

lib/AST/RequirementMachine/MinimalConformances.cpp

@@ -309,9 +309,7 @@ MinimalConformances::decomposeTermIntoConformanceRuleLeftHandSides(
 
   // Compute domain(V).
   const auto &lhs = rule.getLHS();
-  auto protocols = lhs[0].getProtocols();
-  assert(protocols.size() == 1);
-  auto protocol = Symbol::forProtocol(protocols[0], Context);
+  auto protocol = Symbol::forProtocol(lhs[0].getProtocol(), Context);
 
   // A same-type requirement of the form 'Self.Foo == Self' can induce a
   // conformance rule [P].[P] => [P], and we can end up with a minimal
@@ -356,10 +354,7 @@ static const ProtocolDecl *getParentConformanceForTerm(Term lhs) {
 
     // If we have a rule of the form X.[P:Y].[Q] => X.[P:Y] wih non-empty X,
     // then the parent type is X.[P].
-    const auto protos = parentSymbol.getProtocols();
-    assert(protos.size() == 1);
-
-    return protos[0];
+    return parentSymbol.getProtocol();
   }
 
   case Symbol::Kind::GenericParam:
@@ -401,7 +396,7 @@ void MinimalConformances::collectConformanceRules() {
     if (!rule.isAnyConformanceRule())
       continue;
 
-    if (!System.isInMinimizationDomain(rule.getLHS().getRootProtocols()))
+    if (!System.isInMinimizationDomain(rule.getLHS().getRootProtocol()))
       continue;
 
     ConformanceRules.push_back(ruleID);

lib/AST/RequirementMachine/PropertyRelations.cpp

@@ -101,9 +101,8 @@ unsigned RewriteSystem::recordConcreteTypeWitnessRelation(
          Symbol::Kind::ConcreteConformance);
   assert(associatedTypeSymbol.getKind() ==
          Symbol::Kind::AssociatedType);
-  assert(associatedTypeSymbol.getProtocols().size() == 1);
   assert(concreteConformanceSymbol.getProtocol() ==
-         associatedTypeSymbol.getProtocols()[0]);
+         associatedTypeSymbol.getProtocol());
   assert(typeWitnessSymbol.getKind() == Symbol::Kind::ConcreteType);
 
   MutableTerm rhsTerm;

lib/AST/RequirementMachine/RewriteContext.cpp

@@ -99,39 +99,10 @@ RewriteContext::getInheritedProtocols(const ProtocolDecl *proto) {
   return result;
 }
 
-unsigned RewriteContext::getProtocolSupport(
-    const ProtocolDecl *proto) {
-  return getInheritedProtocols(proto).size() + 1;
-}
-
-unsigned RewriteContext::getProtocolSupport(
-    ArrayRef<const ProtocolDecl *> protos) {
-  auto found = Support.find(protos);
-  if (found != Support.end())
-    return found->second;
-
-  unsigned result;
-  if (protos.size() == 1) {
-    result = getProtocolSupport(protos[0]);
-  } else {
-    llvm::DenseSet<const ProtocolDecl *> visited;
-    for (const auto *proto : protos) {
-      visited.insert(proto);
-      for (const auto *inheritedProto : getInheritedProtocols(proto))
-        visited.insert(inheritedProto);
-    }
-
-    result = visited.size();
-  }
-
-  Support[protos] = result;
-  return result;
-}
-
 int RewriteContext::compareProtocols(const ProtocolDecl *lhs,
                                      const ProtocolDecl *rhs) {
-  unsigned lhsSupport = getProtocolSupport(lhs);
-  unsigned rhsSupport = getProtocolSupport(rhs);
+  unsigned lhsSupport = getInheritedProtocols(lhs).size();
+  unsigned rhsSupport = getInheritedProtocols(rhs).size();
 
   if (lhsSupport != rhsSupport)
     return rhsSupport - lhsSupport;

lib/AST/RequirementMachine/RewriteContext.h

@@ -52,10 +52,6 @@ class RewriteContext final {
   llvm::DenseMap<const ProtocolDecl *,
                  llvm::TinyPtrVector<const ProtocolDecl *>> AllInherited;
 
-  /// Cached support of sets of protocols, which is the number of elements in
-  /// the transitive closure of the set under protocol inheritance.
-  llvm::DenseMap<ArrayRef<const ProtocolDecl *>, unsigned> Support;
-
   /// Cache for associated type declarations.
   llvm::DenseMap<Symbol, AssociatedTypeDecl *> AssocTypes;
 
@@ -148,10 +144,6 @@ class RewriteContext final {
   const llvm::TinyPtrVector<const ProtocolDecl *> &
   getInheritedProtocols(const ProtocolDecl *proto);
 
-  unsigned getProtocolSupport(const ProtocolDecl *proto);
-
-  unsigned getProtocolSupport(ArrayRef<const ProtocolDecl *> protos);
-
   int compareProtocols(const ProtocolDecl *lhs,
                        const ProtocolDecl *rhs);
 

lib/AST/RequirementMachine/RewriteSystem.cpp

@@ -647,15 +647,13 @@ void RewriteSystem::simplifyLeftHandSideSubstitutions() {
 ///
 /// All other loops can be discarded since they do not encode redundancies
 /// that are relevant to us.
-bool RewriteSystem::isInMinimizationDomain(
-    ArrayRef<const ProtocolDecl *> protos) const {
-  assert(protos.size() <= 1);
-  assert(Protos.empty() || !protos.empty());
+bool RewriteSystem::isInMinimizationDomain(const ProtocolDecl *proto) const {
+  assert(Protos.empty() || proto != nullptr);
 
-  if (protos.empty() && Protos.empty())
+  if (proto == nullptr && Protos.empty())
     return true;
 
-  if (std::find(Protos.begin(), Protos.end(), protos[0]) != Protos.end())
+  if (std::find(Protos.begin(), Protos.end(), proto) != Protos.end())
     return true;
 
   return false;
@@ -670,7 +668,7 @@ void RewriteSystem::recordRewriteLoop(MutableTerm basepoint,
     return;
 
   // Ignore the rewrite rule if it is not part of our minimization domain.
-  if (!isInMinimizationDomain(basepoint.getRootProtocols()))
+  if (!isInMinimizationDomain(basepoint.getRootProtocol()))
     return;
 
   Loops.push_back(loop);
@@ -740,8 +738,8 @@ void RewriteSystem::verifyRewriteRules(ValidityPolicy policy) const {
       }
     }
 
-    auto lhsDomain = lhs.getRootProtocols();
-    auto rhsDomain = rhs.getRootProtocols();
+    auto lhsDomain = lhs.getRootProtocol();
+    auto rhsDomain = rhs.getRootProtocol();
 
     ASSERT_RULE(lhsDomain == rhsDomain);
   }

lib/AST/RequirementMachine/RewriteSystem.h

@@ -452,7 +452,7 @@ class RewriteSystem final {
   void recordRewriteLoop(MutableTerm basepoint,
                          RewritePath path);
 
-  bool isInMinimizationDomain(ArrayRef<const ProtocolDecl *> protos) const;
+  bool isInMinimizationDomain(const ProtocolDecl *proto) const;
 
   ArrayRef<RewriteLoop> getLoops() const {
     return Loops;