Merge branch 'main' into wangbill/autochunk

Author: YunchuWang

src/Analyzers/Activities/MatchingInputOutputTypeActivityAnalyzer.cs

@@ -75,6 +75,9 @@ public override void Initialize(AnalysisContext context)
             IMethodSymbol taskActivityRunAsync = knownSymbols.TaskActivityBase.GetMembers("RunAsync").OfType<IMethodSymbol>().Single();
             INamedTypeSymbol voidSymbol = context.Compilation.GetSpecialType(SpecialType.System_Void);
 
+            // Get common DI types that should not be treated as activity input
+            INamedTypeSymbol? functionContextSymbol = context.Compilation.GetTypeByMetadataName("Microsoft.Azure.Functions.Worker.FunctionContext");
+
             // Search for Activity invocations
             ConcurrentBag<ActivityInvocation> invocations = [];
             context.RegisterOperationAction(
@@ -161,6 +164,12 @@ public override void Initialize(AnalysisContext context)
                         return;
                     }
 
+                    // If the parameter is FunctionContext, skip validation for this activity (it's a DI parameter, not real input)
+                    if (functionContextSymbol != null && SymbolEqualityComparer.Default.Equals(inputParam.Type, functionContextSymbol))
+                    {
+                        return;
+                    }
+
                     ITypeSymbol? inputType = inputParam.Type;
 
                     ITypeSymbol? outputType = methodSymbol.ReturnType;
@@ -306,7 +315,8 @@ public override void Initialize(AnalysisContext context)
                         continue;
                     }
 
-                    if (!SymbolEqualityComparer.Default.Equals(invocation.InputType, activity.InputType))
+                    // Check input type compatibility
+                    if (!AreTypesCompatible(ctx.Compilation, invocation.InputType, activity.InputType))
                     {
                         string actual = invocation.InputType?.ToDisplayString(SymbolDisplayFormat.CSharpShortErrorMessageFormat) ?? "none";
                         string expected = activity.InputType?.ToDisplayString(SymbolDisplayFormat.CSharpShortErrorMessageFormat) ?? "none";
@@ -316,7 +326,8 @@ public override void Initialize(AnalysisContext context)
                         ctx.ReportDiagnostic(diagnostic);
                     }
 
-                    if (!SymbolEqualityComparer.Default.Equals(invocation.OutputType, activity.OutputType))
+                    // Check output type compatibility
+                    if (!AreTypesCompatible(ctx.Compilation, activity.OutputType, invocation.OutputType))
                     {
                         string actual = invocation.OutputType?.ToDisplayString(SymbolDisplayFormat.CSharpShortErrorMessageFormat) ?? "none";
                         string expected = activity.OutputType?.ToDisplayString(SymbolDisplayFormat.CSharpShortErrorMessageFormat) ?? "none";
@@ -330,6 +341,148 @@ public override void Initialize(AnalysisContext context)
         });
     }
 
+    /// <summary>
+    /// Checks if the source type is compatible with (can be assigned to) the target type.
+    /// This handles polymorphism, interface implementation, inheritance, and collection type compatibility.
+    /// </summary>
+    static bool AreTypesCompatible(Compilation compilation, ITypeSymbol? sourceType, ITypeSymbol? targetType)
+    {
+        // Both null = compatible (no input/output on both sides)
+        if (sourceType == null && targetType == null)
+        {
+            return true;
+        }
+
+        // Special case: null (no input/output provided) can be passed to explicitly nullable parameters
+        // This handles nullable value types (int?) and nullable reference types (string?)
+        if (sourceType == null && targetType != null)
+        {
+            // Check if target is a nullable value type (Nullable<T>)
+            if (targetType.OriginalDefinition.SpecialType == SpecialType.System_Nullable_T)
+            {
+                return true;
+            }
+
+            // Check if target is a nullable reference type (string?)
+            if (targetType.NullableAnnotation == NullableAnnotation.Annotated)
+            {
+                return true;
+            }
+
+            // Not nullable, so null input is incompatible
+            return false;
+        }
+
+        // If targetType is null but sourceType is not, they're incompatible
+        if (targetType == null && sourceType != null)
+        {
+            return false;
+        }
+
+        // Check if types are exactly equal
+        if (SymbolEqualityComparer.Default.Equals(sourceType, targetType))
+        {
+            return true;
+        }
+
+        // Check if source type can be converted to target type (handles inheritance, interface implementation, etc.)
+        // At this point, both sourceType and targetType are guaranteed to be non-null
+        Conversion conversion = compilation.ClassifyConversion(sourceType!, targetType!);
+        if (conversion.IsImplicit || conversion.IsIdentity)
+        {
+            return true;
+        }
+
+        // Special handling for collection types since ClassifyConversion doesn't always recognize
+        // generic interface implementations (e.g., List<T> to IReadOnlyList<T>)
+        // At this point, both sourceType and targetType are guaranteed to be non-null
+        if (IsCollectionTypeCompatible(sourceType!, targetType!))
+        {
+            return true;
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    /// Checks if the source collection type is compatible with the target collection type.
+    /// Handles common scenarios like List to IReadOnlyList, arrays to IEnumerable, etc.
+    /// </summary>
+    static bool IsCollectionTypeCompatible(ITypeSymbol sourceType, ITypeSymbol targetType)
+    {
+        // Check if source is an array and target is a collection interface
+        if (sourceType is IArrayTypeSymbol sourceArray && targetType is INamedTypeSymbol targetNamed)
+        {
+            return IsArrayCompatibleWithCollectionInterface(sourceArray, targetNamed);
+        }
+
+        // Both must be generic named types
+        if (sourceType is not INamedTypeSymbol sourceNamed || targetType is not INamedTypeSymbol targetNamedType)
+        {
+            return false;
+        }
+
+        // Both must be generic types with the same type arguments
+        if (!sourceNamed.IsGenericType || !targetNamedType.IsGenericType)
+        {
+            return false;
+        }
+
+        if (sourceNamed.TypeArguments.Length != targetNamedType.TypeArguments.Length)
+        {
+            return false;
+        }
+
+        // Check if type arguments are compatible (could be different but compatible types)
+        for (int i = 0; i < sourceNamed.TypeArguments.Length; i++)
+        {
+            if (!SymbolEqualityComparer.Default.Equals(sourceNamed.TypeArguments[i], targetNamedType.TypeArguments[i]))
+            {
+                // Type arguments must match exactly for collections (we don't support covariance/contravariance here)
+                return false;
+            }
+        }
+
+        // Check if source type implements or derives from target type
+        // This handles: List<T> → IReadOnlyList<T>, List<T> → IEnumerable<T>, etc.
+        return ImplementsInterface(sourceNamed, targetNamedType);
+    }
+
+    /// <summary>
+    /// Checks if an array type is compatible with a collection interface.
+    /// </summary>
+    static bool IsArrayCompatibleWithCollectionInterface(IArrayTypeSymbol arrayType, INamedTypeSymbol targetInterface)
+    {
+        if (!targetInterface.IsGenericType || targetInterface.TypeArguments.Length != 1)
+        {
+            return false;
+        }
+
+        // Check if array element type matches the generic type argument
+        if (!SymbolEqualityComparer.Default.Equals(arrayType.ElementType, targetInterface.TypeArguments[0]))
+        {
+            return false;
+        }
+
+        // Array implements: IEnumerable<T>, ICollection<T>, IList<T>, IReadOnlyCollection<T>, IReadOnlyList<T>
+        string targetName = targetInterface.OriginalDefinition.ToDisplayString();
+        return targetName == "System.Collections.Generic.IEnumerable<T>" ||
+               targetName == "System.Collections.Generic.ICollection<T>" ||
+               targetName == "System.Collections.Generic.IList<T>" ||
+               targetName == "System.Collections.Generic.IReadOnlyCollection<T>" ||
+               targetName == "System.Collections.Generic.IReadOnlyList<T>";
+    }
+
+    /// <summary>
+    /// Checks if the source type implements the target interface.
+    /// </summary>
+    static bool ImplementsInterface(INamedTypeSymbol sourceType, INamedTypeSymbol targetInterface)
+    {
+        // Check all interfaces implemented by the source type
+        return sourceType.AllInterfaces.Any(@interface =>
+            SymbolEqualityComparer.Default.Equals(@interface.OriginalDefinition, targetInterface.OriginalDefinition));
+    }
+
     struct ActivityInvocation
     {
         public string Name { get; set; }

src/Worker/Core/Shims/TaskOrchestrationContextWrapper.EventSource.cs

@@ -21,6 +21,11 @@ interface IEventSource
         /// </summary>
         Type EventType { get; }
 
+        /// <summary>
+        /// Gets or sets the next event source in the stack (for LIFO ordering).
+        /// </summary>
+        IEventSource? Next { get; set; }
+
         /// <summary>
         /// Tries to set the result on tcs.
         /// </summary>
@@ -33,6 +38,9 @@ class EventTaskCompletionSource<T> : TaskCompletionSource<T>, IEventSource
         /// <inheritdoc/>
         public Type EventType => typeof(T);
 
+        /// <inheritdoc/>
+        public IEventSource? Next { get; set; }
+
         /// <inheritdoc/>
         void IEventSource.TrySetResult(object result) => this.TrySetResult((T)result);
     }

src/Worker/Core/Shims/TaskOrchestrationContextWrapper.cs

@@ -18,7 +18,10 @@ namespace Microsoft.DurableTask.Worker.Shims;
 /// </summary>
 sealed partial class TaskOrchestrationContextWrapper : TaskOrchestrationContext
 {
-    readonly Dictionary<string, Queue<IEventSource>> externalEventSources = new(StringComparer.OrdinalIgnoreCase);
+    // We use a stack (a custom implementation using a single-linked list) to make it easier for users
+    // to abandon external events that they no longer care about. The common case is a Task.WhenAny in a loop.
+    // Events are assigned to the most recent (top of stack) waiter, which naturally avoids issues with cancelled waiters.
+    readonly Dictionary<string, IEventSource> externalEventSources = new(StringComparer.OrdinalIgnoreCase);
     readonly NamedQueue<string> externalEventBuffer = new();
     readonly OrchestrationContext innerContext;
     readonly OrchestrationInvocationContext invocationContext;
@@ -280,29 +283,33 @@ public override async Task CreateTimer(DateTime fireAt, CancellationToken cancel
     /// <inheritdoc/>
     public override Task<T> WaitForExternalEvent<T>(string eventName, CancellationToken cancellationToken = default)
     {
-        // Return immediately if this external event has already arrived.
-        if (this.externalEventBuffer.TryTake(eventName, out string? bufferedEventPayload))
-        {
-            return Task.FromResult(this.DataConverter.Deserialize<T>(bufferedEventPayload));
-        }
-
         // Create a task completion source that will be set when the external event arrives.
         EventTaskCompletionSource<T> eventSource = new();
-        if (this.externalEventSources.TryGetValue(eventName, out Queue<IEventSource>? existing))
+
+        // Set up the stack for listening to external events (LIFO - Last In First Out)
+        // New waiters are added to the top of the stack, so they get events first.
+        // This makes it easier for users to abandon external events they no longer care about.
+        // The common case is a Task.WhenAny in a loop.
+        if (this.externalEventSources.TryGetValue(eventName, out IEventSource? existing))
         {
-            if (existing.Count > 0 && existing.Peek().EventType != typeof(T))
+            if (existing.EventType != typeof(T))
             {
                 throw new ArgumentException("Events with the same name must have the same type argument. Expected"
-                    + $" {existing.Peek().GetType().FullName} but was requested {typeof(T).FullName}.");
+                    + $" {existing.EventType.FullName} but was requested {typeof(T).FullName}.");
             }
 
-            existing.Enqueue(eventSource);
+            // Add new waiter to the top of the stack
+            eventSource.Next = existing;
         }
-        else
+
+        // New waiter becomes the top of the stack
+        this.externalEventSources[eventName] = eventSource;
+
+        // Check the buffer to see if any events came in before the orchestrator was listening
+        if (this.externalEventBuffer.TryTake(eventName, out string? bufferedEvent))
         {
-            Queue<IEventSource> eventSourceQueue = new();
-            eventSourceQueue.Enqueue(eventSource);
-            this.externalEventSources.Add(eventName, eventSourceQueue);
+            // We can complete the event right away, since we already have an event's input
+            this.CompleteExternalEvent(eventName, bufferedEvent);
         }
 
         // TODO: this needs to be tracked and disposed appropriately.
@@ -416,11 +423,23 @@ internal void ExitCriticalSectionIfNeeded()
     /// <param name="rawEventPayload">The serialized event payload.</param>
     internal void CompleteExternalEvent(string eventName, string rawEventPayload)
     {
-        if (this.externalEventSources.TryGetValue(eventName, out Queue<IEventSource>? waiters))
+        if (this.externalEventSources.TryGetValue(eventName, out IEventSource? waiter))
         {
-            object? value;
+            // Get the waiter at the top of the stack (most recent waiter)
+            // If we're going to raise an event we should remove it from the pending collection
+            // because otherwise WaitForExternalEvent() will always find one with this key and run infinitely.
+            IEventSource? next = waiter.Next;
+            if (next == null)
+            {
+                this.externalEventSources.Remove(eventName);
+            }
+            else
+            {
+                // Next waiter becomes the new top of the stack
+                this.externalEventSources[eventName] = next;
+            }
 
-            IEventSource waiter = waiters.Dequeue();
+            object? value;
             if (waiter.EventType == typeof(OperationResult))
             {
                 // use the framework-defined deserialization for entity responses, not the application-defined data converter,
@@ -432,12 +451,6 @@ internal void CompleteExternalEvent(string eventName, string rawEventPayload)
                 value = this.DataConverter.Deserialize(rawEventPayload, waiter.EventType);
             }
 
-            // Events are completed in FIFO order. Remove the key if the last event was delivered.
-            if (waiters.Count == 0)
-            {
-                this.externalEventSources.Remove(eventName);
-            }
-
             waiter.TrySetResult(value);
         }
         else

test/Analyzers.Tests/Activities/MatchingInputOutputTypeActivityAnalyzerTests.cs

@@ -406,7 +406,6 @@ async Task Method(TaskOrchestrationContext context)
         await VerifyCS.VerifyDurableTaskAnalyzerAsync(code);
     }
 
-
     static DiagnosticResult BuildInputDiagnostic()
     {
         return VerifyCS.Diagnostic(MatchingInputOutputTypeActivityAnalyzer.InputArgumentTypeMismatchDiagnosticId);