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 (DiffHandle diff = BuildDiffList(oldTreeId, newTreeId, comparer, diffOptions, paths, explicitPathsOptions, compareOptions))
+            DiffHandle diff = BuildDiffList(oldTreeId, newTreeId, comparer, diffOptions, paths, explicitPathsOptions, compareOptions);
+
+            try
             {
                 return BuildDiffResult<T>(diff);
             }
+            catch
+            {
+                diff.SafeDispose();
+                throw;
+            }
         }
 
         /// <summary>
@@ -343,10 +350,17 @@ public virtual T Compare<T>(Tree oldTree, DiffTargets diffTargets, IEnumerable<s
                 }
             }
 
-            using (DiffHandle diff = BuildDiffList(oldTreeId, null, comparer, diffOptions, paths, explicitPathsOptions, compareOptions))
+            DiffHandle diff = BuildDiffList(oldTreeId, null, comparer, diffOptions, paths, explicitPathsOptions, compareOptions);
+            
+            try
             {
                 return BuildDiffResult<T>(diff);
             }
+            catch
+            {
+                diff.SafeDispose();
+                throw;
+            }
         }
 
         /// <summary>
@@ -462,10 +476,17 @@ internal virtual T Compare<T>(
                 }
             }
 
-            using (DiffHandle diff = BuildDiffList(null, null, comparer, diffOptions, paths, explicitPathsOptions, compareOptions))
+            DiffHandle diff = BuildDiffList(null, null, comparer, diffOptions, paths, explicitPathsOptions, compareOptions);
+
+            try
             {
                 return BuildDiffResult<T>(diff);
             }
+            catch
+            {
+                diff.SafeDispose();
+                throw;
+            }
         }
 
         internal delegate DiffHandle TreeComparisonHandleRetriever(ObjectId oldTreeId, ObjectId newTreeId, GitDiffOptions options);

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 unsafe Patch(DiffHandle 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,24 @@ private string DebuggerDisplay
                                      linesDeleted);
             }
         }
+
+        /// <summary>
+        /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
+        /// </summary>
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        /// <summary>
+        /// Releases unmanaged and - optionally - managed resources.
+        /// </summary>
+        /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
+        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

@@ -27,23 +27,25 @@ protected PatchStats()
 
         internal unsafe PatchStats(DiffHandle 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->new_file.Path != null ? delta->new_file.Path : delta->old_file.Path;
-                    var newFilePath = LaxFilePathMarshaler.FromNative(pathPtr);
+                    using (var patch = Proxy.git_patch_from_diff(diff, i))
+                    {
+                        var delta = Proxy.git_diff_get_delta(diff, i);
+                        var pathPtr = delta->new_file.Path != null ? delta->new_file.Path : delta->old_file.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;
+                        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 +119,24 @@ private string DebuggerDisplay
                                      TotalLinesDeleted);
             }
         }
+
+        /// <summary>
+        /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
+        /// </summary>
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        /// <summary>
+        /// Releases unmanaged and - optionally - managed resources.
+        /// </summary>
+        /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
+        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 unsafe TreeChanges(DiffHandle diff)
         {
-            Proxy.git_diff_foreach(diff, FileCallback, null, null);
+            using(diff)
+                Proxy.git_diff_foreach(diff, FileCallback, null, null);
         }
 
         private unsafe int FileCallback(git_diff_delta* delta, float progress, IntPtr payload)
@@ -169,5 +170,24 @@ private string DebuggerDisplay
                                      Copied.Count());
             }
         }
+
+        /// <summary>
+        /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
+        /// </summary>
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        /// <summary>
+        /// Releases unmanaged and - optionally - managed resources.
+        /// </summary>
+        /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
+        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.
+        }
     }
 }