Add outputs to GN's header checker.

tools/gn/header_checker.cc

 // Copyright 2014 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/header_checker.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/message_loop/message_loop.h"
+#include "base/strings/string_util.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "tools/gn/build_settings.h"
 #include "tools/gn/builder.h"
 #include "tools/gn/c_include_iterator.h"
 #include "tools/gn/config.h"
 #include "tools/gn/err.h"
 #include "tools/gn/filesystem_utils.h"
 #include "tools/gn/scheduler.h"
 #include "tools/gn/source_file_type.h"
 #include "tools/gn/target.h"
 #include "tools/gn/trace.h"
 
 namespace {
 
+struct PublicGeneratedPair {
+  PublicGeneratedPair() : is_public(false), is_generated(false) {}
+  bool is_public;
+  bool is_generated;
+};
+
+// If the given file is in the "gen" folder, trims this so it treats the gen
+// directory as the source root:
+//   //out/Debug/gen/foo/bar.h -> //foo/bar.h
+// If the file isn't in the generated root, returns the input unchanged.
+SourceFile RemoveRootGenDirFromFile(const Target* target,
+                                    const SourceFile& file) {
+  const SourceDir& gen = target->settings()->toolchain_gen_dir();
+  if (StartsWithASCII(file.value(), gen.value(), true))
+    return SourceFile("//" + file.value().substr(gen.value().size()));
+  return file;
+}
+
 // This class makes InputFiles on the stack as it reads files to check. When
 // we throw an error, the Err indicates a locatin which has a pointer to
 // an InputFile that must persist as long as the Err does.
 //
 // To make this work, this function creates a clone of the InputFile managed
 // by the InputFileManager so the error can refer to something that
 // persists. This means that the current file contents will live as long as
 // the program, but this is OK since we're erroring out anyway.
 LocationRange CreatePersistentRange(const InputFile& input_file,
                                     const LocationRange& range) {
@@ skipping 123 matching lines @@
        file_i != files.end(); ++file_i) {
     const TargetVector& vect = file_i->second;
 
     // Only check C-like source files (RC files also have includes).
     SourceFileType type = GetSourceFileType(file_i->first);
     if (type != SOURCE_CC && type != SOURCE_H && type != SOURCE_C &&
         type != SOURCE_M && type != SOURCE_MM && type != SOURCE_RC)
       continue;
 
     // Do a first pass to find if this should be skipped. All targets including
-    // this source file must exclude it from checking.
+    // this source file must exclude it from checking, or it must be generated.
     if (!force_check) {
       bool check_includes = false;
-      for (size_t vect_i = 0; vect_i < vect.size(); ++vect_i)
-        check_includes |= vect[vect_i].target->check_includes();
+      for (size_t vect_i = 0; vect_i < vect.size(); ++vect_i) {
+        check_includes |=
+            vect[vect_i].target->check_includes() &&
+            !vect[vect_i].is_generated;
+      }
       if (!check_includes)
         continue;
     }
 
     for (size_t vect_i = 0; vect_i < vect.size(); ++vect_i) {
       pool->PostWorkerTaskWithShutdownBehavior(
           FROM_HERE,
           base::Bind(&HeaderChecker::DoWork, this,
                      vect[vect_i].target, file_i->first),
           base::SequencedWorkerPool::BLOCK_SHUTDOWN);
@@ skipping 11 matching lines @@
     errors_.push_back(err);
   }
 }
 
 // static
 void HeaderChecker::AddTargetToFileMap(const Target* target, FileMap* dest) {
   // Files in the sources have this public bit by default.
   bool default_public = target->all_headers_public();
 
   // First collect the normal files, they get the default visibility.
-  std::map<SourceFile, bool> files_to_public;
+  std::map<SourceFile, PublicGeneratedPair> files_to_public;
   const Target::FileList& sources = target->sources();
   for (size_t i = 0; i < sources.size(); i++)
-    files_to_public[sources[i]] = default_public;
+    files_to_public[sources[i]].is_public = default_public;
 
   // Add in the public files, forcing them to public. This may overwrite some
   // entries, and it may add new ones.
   const Target::FileList& public_list = target->public_headers();
   if (default_public)
     DCHECK(public_list.empty());  // List only used when default is not public.
   for (size_t i = 0; i < public_list.size(); i++)
-    files_to_public[public_list[i]] = true;
+    files_to_public[public_list[i]].is_public = true;
+
+  // Add in outputs from actions. These are treated as public (since if other
+  // targets can't use them, then there wouldn't be any point in outputting).
+  std::vector<SourceFile> outputs;
+  target->action_values().GetOutputsAsSourceFiles(target, &outputs);
+  for (size_t i = 0; i < outputs.size(); i++) {
+    // For generated files in the "gen" directory, add the filename to the
+    // map assuming "gen" is the source root. This means that when files include
+    // the generated header relative to there (the recommended practice), we'll
+    // find the file.
+    SourceFile output_file = RemoveRootGenDirFromFile(target, outputs[i]);
+    PublicGeneratedPair* pair = &files_to_public[output_file];
+    pair->is_public = true;
+    pair->is_generated = true;
+  }
 
   // Add the merged list to the master list of all files.
-  for (std::map<SourceFile, bool>::const_iterator i = files_to_public.begin();
-       i != files_to_public.end(); ++i)
-    (*dest)[i->first].push_back(TargetInfo(target, i->second));
+  for (std::map<SourceFile, PublicGeneratedPair>::const_iterator i =
+           files_to_public.begin();
+       i != files_to_public.end(); ++i) {
+    (*dest)[i->first].push_back(TargetInfo(
+        target, i->second.is_public, i->second.is_generated));
+  }
 }
 
 bool HeaderChecker::IsFileInOuputDir(const SourceFile& file) const {
   const std::string& build_dir = build_settings_->build_dir().value();
   return file.value().compare(0, build_dir.size(), build_dir) == 0;
 }
 
 // This current assumes all include paths are relative to the source root
 // which is generally the case for Chromium.
 //
@@ skipping 281 matching lines @@
         chain[i]->forward_dependent_configs();
     if (std::find_if(forwarded.begin(), forwarded.end(),
                      LabelPtrPtrEquals<Target>(chain[i - 1])) ==
         forwarded.end())
       return i;
   }
 
   CHECK(false) << "Unable to diagnose dependent config chain problem.";
   return 0;
 }