Add public deps to GN

tools/gn/functions_target.cc

 // Copyright (c) 2013 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/functions.h"
 
 #include "tools/gn/config_values_generator.h"
 #include "tools/gn/err.h"
 #include "tools/gn/parse_tree.h"
 #include "tools/gn/scope.h"
 #include "tools/gn/target_generator.h"
 #include "tools/gn/value.h"
 #include "tools/gn/variables.h"
 
 #define DEPENDENT_CONFIG_VARS \
-    "  Dependent configs: all_dependent_configs, direct_dependent_configs\n"
+    "  Dependent configs: all_dependent_configs, public_configs\n"
 #define DEPS_VARS \
-    "  Deps: data, datadeps, deps, forward_dependent_configs_from, hard_dep\n"
+    "  Deps: data_deps, deps, forward_dependent_configs_from, public_deps\n"
 #define GENERAL_TARGET_VARS \
-    "  General: configs, inputs, sources\n"
+    "  General: check_includes, configs, data, inputs, output_name,\n" \
+    "           output_extension, public, sources, testonly, visibility\n"
 
 namespace functions {
 
 namespace {
 
 Value ExecuteGenericTarget(const char* target_type,
                            Scope* scope,
                            const FunctionCallNode* function,
                            const std::vector<Value>& args,
                            BlockNode* block,
@@ skipping 33 matching lines @@
     "  current build file and converted as needed automatically).\n"
 
 // Common help paragraph on script output directories.
 #define SCRIPT_EXECUTION_OUTPUTS \
     "  All output files must be inside the output directory of the build.\n" \
     "  You would generally use |$target_out_dir| or |$target_gen_dir| to\n" \
     "  reference the output or generated intermediate file directories,\n" \
     "  respectively.\n"
 
 #define ACTION_DEPS \
-    "  The \"deps\" for an action will always be completed before any part\n" \
-    "  of the action is run so it can depend on the output of previous\n" \
-    "  steps. The \"datadeps\" will be built if the action is built, but\n" \
-    "  may not have completed before all steps of the action are started.\n" \
-    "  This can give additional parallelism in the build for runtime-only\n" \
-    "  dependencies.\n"
+    "  The \"deps\" and \"public_deps\" for an action will always be\n" \
+    "  completed before any part of the action is run so it can depend on\n" \
+    "  the output of previous steps. The \"data_deps\" will be built if the\n" \
+    "  action is built, but may not have completed before all steps of the\n" \
+    "  action are started. This can give additional parallelism in the build\n"\
+    "  for runtime-only dependencies.\n"
 
 const char kAction[] = "action";
 const char kAction_HelpShort[] =
     "action: Declare a target that runs a script a single time.";
 const char kAction_Help[] =
     "action: Declare a target that runs a script a single time.\n"
     "\n"
     "  This target type allows you to run a script a single time to produce\n"
     "  or more output files. If you want to run a script once for each of a\n"
     "  set of input files, see \"gn help action_foreach\".\n"
@@ skipping 24 matching lines @@
     "  the \"outputs\".\n"
     "\n"
     SCRIPT_EXECUTION_CONTEXT
     "\n"
     "File name handling\n"
     "\n"
     SCRIPT_EXECUTION_OUTPUTS
     "\n"
     "Variables\n"
     "\n"
-    "  args, data, datadeps, depfile, deps, outputs*, script*,\n"
+    "  args, data, data_deps, depfile, deps, outputs*, script*,\n"
     "  inputs, sources\n"
     "  * = required\n"
     "\n"
     "Example\n"
     "\n"
     "  action(\"run_this_guy_once\") {\n"
     "    script = \"doprocessing.py\"\n"
     "    sources = [ \"my_configuration.txt\" ]\n"
     "    outputs = [ \"$target_gen_dir/insightful_output.txt\" ]\n"
     "\n"
@@ skipping 50 matching lines @@
     "Outputs\n"
     "\n"
     SCRIPT_EXECUTION_CONTEXT
     "\n"
     "File name handling\n"
     "\n"
     SCRIPT_EXECUTION_OUTPUTS
     "\n"
     "Variables\n"
     "\n"
-    "  args, data, datadeps, depfile, deps, outputs*, script*,\n"
+    "  args, data, data_deps, depfile, deps, outputs*, script*,\n"
     "  inputs, sources*\n"
     "  * = required\n"
     "\n"
     "Example\n"
     "\n"
     "  # Runs the script over each IDL file. The IDL script will generate\n"
     "  # both a .cc and a .h file for each input.\n"
     "  action_foreach(\"my_idl\") {\n"
     "    script = \"idl_processor.py\"\n"
     "    sources = [ \"foo.idl\", \"bar.idl\" ]\n"
@@ skipping 148 matching lines @@
 
 const char kSharedLibrary[] = "shared_library";
 const char kSharedLibrary_HelpShort[] =
     "shared_library: Declare a shared library target.";
 const char kSharedLibrary_Help[] =
     "shared_library: Declare a shared library target.\n"
     "\n"
     "  A shared library will be specified on the linker line for targets\n"
     "  listing the shared library in its \"deps\". If you don't want this\n"
     "  (say you dynamically load the library at runtime), then you should\n"
-    "  depend on the shared library via \"datadeps\" instead.\n"
+    "  depend on the shared library via \"data_deps\" instead.\n"
     "\n"
     "Variables\n"
     "\n"
     CONFIG_VALUES_VARS_HELP
     DEPS_VARS
     DEPENDENT_CONFIG_VARS
     GENERAL_TARGET_VARS;
 
 Value RunSharedLibrary(Scope* scope,
                        const FunctionCallNode* function,
@@ skipping 75 matching lines @@
 Value RunStaticLibrary(Scope* scope,
                        const FunctionCallNode* function,
                        const std::vector<Value>& args,
                        BlockNode* block,
                        Err* err) {
   return ExecuteGenericTarget(functions::kStaticLibrary, scope, function, args,
                               block, err);
 }
 
 }  // namespace functions