From f37635a1edb88e13fec6e7312ebf7facd52e65ad Mon Sep 17 00:00:00 2001
From: Arlo Godfrey <arlo.godfrey@outlook.com>
Date: Mon, 27 Mar 2023 20:07:39 -0500
Subject: [PATCH 01/12] Created ToolkitSampleButtonActionAttribute, general
 cleanup

---
 .../GeneratedSampleOptionTemplateSelector.cs  |   3 +
 .../GeneratedSampleOptionsRenderer.xaml       | 112 +++++++++---------
 .../ToolkitSampleBoolOptionAttribute.cs       |   1 -
 .../ToolkitSampleButtonActionAttribute.cs     |  33 ++++++
 ...ToolkitSampleMultiChoiceOptionAttribute.cs |   2 +-
 .../ToolkitSampleOptionBaseAttribute.cs       |   2 +-
 .../CommunityToolkit.Tooling.SampleGen.csproj |   2 +-
 .../GeneratorExtensions.cs                    |  11 +-
 ...lkitSampleButtonActionMetadataViewModel.cs | 101 ++++++++++++++++
 .../Metadata/ToolkitSampleButtonCommand.cs    |  34 ++++++
 .../ToolkitSampleMetadataGenerator.Sample.cs  |  19 ++-
 .../ToolkitSampleOptionGenerator.cs           | 109 +++++++++++++----
 12 files changed, 341 insertions(+), 88 deletions(-)
 create mode 100644 CommunityToolkit.Tooling.SampleGen/Attributes/ToolkitSampleButtonActionAttribute.cs
 create mode 100644 CommunityToolkit.Tooling.SampleGen/Metadata/ToolkitSampleButtonActionMetadataViewModel.cs
 create mode 100644 CommunityToolkit.Tooling.SampleGen/Metadata/ToolkitSampleButtonCommand.cs

diff --git a/CommunityToolkit.App.Shared/Renderers/GeneratedSampleOptionTemplateSelector.cs b/CommunityToolkit.App.Shared/Renderers/GeneratedSampleOptionTemplateSelector.cs
index 7c55f1ba..f9652f52 100644
--- a/CommunityToolkit.App.Shared/Renderers/GeneratedSampleOptionTemplateSelector.cs
+++ b/CommunityToolkit.App.Shared/Renderers/GeneratedSampleOptionTemplateSelector.cs
@@ -13,6 +13,8 @@ internal class GeneratedSampleOptionTemplateSelector : DataTemplateSelector
 {
     public DataTemplate? BoolOptionTemplate { get; set; }
 
+    public DataTemplate? ButtonActionTemplate { get; set; }
+
     public DataTemplate? MultiChoiceOptionTemplate { get; set; }
 
     public DataTemplate? SliderOptionTemplate { get; set; }
@@ -26,6 +28,7 @@ protected override DataTemplate SelectTemplateCore(object item, DependencyObject
         return item switch
         {
             ToolkitSampleBoolOptionMetadataViewModel => BoolOptionTemplate ?? base.SelectTemplateCore(item, container),
+            ToolkitSampleButtonActionMetadataViewModel => ButtonActionTemplate ?? base.SelectTemplateCore(item, container),
             ToolkitSampleMultiChoiceOptionMetadataViewModel => MultiChoiceOptionTemplate ?? base.SelectTemplateCore(item, container),
             ToolkitSampleNumericOptionMetadataViewModel { ShowAsNumberBox: true } => NumberBoxOptionTemplate ?? base.SelectTemplateCore(item, container),
             ToolkitSampleNumericOptionMetadataViewModel { ShowAsNumberBox: false } => SliderOptionTemplate ?? base.SelectTemplateCore(item, container),
diff --git a/CommunityToolkit.App.Shared/Renderers/GeneratedSampleOptionsRenderer.xaml b/CommunityToolkit.App.Shared/Renderers/GeneratedSampleOptionsRenderer.xaml
index f92426ca..3c92242e 100644
--- a/CommunityToolkit.App.Shared/Renderers/GeneratedSampleOptionsRenderer.xaml
+++ b/CommunityToolkit.App.Shared/Renderers/GeneratedSampleOptionsRenderer.xaml
@@ -12,58 +12,64 @@
              d:DesignWidth="400"
              mc:Ignorable="d">
 
-    <UserControl.Resources>
-        <local:GeneratedSampleOptionTemplateSelector x:Key="GeneratedSampleOptionTemplateSelector">
-            <local:GeneratedSampleOptionTemplateSelector.BoolOptionTemplate>
-                <DataTemplate x:DataType="metadata:ToolkitSampleBoolOptionMetadataViewModel">
-                    <ToggleSwitch Header="{x:Bind Title, Mode=OneWay}"
-                                  IsOn="{x:Bind BoolValue, Mode=TwoWay}" />
-                </DataTemplate>
-            </local:GeneratedSampleOptionTemplateSelector.BoolOptionTemplate>
-            <local:GeneratedSampleOptionTemplateSelector.MultiChoiceOptionTemplate>
-                <DataTemplate x:DataType="metadata:ToolkitSampleMultiChoiceOptionMetadataViewModel">
-                    <ComboBox Header="{x:Bind Title, Mode=OneWay}"
-                              ItemsSource="{x:Bind Options}"
-                              SelectedIndex="0"
-                              SelectedItem="{x:Bind Value, Mode=TwoWay}" />
-                </DataTemplate>
-            </local:GeneratedSampleOptionTemplateSelector.MultiChoiceOptionTemplate>
-            <local:GeneratedSampleOptionTemplateSelector.SliderOptionTemplate>
-                <DataTemplate x:DataType="metadata:ToolkitSampleNumericOptionMetadataViewModel">
-                    <Slider Header="{x:Bind Title, Mode=OneWay}"
-                            Maximum="{x:Bind Max, Mode=OneWay}"
-                            Minimum="{x:Bind Min, Mode=OneWay}"
-                            StepFrequency="{x:Bind Step, Mode=OneWay}"
-                            Value="{x:Bind Initial, Mode=TwoWay}" />
-                </DataTemplate>
-            </local:GeneratedSampleOptionTemplateSelector.SliderOptionTemplate>
-            <local:GeneratedSampleOptionTemplateSelector.NumberBoxOptionTemplate>
-                <DataTemplate x:DataType="metadata:ToolkitSampleNumericOptionMetadataViewModel">
-                    <muxc:NumberBox Header="{x:Bind Title, Mode=OneWay}"
-                                    Maximum="{x:Bind Max, Mode=OneWay}"
-                                    Minimum="{x:Bind Min, Mode=OneWay}"
-                                    SmallChange="{x:Bind Step, Mode=OneWay}"
-                                    SpinButtonPlacementMode="Compact"
-                                    Value="{x:Bind Initial, Mode=TwoWay}" />
-                </DataTemplate>
-            </local:GeneratedSampleOptionTemplateSelector.NumberBoxOptionTemplate>
-            <local:GeneratedSampleOptionTemplateSelector.TextOptionTemplate>
-                <DataTemplate x:DataType="metadata:ToolkitSampleTextOptionMetadataViewModel">
-                    <TextBox HorizontalAlignment="Stretch"
-                             Header="{x:Bind Title, Mode=OneWay}"
-                             Text="{x:Bind PlaceholderText, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" />
-                </DataTemplate>
-            </local:GeneratedSampleOptionTemplateSelector.TextOptionTemplate>
-        </local:GeneratedSampleOptionTemplateSelector>
-    </UserControl.Resources>
+	<UserControl.Resources>
+		<local:GeneratedSampleOptionTemplateSelector x:Key="GeneratedSampleOptionTemplateSelector">
+			<local:GeneratedSampleOptionTemplateSelector.BoolOptionTemplate>
+				<DataTemplate x:DataType="metadata:ToolkitSampleBoolOptionMetadataViewModel">
+					<ToggleSwitch Header="{x:Bind Title, Mode=OneWay}"
+					              IsOn="{x:Bind BoolValue, Mode=TwoWay}" />
+				</DataTemplate>
+			</local:GeneratedSampleOptionTemplateSelector.BoolOptionTemplate>
+			<local:GeneratedSampleOptionTemplateSelector.ButtonActionTemplate>
+				<DataTemplate x:DataType="metadata:ToolkitSampleButtonActionMetadataViewModel">
+					<Button Command="{x:Bind CommandValue, Mode=TwoWay}"
+					        Content="{x:Bind Label, Mode=OneWay}" />
+				</DataTemplate>
+			</local:GeneratedSampleOptionTemplateSelector.ButtonActionTemplate>
+			<local:GeneratedSampleOptionTemplateSelector.MultiChoiceOptionTemplate>
+				<DataTemplate x:DataType="metadata:ToolkitSampleMultiChoiceOptionMetadataViewModel">
+					<ComboBox Header="{x:Bind Title, Mode=OneWay}"
+					          ItemsSource="{x:Bind Options}"
+					          SelectedIndex="0"
+					          SelectedItem="{x:Bind Value, Mode=TwoWay}" />
+				</DataTemplate>
+			</local:GeneratedSampleOptionTemplateSelector.MultiChoiceOptionTemplate>
+			<local:GeneratedSampleOptionTemplateSelector.SliderOptionTemplate>
+				<DataTemplate x:DataType="metadata:ToolkitSampleNumericOptionMetadataViewModel">
+					<Slider Header="{x:Bind Title, Mode=OneWay}"
+					        Maximum="{x:Bind Max, Mode=OneWay}"
+					        Minimum="{x:Bind Min, Mode=OneWay}"
+					        StepFrequency="{x:Bind Step, Mode=OneWay}"
+					        Value="{x:Bind Initial, Mode=TwoWay}" />
+				</DataTemplate>
+			</local:GeneratedSampleOptionTemplateSelector.SliderOptionTemplate>
+			<local:GeneratedSampleOptionTemplateSelector.NumberBoxOptionTemplate>
+				<DataTemplate x:DataType="metadata:ToolkitSampleNumericOptionMetadataViewModel">
+					<muxc:NumberBox Header="{x:Bind Title, Mode=OneWay}"
+					                Maximum="{x:Bind Max, Mode=OneWay}"
+					                Minimum="{x:Bind Min, Mode=OneWay}"
+					                SmallChange="{x:Bind Step, Mode=OneWay}"
+					                SpinButtonPlacementMode="Compact"
+					                Value="{x:Bind Initial, Mode=TwoWay}" />
+				</DataTemplate>
+			</local:GeneratedSampleOptionTemplateSelector.NumberBoxOptionTemplate>
+			<local:GeneratedSampleOptionTemplateSelector.TextOptionTemplate>
+				<DataTemplate x:DataType="metadata:ToolkitSampleTextOptionMetadataViewModel">
+					<TextBox HorizontalAlignment="Stretch"
+					         Header="{x:Bind Title, Mode=OneWay}"
+					         Text="{x:Bind PlaceholderText, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" />
+				</DataTemplate>
+			</local:GeneratedSampleOptionTemplateSelector.TextOptionTemplate>
+		</local:GeneratedSampleOptionTemplateSelector>
+	</UserControl.Resources>
 
-    <ItemsControl ItemTemplateSelector="{StaticResource GeneratedSampleOptionTemplateSelector}"
-                  ItemsSource="{x:Bind SampleOptions, Mode=OneWay}">
-        <ItemsControl.ItemsPanel>
-            <ItemsPanelTemplate>
-                <StackPanel Orientation="Vertical"
-                            Spacing="12" />
-            </ItemsPanelTemplate>
-        </ItemsControl.ItemsPanel>
-    </ItemsControl>
+	<ItemsControl ItemTemplateSelector="{StaticResource GeneratedSampleOptionTemplateSelector}"
+	              ItemsSource="{x:Bind SampleOptions, Mode=OneWay}">
+		<ItemsControl.ItemsPanel>
+			<ItemsPanelTemplate>
+				<StackPanel Orientation="Vertical"
+				            Spacing="12" />
+			</ItemsPanelTemplate>
+		</ItemsControl.ItemsPanel>
+	</ItemsControl>
 </UserControl>
diff --git a/CommunityToolkit.Tooling.SampleGen/Attributes/ToolkitSampleBoolOptionAttribute.cs b/CommunityToolkit.Tooling.SampleGen/Attributes/ToolkitSampleBoolOptionAttribute.cs
index 24577848..7b600b7d 100644
--- a/CommunityToolkit.Tooling.SampleGen/Attributes/ToolkitSampleBoolOptionAttribute.cs
+++ b/CommunityToolkit.Tooling.SampleGen/Attributes/ToolkitSampleBoolOptionAttribute.cs
@@ -23,7 +23,6 @@ public sealed class ToolkitSampleBoolOptionAttribute : ToolkitSampleOptionBaseAt
     public ToolkitSampleBoolOptionAttribute(string bindingName, bool defaultState)
         : base(bindingName, defaultState)
     {
- 
     }
 
     /// <summary>
diff --git a/CommunityToolkit.Tooling.SampleGen/Attributes/ToolkitSampleButtonActionAttribute.cs b/CommunityToolkit.Tooling.SampleGen/Attributes/ToolkitSampleButtonActionAttribute.cs
new file mode 100644
index 00000000..8023e93e
--- /dev/null
+++ b/CommunityToolkit.Tooling.SampleGen/Attributes/ToolkitSampleButtonActionAttribute.cs
@@ -0,0 +1,33 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace CommunityToolkit.Tooling.SampleGen.Attributes;
+
+/// <summary>
+/// Generates a command that invokes the decorated method, and a button in the sample option panel that invokes the command when clicked.
+/// </summary>
+/// <remarks>
+/// Using this attribute will automatically generate an <see cref="INotifyPropertyChanged"/>-enabled property
+/// that you can bind to in XAML, and displays an options pane alonside your sample which allows the user to manipulate the property.
+/// </remarks>
+[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
+public sealed class ToolkitSampleButtonActionAttribute : ToolkitSampleOptionBaseAttribute
+{
+    /// <summary>
+    /// Creates a new instance of <see cref="ToolkitSampleButtonActionAttribute"/>.
+    /// </summary>
+    /// <param name="label">The text displayed inside the button.</param>
+    public ToolkitSampleButtonActionAttribute(string label)
+        : base(string.Empty, null)
+    {
+        Label = label;
+    }
+
+    public string Label { get; }
+
+    /// <summary>
+    /// The source generator-friendly type name used for casting.
+    /// </summary>
+    internal override string TypeName { get; } = "System.Windows.Input.ICommand";
+}
diff --git a/CommunityToolkit.Tooling.SampleGen/Attributes/ToolkitSampleMultiChoiceOptionAttribute.cs b/CommunityToolkit.Tooling.SampleGen/Attributes/ToolkitSampleMultiChoiceOptionAttribute.cs
index 109b438d..406baa52 100644
--- a/CommunityToolkit.Tooling.SampleGen/Attributes/ToolkitSampleMultiChoiceOptionAttribute.cs
+++ b/CommunityToolkit.Tooling.SampleGen/Attributes/ToolkitSampleMultiChoiceOptionAttribute.cs
@@ -5,7 +5,7 @@
 namespace CommunityToolkit.Tooling.SampleGen.Attributes;
 
 /// <summary>
-/// Represents a boolean sample option.
+/// Generates a property and multi-choice option in the sample option pane that can be used to update it.
 /// </summary>
 /// <remarks>
 /// Using this attribute will automatically generate an <see cref="INotifyPropertyChanged"/>-enabled property
diff --git a/CommunityToolkit.Tooling.SampleGen/Attributes/ToolkitSampleOptionBaseAttribute.cs b/CommunityToolkit.Tooling.SampleGen/Attributes/ToolkitSampleOptionBaseAttribute.cs
index 9df4dfe9..ac4dd33e 100644
--- a/CommunityToolkit.Tooling.SampleGen/Attributes/ToolkitSampleOptionBaseAttribute.cs
+++ b/CommunityToolkit.Tooling.SampleGen/Attributes/ToolkitSampleOptionBaseAttribute.cs
@@ -24,7 +24,7 @@ public ToolkitSampleOptionBaseAttribute(string bindingName, object? defaultState
     /// <summary>
     /// A name that you can bind to in your XAML.
     /// </summary>
-    public string Name { get; }
+    public string Name { get; internal set; }
 
     /// <summary>
     /// The default state.
diff --git a/CommunityToolkit.Tooling.SampleGen/CommunityToolkit.Tooling.SampleGen.csproj b/CommunityToolkit.Tooling.SampleGen/CommunityToolkit.Tooling.SampleGen.csproj
index ae539b98..f1ab648c 100644
--- a/CommunityToolkit.Tooling.SampleGen/CommunityToolkit.Tooling.SampleGen.csproj
+++ b/CommunityToolkit.Tooling.SampleGen/CommunityToolkit.Tooling.SampleGen.csproj
@@ -4,7 +4,7 @@
     <TargetFramework>netstandard2.0</TargetFramework>
     <Nullable>enable</Nullable>
     <WarningsAsErrors>nullable</WarningsAsErrors>
-    <LangVersion>10.0</LangVersion>
+    <LangVersion>11.0</LangVersion>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/CommunityToolkit.Tooling.SampleGen/GeneratorExtensions.cs b/CommunityToolkit.Tooling.SampleGen/GeneratorExtensions.cs
index 23bae29a..956f2d58 100644
--- a/CommunityToolkit.Tooling.SampleGen/GeneratorExtensions.cs
+++ b/CommunityToolkit.Tooling.SampleGen/GeneratorExtensions.cs
@@ -12,18 +12,21 @@ public static class GeneratorExtensions
     /// Crawls a namespace and all child namespaces for all contained types.
     /// </summary>
     /// <returns>A flattened enumerable of <see cref="INamedTypeSymbol"/>s.</returns>
-    public static IEnumerable<INamedTypeSymbol> CrawlForAllNamedTypes(this INamespaceSymbol namespaceSymbol)
+    public static IEnumerable<ISymbol> CrawlForAllSymbols(this INamespaceSymbol namespaceSymbol, SymbolKind symbolKind)
     {
         foreach (var member in namespaceSymbol.GetMembers())
         {
             if (member is INamespaceSymbol nestedNamespace)
             {
-                foreach (var item in CrawlForAllNamedTypes(nestedNamespace))
+                foreach (var item in CrawlForAllSymbols(nestedNamespace, symbolKind))
                     yield return item;
             }
 
-            if (member is INamedTypeSymbol typeSymbol)
-                yield return typeSymbol;
+            foreach (Enum value in Enum.GetValues(typeof(SymbolKind)))
+            {
+                if (symbolKind.HasFlag(value) && member.Kind.HasFlag(value))
+                    yield return member;
+            }
         }
     }
 
diff --git a/CommunityToolkit.Tooling.SampleGen/Metadata/ToolkitSampleButtonActionMetadataViewModel.cs b/CommunityToolkit.Tooling.SampleGen/Metadata/ToolkitSampleButtonActionMetadataViewModel.cs
new file mode 100644
index 00000000..a37813c8
--- /dev/null
+++ b/CommunityToolkit.Tooling.SampleGen/Metadata/ToolkitSampleButtonActionMetadataViewModel.cs
@@ -0,0 +1,101 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using CommunityToolkit.Tooling.SampleGen.Attributes;
+using System.Windows.Input;
+
+namespace CommunityToolkit.Tooling.SampleGen.Metadata;
+
+/// <summary>
+/// An INPC-enabled metadata container for data defined in an <see cref="ToolkitSampleButtonActionAttribute"/>.
+/// </summary>
+/// <remarks>
+/// Instances of these are generated by the <see cref="ToolkitSampleMetadataGenerator"/> and
+/// provided to the app alongside the sample registration.
+/// </remarks>
+public class ToolkitSampleButtonActionMetadataViewModel : IGeneratedToolkitSampleOptionViewModel
+{
+    private string? _title;
+    private object? _value;
+    private string _label;
+
+    /// <summary>
+    /// Creates a new instance of <see cref="ToolkitSampleButtonActionMetadataViewModel"/>.
+    /// </summary>
+    public ToolkitSampleButtonActionMetadataViewModel(string name, string label, string? title = null)
+    {
+        Name = name;
+
+        _label = label;
+        _title = title;
+    }
+
+    /// <inheritdoc cref="INotifyPropertyChanged.PropertyChanged"/>
+    public event PropertyChangedEventHandler? PropertyChanged;
+
+    /// <summary>
+    /// A unique identifier for this option.
+    /// </summary>
+    /// <remarks>
+    /// Used by the sample system to match up <see cref="ToolkitSampleButtonActionMetadataViewModel"/> to the original <see cref="ToolkitSampleButtonActionAttribute"/> and the control that declared it.
+    /// </remarks>
+    public string Name { get; }
+
+    /// <summary>
+    /// The current boolean value.
+    /// </summary>
+    /// <remarks>
+    /// Provided to accomodate binding to a property that is a non-nullable <see cref="bool"/>.
+    /// </remarks>
+    public ICommand CommandValue
+    {
+        get => (ICommand)_value!;
+        set
+        {
+            _value = value;
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Value)));
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(CommandValue)));
+        }
+    }
+
+    /// <summary>
+    /// The current boolean value.
+    /// </summary>
+    public object? Value
+    {
+        get => _value;
+        set 
+        {
+            _value = value;
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Value)));
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(CommandValue)));
+        }
+    }
+
+    /// <summary>
+    /// The label to display inside the button.
+    /// </summary>
+    public string Label
+    {
+        get => _label;
+        set
+        {
+            _label = value;
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Label)));
+        }
+    }
+
+    /// <summary>
+    /// A title to display on top of the button.
+    /// </summary>
+    public string? Title
+    {
+        get => _title;
+        set
+        {
+            _title = value;
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Title)));
+        }
+    }
+}
diff --git a/CommunityToolkit.Tooling.SampleGen/Metadata/ToolkitSampleButtonCommand.cs b/CommunityToolkit.Tooling.SampleGen/Metadata/ToolkitSampleButtonCommand.cs
new file mode 100644
index 00000000..9d5db522
--- /dev/null
+++ b/CommunityToolkit.Tooling.SampleGen/Metadata/ToolkitSampleButtonCommand.cs
@@ -0,0 +1,34 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Windows.Input;
+
+namespace CommunityToolkit.Tooling.SampleGen.Metadata;
+
+/// <summary>
+/// A command that invokes the provided <see cref="Action"/> when executed.
+/// </summary>
+public class ToolkitSampleButtonCommand : ICommand
+{
+    private readonly Action _callback;
+
+    public ToolkitSampleButtonCommand(Action callback)
+    {
+        _callback = callback;
+    }
+
+    /// <inheritdoc />
+    public event EventHandler? CanExecuteChanged;
+    
+    /// <inheritdoc />
+    public bool CanExecute(object parameter)
+    {
+        throw new NotImplementedException();
+    }
+    /// <inheritdoc />
+    public void Execute(object parameter)
+    {
+        _callback();
+    }
+}
diff --git a/CommunityToolkit.Tooling.SampleGen/ToolkitSampleMetadataGenerator.Sample.cs b/CommunityToolkit.Tooling.SampleGen/ToolkitSampleMetadataGenerator.Sample.cs
index d13cbbf5..024e6888 100644
--- a/CommunityToolkit.Tooling.SampleGen/ToolkitSampleMetadataGenerator.Sample.cs
+++ b/CommunityToolkit.Tooling.SampleGen/ToolkitSampleMetadataGenerator.Sample.cs
@@ -23,16 +23,14 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
     {
         var symbolsInExecutingAssembly = context.SyntaxProvider
             .CreateSyntaxProvider(
-                static (s, _) => s is ClassDeclarationSyntax c && c.AttributeLists.Count > 0,
+                static (s, _) => s is ClassDeclarationSyntax c && c.AttributeLists.Count > 0 || s is MethodDeclarationSyntax m && m.AttributeLists.Count > 0,
                 static (ctx, _) => ctx.SemanticModel.GetDeclaredSymbol(ctx.Node))
             .Where(static m => m is not null)
             .Select(static (x, _) => x!);
 
         var symbolsInReferencedAssemblies = context.CompilationProvider
                               .SelectMany((x, _) => x.SourceModule.ReferencedAssemblySymbols)
-                              .SelectMany((asm, _) => asm.GlobalNamespace.CrawlForAllNamedTypes())
-                              .Where(x => x.TypeKind == TypeKind.Class && x.CanBeReferencedByName)
-                              .Select((x, _) => (ISymbol)x);
+                              .SelectMany((asm, _) => asm.GlobalNamespace.CrawlForAllSymbols(SymbolKind.NamedType | SymbolKind.Method));
 
         var markdownFiles = context.AdditionalTextsProvider
             .Where(static file => file.Path.EndsWith(".md"))
@@ -60,7 +58,7 @@ void Execute(IncrementalValuesProvider<ISymbol> types, bool skipDiagnostics = fa
                 {
                     (ISymbol Symbol, ToolkitSampleOptionBaseAttribute Attribute) item = default;
 
-                    // Try and get base attribute of whatever sample attribute types we support.
+                    // Reconstruct declared sample option attribute class instances from Roslyn symbols.
                     if (x.Item2.TryReconstructAs<ToolkitSampleBoolOptionAttribute>() is ToolkitSampleBoolOptionAttribute boolOptionAttribute)
                     {
                         item = (x.Item1, boolOptionAttribute);
@@ -77,6 +75,13 @@ void Execute(IncrementalValuesProvider<ISymbol> types, bool skipDiagnostics = fa
                     {
                         item = (x.Item1, textOptionAttribute);
                     }
+                    else if (x.Item2.TryReconstructAs<ToolkitSampleButtonActionAttribute>() is ToolkitSampleButtonActionAttribute buttonActionAttribute)
+                    {
+                        // Auto-assign the attached method name as the generated property name.
+                        buttonActionAttribute.Name = x.Item1.Name;
+
+                        item = (x.Item1, buttonActionAttribute);
+                    }
 
                     // Add extra property data, like Title back to Attribute
                     if (item.Attribute != null && x.Item2.TryGetNamedArgument(nameof(ToolkitSampleOptionBaseAttribute.Title), out string? title) && !string.IsNullOrWhiteSpace(title))
@@ -310,6 +315,10 @@ private static IEnumerable<string> BuildNewGeneratedSampleOptionMetadataSource(T
             {
                 yield return $@"new {typeof(ToolkitSampleBoolOptionMetadataViewModel).FullName}(name: ""{boolAttribute.Name}"", defaultState: {boolAttribute.DefaultState?.ToString().ToLower()}, title: ""{boolAttribute.Title}"")";
             }
+            else if (item is ToolkitSampleButtonActionAttribute buttonAttribute)
+            {
+                yield return $@"new {typeof(ToolkitSampleButtonActionMetadataViewModel).FullName}(name: ""{buttonAttribute.Name}"", label: ""{buttonAttribute.Label}"", title: ""{buttonAttribute.Title}"")";
+            }
             else if (item is ToolkitSampleNumericOptionAttribute numericAttribute)
             {
                 yield return $@"new {typeof(ToolkitSampleNumericOptionMetadataViewModel).FullName}(name: ""{numericAttribute.Name}"", initial: {numericAttribute.Initial}, min: {numericAttribute.Min}, max: {numericAttribute.Max}, step: {numericAttribute.Step}, showAsNumberBox: {numericAttribute.ShowAsNumberBox.ToString().ToLower()}, title: ""{numericAttribute.Title}"")";
diff --git a/CommunityToolkit.Tooling.SampleGen/ToolkitSampleOptionGenerator.cs b/CommunityToolkit.Tooling.SampleGen/ToolkitSampleOptionGenerator.cs
index 16fe9de7..f48308f1 100644
--- a/CommunityToolkit.Tooling.SampleGen/ToolkitSampleOptionGenerator.cs
+++ b/CommunityToolkit.Tooling.SampleGen/ToolkitSampleOptionGenerator.cs
@@ -23,7 +23,7 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
     {
         var classes = context.SyntaxProvider
             .CreateSyntaxProvider(
-                static (s, _) => s is ClassDeclarationSyntax c && c.AttributeLists.Count > 0,
+                static (s, _) => s is ClassDeclarationSyntax c && c.AttributeLists.Count > 0 || s is MethodDeclarationSyntax m && m.AttributeLists.Count > 0,
                 static (ctx, _) => ctx.SemanticModel.GetDeclaredSymbol(ctx.Node))
             .Where(static m => m is not null)
             .Select(static (x, _) => x!);
@@ -36,16 +36,19 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
             .Select((x, _) =>
             {
                 if (x.Item2.TryReconstructAs<ToolkitSampleBoolOptionAttribute>() is ToolkitSampleBoolOptionAttribute boolOptionAttribute)
-                    return (Attribute: (ToolkitSampleOptionBaseAttribute)boolOptionAttribute, ContainingClassSymbol: x.Item1, Type: typeof(ToolkitSampleBoolOptionMetadataViewModel));
+                    return (Attribute: (ToolkitSampleOptionBaseAttribute)boolOptionAttribute, AttachedSymbol: x.Item1, Type: typeof(ToolkitSampleBoolOptionMetadataViewModel));
+
+                if (x.Item2.TryReconstructAs<ToolkitSampleButtonActionAttribute>() is ToolkitSampleButtonActionAttribute buttonActionAttribute)
+                    return (Attribute: (ToolkitSampleOptionBaseAttribute)buttonActionAttribute, AttachedSymbol: x.Item1, Type: typeof(ToolkitSampleButtonActionMetadataViewModel));
 
                 if (x.Item2.TryReconstructAs<ToolkitSampleMultiChoiceOptionAttribute>() is ToolkitSampleMultiChoiceOptionAttribute multiChoiceOptionAttribute)
-                    return (Attribute: (ToolkitSampleOptionBaseAttribute)multiChoiceOptionAttribute, ContainingClassSymbol: x.Item1, Type: typeof(ToolkitSampleMultiChoiceOptionMetadataViewModel));
+                    return (Attribute: (ToolkitSampleOptionBaseAttribute)multiChoiceOptionAttribute, AttachedSymbol: x.Item1, Type: typeof(ToolkitSampleMultiChoiceOptionMetadataViewModel));
 
-                if(x.Item2.TryReconstructAs<ToolkitSampleNumericOptionAttribute>() is ToolkitSampleNumericOptionAttribute numericOptionAttribute)
-                    return (Attribute: (ToolkitSampleOptionBaseAttribute)numericOptionAttribute, ContainingClassSymbol: x.Item1, Type: typeof(ToolkitSampleNumericOptionMetadataViewModel));
+                if (x.Item2.TryReconstructAs<ToolkitSampleNumericOptionAttribute>() is ToolkitSampleNumericOptionAttribute numericOptionAttribute)
+                    return (Attribute: (ToolkitSampleOptionBaseAttribute)numericOptionAttribute, AttachedSymbol: x.Item1, Type: typeof(ToolkitSampleNumericOptionMetadataViewModel));
 
                 if (x.Item2.TryReconstructAs<ToolkitSampleTextOptionAttribute>() is ToolkitSampleTextOptionAttribute textOptionAttribute)
-                    return (Attribute: (ToolkitSampleOptionBaseAttribute)textOptionAttribute, ContainingClassSymbol: x.Item1, Type: typeof(ToolkitSampleTextOptionMetadataViewModel));
+                    return (Attribute: (ToolkitSampleOptionBaseAttribute)textOptionAttribute, AttachedSymbol: x.Item1, Type: typeof(ToolkitSampleTextOptionMetadataViewModel));
 
                 return default;
             })
@@ -53,37 +56,63 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
 
         context.RegisterSourceOutput(sampleAttributeOptions, (ctx, data) =>
         {
-            if (_handledContainingClasses.Add(data.ContainingClassSymbol))
+            var format = new SymbolDisplayFormat(
+                    globalNamespaceStyle: SymbolDisplayGlobalNamespaceStyle.OmittedAsContaining,
+                    typeQualificationStyle: SymbolDisplayTypeQualificationStyle.NameAndContainingTypesAndNamespaces,
+                    propertyStyle: SymbolDisplayPropertyStyle.NameOnly,
+                    memberOptions: SymbolDisplayMemberOptions.IncludeContainingType
+                );
+
+            var containingClass = data.AttachedSymbol.Kind switch
+            {
+                SymbolKind.Method => data.AttachedSymbol.ContainingSymbol,
+                SymbolKind.NamedType => data.AttachedSymbol,
+                _ => throw new NotSupportedException("Only methods and classes are supported here."),
+            };
+
+            var name = data.AttachedSymbol.Kind switch
             {
-                if (data.ContainingClassSymbol is ITypeSymbol typeSym && !typeSym.AllInterfaces.Any(x => x.HasFullyQualifiedName("global::System.ComponentModel.INotifyPropertyChanged")))
+                SymbolKind.Method => $"{data.AttachedSymbol.ToDisplayString(format)}.CommandProperty.g",
+                SymbolKind.NamedType => $"{data.AttachedSymbol.ToDisplayString(format)}.Property.{data.Attribute.Name}.g",
+                _ => throw new NotSupportedException("Only methods and classes are supported here."),
+            };
+
+            // Generate property container and INPC
+            if (this._handledContainingClasses.Add(containingClass))
+            {
+                if (containingClass is ITypeSymbol typeSym && !typeSym.AllInterfaces.Any(x => x.HasFullyQualifiedName("global::System.ComponentModel.INotifyPropertyChanged")))
                 {
-                    var inpcImpl = BuildINotifyPropertyChangedImplementation(data.ContainingClassSymbol);
-                    ctx.AddSource($"{data.ContainingClassSymbol}.NotifyPropertyChanged.g", inpcImpl);
+                    var inpcImpl = BuildINotifyPropertyChangedImplementation(containingClass);
+                    ctx.AddSource($"{containingClass}.NotifyPropertyChanged.g", inpcImpl);
                 }
 
-                var propertyContainerSource = BuildGeneratedPropertyMetadataContainer(data.ContainingClassSymbol);
-                ctx.AddSource($"{data.ContainingClassSymbol}.GeneratedPropertyContainer.g", propertyContainerSource);
+                ctx.AddSource($"{containingClass.ToDisplayString(format)}.GeneratedPropertyContainer.g", BuildGeneratedPropertyMetadataContainer(containingClass));
             }
 
-            var name = $"{data.ContainingClassSymbol}.Property.{data.Attribute.Name}.g";
-
-            if (_handledPropertyNames.Add(name))
+            // Generate property
+            if (this._handledPropertyNames.Add(name))
             {
-                var dependencyPropertySource = BuildProperty(data.ContainingClassSymbol, data.Attribute.Name, data.Attribute.TypeName, data.Type);
+                var dependencyPropertySource = data.AttachedSymbol.Kind switch
+                {
+                    SymbolKind.Method => BuildCommandProperty(attachedMethodSymbol: data.AttachedSymbol, data.Type),
+                    SymbolKind.NamedType => BuildProperty(containingClassSymbol: data.AttachedSymbol, data.Attribute.Name, data.Attribute.TypeName, data.Type),
+                    _ => throw new NotSupportedException("Only methods and classes are supported here."),
+                };
+
                 ctx.AddSource(name, dependencyPropertySource);
             }
         });
 
     }
 
-    private static string BuildINotifyPropertyChangedImplementation(ISymbol containingClassSymbol)
+    private static string BuildINotifyPropertyChangedImplementation(ISymbol attachedSymbol)
     {
         return $@"#nullable enable
 using System.ComponentModel;
 
-namespace {containingClassSymbol.ContainingNamespace}
+namespace {attachedSymbol.ContainingNamespace}
 {{
-    public partial class {containingClassSymbol.Name} : {nameof(System.ComponentModel.INotifyPropertyChanged)}
+    public partial class {attachedSymbol.Name} : {nameof(System.ComponentModel.INotifyPropertyChanged)}
     {{
 		public event PropertyChangedEventHandler? PropertyChanged;
     }}
@@ -91,15 +120,15 @@ public partial class {containingClassSymbol.Name} : {nameof(System.ComponentMode
 ";
     }
 
-    private static string BuildGeneratedPropertyMetadataContainer(ISymbol containingClassSymbol)
+    private static string BuildGeneratedPropertyMetadataContainer(ISymbol attachedSymbol)
     {
         return $@"#nullable enable
 using System.ComponentModel;
 using System.Collections.Generic;
 
-namespace {containingClassSymbol.ContainingNamespace}
+namespace {attachedSymbol.ContainingNamespace}
 {{
-    public partial class {containingClassSymbol.Name} : {typeof(IToolkitSampleGeneratedOptionPropertyContainer).Namespace}.{nameof(IToolkitSampleGeneratedOptionPropertyContainer)}
+    public partial class {attachedSymbol.Name} : {typeof(IToolkitSampleGeneratedOptionPropertyContainer).Namespace}.{nameof(IToolkitSampleGeneratedOptionPropertyContainer)}
     {{
         private IEnumerable<{typeof(IGeneratedToolkitSampleOptionViewModel).FullName}>? _generatedPropertyMetadata;
 
@@ -156,4 +185,40 @@ public partial class {containingClassSymbol.Name}
 }}
 ";
     }
+
+    private static string BuildCommandProperty(ISymbol attachedMethodSymbol, Type viewModelType)
+    {
+        // User-supplied command methods are instance methods, and must be called from the same containing object instance.
+        // To generate a command property that points to this, we lazy-set the default command value in
+        // the getter and pass the instance method in as the command delegate.
+
+        return $$"""
+#nullable enable
+using System.ComponentModel;
+using System.Linq;
+
+namespace {{attachedMethodSymbol.ContainingNamespace}}
+{
+    public partial class {{attachedMethodSymbol.ContainingSymbol.Name}}
+    {
+        public {{typeof(System.Windows.Input.ICommand).FullName}} {{attachedMethodSymbol.Name}}Command
+        {
+            get
+            {
+                var metadata = GeneratedPropertyMetadata!.First(x => x.Name == nameof({{attachedMethodSymbol.Name}}));
+                return ({{typeof(System.Windows.Input.ICommand).FullName}})(metadata.Value ??= new {{typeof(ToolkitSampleButtonCommand).FullName}}({{attachedMethodSymbol.Name}}));
+            }
+            set
+            {
+				if (GeneratedPropertyMetadata?.FirstOrDefault(x => x.Name == nameof({{attachedMethodSymbol.Name}})) is {{viewModelType.FullName}} metadata)
+				{
+                    metadata.Value = (object)value;
+					PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof({{attachedMethodSymbol.Name}}Command)));
+				}
+            }
+        }
+    }
+}
+""";
+    }
 }

From 9da7b05a2bf8cd0eef17cd5cc3a64b364db41bcd Mon Sep 17 00:00:00 2001
From: Arlo Godfrey <arlo.godfrey@outlook.com>
Date: Fri, 31 Mar 2023 18:06:10 -0500
Subject: [PATCH 02/12] WIP adding method support to SampleGen

---
 .../ToolkitSampleGeneratedPaneTests.cs        | 377 ++++++++++++++++++
 .../ToolkitSampleMetadataTests.cs             | 342 +---------------
 .../GeneratorExtensions.cs                    |  10 +-
 .../ToolkitSampleMetadataGenerator.Sample.cs  |  19 +-
 4 files changed, 392 insertions(+), 356 deletions(-)
 create mode 100644 CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleGeneratedPaneTests.cs

diff --git a/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleGeneratedPaneTests.cs b/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleGeneratedPaneTests.cs
new file mode 100644
index 00000000..e1316448
--- /dev/null
+++ b/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleGeneratedPaneTests.cs
@@ -0,0 +1,377 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using CommunityToolkit.Tooling.SampleGen.Diagnostics;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace CommunityToolkit.Tooling.SampleGen.Tests;
+
+public partial class ToolkitSampleGeneratedPaneTests
+{
+    [TestMethod]
+    public void PaneOption_GeneratesWithoutDiagnostics()
+    {
+        var source = $@"
+            using System.ComponentModel;
+            using CommunityToolkit.Tooling.SampleGen;
+            using CommunityToolkit.Tooling.SampleGen.Attributes;
+
+            namespace MyApp
+            {{
+                [ToolkitSampleBoolOption(""Test"", false, Title = ""Toggle y"")]
+                [ToolkitSampleMultiChoiceOption(""TextFontFamily"", ""Segoe UI"", ""Arial"", ""Consolas"", Title = ""Font family"")]
+
+                [ToolkitSample(id: nameof(Sample), ""Test Sample"", description: """")]
+                public partial class Sample : Windows.UI.Xaml.Controls.UserControl
+                {{
+                    public Sample()
+                    {{
+                        var x = this.Test;
+                        var y = this.TextFontFamily;
+                    }}
+                }}
+            }}
+
+            namespace Windows.UI.Xaml.Controls
+            {{
+                public class UserControl {{ }}
+            }}";
+
+        ToolkitSampleMetadataTests.VerifyGeneratedDiagnostics<ToolkitSampleOptionGenerator>(source, string.Empty);
+    }
+
+    [TestMethod]
+    public void PaneOption_GeneratesTitleProperty()
+    {
+        var source = """
+            using System.ComponentModel;
+            using CommunityToolkit.Tooling.SampleGen;
+            using CommunityToolkit.Tooling.SampleGen.Attributes;
+
+            namespace MyApp
+            {
+                [ToolkitSampleNumericOption("TextSize", 12, 8, 48, 2, false, Title = "FontSize")]
+                [ToolkitSample(id: nameof(Sample), "Test Sample", description: "")]
+                public partial class Sample : Windows.UI.Xaml.Controls.UserControl
+                {
+                    public Sample()
+                    {
+                        var x = this.Test;
+                        var y = this.TextFontFamily;
+                    }
+                }
+            }
+
+            namespace Windows.UI.Xaml.Controls
+            {
+                public class UserControl { }
+            }
+        """;
+
+        var result = """
+            #nullable enable
+            namespace CommunityToolkit.Tooling.SampleGen;
+
+            public static class ToolkitSampleRegistry
+            {
+                public static System.Collections.Generic.Dictionary<string, CommunityToolkit.Tooling.SampleGen.Metadata.ToolkitSampleMetadata> Listing
+                { get; } = new() {
+                    ["Sample"] = new CommunityToolkit.Tooling.SampleGen.Metadata.ToolkitSampleMetadata("Sample", "Test Sample", "", typeof(MyApp.Sample), () => new MyApp.Sample(), null, null, new CommunityToolkit.Tooling.SampleGen.Metadata.IGeneratedToolkitSampleOptionViewModel[] { new CommunityToolkit.Tooling.SampleGen.Metadata.ToolkitSampleNumericOptionMetadataViewModel(name: "TextSize", initial: 12, min: 8, max: 48, step: 2, showAsNumberBox: false, title: "FontSize") })
+                };
+            }
+            """;
+
+        ToolkitSampleMetadataTests.VerifyGenerateSources("MyApp.Tests", source, new[] { new ToolkitSampleMetadataGenerator() }, ignoreDiagnostics: true, ("ToolkitSampleRegistry.g.cs", result));
+    }
+
+    // https://github.com/CommunityToolkit/Labs-Windows/issues/175
+    [TestMethod]
+    public void PaneOption_GeneratesProperty_DuplicatePropNamesAcrossSampleClasses()
+    {
+        var source = $@"
+            using System.ComponentModel;
+            using CommunityToolkit.Tooling.SampleGen;
+            using CommunityToolkit.Tooling.SampleGen.Attributes;
+
+            namespace MyApp
+            {{
+                [ToolkitSampleBoolOption(""Test"", false, Title = ""Toggle y"")]
+                [ToolkitSampleMultiChoiceOption(""TextFontFamily"", ""Segoe UI"", ""Arial"", ""Consolas"", Title = ""Font family"")]
+
+                [ToolkitSample(id: nameof(Sample), ""Test Sample"", description: """")]
+                public partial class Sample : Windows.UI.Xaml.Controls.UserControl
+                {{
+                    public Sample()
+                    {{
+                        var x = this.Test;
+                        var y = this.TextFontFamily;
+                    }}
+                }}
+
+                [ToolkitSampleBoolOption(""Test"", false, Title = ""Toggle y"")]
+                [ToolkitSampleMultiChoiceOption(""TextFontFamily"", ""Segoe UI"", ""Arial"", ""Consolas"", Title = ""Font family"")]
+
+                [ToolkitSample(id: nameof(Sample2), ""Test Sample"", description: """")]
+                public partial class Sample2 : Windows.UI.Xaml.Controls.UserControl
+                {{
+                    public Sample2()
+                    {{
+                        var x = this.Test;
+                        var y = this.TextFontFamily;
+                    }}
+                }}
+            }}
+
+            namespace Windows.UI.Xaml.Controls
+            {{
+                public class UserControl {{ }}
+            }}";
+
+        ToolkitSampleMetadataTests.VerifyGeneratedDiagnostics<ToolkitSampleOptionGenerator>(source, string.Empty);
+    }
+
+    [TestMethod]
+    public void PaneOptionOnNonSample()
+    {
+        string source = @"
+            using System.ComponentModel;
+            using CommunityToolkit.Tooling.SampleGen.Attributes;
+
+            namespace MyApp
+            {
+                [ToolkitSampleBoolOption(""BindToMe"", false, Title =  ""Toggle visibility"")]
+                public partial class Sample : Windows.UI.Xaml.Controls.UserControl
+                {
+                }
+            }
+
+            namespace Windows.UI.Xaml.Controls
+            {
+                public class UserControl { }
+            }";
+
+        ToolkitSampleMetadataTests.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(source, string.Empty, DiagnosticDescriptors.SamplePaneOptionAttributeOnNonSample.Id);
+    }
+
+    [DataRow("", DisplayName = "Empty string"), DataRow(" ", DisplayName = "Only whitespace"), DataRow("Test ", DisplayName = "Text with whitespace")]
+    [DataRow("_", DisplayName = "Underscore"), DataRow("$", DisplayName = "Dollar sign"), DataRow("%", DisplayName = "Percent symbol")]
+    [DataRow("class", DisplayName = "Reserved keyword 'class'"), DataRow("string", DisplayName = "Reserved keyword 'string'"), DataRow("sealed", DisplayName = "Reserved keyword 'sealed'"), DataRow("ref", DisplayName = "Reserved keyword 'ref'")]
+    [TestMethod]
+    public void PaneOptionWithBadName(string name)
+    {
+        var source = $@"
+            using System.ComponentModel;
+            using CommunityToolkit.Tooling.SampleGen;
+            using CommunityToolkit.Tooling.SampleGen.Attributes;
+
+            namespace MyApp
+            {{
+                [ToolkitSample(id: nameof(Sample), ""Test Sample"", description: """")]
+                [ToolkitSampleBoolOption(""{name}"", false, Title =  ""Toggle visibility"")]
+                public partial class Sample : Windows.UI.Xaml.Controls.UserControl
+                {{
+                }}
+            }}
+
+            namespace Windows.UI.Xaml.Controls
+            {{
+                public class UserControl {{ }}
+            }}";
+
+        ToolkitSampleMetadataTests.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(source, string.Empty, DiagnosticDescriptors.SamplePaneOptionWithBadName.Id, DiagnosticDescriptors.SampleNotReferencedInMarkdown.Id);
+    }
+
+
+    [TestMethod]
+    public void PaneOptionWithConflictingPropertyName()
+    {
+        var source = $@"
+            using System.ComponentModel;
+            using CommunityToolkit.Tooling.SampleGen;
+            using CommunityToolkit.Tooling.SampleGen.Attributes;
+
+            namespace MyApp
+            {{
+                [ToolkitSampleBoolOption(""IsVisible"", false, Title =  ""Toggle x"")]
+                [ToolkitSample(id: nameof(Sample), ""Test Sample"", description: """")]
+                public partial class Sample : Windows.UI.Xaml.Controls.UserControl
+                {{
+                    public string IsVisible {{ get; set; }}
+                }}
+            }}
+
+            namespace Windows.UI.Xaml.Controls
+            {{
+                public class UserControl {{ }}
+            }}";
+
+        ToolkitSampleMetadataTests.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(source, string.Empty, DiagnosticDescriptors.SamplePaneOptionWithConflictingName.Id, DiagnosticDescriptors.SampleNotReferencedInMarkdown.Id);
+    }
+
+    [TestMethod]
+    public void PaneOptionWithConflictingInheritedPropertyName()
+    {
+        var source = $@"
+            using System.ComponentModel;
+            using CommunityToolkit.Tooling.SampleGen;
+            using CommunityToolkit.Tooling.SampleGen.Attributes;
+
+            namespace MyApp
+            {{
+                [ToolkitSampleBoolOption(""IsVisible"", false, Title =  ""Toggle x"")]
+                [ToolkitSample(id: nameof(Sample), ""Test Sample"", description: """")]
+                public partial class Sample : Base
+                {{
+                }}
+
+                public class Base : Windows.UI.Xaml.Controls.UserControl
+                {{
+                    public string IsVisible {{ get; set; }}
+                }}
+            }}
+
+            namespace Windows.UI.Xaml.Controls
+            {{
+                public class UserControl {{ }}
+            }}";
+
+        ToolkitSampleMetadataTests.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(source, string.Empty, DiagnosticDescriptors.SamplePaneOptionWithConflictingName.Id, DiagnosticDescriptors.SampleNotReferencedInMarkdown.Id);
+    }
+
+    [TestMethod]
+    public void PaneOptionWithDuplicateName()
+    {
+        var source = $@"
+            using System.ComponentModel;
+            using CommunityToolkit.Tooling.SampleGen;
+            using CommunityToolkit.Tooling.SampleGen.Attributes;
+
+            namespace MyApp
+            {{
+                [ToolkitSampleBoolOption(""test"", false, Title =  ""Toggle x"")]
+                [ToolkitSampleBoolOption(""test"", false, Title =  ""Toggle y"")]
+                [ToolkitSampleMultiChoiceOption(""TextFontFamily"", ""Segoe UI"", ""Arial"", Title = ""Text foreground"")]
+
+                [ToolkitSample(id: nameof(Sample), ""Test Sample"", description: """")]
+                public partial class Sample : Windows.UI.Xaml.Controls.UserControl
+                {{
+                }}
+            }}
+
+            namespace Windows.UI.Xaml.Controls
+            {{
+                public class UserControl {{ }}
+            }}";
+
+        ToolkitSampleMetadataTests.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(source, string.Empty, DiagnosticDescriptors.SamplePaneOptionWithDuplicateName.Id, DiagnosticDescriptors.SampleNotReferencedInMarkdown.Id);
+    }
+
+    [TestMethod]
+    public void PaneOptionWithDuplicateName_AllowedBetweenSamples()
+    {
+        var source = $@"
+            using System.ComponentModel;
+            using CommunityToolkit.Tooling.SampleGen;
+            using CommunityToolkit.Tooling.SampleGen.Attributes;
+
+            namespace MyApp
+            {{
+                [ToolkitSampleBoolOption(""test"", false, Title =  ""Toggle y"")]
+
+                [ToolkitSample(id: nameof(Sample), ""Test Sample"", description: """")]
+                public partial class Sample : Windows.UI.Xaml.Controls.UserControl
+                {{
+                }}
+
+                [ToolkitSampleBoolOption(""test"", false, Title =  ""Toggle y"")]
+
+                [ToolkitSample(id: nameof(Sample2), ""Test Sample"", description: """")]
+                public partial class Sample2 : Windows.UI.Xaml.Controls.UserControl
+                {{
+                }}
+            }}
+
+            namespace Windows.UI.Xaml.Controls
+            {{
+                public class UserControl {{ }}
+            }}";
+
+        ToolkitSampleMetadataTests.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(source, string.Empty, DiagnosticDescriptors.SampleNotReferencedInMarkdown.Id);
+    }
+
+    [TestMethod]
+    public void SampleGeneratedOptionAttributeOnUnsupportedType()
+    {
+        var source = $@"
+            using System.ComponentModel;
+            using CommunityToolkit.Tooling.SampleGen;
+            using CommunityToolkit.Tooling.SampleGen.Attributes;
+
+            namespace MyApp
+            {{
+                [ToolkitSampleMultiChoiceOption(""TextFontFamily"", ""Segoe UI"", ""Arial"", ""Consolas"", Title = ""Font family"")]
+                [ToolkitSampleBoolOption(""Test"", false, Title =  ""Toggle visibility"")]
+                public partial class Sample
+                {{
+                }}
+            }}";
+
+        ToolkitSampleMetadataTests.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(source, string.Empty, DiagnosticDescriptors.SampleGeneratedOptionAttributeOnUnsupportedType.Id, DiagnosticDescriptors.SamplePaneOptionAttributeOnNonSample.Id);
+    }
+
+    [TestMethod]
+    public void PaneMultipleChoiceOptionWithNoChoices()
+    {
+        var source = $@"
+            using System.ComponentModel;
+            using CommunityToolkit.Tooling.SampleGen;
+            using CommunityToolkit.Tooling.SampleGen.Attributes;
+
+            namespace MyApp
+            {{
+                [ToolkitSampleMultiChoiceOption(""TextFontFamily"", Title = ""Font family"")]
+
+                [ToolkitSample(id: nameof(Sample), ""Test Sample"", description: """")]
+                public partial class Sample : Windows.UI.Xaml.Controls.UserControl
+                {{
+                }}
+            }}
+
+            namespace Windows.UI.Xaml.Controls
+            {{
+                public class UserControl {{ }}
+            }}";
+
+        ToolkitSampleMetadataTests.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(source, string.Empty, DiagnosticDescriptors.SamplePaneMultiChoiceOptionWithNoChoices.Id, DiagnosticDescriptors.SampleNotReferencedInMarkdown.Id);
+    }
+
+    [TestMethod]
+    public void GeneratedPaneOption_ButtonAction()
+    {
+        var source = $@"
+            using System.ComponentModel;
+            using CommunityToolkit.Tooling.SampleGen;
+            using CommunityToolkit.Tooling.SampleGen.Attributes;
+
+            namespace MyApp
+            {{
+                [ToolkitSample(id: nameof(Sample), ""Test Sample"", description: """")]
+                public partial class Sample : Windows.UI.Xaml.Controls.UserControl
+                {{
+                }}
+
+                [ToolkitSampleButtonAction(label: ""Raise notification"")]
+                private void RaiseNotification()
+                {{
+                }}
+            }}
+
+            namespace Windows.UI.Xaml.Controls
+            {{
+                public class UserControl {{ }}
+            }}";
+
+        ToolkitSampleMetadataTests.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(source, string.Empty, DiagnosticDescriptors.SampleNotReferencedInMarkdown.Id);
+    }
+}
diff --git a/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleMetadataTests.cs b/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleMetadataTests.cs
index ca4b3b1e..9ffee707 100644
--- a/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleMetadataTests.cs
+++ b/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleMetadataTests.cs
@@ -15,342 +15,6 @@ namespace CommunityToolkit.Tooling.SampleGen.Tests;
 [TestClass]
 public partial class ToolkitSampleMetadataTests
 {
-    [TestMethod]
-    public void PaneOption_GeneratesWithoutDiagnostics()
-    {
-        var source = $@"
-            using System.ComponentModel;
-            using CommunityToolkit.Tooling.SampleGen;
-            using CommunityToolkit.Tooling.SampleGen.Attributes;
-
-            namespace MyApp
-            {{
-                [ToolkitSampleBoolOption(""Test"", false, Title = ""Toggle y"")]
-                [ToolkitSampleMultiChoiceOption(""TextFontFamily"", ""Segoe UI"", ""Arial"", ""Consolas"", Title = ""Font family"")]
-
-                [ToolkitSample(id: nameof(Sample), ""Test Sample"", description: """")]
-                public partial class Sample : Windows.UI.Xaml.Controls.UserControl
-                {{
-                    public Sample()
-                    {{
-                        var x = this.Test;
-                        var y = this.TextFontFamily;
-                    }}
-                }}
-            }}
-
-            namespace Windows.UI.Xaml.Controls
-            {{
-                public class UserControl {{ }}
-            }}";
-
-        VerifyGeneratedDiagnostics<ToolkitSampleOptionGenerator>(source, string.Empty);
-    }
-
-    [TestMethod]
-    public void PaneOption_GeneratesTitleProperty()
-    {
-        var source = """
-            using System.ComponentModel;
-            using CommunityToolkit.Tooling.SampleGen;
-            using CommunityToolkit.Tooling.SampleGen.Attributes;
-
-            namespace MyApp
-            {
-                [ToolkitSampleNumericOption("TextSize", 12, 8, 48, 2, false, Title = "FontSize")]
-                [ToolkitSample(id: nameof(Sample), "Test Sample", description: "")]
-                public partial class Sample : Windows.UI.Xaml.Controls.UserControl
-                {
-                    public Sample()
-                    {
-                        var x = this.Test;
-                        var y = this.TextFontFamily;
-                    }
-                }
-            }
-
-            namespace Windows.UI.Xaml.Controls
-            {
-                public class UserControl { }
-            }
-        """;
-
-        var result = """
-            #nullable enable
-            namespace CommunityToolkit.Tooling.SampleGen;
-
-            public static class ToolkitSampleRegistry
-            {
-                public static System.Collections.Generic.Dictionary<string, CommunityToolkit.Tooling.SampleGen.Metadata.ToolkitSampleMetadata> Listing
-                { get; } = new() {
-                    ["Sample"] = new CommunityToolkit.Tooling.SampleGen.Metadata.ToolkitSampleMetadata("Sample", "Test Sample", "", typeof(MyApp.Sample), () => new MyApp.Sample(), null, null, new CommunityToolkit.Tooling.SampleGen.Metadata.IGeneratedToolkitSampleOptionViewModel[] { new CommunityToolkit.Tooling.SampleGen.Metadata.ToolkitSampleNumericOptionMetadataViewModel(name: "TextSize", initial: 12, min: 8, max: 48, step: 2, showAsNumberBox: false, title: "FontSize") })
-                };
-            }
-            """;
-
-        VerifyGenerateSources("MyApp.Tests", source, new[] { new ToolkitSampleMetadataGenerator() }, ignoreDiagnostics: true, ("ToolkitSampleRegistry.g.cs", result));
-    }
-
-    // https://github.com/CommunityToolkit/Labs-Windows/issues/175
-    [TestMethod]
-    public void PaneOption_GeneratesProperty_DuplicatePropNamesAcrossSampleClasses()
-    {
-        var source = $@"
-            using System.ComponentModel;
-            using CommunityToolkit.Tooling.SampleGen;
-            using CommunityToolkit.Tooling.SampleGen.Attributes;
-
-            namespace MyApp
-            {{
-                [ToolkitSampleBoolOption(""Test"", false, Title = ""Toggle y"")]
-                [ToolkitSampleMultiChoiceOption(""TextFontFamily"", ""Segoe UI"", ""Arial"", ""Consolas"", Title = ""Font family"")]
-
-                [ToolkitSample(id: nameof(Sample), ""Test Sample"", description: """")]
-                public partial class Sample : Windows.UI.Xaml.Controls.UserControl
-                {{
-                    public Sample()
-                    {{
-                        var x = this.Test;
-                        var y = this.TextFontFamily;
-                    }}
-                }}
-
-                [ToolkitSampleBoolOption(""Test"", false, Title = ""Toggle y"")]
-                [ToolkitSampleMultiChoiceOption(""TextFontFamily"", ""Segoe UI"", ""Arial"", ""Consolas"", Title = ""Font family"")]
-
-                [ToolkitSample(id: nameof(Sample2), ""Test Sample"", description: """")]
-                public partial class Sample2 : Windows.UI.Xaml.Controls.UserControl
-                {{
-                    public Sample2()
-                    {{
-                        var x = this.Test;
-                        var y = this.TextFontFamily;
-                    }}
-                }}
-            }}
-
-            namespace Windows.UI.Xaml.Controls
-            {{
-                public class UserControl {{ }}
-            }}";
-
-        VerifyGeneratedDiagnostics<ToolkitSampleOptionGenerator>(source, string.Empty);
-    }
-
-    [TestMethod]
-    public void PaneOptionOnNonSample()
-    {
-        string source = @"
-            using System.ComponentModel;
-            using CommunityToolkit.Tooling.SampleGen.Attributes;
-
-            namespace MyApp
-            {
-                [ToolkitSampleBoolOption(""BindToMe"", false, Title =  ""Toggle visibility"")]
-                public partial class Sample : Windows.UI.Xaml.Controls.UserControl
-                {
-                }
-            }
-
-            namespace Windows.UI.Xaml.Controls
-            {
-                public class UserControl { }
-            }";
-
-        VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(source, string.Empty, DiagnosticDescriptors.SamplePaneOptionAttributeOnNonSample.Id);
-    }
-
-    [DataRow("", DisplayName = "Empty string"), DataRow(" ", DisplayName = "Only whitespace"), DataRow("Test ", DisplayName = "Text with whitespace")]
-    [DataRow("_", DisplayName = "Underscore"), DataRow("$", DisplayName = "Dollar sign"), DataRow("%", DisplayName = "Percent symbol")]
-    [DataRow("class", DisplayName = "Reserved keyword 'class'"), DataRow("string", DisplayName = "Reserved keyword 'string'"), DataRow("sealed", DisplayName = "Reserved keyword 'sealed'"), DataRow("ref", DisplayName = "Reserved keyword 'ref'")]
-    [TestMethod]
-    public void PaneOptionWithBadName(string name)
-    {
-        var source = $@"
-            using System.ComponentModel;
-            using CommunityToolkit.Tooling.SampleGen;
-            using CommunityToolkit.Tooling.SampleGen.Attributes;
-
-            namespace MyApp
-            {{
-                [ToolkitSample(id: nameof(Sample), ""Test Sample"", description: """")]
-                [ToolkitSampleBoolOption(""{name}"", false, Title =  ""Toggle visibility"")]
-                public partial class Sample : Windows.UI.Xaml.Controls.UserControl
-                {{
-                }}
-            }}
-
-            namespace Windows.UI.Xaml.Controls
-            {{
-                public class UserControl {{ }}
-            }}";
-
-        VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(source, string.Empty, DiagnosticDescriptors.SamplePaneOptionWithBadName.Id, DiagnosticDescriptors.SampleNotReferencedInMarkdown.Id);
-    }
-
-    [TestMethod]
-    public void PaneOptionWithConflictingPropertyName()
-    {
-        var source = $@"
-            using System.ComponentModel;
-            using CommunityToolkit.Tooling.SampleGen;
-            using CommunityToolkit.Tooling.SampleGen.Attributes;
-
-            namespace MyApp
-            {{
-                [ToolkitSampleBoolOption(""IsVisible"", false, Title =  ""Toggle x"")]
-                [ToolkitSample(id: nameof(Sample), ""Test Sample"", description: """")]
-                public partial class Sample : Windows.UI.Xaml.Controls.UserControl
-                {{
-                    public string IsVisible {{ get; set; }}
-                }}
-            }}
-
-            namespace Windows.UI.Xaml.Controls
-            {{
-                public class UserControl {{ }}
-            }}";
-
-        VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(source, string.Empty, DiagnosticDescriptors.SamplePaneOptionWithConflictingName.Id, DiagnosticDescriptors.SampleNotReferencedInMarkdown.Id);
-    }
-
-    [TestMethod]
-    public void PaneOptionWithConflictingInheritedPropertyName()
-    {
-        var source = $@"
-            using System.ComponentModel;
-            using CommunityToolkit.Tooling.SampleGen;
-            using CommunityToolkit.Tooling.SampleGen.Attributes;
-
-            namespace MyApp
-            {{
-                [ToolkitSampleBoolOption(""IsVisible"", false, Title =  ""Toggle x"")]
-                [ToolkitSample(id: nameof(Sample), ""Test Sample"", description: """")]
-                public partial class Sample : Base
-                {{
-                }}
-
-                public class Base : Windows.UI.Xaml.Controls.UserControl
-                {{
-                    public string IsVisible {{ get; set; }}
-                }}
-            }}
-
-            namespace Windows.UI.Xaml.Controls
-            {{
-                public class UserControl {{ }}
-            }}";
-
-        VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(source, string.Empty, DiagnosticDescriptors.SamplePaneOptionWithConflictingName.Id, DiagnosticDescriptors.SampleNotReferencedInMarkdown.Id);
-    }
-
-    [TestMethod]
-    public void PaneOptionWithDuplicateName()
-    {
-        var source = $@"
-            using System.ComponentModel;
-            using CommunityToolkit.Tooling.SampleGen;
-            using CommunityToolkit.Tooling.SampleGen.Attributes;
-
-            namespace MyApp
-            {{
-                [ToolkitSampleBoolOption(""test"", false, Title =  ""Toggle x"")]
-                [ToolkitSampleBoolOption(""test"", false, Title =  ""Toggle y"")]
-                [ToolkitSampleMultiChoiceOption(""TextFontFamily"", ""Segoe UI"", ""Arial"", Title = ""Text foreground"")]
-
-                [ToolkitSample(id: nameof(Sample), ""Test Sample"", description: """")]
-                public partial class Sample : Windows.UI.Xaml.Controls.UserControl
-                {{
-                }}
-            }}
-
-            namespace Windows.UI.Xaml.Controls
-            {{
-                public class UserControl {{ }}
-            }}";
-
-        VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(source, string.Empty, DiagnosticDescriptors.SamplePaneOptionWithDuplicateName.Id, DiagnosticDescriptors.SampleNotReferencedInMarkdown.Id);
-    }
-
-    [TestMethod]
-    public void PaneOptionWithDuplicateName_AllowedBetweenSamples()
-    {
-        var source = $@"
-            using System.ComponentModel;
-            using CommunityToolkit.Tooling.SampleGen;
-            using CommunityToolkit.Tooling.SampleGen.Attributes;
-
-            namespace MyApp
-            {{
-                [ToolkitSampleBoolOption(""test"", false, Title =  ""Toggle y"")]
-
-                [ToolkitSample(id: nameof(Sample), ""Test Sample"", description: """")]
-                public partial class Sample : Windows.UI.Xaml.Controls.UserControl
-                {{
-                }}
-
-                [ToolkitSampleBoolOption(""test"", false, Title =  ""Toggle y"")]
-
-                [ToolkitSample(id: nameof(Sample2), ""Test Sample"", description: """")]
-                public partial class Sample2 : Windows.UI.Xaml.Controls.UserControl
-                {{
-                }}
-            }}
-
-            namespace Windows.UI.Xaml.Controls
-            {{
-                public class UserControl {{ }}
-            }}";
-
-        VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(source, string.Empty, DiagnosticDescriptors.SampleNotReferencedInMarkdown.Id);
-    }
-
-    [TestMethod]
-    public void PaneMultipleChoiceOptionWithNoChoices()
-    {
-        var source = $@"
-            using System.ComponentModel;
-            using CommunityToolkit.Tooling.SampleGen;
-            using CommunityToolkit.Tooling.SampleGen.Attributes;
-
-            namespace MyApp
-            {{
-                [ToolkitSampleMultiChoiceOption(""TextFontFamily"", Title = ""Font family"")]
-
-                [ToolkitSample(id: nameof(Sample), ""Test Sample"", description: """")]
-                public partial class Sample : Windows.UI.Xaml.Controls.UserControl
-                {{
-                }}
-            }}
-
-            namespace Windows.UI.Xaml.Controls
-            {{
-                public class UserControl {{ }}
-            }}";
-
-        VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(source, string.Empty, DiagnosticDescriptors.SamplePaneMultiChoiceOptionWithNoChoices.Id, DiagnosticDescriptors.SampleNotReferencedInMarkdown.Id);
-    }
-
-    [TestMethod]
-    public void SampleGeneratedOptionAttributeOnUnsupportedType()
-    {
-        var source = $@"
-            using System.ComponentModel;
-            using CommunityToolkit.Tooling.SampleGen;
-            using CommunityToolkit.Tooling.SampleGen.Attributes;
-
-            namespace MyApp
-            {{
-                [ToolkitSampleMultiChoiceOption(""TextFontFamily"", ""Segoe UI"", ""Arial"", ""Consolas"", Title = ""Font family"")]
-                [ToolkitSampleBoolOption(""Test"", false, Title =  ""Toggle visibility"")]
-                public partial class Sample
-                {{
-                }}
-            }}";
-
-        VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(source, string.Empty, DiagnosticDescriptors.SampleGeneratedOptionAttributeOnUnsupportedType.Id, DiagnosticDescriptors.SamplePaneOptionAttributeOnNonSample.Id);
-    }
-
     [TestMethod]
     public void SampleAttributeOnUnsupportedType()
     {
@@ -432,7 +96,7 @@ public class UserControl {{ }}
     /// <param name="source">The input source to process.</param>
     /// <param name="markdown">The input documentation info to process.</param>
     /// <param name="diagnosticsIds">The diagnostic ids to expect for the input source code.</param>
-    private static void VerifyGeneratedDiagnostics<TGenerator>(string source, string markdown, params string[] diagnosticsIds)
+    internal static void VerifyGeneratedDiagnostics<TGenerator>(string source, string markdown, params string[] diagnosticsIds)
         where TGenerator : class, IIncrementalGenerator, new()
     {
         VerifyGeneratedDiagnostics<TGenerator>(CSharpSyntaxTree.ParseText(source), markdown, diagnosticsIds);
@@ -445,7 +109,7 @@ private static void VerifyGeneratedDiagnostics<TGenerator>(string source, string
     /// <param name="syntaxTree">The input source tree to process.</param>
     /// <param name="markdown">The input documentation info to process.</param>
     /// <param name="diagnosticsIds">The diagnostic ids to expect for the input source code.</param>
-    private static void VerifyGeneratedDiagnostics<TGenerator>(SyntaxTree syntaxTree, string markdown, params string[] diagnosticsIds)
+    internal static void VerifyGeneratedDiagnostics<TGenerator>(SyntaxTree syntaxTree, string markdown, params string[] diagnosticsIds)
         where TGenerator : class, IIncrementalGenerator, new()
     {
         var sampleAttributeType = typeof(ToolkitSampleAttribute);
@@ -496,7 +160,7 @@ from assembly in AppDomain.CurrentDomain.GetAssemblies()
     /// <param name="source">The input source to process.</param>
     /// <param name="generators">The generators to apply to the input syntax tree.</param>
     /// <param name="results">The source files to compare.</param>
-    private static void VerifyGenerateSources(string assemblyName, string source, IIncrementalGenerator[] generators, bool ignoreDiagnostics = false, params (string Filename, string Text)[] results)
+    internal static void VerifyGenerateSources(string assemblyName, string source, IIncrementalGenerator[] generators, bool ignoreDiagnostics = false, params (string Filename, string Text)[] results)
     {
         // Ensure our types are loaded
         Type sampleattributeObjectType = typeof(ToolkitSampleAttribute);
diff --git a/CommunityToolkit.Tooling.SampleGen/GeneratorExtensions.cs b/CommunityToolkit.Tooling.SampleGen/GeneratorExtensions.cs
index 956f2d58..b0e4a028 100644
--- a/CommunityToolkit.Tooling.SampleGen/GeneratorExtensions.cs
+++ b/CommunityToolkit.Tooling.SampleGen/GeneratorExtensions.cs
@@ -12,21 +12,17 @@ public static class GeneratorExtensions
     /// Crawls a namespace and all child namespaces for all contained types.
     /// </summary>
     /// <returns>A flattened enumerable of <see cref="INamedTypeSymbol"/>s.</returns>
-    public static IEnumerable<ISymbol> CrawlForAllSymbols(this INamespaceSymbol namespaceSymbol, SymbolKind symbolKind)
+    public static IEnumerable<ISymbol> CrawlForAllSymbols(this INamespaceSymbol namespaceSymbol)
     {
         foreach (var member in namespaceSymbol.GetMembers())
         {
             if (member is INamespaceSymbol nestedNamespace)
             {
-                foreach (var item in CrawlForAllSymbols(nestedNamespace, symbolKind))
+                foreach (var item in CrawlForAllSymbols(nestedNamespace))
                     yield return item;
             }
 
-            foreach (Enum value in Enum.GetValues(typeof(SymbolKind)))
-            {
-                if (symbolKind.HasFlag(value) && member.Kind.HasFlag(value))
-                    yield return member;
-            }
+            yield return member;
         }
     }
 
diff --git a/CommunityToolkit.Tooling.SampleGen/ToolkitSampleMetadataGenerator.Sample.cs b/CommunityToolkit.Tooling.SampleGen/ToolkitSampleMetadataGenerator.Sample.cs
index 024e6888..50bc1e62 100644
--- a/CommunityToolkit.Tooling.SampleGen/ToolkitSampleMetadataGenerator.Sample.cs
+++ b/CommunityToolkit.Tooling.SampleGen/ToolkitSampleMetadataGenerator.Sample.cs
@@ -30,7 +30,7 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
 
         var symbolsInReferencedAssemblies = context.CompilationProvider
                               .SelectMany((x, _) => x.SourceModule.ReferencedAssemblySymbols)
-                              .SelectMany((asm, _) => asm.GlobalNamespace.CrawlForAllSymbols(SymbolKind.NamedType | SymbolKind.Method));
+                              .SelectMany((asm, _) => asm.GlobalNamespace.CrawlForAllSymbols().Where(x => x.Kind is SymbolKind.NamedType or SymbolKind.Method));
 
         var markdownFiles = context.AdditionalTextsProvider
             .Where(static file => file.Path.EndsWith(".md"))
@@ -83,15 +83,14 @@ void Execute(IncrementalValuesProvider<ISymbol> types, bool skipDiagnostics = fa
                         item = (x.Item1, buttonActionAttribute);
                     }
 
-                    // Add extra property data, like Title back to Attribute
-                    if (item.Attribute != null && x.Item2.TryGetNamedArgument(nameof(ToolkitSampleOptionBaseAttribute.Title), out string? title) && !string.IsNullOrWhiteSpace(title))
+                    // Add extra property data, like Title, back to Attribute
+                    if (item.Attribute is not null && x.Item2.TryGetNamedArgument(nameof(ToolkitSampleOptionBaseAttribute.Title), out string? title) && !string.IsNullOrWhiteSpace(title))
                     {
                         item.Attribute.Title = title;
                     }
 
                     return item;
                 })
-                .Where(static x => x != default)
                 .Collect();
 
             // Find and reconstruct sample attributes
@@ -121,7 +120,7 @@ void Execute(IncrementalValuesProvider<ISymbol> types, bool skipDiagnostics = fa
             {
                 var toolkitSampleAttributeData = data.Left.Left.Left.Right.Where(x => x != default).Distinct();
                 var optionsPaneAttribute = data.Left.Left.Left.Left.Where(x => x != default).Distinct();
-                var generatedOptionPropertyData = data.Left.Left.Right.Where(x => x != default);
+                var generatedOptionPropertyData = data.Left.Left.Right.Where(x => x.Attribute is not null && x.Symbol is not null);
                 var markdownFileData = data.Left.Right.Where(x => x != default).Distinct();
                 var currentAssembly = data.Right;
 
@@ -191,9 +190,9 @@ private static void ReportDiagnosticsForInvalidAttributeUsage(SourceProductionCo
                                                                   IEnumerable<(ToolkitSampleOptionsPaneAttribute?, ISymbol)> optionsPaneAttribute,
                                                                   IEnumerable<(ISymbol, ToolkitSampleOptionBaseAttribute)> generatedOptionPropertyData)
     {
-        var toolkitAttributesOnUnsupportedType = toolkitSampleAttributeData.Where(x => x.Symbol is not INamedTypeSymbol namedSym || !IsValidXamlControl(namedSym));
-        var optionsAttributeOnUnsupportedType = optionsPaneAttribute.Where(x => x.Item2 is not INamedTypeSymbol namedSym || !IsValidXamlControl(namedSym));
-        var generatedOptionAttributeOnUnsupportedType = generatedOptionPropertyData.Where(x => x.Item1 is not INamedTypeSymbol namedSym || !IsValidXamlControl(namedSym));
+        var toolkitAttributesOnUnsupportedType = toolkitSampleAttributeData.Where(x => x.Symbol is INamedTypeSymbol namedSym && !IsValidXamlControl(namedSym));
+        var optionsAttributeOnUnsupportedType = optionsPaneAttribute.Where(x => x.Item2 is INamedTypeSymbol namedSym && !IsValidXamlControl(namedSym));
+        var generatedOptionAttributeOnUnsupportedType = generatedOptionPropertyData.Where(x => x.Item1 is INamedTypeSymbol namedSym && !IsValidXamlControl(namedSym));
 
 
         foreach (var item in toolkitAttributesOnUnsupportedType)
@@ -237,7 +236,7 @@ private static void ReportDiagnosticsGeneratedOptionsPane(SourceProductionContex
         ReportGeneratedMultiChoiceOptionsPaneDiagnostics(ctx, generatedOptionPropertyData);
 
         // Check for generated options which don't have a valid sample attribute
-        var generatedOptionsWithMissingSampleAttribute = generatedOptionPropertyData.Where(x => !toolkitSampleAttributeData.Any(sample => ReferenceEquals(sample.Symbol, x.Item1)));
+        var generatedOptionsWithMissingSampleAttribute = generatedOptionPropertyData.Where(x => x.Item1 is INamedTypeSymbol && !toolkitSampleAttributeData.Any(sample => ReferenceEquals(sample.Symbol, x.Item1)));
 
         foreach (var item in generatedOptionsWithMissingSampleAttribute)
             ctx.ReportDiagnostic(Diagnostic.Create(DiagnosticDescriptors.SamplePaneOptionAttributeOnNonSample, item.Item1.Locations.FirstOrDefault()));
@@ -260,7 +259,7 @@ private static void ReportDiagnosticsGeneratedOptionsPane(SourceProductionContex
             ctx.ReportDiagnostic(Diagnostic.Create(DiagnosticDescriptors.SamplePaneOptionWithDuplicateName, item.SelectMany(x => x.Item1.Locations).FirstOrDefault(), item.Key));
 
         // Check for generated options that conflict with an existing property name
-        var generatedOptionsWithConflictingPropertyNames = generatedOptionPropertyData.Where(x => GetAllMembers((INamedTypeSymbol)x.Item1).Any(y => x.Item2.Name == y.Name));
+        var generatedOptionsWithConflictingPropertyNames = generatedOptionPropertyData.Where(x => x.Item1 is INamedTypeSymbol sym && GetAllMembers(sym).Any(y => x.Item2.Name == y.Name));
 
         foreach (var item in generatedOptionsWithConflictingPropertyNames)
             ctx.ReportDiagnostic(Diagnostic.Create(DiagnosticDescriptors.SamplePaneOptionWithConflictingName, item.Item1.Locations.FirstOrDefault(), item.Item2.Name));

From c42c1fdcfd01b43868b13725d821d61b0a885daa Mon Sep 17 00:00:00 2001
From: Arlo Godfrey <arlo.godfrey@outlook.com>
Date: Fri, 31 Mar 2023 21:25:50 -0500
Subject: [PATCH 03/12] Cleaning up and organizing SampleGen test tooling

---
 .../SampleGenTestHelpers.cs                   | 118 +++++++++++++++
 .../ToolkitSampleGeneratedPaneTests.cs        |  32 ++--
 .../ToolkitSampleMetadataTests.cs             | 139 +-----------------
 3 files changed, 137 insertions(+), 152 deletions(-)
 create mode 100644 CommunityToolkit.Tooling.SampleGen.Tests/SampleGenTestHelpers.cs

diff --git a/CommunityToolkit.Tooling.SampleGen.Tests/SampleGenTestHelpers.cs b/CommunityToolkit.Tooling.SampleGen.Tests/SampleGenTestHelpers.cs
new file mode 100644
index 00000000..820fb05c
--- /dev/null
+++ b/CommunityToolkit.Tooling.SampleGen.Tests/SampleGenTestHelpers.cs
@@ -0,0 +1,118 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.Text;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace CommunityToolkit.Tooling.SampleGen.Tests;
+
+public static class TestHelpers
+{
+    internal static void VerifyGeneratedDiagnostics<TGenerator>(string source, string markdown, params string[] diagnosticsIds)
+        where TGenerator : class, IIncrementalGenerator, new()
+    {
+        VerifyGeneratedDiagnostics<TGenerator>(CSharpSyntaxTree.ParseText(source), markdown, diagnosticsIds);
+    }
+
+    internal static void VerifyGeneratedDiagnostics<TGenerator>(SyntaxTree syntaxTree, string markdown, params string[] diagnosticsIds)
+        where TGenerator : class, IIncrementalGenerator, new()
+    {
+        var references = GetAllReferencedAssemblies();
+        var compilation = CreateCompilation("original.Samples", syntaxTree, references);
+        var generator = new TGenerator();
+        var driver = CreateGeneratorDriver(syntaxTree, generator);
+
+        if (!string.IsNullOrWhiteSpace(markdown))
+        {
+            var text = new InMemoryAdditionalText(@"C:\pathtorepo\components\experiment\samples\experiment.Samples\documentation.md", markdown);
+            driver = driver.AddAdditionalTexts(ImmutableArray.Create<AdditionalText>(text));
+        }
+
+        _ = driver.RunGeneratorsAndUpdateCompilation(compilation, out Compilation generatorCompilation, out ImmutableArray<Diagnostic> postGeneratorCompilationDiagnostics);
+
+        VerifyCompilationErrors(compilation);
+        VerifyCompilationErrors(generatorCompilation);
+        VerifyDiagnostics(diagnosticsIds, postGeneratorCompilationDiagnostics);
+    }
+
+    internal static void VerifyGenerateSources(string assemblyName, string source, IIncrementalGenerator[] generators, bool ignoreDiagnostics = false, params (string Filename, string Text)[] results)
+    {
+        var references = GetAllReferencedAssemblies();
+        var syntaxTree = CSharpSyntaxTree.ParseText(source, CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp10));
+        var compilation = CreateCompilation(assemblyName, syntaxTree, references);
+        var driver = CreateGeneratorDriver(syntaxTree, generators);
+
+        _ = driver.RunGeneratorsAndUpdateCompilation(compilation, out Compilation generatorCompilation, out ImmutableArray<Diagnostic> diagnostics);
+
+        if (!ignoreDiagnostics)
+        {
+            CollectionAssert.AreEquivalent(Array.Empty<Diagnostic>(), diagnostics);
+        }
+
+        VerifyCompilationErrors(compilation);
+        VerifyGeneratedSources(results, generatorCompilation);
+    }
+
+    internal static IEnumerable<MetadataReference> GetAllReferencedAssemblies()
+    {
+        return from assembly in AppDomain.CurrentDomain.GetAssemblies()
+               where !assembly.IsDynamic
+               let reference = MetadataReference.CreateFromFile(assembly.Location)
+               select reference;
+    }
+
+    internal class InMemoryAdditionalText : AdditionalText
+    {
+        private readonly SourceText _content;
+
+        public InMemoryAdditionalText(string path, string content)
+        {
+            Path = path;
+            _content = SourceText.From(content, Encoding.UTF8);
+        }
+
+        public override string Path { get; }
+
+        public override SourceText GetText(CancellationToken cancellationToken = default) => _content;
+    }
+
+    private static CSharpCompilation CreateCompilation(string assemblyName, SyntaxTree syntaxTree, IEnumerable<MetadataReference> references)
+    {
+        return CSharpCompilation.Create(
+            assemblyName,
+            new[] { syntaxTree },
+            references,
+            new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
+    }
+
+    private static GeneratorDriver CreateGeneratorDriver(SyntaxTree syntaxTree, IIncrementalGenerator generator)
+    {
+        return CSharpGeneratorDriver
+            .Create(generator).WithUpdatedParseOptions((CSharpParseOptions)syntaxTree.Options);
+    }
+
+    private static GeneratorDriver CreateGeneratorDriver(SyntaxTree syntaxTree, IIncrementalGenerator[] generators)
+    {
+        return CSharpGeneratorDriver.Create(generators).WithUpdatedParseOptions((CSharpParseOptions)syntaxTree.Options);
+    }
+
+    private static void VerifyDiagnostics(string[] diagnosticsIds, ImmutableArray<Diagnostic> diagnostics)
+    {
+        HashSet<string> resultingIds = diagnostics.Select(diagnostic => diagnostic.Id).ToHashSet();
+        Assert.IsTrue(resultingIds.SetEquals(diagnosticsIds), $"Expected one of [{string.Join(", ", diagnosticsIds)}] diagnostic Ids. Got [{string.Join(", ", resultingIds)}]");
+    }
+
+    private static void VerifyCompilationErrors(Compilation outputCompilation)
+    {
+        var generatedCompilationDiaghostics = outputCompilation.GetDiagnostics();
+        Assert.IsTrue(generatedCompilationDiaghostics.All(x => x.Severity != DiagnosticSeverity.Error), $"Expected no generated compilation errors. Got: \n{string.Join("\n", generatedCompilationDiaghostics.Where(x => x.Severity == DiagnosticSeverity.Error).Select(x => $"[{x.Id}: {x.GetMessage()}]"))}");
+    }
+
+    private static void VerifyGeneratedSources((string Filename, string Text)[] results, Compilation outputCompilation)
+    {
+        foreach ((string filename, string text) in results)
+        {
+            SyntaxTree generatedTree = outputCompilation.SyntaxTrees.Single(tree => Path.GetFileName(tree.FilePath) == filename);
+            Assert.AreEqual(text, generatedTree.ToString());
+        }
+    }
+}
diff --git a/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleGeneratedPaneTests.cs b/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleGeneratedPaneTests.cs
index e1316448..8d760571 100644
--- a/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleGeneratedPaneTests.cs
+++ b/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleGeneratedPaneTests.cs
@@ -7,6 +7,7 @@
 
 namespace CommunityToolkit.Tooling.SampleGen.Tests;
 
+[TestClass]
 public partial class ToolkitSampleGeneratedPaneTests
 {
     [TestMethod]
@@ -38,7 +39,7 @@ namespace Windows.UI.Xaml.Controls
                 public class UserControl {{ }}
             }}";
 
-        ToolkitSampleMetadataTests.VerifyGeneratedDiagnostics<ToolkitSampleOptionGenerator>(source, string.Empty);
+        TestHelpers.VerifyGeneratedDiagnostics<ToolkitSampleOptionGenerator>(source, string.Empty);
     }
 
     [TestMethod]
@@ -128,7 +129,7 @@ namespace Windows.UI.Xaml.Controls
                 public class UserControl {{ }}
             }}";
 
-        ToolkitSampleMetadataTests.VerifyGeneratedDiagnostics<ToolkitSampleOptionGenerator>(source, string.Empty);
+        TestHelpers.VerifyGeneratedDiagnostics<ToolkitSampleOptionGenerator>(source, string.Empty);
     }
 
     [TestMethod]
@@ -151,7 +152,7 @@ namespace Windows.UI.Xaml.Controls
                 public class UserControl { }
             }";
 
-        ToolkitSampleMetadataTests.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(source, string.Empty, DiagnosticDescriptors.SamplePaneOptionAttributeOnNonSample.Id);
+        TestHelpers.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(source, string.Empty, DiagnosticDescriptors.SamplePaneOptionAttributeOnNonSample.Id);
     }
 
     [DataRow("", DisplayName = "Empty string"), DataRow(" ", DisplayName = "Only whitespace"), DataRow("Test ", DisplayName = "Text with whitespace")]
@@ -179,7 +180,7 @@ namespace Windows.UI.Xaml.Controls
                 public class UserControl {{ }}
             }}";
 
-        ToolkitSampleMetadataTests.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(source, string.Empty, DiagnosticDescriptors.SamplePaneOptionWithBadName.Id, DiagnosticDescriptors.SampleNotReferencedInMarkdown.Id);
+        TestHelpers.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(source, string.Empty, DiagnosticDescriptors.SamplePaneOptionWithBadName.Id, DiagnosticDescriptors.SampleNotReferencedInMarkdown.Id);
     }
 
 
@@ -206,7 +207,7 @@ namespace Windows.UI.Xaml.Controls
                 public class UserControl {{ }}
             }}";
 
-        ToolkitSampleMetadataTests.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(source, string.Empty, DiagnosticDescriptors.SamplePaneOptionWithConflictingName.Id, DiagnosticDescriptors.SampleNotReferencedInMarkdown.Id);
+        TestHelpers.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(source, string.Empty, DiagnosticDescriptors.SamplePaneOptionWithConflictingName.Id, DiagnosticDescriptors.SampleNotReferencedInMarkdown.Id);
     }
 
     [TestMethod]
@@ -236,7 +237,7 @@ namespace Windows.UI.Xaml.Controls
                 public class UserControl {{ }}
             }}";
 
-        ToolkitSampleMetadataTests.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(source, string.Empty, DiagnosticDescriptors.SamplePaneOptionWithConflictingName.Id, DiagnosticDescriptors.SampleNotReferencedInMarkdown.Id);
+        TestHelpers.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(source, string.Empty, DiagnosticDescriptors.SamplePaneOptionWithConflictingName.Id, DiagnosticDescriptors.SampleNotReferencedInMarkdown.Id);
     }
 
     [TestMethod]
@@ -264,7 +265,7 @@ namespace Windows.UI.Xaml.Controls
                 public class UserControl {{ }}
             }}";
 
-        ToolkitSampleMetadataTests.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(source, string.Empty, DiagnosticDescriptors.SamplePaneOptionWithDuplicateName.Id, DiagnosticDescriptors.SampleNotReferencedInMarkdown.Id);
+        TestHelpers.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(source, string.Empty, DiagnosticDescriptors.SamplePaneOptionWithDuplicateName.Id, DiagnosticDescriptors.SampleNotReferencedInMarkdown.Id);
     }
 
     [TestMethod]
@@ -297,7 +298,7 @@ namespace Windows.UI.Xaml.Controls
                 public class UserControl {{ }}
             }}";
 
-        ToolkitSampleMetadataTests.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(source, string.Empty, DiagnosticDescriptors.SampleNotReferencedInMarkdown.Id);
+        TestHelpers.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(source, string.Empty, DiagnosticDescriptors.SampleNotReferencedInMarkdown.Id);
     }
 
     [TestMethod]
@@ -317,7 +318,7 @@ public partial class Sample
                 }}
             }}";
 
-        ToolkitSampleMetadataTests.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(source, string.Empty, DiagnosticDescriptors.SampleGeneratedOptionAttributeOnUnsupportedType.Id, DiagnosticDescriptors.SamplePaneOptionAttributeOnNonSample.Id);
+        TestHelpers.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(source, string.Empty, DiagnosticDescriptors.SampleGeneratedOptionAttributeOnUnsupportedType.Id, DiagnosticDescriptors.SamplePaneOptionAttributeOnNonSample.Id);
     }
 
     [TestMethod]
@@ -343,7 +344,7 @@ namespace Windows.UI.Xaml.Controls
                 public class UserControl {{ }}
             }}";
 
-        ToolkitSampleMetadataTests.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(source, string.Empty, DiagnosticDescriptors.SamplePaneMultiChoiceOptionWithNoChoices.Id, DiagnosticDescriptors.SampleNotReferencedInMarkdown.Id);
+        TestHelpers.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(source, string.Empty, DiagnosticDescriptors.SamplePaneMultiChoiceOptionWithNoChoices.Id, DiagnosticDescriptors.SampleNotReferencedInMarkdown.Id);
     }
 
     [TestMethod]
@@ -359,11 +360,10 @@ namespace MyApp
                 [ToolkitSample(id: nameof(Sample), ""Test Sample"", description: """")]
                 public partial class Sample : Windows.UI.Xaml.Controls.UserControl
                 {{
-                }}
-
-                [ToolkitSampleButtonAction(label: ""Raise notification"")]
-                private void RaiseNotification()
-                {{
+                    [ToolkitSampleButtonAction(label: ""Raise notification"")]
+                    private void RaiseNotification()
+                    {{
+                    }}
                 }}
             }}
 
@@ -372,6 +372,6 @@ namespace Windows.UI.Xaml.Controls
                 public class UserControl {{ }}
             }}";
 
-        ToolkitSampleMetadataTests.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(source, string.Empty, DiagnosticDescriptors.SampleNotReferencedInMarkdown.Id);
+        TestHelpers.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(source, string.Empty, DiagnosticDescriptors.SampleNotReferencedInMarkdown.Id);
     }
 }
diff --git a/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleMetadataTests.cs b/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleMetadataTests.cs
index 9ffee707..6682767c 100644
--- a/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleMetadataTests.cs
+++ b/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleMetadataTests.cs
@@ -2,11 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using CommunityToolkit.Tooling.SampleGen.Attributes;
 using CommunityToolkit.Tooling.SampleGen.Diagnostics;
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp;
-using Microsoft.CodeAnalysis.Text;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using System.ComponentModel.DataAnnotations;
 
@@ -31,7 +27,7 @@ public partial class Sample
                 }}
             }}";
 
-        VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(source, string.Empty, DiagnosticDescriptors.SampleAttributeOnUnsupportedType.Id, DiagnosticDescriptors.SampleNotReferencedInMarkdown.Id);
+        TestHelpers.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(source, string.Empty, DiagnosticDescriptors.SampleAttributeOnUnsupportedType.Id, DiagnosticDescriptors.SampleNotReferencedInMarkdown.Id);
     }
 
     [TestMethod]
@@ -60,7 +56,7 @@ namespace Windows.UI.Xaml.Controls
                 public class UserControl {{ }}
             }}";
 
-        VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(source, string.Empty, DiagnosticDescriptors.SampleOptionPaneAttributeOnUnsupportedType.Id, DiagnosticDescriptors.SampleNotReferencedInMarkdown.Id);
+        TestHelpers.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(source, string.Empty, DiagnosticDescriptors.SampleOptionPaneAttributeOnUnsupportedType.Id, DiagnosticDescriptors.SampleNotReferencedInMarkdown.Id);
     }
 
     [TestMethod]
@@ -86,135 +82,6 @@ public class UserControl {{ }}
             }}";
 
         // TODO: We should have this return the references to the registries or something so we can check the generated output?
-        VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(source, string.Empty, DiagnosticDescriptors.SampleNotReferencedInMarkdown.Id);
-    }
-
-    /// <summary>
-    /// Verifies the output of a source generator.
-    /// </summary>
-    /// <typeparam name="TGenerator">The generator type to use.</typeparam>
-    /// <param name="source">The input source to process.</param>
-    /// <param name="markdown">The input documentation info to process.</param>
-    /// <param name="diagnosticsIds">The diagnostic ids to expect for the input source code.</param>
-    internal static void VerifyGeneratedDiagnostics<TGenerator>(string source, string markdown, params string[] diagnosticsIds)
-        where TGenerator : class, IIncrementalGenerator, new()
-    {
-        VerifyGeneratedDiagnostics<TGenerator>(CSharpSyntaxTree.ParseText(source), markdown, diagnosticsIds);
-    }
-
-    /// <summary>
-    /// Verifies the output of a source generator.
-    /// </summary>
-    /// <typeparam name="TGenerator">The generator type to use.</typeparam>
-    /// <param name="syntaxTree">The input source tree to process.</param>
-    /// <param name="markdown">The input documentation info to process.</param>
-    /// <param name="diagnosticsIds">The diagnostic ids to expect for the input source code.</param>
-    internal static void VerifyGeneratedDiagnostics<TGenerator>(SyntaxTree syntaxTree, string markdown, params string[] diagnosticsIds)
-        where TGenerator : class, IIncrementalGenerator, new()
-    {
-        var sampleAttributeType = typeof(ToolkitSampleAttribute);
-
-        var references =
-            from assembly in AppDomain.CurrentDomain.GetAssemblies()
-            where !assembly.IsDynamic
-            let reference = MetadataReference.CreateFromFile(assembly.Location)
-            select reference;
-
-        var compilation = CSharpCompilation.Create(
-            "original.Samples",
-            new[] { syntaxTree },
-            references,
-            new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
-
-        var compilationDiagnostics = compilation.GetDiagnostics();
-
-        IIncrementalGenerator generator = new TGenerator();
-
-        GeneratorDriver driver =
-            CSharpGeneratorDriver
-                .Create(generator)
-                .WithUpdatedParseOptions((CSharpParseOptions)syntaxTree.Options);
-
-        if (!string.IsNullOrWhiteSpace(markdown))
-        {
-            var text = new InMemoryAdditionalText(@"C:\pathtorepo\components\experiment\samples\experiment.Samples\documentation.md", markdown);
-
-            driver = driver.AddAdditionalTexts(ImmutableArray.Create<AdditionalText>(text));
-        }
-
-        _ = driver.RunGeneratorsAndUpdateCompilation(compilation, out Compilation outputCompilation, out ImmutableArray<Diagnostic> diagnostics);
-
-        HashSet<string> resultingIds = diagnostics.Select(diagnostic => diagnostic.Id).ToHashSet();
-        var generatedCompilationDiaghostics = outputCompilation.GetDiagnostics();
-
-        Assert.IsTrue(resultingIds.SetEquals(diagnosticsIds), $"Expected one of [{string.Join(", ", diagnosticsIds)}] diagnostic Ids. Got [{string.Join(", ", resultingIds)}]");
-        Assert.IsTrue(generatedCompilationDiaghostics.All(x => x.Severity != DiagnosticSeverity.Error), $"Expected no generated compilation errors. Got: \n{string.Join("\n", generatedCompilationDiaghostics.Where(x => x.Severity == DiagnosticSeverity.Error).Select(x => $"[{x.Id}: {x.GetMessage()}]"))}");
-
-        GC.KeepAlive(sampleAttributeType);
-    }
-
-    //// See: https://github.com/CommunityToolkit/dotnet/blob/c2053562d1a4d4829fc04b1cb86d1564c2c4a03c/tests/CommunityToolkit.Mvvm.SourceGenerators.UnitTests/Test_SourceGeneratorsCodegen.cs#L103
-    /// <summary>
-    /// Generates the requested sources
-    /// </summary>
-    /// <param name="source">The input source to process.</param>
-    /// <param name="generators">The generators to apply to the input syntax tree.</param>
-    /// <param name="results">The source files to compare.</param>
-    internal static void VerifyGenerateSources(string assemblyName, string source, IIncrementalGenerator[] generators, bool ignoreDiagnostics = false, params (string Filename, string Text)[] results)
-    {
-        // Ensure our types are loaded
-        Type sampleattributeObjectType = typeof(ToolkitSampleAttribute);
-
-        // Get all assembly references for the loaded assemblies (easy way to pull in all necessary dependencies)
-        IEnumerable<MetadataReference> references =
-            from assembly in AppDomain.CurrentDomain.GetAssemblies()
-            where !assembly.IsDynamic
-            let reference = MetadataReference.CreateFromFile(assembly.Location)
-            select reference;
-
-        SyntaxTree syntaxTree = CSharpSyntaxTree.ParseText(source, CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp10));
-
-        // Create a syntax tree with the input source
-        CSharpCompilation compilation = CSharpCompilation.Create(
-            assemblyName,
-            new SyntaxTree[] { syntaxTree },
-            references,
-            new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
-
-        GeneratorDriver driver = CSharpGeneratorDriver.Create(generators).WithUpdatedParseOptions((CSharpParseOptions)syntaxTree.Options);
-
-        // Run all source generators on the input source code
-        _ = driver.RunGeneratorsAndUpdateCompilation(compilation, out Compilation outputCompilation, out ImmutableArray<Diagnostic> diagnostics);
-
-        // Ensure that no diagnostics were generated
-        if (!ignoreDiagnostics)
-        {
-            CollectionAssert.AreEquivalent(Array.Empty<Diagnostic>(), diagnostics);
-        }
-
-        foreach ((string filename, string text) in results)
-        {
-            SyntaxTree generatedTree = outputCompilation.SyntaxTrees.Single(tree => Path.GetFileName(tree.FilePath) == filename);
-
-            Assert.AreEqual(text, generatedTree.ToString());
-        }
-
-        GC.KeepAlive(sampleattributeObjectType);
-    }
-
-    // From: https://github.com/dotnet/roslyn/blob/main/src/Compilers/Test/Core/SourceGeneration/TestGenerators.cs
-    internal class InMemoryAdditionalText : AdditionalText
-    {
-        private readonly SourceText _content;
-
-        public InMemoryAdditionalText(string path, string content)
-        {
-            Path = path;
-            _content = SourceText.From(content, Encoding.UTF8);
-        }
-
-        public override string Path { get; }
-
-        public override SourceText GetText(CancellationToken cancellationToken = default) => _content;
+        TestHelpers.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(source, string.Empty, DiagnosticDescriptors.SampleNotReferencedInMarkdown.Id);
     }
 }

From 7cb2ce79ee6e93facdc88dfc8e294aa3855dfbfc Mon Sep 17 00:00:00 2001
From: Arlo Godfrey <arlo.godfrey@outlook.com>
Date: Tue, 4 Apr 2023 14:33:55 -0500
Subject: [PATCH 04/12] Complete refactor of SampleGen tests

---
 .../SampleGenTestHelpers.cs                        |  3 +--
 .../ToolkitSampleGeneratedPaneTests.cs             |  4 +---
 .../ToolkitSampleMetadataTests.Documentation.cs    | 14 +++++++-------
 3 files changed, 9 insertions(+), 12 deletions(-)

diff --git a/CommunityToolkit.Tooling.SampleGen.Tests/SampleGenTestHelpers.cs b/CommunityToolkit.Tooling.SampleGen.Tests/SampleGenTestHelpers.cs
index 820fb05c..be58adc9 100644
--- a/CommunityToolkit.Tooling.SampleGen.Tests/SampleGenTestHelpers.cs
+++ b/CommunityToolkit.Tooling.SampleGen.Tests/SampleGenTestHelpers.cs
@@ -29,7 +29,6 @@ internal static void VerifyGeneratedDiagnostics<TGenerator>(SyntaxTree syntaxTre
 
         _ = driver.RunGeneratorsAndUpdateCompilation(compilation, out Compilation generatorCompilation, out ImmutableArray<Diagnostic> postGeneratorCompilationDiagnostics);
 
-        VerifyCompilationErrors(compilation);
         VerifyCompilationErrors(generatorCompilation);
         VerifyDiagnostics(diagnosticsIds, postGeneratorCompilationDiagnostics);
     }
@@ -48,7 +47,7 @@ internal static void VerifyGenerateSources(string assemblyName, string source, I
             CollectionAssert.AreEquivalent(Array.Empty<Diagnostic>(), diagnostics);
         }
 
-        VerifyCompilationErrors(compilation);
+        VerifyCompilationErrors(generatorCompilation);
         VerifyGeneratedSources(results, generatorCompilation);
     }
 
diff --git a/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleGeneratedPaneTests.cs b/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleGeneratedPaneTests.cs
index 8d760571..d479a772 100644
--- a/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleGeneratedPaneTests.cs
+++ b/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleGeneratedPaneTests.cs
@@ -58,8 +58,6 @@ public partial class Sample : Windows.UI.Xaml.Controls.UserControl
                 {
                     public Sample()
                     {
-                        var x = this.Test;
-                        var y = this.TextFontFamily;
                     }
                 }
             }
@@ -83,7 +81,7 @@ public static class ToolkitSampleRegistry
             }
             """;
 
-        ToolkitSampleMetadataTests.VerifyGenerateSources("MyApp.Tests", source, new[] { new ToolkitSampleMetadataGenerator() }, ignoreDiagnostics: true, ("ToolkitSampleRegistry.g.cs", result));
+        TestHelpers.VerifyGenerateSources("MyApp.Tests", source, new[] { new ToolkitSampleMetadataGenerator() }, ignoreDiagnostics: true, ("ToolkitSampleRegistry.g.cs", result));
     }
 
     // https://github.com/CommunityToolkit/Labs-Windows/issues/175
diff --git a/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleMetadataTests.Documentation.cs b/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleMetadataTests.Documentation.cs
index 1b2b156e..5cc24a29 100644
--- a/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleMetadataTests.Documentation.cs
+++ b/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleMetadataTests.Documentation.cs
@@ -40,7 +40,7 @@ public void MissingFrontMatterSection()
             Without any front matter.
             ";
 
-        VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(SimpleSource, markdown, DiagnosticDescriptors.MarkdownYAMLFrontMatterException.Id, DiagnosticDescriptors.SampleNotReferencedInMarkdown.Id);
+        TestHelpers.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(SimpleSource, markdown, DiagnosticDescriptors.MarkdownYAMLFrontMatterException.Id, DiagnosticDescriptors.SampleNotReferencedInMarkdown.Id);
     }
 
     [DataRow(1, DisplayName = "Title")]
@@ -74,7 +74,7 @@ public void MissingFrontMatterField(int removeline)
         lines.RemoveAt(removeline);
         markdown = String.Join('\n', lines);
 
-        VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(SimpleSource, markdown, DiagnosticDescriptors.MarkdownYAMLFrontMatterMissingField.Id, DiagnosticDescriptors.SampleNotReferencedInMarkdown.Id); // We won't see the sample reference as we bail out when the front matter fails to be complete...
+        TestHelpers.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(SimpleSource, markdown, DiagnosticDescriptors.MarkdownYAMLFrontMatterMissingField.Id, DiagnosticDescriptors.SampleNotReferencedInMarkdown.Id); // We won't see the sample reference as we bail out when the front matter fails to be complete...
     }
 
     [TestMethod]
@@ -97,7 +97,7 @@ public void MarkdownInvalidSampleReference()
 Without any front matter.
 ";
 
-        VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(SimpleSource, markdown,
+        TestHelpers.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(SimpleSource, markdown,
             DiagnosticDescriptors.MarkdownSampleIdNotFound.Id,
             DiagnosticDescriptors.SampleNotReferencedInMarkdown.Id);
     }
@@ -120,7 +120,7 @@ public void DocumentationMissingSample()
 # This is some test documentation...
 Without any sample.";
 
-        VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(SimpleSource, markdown,
+        TestHelpers.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(SimpleSource, markdown,
             DiagnosticDescriptors.DocumentationHasNoSamples.Id,
             DiagnosticDescriptors.SampleNotReferencedInMarkdown.Id);
     }
@@ -144,7 +144,7 @@ public void DocumentationValid()
 Which is valid.
 > [!SAMPLE Sample]";
 
-        VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(SimpleSource, markdown);
+        TestHelpers.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(SimpleSource, markdown);
     }
 
     [TestMethod]
@@ -165,7 +165,7 @@ public void DocumentationInvalidDiscussionId()
 # This is some test documentation...
 Without an invalid discussion id.";
 
-        VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(string.Empty, markdown,
+        TestHelpers.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(string.Empty, markdown,
             DiagnosticDescriptors.MarkdownYAMLFrontMatterException.Id,
             DiagnosticDescriptors.DocumentationHasNoSamples.Id);
     }
@@ -188,7 +188,7 @@ public void DocumentationInvalidIssueId()
 # This is some test documentation...
 Without an invalid discussion id.";
 
-        VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(string.Empty, markdown,
+        TestHelpers.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(string.Empty, markdown,
             DiagnosticDescriptors.MarkdownYAMLFrontMatterException.Id,
             DiagnosticDescriptors.DocumentationHasNoSamples.Id);
     }

From 0e7616d27e2750f3fc28f84e30b66d4bb061e302 Mon Sep 17 00:00:00 2001
From: Arlo Godfrey <arlo.godfrey@outlook.com>
Date: Wed, 5 Apr 2023 13:45:32 -0500
Subject: [PATCH 05/12] Refactored test tooling for additional flexibility

---
 .../Helpers/InMemoryAdditionalText.cs         |  19 +++
 .../Helpers/SourceGeneratorRunResult.cs       |   9 ++
 .../Helpers/TestHelpers.Compilation.cs        |  59 +++++++++
 .../Helpers/TestHelpers.cs                    |  59 +++++++++
 .../SampleGenTestHelpers.cs                   | 117 ------------------
 .../ToolkitSampleGeneratedPaneTests.cs        |  85 +++++++++----
 ...oolkitSampleMetadataTests.Documentation.cs |  46 ++++---
 .../ToolkitSampleMetadataTests.cs             |  20 ++-
 8 files changed, 251 insertions(+), 163 deletions(-)
 create mode 100644 CommunityToolkit.Tooling.SampleGen.Tests/Helpers/InMemoryAdditionalText.cs
 create mode 100644 CommunityToolkit.Tooling.SampleGen.Tests/Helpers/SourceGeneratorRunResult.cs
 create mode 100644 CommunityToolkit.Tooling.SampleGen.Tests/Helpers/TestHelpers.Compilation.cs
 create mode 100644 CommunityToolkit.Tooling.SampleGen.Tests/Helpers/TestHelpers.cs
 delete mode 100644 CommunityToolkit.Tooling.SampleGen.Tests/SampleGenTestHelpers.cs

diff --git a/CommunityToolkit.Tooling.SampleGen.Tests/Helpers/InMemoryAdditionalText.cs b/CommunityToolkit.Tooling.SampleGen.Tests/Helpers/InMemoryAdditionalText.cs
new file mode 100644
index 00000000..45888822
--- /dev/null
+++ b/CommunityToolkit.Tooling.SampleGen.Tests/Helpers/InMemoryAdditionalText.cs
@@ -0,0 +1,19 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Text;
+
+namespace CommunityToolkit.Tooling.SampleGen.Tests.Helpers;
+
+internal class InMemoryAdditionalText : AdditionalText
+{
+    private readonly SourceText _content;
+
+    public InMemoryAdditionalText(string path, string content)
+    {
+        Path = path;
+        _content = SourceText.From(content, Encoding.UTF8);
+    }
+
+    public override string Path { get; }
+
+    public override SourceText GetText(CancellationToken cancellationToken = default) => _content;
+}
diff --git a/CommunityToolkit.Tooling.SampleGen.Tests/Helpers/SourceGeneratorRunResult.cs b/CommunityToolkit.Tooling.SampleGen.Tests/Helpers/SourceGeneratorRunResult.cs
new file mode 100644
index 00000000..ff38f74b
--- /dev/null
+++ b/CommunityToolkit.Tooling.SampleGen.Tests/Helpers/SourceGeneratorRunResult.cs
@@ -0,0 +1,9 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.CodeAnalysis;
+
+namespace CommunityToolkit.Tooling.SampleGen.Tests.Helpers;
+
+public record SourceGeneratorRunResult(Compilation Compilation, ImmutableArray<Diagnostic> Diagnostics);
diff --git a/CommunityToolkit.Tooling.SampleGen.Tests/Helpers/TestHelpers.Compilation.cs b/CommunityToolkit.Tooling.SampleGen.Tests/Helpers/TestHelpers.Compilation.cs
new file mode 100644
index 00000000..d087378a
--- /dev/null
+++ b/CommunityToolkit.Tooling.SampleGen.Tests/Helpers/TestHelpers.Compilation.cs
@@ -0,0 +1,59 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+
+namespace CommunityToolkit.Tooling.SampleGen.Tests.Helpers;
+
+public static partial class TestHelpers
+{
+    internal static IEnumerable<MetadataReference> GetAllReferencedAssemblies()
+    {
+        return from assembly in AppDomain.CurrentDomain.GetAssemblies()
+               where !assembly.IsDynamic
+               let reference = MetadataReference.CreateFromFile(assembly.Location)
+               select reference;
+    }
+
+    internal static SyntaxTree ToSyntaxTree(this string source)
+    {
+        return CSharpSyntaxTree.ParseText(source,
+            CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp10));
+    }
+
+    internal static CSharpCompilation CreateCompilation(this SyntaxTree syntaxTree, string assemblyName, IEnumerable<MetadataReference>? references = null)
+    {
+        return CSharpCompilation.Create(assemblyName, new[] { syntaxTree }, references ?? GetAllReferencedAssemblies(), new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
+    }
+
+    internal static CSharpCompilation CreateCompilation(this IEnumerable<SyntaxTree> syntaxTree, string assemblyName, IEnumerable<MetadataReference>? references = null)
+    {
+        return CSharpCompilation.Create(assemblyName, syntaxTree, references ?? GetAllReferencedAssemblies(), new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
+    }
+
+    internal static GeneratorDriver CreateSourceGeneratorDriver(this SyntaxTree syntaxTree, IIncrementalGenerator generator)
+    {
+        return CSharpGeneratorDriver.Create(generator).WithUpdatedParseOptions((CSharpParseOptions)syntaxTree.Options);
+    }
+
+    internal static GeneratorDriver CreateSourceGeneratorDriver(this SyntaxTree syntaxTree, params IIncrementalGenerator[] generators)
+    {
+        return CSharpGeneratorDriver.Create(generators).WithUpdatedParseOptions((CSharpParseOptions)syntaxTree.Options);
+    }
+
+    internal static GeneratorDriver WithMarkdown(this GeneratorDriver driver, params string[] markdownFilesToCreate)
+    {
+        foreach (var markdown in markdownFilesToCreate)
+        {
+            if (!string.IsNullOrWhiteSpace(markdown))
+            {
+                var text = new InMemoryAdditionalText(@"C:\pathtorepo\components\experiment\samples\experiment.Samples\documentation.md", markdown);
+                driver = driver.AddAdditionalTexts(ImmutableArray.Create<AdditionalText>(text));
+            }
+        }
+
+        return driver;
+    }
+}
diff --git a/CommunityToolkit.Tooling.SampleGen.Tests/Helpers/TestHelpers.cs b/CommunityToolkit.Tooling.SampleGen.Tests/Helpers/TestHelpers.cs
new file mode 100644
index 00000000..b048dc03
--- /dev/null
+++ b/CommunityToolkit.Tooling.SampleGen.Tests/Helpers/TestHelpers.cs
@@ -0,0 +1,59 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace CommunityToolkit.Tooling.SampleGen.Tests.Helpers;
+
+public static partial class TestHelpers
+{
+    internal static SourceGeneratorRunResult RunSourceGenerator<TGenerator>(this string source, string assemblyName, string markdown = "") where TGenerator : class, IIncrementalGenerator, new() => RunSourceGenerator<TGenerator>(source.ToSyntaxTree(), assemblyName, markdown);
+
+    internal static SourceGeneratorRunResult RunSourceGenerator<TGenerator>(this SyntaxTree syntaxTree, string assemblyName, string markdown = "")
+        where TGenerator : class, IIncrementalGenerator, new()
+    {
+        var references = GetAllReferencedAssemblies();
+        var compilation = syntaxTree.CreateCompilation(assemblyName, references); // assembly name should always be supplied in param
+        return RunSourceGenerator<TGenerator>(syntaxTree, compilation, markdown);
+    }
+
+    internal static SourceGeneratorRunResult RunSourceGenerator<TGenerator>(this SyntaxTree syntaxTree, Compilation compilation, string markdown = "")
+        where TGenerator : class, IIncrementalGenerator, new()
+    {
+        // Create a driver for the source generator
+        var driver = syntaxTree
+            .CreateSourceGeneratorDriver(new TGenerator())
+            .WithMarkdown(markdown);
+
+        // Update the original compilation using the source generator
+        _ = driver.RunGeneratorsAndUpdateCompilation(compilation, out Compilation generatorCompilation, out ImmutableArray<Diagnostic> postGeneratorCompilationDiagnostics);
+
+        return new(generatorCompilation, postGeneratorCompilationDiagnostics);
+    }
+
+    internal static void AssertDiagnosticsAre(this IEnumerable<Diagnostic> diagnostics, params DiagnosticDescriptor[] expectedDiagnosticDescriptors)
+    {
+        var expectedIds = expectedDiagnosticDescriptors.Select(x => x.Id).ToHashSet();
+        var resultingIds = diagnostics.Select(diagnostic => diagnostic.Id).ToHashSet();
+
+        Assert.IsTrue(resultingIds.SetEquals(expectedIds), $"Expected [{string.Join(", ", expectedIds)}] diagnostic Ids. Got [{string.Join(", ", resultingIds)}]");
+    }
+
+    internal static void AssertNoCompilationErrors(this Compilation outputCompilation)
+    {
+        var generatedCompilationDiagnostics = outputCompilation.GetDiagnostics();
+        Assert.IsTrue(generatedCompilationDiagnostics.All(x => x.Severity != DiagnosticSeverity.Error), $"Expected no generated compilation errors. Got: \n{string.Join("\n", generatedCompilationDiagnostics.Where(x => x.Severity == DiagnosticSeverity.Error).Select(x => $"[{x.Id}: {x.GetMessage()}]"))}");
+    }
+
+    internal static void AssertSourceGenerated(this Compilation compilation, string filename, string expectedContents)
+    {
+        var generatedTree = compilation.SyntaxTrees.SingleOrDefault(tree => Path.GetFileName(tree.FilePath) == filename);
+
+        Assert.IsNotNull(generatedTree, $"No file named {filename} was generated");
+        Assert.AreEqual(expectedContents, generatedTree.ToString(), "Unexpected code generated");
+    }
+
+    internal static void AssertDiagnosticsAre(this SourceGeneratorRunResult result, params DiagnosticDescriptor[] expectedDiagnosticDescriptors) => AssertDiagnosticsAre(result.Diagnostics, expectedDiagnosticDescriptors);
+
+    internal static void AssertNoCompilationErrors(this SourceGeneratorRunResult result) => AssertNoCompilationErrors(result.Compilation);
+
+    internal static void AssertSourceGenerated(this SourceGeneratorRunResult result, string filename, string expectedContents) => AssertSourceGenerated(result.Compilation, filename, expectedContents);
+}
diff --git a/CommunityToolkit.Tooling.SampleGen.Tests/SampleGenTestHelpers.cs b/CommunityToolkit.Tooling.SampleGen.Tests/SampleGenTestHelpers.cs
deleted file mode 100644
index be58adc9..00000000
--- a/CommunityToolkit.Tooling.SampleGen.Tests/SampleGenTestHelpers.cs
+++ /dev/null
@@ -1,117 +0,0 @@
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp;
-using Microsoft.CodeAnalysis.Text;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-
-namespace CommunityToolkit.Tooling.SampleGen.Tests;
-
-public static class TestHelpers
-{
-    internal static void VerifyGeneratedDiagnostics<TGenerator>(string source, string markdown, params string[] diagnosticsIds)
-        where TGenerator : class, IIncrementalGenerator, new()
-    {
-        VerifyGeneratedDiagnostics<TGenerator>(CSharpSyntaxTree.ParseText(source), markdown, diagnosticsIds);
-    }
-
-    internal static void VerifyGeneratedDiagnostics<TGenerator>(SyntaxTree syntaxTree, string markdown, params string[] diagnosticsIds)
-        where TGenerator : class, IIncrementalGenerator, new()
-    {
-        var references = GetAllReferencedAssemblies();
-        var compilation = CreateCompilation("original.Samples", syntaxTree, references);
-        var generator = new TGenerator();
-        var driver = CreateGeneratorDriver(syntaxTree, generator);
-
-        if (!string.IsNullOrWhiteSpace(markdown))
-        {
-            var text = new InMemoryAdditionalText(@"C:\pathtorepo\components\experiment\samples\experiment.Samples\documentation.md", markdown);
-            driver = driver.AddAdditionalTexts(ImmutableArray.Create<AdditionalText>(text));
-        }
-
-        _ = driver.RunGeneratorsAndUpdateCompilation(compilation, out Compilation generatorCompilation, out ImmutableArray<Diagnostic> postGeneratorCompilationDiagnostics);
-
-        VerifyCompilationErrors(generatorCompilation);
-        VerifyDiagnostics(diagnosticsIds, postGeneratorCompilationDiagnostics);
-    }
-
-    internal static void VerifyGenerateSources(string assemblyName, string source, IIncrementalGenerator[] generators, bool ignoreDiagnostics = false, params (string Filename, string Text)[] results)
-    {
-        var references = GetAllReferencedAssemblies();
-        var syntaxTree = CSharpSyntaxTree.ParseText(source, CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp10));
-        var compilation = CreateCompilation(assemblyName, syntaxTree, references);
-        var driver = CreateGeneratorDriver(syntaxTree, generators);
-
-        _ = driver.RunGeneratorsAndUpdateCompilation(compilation, out Compilation generatorCompilation, out ImmutableArray<Diagnostic> diagnostics);
-
-        if (!ignoreDiagnostics)
-        {
-            CollectionAssert.AreEquivalent(Array.Empty<Diagnostic>(), diagnostics);
-        }
-
-        VerifyCompilationErrors(generatorCompilation);
-        VerifyGeneratedSources(results, generatorCompilation);
-    }
-
-    internal static IEnumerable<MetadataReference> GetAllReferencedAssemblies()
-    {
-        return from assembly in AppDomain.CurrentDomain.GetAssemblies()
-               where !assembly.IsDynamic
-               let reference = MetadataReference.CreateFromFile(assembly.Location)
-               select reference;
-    }
-
-    internal class InMemoryAdditionalText : AdditionalText
-    {
-        private readonly SourceText _content;
-
-        public InMemoryAdditionalText(string path, string content)
-        {
-            Path = path;
-            _content = SourceText.From(content, Encoding.UTF8);
-        }
-
-        public override string Path { get; }
-
-        public override SourceText GetText(CancellationToken cancellationToken = default) => _content;
-    }
-
-    private static CSharpCompilation CreateCompilation(string assemblyName, SyntaxTree syntaxTree, IEnumerable<MetadataReference> references)
-    {
-        return CSharpCompilation.Create(
-            assemblyName,
-            new[] { syntaxTree },
-            references,
-            new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
-    }
-
-    private static GeneratorDriver CreateGeneratorDriver(SyntaxTree syntaxTree, IIncrementalGenerator generator)
-    {
-        return CSharpGeneratorDriver
-            .Create(generator).WithUpdatedParseOptions((CSharpParseOptions)syntaxTree.Options);
-    }
-
-    private static GeneratorDriver CreateGeneratorDriver(SyntaxTree syntaxTree, IIncrementalGenerator[] generators)
-    {
-        return CSharpGeneratorDriver.Create(generators).WithUpdatedParseOptions((CSharpParseOptions)syntaxTree.Options);
-    }
-
-    private static void VerifyDiagnostics(string[] diagnosticsIds, ImmutableArray<Diagnostic> diagnostics)
-    {
-        HashSet<string> resultingIds = diagnostics.Select(diagnostic => diagnostic.Id).ToHashSet();
-        Assert.IsTrue(resultingIds.SetEquals(diagnosticsIds), $"Expected one of [{string.Join(", ", diagnosticsIds)}] diagnostic Ids. Got [{string.Join(", ", resultingIds)}]");
-    }
-
-    private static void VerifyCompilationErrors(Compilation outputCompilation)
-    {
-        var generatedCompilationDiaghostics = outputCompilation.GetDiagnostics();
-        Assert.IsTrue(generatedCompilationDiaghostics.All(x => x.Severity != DiagnosticSeverity.Error), $"Expected no generated compilation errors. Got: \n{string.Join("\n", generatedCompilationDiaghostics.Where(x => x.Severity == DiagnosticSeverity.Error).Select(x => $"[{x.Id}: {x.GetMessage()}]"))}");
-    }
-
-    private static void VerifyGeneratedSources((string Filename, string Text)[] results, Compilation outputCompilation)
-    {
-        foreach ((string filename, string text) in results)
-        {
-            SyntaxTree generatedTree = outputCompilation.SyntaxTrees.Single(tree => Path.GetFileName(tree.FilePath) == filename);
-            Assert.AreEqual(text, generatedTree.ToString());
-        }
-    }
-}
diff --git a/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleGeneratedPaneTests.cs b/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleGeneratedPaneTests.cs
index d479a772..3f84d798 100644
--- a/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleGeneratedPaneTests.cs
+++ b/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleGeneratedPaneTests.cs
@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using CommunityToolkit.Tooling.SampleGen.Diagnostics;
+using CommunityToolkit.Tooling.SampleGen.Tests.Helpers;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace CommunityToolkit.Tooling.SampleGen.Tests;
@@ -10,6 +11,8 @@ namespace CommunityToolkit.Tooling.SampleGen.Tests;
 [TestClass]
 public partial class ToolkitSampleGeneratedPaneTests
 {
+    private const string SAMPLE_ASM_NAME = "PaneTests.Samples";
+
     [TestMethod]
     public void PaneOption_GeneratesWithoutDiagnostics()
     {
@@ -39,13 +42,16 @@ namespace Windows.UI.Xaml.Controls
                 public class UserControl {{ }}
             }}";
 
-        TestHelpers.VerifyGeneratedDiagnostics<ToolkitSampleOptionGenerator>(source, string.Empty);
+        var result = source.RunSourceGenerator<ToolkitSampleOptionGenerator>(SAMPLE_ASM_NAME);
+
+        result.AssertNoCompilationErrors();
+        result.AssertDiagnosticsAre();
     }
 
     [TestMethod]
     public void PaneOption_GeneratesTitleProperty()
     {
-        var source = """
+        var syntaxTree = """
             using System.ComponentModel;
             using CommunityToolkit.Tooling.SampleGen;
             using CommunityToolkit.Tooling.SampleGen.Attributes;
@@ -66,25 +72,31 @@ namespace Windows.UI.Xaml.Controls
             {
                 public class UserControl { }
             }
-        """;
+        """.ToSyntaxTree();
 
-        var result = """
-            #nullable enable
-            namespace CommunityToolkit.Tooling.SampleGen;
+        // Create compilation builder with custom assembly name
+        var compilation = syntaxTree.CreateCompilation("MyApp.Tests");
 
-            public static class ToolkitSampleRegistry
-            {
-                public static System.Collections.Generic.Dictionary<string, CommunityToolkit.Tooling.SampleGen.Metadata.ToolkitSampleMetadata> Listing
-                { get; } = new() {
-                    ["Sample"] = new CommunityToolkit.Tooling.SampleGen.Metadata.ToolkitSampleMetadata("Sample", "Test Sample", "", typeof(MyApp.Sample), () => new MyApp.Sample(), null, null, new CommunityToolkit.Tooling.SampleGen.Metadata.IGeneratedToolkitSampleOptionViewModel[] { new CommunityToolkit.Tooling.SampleGen.Metadata.ToolkitSampleNumericOptionMetadataViewModel(name: "TextSize", initial: 12, min: 8, max: 48, step: 2, showAsNumberBox: false, title: "FontSize") })
-                };
-            }
-            """;
+        // Run source generator
+        var result = syntaxTree.RunSourceGenerator<ToolkitSampleMetadataGenerator>(compilation);
 
-        TestHelpers.VerifyGenerateSources("MyApp.Tests", source, new[] { new ToolkitSampleMetadataGenerator() }, ignoreDiagnostics: true, ("ToolkitSampleRegistry.g.cs", result));
+        result.AssertDiagnosticsAre();
+        result.AssertNoCompilationErrors();
+
+        result.AssertSourceGenerated(filename: "ToolkitSampleRegistry.g.cs", expectedContents: """
+        #nullable enable
+        namespace CommunityToolkit.Tooling.SampleGen;
+
+        public static class ToolkitSampleRegistry
+        {
+            public static System.Collections.Generic.Dictionary<string, CommunityToolkit.Tooling.SampleGen.Metadata.ToolkitSampleMetadata> Listing
+            { get; } = new() {
+                ["Sample"] = new CommunityToolkit.Tooling.SampleGen.Metadata.ToolkitSampleMetadata("Sample", "Test Sample", "", typeof(MyApp.Sample), () => new MyApp.Sample(), null, null, new CommunityToolkit.Tooling.SampleGen.Metadata.IGeneratedToolkitSampleOptionViewModel[] { new CommunityToolkit.Tooling.SampleGen.Metadata.ToolkitSampleNumericOptionMetadataViewModel(name: "TextSize", initial: 12, min: 8, max: 48, step: 2, showAsNumberBox: false, title: "FontSize") })
+            };
+        }
+        """);
     }
 
-    // https://github.com/CommunityToolkit/Labs-Windows/issues/175
     [TestMethod]
     public void PaneOption_GeneratesProperty_DuplicatePropNamesAcrossSampleClasses()
     {
@@ -127,7 +139,10 @@ namespace Windows.UI.Xaml.Controls
                 public class UserControl {{ }}
             }}";
 
-        TestHelpers.VerifyGeneratedDiagnostics<ToolkitSampleOptionGenerator>(source, string.Empty);
+        var result = source.RunSourceGenerator<ToolkitSampleOptionGenerator>(SAMPLE_ASM_NAME);
+
+        result.AssertNoCompilationErrors();
+        result.AssertDiagnosticsAre();
     }
 
     [TestMethod]
@@ -150,7 +165,8 @@ namespace Windows.UI.Xaml.Controls
                 public class UserControl { }
             }";
 
-        TestHelpers.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(source, string.Empty, DiagnosticDescriptors.SamplePaneOptionAttributeOnNonSample.Id);
+        var result = source.RunSourceGenerator<ToolkitSampleMetadataGenerator>(SAMPLE_ASM_NAME);
+        result.Diagnostics.AssertDiagnosticsAre(DiagnosticDescriptors.SamplePaneOptionAttributeOnNonSample);
     }
 
     [DataRow("", DisplayName = "Empty string"), DataRow(" ", DisplayName = "Only whitespace"), DataRow("Test ", DisplayName = "Text with whitespace")]
@@ -178,7 +194,9 @@ namespace Windows.UI.Xaml.Controls
                 public class UserControl {{ }}
             }}";
 
-        TestHelpers.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(source, string.Empty, DiagnosticDescriptors.SamplePaneOptionWithBadName.Id, DiagnosticDescriptors.SampleNotReferencedInMarkdown.Id);
+        var result = source.RunSourceGenerator<ToolkitSampleMetadataGenerator>(SAMPLE_ASM_NAME);
+
+        result.AssertDiagnosticsAre(DiagnosticDescriptors.SamplePaneOptionWithBadName, DiagnosticDescriptors.SampleNotReferencedInMarkdown);
     }
 
 
@@ -205,7 +223,9 @@ namespace Windows.UI.Xaml.Controls
                 public class UserControl {{ }}
             }}";
 
-        TestHelpers.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(source, string.Empty, DiagnosticDescriptors.SamplePaneOptionWithConflictingName.Id, DiagnosticDescriptors.SampleNotReferencedInMarkdown.Id);
+        var result = source.RunSourceGenerator<ToolkitSampleMetadataGenerator>(SAMPLE_ASM_NAME);
+
+        result.AssertDiagnosticsAre(DiagnosticDescriptors.SamplePaneOptionWithConflictingName, DiagnosticDescriptors.SampleNotReferencedInMarkdown);
     }
 
     [TestMethod]
@@ -235,7 +255,9 @@ namespace Windows.UI.Xaml.Controls
                 public class UserControl {{ }}
             }}";
 
-        TestHelpers.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(source, string.Empty, DiagnosticDescriptors.SamplePaneOptionWithConflictingName.Id, DiagnosticDescriptors.SampleNotReferencedInMarkdown.Id);
+        var result = source.RunSourceGenerator<ToolkitSampleMetadataGenerator>(SAMPLE_ASM_NAME);
+
+        result.AssertDiagnosticsAre(DiagnosticDescriptors.SamplePaneOptionWithConflictingName, DiagnosticDescriptors.SampleNotReferencedInMarkdown);
     }
 
     [TestMethod]
@@ -263,7 +285,9 @@ namespace Windows.UI.Xaml.Controls
                 public class UserControl {{ }}
             }}";
 
-        TestHelpers.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(source, string.Empty, DiagnosticDescriptors.SamplePaneOptionWithDuplicateName.Id, DiagnosticDescriptors.SampleNotReferencedInMarkdown.Id);
+        var result = source.RunSourceGenerator<ToolkitSampleMetadataGenerator>(SAMPLE_ASM_NAME);
+
+        result.AssertDiagnosticsAre(DiagnosticDescriptors.SamplePaneOptionWithDuplicateName, DiagnosticDescriptors.SampleNotReferencedInMarkdown);
     }
 
     [TestMethod]
@@ -296,7 +320,9 @@ namespace Windows.UI.Xaml.Controls
                 public class UserControl {{ }}
             }}";
 
-        TestHelpers.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(source, string.Empty, DiagnosticDescriptors.SampleNotReferencedInMarkdown.Id);
+        var result = source.RunSourceGenerator<ToolkitSampleMetadataGenerator>(SAMPLE_ASM_NAME);
+
+        result.AssertDiagnosticsAre(DiagnosticDescriptors.SampleNotReferencedInMarkdown);
     }
 
     [TestMethod]
@@ -316,7 +342,9 @@ public partial class Sample
                 }}
             }}";
 
-        TestHelpers.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(source, string.Empty, DiagnosticDescriptors.SampleGeneratedOptionAttributeOnUnsupportedType.Id, DiagnosticDescriptors.SamplePaneOptionAttributeOnNonSample.Id);
+        var result = source.RunSourceGenerator<ToolkitSampleMetadataGenerator>(SAMPLE_ASM_NAME);
+
+        result.AssertDiagnosticsAre(DiagnosticDescriptors.SampleGeneratedOptionAttributeOnUnsupportedType, DiagnosticDescriptors.SamplePaneOptionAttributeOnNonSample);
     }
 
     [TestMethod]
@@ -342,7 +370,9 @@ namespace Windows.UI.Xaml.Controls
                 public class UserControl {{ }}
             }}";
 
-        TestHelpers.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(source, string.Empty, DiagnosticDescriptors.SamplePaneMultiChoiceOptionWithNoChoices.Id, DiagnosticDescriptors.SampleNotReferencedInMarkdown.Id);
+        var result = source.RunSourceGenerator<ToolkitSampleMetadataGenerator>(SAMPLE_ASM_NAME);
+
+        result.AssertDiagnosticsAre(DiagnosticDescriptors.SamplePaneMultiChoiceOptionWithNoChoices, DiagnosticDescriptors.SampleNotReferencedInMarkdown);
     }
 
     [TestMethod]
@@ -370,6 +400,9 @@ namespace Windows.UI.Xaml.Controls
                 public class UserControl {{ }}
             }}";
 
-        TestHelpers.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(source, string.Empty, DiagnosticDescriptors.SampleNotReferencedInMarkdown.Id);
+
+        var result = source.RunSourceGenerator<ToolkitSampleMetadataGenerator>(SAMPLE_ASM_NAME);
+
+        result.AssertDiagnosticsAre(DiagnosticDescriptors.SampleNotReferencedInMarkdown);
     }
 }
diff --git a/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleMetadataTests.Documentation.cs b/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleMetadataTests.Documentation.cs
index 5cc24a29..f9c6ffef 100644
--- a/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleMetadataTests.Documentation.cs
+++ b/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleMetadataTests.Documentation.cs
@@ -7,6 +7,7 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
+using CommunityToolkit.Tooling.SampleGen.Tests.Helpers;
 
 namespace CommunityToolkit.Tooling.SampleGen.Tests;
 
@@ -40,7 +41,10 @@ public void MissingFrontMatterSection()
             Without any front matter.
             ";
 
-        TestHelpers.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(SimpleSource, markdown, DiagnosticDescriptors.MarkdownYAMLFrontMatterException.Id, DiagnosticDescriptors.SampleNotReferencedInMarkdown.Id);
+        var result = SimpleSource.RunSourceGenerator<ToolkitSampleMetadataGenerator>(SAMPLE_ASM_NAME, markdown);
+        
+        result.AssertNoCompilationErrors();
+        result.AssertDiagnosticsAre(DiagnosticDescriptors.MarkdownYAMLFrontMatterException, DiagnosticDescriptors.SampleNotReferencedInMarkdown);
     }
 
     [DataRow(1, DisplayName = "Title")]
@@ -74,7 +78,11 @@ public void MissingFrontMatterField(int removeline)
         lines.RemoveAt(removeline);
         markdown = String.Join('\n', lines);
 
-        TestHelpers.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(SimpleSource, markdown, DiagnosticDescriptors.MarkdownYAMLFrontMatterMissingField.Id, DiagnosticDescriptors.SampleNotReferencedInMarkdown.Id); // We won't see the sample reference as we bail out when the front matter fails to be complete...
+        var result = SimpleSource.RunSourceGenerator<ToolkitSampleMetadataGenerator>(SAMPLE_ASM_NAME, markdown);
+
+        // We won't see the sample reference as we bail out when the front matter fails to be complete
+        result.AssertNoCompilationErrors();
+        result.AssertDiagnosticsAre(DiagnosticDescriptors.MarkdownYAMLFrontMatterMissingField, DiagnosticDescriptors.SampleNotReferencedInMarkdown);
     }
 
     [TestMethod]
@@ -97,9 +105,10 @@ public void MarkdownInvalidSampleReference()
 Without any front matter.
 ";
 
-        TestHelpers.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(SimpleSource, markdown,
-            DiagnosticDescriptors.MarkdownSampleIdNotFound.Id,
-            DiagnosticDescriptors.SampleNotReferencedInMarkdown.Id);
+        var result = SimpleSource.RunSourceGenerator<ToolkitSampleMetadataGenerator>(SAMPLE_ASM_NAME, markdown);
+        
+        result.AssertNoCompilationErrors();
+        result.AssertDiagnosticsAre(DiagnosticDescriptors.MarkdownSampleIdNotFound, DiagnosticDescriptors.SampleNotReferencedInMarkdown);
     }
 
     [TestMethod]
@@ -120,9 +129,10 @@ public void DocumentationMissingSample()
 # This is some test documentation...
 Without any sample.";
 
-        TestHelpers.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(SimpleSource, markdown,
-            DiagnosticDescriptors.DocumentationHasNoSamples.Id,
-            DiagnosticDescriptors.SampleNotReferencedInMarkdown.Id);
+        var result = SimpleSource.RunSourceGenerator<ToolkitSampleMetadataGenerator>(SAMPLE_ASM_NAME, markdown);
+        
+        result.AssertNoCompilationErrors();
+        result.AssertDiagnosticsAre(DiagnosticDescriptors.DocumentationHasNoSamples, DiagnosticDescriptors.SampleNotReferencedInMarkdown);
     }
 
     [TestMethod]
@@ -143,8 +153,12 @@ public void DocumentationValid()
 # This is some test documentation...
 Which is valid.
 > [!SAMPLE Sample]";
+        
+
+        var result = SimpleSource.RunSourceGenerator<ToolkitSampleMetadataGenerator>(SAMPLE_ASM_NAME, markdown);
 
-        TestHelpers.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(SimpleSource, markdown);
+        result.AssertNoCompilationErrors();
+        result.AssertDiagnosticsAre();
     }
 
     [TestMethod]
@@ -165,9 +179,10 @@ public void DocumentationInvalidDiscussionId()
 # This is some test documentation...
 Without an invalid discussion id.";
 
-        TestHelpers.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(string.Empty, markdown,
-            DiagnosticDescriptors.MarkdownYAMLFrontMatterException.Id,
-            DiagnosticDescriptors.DocumentationHasNoSamples.Id);
+        var result = string.Empty.RunSourceGenerator<ToolkitSampleMetadataGenerator>(SAMPLE_ASM_NAME, markdown);
+        
+        result.AssertNoCompilationErrors();
+        result.AssertDiagnosticsAre(DiagnosticDescriptors.MarkdownYAMLFrontMatterException, DiagnosticDescriptors.DocumentationHasNoSamples);
     }
 
     [TestMethod]
@@ -188,8 +203,9 @@ public void DocumentationInvalidIssueId()
 # This is some test documentation...
 Without an invalid discussion id.";
 
-        TestHelpers.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(string.Empty, markdown,
-            DiagnosticDescriptors.MarkdownYAMLFrontMatterException.Id,
-            DiagnosticDescriptors.DocumentationHasNoSamples.Id);
+        var result = string.Empty.RunSourceGenerator<ToolkitSampleMetadataGenerator>(SAMPLE_ASM_NAME, markdown);
+        
+        result.AssertNoCompilationErrors();
+        result.AssertDiagnosticsAre(DiagnosticDescriptors.MarkdownYAMLFrontMatterException, DiagnosticDescriptors.DocumentationHasNoSamples);
     }
 }
diff --git a/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleMetadataTests.cs b/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleMetadataTests.cs
index 6682767c..3d401f94 100644
--- a/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleMetadataTests.cs
+++ b/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleMetadataTests.cs
@@ -3,14 +3,16 @@
 // See the LICENSE file in the project root for more information.
 
 using CommunityToolkit.Tooling.SampleGen.Diagnostics;
+using CommunityToolkit.Tooling.SampleGen.Tests.Helpers;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
-using System.ComponentModel.DataAnnotations;
 
 namespace CommunityToolkit.Tooling.SampleGen.Tests;
 
 [TestClass]
 public partial class ToolkitSampleMetadataTests
 {
+    private const string SAMPLE_ASM_NAME = "MetadataTests.Samples";
+
     [TestMethod]
     public void SampleAttributeOnUnsupportedType()
     {
@@ -27,7 +29,10 @@ public partial class Sample
                 }}
             }}";
 
-        TestHelpers.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(source, string.Empty, DiagnosticDescriptors.SampleAttributeOnUnsupportedType.Id, DiagnosticDescriptors.SampleNotReferencedInMarkdown.Id);
+        var result = source.RunSourceGenerator<ToolkitSampleMetadataGenerator>(SAMPLE_ASM_NAME);
+
+        result.AssertDiagnosticsAre(DiagnosticDescriptors.SampleAttributeOnUnsupportedType, DiagnosticDescriptors.SampleNotReferencedInMarkdown);
+        result.AssertNoCompilationErrors();
     }
 
     [TestMethod]
@@ -56,7 +61,10 @@ namespace Windows.UI.Xaml.Controls
                 public class UserControl {{ }}
             }}";
 
-        TestHelpers.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(source, string.Empty, DiagnosticDescriptors.SampleOptionPaneAttributeOnUnsupportedType.Id, DiagnosticDescriptors.SampleNotReferencedInMarkdown.Id);
+        var result = source.RunSourceGenerator<ToolkitSampleMetadataGenerator>(SAMPLE_ASM_NAME);
+
+        result.AssertDiagnosticsAre(DiagnosticDescriptors.SampleOptionPaneAttributeOnUnsupportedType, DiagnosticDescriptors.SampleNotReferencedInMarkdown);
+        result.AssertNoCompilationErrors();
     }
 
     [TestMethod]
@@ -81,7 +89,9 @@ namespace Windows.UI.Xaml.Controls
                 public class UserControl {{ }}
             }}";
 
-        // TODO: We should have this return the references to the registries or something so we can check the generated output?
-        TestHelpers.VerifyGeneratedDiagnostics<ToolkitSampleMetadataGenerator>(source, string.Empty, DiagnosticDescriptors.SampleNotReferencedInMarkdown.Id);
+        var result = source.RunSourceGenerator<ToolkitSampleMetadataGenerator>(SAMPLE_ASM_NAME);
+
+        result.AssertDiagnosticsAre(DiagnosticDescriptors.SampleNotReferencedInMarkdown);
+        result.AssertNoCompilationErrors();
     }
 }

From b8481d14d0f82e9e1c933658d9741e60d90e6271 Mon Sep 17 00:00:00 2001
From: Arlo Godfrey <arlo.godfrey@outlook.com>
Date: Wed, 5 Apr 2023 14:45:59 -0500
Subject: [PATCH 06/12] Updated tooling and refactored SampleGen to remove
 special code path for when executing in tests

---
 .../Helpers/TestHelpers.Compilation.cs        |  8 ++--
 .../Helpers/TestHelpers.cs                    | 11 +++--
 .../ToolkitSampleGeneratedPaneTests.cs        | 43 +++++++++++++++----
 .../ToolkitSampleMetadataGenerator.Sample.cs  |  5 +--
 4 files changed, 44 insertions(+), 23 deletions(-)

diff --git a/CommunityToolkit.Tooling.SampleGen.Tests/Helpers/TestHelpers.Compilation.cs b/CommunityToolkit.Tooling.SampleGen.Tests/Helpers/TestHelpers.Compilation.cs
index d087378a..85dd48ad 100644
--- a/CommunityToolkit.Tooling.SampleGen.Tests/Helpers/TestHelpers.Compilation.cs
+++ b/CommunityToolkit.Tooling.SampleGen.Tests/Helpers/TestHelpers.Compilation.cs
@@ -33,14 +33,14 @@ internal static CSharpCompilation CreateCompilation(this IEnumerable<SyntaxTree>
         return CSharpCompilation.Create(assemblyName, syntaxTree, references ?? GetAllReferencedAssemblies(), new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
     }
 
-    internal static GeneratorDriver CreateSourceGeneratorDriver(this SyntaxTree syntaxTree, IIncrementalGenerator generator)
+    internal static GeneratorDriver CreateSourceGeneratorDriver(this SyntaxTree syntaxTree, params IIncrementalGenerator[] generators)
     {
-        return CSharpGeneratorDriver.Create(generator).WithUpdatedParseOptions((CSharpParseOptions)syntaxTree.Options);
+        return CSharpGeneratorDriver.Create(generators).WithUpdatedParseOptions((CSharpParseOptions)syntaxTree.Options);
     }
 
-    internal static GeneratorDriver CreateSourceGeneratorDriver(this SyntaxTree syntaxTree, params IIncrementalGenerator[] generators)
+    internal static GeneratorDriver CreateSourceGeneratorDriver(this Compilation compilation, params IIncrementalGenerator[] generators)
     {
-        return CSharpGeneratorDriver.Create(generators).WithUpdatedParseOptions((CSharpParseOptions)syntaxTree.Options);
+        return CSharpGeneratorDriver.Create(generators).WithUpdatedParseOptions((CSharpParseOptions)compilation.SyntaxTrees.First().Options);
     }
 
     internal static GeneratorDriver WithMarkdown(this GeneratorDriver driver, params string[] markdownFilesToCreate)
diff --git a/CommunityToolkit.Tooling.SampleGen.Tests/Helpers/TestHelpers.cs b/CommunityToolkit.Tooling.SampleGen.Tests/Helpers/TestHelpers.cs
index b048dc03..76d96960 100644
--- a/CommunityToolkit.Tooling.SampleGen.Tests/Helpers/TestHelpers.cs
+++ b/CommunityToolkit.Tooling.SampleGen.Tests/Helpers/TestHelpers.cs
@@ -6,20 +6,19 @@ namespace CommunityToolkit.Tooling.SampleGen.Tests.Helpers;
 public static partial class TestHelpers
 {
     internal static SourceGeneratorRunResult RunSourceGenerator<TGenerator>(this string source, string assemblyName, string markdown = "") where TGenerator : class, IIncrementalGenerator, new() => RunSourceGenerator<TGenerator>(source.ToSyntaxTree(), assemblyName, markdown);
-
+    
     internal static SourceGeneratorRunResult RunSourceGenerator<TGenerator>(this SyntaxTree syntaxTree, string assemblyName, string markdown = "")
         where TGenerator : class, IIncrementalGenerator, new()
     {
-        var references = GetAllReferencedAssemblies();
-        var compilation = syntaxTree.CreateCompilation(assemblyName, references); // assembly name should always be supplied in param
-        return RunSourceGenerator<TGenerator>(syntaxTree, compilation, markdown);
+        var compilation = syntaxTree.CreateCompilation(assemblyName); // assembly name should always be supplied in param
+        return RunSourceGenerator<TGenerator>(compilation, markdown);
     }
 
-    internal static SourceGeneratorRunResult RunSourceGenerator<TGenerator>(this SyntaxTree syntaxTree, Compilation compilation, string markdown = "")
+    internal static SourceGeneratorRunResult RunSourceGenerator<TGenerator>(this Compilation compilation, string markdown = "")
         where TGenerator : class, IIncrementalGenerator, new()
     {
         // Create a driver for the source generator
-        var driver = syntaxTree
+        var driver = compilation
             .CreateSourceGeneratorDriver(new TGenerator())
             .WithMarkdown(markdown);
 
diff --git a/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleGeneratedPaneTests.cs b/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleGeneratedPaneTests.cs
index 3f84d798..bfb245c2 100644
--- a/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleGeneratedPaneTests.cs
+++ b/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleGeneratedPaneTests.cs
@@ -4,7 +4,9 @@
 
 using CommunityToolkit.Tooling.SampleGen.Diagnostics;
 using CommunityToolkit.Tooling.SampleGen.Tests.Helpers;
+using Microsoft.CodeAnalysis;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System.Linq;
 
 namespace CommunityToolkit.Tooling.SampleGen.Tests;
 
@@ -51,7 +53,9 @@ public class UserControl {{ }}
     [TestMethod]
     public void PaneOption_GeneratesTitleProperty()
     {
-        var syntaxTree = """
+        // The sample registry is designed to be declared in the sample project, and generated in the project head where its displayed in the UI as data.
+        // To test the contents of the generated sample registry, we must replicate this setup.
+        var sampleProjectAssembly = """
             using System.ComponentModel;
             using CommunityToolkit.Tooling.SampleGen;
             using CommunityToolkit.Tooling.SampleGen.Attributes;
@@ -72,13 +76,16 @@ namespace Windows.UI.Xaml.Controls
             {
                 public class UserControl { }
             }
-        """.ToSyntaxTree();
+        """.ToSyntaxTree()
+            .CreateCompilation("MyApp.Samples")
+            .ToMetadataReference();
 
-        // Create compilation builder with custom assembly name
-        var compilation = syntaxTree.CreateCompilation("MyApp.Tests");
+        // Get all current referenced assemblies + our generated sample project.
+        var headReferences = TestHelpers.GetAllReferencedAssemblies().Concat(new[] { sampleProjectAssembly });
+        var headCompilation = string.Empty.ToSyntaxTree().CreateCompilation("MyApp.Head", headReferences);
 
         // Run source generator
-        var result = syntaxTree.RunSourceGenerator<ToolkitSampleMetadataGenerator>(compilation);
+        var result = headCompilation.RunSourceGenerator<ToolkitSampleMetadataGenerator>();
 
         result.AssertDiagnosticsAre();
         result.AssertNoCompilationErrors();
@@ -378,7 +385,7 @@ public class UserControl {{ }}
     [TestMethod]
     public void GeneratedPaneOption_ButtonAction()
     {
-        var source = $@"
+        var syntaxTree = $@"
             using System.ComponentModel;
             using CommunityToolkit.Tooling.SampleGen;
             using CommunityToolkit.Tooling.SampleGen.Attributes;
@@ -398,11 +405,29 @@ private void RaiseNotification()
             namespace Windows.UI.Xaml.Controls
             {{
                 public class UserControl {{ }}
-            }}";
+            }}".ToSyntaxTree();
 
 
-        var result = source.RunSourceGenerator<ToolkitSampleMetadataGenerator>(SAMPLE_ASM_NAME);
+        // Create compilation builder with custom assembly name
+        var compilation = syntaxTree.CreateCompilation("MyApp.Tests");
 
-        result.AssertDiagnosticsAre(DiagnosticDescriptors.SampleNotReferencedInMarkdown);
+        // Run source generator
+        var result = compilation.RunSourceGenerator<ToolkitSampleMetadataGenerator>();
+
+        result.AssertDiagnosticsAre();
+        result.AssertNoCompilationErrors();
+
+        result.AssertSourceGenerated(filename: "ToolkitSampleRegistry.g.cs", expectedContents: """
+        #nullable enable
+        namespace CommunityToolkit.Tooling.SampleGen;
+
+        public static class ToolkitSampleRegistry
+        {
+            public static System.Collections.Generic.Dictionary<string, CommunityToolkit.Tooling.SampleGen.Metadata.ToolkitSampleMetadata> Listing
+            { get; } = new() {
+                ["Sample"] = new CommunityToolkit.Tooling.SampleGen.Metadata.ToolkitSampleMetadata("Sample", "Test Sample", "", typeof(MyApp.Sample), () => new MyApp.Sample(), null, null, new CommunityToolkit.Tooling.SampleGen.Metadata.IGeneratedToolkitSampleOptionViewModel[] { new CommunityToolkit.Tooling.SampleGen.Metadata.ToolkitSampleNumericOptionMetadataViewModel(name: "TextSize", initial: 12, min: 8, max: 48, step: 2, showAsNumberBox: false, title: "FontSize") })
+            };
+        }
+        """);
     }
 }
diff --git a/CommunityToolkit.Tooling.SampleGen/ToolkitSampleMetadataGenerator.Sample.cs b/CommunityToolkit.Tooling.SampleGen/ToolkitSampleMetadataGenerator.Sample.cs
index 50bc1e62..3f4dd47c 100644
--- a/CommunityToolkit.Tooling.SampleGen/ToolkitSampleMetadataGenerator.Sample.cs
+++ b/CommunityToolkit.Tooling.SampleGen/ToolkitSampleMetadataGenerator.Sample.cs
@@ -125,7 +125,6 @@ void Execute(IncrementalValuesProvider<ISymbol> types, bool skipDiagnostics = fa
                 var currentAssembly = data.Right;
 
                 var isExecutingInSampleProject = currentAssembly?.EndsWith(".Samples") ?? false;
-                var isExecutingInTestProject = currentAssembly?.EndsWith(".Tests") ?? false;
 
                 // Reconstruct sample metadata from attributes
                 var sampleMetadata = toolkitSampleAttributeData
@@ -151,9 +150,7 @@ void Execute(IncrementalValuesProvider<ISymbol> types, bool skipDiagnostics = fa
                     ReportDocumentDiagnostics(ctx, sampleMetadata, markdownFileData, toolkitSampleAttributeData, docFrontMatter);
                 }
 
-                // For tests we need one pass to do diagnostics and registry as we're in a contrived environment that'll have both our scenarios. Though we check if we have anything to write, as we will hit both executes.
-                if ((!isExecutingInSampleProject && !skipRegistry) ||
-                    (isExecutingInTestProject && (docFrontMatter.Any() || sampleMetadata.Any())))
+                if (!isExecutingInSampleProject && !skipRegistry)
                 {
                     CreateDocumentRegistry(ctx, docFrontMatter);
                     CreateSampleRegistry(ctx, sampleMetadata);

From c698a4bd5991d8f5368233f153fddf6c62f58e73 Mon Sep 17 00:00:00 2001
From: Arlo Godfrey <arlo.godfrey@outlook.com>
Date: Wed, 5 Apr 2023 15:08:46 -0500
Subject: [PATCH 07/12] Enabled asserting partial string comparisons of
 generated source.

---
 .../Helpers/TestHelpers.cs                    | 14 ++++----
 .../ToolkitSampleGeneratedPaneTests.cs        | 33 +++++++++++--------
 2 files changed, 28 insertions(+), 19 deletions(-)

diff --git a/CommunityToolkit.Tooling.SampleGen.Tests/Helpers/TestHelpers.cs b/CommunityToolkit.Tooling.SampleGen.Tests/Helpers/TestHelpers.cs
index 76d96960..64e8a3f6 100644
--- a/CommunityToolkit.Tooling.SampleGen.Tests/Helpers/TestHelpers.cs
+++ b/CommunityToolkit.Tooling.SampleGen.Tests/Helpers/TestHelpers.cs
@@ -6,7 +6,7 @@ namespace CommunityToolkit.Tooling.SampleGen.Tests.Helpers;
 public static partial class TestHelpers
 {
     internal static SourceGeneratorRunResult RunSourceGenerator<TGenerator>(this string source, string assemblyName, string markdown = "") where TGenerator : class, IIncrementalGenerator, new() => RunSourceGenerator<TGenerator>(source.ToSyntaxTree(), assemblyName, markdown);
-    
+
     internal static SourceGeneratorRunResult RunSourceGenerator<TGenerator>(this SyntaxTree syntaxTree, string assemblyName, string markdown = "")
         where TGenerator : class, IIncrementalGenerator, new()
     {
@@ -42,17 +42,19 @@ internal static void AssertNoCompilationErrors(this Compilation outputCompilatio
         Assert.IsTrue(generatedCompilationDiagnostics.All(x => x.Severity != DiagnosticSeverity.Error), $"Expected no generated compilation errors. Got: \n{string.Join("\n", generatedCompilationDiagnostics.Where(x => x.Severity == DiagnosticSeverity.Error).Select(x => $"[{x.Id}: {x.GetMessage()}]"))}");
     }
 
-    internal static void AssertSourceGenerated(this Compilation compilation, string filename, string expectedContents)
+    internal static string GetFileContentsByName(this Compilation compilation, string filename)
     {
         var generatedTree = compilation.SyntaxTrees.SingleOrDefault(tree => Path.GetFileName(tree.FilePath) == filename);
-
         Assert.IsNotNull(generatedTree, $"No file named {filename} was generated");
-        Assert.AreEqual(expectedContents, generatedTree.ToString(), "Unexpected code generated");
+
+        return generatedTree.ToString();
+    }
+
+    internal static void AssertSourceGenerated(this Compilation compilation, string filename, string expectedContents)
+    {
     }
 
     internal static void AssertDiagnosticsAre(this SourceGeneratorRunResult result, params DiagnosticDescriptor[] expectedDiagnosticDescriptors) => AssertDiagnosticsAre(result.Diagnostics, expectedDiagnosticDescriptors);
 
     internal static void AssertNoCompilationErrors(this SourceGeneratorRunResult result) => AssertNoCompilationErrors(result.Compilation);
-
-    internal static void AssertSourceGenerated(this SourceGeneratorRunResult result, string filename, string expectedContents) => AssertSourceGenerated(result.Compilation, filename, expectedContents);
 }
diff --git a/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleGeneratedPaneTests.cs b/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleGeneratedPaneTests.cs
index bfb245c2..c9a24ca4 100644
--- a/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleGeneratedPaneTests.cs
+++ b/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleGeneratedPaneTests.cs
@@ -80,9 +80,11 @@ public class UserControl { }
             .CreateCompilation("MyApp.Samples")
             .ToMetadataReference();
 
-        // Get all current referenced assemblies + our generated sample project.
-        var headReferences = TestHelpers.GetAllReferencedAssemblies().Concat(new[] { sampleProjectAssembly });
-        var headCompilation = string.Empty.ToSyntaxTree().CreateCompilation("MyApp.Head", headReferences);
+        // Create application head that references generated sample project
+        var headCompilation = string.Empty
+            .ToSyntaxTree()
+            .CreateCompilation("MyApp.Head", TestHelpers.GetAllReferencedAssemblies())
+            .AddReferences(sampleProjectAssembly);
 
         // Run source generator
         var result = headCompilation.RunSourceGenerator<ToolkitSampleMetadataGenerator>();
@@ -90,7 +92,7 @@ public class UserControl { }
         result.AssertDiagnosticsAre();
         result.AssertNoCompilationErrors();
 
-        result.AssertSourceGenerated(filename: "ToolkitSampleRegistry.g.cs", expectedContents: """
+        Assert.AreEqual(result.Compilation.GetFileContentsByName("ToolkitSampleRegistry.g.cs"), """
         #nullable enable
         namespace CommunityToolkit.Tooling.SampleGen;
 
@@ -101,7 +103,7 @@ public static class ToolkitSampleRegistry
                 ["Sample"] = new CommunityToolkit.Tooling.SampleGen.Metadata.ToolkitSampleMetadata("Sample", "Test Sample", "", typeof(MyApp.Sample), () => new MyApp.Sample(), null, null, new CommunityToolkit.Tooling.SampleGen.Metadata.IGeneratedToolkitSampleOptionViewModel[] { new CommunityToolkit.Tooling.SampleGen.Metadata.ToolkitSampleNumericOptionMetadataViewModel(name: "TextSize", initial: 12, min: 8, max: 48, step: 2, showAsNumberBox: false, title: "FontSize") })
             };
         }
-        """);
+        """, "Unexpected code generated");
     }
 
     [TestMethod]
@@ -385,7 +387,7 @@ public class UserControl {{ }}
     [TestMethod]
     public void GeneratedPaneOption_ButtonAction()
     {
-        var syntaxTree = $@"
+        var sampleProjectAssembly = $@"
             using System.ComponentModel;
             using CommunityToolkit.Tooling.SampleGen;
             using CommunityToolkit.Tooling.SampleGen.Attributes;
@@ -405,19 +407,24 @@ private void RaiseNotification()
             namespace Windows.UI.Xaml.Controls
             {{
                 public class UserControl {{ }}
-            }}".ToSyntaxTree();
-
+            }}"
+            .ToSyntaxTree()
+            .CreateCompilation("MyApp.Samples")
+            .ToMetadataReference();
 
-        // Create compilation builder with custom assembly name
-        var compilation = syntaxTree.CreateCompilation("MyApp.Tests");
+        // Create application head that references generated sample project
+        var headCompilation = string.Empty
+            .ToSyntaxTree()
+            .CreateCompilation("MyApp.Head", TestHelpers.GetAllReferencedAssemblies())
+            .AddReferences(sampleProjectAssembly);
 
         // Run source generator
-        var result = compilation.RunSourceGenerator<ToolkitSampleMetadataGenerator>();
+        var result = headCompilation.RunSourceGenerator<ToolkitSampleMetadataGenerator>();
 
         result.AssertDiagnosticsAre();
         result.AssertNoCompilationErrors();
 
-        result.AssertSourceGenerated(filename: "ToolkitSampleRegistry.g.cs", expectedContents: """
+        Assert.AreEqual(result.Compilation.GetFileContentsByName("ToolkitSampleRegistry.g.cs"), """
         #nullable enable
         namespace CommunityToolkit.Tooling.SampleGen;
 
@@ -428,6 +435,6 @@ public static class ToolkitSampleRegistry
                 ["Sample"] = new CommunityToolkit.Tooling.SampleGen.Metadata.ToolkitSampleMetadata("Sample", "Test Sample", "", typeof(MyApp.Sample), () => new MyApp.Sample(), null, null, new CommunityToolkit.Tooling.SampleGen.Metadata.IGeneratedToolkitSampleOptionViewModel[] { new CommunityToolkit.Tooling.SampleGen.Metadata.ToolkitSampleNumericOptionMetadataViewModel(name: "TextSize", initial: 12, min: 8, max: 48, step: 2, showAsNumberBox: false, title: "FontSize") })
             };
         }
-        """);
+        """, "Unexpected code generated");
     }
 }

From 08914e74cfc8765a6b2f01e628ce6190dfc8e141 Mon Sep 17 00:00:00 2001
From: Arlo Godfrey <arlo.godfrey@outlook.com>
Date: Thu, 6 Apr 2023 13:41:14 -0500
Subject: [PATCH 08/12] Fixes to accomodate generated ToolkitSampleButtonAction

---
 .../ToolkitSampleGeneratedPaneTests.cs        |  3 +--
 .../GeneratorExtensions.cs                    | 20 +++++++++++++++++--
 .../ToolkitSampleMetadataGenerator.Sample.cs  | 12 ++++++-----
 3 files changed, 26 insertions(+), 9 deletions(-)

diff --git a/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleGeneratedPaneTests.cs b/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleGeneratedPaneTests.cs
index c9a24ca4..c6fcc18e 100644
--- a/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleGeneratedPaneTests.cs
+++ b/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleGeneratedPaneTests.cs
@@ -208,7 +208,6 @@ public class UserControl {{ }}
         result.AssertDiagnosticsAre(DiagnosticDescriptors.SamplePaneOptionWithBadName, DiagnosticDescriptors.SampleNotReferencedInMarkdown);
     }
 
-
     [TestMethod]
     public void PaneOptionWithConflictingPropertyName()
     {
@@ -432,7 +431,7 @@ public static class ToolkitSampleRegistry
         {
             public static System.Collections.Generic.Dictionary<string, CommunityToolkit.Tooling.SampleGen.Metadata.ToolkitSampleMetadata> Listing
             { get; } = new() {
-                ["Sample"] = new CommunityToolkit.Tooling.SampleGen.Metadata.ToolkitSampleMetadata("Sample", "Test Sample", "", typeof(MyApp.Sample), () => new MyApp.Sample(), null, null, new CommunityToolkit.Tooling.SampleGen.Metadata.IGeneratedToolkitSampleOptionViewModel[] { new CommunityToolkit.Tooling.SampleGen.Metadata.ToolkitSampleNumericOptionMetadataViewModel(name: "TextSize", initial: 12, min: 8, max: 48, step: 2, showAsNumberBox: false, title: "FontSize") })
+                ["Sample"] = new CommunityToolkit.Tooling.SampleGen.Metadata.ToolkitSampleMetadata("Sample", "Test Sample", "", typeof(MyApp.Sample), () => new MyApp.Sample(), null, null, new CommunityToolkit.Tooling.SampleGen.Metadata.IGeneratedToolkitSampleOptionViewModel[] { new CommunityToolkit.Tooling.SampleGen.Metadata.ToolkitSampleButtonActionMetadataViewModel(name: "RaiseNotification", label: "Raise notification", title: "") })
             };
         }
         """, "Unexpected code generated");
diff --git a/CommunityToolkit.Tooling.SampleGen/GeneratorExtensions.cs b/CommunityToolkit.Tooling.SampleGen/GeneratorExtensions.cs
index b0e4a028..fbe9b807 100644
--- a/CommunityToolkit.Tooling.SampleGen/GeneratorExtensions.cs
+++ b/CommunityToolkit.Tooling.SampleGen/GeneratorExtensions.cs
@@ -3,6 +3,8 @@
 // See the LICENSE file in the project root for more information.
 
 using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
 
 namespace CommunityToolkit.Tooling.SampleGen;
 
@@ -14,15 +16,29 @@ public static class GeneratorExtensions
     /// <returns>A flattened enumerable of <see cref="INamedTypeSymbol"/>s.</returns>
     public static IEnumerable<ISymbol> CrawlForAllSymbols(this INamespaceSymbol namespaceSymbol)
     {
-        foreach (var member in namespaceSymbol.GetMembers())
+        foreach (var member in namespaceSymbol.GetNamespaceMembers())
         {
             if (member is INamespaceSymbol nestedNamespace)
             {
                 foreach (var item in CrawlForAllSymbols(nestedNamespace))
+                {
                     yield return item;
+                }
             }
+        }
+
+        // Get all classes and methods
+        foreach (var item in namespaceSymbol.GetTypeMembers())
+        {
+            yield return item;
 
-            yield return member;
+            foreach (var itemMember in item.GetMembers())
+            {
+                if (itemMember.Kind == SymbolKind.Method)
+                {
+                    yield return itemMember;
+                }
+            }
         }
     }
 
diff --git a/CommunityToolkit.Tooling.SampleGen/ToolkitSampleMetadataGenerator.Sample.cs b/CommunityToolkit.Tooling.SampleGen/ToolkitSampleMetadataGenerator.Sample.cs
index 3f4dd47c..0f669527 100644
--- a/CommunityToolkit.Tooling.SampleGen/ToolkitSampleMetadataGenerator.Sample.cs
+++ b/CommunityToolkit.Tooling.SampleGen/ToolkitSampleMetadataGenerator.Sample.cs
@@ -29,8 +29,8 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
             .Select(static (x, _) => x!);
 
         var symbolsInReferencedAssemblies = context.CompilationProvider
-                              .SelectMany((x, _) => x.SourceModule.ReferencedAssemblySymbols)
-                              .SelectMany((asm, _) => asm.GlobalNamespace.CrawlForAllSymbols().Where(x => x.Kind is SymbolKind.NamedType or SymbolKind.Method));
+            .SelectMany((x, _) => x.SourceModule.ReferencedAssemblySymbols)
+            .SelectMany((asm, _) => asm.GlobalNamespace.CrawlForAllSymbols());
 
         var markdownFiles = context.AdditionalTextsProvider
             .Where(static file => file.Path.EndsWith(".md"))
@@ -80,7 +80,7 @@ void Execute(IncrementalValuesProvider<ISymbol> types, bool skipDiagnostics = fa
                         // Auto-assign the attached method name as the generated property name.
                         buttonActionAttribute.Name = x.Item1.Name;
 
-                        item = (x.Item1, buttonActionAttribute);
+                        item = (x.Item1.ContainingSymbol, buttonActionAttribute);
                     }
 
                     // Add extra property data, like Title, back to Attribute
@@ -138,7 +138,7 @@ void Execute(IncrementalValuesProvider<ISymbol> types, bool skipDiagnostics = fa
                                 sample.Attribute.Description,
                                 sample.AttachedQualifiedTypeName,
                                 optionsPaneAttribute.FirstOrDefault(x => x.Item1?.SampleId == sample.Attribute.Id).Item2?.ToString(),
-                                generatedOptionPropertyData.Where(x => ReferenceEquals(x.Item1, sample.Symbol)).Select(x => x.Item2)
+                                generatedOptionPropertyData.Where(x => Equals(x.Symbol, sample.Symbol)).Select(x => x.Item2)
                             )
                     );
 
@@ -256,7 +256,9 @@ private static void ReportDiagnosticsGeneratedOptionsPane(SourceProductionContex
             ctx.ReportDiagnostic(Diagnostic.Create(DiagnosticDescriptors.SamplePaneOptionWithDuplicateName, item.SelectMany(x => x.Item1.Locations).FirstOrDefault(), item.Key));
 
         // Check for generated options that conflict with an existing property name
-        var generatedOptionsWithConflictingPropertyNames = generatedOptionPropertyData.Where(x => x.Item1 is INamedTypeSymbol sym && GetAllMembers(sym).Any(y => x.Item2.Name == y.Name));
+        var generatedOptionsWithConflictingPropertyNames = generatedOptionPropertyData
+            .Where(x => x.Item2 is not ToolkitSampleButtonActionAttribute)
+            .Where(x => x.Item1 is INamedTypeSymbol sym && GetAllMembers(sym).Any(y => x.Item2.Name == y.Name));
 
         foreach (var item in generatedOptionsWithConflictingPropertyNames)
             ctx.ReportDiagnostic(Diagnostic.Create(DiagnosticDescriptors.SamplePaneOptionWithConflictingName, item.Item1.Locations.FirstOrDefault(), item.Item2.Name));

From 96a460fded38c9c97e64ea9f11137ba5b44fcce3 Mon Sep 17 00:00:00 2001
From: Arlo Godfrey <arlo.godfrey@outlook.com>
Date: Tue, 11 Apr 2023 15:51:34 -0500
Subject: [PATCH 09/12] Fixed not finding attributes on methods symbols, misc
 cleanup

---
 .../ToolkitSampleGeneratedPaneTests.cs        |  4 ++--
 .../GeneratorExtensions.cs                    | 22 +++++++++----------
 .../Metadata/ToolkitSampleButtonCommand.cs    |  4 ++--
 .../ToolkitSampleMetadataGenerator.Sample.cs  |  8 +++----
 .../ToolkitSampleOptionGenerator.cs           |  2 +-
 5 files changed, 19 insertions(+), 21 deletions(-)

diff --git a/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleGeneratedPaneTests.cs b/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleGeneratedPaneTests.cs
index c6fcc18e..45442eb4 100644
--- a/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleGeneratedPaneTests.cs
+++ b/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleGeneratedPaneTests.cs
@@ -83,7 +83,7 @@ public class UserControl { }
         // Create application head that references generated sample project
         var headCompilation = string.Empty
             .ToSyntaxTree()
-            .CreateCompilation("MyApp.Head", TestHelpers.GetAllReferencedAssemblies())
+            .CreateCompilation("MyApp.Head")
             .AddReferences(sampleProjectAssembly);
 
         // Run source generator
@@ -414,7 +414,7 @@ public class UserControl {{ }}
         // Create application head that references generated sample project
         var headCompilation = string.Empty
             .ToSyntaxTree()
-            .CreateCompilation("MyApp.Head", TestHelpers.GetAllReferencedAssemblies())
+            .CreateCompilation("MyApp.Head")
             .AddReferences(sampleProjectAssembly);
 
         // Run source generator
diff --git a/CommunityToolkit.Tooling.SampleGen/GeneratorExtensions.cs b/CommunityToolkit.Tooling.SampleGen/GeneratorExtensions.cs
index fbe9b807..8f9aafaf 100644
--- a/CommunityToolkit.Tooling.SampleGen/GeneratorExtensions.cs
+++ b/CommunityToolkit.Tooling.SampleGen/GeneratorExtensions.cs
@@ -16,17 +16,6 @@ public static class GeneratorExtensions
     /// <returns>A flattened enumerable of <see cref="INamedTypeSymbol"/>s.</returns>
     public static IEnumerable<ISymbol> CrawlForAllSymbols(this INamespaceSymbol namespaceSymbol)
     {
-        foreach (var member in namespaceSymbol.GetNamespaceMembers())
-        {
-            if (member is INamespaceSymbol nestedNamespace)
-            {
-                foreach (var item in CrawlForAllSymbols(nestedNamespace))
-                {
-                    yield return item;
-                }
-            }
-        }
-
         // Get all classes and methods
         foreach (var item in namespaceSymbol.GetTypeMembers())
         {
@@ -35,8 +24,17 @@ public static IEnumerable<ISymbol> CrawlForAllSymbols(this INamespaceSymbol name
             foreach (var itemMember in item.GetMembers())
             {
                 if (itemMember.Kind == SymbolKind.Method)
-                {
                     yield return itemMember;
+            }
+        }
+
+        foreach (var member in namespaceSymbol.GetNamespaceMembers())
+        {
+            if (member is INamespaceSymbol nestedNamespace)
+            {
+                foreach (var item in CrawlForAllSymbols(nestedNamespace))
+                {
+                    yield return item;
                 }
             }
         }
diff --git a/CommunityToolkit.Tooling.SampleGen/Metadata/ToolkitSampleButtonCommand.cs b/CommunityToolkit.Tooling.SampleGen/Metadata/ToolkitSampleButtonCommand.cs
index 9d5db522..b27f7375 100644
--- a/CommunityToolkit.Tooling.SampleGen/Metadata/ToolkitSampleButtonCommand.cs
+++ b/CommunityToolkit.Tooling.SampleGen/Metadata/ToolkitSampleButtonCommand.cs
@@ -20,11 +20,11 @@ public ToolkitSampleButtonCommand(Action callback)
 
     /// <inheritdoc />
     public event EventHandler? CanExecuteChanged;
-    
+
     /// <inheritdoc />
     public bool CanExecute(object parameter)
     {
-        throw new NotImplementedException();
+        return true;
     }
     /// <inheritdoc />
     public void Execute(object parameter)
diff --git a/CommunityToolkit.Tooling.SampleGen/ToolkitSampleMetadataGenerator.Sample.cs b/CommunityToolkit.Tooling.SampleGen/ToolkitSampleMetadataGenerator.Sample.cs
index 0f669527..d9773284 100644
--- a/CommunityToolkit.Tooling.SampleGen/ToolkitSampleMetadataGenerator.Sample.cs
+++ b/CommunityToolkit.Tooling.SampleGen/ToolkitSampleMetadataGenerator.Sample.cs
@@ -54,7 +54,7 @@ void Execute(IncrementalValuesProvider<ISymbol> types, bool skipDiagnostics = fa
 
             // Find and reconstruct generated pane option attributes + the original type symbol.
             var generatedPaneOptions = allAttributeData
-                .Select(static (x, _) =>
+                .Select((x, _) =>
                 {
                     (ISymbol Symbol, ToolkitSampleOptionBaseAttribute Attribute) item = default;
 
@@ -118,7 +118,7 @@ void Execute(IncrementalValuesProvider<ISymbol> types, bool skipDiagnostics = fa
 
             context.RegisterSourceOutput(all, (ctx, data) =>
             {
-                var toolkitSampleAttributeData = data.Left.Left.Left.Right.Where(x => x != default).Distinct();
+                var toolkitSampleAttributeData = data.Left.Left.Left.Right.Where(x => x != default).Distinct().ToArray();
                 var optionsPaneAttribute = data.Left.Left.Left.Left.Where(x => x != default).Distinct();
                 var generatedOptionPropertyData = data.Left.Left.Right.Where(x => x.Attribute is not null && x.Symbol is not null);
                 var markdownFileData = data.Left.Right.Where(x => x != default).Distinct();
@@ -138,7 +138,7 @@ void Execute(IncrementalValuesProvider<ISymbol> types, bool skipDiagnostics = fa
                                 sample.Attribute.Description,
                                 sample.AttachedQualifiedTypeName,
                                 optionsPaneAttribute.FirstOrDefault(x => x.Item1?.SampleId == sample.Attribute.Id).Item2?.ToString(),
-                                generatedOptionPropertyData.Where(x => Equals(x.Symbol, sample.Symbol)).Select(x => x.Item2)
+                                generatedOptionPropertyData.Where(x => x.Symbol.Equals(sample.Symbol, SymbolEqualityComparer.Default)).Select(x => x.Item2)
                             )
                     );
 
@@ -315,7 +315,7 @@ private static IEnumerable<string> BuildNewGeneratedSampleOptionMetadataSource(T
             }
             else if (item is ToolkitSampleButtonActionAttribute buttonAttribute)
             {
-                yield return $@"new {typeof(ToolkitSampleButtonActionMetadataViewModel).FullName}(name: ""{buttonAttribute.Name}"", label: ""{buttonAttribute.Label}"", title: ""{buttonAttribute.Title}"")";
+                yield return $@"new {typeof(ToolkitSampleButtonActionMetadataViewModel).FullName}(name: ""{buttonAttribute.Name}"", controlToBindingValueFactory: x => x.{buttonAttribute.Name}Command, label: ""{buttonAttribute.Label}"", title: ""{buttonAttribute.Title}"")";
             }
             else if (item is ToolkitSampleNumericOptionAttribute numericAttribute)
             {
diff --git a/CommunityToolkit.Tooling.SampleGen/ToolkitSampleOptionGenerator.cs b/CommunityToolkit.Tooling.SampleGen/ToolkitSampleOptionGenerator.cs
index f48308f1..ffd20604 100644
--- a/CommunityToolkit.Tooling.SampleGen/ToolkitSampleOptionGenerator.cs
+++ b/CommunityToolkit.Tooling.SampleGen/ToolkitSampleOptionGenerator.cs
@@ -206,7 +206,7 @@ public partial class {{attachedMethodSymbol.ContainingSymbol.Name}}
             get
             {
                 var metadata = GeneratedPropertyMetadata!.First(x => x.Name == nameof({{attachedMethodSymbol.Name}}));
-                return ({{typeof(System.Windows.Input.ICommand).FullName}})(metadata.Value ??= new {{typeof(ToolkitSampleButtonCommand).FullName}}({{attachedMethodSymbol.Name}}));
+                return ({{typeof(System.Windows.Input.ICommand).FullName}})(metadata.Value ??= new {{typeof(ToolkitSampleButtonCommand).FullName}}(() => {{attachedMethodSymbol.Name}}()));
             }
             set
             {

From f8c94e3411459bce43aaac8c7ca3ad6182564ca1 Mon Sep 17 00:00:00 2001
From: Arlo Godfrey <arlo.godfrey@outlook.com>
Date: Tue, 11 Apr 2023 16:15:57 -0500
Subject: [PATCH 10/12] Minor cleanup

---
 .../ToolkitSampleMetadataGenerator.Sample.cs                    | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CommunityToolkit.Tooling.SampleGen/ToolkitSampleMetadataGenerator.Sample.cs b/CommunityToolkit.Tooling.SampleGen/ToolkitSampleMetadataGenerator.Sample.cs
index d9773284..4d73e1a5 100644
--- a/CommunityToolkit.Tooling.SampleGen/ToolkitSampleMetadataGenerator.Sample.cs
+++ b/CommunityToolkit.Tooling.SampleGen/ToolkitSampleMetadataGenerator.Sample.cs
@@ -118,7 +118,7 @@ void Execute(IncrementalValuesProvider<ISymbol> types, bool skipDiagnostics = fa
 
             context.RegisterSourceOutput(all, (ctx, data) =>
             {
-                var toolkitSampleAttributeData = data.Left.Left.Left.Right.Where(x => x != default).Distinct().ToArray();
+                var toolkitSampleAttributeData = data.Left.Left.Left.Right.Where(x => x != default).Distinct();
                 var optionsPaneAttribute = data.Left.Left.Left.Left.Where(x => x != default).Distinct();
                 var generatedOptionPropertyData = data.Left.Left.Right.Where(x => x.Attribute is not null && x.Symbol is not null);
                 var markdownFileData = data.Left.Right.Where(x => x != default).Distinct();

From d0637154e5eddaa0d8e9fea895b3828b5e29f059 Mon Sep 17 00:00:00 2001
From: Arlo Godfrey <arlo.godfrey@outlook.com>
Date: Thu, 15 Jun 2023 12:49:04 -0500
Subject: [PATCH 11/12] Checkpoint commit

---
 .../Helpers/SourceGeneratorRunResult.cs                     | 1 +
 .../Helpers/TestHelpers.Compilation.cs                      | 1 +
 .../Helpers/TestHelpers.cs                                  | 1 +
 .../ToolkitSampleGeneratedPaneTests.cs                      | 2 +-
 .../Metadata/ToolkitSampleButtonActionMetadataViewModel.cs  | 6 +++---
 .../ToolkitSampleMetadataGenerator.Sample.cs                | 3 +--
 6 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/CommunityToolkit.Tooling.SampleGen.Tests/Helpers/SourceGeneratorRunResult.cs b/CommunityToolkit.Tooling.SampleGen.Tests/Helpers/SourceGeneratorRunResult.cs
index ff38f74b..37ac706d 100644
--- a/CommunityToolkit.Tooling.SampleGen.Tests/Helpers/SourceGeneratorRunResult.cs
+++ b/CommunityToolkit.Tooling.SampleGen.Tests/Helpers/SourceGeneratorRunResult.cs
@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using Microsoft.CodeAnalysis;
+using System.Collections.Immutable;
 
 namespace CommunityToolkit.Tooling.SampleGen.Tests.Helpers;
 
diff --git a/CommunityToolkit.Tooling.SampleGen.Tests/Helpers/TestHelpers.Compilation.cs b/CommunityToolkit.Tooling.SampleGen.Tests/Helpers/TestHelpers.Compilation.cs
index 85dd48ad..5d309c28 100644
--- a/CommunityToolkit.Tooling.SampleGen.Tests/Helpers/TestHelpers.Compilation.cs
+++ b/CommunityToolkit.Tooling.SampleGen.Tests/Helpers/TestHelpers.Compilation.cs
@@ -4,6 +4,7 @@
 
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
+using System.Collections.Immutable;
 
 namespace CommunityToolkit.Tooling.SampleGen.Tests.Helpers;
 
diff --git a/CommunityToolkit.Tooling.SampleGen.Tests/Helpers/TestHelpers.cs b/CommunityToolkit.Tooling.SampleGen.Tests/Helpers/TestHelpers.cs
index 64e8a3f6..c94da675 100644
--- a/CommunityToolkit.Tooling.SampleGen.Tests/Helpers/TestHelpers.cs
+++ b/CommunityToolkit.Tooling.SampleGen.Tests/Helpers/TestHelpers.cs
@@ -1,5 +1,6 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System.Collections.Immutable;
 
 namespace CommunityToolkit.Tooling.SampleGen.Tests.Helpers;
 
diff --git a/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleGeneratedPaneTests.cs b/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleGeneratedPaneTests.cs
index 45442eb4..ca130171 100644
--- a/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleGeneratedPaneTests.cs
+++ b/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleGeneratedPaneTests.cs
@@ -414,7 +414,7 @@ public class UserControl {{ }}
         // Create application head that references generated sample project
         var headCompilation = string.Empty
             .ToSyntaxTree()
-            .CreateCompilation("MyApp.Head")
+            .CreateCompilation("CommunityToolkit.App.Head")
             .AddReferences(sampleProjectAssembly);
 
         // Run source generator
diff --git a/CommunityToolkit.Tooling.SampleGen/Metadata/ToolkitSampleButtonActionMetadataViewModel.cs b/CommunityToolkit.Tooling.SampleGen/Metadata/ToolkitSampleButtonActionMetadataViewModel.cs
index a37813c8..529d966b 100644
--- a/CommunityToolkit.Tooling.SampleGen/Metadata/ToolkitSampleButtonActionMetadataViewModel.cs
+++ b/CommunityToolkit.Tooling.SampleGen/Metadata/ToolkitSampleButtonActionMetadataViewModel.cs
@@ -43,7 +43,7 @@ public ToolkitSampleButtonActionMetadataViewModel(string name, string label, str
     public string Name { get; }
 
     /// <summary>
-    /// The current boolean value.
+    /// The current command value.
     /// </summary>
     /// <remarks>
     /// Provided to accomodate binding to a property that is a non-nullable <see cref="bool"/>.
@@ -60,12 +60,12 @@ public ICommand CommandValue
     }
 
     /// <summary>
-    /// The current boolean value.
+    /// The current value.
     /// </summary>
     public object? Value
     {
         get => _value;
-        set 
+        set
         {
             _value = value;
             PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Value)));
diff --git a/CommunityToolkit.Tooling.SampleGen/ToolkitSampleMetadataGenerator.Sample.cs b/CommunityToolkit.Tooling.SampleGen/ToolkitSampleMetadataGenerator.Sample.cs
index 4d73e1a5..5c64fe4a 100644
--- a/CommunityToolkit.Tooling.SampleGen/ToolkitSampleMetadataGenerator.Sample.cs
+++ b/CommunityToolkit.Tooling.SampleGen/ToolkitSampleMetadataGenerator.Sample.cs
@@ -8,7 +8,6 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Microsoft.CodeAnalysis.Text;
 
 namespace CommunityToolkit.Tooling.SampleGen;
 
@@ -315,7 +314,7 @@ private static IEnumerable<string> BuildNewGeneratedSampleOptionMetadataSource(T
             }
             else if (item is ToolkitSampleButtonActionAttribute buttonAttribute)
             {
-                yield return $@"new {typeof(ToolkitSampleButtonActionMetadataViewModel).FullName}(name: ""{buttonAttribute.Name}"", controlToBindingValueFactory: x => x.{buttonAttribute.Name}Command, label: ""{buttonAttribute.Label}"", title: ""{buttonAttribute.Title}"")";
+                yield return $@"new {typeof(ToolkitSampleButtonActionMetadataViewModel).FullName}(name: ""{buttonAttribute.Name}"", label: ""{buttonAttribute.Label}"", title: ""{buttonAttribute.Title}"")";
             }
             else if (item is ToolkitSampleNumericOptionAttribute numericAttribute)
             {

From 102f46a20a5f58639357a6a4fdffc9669088a3e1 Mon Sep 17 00:00:00 2001
From: Arlo Godfrey <arlo.godfrey@outlook.com>
Date: Thu, 15 Jun 2023 14:55:56 -0500
Subject: [PATCH 12/12] Removed generated ButtonAction sample pane option

---
 .../GeneratedSampleOptionTemplateSelector.cs  |   3 -
 .../GeneratedSampleOptionsRenderer.xaml       |  78 +++++++-------
 .../ToolkitSampleGeneratedPaneTests.cs        |  54 ----------
 .../ToolkitSampleButtonActionAttribute.cs     |  33 ------
 ...lkitSampleButtonActionMetadataViewModel.cs | 101 ------------------
 .../ToolkitSampleMetadataGenerator.Sample.cs  |  15 +--
 .../ToolkitSampleOptionGenerator.cs           |  40 -------
 7 files changed, 37 insertions(+), 287 deletions(-)
 delete mode 100644 CommunityToolkit.Tooling.SampleGen/Attributes/ToolkitSampleButtonActionAttribute.cs
 delete mode 100644 CommunityToolkit.Tooling.SampleGen/Metadata/ToolkitSampleButtonActionMetadataViewModel.cs

diff --git a/CommunityToolkit.App.Shared/Renderers/GeneratedSampleOptionTemplateSelector.cs b/CommunityToolkit.App.Shared/Renderers/GeneratedSampleOptionTemplateSelector.cs
index f9652f52..7c55f1ba 100644
--- a/CommunityToolkit.App.Shared/Renderers/GeneratedSampleOptionTemplateSelector.cs
+++ b/CommunityToolkit.App.Shared/Renderers/GeneratedSampleOptionTemplateSelector.cs
@@ -13,8 +13,6 @@ internal class GeneratedSampleOptionTemplateSelector : DataTemplateSelector
 {
     public DataTemplate? BoolOptionTemplate { get; set; }
 
-    public DataTemplate? ButtonActionTemplate { get; set; }
-
     public DataTemplate? MultiChoiceOptionTemplate { get; set; }
 
     public DataTemplate? SliderOptionTemplate { get; set; }
@@ -28,7 +26,6 @@ protected override DataTemplate SelectTemplateCore(object item, DependencyObject
         return item switch
         {
             ToolkitSampleBoolOptionMetadataViewModel => BoolOptionTemplate ?? base.SelectTemplateCore(item, container),
-            ToolkitSampleButtonActionMetadataViewModel => ButtonActionTemplate ?? base.SelectTemplateCore(item, container),
             ToolkitSampleMultiChoiceOptionMetadataViewModel => MultiChoiceOptionTemplate ?? base.SelectTemplateCore(item, container),
             ToolkitSampleNumericOptionMetadataViewModel { ShowAsNumberBox: true } => NumberBoxOptionTemplate ?? base.SelectTemplateCore(item, container),
             ToolkitSampleNumericOptionMetadataViewModel { ShowAsNumberBox: false } => SliderOptionTemplate ?? base.SelectTemplateCore(item, container),
diff --git a/CommunityToolkit.App.Shared/Renderers/GeneratedSampleOptionsRenderer.xaml b/CommunityToolkit.App.Shared/Renderers/GeneratedSampleOptionsRenderer.xaml
index 3c92242e..f6618a85 100644
--- a/CommunityToolkit.App.Shared/Renderers/GeneratedSampleOptionsRenderer.xaml
+++ b/CommunityToolkit.App.Shared/Renderers/GeneratedSampleOptionsRenderer.xaml
@@ -12,64 +12,58 @@
              d:DesignWidth="400"
              mc:Ignorable="d">
 
-	<UserControl.Resources>
-		<local:GeneratedSampleOptionTemplateSelector x:Key="GeneratedSampleOptionTemplateSelector">
-			<local:GeneratedSampleOptionTemplateSelector.BoolOptionTemplate>
-				<DataTemplate x:DataType="metadata:ToolkitSampleBoolOptionMetadataViewModel">
-					<ToggleSwitch Header="{x:Bind Title, Mode=OneWay}"
+    <UserControl.Resources>
+        <local:GeneratedSampleOptionTemplateSelector x:Key="GeneratedSampleOptionTemplateSelector">
+            <local:GeneratedSampleOptionTemplateSelector.BoolOptionTemplate>
+                <DataTemplate x:DataType="metadata:ToolkitSampleBoolOptionMetadataViewModel">
+                    <ToggleSwitch Header="{x:Bind Title, Mode=OneWay}"
 					              IsOn="{x:Bind BoolValue, Mode=TwoWay}" />
-				</DataTemplate>
-			</local:GeneratedSampleOptionTemplateSelector.BoolOptionTemplate>
-			<local:GeneratedSampleOptionTemplateSelector.ButtonActionTemplate>
-				<DataTemplate x:DataType="metadata:ToolkitSampleButtonActionMetadataViewModel">
-					<Button Command="{x:Bind CommandValue, Mode=TwoWay}"
-					        Content="{x:Bind Label, Mode=OneWay}" />
-				</DataTemplate>
-			</local:GeneratedSampleOptionTemplateSelector.ButtonActionTemplate>
-			<local:GeneratedSampleOptionTemplateSelector.MultiChoiceOptionTemplate>
-				<DataTemplate x:DataType="metadata:ToolkitSampleMultiChoiceOptionMetadataViewModel">
-					<ComboBox Header="{x:Bind Title, Mode=OneWay}"
+                </DataTemplate>
+            </local:GeneratedSampleOptionTemplateSelector.BoolOptionTemplate>
+            <local:GeneratedSampleOptionTemplateSelector.MultiChoiceOptionTemplate>
+                <DataTemplate x:DataType="metadata:ToolkitSampleMultiChoiceOptionMetadataViewModel">
+                    <ComboBox Header="{x:Bind Title, Mode=OneWay}"
 					          ItemsSource="{x:Bind Options}"
 					          SelectedIndex="0"
 					          SelectedItem="{x:Bind Value, Mode=TwoWay}" />
-				</DataTemplate>
-			</local:GeneratedSampleOptionTemplateSelector.MultiChoiceOptionTemplate>
-			<local:GeneratedSampleOptionTemplateSelector.SliderOptionTemplate>
-				<DataTemplate x:DataType="metadata:ToolkitSampleNumericOptionMetadataViewModel">
-					<Slider Header="{x:Bind Title, Mode=OneWay}"
+                </DataTemplate>
+            </local:GeneratedSampleOptionTemplateSelector.MultiChoiceOptionTemplate>
+            <local:GeneratedSampleOptionTemplateSelector.SliderOptionTemplate>
+                <DataTemplate x:DataType="metadata:ToolkitSampleNumericOptionMetadataViewModel">
+                    <Slider Header="{x:Bind Title, Mode=OneWay}"
 					        Maximum="{x:Bind Max, Mode=OneWay}"
 					        Minimum="{x:Bind Min, Mode=OneWay}"
 					        StepFrequency="{x:Bind Step, Mode=OneWay}"
 					        Value="{x:Bind Initial, Mode=TwoWay}" />
-				</DataTemplate>
-			</local:GeneratedSampleOptionTemplateSelector.SliderOptionTemplate>
-			<local:GeneratedSampleOptionTemplateSelector.NumberBoxOptionTemplate>
-				<DataTemplate x:DataType="metadata:ToolkitSampleNumericOptionMetadataViewModel">
-					<muxc:NumberBox Header="{x:Bind Title, Mode=OneWay}"
+                </DataTemplate>
+            </local:GeneratedSampleOptionTemplateSelector.SliderOptionTemplate>
+            <local:GeneratedSampleOptionTemplateSelector.NumberBoxOptionTemplate>
+                <DataTemplate x:DataType="metadata:ToolkitSampleNumericOptionMetadataViewModel">
+                    <muxc:NumberBox Header="{x:Bind Title, Mode=OneWay}"
 					                Maximum="{x:Bind Max, Mode=OneWay}"
 					                Minimum="{x:Bind Min, Mode=OneWay}"
 					                SmallChange="{x:Bind Step, Mode=OneWay}"
 					                SpinButtonPlacementMode="Compact"
 					                Value="{x:Bind Initial, Mode=TwoWay}" />
-				</DataTemplate>
-			</local:GeneratedSampleOptionTemplateSelector.NumberBoxOptionTemplate>
-			<local:GeneratedSampleOptionTemplateSelector.TextOptionTemplate>
-				<DataTemplate x:DataType="metadata:ToolkitSampleTextOptionMetadataViewModel">
-					<TextBox HorizontalAlignment="Stretch"
+                </DataTemplate>
+            </local:GeneratedSampleOptionTemplateSelector.NumberBoxOptionTemplate>
+            <local:GeneratedSampleOptionTemplateSelector.TextOptionTemplate>
+                <DataTemplate x:DataType="metadata:ToolkitSampleTextOptionMetadataViewModel">
+                    <TextBox HorizontalAlignment="Stretch"
 					         Header="{x:Bind Title, Mode=OneWay}"
 					         Text="{x:Bind PlaceholderText, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" />
-				</DataTemplate>
-			</local:GeneratedSampleOptionTemplateSelector.TextOptionTemplate>
-		</local:GeneratedSampleOptionTemplateSelector>
-	</UserControl.Resources>
+                </DataTemplate>
+            </local:GeneratedSampleOptionTemplateSelector.TextOptionTemplate>
+        </local:GeneratedSampleOptionTemplateSelector>
+    </UserControl.Resources>
 
-	<ItemsControl ItemTemplateSelector="{StaticResource GeneratedSampleOptionTemplateSelector}"
+    <ItemsControl ItemTemplateSelector="{StaticResource GeneratedSampleOptionTemplateSelector}"
 	              ItemsSource="{x:Bind SampleOptions, Mode=OneWay}">
-		<ItemsControl.ItemsPanel>
-			<ItemsPanelTemplate>
-				<StackPanel Orientation="Vertical"
+        <ItemsControl.ItemsPanel>
+            <ItemsPanelTemplate>
+                <StackPanel Orientation="Vertical"
 				            Spacing="12" />
-			</ItemsPanelTemplate>
-		</ItemsControl.ItemsPanel>
-	</ItemsControl>
+            </ItemsPanelTemplate>
+        </ItemsControl.ItemsPanel>
+    </ItemsControl>
 </UserControl>
diff --git a/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleGeneratedPaneTests.cs b/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleGeneratedPaneTests.cs
index ca130171..17d5e8ee 100644
--- a/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleGeneratedPaneTests.cs
+++ b/CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleGeneratedPaneTests.cs
@@ -382,58 +382,4 @@ public class UserControl {{ }}
 
         result.AssertDiagnosticsAre(DiagnosticDescriptors.SamplePaneMultiChoiceOptionWithNoChoices, DiagnosticDescriptors.SampleNotReferencedInMarkdown);
     }
-
-    [TestMethod]
-    public void GeneratedPaneOption_ButtonAction()
-    {
-        var sampleProjectAssembly = $@"
-            using System.ComponentModel;
-            using CommunityToolkit.Tooling.SampleGen;
-            using CommunityToolkit.Tooling.SampleGen.Attributes;
-
-            namespace MyApp
-            {{
-                [ToolkitSample(id: nameof(Sample), ""Test Sample"", description: """")]
-                public partial class Sample : Windows.UI.Xaml.Controls.UserControl
-                {{
-                    [ToolkitSampleButtonAction(label: ""Raise notification"")]
-                    private void RaiseNotification()
-                    {{
-                    }}
-                }}
-            }}
-
-            namespace Windows.UI.Xaml.Controls
-            {{
-                public class UserControl {{ }}
-            }}"
-            .ToSyntaxTree()
-            .CreateCompilation("MyApp.Samples")
-            .ToMetadataReference();
-
-        // Create application head that references generated sample project
-        var headCompilation = string.Empty
-            .ToSyntaxTree()
-            .CreateCompilation("CommunityToolkit.App.Head")
-            .AddReferences(sampleProjectAssembly);
-
-        // Run source generator
-        var result = headCompilation.RunSourceGenerator<ToolkitSampleMetadataGenerator>();
-
-        result.AssertDiagnosticsAre();
-        result.AssertNoCompilationErrors();
-
-        Assert.AreEqual(result.Compilation.GetFileContentsByName("ToolkitSampleRegistry.g.cs"), """
-        #nullable enable
-        namespace CommunityToolkit.Tooling.SampleGen;
-
-        public static class ToolkitSampleRegistry
-        {
-            public static System.Collections.Generic.Dictionary<string, CommunityToolkit.Tooling.SampleGen.Metadata.ToolkitSampleMetadata> Listing
-            { get; } = new() {
-                ["Sample"] = new CommunityToolkit.Tooling.SampleGen.Metadata.ToolkitSampleMetadata("Sample", "Test Sample", "", typeof(MyApp.Sample), () => new MyApp.Sample(), null, null, new CommunityToolkit.Tooling.SampleGen.Metadata.IGeneratedToolkitSampleOptionViewModel[] { new CommunityToolkit.Tooling.SampleGen.Metadata.ToolkitSampleButtonActionMetadataViewModel(name: "RaiseNotification", label: "Raise notification", title: "") })
-            };
-        }
-        """, "Unexpected code generated");
-    }
 }
diff --git a/CommunityToolkit.Tooling.SampleGen/Attributes/ToolkitSampleButtonActionAttribute.cs b/CommunityToolkit.Tooling.SampleGen/Attributes/ToolkitSampleButtonActionAttribute.cs
deleted file mode 100644
index 8023e93e..00000000
--- a/CommunityToolkit.Tooling.SampleGen/Attributes/ToolkitSampleButtonActionAttribute.cs
+++ /dev/null
@@ -1,33 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-namespace CommunityToolkit.Tooling.SampleGen.Attributes;
-
-/// <summary>
-/// Generates a command that invokes the decorated method, and a button in the sample option panel that invokes the command when clicked.
-/// </summary>
-/// <remarks>
-/// Using this attribute will automatically generate an <see cref="INotifyPropertyChanged"/>-enabled property
-/// that you can bind to in XAML, and displays an options pane alonside your sample which allows the user to manipulate the property.
-/// </remarks>
-[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
-public sealed class ToolkitSampleButtonActionAttribute : ToolkitSampleOptionBaseAttribute
-{
-    /// <summary>
-    /// Creates a new instance of <see cref="ToolkitSampleButtonActionAttribute"/>.
-    /// </summary>
-    /// <param name="label">The text displayed inside the button.</param>
-    public ToolkitSampleButtonActionAttribute(string label)
-        : base(string.Empty, null)
-    {
-        Label = label;
-    }
-
-    public string Label { get; }
-
-    /// <summary>
-    /// The source generator-friendly type name used for casting.
-    /// </summary>
-    internal override string TypeName { get; } = "System.Windows.Input.ICommand";
-}
diff --git a/CommunityToolkit.Tooling.SampleGen/Metadata/ToolkitSampleButtonActionMetadataViewModel.cs b/CommunityToolkit.Tooling.SampleGen/Metadata/ToolkitSampleButtonActionMetadataViewModel.cs
deleted file mode 100644
index 529d966b..00000000
--- a/CommunityToolkit.Tooling.SampleGen/Metadata/ToolkitSampleButtonActionMetadataViewModel.cs
+++ /dev/null
@@ -1,101 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-using CommunityToolkit.Tooling.SampleGen.Attributes;
-using System.Windows.Input;
-
-namespace CommunityToolkit.Tooling.SampleGen.Metadata;
-
-/// <summary>
-/// An INPC-enabled metadata container for data defined in an <see cref="ToolkitSampleButtonActionAttribute"/>.
-/// </summary>
-/// <remarks>
-/// Instances of these are generated by the <see cref="ToolkitSampleMetadataGenerator"/> and
-/// provided to the app alongside the sample registration.
-/// </remarks>
-public class ToolkitSampleButtonActionMetadataViewModel : IGeneratedToolkitSampleOptionViewModel
-{
-    private string? _title;
-    private object? _value;
-    private string _label;
-
-    /// <summary>
-    /// Creates a new instance of <see cref="ToolkitSampleButtonActionMetadataViewModel"/>.
-    /// </summary>
-    public ToolkitSampleButtonActionMetadataViewModel(string name, string label, string? title = null)
-    {
-        Name = name;
-
-        _label = label;
-        _title = title;
-    }
-
-    /// <inheritdoc cref="INotifyPropertyChanged.PropertyChanged"/>
-    public event PropertyChangedEventHandler? PropertyChanged;
-
-    /// <summary>
-    /// A unique identifier for this option.
-    /// </summary>
-    /// <remarks>
-    /// Used by the sample system to match up <see cref="ToolkitSampleButtonActionMetadataViewModel"/> to the original <see cref="ToolkitSampleButtonActionAttribute"/> and the control that declared it.
-    /// </remarks>
-    public string Name { get; }
-
-    /// <summary>
-    /// The current command value.
-    /// </summary>
-    /// <remarks>
-    /// Provided to accomodate binding to a property that is a non-nullable <see cref="bool"/>.
-    /// </remarks>
-    public ICommand CommandValue
-    {
-        get => (ICommand)_value!;
-        set
-        {
-            _value = value;
-            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Value)));
-            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(CommandValue)));
-        }
-    }
-
-    /// <summary>
-    /// The current value.
-    /// </summary>
-    public object? Value
-    {
-        get => _value;
-        set
-        {
-            _value = value;
-            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Value)));
-            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(CommandValue)));
-        }
-    }
-
-    /// <summary>
-    /// The label to display inside the button.
-    /// </summary>
-    public string Label
-    {
-        get => _label;
-        set
-        {
-            _label = value;
-            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Label)));
-        }
-    }
-
-    /// <summary>
-    /// A title to display on top of the button.
-    /// </summary>
-    public string? Title
-    {
-        get => _title;
-        set
-        {
-            _title = value;
-            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Title)));
-        }
-    }
-}
diff --git a/CommunityToolkit.Tooling.SampleGen/ToolkitSampleMetadataGenerator.Sample.cs b/CommunityToolkit.Tooling.SampleGen/ToolkitSampleMetadataGenerator.Sample.cs
index 5c64fe4a..0d37a907 100644
--- a/CommunityToolkit.Tooling.SampleGen/ToolkitSampleMetadataGenerator.Sample.cs
+++ b/CommunityToolkit.Tooling.SampleGen/ToolkitSampleMetadataGenerator.Sample.cs
@@ -74,13 +74,6 @@ void Execute(IncrementalValuesProvider<ISymbol> types, bool skipDiagnostics = fa
                     {
                         item = (x.Item1, textOptionAttribute);
                     }
-                    else if (x.Item2.TryReconstructAs<ToolkitSampleButtonActionAttribute>() is ToolkitSampleButtonActionAttribute buttonActionAttribute)
-                    {
-                        // Auto-assign the attached method name as the generated property name.
-                        buttonActionAttribute.Name = x.Item1.Name;
-
-                        item = (x.Item1.ContainingSymbol, buttonActionAttribute);
-                    }
 
                     // Add extra property data, like Title, back to Attribute
                     if (item.Attribute is not null && x.Item2.TryGetNamedArgument(nameof(ToolkitSampleOptionBaseAttribute.Title), out string? title) && !string.IsNullOrWhiteSpace(title))
@@ -255,9 +248,7 @@ private static void ReportDiagnosticsGeneratedOptionsPane(SourceProductionContex
             ctx.ReportDiagnostic(Diagnostic.Create(DiagnosticDescriptors.SamplePaneOptionWithDuplicateName, item.SelectMany(x => x.Item1.Locations).FirstOrDefault(), item.Key));
 
         // Check for generated options that conflict with an existing property name
-        var generatedOptionsWithConflictingPropertyNames = generatedOptionPropertyData
-            .Where(x => x.Item2 is not ToolkitSampleButtonActionAttribute)
-            .Where(x => x.Item1 is INamedTypeSymbol sym && GetAllMembers(sym).Any(y => x.Item2.Name == y.Name));
+        var generatedOptionsWithConflictingPropertyNames = generatedOptionPropertyData.Where(x => x.Item1 is INamedTypeSymbol sym && GetAllMembers(sym).Any(y => x.Item2.Name == y.Name));
 
         foreach (var item in generatedOptionsWithConflictingPropertyNames)
             ctx.ReportDiagnostic(Diagnostic.Create(DiagnosticDescriptors.SamplePaneOptionWithConflictingName, item.Item1.Locations.FirstOrDefault(), item.Item2.Name));
@@ -312,10 +303,6 @@ private static IEnumerable<string> BuildNewGeneratedSampleOptionMetadataSource(T
             {
                 yield return $@"new {typeof(ToolkitSampleBoolOptionMetadataViewModel).FullName}(name: ""{boolAttribute.Name}"", defaultState: {boolAttribute.DefaultState?.ToString().ToLower()}, title: ""{boolAttribute.Title}"")";
             }
-            else if (item is ToolkitSampleButtonActionAttribute buttonAttribute)
-            {
-                yield return $@"new {typeof(ToolkitSampleButtonActionMetadataViewModel).FullName}(name: ""{buttonAttribute.Name}"", label: ""{buttonAttribute.Label}"", title: ""{buttonAttribute.Title}"")";
-            }
             else if (item is ToolkitSampleNumericOptionAttribute numericAttribute)
             {
                 yield return $@"new {typeof(ToolkitSampleNumericOptionMetadataViewModel).FullName}(name: ""{numericAttribute.Name}"", initial: {numericAttribute.Initial}, min: {numericAttribute.Min}, max: {numericAttribute.Max}, step: {numericAttribute.Step}, showAsNumberBox: {numericAttribute.ShowAsNumberBox.ToString().ToLower()}, title: ""{numericAttribute.Title}"")";
diff --git a/CommunityToolkit.Tooling.SampleGen/ToolkitSampleOptionGenerator.cs b/CommunityToolkit.Tooling.SampleGen/ToolkitSampleOptionGenerator.cs
index ffd20604..d487eb25 100644
--- a/CommunityToolkit.Tooling.SampleGen/ToolkitSampleOptionGenerator.cs
+++ b/CommunityToolkit.Tooling.SampleGen/ToolkitSampleOptionGenerator.cs
@@ -38,9 +38,6 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
                 if (x.Item2.TryReconstructAs<ToolkitSampleBoolOptionAttribute>() is ToolkitSampleBoolOptionAttribute boolOptionAttribute)
                     return (Attribute: (ToolkitSampleOptionBaseAttribute)boolOptionAttribute, AttachedSymbol: x.Item1, Type: typeof(ToolkitSampleBoolOptionMetadataViewModel));
 
-                if (x.Item2.TryReconstructAs<ToolkitSampleButtonActionAttribute>() is ToolkitSampleButtonActionAttribute buttonActionAttribute)
-                    return (Attribute: (ToolkitSampleOptionBaseAttribute)buttonActionAttribute, AttachedSymbol: x.Item1, Type: typeof(ToolkitSampleButtonActionMetadataViewModel));
-
                 if (x.Item2.TryReconstructAs<ToolkitSampleMultiChoiceOptionAttribute>() is ToolkitSampleMultiChoiceOptionAttribute multiChoiceOptionAttribute)
                     return (Attribute: (ToolkitSampleOptionBaseAttribute)multiChoiceOptionAttribute, AttachedSymbol: x.Item1, Type: typeof(ToolkitSampleMultiChoiceOptionMetadataViewModel));
 
@@ -94,7 +91,6 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
             {
                 var dependencyPropertySource = data.AttachedSymbol.Kind switch
                 {
-                    SymbolKind.Method => BuildCommandProperty(attachedMethodSymbol: data.AttachedSymbol, data.Type),
                     SymbolKind.NamedType => BuildProperty(containingClassSymbol: data.AttachedSymbol, data.Attribute.Name, data.Attribute.TypeName, data.Type),
                     _ => throw new NotSupportedException("Only methods and classes are supported here."),
                 };
@@ -185,40 +181,4 @@ public partial class {containingClassSymbol.Name}
 }}
 ";
     }
-
-    private static string BuildCommandProperty(ISymbol attachedMethodSymbol, Type viewModelType)
-    {
-        // User-supplied command methods are instance methods, and must be called from the same containing object instance.
-        // To generate a command property that points to this, we lazy-set the default command value in
-        // the getter and pass the instance method in as the command delegate.
-
-        return $$"""
-#nullable enable
-using System.ComponentModel;
-using System.Linq;
-
-namespace {{attachedMethodSymbol.ContainingNamespace}}
-{
-    public partial class {{attachedMethodSymbol.ContainingSymbol.Name}}
-    {
-        public {{typeof(System.Windows.Input.ICommand).FullName}} {{attachedMethodSymbol.Name}}Command
-        {
-            get
-            {
-                var metadata = GeneratedPropertyMetadata!.First(x => x.Name == nameof({{attachedMethodSymbol.Name}}));
-                return ({{typeof(System.Windows.Input.ICommand).FullName}})(metadata.Value ??= new {{typeof(ToolkitSampleButtonCommand).FullName}}(() => {{attachedMethodSymbol.Name}}()));
-            }
-            set
-            {
-				if (GeneratedPropertyMetadata?.FirstOrDefault(x => x.Name == nameof({{attachedMethodSymbol.Name}})) is {{viewModelType.FullName}} metadata)
-				{
-                    metadata.Value = (object)value;
-					PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof({{attachedMethodSymbol.Name}}Command)));
-				}
-            }
-        }
-    }
-}
-""";
-    }
 }