Merge pull request #2730 from jhasse/restat-with-builddir

"ninja -t restat" doesn't work with "builddir"

Author: jhasse

doc/manual.asciidoc

@@ -397,6 +397,9 @@ _Available since Ninja 1.11._
 
 `restat`:: updates all recorded file modification timestamps in the `.ninja_log`
 file. _Available since Ninja 1.10._
++
+The build manifest won't be parsed when running this tool. If you're using a
+`builddir` you must pass it via `--builddir=DIR`. _Available since Ninja 1.14._
 
 `rules`:: output the list of all rules. It can be used to know which rule name
 to pass to +ninja -t targets rule _name_+ or +ninja -t compdb+. Adding the `-d`

src/ninja.cc

@@ -1114,20 +1114,25 @@ int NinjaMain::ToolRestat(const Options* options, int argc, char* argv[]) {
 
   optind = 1;
   int opt;
-  while ((opt = getopt(argc, argv, const_cast<char*>("h"))) != -1) {
+  const option kLongOptions[] = { { "builddir", required_argument, nullptr,
+                                    'b' },
+                                  { "help", no_argument, nullptr, 'h' },
+                                  { nullptr, 0, nullptr, 0 } };
+  while ((opt = getopt_long(argc, argv, const_cast<char*>("h"), kLongOptions,
+                            nullptr)) != -1) {
     switch (opt) {
+    case 'b':
+      build_dir_ = optarg;
+      break;
     case 'h':
     default:
-      printf("usage: ninja -t restat [outputs]\n");
+      printf("usage: ninja -t restat [--builddir=DIR] [outputs]\n");
       return 1;
     }
   }
   argv += optind;
   argc -= optind;
 
-  if (!EnsureBuildDirExists())
-    return 1;
-
   string log_path = ".ninja_log";
   if (!build_dir_.empty())
     log_path = build_dir_ + "/" + log_path;

tests/restat/test_restat_builddir.py

@@ -0,0 +1,129 @@
+#!/usr/bin/env python3
+
+"""Integration test for 'ninja -t restat' with builddir."""
+
+import os
+import subprocess
+import tempfile
+import time
+import unittest
+
+NINJA_PATH = os.path.abspath("./ninja")
+
+
+class RestatBuildDirTest(unittest.TestCase):
+    """Test that 'ninja -t restat' respects builddir."""
+
+    def setUp(self):
+        """Create a temporary directory for the test."""
+        self.test_dir = tempfile.mkdtemp(prefix="ninja_restat_test_")
+        self.original_dir = os.getcwd()
+        os.chdir(self.test_dir)
+
+    def tearDown(self):
+        """Clean up the temporary directory."""
+        os.chdir(self.original_dir)
+        import shutil
+
+        shutil.rmtree(self.test_dir, ignore_errors=True)
+
+    def test_restat_with_builddir(self):
+        """Test that ninja -t restat updates mtime in builddir/.ninja_log."""
+
+        # Create a simple build.ninja file with builddir
+        build_ninja = """
+builddir = build
+
+rule touch
+  command = touch $out
+  description = Creating $out
+
+build output.txt: touch
+"""
+        with open("build.ninja", "w") as f:
+            f.write(build_ninja)
+
+        # Run ninja to build the output
+        result = subprocess.run([NINJA_PATH], capture_output=True, text=True)
+        self.assertEqual(result.returncode, 0, f"Initial build failed: {result.stderr}")
+        self.assertTrue(os.path.exists("output.txt"), "output.txt was not created")
+        self.assertTrue(
+            os.path.exists("build/.ninja_log"), "build/.ninja_log was not created"
+        )
+
+        # Read the original .ninja_log to get the initial mtime
+        with open("build/.ninja_log", "r") as f:
+            log_lines = f.readlines()
+
+        # Find the entry for output.txt
+        output_entry = ""
+        for line in log_lines:
+            if "output.txt" in line:
+                output_entry = line.strip()
+                break
+
+        self.assertNotEqual(
+            output_entry, "", "output.txt not found in build/.ninja_log"
+        )
+
+        # Parse the log entry: start_time\tend_time\tmtime\toutput\tcommand_hash
+        parts = output_entry.split("\t")
+        self.assertEqual(len(parts), 5, f"Unexpected log format: {output_entry}")
+        original_mtime = int(parts[2])
+
+        # Wait a bit to ensure different mtime
+        time.sleep(0.01)
+
+        # Touch the output file to update its mtime using explicit time
+        current_time = time.time() + 2  # Add 2 seconds to ensure different mtime
+        os.utime("output.txt", (current_time, current_time))
+
+        # Get the new actual file mtime
+        new_file_mtime = int(
+            os.path.getmtime("output.txt") * 1000000000
+        )  # Convert to nanoseconds
+        self.assertGreater(
+            new_file_mtime,
+            original_mtime,
+            f"File mtime should have increased: {new_file_mtime} vs {original_mtime}",
+        )
+
+        # Run ninja -t restat
+        result = subprocess.run(
+            [NINJA_PATH, "-t", "restat", "--builddir=build"],
+            capture_output=True,
+            text=True,
+        )
+        self.assertEqual(
+            result.returncode, 0, f"ninja -t restat failed: {result.stderr}"
+        )
+
+        # Read the updated .ninja_log
+        with open("build/.ninja_log", "r") as f:
+            updated_log_lines = f.readlines()
+
+        # Find the updated entry for output.txt
+        updated_entry = ""
+        for line in updated_log_lines:
+            if "output.txt" in line:
+                updated_entry = line.strip()
+                break
+
+        self.assertNotEqual(
+            updated_entry, "", "output.txt not found in updated build/.ninja_log"
+        )
+
+        # Parse the updated log entry
+        updated_parts = updated_entry.split("\t")
+        self.assertEqual(
+            len(updated_parts), 5, f"Unexpected updated log format: {updated_entry}"
+        )
+        updated_mtime = int(updated_parts[2])
+
+        # Verify that the mtime was updated in the log
+        self.assertGreater(
+            updated_mtime,
+            original_mtime,
+            f"mtime in build/.ninja_log should have been updated. "
+            f"Original: {original_mtime}, Updated: {updated_mtime}",
+        )