merge FileStat into Node

The two were always one-to-one anyway.  I started adding accessors
to FileStat and then realized most users wanted them on Node and
that forwarding them through was silly.

Author: evmar

src/build.cc

@@ -195,8 +195,8 @@ bool Plan::AddSubTarget(Node* node, vector<Node*>* stack, string* err) {
     if (node->dirty_) {
       string referenced;
       if (!stack->empty())
-        referenced = ", needed by '" + stack->back()->file_->path_ + "',";
-      *err = "'" + node->file_->path_ + "'" + referenced + " missing "
+        referenced = ", needed by '" + stack->back()->path() + "',";
+      *err = "'" + node->path() + "'" + referenced + " missing "
              "and no known rule to make it";
     }
     return false;
@@ -256,7 +256,7 @@ bool Plan::CheckDependencyCycle(Node* node, vector<Node*>* stack, string* err) {
   for (vector<Node*>::iterator i = start; i != stack->end(); ++i) {
     if (i != start)
       err->append(" -> ");
-    err->append((*i)->file_->path_);
+    err->append((*i)->path());
   }
   return true;
 }
@@ -324,8 +324,8 @@ void Plan::CleanNode(BuildLog* build_log, Node* node) {
       // Recompute most_recent_input and command.
       time_t most_recent_input = 1;
       for (vector<Node*>::iterator ni = begin; ni != end; ++ni)
-        if ((*ni)->file_->mtime_ > most_recent_input)
-          most_recent_input = (*ni)->file_->mtime_;
+        if ((*ni)->mtime() > most_recent_input)
+          most_recent_input = (*ni)->mtime();
       string command = (*ei)->EvaluateCommand();
 
       // Now, recompute the dirty state of each output.
@@ -454,7 +454,7 @@ Node* Builder::AddTarget(const string& name, string* err) {
 }
 
 bool Builder::AddTarget(Node* node, string* err) {
-  node->file_->StatIfNecessary(disk_interface_);
+  node->StatIfNecessary(disk_interface_);
   if (Edge* in_edge = node->in_edge_) {
     if (!in_edge->RecomputeDirty(state_, disk_interface_, err))
       return false;
@@ -555,7 +555,7 @@ bool Builder::StartEdge(Edge* edge, string* err) {
   // XXX: this will block; do we care?
   for (vector<Node*>::iterator i = edge->outputs_.begin();
        i != edge->outputs_.end(); ++i) {
-    if (!disk_interface_->MakeDirs((*i)->file_->path_))
+    if (!disk_interface_->MakeDirs((*i)->path()))
       return false;
   }
 
@@ -578,9 +578,9 @@ void Builder::FinishEdge(Edge* edge, bool success, const string& output) {
 
       for (vector<Node*>::iterator i = edge->outputs_.begin();
            i != edge->outputs_.end(); ++i) {
-        if ((*i)->file_->exists()) {
-          time_t new_mtime = disk_interface_->Stat((*i)->file_->path_);
-          if ((*i)->file_->mtime_ == new_mtime) {
+        if ((*i)->exists()) {
+          time_t new_mtime = disk_interface_->Stat((*i)->path());
+          if ((*i)->mtime() == new_mtime) {
             // The rule command did not change the output.  Propagate the clean
             // state through the build graph.
             plan_.CleanNode(log_, *i);
@@ -594,7 +594,7 @@ void Builder::FinishEdge(Edge* edge, bool success, const string& output) {
         // (existing) non-order-only input or the depfile.
         for (vector<Node*>::iterator i = edge->inputs_.begin();
              i != edge->inputs_.end() - edge->order_only_deps_; ++i) {
-          time_t input_mtime = disk_interface_->Stat((*i)->file_->path_);
+          time_t input_mtime = disk_interface_->Stat((*i)->path());
           if (input_mtime == 0) {
             restat_mtime = 0;
             break;

src/build_log.cc

@@ -73,7 +73,7 @@ void BuildLog::RecordCommand(Edge* edge, int start_time, int end_time,
   const string command = edge->EvaluateCommand();
   for (vector<Node*>::iterator out = edge->outputs_.begin();
        out != edge->outputs_.end(); ++out) {
-    const string& path = (*out)->file_->path_;
+    const string& path = (*out)->path();
     Log::iterator i = log_.find(path.c_str());
     LogEntry* log_entry;
     if (i != log_.end()) {

src/build_test.cc

@@ -38,17 +38,17 @@ TEST_F(PlanTest, Basic) {
 
   Edge* edge = plan_.FindWork();
   ASSERT_TRUE(edge);
-  ASSERT_EQ("in",  edge->inputs_[0]->file_->path_);
-  ASSERT_EQ("mid", edge->outputs_[0]->file_->path_);
+  ASSERT_EQ("in",  edge->inputs_[0]->path());
+  ASSERT_EQ("mid", edge->outputs_[0]->path());
 
   ASSERT_FALSE(plan_.FindWork());
 
   plan_.EdgeFinished(edge);
 
   edge = plan_.FindWork();
   ASSERT_TRUE(edge);
-  ASSERT_EQ("mid", edge->inputs_[0]->file_->path_);
-  ASSERT_EQ("out", edge->outputs_[0]->file_->path_);
+  ASSERT_EQ("mid", edge->inputs_[0]->path());
+  ASSERT_EQ("out", edge->outputs_[0]->path());
 
   plan_.EdgeFinished(edge);
 
@@ -222,7 +222,7 @@ void BuildTest::Dirty(const string& path) {
   // If it's an input file, mark that we've already stat()ed it and
   // it's missing.
   if (!node->in_edge_)
-    node->file_->mtime_ = 0;
+    node->MarkMissing();
 }
 
 bool BuildTest::CanRunMore() {
@@ -237,7 +237,7 @@ bool BuildTest::StartCommand(Edge* edge) {
       edge->rule().name_ == "touch") {
     for (vector<Node*>::iterator out = edge->outputs_.begin();
          out != edge->outputs_.end(); ++out) {
-      fs_.Create((*out)->file_->path_, now_, "");
+      fs_.Create((*out)->path(), now_, "");
     }
   } else if (edge->rule().name_ == "true" ||
              edge->rule().name_ == "fail") {
@@ -508,10 +508,10 @@ TEST_F(BuildTest, OrderOnlyDeps) {
   EXPECT_EQ(1, edge->order_only_deps_);
   // Verify the inputs are in the order we expect
   // (explicit then implicit then orderonly).
-  EXPECT_EQ("foo.c", edge->inputs_[0]->file_->path_);
-  EXPECT_EQ("blah.h", edge->inputs_[1]->file_->path_);
-  EXPECT_EQ("bar.h", edge->inputs_[2]->file_->path_);
-  EXPECT_EQ("otherfile", edge->inputs_[3]->file_->path_);
+  EXPECT_EQ("foo.c", edge->inputs_[0]->path());
+  EXPECT_EQ("blah.h", edge->inputs_[1]->path());
+  EXPECT_EQ("bar.h", edge->inputs_[2]->path());
+  EXPECT_EQ("otherfile", edge->inputs_[3]->path());
 
   // Expect the command line we generate to only use the original input.
   ASSERT_EQ("cc foo.c", edge->EvaluateCommand());

src/clean.cc

@@ -109,7 +109,7 @@ int Cleaner::CleanAll(bool generator) {
       continue;
     for (vector<Node*>::iterator out_node = (*e)->outputs_.begin();
          out_node != (*e)->outputs_.end(); ++out_node) {
-      Remove((*out_node)->file_->path_);
+      Remove((*out_node)->path());
     }
     if (!(*e)->rule().depfile_.empty())
       Remove((*e)->EvaluateDepFile());
@@ -120,7 +120,7 @@ int Cleaner::CleanAll(bool generator) {
 
 void Cleaner::DoCleanTarget(Node* target) {
   if (target->in_edge_) {
-    Remove(target->file_->path_);
+    Remove(target->path());
     for (vector<Node*>::iterator n = target->in_edge_->inputs_.begin();
          n != target->in_edge_->inputs_.end();
          ++n) {
@@ -182,7 +182,7 @@ void Cleaner::DoCleanRule(const Rule* rule) {
       for (vector<Node*>::iterator out_node = (*e)->outputs_.begin();
            out_node != (*e)->outputs_.end();
            ++out_node)
-        Remove((*out_node)->file_->path_);
+        Remove((*out_node)->path());
 }
 
 int Cleaner::CleanRule(const Rule* rule) {

src/disk_interface_test.cc

@@ -193,7 +193,7 @@ TEST_F(StatTest, Simple) {
 "build out: cat in\n"));
 
   Node* out = GetNode("out");
-  out->file_->Stat(this);
+  out->Stat(this);
   ASSERT_EQ(1u, stats_.size());
   Edge* edge = out->in_edge_;
   edge->RecomputeDirty(NULL, this, NULL);
@@ -208,7 +208,7 @@ TEST_F(StatTest, TwoStep) {
 "build mid: cat in\n"));
 
   Node* out = GetNode("out");
-  out->file_->Stat(this);
+  out->Stat(this);
   ASSERT_EQ(1u, stats_.size());
   Edge* edge = out->in_edge_;
   edge->RecomputeDirty(NULL, this, NULL);
@@ -227,7 +227,7 @@ TEST_F(StatTest, Tree) {
 "build mid2: cat in21 in22\n"));
 
   Node* out = GetNode("out");
-  out->file_->Stat(this);
+  out->Stat(this);
   ASSERT_EQ(1u, stats_.size());
   Edge* edge = out->in_edge_;
   edge->RecomputeDirty(NULL, this, NULL);
@@ -247,7 +247,7 @@ TEST_F(StatTest, Middle) {
   mtimes_["out"] = 1;
 
   Node* out = GetNode("out");
-  out->file_->Stat(this);
+  out->Stat(this);
   ASSERT_EQ(1u, stats_.size());
   Edge* edge = out->in_edge_;
   edge->RecomputeDirty(NULL, this, NULL);

src/graph.cc

@@ -23,7 +23,7 @@
 #include "state.h"
 #include "util.h"
 
-bool FileStat::Stat(DiskInterface* disk_interface) {
+bool Node::Stat(DiskInterface* disk_interface) {
   mtime_ = disk_interface->Stat(path_);
   return mtime_ > 0;
 }
@@ -41,13 +41,13 @@ bool Edge::RecomputeDirty(State* state, DiskInterface* disk_interface,
   // Visit all inputs; we're dirty if any of the inputs are dirty.
   time_t most_recent_input = 1;
   for (vector<Node*>::iterator i = inputs_.begin(); i != inputs_.end(); ++i) {
-    if ((*i)->file_->StatIfNecessary(disk_interface)) {
+    if ((*i)->StatIfNecessary(disk_interface)) {
       if (Edge* edge = (*i)->in_edge_) {
         if (!edge->RecomputeDirty(state, disk_interface, err))
           return false;
       } else {
         // This input has no in-edge; it is dirty if it is missing.
-        (*i)->dirty_ = !(*i)->file_->exists();
+        (*i)->dirty_ = !(*i)->exists();
       }
     }
 
@@ -63,8 +63,8 @@ bool Edge::RecomputeDirty(State* state, DiskInterface* disk_interface,
       if ((*i)->dirty_) {
         dirty = true;
       } else {
-        if ((*i)->file_->mtime_ > most_recent_input)
-          most_recent_input = (*i)->file_->mtime_;
+        if ((*i)->mtime() > most_recent_input)
+          most_recent_input = (*i)->mtime();
       }
     }
   }
@@ -77,7 +77,7 @@ bool Edge::RecomputeDirty(State* state, DiskInterface* disk_interface,
 
     for (vector<Node*>::iterator i = outputs_.begin();
          i != outputs_.end(); ++i) {
-      (*i)->file_->StatIfNecessary(disk_interface);
+      (*i)->StatIfNecessary(disk_interface);
       if (RecomputeOutputDirty(build_log, most_recent_input, command, *i)) {
         dirty = true;
         break;
@@ -88,7 +88,7 @@ bool Edge::RecomputeDirty(State* state, DiskInterface* disk_interface,
   // Finally, visit each output to mark off that we've visited it, and update
   // their dirty state if necessary.
   for (vector<Node*>::iterator i = outputs_.begin(); i != outputs_.end(); ++i) {
-    (*i)->file_->StatIfNecessary(disk_interface);
+    (*i)->StatIfNecessary(disk_interface);
     if (dirty)
       (*i)->dirty_ = true;
   }
@@ -107,23 +107,23 @@ bool Edge::RecomputeOutputDirty(BuildLog* build_log, time_t most_recent_input,
   if (is_phony()) {
     // Phony edges don't write any output.
     // Outputs are only dirty if there are no inputs and we're missing the output.
-    return inputs_.empty() && !output->file_->exists();
+    return inputs_.empty() && !output->exists();
   }
 
   BuildLog::LogEntry* entry = 0;
 
   // Dirty if we're missing the output.
-  if (!output->file_->exists())
+  if (!output->exists())
     return true;
 
   // Dirty if the output is older than the input.
-  if (output->file_->mtime_ < most_recent_input) {
+  if (output->mtime() < most_recent_input) {
     // If this is a restat rule, we may have cleaned the output with a restat
     // rule in a previous run and stored the most recent input mtime in the
     // build log.  Use that mtime instead, so that the file will only be
     // considered dirty if an input was modified since the previous run.
     if (rule_->restat_ && build_log &&
-        (entry = build_log->LookupByOutput(output->file_->path_))) {
+        (entry = build_log->LookupByOutput(output->path()))) {
       if (entry->restat_mtime < most_recent_input)
         return true;
     } else {
@@ -135,7 +135,7 @@ bool Edge::RecomputeOutputDirty(BuildLog* build_log, time_t most_recent_input,
   // But if this is a generator rule, the command changing does not make us
   // dirty.
   if (!rule_->generator_ && build_log &&
-      (entry || (entry = build_log->LookupByOutput(output->file_->path_)))) {
+      (entry || (entry = build_log->LookupByOutput(output->path())))) {
     if (command != entry->command)
       return true;
   }
@@ -164,14 +164,14 @@ struct EdgeEnv : public Env {
            i != edge_->inputs_.end() && explicit_deps; ++i, --explicit_deps) {
         if (!result.empty())
           result.push_back(' ');
-        result.append((*i)->file_->path_);
+        result.append((*i)->path());
       }
     } else if (var == "out") {
       for (vector<Node*>::iterator i = edge_->outputs_.begin();
            i != edge_->outputs_.end(); ++i) {
         if (!result.empty())
           result.push_back(' ');
-        result.append((*i)->file_->path_);
+        result.append((*i)->path());
       }
     } else if (edge_->env_) {
       return edge_->env_->LookupVariable(var);
@@ -213,10 +213,10 @@ bool Edge::LoadDepFile(State* state, DiskInterface* disk_interface,
   }
 
   // Check that this depfile matches our output.
-  StringPiece opath = StringPiece(outputs_[0]->file_->path_);
+  StringPiece opath = StringPiece(outputs_[0]->path());
   if (opath != makefile.out_) {
     *err = "expected depfile '" + path + "' to mention '" +
-      outputs_[0]->file_->path_ + "', got '" + makefile.out_.AsString() + "'";
+      outputs_[0]->path() + "', got '" + makefile.out_.AsString() + "'";
     return false;
   }
 
@@ -260,11 +260,11 @@ bool Edge::LoadDepFile(State* state, DiskInterface* disk_interface,
 void Edge::Dump() {
   printf("[ ");
   for (vector<Node*>::iterator i = inputs_.begin(); i != inputs_.end(); ++i) {
-    printf("%s ", (*i)->file_->path_.c_str());
+    printf("%s ", (*i)->path().c_str());
   }
   printf("--%s-> ", rule_->name_.c_str());
   for (vector<Node*>::iterator i = outputs_.begin(); i != outputs_.end(); ++i) {
-    printf("%s ", (*i)->file_->path_.c_str());
+    printf("%s ", (*i)->path().c_str());
   }
   printf("]\n");
 }