CQ: Redesign the code

Author: XTorLukas

src/Files.Core.SourceGenerator/Constants.cs

@@ -104,6 +104,16 @@ internal class StringsPropertyGenerator
 		/// </summary>
 		internal class RealTimeLayoutGenerator
 		{
+			/// <summary>
+			/// The name of the real-time service interface.
+			/// </summary>
+			internal const string ServiceInterfaceName = "IRealTimeLayoutService";
+
+			/// <summary>
+			/// The name of the real-time service generated variable.
+			/// </summary>
+			internal const string ServiceVariableName = "__rtls__";
+
 			/// <summary>
 			/// The name of the real-time specification window.
 			/// </summary>

src/Files.Core.SourceGenerator/Generators/RealTimeLayoutGenerator.cs

@@ -47,7 +47,7 @@ private static bool IsValidCandidate(SyntaxNode syntaxNode)
 			{
 				return classDeclaration.BaseList?.Types.Any(baseType => baseType.Type is IdentifierNameSyntax identifier &&
 					(identifier.Identifier.Text == SpecificationWindowName || identifier.Identifier.Text == SpecificationControlName)) == true;
-			}
+		}
 			return false;
 		}
 
@@ -72,10 +72,7 @@ private static (ClassDeclarationSyntax Class, SpecificationType Type)? GetCandid
 				}
 			}
 
-			if (type != SpecificationType.None)
-				return (classDeclaration, type);
-
-			return null;
+			return type != SpecificationType.None ? (classDeclaration, type) : null;
 		}
 
 		/// <summary>
@@ -89,41 +86,43 @@ private static string GenerateClass(string namespaceName, string className, Spec
 		{
 			// Namespace
 			var namespaceDeclaration = SyntaxFactory.NamespaceDeclaration(SyntaxFactory.ParseName(namespaceName))
+				.WithLeadingTrivia(SourceGeneratorHelper.GetLicenceHeader())
 				.NormalizeWhitespace();
 
 			// Usings
-			var usings = new[]
-			{
-				SyntaxFactory.UsingDirective(SyntaxFactory.ParseName("System.Windows")),
-				SyntaxFactory.UsingDirective(SyntaxFactory.ParseName("Microsoft.UI.Xaml")),
-				SyntaxFactory.UsingDirective(SyntaxFactory.ParseName("Microsoft.UI.Xaml.Controls"))
-			};
+			var usings = Array.Empty<UsingDirectiveSyntax>();
 
 			// Field declaration: private IRealTimeLayoutService RTLayoutService;
 			var fieldDeclaration = SyntaxFactory.FieldDeclaration(
 				SyntaxFactory.VariableDeclaration(
-					SyntaxFactory.IdentifierName("IRealTimeLayoutService"))
-				.AddVariables(SyntaxFactory.VariableDeclarator("RTLayoutService")))
-				.AddModifiers(SyntaxFactory.Token(SyntaxKind.PrivateKeyword));
+					SyntaxFactory.IdentifierName(ServiceInterfaceName))
+				.AddVariables(SyntaxFactory.VariableDeclarator(ServiceVariableName)
+					.WithInitializer(SyntaxFactory.EqualsValueClause(
+						SyntaxFactory.ParseExpression($"Ioc.Default.GetRequiredService<{ServiceInterfaceName}>()")))))
+				.AddModifiers(SyntaxFactory.Token(SyntaxKind.PrivateKeyword), SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword))
+				.AddAttributeLists(SourceGeneratorHelper.GetAttributeForField(nameof(RealTimeLayoutGenerator)));
 
 			// Method: InitializeContentLayout
 			var initializeContentLayoutMethod = SyntaxFactory.MethodDeclaration(
 					SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.VoidKeyword)),
 					"InitializeContentLayout")
 				.AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword))
-				.WithBody(SyntaxFactory.Block(CreateInitializeContentLayoutBody(type)));
+				.WithBody(SyntaxFactory.Block(CreateContentLayoutBody(type, isInitialize: true)))
+				.AddAttributeLists(SourceGeneratorHelper.GetAttributeForMethod(nameof(RealTimeLayoutGenerator)));
 
 			// Method: UpdateContentLayout
 			var updateContentLayoutMethod = SyntaxFactory.MethodDeclaration(
 					SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.VoidKeyword)),
 					"UpdateContentLayout")
 				.AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword))
-				.WithBody(SyntaxFactory.Block(CreateUpdateContentLayoutBody(type)));
+				.WithBody(SyntaxFactory.Block(CreateContentLayoutBody(type)))
+				.AddAttributeLists(SourceGeneratorHelper.GetAttributeForMethod(nameof(RealTimeLayoutGenerator)));
 
 			// Class declaration
 			var classDeclaration = SyntaxFactory.ClassDeclaration(className)
 				.AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword), SyntaxFactory.Token(SyntaxKind.PartialKeyword))
-				.AddMembers(fieldDeclaration, initializeContentLayoutMethod, updateContentLayoutMethod);
+				.AddMembers(fieldDeclaration, initializeContentLayoutMethod, updateContentLayoutMethod)
+				.AddAttributeLists(SourceGeneratorHelper.GetAttributeForField(nameof(RealTimeLayoutGenerator)));
 
 			// Add class to namespace
 			namespaceDeclaration = namespaceDeclaration.AddMembers(classDeclaration);
@@ -133,44 +132,66 @@ private static string GenerateClass(string namespaceName, string className, Spec
 				.AddMembers(namespaceDeclaration)
 				.NormalizeWhitespace();
 
-			return compilationUnit.ToFullString();
+			return SyntaxFactory.SyntaxTree(compilationUnit, encoding: Encoding.UTF8).GetText().ToString();
 		}
 
 		/// <summary>
-		/// Creates the body statements for the InitializeContentLayout method.
+		/// Creates a collection of statements for updating the content layout body.
+		/// Depending on the specification type, it will update the title bar and content layout.
+		/// If the <paramref name="isInitialize"/> flag is set to true, a callback is added for updating the content layout.
 		/// </summary>
-		/// <param name="type">The type of the specification (Window or Control).</param>
-		/// <returns>A collection of statements for the method body.</returns>
-		private static IEnumerable<StatementSyntax> CreateInitializeContentLayoutBody(SpecificationType type)
-		{
-			var statements = new List<StatementSyntax>
-			{
-
-				SyntaxFactory.ParseStatement("RTLayoutService = Ioc.Default.GetRequiredService<IRealTimeLayoutService>();")
-			};
-
-			if (type == SpecificationType.Window)
-				statements.Add(SyntaxFactory.ParseStatement("RTLayoutService.UpdateTitleBar(this);"));
-
-			statements.Add(SyntaxFactory.ParseStatement("RTLayoutService.UpdateContent(this);"));
-			statements.Add(SyntaxFactory.ParseStatement("RTLayoutService.AddCallback(this, UpdateContentLayout);"));
-
-			return statements;
-		}
-
-		/// <summary>
-		/// Creates the body statements for the UpdateContentLayout method.
-		/// </summary>
-		/// <param name="type">The type of the specification (Window or Control).</param>
-		/// <returns>A collection of statements for the method body.</returns>
-		private static IEnumerable<StatementSyntax> CreateUpdateContentLayoutBody(SpecificationType type)
+		/// <param name="type">The specification type, used to determine if the title bar should be updated.</param>
+		/// <param name="isInitialize">A flag indicating whether to add a callback for content layout initialization.</param>
+		/// <returns>An IEnumerable of <see cref="StatementSyntax"/> representing the generated statements.</returns>
+		private static IEnumerable<StatementSyntax> CreateContentLayoutBody(SpecificationType type, bool isInitialize = false)
 		{
 			var statements = new List<StatementSyntax>();
 
 			if (type == SpecificationType.Window)
-				statements.Add(SyntaxFactory.ParseStatement("RTLayoutService.UpdateTitleBar(this);"));
+			{
+				statements.Add(
+					SyntaxFactory.ExpressionStatement(
+						SyntaxFactory.InvocationExpression(
+							SyntaxFactory.MemberAccessExpression(
+								SyntaxKind.SimpleMemberAccessExpression,
+								SyntaxFactory.IdentifierName(ServiceVariableName),
+								SyntaxFactory.IdentifierName("UpdateTitleBar")))
+						.WithArgumentList(
+							SyntaxFactory.ArgumentList(
+								SyntaxFactory.SingletonSeparatedList(
+									SyntaxFactory.Argument(SyntaxFactory.ThisExpression()))))));
+			}
 
-			statements.Add(SyntaxFactory.ParseStatement("RTLayoutService.UpdateContent(this);"));
+			statements.Add(
+				SyntaxFactory.ExpressionStatement(
+					SyntaxFactory.InvocationExpression(
+						SyntaxFactory.MemberAccessExpression(
+							SyntaxKind.SimpleMemberAccessExpression,
+							SyntaxFactory.IdentifierName(ServiceVariableName),
+							SyntaxFactory.IdentifierName("UpdateContent")))
+					.WithArgumentList(
+						SyntaxFactory.ArgumentList(
+							SyntaxFactory.SingletonSeparatedList(
+								SyntaxFactory.Argument(SyntaxFactory.ThisExpression()))))));
+
+			if (isInitialize)
+			{
+				statements.Add(
+				SyntaxFactory.ExpressionStatement(
+					SyntaxFactory.InvocationExpression(
+						SyntaxFactory.MemberAccessExpression(
+							SyntaxKind.SimpleMemberAccessExpression,
+							SyntaxFactory.IdentifierName(ServiceVariableName),
+							SyntaxFactory.IdentifierName("AddCallback")))
+					.WithArgumentList(
+						SyntaxFactory.ArgumentList(
+							SyntaxFactory.SeparatedList(
+								new[]
+								{
+							SyntaxFactory.Argument(SyntaxFactory.ThisExpression()),
+							SyntaxFactory.Argument(SyntaxFactory.IdentifierName("UpdateContentLayout"))
+								})))));
+			}
 
 			return statements;
 		}
@@ -188,6 +209,7 @@ private static string GetNamespace(SyntaxNode node)
 					return namespaceDeclaration.Name.ToString();
 				node = node.Parent!;
 			}
+
 			return "GlobalNamespace";
 		}
 	}

src/Files.Core.SourceGenerator/Utilities/SourceGeneratorHelper.cs

@@ -377,5 +377,17 @@ internal static StringBuilder GenerateFileHeader(this HashSet<string> namespaces
 				_ = stringBuilder.AppendLine($"using {s};");
 			return stringBuilder;
 		}
+
+		/// <summary>
+		/// Generates a license header comment for the code.
+		/// </summary>
+		/// <returns>A <see cref="SyntaxTriviaList"/> containing the license header comment and a line break.</returns>
+		internal static SyntaxTriviaList GetLicenceHeader()
+		{
+			return SyntaxFactory.TriviaList(
+				SyntaxFactory.Comment(
+					new StringBuilder().AppendLicenceHeader().ToString()),
+				SyntaxFactory.CarriageReturnLineFeed);
+		}
 	}
 }