tools/gn/header_checker.h

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef TOOLS_GN_HEADER_CHECKER_H_
   6 #define TOOLS_GN_HEADER_CHECKER_H_
   7
   8 #include <map>
   9 #include <set>
  10 #include <vector>
  11
  12 #include "base/basictypes.h"
  13 #include "base/gtest_prod_util.h"
  14 #include "base/memory/ref_counted.h"
  15 #include "base/run_loop.h"
  16 #include "base/strings/string_piece.h"
  17 #include "base/synchronization/lock.h"
  18 #include "tools/gn/err.h"
  19
  20 class BuildSettings;
  21 class InputFile;
  22 class Label;
  23 class LocationRange;
  24 class SourceFile;
  25 class Target;
  26
  27 namespace base {
  28 class MessageLoop;
  29 }
  30
  31 class HeaderChecker : public base::RefCountedThreadSafe<HeaderChecker> {
  32  public:
  33   // Represents a dependency chain.
  34   struct ChainLink {
  35     ChainLink() : target(nullptr), is_public(false) {}
  36     ChainLink(const Target* t, bool p) : target(t), is_public(p) {}
  37
  38     const Target* target;
  39
  40     // True when the dependency on this target is public.
  41     bool is_public;
  42
  43     // Used for testing.
  44     bool operator==(const ChainLink& other) const {
  45       return target == other.target && is_public == other.is_public;
  46     }
  47   };
  48   typedef std::vector<ChainLink> Chain;
  49
  50   HeaderChecker(const BuildSettings* build_settings,
  51                 const std::vector<const Target*>& targets);
  52
  53   // Runs the check. The targets in to_check will be checked.
  54   //
  55   // This assumes that the current thread already has a message loop. On
  56   // error, fills the given vector with the errors and returns false. Returns
  57   // true on success.
  58   //
  59   // force_check, if true, will override targets opting out of header checking
  60   // with "check_includes = false" and will check them anyway.
  61   bool Run(const std::vector<const Target*>& to_check,
  62            bool force_check,
  63            std::vector<Err>* errors);
  64
  65  private:
  66   friend class base::RefCountedThreadSafe<HeaderChecker>;
  67   FRIEND_TEST_ALL_PREFIXES(HeaderCheckerTest, IsDependencyOf);
  68   FRIEND_TEST_ALL_PREFIXES(HeaderCheckerTest, CheckInclude);
  69   FRIEND_TEST_ALL_PREFIXES(HeaderCheckerTest, PublicFirst);
  70   FRIEND_TEST_ALL_PREFIXES(HeaderCheckerTest, CheckIncludeAllowCircular);
  71   ~HeaderChecker();
  72
  73   struct TargetInfo {
  74     TargetInfo() : target(nullptr), is_public(false), is_generated(false) {}
  75     TargetInfo(const Target* t, bool is_pub, bool is_gen)
  76         : target(t),
  77           is_public(is_pub),
  78           is_generated(is_gen) {
  79     }
  80
  81     const Target* target;
  82
  83     // True if the file is public in the given target.
  84     bool is_public;
  85
  86     // True if this file is generated and won't actually exist on disk.
  87     bool is_generated;
  88   };
  89
  90   typedef std::vector<TargetInfo> TargetVector;
  91   typedef std::map<SourceFile, TargetVector> FileMap;
  92
  93   // Backend for Run() that takes the list of files to check. The errors_ list
  94   // will be populate on failure.
  95   void RunCheckOverFiles(const FileMap& flies, bool force_check);
  96
  97   void DoWork(const Target* target, const SourceFile& file);
  98
  99   // Adds the sources and public files from the given target to the given map.
 100   static void AddTargetToFileMap(const Target* target, FileMap* dest);
 101
 102   // Returns true if the given file is in the output directory.
 103   bool IsFileInOuputDir(const SourceFile& file) const;
 104
 105   // Resolves the contents of an include to a SourceFile.
 106   SourceFile SourceFileForInclude(const base::StringPiece& input) const;
 107
 108   // from_target is the target the file was defined from. It will be used in
 109   // error messages.
 110   bool CheckFile(const Target* from_target,
 111                  const SourceFile& file,
 112                  Err* err) const;
 113
 114   // Checks that the given file in the given target can include the given
 115   // include file. If disallowed, returns false and sets the error. The
 116   // range indicates the location of the include in the file for error
 117   // reporting.
 118   bool CheckInclude(const Target* from_target,
 119                     const InputFile& source_file,
 120                     const SourceFile& include_file,
 121                     const LocationRange& range,
 122                     Err* err) const;
 123
 124   // Returns true if the given search_for target is a dependency of
 125   // search_from.
 126   //
 127   // If found, the vector given in "chain" will be filled with the reverse
 128   // dependency chain from the dest target (chain[0] = search_for) to the src
 129   // target (chain[chain.size() - 1] = search_from).
 130   //
 131   // Chains with permitted dependencies will be considered first. If a
 132   // permitted match is found, *is_permitted will be set to true. A chain with
 133   // indirect, non-public dependencies will only be considered if there are no
 134   // public or direct chains. In this case, *is_permitted will be false.
 135   //
 136   // A permitted dependency is a sequence of public dependencies. The first
 137   // one may be private, since a direct dependency always allows headers to be
 138   // included.
 139   bool IsDependencyOf(const Target* search_for,
 140                       const Target* search_from,
 141                       Chain* chain,
 142                       bool* is_permitted) const;
 143
 144   // For internal use by the previous override of IsDependencyOf.  If
 145   // require_public is true, only public dependency chains are searched.
 146   bool IsDependencyOf(const Target* search_for,
 147                       const Target* search_from,
 148                       bool require_permitted,
 149                       Chain* chain) const;
 150
 151   // Makes a very descriptive error message for when an include is disallowed
 152   // from a given from_target, with a missing dependency to one of the given
 153   // targets.
 154   static Err MakeUnreachableError(const InputFile& source_file,
 155                                   const LocationRange& range,
 156                                   const Target* from_target,
 157                                   const TargetVector& targets);
 158
 159   // Non-locked variables ------------------------------------------------------
 160   //
 161   // These are initialized during construction (which happens on one thread)
 162   // and are not modified after, so any thread can read these without locking.
 163
 164   base::MessageLoop* main_loop_;
 165   base::RunLoop main_thread_runner_;
 166
 167   const BuildSettings* build_settings_;
 168
 169   // Maps source files to targets it appears in (usually just one target).
 170   FileMap file_map_;
 171
 172   // Locked variables ----------------------------------------------------------
 173   //
 174   // These are mutable during runtime and require locking.
 175
 176   base::Lock lock_;
 177
 178   std::vector<Err> errors_;
 179
 180   DISALLOW_COPY_AND_ASSIGN(HeaderChecker);
 181 };
 182
 183 #endif  // TOOLS_GN_HEADER_CHECKER_H_