Stripped Async suffix to generated command names

Author: Sergio0694

Microsoft.Toolkit.Mvvm.SourceGenerators/Input/ICommandGenerator.cs

@@ -126,9 +126,7 @@ private static void OnExecute(
         private static IEnumerable<MemberDeclarationSyntax> CreateCommandMembers(GeneratorExecutionContext context, SyntaxTriviaList leadingTrivia, IMethodSymbol methodSymbol)
         {
             // Get the command member names
-            string
-                propertyName = methodSymbol.Name + "Command",
-                fieldName = $"{char.ToLower(propertyName[0])}{propertyName.Substring(1)}";
+            var (fieldName, propertyName) = GetGeneratedFieldAndPropertyNames(context, methodSymbol);
 
             // Get the command type symbols
             if (!TryMapCommandTypesFromMethod(
@@ -190,6 +188,30 @@ private static IEnumerable<MemberDeclarationSyntax> CreateCommandMembers(Generat
             return new MemberDeclarationSyntax[] { fieldDeclaration, propertyDeclaration };
         }
 
+        /// <summary>
+        /// Get the generated field and property names for the input method.
+        /// </summary>
+        /// <param name="context">The input <see cref="GeneratorExecutionContext"/> instance to use.</param>
+        /// <param name="methodSymbol">The input <see cref="IMethodSymbol"/> instance to process.</param>
+        /// <returns>The generated field and property names for <paramref name="methodSymbol"/>.</returns>
+        [Pure]
+        private static (string FieldName, string PropertyName) GetGeneratedFieldAndPropertyNames(GeneratorExecutionContext context, IMethodSymbol methodSymbol)
+        {
+            string propertyName = methodSymbol.Name;
+
+            if (SymbolEqualityComparer.Default.Equals(methodSymbol.ReturnType, context.Compilation.GetTypeByMetadataName("System.Threading.Tasks.Task")!) &&
+                methodSymbol.Name.EndsWith("Async"))
+            {
+                propertyName = propertyName.Substring(0, propertyName.Length - "Async".Length);
+            }
+
+            propertyName += "Command";
+
+            string fieldName = $"{char.ToLower(propertyName[0])}{propertyName.Substring(1)}";
+
+            return (fieldName, propertyName);
+        }
+
         /// <summary>
         /// Gets the type symbols for the input method, if supported.
         /// </summary>

UnitTests/UnitTests.NetCore/Mvvm/Test_ICommandAttribute.cs

@@ -16,7 +16,7 @@ public partial class Test_ICommandAttribute
     {
         [TestCategory("Mvvm")]
         [TestMethod]
-        public void Test_ICommandAttribute_RelayCommand()
+        public async Task Test_ICommandAttribute_RelayCommand()
         {
             var model = new MyViewModel();
 
@@ -30,19 +30,19 @@ public void Test_ICommandAttribute_RelayCommand()
 
             Assert.AreEqual(model.Counter, 6);
 
-            model.IncrementCounterAsyncCommand.Execute(null);
+            await model.DelayAndIncrementCounterCommand.ExecuteAsync(null);
 
             Assert.AreEqual(model.Counter, 7);
 
-            model.IncrementCounterWithTokenAsyncCommand.Execute(null);
+            await model.DelayAndIncrementCounterWithTokenCommand.ExecuteAsync(null);
 
             Assert.AreEqual(model.Counter, 8);
 
-            model.IncrementCounterWithValueAsyncCommand.Execute(5);
+            await model.DelayAndIncrementCounterWithValueCommand.ExecuteAsync(5);
 
             Assert.AreEqual(model.Counter, 13);
 
-            model.IncrementCounterWithValueAndTokenAsyncCommand.Execute(5);
+            await model.DelayAndIncrementCounterWithValueAndTokenCommand.ExecuteAsync(5);
 
             Assert.AreEqual(model.Counter, 18);
         }
@@ -64,35 +64,35 @@ private void IncrementCounterWithValue(int count)
             }
 
             [ICommand]
-            private Task IncrementCounterAsync()
+            private async Task DelayAndIncrementCounterAsync()
             {
-                Counter += 1;
+                await Task.Delay(50);
 
-                return Task.CompletedTask;
+                Counter += 1;
             }
 
             [ICommand]
-            private Task IncrementCounterWithTokenAsync(CancellationToken token)
+            private async Task DelayAndIncrementCounterWithTokenAsync(CancellationToken token)
             {
-                Counter += 1;
+                await Task.Delay(50);
 
-                return Task.CompletedTask;
+                Counter += 1;
             }
 
             [ICommand]
-            private Task IncrementCounterWithValueAsync(int count)
+            private async Task DelayAndIncrementCounterWithValueAsync(int count)
             {
-                Counter += count;
+                await Task.Delay(50);
 
-                return Task.CompletedTask;
+                Counter += count;
             }
 
             [ICommand]
-            private Task IncrementCounterWithValueAndTokenAsync(int count, CancellationToken token)
+            private async Task DelayAndIncrementCounterWithValueAndTokenAsync(int count, CancellationToken token)
             {
-                Counter += count;
+                await Task.Delay(50);
 
-                return Task.CompletedTask;
+                Counter += count;
             }
         }
     }

UnitTests/UnitTests.NetCore/Mvvm/Test_ObservablePropertyAttribute.cs

@@ -60,7 +60,6 @@ public void Test_AlsoNotifyForAttribute_Events()
         {
             var model = new DependentPropertyModel();
 
-            (PropertyChangedEventArgs, int) changed = default;
             List<string> propertyNames = new();
 
             model.PropertyChanged += (s, e) => propertyNames.Add(e.PropertyName);