Declare command properties as notnull (#46) (#47)

mycroes · Michael Croes · ChrisPulman · web-flow · commit e746a927ff38 · 2024-09-18T23:06:29.000+01:00
* Declare command properties as notnull (#46) * fix(ReactiveCommand): Normalize whitespace for backing field * Remove InitializeCommands from Readme and examples --------- Co-authored-by: Michael Croes <mycroes@mycroes.nl> Co-authored-by: Chris Pulman <chris.pulman@yahoo.com>
diff --git a/README.md b/README.md
@@ -176,11 +176,6 @@ using ReactiveUI.SourceGenerators;
 
 public partial class MyReactiveClass
 {
-    public MyReactiveClass()
-    {
-        InitializeCommands();
-    }
-
     [ReactiveCommand]
     private void Execute() { }
 }
@@ -192,11 +187,6 @@ using ReactiveUI.SourceGenerators;
 
 public partial class MyReactiveClass
 {
-    public MyReactiveClass()
-    {
-        InitializeCommands();
-    }
-
     [ReactiveCommand]
     private void Execute(string parameter) { }
 }
@@ -208,11 +198,6 @@ using ReactiveUI.SourceGenerators;
 
 public partial class MyReactiveClass
 {
-    public MyReactiveClass()
-    {
-        InitializeCommands();
-    }
-
     [ReactiveCommand]
     private string Execute(string parameter) => parameter;
 }
@@ -224,11 +209,6 @@ using ReactiveUI.SourceGenerators;
 
 public partial class MyReactiveClass
 {
-    public MyReactiveClass()
-    {
-        InitializeCommands();
-    }
-
     [ReactiveCommand]
     private async Task<string> Execute(string parameter) => await Task.FromResult(parameter);
 }
@@ -240,11 +220,6 @@ using ReactiveUI.SourceGenerators;
 
 public partial class MyReactiveClass
 {
-    public MyReactiveClass()
-    {
-        InitializeCommands();
-    }
-
     [ReactiveCommand]
     private IObservable<string> Execute(string parameter) => Observable.Return(parameter);
 }
@@ -256,11 +231,6 @@ using ReactiveUI.SourceGenerators;
 
 public partial class MyReactiveClass
 {
-    public MyReactiveClass()
-    {
-        InitializeCommands();
-    }
-
     [ReactiveCommand]
     private async Task Execute(CancellationToken token) => await Task.Delay(1000, token);
 }
@@ -272,11 +242,6 @@ using ReactiveUI.SourceGenerators;
 
 public partial class MyReactiveClass
 {
-    public MyReactiveClass()
-    {
-        InitializeCommands();
-    }
-
     [ReactiveCommand]
     private async Task<string> Execute(string parameter, CancellationToken token)
     {
@@ -302,7 +267,6 @@ public partial class MyReactiveClass
 
     public MyReactiveClass()
     {
-        InitializeCommands();
         _canExecute = this.WhenAnyValue(x => x.MyProperty1, x => x.MyProperty2, (x, y) => !string.IsNullOrEmpty(x) && !string.IsNullOrEmpty(y));
     }
 
@@ -327,7 +291,6 @@ public partial class MyReactiveClass
 
     public MyReactiveClass()
     {
-        InitializeCommands();
         _canExecute = this.WhenAnyValue(x => x.MyProperty1, x => x.MyProperty2, (x, y) => !string.IsNullOrEmpty(x) && !string.IsNullOrEmpty(y));
     }
 
diff --git a/src/ReactiveUI.SourceGenerators.Execute/TestViewModel.cs b/src/ReactiveUI.SourceGenerators.Execute/TestViewModel.cs
@@ -33,7 +33,6 @@ public partial class TestViewModel : ReactiveObject
     /// </summary>
     public TestViewModel()
     {
-        InitializeCommands();
         InitializeOAPH();
 
         Console.Out.WriteLine(Test1Command);
diff --git a/src/ReactiveUI.SourceGenerators/Helpers/AttributeDefinitions.cs b/src/ReactiveUI.SourceGenerators/Helpers/AttributeDefinitions.cs
@@ -11,6 +11,7 @@ internal static class AttributeDefinitions
 {
     public const string GeneratedCode = "global::System.CodeDom.Compiler.GeneratedCode";
     public const string ExcludeFromCodeCoverage = "global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage";
+    public const string Obsolete = "global::System.Obsolete";
     public const string ReactiveObjectAttribute = """
 // Copyright (c) 2024 .NET Foundation and Contributors. All rights reserved.
 // Licensed to the .NET Foundation under one or more agreements.
diff --git a/src/ReactiveUI.SourceGenerators/ReactiveCommand/ReactiveCommandGenerator.Execute.cs b/src/ReactiveUI.SourceGenerators/ReactiveCommand/ReactiveCommandGenerator.Execute.cs
@@ -30,37 +30,14 @@ public partial class ReactiveCommandGenerator
     private const string Create = ".Create";
     private const string CreateO = ".CreateFromObservable";
     private const string CreateT = ".CreateFromTask";
+    private const string ObsoleteReason = "Commands are initialized automatically. Method will be removed in future version.";
 
     /// <summary>
     /// A container for all the logic for <see cref="ReactiveCommandGenerator"/>.
     /// </summary>
     internal static class Execute
     {
-        internal static MethodDeclarationSyntax GetCommandInitiliser(CommandInfo[] commandExtensionInfos)
-        {
-            using var commandInitilisers = ImmutableArrayBuilder<StatementSyntax>.Rent();
-
-            // Add the command initializations
-            foreach (var commandExtensionInfo in commandExtensionInfos)
-            {
-                var commandName = GetGeneratedCommandName(commandExtensionInfo.MethodName);
-                var outputType = commandExtensionInfo.GetOutputTypeText();
-                var inputType = commandExtensionInfo.GetInputTypeText();
-                if (commandExtensionInfo.ArgumentType == null)
-                {
-                    commandInitilisers.Add(GenerateBasicCommand(commandExtensionInfo, commandName));
-                }
-                else if (commandExtensionInfo.ArgumentType != null && commandExtensionInfo.IsReturnTypeVoid)
-                {
-                    commandInitilisers.Add(GenerateInCommand(commandExtensionInfo, commandName, inputType));
-                }
-                else if (commandExtensionInfo.ArgumentType != null && !commandExtensionInfo.IsReturnTypeVoid)
-                {
-                    commandInitilisers.Add(GenerateInOutCommand(commandExtensionInfo, commandName, outputType, inputType));
-                }
-            }
-
-            return MethodDeclaration(
+        internal static MethodDeclarationSyntax GetCommandInitiliser() => MethodDeclaration(
                     PredefinedType(Token(SyntaxKind.VoidKeyword)),
                     Identifier("InitializeCommands"))
                 .AddAttributeLists(
@@ -69,59 +46,45 @@ internal static MethodDeclarationSyntax GetCommandInitiliser(CommandInfo[] comma
                         .AddArgumentListArguments(
                             AttributeArgument(LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(typeof(ReactiveGenerator).FullName))),
                             AttributeArgument(LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(typeof(ReactiveGenerator).Assembly.GetName().Version.ToString())))))),
-                    AttributeList(SingletonSeparatedList(Attribute(IdentifierName(AttributeDefinitions.ExcludeFromCodeCoverage)))))
+                    AttributeList(SingletonSeparatedList(Attribute(IdentifierName(AttributeDefinitions.ExcludeFromCodeCoverage)))),
+                    AttributeList(SingletonSeparatedList(Attribute(IdentifierName(AttributeDefinitions.Obsolete))
+                        .AddArgumentListArguments(
+                            AttributeArgument(LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(ObsoleteReason)))))))
                 .WithModifiers(TokenList(Token(SyntaxKind.ProtectedKeyword)))
-                .WithBody(Block(commandInitilisers.ToImmutable()));
+                .WithBody(Block());
 
-            static StatementSyntax GenerateBasicCommand(CommandInfo commandExtensionInfo, string commandName)
-            {
-                var commandType = commandExtensionInfo.IsObservable ? CreateO : commandExtensionInfo.IsTask ? CreateT : Create;
-                if (string.IsNullOrEmpty(commandExtensionInfo.CanExecuteObservableName))
-                {
-                    return ParseStatement($"{commandName} = {RxCmd}{commandType}({commandExtensionInfo.MethodName});");
-                }
+        internal static MemberDeclarationSyntax[] GetCommandProperty(CommandInfo commandExtensionInfo)
+        {
+            var outputType = commandExtensionInfo.GetOutputTypeText();
+            var inputType = commandExtensionInfo.GetInputTypeText();
+            var commandName = GetGeneratedCommandName(commandExtensionInfo.MethodName);
+            var fieldName = GetGeneratedFieldName(commandName);
 
-                return ParseStatement($"{commandName} = {RxCmd}{commandType}({commandExtensionInfo.MethodName}, {commandExtensionInfo.CanExecuteObservableName}{(commandExtensionInfo.CanExecuteTypeInfo == CanExecuteTypeInfo.MethodObservable ? "()" : string.Empty)});");
+            ExpressionSyntax initializer;
+            if (commandExtensionInfo.ArgumentType == null)
+            {
+                initializer = GenerateBasicCommand(commandExtensionInfo, fieldName);
             }
-
-            static StatementSyntax GenerateInOutCommand(CommandInfo commandExtensionInfo, string commandName, string outputType, string inputType)
+            else if (commandExtensionInfo.ArgumentType != null && commandExtensionInfo.IsReturnTypeVoid)
             {
-                var commandType = commandExtensionInfo.IsObservable ? CreateO : commandExtensionInfo.IsTask ? CreateT : Create;
-                if (string.IsNullOrEmpty(commandExtensionInfo.CanExecuteObservableName))
-                {
-                    return ParseStatement($"{commandName} = {RxCmd}{commandType}<{inputType}, {outputType}>({commandExtensionInfo.MethodName});");
-                }
-
-                return ParseStatement($"{commandName} = {RxCmd}{commandType}<{inputType}, {outputType}>({commandExtensionInfo.MethodName}, {commandExtensionInfo.CanExecuteObservableName}{(commandExtensionInfo.CanExecuteTypeInfo == CanExecuteTypeInfo.MethodObservable ? "()" : string.Empty)});");
+                initializer = GenerateInCommand(commandExtensionInfo, fieldName, inputType);
             }
-
-            static StatementSyntax GenerateInCommand(CommandInfo commandExtensionInfo, string commandName, string inputType)
+            else if (commandExtensionInfo.ArgumentType != null && !commandExtensionInfo.IsReturnTypeVoid)
             {
-                var commandType = commandExtensionInfo.IsTask ? CreateT : Create;
-                if (string.IsNullOrEmpty(commandExtensionInfo.CanExecuteObservableName))
-                {
-                    return ParseStatement($"{commandName} = {RxCmd}{commandType}<{inputType}>({commandExtensionInfo.MethodName});");
-                }
-
-                return ParseStatement($"{commandName} = {RxCmd}{commandType}<{inputType}>({commandExtensionInfo.MethodName}, {commandExtensionInfo.CanExecuteObservableName}{(commandExtensionInfo.CanExecuteTypeInfo == CanExecuteTypeInfo.MethodObservable ? "()" : string.Empty)});");
+                initializer = GenerateInOutCommand(commandExtensionInfo, fieldName, outputType, inputType);
+            }
+            else
+            {
+                return [];
             }
-        }
-
-        internal static MemberDeclarationSyntax GetCommandProperty(CommandInfo commandExtensionInfo)
-        {
-            var outputType = commandExtensionInfo.GetOutputTypeText();
-            var inputType = commandExtensionInfo.GetInputTypeText();
-            var commandName = GetGeneratedCommandName(commandExtensionInfo.MethodName);
 
             // Prepare any forwarded property attributes
             var forwardedPropertyAttributes =
             commandExtensionInfo.ForwardedPropertyAttributes
             .Select(static a => AttributeList(SingletonSeparatedList(a.GetSyntax())))
             .ToImmutableArray();
 
-            var commandDeclaration = PropertyDeclaration(
-                NullableType(
-            QualifiedName(
+            var qualifiedName = QualifiedName(
                 IdentifierName(ReactiveUI),
                 GenericName(
                     Identifier(ReactiveCommand))
@@ -133,18 +96,63 @@ internal static MemberDeclarationSyntax GetCommandProperty(CommandInfo commandEx
                                     IdentifierName(inputType),
                                     Token(SyntaxKind.CommaToken),
                                     IdentifierName(outputType)
-                            }))))),
+                            }))));
+
+            var fieldDeclaration = FieldDeclaration(
+                VariableDeclaration(NullableType(qualifiedName)))
+                .AddDeclarationVariables(VariableDeclarator(fieldName))
+                .AddAttributeLists(AttributeList(SingletonSeparatedList(
+                        Attribute(IdentifierName(AttributeDefinitions.GeneratedCode))
+                        .AddArgumentListArguments(
+                            AttributeArgument(LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(typeof(ReactiveCommandGenerator).FullName))),
+                            AttributeArgument(LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(typeof(ReactiveCommandGenerator).Assembly.GetName().Version.ToString())))))))
+                        .AddModifiers(
+                        Token(SyntaxKind.PrivateKeyword))
+                        .NormalizeWhitespace();
+
+            var commandDeclaration = PropertyDeclaration(
+                qualifiedName,
                 Identifier(commandName))
                 .AddModifiers(Token(SyntaxKind.PublicKeyword))
                 .AddAccessorListAccessors(
                     AccessorDeclaration(SyntaxKind.GetAccessorDeclaration)
-                        .WithSemicolonToken(Token(SyntaxKind.SemicolonToken)),
-                    AccessorDeclaration(SyntaxKind.SetAccessorDeclaration)
-                        .WithModifiers(TokenList(Token(SyntaxKind.PrivateKeyword)))
-                        .WithSemicolonToken(Token(SyntaxKind.SemicolonToken)))
+                        .WithExpressionBody(ArrowExpressionClause(initializer)))
                 .AddAttributeLists([.. forwardedPropertyAttributes])
                 .NormalizeWhitespace();
-            return commandDeclaration;
+            return [fieldDeclaration, commandDeclaration];
+
+            static ExpressionSyntax GenerateBasicCommand(CommandInfo commandExtensionInfo, string fieldName)
+            {
+                var commandType = commandExtensionInfo.IsObservable ? CreateO : commandExtensionInfo.IsTask ? CreateT : Create;
+                if (string.IsNullOrEmpty(commandExtensionInfo.CanExecuteObservableName))
+                {
+                    return ParseExpression($"{fieldName} ??= {RxCmd}{commandType}({commandExtensionInfo.MethodName});");
+                }
+
+                return ParseExpression($"{fieldName} ??= {RxCmd}{commandType}({commandExtensionInfo.MethodName}, {commandExtensionInfo.CanExecuteObservableName}{(commandExtensionInfo.CanExecuteTypeInfo == CanExecuteTypeInfo.MethodObservable ? "()" : string.Empty)});");
+            }
+
+            static ExpressionSyntax GenerateInOutCommand(CommandInfo commandExtensionInfo, string fieldName, string outputType, string inputType)
+            {
+                var commandType = commandExtensionInfo.IsObservable ? CreateO : commandExtensionInfo.IsTask ? CreateT : Create;
+                if (string.IsNullOrEmpty(commandExtensionInfo.CanExecuteObservableName))
+                {
+                    return ParseExpression($"{fieldName} ??= {RxCmd}{commandType}<{inputType}, {outputType}>({commandExtensionInfo.MethodName});");
+                }
+
+                return ParseExpression($"{fieldName} ??= {RxCmd}{commandType}<{inputType}, {outputType}>({commandExtensionInfo.MethodName}, {commandExtensionInfo.CanExecuteObservableName}{(commandExtensionInfo.CanExecuteTypeInfo == CanExecuteTypeInfo.MethodObservable ? "()" : string.Empty)});");
+            }
+
+            static ExpressionSyntax GenerateInCommand(CommandInfo commandExtensionInfo, string fieldName, string inputType)
+            {
+                var commandType = commandExtensionInfo.IsTask ? CreateT : Create;
+                if (string.IsNullOrEmpty(commandExtensionInfo.CanExecuteObservableName))
+                {
+                    return ParseExpression($"{fieldName} ??= {RxCmd}{commandType}<{inputType}>({commandExtensionInfo.MethodName});");
+                }
+
+                return ParseExpression($"{fieldName} ??= {RxCmd}{commandType}<{inputType}>({commandExtensionInfo.MethodName}, {commandExtensionInfo.CanExecuteObservableName}{(commandExtensionInfo.CanExecuteTypeInfo == CanExecuteTypeInfo.MethodObservable ? "()" : string.Empty)});");
+            }
         }
 
         internal static bool IsTaskReturnType(ITypeSymbol? typeSymbol)
@@ -458,5 +466,8 @@ internal static string GetGeneratedCommandName(string methodName)
 
             return $"{char.ToUpper(commandName[0], CultureInfo.InvariantCulture)}{commandName.Substring(1)}Command";
         }
+
+        internal static string GetGeneratedFieldName(string generatedCommandName) =>
+            $"_{char.ToLower(generatedCommandName[0], CultureInfo.InvariantCulture)}{generatedCommandName.Substring(1)}";
     }
 }
diff --git a/src/ReactiveUI.SourceGenerators/ReactiveCommand/ReactiveCommandGenerator.cs b/src/ReactiveUI.SourceGenerators/ReactiveCommand/ReactiveCommandGenerator.cs
@@ -139,10 +139,10 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
             // Generate all member declarations for the current type
             var propertyDeclarations =
                 commandInfos
-                .Select(Execute.GetCommandProperty)
+                .SelectMany(Execute.GetCommandProperty)
                 .ToList();
 
-            var c = Execute.GetCommandInitiliser(commandInfos);
+            var c = Execute.GetCommandInitiliser();
             propertyDeclarations.Add(c);
             var memberDeclarations = propertyDeclarations.ToImmutableArray();
 

Original file line number	Diff line number	Diff line change
`@@ -176,11 +176,6 @@ using ReactiveUI.SourceGenerators;`
`176`	`176`
`177`	`177`	`public partial class MyReactiveClass`
`178`	`178`	`{`
`179`		`- public MyReactiveClass()`
`180`		`- {`
`181`		`- InitializeCommands();`
`182`		`- }`
`183`		`-`
`184`	`179`	`[ReactiveCommand]`
`185`	`180`	`private void Execute() { }`
`186`	`181`	`}`
`@@ -192,11 +187,6 @@ using ReactiveUI.SourceGenerators;`
`192`	`187`
`193`	`188`	`public partial class MyReactiveClass`
`194`	`189`	`{`
`195`		`- public MyReactiveClass()`
`196`		`- {`
`197`		`- InitializeCommands();`
`198`		`- }`
`199`		`-`
`200`	`190`	`[ReactiveCommand]`
`201`	`191`	`private void Execute(string parameter) { }`
`202`	`192`	`}`
`@@ -208,11 +198,6 @@ using ReactiveUI.SourceGenerators;`
`208`	`198`
`209`	`199`	`public partial class MyReactiveClass`
`210`	`200`	`{`
`211`		`- public MyReactiveClass()`
`212`		`- {`
`213`		`- InitializeCommands();`
`214`		`- }`
`215`		`-`
`216`	`201`	`[ReactiveCommand]`
`217`	`202`	`private string Execute(string parameter) => parameter;`
`218`	`203`	`}`
`@@ -224,11 +209,6 @@ using ReactiveUI.SourceGenerators;`
`224`	`209`
`225`	`210`	`public partial class MyReactiveClass`
`226`	`211`	`{`
`227`		`- public MyReactiveClass()`
`228`		`- {`
`229`		`- InitializeCommands();`
`230`		`- }`
`231`		`-`
`232`	`212`	`[ReactiveCommand]`
`233`	`213`	`private async Task<string> Execute(string parameter) => await Task.FromResult(parameter);`
`234`	`214`	`}`
`@@ -240,11 +220,6 @@ using ReactiveUI.SourceGenerators;`
`240`	`220`
`241`	`221`	`public partial class MyReactiveClass`
`242`	`222`	`{`
`243`		`- public MyReactiveClass()`
`244`		`- {`
`245`		`- InitializeCommands();`
`246`		`- }`
`247`		`-`
`248`	`223`	`[ReactiveCommand]`
`249`	`224`	`private IObservable<string> Execute(string parameter) => Observable.Return(parameter);`
`250`	`225`	`}`
`@@ -256,11 +231,6 @@ using ReactiveUI.SourceGenerators;`
`256`	`231`
`257`	`232`	`public partial class MyReactiveClass`
`258`	`233`	`{`
`259`		`- public MyReactiveClass()`
`260`		`- {`
`261`		`- InitializeCommands();`
`262`		`- }`
`263`		`-`
`264`	`234`	`[ReactiveCommand]`
`265`	`235`	`private async Task Execute(CancellationToken token) => await Task.Delay(1000, token);`
`266`	`236`	`}`
`@@ -272,11 +242,6 @@ using ReactiveUI.SourceGenerators;`
`272`	`242`
`273`	`243`	`public partial class MyReactiveClass`
`274`	`244`	`{`
`275`		`- public MyReactiveClass()`
`276`		`- {`
`277`		`- InitializeCommands();`
`278`		`- }`
`279`		`-`
`280`	`245`	`[ReactiveCommand]`
`281`	`246`	`private async Task<string> Execute(string parameter, CancellationToken token)`
`282`	`247`	`{`
`@@ -302,7 +267,6 @@ public partial class MyReactiveClass`
`302`	`267`
`303`	`268`	`public MyReactiveClass()`
`304`	`269`	`{`
`305`		`- InitializeCommands();`
`306`	`270`	`_canExecute = this.WhenAnyValue(x => x.MyProperty1, x => x.MyProperty2, (x, y) => !string.IsNullOrEmpty(x) && !string.IsNullOrEmpty(y));`
`307`	`271`	`}`
`308`	`272`
`@@ -327,7 +291,6 @@ public partial class MyReactiveClass`
`327`	`291`
`328`	`292`	`public MyReactiveClass()`
`329`	`293`	`{`
`330`		`- InitializeCommands();`
`331`	`294`	`_canExecute = this.WhenAnyValue(x => x.MyProperty1, x => x.MyProperty2, (x, y) => !string.IsNullOrEmpty(x) && !string.IsNullOrEmpty(y));`
`332`	`295`	`}`
`333`	`296`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,6 @@ public partial class TestViewModel : ReactiveObject`
`33`	`33`	`/// </summary>`
`34`	`34`	`public TestViewModel()`
`35`	`35`	`{`
`36`		`- InitializeCommands();`
`37`	`36`	`InitializeOAPH();`
`38`	`37`
`39`	`38`	`Console.Out.WriteLine(Test1Command);`
Original file line number	Diff line number	Diff line change
`@@ -11,6 +11,7 @@ internal static class AttributeDefinitions`
`11`	`11`	`{`
`12`	`12`	`public const string GeneratedCode = "global::System.CodeDom.Compiler.GeneratedCode";`
`13`	`13`	`public const string ExcludeFromCodeCoverage = "global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage";`
	`14`	`+ public const string Obsolete = "global::System.Obsolete";`
`14`	`15`	`public const string ReactiveObjectAttribute = """`
`15`	`16`	`// Copyright (c) 2024 .NET Foundation and Contributors. All rights reserved.`
`16`	`17`	`// Licensed to the .NET Foundation under one or more agreements.`