Makes declared_arguments per toolchain

tools/gn/args.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/args.h"
 
 #include "base/sys_info.h"
 #include "build/build_config.h"
 #include "tools/gn/variables.h"
 
@@ skipping 48 matching lines @@
     "  default values. These default values will apply if none of the steps\n"
     "  listed in the \"How build arguments are set\" section above apply to\n"
     "  the given argument, but the defaults will not override any of these.\n"
     "\n"
     "  Often, the root build config file will declare global arguments that\n"
     "  will be passed to all buildfiles. Individual build files can also\n"
     "  specify arguments that apply only to those files. It is also useful\n"
     "  to specify build args in an \"import\"-ed file if you want such\n"
     "  arguments to apply to multiple buildfiles.\n";
 
+namespace {
+
+// Removes all entries in |overrides| that are in |declared_overrides|.
+void RemoveDeclaredOverrides(const Scope::KeyValueMap& declared_arguments,
+                             Scope::KeyValueMap* overrides) {
+  for (Scope::KeyValueMap::iterator override = overrides->begin();
+       override != overrides->end();) {
+    if (declared_arguments.find(override->first) == declared_arguments.end())
+      ++override;
+    else
+      overrides->erase(override++);
+  }
+}
+
+}  // namespace
+
 Args::Args() {
 }
 
 Args::Args(const Args& other)
     : overrides_(other.overrides_),
       all_overrides_(other.all_overrides_),
-      declared_arguments_(other.declared_arguments_) {
+      declared_arguments_per_toolchain_(
+          other.declared_arguments_per_toolchain_) {
 }
 
 Args::~Args() {
 }
 
 void Args::AddArgOverride(const char* name, const Value& value) {
   base::AutoLock lock(lock_);
 
   overrides_[base::StringPiece(name)] = value;
   all_overrides_[base::StringPiece(name)] = value;
@@ skipping 31 matching lines @@
   ApplyOverridesLocked(overrides_, dest);
   ApplyOverridesLocked(toolchain_overrides, dest);
   SaveOverrideRecordLocked(toolchain_overrides);
 }
 
 bool Args::DeclareArgs(const Scope::KeyValueMap& args,
                        Scope* scope_to_set,
                        Err* err) const {
   base::AutoLock lock(lock_);
 
+  Scope::KeyValueMap& declared_arguments(
+      DeclaredArgumentsForToolchainLocked(scope_to_set));
   for (const auto& arg : args) {
     // Verify that the value hasn't already been declared. We want each value
     // to be declared only once.
     //
     // The tricky part is that a buildfile can be interpreted multiple times
     // when used from different toolchains, so we can't just check that we've
     // seen it before. Instead, we check that the location matches.
     Scope::KeyValueMap::iterator previously_declared =
-        declared_arguments_.find(arg.first);
-    if (previously_declared != declared_arguments_.end()) {
+        declared_arguments.find(arg.first);
+    if (previously_declared != declared_arguments.end()) {
       if (previously_declared->second.origin() != arg.second.origin()) {
         // Declaration location mismatch.
         *err = Err(arg.second.origin(),
             "Duplicate build argument declaration.",
             "Here you're declaring an argument that was already declared "
             "elsewhere.\nYou can only declare each argument once in the entire "
             "build so there is one\ncanonical place for documentation and the "
             "default value. Either move this\nargument to the build config "
             "file (for visibility everywhere) or to a .gni file\nthat you "
             "\"import\" from the files where you need it (preferred).");
         err->AppendSubErr(Err(previously_declared->second.origin(),
                               "Previous declaration.",
                               "See also \"gn help buildargs\" for more on how "
                               "build arguments work."));
         return false;
       }
     } else {
-      declared_arguments_.insert(arg);
+      declared_arguments.insert(arg);
     }
 
     // Only set on the current scope to the new value if it hasn't been already
     // set. Mark the variable used so the build script can override it in
     // certain cases without getting unused value errors.
     if (!scope_to_set->GetValue(arg.first)) {
       scope_to_set->SetValue(arg.first, arg.second, arg.second.origin());
       scope_to_set->MarkUsed(arg.first);
     }
   }
 
   return true;
 }
 
 bool Args::VerifyAllOverridesUsed(Err* err) const {
   base::AutoLock lock(lock_);
-  return VerifyAllOverridesUsed(all_overrides_, declared_arguments_, err);
-}
+  Scope::KeyValueMap all_overrides(all_overrides_);
+  for (const auto& map_pair : declared_arguments_per_toolchain_)
+    RemoveDeclaredOverrides(map_pair.second, &all_overrides);
 
-bool Args::VerifyAllOverridesUsed(
-    const Scope::KeyValueMap& overrides,
-    const Scope::KeyValueMap& declared_arguments,
-    Err* err) {
-  for (const auto& override : overrides) {
-    if (declared_arguments.find(override.first) == declared_arguments.end()) {
-      // Get a list of all possible overrides for help with error finding.
-      //
-      // It might be nice to do edit distance checks to see if we can find one
-      // close to what you typed.
-      std::string all_declared_str;
-      for (Scope::KeyValueMap::const_iterator cur_str =
-               declared_arguments.begin();
-           cur_str != declared_arguments.end(); ++cur_str) {
-        if (cur_str != declared_arguments.begin())
-          all_declared_str += ", ";
-        all_declared_str += cur_str->first.as_string();
-      }
+  if (all_overrides.empty())
+    return true;
 
-      *err = Err(override.second.origin(), "Build argument has no effect.",
-          "The variable \"" + override.first.as_string() +
-          "\" was set as a build "
-          "argument\nbut never appeared in a declare_args() block in any "
-          "buildfile.\n\nPossible arguments: " + all_declared_str);
-      return false;
+  // Get a list of all possible overrides for help with error finding.
+  //
+  // It might be nice to do edit distance checks to see if we can find one close
+  // to what you typed.
+  std::string all_declared_str;
+  for (const auto& map_pair : declared_arguments_per_toolchain_) {
+    for (const auto& cur_str : map_pair.second) {
+      if (!all_declared_str.empty())
+        all_declared_str += ", ";
+      all_declared_str += cur_str.first.as_string();
     }
   }
-  return true;
+
+  *err = Err(
+      all_overrides.begin()->second.origin(), "Build argument has no effect.",
+      "The variable \"" + all_overrides.begin()->first.as_string() +
+          "\" was set as a build argument\nbut never appeared in a " +

[sky, 2015/03/16 16:20:45]

git cl format did this. No idea why it indented here, but I left it rather than
fight it.

+          "declare_args() block in any buildfile.\n\nPossible arguments: " +
+          all_declared_str);
+  return false;
 }
 
 void Args::MergeDeclaredArguments(Scope::KeyValueMap* dest) const {
   base::AutoLock lock(lock_);
-  for (const auto& arg : declared_arguments_)
-    (*dest)[arg.first] = arg.second;
+  for (const auto& map_pair : declared_arguments_per_toolchain_) {
+    for (const auto& arg : map_pair.second)
+      (*dest)[arg.first] = arg.second;
+  }
 }
 
 void Args::SetSystemVarsLocked(Scope* dest) const {
   lock_.AssertAcquired();
 
   // Host OS.
   const char* os = nullptr;
 #if defined(OS_WIN)
   os = "win";
 #elif defined(OS_MACOSX)
@@ skipping 32 matching lines @@
   Value os_val(nullptr, std::string(os));
   dest->SetValue(variables::kHostOs, os_val, nullptr);
   dest->SetValue(variables::kTargetOs, empty_string, nullptr);
   dest->SetValue(variables::kCurrentOs, empty_string, nullptr);
 
   Value arch_val(nullptr, std::string(arch));
   dest->SetValue(variables::kHostCpu, arch_val, nullptr);
   dest->SetValue(variables::kTargetCpu, empty_string, nullptr);
   dest->SetValue(variables::kCurrentCpu, empty_string, nullptr);
 
-  declared_arguments_[variables::kHostOs] = os_val;
-  declared_arguments_[variables::kCurrentOs] = empty_string;
-  declared_arguments_[variables::kTargetOs] = empty_string;
-  declared_arguments_[variables::kHostCpu] = arch_val;
-  declared_arguments_[variables::kCurrentCpu] = empty_string;
-  declared_arguments_[variables::kTargetCpu] = empty_string;
+  Scope::KeyValueMap& declared_arguments(
+      DeclaredArgumentsForToolchainLocked(dest));
+  declared_arguments[variables::kHostOs] = os_val;
+  declared_arguments[variables::kCurrentOs] = empty_string;
+  declared_arguments[variables::kTargetOs] = empty_string;
+  declared_arguments[variables::kHostCpu] = arch_val;
+  declared_arguments[variables::kCurrentCpu] = empty_string;
+  declared_arguments[variables::kTargetCpu] = empty_string;
 
   // Mark these variables used so the build config file can override them
   // without geting a warning about overwriting an unused variable.
   dest->MarkUsed(variables::kHostCpu);
   dest->MarkUsed(variables::kCurrentCpu);
   dest->MarkUsed(variables::kTargetCpu);
   dest->MarkUsed(variables::kHostOs);
   dest->MarkUsed(variables::kCurrentOs);
   dest->MarkUsed(variables::kTargetOs);
 }
 
 void Args::ApplyOverridesLocked(const Scope::KeyValueMap& values,
                                 Scope* scope) const {
   lock_.AssertAcquired();
   for (const auto& val : values)
     scope->SetValue(val.first, val.second, val.second.origin());
 }
 
 void Args::SaveOverrideRecordLocked(const Scope::KeyValueMap& values) const {
   lock_.AssertAcquired();
   for (const auto& val : values)
     all_overrides_[val.first] = val.second;
 }
+
+Scope::KeyValueMap& Args::DeclaredArgumentsForToolchainLocked(
+    Scope* scope) const {
+  lock_.AssertAcquired();
+  return declared_arguments_per_toolchain_[scope->settings()];
+}