Remove old, same-named files from a build directory if the file in the source directory does not exist. (Patrick Mezard)

3 files changed, 50 insertions, 3 deletions

diff --git a/src/CHANGES.txt b/src/CHANGES.txt
index 0d1cf5f..902b915 100644
--- a/src/CHANGES.txt
+++ b/src/CHANGES.txt
@@ -396,6 +396,10 @@ RELEASE 0.97 - XXX
   - Fix the -n option when used with -c to print all of the targets
     that will be removed for a multi-target Builder call.
 
+  - If there's no file in the source directory, make sure there isn't
+    one in the build directory, too, to avoid dangling files left
+    over from previous runs when a source file is removed.
+
   From Georg Mischler:
 
   - Remove the space after the -o option when invoking the Borland
diff --git a/src/engine/SCons/Node/FS.py b/src/engine/SCons/Node/FS.py
index ffdc1eb..ceec696 100644
--- a/src/engine/SCons/Node/FS.py
+++ b/src/engine/SCons/Node/FS.py
@@ -1866,12 +1866,24 @@ class File(Base):
         "__cacheable__"
         # Duplicate from source path if we are set up to do this.
         if self.duplicate and not self.is_derived() and not self.linked:
-            src=self.srcnode()
+            src = self.srcnode()
             if src is self:
                 return Base.exists(self)
+            # At this point, src is meant to be copied in a build directory.
             src = src.rfile()
-            if src.abspath != self.abspath and src.exists():
-                self.do_duplicate(src)
+            if src.abspath != self.abspath:
+                if src.exists():
+                    self.do_duplicate(src)
+                    # Can't return 1 here because the duplication might
+                    # not actually occur if the -n option is being used.
+                else:
+                    # The source file does not exist.  Make sure no old
+                    # copy remains in the build directory.
+                    if Base.exists(self) or self.islink():
+                        self.fs.unlink(self.path)
+                    # Return None explicitly because the Base.exists() call
+                    # above will have cached its value if the file existed.
+                    return None
         return Base.exists(self)
 
     #
diff --git a/src/engine/SCons/Node/FSTests.py b/src/engine/SCons/Node/FSTests.py
index 60b0197..71fb3ef 100644
--- a/src/engine/SCons/Node/FSTests.py
+++ b/src/engine/SCons/Node/FSTests.py
@@ -1836,6 +1836,37 @@ class FileTestCase(_tempdirTestCase):
         dirs = fff.Dirs(['d1', 'd2'])
         assert dirs == [d1, d2], map(str, dirs)
 
+    def test_exists(self):
+        """Test the File.exists() method"""
+        fs = self.fs
+        test = self.test
+
+        src_f1 = fs.File('src/f1')
+        assert not src_f1.exists(), "%s apparently exists?" % src_f1
+
+        test.subdir('src')
+        test.write(['src', 'f1'], "src/f1\n")
+
+        assert not src_f1.exists(), "%s did not cache previous exists() value" % src_f1
+        src_f1.clear()
+        assert src_f1.exists(), "%s apparently does not exist?" % src_f1
+
+        test.subdir('build')
+        fs.BuildDir('build', 'src')
+        build_f1 = fs.File('build/f1')
+
+        assert build_f1.exists(), "%s did not realize that %s exists" % (build_f1, src_f1)
+        assert os.path.exists(build_f1.abspath), "%s did not get duplicated on disk" % build_f1.abspath
+
+        test.unlink(['src', 'f1'])
+        src_f1.clear()  # so the next exists() call will look on disk again
+
+        assert build_f1.exists(), "%s did not cache previous exists() value" % build_f1
+        build_f1.clear()
+        build_f1.linked = None
+        assert not build_f1.exists(), "%s did not realize that %s disappeared" % (build_f1, src_f1)
+        assert not os.path.exists(build_f1.abspath), "%s did not get removed after %s was removed" % (build_f1, src_f1)
+
 
 
 class RepositoryTestCase(_tempdirTestCase):