Add support for patterns (#118267)

This adds local and property pattern support, but may not cover all
possible ways a pattern can introduce a local variable.

Fixes #113922

Author: agocke

src/tools/illink/src/ILLink.RoslynAnalyzer/DataFlow/LocalDataFlowVisitor.cs

@@ -171,7 +171,7 @@ public abstract TValue HandleMethodCall(
 
         public override TValue VisitLocalReference(ILocalReferenceOperation operation, LocalDataFlowState<TValue, TContext, TValueLattice, TContextLattice> state)
         {
-            return GetLocal(operation, state);
+            return GetLocal(operation.Local, state);
         }
 
         private TValue ProcessBinderCall(IOperation operation, string methodName, LocalDataFlowState<TValue, TContext, TValueLattice, TContextLattice> state)
@@ -199,21 +199,19 @@ public override TValue VisitDynamicMemberReference(IDynamicMemberReferenceOperat
         public override TValue VisitDynamicIndexerAccess(IDynamicIndexerAccessOperation operation, LocalDataFlowState<TValue, TContext, TValueLattice, TContextLattice> state)
             => ProcessBinderCall(operation, operation.GetValueUsageInfo(OwningSymbol).HasFlag(ValueUsageInfo.Write) ? "SetIndex" : "GetIndex", state);
 
-        private bool IsReferenceToCapturedVariable(ILocalReferenceOperation localReference)
+        private bool IsCapturedVariable(ILocalSymbol local)
         {
-            var local = localReference.Local;
-
             if (local.IsConst)
                 return false;
             Debug.Assert(local.ContainingSymbol is IMethodSymbol or IFieldSymbol, // backing field for property initializers
-                $"{local.ContainingSymbol.GetType()}: {localReference.Syntax.GetLocation().GetLineSpan()}");
+                $"{local.ContainingSymbol.GetType()}: {local.Locations[0].GetLineSpan()}");
             return !ReferenceEquals(local.ContainingSymbol, OwningSymbol);
         }
 
-        private TValue GetLocal(ILocalReferenceOperation operation, LocalDataFlowState<TValue, TContext, TValueLattice, TContextLattice> state)
+        private TValue GetLocal(ILocalSymbol symbol, LocalDataFlowState<TValue, TContext, TValueLattice, TContextLattice> state)
         {
-            var local = new LocalKey(operation.Local);
-            if (IsReferenceToCapturedVariable(operation))
+            var local = new LocalKey(symbol);
+            if (IsCapturedVariable(symbol))
                 InterproceduralState.TrackHoistedLocal(local);
 
             // Get the value from the hoisted locals, if it's tracked there.
@@ -223,10 +221,10 @@ private TValue GetLocal(ILocalReferenceOperation operation, LocalDataFlowState<T
             return state.Get(local);
         }
 
-        private void SetLocal(ILocalReferenceOperation operation, TValue value, LocalDataFlowState<TValue, TContext, TValueLattice, TContextLattice> state, bool merge = false)
+        private void SetLocal(ILocalSymbol localSymbol, TValue value, LocalDataFlowState<TValue, TContext, TValueLattice, TContextLattice> state, bool merge = false)
         {
-            var local = new LocalKey(operation.Local);
-            if (IsReferenceToCapturedVariable(operation))
+            var local = new LocalKey(localSymbol);
+            if (IsCapturedVariable(localSymbol))
                 InterproceduralState.TrackHoistedLocal(local);
 
             // Update the value stored in the hoisted locals, if it's tracked there.
@@ -239,7 +237,23 @@ private void SetLocal(ILocalReferenceOperation operation, TValue value, LocalDat
             state.Set(local, newValue);
         }
 
-        private TValue ProcessSingleTargetAssignment(IOperation targetOperation, IAssignmentOperation operation, LocalDataFlowState<TValue, TContext, TValueLattice, TContextLattice> state, bool merge)
+        private TValue ProcessSingleTargetAssignment(
+            IOperation targetOperation,
+            IAssignmentOperation operation,
+            LocalDataFlowState<TValue, TContext, TValueLattice, TContextLattice> state,
+            bool merge
+        )
+        {
+            return ProcessSingleTargetAssignment(targetOperation, operation.Value, operation, state, merge);
+        }
+
+        private TValue ProcessSingleTargetAssignment(
+            IOperation targetOperation,
+            IOperation valueOperation,
+            IOperation assignmentOperation,
+            LocalDataFlowState<TValue, TContext, TValueLattice, TContextLattice> state,
+            bool merge
+        )
         {
             switch (targetOperation)
             {
@@ -253,8 +267,8 @@ private TValue ProcessSingleTargetAssignment(IOperation targetOperation, IAssign
                         IParameterReferenceOperation parameterRef => GetParameterTargetValue(parameterRef.Parameter),
                         _ => throw new InvalidOperationException()
                     };
-                    TValue value = Visit(operation.Value, state);
-                    HandleAssignment(value, targetValue, operation, in current.Context);
+                    TValue value = Visit(valueOperation, state);
+                    HandleAssignment(value, targetValue, assignmentOperation, in current.Context);
                     return value;
                 }
 
@@ -266,7 +280,7 @@ private TValue ProcessSingleTargetAssignment(IOperation targetOperation, IAssign
                     // correctly detect whether it is used for reading or writing inside of VisitPropertyReference.
                     // https://github.com/dotnet/roslyn/issues/25057
                     TValue instanceValue = Visit(propertyRef.Instance, state);
-                    TValue value = Visit(operation.Value, state);
+                    TValue value = Visit(valueOperation, state);
                     IMethodSymbol? setMethod = propertyRef.Property.GetSetMethod();
 
                     if (setMethod == null ||
@@ -287,7 +301,7 @@ private TValue ProcessSingleTargetAssignment(IOperation targetOperation, IAssign
 
                         var current = state.Current;
                         TValue targetValue = GetBackingFieldTargetValue(propertyRef, in current.Context);
-                        HandleAssignment(value, targetValue, operation, in current.Context);
+                        HandleAssignment(value, targetValue, assignmentOperation, in current.Context);
                         return value;
                     }
 
@@ -297,7 +311,7 @@ private TValue ProcessSingleTargetAssignment(IOperation targetOperation, IAssign
                         arguments.Add(Visit(val, state));
                     arguments.Add(value);
 
-                    HandleMethodCallHelper(setMethod, instanceValue, arguments.ToImmutableArray(), operation, state);
+                    HandleMethodCallHelper(setMethod, instanceValue, arguments.ToImmutableArray(), assignmentOperation, state);
                     // The return value of a property set expression is the value,
                     // even though a property setter has no return value.
                     return value;
@@ -308,14 +322,14 @@ private TValue ProcessSingleTargetAssignment(IOperation targetOperation, IAssign
                     // not a call to an event accessor method. There is no Roslyn API to access the field,
                     // so just visit the instance and the value. https://github.com/dotnet/roslyn/issues/40103
                     Visit(eventRef.Instance, state);
-                    return Visit(operation.Value, state);
+                    return Visit(valueOperation, state);
                 }
                 case IImplicitIndexerReferenceOperation indexerRef:
                 {
                     // An implicit reference to an indexer where the argument is a System.Index
                     TValue instanceValue = Visit(indexerRef.Instance, state);
                     TValue indexArgumentValue = Visit(indexerRef.Argument, state);
-                    TValue value = Visit(operation.Value, state);
+                    TValue value = Visit(valueOperation, state);
 
                     var property = (IPropertySymbol)indexerRef.IndexerSymbol;
 
@@ -331,15 +345,23 @@ private TValue ProcessSingleTargetAssignment(IOperation targetOperation, IAssign
                         break;
                     }
 
-                    HandleMethodCallHelper(setMethod, instanceValue, argumentsBuilder.ToImmutableArray(), operation, state);
+                    HandleMethodCallHelper(setMethod, instanceValue, argumentsBuilder.ToImmutableArray(), assignmentOperation, state);
                     return value;
                 }
 
                 // TODO: when setting a property in an attribute, target is an IPropertyReference.
                 case ILocalReferenceOperation localRef:
                 {
-                    TValue value = Visit(operation.Value, state);
-                    SetLocal(localRef, value, state, merge);
+                    TValue value = Visit(valueOperation, state);
+                    SetLocal(localRef.Local, value, state, merge);
+                    return value;
+                }
+                case IDeclarationPatternOperation declPattern:
+                {
+                    if (declPattern.DeclaredSymbol is not ILocalSymbol declaredSymbol)
+                        break;
+                    var value = Visit(valueOperation, state);
+                    SetLocal(declaredSymbol, value, state, merge);
                     return value;
                 }
                 case IArrayElementReferenceOperation arrayElementRef:
@@ -349,22 +371,22 @@ private TValue ProcessSingleTargetAssignment(IOperation targetOperation, IAssign
 
                     TValue arrayRef = Visit(arrayElementRef.ArrayReference, state);
                     TValue index = Visit(arrayElementRef.Indices[0], state);
-                    TValue value = Visit(operation.Value, state);
-                    HandleArrayElementWrite(arrayRef, index, value, operation, merge: merge);
+                    TValue value = Visit(valueOperation, state);
+                    HandleArrayElementWrite(arrayRef, index, value, assignmentOperation, merge: merge);
                     return value;
                 }
                 case IInlineArrayAccessOperation inlineArrayAccess:
                 {
                     TValue arrayRef = Visit(inlineArrayAccess.Instance, state);
                     TValue index = Visit(inlineArrayAccess.Argument, state);
-                    TValue value = Visit(operation.Value, state);
-                    HandleArrayElementWrite(arrayRef, index, value, operation, merge: merge);
+                    TValue value = Visit(valueOperation, state);
+                    HandleArrayElementWrite(arrayRef, index, value, assignmentOperation, merge: merge);
                     return value;
                 }
                 case IDiscardOperation:
                     // Assignments like "_ = SomeMethod();" don't need dataflow tracking.
                     // Seems like this can't happen with a flow capture operation.
-                    Debug.Assert(operation.Target is not IFlowCaptureReferenceOperation);
+                    Debug.Assert(targetOperation is not IFlowCaptureReferenceOperation);
                     break;
                 case IInstanceReferenceOperation:
                 // Assignment to 'this' is not tracked currently.
@@ -389,14 +411,45 @@ private TValue ProcessSingleTargetAssignment(IOperation targetOperation, IAssign
                     UnexpectedOperationHandler.Handle(targetOperation);
                     break;
             }
-            return Visit(operation.Value, state);
+            return Visit(valueOperation, state);
         }
 
         public override TValue VisitSimpleAssignment(ISimpleAssignmentOperation operation, LocalDataFlowState<TValue, TContext, TValueLattice, TContextLattice> state)
         {
             return ProcessAssignment(operation, state);
         }
 
+        public override TValue VisitIsPattern(IIsPatternOperation operation, LocalDataFlowState<TValue, TContext, TValueLattice, TContextLattice> state)
+        {
+            if (operation.Pattern is IDeclarationPatternOperation declarationPattern)
+            {
+                // A declaration pattern is like an assignment to a local
+                return ProcessSingleTargetAssignment(
+                    declarationPattern,
+                    operation.Value,
+                    operation,
+                    state,
+                    merge: false
+                );
+            }
+            return base.VisitIsPattern(operation, state);
+        }
+
+        public override TValue VisitPropertySubpattern(IPropertySubpatternOperation propPattern, LocalDataFlowState<TValue, TContext, TValueLattice, TContextLattice> state)
+        {
+            if (propPattern.Pattern is IDeclarationPatternOperation declPattern)
+            {
+                return ProcessSingleTargetAssignment(
+                    declPattern,
+                    propPattern.Member,
+                    propPattern,
+                    state,
+                    merge: false
+                );
+            }
+            return base.VisitPropertySubpattern(propPattern, state);
+        }
+
         public override TValue VisitCompoundAssignment(ICompoundAssignmentOperation operation, LocalDataFlowState<TValue, TContext, TValueLattice, TContextLattice> state)
         {
             return ProcessAssignment(operation, state);

src/tools/illink/src/ILLink.RoslynAnalyzer/DataFlow/LocalStateLattice.cs

@@ -45,12 +45,6 @@ public struct LocalState<TValue> : IEquatable<LocalState<TValue>>
         // are tracked as part of the dictionary of values, keyed by LocalKey.
         public DefaultValueDictionary<CaptureId, ValueSet<CapturedReferenceValue>> CapturedReferences;
 
-        public LocalState(TValue defaultValue)
-            : this(new DefaultValueDictionary<LocalKey, TValue>(defaultValue),
-                new DefaultValueDictionary<CaptureId, ValueSet<CapturedReferenceValue>>(default(ValueSet<CapturedReferenceValue>)))
-        {
-        }
-
         public LocalState(DefaultValueDictionary<LocalKey, TValue> dictionary, DefaultValueDictionary<CaptureId, ValueSet<CapturedReferenceValue>> capturedReferences)
         {
             Dictionary = dictionary;

src/tools/illink/test/ILLink.RoslynAnalyzer.Tests/DataFlowTests.cs

@@ -294,7 +294,6 @@ public Task LocalDataFlow()
             return RunTest(nameof(LocalDataFlow));
         }
 
-
         [Fact]
         public Task ExceptionalDataFlow()
         {

src/tools/illink/test/Mono.Linker.Tests.Cases.Expectations/Assertions/BaseInAssemblyAttribute.cs

@@ -10,6 +10,6 @@ public abstract class BaseInAssemblyAttribute : BaseExpectedLinkedBehaviorAttrib
         /// This property can override that by setting only the platforms
         /// which are expected to preserve the desired behavior.
         /// </summary>
-        public Tool Tool { get; set; } = Tool.TrimmerAnalyzerAndNativeAot;
+        public Tool Tool { get; set; } = Tool.All;
     }
 }

src/tools/illink/test/Mono.Linker.Tests.Cases.Expectations/Assertions/IgnoreTestCaseAttribute.cs

@@ -14,6 +14,6 @@ public IgnoreTestCaseAttribute(string reason)
             ArgumentNullException.ThrowIfNull(reason);
         }
 
-        public Tool IgnoredBy { get; set; } = Tool.TrimmerAnalyzerAndNativeAot;
+        public Tool IgnoredBy { get; set; } = Tool.All;
     }
 }

src/tools/illink/test/Mono.Linker.Tests.Cases.Expectations/Assertions/KeptAttribute.cs

@@ -13,6 +13,6 @@ public class KeptAttribute : BaseExpectedLinkedBehaviorAttribute
         /// This property can override that by setting only the platforms
         /// which are expected to keep the target.
         /// </summary>
-        public Tool By { get; set; } = Tool.TrimmerAnalyzerAndNativeAot;
+        public Tool By { get; set; } = Tool.All;
     }
 }

src/tools/illink/test/Mono.Linker.Tests.Cases.Expectations/Assertions/LogContainsAttribute.cs

@@ -21,6 +21,6 @@ public LogContainsAttribute(string message, bool regexMatch = false)
         /// Property used by the result checkers of trimmer and analyzers to determine whether
         /// the tool should have produced the specified warning on the annotated member.
         /// </summary>
-        public Tool ProducedBy { get; set; } = Tool.TrimmerAnalyzerAndNativeAot;
+        public Tool ProducedBy { get; set; } = Tool.All;
     }
 }

src/tools/illink/test/Mono.Linker.Tests.Cases.Expectations/Assertions/LogDoesNotContainAttribute.cs

@@ -21,6 +21,6 @@ public LogDoesNotContainAttribute(string message, bool regexMatch = false)
         /// Property used by the result checkers of trimmer and analyzers to determine whether
         /// the tool should have produced the specified warning on the annotated member.
         /// </summary>
-        public Tool ProducedBy { get; set; } = Tool.TrimmerAnalyzerAndNativeAot;
+        public Tool ProducedBy { get; set; } = Tool.All;
     }
 }

src/tools/illink/test/Mono.Linker.Tests.Cases.Expectations/Assertions/SkipKeptItemsValidationAttribute.cs

@@ -10,6 +10,6 @@ public class SkipKeptItemsValidationAttribute : BaseExpectedLinkedBehaviorAttrib
     {
         public SkipKeptItemsValidationAttribute() { }
 
-        public Tool By { get; set; } = Tool.TrimmerAnalyzerAndNativeAot;
+        public Tool By { get; set; } = Tool.All;
     }
 }

src/tools/illink/test/Mono.Linker.Tests.Cases.Expectations/Assertions/Tool.cs

@@ -17,6 +17,6 @@ public enum Tool
         Trimmer = 1,
         Analyzer = 2,
         NativeAot = 4,
-        TrimmerAnalyzerAndNativeAot = Trimmer | Analyzer | NativeAot
+        All = Trimmer | Analyzer | NativeAot
     }
 }