Allow directory as inputs, i.e. input paths ending in /

doc/manual.asciidoc

@@ -1176,6 +1176,28 @@ express the implicit dependency.)
 File paths are compared as is, which means that an absolute path and a
 relative path, pointing to the same file, are considered different by Ninja.
 
+[[dir_inputs]]
+Directory inputs
+~~~~~~~~~~~~~~~~
+
+_Available since Ninja 1.14._
+
+If an input path on a build line ends with a path separator (`/`), the input is
+treated as a directory rather than a regular file. When Ninja checks whether the
+build edge is up-to-date, it stats the directory itself and compares its
+modification time against the outputs.
+
+Most filesystems update a directory's modification time whenever entries are
+added to or removed from it, so a directory input is a convenient way to
+re-run a command when the *set* of files in a directory changes (for example,
+to regenerate an index when new source files are added). Changes to the
+contents of individual files inside the directory do not normally update the
+directory's modification time, so they will not by themselves trigger a rebuild
+- list the affected files explicitly (or via a depfile) if that is desired.
+
+A path with a trailing separator that exists but is not a directory is treated
+as missing.
+
 [[validations]]
 Validations
 ~~~~~~~~~~~

src/build.cc

@@ -110,7 +110,10 @@ bool Plan::AddSubTarget(const Node* node, const Node* dependent, string* err,
        string referenced;
        if (dependent)
          referenced = ", needed by '" + dependent->path() + "',";
-       *err = "'" + node->path() + "'" + referenced +
+       string display_path = node->path();
+       if (node->is_directory())
+         display_path += '/';
+       *err = "'" + display_path + "'" + referenced +
               " missing and no known rule to make it";
      }
      return false;

src/graph.cc

@@ -293,7 +293,19 @@ bool RecomputeOutputsDirtyCache::RecomputeOutputDirty(
 }  // namespace
 
 bool Node::Stat(DiskInterface* disk_interface, string* err) {
-  mtime_ = disk_interface->Stat(path_, err);
+  // For directory inputs, append a trailing slash so that the underlying
+  // stat() call only succeeds for actual directories. On POSIX, stat()ing a
+  // regular file with a trailing slash returns ENOTDIR, which the disk
+  // interface reports as a missing file (mtime == 0). Directories
+  // successfully stat()ed will report the directory's own mtime, which
+  // changes whenever entries are added to or removed from the directory.
+  if (is_directory_) {
+    string stat_path = path_;
+    stat_path += '/';
+    mtime_ = disk_interface->Stat(stat_path, err);
+  } else {
+    mtime_ = disk_interface->Stat(path_, err);
+  }
   if (mtime_ == -1) {
     return false;
   }

src/graph.h

@@ -110,6 +110,12 @@ struct Node {
     generated_by_dep_loader_ = value;
   }
 
+  /// True if this node refers to a directory (path was given with a trailing
+  /// slash in the manifest). When stat()ed, the directory's mtime is used to
+  /// determine whether dependents are out-of-date.
+  bool is_directory() const { return is_directory_; }
+  void set_directory(bool value) { is_directory_ = value; }
+
   int id() const { return id_; }
   void set_id(int id) { id_ = id; }
 
@@ -159,6 +165,11 @@ struct Node {
   /// can be loaded before the manifest.
   bool generated_by_dep_loader_ = true;
 
+  /// True if this node refers to a directory rather than a regular file.
+  /// Set when a manifest input/output path ends with a trailing slash. When
+  /// stat()ing, the path is treated as a directory and its mtime is used.
+  bool is_directory_ = false;
+
   /// A dense integer id for the node, assigned and used by DepsLog.
   int id_ = -1;
 

src/graph_test.cc

@@ -1255,3 +1255,67 @@ TEST_F(GraphTest, PhonyOutputWithValidation) {
   ASSERT_EQ(1u, validation_nodes.size());
   EXPECT_EQ("valid", validation_nodes[0]->path());
 }
+
+// A trailing slash in a manifest input marks the input as a directory. The
+// canonical path on the Node has the slash removed, but the node carries the
+// is_directory() flag so that Node::Stat() looks up the directory entry.
+TEST_F(GraphTest, DirectoryInputParsed) {
+  ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
+                                      "build out: cat indir/\n"));
+
+  Node* in_node = GetNode("indir");
+  ASSERT_TRUE(in_node != NULL);
+  EXPECT_TRUE(in_node->is_directory());
+  EXPECT_EQ("indir", in_node->path());
+}
+
+// When the directory mtime advances past the output's mtime, the output is
+// considered dirty.
+TEST_F(GraphTest, DirectoryInputMtimeDirty) {
+  ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
+                                      "build out: cat indir/\n"));
+  // Initial state: directory and output both at tick 1.
+  fs_.Create("indir/", "");
+  fs_.Create("out", "");
+  fs_.Tick();
+  // Directory mtime bumped (e.g. a file was added).
+  fs_.Create("indir/", "");
+
+  string err;
+  EXPECT_TRUE(scan_.RecomputeDirty(GetNode("out"), NULL, &err));
+  ASSERT_EQ("", err);
+  EXPECT_TRUE(GetNode("out")->dirty());
+}
+
+// When the directory mtime is unchanged, the output is up-to-date even though
+// individual files inside the directory may have changed.
+TEST_F(GraphTest, DirectoryInputUpToDate) {
+  ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
+                                      "build out: cat indir/\n"));
+  fs_.Create("indir/", "");
+  fs_.Tick();
+  fs_.Create("out", "");
+
+  string err;
+  EXPECT_TRUE(scan_.RecomputeDirty(GetNode("out"), NULL, &err));
+  ASSERT_EQ("", err);
+  EXPECT_FALSE(GetNode("out")->dirty());
+}
+
+// A directory input pointing at a non-existent directory should be treated as
+// missing (and therefore dirty), even if a regular file exists at the same
+// path without a trailing slash.
+TEST_F(GraphTest, DirectoryInputMissingTreatedAsDirty) {
+  ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
+                                      "build out: cat indir/\n"));
+  // A regular file with the same name as the directory, but no directory
+  // entry. The virtual filesystem keys entries by exact path, so "indir/"
+  // is not found.
+  fs_.Create("indir", "");
+  fs_.Create("out", "");
+
+  string err;
+  EXPECT_TRUE(scan_.RecomputeDirty(GetNode("out"), NULL, &err));
+  ASSERT_EQ("", err);
+  EXPECT_TRUE(GetNode("out")->dirty());
+}

src/manifest_parser.cc

@@ -363,9 +363,13 @@ bool ManifestParser::ParseEdge(string* err) {
     string path = i->Evaluate(env);
     if (path.empty())
       return lexer_.Error("empty path", err);
+    // A trailing path separator indicates that the input refers to a directory
+    // rather than a regular file. CanonicalizePath strips the separator, so
+    // detect it first.
+    bool is_directory = path.back() == '/';
     uint64_t slash_bits;
     CanonicalizePath(&path, &slash_bits);
-    state_->AddIn(edge, path, slash_bits);
+    state_->AddIn(edge, path, slash_bits, is_directory);
   }
   edge->implicit_deps_ = implicit;
   edge->order_only_deps_ = order_only;

src/state.cc

@@ -125,9 +125,13 @@ Node* State::SpellcheckNode(const string& path) {
   return result;
 }
 
-void State::AddIn(Edge* edge, StringPiece path, uint64_t slash_bits) {
+void State::AddIn(Edge* edge, StringPiece path, uint64_t slash_bits,
+                  bool is_directory) {
   Node* node = GetNode(path, slash_bits);
   node->set_generated_by_dep_loader(false);
+  if (is_directory) {
+    node->set_directory(true);
+  }
   edge->inputs_.push_back(node);
   node->AddOutEdge(edge);
 }

src/state.h

@@ -110,7 +110,10 @@ struct State {
   /// Add input / output / validation nodes to a given edge. This also
   /// ensures that the generated_by_dep_loader() flag for all these nodes
   /// is set to false, to indicate that they come from the input manifest.
-  void AddIn(Edge* edge, StringPiece path, uint64_t slash_bits);
+  /// If \a is_directory is true, the input refers to a directory (the
+  /// manifest path ended with a trailing slash).
+  void AddIn(Edge* edge, StringPiece path, uint64_t slash_bits,
+             bool is_directory = false);
   bool AddOut(Edge* edge, StringPiece path, uint64_t slash_bits, std::string* err);
   void AddValidation(Edge* edge, StringPiece path, uint64_t slash_bits);
   bool AddDefault(StringPiece path, std::string* error);