Introduce the TypeApiFactory to encapsulate the creation of the ITypeLibWrapper & ITypeInfoWrapper, making it easy to get them traced with appropriate flags. Redirect all the news into the factory. Also some cleanup of missed abstractions.

bclothier · bclothier · commit c72b8a6a13e7 · 2019-08-01T09:04:36.000-05:00
diff --git a/Rubberduck.VBEEditor/ComManagement/TypeLibs/TypeApiFactory.cs b/Rubberduck.VBEEditor/ComManagement/TypeLibs/TypeApiFactory.cs
@@ -0,0 +1,45 @@
+﻿#define TRACE_TYPEAPI
+
+using System;
+using System.Runtime.InteropServices.ComTypes;
+using Rubberduck.VBEditor.ComManagement.TypeLibs.Abstract;
+
+#if DEBUG && TRACE_TYPEAPI
+using Rubberduck.VBEditor.ComManagement.TypeLibs.DebugInternal;
+#endif
+
+namespace Rubberduck.VBEditor.ComManagement.TypeLibs
+{
+    internal static class TypeApiFactory
+    {
+        internal static ITypeLibWrapper GetTypeLibWrapper(IntPtr rawObjectPtr, bool addRef)
+        {
+            var wrapper = new TypeLibWrapper(rawObjectPtr, addRef);
+#if DEBUG && TRACE_TYPEAPI
+            return new TypeLibWrapperTracer(wrapper);
+#else
+            return wrapper;
+#endif
+        }
+
+        internal static ITypeInfoWrapper GetTypeInfoWrapper(IntPtr rawObjectPtr, int? parentUserFormUniqueId = null)
+        {
+            var wrapper = new TypeInfoWrapper(rawObjectPtr, parentUserFormUniqueId);
+#if DEBUG && TRACE_TYPEAPI
+            return new TypeInfoWrapperTracer(wrapper);
+#else
+            return wrapper;
+#endif
+        }
+
+        internal static ITypeInfoWrapper GetTypeInfoWrapper(ITypeInfo rawTypeInfo)
+        {
+            var wrapper = new TypeInfoWrapper(rawTypeInfo);
+#if DEBUG && TRACE_TYPEAPI
+            return new TypeInfoWrapperTracer(wrapper);
+#else
+            return wrapper;
+#endif
+        }
+    }
+}
diff --git a/Rubberduck.VBEEditor/ComManagement/TypeLibs/TypeInfoImplementedInterfacesCollection.cs b/Rubberduck.VBEEditor/ComManagement/TypeLibs/TypeInfoImplementedInterfacesCollection.cs
@@ -24,7 +24,7 @@ public override ITypeInfoWrapper GetItemByIndex(int index)
             _parent.GetRefTypeOfImplType(index, out var href);
             _parent.GetRefTypeInfo(href, out var ti);
 
-            return new TypeInfoWrapper(ti);
+            return TypeApiFactory.GetTypeInfoWrapper(ti);
         }
 
         /// <summary>
diff --git a/Rubberduck.VBEEditor/ComManagement/TypeLibs/TypeInfoWrapper.cs b/Rubberduck.VBEEditor/ComManagement/TypeLibs/TypeInfoWrapper.cs
@@ -133,7 +133,7 @@ private void InitCommon()
                 if (!ComHelper.HRESULT_FAILED(hr))
                 {
                     // We have to wrap the ITypeLib returned by GetContainingTypeLib
-                    _container = new TypeLibWrapper(typeLibPtr.Value, addRef: false);
+                    _container = (TypeLibInternalSelfMarshalForwarderBase)TypeApiFactory.GetTypeLibWrapper(typeLibPtr.Value, addRef: false);
                     ContainerIndex = containerTypeLibIndex.Value;
                 }
                 else
@@ -180,7 +180,11 @@ private void InitFromRawPointer(IntPtr rawObjectPtr, bool addRef)
             DetectUserFormClass();
         }
 
-        public TypeInfoWrapper(ComTypes.ITypeInfo rawTypeInfo)
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="rawTypeInfo">The ITypeInfo object to be wrapped. It will be checked if it's already wrapped to avoid double-wraping.</param>
+        internal TypeInfoWrapper(ComTypes.ITypeInfo rawTypeInfo)
         {
             if ((rawTypeInfo as TypeInfoInternalSelfMarshalForwarderBase) != null)
             {
@@ -200,7 +204,7 @@ public TypeInfoWrapper(ComTypes.ITypeInfo rawTypeInfo)
         /// </summary>
         /// <param name="rawObjectPtr">The raw unmanaged pointer to the ITypeInfo.  This class takes ownership, and will call Marshall.Release() on it upon disposal.</param>
         /// <param name="parentUserFormUniqueId">used internally for providing a name for UserForm base classes</param>
-        public TypeInfoWrapper(IntPtr rawObjectPtr, int? parentUserFormUniqueId = null)
+        internal TypeInfoWrapper(IntPtr rawObjectPtr, int? parentUserFormUniqueId = null)
         {
             // base classes of VBE UserForms cause an access violation on calling GetDocumentation(MEMBERID_NIL)
             // so we have to detect UserForm parents, and ensure GetDocumentation(MEMBERID_NIL) never gets through
@@ -296,7 +300,7 @@ private void DetectUserFormClass()
             }
         }
 
-        public int GetSafeRefTypeInfo(int hRef, out TypeInfoWrapper outTI)
+        public int GetSafeRefTypeInfo(int hRef, out ITypeInfoWrapper outTI)
         {
             outTI = null;
 
@@ -305,7 +309,7 @@ public int GetSafeRefTypeInfo(int hRef, out TypeInfoWrapper outTI)
                 var hr = _target_ITypeInfo.GetRefTypeInfo(hRef, typeInfoPtr.Address);
                 if (ComHelper.HRESULT_FAILED(hr)) return HandleBadHRESULT(hr);
 
-                var outVal = new TypeInfoWrapper(typeInfoPtr.Value, IsUserFormBaseClass ? (int?)hRef : null); // takes ownership of the COM reference
+                var outVal = TypeApiFactory.GetTypeInfoWrapper(typeInfoPtr.Value, IsUserFormBaseClass ? (int?)hRef : null); // takes ownership of the COM reference
                 _cachedReferencedTypeInfos = _cachedReferencedTypeInfos ?? new DisposableList<ITypeInfoWrapper>();
                 _cachedReferencedTypeInfos.Add(outVal);
                 outTI = outVal;
diff --git a/Rubberduck.VBEEditor/ComManagement/TypeLibs/TypeLibVBEExtensions.cs b/Rubberduck.VBEEditor/ComManagement/TypeLibs/TypeLibVBEExtensions.cs
@@ -165,7 +165,7 @@ public ITypeLibWrapper GetVBEReferenceTypeLibByIndex(int index)
             {
                 throw new ArgumentException("Reference TypeLib not available - probably a missing reference.");
             }
-            return new TypeLibWrapper(referenceTypeLibPtr, addRef: false);
+            return TypeApiFactory.GetTypeLibWrapper(referenceTypeLibPtr, addRef: false);
         }
         
         public ITypeLibReference GetVBEReferenceByGuid(Guid referenceGuid)
diff --git a/Rubberduck.VBEEditor/ComManagement/TypeLibs/TypeLibWrapper.cs b/Rubberduck.VBEEditor/ComManagement/TypeLibs/TypeLibWrapper.cs
@@ -108,7 +108,7 @@ internal static ITypeLibWrapper FromVBProject(IVBProject vbProject)
             {
                 // Now we've got the references object, we can read the internal object structure to grab the ITypeLib
                 var internalReferencesObj = StructHelper.ReadComObjectStructure<VBEReferencesObj>(references.Target);
-                return new TypeLibWrapper(internalReferencesObj._typeLib, addRef: true);
+                return TypeApiFactory.GetTypeLibWrapper(internalReferencesObj._typeLib, addRef: true);
             }
         }
 
@@ -132,7 +132,7 @@ private void InitFromRawPointer(IntPtr rawObjectPtr, bool addRef)
         /// direct memory read. Setting the parameter will effect an IUnknown::AddRef
         /// on the pointer. 
         /// </param>
-        public TypeLibWrapper(IntPtr rawObjectPtr, bool addRef)
+        internal TypeLibWrapper(IntPtr rawObjectPtr, bool addRef)
         {
             InitFromRawPointer(rawObjectPtr, addRef);
         }
@@ -147,7 +147,7 @@ public override void Dispose()
             _typeLibPointer.Dispose();
         }
 
-        public int GetSafeTypeInfoByIndex(int index, out TypeInfoWrapper outTI)
+        public int GetSafeTypeInfoByIndex(int index, out ITypeInfoWrapper outTI)
         {
             outTI = null;
 
@@ -159,7 +159,7 @@ public int GetSafeTypeInfoByIndex(int index, out TypeInfoWrapper outTI)
                     return HandleBadHRESULT(hr);
                 }
 
-                var outVal = new TypeInfoWrapper(typeInfoPtr.Value);
+                var outVal = TypeApiFactory.GetTypeInfoWrapper(typeInfoPtr.Value);
                 _cachedTypeInfos = _cachedTypeInfos ?? new DisposableList<ITypeInfoWrapper>();
                 _cachedTypeInfos.Add(outVal);
                 outTI = outVal;
@@ -241,7 +241,7 @@ public override int GetTypeInfoOfGuid(ref Guid guid, IntPtr ppTInfo)
             if (ComHelper.HRESULT_FAILED(hr)) return HandleBadHRESULT(hr);
 
             var pTInfo = RdMarshal.ReadIntPtr(ppTInfo);
-            using (var outVal = new TypeInfoWrapper(pTInfo)) // takes ownership of the COM reference [pTInfo]
+            using (var outVal = TypeApiFactory.GetTypeInfoWrapper(pTInfo)) // takes ownership of the COM reference [pTInfo]
             {
                 RdMarshal.WriteIntPtr(ppTInfo, outVal.GetCOMReferencePtr());
 
diff --git a/Rubberduck.VBEEditor/ComManagement/TypeLibs/Unmanaged/VBETypeLibsIterator.cs b/Rubberduck.VBEEditor/ComManagement/TypeLibs/Unmanaged/VBETypeLibsIterator.cs
@@ -2,6 +2,7 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.Runtime.InteropServices;
+using Rubberduck.VBEditor.ComManagement.TypeLibs.Abstract;
 
 namespace Rubberduck.VBEditor.ComManagement.TypeLibs.Unmanaged
 {
@@ -22,7 +23,7 @@ internal struct VBETypeLibObj
     /// <summary>
     /// An enumerable class for iterating over the double linked list of ITypeLibs provided by the VBE 
     /// </summary>
-    internal sealed class VBETypeLibsIterator : IEnumerable<TypeLibWrapper>, IEnumerator<TypeLibWrapper>
+    internal sealed class VBETypeLibsIterator : IEnumerable<ITypeLibWrapper>, IEnumerator<ITypeLibWrapper>
     {
         private IntPtr _currentTypeLibPtr;
         private VBETypeLibObj _currentTypeLibStruct;
@@ -41,10 +42,10 @@ public void Dispose()
         }
 
         IEnumerator IEnumerable.GetEnumerator() => this;
-        public IEnumerator<TypeLibWrapper> GetEnumerator() => this;
+        public IEnumerator<ITypeLibWrapper> GetEnumerator() => this;
 
-        TypeLibWrapper IEnumerator<TypeLibWrapper>.Current => new TypeLibWrapper(_currentTypeLibPtr, addRef: true);
-        object IEnumerator.Current => new TypeLibWrapper(_currentTypeLibPtr, addRef: true);
+        ITypeLibWrapper IEnumerator<ITypeLibWrapper>.Current => TypeApiFactory.GetTypeLibWrapper(_currentTypeLibPtr, addRef: true);
+        object IEnumerator.Current => TypeApiFactory.GetTypeLibWrapper(_currentTypeLibPtr, addRef: true);
 
         public void Reset()  // walk back to the first project in the chain
         {
diff --git a/Rubberduck.VBEEditor/ComManagement/TypeLibs/VBETypeLibsAccessor.cs b/Rubberduck.VBEEditor/ComManagement/TypeLibs/VBETypeLibsAccessor.cs
@@ -34,7 +34,7 @@ internal struct VBEReferencesObj
     ///   Make sure you call VBETypeLibsAccessor.Dispose() as soon as you have done what you need to do with it.
     ///   Once control returns back to the VBE, you must assume that all the ITypeLib/ITypeInfo pointers are now invalid.
     /// </remarks>
-    internal class VBETypeLibsAccessor : DisposableList<TypeLibWrapper>
+    internal class VBETypeLibsAccessor : DisposableList<ITypeLibWrapper>
     {
         internal VBETypeLibsAccessor(IVBE ide)
         {

Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ public override ITypeInfoWrapper GetItemByIndex(int index)`
`24`	`24`	`_parent.GetRefTypeOfImplType(index, out var href);`
`25`	`25`	`_parent.GetRefTypeInfo(href, out var ti);`
`26`	`26`
`27`		`- return new TypeInfoWrapper(ti);`
	`27`	`+ return TypeApiFactory.GetTypeInfoWrapper(ti);`
`28`	`28`	`}`
`29`	`29`
`30`	`30`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -133,7 +133,7 @@ private void InitCommon()`
`133`	`133`	`if (!ComHelper.HRESULT_FAILED(hr))`
`134`	`134`	`{`
`135`	`135`	`// We have to wrap the ITypeLib returned by GetContainingTypeLib`
`136`		`- _container = new TypeLibWrapper(typeLibPtr.Value, addRef: false);`
	`136`	`+ _container = (TypeLibInternalSelfMarshalForwarderBase)TypeApiFactory.GetTypeLibWrapper(typeLibPtr.Value, addRef: false);`
`137`	`137`	`ContainerIndex = containerTypeLibIndex.Value;`
`138`	`138`	`}`
`139`	`139`	`else`
`@@ -180,7 +180,11 @@ private void InitFromRawPointer(IntPtr rawObjectPtr, bool addRef)`
`180`	`180`	`DetectUserFormClass();`
`181`	`181`	`}`
`182`	`182`
`183`		`- public TypeInfoWrapper(ComTypes.ITypeInfo rawTypeInfo)`
	`183`	`+ /// <summary>`
	`184`	`+ /// Constructor`
	`185`	`+ /// </summary>`
	`186`	`+ /// <param name="rawTypeInfo">The ITypeInfo object to be wrapped. It will be checked if it's already wrapped to avoid double-wraping.</param>`
	`187`	`+ internal TypeInfoWrapper(ComTypes.ITypeInfo rawTypeInfo)`
`184`	`188`	`{`
`185`	`189`	`if ((rawTypeInfo as TypeInfoInternalSelfMarshalForwarderBase) != null)`
`186`	`190`	`{`
`@@ -200,7 +204,7 @@ public TypeInfoWrapper(ComTypes.ITypeInfo rawTypeInfo)`
`200`	`204`	`/// </summary>`
`201`	`205`	`/// <param name="rawObjectPtr">The raw unmanaged pointer to the ITypeInfo. This class takes ownership, and will call Marshall.Release() on it upon disposal.</param>`
`202`	`206`	`/// <param name="parentUserFormUniqueId">used internally for providing a name for UserForm base classes</param>`
`203`		`- public TypeInfoWrapper(IntPtr rawObjectPtr, int? parentUserFormUniqueId = null)`
	`207`	`+ internal TypeInfoWrapper(IntPtr rawObjectPtr, int? parentUserFormUniqueId = null)`
`204`	`208`	`{`
`205`	`209`	`// base classes of VBE UserForms cause an access violation on calling GetDocumentation(MEMBERID_NIL)`
`206`	`210`	`// so we have to detect UserForm parents, and ensure GetDocumentation(MEMBERID_NIL) never gets through`
`@@ -296,7 +300,7 @@ private void DetectUserFormClass()`
`296`	`300`	`}`
`297`	`301`	`}`
`298`	`302`
`299`		`- public int GetSafeRefTypeInfo(int hRef, out TypeInfoWrapper outTI)`
	`303`	`+ public int GetSafeRefTypeInfo(int hRef, out ITypeInfoWrapper outTI)`
`300`	`304`	`{`
`301`	`305`	`outTI = null;`
`302`	`306`
`@@ -305,7 +309,7 @@ public int GetSafeRefTypeInfo(int hRef, out TypeInfoWrapper outTI)`
`305`	`309`	`var hr = _target_ITypeInfo.GetRefTypeInfo(hRef, typeInfoPtr.Address);`
`306`	`310`	`if (ComHelper.HRESULT_FAILED(hr)) return HandleBadHRESULT(hr);`
`307`	`311`
`308`		`- var outVal = new TypeInfoWrapper(typeInfoPtr.Value, IsUserFormBaseClass ? (int?)hRef : null); // takes ownership of the COM reference`
	`312`	`+ var outVal = TypeApiFactory.GetTypeInfoWrapper(typeInfoPtr.Value, IsUserFormBaseClass ? (int?)hRef : null); // takes ownership of the COM reference`
`309`	`313`	`_cachedReferencedTypeInfos = _cachedReferencedTypeInfos ?? new DisposableList<ITypeInfoWrapper>();`
`310`	`314`	`_cachedReferencedTypeInfos.Add(outVal);`
`311`	`315`	`outTI = outVal;`
Original file line number	Diff line number	Diff line change
`@@ -165,7 +165,7 @@ public ITypeLibWrapper GetVBEReferenceTypeLibByIndex(int index)`
`165`	`165`	`{`
`166`	`166`	`throw new ArgumentException("Reference TypeLib not available - probably a missing reference.");`
`167`	`167`	`}`
`168`		`- return new TypeLibWrapper(referenceTypeLibPtr, addRef: false);`
	`168`	`+ return TypeApiFactory.GetTypeLibWrapper(referenceTypeLibPtr, addRef: false);`
`169`	`169`	`}`
`170`	`170`
`171`	`171`	`public ITypeLibReference GetVBEReferenceByGuid(Guid referenceGuid)`
Original file line number	Diff line number	Diff line change
`@@ -108,7 +108,7 @@ internal static ITypeLibWrapper FromVBProject(IVBProject vbProject)`
`108`	`108`	`{`
`109`	`109`	`// Now we've got the references object, we can read the internal object structure to grab the ITypeLib`
`110`	`110`	`var internalReferencesObj = StructHelper.ReadComObjectStructure<VBEReferencesObj>(references.Target);`
`111`		`- return new TypeLibWrapper(internalReferencesObj._typeLib, addRef: true);`
	`111`	`+ return TypeApiFactory.GetTypeLibWrapper(internalReferencesObj._typeLib, addRef: true);`
`112`	`112`	`}`
`113`	`113`	`}`
`114`	`114`
`@@ -132,7 +132,7 @@ private void InitFromRawPointer(IntPtr rawObjectPtr, bool addRef)`
`132`	`132`	`/// direct memory read. Setting the parameter will effect an IUnknown::AddRef`
`133`	`133`	`/// on the pointer.`
`134`	`134`	`/// </param>`
`135`		`- public TypeLibWrapper(IntPtr rawObjectPtr, bool addRef)`
	`135`	`+ internal TypeLibWrapper(IntPtr rawObjectPtr, bool addRef)`
`136`	`136`	`{`
`137`	`137`	`InitFromRawPointer(rawObjectPtr, addRef);`
`138`	`138`	`}`
`@@ -147,7 +147,7 @@ public override void Dispose()`
`147`	`147`	`_typeLibPointer.Dispose();`
`148`	`148`	`}`
`149`	`149`
`150`		`- public int GetSafeTypeInfoByIndex(int index, out TypeInfoWrapper outTI)`
	`150`	`+ public int GetSafeTypeInfoByIndex(int index, out ITypeInfoWrapper outTI)`
`151`	`151`	`{`
`152`	`152`	`outTI = null;`
`153`	`153`
`@@ -159,7 +159,7 @@ public int GetSafeTypeInfoByIndex(int index, out TypeInfoWrapper outTI)`
`159`	`159`	`return HandleBadHRESULT(hr);`
`160`	`160`	`}`
`161`	`161`
`162`		`- var outVal = new TypeInfoWrapper(typeInfoPtr.Value);`
	`162`	`+ var outVal = TypeApiFactory.GetTypeInfoWrapper(typeInfoPtr.Value);`
`163`	`163`	`_cachedTypeInfos = _cachedTypeInfos ?? new DisposableList<ITypeInfoWrapper>();`
`164`	`164`	`_cachedTypeInfos.Add(outVal);`
`165`	`165`	`outTI = outVal;`
`@@ -241,7 +241,7 @@ public override int GetTypeInfoOfGuid(ref Guid guid, IntPtr ppTInfo)`
`241`	`241`	`if (ComHelper.HRESULT_FAILED(hr)) return HandleBadHRESULT(hr);`
`242`	`242`
`243`	`243`	`var pTInfo = RdMarshal.ReadIntPtr(ppTInfo);`
`244`		`- using (var outVal = new TypeInfoWrapper(pTInfo)) // takes ownership of the COM reference [pTInfo]`
	`244`	`+ using (var outVal = TypeApiFactory.GetTypeInfoWrapper(pTInfo)) // takes ownership of the COM reference [pTInfo]`
`245`	`245`	`{`
`246`	`246`	`RdMarshal.WriteIntPtr(ppTInfo, outVal.GetCOMReferencePtr());`
`247`	`247`
Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@ internal struct VBEReferencesObj`
`34`	`34`	`/// Make sure you call VBETypeLibsAccessor.Dispose() as soon as you have done what you need to do with it.`
`35`	`35`	`/// Once control returns back to the VBE, you must assume that all the ITypeLib/ITypeInfo pointers are now invalid.`
`36`	`36`	`/// </remarks>`
`37`		`- internal class VBETypeLibsAccessor : DisposableList<TypeLibWrapper>`
	`37`	`+ internal class VBETypeLibsAccessor : DisposableList<ITypeLibWrapper>`
`38`	`38`	`{`
`39`	`39`	`internal VBETypeLibsAccessor(IVBE ide)`
`40`	`40`	`{`