GN: Check if targets with precompiled headers use unsupported toolchains.

tools/gn/target.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/target.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
@@ skipping 290 matching lines @@
   FillOutputFiles();
 
   if (settings()->build_settings()->check_for_bad_items()) {
     if (!CheckVisibility(err))
       return false;
     if (!CheckTestonly(err))
       return false;
     if (!CheckAssertNoDeps(err))
       return false;
     CheckSourcesGenerated();
+    if (config_values_.has_precompiled_headers() &&
+        !CheckPrecompiledHeaders(err))
+      return false;
   }
 
   if (!write_runtime_deps_output_.value().empty())
     g_scheduler->AddWriteRuntimeDepsTarget(this);
 
   return true;
 }
 
 bool Target::IsBinary() const {
   return output_type_ == EXECUTABLE ||
@@ skipping 449 matching lines @@
     check_data_deps = g_scheduler->IsFileGeneratedByWriteRuntimeDeps(out_file);
     // Check object files (much slower and very rare) only if the "normal"
     // output check failed.
     consider_object_files = !check_data_deps;
     if (!EnsureFileIsGeneratedByDependency(this, out_file, true,
                                            consider_object_files,
                                            check_data_deps, &seen_targets))
       g_scheduler->AddUnknownGeneratedInput(this, source);
   }
 }
+
+bool Target::CheckPrecompiledHeaders(Err* err) const {
+  // Figure out what source types are needed.
+  SourceFileTypeSet used_types;
+  for (const auto& source : sources_)
+    used_types.Set(GetSourceFileType(source));
+
+  // Not all source types support precompiled precompiled headers.
+  static const SourceFileType kSourceTypesToCheck[] = {
+      SOURCE_C, SOURCE_CPP, SOURCE_M, SOURCE_MM,
+  };
+
+  bool is_valid = true;
+  for (auto type : kSourceTypesToCheck) {
+    if (!used_types.Get(type))
+      continue;
+
+    const Toolchain::ToolType toolType =
+        Toolchain::GetToolTypeForSourceType(type);
+    const Tool* tool = toolchain_->GetTool(toolType);
+
+    if (!tool || tool->precompiled_header_type() != Tool::PCH_NONE)
+      continue;
+
+    // Make a generic error first and then append a list of "broken" tool()s.
+    if (!err->has_error()) {
+      *err = Err(defined_from(),
+                 "Toolchain (" + toolchain_->label().GetUserVisibleName(false) +
+                     ") used by target (" + label().GetUserVisibleName(false) +
+                     ") doesn't support precompiled headers.",
+                 "Either remove the precompiled header from the target or add "
+                 "support to the toolchain.");
+      is_valid = false;
+    }
+
+    err->AppendSubErr(Err(tool->defined_from(),
+                          "Tool \"" + Toolchain::ToolTypeToName(toolType) +
+                              "\" doesn't set precompiled_header_type."));
+  }
+
+  return is_valid;
+}