WIP: Custom Command handling

SecretAPI.CodeGeneration/AnalyzerReleases.Shipped.md

@@ -0,0 +1 @@
+

SecretAPI.CodeGeneration/AnalyzerReleases.Unshipped.md

@@ -0,0 +1,5 @@
+### New Rules
+
+ Rule ID    | Category | Severity | Notes               
+------------|----------|----------|---------------------
+ SecretGen0 | Usage    | Error    | CA6000_AnalyzerName 

SecretAPI.CodeGeneration/CodeBuilders/ClassBuilder.cs

@@ -0,0 +1,60 @@
+namespace SecretAPI.CodeGeneration.CodeBuilders;
+
+internal class ClassBuilder : CodeBuilder<ClassBuilder>
+{
+    private NamespaceDeclarationSyntax _namespaceDeclaration;
+    private ClassDeclarationSyntax _classDeclaration;
+
+    private readonly List<UsingDirectiveSyntax> _usings = new();
+    private readonly List<MethodDeclarationSyntax> _methods = new();
+
+    private ClassBuilder(NamespaceDeclarationSyntax namespaceDeclaration, ClassDeclarationSyntax classDeclaration)
+    {
+        _namespaceDeclaration = namespaceDeclaration;
+        _classDeclaration = classDeclaration;
+
+        AddUsingStatements("System.CodeDom.Compiler");
+    }
+
+    internal static ClassBuilder CreateBuilder(INamedTypeSymbol namedClass)
+        => 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)
+    {
+        foreach (string statement in usingStatements)
+        {
+            UsingDirectiveSyntax usings = UsingDirective(ParseName(statement));
+            if (!_usings.Any(existing => existing.IsEquivalentTo(usings)))
+                _usings.Add(usings);
+        }
+
+        return this;
+    }
+
+    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);
+
+    internal CompilationUnitSyntax Build()
+    {
+        _classDeclaration = _classDeclaration
+            .AddAttributeLists(GetGeneratedCodeAttributeListSyntax())
+            .AddModifiers(_modifiers.ToArray())
+            .AddMembers(_methods.Cast<MemberDeclarationSyntax>().ToArray());
+
+        _namespaceDeclaration = _namespaceDeclaration
+            .AddUsings(_usings.ToArray())
+            .AddMembers(_classDeclaration);
+
+        return CompilationUnit()
+            .AddMembers(_namespaceDeclaration)
+            .NormalizeWhitespace()
+            .WithLeadingTrivia(Comment("// <auto-generated>"), LineFeed, Comment("#pragma warning disable"), LineFeed, LineFeed);
+    }
+
+    internal void Build(SourceProductionContext context, string name) => context.AddSource(name, Build().ToFullString());
+}

SecretAPI.CodeGeneration/CodeBuilders/CodeBuilder.cs

@@ -0,0 +1,19 @@
+namespace SecretAPI.CodeGeneration.CodeBuilders;
+
+/// <summary>
+/// Base of a code builder.
+/// </summary>
+/// <typeparam name="TCodeBuilder">The <see cref="CodeBuilder{TCodeBuilder}"/> this is handling.</typeparam>
+internal abstract class CodeBuilder<TCodeBuilder>
+    where TCodeBuilder : CodeBuilder<TCodeBuilder>
+{
+    protected readonly List<SyntaxToken> _modifiers = new();
+
+    internal TCodeBuilder AddModifiers(params SyntaxKind[] modifiers)
+    {
+        foreach (SyntaxKind token in modifiers)
+            _modifiers.Add(Token(token));
+
+        return (TCodeBuilder)this;
+    }
+}

SecretAPI.CodeGeneration/CodeBuilders/MethodBuilder.cs

@@ -0,0 +1,44 @@
+namespace SecretAPI.CodeGeneration.CodeBuilders;
+
+internal class MethodBuilder : CodeBuilder<MethodBuilder>
+{
+    private readonly ClassBuilder _classBuilder;
+    private readonly List<ParameterSyntax> _parameters = new();
+    private readonly List<StatementSyntax> _statements = new();
+    private readonly string _methodName;
+    private readonly TypeSyntax _returnType;
+
+    internal MethodBuilder(ClassBuilder classBuilder, string methodName, TypeSyntax returnType)
+    {
+        _classBuilder = classBuilder;
+        _methodName = methodName;
+        _returnType = returnType;
+    }
+
+    internal MethodBuilder AddStatements(params StatementSyntax[] statements)
+    {
+        _statements.AddRange(statements);
+        return this;
+    }
+
+    internal MethodBuilder AddParameters(params MethodParameter[] parameters)
+    {
+        foreach (MethodParameter parameter in parameters)
+            _parameters.Add(parameter.Syntax);
+
+        return this;
+    }
+
+    internal ClassBuilder FinishMethodBuild()
+    {
+        BlockSyntax body = _statements.Any() ? Block(_statements) : Block();
+
+        MethodDeclarationSyntax methodDeclaration = MethodDeclaration(_returnType, _methodName)
+            .AddModifiers(_modifiers.ToArray())
+            .AddParameterListParameters(_parameters.ToArray())
+            .WithBody(body);
+
+        _classBuilder.AddMethodDefinition(methodDeclaration);
+        return _classBuilder;
+    }
+}

SecretAPI.CodeGeneration/Diagnostics/CommandDiagnostics.cs

@@ -0,0 +1,12 @@
+namespace SecretAPI.CodeGeneration.Diagnostics;
+
+internal static class CommandDiagnostics
+{
+    internal static readonly DiagnosticDescriptor InvalidExecuteMethod = new(
+        "SecretGen0",
+        "Invalid ExecuteCommand method",
+        "Method '{0}' marked with [ExecuteCommand] is invalid: {1}",
+        "Usage",
+        DiagnosticSeverity.Error,
+        true);
+}

SecretAPI.CodeGeneration/Generators/CallOnLoadGenerator.cs

@@ -0,0 +1,122 @@
+namespace SecretAPI.CodeGeneration.Generators;
+
+/// <summary>
+/// Code generator for CallOnLoad/CallOnUnload
+/// </summary>
+[Generator]
+public class CallOnLoadGenerator : IIncrementalGenerator
+{
+    private const string PluginNamespace = "LabApi.Loader.Features.Plugins";
+    private const string PluginBaseClassName = "Plugin";
+    private const string CallOnLoadAttributeLocation = "SecretAPI.Attributes.CallOnLoadAttribute";
+    private const string CallOnUnloadAttributeLocation = "SecretAPI.Attributes.CallOnUnloadAttribute";
+
+    /// <inheritdoc/>
+    public void Initialize(IncrementalGeneratorInitializationContext context)
+    {
+        IncrementalValuesProvider<IMethodSymbol> methodProvider =
+            context.SyntaxProvider.CreateSyntaxProvider(
+                    static (node, _) => node is MethodDeclarationSyntax { AttributeLists.Count: > 0 },
+                    static (ctx, _) =>
+                        ctx.SemanticModel.GetDeclaredSymbol(ctx.Node) as IMethodSymbol)
+                .Where(static m => m is not null)!;
+
+        IncrementalValuesProvider<(IMethodSymbol method, bool isLoad, bool isUnload)> callProvider =
+            methodProvider.Select(static (method, _) => (
+                    method,
+                    HasAttribute(method, CallOnLoadAttributeLocation),
+                    HasAttribute(method, CallOnUnloadAttributeLocation)))
+                .Where(static m => m.Item2 || m.Item3);
+
+        IncrementalValuesProvider<INamedTypeSymbol?> pluginClassProvider =
+            context.SyntaxProvider.CreateSyntaxProvider(
+                    static (node, _) => node is ClassDeclarationSyntax,
+                    static (ctx, _) =>
+                        ctx.SemanticModel.GetDeclaredSymbol(ctx.Node) as INamedTypeSymbol)
+                .Where(static c => c != null && !c.IsAbstract && c.BaseType?.Name == PluginBaseClassName &&
+                                   c.BaseType.ContainingNamespace.ToDisplayString() == PluginNamespace);
+
+        context.RegisterSourceOutput(pluginClassProvider.Combine(callProvider.Collect()), static (context, data) =>
+        {
+            Generate(context, data.Left, data.Right);
+        });
+    }
+
+    private static bool HasAttribute(IMethodSymbol? method, string attributeLocation)
+    {
+        if (method == null)
+            return false;
+
+        foreach (AttributeData attribute in method.GetAttributes())
+        {
+            if (attribute.AttributeClass?.ToDisplayString() == attributeLocation)
+                return true;
+        }
+
+        return false;
+    }
+
+    private static int GetPriority(IMethodSymbol method, string attributeLocation)
+    {
+        AttributeData? attribute = method.GetAttributes()
+            .FirstOrDefault(a => a.AttributeClass?.ToDisplayString() == attributeLocation);
+        if (attribute == null)
+            return 0;
+
+        if (attribute.ConstructorArguments.Length > 0)
+            return (int)attribute.ConstructorArguments[0].Value!;
+
+        return 0;
+    }
+
+    private static bool ShouldAutogenerate(IMethodSymbol method, string attributeLocation)
+    {
+        AttributeData? attribute = method.GetAttributes()
+            .FirstOrDefault(a => a.AttributeClass?.ToDisplayString() == attributeLocation);
+
+        if (attribute is { ConstructorArguments.Length: >= 2 })
+            return (bool)attribute.ConstructorArguments[1].Value!;
+
+        return false;
+    }
+
+    private static void Generate(
+        SourceProductionContext context,
+        INamedTypeSymbol? pluginClassSymbol,
+        ImmutableArray<(IMethodSymbol method, bool isLoad, bool isUnload)> methods)
+    {
+        if (pluginClassSymbol == null || methods.IsEmpty)
+            return;
+
+        IMethodSymbol[] loadCalls = methods
+            .Where(m => m.isLoad && ShouldAutogenerate(m.method, CallOnLoadAttributeLocation))
+            .Select(m => m.method)
+            .OrderBy(m => GetPriority(m, CallOnLoadAttributeLocation))
+            .ToArray();
+
+        IMethodSymbol[] unloadCalls = methods
+            .Where(m => m.isUnload && ShouldAutogenerate(m.method, CallOnUnloadAttributeLocation))
+            .Select(m => m.method)
+            .OrderBy(m => GetPriority(m, CallOnUnloadAttributeLocation))
+            .ToArray();
+
+        if (!loadCalls.Any() && !unloadCalls.Any())
+            return;
+
+        ClassBuilder classBuilder = ClassBuilder.CreateBuilder(pluginClassSymbol)
+            .AddUsingStatements("System")
+            .AddModifiers(SyntaxKind.PartialKeyword);
+
+        classBuilder.StartMethodCreation("OnLoad", SyntaxKind.VoidKeyword)
+            .AddModifiers(SyntaxKind.PublicKeyword)
+            .AddStatements(MethodCallStatements(loadCalls))
+            .FinishMethodBuild();
+
+        classBuilder.StartMethodCreation("OnUnload", SyntaxKind.VoidKeyword)
+            .AddModifiers(SyntaxKind.PublicKeyword)
+            .AddStatements(MethodCallStatements(unloadCalls))
+            .FinishMethodBuild();
+
+        classBuilder.Build(context, $"{pluginClassSymbol.Name}.g.cs");
+    }
+}