[CSBindings] Represent literal requirements as a struct instead of a tuple

Doing so streamlines access to the information associated with literal
protocol requirements and allows to add more helpers.

Also cache default type in the struct itself for easy access.

Author: xedin

include/swift/Sema/ConstraintSystem.h

@@ -4723,17 +4723,51 @@ class ConstraintSystem {
     }
   };
 
+  struct LiteralRequirement {
+    /// The source of the literal requirement.
+    Constraint *Source;
+    /// The default type associated with this literal (if any).
+    Type DefaultType;
+    /// Determines whether this literal is a direct requirement
+    /// of the current type variable.
+    bool IsDirectRequirement;
+
+    /// If the literal is covered by existing type binding,
+    /// this points to the source of the binding.
+    mutable Constraint *CoveredBy = nullptr;
+
+    Constraint *getSource() const { return Source; }
+
+    ProtocolDecl *getProtocol() const { return Source->getProtocol(); }
+
+    bool isCovered() const { return bool(CoveredBy); }
+
+    bool isDirectRequirement() const { return IsDirectRequirement; }
+
+    bool hasDefaultType() const { return bool(DefaultType); }
+
+    Type getDefaultType() const {
+      assert(hasDefaultType());
+      return DefaultType;
+    }
+
+    void setCoveredBy(Constraint *coveredBy) {
+      assert(!isCovered());
+      CoveredBy = coveredBy;
+    }
+
+    bool isCoveredBy(Type type, DeclContext *useDC) const;
+
+    /// Determines whether literal protocol associated with this
+    /// meta-information is viable for inclusion as a defaultable binding.
+    bool viableAsBinding() const { return !isCovered() && hasDefaultType(); }
+  };
+
+private:
   struct PotentialBindings {
     using BindingScore =
         std::tuple<bool, bool, bool, bool, bool, unsigned char, int>;
 
-    /// - Constraint * - The source of the literal requirement;
-    /// - bool - Determines whether this literal is a direct requirement
-    ///          of the current type variable;
-    /// - Constraint * - If the literal is covered, this points to the
-    ///                  source of the binding;
-    using LiteralInfo = std::tuple<Constraint *, bool, Constraint *>;
-
     /// The constraint system this type variable and its bindings belong to.
     ConstraintSystem &CS;
 
@@ -4755,7 +4789,7 @@ class ConstraintSystem {
     /// Note that ordering is important when it comes to bindings, we'd
     /// like to add any "direct" default types first to attempt them
     /// before transitive ones.
-    llvm::SmallMapVector<ProtocolDecl *, LiteralInfo, 2> Literals;
+    llvm::SmallMapVector<ProtocolDecl *, LiteralRequirement, 2> Literals;
 
     /// The set of constraints which would be used to infer default types.
     llvm::SmallDenseMap<CanType, Constraint *, 2> Defaults;
@@ -4970,15 +5004,9 @@ class ConstraintSystem {
     /// \param canBeNil The flag that determines whether given type
     /// variable requires all of its bindings to be optional.
     ///
-    /// \param isDirectRequirement The flag that determines whether
-    /// this literal conformance requirement is associated with the
-    /// current type variable or it's inferred.
-    ///
     /// \returns true if binding covers given literal protocol.
-    bool isLiteralCoveredBy(ProtocolDecl *literal,
-                            PotentialBinding &binding,
-                            bool canBeNil,
-                            bool isDirectRequirement) const;
+    bool isLiteralCoveredBy(const LiteralRequirement &literal,
+                            PotentialBinding &binding, bool canBeNil) const;
 
     /// Add a potential binding to the list of bindings,
     /// coalescing supertype bounds when we are able to compute the meet.

lib/Sema/CSBindings.cpp

@@ -319,7 +319,7 @@ void ConstraintSystem::PotentialBindings::inferTransitiveBindings(
     // `ExpressibleByStringLiteral` conformance, we'd end up picking
     // `T` with only one type `Any?` which is incorrect.
     for (const auto &literal : bindings.Literals)
-      addLiteral(std::get<0>(literal.second));
+      addLiteral(literal.second.getSource());
 
     // Infer transitive defaults.
     for (const auto &def : bindings.Defaults)
@@ -476,7 +476,8 @@ void ConstraintSystem::PotentialBindings::addDefault(Constraint *constraint) {
   Defaults.insert({defaultTy->getCanonicalType(), constraint});
 }
 
-static bool isCoveredBy(ProtocolDecl *protocol, Type type, DeclContext *useDC) {
+bool ConstraintSystem::LiteralRequirement::isCoveredBy(
+    Type type, DeclContext *useDC) const {
   auto coversDefaultType = [](Type type, Type defaultType) -> bool {
     if (!defaultType->hasUnboundGenericType())
       return type->isEqual(defaultType);
@@ -493,17 +494,15 @@ static bool isCoveredBy(ProtocolDecl *protocol, Type type, DeclContext *useDC) {
     return nominal == type->getAnyNominal();
   };
 
-  if (auto defaultType = TypeChecker::getDefaultType(protocol, useDC)) {
-    if (coversDefaultType(type, defaultType))
-      return true;
-  }
+  if (hasDefaultType() && coversDefaultType(type, getDefaultType()))
+    return true;
 
-  return bool(TypeChecker::conformsToProtocol(type, protocol, useDC));
+  return bool(TypeChecker::conformsToProtocol(type, getProtocol(), useDC));
 }
 
 bool ConstraintSystem::PotentialBindings::isLiteralCoveredBy(
-    ProtocolDecl *literal, PotentialBinding &binding, bool canBeNil,
-    bool isDirectRequirement) const {
+    const LiteralRequirement &literal, PotentialBinding &binding,
+    bool canBeNil) const {
   auto type = binding.BindingType;
   switch (binding.Kind) {
   case AllowedBindingKind::Exact:
@@ -521,7 +520,7 @@ bool ConstraintSystem::PotentialBindings::isLiteralCoveredBy(
 
   bool requiresUnwrap = false;
   do {
-    if (isCoveredBy(literal, type, CS.DC)) {
+    if (literal.isCoveredBy(type, CS.DC)) {
       // FIXME: Side-effect like this is not great (to say the least),
       // but this is an artifact of the binding collection which could
       // be fixed separately.
@@ -538,7 +537,7 @@ bool ConstraintSystem::PotentialBindings::isLiteralCoveredBy(
     // If this literal protocol is not a direct requirement it
     // would not be possible to change optionality while inferring
     // bindings for a supertype, so this hack doesn't apply.
-    if (!isDirectRequirement)
+    if (!literal.isDirectRequirement())
       return false;
 
     // If we're allowed to bind to subtypes, look through optionals.
@@ -613,12 +612,11 @@ void ConstraintSystem::PotentialBindings::addPotentialBinding(
               KnownProtocolKind::ExpressibleByNilLiteral))
         continue;
 
-      auto isDirectRequirement = std::get<1>(literal.second);
-      auto *&coveredBy = std::get<2>(literal.second);
+      auto &info = literal.second;
 
-      if (!coveredBy &&
-          isLiteralCoveredBy(protocol, binding, allowsNil, isDirectRequirement))
-        coveredBy = binding.getSource();
+      if (info.viableAsBinding() &&
+          isLiteralCoveredBy(info, binding, allowsNil))
+        info.setCoveredBy(binding.getSource());
     }
   }
 
@@ -661,32 +659,38 @@ void ConstraintSystem::PotentialBindings::addLiteral(Constraint *constraint) {
     return;
 
   bool isDirect = isDirectRequirement(constraint);
-  Constraint *coveredBy = nullptr;
 
   // Coverage is not applicable to `ExpressibleByNilLiteral` since it
   // doesn't have a default type.
   if (protocol->isSpecificProtocol(
           KnownProtocolKind::ExpressibleByNilLiteral)) {
-    Literals.insert(
-        {protocol, std::make_tuple(constraint, isDirect, coveredBy)});
+    Literals.insert({protocol,
+                     {.Source = constraint,
+                      .DefaultType = Type(),
+                      .IsDirectRequirement = isDirect}});
     return;
   }
 
   // Check whether any of the existing bindings covers this literal
   // protocol.
+  LiteralRequirement literal{.Source = constraint,
+                             .DefaultType =
+                                 TypeChecker::getDefaultType(protocol, CS.DC),
+                             .IsDirectRequirement = isDirect};
+
   {
     bool allowsNil = canBeNil();
 
     for (auto &binding : Bindings) {
-      if (!coveredBy &&
-          isLiteralCoveredBy(protocol, binding, allowsNil, isDirect)) {
-        coveredBy = binding.getSource();
+      if (!literal.isCovered() &&
+          isLiteralCoveredBy(literal, binding, allowsNil)) {
+        literal.setCoveredBy(binding.getSource());
         break;
       }
     }
   }
 
-  Literals.insert({protocol, std::make_tuple(constraint, isDirect, coveredBy)});
+  Literals.insert({protocol, std::move(literal)});
 }
 
 bool ConstraintSystem::PotentialBindings::isViable(
@@ -1180,10 +1184,10 @@ ConstraintSystem::PotentialBindings::getLiteralKind() const {
 
   for (const auto &literal : Literals) {
     auto *protocol = literal.first;
-    auto *coveredBy = std::get<2>(literal.second);
+    const auto &info = literal.second;
 
     // Only uncovered defaultable literal protocols participate.
-    if (coveredBy || !TypeChecker::getDefaultType(protocol, CS.DC))
+    if (!info.viableAsBinding())
       continue;
 
     switch (*protocol->getKnownProtocolKind()) {
@@ -1210,8 +1214,7 @@ ConstraintSystem::PotentialBindings::getLiteralKind() const {
 unsigned
 ConstraintSystem::PotentialBindings::getNumViableLiteralBindings() const {
   return llvm::count_if(Literals, [&](const auto &literal) {
-    auto *coveredBy = std::get<2>(literal.second);
-    return !(coveredBy || !TypeChecker::getDefaultType(literal.first, CS.DC));
+    return literal.second.viableAsBinding();
   });
 }
 

lib/Sema/CSSolver.cpp

@@ -2301,12 +2301,8 @@ void DisjunctionChoice::propagateConversionInfo(ConstraintSystem &cs) const {
     conversionType = bindings.Bindings[0].BindingType;
   } else {
     for (const auto &literal : bindings.Literals) {
-      auto *coveredBy = std::get<2>(literal.second);
-      if (coveredBy)
-        continue;
-
-      if (auto defaultTy = TypeChecker::getDefaultType(literal.first, cs.DC)) {
-        conversionType = defaultTy;
+      if (literal.second.viableAsBinding()) {
+        conversionType = literal.second.getDefaultType();
         break;
       }
     }

lib/Sema/ConstraintSystem.cpp

@@ -5368,30 +5368,19 @@ TypeVarBindingProducer::TypeVarBindingProducer(
   }
 
   // Infer defaults based on "uncovered" literal protocol requirements.
-  for (const auto &literal : bindings.Literals) {
-    Constraint *constraint = nullptr;
-    bool isDirectRequirement = false;
-    Constraint *coveredBy = nullptr;
+  for (const auto &info : bindings.Literals) {
+    const auto &literal = info.second;
 
-    std::tie(constraint, isDirectRequirement, coveredBy) = literal.second;
-
-    // Can't be defaulted because it's already covered by an
-    // existing direct or transitive binding which is always
-    // better.
-    if (coveredBy)
-      continue;
-
-    auto defaultType = TypeChecker::getDefaultType(literal.first, CS.DC);
-    if (!defaultType)
+    if (!literal.viableAsBinding())
       continue;
 
     // We need to figure out whether this is a direct conformance
     // requirement or inferred transitive one to identify binding
     // kind correctly.
-    addBinding(
-        {defaultType,
-         isDirectRequirement ? BindingKind::Subtypes : BindingKind::Supertypes,
-         constraint});
+    addBinding({literal.getDefaultType(),
+                literal.isDirectRequirement() ? BindingKind::Subtypes
+                                              : BindingKind::Supertypes,
+                literal.getSource()});
   }
 
   // Let's always consider `Any` to be a last resort binding because