[libcxx] Cleanup the cleanup of temporary files.

[EricWF]

Summary

The pythonic way to guard resources is using a with statement. This patch adds a class that allows the creation and deletion of temporary files using a with statement.

[mclow.lists]

This looks reasonable to me.

test/lit.cfg

135

Can self._evaluate_test throw?

If so, you'll skip the call to _clean.
On the other hand, _clean appears to be empty now.

[EricWF]

test/lit.cfg

135

I would like @danalbert to comment on this. I think he uses _clean() in the android configuration.

[danalbert]

test/lit.cfg

135

_clean() should be thought of as a virtual method. It needs to be overridden for remote execution because the steps taken to clean up remote workspaces will vary.

[danalbert]

test/lit.cfg

23

Doesn't contextlib cover this?

[EricWF]

This is no longer relevant.

test/lit.cfg

 import lit.formats
 import lit.util
 
+class GuardedTempFilename(object):
+    """
+    GuardedTempFilename - A utility class that allows temporary files to be used
+    in a python 'with' statement.
+    ex.
+        with GuardedTempFilename(suffix='.exe') as temp_file_name:
+            pass
+    """
+    def __init__(self, suffix='', prefix='tmp', dir=None):
+        # Store the options for later. Don't create the tempfile outside of a
+        # with statement.
+        self.suffix = suffix
+        self.prefix = prefix
+        self.dir = dir
+        self.name = None
+
+    def __enter__(self):
+        try:
+            tmp_file = tempfile.NamedTemporaryFile(suffix=self.suffix, prefix=self.prefix, dir=self.dir, delete=False)
+            self.name = tmp_file.name
+            tmp_file.close()
+            return self.name
+        except:
+            self.delete()
+            raise
+
+    def __exit__(self, type, value, traceback):
+        self.delete()
+        return False
+
+    def delete(self):
+        if self.name is not None:
+            try:
+                os.remove(self.name)
+            except:
+                pass
+            self.name = None
+
+    def __repr__(self):
+        return self.name
+
 class LibcxxTestFormat(lit.formats.FileBasedTest):
     """
     Custom test format handler for use with the test format use by libc++.

                        ', '.join(unsupported_features),))
 
         # Evaluate the test.
-        return self._evaluate_test(test, use_verify, lit_config)
+        res = self._evaluate_test(test, use_verify, lit_config)
+        self._clean()
+        return res
 
     def _make_report(self, cmd, out, err, rc):
         report = "Command: %s\n" % cmd

         return cmd, out, err, rc
 
     def _compile_and_link(self, exec_path, source_path):
-        object_file = tempfile.NamedTemporaryFile(suffix=".o", delete=False)
-        object_path = object_file.name
-        object_file.close()
-        try:
+        with GuardedTempFilename(suffix='.o') as object_path:
             cmd, out, err, rc = self._compile(object_path, source_path)
             if rc != 0:
                 return cmd, out, err, rc
             return self._link(exec_path, object_path)
-        finally:
-            try:
-                os.remove(object_path)
-            except:
-                pass
 
     def _build(self, exec_path, source_path, compile_only=False,
                use_verify=False):

             cmd, out, err, rc = self._compile_and_link(exec_path, source_path)
         return self._make_report(cmd, out, err, rc)
 
-    def _clean(self, exec_path):
-        os.remove(exec_path)
+    def _clean(self):
+        pass
 
     def _run(self, exec_path, lit_config, in_dir=None):
         cmd = []

             else:
                 return lit.Test.FAIL, report + 'Expected compilation to fail!\n'
         else:
-            exec_file = tempfile.NamedTemporaryFile(suffix="exe", delete=False)
-            exec_path = exec_file.name
-            exec_file.close()
-
-            try:
+            with GuardedTempFilename(suffix='.exe') as exec_path:
                 cmd, report, rc = self._build(exec_path, source_path)
                 compile_cmd = cmd
                 if rc != 0:

                     report = "Compiled With: %s\n%s" % (compile_cmd, report)
                     report += "Compiled test failed unexpectedly!"
                     return lit.Test.FAIL, report
-            finally:
-                try:
-                    # Note that cleanup of exec_file happens in `_clean()`. If
-                    # you override this, cleanup is your reponsibility.
-                    self._clean(exec_path)
-                except:
-                    pass
         return lit.Test.PASS, ""