Add forward_variables_from() and target() to GN

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 {
+
+namespace {
+
+void ForwardAllValues(const FunctionCallNode* function,
+                      Scope* source,
+                      Scope* dest,
+                      Err* err) {
+  Scope::MergeOptions options;
+  // This function needs to clobber existing for it to be useful. It will be
+  // called in a template to forward all values, but there will be some
+  // default stuff like configs set up in both scopes, so it would always
+  // fail if it didn't clobber.
+  options.clobber_existing = true;
+  options.skip_private_vars = true;
+  options.mark_dest_used = false;
+  source->NonRecursiveMergeTo(dest, options, function,
+                              "source scope", err);
+  source->MarkAllUsed();
+}
+
+void ForwardValuesFromList(Scope* source,
+                           Scope* dest,
+                           const std::vector<Value>& list,
+                           Err* err) {
+  for (const Value& cur : list) {
+    if (!cur.VerifyTypeIs(Value::STRING, err))
+      return;
+    const Value* value = source->GetValue(cur.string_value(), true);
+    if (value) {
+      // Use the storage key for the original value rather than the string in
+      // "cur" because "cur" is a temporary that will be deleted, and Scopes
+      // expect a persistent StringPiece (it won't copy). Not doing this will
+      // lead the scope's key to point to invalid memory after this returns.
+      base::StringPiece storage_key = source->GetStorageKey(cur.string_value());
+      if (storage_key.empty()) {
+        // Programmatic value, don't allow copying.
+        *err = Err(cur, "This value can't be forwarded.",
+            "The variable \"" + cur.string_value() + "\" is a built-in.");
+        return;
+      }
+
+      // Keep the origin information from the original value. The normal
+      // usage is for this to be used in a template, and if there's an error,
+      // the user expects to see the line where they set the variable
+      // blamed, rather than a template call to forward_variables_from().
+      dest->SetValue(storage_key, *value, value->origin());
+    }
+  }
+}
+
+}  // namespace
+
+const char kForwardVariablesFrom[] = "forward_variables_from";
+const char kForwardVariablesFrom_HelpShort[] =
+    "forward_variables_from: Copies variables from a different scope.";
+const char kForwardVariablesFrom_Help[] =
+    "forward_variables_from: Copies variables from a different scope.\n"
+    "\n"
+    "  forward_variables_from(from_scope, variable_list_or_star)\n"
+    "\n"
+    "  Copies the given variables from the given scope to the local scope\n"
+    "  if they exist. This is normally used in the context of templates to\n"
+    "  use the values of variables defined in the template invocation to\n"
+    "  a template-defined target.\n"
+    "\n"
+    "  The variables in the given variable_list will be copied if they exist\n"
+    "  in the given scope or any enclosing scope. If they do not exist,\n"
+    "  nothing will happen and they be left undefined in the current scope.\n"
+    "\n"
+    "  As a special case, if the variable_list is a string with the value of\n"
+    "  \"*\", all variables from the given scope will be copied. \"*\" only\n"
+    "  copies variables set directly on the from_scope, not enclosing ones.\n"
+    "  Otherwise it would duplicate all global variables.\n"
+    "\n"
+    "  When an explicit list of variables is supplied, if the variable exists\n"
+    "  in the current (destination) scope already, an error will be thrown.\n"
+    "  If \"*\" is specified, variables in the current scope will be\n"
+    "  clobbered (the latter is important because most targets have an\n"
+    "  implicit configs list, which means it wouldn't work at all if it\n"
+    "  didn't clobber).\n"
+    "\n"
+    "  The sources assignment filter (see \"gn help "
+          "set_sources_assignment_filter\")\n"
+    "  is never applied by this function. It's assumed than any desired\n"
+    "  filtering was already done when sources was set on the from_scope.\n"
+    "\n"
+    "Examples\n"
+    "\n"
+    "  # This is a common action template. It would invoke a script with\n"
+    "  # some given parameters, and wants to use the various types of deps\n"
+    "  # and the visibility from the invoker if it's defined. It also injects\n"
+    "  # an additional dependency to all targets.\n"
+    "  template(\"my_test\") {\n"
+    "    action(target_name) {\n"
+    "      forward_variables_from(invoker, [ \"data_deps\", \"deps\",\n"
+    "                                        \"public_deps\", \"visibility\" "
+                                                                         "])\n"
+    "      # Add our test code to the dependencies.\n"
+    "      # \"deps\" may or may not be defined at this point.\n"
+    "      if (defined(deps)) {\n"
+    "        deps += [ \"//tools/doom_melon\" ]\n"
+    "      } else {\n"
+    "        deps = [ \"//tools/doom_melon\" ]\n"
+    "      }\n"
+    "    }\n"
+    "  }\n"
+    "\n"
+    "  # This is a template around either a target whose type depends on a\n"
+    "  # global variable. It forwards all values from the invoker.\n"
+    "  template(\"my_wrapper\") {\n"
+    "    target(my_wrapper_target_type, target_name) {\n"
+    "      forward_variables_from(invoker, \"*\")\n"
+    "    }\n"
+    " }\n";
+
+// This function takes a ListNode rather than a resolved vector of values
+// both avoid copying the potentially-large source scope, and so the variables
+// in the source scope can be marked as used.
+Value RunForwardVariablesFrom(Scope* scope,
+                              const FunctionCallNode* function,
+                              const ListNode* args_list,
+                              Err* err) {
+  const std::vector<const ParseNode*>& args_vector = args_list->contents();
+  if (args_vector.size() != 2) {
+    *err = Err(function, "Wrong number of arguments.",
+               "Expecting exactly two.");
+    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.
+  const IdentifierNode* identifier = args_vector[0]->AsIdentifier();
+  if (!identifier) {
+    *err = Err(args_vector[0], "Expected an identifier for the scope.");
+    return Value();
+  }
+
+  // Extract the source scope.
+  Value* value = scope->GetMutableValue(identifier->value().value(), 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 list. If all_values is not set, the what_value will be a list.
+  Value what_value = args_vector[1]->Execute(scope, err);
+  if (err->has_error())
+    return Value();
+  if (what_value.type() == Value::STRING) {
+    if (what_value.string_value() == "*") {
+      ForwardAllValues(function, source, scope, err);
+      return Value();
+    }
+  } else {
+    if (what_value.type() == Value::LIST) {
+      ForwardValuesFromList(source, scope, what_value.list_value(), err);
+      return Value();
+    }
+  }
+
+  // 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