feat!: net10 supports

Author: mrdevrobot

ProjectR.Sample/ProjectR.Sample.csproj

@@ -6,6 +6,8 @@
     <ImplicitUsings>enable</ImplicitUsings>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <IsPackable>false</IsPackable>
+    <EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
+    <CompilerGeneratedFilesOutputPath>$(BaseIntermediateOutputPath)Generated</CompilerGeneratedFilesOutputPath>
   </PropertyGroup>
 
   <ItemGroup>

ProjectR.Tests/GeneratorTests.cs

@@ -0,0 +1,131 @@
+using System.Threading.Tasks;
+using System.Collections.Immutable;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Testing;
+using Microsoft.CodeAnalysis.Testing;
+using Microsoft.CodeAnalysis.Testing.Verifiers;
+using Xunit;
+using ProjectR;
+
+namespace ProjectR.Tests
+{
+    public static class CSharpSourceGeneratorVerifier<TSourceGenerator>
+        where TSourceGenerator : IIncrementalGenerator, new()
+    {
+        public class Test : CSharpSourceGeneratorTest<TSourceGenerator, XUnitVerifier>
+        {
+            public Test()
+            {
+                ReferenceAssemblies = ReferenceAssemblies.Net.Net80;
+            }
+
+            protected override CompilationOptions CreateCompilationOptions()
+            {
+                var options = base.CreateCompilationOptions();
+                return options.WithSpecificDiagnosticOptions(
+                    options.SpecificDiagnosticOptions.SetItems(CSharpVerifierHelper.NullableWarnings));
+            }
+        }
+    }
+
+    internal static class CSharpVerifierHelper
+    {
+        /// <summary>
+        /// By default, the compiler reports diagnostics for nullable reference types at
+        /// <see cref="DiagnosticSeverity.Warning"/>, and the analyzer test framework defaults to only validating
+        /// diagnostics at <see cref="DiagnosticSeverity.Error"/>. This map contains all compiler diagnostic IDs
+        /// related to nullability wrapped with <see cref="ReportDiagnostic.Error"/>, which is then used to enable all
+        /// of these warnings for default validation during analyzer and code fix tests.
+        /// </summary>
+        internal static ImmutableDictionary<string, ReportDiagnostic> NullableWarnings { get; } = GetNullableWarningsFromCompiler();
+
+        private static ImmutableDictionary<string, ReportDiagnostic> GetNullableWarningsFromCompiler()
+        {
+            string[] args = { "/warnaserror:nullable" };
+            var commandLineArguments = CSharpCommandLineParser.Default.Parse(args, baseDirectory: null, sdkDirectory: null);
+            return commandLineArguments.CompilationOptions.SpecificDiagnosticOptions;
+        }
+    }
+
+    public class GeneratorTests
+    {
+        [Fact]
+        public async Task SimpleMapping_GeneratesCorrectCode()
+        {
+            var source = @"
+using ProjectR;
+
+namespace TestNamespace
+{
+    public class Source
+    {
+        public int Id { get; set; }
+        public string Name { get; set; }
+    }
+
+    public class Destination
+    {
+        public int Id { get; set; }
+        public string Name { get; set; }
+    }
+
+    public partial class TestMapper : Mapper<Source, Destination>
+    {
+    }
+}";
+
+            var expected = @"// <auto-generated/>
+using System;
+using System.Linq;
+using ProjectR;
+
+namespace TestNamespace
+{
+    public partial class TestMapper
+    {
+        public override TestNamespace.Destination ProjectGenerated(TestNamespace.Source source)
+        {
+            if (source is null) return default(TestNamespace.Destination);
+
+            return new TestNamespace.Destination
+            {
+                Id = source.Id,
+                Name = source.Name,
+            };
+
+        }
+
+        public override TestNamespace.Source BuildGenerated(TestNamespace.Destination source)
+        {
+            if (source is null) return default(TestNamespace.Source);
+
+            return new TestNamespace.Source
+            {
+                Id = source.Id,
+                Name = source.Name,
+            };
+
+        }
+
+    }
+}
+";
+
+            var test = new CSharpSourceGeneratorVerifier<MapperGenerator>.Test
+            {
+                TestState = 
+                {
+                    Sources = { source },
+                    GeneratedSources = 
+                    {
+                        (typeof(MapperGenerator), "TestMapper.g.cs", expected)
+                    },
+                    AdditionalReferences = { MetadataReference.CreateFromFile(typeof(ProjectR.Mapper<,>).Assembly.Location) }
+                },
+            };
+
+            await test.RunAsync();
+        }
+    }
+}

ProjectR.Tests/ProjectR.Tests.csproj

@@ -1,7 +1,7 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
 
@@ -24,6 +24,7 @@
     <PackageReference Include="FluentAssertions" Version="6.12.0" />
     <PackageReference Include="Moq" Version="4.20.69" />
     <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="8.0.0" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.SourceGenerators.Testing.XUnit" Version="1.1.2-beta1.23306.2" />
   </ItemGroup>
 
   <ItemGroup>

ProjectR/Mapping/MapperGenerator.cs

@@ -101,7 +101,8 @@ private static void Execute(Compilation compilation,
     public partial class {mapperName} : global::ProjectR.Mapper<{entityFullName}, {dtoFullName}> {{ }}
 }}";
                     context.AddSource($"{mapperName}.ph.g.cs", sourceText);
-                    var syntaxTree = CSharpSyntaxTree.ParseText(sourceText, path: $"{mapperName}.ph.g.cs");
+                    var parseOptions = (compilation.SyntaxTrees.FirstOrDefault()?.Options as CSharpParseOptions) ?? CSharpParseOptions.Default;
+                    var syntaxTree = CSharpSyntaxTree.ParseText(sourceText, parseOptions, path: $"{mapperName}.ph.g.cs");
                     placeholderSyntaxTrees.Add(syntaxTree);
 
                     var placeholderClassNode = syntaxTree.GetRoot().DescendantNodes().OfType<ClassDeclarationSyntax>().First();