Perform exceptions path analysis for all flow analyses

Fixes #5199
Fixes #5160

We already had implementation and option based support to perform exception path analysis to handle all operations that can potentially throw an exception, and hence need flow analysis data at the point of operation to be merged with analysis data at start of reachable catch blocks from that operation. However, we were only performing this analysis post pass when flow analysis is looking at exceptions data. Now we do it for all analysis as this is required for more accurate input analysis data at start of catch and finally blocks.
NOTE: Fixing this issue led to an assert firing in CodeAnalysis dataflow operation visitor for an existing unit test, which has also been fixed in this PR

Author: mavasani

src/Utilities/FlowAnalysis/FlowAnalysis/Analysis/CopyAnalysis/CopyAnalysis.CopyDataFlowOperationVisitor.cs

@@ -397,9 +397,9 @@ protected override void UpdateValuesForAnalysisData(CopyAnalysisData targetAnaly
                         continue;
                     }
 
+                    var existingValue = targetAnalysisData[key];
                     if (CurrentAnalysisData.TryGetValue(key, out var newValue))
                     {
-                        var existingValue = targetAnalysisData[key];
                         if (newValue.AnalysisEntities.Count == 1)
                         {
                             if (existingValue.AnalysisEntities.Count == 1)
@@ -423,6 +423,23 @@ protected override void UpdateValuesForAnalysisData(CopyAnalysisData targetAnaly
 
                         processedEntities.AddRange(newValue.AnalysisEntities);
                     }
+                    else
+                    {
+                        var entitiesToExclude = existingValue.AnalysisEntities.Where(e => !CurrentAnalysisData.HasAbstractValue(e));
+                        var excludedCount = 0;
+                        foreach (var entity in entitiesToExclude)
+                        {
+                            targetAnalysisData.RemoveEntries(entity);
+                            processedEntities.Add(entity);
+                            excludedCount++;
+                        }
+
+                        if (excludedCount < existingValue.AnalysisEntities.Count)
+                        {
+                            newValue = existingValue.WithEntitiesRemoved(entitiesToExclude);
+                            targetAnalysisData.SetAbstactValueForEntities(newValue, entityBeingAssigned: null);
+                        }
+                    }
                 }
             }
 

src/Utilities/FlowAnalysis/FlowAnalysis/Framework/DataFlow/DataFlowAnalysis.cs

@@ -86,7 +86,7 @@ protected DataFlowAnalysis(AbstractAnalysisDomain<TAnalysisData> analysisDomain,
             // i.e. for every '{key, value}' pair in the dictionary, 'key' is the destination of at least one back edge
             // and 'value' is the minimum ordinal such that there is no back edge to 'key' from any basic block with ordinal > 'value'.
             using var loopRangeMap = PooledDictionary<int, int>.GetInstance();
-            ComputeLoopRangeMap(cfg, loopRangeMap);
+            var hasAnyTryBlock = ComputeLoopRangeMap(cfg, loopRangeMap);
 
             TAnalysisData? normalPathsExitBlockData = null, exceptionPathsExitBlockData = null;
 
@@ -115,7 +115,12 @@ protected DataFlowAnalysis(AbstractAnalysisDomain<TAnalysisData> analysisDomain,
                     blockToUniqueInputFlowMap, loopRangeMap, exceptionPathsAnalysisPostPass: false);
                 normalPathsExitBlockData = resultBuilder.ExitBlockOutputData;
 
-                if (analysisContext.ExceptionPathsAnalysis)
+                // If we are executing exception paths analysis OR have at least one try/catch/finally block
+                // in the method, execute an exception path analysis post pass.
+                // This post pass will handle all possible operations within the control flow graph that can
+                // throw an exception and merge analysis data after all such operation analyses into the
+                // catch blocks reachable from those operations.
+                if (analysisContext.ExceptionPathsAnalysis || hasAnyTryBlock)
                 {
                     RoslynDebug.Assert(normalPathsExitBlockData != null);
 
@@ -286,11 +291,9 @@ private void RunCore(
 
                 // Check if we are starting a try region which has one or more associated catch/filter regions.
                 // If so, we conservatively merge the input data for try region into the input data for the associated catch/filter regions.
-#pragma warning disable CA1508 // Avoid dead conditional code - https://github.com/dotnet/roslyn-analyzers/issues/4408
                 if (block.EnclosingRegion?.Kind == ControlFlowRegionKind.Try &&
                     block.EnclosingRegion.EnclosingRegion?.Kind == ControlFlowRegionKind.TryAndCatch &&
                     block.EnclosingRegion.EnclosingRegion.FirstBlockOrdinal == block.Ordinal)
-#pragma warning restore CA1508 // Avoid dead conditional code
                 {
                     MergeIntoCatchInputData(block.EnclosingRegion.EnclosingRegion, input, block);
                 }
@@ -791,15 +794,20 @@ private void CloneAndUpdateOutputIfEntryOrExitBlock(DataFlowAnalysisResultBuilde
             }
         }
 
-        private static void ComputeLoopRangeMap(ControlFlowGraph cfg, PooledDictionary<int, int> loopRangeMap)
+        private static bool ComputeLoopRangeMap(ControlFlowGraph cfg, PooledDictionary<int, int> loopRangeMap)
         {
+            var hasAnyTryBlock = false;
             for (int i = cfg.Blocks.Length - 1; i > 0; i--)
             {
                 var block = cfg.Blocks[i];
                 HandleBranch(block.FallThroughSuccessor);
                 HandleBranch(block.ConditionalSuccessor);
+
+                hasAnyTryBlock |= block.EnclosingRegion.Kind == ControlFlowRegionKind.Try;
             }
 
+            return hasAnyTryBlock;
+
             void HandleBranch(ControlFlowBranch? branch)
             {
                 if (branch?.Destination != null && branch.IsBackEdge() && !loopRangeMap.ContainsKey(branch.Destination.Ordinal))

src/Utilities/FlowAnalysis/FlowAnalysis/Framework/DataFlow/DataFlowOperationVisitor.cs

@@ -844,7 +844,6 @@ private TAbstractAnalysisValue GetAbstractValueForReturnOperation(IOperation ret
 
         protected virtual void HandlePossibleThrowingOperation(IOperation operation)
         {
-            Debug.Assert(DataFlowAnalysisContext.ExceptionPathsAnalysis);
             Debug.Assert(ExecutingExceptionPathsAnalysisPostPass);
 
             // Bail out if we are not analyzing an interprocedural call and there is no