Allow GN toolchains to specify runtime deps outputs.

tools/gn/function_toolchain.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 <algorithm>
 #include <limits>
 #include <utility>
 
 #include "tools/gn/err.h"
 #include "tools/gn/functions.h"
@@ skipping 29 matching lines @@
 
   (tool->*set)(v->boolean_value());
   return true;
 }
 
 // Reads the given string from the scope (if present) and puts the result into
 // dest. If the value is not a string, sets the error and returns false.
 bool ReadString(Scope* scope,
                 const char* var,
                 Tool* tool,
-                void (Tool::*set)(const std::string&),
+                void (Tool::*set)(std::string),
                 Err* err) {
   const Value* v = scope->GetValue(var, true);
   if (!v)
     return true;  // Not present is fine.
   if (!v->VerifyTypeIs(Value::STRING, err))
     return false;
 
   (tool->*set)(v->string_value());
   return true;
 }
 
 // Reads the given label from the scope (if present) and puts the result into
 // dest. If the value is not a label, sets the error and returns false.
 bool ReadLabel(Scope* scope,
                const char* var,
                Tool* tool,
-               const ParseNode* origin,
                const Label& current_toolchain,
-               void (Tool::*set)(const LabelPtrPair<Pool>&),
+               void (Tool::*set)(LabelPtrPair<Pool>),
                Err* err) {
   const Value* v = scope->GetValue(var, true);
   if (!v)
     return true;  // Not present is fine.
 
   Label label =
       Label::Resolve(scope->GetSourceDir(), current_toolchain, *v, err);
   if (err->has_error())
     return false;
 
   LabelPtrPair<Pool> pair(label);
-  pair.origin = origin;
+  pair.origin = tool->defined_from();
 
-  (tool->*set)(pair);
+  (tool->*set)(std::move(pair));
   return true;
 }
 
 // Calls the given validate function on each type in the list. On failure,
 // sets the error, blame the value, and return false.
 bool ValidateSubstitutionList(const std::vector<SubstitutionType>& list,
                               bool (*validate)(SubstitutionType),
                               const Value* origin,
                               Err* err) {
   for (const auto& cur_type : list) {
     if (!validate(cur_type)) {
       *err = Err(*origin, "Pattern not valid here.",
           "You used the pattern " + std::string(kSubstitutionNames[cur_type]) +
           " which is not valid\nfor this variable.");
       return false;
     }
   }
   return true;
 }
 
 bool ReadPattern(Scope* scope,
                  const char* name,
                  bool (*validate)(SubstitutionType),
                  Tool* tool,
-                 void (Tool::*set)(const SubstitutionPattern&),
+                 void (Tool::*set)(SubstitutionPattern),
                  Err* err) {
   const Value* value = scope->GetValue(name, true);
   if (!value)
     return true;  // Not present is fine.
   if (!value->VerifyTypeIs(Value::STRING, err))
     return false;
 
   SubstitutionPattern pattern;
   if (!pattern.Parse(*value, err))
     return false;
   if (!ValidateSubstitutionList(pattern.required_types(), validate, value, err))
     return false;
 
-  (tool->*set)(pattern);
+  (tool->*set)(std::move(pattern));
   return true;
 }
 
+bool ReadPatternList(Scope* scope,
+                     const char* name,
+                     bool (*validate)(SubstitutionType),
+                     Tool* tool,
+                     void (Tool::*set)(SubstitutionList),
+                     Err* err) {
+  const Value* value = scope->GetValue(name, true);
+  if (!value)
+    return true;  // Not present is fine.
+  if (!value->VerifyTypeIs(Value::LIST, err))
+    return false;
+
+  SubstitutionList list;
+  if (!list.Parse(*value, err))
+    return false;
+
+  // Validate the right kinds of patterns are used.
+  if (!ValidateSubstitutionList(list.required_types(), validate, value, err))
+    return false;
+
+  (tool->*set)(std::move(list));
+  return true;
+}
+
 bool ReadOutputExtension(Scope* scope, Tool* tool, Err* err) {
   const Value* value = scope->GetValue("default_output_extension", true);
   if (!value)
     return true;  // Not present is fine.
   if (!value->VerifyTypeIs(Value::STRING, err))
     return false;
 
   if (value->string_value().empty())
     return true;  // Accept empty string.
 
@@ skipping 39 matching lines @@
     tool->set_depsformat(Tool::DEPS_GCC);
   } else if (value->string_value() == "msvc") {
     tool->set_depsformat(Tool::DEPS_MSVC);
   } else {
     *err = Err(*value, "Deps format must be \"gcc\" or \"msvc\".");
     return false;
   }
   return true;
 }
 
-bool ReadOutputs(Scope* scope,
-                 const FunctionCallNode* tool_function,
-                 bool (*validate)(SubstitutionType),
-                 Tool* tool,
-                 Err* err) {
-  const Value* value = scope->GetValue("outputs", true);
-  if (!value) {
-    *err = Err(tool_function, "\"outputs\" must be specified for this tool.");
-    return false;
-  }
-
-  SubstitutionList list;
-  if (!list.Parse(*value, err))
-    return false;
-
-  // Validate the right kinds of patterns are used.
-  if (!ValidateSubstitutionList(list.required_types(), validate, value, err))
-    return false;
-
-  // There should always be at least one output.
-  if (list.list().empty()) {
-    *err = Err(*value, "Outputs list is empty.", "I need some outputs.");
-    return false;
-  }
-
-  tool->set_outputs(list);
-  return true;
-}
-
 bool IsCompilerTool(Toolchain::ToolType type) {
   return type == Toolchain::TYPE_CC ||
          type == Toolchain::TYPE_CXX ||
          type == Toolchain::TYPE_OBJC ||
          type == Toolchain::TYPE_OBJCXX ||
          type == Toolchain::TYPE_RC ||
          type == Toolchain::TYPE_ASM;
 }
 
 bool IsLinkerTool(Toolchain::ToolType type) {
   // "alink" is not counted as in the generic "linker" tool list.
   return type == Toolchain::TYPE_SOLINK ||
          type == Toolchain::TYPE_SOLINK_MODULE ||
          type == Toolchain::TYPE_LINK;
 }
 
 bool IsPatternInOutputList(const SubstitutionList& output_list,
                            const SubstitutionPattern& pattern) {
   for (const auto& cur : output_list.list()) {
     if (pattern.ranges().size() == cur.ranges().size() &&
         std::equal(pattern.ranges().begin(), pattern.ranges().end(),
                    cur.ranges().begin()))
       return true;
   }
   return false;
 }
 
+
+bool ValidateOutputs(const Tool* tool, Err* err) {
+  if (tool->outputs().list().empty()) {
+    *err = Err(tool->defined_from(),
+               "\"outputs\" must be specified for this tool.");
+    return false;
+  }
+  return true;
+}
+
+// Validates either link_output or depend_output. To generalize to either, pass
+// the associated pattern, and the variable name that should appear in error
+// messages.
+bool ValidateLinkAndDependOutput(const Tool* tool,
+                                 Toolchain::ToolType tool_type,
+                                 const SubstitutionPattern& pattern,
+                                 const char* variable_name,
+                                 Err* err) {
+  if (pattern.empty())
+    return true;  // Empty is always OK.
+
+  // It should only be specified for certain tool types.
+  if (tool_type != Toolchain::TYPE_SOLINK &&
+      tool_type != Toolchain::TYPE_SOLINK_MODULE) {
+    *err = Err(tool->defined_from(),
+        "This tool specifies a " + std::string(variable_name) + ".",
+        "This is only valid for solink and solink_module tools.");
+    return false;
+  }
+
+  if (!IsPatternInOutputList(tool->outputs(), pattern)) {
+    *err = Err(tool->defined_from(), "This tool's link_output is bad.",
+               "It must match one of the outputs.");
+    return false;
+  }
+
+  return true;
+}
+
+bool ValidateRuntimeOutputs(const Tool* tool,
+                            Toolchain::ToolType tool_type,
+                            Err* err) {
+  if (tool->runtime_outputs().list().empty())
+    return true;  // Empty is always OK.
+
+  if (!IsLinkerTool(tool_type)) {
+    *err = Err(tool->defined_from(), "This tool specifies runtime_outputs.",
+        "This is only valid for linker tools (alink doesn't count).");
+    return false;
+  }
+
+  for (const SubstitutionPattern& pattern : tool->runtime_outputs().list()) {
+    if (!IsPatternInOutputList(tool->outputs(), pattern)) {
+      *err = Err(tool->defined_from(), "This tool's runtime_outputs is bad.",
+                 "It must be a subset of the outputs. The bad one is:\n  " +
+                  pattern.AsString());
+      return false;
+    }
+  }
+  return true;
+}
+
 }  // namespace
 
 // toolchain -------------------------------------------------------------------
 
 const char kToolchain[] = "toolchain";
 const char kToolchain_HelpShort[] =
     "toolchain: Defines a toolchain.";
 const char kToolchain_Help[] =
     "toolchain: Defines a toolchain.\n"
     "\n"
@@ skipping 269 matching lines @@
     "        at least one output file. There can be more than one output (a\n"
     "        linker might produce a library and an import library, for\n"
     "        example).\n"
     "\n"
     "        This array just declares to GN what files the tool will\n"
     "        produce. It is your responsibility to specify the tool command\n"
     "        that actually produces these files.\n"
     "\n"
     "        If you specify more than one output for shared library links,\n"
     "        you should consider setting link_output, depend_output, and\n"
-    "        runtime_link_output. Otherwise, the first entry in the\n"
-    "        outputs list should always be the main output which will be\n"
-    "        linked to.\n"
+    "        runtime_outputs.\n"
     "\n"
     "        Example for a compiler tool that produces .obj files:\n"
     "          outputs = [\n"
     "            \"{{source_out_dir}}/{{source_name_part}}.obj\"\n"
     "          ]\n"
     "\n"
     "        Example for a linker tool that produces a .dll and a .lib. The\n"
     "        use of {{target_output_name}}, {{output_extension}} and\n"
     "        {{output_dir}} allows the target to override these values.\n"
     "          outputs = [\n"
     "            \"{{output_dir}}/{{target_output_name}}"
                      "{{output_extension}}\",\n"
     "            \"{{output_dir}}/{{target_output_name}}.lib\",\n"
     "          ]\n"
     "\n"
     "    pool [label, optional]\n"
     "\n"
     "        Label of the pool to use for the tool. Pools are used to limit\n"
     "        the number of tasks that can execute concurrently during the\n"
     "        build.\n"
     "\n"
     "        See also \"gn help pool\".\n"
     "\n"
     "    link_output  [string with substitutions]\n"
     "    depend_output  [string with substitutions]\n"
-    "    runtime_link_output  [string with substitutions]\n"
     "        Valid for: \"solink\" only (optional)\n"
     "\n"
-    "        These three files specify which of the outputs from the solink\n"
+    "        These two files specify which of the outputs from the solink\n"
     "        tool should be used for linking and dependency tracking. These\n"
     "        should match entries in the \"outputs\". If unspecified, the\n"
     "        first item in the \"outputs\" array will be used for all. See\n"
     "        \"Separate linking and dependencies for shared libraries\"\n"
-    "        below for more. If link_output is set but runtime_link_output\n"
-    "        is not set, runtime_link_output defaults to link_output.\n"
+    "        below for more.\n"
     "\n"
     "        On Windows, where the tools produce a .dll shared library and\n"
     "        a .lib import library, you will want the first two to be the\n"
     "        import library and the third one to be the .dll file.\n"
     "        On Linux, if you're not doing the separate linking/dependency\n"
     "        optimization, all of these should be the .so output.\n"
     "\n"
     "    output_prefix  [string]\n"
     "        Valid for: Linker tools (optional)\n"
     "\n"
@@ skipping 57 matching lines @@
     "        allows you to get around OS command-line length limits.\n"
     "\n"
     "        This example adds the inputs and libraries to a response file,\n"
     "        but passes the linker flags directly on the command line:\n"
     "          tool(\"link\") {\n"
     "            command = \"link -o {{output}} {{ldflags}} @{{output}}.rsp\"\n"
     "            rspfile = \"{{output}}.rsp\"\n"
     "            rspfile_content = \"{{inputs}} {{solibs}} {{libs}}\"\n"
     "          }\n"
     "\n"
+    "    runtime_outputs  [string list with substitutions]\n"
+    "        Valid for: linker tools\n"
+    "\n"
+    "        If specified, this list is the subset of the outputs that should\n"
+    "        be added to runtime deps (see \"gn help runtime_deps\"). By\n"
+    "        default (if runtime_outputs is empty or unspecified), it will be\n"
+    "        the link_output.\n"
+    "\n"
     "Expansions for tool variables\n"
     "\n"
     "  All paths are relative to the root build directory, which is the\n"
     "  current directory for running all tools. These expansions are\n"
     "  available to all tools:\n"
     "\n"
     "    {{label}}\n"
     "        The label of the current target. This is typically used in the\n"
     "        \"description\" field for link tools. The toolchain will be\n"
     "        omitted from the label for targets in the default toolchain, and\n"
@@ skipping 253 matching lines @@
     subst_output_validator = &IsValidCopySubstitution;
   } else if (tool_type == Toolchain::TYPE_COMPILE_XCASSETS) {
     subst_validator = &IsValidCompileXCassetsSubstitution;
     subst_output_validator = &IsValidCompileXCassetsSubstitution;
   } else {
     subst_validator = &IsValidToolSubstitution;
     subst_output_validator = &IsValidToolSubstitution;
   }
 
   std::unique_ptr<Tool> tool(new Tool);
+  tool->set_defined_from(function);
 
   if (!ReadPattern(&block_scope, "command", subst_validator, tool.get(),
                    &Tool::set_command, err) ||
       !ReadOutputExtension(&block_scope, tool.get(), err) ||
       !ReadPattern(&block_scope, "depfile", subst_validator, tool.get(),
                    &Tool::set_depfile, err) ||
       !ReadDepsFormat(&block_scope, tool.get(), err) ||
       !ReadPattern(&block_scope, "description", subst_validator, tool.get(),
                    &Tool::set_description, err) ||
       !ReadString(&block_scope, "lib_switch", tool.get(), &Tool::set_lib_switch,
                   err) ||
       !ReadString(&block_scope, "lib_dir_switch", tool.get(),
                   &Tool::set_lib_dir_switch, err) ||
       !ReadPattern(&block_scope, "link_output", subst_validator, tool.get(),
                    &Tool::set_link_output, err) ||
       !ReadPattern(&block_scope, "depend_output", subst_validator, tool.get(),
                    &Tool::set_depend_output, err) ||
-      !ReadPattern(&block_scope, "runtime_link_output", subst_validator,
-                   tool.get(), &Tool::set_runtime_link_output, err) ||
+      !ReadPatternList(&block_scope, "runtime_outputs", subst_validator,
+                       tool.get(), &Tool::set_runtime_outputs, err) ||
       !ReadString(&block_scope, "output_prefix", tool.get(),
                   &Tool::set_output_prefix, err) ||
       !ReadPattern(&block_scope, "default_output_dir", subst_validator,
                    tool.get(), &Tool::set_default_output_dir, err) ||
       !ReadPrecompiledHeaderType(&block_scope, tool.get(), err) ||
       !ReadBool(&block_scope, "restat", tool.get(), &Tool::set_restat, err) ||
       !ReadPattern(&block_scope, "rspfile", subst_validator, tool.get(),
                    &Tool::set_rspfile, err) ||
       !ReadPattern(&block_scope, "rspfile_content", subst_validator, tool.get(),
                    &Tool::set_rspfile_content, err) ||
-      !ReadLabel(&block_scope, "pool", tool.get(), function, toolchain->label(),
+      !ReadLabel(&block_scope, "pool", tool.get(), toolchain->label(),
                  &Tool::set_pool, err)) {
     return Value();
   }
 
   if (tool_type != Toolchain::TYPE_COPY &&
       tool_type != Toolchain::TYPE_STAMP &&
       tool_type != Toolchain::TYPE_COPY_BUNDLE_DATA &&
       tool_type != Toolchain::TYPE_COMPILE_XCASSETS) {
     // All tools should have outputs, except the copy, stamp, copy_bundle_data
     // and compile_xcassets tools that generate their outputs internally.
-    if (!ReadOutputs(&block_scope, function, subst_output_validator,
-                     tool.get(), err))
+    if (!ReadPatternList(&block_scope, "outputs", subst_output_validator,
+                         tool.get(), &Tool::set_outputs, err) ||
+        !ValidateOutputs(tool.get(), err))
       return Value();
   }
+  if (!ValidateRuntimeOutputs(tool.get(), tool_type, err))
+    return Value();
 
-  // Validate that the link_output, depend_output, and runtime_link_output
-  // refer to items in the outputs and aren't defined for irrelevant tool
-  // types.
-  if (!tool->link_output().empty()) {
-    if (tool_type != Toolchain::TYPE_SOLINK &&
-        tool_type != Toolchain::TYPE_SOLINK_MODULE) {
-      *err = Err(function, "This tool specifies a link_output.",
-          "This is only valid for solink and solink_module tools.");
-      return Value();
-    }
-    if (!IsPatternInOutputList(tool->outputs(), tool->link_output())) {
-      *err = Err(function, "This tool's link_output is bad.",
-                 "It must match one of the outputs.");
-      return Value();
-    }
-  }
-  if (!tool->depend_output().empty()) {
-    if (tool_type != Toolchain::TYPE_SOLINK &&
-        tool_type != Toolchain::TYPE_SOLINK_MODULE) {
-      *err = Err(function, "This tool specifies a depend_output.",
-          "This is only valid for solink and solink_module tools.");
-      return Value();
-    }
-    if (!IsPatternInOutputList(tool->outputs(), tool->depend_output())) {
-      *err = Err(function, "This tool's depend_output is bad.",
-                 "It must match one of the outputs.");
-      return Value();
-    }
-  }
+  // Validate link_output and depend_output.
+  if (!ValidateLinkAndDependOutput(tool.get(), tool_type, tool->link_output(),
+                                   "link_output", err))
+    return Value();
+  if (!ValidateLinkAndDependOutput(tool.get(), tool_type, tool->depend_output(),
+                                   "depend_output", err))
+    return Value();
   if ((!tool->link_output().empty() && tool->depend_output().empty()) ||
       (tool->link_output().empty() && !tool->depend_output().empty())) {
     *err = Err(function, "Both link_output and depend_output should either "
         "be specified or they should both be empty.");
     return Value();
   }
-  if (!tool->runtime_link_output().empty()) {
-    if (tool_type != Toolchain::TYPE_SOLINK &&
-        tool_type != Toolchain::TYPE_SOLINK_MODULE) {
-      *err = Err(function, "This tool specifies a runtime_link_output.",
-          "This is only valid for solink and solink_module tools.");
-      return Value();
-    }
-    if (!IsPatternInOutputList(tool->outputs(), tool->runtime_link_output())) {
-      *err = Err(function, "This tool's runtime_link_output is bad.",
-                 "It must match one of the outputs.");
-      return Value();
-    }
-  }
 
   // Make sure there weren't any vars set in this tool that were unused.
   if (!block_scope.CheckForUnusedVars(err))
     return Value();
 
   toolchain->SetTool(tool_type, std::move(tool));
   return Value();
 }
 
 // toolchain_args --------------------------------------------------------------
@@ skipping 66 matching lines @@
     return Value();
 
   Scope::KeyValueMap values;
   block_scope.GetCurrentScopeValues(&values);
   toolchain->args() = values;
 
   return Value();
 }
 
 }  // namespace functions