Remove AsIntPtr

bording · bording · commit 123dc913db42 · 2024-11-22T23:05:45.000-05:00
diff --git a/LibGit2Sharp/Core/Handles/Libgit2Object.cs b/LibGit2Sharp/Core/Handles/Libgit2Object.cs
@@ -110,8 +110,6 @@ internal unsafe Libgit2Object(IntPtr ptr, bool owned)
 
         public override bool IsInvalid => handle == IntPtr.Zero;
 
-        internal IntPtr AsIntPtr() => DangerousGetHandle();
-
         protected override void Dispose(bool disposing)
         {
 #if LEAKS_IDENTIFYING
diff --git a/LibGit2Sharp/Core/Handles/Objects.cs b/LibGit2Sharp/Core/Handles/Objects.cs
@@ -25,7 +25,7 @@ protected override bool ReleaseHandle()
 
         public static implicit operator git_tree_entry*(TreeEntryHandle handle)
         {
-            return (git_tree_entry*)handle.AsIntPtr();
+            return (git_tree_entry*)handle.DangerousGetHandle();
         }
     }
 
@@ -50,7 +50,7 @@ protected override bool ReleaseHandle()
 
         public static implicit operator git_reference*(ReferenceHandle handle)
         {
-            return (git_reference*)handle.AsIntPtr();
+            return (git_reference*)handle.DangerousGetHandle();
         }
     }
 
@@ -75,7 +75,7 @@ protected override bool ReleaseHandle()
 
         public static implicit operator git_repository*(RepositoryHandle handle)
         {
-            return (git_repository*)handle.AsIntPtr();
+            return (git_repository*)handle.DangerousGetHandle();
         }
     }
 
@@ -100,7 +100,7 @@ protected override bool ReleaseHandle()
 
         public static implicit operator git_signature*(SignatureHandle handle)
         {
-            return (git_signature*)handle.AsIntPtr();
+            return (git_signature*)handle.DangerousGetHandle();
         }
     }
 
@@ -125,7 +125,7 @@ protected override bool ReleaseHandle()
 
         public static implicit operator git_status_list*(StatusListHandle handle)
         {
-            return (git_status_list*)handle.AsIntPtr();
+            return (git_status_list*)handle.DangerousGetHandle();
         }
     }
 
@@ -150,7 +150,7 @@ protected override bool ReleaseHandle()
 
         public static implicit operator git_blame*(BlameHandle handle)
         {
-            return (git_blame*)handle.AsIntPtr();
+            return (git_blame*)handle.DangerousGetHandle();
         }
     }
 
@@ -175,7 +175,7 @@ protected override bool ReleaseHandle()
 
         public static implicit operator git_diff*(DiffHandle handle)
         {
-            return (git_diff*)handle.AsIntPtr();
+            return (git_diff*)handle.DangerousGetHandle();
         }
     }
 
@@ -200,7 +200,7 @@ protected override bool ReleaseHandle()
 
         public static implicit operator git_patch*(PatchHandle handle)
         {
-            return (git_patch*)handle.AsIntPtr();
+            return (git_patch*)handle.DangerousGetHandle();
         }
     }
 
@@ -225,7 +225,7 @@ protected override bool ReleaseHandle()
 
         public static implicit operator git_config*(ConfigurationHandle handle)
         {
-            return (git_config*)handle.AsIntPtr();
+            return (git_config*)handle.DangerousGetHandle();
         }
     }
 
@@ -250,7 +250,7 @@ protected override bool ReleaseHandle()
 
         public static implicit operator git_index_conflict_iterator*(ConflictIteratorHandle handle)
         {
-            return (git_index_conflict_iterator*)handle.AsIntPtr();
+            return (git_index_conflict_iterator*)handle.DangerousGetHandle();
         }
     }
 
@@ -275,7 +275,7 @@ protected override bool ReleaseHandle()
 
         public static implicit operator git_index*(IndexHandle handle)
         {
-            return (git_index*)handle.AsIntPtr();
+            return (git_index*)handle.DangerousGetHandle();
         }
     }
 
@@ -300,7 +300,7 @@ protected override bool ReleaseHandle()
 
         public static implicit operator git_reflog*(ReflogHandle handle)
         {
-            return (git_reflog*)handle.AsIntPtr();
+            return (git_reflog*)handle.DangerousGetHandle();
         }
     }
 
@@ -325,7 +325,7 @@ protected override bool ReleaseHandle()
 
         public static implicit operator git_treebuilder*(TreeBuilderHandle handle)
         {
-            return (git_treebuilder*)handle.AsIntPtr();
+            return (git_treebuilder*)handle.DangerousGetHandle();
         }
     }
 
@@ -350,7 +350,7 @@ protected override bool ReleaseHandle()
 
         public static implicit operator git_packbuilder*(PackBuilderHandle handle)
         {
-            return (git_packbuilder*)handle.AsIntPtr();
+            return (git_packbuilder*)handle.DangerousGetHandle();
         }
     }
 
@@ -375,7 +375,7 @@ protected override bool ReleaseHandle()
 
         public static implicit operator git_note*(NoteHandle handle)
         {
-            return (git_note*)handle.AsIntPtr();
+            return (git_note*)handle.DangerousGetHandle();
         }
     }
 
@@ -400,7 +400,7 @@ protected override bool ReleaseHandle()
 
         public static implicit operator git_describe_result*(DescribeResultHandle handle)
         {
-            return (git_describe_result*)handle.AsIntPtr();
+            return (git_describe_result*)handle.DangerousGetHandle();
         }
     }
 
@@ -425,7 +425,7 @@ protected override bool ReleaseHandle()
 
         public static implicit operator git_submodule*(SubmoduleHandle handle)
         {
-            return (git_submodule*)handle.AsIntPtr();
+            return (git_submodule*)handle.DangerousGetHandle();
         }
     }
 
@@ -450,7 +450,7 @@ protected override bool ReleaseHandle()
 
         public static implicit operator git_annotated_commit*(AnnotatedCommitHandle handle)
         {
-            return (git_annotated_commit*)handle.AsIntPtr();
+            return (git_annotated_commit*)handle.DangerousGetHandle();
         }
     }
 
@@ -475,7 +475,7 @@ protected override bool ReleaseHandle()
 
         public static implicit operator git_odb*(ObjectDatabaseHandle handle)
         {
-            return (git_odb*)handle.AsIntPtr();
+            return (git_odb*)handle.DangerousGetHandle();
         }
     }
 
@@ -500,7 +500,7 @@ protected override bool ReleaseHandle()
 
         public static implicit operator git_revwalk*(RevWalkerHandle handle)
         {
-            return (git_revwalk*)handle.AsIntPtr();
+            return (git_revwalk*)handle.DangerousGetHandle();
         }
     }
 
@@ -525,7 +525,7 @@ protected override bool ReleaseHandle()
 
         public static implicit operator git_remote*(RemoteHandle handle)
         {
-            return (git_remote*)handle.AsIntPtr();
+            return (git_remote*)handle.DangerousGetHandle();
         }
     }
 
@@ -550,7 +550,7 @@ protected override bool ReleaseHandle()
 
         public static implicit operator git_object*(ObjectHandle handle)
         {
-            return (git_object*)handle.AsIntPtr();
+            return (git_object*)handle.DangerousGetHandle();
         }
     }
 
@@ -575,7 +575,7 @@ protected override bool ReleaseHandle()
 
         public static implicit operator git_rebase*(RebaseHandle handle)
         {
-            return (git_rebase*)handle.AsIntPtr();
+            return (git_rebase*)handle.DangerousGetHandle();
         }
     }
 
@@ -600,7 +600,7 @@ protected override bool ReleaseHandle()
 
         public static implicit operator git_odb_stream*(OdbStreamHandle handle)
         {
-            return (git_odb_stream*)handle.AsIntPtr();
+            return (git_odb_stream*)handle.DangerousGetHandle();
         }
     }
 
@@ -625,7 +625,7 @@ protected override bool ReleaseHandle()
 
         public static implicit operator git_worktree*(WorktreeHandle handle)
         {
-            return (git_worktree*)handle.AsIntPtr();
+            return (git_worktree*)handle.DangerousGetHandle();
         }
     }
 
diff --git a/LibGit2Sharp/Core/Handles/Objects.tt b/LibGit2Sharp/Core/Handles/Objects.tt
@@ -91,7 +91,7 @@ for (var i = 0; i < cNames.Length; i++)
 
         public static implicit operator <#= cNames[i] #>*(<#= csNames[i] #> handle)
         {
-            return (<#= cNames[i] #>*)handle.AsIntPtr();
+            return (<#= cNames[i] #>*)handle.DangerousGetHandle();
         }
     }
 
diff --git a/LibGit2Sharp/Core/NativeMethods.cs b/LibGit2Sharp/Core/NativeMethods.cs
@@ -254,7 +254,7 @@ internal static extern void git_branch_iterator_free(
         [DllImport(libgit2, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int git_branch_iterator_new(
             out IntPtr iter_out,
-            IntPtr repo,
+            RepositoryHandle repo,
             GitBranchType branch_type);
 
         [DllImport(libgit2, CallingConvention = CallingConvention.Cdecl)]
@@ -560,7 +560,7 @@ internal static extern unsafe int git_config_foreach(
         [DllImport(libgit2, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int git_config_iterator_glob_new(
             out IntPtr iter,
-            IntPtr cfg,
+            ConfigurationHandle cfg,
             [MarshalAs(UnmanagedType.CustomMarshaler, MarshalCookie = UniqueId.UniqueIdentifier, MarshalTypeRef = typeof(StrictUtf8Marshaler))] string regexp);
 
         [DllImport(libgit2, CallingConvention = CallingConvention.Cdecl)]
@@ -1236,7 +1236,7 @@ internal static extern unsafe int git_reference_lookup(
 
         [DllImport(libgit2, CallingConvention = CallingConvention.Cdecl)]
         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalCookie = UniqueId.UniqueIdentifier, MarshalTypeRef = typeof(LaxUtf8NoCleanupMarshaler))]
-        internal static extern unsafe string git_reference_name(git_reference* reference);
+        internal static extern unsafe string git_reference_name(ReferenceHandle reference);
 
         [DllImport(libgit2, CallingConvention = CallingConvention.Cdecl)]
         internal static extern unsafe int git_reference_remove(
@@ -1273,7 +1273,7 @@ internal static extern unsafe int git_reference_symbolic_set_target(
         internal static extern unsafe string git_reference_symbolic_target(git_reference* reference);
 
         [DllImport(libgit2, CallingConvention = CallingConvention.Cdecl)]
-        internal static extern unsafe GitReferenceType git_reference_type(git_reference* reference);
+        internal static extern unsafe GitReferenceType git_reference_type(ReferenceHandle reference);
 
         [DllImport(libgit2, CallingConvention = CallingConvention.Cdecl)]
         internal static extern unsafe int git_reference_ensure_log(
@@ -1533,10 +1533,10 @@ internal static extern unsafe int git_repository_fetchhead_foreach(
         internal static extern unsafe void git_repository_free(git_repository* repo);
 
         [DllImport(libgit2, CallingConvention = CallingConvention.Cdecl)]
-        internal static extern int git_repository_head_detached(IntPtr repo);
+        internal static extern int git_repository_head_detached(RepositoryHandle repo);
 
         [DllImport(libgit2, CallingConvention = CallingConvention.Cdecl)]
-        internal static extern int git_repository_head_unborn(IntPtr repo);
+        internal static extern int git_repository_head_unborn(RepositoryHandle repo);
 
         [DllImport(libgit2, CallingConvention = CallingConvention.Cdecl)]
         internal static extern unsafe int git_repository_ident(
@@ -1554,10 +1554,10 @@ internal static extern unsafe int git_repository_init_ext(
             GitRepositoryInitOptions options);
 
         [DllImport(libgit2, CallingConvention = CallingConvention.Cdecl)]
-        internal static extern int git_repository_is_bare(IntPtr handle);
+        internal static extern int git_repository_is_bare(RepositoryHandle handle);
 
         [DllImport(libgit2, CallingConvention = CallingConvention.Cdecl)]
-        internal static extern int git_repository_is_shallow(IntPtr repo);
+        internal static extern int git_repository_is_shallow(RepositoryHandle repo);
 
         [DllImport(libgit2, CallingConvention = CallingConvention.Cdecl)]
         internal static extern unsafe int git_repository_state_cleanup(git_repository* repo);
diff --git a/LibGit2Sharp/Core/Proxy.cs b/LibGit2Sharp/Core/Proxy.cs
@@ -131,7 +131,7 @@ public static unsafe void git_branch_delete(ReferenceHandle reference)
         public static IEnumerable<Branch> git_branch_iterator(Repository repo, GitBranchType branchType)
         {
             IntPtr iter;
-            var res = NativeMethods.git_branch_iterator_new(out iter, repo.Handle.AsIntPtr(), branchType);
+            var res = NativeMethods.git_branch_iterator_new(out iter, repo.Handle, branchType);
             Ensure.ZeroResult(res);
 
             try
@@ -345,7 +345,7 @@ public static unsafe string git_commit_create_buffer(
                 try
                 {
                     handles = parents.Select(c => Proxy.git_object_lookup(c.repo.Handle, c.Id, GitObjectType.Commit)).ToArray();
-                    var ptrs = handles.Select(p => p.AsIntPtr()).ToArray();
+                    var ptrs = handles.Select(p => p.DangerousGetHandle()).ToArray();
                     int res;
                     fixed (IntPtr* objs = ptrs)
                     {
@@ -624,7 +624,7 @@ public static IEnumerable<ConfigurationEntry<string>> git_config_iterator_glob(
             string regexp)
         {
             IntPtr iter;
-            var res = NativeMethods.git_config_iterator_glob_new(out iter, config.AsIntPtr(), regexp);
+            var res = NativeMethods.git_config_iterator_glob_new(out iter, config, regexp);
             Ensure.ZeroResult(res);
             try
             {
@@ -1302,7 +1302,7 @@ public static unsafe ObjectId git_annotated_commit_id(AnnotatedCommitHandle merg
 
         public static unsafe void git_merge(RepositoryHandle repo, AnnotatedCommitHandle[] heads, GitMergeOpts mergeOptions, GitCheckoutOpts checkoutOptions, out bool earlyStop)
         {
-            IntPtr[] their_heads = heads.Select(head => head.AsIntPtr()).ToArray();
+            IntPtr[] their_heads = heads.Select(head => head.DangerousGetHandle()).ToArray();
 
             int res = NativeMethods.git_merge(repo,
                                               their_heads,
@@ -1327,7 +1327,7 @@ public static unsafe void git_merge_analysis(
             out GitMergeAnalysis analysis_out,
             out GitMergePreference preference_out)
         {
-            IntPtr[] their_heads = heads.Select(head => head.AsIntPtr()).ToArray();
+            IntPtr[] their_heads = heads.Select(head => head.DangerousGetHandle()).ToArray();
 
             int res = NativeMethods.git_merge_analysis(out analysis_out,
                                                        out preference_out,
@@ -1955,7 +1955,7 @@ public static unsafe ReferenceHandle git_reference_lookup(RepositoryHandle repo,
             return new ReferenceHandle(handle, true);
         }
 
-        public static unsafe string git_reference_name(git_reference* reference)
+        public static unsafe string git_reference_name(ReferenceHandle reference)
         {
             return NativeMethods.git_reference_name(reference);
         }
@@ -2011,7 +2011,7 @@ public static unsafe string git_reference_symbolic_target(git_reference* referen
             return NativeMethods.git_reference_symbolic_target(reference);
         }
 
-        public static unsafe GitReferenceType git_reference_type(git_reference* reference)
+        public static unsafe GitReferenceType git_reference_type(ReferenceHandle reference)
         {
             return NativeMethods.git_reference_type(reference);
         }
@@ -3779,9 +3779,9 @@ private static ICollection<TResult> git_foreach<T1, T2, T3, T4, TResult>(
             return result;
         }
 
-        private static unsafe bool RepositoryStateChecker(RepositoryHandle repo, Func<IntPtr, int> checker)
+        private static unsafe bool RepositoryStateChecker(RepositoryHandle repo, Func<RepositoryHandle, int> checker)
         {
-            int res = checker(repo.AsIntPtr());
+            int res = checker(repo);
             Ensure.BooleanResult(res);
 
             return (res == 1);
diff --git a/LibGit2Sharp/Reference.cs b/LibGit2Sharp/Reference.cs
@@ -32,13 +32,7 @@ private protected Reference(IRepository repo, string canonicalName, string targe
             this.targetIdentifier = targetIdentifier;
         }
 
-        // This overload lets public-facing methods avoid having to use the pointers directly
         internal static unsafe T BuildFromPtr<T>(ReferenceHandle handle, Repository repo) where T : Reference
-        {
-            return BuildFromPtr<T>((git_reference*)handle.AsIntPtr(), repo);
-        }
-
-        internal static unsafe T BuildFromPtr<T>(git_reference* handle, Repository repo) where T : Reference
         {
             GitReferenceType type = Proxy.git_reference_type(handle);
             string name = Proxy.git_reference_name(handle);

Original file line number	Diff line number	Diff line change
`@@ -110,8 +110,6 @@ internal unsafe Libgit2Object(IntPtr ptr, bool owned)`
`110`	`110`
`111`	`111`	`public override bool IsInvalid => handle == IntPtr.Zero;`
`112`	`112`
`113`		`- internal IntPtr AsIntPtr() => DangerousGetHandle();`
`114`		`-`
`115`	`113`	`protected override void Dispose(bool disposing)`
`116`	`114`	`{`
`117`	`115`	`#if LEAKS_IDENTIFYING`
Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@ protected override bool ReleaseHandle()`
`25`	`25`
`26`	`26`	`public static implicit operator git_tree_entry*(TreeEntryHandle handle)`
`27`	`27`	`{`
`28`		`- return (git_tree_entry*)handle.AsIntPtr();`
	`28`	`+ return (git_tree_entry*)handle.DangerousGetHandle();`
`29`	`29`	`}`
`30`	`30`	`}`
`31`	`31`
`@@ -50,7 +50,7 @@ protected override bool ReleaseHandle()`
`50`	`50`
`51`	`51`	`public static implicit operator git_reference*(ReferenceHandle handle)`
`52`	`52`	`{`
`53`		`- return (git_reference*)handle.AsIntPtr();`
	`53`	`+ return (git_reference*)handle.DangerousGetHandle();`
`54`	`54`	`}`
`55`	`55`	`}`
`56`	`56`
`@@ -75,7 +75,7 @@ protected override bool ReleaseHandle()`
`75`	`75`
`76`	`76`	`public static implicit operator git_repository*(RepositoryHandle handle)`
`77`	`77`	`{`
`78`		`- return (git_repository*)handle.AsIntPtr();`
	`78`	`+ return (git_repository*)handle.DangerousGetHandle();`
`79`	`79`	`}`
`80`	`80`	`}`
`81`	`81`
`@@ -100,7 +100,7 @@ protected override bool ReleaseHandle()`
`100`	`100`
`101`	`101`	`public static implicit operator git_signature*(SignatureHandle handle)`
`102`	`102`	`{`
`103`		`- return (git_signature*)handle.AsIntPtr();`
	`103`	`+ return (git_signature*)handle.DangerousGetHandle();`
`104`	`104`	`}`
`105`	`105`	`}`
`106`	`106`
`@@ -125,7 +125,7 @@ protected override bool ReleaseHandle()`
`125`	`125`
`126`	`126`	`public static implicit operator git_status_list*(StatusListHandle handle)`
`127`	`127`	`{`
`128`		`- return (git_status_list*)handle.AsIntPtr();`
	`128`	`+ return (git_status_list*)handle.DangerousGetHandle();`
`129`	`129`	`}`
`130`	`130`	`}`
`131`	`131`
`@@ -150,7 +150,7 @@ protected override bool ReleaseHandle()`
`150`	`150`
`151`	`151`	`public static implicit operator git_blame*(BlameHandle handle)`
`152`	`152`	`{`
`153`		`- return (git_blame*)handle.AsIntPtr();`
	`153`	`+ return (git_blame*)handle.DangerousGetHandle();`
`154`	`154`	`}`
`155`	`155`	`}`
`156`	`156`
`@@ -175,7 +175,7 @@ protected override bool ReleaseHandle()`
`175`	`175`
`176`	`176`	`public static implicit operator git_diff*(DiffHandle handle)`
`177`	`177`	`{`
`178`		`- return (git_diff*)handle.AsIntPtr();`
	`178`	`+ return (git_diff*)handle.DangerousGetHandle();`
`179`	`179`	`}`
`180`	`180`	`}`
`181`	`181`
`@@ -200,7 +200,7 @@ protected override bool ReleaseHandle()`
`200`	`200`
`201`	`201`	`public static implicit operator git_patch*(PatchHandle handle)`
`202`	`202`	`{`
`203`		`- return (git_patch*)handle.AsIntPtr();`
	`203`	`+ return (git_patch*)handle.DangerousGetHandle();`
`204`	`204`	`}`
`205`	`205`	`}`
`206`	`206`
`@@ -225,7 +225,7 @@ protected override bool ReleaseHandle()`
`225`	`225`
`226`	`226`	`public static implicit operator git_config*(ConfigurationHandle handle)`
`227`	`227`	`{`
`228`		`- return (git_config*)handle.AsIntPtr();`
	`228`	`+ return (git_config*)handle.DangerousGetHandle();`
`229`	`229`	`}`
`230`	`230`	`}`
`231`	`231`
`@@ -250,7 +250,7 @@ protected override bool ReleaseHandle()`
`250`	`250`
`251`	`251`	`public static implicit operator git_index_conflict_iterator*(ConflictIteratorHandle handle)`
`252`	`252`	`{`
`253`		`- return (git_index_conflict_iterator*)handle.AsIntPtr();`
	`253`	`+ return (git_index_conflict_iterator*)handle.DangerousGetHandle();`
`254`	`254`	`}`
`255`	`255`	`}`
`256`	`256`
`@@ -275,7 +275,7 @@ protected override bool ReleaseHandle()`
`275`	`275`
`276`	`276`	`public static implicit operator git_index*(IndexHandle handle)`
`277`	`277`	`{`
`278`		`- return (git_index*)handle.AsIntPtr();`
	`278`	`+ return (git_index*)handle.DangerousGetHandle();`
`279`	`279`	`}`
`280`	`280`	`}`
`281`	`281`
`@@ -300,7 +300,7 @@ protected override bool ReleaseHandle()`
`300`	`300`
`301`	`301`	`public static implicit operator git_reflog*(ReflogHandle handle)`
`302`	`302`	`{`
`303`		`- return (git_reflog*)handle.AsIntPtr();`
	`303`	`+ return (git_reflog*)handle.DangerousGetHandle();`
`304`	`304`	`}`
`305`	`305`	`}`
`306`	`306`
`@@ -325,7 +325,7 @@ protected override bool ReleaseHandle()`
`325`	`325`
`326`	`326`	`public static implicit operator git_treebuilder*(TreeBuilderHandle handle)`
`327`	`327`	`{`
`328`		`- return (git_treebuilder*)handle.AsIntPtr();`
	`328`	`+ return (git_treebuilder*)handle.DangerousGetHandle();`
`329`	`329`	`}`
`330`	`330`	`}`
`331`	`331`
`@@ -350,7 +350,7 @@ protected override bool ReleaseHandle()`
`350`	`350`
`351`	`351`	`public static implicit operator git_packbuilder*(PackBuilderHandle handle)`
`352`	`352`	`{`
`353`		`- return (git_packbuilder*)handle.AsIntPtr();`
	`353`	`+ return (git_packbuilder*)handle.DangerousGetHandle();`
`354`	`354`	`}`
`355`	`355`	`}`
`356`	`356`
`@@ -375,7 +375,7 @@ protected override bool ReleaseHandle()`
`375`	`375`
`376`	`376`	`public static implicit operator git_note*(NoteHandle handle)`
`377`	`377`	`{`
`378`		`- return (git_note*)handle.AsIntPtr();`
	`378`	`+ return (git_note*)handle.DangerousGetHandle();`
`379`	`379`	`}`
`380`	`380`	`}`
`381`	`381`
`@@ -400,7 +400,7 @@ protected override bool ReleaseHandle()`
`400`	`400`
`401`	`401`	`public static implicit operator git_describe_result*(DescribeResultHandle handle)`
`402`	`402`	`{`
`403`		`- return (git_describe_result*)handle.AsIntPtr();`
	`403`	`+ return (git_describe_result*)handle.DangerousGetHandle();`
`404`	`404`	`}`
`405`	`405`	`}`
`406`	`406`
`@@ -425,7 +425,7 @@ protected override bool ReleaseHandle()`
`425`	`425`
`426`	`426`	`public static implicit operator git_submodule*(SubmoduleHandle handle)`
`427`	`427`	`{`
`428`		`- return (git_submodule*)handle.AsIntPtr();`
	`428`	`+ return (git_submodule*)handle.DangerousGetHandle();`
`429`	`429`	`}`
`430`	`430`	`}`
`431`	`431`
`@@ -450,7 +450,7 @@ protected override bool ReleaseHandle()`
`450`	`450`
`451`	`451`	`public static implicit operator git_annotated_commit*(AnnotatedCommitHandle handle)`
`452`	`452`	`{`
`453`		`- return (git_annotated_commit*)handle.AsIntPtr();`
	`453`	`+ return (git_annotated_commit*)handle.DangerousGetHandle();`
`454`	`454`	`}`
`455`	`455`	`}`
`456`	`456`
`@@ -475,7 +475,7 @@ protected override bool ReleaseHandle()`
`475`	`475`
`476`	`476`	`public static implicit operator git_odb*(ObjectDatabaseHandle handle)`
`477`	`477`	`{`
`478`		`- return (git_odb*)handle.AsIntPtr();`
	`478`	`+ return (git_odb*)handle.DangerousGetHandle();`
`479`	`479`	`}`
`480`	`480`	`}`
`481`	`481`
`@@ -500,7 +500,7 @@ protected override bool ReleaseHandle()`
`500`	`500`
`501`	`501`	`public static implicit operator git_revwalk*(RevWalkerHandle handle)`
`502`	`502`	`{`
`503`		`- return (git_revwalk*)handle.AsIntPtr();`
	`503`	`+ return (git_revwalk*)handle.DangerousGetHandle();`
`504`	`504`	`}`
`505`	`505`	`}`
`506`	`506`
`@@ -525,7 +525,7 @@ protected override bool ReleaseHandle()`
`525`	`525`
`526`	`526`	`public static implicit operator git_remote*(RemoteHandle handle)`
`527`	`527`	`{`
`528`		`- return (git_remote*)handle.AsIntPtr();`
	`528`	`+ return (git_remote*)handle.DangerousGetHandle();`
`529`	`529`	`}`
`530`	`530`	`}`
`531`	`531`
`@@ -550,7 +550,7 @@ protected override bool ReleaseHandle()`
`550`	`550`
`551`	`551`	`public static implicit operator git_object*(ObjectHandle handle)`
`552`	`552`	`{`
`553`		`- return (git_object*)handle.AsIntPtr();`
	`553`	`+ return (git_object*)handle.DangerousGetHandle();`
`554`	`554`	`}`
`555`	`555`	`}`
`556`	`556`
`@@ -575,7 +575,7 @@ protected override bool ReleaseHandle()`
`575`	`575`
`576`	`576`	`public static implicit operator git_rebase*(RebaseHandle handle)`
`577`	`577`	`{`
`578`		`- return (git_rebase*)handle.AsIntPtr();`
	`578`	`+ return (git_rebase*)handle.DangerousGetHandle();`
`579`	`579`	`}`
`580`	`580`	`}`
`581`	`581`
`@@ -600,7 +600,7 @@ protected override bool ReleaseHandle()`
`600`	`600`
`601`	`601`	`public static implicit operator git_odb_stream*(OdbStreamHandle handle)`
`602`	`602`	`{`
`603`		`- return (git_odb_stream*)handle.AsIntPtr();`
	`603`	`+ return (git_odb_stream*)handle.DangerousGetHandle();`
`604`	`604`	`}`
`605`	`605`	`}`
`606`	`606`
`@@ -625,7 +625,7 @@ protected override bool ReleaseHandle()`
`625`	`625`
`626`	`626`	`public static implicit operator git_worktree*(WorktreeHandle handle)`
`627`	`627`	`{`
`628`		`- return (git_worktree*)handle.AsIntPtr();`
	`628`	`+ return (git_worktree*)handle.DangerousGetHandle();`
`629`	`629`	`}`
`630`	`630`	`}`
`631`	`631`
Original file line number	Diff line number	Diff line change
`@@ -91,7 +91,7 @@ for (var i = 0; i < cNames.Length; i++)`
`91`	`91`
`92`	`92`	`public static implicit operator <#= cNames[i] #>*(<#= csNames[i] #> handle)`
`93`	`93`	`{`
`94`		`- return (<#= cNames[i] #>*)handle.AsIntPtr();`
	`94`	`+ return (<#= cNames[i] #>*)handle.DangerousGetHandle();`
`95`	`95`	`}`
`96`	`96`	`}`
`97`	`97`
Original file line number	Diff line number	Diff line change
`@@ -131,7 +131,7 @@ public static unsafe void git_branch_delete(ReferenceHandle reference)`
`131`	`131`	`public static IEnumerable<Branch> git_branch_iterator(Repository repo, GitBranchType branchType)`
`132`	`132`	`{`
`133`	`133`	`IntPtr iter;`
`134`		`- var res = NativeMethods.git_branch_iterator_new(out iter, repo.Handle.AsIntPtr(), branchType);`
	`134`	`+ var res = NativeMethods.git_branch_iterator_new(out iter, repo.Handle, branchType);`
`135`	`135`	`Ensure.ZeroResult(res);`
`136`	`136`
`137`	`137`	`try`
`@@ -345,7 +345,7 @@ public static unsafe string git_commit_create_buffer(`
`345`	`345`	`try`
`346`	`346`	`{`
`347`	`347`	`handles = parents.Select(c => Proxy.git_object_lookup(c.repo.Handle, c.Id, GitObjectType.Commit)).ToArray();`
`348`		`- var ptrs = handles.Select(p => p.AsIntPtr()).ToArray();`
	`348`	`+ var ptrs = handles.Select(p => p.DangerousGetHandle()).ToArray();`
`349`	`349`	`int res;`
`350`	`350`	`fixed (IntPtr* objs = ptrs)`
`351`	`351`	`{`
`@@ -624,7 +624,7 @@ public static IEnumerable<ConfigurationEntry<string>> git_config_iterator_glob(`
`624`	`624`	`string regexp)`
`625`	`625`	`{`
`626`	`626`	`IntPtr iter;`
`627`		`- var res = NativeMethods.git_config_iterator_glob_new(out iter, config.AsIntPtr(), regexp);`
	`627`	`+ var res = NativeMethods.git_config_iterator_glob_new(out iter, config, regexp);`
`628`	`628`	`Ensure.ZeroResult(res);`
`629`	`629`	`try`
`630`	`630`	`{`
`@@ -1302,7 +1302,7 @@ public static unsafe ObjectId git_annotated_commit_id(AnnotatedCommitHandle merg`
`1302`	`1302`
`1303`	`1303`	`public static unsafe void git_merge(RepositoryHandle repo, AnnotatedCommitHandle[] heads, GitMergeOpts mergeOptions, GitCheckoutOpts checkoutOptions, out bool earlyStop)`
`1304`	`1304`	`{`
`1305`		`- IntPtr[] their_heads = heads.Select(head => head.AsIntPtr()).ToArray();`
	`1305`	`+ IntPtr[] their_heads = heads.Select(head => head.DangerousGetHandle()).ToArray();`
`1306`	`1306`
`1307`	`1307`	`int res = NativeMethods.git_merge(repo,`
`1308`	`1308`	`their_heads,`
`@@ -1327,7 +1327,7 @@ public static unsafe void git_merge_analysis(`
`1327`	`1327`	`out GitMergeAnalysis analysis_out,`
`1328`	`1328`	`out GitMergePreference preference_out)`
`1329`	`1329`	`{`
`1330`		`- IntPtr[] their_heads = heads.Select(head => head.AsIntPtr()).ToArray();`
	`1330`	`+ IntPtr[] their_heads = heads.Select(head => head.DangerousGetHandle()).ToArray();`
`1331`	`1331`
`1332`	`1332`	`int res = NativeMethods.git_merge_analysis(out analysis_out,`
`1333`	`1333`	`out preference_out,`
`@@ -1955,7 +1955,7 @@ public static unsafe ReferenceHandle git_reference_lookup(RepositoryHandle repo,`
`1955`	`1955`	`return new ReferenceHandle(handle, true);`
`1956`	`1956`	`}`
`1957`	`1957`
`1958`		`- public static unsafe string git_reference_name(git_reference* reference)`
	`1958`	`+ public static unsafe string git_reference_name(ReferenceHandle reference)`
`1959`	`1959`	`{`
`1960`	`1960`	`return NativeMethods.git_reference_name(reference);`
`1961`	`1961`	`}`
`@@ -2011,7 +2011,7 @@ public static unsafe string git_reference_symbolic_target(git_reference* referen`
`2011`	`2011`	`return NativeMethods.git_reference_symbolic_target(reference);`
`2012`	`2012`	`}`
`2013`	`2013`
`2014`		`- public static unsafe GitReferenceType git_reference_type(git_reference* reference)`
	`2014`	`+ public static unsafe GitReferenceType git_reference_type(ReferenceHandle reference)`
`2015`	`2015`	`{`
`2016`	`2016`	`return NativeMethods.git_reference_type(reference);`
`2017`	`2017`	`}`
`@@ -3779,9 +3779,9 @@ private static ICollection<TResult> git_foreach<T1, T2, T3, T4, TResult>(`
`3779`	`3779`	`return result;`
`3780`	`3780`	`}`
`3781`	`3781`
`3782`		`- private static unsafe bool RepositoryStateChecker(RepositoryHandle repo, Func<IntPtr, int> checker)`
	`3782`	`+ private static unsafe bool RepositoryStateChecker(RepositoryHandle repo, Func<RepositoryHandle, int> checker)`
`3783`	`3783`	`{`
`3784`		`- int res = checker(repo.AsIntPtr());`
	`3784`	`+ int res = checker(repo);`
`3785`	`3785`	`Ensure.BooleanResult(res);`
`3786`	`3786`
`3787`	`3787`	`return (res == 1);`
Original file line number	Diff line number	Diff line change
`@@ -32,13 +32,7 @@ private protected Reference(IRepository repo, string canonicalName, string targe`
`32`	`32`	`this.targetIdentifier = targetIdentifier;`
`33`	`33`	`}`
`34`	`34`
`35`		`- // This overload lets public-facing methods avoid having to use the pointers directly`
`36`	`35`	`internal static unsafe T BuildFromPtr<T>(ReferenceHandle handle, Repository repo) where T : Reference`
`37`		`- {`
`38`		`- return BuildFromPtr<T>((git_reference*)handle.AsIntPtr(), repo);`
`39`		`- }`
`40`		`-`
`41`		`- internal static unsafe T BuildFromPtr<T>(git_reference* handle, Repository repo) where T : Reference`
`42`	`36`	`{`
`43`	`37`	`GitReferenceType type = Proxy.git_reference_type(handle);`
`44`	`38`	`string name = Proxy.git_reference_name(handle);`