Update GN toolchain_args to be a variable.

tools/gn/function_forward_variables_from.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "tools/gn/err.h"
 #include "tools/gn/functions.h"
 #include "tools/gn/parse_tree.h"
 #include "tools/gn/scope.h"
 
 namespace functions {
@@ skipping 154 matching lines @@
                               const FunctionCallNode* function,
                               const ListNode* args_list,
                               Err* err) {
   const auto& args_vector = args_list->contents();
   if (args_vector.size() != 2 && args_vector.size() != 3) {
     *err = Err(function, "Wrong number of arguments.",
                "Expecting two or three arguments.");
     return Value();
   }
 
-  // Extract the scope identifier. This assumes the first parameter is an
-  // identifier. It is difficult to write code where this is not the case, and
-  // this saves an expensive scope copy. If necessary, this could be expanded
-  // to execute the ParseNode and get the value out if it's not an identifer.
+  Value* value = nullptr;  // Value to use, may point to result_value.
+  Value result_value;  // Storage for the "evaluate" case.
   const IdentifierNode* identifier = args_vector[0]->AsIdentifier();
-  if (!identifier) {
-    *err = Err(args_vector[0].get(), "Expected an identifier for the scope.");
-    return Value();
+  if (identifier) {
+    // Optimize the common case where the input scope is an identifier. This
+    // prevents a copy of a potentially large Scope object.
+    value = scope->GetMutableValue(identifier->value().value(),
+                                   Scope::SEARCH_NESTED, true);
+    if (!value) {
+      *err = Err(identifier, "Undefined identifier.");
+      return Value();
+    }
+  } else {
+    // Non-optimized case, just evaluate the argument.
+    result_value = args_vector[0]->Execute(scope, err);
+    if (err->has_error())
+      return Value();
+    value = &result_value;
   }
 
   // Extract the source scope.
-  Value* value = scope->GetMutableValue(
-      identifier->value().value(), Scope::SEARCH_NESTED, true);
-  if (!value) {
-    *err = Err(identifier, "Undefined identifier.");
-    return Value();
-  }
   if (!value->VerifyTypeIs(Value::SCOPE, err))
     return Value();
   Scope* source = value->scope_value();
 
   // Extract the exclusion list if defined.
   std::set<std::string> exclusion_set;
   if (args_vector.size() == 3) {
     Value exclusion_value = args_vector[2]->Execute(scope, err);
     if (err->has_error())
       return Value();
@@ skipping 29 matching lines @@
     }
   }
 
   // Not the right type of argument.
   *err = Err(what_value, "Not a valid list of variables to copy.",
              "Expecting either the string \"*\" or a list of strings.");
   return Value();
 }
 
 }  // namespace functions