🐜 GN: Make write_runtime_deps take effect only a target is resolved

tools/gn/test_with_scope.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/test_with_scope.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "tools/gn/parser.h"
 #include "tools/gn/tokenizer.h"
 
 TestWithScope::TestWithScope()
     : build_settings_(),
       settings_(&build_settings_, std::string()),
       toolchain_(&settings_, Label(SourceDir("//toolchain/"), "default")),
       scope_(&settings_),
       scope_progammatic_provider_(&scope_, true) {
   build_settings_.SetBuildDir(SourceDir("//out/Debug/"));
   build_settings_.set_print_callback(
       base::Bind(&TestWithScope::AppendPrintOutput, base::Unretained(this)));
 
   settings_.set_toolchain_label(toolchain_.label());
   settings_.set_default_toolchain_label(toolchain_.label());
 
   SetupToolchain(&toolchain_);
+  scope_.set_item_collector(&items_);
 }
 
 TestWithScope::~TestWithScope() {
 }
 
 Label TestWithScope::ParseLabel(const std::string& str) const {
   Err err;
   Label result = Label::Resolve(SourceDir("//"), toolchain_.label(),
                                 Value(nullptr, str), &err);
   CHECK(!err.has_error());
   return result;
 }
 
+bool TestWithScope::ExecuteSnippet(const std::string& str, Err* err) {
+  TestParseInput input(str);
+  if (input.has_error()) {
+    if (err != nullptr) {

[brettw, 2016/04/19 18:29:39]

I've not used optional errors in any places to avoid this type of checking
getting out of control or being inconsistent. Can you remove the null checks for
Err for this function? (And you can clean up my_err below).

[agrieve, 2016/04/20 00:45:02]

Done.

+      *err = input.parse_err();
+    }
+    return false;
+  }
+
+  size_t first_item = items_.size();
+  Err my_err;
+  input.parsed()->Execute(&scope_, &my_err);
+  if (my_err.has_error()) {
+    if (err != nullptr) {
+      *err = my_err;
+    }
+    return false;
+  }
+
+  for (size_t i = first_item; i < items_.size(); ++i) {
+    CHECK(items_[i]->AsTarget() != nullptr)
+        << "Only targets are supported in ExecuteSnippet()";
+    items_[i]->AsTarget()->SetToolchain(&toolchain_);
+    if (!items_[i]->OnResolved(err))
+      return false;
+  }
+  return true;
+}
+
 // static
 void TestWithScope::SetupToolchain(Toolchain* toolchain) {
   Err err;
 
   // CC
   std::unique_ptr<Tool> cc_tool(new Tool);
   SetCommandForTool(
       "cc {{source}} {{cflags}} {{cflags_c}} {{defines}} {{include_dirs}} "
       "-o {{output}}",
       cc_tool.get());
@@ skipping 133 matching lines @@
                        const std::string& label_string,
                        Target::OutputType type)
     : Target(setup.settings(), setup.ParseLabel(label_string)) {
   visibility().SetPublic();
   set_output_type(type);
   SetToolchain(setup.toolchain());
 }
 
 TestTarget::~TestTarget() {
 }