Simplify the sorting of DataFlowAnalysis results

src/Compilers/CSharp/Portable/FlowAnalysis/CSharpDataFlowAnalysis.cs

@@ -53,7 +53,7 @@ public override ImmutableArray<ISymbol> VariablesDeclared
                 if (_variablesDeclared.IsDefault)
                 {
                     var result = Succeeded
-                        ? ((IEnumerable<ISymbol>)VariablesDeclaredWalker.Analyze(_context.Compilation, _context.Member, _context.BoundNode, _context.FirstInRegion, _context.LastInRegion)).Sorted()
+                        ? Sort(VariablesDeclaredWalker.Analyze(_context.Compilation, _context.Member, _context.BoundNode, _context.FirstInRegion, _context.LastInRegion))
                         : ImmutableArray<ISymbol>.Empty;
                     ImmutableInterlocked.InterlockedInitialize(ref _variablesDeclared, result);
                 }
@@ -89,7 +89,7 @@ public override ImmutableArray<ISymbol> DataFlowsIn
                 {
                     _succeeded = !_context.Failed;
                     var result = _context.Failed ? ImmutableArray<ISymbol>.Empty :
-                        ((IEnumerable<ISymbol>)DataFlowsInWalker.Analyze(_context.Compilation, _context.Member, _context.BoundNode, _context.FirstInRegion, _context.LastInRegion, UnassignedVariables, UnassignedVariableAddressOfSyntaxes, out _succeeded)).Sorted();
+                        Sort(DataFlowsInWalker.Analyze(_context.Compilation, _context.Member, _context.BoundNode, _context.FirstInRegion, _context.LastInRegion, UnassignedVariables, UnassignedVariableAddressOfSyntaxes, out _succeeded));
                     ImmutableInterlocked.InterlockedInitialize(ref _dataFlowsIn, result);
                 }
 
@@ -109,7 +109,7 @@ public override ImmutableArray<ISymbol> DataFlowsOut
                 if (_dataFlowsOut == null)
                 {
                     var result = Succeeded
-                        ? ((IEnumerable<ISymbol>)DataFlowsOutWalker.Analyze(_context.Compilation, _context.Member, _context.BoundNode, _context.FirstInRegion, _context.LastInRegion, UnassignedVariables, _dataFlowsIn)).Sorted()
+                        ? Sort(DataFlowsOutWalker.Analyze(_context.Compilation, _context.Member, _context.BoundNode, _context.FirstInRegion, _context.LastInRegion, UnassignedVariables, _dataFlowsIn))
                         : ImmutableArray<ISymbol>.Empty;
                     ImmutableInterlocked.InterlockedInitialize(ref _dataFlowsOut, result);
                 }
@@ -128,7 +128,7 @@ public override ImmutableArray<ISymbol> AlwaysAssigned
                 if (_alwaysAssigned == null)
                 {
                     var result = Succeeded
-                        ? ((IEnumerable<ISymbol>)AlwaysAssignedWalker.Analyze(_context.Compilation, _context.Member, _context.BoundNode, _context.FirstInRegion, _context.LastInRegion)).Sorted()
+                        ? Sort(AlwaysAssignedWalker.Analyze(_context.Compilation, _context.Member, _context.BoundNode, _context.FirstInRegion, _context.LastInRegion))
                         : ImmutableArray<ISymbol>.Empty;
                     ImmutableInterlocked.InterlockedInitialize(ref _alwaysAssigned, result);
                 }
@@ -203,7 +203,7 @@ public override ImmutableArray<ISymbol> WrittenOutside
 
         private void AnalyzeReadWrite()
         {
-            ImmutableArray<ISymbol> readInside, writtenInside, readOutside, writtenOutside, captured, unsafeAddressTaken;
+            ImmutableArray<Symbol> readInside, writtenInside, readOutside, writtenOutside, captured, unsafeAddressTaken;
             if (Succeeded)
             {
                 ReadWriteWalker.Analyze(_context.Compilation, _context.Member, _context.BoundNode, _context.FirstInRegion, _context.LastInRegion, UnassignedVariableAddressOfSyntaxes,
@@ -213,15 +213,15 @@ private void AnalyzeReadWrite()
             }
             else
             {
-                readInside = writtenInside = readOutside = writtenOutside = captured = unsafeAddressTaken = ImmutableArray<ISymbol>.Empty;
+                readInside = writtenInside = readOutside = writtenOutside = captured = unsafeAddressTaken = ImmutableArray<Symbol>.Empty;
             }
 
-            ImmutableInterlocked.InterlockedInitialize(ref _readInside, readInside.Sorted());
-            ImmutableInterlocked.InterlockedInitialize(ref _writtenInside, writtenInside.Sorted());
-            ImmutableInterlocked.InterlockedInitialize(ref _readOutside, readOutside.Sorted());
-            ImmutableInterlocked.InterlockedInitialize(ref _writtenOutside, writtenOutside.Sorted());
-            ImmutableInterlocked.InterlockedInitialize(ref _captured, captured.Sorted());
-            ImmutableInterlocked.InterlockedInitialize(ref _unsafeAddressTaken, unsafeAddressTaken.Sorted());
+            ImmutableInterlocked.InterlockedInitialize(ref _readInside, Sort(readInside));
+            ImmutableInterlocked.InterlockedInitialize(ref _writtenInside, Sort(writtenInside));
+            ImmutableInterlocked.InterlockedInitialize(ref _readOutside, Sort(readOutside));
+            ImmutableInterlocked.InterlockedInitialize(ref _writtenOutside, Sort(writtenOutside));
+            ImmutableInterlocked.InterlockedInitialize(ref _captured, Sort(captured));
+            ImmutableInterlocked.InterlockedInitialize(ref _unsafeAddressTaken, Sort(unsafeAddressTaken));
         }
 
         /// <summary>
@@ -293,25 +293,13 @@ public sealed override bool Succeeded
                 return _succeeded.Value;
             }
         }
-    }
-
-    static class Sorter
-    {
-        class LexicalISymbolComparer : IComparer<ISymbol>
-        {
-            internal static LexicalISymbolComparer Instance = new LexicalISymbolComparer();
-            public int Compare(ISymbol x, ISymbol y)
-            {
-                return LexicalOrderSymbolComparer.Instance.Compare((Symbol)x, (Symbol)y);
-            }
-        }
 
-        internal static ImmutableArray<ISymbol> Sorted(this IEnumerable<ISymbol> data)
+        internal static ImmutableArray<ISymbol> Sort(IEnumerable<Symbol> data)
         {
-            var builder = ArrayBuilder<ISymbol>.GetInstance();
+            var builder = ArrayBuilder<Symbol>.GetInstance();
             builder.AddRange(data);
-            builder.Sort(LexicalISymbolComparer.Instance);
-            return builder.ToImmutableAndFree();
+            builder.Sort(LexicalOrderSymbolComparer.Instance);
+            return builder.ToImmutableAndFree().As<ISymbol>();
         }
     }
 }

src/Compilers/CSharp/Portable/FlowAnalysis/ReadWriteWalker.cs

@@ -14,12 +14,12 @@ internal class ReadWriteWalker : AbstractRegionDataFlowPass
     {
         internal static void Analyze(
             CSharpCompilation compilation, Symbol member, BoundNode node, BoundNode firstInRegion, BoundNode lastInRegion, HashSet<PrefixUnaryExpressionSyntax> unassignedVariableAddressOfSyntaxes,
-            out ImmutableArray<ISymbol> readInside,
-            out ImmutableArray<ISymbol> writtenInside,
-            out ImmutableArray<ISymbol> readOutside,
-            out ImmutableArray<ISymbol> writtenOutside,
-            out ImmutableArray<ISymbol> captured,
-            out ImmutableArray<ISymbol> unsafeAddressTaken)
+            out ImmutableArray<Symbol> readInside,
+            out ImmutableArray<Symbol> writtenInside,
+            out ImmutableArray<Symbol> readOutside,
+            out ImmutableArray<Symbol> writtenOutside,
+            out ImmutableArray<Symbol> captured,
+            out ImmutableArray<Symbol> unsafeAddressTaken)
         {
             var walker = new ReadWriteWalker(compilation, member, node, firstInRegion, lastInRegion, unassignedVariableAddressOfSyntaxes);
             try
@@ -28,17 +28,17 @@ internal class ReadWriteWalker : AbstractRegionDataFlowPass
                 walker.Analyze(ref badRegion);
                 if (badRegion)
                 {
-                    readInside = writtenInside = readOutside = writtenOutside = captured = unsafeAddressTaken = ImmutableArray<ISymbol>.Empty;
+                    readInside = writtenInside = readOutside = writtenOutside = captured = unsafeAddressTaken = ImmutableArray<Symbol>.Empty;
                 }
                 else
                 {
-                    readInside = ((IEnumerable<ISymbol>)walker._readInside).ToImmutableArray();
-                    writtenInside = ((IEnumerable<ISymbol>)walker._writtenInside).ToImmutableArray();
-                    readOutside = ((IEnumerable<ISymbol>)walker._readOutside).ToImmutableArray();
-                    writtenOutside = ((IEnumerable<ISymbol>)walker._writtenOutside).ToImmutableArray();
+                    readInside = walker._readInside.ToImmutableArray();
+                    writtenInside = walker._writtenInside.ToImmutableArray();
+                    readOutside = walker._readOutside.ToImmutableArray();
+                    writtenOutside = walker._writtenOutside.ToImmutableArray();
 
-                    captured = ((IEnumerable<ISymbol>)walker.GetCaptured()).ToImmutableArray();
-                    unsafeAddressTaken = ((IEnumerable<ISymbol>)walker.GetUnsafeAddressTaken()).ToImmutableArray();
+                    captured = walker.GetCaptured().ToImmutableArray();
+                    unsafeAddressTaken = walker.GetUnsafeAddressTaken().ToImmutableArray();
                 }
             }
             finally

src/Compilers/VisualBasic/Portable/Analysis/FlowAnalysis/ReadWriteWalker.vb

@@ -15,22 +15,22 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
         Inherits AbstractRegionDataFlowPass
 
         Friend Overloads Shared Sub Analyze(info As FlowAnalysisInfo, region As FlowAnalysisRegionInfo,
-                                            ByRef readInside As ImmutableArray(Of ISymbol),
-                                            ByRef writtenInside As ImmutableArray(Of ISymbol),
-                                            ByRef readOutside As ImmutableArray(Of ISymbol),
-                                            ByRef writtenOutside As ImmutableArray(Of ISymbol),
-                                            ByRef captured As ImmutableArray(Of ISymbol))
+                                            ByRef readInside As ImmutableArray(Of Symbol),
+                                            ByRef writtenInside As ImmutableArray(Of Symbol),
+                                            ByRef readOutside As ImmutableArray(Of Symbol),
+                                            ByRef writtenOutside As ImmutableArray(Of Symbol),
+                                            ByRef captured As ImmutableArray(Of Symbol))
 
             Dim walker = New ReadWriteWalker(info, region)
             Try
                 If walker.Analyze() Then
-                    readInside = walker.readInside.Cast(Of ISymbol).ToImmutableArray()
-                    writtenInside = walker.writtenInside.Cast(Of ISymbol).ToImmutableArray()
-                    readOutside = walker.readOutside.Cast(Of ISymbol).ToImmutableArray()
-                    writtenOutside = walker.writtenOutside.Cast(Of ISymbol).ToImmutableArray()
-                    captured = walker.captured.Cast(Of ISymbol).ToImmutableArray()
+                    readInside = walker.readInside.ToImmutableArray()
+                    writtenInside = walker.writtenInside.ToImmutableArray()
+                    readOutside = walker.readOutside.ToImmutableArray()
+                    writtenOutside = walker.writtenOutside.ToImmutableArray()
+                    captured = walker.captured.ToImmutableArray()
                 Else
-                    readInside = ImmutableArray(Of ISymbol).Empty
+                    readInside = ImmutableArray(Of Symbol).Empty
                     writtenInside = readInside
                     readOutside = readInside
                     writtenOutside = readInside

src/Compilers/VisualBasic/Portable/Analysis/FlowAnalysis/VisualBasicDataFlowAnalysis.vb

@@ -46,7 +46,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             Get
                 If _variablesDeclared.IsDefault Then
                     Dim result = If(Me._context.Failed, ImmutableArray(Of ISymbol).Empty,
-                                    DirectCast(VariablesDeclaredWalker.Analyze(_context.AnalysisInfo, _context.RegionInfo), IEnumerable(Of ISymbol)).Sorted())
+                                    Sort(VariablesDeclaredWalker.Analyze(_context.AnalysisInfo, _context.RegionInfo)))
                     ImmutableInterlocked.InterlockedCompareExchange(_variablesDeclared, result, Nothing)
                 End If
                 Return _variablesDeclared
@@ -72,7 +72,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                 If _dataFlowsIn.IsDefault Then
                     Me._succeeded = Not Me._context.Failed
                     Dim result = If(Me._context.Failed, ImmutableArray(Of ISymbol).Empty,
-                                    DirectCast(DataFlowsInWalker.Analyze(_context.AnalysisInfo, _context.RegionInfo, UnassignedVariables, _succeeded, _invalidRegionDetected), IEnumerable(Of ISymbol)).Sorted())
+                                    Sort(DataFlowsInWalker.Analyze(_context.AnalysisInfo, _context.RegionInfo, UnassignedVariables, _succeeded, _invalidRegionDetected)))
                     ImmutableInterlocked.InterlockedCompareExchange(_dataFlowsIn, result.ToImmutableArray(), Nothing)
                 End If
                 Return _dataFlowsIn
@@ -87,7 +87,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                 Dim discarded = DataFlowsIn
                 If _dataFlowsOut.IsDefault Then
                     Dim result = If(Me._context.Failed, ImmutableArray(Of ISymbol).Empty,
-                                    DirectCast(DataFlowsOutWalker.Analyze(_context.AnalysisInfo, _context.RegionInfo, UnassignedVariables, _dataFlowsIn), IEnumerable(Of ISymbol)).Sorted())
+                                    Sort(DataFlowsOutWalker.Analyze(_context.AnalysisInfo, _context.RegionInfo, UnassignedVariables, _dataFlowsIn)))
                     ImmutableInterlocked.InterlockedCompareExchange(_dataFlowsOut, result, Nothing)
                 End If
                 Return _dataFlowsOut
@@ -101,7 +101,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             Get
                 If _alwaysAssigned.IsDefault Then
                     Dim result = If(Me._context.Failed, ImmutableArray(Of ISymbol).Empty,
-                                    DirectCast(AlwaysAssignedWalker.Analyze(_context.AnalysisInfo, _context.RegionInfo), IEnumerable(Of ISymbol)).Sorted())
+                                    Sort(AlwaysAssignedWalker.Analyze(_context.AnalysisInfo, _context.RegionInfo)))
                     ImmutableInterlocked.InterlockedCompareExchange(_alwaysAssigned, result, Nothing)
                 End If
                 Return _alwaysAssigned
@@ -157,14 +157,14 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
         End Property
 
         Private Sub AnalyzeReadWrite()
-            Dim readInside As ImmutableArray(Of ISymbol) = Nothing
-            Dim writtenInside As ImmutableArray(Of ISymbol) = Nothing
-            Dim readOutside As ImmutableArray(Of ISymbol) = Nothing
-            Dim writtenOutside As ImmutableArray(Of ISymbol) = Nothing
-            Dim captured As ImmutableArray(Of ISymbol) = Nothing
+            Dim readInside As ImmutableArray(Of Symbol) = Nothing
+            Dim writtenInside As ImmutableArray(Of Symbol) = Nothing
+            Dim readOutside As ImmutableArray(Of Symbol) = Nothing
+            Dim writtenOutside As ImmutableArray(Of Symbol) = Nothing
+            Dim captured As ImmutableArray(Of Symbol) = Nothing
 
             If Not Me.Succeeded Then
-                readInside = ImmutableArray(Of ISymbol).Empty
+                readInside = ImmutableArray(Of Symbol).Empty
                 writtenInside = readInside
                 readOutside = readInside
                 writtenOutside = readInside
@@ -180,11 +180,11 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                     captured:=captured)
             End If
 
-            ImmutableInterlocked.InterlockedCompareExchange(Me._readInside, readInside.Sorted(), Nothing)
-            ImmutableInterlocked.InterlockedCompareExchange(Me._writtenInside, writtenInside.Sorted(), Nothing)
-            ImmutableInterlocked.InterlockedCompareExchange(Me._readOutside, readOutside.Sorted(), Nothing)
-            ImmutableInterlocked.InterlockedCompareExchange(Me._writtenOutside, writtenOutside.Sorted(), Nothing)
-            ImmutableInterlocked.InterlockedCompareExchange(Me._captured, captured.Sorted(), Nothing)
+            ImmutableInterlocked.InterlockedCompareExchange(Me._readInside, Sort(readInside), Nothing)
+            ImmutableInterlocked.InterlockedCompareExchange(Me._writtenInside, Sort(writtenInside), Nothing)
+            ImmutableInterlocked.InterlockedCompareExchange(Me._readOutside, Sort(readOutside), Nothing)
+            ImmutableInterlocked.InterlockedCompareExchange(Me._writtenOutside, Sort(writtenOutside), Nothing)
+            ImmutableInterlocked.InterlockedCompareExchange(Me._captured, Sort(captured), Nothing)
         End Sub
 
         ''' <summary>
@@ -222,24 +222,13 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                 Return ImmutableArray(Of ISymbol).Empty
             End Get
         End Property
-    End Class
 
-    Friend Module Sorter
-        Class LexicalISymbolComparer
-            Implements IComparer(Of ISymbol)
-            Friend Shared Instance As LexicalISymbolComparer = New LexicalISymbolComparer()
-            Public Function Compare(x As ISymbol, y As ISymbol) As Integer Implements IComparer(Of ISymbol).Compare
-                Return LexicalOrderSymbolComparer.Instance.Compare(CType(x, Symbol), CType(y, Symbol))
-            End Function
-        End Class
-
-        <Runtime.CompilerServices.Extension>
-        Friend Function Sorted(data As IEnumerable(Of ISymbol)) As ImmutableArray(Of ISymbol)
-            Dim builder = ArrayBuilder(Of ISymbol).GetInstance()
+        Friend Function Sort(data As IEnumerable(Of Symbol)) As ImmutableArray(Of ISymbol)
+            Dim builder = ArrayBuilder(Of Symbol).GetInstance()
             builder.AddRange(data)
-            builder.Sort(LexicalISymbolComparer.Instance)
-            Return builder.ToImmutableAndFree()
+            builder.Sort(LexicalOrderSymbolComparer.Instance)
+            Return builder.ToImmutableAndFree().As(Of ISymbol)()
         End Function
-    End Module
+    End Class
 
 End Namespace