[ConstraintSystem] Move getAtomicLiteralKind to TypeVariableType::Implementation

Author: hborla

lib/Sema/CSSimplify.cpp

@@ -32,8 +32,6 @@
 #include "llvm/ADT/SetVector.h"
 #include "llvm/Support/Compiler.h"
 
-#include <unordered_set>
-
 using namespace swift;
 using namespace constraints;
 
@@ -10421,30 +10419,6 @@ void ConstraintSystem::addContextualConversionConstraint(
                 convertTypeLocator, /*isFavored*/ true);
 }
 
-Optional<ExprKind>
-ConstraintSystem::getAtomicLiteralKind(TypeVariableType *typeVar) const {
-  const std::unordered_set<ExprKind> atomicLiteralKinds = {
-    ExprKind::IntegerLiteral,
-    ExprKind::FloatLiteral,
-    ExprKind::StringLiteral,
-    ExprKind::BooleanLiteral,
-    ExprKind::NilLiteral,
-  };
-
-  if (!typeVar)
-    return None;
-
-  auto *locator = typeVar->getImpl().getLocator();
-  if (!locator->directlyAt<LiteralExpr>())
-    return None;
-
-  auto literalKind = getAsExpr(locator->getAnchor())->getKind();
-  if (!atomicLiteralKinds.count(literalKind))
-    return None;
-
-  return literalKind;
-}
-
 void ConstraintSystem::addFixConstraint(ConstraintFix *fix, ConstraintKind kind,
                                         Type first, Type second,
                                         ConstraintLocatorBuilder locator,

lib/Sema/ConstraintSystem.h

@@ -306,6 +306,11 @@ class TypeVariableType::Implementation {
   /// Retrieve the generic parameter opened by this type variable.
   GenericTypeParamType *getGenericParameter() const;
 
+  /// Returns the \c ExprKind of this type variable if it's the type of an
+  /// atomic literal expression, meaning the literal can't be composed of subexpressions.
+  /// Otherwise, returns \c None.
+  Optional<ExprKind> getAtomicLiteralKind() const;
+
   /// Determine whether this type variable represents a closure type.
   bool isClosureType() const;
 
@@ -2994,11 +2999,6 @@ class ConstraintSystem {
   bool isDeclUnavailable(const Decl *D,
                          ConstraintLocator *locator = nullptr) const;
 
-  /// Returns the \c ExprKind of the given type variable if it's the type of an
-  /// atomic literal expression, meaning the literal can't be composed of subexpressions.
-  /// Otherwise, returns \c None.
-  Optional<ExprKind> getAtomicLiteralKind(TypeVariableType *typeVar) const;
-
 public:
 
   /// Whether we should attempt to fix problems.
@@ -3127,18 +3127,19 @@ class ConstraintSystem {
       // We can merge the type variables of same-kind atomic literal expressions because they
       // will all have the same set of constraints and therefore can never resolve to anything
       // different.
-      auto *typeVar = type->getAs<TypeVariableType>();
-      if (auto literalKind = getAtomicLiteralKind(typeVar)) {
-        auto *&originalRep = representativeForKind[RawExprKind(*literalKind)];
-        auto *currentRep = getRepresentative(typeVar);
-
-        if (originalRep) {
-          if (originalRep != currentRep)
-            mergeEquivalenceClasses(currentRep, originalRep);
-          continue;
-        }
+      if (auto *typeVar = type->getAs<TypeVariableType>()) {
+        if (auto literalKind = typeVar->getImpl().getAtomicLiteralKind()) {
+          auto *&originalRep = representativeForKind[RawExprKind(*literalKind)];
+          auto *currentRep = getRepresentative(typeVar);
+
+          if (originalRep) {
+            if (originalRep != currentRep)
+              mergeEquivalenceClasses(currentRep, originalRep);
+            continue;
+          }
 
-        originalRep = currentRep;
+          originalRep = currentRep;
+        }
       }
 
       // Introduce conversions from each input type to the supertype.

lib/Sema/TypeCheckConstraints.cpp

@@ -82,6 +82,24 @@ TypeVariableType::Implementation::getGenericParameter() const {
   return locator ? locator->getGenericParameter() : nullptr;
 }
 
+Optional<ExprKind>
+TypeVariableType::Implementation::getAtomicLiteralKind() const {
+  if (!locator || !locator->directlyAt<LiteralExpr>())
+    return None;
+
+  auto kind = getAsExpr(locator->getAnchor())->getKind();
+  switch (kind) {
+  case ExprKind::IntegerLiteral:
+  case ExprKind::FloatLiteral:
+  case ExprKind::StringLiteral:
+  case ExprKind::BooleanLiteral:
+  case ExprKind::NilLiteral:
+    return kind;
+  default:
+    return None;
+  }
+}
+
 bool TypeVariableType::Implementation::isClosureType() const {
   if (!(locator && locator->getAnchor()))
     return false;