Improvements

Author: obvEve

SecretAPI.CodeGeneration/CodeBuilders/ClassBuilder.cs

@@ -4,25 +4,23 @@ internal class ClassBuilder : CodeBuilder<ClassBuilder>
 {
     private NamespaceDeclarationSyntax _namespaceDeclaration;
     private ClassDeclarationSyntax _classDeclaration;
-    private string _className;
 
     private readonly List<UsingDirectiveSyntax> _usings = new();
     private readonly List<MethodDeclarationSyntax> _methods = new();
 
-    private ClassBuilder(string @namespace, string className)
+    private ClassBuilder(NamespaceDeclarationSyntax namespaceDeclaration, ClassDeclarationSyntax classDeclaration)
     {
-        _namespaceDeclaration = NamespaceDeclaration(ParseName(@namespace));
-        _className = className;
-        _classDeclaration = ClassDeclaration(className);
+        _namespaceDeclaration = namespaceDeclaration;
+        _classDeclaration = classDeclaration;
 
         AddUsingStatements("System.CodeDom.Compiler");
     }
-    
-    internal static ClassBuilder CreateBuilder(string @namespace, string className)
-        => new(@namespace, className);
 
     internal static ClassBuilder CreateBuilder(INamedTypeSymbol namedClass)
-        => new(namedClass.ContainingNamespace.ToDisplayString(), namedClass.Name);
+        => CreateBuilder(NamespaceDeclaration(ParseName(namedClass.ContainingNamespace.ToDisplayString())), ClassDeclaration(namedClass.Name));
+
+    internal static ClassBuilder CreateBuilder(NamespaceDeclarationSyntax namespaceDeclaration, ClassDeclarationSyntax classDeclaration)
+        => new(namespaceDeclaration, classDeclaration);
 
     internal ClassBuilder AddUsingStatements(params string[] usingStatements)
     {
@@ -36,7 +34,8 @@ internal ClassBuilder AddUsingStatements(params string[] usingStatements)
         return this;
     }
 
-    internal MethodBuilder StartMethodCreation(string methodName, string returnType) => new(this, methodName, returnType);
+    internal MethodBuilder StartMethodCreation(string methodName, TypeSyntax returnType) => new(this, methodName, returnType);
+    internal MethodBuilder StartMethodCreation(string methodName, SyntaxKind returnType) => StartMethodCreation(methodName, GetPredefinedTypeSyntax(returnType));
 
     internal void AddMethodDefinition(MethodDeclarationSyntax method) => _methods.Add(method);
 

SecretAPI.CodeGeneration/CodeBuilders/MethodBuilder.cs

@@ -6,9 +6,9 @@ internal class MethodBuilder : CodeBuilder<MethodBuilder>
     private readonly List<ParameterSyntax> _parameters = new();
     private readonly List<StatementSyntax> _statements = new();
     private readonly string _methodName;
-    private readonly string _returnType;
+    private readonly TypeSyntax _returnType;
 
-    internal MethodBuilder(ClassBuilder classBuilder, string methodName, string returnType)
+    internal MethodBuilder(ClassBuilder classBuilder, string methodName, TypeSyntax returnType)
     {
         _classBuilder = classBuilder;
         _methodName = methodName;
@@ -33,7 +33,7 @@ internal ClassBuilder FinishMethodBuild()
     {
         BlockSyntax body = _statements.Any() ? Block(_statements) : Block();
 
-        MethodDeclarationSyntax methodDeclaration = MethodDeclaration(ParseTypeName(_returnType), _methodName)
+        MethodDeclarationSyntax methodDeclaration = MethodDeclaration(_returnType, _methodName)
             .AddModifiers(_modifiers.ToArray())
             .AddParameterListParameters(_parameters.ToArray())
             .WithBody(body);

SecretAPI.CodeGeneration/Generators/CallOnLoadGenerator.cs

@@ -106,16 +106,16 @@ private static void Generate(
         CompilationUnitSyntax compilation = ClassBuilder.CreateBuilder(pluginClassSymbol)
             .AddUsingStatements("System")
             .AddModifiers(SyntaxKind.PartialKeyword)
-            .StartMethodCreation("OnLoad", "void")
+            .StartMethodCreation("OnLoad", SyntaxKind.VoidKeyword)
             .AddModifiers(SyntaxKind.PublicKeyword)
             .AddStatements(MethodCallStatements(loadCalls))
             .FinishMethodBuild()
-            .StartMethodCreation("OnUnload", "void")
+            .StartMethodCreation("OnUnload", SyntaxKind.VoidKeyword)
             .AddModifiers(SyntaxKind.PublicKeyword)
             .AddStatements(MethodCallStatements(unloadCalls))
             .FinishMethodBuild()
             .Build();
-        
+
         context.AddSource($"{pluginClassSymbol.Name}.g.cs",  compilation.ToFullString());
     }
 }

SecretAPI.CodeGeneration/Generators/CustomCommandGenerator.cs

@@ -92,7 +92,7 @@ private static void Generate(
             .AddUsingStatements("System", "System.Collections.Generic")
             .AddUsingStatements("CommandSystem")
             .AddModifiers(SyntaxKind.PartialKeyword)
-            .StartMethodCreation(ExecuteMethodName, "bool")
+            .StartMethodCreation(ExecuteMethodName, SyntaxKind.BoolKeyword)
             .AddModifiers(SyntaxKind.PublicKeyword, SyntaxKind.OverrideKeyword)
             .AddParameters(ArgumentsParam, SenderParam, ResponseParam)
             .FinishMethodBuild()

SecretAPI.CodeGeneration/Utils/MethodUtils.cs

@@ -2,20 +2,19 @@
 
 internal static class MethodUtils
 {
-    internal static StatementSyntax MethodCallStatement(string typeName, string methodName)
+    internal static StatementSyntax MethodCallStatement(string typeName, string methodName) =>
+        MethodCallStatement(ParseTypeName(typeName), IdentifierName(methodName));
+    
+    internal static StatementSyntax MethodCallStatement(TypeSyntax type, IdentifierNameSyntax method)
         => ExpressionStatement(
             InvocationExpression(
                 MemberAccessExpression(
                     SyntaxKind.SimpleMemberAccessExpression,
-                    ParseTypeName(typeName), IdentifierName(methodName))));
+                    type, method)));
 
     internal static StatementSyntax[] MethodCallStatements(IMethodSymbol[] methodCalls)
     {
-        List<StatementSyntax> statements = new();
-        
-        foreach (IMethodSymbol method in methodCalls)
-            statements.Add(MethodCallStatement(method.ContainingType.ToDisplayString(), method.Name));
-
+        IEnumerable<StatementSyntax> statements = methodCalls.Select(s => MethodCallStatement(s.ContainingType.ToDisplayString(), s.Name));
         return statements.ToArray();
     }
 }