Support private values in GN.

tools/gn/loader.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/loader.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "tools/gn/build_settings.h"
 #include "tools/gn/err.h"
 #include "tools/gn/filesystem_utils.h"
 #include "tools/gn/input_file_manager.h"
 #include "tools/gn/parse_tree.h"
 #include "tools/gn/scheduler.h"
 #include "tools/gn/scope_per_file_provider.h"
 #include "tools/gn/settings.h"
 #include "tools/gn/source_dir.h"
 #include "tools/gn/source_file.h"
 #include "tools/gn/trace.h"
 
+namespace {
+
+void ClearPrivateVariables(Scope* scope) {

[cjhopman, 2014/05/14 16:42:43]

Why not just add this on Scope?

[brettw, 2014/05/15 19:44:15]

Done.

+  std::vector<base::StringPiece> variables;
+  scope->GetCurrentScopeVariables(&variables);
+  for (size_t i = 0; i < variables.size(); i++) {
+    if (Scope::IsPrivateVar(variables[i]))
+      scope->DeleteValue(variables[i]);
+  }
+}
+
+}  // namespace
+
 // Identifies one time a file is loaded in a given toolchain so we don't load
 // it more than once.
 struct LoaderImpl::LoadID {
   LoadID() {}
   LoadID(const SourceFile& f, const Label& tc_name)
       : file(f),
         toolchain_name(tc_name) {
   }
 
   bool operator<(const LoadID& other) const {
@@ skipping 206 matching lines @@
   our_scope.set_item_collector(&collected_items);
 
   ScopedTrace trace(TraceItem::TRACE_FILE_EXECUTE, file_name.value());
   trace.SetToolchain(settings->toolchain_label());
 
   Err err;
   root->Execute(&our_scope, &err);
   if (err.has_error())
     g_scheduler->FailWithError(err);
 
+  if (!our_scope.CheckForUnusedVars(&err))
+    g_scheduler->FailWithError(err);
+
   // Pass all of the items that were defined off to the builder.
   for (size_t i = 0; i < collected_items.size(); i++)
     settings->build_settings()->ItemDefined(collected_items[i]->Pass());
 
   trace.Done();
 
   main_loop_->PostTask(FROM_HERE, base::Bind(&LoaderImpl::DidLoadFile, this));
 }
 
 void LoaderImpl::BackgroundLoadBuildConfig(
@@ skipping 20 matching lines @@
     base_config->SetProperty(kDefaultToolchainKey, &default_toolchain_label);
 
   ScopedTrace trace(TraceItem::TRACE_FILE_EXECUTE,
       settings->build_settings()->build_config_file().value());
   trace.SetToolchain(settings->toolchain_label());
 
   const BlockNode* root_block = root->AsBlock();
   Err err;
   root_block->ExecuteBlockInScope(base_config, &err);
 
+  // Clear all private variables left in the scope. We want the root build
+  // config to be like a .gni file in that variables beginning with an
+  // underscore aren't exported.
+  ClearPrivateVariables(base_config);
+
   trace.Done();
 
   if (err.has_error())
     g_scheduler->FailWithError(err);
 
   base_config->ClearProcessingBuildConfig();
   if (settings->is_default()) {
     // The default toolchain must have been set in the default build config
     // file.
     if (default_toolchain_label.is_null()) {
@@ skipping 88 matching lines @@
     const SourceFile& file_name,
     const base::Callback<void(const ParseNode*)>& callback,
     Err* err) {
   if (async_load_file_.is_null()) {
     return g_scheduler->input_file_manager()->AsyncLoadFile(
         origin, build_settings, file_name, callback, err);
   }
   return async_load_file_.Run(
       origin, build_settings, file_name, callback, err);
 }