com.wallstop-studios.dxmessaging 2.0.0-rc26.2 → 2.0.0-rc26.4

package/Editor/CustomEditors/MessagingComponentEditor.cs

@@ -27,6 +27,8 @@
         private GUIStyle _matchingStyle;
         private GUIStyle _potentialMatchStyle;
         private GUIStyle _defaultStyle;
+        private GUIStyle _leftAlignedStyle;
+        private GUIStyle _rightAlignedStyle;
 
         private void OnEnable()
         {
@@ -48,6 +50,14 @@
                 fontStyle = FontStyle.Bold,
             };
             _defaultStyle ??= new GUIStyle(EditorStyles.label);
+            _leftAlignedStyle ??= new GUIStyle(EditorStyles.label)
+            {
+                alignment = TextAnchor.MiddleLeft,
+            };
+            _rightAlignedStyle ??= new GUIStyle(EditorStyles.label)
+            {
+                alignment = TextAnchor.MiddleRight,
+            };
 
             MessagingComponent component = target as MessagingComponent;
             if (component == null)
@@ -209,11 +219,6 @@
                                     {
                                         style = _defaultStyle;
                                     }
-                                    EditorGUILayout.LabelField(
-                                        "Context",
-                                        $"{unityObject.name} - {unityObject.GetType().Name}",
-                                        style
-                                    );
                                 }
                                 else
                                 {
@@ -231,6 +236,33 @@
                                 );
 
                                 EditorGUILayout.LabelField(labelContent, valueContent, style);
+                                if (context?.Object != null)
+                                {
+                                    Object unityObject = context.Value.Object;
+                                    string label = "Context";
+                                    if (
+                                        typeof(ITargetedMessage).IsAssignableFrom(
+                                            globalEmissionData.message.MessageType
+                                        )
+                                    )
+                                    {
+                                        label = "Target";
+                                    }
+                                    else if (
+                                        typeof(IBroadcastMessage).IsAssignableFrom(
+                                            globalEmissionData.message.MessageType
+                                        )
+                                    )
+                                    {
+                                        label = "Source";
+                                    }
+                                    EditorGUILayout.ObjectField(
+                                        label,
+                                        unityObject,
+                                        typeof(Object),
+                                        true
+                                    );
+                                }
                             }
                         }
                     }
@@ -306,16 +338,6 @@
                         {
                             using (new EditorGUILayout.VerticalScope("box"))
                             {
-                                InstanceId? context = globalEmissionData.context;
-                                if (context?.Object != null)
-                                {
-                                    Object unityObject = context.Value.Object;
-                                    EditorGUILayout.LabelField(
-                                        "Context",
-                                        $"{unityObject.name} - {unityObject.GetType().Name}"
-                                    );
-                                }
-
                                 GUIContent labelContent = new("Message Type");
                                 GUIContent valueContent = new(
                                     globalEmissionData.message.MessageType.Name,
@@ -323,6 +345,35 @@
                                 );
 
                                 EditorGUILayout.LabelField(labelContent, valueContent);
+
+                                InstanceId? context = globalEmissionData.context;
+                                if (context?.Object != null)
+                                {
+                                    Object unityObject = context.Value.Object;
+                                    string label = "Context";
+                                    if (
+                                        typeof(ITargetedMessage).IsAssignableFrom(
+                                            globalEmissionData.message.MessageType
+                                        )
+                                    )
+                                    {
+                                        label = "Target";
+                                    }
+                                    else if (
+                                        typeof(IBroadcastMessage).IsAssignableFrom(
+                                            globalEmissionData.message.MessageType
+                                        )
+                                    )
+                                    {
+                                        label = "Source";
+                                    }
+                                    EditorGUILayout.ObjectField(
+                                        label,
+                                        unityObject,
+                                        typeof(Object),
+                                        true
+                                    );
+                                }
                             }
                         }
                     }
@@ -441,27 +492,36 @@
                 ) in pagedRegistrations
             )
             {
-                int callCount = token._callCounts.GetValueOrDefault(handle, 0);
+                using (new EditorGUILayout.VerticalScope("box"))
+                {
+                    int callCount = token._callCounts.GetValueOrDefault(handle, 0);
 
-                string messageName = metadata.type?.Name ?? string.Empty;
-                EditorGUILayout.LabelField(messageName, EditorStyles.boldLabel);
+                    string messageName = metadata.type?.Name ?? string.Empty;
+                    GUIContent labelContent = new(messageName, $"Priority: {metadata.priority}");
+                    GUIContent valueContent = new(
+                        metadata.registrationType.ToString(),
+                        $"Priority: {metadata.priority}"
+                    );
 
-                EditorGUI.indentLevel++;
+                    EditorGUILayout.LabelField(labelContent, valueContent);
+                    if (metadata.context?.Object != null)
+                    {
+                        Object unityObject = metadata.context.Value.Object;
+                        string label = "Context";
+                        if (typeof(ITargetedMessage).IsAssignableFrom(metadata.type))
+                        {
+                            label = "Target";
+                        }
+                        else if (typeof(IBroadcastMessage).IsAssignableFrom(metadata.type))
+                        {
+                            label = "Source";
+                        }
+                        EditorGUILayout.ObjectField(label, unityObject, typeof(Object), true);
+                    }
 
-                EditorGUILayout.LabelField("Type", metadata.registrationType.ToString());
-                EditorGUILayout.LabelField("Priority", metadata.priority.ToString());
-                EditorGUILayout.LabelField("Call Count", callCount.ToString());
-                if (metadata.context?.Object != null)
-                {
-                    Object unityObject = metadata.context.Value.Object;
-                    EditorGUILayout.LabelField(
-                        "Context",
-                        $"{unityObject.name} - {unityObject.GetType().Name}"
-                    );
+                    EditorGUILayout.LabelField("Call Count", callCount.ToString());
+                    EditorGUILayout.Space();
                 }
-
-                EditorGUI.indentLevel--;
-                EditorGUILayout.Space();
             }
             EditorGUI.indentLevel--;
         }

package/Runtime/Core/Attributes/DxAutoConstructorAttribute.cs

@@ -0,0 +1,14 @@
+namespace DxMessaging.Core.Attributes
+{
+    using System;
+
+    [AttributeUsage(
+        AttributeTargets.Class | AttributeTargets.Struct,
+        Inherited = false,
+        AllowMultiple = false
+    )]
+    public sealed class DxAutoConstructorAttribute : Attribute
+    {
+        public DxAutoConstructorAttribute() { }
+    }
+}

package/Runtime/Core/Attributes/DxAutoConstructorAttribute.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: bef6adb9baf545129cb9a841b13da451
+timeCreated: 1749776355

package/SourceGenerators/WallstopStudios.DxMessaging.SourceGenerators/DxAutoConstructorGenerator.cs

@@ -0,0 +1,250 @@
+namespace WallstopStudios.DxMessaging.SourceGenerators
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Collections.Immutable;
+    using System.Diagnostics;
+    using System.Linq;
+    using System.Text;
+    using System.Threading;
+    using Microsoft.CodeAnalysis;
+    using Microsoft.CodeAnalysis.CSharp;
+    using Microsoft.CodeAnalysis.CSharp.Syntax;
+    using Microsoft.CodeAnalysis.Text;
+
+    [Generator(LanguageNames.CSharp)]
+    public sealed class DxAutoConstructorGenerator : IIncrementalGenerator
+    {
+        private const string AutoGenConstructorAttrFullName =
+            "DxMessaging.Core.Attributes.DxAutoConstructorAttribute";
+
+        // Info needed during generation for a valid type
+        private record struct TypeToGenerateInfo(
+            INamedTypeSymbol TypeSymbol,
+            TypeDeclarationSyntax DeclarationSyntax,
+            ImmutableArray<IFieldSymbol> FieldsToInject // Public readonly non-static fields
+        );
+
+        public void Initialize(IncrementalGeneratorInitializationContext context)
+        {
+            // Find all class/struct/record declarations that have attribute lists
+            IncrementalValuesProvider<TypeDeclarationSyntax> potentialTypeDeclarations =
+                context.SyntaxProvider.CreateSyntaxProvider(
+                    predicate: static (node, _) => IsSyntaxTargetForGeneration(node),
+                    transform: static (ctx, _) => (TypeDeclarationSyntax)ctx.Node
+                );
+
+            // Get semantic info for potential types
+            IncrementalValuesProvider<TypeToGenerateInfo?> semanticTargets =
+                potentialTypeDeclarations
+                    .Combine(context.CompilationProvider)
+                    .Select(
+                        static (data, ct) =>
+                            GetSemanticTargetForGeneration(data.Left, data.Right, ct)
+                    );
+
+            // Filter out nulls (types that aren't valid for auto-gen constructor)
+            IncrementalValuesProvider<TypeToGenerateInfo> validSemanticTargets = semanticTargets
+                .Where(static target => target.HasValue)
+                .Select(static (target, _) => target!.Value);
+
+            // Collect all valid types for generation
+            IncrementalValueProvider<ImmutableArray<TypeToGenerateInfo>> collectedTargets =
+                validSemanticTargets.Collect();
+
+            IncrementalValueProvider<(
+                Compilation,
+                ImmutableArray<TypeToGenerateInfo>
+            )> compilationAndTypes = context.CompilationProvider.Combine(collectedTargets);
+
+            // Register the source output step
+            context.RegisterSourceOutput(
+                compilationAndTypes,
+                static (spc, source) => Execute(source.Item1, source.Item2, spc)
+            );
+        }
+
+        private static bool IsSyntaxTargetForGeneration(SyntaxNode node) =>
+            node is TypeDeclarationSyntax { AttributeLists.Count: > 0 } typeDecl
+            && (
+                typeDecl.IsKind(SyntaxKind.ClassDeclaration)
+                || typeDecl.IsKind(SyntaxKind.StructDeclaration)
+                || typeDecl.IsKind(SyntaxKind.RecordDeclaration)
+                || typeDecl.IsKind(SyntaxKind.RecordStructDeclaration)
+            );
+
+        private static TypeToGenerateInfo? GetSemanticTargetForGeneration(
+            TypeDeclarationSyntax typeDeclarationSyntax,
+            Compilation compilation,
+            CancellationToken cancellationToken
+        )
+        {
+            SemanticModel semanticModel = compilation.GetSemanticModel(
+                typeDeclarationSyntax.SyntaxTree
+            );
+            if (
+                semanticModel.GetDeclaredSymbol(typeDeclarationSyntax, cancellationToken)
+                is not { } typeSymbol
+            )
+            {
+                return null;
+            }
+
+            // Check if the type has the DxAutoGenConstructor attribute
+            bool hasAutoGenConstructorAttribute = false;
+            foreach (AttributeData attributeData in typeSymbol.GetAttributes())
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+                if (
+                    attributeData.AttributeClass?.ToDisplayString()
+                    == AutoGenConstructorAttrFullName
+                )
+                {
+                    hasAutoGenConstructorAttribute = true;
+                    break;
+                }
+            }
+
+            if (!hasAutoGenConstructorAttribute)
+            {
+                return null;
+            }
+
+            // Find public readonly non-static fields in declaration order
+            ImmutableArray<IFieldSymbol> fieldsToInject = typeSymbol
+                .GetMembers()
+                .OfType<IFieldSymbol>()
+                .Where(f => f.DeclaredAccessibility == Accessibility.Public && !f.IsStatic)
+                .OrderBy(f => f.DeclaringSyntaxReferences.FirstOrDefault()?.Span.Start ?? 0) // Order by declaration in source
+                .ToImmutableArray();
+
+            // If there are no relevant fields, we don't need to generate a constructor
+            if (fieldsToInject.Length == 0)
+            {
+                return null;
+            }
+
+            return new TypeToGenerateInfo(typeSymbol, typeDeclarationSyntax, fieldsToInject);
+        }
+
+        private static void Execute(
+            Compilation compilation,
+            ImmutableArray<TypeToGenerateInfo> typesToGenerate,
+            SourceProductionContext context
+        )
+        {
+            if (typesToGenerate.IsDefaultOrEmpty)
+            {
+                return;
+            }
+
+            // Use a HashSet to track types already processed to avoid duplicate generation for partial classes
+            HashSet<INamedTypeSymbol> processedTypes = new(SymbolEqualityComparer.Default);
+
+            foreach (TypeToGenerateInfo typeInfo in typesToGenerate)
+            {
+                if (!processedTypes.Add(typeInfo.TypeSymbol) || typeInfo.FieldsToInject.Length == 0)
+                {
+                    continue; // Already processed this type (e.g., from another partial definition)
+                }
+
+                context.CancellationToken.ThrowIfCancellationRequested();
+
+                // Generate the partial class/struct with the constructor
+                string generatedSource = GenerateConstructorSource(
+                    typeInfo.TypeSymbol,
+                    typeInfo.FieldsToInject
+                );
+                string hintName =
+                    $"{typeInfo.TypeSymbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat)}.AutoGenConstructor.g.cs"
+                        .Replace("global::", "")
+                        .Replace("<", "_")
+                        .Replace(">", "_")
+                        .Replace(",", "_"); // Clean hint name for file system
+
+                context.AddSource(hintName, SourceText.From(generatedSource, Encoding.UTF8));
+            }
+        }
+
+        private static string GenerateConstructorSource(
+            INamedTypeSymbol typeSymbol,
+            ImmutableArray<IFieldSymbol> fieldsToInject
+        )
+        {
+
+            string namespaceName = typeSymbol.ContainingNamespace.IsGlobalNamespace
+                ? string.Empty
+                : typeSymbol.ContainingNamespace.ToDisplayString();
+            string namespaceBlockOpen = string.IsNullOrEmpty(namespaceName)
+                ? string.Empty
+                : $"namespace {namespaceName}\n{{";
+            string namespaceBlockClose = string.IsNullOrEmpty(namespaceName) ? string.Empty : "}";
+            const string indent = "    ";
+
+            string typeName = typeSymbol.ToDisplayString(
+                SymbolDisplayFormat.MinimallyQualifiedFormat
+            );
+            string typeKind = typeSymbol.TypeKind switch
+            {
+                TypeKind.Class => typeSymbol.IsRecord ? "record class" : "class",
+                TypeKind.Struct => typeSymbol.IsRecord ? "record struct" : "struct",
+                _ => throw new InvalidOperationException(
+                    "Unsupported type kind for constructor generation"
+                ),
+            };
+
+            string typeAccessibility = typeSymbol.DeclaredAccessibility switch
+            {
+                Accessibility.Public => "public",
+                Accessibility.Protected => "protected",
+                Accessibility.Private => "private",
+                Accessibility.Internal => "internal",
+                _ => "internal", // Default to internal if not public or protected
+            };
+
+            string constructorAccessibility = "public"; // Always public as requested
+
+            // Generate constructor parameters and body assignments
+            StringBuilder constructorParams = new();
+            StringBuilder constructorBody = new();
+
+            SymbolDisplayFormat fieldTypeFormat =
+                SymbolDisplayFormat.FullyQualifiedFormat.WithMiscellaneousOptions(
+                    SymbolDisplayMiscellaneousOptions.EscapeKeywordIdentifiers
+                );
+
+            for (int i = 0; i < fieldsToInject.Length; i++)
+            {
+                IFieldSymbol field = fieldsToInject[i];
+                string fieldType = field.Type.ToDisplayString(fieldTypeFormat);
+                string fieldName = field.Name;
+
+                constructorParams.Append($"{fieldType} {fieldName}");
+                if (i < fieldsToInject.Length - 1)
+                {
+                    constructorParams.Append(", ");
+                }
+                constructorBody.AppendLine($"{indent}{indent}    this.{fieldName} = {fieldName};");
+            }
+
+            return $$"""
+                // <auto-generated by DxAutoGenConstructorGenerator/>
+                #pragma warning disable
+                #nullable enable annotations
+
+                {{namespaceBlockOpen}}
+                {{indent}}{{typeAccessibility}} partial {{typeKind}} {{typeName}}
+                {{indent}}{
+                {{indent}}    /// <summary>
+                {{indent}}    /// Auto-generated constructor by DxAutoGenConstructorGenerator.
+                {{indent}}    /// </summary>
+                {{indent}}    {{constructorAccessibility}} {{typeSymbol.Name}}({{constructorParams}})
+                {{indent}}    {
+                {{constructorBody}}
+                {{indent}}    }
+                {{indent}}}
+                {{namespaceBlockClose}}
+                """;
+        }
+    }
+}

package/SourceGenerators/WallstopStudios.DxMessaging.SourceGenerators/DxAutoConstructorGenerator.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 1b72dc77d3697c1d6bc2f3e1d262f9af
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/SourceGenerators/WallstopStudios.DxMessaging.SourceGenerators/DxMessageIdGenerator.cs

@@ -258,9 +258,9 @@
                 ? string.Empty
                 : typeSymbol.ContainingNamespace.ToDisplayString();
             string namespaceBlockOpen = string.IsNullOrEmpty(namespaceName)
-                ? "namespace\n{"
+                ? string.Empty
                 : $"namespace {namespaceName}\n{{";
-            const string namespaceBlockClose = "}";
+            string namespaceBlockClose = string.IsNullOrEmpty(namespaceName) ? string.Empty : "}";
             const string indent = "    ";
 
             string typeNameWithGenerics = typeSymbol.ToDisplayString(
@@ -279,10 +279,12 @@
 
             string accessibility = typeSymbol.DeclaredAccessibility switch
             {
-                Accessibility.Public => "public ",
-                Accessibility.Internal => "internal ",
+                Accessibility.Public => "public",
+                Accessibility.Protected => "protected",
+                Accessibility.Private => "private",
+                Accessibility.Internal => "internal",
                 // Add others if necessary, default to internal if restrictive
-                _ => "internal ",
+                _ => "internal",
             };
 
             string interfaceDeclaration = $", global::{targetInterfaceFullName}";
@@ -294,7 +296,7 @@
 
                 {{namespaceBlockOpen}}
                 {{indent}}// Partial implementation for {{typeNameWithGenerics}} to implement {{BaseInterfaceFullName}}
-                {{indent}}{{accessibility}}partial {{typeKind}} {{typeNameWithGenerics}} : global::{{BaseInterfaceFullName}} {{interfaceDeclaration}}
+                {{indent}}{{accessibility}} partial {{typeKind}} {{typeNameWithGenerics}} : global::{{BaseInterfaceFullName}} {{interfaceDeclaration}}
                 {{indent}}{
                 {{indent}}    /// <inheritdoc/>
                 {{indent}}    public global::System.Type MessageType => typeof({{fullyQualifiedName}});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.wallstop-studios.dxmessaging",
-  "version": "2.0.0-rc26.2",
+  "version": "2.0.0-rc26.4",
   "displayName": "DxMessaging",
   "description": "Synchronous Event Bus for Unity",
   "unity": "2021.3",
@@ -34,3 +34,5 @@
 }
 
 
+
+