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 54 matching lines @@
     "  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";
 
 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(
+      DeclaredArgumentsForToolchain(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);
+  for (const auto& map_pair : declared_arguments_per_toolchain_) {
+    if (!VerifyAllOverridesUsed(all_overrides_, map_pair.second, err))

[brettw, 2015/03/14 05:14:32]

I don't think this is quite right. We want to return true if all overrides were
used anywhere, not whether they were all used in all toolchains.

One way is to make a copy of the overrides (generally very small), go through
each toolchain and remove the ones we find in that toolchain, and then throw an
error listing all remaining items.

We should probably add a case like this to the test.

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

Done.

+      return false;
+  }
+  return true;
 }
 
+void Args::MergeDeclaredArguments(Scope::KeyValueMap* dest) const {
+  base::AutoLock lock(lock_);
+  for (const auto& map_pair : declared_arguments_per_toolchain_) {
+    for (const auto& arg : map_pair.second)
+      (*dest)[arg.first] = arg.second;
+  }
+}
+
+// static
 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.
@@ skipping 10 matching lines @@
           "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;
     }
   }
   return true;
 }
 
-void Args::MergeDeclaredArguments(Scope::KeyValueMap* dest) const {
-  base::AutoLock lock(lock_);
-  for (const auto& arg : declared_arguments_)
-    (*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)
   os = "mac";
 #elif defined(OS_LINUX)
@@ skipping 30 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(DeclaredArgumentsForToolchain(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::DeclaredArgumentsForToolchain(Scope* scope) const {
+  lock_.AssertAcquired();
+  return declared_arguments_per_toolchain_[scope->settings()];
+}