Makes declared_arguments per toolchain

tools/gn/args.cc

Index: tools/gn/args.cc
diff --git a/tools/gn/args.cc b/tools/gn/args.cc
index 2a1509a4cbe11ff60e51a3e4dc95ce1a4a7032f3..ced8b70c6cf22148cce4143e9dfc8036b8521715 100644
--- a/tools/gn/args.cc
+++ b/tools/gn/args.cc
@@ -72,7 +72,8 @@ 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() {
@@ -124,6 +125,8 @@ bool Args::DeclareArgs(const Scope::KeyValueMap& args,
                        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.
@@ -132,8 +135,8 @@ bool Args::DeclareArgs(const Scope::KeyValueMap& args,
     // 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(),
@@ -151,7 +154,7 @@ bool Args::DeclareArgs(const Scope::KeyValueMap& args,
         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
@@ -168,9 +171,22 @@ bool Args::DeclareArgs(const Scope::KeyValueMap& args,
 
 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,
@@ -201,12 +217,6 @@ bool Args::VerifyAllOverridesUsed(
   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();
 
@@ -257,12 +267,13 @@ void Args::SetSystemVarsLocked(Scope* dest) const {
   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.
@@ -286,3 +297,8 @@ void Args::SaveOverrideRecordLocked(const Scope::KeyValueMap& values) const {
   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()];
+}