[AST] Rename resolveComponents -> setComponents

The naming here has bothered me for a little while
now, it just sets the components, it doesn't
resolve anything.

Author: hamishknight

include/swift/AST/Expr.h

@@ -5592,10 +5592,9 @@ class KeyPathExpr : public Expr {
     return Components;
   }
 
-  /// Resolve the components of an un-type-checked expr. This copies over the
-  /// components from the argument array.
-  void resolveComponents(ASTContext &C,
-                         ArrayRef<Component> resolvedComponents);
+  /// Set the key path components. This copies over the components from the
+  /// argument array.
+  void setComponents(ASTContext &C, ArrayRef<Component> newComponents);
 
   /// Indicates if the key path expression is composed by a single invalid
   /// component. e.g. missing component `\Root`

lib/AST/Expr.cpp

@@ -2001,20 +2001,20 @@ KeyPathExpr::KeyPathExpr(ASTContext &C, SourceLoc keywordLoc,
 }
 
 void
-KeyPathExpr::resolveComponents(ASTContext &C,
-                          ArrayRef<KeyPathExpr::Component> resolvedComponents) {
+KeyPathExpr::setComponents(ASTContext &C,
+                           ArrayRef<KeyPathExpr::Component> newComponents) {
   // Reallocate the components array if it needs to be.
-  if (Components.size() < resolvedComponents.size()) {
-    Components = C.Allocate<Component>(resolvedComponents.size());
+  if (Components.size() < newComponents.size()) {
+    Components = C.Allocate<Component>(newComponents.size());
     for (unsigned i : indices(Components)) {
       ::new ((void*)&Components[i]) Component{};
     }
   }
 
-  for (unsigned i : indices(resolvedComponents)) {
-    Components[i] = resolvedComponents[i];
+  for (unsigned i : indices(newComponents)) {
+    Components[i] = newComponents[i];
   }
-  Components = Components.slice(0, resolvedComponents.size());
+  Components = Components.slice(0, newComponents.size());
 }
 
 Optional<unsigned> KeyPathExpr::findComponentWithSubscriptArg(Expr *arg) {

lib/Sema/CSApply.cpp

@@ -2247,7 +2247,7 @@ namespace {
       case OverloadChoiceKind::KeyPathDynamicMemberLookup: {
         buildKeyPathSubscriptComponent(overload, dotLoc, /*args=*/nullptr,
                                        componentLoc, components);
-        keyPath->resolveComponents(ctx, components);
+        keyPath->setComponents(ctx, components);
         cs.cacheExprTypes(keyPath);
         return keyPath;
       }
@@ -2328,7 +2328,7 @@ namespace {
       cs.cacheType(componentExpr);
 
       keyPath->setParsedPath(componentExpr);
-      keyPath->resolveComponents(ctx, components);
+      keyPath->setComponents(ctx, components);
       cs.cacheExprTypes(keyPath);
 
       // See whether there's an equivalent ObjC key path string we can produce
@@ -4894,7 +4894,7 @@ namespace {
       }
 
       // Set the resolved components, and cache their types.
-      E->resolveComponents(cs.getASTContext(), resolvedComponents);
+      E->setComponents(cs.getASTContext(), resolvedComponents);
       cs.cacheExprTypes(E);
 
       // See whether there's an equivalent ObjC key path string we can produce

lib/Sema/PreCheckExpr.cpp

@@ -2008,7 +2008,7 @@ void PreCheckExpression::resolveKeyPathExpr(KeyPathExpr *KPE) {
   std::reverse(components.begin(), components.end());
 
   KPE->setRootType(rootType);
-  KPE->resolveComponents(getASTContext(), components);
+  KPE->setComponents(getASTContext(), components);
 }
 
 Expr *PreCheckExpression::simplifyTypeConstructionWithLiteralArg(Expr *E) {

lib/Sema/TypeCheckExprObjC.cpp

@@ -419,7 +419,7 @@ Optional<Type> TypeChecker::checkObjCKeyPathExpr(DeclContext *dc,
   // A successful check of an ObjC keypath shouldn't add or remove components,
   // currently.
   if (resolvedComponents.size() == expr->getComponents().size())
-    expr->resolveComponents(Context, resolvedComponents);
+    expr->setComponents(Context, resolvedComponents);
 
   // Check for an empty key-path string.
   auto keyPathString = keyPathOS.str();