From 43c98fcead6566bb53abca53a36c29225d0a58fc Mon Sep 17 00:00:00 2001
From: xtqqczze <xtqqczze@gmail.com>
Date: Sun, 20 Dec 2020 22:36:51 +0000
Subject: [PATCH 1/3] Enable SA1314: Type parameter names should begin with T

https://github.com/DotNetAnalyzers/StyleCopAnalyzers/blob/master/documentation/SA1314.md
---
 .globalconfig                                      |  2 +-
 .../commands/utility/ImplicitRemotingCommands.cs   | 14 +++++++++-----
 .../commands/utility/Measure-Object.cs             | 14 +++++++-------
 3 files changed, 17 insertions(+), 13 deletions(-)

diff --git a/.globalconfig b/.globalconfig
index f0cc41c388e..54f5bac867c 100644
--- a/.globalconfig
+++ b/.globalconfig
@@ -1307,7 +1307,7 @@ dotnet_diagnostic.SA1312.severity = none
 dotnet_diagnostic.SA1313.severity = none
 
 # SA1314: Type parameter names should begin with T
-dotnet_diagnostic.SA1314.severity = none
+dotnet_diagnostic.SA1314.severity = warning
 
 # SA1316: Tuple element names should use correct casing
 dotnet_diagnostic.SA1316.severity = none
diff --git a/src/Microsoft.PowerShell.Commands.Utility/commands/utility/ImplicitRemotingCommands.cs b/src/Microsoft.PowerShell.Commands.Utility/commands/utility/ImplicitRemotingCommands.cs
index 03ca0953e94..67d25128558 100644
--- a/src/Microsoft.PowerShell.Commands.Utility/commands/utility/ImplicitRemotingCommands.cs
+++ b/src/Microsoft.PowerShell.Commands.Utility/commands/utility/ImplicitRemotingCommands.cs
@@ -1066,17 +1066,21 @@ private List<T> RehydrateList<T>(string commandName, object deserializedList, Fu
             return result;
         }
 
-        private Dictionary<K, V> RehydrateDictionary<K, V>(string commandName, PSObject deserializedObject, string propertyName, Func<PSObject, V> valueRehydrator)
+        private Dictionary<TKey, TValue> RehydrateDictionary<TKey, TValue>(
+            string commandName,
+            PSObject deserializedObject, 
+            string propertyName,
+            Func<PSObject, TValue> valueRehydrator)
         {
             Dbg.Assert(deserializedObject != null, "deserializedObject parameter != null");
             Dbg.Assert(!string.IsNullOrEmpty(propertyName), "propertyName parameter != null");
 
             if (valueRehydrator == null)
             {
-                valueRehydrator = (PSObject pso) => ConvertTo<V>(commandName, pso);
+                valueRehydrator = (PSObject pso) => ConvertTo<TValue>(commandName, pso);
             }
 
-            Dictionary<K, V> result = new();
+            Dictionary<TKey, TValue> result = new();
             PSPropertyInfo deserializedDictionaryProperty = deserializedObject.Properties[propertyName];
             if (deserializedDictionaryProperty != null)
             {
@@ -1085,10 +1089,10 @@ private Dictionary<K, V> RehydrateDictionary<K, V>(string commandName, PSObject
                 {
                     foreach (DictionaryEntry deserializedItem in deserializedDictionary)
                     {
-                        K itemKey = ConvertTo<K>(commandName, deserializedItem.Key);
+                        TKey itemKey = ConvertTo<TKey>(commandName, deserializedItem.Key);
 
                         PSObject deserializedItemValue = ConvertTo<PSObject>(commandName, deserializedItem.Value);
-                        V itemValue = valueRehydrator(deserializedItemValue);
+                        TValue itemValue = valueRehydrator(deserializedItemValue);
 
                         result.Add(itemKey, itemValue);
                     }
diff --git a/src/Microsoft.PowerShell.Commands.Utility/commands/utility/Measure-Object.cs b/src/Microsoft.PowerShell.Commands.Utility/commands/utility/Measure-Object.cs
index 4bc6a3b42e0..452e8bfe09c 100644
--- a/src/Microsoft.PowerShell.Commands.Utility/commands/utility/Measure-Object.cs
+++ b/src/Microsoft.PowerShell.Commands.Utility/commands/utility/Measure-Object.cs
@@ -159,12 +159,12 @@ public sealed class MeasureObjectCommand : PSCmdlet
         /// Dictionary to be used by Measure-Object implementation.
         /// Keys are strings. Keys are compared with OrdinalIgnoreCase.
         /// </summary>
-        /// <typeparam name="V">Value type.</typeparam>
-        private class MeasureObjectDictionary<V> : Dictionary<string, V>
-            where V : new()
+        /// <typeparam name="TValue">Value type.</typeparam>
+        private class MeasureObjectDictionary<TValue> : Dictionary<string, TValue>
+            where TValue : new()
         {
             /// <summary>
-            /// Initializes a new instance of the <see cref="MeasureObjectDictionary{V}"/> class.
+            /// Initializes a new instance of the <see cref="MeasureObjectDictionary{TValue}"/> class.
             /// Default ctor.
             /// </summary>
             internal MeasureObjectDictionary() : base(StringComparer.OrdinalIgnoreCase)
@@ -181,12 +181,12 @@ internal MeasureObjectDictionary() : base(StringComparer.OrdinalIgnoreCase)
             /// <returns>
             /// The existing value, or a newly-created value.
             /// </returns>
-            public V EnsureEntry(string key)
+            public TValue EnsureEntry(string key)
             {
-                V val;
+                TValue val;
                 if (!TryGetValue(key, out val))
                 {
-                    val = new V();
+                    val = new TValue();
                     this[key] = val;
                 }
 

From 39f788f01b92ac68b51bf6688542159a4a35294b Mon Sep 17 00:00:00 2001
From: xtqqczze <xtqqczze@gmail.com>
Date: Mon, 21 Dec 2020 00:20:53 +0000
Subject: [PATCH 2/3] Rename type arguments

---
 .../engine/MshObject.cs                       | 15 ++--
 .../engine/hostifaces/PSDataCollection.cs     | 22 +++---
 .../engine/interpreter/Utilities.cs           | 10 +--
 .../common/WireDataFormat/EncodeAndDecode.cs  |  8 +--
 .../engine/serialization.cs                   | 12 ++--
 .../utils/ObjectReader.cs                     | 70 +++++++++----------
 6 files changed, 69 insertions(+), 68 deletions(-)

diff --git a/src/System.Management.Automation/engine/MshObject.cs b/src/System.Management.Automation/engine/MshObject.cs
index 2253c7c913e..7ea7ef1bd72 100644
--- a/src/System.Management.Automation/engine/MshObject.cs
+++ b/src/System.Management.Automation/engine/MshObject.cs
@@ -164,20 +164,21 @@ private static T AdapterGetFirstMemberOrDefaultDelegate<T>(PSObject msjObj, Memb
             return retValue;
         }
 
-        internal static PSMemberInfoInternalCollection<U> TransformMemberInfoCollection<T, U>(PSMemberInfoCollection<T> source) where T : PSMemberInfo where U : PSMemberInfo
+        internal static PSMemberInfoInternalCollection<TResult> TransformMemberInfoCollection<TSource, TResult>(PSMemberInfoCollection<TSource> source)
+            where TSource : PSMemberInfo where TResult : PSMemberInfo
         {
-            if (typeof(T) == typeof(U))
+            if (typeof(TSource) == typeof(TResult))
             {
                 // If the types are the same, don't make a copy, return the cached collection.
-                return source as PSMemberInfoInternalCollection<U>;
+                return source as PSMemberInfoInternalCollection<TResult>;
             }
 
-            PSMemberInfoInternalCollection<U> returnValue = new PSMemberInfoInternalCollection<U>();
-            foreach (T member in source)
+            PSMemberInfoInternalCollection<TResult> returnValue = new PSMemberInfoInternalCollection<TResult>();
+            foreach (TSource member in source)
             {
-                if (member is U tAsU)
+                if (member is TResult result)
                 {
-                    returnValue.Add(tAsU);
+                    returnValue.Add(result);
                 }
             }
 
diff --git a/src/System.Management.Automation/engine/hostifaces/PSDataCollection.cs b/src/System.Management.Automation/engine/hostifaces/PSDataCollection.cs
index 1743e6d4678..f484fbe865e 100644
--- a/src/System.Management.Automation/engine/hostifaces/PSDataCollection.cs
+++ b/src/System.Management.Automation/engine/hostifaces/PSDataCollection.cs
@@ -1809,8 +1809,8 @@ protected void Dispose(bool disposing)
     /// Needed to provide a way to get to the non-blocking
     /// MoveNext implementation.
     /// </summary>
-    /// <typeparam name="W"></typeparam>
-    internal interface IBlockingEnumerator<out W> : IEnumerator<W>
+    /// <typeparam name="T"></typeparam>
+    internal interface IBlockingEnumerator<out T> : IEnumerator<T>
     {
         bool MoveNext(bool block);
     }
@@ -1822,14 +1822,14 @@ internal interface IBlockingEnumerator<out W> : IEnumerator<W>
     /// either all the PowerShell operations are completed or the
     /// PSDataCollection is closed.
     /// </summary>
-    /// <typeparam name="W"></typeparam>
-    internal sealed class PSDataCollectionEnumerator<W> : IBlockingEnumerator<W>
+    /// <typeparam name="T"></typeparam>
+    internal sealed class PSDataCollectionEnumerator<T> : IBlockingEnumerator<T>
     {
         #region Private Data
 
-        private W _currentElement;
+        private T _currentElement;
         private int _index;
-        private readonly PSDataCollection<W> _collToEnumerate;
+        private readonly PSDataCollection<T> _collToEnumerate;
         private readonly bool _neverBlock;
 
         #endregion
@@ -1845,7 +1845,7 @@ internal sealed class PSDataCollectionEnumerator<W> : IBlockingEnumerator<W>
         /// <param name="neverBlock">
         /// Controls if the enumerator is blocking by default or not.
         /// </param>
-        internal PSDataCollectionEnumerator(PSDataCollection<W> collection, bool neverBlock)
+        internal PSDataCollectionEnumerator(PSDataCollection<T> collection, bool neverBlock)
         {
             Dbg.Assert(collection != null,
                 "Collection cannot be null");
@@ -1854,7 +1854,7 @@ internal PSDataCollectionEnumerator(PSDataCollection<W> collection, bool neverBl
 
             _collToEnumerate = collection;
             _index = 0;
-            _currentElement = default(W);
+            _currentElement = default(T);
             _collToEnumerate.IsEnumerated = true;
             _neverBlock = neverBlock;
         }
@@ -1872,7 +1872,7 @@ internal PSDataCollectionEnumerator(PSDataCollection<W> collection, bool neverBl
         /// if the enumerator is positioned before the first element or after
         /// the last element; the value of the property is undefined.
         /// </remarks>
-        W IEnumerator<W>.Current
+        T IEnumerator<T>.Current
         {
             get
             {
@@ -1933,7 +1933,7 @@ public bool MoveNext(bool block)
                         _currentElement = _collToEnumerate[_index];
                         if (_collToEnumerate.ReleaseOnEnumeration)
                         {
-                            _collToEnumerate[_index] = default(W);
+                            _collToEnumerate[_index] = default(T);
                         }
 
                         _index++;
@@ -1975,7 +1975,7 @@ public bool MoveNext(bool block)
         /// </summary>
         public void Reset()
         {
-            _currentElement = default(W);
+            _currentElement = default(T);
             _index = 0;
         }
 
diff --git a/src/System.Management.Automation/engine/interpreter/Utilities.cs b/src/System.Management.Automation/engine/interpreter/Utilities.cs
index 3d4307f1d3a..ac896719d62 100644
--- a/src/System.Management.Automation/engine/interpreter/Utilities.cs
+++ b/src/System.Management.Automation/engine/interpreter/Utilities.cs
@@ -1084,14 +1084,14 @@ internal static bool TrueForAll<T>(this IEnumerable<T> collection, Predicate<T>
             return true;
         }
 
-        internal static U[] Map<T, U>(this ICollection<T> collection, Func<T, U> select)
+        internal static TResult[] Map<TSource, TResult>(this ICollection<TSource> source, Func<TSource, TResult> selector)
         {
-            int count = collection.Count;
-            U[] result = new U[count];
+            int count = source.Count;
+            TResult[] result = new TResult[count];
             count = 0;
-            foreach (T t in collection)
+            foreach (TSource t in source)
             {
-                result[count++] = select(t);
+                result[count++] = selector(t);
             }
 
             return result;
diff --git a/src/System.Management.Automation/engine/remoting/common/WireDataFormat/EncodeAndDecode.cs b/src/System.Management.Automation/engine/remoting/common/WireDataFormat/EncodeAndDecode.cs
index 03a3cd51a87..d99fbe21126 100644
--- a/src/System.Management.Automation/engine/remoting/common/WireDataFormat/EncodeAndDecode.cs
+++ b/src/System.Management.Automation/engine/remoting/common/WireDataFormat/EncodeAndDecode.cs
@@ -1803,7 +1803,7 @@ internal static IEnumerable<T> EnumerateListProperty<T>(PSObject psObject, strin
             }
         }
 
-        internal static IEnumerable<KeyValuePair<KeyType, ValueType>> EnumerateHashtableProperty<KeyType, ValueType>(PSObject psObject, string propertyName)
+        internal static IEnumerable<KeyValuePair<TKey, TValue>> EnumerateHashtableProperty<TKey, TValue>(PSObject psObject, string propertyName)
         {
             if (psObject == null)
             {
@@ -1820,9 +1820,9 @@ internal static IEnumerable<KeyValuePair<KeyType, ValueType>> EnumerateHashtable
             {
                 foreach (DictionaryEntry e in h)
                 {
-                    KeyType key = ConvertPropertyValueTo<KeyType>(propertyName, e.Key);
-                    ValueType value = ConvertPropertyValueTo<ValueType>(propertyName, e.Value);
-                    yield return new KeyValuePair<KeyType, ValueType>(key, value);
+                    TKey key = ConvertPropertyValueTo<TKey>(propertyName, e.Key);
+                    TValue value = ConvertPropertyValueTo<TValue>(propertyName, e.Value);
+                    yield return new KeyValuePair<TKey, TValue>(key, value);
                 }
             }
         }
diff --git a/src/System.Management.Automation/engine/serialization.cs b/src/System.Management.Automation/engine/serialization.cs
index a01f67b81e2..b4115de05cb 100644
--- a/src/System.Management.Automation/engine/serialization.cs
+++ b/src/System.Management.Automation/engine/serialization.cs
@@ -6871,27 +6871,27 @@ internal static T GetPropertyValue<T>(PSObject pso, string propertyName, Rehydra
             }
         }
 
-        private static ListType RehydrateList<ListType, ItemType>(PSObject pso, string propertyName, RehydrationFlags flags)
-            where ListType : IList, new()
+        private static TList RehydrateList<TList, TItem>(PSObject pso, string propertyName, RehydrationFlags flags)
+            where TList : IList, new()
         {
             ArrayList deserializedList = GetPropertyValue<ArrayList>(pso, propertyName, flags);
             if (deserializedList == null)
             {
                 if ((flags & RehydrationFlags.NullValueMeansEmptyList) == RehydrationFlags.NullValueMeansEmptyList)
                 {
-                    return new ListType();
+                    return new TList();
                 }
                 else
                 {
-                    return default(ListType);
+                    return default(TList);
                 }
             }
             else
             {
-                ListType newList = new ListType();
+                TList newList = new TList();
                 foreach (object deserializedItem in deserializedList)
                 {
-                    ItemType item = (ItemType)LanguagePrimitives.ConvertTo(deserializedItem, typeof(ItemType), CultureInfo.InvariantCulture);
+                    TItem item = (TItem)LanguagePrimitives.ConvertTo(deserializedItem, typeof(TItem), CultureInfo.InvariantCulture);
                     newList.Add(item);
                 }
 
diff --git a/src/System.Management.Automation/utils/ObjectReader.cs b/src/System.Management.Automation/utils/ObjectReader.cs
index f06243ddd5b..b333ec25be2 100644
--- a/src/System.Management.Automation/utils/ObjectReader.cs
+++ b/src/System.Management.Automation/utils/ObjectReader.cs
@@ -483,12 +483,12 @@ private static Collection<PSObject> MakePSObjectCollection(
     /// commands concurrently.
     /// Only Read() operation is supported currently.
     /// </remarks>
-    internal class PSDataCollectionReader<DataStoreType, ReturnType>
-        : ObjectReaderBase<ReturnType>
+    internal class PSDataCollectionReader<T, TResult>
+        : ObjectReaderBase<TResult>
     {
         #region Private Data
 
-        private readonly PSDataCollectionEnumerator<DataStoreType> _enumerator;
+        private readonly PSDataCollectionEnumerator<T> _enumerator;
 
         #endregion
 
@@ -498,12 +498,12 @@ internal class PSDataCollectionReader<DataStoreType, ReturnType>
         /// </summary>
         /// <param name="stream">The stream to read.</param>
         /// <exception cref="ArgumentNullException">Thrown if the specified stream is null.</exception>
-        public PSDataCollectionReader(PSDataCollectionStream<DataStoreType> stream)
+        public PSDataCollectionReader(PSDataCollectionStream<T> stream)
             : base(stream)
         {
             System.Management.Automation.Diagnostics.Assert(stream.ObjectStore != null,
                 "Stream should have a valid data store");
-            _enumerator = (PSDataCollectionEnumerator<DataStoreType>)stream.ObjectStore.GetEnumerator();
+            _enumerator = (PSDataCollectionEnumerator<T>)stream.ObjectStore.GetEnumerator();
         }
 
         #endregion ctor
@@ -513,7 +513,7 @@ public PSDataCollectionReader(PSDataCollectionStream<DataStoreType> stream)
         /// </summary>
         /// <param name="count">The maximum number of objects to read.</param>
         /// <returns>The objects read.</returns>
-        public override Collection<ReturnType> Read(int count)
+        public override Collection<TResult> Read(int count)
         {
             throw new NotSupportedException();
         }
@@ -528,7 +528,7 @@ public override Collection<ReturnType> Read(int count)
         /// <remarks>
         /// This method blocks if the buffer is empty.
         /// </remarks>
-        public override ReturnType Read()
+        public override TResult Read()
         {
             object result = AutomationNull.Value;
             if (_enumerator.MoveNext())
@@ -544,7 +544,7 @@ public override ReturnType Read()
         /// </summary>
         /// <returns></returns>
         /// <remarks></remarks>
-        public override Collection<ReturnType> ReadToEnd()
+        public override Collection<TResult> ReadToEnd()
         {
             throw new NotSupportedException();
         }
@@ -554,7 +554,7 @@ public override Collection<ReturnType> ReadToEnd()
         /// </summary>
         /// <returns></returns>
         /// <remarks></remarks>
-        public override Collection<ReturnType> NonBlockingRead()
+        public override Collection<TResult> NonBlockingRead()
         {
             return NonBlockingRead(Int32.MaxValue);
         }
@@ -567,7 +567,7 @@ public override Collection<ReturnType> NonBlockingRead()
         /// <param name="maxRequested">
         /// Return no more than maxRequested objects.
         /// </param>
-        public override Collection<ReturnType> NonBlockingRead(int maxRequested)
+        public override Collection<TResult> NonBlockingRead(int maxRequested)
         {
             if (maxRequested < 0)
             {
@@ -576,31 +576,31 @@ public override Collection<ReturnType> NonBlockingRead(int maxRequested)
 
             if (maxRequested == 0)
             {
-                return new Collection<ReturnType>();
+                return new Collection<TResult>();
             }
 
-            Collection<ReturnType> results = new Collection<ReturnType>();
+            Collection<TResult> result = new Collection<TResult>();
             int readCount = maxRequested;
 
             while (readCount > 0)
             {
                 if (_enumerator.MoveNext(false))
                 {
-                    results.Add(ConvertToReturnType(_enumerator.Current));
+                    result.Add(ConvertToReturnType(_enumerator.Current));
                     continue;
                 }
 
                 break;
             }
 
-            return results;
+            return result;
         }
 
         /// <summary>
         /// This method is not supported.
         /// </summary>
         /// <returns></returns>
-        public override ReturnType Peek()
+        public override TResult Peek()
         {
             throw new NotSupportedException();
         }
@@ -617,12 +617,12 @@ protected override void Dispose(bool disposing)
             }
         }
 
-        private static ReturnType ConvertToReturnType(object inputObject)
+        private static TResult ConvertToReturnType(object inputObject)
         {
-            Type resultType = typeof(ReturnType);
+            Type resultType = typeof(TResult);
             if (typeof(PSObject) == resultType || typeof(object) == resultType)
             {
-                ReturnType result;
+                TResult result;
                 LanguagePrimitives.TryConvertTo(inputObject, out result);
                 return result;
             }
@@ -642,12 +642,12 @@ private static ReturnType ConvertToReturnType(object inputObject)
     /// commands concurrently.
     /// Only Read() operation is supported currently.
     /// </remarks>
-    internal class PSDataCollectionPipelineReader<DataStoreType, ReturnType>
-        : ObjectReaderBase<ReturnType>
+    internal class PSDataCollectionPipelineReader<T, TReturn>
+        : ObjectReaderBase<TReturn>
     {
         #region Private Data
 
-        private readonly PSDataCollection<DataStoreType> _datastore;
+        private readonly PSDataCollection<T> _datastore;
 
         #endregion Private Data
 
@@ -658,7 +658,7 @@ internal class PSDataCollectionPipelineReader<DataStoreType, ReturnType>
         /// <param name="stream">The stream to read.</param>
         /// <param name="computerName"></param>
         /// <param name="runspaceId"></param>
-        internal PSDataCollectionPipelineReader(PSDataCollectionStream<DataStoreType> stream,
+        internal PSDataCollectionPipelineReader(PSDataCollectionStream<T> stream,
             string computerName, Guid runspaceId)
             : base(stream)
         {
@@ -688,7 +688,7 @@ internal PSDataCollectionPipelineReader(PSDataCollectionStream<DataStoreType> st
         /// </summary>
         /// <param name="count">The maximum number of objects to read.</param>
         /// <returns>The objects read.</returns>
-        public override Collection<ReturnType> Read(int count)
+        public override Collection<TReturn> Read(int count)
         {
             throw new NotSupportedException();
         }
@@ -703,14 +703,14 @@ public override Collection<ReturnType> Read(int count)
         /// <remarks>
         /// This method blocks if the buffer is empty.
         /// </remarks>
-        public override ReturnType Read()
+        public override TReturn Read()
         {
             object result = AutomationNull.Value;
             if (_datastore.Count > 0)
             {
-                Collection<DataStoreType> resultCollection = _datastore.ReadAndRemove(1);
+                Collection<T> resultCollection = _datastore.ReadAndRemove(1);
 
-                // ReadAndRemove returns a Collection<DataStoreType> type but we
+                // ReadAndRemove returns a Collection<T> type but we
                 // just want the single object contained in the collection.
                 if (resultCollection.Count == 1)
                 {
@@ -726,7 +726,7 @@ public override ReturnType Read()
         /// </summary>
         /// <returns></returns>
         /// <remarks></remarks>
-        public override Collection<ReturnType> ReadToEnd()
+        public override Collection<TReturn> ReadToEnd()
         {
             throw new NotSupportedException();
         }
@@ -736,7 +736,7 @@ public override Collection<ReturnType> ReadToEnd()
         /// </summary>
         /// <returns></returns>
         /// <remarks></remarks>
-        public override Collection<ReturnType> NonBlockingRead()
+        public override Collection<TReturn> NonBlockingRead()
         {
             return NonBlockingRead(Int32.MaxValue);
         }
@@ -749,7 +749,7 @@ public override Collection<ReturnType> NonBlockingRead()
         /// <param name="maxRequested">
         /// Return no more than maxRequested objects.
         /// </param>
-        public override Collection<ReturnType> NonBlockingRead(int maxRequested)
+        public override Collection<TReturn> NonBlockingRead(int maxRequested)
         {
             if (maxRequested < 0)
             {
@@ -758,10 +758,10 @@ public override Collection<ReturnType> NonBlockingRead(int maxRequested)
 
             if (maxRequested == 0)
             {
-                return new Collection<ReturnType>();
+                return new Collection<TReturn>();
             }
 
-            Collection<ReturnType> results = new Collection<ReturnType>();
+            Collection<TReturn> results = new Collection<TReturn>();
             int readCount = maxRequested;
 
             while (readCount > 0)
@@ -783,7 +783,7 @@ public override Collection<ReturnType> NonBlockingRead(int maxRequested)
         /// This method is not supported.
         /// </summary>
         /// <returns></returns>
-        public override ReturnType Peek()
+        public override TReturn Peek()
         {
             throw new NotSupportedException();
         }
@@ -793,12 +793,12 @@ public override ReturnType Peek()
         /// </summary>
         /// <param name="inputObject">Input object to convert.</param>
         /// <returns>Input object converted to the specified return type.</returns>
-        private static ReturnType ConvertToReturnType(object inputObject)
+        private static TReturn ConvertToReturnType(object inputObject)
         {
-            Type resultType = typeof(ReturnType);
+            Type resultType = typeof(TReturn);
             if (typeof(PSObject) == resultType || typeof(object) == resultType)
             {
-                ReturnType result;
+                TReturn result;
                 LanguagePrimitives.TryConvertTo(inputObject, out result);
                 return result;
             }

From c3804e9777cf0456216f770d8a795b6290cef3b6 Mon Sep 17 00:00:00 2001
From: xtqqczze <xtqqczze@gmail.com>
Date: Mon, 21 Dec 2020 00:26:51 +0000
Subject: [PATCH 3/3] Remove unnecessary type argument

The type argument for the `struct Enumerator` is unnecessary, we can use the argument from the class declaration.
---
 .../engine/MshMemberInfo.cs                      | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/System.Management.Automation/engine/MshMemberInfo.cs b/src/System.Management.Automation/engine/MshMemberInfo.cs
index 9bbec9c4312..34a3a1f9ee6 100644
--- a/src/System.Management.Automation/engine/MshMemberInfo.cs
+++ b/src/System.Management.Automation/engine/MshMemberInfo.cs
@@ -4974,7 +4974,7 @@ internal override ReadOnlyPSMemberInfoCollection<T> Match(string name, PSMemberT
         /// <returns>The enumerator for this collection.</returns>
         public override IEnumerator<T> GetEnumerator()
         {
-            return new Enumerator<T>(this);
+            return new Enumerator(this);
         }
 
         internal override T FirstOrDefault(MemberNamePredicate predicate)
@@ -5028,17 +5028,17 @@ internal override T FirstOrDefault(MemberNamePredicate predicate)
         /// <summary>
         /// Enumerable for this class.
         /// </summary>
-        internal struct Enumerator<S> : IEnumerator<S> where S : PSMemberInfo
+        internal struct Enumerator : IEnumerator<T>
         {
-            private S _current;
+            private T _current;
             private int _currentIndex;
-            private readonly PSMemberInfoInternalCollection<S> _allMembers;
+            private readonly PSMemberInfoInternalCollection<T> _allMembers;
 
             /// <summary>
             /// Constructs this instance to enumerate over members.
             /// </summary>
             /// <param name="integratingCollection">Members we are enumerating.</param>
-            internal Enumerator(PSMemberInfoIntegratingCollection<S> integratingCollection)
+            internal Enumerator(PSMemberInfoIntegratingCollection<T> integratingCollection)
             {
                 using (PSObject.MemberResolution.TraceScope("Enumeration Start"))
                 {
@@ -5070,7 +5070,7 @@ public bool MoveNext()
             {
                 _currentIndex++;
 
-                S member = null;
+                T member = null;
                 while (_currentIndex < _allMembers.Count)
                 {
                     member = _allMembers[_currentIndex];
@@ -5096,7 +5096,7 @@ public bool MoveNext()
             /// Current PSMemberInfo in the enumeration.
             /// </summary>
             /// <exception cref="ArgumentException">For invalid arguments.</exception>
-            S IEnumerator<S>.Current
+            T IEnumerator<T>.Current
             {
                 get
                 {
@@ -5109,7 +5109,7 @@ S IEnumerator<S>.Current
                 }
             }
 
-            object IEnumerator.Current => ((IEnumerator<S>)this).Current;
+            object IEnumerator.Current => ((IEnumerator<T>)this).Current;
 
             void IEnumerator.Reset()
             {