Merge pull request #76477 from slavapestov/tiny-rqm-cleanup

RequirementMachine: Small cleanup

Author: slavapestov

lib/AST/RequirementMachine/HomotopyReduction.cpp

@@ -501,7 +501,7 @@ void RewriteSystem::minimizeRewriteSystem(const PropertyMap &map) {
   performHomotopyReduction([&](unsigned loopID, unsigned ruleID) -> bool {
     const auto &rule = getRule(ruleID);
 
-    if (rule.containsUnresolvedSymbols())
+    if (rule.containsNameSymbols())
       return true;
 
     return false;
@@ -613,7 +613,7 @@ GenericSignatureErrors RewriteSystem::getErrors() const {
 
     if (!rule.isRedundant() &&
         !rule.isProtocolTypeAliasRule() &&
-        rule.containsUnresolvedSymbols())
+        rule.containsNameSymbols())
       result |= GenericSignatureErrorFlags::HasInvalidRequirements;
 
     if (rule.isRecursive())
@@ -626,7 +626,7 @@ GenericSignatureErrors RewriteSystem::getErrors() const {
 
         if (property->hasSubstitutions()) {
           for (auto t : property->getSubstitutions()) {
-            if (t.containsUnresolvedSymbols())
+            if (t.containsNameSymbols())
               result |= GenericSignatureErrorFlags::HasInvalidRequirements;
           }
         }
@@ -663,7 +663,7 @@ RewriteSystem::getMinimizedProtocolRules() const {
 
     if (rule.isProtocolTypeAliasRule())
       rules[proto].TypeAliases.push_back(ruleID);
-    else if (!rule.containsUnresolvedSymbols())
+    else if (!rule.containsNameSymbols())
       rules[proto].Requirements.push_back(ruleID);
   }
 
@@ -687,7 +687,7 @@ RewriteSystem::getMinimizedGenericSignatureRules() const {
     if (rule.isPermanent() ||
         rule.isRedundant() ||
         rule.isConflicting() ||
-        rule.containsUnresolvedSymbols()) {
+        rule.containsNameSymbols()) {
       continue;
     }
 
@@ -793,7 +793,7 @@ void RewriteSystem::verifyMinimizedRules(
         rule.isAnyConformanceRule() &&
         !rule.isRHSSimplified() &&
         !rule.isSubstitutionSimplified() &&
-        !rule.containsUnresolvedSymbols() &&
+        !rule.containsNameSymbols() &&
         !redundantConformances.count(ruleID)) {
       llvm::errs() << "Minimal conformance is redundant: " << rule << "\n\n";
       dump(llvm::errs());

lib/AST/RequirementMachine/InterfaceType.cpp

@@ -107,11 +107,6 @@
 using namespace swift;
 using namespace rewriting;
 
-Term RewriteContext::getTermForType(CanType paramType,
-                                    const ProtocolDecl *proto) {
-  return Term::get(getMutableTermForType(paramType, proto), *this);
-}
-
 /// Map an interface type to a term.
 ///
 /// If \p proto is null, this is a term relative to a generic

lib/AST/RequirementMachine/MinimalConformances.cpp

@@ -311,7 +311,7 @@ void MinimalConformances::collectConformanceRules() {
         rule.isSubstitutionSimplified())
       continue;
 
-    if (rule.containsUnresolvedSymbols())
+    if (rule.containsNameSymbols())
       continue;
 
     if (!rule.isAnyConformanceRule())
@@ -426,7 +426,7 @@ void RewriteSystem::computeCandidateConformancePaths(
     if (lhs.isRHSSimplified() ||
         lhs.isSubstitutionSimplified() ||
         lhs.isIdentityConformanceRule() ||
-        lhs.containsUnresolvedSymbols())
+        lhs.containsNameSymbols())
       continue;
 
     if (!lhs.isAnyConformanceRule() &&
@@ -505,7 +505,7 @@ void RewriteSystem::computeCandidateConformancePaths(
         if (rhs.isRHSSimplified() ||
             rhs.isSubstitutionSimplified() ||
             rhs.isIdentityConformanceRule() ||
-            rhs.containsUnresolvedSymbols())
+            rhs.containsNameSymbols())
           return;
 
         if (!rhs.isAnyConformanceRule() &&
@@ -951,7 +951,7 @@ void MinimalConformances::verifyMinimalConformances() const {
       continue;
     }
 
-    if (rule.containsUnresolvedSymbols()) {
+    if (rule.containsNameSymbols()) {
       llvm::errs() << "Minimal conformance contains unresolved symbols: ";
       llvm::errs() << rule << "\n\n";
       dumpMinimalConformanceEquations(llvm::errs());

lib/AST/RequirementMachine/RequirementBuilder.cpp

@@ -194,16 +194,16 @@ void RequirementBuilder::addRequirementRules(ArrayRef<unsigned> rules) {
 
       case Symbol::Kind::Superclass:
       case Symbol::Kind::ConcreteType: {
-        bool containsUnresolvedSymbols = false;
+        bool containsNameSymbols = false;
         for (auto term : prop->getSubstitutions()) {
-          containsUnresolvedSymbols |= term.containsUnresolvedSymbols();
+          containsNameSymbols |= term.containsNameSymbols();
         }
 
         Type concreteType = Map.getTypeFromSubstitutionSchema(
                                 prop->getConcreteType(),
                                 prop->getSubstitutions(),
                                 GenericParams, MutableTerm());
-        if (containsUnresolvedSymbols || rule.isRecursive())
+        if (containsNameSymbols || rule.isRecursive())
           concreteType = replaceTypeParametersWithErrorTypes(concreteType);
 
         if (ReconstituteSugar)
@@ -302,7 +302,7 @@ void RequirementBuilder::addTypeAliasRules(ArrayRef<unsigned> rules) {
       // Requirements containing unresolved name symbols originate from
       // invalid code and should not appear in the generic signature.
       for (auto term : prop->getSubstitutions()) {
-        if (term.containsUnresolvedSymbols())
+        if (term.containsNameSymbols())
           continue;
       }
 

lib/AST/RequirementMachine/RewriteContext.h

@@ -174,8 +174,6 @@ class RewriteContext final {
 
   static unsigned getGenericParamIndex(Type type);
 
-  Term getTermForType(CanType paramType, const ProtocolDecl *proto);
-
   MutableTerm getMutableTermForType(CanType paramType,
                                     const ProtocolDecl *proto);
 

lib/AST/RequirementMachine/RewriteSystem.h

@@ -65,9 +65,6 @@ class RewriteSystem final {
   /// top-level generic signature and this array is empty.
   ArrayRef<const ProtocolDecl *> Protos;
 
-  /// The requirements written in source code.
-  std::vector<StructuralRequirement> WrittenRequirements;
-
   /// The rules added so far, including rules from our client, as well
   /// as rules introduced by the completion procedure.
   std::vector<Rule> Rules;

lib/AST/RequirementMachine/Rule.cpp

@@ -177,9 +177,9 @@ std::optional<Identifier> Rule::isProtocolTypeAliasRule() const {
   if (LHS.size() == 2) {
     // This is the case where the underlying type is a type parameter.
     //
-    // We shouldn't have unresolved symbols on the right hand side;
-    // they should have been simplified away.
-    if (RHS.containsUnresolvedSymbols()) {
+    // We shouldn't have name symbols on the right hand side; they
+    // should have been simplified away.
+    if (RHS.containsNameSymbols()) {
       if (RHS.size() != 2 ||
           RHS[0] != LHS[0] ||
           RHS[1].getKind() != Symbol::Kind::Name) {

lib/AST/RequirementMachine/Rule.h

@@ -38,14 +38,6 @@ class Rule final {
   Term LHS;
   Term RHS;
 
-  /// The written requirement ID, which can be used to index into the
-  /// \c WrittenRequirements array in the rewrite system to retrieve
-  /// the structural requirement.
-  ///
-  /// This uses a biased representation where an ID of 0 means 'no ID',
-  /// otherwise the value is the actual ID plus one.
-  unsigned RequirementID : 16;
-
   /// A 'permanent' rule cannot be deleted by homotopy reduction. These
   /// do not correspond to generic requirements and are re-added when the
   /// rewrite system is built.
@@ -96,7 +88,6 @@ class Rule final {
 public:
   Rule(Term lhs, Term rhs)
       : LHS(lhs), RHS(rhs) {
-    RequirementID = 0;
     Permanent = false;
     Explicit = false;
     LHSSimplified = false;
@@ -162,9 +153,9 @@ class Rule final {
     return Frozen;
   }
 
-  bool containsUnresolvedSymbols() const {
-    return (LHS.containsUnresolvedSymbols() ||
-            RHS.containsUnresolvedSymbols());
+  bool containsNameSymbols() const {
+    return (LHS.containsNameSymbols() ||
+            RHS.containsNameSymbols());
   }
 
   std::optional<Identifier> isProtocolTypeAliasRule() const;
@@ -228,7 +219,6 @@ class Rule final {
 
   void freeze() {
     Redundant = false;
-    RequirementID = 0;
     Frozen = true;
   }
 

lib/AST/RequirementMachine/Symbol.cpp

@@ -113,7 +113,7 @@ struct Symbol::Storage final
   }
 
   Storage(CanType type, ArrayRef<Term> substitutions, const ProtocolDecl *proto) {
-    DEBUG_ASSERT(!type->hasTypeVariable());
+    ASSERT(!type->hasTypeVariable());
     ASSERT(type->hasTypeParameter() != substitutions.empty());
 
     Kind = Symbol::Kind::ConcreteConformance;

lib/AST/RequirementMachine/Term.cpp

@@ -113,7 +113,7 @@ void Term::Storage::Profile(llvm::FoldingSetNodeID &id) const {
     id.AddPointer(symbol.getOpaquePointer());
 }
 
-bool Term::containsUnresolvedSymbols() const {
+bool Term::containsNameSymbols() const {
   for (auto symbol : *this) {
     if (symbol.getKind() == Symbol::Kind::Name)
       return true;

lib/AST/RequirementMachine/Term.h

@@ -76,7 +76,7 @@ class Term final {
     return begin()->getRootProtocol();
   }
 
-  bool containsUnresolvedSymbols() const;
+  bool containsNameSymbols() const;
 
   void dump(llvm::raw_ostream &out) const;