Fix semantic model caching in source generator (#172)

Fixes #170.

Author: atifaziz

src/DocoptNet/CodeGeneration/SourceGenerator.cs

@@ -109,13 +109,19 @@ public void Execute(GeneratorExecutionContext context)
             var syntaxReceiver = (SyntaxReceiver)(context.SyntaxContextReceiver ?? throw new NullReferenceException());
 
             SemanticModel? model = null;
+            SyntaxTree? modelSyntaxTree = null;
 
             var docoptTypes = new List<(string? Namespace, string Name, DocoptArgumentsAttribute? ArgumentsAttribute,
                                         SourceText Help, GenerationOptions Options)>();
 
             foreach (var (cds, attributeData) in syntaxReceiver.ClassAttributes)
             {
-                model ??= context.Compilation.GetSemanticModel(cds.SyntaxTree);
+                if (model is null || modelSyntaxTree != cds.SyntaxTree)
+                {
+                    model = context.Compilation.GetSemanticModel(cds.SyntaxTree);
+                    modelSyntaxTree = cds.SyntaxTree;
+                }
+
                 var symbol = model.GetDeclaredSymbol(cds) as INamedTypeSymbol;
                 if (symbol is null)
                     continue;

tests/DocoptNet.Tests/CodeGeneration/SourceGeneratorTests.cs

@@ -192,6 +192,32 @@ sealed partial class ProgramArguments
             });
         }
 
+        [Test]
+        public void Generate_with_classes_in_separate_files()
+        {
+            AssertMatchesSnapshot(new[]
+            {
+                ("File1.cs", SourceText.From(@"
+                    namespace Namespace1
+                    {
+                        [DocoptNet.DocoptArguments]
+                        sealed partial class ProgramArguments
+                        {
+                            const string Help = ""Usage: program"";
+                        }
+                    }")),
+                ("File2.cs", SourceText.From(@"
+                    namespace Namespace2
+                    {
+                        [DocoptNet.DocoptArguments]
+                        sealed partial class ProgramArguments
+                        {
+                            const string Help = ""Usage: program"";
+                        }
+                    }")),
+            });
+        }
+
         void AssertMatchesSnapshot((string Path, SourceText Text)[] sources,
                                    [CallerMemberName]string? callerName = null)
         {

tests/DocoptNet.Tests/CodeGeneration/SourceGeneratorTests/Generate_with_classes_in_separate_files/Namespace1.ProgramArguments.cs

@@ -0,0 +1,74 @@
+#nullable enable annotations
+
+using System.Collections;
+using System.Collections.Generic;
+using DocoptNet;
+using DocoptNet.Internals;
+using Leaves = DocoptNet.Internals.ReadOnlyList<DocoptNet.Internals.LeafPattern>;
+
+namespace Namespace1
+{
+    partial class ProgramArguments : IEnumerable<KeyValuePair<string, object?>>
+    {
+        public const string Usage = "Usage: program";
+
+        static readonly IBaselineParser<ProgramArguments> Parser = GeneratedSourceModule.CreateParser(Help, Parse);
+
+        public static IBaselineParser<ProgramArguments> CreateParser() => Parser;
+
+        static IParser<ProgramArguments>.IResult Parse(IEnumerable<string> args, ParseFlags flags, string? version)
+        {
+            var options = new List<Option>
+            {
+            };
+
+            return GeneratedSourceModule.Parse(Help, Usage, args, options, flags, version, Parse);
+
+            static IParser<ProgramArguments>.IResult Parse(Leaves left)
+            {
+                var required = new RequiredMatcher(1, left, new Leaves());
+                Match(ref required);
+                if (!required.Result || required.Left.Count > 0)
+                {
+                    return GeneratedSourceModule.CreateInputErrorResult<ProgramArguments>(string.Empty, Usage);
+                }
+                var collected = required.Collected;
+                var result = new ProgramArguments();
+
+                return GeneratedSourceModule.CreateArgumentsResult(result);
+            }
+
+            static void Match(ref RequiredMatcher required)
+            {
+                // Required(Required())
+                var a = new RequiredMatcher(1, required.Left, required.Collected);
+                while (a.Next())
+                {
+                    // Required()
+                    var b = new RequiredMatcher(0, a.Left, a.Collected);
+                    while (b.Next())
+                    {
+                        if (!b.LastMatched)
+                        {
+                            break;
+                        }
+                    }
+                    a.Fold(b.Result);
+                    if (!a.LastMatched)
+                    {
+                        break;
+                    }
+                }
+                required.Fold(a.Result);
+            }
+        }
+
+        IEnumerator<KeyValuePair<string, object?>> GetEnumerator()
+        {
+            yield break;
+        }
+
+        IEnumerator<KeyValuePair<string, object?>> IEnumerable<KeyValuePair<string, object?>>.GetEnumerator() => GetEnumerator();
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+    }
+}

tests/DocoptNet.Tests/CodeGeneration/SourceGeneratorTests/Generate_with_classes_in_separate_files/Namespace2.ProgramArguments.cs

@@ -0,0 +1,74 @@
+#nullable enable annotations
+
+using System.Collections;
+using System.Collections.Generic;
+using DocoptNet;
+using DocoptNet.Internals;
+using Leaves = DocoptNet.Internals.ReadOnlyList<DocoptNet.Internals.LeafPattern>;
+
+namespace Namespace2
+{
+    partial class ProgramArguments : IEnumerable<KeyValuePair<string, object?>>
+    {
+        public const string Usage = "Usage: program";
+
+        static readonly IBaselineParser<ProgramArguments> Parser = GeneratedSourceModule.CreateParser(Help, Parse);
+
+        public static IBaselineParser<ProgramArguments> CreateParser() => Parser;
+
+        static IParser<ProgramArguments>.IResult Parse(IEnumerable<string> args, ParseFlags flags, string? version)
+        {
+            var options = new List<Option>
+            {
+            };
+
+            return GeneratedSourceModule.Parse(Help, Usage, args, options, flags, version, Parse);
+
+            static IParser<ProgramArguments>.IResult Parse(Leaves left)
+            {
+                var required = new RequiredMatcher(1, left, new Leaves());
+                Match(ref required);
+                if (!required.Result || required.Left.Count > 0)
+                {
+                    return GeneratedSourceModule.CreateInputErrorResult<ProgramArguments>(string.Empty, Usage);
+                }
+                var collected = required.Collected;
+                var result = new ProgramArguments();
+
+                return GeneratedSourceModule.CreateArgumentsResult(result);
+            }
+
+            static void Match(ref RequiredMatcher required)
+            {
+                // Required(Required())
+                var a = new RequiredMatcher(1, required.Left, required.Collected);
+                while (a.Next())
+                {
+                    // Required()
+                    var b = new RequiredMatcher(0, a.Left, a.Collected);
+                    while (b.Next())
+                    {
+                        if (!b.LastMatched)
+                        {
+                            break;
+                        }
+                    }
+                    a.Fold(b.Result);
+                    if (!a.LastMatched)
+                    {
+                        break;
+                    }
+                }
+                required.Fold(a.Result);
+            }
+        }
+
+        IEnumerator<KeyValuePair<string, object?>> GetEnumerator()
+        {
+            yield break;
+        }
+
+        IEnumerator<KeyValuePair<string, object?>> IEnumerable<KeyValuePair<string, object?>>.GetEnumerator() => GetEnumerator();
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+    }
+}