Check for GN args using the union of all rather than individually.

tools/gn/command_gyp.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 <iostream>
 #include <map>
 #include <utility>
 #include <vector>
 
 #include "base/command_line.h"
@@ skipping 299 matching lines @@
        i != grouped_targets.end(); ++i) {
     GypTargetWriter::WriteFile(i->first, i->second, debug_toolchain, err);
     if (err->has_error())
       return std::make_pair(0, 0);
   }
 
   return std::make_pair(target_count,
                         static_cast<int>(grouped_targets.size()));
 }
 
+// Verifies that all build argument overrides are used by at least one of the
+// build types.
+void VerifyAllOverridesUsed(const Setups& setups) {
+  // Collect all declared args from all builds.
+  Scope::KeyValueMap declared;
+  setups.debug->build_settings().build_args().MergeDeclaredArguments(
+      &declared);
+  setups.release->build_settings().build_args().MergeDeclaredArguments(
+      &declared);
+  if (setups.debug64 && setups.release64) {
+    setups.debug64->build_settings().build_args().MergeDeclaredArguments(
+        &declared);
+    setups.release64->build_settings().build_args().MergeDeclaredArguments(
+        &declared);
+  }
+  if (setups.xcode_debug && setups.xcode_release) {
+    setups.xcode_debug->build_settings().build_args().MergeDeclaredArguments(
+        &declared);
+    setups.xcode_release->build_settings().build_args().MergeDeclaredArguments(
+        &declared);
+  }
+
+  Scope::KeyValueMap used =
+      setups.debug->build_settings().build_args().GetAllOverrides();
+
+  Err err;
+  if (!Args::VerifyAllOverridesUsed(used, declared, &err)) {
+    // TODO(brettw) implement a system of warnings. Until we have a better
+    // system, print the error but don't cause a failure.
+    err.PrintToStdout();
+  }
+}
+
 }  // namespace
 
 // Suppress output on success.
 const char kSwitchQuiet[] = "q";
 
 const char kGyp[] = "gyp";
 const char kGyp_HelpShort[] =
     "gyp: Make GYP files from GN.";
 const char kGyp_Help[] =
     "gyp: Make GYP files from GN.\n"
@@ skipping 54 matching lines @@
     "  executable(\"my_app\") {\n"
     "    deps = [ \":gyp_target\" ]\n"
     "    gyp_file = \"//foo/myapp.gyp\"\n"
     "    sources = ...\n"
     "  }\n";
 
 int RunGyp(const std::vector<std::string>& args) {
   base::ElapsedTimer timer;
   Setups setups;
 
-  // Deliberately leaked to avoid expensive process teardown.
+  // Deliberately leaked to avoid expensive process teardown. We also turn off
+  // unused override checking since we want to merge all declared arguments and
+  // check those, rather than check each build individually. Otherwise, you
+  // couldn't have an arg that was used in only one build type. This comes up
+  // because some args are build-type specific.
   setups.debug = new Setup;
+  setups.debug->set_check_for_unused_overrides(false);
   if (!setups.debug->DoSetup())
     return 1;
   const char kIsDebug[] = "is_debug";
 
   SourceDir base_build_dir = setups.debug->build_settings().build_dir();
   setups.debug->build_settings().SetBuildDir(
       AppendDirSuffix(base_build_dir, ".Debug"));
 
   // Make a release build based on the debug one. We use a new directory for
   // the build output so that they don't stomp on each other.
@@ skipping 53 matching lines @@
     return 1;
   if (setups.debug64 && !setups.debug64->RunPostMessageLoop())
     return 1;
   if (setups.release64 && !setups.release64->RunPostMessageLoop())
     return 1;
   if (setups.xcode_debug && !setups.xcode_debug->RunPostMessageLoop())
     return 1;
   if (setups.xcode_release && !setups.xcode_release->RunPostMessageLoop())
     return 1;
 
+  VerifyAllOverridesUsed(setups);
+
   Err err;
   std::pair<int, int> counts = WriteGypFiles(setups, &err);
   if (err.has_error()) {
     err.PrintToStdout();
     return 1;
   }
 
   base::TimeDelta elapsed_time = timer.Elapsed();
 
   if (!CommandLine::ForCurrentProcess()->HasSwitch(kSwitchQuiet)) {
     OutputString("Done. ", DECORATION_GREEN);
 
     std::string stats = "Wrote " +
         base::IntToString(counts.first) + " targets to " +
         base::IntToString(counts.second) + " GYP files read from " +
         base::IntToString(
             setups.debug->scheduler().input_file_manager()->GetInputFileCount())
         + " GN files in " +
         base::IntToString(elapsed_time.InMilliseconds()) + "ms\n";
 
     OutputString(stats);
   }
 
   return 0;
 }
 
 }  // namespace commands