Sema: Record fixed requirements in the trail

Author: slavapestov

include/swift/Sema/CSTrail.h

@@ -57,6 +57,8 @@ class SolverTrail {
     AddedConversionRestriction,
     /// Recorded a fix.
     AddedFix,
+    /// Recorded a fixed requirement.
+    AddedFixedRequirement,
   };
 
   /// A change made to the constraint system.
@@ -115,6 +117,11 @@ class SolverTrail {
       } Restriction;
 
       ConstraintFix *Fix;
+
+      struct {
+        GenericTypeParamType *GP;
+        Type ReqTy;
+      } FixedRequirement;
     };
 
     Change() : Kind(ChangeKind::AddedTypeVariable), TypeVar(nullptr) { }
@@ -157,6 +164,11 @@ class SolverTrail {
     /// Create a change that recorded a fix.
     static Change addedFix(ConstraintFix *fix);
 
+    /// Create a change that recorded a fixed requirement.
+    static Change addedFixedRequirement(GenericTypeParamType *GP,
+                                        unsigned reqKind,
+                                        Type requirementTy);
+
     /// Undo this change, reverting the constraint graph to the state it
     /// had prior to this change.
     ///

include/swift/Sema/ConstraintSystem.h

@@ -1507,6 +1507,11 @@ class Solution {
   /// to make the solution work.
   std::vector<ConstraintFix *> Fixes;
 
+  /// The list of fixed requirements.
+  using FixedRequirement =
+      std::tuple<GenericTypeParamType *, unsigned, TypeBase *>;
+  std::vector<FixedRequirement> FixedRequirements;
+
   /// Maps expressions for implied results (e.g implicit 'then' statements,
   /// implicit 'return' statements in single expression body closures) to their
   /// result kind.
@@ -2138,6 +2143,7 @@ class ConstraintSystem {
   friend class RequirementFailure;
   friend class MissingMemberFailure;
   friend struct ClosureIsolatedByPreconcurrency;
+  friend class SolverTrail;
 
   class SolverScope;
 
@@ -2363,12 +2369,22 @@ class ConstraintSystem {
   /// solver path.
   using FixedRequirement =
       std::tuple<GenericTypeParamType *, unsigned, TypeBase *>;
-  llvm::SmallSetVector<FixedRequirement, 4> FixedRequirements;
+  llvm::DenseSet<FixedRequirement> FixedRequirements;
 
   bool isFixedRequirement(ConstraintLocator *reqLocator, Type requirementTy);
+
+  /// Add a fixed requirement and record a change to the trail.
   void recordFixedRequirement(ConstraintLocator *reqLocator,
                               Type requirementTy);
 
+  /// Primitive form used when applying solution.
+  void recordFixedRequirement(GenericTypeParamType *paramTy,
+                              unsigned reqKind, Type reqTy);
+
+  /// Called to undo the above change.
+  void removeFixedRequirement(GenericTypeParamType *paramTy,
+                              unsigned reqKind, Type reqTy);
+
   /// A mapping from constraint locators to the opened existential archetype
   /// used for the 'self' of an existential type.
   llvm::SmallMapVector<ConstraintLocator *, OpenedArchetypeType *, 4>
@@ -2863,9 +2879,6 @@ class ConstraintSystem {
     /// FIXME: Remove this.
     unsigned numFixes;
 
-    /// The length of \c FixedRequirements.
-    unsigned numFixedRequirements;
-
     /// The length of \c DisjunctionChoices.
     unsigned numDisjunctionChoices;
 

lib/Sema/CSSolver.cpp

@@ -137,6 +137,10 @@ Solution ConstraintSystem::finalize() {
        llvm::make_range(Fixes.begin() + firstFixIndex, Fixes.end()))
     solution.Fixes.push_back(fix);
 
+  for (const auto &fix : FixedRequirements) {
+    solution.FixedRequirements.push_back(fix);
+  }
+
   // Remember all the disjunction choices we made.
   for (auto &choice : DisjunctionChoices) {
     solution.DisjunctionChoices.insert(choice);
@@ -421,6 +425,10 @@ void ConstraintSystem::applySolution(const Solution &solution) {
   // Register any fixes produced along this path.
   for (auto *fix : solution.Fixes)
     addFix(fix);
+
+  // Register fixed requirements.
+  for (auto fix : solution.FixedRequirements)
+    recordFixedRequirement(std::get<0>(fix), std::get<1>(fix), std::get<2>(fix));
 }
 bool ConstraintSystem::simplify() {
   // While we have a constraint in the worklist, process it.
@@ -654,7 +662,6 @@ ConstraintSystem::SolverScope::SolverScope(ConstraintSystem &cs)
 
   numTypeVariables = cs.TypeVariables.size();
   numFixes = cs.Fixes.size();
-  numFixedRequirements = cs.FixedRequirements.size();
   numDisjunctionChoices = cs.DisjunctionChoices.size();
   numAppliedDisjunctions = cs.AppliedDisjunctions.size();
   numArgumentMatchingChoices = cs.argumentMatchingChoices.size();
@@ -732,10 +739,6 @@ ConstraintSystem::SolverScope::~SolverScope() {
   // Remove any opened types.
   truncate(cs.OpenedTypes, numOpenedTypes);
 
-  // Remove any conformances solver had to fix along
-  // the current path.
-  truncate(cs.FixedRequirements, numFixedRequirements);
-
   // Remove any opened existential types.
   truncate(cs.OpenedExistentialTypes, numOpenedExistentialTypes);
 

lib/Sema/CSTrail.cpp

@@ -139,6 +139,18 @@ SolverTrail::Change::addedFix(ConstraintFix *fix) {
   return result;
 }
 
+SolverTrail::Change
+SolverTrail::Change::addedFixedRequirement(GenericTypeParamType *GP,
+                                           unsigned reqKind,
+                                           Type reqTy) {
+  Change result;
+  result.Kind = ChangeKind::AddedFixedRequirement;
+  result.FixedRequirement.GP = GP;
+  result.FixedRequirement.ReqTy = reqTy;
+  result.Options = reqKind;
+  return result;
+}
+
 void SolverTrail::Change::undo(ConstraintSystem &cs) const {
   auto &cg = cs.getConstraintGraph();
 
@@ -186,6 +198,11 @@ void SolverTrail::Change::undo(ConstraintSystem &cs) const {
   case ChangeKind::AddedFix:
     cs.removeFix(Fix);
     break;
+
+  case ChangeKind::AddedFixedRequirement:
+    cs.removeFixedRequirement(FixedRequirement.GP, Options,
+                              FixedRequirement.ReqTy);
+    break;
   }
 }
 
@@ -287,6 +304,15 @@ void SolverTrail::Change::dump(llvm::raw_ostream &out,
     Fix->print(out);
     out << ")\n";
     break;
+
+  case ChangeKind::AddedFixedRequirement:
+    out << "(added a fixed requirement ";
+    FixedRequirement.GP->print(out, PO);
+    out << " kind ";
+    out << Options << " ";
+    FixedRequirement.ReqTy->print(out, PO);
+    out << ")\n";
+    break;
   }
 }
 

lib/Sema/ConstraintSystem.cpp

@@ -4404,6 +4404,7 @@ size_t Solution::getTotalMemory() const {
          overloadChoices.getMemorySize() +
          ConstraintRestrictions.getMemorySize() +
          (Fixes.size() * sizeof(void *)) + DisjunctionChoices.getMemorySize() +
+         AppliedDisjunctions.getMemorySize() +
          OpenedTypes.getMemorySize() + OpenedExistentialTypes.getMemorySize() +
          OpenedPackExpansionTypes.getMemorySize() +
          PackExpansionEnvironments.getMemorySize() +
@@ -7369,11 +7370,31 @@ void ConstraintSystem::recordFixedRequirement(ConstraintLocator *reqLocator,
   if (auto reqInfo = getRequirementInfo(*this, reqLocator)) {
     auto *GP = reqInfo->first;
     auto reqKind = static_cast<unsigned>(reqInfo->second);
-    FixedRequirements.insert(
-        std::make_tuple(GP, reqKind, requirementTy.getPointer()));
+    recordFixedRequirement(GP, reqKind, requirementTy);
+  }
+}
+
+void ConstraintSystem::recordFixedRequirement(GenericTypeParamType *GP,
+                                              unsigned reqKind,
+                                              Type requirementTy) {
+  bool inserted = FixedRequirements.insert(
+      std::make_tuple(GP, reqKind, requirementTy.getPointer())).second;
+  if (inserted) {
+    if (isRecordingChanges()) {
+      recordChange(SolverTrail::Change::addedFixedRequirement(
+          GP, reqKind, requirementTy));
+    }
   }
 }
 
+void ConstraintSystem::removeFixedRequirement(GenericTypeParamType *GP,
+                                              unsigned reqKind,
+                                              Type requirementTy) {
+  auto key = std::make_tuple(GP, reqKind, requirementTy.getPointer());
+  bool erased = FixedRequirements.erase(key);
+  ASSERT(erased);
+}
+
 // Replace any error types encountered with placeholders.
 Type ConstraintSystem::getVarType(const VarDecl *var) {
   auto type = var->getTypeInContext();