Refactor GN source expansions.

tools/gn/action_target_generator.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/action_target_generator.h"
 
 #include "tools/gn/build_settings.h"
 #include "tools/gn/err.h"
 #include "tools/gn/filesystem_utils.h"
 #include "tools/gn/parse_tree.h"
 #include "tools/gn/scope.h"
 #include "tools/gn/value.h"
 #include "tools/gn/value_extractors.h"
 #include "tools/gn/variables.h"
 
-namespace {
-
-// Returns true if the list of files looks like it might have a {{ }} pattern
-// in it. Used for error checking.
-bool StringListHasPattern(const std::vector<std::string>& files) {
-  for (size_t i = 0; i < files.size(); i++) {
-    if (files[i].find("{{") != std::string::npos &&
-        files[i].find("}}") != std::string::npos)
-      return true;
-  }
-  return false;
-}
-
-}  // namespace
-
 ActionTargetGenerator::ActionTargetGenerator(
     Target* target,
     Scope* scope,
     const FunctionCallNode* function_call,
     Target::OutputType type,
     Err* err)
     : TargetGenerator(target, scope, function_call, err),
       output_type_(type) {
 }
 
@@ skipping 60 matching lines @@
     return;
   }
   target_->action_values().set_script(script_file);
 }
 
 void ActionTargetGenerator::FillScriptArgs() {
   const Value* value = scope_->GetValue(variables::kArgs, true);
   if (!value)
     return;
 
-  if (!ExtractListOfStringValues(*value, &target_->action_values().args(),
-                                 err_))
+  if (!target_->action_values().args().Parse(*value, err_))
     return;
 }
 
 void ActionTargetGenerator::FillDepfile() {
   const Value* value = scope_->GetValue(variables::kDepfile, true);
   if (!value)
     return;
-  target_->action_values().set_depfile(
-      scope_->settings()->build_settings()->build_dir().ResolveRelativeFile(
-          value->string_value()));
+
+  SubstitutionPattern depfile;
+  if (!depfile.Parse(*value, err_))
+    return;
+  if (!EnsureSubstitutionIsInOutputDir(depfile, *value))
+    return;
+
+  target_->action_values().set_depfile(depfile);
 }
 
 void ActionTargetGenerator::CheckOutputs() {
-  const std::vector<std::string>& outputs = target_->action_values().outputs();
-  if (outputs.empty()) {
+  const SubstitutionList& outputs = target_->action_values().outputs();
+  if (outputs.list().empty()) {
     *err_ = Err(function_call_, "Action has no outputs.",
         "If you have no outputs, the build system can not tell when your\n"
         "script needs to be run.");
     return;
   }
 
   if (output_type_ == Target::ACTION) {
-    // Make sure the outputs for an action have no patterns in them.
-    if (StringListHasPattern(outputs)) {
+    if (!outputs.required_types().empty()) {
       *err_ = Err(function_call_, "Action has patterns in the output.",
           "An action target should have the outputs completely specified. If\n"
           "you want to provide a mapping from source to output, use an\n"
           "\"action_foreach\" target.");
       return;
     }
   } else if (output_type_ == Target::ACTION_FOREACH) {
     // A foreach target should always have a pattern in the outputs.
-    if (!StringListHasPattern(outputs)) {
+    if (outputs.required_types().empty()) {
       *err_ = Err(function_call_,
           "action_foreach should have a pattern in the output.",
           "An action_foreach target should have a source expansion pattern in\n"
           "it to map source file to unique output file name. Otherwise, the\n"
           "build system can't determine when your script needs to be run.");
       return;
     }
   }
 }