Sema: Collect LiteralRequirements in PotentialBindings::infer()

Author: slavapestov

include/swift/Sema/CSBindings.h

@@ -179,6 +179,10 @@ struct LiteralRequirement {
 
   bool isDirectRequirement() const { return IsDirectRequirement; }
 
+  void setDirectRequirement(bool isDirectRequirement) {
+    IsDirectRequirement = isDirectRequirement;
+  }
+
   bool hasDefaultType() const { return bool(DefaultType); }
 
   Type getDefaultType() const {
@@ -248,6 +252,10 @@ struct PotentialBindings {
   /// The set of protocol conformance requirements imposed on this type variable.
   llvm::SmallVector<Constraint *, 4> Protocols;
 
+  /// The set of unique literal protocol requirements placed on this
+  /// type variable.
+  llvm::SmallVector<LiteralRequirement, 2> Literals;
+
   /// The set of fallback constraints imposed on this type variable.
   llvm::SmallVector<Constraint *, 2> Defaults;
 
@@ -270,7 +278,10 @@ struct PotentialBindings {
     return Protocols;
   }
 
-private:
+  void inferFromLiteral(ConstraintSystem &CS,
+                        TypeVariableType *TypeVar,
+                        Constraint *literal);
+
   /// Attempt to infer a new binding and other useful information
   /// (i.e. whether bindings should be delayed) from the given
   /// relational constraint.
@@ -279,7 +290,6 @@ struct PotentialBindings {
       TypeVariableType *TypeVar,
       Constraint *constraint);
 
-public:
   void infer(ConstraintSystem &CS,
              TypeVariableType *TypeVar,
              Constraint *constraint);
@@ -621,8 +631,6 @@ class BindingSet {
   /// checking.
   void addBinding(PotentialBinding binding, bool isTransitive);
 
-  void addLiteralRequirement(Constraint *literal);
-
   void addDefault(Constraint *constraint);
 
   StringRef getLiteralBindingKind(LiteralBindingKind K) const {

include/swift/Sema/CSTrail.def

@@ -76,6 +76,7 @@ GRAPH_NODE_CHANGE(AddedConstraint)
 GRAPH_NODE_CHANGE(RemovedConstraint)
 GRAPH_NODE_CHANGE(InferredBindings)
 GRAPH_NODE_CHANGE(RetractedBindings)
+GRAPH_NODE_CHANGE(RetractedLiteral)
 GRAPH_NODE_CHANGE(RetractedDelayedBy)
 GRAPH_NODE_CHANGE(RetractedProtocol)
 GRAPH_NODE_CHANGE(RetractedDefault)

lib/Sema/CSBindings.cpp

@@ -55,16 +55,8 @@ BindingSet::BindingSet(ConstraintSystem &CS, TypeVariableType *TypeVar,
   for (const auto &binding : info.Bindings)
     addBinding(binding, /*isTransitive=*/false);
 
-  for (auto *constraint : info.Constraints) {
-    switch (constraint->getKind()) {
-    case ConstraintKind::LiteralConformsTo:
-      addLiteralRequirement(constraint);
-      break;
-
-    default:
-      break;
-    }
-  }
+  for (const auto &literal : info.Literals)
+    Literals.push_back(literal);
 
   for (auto *constraint : info.Defaults) {
     // Do these in a separate pass.
@@ -653,8 +645,19 @@ void BindingSet::inferTransitiveSupertypeBindings() {
     // If one of the literal arguments doesn't propagate its
     // `ExpressibleByStringLiteral` conformance, we'd end up picking
     // `T` with only one type `Any?` which is incorrect.
-    for (const auto &literal : bindings.Literals)
-      addLiteralRequirement(literal.getSource());
+    for (auto literal : bindings.Literals) {
+      auto *protocol = literal.getProtocol();
+
+      bool found = llvm::any_of(Literals,
+          [&](const auto &literal) -> bool {
+            return literal.getProtocol() == protocol;
+          });
+      if (found)
+        continue;
+
+      literal.setDirectRequirement(false);
+      Literals.push_back(literal);
+    }
 
     // Infer transitive defaults.
     for (auto *def : bindings.Defaults) {
@@ -1055,7 +1058,9 @@ void BindingSet::coalesceIntegerAndFloatLiteralRequirements() {
   }
 }
 
-void BindingSet::addLiteralRequirement(Constraint *constraint) {
+void PotentialBindings::inferFromLiteral(ConstraintSystem &CS,
+                                         TypeVariableType *TypeVar,
+                                         Constraint *constraint) {
   auto *protocol = constraint->getProtocol();
 
   for (const auto &literal : Literals) {
@@ -2088,10 +2093,13 @@ void PotentialBindings::infer(ConstraintSystem &CS,
   case ConstraintKind::PackElementOf:
   case ConstraintKind::SameShape:
   case ConstraintKind::MaterializePackExpansion:
-  case ConstraintKind::LiteralConformsTo:
     // Constraints from which we can't do anything.
     break;
 
+  case ConstraintKind::LiteralConformsTo:
+    inferFromLiteral(CS, TypeVar, constraint);
+    break;
+
   case ConstraintKind::Defaultable:
   case ConstraintKind::FallbackType:
     Defaults.push_back(constraint);
@@ -2219,6 +2227,20 @@ void PotentialBindings::retract(ConstraintSystem &CS,
                       }),
       Bindings.end());
 
+  Literals.erase(
+      llvm::remove_if(Literals,
+                      [&](const LiteralRequirement &literal) {
+                        if (literal.getSource() == constraint) {
+                          if (recordingChanges) {
+                            CS.recordChange(SolverTrail::Change::RetractedLiteral(
+                                TypeVar, constraint));
+                          }
+                          return true;
+                        }
+                        return false;
+                      }),
+      Literals.end());
+
 #define CALLBACK(ChangeKind)                                                   \
   [&](Constraint *other) {                                                     \
     if (other == constraint) {                                                 \

lib/Sema/CSTrail.cpp

@@ -548,6 +548,12 @@ void SolverTrail::Change::undo(ConstraintSystem &cs) const {
         .Defaults.push_back(TheConstraint.Constraint);
     break;
 
+  case ChangeKind::RetractedLiteral:
+    cg[TheConstraint.TypeVar].getPotentialBindings()
+        .inferFromLiteral(cs, TheConstraint.TypeVar,
+                          TheConstraint.Constraint);
+    break;
+
   case ChangeKind::RetractedAdjacentVar:
     cg[BindingRelation.TypeVar].getPotentialBindings()
         .AdjacentVars.emplace_back(BindingRelation.OtherTypeVar,