Make all DiffResults disposable, move ownership of diff handle

This will let us perform lazy loading of details in these classes,
just as we do with commits and some other classes.

Author: niik

LibGit2Sharp/Diff.cs

@@ -241,10 +241,17 @@ public virtual T Compare<T>(Tree oldTree, Tree newTree, IEnumerable<string> path
                 }
             }
 
-            using (DiffSafeHandle diff = BuildDiffList(oldTreeId, newTreeId, comparer, diffOptions, paths, explicitPathsOptions, compareOptions))
+            DiffSafeHandle diff = BuildDiffList(oldTreeId, newTreeId, comparer, diffOptions, paths, explicitPathsOptions, compareOptions);
+
+            try
             {
                 return BuildDiffResult<T>(diff);
             }
+            catch
+            {
+                diff.SafeDispose();
+                throw;
+            }
         }
 
         /// <summary>

LibGit2Sharp/IDiffResult.cs

@@ -1,8 +1,10 @@
-namespace LibGit2Sharp
+using System;
+
+namespace LibGit2Sharp
 {
     /// <summary>
     ///   Marker interface to identify Diff results.
     /// </summary>
-    public interface IDiffResult
+    public interface IDiffResult: IDisposable
     { }
 }

LibGit2Sharp/Patch.cs

@@ -32,14 +32,17 @@ protected Patch()
 
         internal Patch(DiffSafeHandle diff)
         {
-            int count = Proxy.git_diff_num_deltas(diff);
-            for (int i = 0; i < count; i++)
+            using (diff)
             {
-                using (var patch = Proxy.git_patch_from_diff(diff, i))
+                int count = Proxy.git_diff_num_deltas(diff);
+                for (int i = 0; i < count; i++)
                 {
-                    var delta = Proxy.git_diff_get_delta(diff, i);
-                    AddFileChange(delta);
-                    Proxy.git_patch_print(patch, PrintCallBack);
+                    using (var patch = Proxy.git_patch_from_diff(diff, i))
+                    {
+                        var delta = Proxy.git_diff_get_delta(diff, i);
+                        AddFileChange(delta);
+                        Proxy.git_patch_print(patch, PrintCallBack);
+                    }
                 }
             }
         }
@@ -180,5 +183,17 @@ private string DebuggerDisplay
                                      linesDeleted);
             }
         }
+
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            // This doesn't do anything yet because it loads everything
+            // eagerly and disposes of the diff handle in the constructor.
+        }
     }
 }

LibGit2Sharp/PatchStats.cs

@@ -15,6 +15,8 @@ namespace LibGit2Sharp
     [DebuggerDisplay("{DebuggerDisplay,nq}")]
     public class PatchStats : IEnumerable<ContentChangeStats>, IDiffResult
     {
+        private readonly DiffSafeHandle diff;
+
         private readonly IDictionary<FilePath, ContentChangeStats> changes = new Dictionary<FilePath, ContentChangeStats>();
         private readonly int totalLinesAdded;
         private readonly int totalLinesDeleted;
@@ -27,23 +29,25 @@ protected PatchStats()
 
         internal PatchStats(DiffSafeHandle diff)
         {
-            int count = Proxy.git_diff_num_deltas(diff);
-            for (int i = 0; i < count; i++)
+            using (diff)
             {
-                using (var patch = Proxy.git_patch_from_diff(diff, i))
+                int count = Proxy.git_diff_num_deltas(diff);
+                for (int i = 0; i < count; i++)
                 {
-                    var delta = Proxy.git_diff_get_delta(diff, i);
-                    var pathPtr = delta.NewFile.Path != IntPtr.Zero ? delta.NewFile.Path : delta.OldFile.Path;
-                    var newFilePath = LaxFilePathMarshaler.FromNative(pathPtr);
-
-                    var stats = Proxy.git_patch_line_stats(patch);
-                    int added = stats.Item1;
-                    int deleted = stats.Item2;
-                    changes.Add(newFilePath, new ContentChangeStats(added, deleted));
-                    totalLinesAdded += added;
-                    totalLinesDeleted += deleted;
-                }
+                    using (var patch = Proxy.git_patch_from_diff(diff, i))
+                    {
+                        var delta = Proxy.git_diff_get_delta(diff, i);
+                        var pathPtr = delta.NewFile.Path != IntPtr.Zero ? delta.NewFile.Path : delta.OldFile.Path;
+                        var newFilePath = LaxFilePathMarshaler.FromNative(pathPtr);
 
+                        var stats = Proxy.git_patch_line_stats(patch);
+                        int added = stats.Item1;
+                        int deleted = stats.Item2;
+                        changes.Add(newFilePath, new ContentChangeStats(added, deleted));
+                        totalLinesAdded += added;
+                        totalLinesDeleted += deleted;
+                    }
+                }
             }
         }
 
@@ -117,5 +121,17 @@ private string DebuggerDisplay
                                      TotalLinesDeleted);
             }
         }
+
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            // This doesn't do anything yet because it loads everything
+            // eagerly and disposes of the diff handle in the constructor.
+        }
     }
 }

LibGit2Sharp/TreeChanges.cs

@@ -52,7 +52,8 @@ protected TreeChanges()
 
         internal TreeChanges(DiffSafeHandle diff)
         {
-            Proxy.git_diff_foreach(diff, FileCallback, null, null);
+            using(diff)
+                Proxy.git_diff_foreach(diff, FileCallback, null, null);
         }
 
         private int FileCallback(GitDiffDelta delta, float progress, IntPtr payload)
@@ -169,5 +170,17 @@ private string DebuggerDisplay
                                      Copied.Count());
             }
         }
+
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            // This doesn't do anything yet because it loads everything
+            // eagerly and disposes of the diff handle in the constructor.
+        }
     }
 }