com.wallstop-studios.dxmessaging 3.0.1 → 3.1.0

package/Runtime/Unity/MessageAwareComponent.cs

@@ -19,6 +19,8 @@ namespace DxMessaging.Unity
     /// - <see cref="Awake"/> creates the token and calls <see cref="RegisterMessageHandlers"/>.
     /// - <see cref="OnEnable"/>/<see cref="OnDisable"/> enable/disable the token when
     ///   <see cref="MessageRegistrationTiedToEnableStatus"/> is true.
+    /// - <see cref="OnEnable"/> can additionally re-create a released token when
+    ///   <see cref="ReregisterOnEnableAfterRelease"/> is overridden to true.
     /// - <see cref="OnDestroy"/> disables the token and releases references.
     /// </remarks>
     /// <example>
@@ -61,6 +63,25 @@ namespace DxMessaging.Unity
         /// </summary>
         protected virtual bool MessageRegistrationTiedToEnableStatus => true;
 
+        /// <summary>
+        /// Controls whether enabling this component re-creates its registration token and replays
+        /// <see cref="RegisterMessageHandlers"/> after the token was released (for example via
+        /// <see cref="MessagingComponent.Release"/>).
+        /// </summary>
+        /// <remarks>
+        /// Default <c>false</c>: once released, the component stays unregistered across
+        /// enable/disable cycles until <see cref="MessagingComponent.Create"/> is invoked manually.
+        /// Override to return <c>true</c> to opt into automatic recovery on the next enable:
+        /// if no live token exists, a fresh one is created and <see cref="RegisterMessageHandlers"/>
+        /// replays exactly once; if a manual <see cref="MessagingComponent.Create"/> already minted
+        /// a fresh token since the release, that token is adopted as-is (the manual creator owns
+        /// staging, so nothing is replayed and nothing double-stages).
+        /// When <see cref="MessageRegistrationTiedToEnableStatus"/> is false, the recovery still
+        /// re-creates and stages but does NOT enable the new token; call
+        /// <see cref="MessageRegistrationToken.Enable"/> yourself, exactly as for the original token.
+        /// </remarks>
+        protected virtual bool ReregisterOnEnableAfterRelease => false;
+
         /// <summary>
         /// If true, registers demo handlers for <see cref="Core.Messages.StringMessage"/> and
         /// <see cref="Core.Messages.GlobalStringMessage"/>. Override and return <c>false</c> to disable.
@@ -138,9 +159,33 @@ namespace DxMessaging.Unity
 
         /// <summary>
         /// Enables the token if <see cref="MessageRegistrationTiedToEnableStatus"/> is true.
+        /// When <see cref="ReregisterOnEnableAfterRelease"/> is true and the token was released,
+        /// a fresh token is created and <see cref="RegisterMessageHandlers"/> replays first.
         /// </summary>
         protected virtual void OnEnable()
         {
+            if (
+                ReregisterOnEnableAfterRelease
+                && _messageRegistrationToken != null
+                && _messagingComponent != null
+            )
+            {
+                if (_messagingComponent.TryGetToken(this, out MessageRegistrationToken liveToken))
+                {
+                    // A manual MessagingComponent.Create(this) between the release and
+                    // this enable minted a fresh token the field does not know about;
+                    // adopt it so Token/Enable() operate on the live registration. The
+                    // manual creator owns staging in that case, so RegisterMessageHandlers
+                    // is NOT replayed here (no double-staging).
+                    _messageRegistrationToken = liveToken;
+                }
+                else
+                {
+                    _messageRegistrationToken = _messagingComponent.Create(this);
+                    RegisterMessageHandlers();
+                }
+            }
+
             if (MessageRegistrationTiedToEnableStatus)
             {
                 _messageRegistrationToken?.Enable();
@@ -159,7 +204,7 @@ namespace DxMessaging.Unity
                 Debug.LogError(
                     $"[DxMessaging] {GetType().Name} appears to be missing a base.Awake() call; "
                         + "no registration token exists, so this component will not receive messages. "
-                        + "See https://github.com/wallstop/DxMessaging/blob/master/docs/reference/analyzers.md#dxmsg006-missing-base-call",
+                        + "See https://github.com/Ambiguous-Interactive/DxMessaging/blob/master/docs/reference/analyzers.md#dxmsg006-missing-base-call",
                     this
                 );
             }

package/Runtime/Unity/MessagingComponent.cs

@@ -185,8 +185,9 @@ namespace DxMessaging.Unity
         /// </summary>
         /// <param name="listener">Listener whose token should be released.</param>
         /// <remarks>
-        /// Invokes <see cref="MessageRegistrationToken.Disable"/> and removes the listener from the internal cache.
-        /// Safe to call multiple times.
+        /// Invokes <see cref="MessageRegistrationToken.Dispose"/> and removes the listener from the internal cache after
+        /// disposal succeeds. If token disposal throws, the listener remains cached so release can be retried. Safe to call
+        /// multiple times after a successful release.
         /// </remarks>
         public bool Release(MonoBehaviour listener)
         {
@@ -195,9 +196,10 @@ namespace DxMessaging.Unity
                 return false;
             }
 
-            if (_registeredListeners.Remove(listener, out MessageRegistrationToken token))
+            if (_registeredListeners.TryGetValue(listener, out MessageRegistrationToken token))
             {
-                token?.Disable();
+                token?.Dispose();
+                _ = _registeredListeners.Remove(listener);
                 return true;
             }
 
@@ -225,34 +227,65 @@ namespace DxMessaging.Unity
         /// <summary>
         /// Activates the underlying handler when this component becomes enabled.
         /// </summary>
+        /// <remarks>
+        /// When <see cref="emitMessagesWhenDisabled"/> is true, the Unity enable/disable
+        /// lifecycle leaves the handler untouched in BOTH directions, so an explicit
+        /// <see cref="ToggleMessageHandler"/> decision survives enable/disable cycles.
+        /// </remarks>
         public void OnEnable()
         {
-            ToggleMessageHandler(true);
+            if (!emitMessagesWhenDisabled)
+            {
+                ToggleMessageHandler(true);
+            }
         }
 
         /// <summary>
         /// Deactivates the underlying handler when this component becomes disabled.
         /// </summary>
+        /// <remarks>
+        /// When <see cref="emitMessagesWhenDisabled"/> is true, disabling leaves the handler
+        /// active so the GameObject keeps emitting (and listeners whose tokens are not tied to
+        /// the Unity lifecycle keep receiving).
+        /// </remarks>
         public void OnDisable()
         {
-            ToggleMessageHandler(false);
+            if (!emitMessagesWhenDisabled)
+            {
+                ToggleMessageHandler(false);
+            }
         }
 
         /// <summary>
         /// Explicitly toggle the underlying handler's active state.
         /// </summary>
         /// <param name="newActive">Desired active state.</param>
+        /// <remarks>
+        /// Explicit calls always win: unlike the Unity lifecycle, this method is never gated by
+        /// <see cref="emitMessagesWhenDisabled"/>.
+        /// </remarks>
         public void ToggleMessageHandler(bool newActive)
         {
-            if (!newActive && emitMessagesWhenDisabled)
+            if (_messageHandler != null && _messageHandler.active != newActive)
             {
-                return;
+                _messageHandler.active = newActive;
             }
+        }
 
-            if (_messageHandler != null && _messageHandler.active != newActive)
+        /// <summary>
+        /// Fetches the live (created and not released) registration token for
+        /// <paramref name="listener"/> without the double-create warning
+        /// <see cref="Create(MonoBehaviour)"/> logs.
+        /// </summary>
+        internal bool TryGetToken(MonoBehaviour listener, out MessageRegistrationToken token)
+        {
+            if (listener == null)
             {
-                _messageHandler.active = newActive;
+                token = null;
+                return false;
             }
+
+            return _registeredListeners.TryGetValue(listener, out token);
         }
 
         /// <summary>

package/Runtime/WallstopStudios.DxMessaging.asmdef

@@ -6,7 +6,7 @@
   "excludePlatforms": [],
   "allowUnsafeCode": true,
   "overrideReferences": false,
-  "precompiledReferences": ["System.Runtime.CompilerServices.Unsafe.dll"],
+  "precompiledReferences": [],
   "autoReferenced": true,
   "defineConstraints": [],
   "versionDefines": [],

package/Samples~/DI/README.md

@@ -31,15 +31,15 @@ Each sample shows:
 1. **Place the prefab**  
    Drag `Prefabs/MessagingInstallerSample.prefab` into your test scene. The root object carries `MessagingComponentInstaller` with its provider handle already pointing at the global provider ScriptableObject.
 
-1. **Hook up the container**  
-   - **Zenject**:  
-     - Add `DxMessagingRegistrationInstaller` (from [Runtime/Unity/Integrations](../../Runtime/Unity/Integrations/)) to your ProjectContext or scene installer list.  
+1. **Hook up the container**
+   - **Zenject**:
+     - Add `DxMessagingRegistrationInstaller` (from [Runtime/Unity/Integrations](../../Runtime/Unity/Integrations/)) to your ProjectContext or scene installer list.
      - Drop [SampleInstaller.cs](./Zenject/SampleInstaller.cs) into your project and register it alongside other installers. When the scene runs, the installer resolves `IMessageRegistrationBuilder`, stages a `PlayerSpawned` listener, and activates via the Zenject lifecycle.
-   - **VContainer**:  
-     - Define `VCONTAINER_PRESENT` and reference the optional extension under [VContainerRegistrationExtensions.cs](../../Runtime/Unity/Integrations/VContainerRegistrationExtensions.cs).  
+   - **VContainer**:
+     - Define `VCONTAINER_PRESENT` and reference the optional extension under [VContainerRegistrationExtensions.cs](../../Runtime/Unity/Integrations/VContainer/VContainerRegistrationExtensions.cs).
      - Add [SampleLifetimeScope.cs](./VContainer/SampleLifetimeScope.cs) to the scene (or derive from it); the sample scope registers the builder and an entry point that emits/consumes `ScoreUpdated` messages each tick.
-   - **Reflex**:  
-     - Enable `REFLEX_PRESENT` and install `DxMessagingRegistrationInstaller` into your container bootstrap.  
+   - **Reflex**:
+     - Enable `REFLEX_PRESENT` and install `DxMessagingRegistrationInstaller` into your container bootstrap.
      - Include [SampleInstaller.cs](./Reflex/SampleInstaller.cs) in your installer chain. The sample service resolves `IMessageRegistrationBuilder`, subscribes to `PlayerAlert`, and can emit alerts via `EmitAlertFor`.
 
 1. **Emit a message**  

package/SourceGenerators/Directory.Build.props

@@ -1,9 +1,56 @@
 <Project>
-  <PropertyGroup Condition="'$(MSBuildProjectName)' == 'WallstopStudios.DxMessaging.SourceGenerators.Tests'">
+  <!--
+    Redirect ALL build output for every project under SourceGenerators/ into the
+    repo's Unity-ignored, git-ignored .artifacts/ tree.
+
+    WHY: this repo IS a Unity UPM package and the repo root is the package root,
+    so Unity imports everything under it that is not in a Unity-ignored location.
+    Unity ignores files/folders whose names start with '.' (e.g. .artifacts) or
+    end with '~'. If a SourceGenerators project builds its obj/ or bin/ in-tree,
+    Unity imports those build outputs. The analyzer/source-generator DLLs there
+    have the SAME assembly names as the correctly-configured shipped analyzers in
+    Editor/Analyzers/, but their Unity-auto-generated .meta lack the
+    RoslynAnalyzer label / validateReferences:0 / all-platforms-disabled config.
+    Unity then fails to resolve their Microsoft.CodeAnalysis reference and the
+    duplicate shadows the real analyzers, so the source generator never runs and
+    every [Dx*Message] type fails to implement its generated interface
+    (CS0315/CS0452) project-wide.
+
+    Building these projects is REQUIRED by the dev workflow (the main projects'
+    PostBuildCopyAnalyzers target copies the freshly-built DLL into
+    Editor/Analyzers/), so the build MUST go somewhere Unity ignores.
+
+    HOW: redirect per-project obj/ and bin/ to
+    $(SolutionDir).artifacts/$(MSBuildProjectName)/{obj,bin}/$(Configuration)/.
+    BaseIntermediateOutputPath is set here because Directory.Build.props is
+    imported BEFORE the .NET SDK's default-path logic (Sdk.props) that derives
+    obj/ paths and before NuGet restore writes project.assets.json; setting it
+    here ensures even 'dotnet restore' writes obj/project.assets.json under
+    .artifacts/ instead of an in-tree obj/. IntermediateOutputPath (the
+    Configuration-scoped obj subfolder) and OutputPath (bin) are set for the
+    build itself. $(TargetPath) therefore resolves under .artifacts/, and the
+    PostBuildCopyAnalyzers targets still copy the built DLL into
+    Editor/Analyzers/ correctly.
+  -->
+  <PropertyGroup>
     <SolutionDir Condition="'$(SolutionDir)' == ''">$(MSBuildThisFileDirectory)..\</SolutionDir>
-    <ArtifactsRoot>$(SolutionDir).artifacts/SourceGenerators.Tests/</ArtifactsRoot>
-    <IntermediateOutputPath>$(ArtifactsRoot)obj/$(Configuration)/</IntermediateOutputPath>
+    <ArtifactsRoot Condition="'$(ArtifactsRoot)' == ''"
+      >$(SolutionDir).artifacts/$(MSBuildProjectName)/</ArtifactsRoot>
+    <!-- Set BaseIntermediateOutputPath early so NuGet restore's obj/ (and
+         project.assets.json) is written under .artifacts/, never in-tree. The
+         trailing slash is required by the SDK's path-joining logic. -->
+    <BaseIntermediateOutputPath>$(ArtifactsRoot)obj/</BaseIntermediateOutputPath>
+    <IntermediateOutputPath>$(BaseIntermediateOutputPath)$(Configuration)/</IntermediateOutputPath>
     <OutputPath>$(ArtifactsRoot)bin/$(Configuration)/</OutputPath>
     <VSTestResultsDirectory>$(ArtifactsRoot)TestResults/</VSTestResultsDirectory>
+    <LangVersion>10.0</LangVersion>
+    <Deterministic>true</Deterministic>
+    <ContinuousIntegrationBuild>true</ContinuousIntegrationBuild>
+    <IncludeSourceRevisionInInformationalVersion>false</IncludeSourceRevisionInInformationalVersion>
+    <DebugType>none</DebugType>
+    <DebugSymbols>false</DebugSymbols>
+    <CopyAnalyzerPayload Condition="'$(CopyAnalyzerPayload)' == ''">true</CopyAnalyzerPayload>
+    <AnalyzerPayloadOutputDir Condition="'$(AnalyzerPayloadOutputDir)' == ''"
+      >$([System.IO.Path]::Combine('$(SolutionDir)', 'Editor', 'Analyzers'))</AnalyzerPayloadOutputDir>
   </PropertyGroup>
 </Project>

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

@@ -13,8 +13,8 @@ namespace WallstopStudios.DxMessaging.SourceGenerators
     using Microsoft.CodeAnalysis.CSharp.Syntax;
     using Microsoft.CodeAnalysis.Text;
 
-    [Generator(LanguageNames.CSharp)]
-    public sealed class DxAutoConstructorGenerator : IIncrementalGenerator
+    [Generator]
+    public sealed class DxAutoConstructorGenerator : ISourceGenerator
     {
         private static readonly DiagnosticDescriptor NonPartialContainerDiagnostic = new(
             id: "DXMSG003",
@@ -57,46 +57,34 @@ namespace WallstopStudios.DxMessaging.SourceGenerators
         );
 
         /// <summary>
-        /// Configures the incremental generator pipeline that discovers annotated types and emits constructors.
+        /// Configures syntax collection for annotated types that need generated constructors.
         /// </summary>
         /// <param name="context">Initialization context provided by Roslyn.</param>
-        public void Initialize(IncrementalGeneratorInitializationContext context)
+        public void Initialize(GeneratorInitializationContext 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
-                );
+            context.RegisterForSyntaxNotifications(static () => new TypeSyntaxReceiver());
+        }
 
-            // Get semantic info for potential types
-            IncrementalValuesProvider<TypeToGenerateInfo?> semanticTargets =
-                potentialTypeDeclarations
-                    .Combine(context.CompilationProvider)
-                    .Select(
-                        static (data, ct) =>
-                            GetSemanticTargetForGeneration(data.Left, data.Right, ct)
-                    );
+        public void Execute(GeneratorExecutionContext context)
+        {
+            if (context.SyntaxReceiver is not TypeSyntaxReceiver receiver)
+            {
+                return;
+            }
 
-            // Filter out nulls (types that aren't valid for auto-gen constructor)
-            IncrementalValuesProvider<TypeToGenerateInfo> validSemanticTargets = semanticTargets
+            ImmutableArray<TypeToGenerateInfo> typesToGenerate = receiver
+                .Candidates.Select(typeDeclarationSyntax =>
+                    GetSemanticTargetForGeneration(
+                        typeDeclarationSyntax,
+                        context.Compilation,
+                        context.CancellationToken
+                    )
+                )
                 .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);
+                .Select(static target => target!.Value)
+                .ToImmutableArray();
 
-            // Register the source output step
-            context.RegisterSourceOutput(
-                compilationAndTypes,
-                static (spc, source) => Execute(source.Item1, source.Item2, spc)
-            );
+            Execute(typesToGenerate, context);
         }
 
         private static bool IsSyntaxTargetForGeneration(SyntaxNode node) =>
@@ -105,7 +93,11 @@ namespace WallstopStudios.DxMessaging.SourceGenerators
                 typeDecl.IsKind(SyntaxKind.ClassDeclaration)
                 || typeDecl.IsKind(SyntaxKind.StructDeclaration)
                 || typeDecl.IsKind(SyntaxKind.RecordDeclaration)
-                || typeDecl.IsKind(SyntaxKind.RecordStructDeclaration)
+                || string.Equals(
+                    typeDecl.Kind().ToString(),
+                    "RecordStructDeclaration",
+                    StringComparison.Ordinal
+                )
             );
 
         private static TypeToGenerateInfo? GetSemanticTargetForGeneration(
@@ -163,9 +155,8 @@ namespace WallstopStudios.DxMessaging.SourceGenerators
         }
 
         private static void Execute(
-            Compilation compilation,
             ImmutableArray<TypeToGenerateInfo> typesToGenerate,
-            SourceProductionContext context
+            GeneratorExecutionContext context
         )
         {
             if (typesToGenerate.IsDefaultOrEmpty)
@@ -235,7 +226,11 @@ namespace WallstopStudios.DxMessaging.SourceGenerators
                 }
 
                 // Generate the partial class/struct with the constructor
-                string generatedSource = GenerateConstructorSource(compilation, typeInfo, context);
+                string generatedSource = GenerateConstructorSource(
+                    context.Compilation,
+                    typeInfo,
+                    context
+                );
                 string hintName =
                     $"{typeInfo.TypeSymbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat)}.AutoGenConstructor.g.cs"
                         .Replace("global::", "")
@@ -250,7 +245,7 @@ namespace WallstopStudios.DxMessaging.SourceGenerators
         private static string GenerateConstructorSource(
             Compilation compilation,
             TypeToGenerateInfo typeInfo,
-            SourceProductionContext spc
+            GeneratorExecutionContext spc
         )
         {
             INamedTypeSymbol typeSymbol = typeInfo.TypeSymbol;
@@ -290,10 +285,11 @@ namespace WallstopStudios.DxMessaging.SourceGenerators
                     _ => "internal",
                 };
 
+                bool containerIsRecord = IsRecordDeclaration(container);
                 string containerKind = container.TypeKind switch
                 {
-                    TypeKind.Class => container.IsRecord ? "record class" : "class",
-                    TypeKind.Struct => container.IsRecord ? "record struct" : "struct",
+                    TypeKind.Class => containerIsRecord ? "record class" : "class",
+                    TypeKind.Struct => containerIsRecord ? "record struct" : "struct",
                     _ => "class",
                 };
 
@@ -323,10 +319,11 @@ namespace WallstopStudios.DxMessaging.SourceGenerators
                         + ">"
                     : string.Empty;
             string typeName = typeSymbol.Name + typeGenericParams;
+            bool typeIsRecord = IsRecordDeclaration(typeSymbol);
             string typeKind = typeSymbol.TypeKind switch
             {
-                TypeKind.Class => typeSymbol.IsRecord ? "record class" : "class",
-                TypeKind.Struct => typeSymbol.IsRecord ? "record struct" : "struct",
+                TypeKind.Class => typeIsRecord ? "record class" : "class",
+                TypeKind.Struct => typeIsRecord ? "record struct" : "struct",
                 _ => throw new InvalidOperationException(
                     "Unsupported type kind for constructor generation"
                 ),
@@ -524,25 +521,30 @@ namespace WallstopStudios.DxMessaging.SourceGenerators
                 containersClose.Append(currentIndent).AppendLine("}");
             }
 
-            return $$"""
-                // <auto-generated by DxAutoGenConstructorGenerator/>
-                #pragma warning disable
-                #nullable enable annotations
-
-                {{namespaceBlockOpen}}
-                {{containersOpen}}{{innerIndent}}{{typeAccessibility}} partial {{typeKind}} {{typeName}}
-                {{innerIndent}}{
-                {{Indent}}    /// <summary>
-                {{Indent}}    /// Auto-generated constructor by DxAutoGenConstructorGenerator.
-                {{Indent}}    /// </summary>
-                {{innerIndent}}    {{constructorAccessibility}} {{typeSymbol.Name}}({{constructorParams}})
-                {{innerIndent}}    {
-                {{constructorBody}}
-                {{innerIndent}}    }
-                {{innerIndent}}}
-                {{containersClose}}
-                {{namespaceBlockClose}}
-                """;
+            return string.Join(
+                "\r\n",
+                new[]
+                {
+                    "// <auto-generated by DxAutoGenConstructorGenerator/>",
+                    "#pragma warning disable",
+                    "#nullable enable annotations",
+                    string.Empty,
+                    namespaceBlockOpen,
+                    $"{containersOpen}{innerIndent}{typeAccessibility} partial {typeKind} {typeName}",
+                    $"{innerIndent}{{",
+                    $"{Indent}    /// <summary>",
+                    $"{Indent}    /// Auto-generated constructor by DxAutoGenConstructorGenerator.",
+                    $"{Indent}    /// </summary>",
+                    $"{innerIndent}    {constructorAccessibility} {typeSymbol.Name}({constructorParams})",
+                    $"{innerIndent}    {{",
+                    $"{constructorBody}",
+                    $"{innerIndent}    }}",
+                    $"{innerIndent}}}",
+                    $"{containersClose}",
+                    namespaceBlockClose,
+                    string.Empty,
+                }
+            );
         }
 
         private static string FormatLiteral(object value, ITypeSymbol type)
@@ -651,6 +653,23 @@ namespace WallstopStudios.DxMessaging.SourceGenerators
             }
         }
 
+        private static bool IsRecordDeclaration(INamedTypeSymbol symbol)
+        {
+            foreach (SyntaxReference syntaxReference in symbol.DeclaringSyntaxReferences)
+            {
+                if (syntaxReference.GetSyntax() is TypeDeclarationSyntax declaration)
+                {
+                    string kind = declaration.Kind().ToString();
+                    if (kind.IndexOf("Record", StringComparison.Ordinal) >= 0)
+                    {
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+
         private static List<INamedTypeSymbol> GetNonPartialContainers(INamedTypeSymbol typeSymbol)
         {
             List<INamedTypeSymbol> result = new();
@@ -694,5 +713,19 @@ namespace WallstopStudios.DxMessaging.SourceGenerators
 
             return true;
         }
+
+        private sealed class TypeSyntaxReceiver : ISyntaxReceiver
+        {
+            public List<TypeDeclarationSyntax> Candidates { get; } =
+                new List<TypeDeclarationSyntax>();
+
+            public void OnVisitSyntaxNode(SyntaxNode syntaxNode)
+            {
+                if (IsSyntaxTargetForGeneration(syntaxNode))
+                {
+                    Candidates.Add((TypeDeclarationSyntax)syntaxNode);
+                }
+            }
+        }
     }
 }