CancellationToken roslyn analyzer (#303)

Currently, CancellationToken binding is not supported (ignored) during [input conversion](https://github.com/Azure/azure-functions-durable-extension/blob/dev/src/Worker.Extensions.DurableTask/OrchestrationInputConverter.cs#L79). This analyzer will prevent users from using it inside Azure Functions Orchestrators.

src/Analyzers/AnalyzerReleases.Unshipped.md

@@ -8,6 +8,7 @@ Rule ID | Category | Severity | Notes
 DURABLE0001 | Orchestration | Warning | DateTimeOrchestrationAnalyzer
 DURABLE0002 | Orchestration | Warning | GuidOrchestrationAnalyzer
 DURABLE0003 | Orchestration | Warning | DelayOrchestrationAnalyzer
+DURABLE0007 | Orchestration | Warning | CancellationTokenOrchestrationAnalyzer
 DURABLE1001 | Attribute Binding | Error | OrchestrationTriggerBindingAnalyzer
 DURABLE1002 | Attribute Binding | Error | DurableClientBindingAnalyzer
 DURABLE1003 | Attribute Binding | Error | EntityTriggerBindingAnalyzer

src/Analyzers/Functions/Orchestration/CancellationTokenOrchestrationAnalyzer.cs

@@ -0,0 +1,61 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System.Collections.Immutable;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.DurableTask.Analyzers.Orchestration;
+using static Microsoft.DurableTask.Analyzers.Functions.Orchestration.CancellationTokenOrchestrationAnalyzer;
+
+namespace Microsoft.DurableTask.Analyzers.Functions.Orchestration;
+
+/// <summary>
+/// Analyzer that reports a warning when CancellationToken is used in a Durable Functions Orchestration.
+/// </summary>
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public class CancellationTokenOrchestrationAnalyzer : OrchestrationAnalyzer<CancellationTokenOrchestrationVisitor>
+{
+    /// <summary>
+    /// Diagnostic ID supported for the analyzer.
+    /// </summary>
+    public const string DiagnosticId = "DURABLE0007";
+
+    static readonly LocalizableString Title = new LocalizableResourceString(nameof(Resources.CancellationTokenOrchestrationAnalyzerTitle), Resources.ResourceManager, typeof(Resources));
+    static readonly LocalizableString MessageFormat = new LocalizableResourceString(nameof(Resources.CancellationTokenOrchestrationAnalyzerMessageFormat), Resources.ResourceManager, typeof(Resources));
+
+    static readonly DiagnosticDescriptor Rule = new(
+        DiagnosticId,
+        Title,
+        MessageFormat,
+        AnalyzersCategories.Orchestration,
+        DiagnosticSeverity.Warning,
+        isEnabledByDefault: true);
+
+    /// <inheritdoc/>
+    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => [Rule];
+
+    /// <summary>
+    /// Visitor that inspects Durable Functions's method signatures for CancellationToken parameters.
+    /// </summary>
+    public sealed class CancellationTokenOrchestrationVisitor : OrchestrationVisitor
+    {
+        /// <inheritdoc/>
+        public override bool Initialize()
+        {
+            return this.KnownTypeSymbols.CancellationToken is not null;
+        }
+
+        /// <inheritdoc/>
+        public override void VisitDurableFunction(SemanticModel semanticModel, MethodDeclarationSyntax methodSyntax, IMethodSymbol methodSymbol, string orchestrationName, Action<Diagnostic> reportDiagnostic)
+        {
+            foreach (IParameterSymbol parameter in methodSymbol.Parameters)
+            {
+                if (parameter.Type.Equals(this.KnownTypeSymbols.CancellationToken, SymbolEqualityComparer.Default))
+                {
+                    reportDiagnostic(RoslynExtensions.BuildDiagnostic(Rule, parameter, orchestrationName));
+                }
+            }
+        }
+    }
+}

src/Analyzers/KnownTypeSymbols.Net.cs

@@ -17,6 +17,7 @@ public sealed partial class KnownTypeSymbols
     INamedTypeSymbol? thread;
     INamedTypeSymbol? task;
     INamedTypeSymbol? taskT;
+    INamedTypeSymbol? cancellationToken;
 
     /// <summary>
     /// Gets a Guid type symbol.
@@ -37,4 +38,9 @@ public sealed partial class KnownTypeSymbols
     /// Gets a Task&lt;T&gt; type symbol.
     /// </summary>
     public INamedTypeSymbol? TaskT => this.GetOrResolveFullyQualifiedType(typeof(Task<>).FullName, ref this.taskT);
+
+    /// <summary>
+    /// Gets a CancellationToken type symbol.
+    /// </summary>
+    public INamedTypeSymbol? CancellationToken => this.GetOrResolveFullyQualifiedType(typeof(CancellationToken).FullName, ref this.cancellationToken);
 }

src/Analyzers/Resources.resx

@@ -153,4 +153,10 @@
   <data name="DurableClientBindingAnalyzerTitle" xml:space="preserve">
     <value>[DurableClient] must be used with DurableTaskClient</value>
   </data>
+  <data name="CancellationTokenOrchestrationAnalyzerMessageFormat" xml:space="preserve">
+    <value>Orchestration '{0}' is using a CancellationToken binding, which is not supported</value>
+  </data>
+  <data name="CancellationTokenOrchestrationAnalyzerTitle" xml:space="preserve">
+    <value>CancellationToken should not be used as an orchestrator function parameter</value>
+  </data>
 </root>

test/Analyzers.Tests/Functions/Orchestration/CancellationTokenOrchestrationAnalyzerTests.cs

@@ -0,0 +1,39 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using Microsoft.CodeAnalysis.Testing;
+using Microsoft.DurableTask.Analyzers.Functions.Orchestration;
+using VerifyCS = Microsoft.DurableTask.Analyzers.Tests.Verifiers.CSharpAnalyzerVerifier<Microsoft.DurableTask.Analyzers.Functions.Orchestration.CancellationTokenOrchestrationAnalyzer>;
+
+namespace Microsoft.DurableTask.Analyzers.Tests.Functions.Orchestration;
+
+public class CancellationTokenOrchestrationAnalyzerTests
+{
+    [Fact]
+    public async Task EmptyCodeHasNoDiag()
+    {
+        string code = @"";
+
+        await VerifyCS.VerifyDurableTaskAnalyzerAsync(code);
+    }
+
+    [Fact]
+    public async Task DurableFunctionOrchestrationUsingCancellationTokenAsParameterHasDiag()
+    {
+        string code = Wrapper.WrapDurableFunctionOrchestration(@"
+[Function(""Run"")]
+void Method([OrchestrationTrigger] TaskOrchestrationContext context, {|#0:CancellationToken token|})
+{
+}
+");
+
+        DiagnosticResult expected = BuildDiagnostic().WithLocation(0).WithArguments("Run");
+
+        await VerifyCS.VerifyDurableTaskAnalyzerAsync(code, expected);
+    }
+
+    static DiagnosticResult BuildDiagnostic()
+    {
+        return VerifyCS.Diagnostic(CancellationTokenOrchestrationAnalyzer.DiagnosticId);
+    }
+}