fix only first assembly being used to generate code

src/Vetuviem.IntegrationTests/ReactiveUI/WPF/MahAppsMetroViewBindingModelGeneratorTests.cs

@@ -0,0 +1,87 @@
+// Copyright (c) 2022 DPVreony and Contributors. All rights reserved.
+// DPVreony and Contributors licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Vetuviem.SourceGenerator.Features.ControlBindingModels;
+using Vetuviem.Testing;
+using Vetuviem.WPF.SourceGenerator;
+using Xunit.Abstractions;
+
+namespace Vetuviem.IntegrationTests.ReactiveUI.WPF
+{
+    /// <summary>
+    /// Unit Tests for the ViewBinding Model Source Generator for MahApps Metro.
+    /// </summary>
+    public static class MahAppsMetroViewBindingModelGeneratorTests
+    {
+        /// <inheritdoc />
+        public sealed class ExecuteMethod : BaseGeneratorTests.BaseExecuteMethod<WpfControlBindingModelSourceGenerator, ControlBindingModelGeneratorProcessor>
+        {
+            /// <summary>
+            /// Initializes a new instance of the <see cref="ExecuteMethod"/> class.
+            /// </summary>
+            /// <param name="output">Test Output Helper.</param>
+            public ExecuteMethod(ITestOutputHelper output)
+                : base(output)
+            {
+            }
+
+            /// <inheritdoc />
+            protected override AnalyzerConfigOptionsProvider? GetAnalyzerConfigOptionsProvider()
+            {
+                var globalOptions = new InMemoryAnalyzerConfigOptions();
+                globalOptions.Add(
+                    "build_property.Vetuviem_Assemblies",
+                    "ControlzEx.dll,MahApps.Metro.dll,MahApps.Metro.SimpleChildWindow.dll");
+
+                return new InMemoryAnalyzerConfigOptionsProvider(globalOptions);
+            }
+
+            /// <inheritdoc />
+            protected override void AddReferenceAssemblies(IList<MetadataReference> metadataReferences)
+            {
+                if (metadataReferences == null)
+                {
+                    throw new ArgumentNullException(nameof(metadataReferences));
+                }
+
+                var trustedAssembliesPaths = GetPlatformAssemblyPaths();
+                if (trustedAssembliesPaths == null)
+                {
+                    return;
+                }
+
+                foreach (string trustedAssembliesPath in trustedAssembliesPaths)
+                {
+                    var metadataReference = MetadataReference.CreateFromFile(trustedAssembliesPath);
+                    if (metadataReference == null)
+                    {
+                        throw new InvalidOperationException($"Failed to create metadata reference for {trustedAssembliesPath}");
+                    }
+                    metadataReferences.Add(metadataReference);
+                }
+            }
+
+            /// <inheritdoc />
+            protected override Func<WpfControlBindingModelSourceGenerator> GetFactory()
+            {
+                return () => new WpfControlBindingModelSourceGenerator();
+            }
+
+            private static string[]? GetPlatformAssemblyPaths()
+            {
+                if (AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES") is string trustedPlatformAssemblies)
+                {
+                    return trustedPlatformAssemblies.Split(Path.PathSeparator);
+                }
+
+                return null;
+            }
+        }
+    }
+}

src/Vetuviem.IntegrationTests/ReactiveUI/WPF/WpfViewBindingModelGeneratorTests.cs

@@ -6,6 +6,7 @@
 using System.Collections.Generic;
 using System.IO;
 using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Diagnostics;
 using Vetuviem.SourceGenerator.Features.ControlBindingModels;
 using Vetuviem.Testing;
 using Vetuviem.WPF.SourceGenerator;
@@ -30,6 +31,12 @@ public ExecuteMethod(ITestOutputHelper output)
             {
             }
 
+            /// <inheritdoc />
+            protected override AnalyzerConfigOptionsProvider? GetAnalyzerConfigOptionsProvider()
+            {
+                return null;
+            }
+
             /// <inheritdoc />
             protected override void AddReferenceAssemblies(IList<MetadataReference> metadataReferences)
             {

src/Vetuviem.IntegrationTests/ReactiveUI/WinUi3/WinUi3ViewBindingModelGeneratorTests.cs

@@ -5,6 +5,7 @@
 using System;
 using System.Collections.Generic;
 using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Diagnostics;
 using Vetuviem.SourceGenerator.Features.ControlBindingModels;
 using Vetuviem.Testing;
 using Vetuviem.WinUi.SourceGenerator;
@@ -29,6 +30,12 @@ public ExecuteMethod(ITestOutputHelper output)
             {
             }
 
+            /// <inheritdoc />
+            protected override AnalyzerConfigOptionsProvider? GetAnalyzerConfigOptionsProvider()
+            {
+                return null;
+            }
+
             /// <inheritdoc />
             protected override void AddReferenceAssemblies(IList<MetadataReference> metadataReferences)
             {

src/Vetuviem.IntegrationTests/ReactiveUI/Winforms/WinformsViewBindingModelGeneratorTests.cs

@@ -6,6 +6,7 @@
 using System.Collections.Generic;
 using System.IO;
 using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Diagnostics;
 using Vetuviem.SourceGenerator.Features.ControlBindingModels;
 using Vetuviem.Testing;
 using Vetuviem.Winforms.SourceGenerator;
@@ -30,6 +31,12 @@ public ExecuteMethod(ITestOutputHelper output)
             {
             }
 
+            /// <inheritdoc />
+            protected override AnalyzerConfigOptionsProvider? GetAnalyzerConfigOptionsProvider()
+            {
+                return null;
+            }
+
             /// <inheritdoc />
             protected override void AddReferenceAssemblies(IList<MetadataReference> metadataReferences)
             {

src/Vetuviem.IntegrationTests/Vetuviem.IntegrationTests.csproj

@@ -1,11 +1,17 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net8.0-windows</TargetFramework>
+    <TargetFramework>net8.0-windows10.0.19041</TargetFramework>
     <UseWpf>True</UseWpf>
     <IsPackable>False</IsPackable>
   </PropertyGroup>
 
+  <ItemGroup>
+    <PackageReference Include="MahApps.Metro" Version="2.4.10" />
+    <PackageReference Include="MahApps.Metro.SimpleChildWindow" Version="2.2.1" />
+    <PackageReference Include="ReactiveUI.WPF" Version="20.1.1" />
+  </ItemGroup>
+
   <ItemGroup>
     <ProjectReference Include="..\Vetuviem.Testing\Vetuviem.Testing.csproj" />
     <ProjectReference Include="..\Vetuviem.Winforms.SourceGenerator\Vetuviem.Winforms.SourceGenerator.csproj" />

src/Vetuviem.SourceGenerator/AbstractBaseSourceGenerator.cs

@@ -128,7 +128,7 @@ public void Execute(GeneratorExecutionContext context)
 
             globalOptions.TryGetBuildPropertyValue("Vetuviem_Assemblies", out var assemblies);
             var assembliesArray = assemblies?.Split(
-                [';'],
+                [','],
                 StringSplitOptions.RemoveEmptyEntries)
                 .Where(s => !string.IsNullOrWhiteSpace(s))
                 .ToArray();

src/Vetuviem.SourceGenerator/Features/Core/ReportDiagnosticFactory.cs

@@ -45,7 +45,7 @@ public static Diagnostic StartingScanOfAssembly(MetadataReference metadataRefere
         {
             return InfoDiagnostic(
                 ReportDiagnosticIds.StartingScanOfAssembly,
-                $"Starting Scan Of Namespace: {metadataReference.Display}");
+                $"Starting Scan Of Assembly: {metadataReference.Display}");
         }
 
         /// <summary>

src/Vetuviem.Testing/BaseGeneratorTests.cs

@@ -8,8 +8,10 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Reflection;
+using Castle.Core.Logging;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.Extensions.Logging;
 using Vetuviem.SourceGenerator;
 using Vetuviem.SourceGenerator.Features.Core;
@@ -61,8 +63,11 @@
 
                 var comp = CreateCompilation(string.Empty, references);
 
+                var analyzerConfigOptionsProvider = GetAnalyzerConfigOptionsProvider();
+
                 var newComp = RunGenerators(
                     comp,
+                    analyzerConfigOptionsProvider,
                     out var generatorDiags,
                     instance);
 
@@ -76,9 +81,23 @@
                     hasErrors |= generatorDiag.Severity == DiagnosticSeverity.Error;
                 }
 
+                foreach (var newCompSyntaxTree in newComp.SyntaxTrees)
+                {
+                    _logger.LogInformation("Syntax Tree:");
+                    _logger.LogInformation(newCompSyntaxTree.GetText().ToString());
+                }
+
                 Assert.False(hasErrors);
+
+
             }
 
+            /// <summary>
+            /// Gets the analyzer config options provider to test with.
+            /// </summary>
+            /// <returns>Analyzer Config Options.</returns>
+            protected abstract AnalyzerConfigOptionsProvider? GetAnalyzerConfigOptionsProvider();
+
             /// <summary>
             /// Allows addition of platform specific metadata references. Unit Tests start in an agnostic fashion
             /// with no specific references loaded. Source generators typically take these via MSBuild loading
@@ -93,21 +112,37 @@
             /// <returns>Function for creating a source generator.</returns>
             protected abstract Func<TGenerator> GetFactory();
 
             private static Compilation CreateCompilation(string source, IEnumerable<MetadataReference> reference) => CSharpCompilation.Create(
                 assemblyName: "compilation",
                 syntaxTrees: new[] { CSharpSyntaxTree.ParseText(source, new CSharpParseOptions(LanguageVersion.Preview)) },
                 references: reference,
                 options: new CSharpCompilationOptions(OutputKind.ConsoleApplication));
 
-            private static GeneratorDriver CreateDriver(Compilation compilation, params ISourceGenerator[] generators) => CSharpGeneratorDriver.Create(
+            private static GeneratorDriver CreateDriver(
+                Compilation compilation,
+                AnalyzerConfigOptionsProvider? analyzerConfigOptionsProvider,
+                params ISourceGenerator[] generators) => CSharpGeneratorDriver.Create(
                 generators: ImmutableArray.Create(generators),
                 additionalTexts: ImmutableArray<AdditionalText>.Empty,
                 parseOptions: (CSharpParseOptions)compilation.SyntaxTrees.First().Options,
-                optionsProvider: null);
+                optionsProvider: analyzerConfigOptionsProvider);
 
-            private static Compilation RunGenerators(Compilation compilation, out ImmutableArray<Diagnostic> diagnostics, params ISourceGenerator[] generators)
+            private static Compilation RunGenerators(
+                Compilation compilation,
+                AnalyzerConfigOptionsProvider? analyzerConfigOptionsProvider,
+                out ImmutableArray<Diagnostic> diagnostics,
+                params ISourceGenerator[] generators)
             {
-                CreateDriver(compilation, generators).RunGeneratorsAndUpdateCompilation(compilation, out var updatedCompilation, out diagnostics);
+                var driver = CreateDriver(
+                    compilation,
+                    analyzerConfigOptionsProvider,
+                    generators);
+
+                driver.RunGeneratorsAndUpdateCompilation(
+                    compilation,
+                    out var updatedCompilation,
+                    out diagnostics);
+
                 return updatedCompilation;
             }
         }

src/Vetuviem.Testing/InMemoryAnalyzerConfigOptions.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Text;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace Vetuviem.Testing
+{
+    public sealed class InMemoryAnalyzerConfigOptions : AnalyzerConfigOptions
+    {
+        private readonly Dictionary<string, string> _options = new();
+
+        public void Add(string key, string value)
+        {
+            _options.Add(key, value);
+        }
+
+        /// <inheritdoc />
+        public override bool TryGetValue(string key, [NotNullWhen(true)] out string? value)
+        {
+            return _options.TryGetValue(key, out value);
+        }
+    }
+}

src/Vetuviem.Testing/InMemoryAnalyzerConfigOptionsProvider.cs

@@ -0,0 +1,45 @@
+// Copyright (c) 2022 DPVreony and Contributors. All rights reserved.
+// DPVreony and Contributors licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System.Collections.Generic;
+using System.IO;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace Vetuviem.Testing
+{
+    public sealed class InMemoryAnalyzerConfigOptionsProvider : AnalyzerConfigOptionsProvider
+    {
+        private readonly Dictionary<string, AnalyzerConfigOptions> _options = [];
+        private readonly AnalyzerConfigOptions _globalOptions;
+
+        public InMemoryAnalyzerConfigOptionsProvider(AnalyzerConfigOptions globalOptions)
+        {
+            System.ArgumentNullException.ThrowIfNull(globalOptions);
+            _globalOptions = globalOptions;
+        }
+
+        public override AnalyzerConfigOptions GetOptions(SyntaxTree tree)
+        {
+            return GetOptions(Path.GetFileName(tree.FilePath));
+        }
+
+        public override AnalyzerConfigOptions GetOptions(Microsoft.CodeAnalysis.AdditionalText textFile)
+        {
+            return GetOptions(Path.GetFileName(textFile.Path));
+        }
+
+        public override AnalyzerConfigOptions GlobalOptions => _globalOptions;
+
+        private AnalyzerConfigOptions GetOptions(string path)
+        {
+            if (!_options.TryGetValue(path, out var options))
+            {
+                options ??= new InMemoryAnalyzerConfigOptions();
+            }
+
+            return options;
+        }
+    }
+}

src/Vetuviem.Testing/TestAnalyzerConfigOptionsProvider.cs

@@ -0,0 +1,25 @@
+#if TBC
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace Vetuviem.Testing
+{
+    public sealed class TestAnalyzerConfigOptionsProvider : AnalyzerConfigOptionsProvider
+    {
+        public override AnalyzerConfigOptions GetOptions(SyntaxTree tree)
+        {
+            throw new NotImplementedException();
+        }
+
+        public override AnalyzerConfigOptions GetOptions(AdditionalText textFile)
+        {
+            throw new NotImplementedException();
+        }
+
+        public override AnalyzerConfigOptions GlobalOptions { get; }
+    }
+}
+#endif

src/Vetuviem.Testing/Vetuviem.Testing.csproj

@@ -1,9 +1,10 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>netstandard2.0</TargetFramework>
+    <TargetFrameworks>net8.0</TargetFrameworks>
     <IsPackable>False</IsPackable>
-    <LangVersion>8</LangVersion>
+    <LangVersion>latest</LangVersion>
+    <Nullable>enable</Nullable>
   </PropertyGroup>
 
   <ItemGroup>

src/Vetuviem.UnitTests/Vetuviem.UnitTests.csproj

@@ -1,7 +1,7 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net7.0</TargetFramework>
+    <TargetFramework>net8.0</TargetFramework>
     <IsPackable>False</IsPackable>
   </PropertyGroup>