SourceGen: A ton of progress on source generation. Multiple errors are now reported instead of breaking out 1 error per method, resolver, or object. Simplified some code. Deleted unused code.

Author: maverickliberty

EppNet-SourceGen/RegisterObjectsGenerator.cs

@@ -6,8 +6,11 @@
 using EppNet.SourceGen.Models;
 
 using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 
+using System.Collections.Concurrent;
+using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 
@@ -24,57 +27,70 @@ public class RegisterObjectsGenerator : IIncrementalGenerator
         public void Initialize(IncrementalGeneratorInitializationContext context)
         {
 
+            ConcurrentDictionary<string, string> resolverDict = new();
+
             // Let's locate our resolvers
-            IncrementalValuesProvider<ResolverModel?> resolverProvider = context.SyntaxProvider
+            var resolvers = context.SyntaxProvider
                 .ForAttributeWithMetadataName(
                     NetTypeResolverAttrFullName,
                     predicate: static (node, _) => node is ClassDeclarationSyntax,
-                    transform: static (ctx, ct) => LocateResolver(ctx.TargetNode, ctx.SemanticModel, ct).Item1
-                );
-
-            var resolvers = resolverProvider
+                    transform: static (ctx, ct) => TryCreateResolver(ctx.TargetNode as CSharpSyntaxNode, ctx.SemanticModel, ct).Item1
+                )
                 .Where(static r => r is not null)
                 .Collect()
-                .Select(static (list, _) => list.ToDictionary(r => r.Value.ResolvedTypeFullName, r => r.Value.Name));
+                .Select(static (list, _) => list.ToDictionary(r => r!.Value.ResolvedTypeFullName, r => r!.Value.Name));
 
             var netObjects = context.SyntaxProvider
                 .ForAttributeWithMetadataName(
                     NetObjectAttrFullName,
                     predicate: static (node, _) => node is ClassDeclarationSyntax,
-                    transform: static (ctx, ct) => LocateNetObject(ctx.TargetNode, ctx.SemanticModel, ct)
+                    transform: (ctx, ct) => TryCreateNetObject(ctx.TargetNode as CSharpSyntaxNode, ctx.SemanticModel, null, ct)
                 )
-                //.Combine(resolvers)
                 .Where(static o => o.Item1 is not null)
                 .Collect()
-                .Select(static (list, _) => list.ToDictionary(o => o.Item1.Value.FullyQualifiedName, o => o.Item1));
+                .Select(static (list, _) => list.ToDictionary(o => o!.Item1.Value.FullyQualifiedName, o => o!.Item1.Value));
 
-            var combined = netObjects.Combine(resolvers);
+            context.RegisterSourceOutput(netObjects.Combine(resolvers), static (SourceProductionContext spc, (Dictionary<string, NetworkObjectModel>, Dictionary<string, string>) b) =>
+            {
 
-            var netMethods = context.SyntaxProvider
-                .ForAttributeWithMetadataName(
-                    NetMethodAttrFullName,
-                    predicate: static (node, _) => node is MethodDeclarationSyntax,
-                    transform: static (ctx, ct) => (ctx, ct)
-                )
-                .Combine(combined)
-                .Select(static (pair, _) =>
+                (Dictionary<string, NetworkObjectModel> objs, Dictionary<string, string> resolverDict) = b;
+
+                foreach (KeyValuePair<string, NetworkObjectModel> kvp in objs)
                 {
-                    var ((ctx, ct), (netObjects, resolvers)) = pair;
-                    return LocateNetMethod(ctx.TargetNode, ctx.SemanticModel, resolvers, netObjects, ct);
-                });
+                    string fqn = kvp.Key;
+                    NetworkObjectModel model = kvp.Value;
 
-            context.RegisterSourceOutput(netObjects, static (spc, objs) =>
-            {
+                    StringBuilder availableMethods = new();
 
-                foreach (NetworkObjectModel? obj in objs.Values)
-                {
-                    if (!obj.HasValue)
-                        return;
+                    foreach (KeyValuePair<string, EquatableList<NetworkMethodModel>> kvp2 in model.Methods)
+                    {
+                        EquatableList<NetworkMethodModel> methods = kvp2.Value;
+
+                        foreach (NetworkMethodModel method in methods)
+                            availableMethods.AppendLine($"// - {method.ToString()}");
+                    }
+
+                    if (availableMethods.Length == 0)
+                        availableMethods.Append($"// no methods found?!?! HELLO!? Methods.Count: {model.Methods.Count}");
+
+                    StringBuilder hierarchy = new();
+
+                    if (model.NetObjectHierarchy == null)
+                        hierarchy.AppendLine("// - System.Object");
+                    else
+                    {
+                        foreach (string bFQN in model.NetObjectHierarchy)
+                            hierarchy.AppendLine($"// - {bFQN}");
+                    }
 
-                    NetworkObjectModel model = obj.Value;
                     StringBuilder builder = new($$"""
                         // <auto-generated/>
                         // full {{model.FullNamespace}}
+                        // hierarchy:
+                        {{hierarchy.ToString()}}
+                        // available methods:
+                        {{availableMethods.ToString()}}
+                        // dist: {{model.Distribution}}
 
                         using EppNet.Logging;
                         using EppNet.Node;

EppNet-SourceGen/ResolverGenerator.cs

@@ -5,17 +5,17 @@
 //////////////////////////////////////////////
 
 using EppNet.SourceGen;
+using EppNet.SourceGen.Errors;
 using EppNet.SourceGen.Models;
 
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 
-using System;
 using System.Collections.Concurrent;
+using System.Collections.Generic;
 using System.Collections.Immutable;
-using System.Reflection;
 
 namespace EppNet.Source.Analysis
 {
@@ -24,14 +24,13 @@ public class NetworkObjectAnalysis : DiagnosticAnalyzer
     {
 
         public static ConcurrentDictionary<string, string> Resolvers = new();
-        public static ConcurrentDictionary<string, NetworkObjectModel?> Objects = new();
+        public static ConcurrentDictionary<string, NetworkObjectModel> Objects = new();
 
         public override void Initialize(AnalysisContext context)
         {
             context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
             context.EnableConcurrentExecution();
 
-
             context.RegisterCompilationStartAction(compContext =>
             {
 
@@ -43,32 +42,13 @@ public override void Initialize(AnalysisContext context)
                     if (!Globals.HasAttribute(classNode, Globals.NetTypeResolverAttr))
                         return;
 
-                    (ResolverModel?, ResolverAnalysisError) data = Globals.LocateResolver(snac.Node, snac.SemanticModel, snac.CancellationToken);
-                    ResolverAnalysisError results = data.Item2;
-
-                    foreach (ResolverAnalysisError error in Enum.GetValues(typeof(ResolverAnalysisError)))
-                    {
-                        if (error == ResolverAnalysisError.None)
-                            continue;
-
-                        if (results.HasFlag(error))
-                        {
-                            string message = error switch
-                            {
-                                ResolverAnalysisError.LacksSingleton => $"{classNode.Identifier.Text}: Resolvers must define a public static singleton field or property \"Instance\"",
-                                ResolverAnalysisError.LacksInheritance => $"{classNode.Identifier.Text}: Resolvers must inherit from {Globals.TypeResolverFullGenericName}",
-                                ResolverAnalysisError.NotClass => $"{classNode.Identifier.Text}: Resolvers must be a class!",
-                                _ => ToString(),
-                            };
-                            snac.ReportDiagnostic(Diagnostic.Create(Globals.DescTypeResolverError,
-                                classNode.Identifier.GetLocation(), message));
-                        }
-                    }
-
-                    if (results == ResolverAnalysisError.None && data.Item1.HasValue)
-                    {
-                        Resolvers[data.Item1.Value.ResolvedTypeFullName] = data.Item1.Value.Name;
-                    }
+                    (ResolverModel? model, List<AnalysisError> errors) = Globals.TryCreateResolver(snac.Node as CSharpSyntaxNode, snac.SemanticModel, snac.CancellationToken);
+
+                    foreach (AnalysisError error in errors)
+                        snac.ReportDiagnostic(error.CreateDiagnostic());
+
+                    if (model.HasValue && errors.Count == 0)
+                        Resolvers[model.Value.ResolvedTypeFullName] = model.Value.Name;
 
                 }, SyntaxKind.ClassDeclaration);
 
@@ -79,36 +59,14 @@ public override void Initialize(AnalysisContext context)
                     if (!Globals.HasAttribute(classNode, Globals.NetObjectAttr))
                         return;
 
-                    var data = Globals.LocateNetObject(
-                        classNode, snac.SemanticModel, snac.CancellationToken);
-
-                    NetworkObjectModel? netModel = data.Item1;
-                    NetworkObjectAnalysisError results = data.Item2;
-
-                    foreach (NetworkObjectAnalysisError error in Enum.GetValues(typeof(NetworkObjectAnalysisError)))
-                    {
-                        if (error == NetworkObjectAnalysisError.None)
-                            continue;
-
-                        if (results.HasFlag(error))
-                        {
-                            string message = error switch
-                            {
-                                NetworkObjectAnalysisError.NotPartial => $"{classNode.Identifier.Text}: Network Object definitions must be partial! Num Resolvers: {Resolvers.Count}",
-                                NetworkObjectAnalysisError.LacksInheritance => $"{classNode.Identifier.Text}: Network Object definitions must inherit from {Globals.NetworkObjectInterfaceName}",
-                                NetworkObjectAnalysisError.NotClass => $"{classNode.Identifier.Text}: Network Object definitions must be a class!",
-                                _ => ToString(),
-                            };
-
-                            snac.ReportDiagnostic(Diagnostic.Create(Globals.DescNetObjError,
-                                classNode.Identifier.GetLocation(), message));
-                        }
-                    }
-
-                    if (results == NetworkObjectAnalysisError.None && data.Item1.HasValue)
-                    {
-                        Objects[data.Item1.Value.FullyQualifiedName] = data.Item1;
-                    }
+                    (NetworkObjectModel? netModel, List<AnalysisError> errors) = Globals.TryCreateNetObject(
+                        classNode, snac.SemanticModel, Resolvers, snac.CancellationToken);
+
+                    foreach (AnalysisError error in errors)
+                        snac.ReportDiagnostic(error.CreateDiagnostic());
+
+                    if (netModel.HasValue && errors.Count == 0)
+                        Objects[netModel.Value.FullyQualifiedName] = netModel.Value;
 
                 }, SyntaxKind.ClassDeclaration);
 
@@ -117,51 +75,18 @@ public override void Initialize(AnalysisContext context)
 
                     MethodDeclarationSyntax methodNode = snac.Node as MethodDeclarationSyntax;
 
-                    if (!Globals.HasAttribute(methodNode, Globals.NetMethodAttr))
+                    if (methodNode is not null && !Globals.HasAttribute(methodNode, Globals.NetMethodAttr))
                         return;
 
-                    var data = Globals.LocateNetMethod(methodNode, snac.SemanticModel, Resolvers, Objects);
-                    NetworkMethodAnalysisError results = data.Item2;
-
-                    foreach (NetworkMethodAnalysisError error in Enum.GetValues(typeof(NetworkMethodAnalysisError)))
-                    {
-                        if (error == NetworkMethodAnalysisError.None)
-                            continue;
-
-                        if (results.HasFlag(error))
-                        {
+                    (NetworkMethodModel? model, List<AnalysisError> errors)
+                        = Globals.TryCreateNetMethod(methodNode, snac.SemanticModel, Resolvers, snac.CancellationToken);
 
-                            if (error == NetworkMethodAnalysisError.MissingResolver)
-                            {
-                                ITypeSymbol typeSymbol = snac.SemanticModel.GetTypeInfo(data.Item4).Type;
-
-                                if (typeSymbol == null)
-                                    continue;
-
-                                string fullTypeName = $"{typeSymbol.ContainingNamespace.ToDisplayString()}.{typeSymbol.Name}";
-
-                                snac.ReportDiagnostic(Diagnostic.Create(Globals.DescNetMethodError,
-                                    data.Item3.GetLocation(), [data.Item4.GetLocation()], $"{methodNode.Identifier.Text}: Type {fullTypeName} does not have a registered Resolver!"));
-
-                                continue;
-                            }
-
-                            string message = error switch
-                            {
-                                NetworkMethodAnalysisError.NotNetworkObjectClass => $"{methodNode.Identifier.Text}: Network method must be within a class decorated with the NetworkObject attribute!",
-                                NetworkMethodAnalysisError.Inaccessible => $"{methodNode.Identifier.Text}: Network method must be public!",
-                                _ => $"{ToString()}",
-                            };
-
-                            snac.ReportDiagnostic(Diagnostic.Create(Globals.DescNetMethodError,
-                                methodNode.Identifier.GetLocation(), message));
-                        }
-                    }
+                    foreach (AnalysisError error in errors)
+                        snac.ReportDiagnostic(error.CreateDiagnostic());
 
                 }, SyntaxKind.MethodDeclaration);
             });
 
-
         }
 
         public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics =>