Replace boxing ArrayLists in UIAutomationClientSideProviders (ClickablePoint) (#9430)

* replace boxing ArrayList with generic List<CPRect>

* make fields readonly

* rename "al" params as "list" params to reflect reality

* use pattern matching where applicable

* add readonly constraint to CPRect bool methods

* adjust comments from "Program" to "Progman"

* Resolve post-merge issues

Author: h3xds1nz

src/Microsoft.DotNet.Wpf/src/UIAutomation/UIAutomationClientSideProviders/MS/Internal/AutomationProxies/ClickablePoint.cs

@@ -1,29 +1,29 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
 
-using System;
-using System.Collections;
+using System.Collections.Generic;
 using MS.Win32;
+using System;
 
 namespace MS.Internal.AutomationProxies
 {
     static internal class ClickablePoint
     {
         /// <summary>
-        /// Static Constructor. Retrieve and keeps the hwnd for "Program"
-        /// The Windows Rectangle for "Program"  is the union for the real
+        /// Static Constructor. Retrieve and keeps the hwnd for "Progman"
+        /// The Windows Rectangle for "Progman" is the union for the real
         /// Estate for all the monitors.
         /// </summary>
         static ClickablePoint()
         {
+            _hwndDesktop = UnsafeNativeMethods.GetDesktopWindow();
             _hwndProgman = Misc.FindWindowEx(IntPtr.Zero, IntPtr.Zero, "Progman", null);
             if (_hwndProgman == IntPtr.Zero)
             {
                 _hwndProgman = _hwndDesktop;
             }
         }
-        
+
         //------------------------------------------------------
         //
         //  Internal Methods
@@ -46,11 +46,11 @@ static ClickablePoint()
         /// But makes it a bit more efficent.
         /// </summary>
         /// <param name="hwnd">Window Handle</param>
-        /// <param name="alIn">Input list of Rectangles to check GetPoint against</param>
-        /// <param name="alOut">Output list of Rectangles after the exclusion test</param>
+        /// <param name="listIn">Input list of Rectangles to check GetPoint against</param>
+        /// <param name="listOut">Output list of Rectangles after the exclusion test</param>
         /// <param name="pt">Clickable Point</param>
         /// <returns>True if there is a clickable in ro</returns>
-        static internal bool GetPoint(IntPtr hwnd, ArrayList alIn, ArrayList alOut, ref NativeMethods.Win32Point pt)
+        static internal bool GetPoint(IntPtr hwnd, List<CPRect> listIn, List<CPRect> listOut, ref NativeMethods.Win32Point pt)
         {
             IntPtr hwndStart = hwnd;
             IntPtr hwndCurrent = hwnd;
@@ -61,7 +61,7 @@ static internal bool GetPoint(IntPtr hwnd, ArrayList alIn, ArrayList alOut, ref
             {
                 // For siblings, the element bounding rectangle must not be covered by the
                 // bounding rect of its siblings
-                if (!ClickableInRect(hwnd, ref pt, true, alIn, alOut))
+                if (!ClickableInRect(hwnd, ref pt, true, listIn, listOut))
                 {
                     return false;
                 }
@@ -103,7 +103,7 @@ static internal bool GetPoint(IntPtr hwnd, ArrayList alIn, ArrayList alOut, ref
                     // Substitute the Desktop with the Progman hwnd for clipping calculation
                     IntPtr hwndClip = hwnd == _hwndDesktop ? _hwndProgman : hwnd;
 
-                    if (!ClickableInRect(hwndClip, ref pt, false, alIn, alOut))
+                    if (!ClickableInRect(hwndClip, ref pt, false, listIn, listOut))
                     {
                         return false;
                     }
@@ -115,7 +115,7 @@ static internal bool GetPoint(IntPtr hwnd, ArrayList alIn, ArrayList alOut, ref
 
                 // For siblings, the element bounding rectangle must not be covered by the
                 // bounding rect of its siblings
-                if (!ClickableInRect(hwnd, ref pt, true, alIn, alOut))
+                if (!ClickableInRect(hwnd, ref pt, true, listIn, listOut))
                 {
                     return false;
                 }
@@ -131,9 +131,9 @@ static internal bool GetPoint(IntPtr hwnd, ArrayList alIn, ArrayList alOut, ref
         /// be performed. There is no easy way out.
         /// </summary>
         /// <param name="fragment"></param>
-        /// <param name="alIn"></param>
-        /// <param name="alOut"></param>
-        internal static void ExcludeChildren(ProxyFragment fragment, ArrayList alIn, ArrayList alOut)
+        /// <param name="listIn"></param>
+        /// <param name="listOut"></param>
+        internal static void ExcludeChildren(ProxyFragment fragment, List<CPRect> listIn, List<CPRect> listOut)
         {
             // First go through all the children to exclude whatever is on top
             for (ProxySimple simple = fragment.GetFirstChild(); simple != null; simple = fragment.GetNextSibling(simple))
@@ -145,18 +145,18 @@ internal static void ExcludeChildren(ProxyFragment fragment, ArrayList alIn, Arr
                 }
 
                 // Copy the output bits
-                alIn.Clear();
-                alIn.AddRange(alOut);
+                listIn.Clear();
+                listIn.AddRange(listOut);
 
                 NativeMethods.Win32Rect rc = new NativeMethods.Win32Rect(simple.BoundingRectangle);
                 CPRect rcp = new CPRect(ref rc, false);
 
-                ClickablePoint.SplitRect(alIn, ref rcp, alOut, true);
+                SplitRect(listIn, ref rcp, listOut, true);
 
                 // recurse on the children
-                if (simple is ProxyFragment)
+                if (simple is ProxyFragment proxyFrag)
                 {
-                    ExcludeChildren((ProxyFragment)simple, alIn, alOut);
+                    ExcludeChildren(proxyFrag, listIn, listOut);
                 }
             }
         }
@@ -206,13 +206,13 @@ internal CPRect(ref NativeMethods.Win32Rect rc, bool fRiAsInsideRect)
             }
 
             // return true if the 2 rectangle intersects
-            internal bool Intersect(ref CPRect ri)
+            internal readonly bool Intersect(ref CPRect ri)
             {
                 return !(_top >= ri._bottom || ri._top >= _bottom || _left >= ri._right || ri._left >= _right);
             }
 
             // return true if ri completely covers this
-            internal bool Overlap(ref CPRect ri)
+            internal readonly bool Overlap(ref CPRect ri)
             {
                 return (ri._left <= _left && ri._right >= _right && ri._top <= _top && ri._bottom >= _bottom);
             }
@@ -228,7 +228,7 @@ internal bool Overlap(ref CPRect ri)
 
         #region Private Methods
 
-        private static bool ClickableInRect(IntPtr hwnd, ref NativeMethods.Win32Point pt, bool fRiAsInsideRect, ArrayList alIn, ArrayList alOut)
+        private static bool ClickableInRect(IntPtr hwnd, ref NativeMethods.Win32Point pt, bool fRiAsInsideRect, List<CPRect> listIn, List<CPRect> listOut)
         {
             if (!SafeNativeMethods.IsWindowVisible(hwnd))
             {
@@ -270,13 +270,13 @@ private static bool ClickableInRect(IntPtr hwnd, ref NativeMethods.Win32Point pt
             }
 
             // Copy the output bits
-            alIn.Clear();
-            alIn.AddRange(alOut);
+            listIn.Clear();
+            listIn.AddRange(listOut);
 
             CPRect rcp = new CPRect(ref rc, false);
 
-            ClickablePoint.SplitRect(alIn, ref rcp, alOut, fRiAsInsideRect);
-            if (!GetClickablePoint(alOut, out pt.x, out pt.y))
+            SplitRect(listIn, ref rcp, listOut, fRiAsInsideRect);
+            if (!GetClickablePoint(listOut, out pt.x, out pt.y))
             {
                 return false;
             }
@@ -294,9 +294,9 @@ private static bool ClickableInRect(IntPtr hwnd, ref NativeMethods.Win32Point pt
         /// <param name="ri">Inside Rectangle</param>
         /// <param name="left">Left Margin for the resulting rectangles</param>
         /// <param name="right">Right Margin for the resulting rectangles</param>
-        /// <param name="alRect">Array of resulting rectangles</param>
+        /// <param name="rectList">Array of resulting rectangles</param>
         /// <param name="fRiAsInsideRect">Covered flag</param>
-        static private void SplitVertical(ref CPRect ro, ref CPRect ri, int left, int right, ArrayList alRect, bool fRiAsInsideRect)
+        static private void SplitVertical(ref CPRect ro, ref CPRect ri, int left, int right, List<CPRect> rectList, bool fRiAsInsideRect)
         {
             // bottom clip
             if (ri._bottom > ro._bottom)
@@ -309,21 +309,21 @@ static private void SplitVertical(ref CPRect ro, ref CPRect ri, int left, int ri
 
             if (bottom > top)
             {
-                alRect.Add(new CPRect(left, top, right, bottom, ro._fNotCovered));
+                rectList.Add(new CPRect(left, top, right, bottom, ro._fNotCovered));
                 top = bottom;
             }
 
             bottom = ri._bottom;
             if (bottom > top)
             {
-                alRect.Add(new CPRect(left, top, right, bottom, ro._fNotCovered & fRiAsInsideRect));
+                rectList.Add(new CPRect(left, top, right, bottom, ro._fNotCovered & fRiAsInsideRect));
                 top = bottom;
             }
 
             bottom = ro._bottom;
             if (bottom > top)
             {
-                alRect.Add(new CPRect(left, top, right, bottom, ro._fNotCovered));
+                rectList.Add(new CPRect(left, top, right, bottom, ro._fNotCovered));
             }
         }
 
@@ -350,20 +350,20 @@ static private void SplitVertical(ref CPRect ro, ref CPRect ri, int left, int ri
         /// <param name="ri">Inside Rectangle</param>
         /// <param name="alRect">Collection of resulting rectangles</param>
         /// <param name="fRiAsInsideRect"></param>
-        static private void SplitRect(ref CPRect ro, CPRect ri, ArrayList alRect, bool fRiAsInsideRect)
+        static private void SplitRect(ref CPRect ro, CPRect ri, List<CPRect> rectList, bool fRiAsInsideRect)
         {
             // If ri is fully outside easy way out.
             if (!ro._fNotCovered || !ro.Intersect(ref ri))
             {
                 ro._fNotCovered &= fRiAsInsideRect;
-                alRect.Add(ro);
+                rectList.Add(ro);
                 return;
             }
 
             if (ro.Overlap(ref ri))
             {
                 ro._fNotCovered &= !fRiAsInsideRect;
-                alRect.Add(ro);
+                rectList.Add(ro);
                 return;
             }
 
@@ -384,21 +384,21 @@ static private void SplitRect(ref CPRect ro, CPRect ri, ArrayList alRect, bool f
 
             if (right > left)
             {
-                alRect.Add(new CPRect(left, ro._top, right, ro._bottom, ro._fNotCovered & fRiAsInsideRect));
+                rectList.Add(new CPRect(left, ro._top, right, ro._bottom, ro._fNotCovered & fRiAsInsideRect));
                 left = right;
             }
 
             right = ri._right;
             if (right > left)
             {
-                SplitVertical(ref ro, ref ri, left, right, alRect, !fRiAsInsideRect);
+                SplitVertical(ref ro, ref ri, left, right, rectList, !fRiAsInsideRect);
                 left = right;
             }
 
             right = ro._right;
             if (right > left)
             {
-                alRect.Add(new CPRect(left, ro._top, right, ro._bottom, ro._fNotCovered & fRiAsInsideRect));
+                rectList.Add(new CPRect(left, ro._top, right, ro._bottom, ro._fNotCovered & fRiAsInsideRect));
             }
         }
 
@@ -408,19 +408,19 @@ static private void SplitRect(ref CPRect ro, CPRect ri, ArrayList alRect, bool f
         /// marked as covered or not.
         /// 
         /// </summary>
-        /// <param name="alIn">List of input rectangle</param>
+        /// <param name="listIn">List of input rectangle</param>
         /// <param name="ri">Overlapping Rectangle</param>
-        /// <param name="alOut">New sets of reactangle</param>
+        /// <param name="listOut">New sets of reactangle</param>
         /// <param name="fRiAsInsideRect">Input Rectangle is rectangle covering alIn Rects or everything
         ///                               outside of ri must be marked as covered</param>
-        static private void SplitRect(ArrayList alIn, ref CPRect ri, ArrayList alOut, bool fRiAsInsideRect)
+        static private void SplitRect(List<CPRect> listIn, ref CPRect ri, List<CPRect> listOut, bool fRiAsInsideRect)
         {
-            alOut.Clear();
-            for (int i = 0, c = alIn.Count; i < c; i++)
+            listOut.Clear();
+            for (int i = 0; i < listIn.Count; i++)
             {
-                CPRect ro = (CPRect)alIn[i];
+                CPRect ro = listIn[i];
 
-                SplitRect(ref ro, ri, alOut, fRiAsInsideRect);
+                SplitRect(ref ro, ri, listOut, fRiAsInsideRect);
             }
         }
 
@@ -429,15 +429,15 @@ static private void SplitRect(ArrayList alIn, ref CPRect ri, ArrayList alOut, bo
         /// Goes through the list of rectangle, stops on the first rectangle that is not covered
         /// and returns the mid point
         /// </summary>
-        /// <param name="al">list of ractangle</param>
+        /// <param name="rectList">list of ractangle</param>
         /// <param name="x">X coordinate for a clickable point</param>
         /// <param name="y">Y coordinate for a clickable point</param>
         /// <returns>Clickable point found</returns>
-        static private bool GetClickablePoint(ArrayList al, out int x, out int y)
+        static private bool GetClickablePoint(List<CPRect> rectList, out int x, out int y)
         {
-            for (int i = 0, c = al.Count; i < c; i++)
+            for (int i = 0; i < rectList.Count; i++)
             {
-                CPRect r = (CPRect)al[i];
+                CPRect r = rectList[i];
 
                 if (r._fNotCovered == true && (r._right - r._left) * (r._bottom - r._top) > 0)
                 {
@@ -457,16 +457,16 @@ static private bool GetClickablePoint(ArrayList al, out int x, out int y)
         }
 
         #endregion
-        
+
         #region Private fields
-        
+
         // Top level Desktop window
-        private static IntPtr _hwndDesktop = UnsafeNativeMethods.GetDesktopWindow();
+        private static readonly IntPtr _hwndDesktop;
 
-        /// The WindowsRect for "Program" is the union for the real
+        /// The WindowsRect for "Progman" is the union for the real
         /// estate for all the monitors. Instead of doing clipping against the root of the hwnd
         /// tree that is the desktop. The last clipping should be done against the Progman hwnd.
-        private static IntPtr _hwndProgman;
+        private static readonly IntPtr _hwndProgman;
 
         #endregion Private fields
 

src/Microsoft.DotNet.Wpf/src/UIAutomation/UIAutomationClientSideProviders/MS/Internal/AutomationProxies/ProxySimple.cs

@@ -29,7 +29,7 @@
 using System;
 using System.Windows.Automation;
 using System.Windows.Automation.Provider;
-using System.Collections;
+using System.Collections.Generic;
 using Accessibility;
 using System.Windows;
 using MS.Win32;
@@ -585,22 +585,21 @@ internal bool GetClickablePoint(out NativeMethods.Win32Point pt, bool fClipClien
                 }
             }
 
-            ArrayList alIn = new ArrayList(100);
-            ArrayList alOut = new ArrayList(100);
+            List<ClickablePoint.CPRect> listIn = new(100);
+            List<ClickablePoint.CPRect> listOut = new(100);
 
             // Get the mid point to start with
             pt.x = (rcItem.right - 1 + rcItem.left) / 2;
             pt.y = (rcItem.bottom - 1 + rcItem.top) / 2;
-            alOut.Add(new ClickablePoint.CPRect(ref rcItem, true));
+            listOut.Add(new ClickablePoint.CPRect(ref rcItem, true));
 
             // First go through all the children to exclude whatever is on top
-            ProxyFragment proxyFrag = this as ProxyFragment;
-            if (proxyFrag != null)
+            if (this is ProxyFragment proxyFrag)
             {
-                ClickablePoint.ExcludeChildren(proxyFrag, alIn, alOut);
+                ClickablePoint.ExcludeChildren(proxyFrag, listIn, listOut);
             }
 
-            return ClickablePoint.GetPoint(_hwnd, alIn, alOut, ref pt);
+            return ClickablePoint.GetPoint(_hwnd, listIn, listOut, ref pt);
         }
 
         internal string GetAccessibleName(int item)