Make getObjectLiteralConstructorName a utility

Author: CodaFi

lib/Sema/CSDiag.cpp

@@ -3531,13 +3531,14 @@ bool FailureDiagnosis::visitObjectLiteralExpr(ObjectLiteralExpr *E) {
   auto protocol = TypeChecker::getLiteralProtocol(CS.getASTContext(), E);
   if (!protocol)
     return false;
-  DeclName constrName = TC.getObjectLiteralConstructorName(E);
+  auto constrName =
+      TypeChecker::getObjectLiteralConstructorName(CS.getASTContext(), E);
   assert(constrName);
   auto *constr = dyn_cast_or_null<ConstructorDecl>(
       protocol->getSingleRequirement(constrName));
   if (!constr)
     return false;
-  auto paramType = TC.getObjectLiteralParameterType(E, constr);
+  auto paramType = TypeChecker::getObjectLiteralParameterType(E, constr);
   if (!typeCheckChildIndependently(
         E->getArg(), paramType, CTP_CallArgument))
     return true;

lib/Sema/CSGen.cpp

@@ -1260,10 +1260,10 @@ namespace {
       if (expr->getType())
         return expr->getType();
 
-      auto &tc = CS.getTypeChecker();
+      auto &de = CS.getASTContext().Diags;
       auto protocol = TypeChecker::getLiteralProtocol(CS.getASTContext(), expr);
       if (!protocol) {
-        tc.diagnose(expr->getLoc(), diag::use_unknown_object_literal_protocol,
+        de.diagnose(expr->getLoc(), diag::use_unknown_object_literal_protocol,
                     expr->getLiteralKindPlainName());
         return nullptr;
       }
@@ -1282,15 +1282,18 @@ namespace {
       // all the redundant stuff about literals (leaving e.g. "red:").
       // Constraint application will quietly rewrite the type of 'args' to
       // use the right labels before forming the call to the initializer.
-      DeclName constrName = tc.getObjectLiteralConstructorName(expr);
+      auto constrName =
+          TypeChecker::getObjectLiteralConstructorName(CS.getASTContext(),
+                                                       expr);
       assert(constrName);
       auto *constr = dyn_cast_or_null<ConstructorDecl>(
           protocol->getSingleRequirement(constrName));
       if (!constr) {
-        tc.diagnose(protocol, diag::object_literal_broken_proto);
+        de.diagnose(protocol, diag::object_literal_broken_proto);
         return nullptr;
       }
-      auto constrParamType = tc.getObjectLiteralParameterType(expr, constr);
+      auto constrParamType =
+          TypeChecker::getObjectLiteralParameterType(expr, constr);
 
       // Extract the arguments.
       SmallVector<AnyFunctionType::Param, 8> args;

lib/Sema/TypeChecker.cpp

@@ -161,7 +161,8 @@ ProtocolDecl *TypeChecker::getLiteralProtocol(ASTContext &Context, Expr *expr) {
   return nullptr;
 }
 
-DeclName TypeChecker::getObjectLiteralConstructorName(ObjectLiteralExpr *expr) {
+DeclName TypeChecker::getObjectLiteralConstructorName(ASTContext &Context,
+                                                      ObjectLiteralExpr *expr) {
   switch (expr->getLiteralKind()) {
   case ObjectLiteralExpr::colorLiteral: {
     return DeclName(Context, DeclBaseName::createConstructor(),
@@ -200,6 +201,7 @@ Type TypeChecker::getObjectLiteralParameterType(ObjectLiteralExpr *expr,
   newParams.append(params.begin(), params.end());
 
   auto replace = [&](StringRef replacement) -> Type {
+    auto &Context = ctor->getASTContext();
     newParams[0] = AnyFunctionType::Param(newParams[0].getPlainType(),
                                           Context.getIdentifier(replacement),
                                           newParams[0].getParameterFlags());

lib/Sema/TypeChecker.h

@@ -1648,10 +1648,11 @@ class TypeChecker final {
   /// expression does not have an associated literal protocol.
   static ProtocolDecl *getLiteralProtocol(ASTContext &ctx, Expr *expr);
 
-  DeclName getObjectLiteralConstructorName(ObjectLiteralExpr *expr);
+  static DeclName getObjectLiteralConstructorName(ASTContext &ctx,
+                                                  ObjectLiteralExpr *expr);
 
-  Type getObjectLiteralParameterType(ObjectLiteralExpr *expr,
-                                     ConstructorDecl *ctor);
+  static Type getObjectLiteralParameterType(ObjectLiteralExpr *expr,
+                                            ConstructorDecl *ctor);
 
   /// Get the module appropriate for looking up standard library types.
   ///