From 7ec36f9e64ae277abf5a2744d01b002e31f9a186 Mon Sep 17 00:00:00 2001 From: juner Date: Fri, 8 May 2026 14:18:56 +0900 Subject: [PATCH 01/49] chore: add package tags for abstractions package --- CHANGELOG.md | 4 ++++ Processor.Abstractions/Esolang.Processor.Abstractions.csproj | 1 + 2 files changed, 5 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 7648df2..62abc23 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,6 +6,10 @@ The format is based on Keep a Changelog. ## [Unreleased] +### Changed + +- `Esolang.Processor.Abstractions`: refined NuGet `PackageTags` to improve discoverability (`esolang;processor;abstractions`). + ## [1.0.0] - 2026-05-07 ### Added diff --git a/Processor.Abstractions/Esolang.Processor.Abstractions.csproj b/Processor.Abstractions/Esolang.Processor.Abstractions.csproj index 30ccc13..404cd96 100644 --- a/Processor.Abstractions/Esolang.Processor.Abstractions.csproj +++ b/Processor.Abstractions/Esolang.Processor.Abstractions.csproj @@ -7,6 +7,7 @@ Unified processor abstractions for esolang execution. Esolang.Processor.Abstractions README.md + esolang;processor;abstractions From 45662c2177ed7a97d54c1e1f3c56237d0ab70181 Mon Sep 17 00:00:00 2001 From: juner Date: Wed, 27 May 2026 14:46:04 +0900 Subject: [PATCH 02/49] feat: setup testing infrastructure for Processor.Abstractions and translate doc comments to English --- .gitignore | 2 + Directory.Build.props | 14 +- Directory.Build.targets | 6 + Esolang.Abstractions.code-workspace | 5 + Esolang.Abstractions.slnx | 4 + GEMINI.md | 3 + ...solang.Processor.Abstractions.Tests.csproj | 26 +++ .../PipeProcessorExtensionsTests.cs | 180 ++++++++++++++++++ .../TextProcessorExtensionsTests.cs | 149 +++++++++++++++ .../Esolang.Processor.Abstractions.csproj | 7 +- Processor.Abstractions/IProcessor.cs | 111 +++++++---- .../PipeProcessorExtensions.cs | 109 +++++++++++ .../TextProcessorExtensions.cs | 109 +++++++++++ dotnet-tools.json | 13 ++ global.json | 3 + 15 files changed, 704 insertions(+), 37 deletions(-) create mode 100644 GEMINI.md create mode 100644 Processor.Abstractions.Tests/Esolang.Processor.Abstractions.Tests.csproj create mode 100644 Processor.Abstractions.Tests/PipeProcessorExtensionsTests.cs create mode 100644 Processor.Abstractions.Tests/TextProcessorExtensionsTests.cs create mode 100644 Processor.Abstractions/PipeProcessorExtensions.cs create mode 100644 Processor.Abstractions/TextProcessorExtensions.cs create mode 100644 dotnet-tools.json diff --git a/.gitignore b/.gitignore index 0808c4a..400ec62 100644 --- a/.gitignore +++ b/.gitignore @@ -480,3 +480,5 @@ $RECYCLE.BIN/ # Vim temporary swap files *.swp + +coveragereport \ No newline at end of file diff --git a/Directory.Build.props b/Directory.Build.props index 4d954bc..fab8aef 100644 --- a/Directory.Build.props +++ b/Directory.Build.props @@ -3,9 +3,9 @@ enable enable 14 - 1.0.0.1 - 1.0.0.1 - 1.0.0 + 2.0.0.2 + 2.0.0.2 + 2.0.0 https://github.com/Esolang-NET/Abstractions/ https://github.com/Esolang-NET/Abstractions.git true @@ -36,11 +36,19 @@ + + + + + $(MSBuildProjectDirectory)\TestResults false true false $(NoWarn);RS1035 + Exe + true + true diff --git a/Directory.Build.targets b/Directory.Build.targets index 18aa81f..6e3b325 100644 --- a/Directory.Build.targets +++ b/Directory.Build.targets @@ -1,6 +1,12 @@ + + + + + + diff --git a/Esolang.Abstractions.code-workspace b/Esolang.Abstractions.code-workspace index 1369a7f..7bdfe17 100644 --- a/Esolang.Abstractions.code-workspace +++ b/Esolang.Abstractions.code-workspace @@ -7,6 +7,10 @@ { "path": "Processor.Abstractions", "name": "Esolang.Processor.Abstractions" + }, + { + "path": "Processor.Abstractions.Tests", + "name": "Esolang.Processor.Abstractions.Tests" } ], "settings": { @@ -17,6 +21,7 @@ "**/.DS_Store": true, "**/Thumbs.db": true, "Processor.Abstractions": true, + "Processor.Abstractions.Tests": true } } } \ No newline at end of file diff --git a/Esolang.Abstractions.slnx b/Esolang.Abstractions.slnx index 9a64952..fc58da8 100644 --- a/Esolang.Abstractions.slnx +++ b/Esolang.Abstractions.slnx @@ -1,4 +1,8 @@ + + + + diff --git a/GEMINI.md b/GEMINI.md new file mode 100644 index 0000000..6844ead --- /dev/null +++ b/GEMINI.md @@ -0,0 +1,3 @@ +# Workflow Guidelines + +- **Working Directory**: Always ensure the current working directory is the solution root (containing `global.json` and the `.slnx` solution file) before executing `dotnet` commands. This is critical for correct SDK version resolution and dependency management. diff --git a/Processor.Abstractions.Tests/Esolang.Processor.Abstractions.Tests.csproj b/Processor.Abstractions.Tests/Esolang.Processor.Abstractions.Tests.csproj new file mode 100644 index 0000000..3767fcf --- /dev/null +++ b/Processor.Abstractions.Tests/Esolang.Processor.Abstractions.Tests.csproj @@ -0,0 +1,26 @@ + + + + net48;net9.0;net10.0 + net9.0;net10.0 + Esolang.Processor.Tests + Esolang.Processor.Abstractions.Tests + + + + + + + + + + + + + + + + + + + diff --git a/Processor.Abstractions.Tests/PipeProcessorExtensionsTests.cs b/Processor.Abstractions.Tests/PipeProcessorExtensionsTests.cs new file mode 100644 index 0000000..200f75b --- /dev/null +++ b/Processor.Abstractions.Tests/PipeProcessorExtensionsTests.cs @@ -0,0 +1,180 @@ +using System.Buffers; +using System.IO.Pipelines; +using System.Text; + +namespace Esolang.Processor.Tests; + +[TestClass] +public class PipeProcessorExtensionsTests(TestContext TestContext) +{ + CancellationToken CancellationToken => TestContext.CancellationToken; + + private class MockEventProcessor(List events) : IEventProcessor + { + public async IAsyncEnumerable RunAsyncEnumerable([System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken cancellationToken = default) + { + foreach (var ev in events) + { + yield return ev; + } + await Task.CompletedTask; + } + } + + [TestMethod] + [Timeout(Constants.Timeout, CooperativeCancellation = true)] + public async Task RunToEndAsync_HandlesEndEvent() + { + var processor = new MockEventProcessor(new List { new EndEvent(42) }); + var exitCode = await PipeProcessorExtensions.RunToEndAsync(processor, null, null, CancellationToken); + Assert.AreEqual(42, exitCode); + } + + [TestMethod] + [Timeout(Constants.Timeout, CooperativeCancellation = true)] + public async Task RunToEndAsync_HandlesOutputCharEvent() + { + var processor = new MockEventProcessor(new List { new OutputCharEvent('A'), new EndEvent(0) }); + var pipe = new Pipe(); + + var readTask = Task.Run(async () => + { + var result = await pipe.Reader.ReadAsync(CancellationToken); + var content = Encoding.UTF8.GetString(result.Buffer.ToArray()); + Assert.AreEqual("A", content); + pipe.Reader.AdvanceTo(result.Buffer.End); + pipe.Reader.Complete(); + }, CancellationToken); + + var exitCode = await PipeProcessorExtensions.RunToEndAsync(processor, null, pipe.Writer, CancellationToken); + + await readTask; + Assert.AreEqual(0, exitCode); + } + + [TestMethod] + [Timeout(Constants.Timeout, CooperativeCancellation = true)] + public async Task RunToEndAsync_HandlesOutputIntEvent() + { + var processor = new MockEventProcessor([new OutputIntEvent(123), new EndEvent(0)]); + var pipe = new Pipe(); + + var readTask = Task.Run(async () => + { + var result = await pipe.Reader.ReadAsync(CancellationToken); + var content = Encoding.UTF8.GetString(result.Buffer.ToArray()); + Assert.AreEqual("123", content); + pipe.Reader.AdvanceTo(result.Buffer.End); + pipe.Reader.Complete(); + }, CancellationToken); + + var exitCode = await PipeProcessorExtensions.RunToEndAsync(processor, null, pipe.Writer, CancellationToken); + + await readTask; + Assert.AreEqual(0, exitCode); + } + + [TestMethod] + [Timeout(Constants.Timeout, CooperativeCancellation = true)] + public async Task RunToEndAsync_HandlesInputCharEvent() + { + var capturedChar = ' '; + var processor = new MockEventProcessor(new List { + new TestInputCharEvent(c => capturedChar = c), + new EndEvent(0) + }); + + var pipe = new Pipe(); + await pipe.Writer.WriteAsync(Encoding.UTF8.GetBytes("X"), CancellationToken); + pipe.Writer.Complete(); + + await PipeProcessorExtensions.RunToEndAsync(processor, pipe.Reader, null, CancellationToken); + + Assert.AreEqual('X', capturedChar); + } + + [TestMethod] + [Timeout(Constants.Timeout, CooperativeCancellation = true)] + public async Task RunToEndAsync_HandlesInputIntEvent() + { + var capturedInt = 0; + var processor = new MockEventProcessor([ + new TestInputIntEvent(i => capturedInt = i), + new EndEvent(0) + ]); + + var pipe = new Pipe(); + await pipe.Writer.WriteAsync(BitConverter.GetBytes(123).AsMemory(), CancellationToken); + pipe.Writer.Complete(); + + await PipeProcessorExtensions.RunToEndAsync(processor, pipe.Reader, null, CancellationToken); + + Assert.AreEqual(123, capturedInt); + } + + [TestMethod] + [Timeout(Constants.Timeout, CooperativeCancellation = true)] + public void RunToEnd_HandlesEndEvent() + { + var processor = new MockEventProcessor([new EndEvent(99)]); + var exitCode = PipeProcessorExtensions.RunToEnd(processor, null, null, CancellationToken); + Assert.AreEqual(99, exitCode); + } + + [TestMethod] + [Timeout(Constants.Timeout, CooperativeCancellation = true)] + public async Task RunToEndAsync_ThrowsArgumentNullExceptionOnNullReader() + { + var processor = new MockEventProcessor([new InputCharEventMock()]); + await Assert.ThrowsAsync(() => PipeProcessorExtensions.RunToEndAsync(processor, null, null, CancellationToken).AsTask()); + } + + [TestMethod] + [Timeout(Constants.Timeout, CooperativeCancellation = true)] + public async Task RunToEndAsync_ThrowsArgumentNullExceptionOnNullWriter() + { + var processor = new MockEventProcessor([new OutputCharEvent('A')]); + await Assert.ThrowsAsync(() => PipeProcessorExtensions.RunToEndAsync(processor, null, null, CancellationToken).AsTask()); + } + + [TestMethod] + [Timeout(Constants.Timeout, CooperativeCancellation = true)] + public async Task RunToEndAsync_ThrowsArgumentNullExceptionOnNullReader_InputInt() + { + var processor = new MockEventProcessor([new InputIntEventMock()]); + await Assert.ThrowsAsync(() => PipeProcessorExtensions.RunToEndAsync(processor, null, null, CancellationToken).AsTask()); + } + + [TestMethod] + [Timeout(Constants.Timeout, CooperativeCancellation = true)] + public async Task RunToEndAsync_ThrowsArgumentNullExceptionOnNullWriter_OutputInt() + { + var processor = new MockEventProcessor([new OutputIntEvent(123)]); + await Assert.ThrowsAsync(() => PipeProcessorExtensions.RunToEndAsync(processor, null, null, CancellationToken).AsTask()); + } + + private class TestInputCharEvent(Action write) : InputCharEvent + { + public override void Write(char c) => write(c); + } + + private class TestInputIntEvent(Action write) : InputIntEvent + { + public override void Write(int i) => write(i); + } + + private class InputCharEventMock : InputCharEvent + { + public override void Write(char c) { } + } + + private class InputIntEventMock : InputIntEvent + { + public override void Write(int i) { } + } +} + +file static class Constants +{ + public const int Timeout = 2000; +} diff --git a/Processor.Abstractions.Tests/TextProcessorExtensionsTests.cs b/Processor.Abstractions.Tests/TextProcessorExtensionsTests.cs new file mode 100644 index 0000000..47e12c9 --- /dev/null +++ b/Processor.Abstractions.Tests/TextProcessorExtensionsTests.cs @@ -0,0 +1,149 @@ +using Esolang.Processor; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using System.Text; + +namespace Esolang.Processor.Tests; + +[TestClass] +public class TextProcessorExtensionsTests(TestContext TestContext) +{ + CancellationToken CancellationToken => TestContext.CancellationToken; + + private class MockEventProcessor(List events) : IEventProcessor + { + public async IAsyncEnumerable RunAsyncEnumerable([System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken cancellationToken = default) + { + foreach (var ev in events) + { + yield return ev; + } + await Task.CompletedTask; + } + } + + [TestMethod] + [Timeout(Constants.Timeout, CooperativeCancellation = true)] + public async Task RunToEndAsync_HandlesOutputCharEvent() + { + var processor = new MockEventProcessor([new OutputCharEvent('A'), new EndEvent(0)]); + using var writer = new StringWriter(); + + var exitCode = await TextProcessorExtensions.RunToEndAsync(processor, null, writer, CancellationToken); + + Assert.AreEqual("A", writer.ToString()); + Assert.AreEqual(0, exitCode); + } + + [TestMethod] + [Timeout(Constants.Timeout, CooperativeCancellation = true)] + public async Task RunToEndAsync_HandlesOutputIntEvent() + { + var processor = new MockEventProcessor([new OutputIntEvent(123), new EndEvent(0)]); + using var writer = new StringWriter(); + + var exitCode = await TextProcessorExtensions.RunToEndAsync(processor, null, writer, CancellationToken); + + Assert.AreEqual("123" + Environment.NewLine, writer.ToString()); + Assert.AreEqual(0, exitCode); + } + + [TestMethod] + [Timeout(Constants.Timeout, CooperativeCancellation = true)] + public async Task RunToEndAsync_HandlesInputCharEvent() + { + var capturedChar = ' '; + var processor = new MockEventProcessor([ + new TestInputCharEvent(c => capturedChar = c), + new EndEvent(0) + ]); + + using var reader = new StringReader("X"); + await TextProcessorExtensions.RunToEndAsync(processor, reader, null, CancellationToken); + + Assert.AreEqual('X', capturedChar); + } + + [TestMethod] + [Timeout(Constants.Timeout, CooperativeCancellation = true)] + public async Task RunToEndAsync_HandlesInputIntEvent() + { + var capturedInt = 0; + var processor = new MockEventProcessor([ + new TestInputIntEvent(i => capturedInt = i), + new EndEvent(0) + ]); + + using var reader = new StringReader("123"); + await TextProcessorExtensions.RunToEndAsync(processor, reader, null, CancellationToken); + + Assert.AreEqual(123, capturedInt); + } + + [TestMethod] + [Timeout(Constants.Timeout, CooperativeCancellation = true)] + public async Task RunToEndAsync_ThrowsArgumentNullExceptionOnNullInput() + { + var processor = new MockEventProcessor([new InputCharEventMock()]); + await Assert.ThrowsAsync(() => TextProcessorExtensions.RunToEndAsync(processor, null, null, CancellationToken).AsTask()); + } + + [TestMethod] + [Timeout(Constants.Timeout, CooperativeCancellation = true)] + public async Task RunToEndAsync_ThrowsArgumentNullExceptionOnNullOutput() + { + var processor = new MockEventProcessor([new OutputCharEvent('A')]); + await Assert.ThrowsAsync(() => TextProcessorExtensions.RunToEndAsync(processor, null, null, CancellationToken).AsTask()); + } + + [TestMethod] + [Timeout(Constants.Timeout, CooperativeCancellation = true)] + public async Task RunToEndAsync_ThrowsArgumentNullExceptionOnNullInput_InputInt() + { + var processor = new MockEventProcessor([new InputIntEventMock()]); + await Assert.ThrowsAsync(() => TextProcessorExtensions.RunToEndAsync(processor, null, null, CancellationToken).AsTask()); + } + + [TestMethod] + [Timeout(Constants.Timeout, CooperativeCancellation = true)] + public async Task RunToEndAsync_ThrowsArgumentNullExceptionOnNullOutput_OutputInt() + { + var processor = new MockEventProcessor([new OutputIntEvent(123)]); + await Assert.ThrowsAsync(() => TextProcessorExtensions.RunToEndAsync(processor, null, null, CancellationToken).AsTask()); + } + + [TestMethod] + [Timeout(Constants.Timeout, CooperativeCancellation = true)] + public void RunToEnd_HandlesEndEvent() + { + var processor = new MockEventProcessor([new EndEvent(88)]); +#pragma warning disable CS0618 + var exitCode = TextProcessorExtensions.RunToEnd(processor, null, null, CancellationToken); +#pragma warning restore CS0618 + Assert.AreEqual(88, exitCode); + } + + private class TestInputCharEvent(Action write) : InputCharEvent + { + public override void Write(char c) => write(c); + } + + private class TestInputIntEvent(Action write) : InputIntEvent + { + public override void Write(int i) => write(i); + } + + private class InputCharEventMock : InputCharEvent + { + public override void Write(char c) { } + } + + private class InputIntEventMock : InputIntEvent + { + public override void Write(int i) { } + } +} + +file static class Constants +{ + public const int Timeout = 2000; +} diff --git a/Processor.Abstractions/Esolang.Processor.Abstractions.csproj b/Processor.Abstractions/Esolang.Processor.Abstractions.csproj index 404cd96..b9fa140 100644 --- a/Processor.Abstractions/Esolang.Processor.Abstractions.csproj +++ b/Processor.Abstractions/Esolang.Processor.Abstractions.csproj @@ -1,19 +1,24 @@ - netstandard2.0 + netstandard2.0;netstandard2.1 enable true Unified processor abstractions for esolang execution. Esolang.Processor.Abstractions README.md esolang;processor;abstractions + Esolang.Processor + + + + diff --git a/Processor.Abstractions/IProcessor.cs b/Processor.Abstractions/IProcessor.cs index ce93f7c..8b097bf 100644 --- a/Processor.Abstractions/IProcessor.cs +++ b/Processor.Abstractions/IProcessor.cs @@ -1,53 +1,98 @@ -using System.IO.Pipelines; - -#pragma warning disable IDE0130 // Namespace does not match folder structure namespace Esolang.Processor; -#pragma warning restore IDE0130 /// -/// Processor の共通基底。実行対象のプログラムを保持する。 +/// Common base interface for all processors. +/// +public interface IProcessor { } + +/// +/// Common base interface for processors that hold a program to be executed. /// -/// パース済みプログラムの型。 -public interface IProcessor +/// The type of the parsed program. +public interface IProcessor : IProcessor { - /// パース済みプログラム。 + /// The parsed program. TProgram Program { get; } } /// -/// / ベースの実行 IF。 +/// Execution model based on a stream of I/O events. /// -/// パース済みプログラムの型。 -public interface ITextProcessor : IProcessor +public interface IEventProcessor : IProcessor { - /// プログラムを最後まで実行し、終了コードを返す。 - int RunToEnd( - TextReader? input = null, - TextWriter? output = null, + /// + /// Executes the processor and returns a stream of I/O events. + /// + /// The cancellation token. + /// An asynchronous stream of I/O events. + IAsyncEnumerable RunAsyncEnumerable( CancellationToken cancellationToken = default); +} + +/// +/// Represents an I/O event. +/// +public interface IOEvent +{ - /// プログラムを最後まで非同期実行し、終了コードを返す。 - ValueTask RunToEndAsync( - TextReader? input = null, - TextWriter? output = null, - CancellationToken cancellationToken = default); } /// -/// / ベースの実行 IF。 +/// Represents an event requesting a character input. /// -/// パース済みプログラムの型。 -public interface IPipeProcessor : IProcessor +public abstract class InputCharEvent : IOEvent { - /// プログラムを最後まで実行し、終了コードを返す。 - int RunToEnd( - PipeReader input, - PipeWriter output, - CancellationToken cancellationToken = default); + /// + /// Writes the input character to the processor. + /// + /// The input character. + public abstract void Write(char c); +} - /// プログラムを最後まで非同期実行し、終了コードを返す。 - ValueTask RunToEndAsync( - PipeReader input, - PipeWriter output, - CancellationToken cancellationToken = default); +/// +/// Represents an event requesting an integer input. +/// +public abstract class InputIntEvent : IOEvent +{ + /// + /// Writes the input integer to the processor. + /// + /// The input integer. + public abstract void Write(int i); +} + +/// +/// Represents an event that outputs a character. +/// +/// The character to output. +public sealed class OutputCharEvent(char Output) : IOEvent +{ + /// + /// The character to output. + /// + public char Output { get; } = Output; +} + +/// +/// Represents an event that outputs an integer. +/// +/// The integer to output. +public sealed class OutputIntEvent(int Output) : IOEvent +{ + /// + /// The integer to output. + /// + public int Output { get; } = Output; +} + +/// +/// Represents an event indicating the end of execution. +/// +/// The exit code. +public sealed class EndEvent(int exitCode) : IOEvent +{ + /// + /// The exit code. + /// + public int ExitCode { get; } = exitCode; } diff --git a/Processor.Abstractions/PipeProcessorExtensions.cs b/Processor.Abstractions/PipeProcessorExtensions.cs new file mode 100644 index 0000000..bf2c70e --- /dev/null +++ b/Processor.Abstractions/PipeProcessorExtensions.cs @@ -0,0 +1,109 @@ +using System.Buffers; +using System.IO.Pipelines; +using System.Text; + +namespace Esolang.Processor; + +/// +/// Provides extension methods for running using and . +/// +public static class PipeProcessorExtensions +{ + /// + /// Executes the processor until it reaches an . + /// + /// The event processor. + /// The input pipe reader. + /// The output pipe writer. + /// The cancellation token. + /// The exit code. + /// Thrown when input or output is null depending on the event. + public static async ValueTask RunToEndAsync( + this IEventProcessor processor, + PipeReader? input, + PipeWriter? output, + CancellationToken cancellationToken = default) + { + await foreach (var ev in processor.RunAsyncEnumerable(cancellationToken)) + { + switch (ev) + { + case InputCharEvent inputChar: + if (input == null) + throw new ArgumentNullException(nameof(input)); + var result = await input.ReadAtLeastAsync(1, cancellationToken); + var buffer = ArrayPool.Shared.Rent(1); + try + { +#if NETSTANDARD2_1_OR_GREATER + result.Buffer.Slice(0, 1).CopyTo(buffer.AsSpan()); +#else + result.Buffer.Slice(0, 1).ToArray().CopyTo(buffer, 0); +#endif + input.AdvanceTo(result.Buffer.GetPosition(1)); + inputChar.Write((char)buffer[0]); + } + finally + { + ArrayPool.Shared.Return(buffer); + } + break; + case InputIntEvent inputInt: + if (input == null) + throw new ArgumentNullException(nameof(input)); + var result2 = await input.ReadAtLeastAsync(1, cancellationToken); + var buffer2 = ArrayPool.Shared.Rent(1); + try + { +#if NETSTANDARD2_1_OR_GREATER + result2.Buffer.Slice(0, 4).CopyTo(buffer2.AsSpan()); +#else + result2.Buffer.Slice(0, 4).ToArray().CopyTo(buffer2, 0); +#endif + input.AdvanceTo(result2.Buffer.GetPosition(4)); + inputInt.Write(BitConverter.ToInt32(buffer2, 0)); + } + finally + { + ArrayPool.Shared.Return(buffer2); + } + break; + case OutputCharEvent outputChar: + if (output == null) + throw new ArgumentNullException(nameof(output)); + output.Write(Encoding.UTF8.GetBytes(new[] { outputChar.Output })); + await output.FlushAsync(cancellationToken); + break; + case OutputIntEvent outputInt: + if (output == null) + throw new ArgumentNullException(nameof(output)); + output.Write(Encoding.UTF8.GetBytes(outputInt.Output.ToString())); + await output.FlushAsync(cancellationToken); + break; + case EndEvent end: + return end.ExitCode; + } + } + return 0; + } + + /// + /// Executes the processor synchronously until it reaches an . + /// + /// The event processor. + /// The input pipe reader. + /// The output pipe writer. + /// The cancellation token. + /// The exit code. + public static int RunToEnd( + this IEventProcessor processor, + PipeReader? input = null, + PipeWriter? output = null, + CancellationToken cancellationToken = default) + { + var result = RunToEndAsync(processor, input, output, cancellationToken); + if (result.IsCompleted) + return result.GetAwaiter().GetResult(); + return result.AsTask().GetAwaiter().GetResult(); + } +} diff --git a/Processor.Abstractions/TextProcessorExtensions.cs b/Processor.Abstractions/TextProcessorExtensions.cs new file mode 100644 index 0000000..ba9bf71 --- /dev/null +++ b/Processor.Abstractions/TextProcessorExtensions.cs @@ -0,0 +1,109 @@ +using System.Buffers; + +namespace Esolang.Processor; + +/// +/// Provides extension methods for running using and . +/// +public static class TextProcessorExtensions +{ + /// + /// Executes the processor until it reaches an . + /// + /// The event processor. + /// The input text reader. + /// The output text writer. + /// The cancellation token. + /// The exit code. + /// Thrown when input or output is null depending on the event. + public static async ValueTask RunToEndAsync( + this IEventProcessor processor, + TextReader? input = null, + TextWriter? output = null, + CancellationToken cancellationToken = default) + { + await foreach (var ioEvent in processor.RunAsyncEnumerable(cancellationToken)) + { + switch (ioEvent) + { + case InputCharEvent charInput: + if (input is null) + throw new ArgumentNullException(nameof(input)); + { + var buffer = ArrayPool.Shared.Rent(1); + try + { + int read; + do + { +#if NETSTANDARD2_1_OR_GREATER + read = await input.ReadAsync(buffer.AsMemory(0, 1), cancellationToken).ConfigureAwait(false); +#else + read = await input.ReadAsync(buffer, 0, 1).ConfigureAwait(false); +#endif + if (read < 0) continue; + charInput.Write(buffer[0]); + break; + } while (read < 0 && !cancellationToken.IsCancellationRequested); + } + finally + { + ArrayPool.Shared.Return(buffer); + } + } + break; + case InputIntEvent intInput: + if (input is null) + throw new ArgumentNullException(nameof(input)); + { + var inputString = await input.ReadLineAsync(); + if (int.TryParse(inputString, out var i)) + { + intInput.Write(i); + } + } + break; + case OutputCharEvent charOutput: + if (output is null) + throw new ArgumentNullException(nameof(output)); + { + await output.WriteAsync(charOutput.Output).ConfigureAwait(false); + await output.FlushAsync().ConfigureAwait(false); + } + break; + case OutputIntEvent intOutput: + if (output is null) + throw new ArgumentNullException(nameof(output)); + { + await output.WriteLineAsync(intOutput.Output.ToString()).ConfigureAwait(false); + await output.FlushAsync().ConfigureAwait(false); + } + break; + case EndEvent endEvent: + return endEvent.ExitCode; + } + } + return 0; + } + + /// + /// Executes the processor synchronously until it reaches an . + /// + /// The event processor. + /// The input text reader. + /// The output text writer. + /// The cancellation token. + /// The exit code. + [Obsolete("Use RunToEndAsync instead.")] + public static int RunToEnd( + this IEventProcessor processor, + TextReader? input = null, + TextWriter? output = null, + CancellationToken cancellationToken = default) + { + var result = RunToEndAsync(processor, input, output, cancellationToken); + if (result.IsCompleted) + return result.GetAwaiter().GetResult(); + return result.AsTask().GetAwaiter().GetResult(); + } +} diff --git a/dotnet-tools.json b/dotnet-tools.json new file mode 100644 index 0000000..307b712 --- /dev/null +++ b/dotnet-tools.json @@ -0,0 +1,13 @@ +{ + "version": 1, + "isRoot": true, + "tools": { + "dotnet-reportgenerator-globaltool": { + "version": "5.5.10", + "commands": [ + "reportgenerator" + ], + "rollForward": false + } + } +} \ No newline at end of file diff --git a/global.json b/global.json index 9d2ec9d..aaf91c4 100644 --- a/global.json +++ b/global.json @@ -2,5 +2,8 @@ "sdk": { "rollForward": "latestMinor", "version": "10.0.0" + }, + "test": { + "runner": "Microsoft.Testing.Platform" } } From de319316f8dfb9966b5115b9874b13923880cc2d Mon Sep 17 00:00:00 2001 From: juner Date: Wed, 27 May 2026 14:50:12 +0900 Subject: [PATCH 03/49] docs: update README.md to reflect IEventProcessor-based architecture --- Processor.Abstractions/README.md | 90 +++++++++----------------------- 1 file changed, 25 insertions(+), 65 deletions(-) diff --git a/Processor.Abstractions/README.md b/Processor.Abstractions/README.md index 9b7f412..135db93 100644 --- a/Processor.Abstractions/README.md +++ b/Processor.Abstractions/README.md @@ -10,105 +10,65 @@ dotnet add package Esolang.Processor.Abstractions ## Overview -This package provides common interfaces for implementing esolang processors (interpreters) with consistent execution patterns. +This package provides common interfaces and extension methods for implementing esolang processors (interpreters) based on an event-driven I/O model. -## Interfaces +## Core Interfaces ### IProcessor\ Base interface that holds a parsed program. ```csharp -public interface IProcessor +public interface IProcessor : IProcessor { - /// Parsed program instance. + /// The parsed program. TProgram Program { get; } } ``` -### ITextProcessor\ +### IEventProcessor -Execution interface using `TextReader` and `TextWriter` for input/output. +Execution interface based on a stream of I/O events. ```csharp -public interface ITextProcessor : IProcessor +public interface IEventProcessor : IProcessor { - /// Execute the program synchronously and return exit code. - int RunToEnd( - TextReader? input = null, - TextWriter? output = null, - CancellationToken cancellationToken = default); - - /// Execute the program asynchronously and return exit code. - ValueTask RunToEndAsync( - TextReader? input = null, - TextWriter? output = null, - CancellationToken cancellationToken = default); + /// + /// Executes the processor and returns an asynchronous stream of I/O events. + /// + IAsyncEnumerable RunAsyncEnumerable(CancellationToken cancellationToken = default); } ``` -### IPipeProcessor\ +## Extension Methods -Execution interface using `PipeReader` and `PipeWriter` for high-performance I/O. +To facilitate running processors with common I/O types, we provide extension methods: + +- **`TextProcessorExtensions`**: For `TextReader` and `TextWriter`. +- **`PipeProcessorExtensions`**: For `PipeReader` and `PipeWriter`. ```csharp -public interface IPipeProcessor : IProcessor -{ - /// Execute the program synchronously and return exit code. - int RunToEnd( - PipeReader input, - PipeWriter output, - CancellationToken cancellationToken = default); - - /// Execute the program asynchronously and return exit code. - ValueTask RunToEndAsync( - PipeReader input, - PipeWriter output, - CancellationToken cancellationToken = default); -} +// Example using TextReader/TextWriter +await processor.RunToEndAsync(inputReader, outputWriter, cancellationToken); + +// Example using PipeReader/PipeWriter +await processor.RunToEndAsync(inputPipe, outputPipe, cancellationToken); ``` ## Usage Example -Implement these interfaces in your processor: +Implement `IEventProcessor` in your processor: ```csharp using Esolang.Processor; -using System.IO.Pipelines; -public class MyEsolangProcessor : ITextProcessor, IPipeProcessor +public class MyEsolangProcessor : IEventProcessor { public MyProgram Program { get; } - public MyEsolangProcessor(MyProgram program) - { - Program = program; - } - - // Text-based I/O - public int RunToEnd(TextReader? input = null, TextWriter? output = null, CancellationToken cancellationToken = default) - { - // Execute program with text I/O, return exit code - return 0; - } - - public ValueTask RunToEndAsync(TextReader? input = null, TextWriter? output = null, CancellationToken cancellationToken = default) - { - // Async variant - return new ValueTask(0); - } - - // Pipe-based I/O - public int RunToEnd(PipeReader input, PipeWriter output, CancellationToken cancellationToken = default) - { - // Execute program with pipe I/O, return exit code - return 0; - } - - public ValueTask RunToEndAsync(PipeReader input, PipeWriter output, CancellationToken cancellationToken = default) + public IAsyncEnumerable RunAsyncEnumerable(CancellationToken cancellationToken = default) { - // Async variant - return new ValueTask(0); + // Implement the execution logic yielding IOEvents (InputCharEvent, OutputCharEvent, etc.) } } ``` From ce2124314c6966c5889f33b8ef3808230275b8a1 Mon Sep 17 00:00:00 2001 From: juner Date: Wed, 27 May 2026 14:56:15 +0900 Subject: [PATCH 04/49] feat: add Esolang.Generator.Abstractions project --- Esolang.Abstractions.slnx | 1 + .../Esolang.Generator.Abstractions.csproj | 10 ++++++++++ Generator.Abstractions/KnownTypes.cs | 11 +++++++++++ 3 files changed, 22 insertions(+) create mode 100644 Generator.Abstractions/Esolang.Generator.Abstractions.csproj create mode 100644 Generator.Abstractions/KnownTypes.cs diff --git a/Esolang.Abstractions.slnx b/Esolang.Abstractions.slnx index fc58da8..1489e2e 100644 --- a/Esolang.Abstractions.slnx +++ b/Esolang.Abstractions.slnx @@ -15,4 +15,5 @@ + \ No newline at end of file diff --git a/Generator.Abstractions/Esolang.Generator.Abstractions.csproj b/Generator.Abstractions/Esolang.Generator.Abstractions.csproj new file mode 100644 index 0000000..ed96d00 --- /dev/null +++ b/Generator.Abstractions/Esolang.Generator.Abstractions.csproj @@ -0,0 +1,10 @@ + + + + netstandard2.0;netstandard2.1 + enable + enable + true + + + diff --git a/Generator.Abstractions/KnownTypes.cs b/Generator.Abstractions/KnownTypes.cs new file mode 100644 index 0000000..3aa8fd6 --- /dev/null +++ b/Generator.Abstractions/KnownTypes.cs @@ -0,0 +1,11 @@ +namespace Esolang.Generator; + +/// +/// Provides commonly used types and constants for Esolang code generators. +/// +public static class KnownTypes +{ + // ジェネレーター間で共有される基本的な型定義をここに配置します。 + // 例: + // public const string GeneratedCodeAttribute = "System.CodeDom.Compiler.GeneratedCodeAttribute"; +} From c69b0bc73fde650d21694996b47d998b23d40c72 Mon Sep 17 00:00:00 2001 From: juner Date: Wed, 27 May 2026 15:03:52 +0900 Subject: [PATCH 05/49] refactor: adjust KnownTypes to protected readonly struct --- .../Esolang.Generator.Abstractions.csproj | 4 ++++ Generator.Abstractions/KnownTypes.cs | 24 +++++++++++++++---- 2 files changed, 23 insertions(+), 5 deletions(-) diff --git a/Generator.Abstractions/Esolang.Generator.Abstractions.csproj b/Generator.Abstractions/Esolang.Generator.Abstractions.csproj index ed96d00..0df5328 100644 --- a/Generator.Abstractions/Esolang.Generator.Abstractions.csproj +++ b/Generator.Abstractions/Esolang.Generator.Abstractions.csproj @@ -7,4 +7,8 @@ true + + + + diff --git a/Generator.Abstractions/KnownTypes.cs b/Generator.Abstractions/KnownTypes.cs index 3aa8fd6..25ff529 100644 --- a/Generator.Abstractions/KnownTypes.cs +++ b/Generator.Abstractions/KnownTypes.cs @@ -1,11 +1,25 @@ +using Microsoft.CodeAnalysis; + namespace Esolang.Generator; /// -/// Provides commonly used types and constants for Esolang code generators. +/// Provides a base structure for resolving types from a . /// -public static class KnownTypes +public readonly struct KnownTypes { - // ジェネレーター間で共有される基本的な型定義をここに配置します。 - // 例: - // public const string GeneratedCodeAttribute = "System.CodeDom.Compiler.GeneratedCodeAttribute"; + /// + /// Resolves the best for the specified metadata name. + /// + protected static INamedTypeSymbol? GetBestTypeByMetadataName(Compilation compilation, string metadataName) + { + var type = compilation.GetTypeByMetadataName(metadataName); + if (type != null) return type; + + foreach (var assembly in compilation.SourceModule.ReferencedAssemblySymbols) + { + var found = assembly.GetTypeByMetadataName(metadataName); + if (found != null) return found; + } + return null; + } } From 9ca6c754d867753f0417f22ac6e554f950ada88f Mon Sep 17 00:00:00 2001 From: juner Date: Wed, 27 May 2026 15:05:23 +0900 Subject: [PATCH 06/49] feat: standardize common generator types in Esolang.Generator.Abstractions --- Generator.Abstractions/KnownTypes.cs | 26 +++++++++++++++++++++++--- 1 file changed, 23 insertions(+), 3 deletions(-) diff --git a/Generator.Abstractions/KnownTypes.cs b/Generator.Abstractions/KnownTypes.cs index 25ff529..0da0a7f 100644 --- a/Generator.Abstractions/KnownTypes.cs +++ b/Generator.Abstractions/KnownTypes.cs @@ -3,14 +3,34 @@ namespace Esolang.Generator; /// -/// Provides a base structure for resolving types from a . +/// Defines metadata names for commonly used types in esolang source generators. /// -public readonly struct KnownTypes +public static class KnownTypeNames +{ + public const string Task = "System.Threading.Tasks.Task"; + public const string TaskT = "System.Threading.Tasks.Task`1"; + public const string ValueTask = "System.Threading.Tasks.ValueTask"; + public const string ValueTaskT = "System.Threading.Tasks.ValueTask`1"; + public const string IEnumerableT = "System.Collections.Generic.IEnumerable`1"; + public const string IAsyncEnumerableT = "System.Collections.Generic.IAsyncEnumerable`1"; + public const string PipeReader = "System.IO.Pipelines.PipeReader"; + public const string PipeWriter = "System.IO.Pipelines.PipeWriter"; + public const string TextReader = "System.IO.TextReader"; + public const string TextWriter = "System.IO.TextWriter"; + public const string CancellationToken = "System.Threading.CancellationToken"; + public const string ILogger = "Microsoft.Extensions.Logging.ILogger"; + public const string ILoggerT = "Microsoft.Extensions.Logging.ILogger`1"; +} + +/// +/// Provides utility methods for resolving types from a . +/// +public static class TypeResolutionExtensions { /// /// Resolves the best for the specified metadata name. /// - protected static INamedTypeSymbol? GetBestTypeByMetadataName(Compilation compilation, string metadataName) + public static INamedTypeSymbol? GetBestTypeByMetadataName(this Compilation compilation, string metadataName) { var type = compilation.GetTypeByMetadataName(metadataName); if (type != null) return type; From 8d521c919268262b376fd111bcb1b0aad1467637 Mon Sep 17 00:00:00 2001 From: juner Date: Wed, 27 May 2026 15:23:01 +0900 Subject: [PATCH 07/49] feat: complete KnownTypes standardization and nullable handling in Generator.Abstractions --- Generator.Abstractions/KnownTypes.cs | 85 +++++++++++++++++++++++----- 1 file changed, 70 insertions(+), 15 deletions(-) diff --git a/Generator.Abstractions/KnownTypes.cs b/Generator.Abstractions/KnownTypes.cs index 0da0a7f..8bf5a3a 100644 --- a/Generator.Abstractions/KnownTypes.cs +++ b/Generator.Abstractions/KnownTypes.cs @@ -3,23 +3,78 @@ namespace Esolang.Generator; /// -/// Defines metadata names for commonly used types in esolang source generators. +/// Holds resolved type symbols for a compilation. /// -public static class KnownTypeNames +public readonly struct KnownTypes { - public const string Task = "System.Threading.Tasks.Task"; - public const string TaskT = "System.Threading.Tasks.Task`1"; - public const string ValueTask = "System.Threading.Tasks.ValueTask"; - public const string ValueTaskT = "System.Threading.Tasks.ValueTask`1"; - public const string IEnumerableT = "System.Collections.Generic.IEnumerable`1"; - public const string IAsyncEnumerableT = "System.Collections.Generic.IAsyncEnumerable`1"; - public const string PipeReader = "System.IO.Pipelines.PipeReader"; - public const string PipeWriter = "System.IO.Pipelines.PipeWriter"; - public const string TextReader = "System.IO.TextReader"; - public const string TextWriter = "System.IO.TextWriter"; - public const string CancellationToken = "System.Threading.CancellationToken"; - public const string ILogger = "Microsoft.Extensions.Logging.ILogger"; - public const string ILoggerT = "Microsoft.Extensions.Logging.ILogger`1"; +#pragma warning disable CS1591 + public readonly INamedTypeSymbol? String; + public readonly INamedTypeSymbol? Task; + public readonly INamedTypeSymbol? TaskT; + public readonly INamedTypeSymbol? ValueTask; + public readonly INamedTypeSymbol? ValueTaskT; + public readonly INamedTypeSymbol? IEnumerableT; + public readonly INamedTypeSymbol? IAsyncEnumerableT; + public readonly INamedTypeSymbol? PipeReader; + public readonly INamedTypeSymbol? PipeWriter; + public readonly INamedTypeSymbol? TextReader; + public readonly INamedTypeSymbol? TextWriter; + public readonly INamedTypeSymbol? CancellationToken; + public readonly INamedTypeSymbol? ILogger; + public readonly INamedTypeSymbol? ILoggerT; + + public KnownTypes(Compilation compilation) + { + String = compilation.GetSpecialType(SpecialType.System_String); + + Task = compilation.GetBestTypeByMetadataName("System.Threading.Tasks.Task"); + TaskT = compilation.GetBestTypeByMetadataName("System.Threading.Tasks.Task`1"); + ValueTask = compilation.GetBestTypeByMetadataName("System.Threading.Tasks.ValueTask"); + ValueTaskT = compilation.GetBestTypeByMetadataName("System.Threading.Tasks.ValueTask`1"); + IEnumerableT = compilation.GetBestTypeByMetadataName("System.Collections.Generic.IEnumerable`1"); + IAsyncEnumerableT = compilation.GetBestTypeByMetadataName("System.Collections.Generic.IAsyncEnumerable`1"); + PipeReader = compilation.GetBestTypeByMetadataName("System.IO.Pipelines.PipeReader"); + PipeWriter = compilation.GetBestTypeByMetadataName("System.IO.Pipelines.PipeWriter"); + TextReader = compilation.GetBestTypeByMetadataName("System.IO.TextReader"); + TextWriter = compilation.GetBestTypeByMetadataName("System.IO.TextWriter"); + CancellationToken = compilation.GetBestTypeByMetadataName("System.Threading.CancellationToken"); + ILogger = compilation.GetBestTypeByMetadataName("Microsoft.Extensions.Logging.ILogger"); + ILoggerT = compilation.GetBestTypeByMetadataName("Microsoft.Extensions.Logging.ILogger`1"); + } + + private static ITypeSymbol? Unwrap(ITypeSymbol? type) + { + if (type is INamedTypeSymbol namedType && namedType.ConstructedFrom.SpecialType == SpecialType.System_Nullable_T) + { + return namedType.TypeArguments[0]; + } + return type; + } + + private static bool EqualsDefinition(ITypeSymbol? type, ISymbol? symbol) => + type != null && symbol != null && SymbolEqualityComparer.Default.Equals(Unwrap(type)?.OriginalDefinition, symbol); + + private static bool EqualsType(ITypeSymbol? type, ISymbol? symbol) => + type != null && symbol != null && SymbolEqualityComparer.Default.Equals(Unwrap(type)?.WithNullableAnnotation(NullableAnnotation.None), symbol); + + public bool IsString(ITypeSymbol? type) => EqualsType(type, String); + public bool IsTask(ITypeSymbol? type) => EqualsType(type, Task); + public bool IsTaskT(ITypeSymbol? type) => EqualsDefinition(type, TaskT); + public bool IsValueTask(ITypeSymbol? type) => EqualsType(type, ValueTask); + public bool IsValueTaskT(ITypeSymbol? type) => EqualsDefinition(type, ValueTaskT); + public bool IsIEnumerableT(ITypeSymbol? type) => EqualsDefinition(type, IEnumerableT); + public bool IsIAsyncEnumerableT(ITypeSymbol? type) => EqualsDefinition(type, IAsyncEnumerableT); + public bool IsPipeReader(ITypeSymbol? type) => EqualsType(type, PipeReader); + public bool IsPipeWriter(ITypeSymbol? type) => EqualsType(type, PipeWriter); + public bool IsTextReader(ITypeSymbol? type) => EqualsType(type, TextReader); + public bool IsTextWriter(ITypeSymbol? type) => EqualsType(type, TextWriter); + public bool IsCancellationToken(ITypeSymbol? type) => EqualsType(type, CancellationToken); + public bool IsILogger(ITypeSymbol? type) => EqualsType(type, ILogger); + public bool IsILoggerT(ITypeSymbol? type) => EqualsDefinition(type, ILoggerT); + + public bool IsTaskString(ITypeSymbol? type) => IsTaskT(type) && ((INamedTypeSymbol)Unwrap(type)!).TypeArguments[0].SpecialType == SpecialType.System_String; + public bool IsValueTaskString(ITypeSymbol? type) => IsValueTaskT(type) && ((INamedTypeSymbol)Unwrap(type)!).TypeArguments[0].SpecialType == SpecialType.System_String; +#pragma warning restore CS1591 } /// From 3a0e44c0b41219f8a76e118af6d64d2d225d018c Mon Sep 17 00:00:00 2001 From: juner Date: Wed, 27 May 2026 15:44:16 +0900 Subject: [PATCH 08/49] feat: finalize KnownTypes implementation in Esolang.Generator.Abstractions --- Generator.Abstractions/KnownTypes.cs | 30 ++++++++++++++++++++++------ 1 file changed, 24 insertions(+), 6 deletions(-) diff --git a/Generator.Abstractions/KnownTypes.cs b/Generator.Abstractions/KnownTypes.cs index 8bf5a3a..ec52bb5 100644 --- a/Generator.Abstractions/KnownTypes.cs +++ b/Generator.Abstractions/KnownTypes.cs @@ -22,10 +22,20 @@ public readonly struct KnownTypes public readonly INamedTypeSymbol? CancellationToken; public readonly INamedTypeSymbol? ILogger; public readonly INamedTypeSymbol? ILoggerT; + + // Brainfuck compatibility + public readonly INamedTypeSymbol? TaskInt; + public readonly INamedTypeSymbol? TaskString; + public readonly INamedTypeSymbol? ValueTaskInt; + public readonly INamedTypeSymbol? ValueTaskString; + public readonly INamedTypeSymbol? IEnumerableByte; + public readonly INamedTypeSymbol? IAsyncEnumerableByte; public KnownTypes(Compilation compilation) { String = compilation.GetSpecialType(SpecialType.System_String); + var byteSymbol = compilation.GetSpecialType(SpecialType.System_Byte); + var intSymbol = compilation.GetSpecialType(SpecialType.System_Int32); Task = compilation.GetBestTypeByMetadataName("System.Threading.Tasks.Task"); TaskT = compilation.GetBestTypeByMetadataName("System.Threading.Tasks.Task`1"); @@ -40,6 +50,13 @@ public KnownTypes(Compilation compilation) CancellationToken = compilation.GetBestTypeByMetadataName("System.Threading.CancellationToken"); ILogger = compilation.GetBestTypeByMetadataName("Microsoft.Extensions.Logging.ILogger"); ILoggerT = compilation.GetBestTypeByMetadataName("Microsoft.Extensions.Logging.ILogger`1"); + + TaskInt = TaskT?.Construct(intSymbol); + TaskString = TaskT?.Construct(String); + ValueTaskInt = ValueTaskT?.Construct(intSymbol); + ValueTaskString = ValueTaskT?.Construct(String); + IEnumerableByte = IEnumerableT?.Construct(byteSymbol); + IAsyncEnumerableByte = IAsyncEnumerableT?.Construct(byteSymbol); } private static ITypeSymbol? Unwrap(ITypeSymbol? type) @@ -62,18 +79,19 @@ private static bool EqualsType(ITypeSymbol? type, ISymbol? symbol) => public bool IsTaskT(ITypeSymbol? type) => EqualsDefinition(type, TaskT); public bool IsValueTask(ITypeSymbol? type) => EqualsType(type, ValueTask); public bool IsValueTaskT(ITypeSymbol? type) => EqualsDefinition(type, ValueTaskT); - public bool IsIEnumerableT(ITypeSymbol? type) => EqualsDefinition(type, IEnumerableT); - public bool IsIAsyncEnumerableT(ITypeSymbol? type) => EqualsDefinition(type, IAsyncEnumerableT); public bool IsPipeReader(ITypeSymbol? type) => EqualsType(type, PipeReader); public bool IsPipeWriter(ITypeSymbol? type) => EqualsType(type, PipeWriter); public bool IsTextReader(ITypeSymbol? type) => EqualsType(type, TextReader); public bool IsTextWriter(ITypeSymbol? type) => EqualsType(type, TextWriter); public bool IsCancellationToken(ITypeSymbol? type) => EqualsType(type, CancellationToken); - public bool IsILogger(ITypeSymbol? type) => EqualsType(type, ILogger); - public bool IsILoggerT(ITypeSymbol? type) => EqualsDefinition(type, ILoggerT); - public bool IsTaskString(ITypeSymbol? type) => IsTaskT(type) && ((INamedTypeSymbol)Unwrap(type)!).TypeArguments[0].SpecialType == SpecialType.System_String; - public bool IsValueTaskString(ITypeSymbol? type) => IsValueTaskT(type) && ((INamedTypeSymbol)Unwrap(type)!).TypeArguments[0].SpecialType == SpecialType.System_String; + // Brainfuck compatibility helpers + public bool IsTaskInt(ITypeSymbol? type) => EqualsType(type, TaskInt); + public bool IsTaskString(ITypeSymbol? type) => EqualsType(type, TaskString); + public bool IsValueTaskInt(ITypeSymbol? type) => EqualsType(type, ValueTaskInt); + public bool IsValueTaskString(ITypeSymbol? type) => EqualsType(type, ValueTaskString); + public bool IsIEnumerableByte(ITypeSymbol? type) => EqualsType(type, IEnumerableByte); + public bool IsIAsyncEnumerableByte(ITypeSymbol? type) => EqualsType(type, IAsyncEnumerableByte); #pragma warning restore CS1591 } From 1345edbb1e3300d600e4837f24b267c5ed50ca68 Mon Sep 17 00:00:00 2001 From: juner Date: Wed, 27 May 2026 18:50:08 +0900 Subject: [PATCH 09/49] =?UTF-8?q?=E3=81=A1=E3=82=87=E3=81=A3=E3=81=A8?= =?UTF-8?q?=E3=82=B3=E3=83=9F=E3=83=83=E3=83=88?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Generator.Abstractions/KnownTypes.cs | 55 +++++++++------------------- 1 file changed, 17 insertions(+), 38 deletions(-) diff --git a/Generator.Abstractions/KnownTypes.cs b/Generator.Abstractions/KnownTypes.cs index ec52bb5..1fb1fee 100644 --- a/Generator.Abstractions/KnownTypes.cs +++ b/Generator.Abstractions/KnownTypes.cs @@ -22,20 +22,10 @@ public readonly struct KnownTypes public readonly INamedTypeSymbol? CancellationToken; public readonly INamedTypeSymbol? ILogger; public readonly INamedTypeSymbol? ILoggerT; - - // Brainfuck compatibility - public readonly INamedTypeSymbol? TaskInt; - public readonly INamedTypeSymbol? TaskString; - public readonly INamedTypeSymbol? ValueTaskInt; - public readonly INamedTypeSymbol? ValueTaskString; - public readonly INamedTypeSymbol? IEnumerableByte; - public readonly INamedTypeSymbol? IAsyncEnumerableByte; public KnownTypes(Compilation compilation) { String = compilation.GetSpecialType(SpecialType.System_String); - var byteSymbol = compilation.GetSpecialType(SpecialType.System_Byte); - var intSymbol = compilation.GetSpecialType(SpecialType.System_Int32); Task = compilation.GetBestTypeByMetadataName("System.Threading.Tasks.Task"); TaskT = compilation.GetBestTypeByMetadataName("System.Threading.Tasks.Task`1"); @@ -50,48 +40,37 @@ public KnownTypes(Compilation compilation) CancellationToken = compilation.GetBestTypeByMetadataName("System.Threading.CancellationToken"); ILogger = compilation.GetBestTypeByMetadataName("Microsoft.Extensions.Logging.ILogger"); ILoggerT = compilation.GetBestTypeByMetadataName("Microsoft.Extensions.Logging.ILogger`1"); - - TaskInt = TaskT?.Construct(intSymbol); - TaskString = TaskT?.Construct(String); - ValueTaskInt = ValueTaskT?.Construct(intSymbol); - ValueTaskString = ValueTaskT?.Construct(String); - IEnumerableByte = IEnumerableT?.Construct(byteSymbol); - IAsyncEnumerableByte = IAsyncEnumerableT?.Construct(byteSymbol); - } - - private static ITypeSymbol? Unwrap(ITypeSymbol? type) - { - if (type is INamedTypeSymbol namedType && namedType.ConstructedFrom.SpecialType == SpecialType.System_Nullable_T) - { - return namedType.TypeArguments[0]; - } - return type; } private static bool EqualsDefinition(ITypeSymbol? type, ISymbol? symbol) => - type != null && symbol != null && SymbolEqualityComparer.Default.Equals(Unwrap(type)?.OriginalDefinition, symbol); + type != null && symbol != null && SymbolEqualityComparer.Default.Equals(type.OriginalDefinition, symbol); private static bool EqualsType(ITypeSymbol? type, ISymbol? symbol) => - type != null && symbol != null && SymbolEqualityComparer.Default.Equals(Unwrap(type)?.WithNullableAnnotation(NullableAnnotation.None), symbol); + type != null && symbol != null && SymbolEqualityComparer.Default.Equals(type, symbol); + + public bool IsString(ITypeSymbol? type, bool? isNullable = null) => + type != null && SymbolEqualityComparer.Default.Equals(type, String) && (isNullable == null || type.NullableAnnotation == (isNullable.Value ? NullableAnnotation.Annotated : NullableAnnotation.NotAnnotated)); - public bool IsString(ITypeSymbol? type) => EqualsType(type, String); public bool IsTask(ITypeSymbol? type) => EqualsType(type, Task); - public bool IsTaskT(ITypeSymbol? type) => EqualsDefinition(type, TaskT); + public bool IsTaskT(ITypeSymbol? type, bool? isNullable = null) + { + if (type is not INamedTypeSymbol named || !SymbolEqualityComparer.Default.Equals(named.ConstructedFrom, TaskT)) return false; + return isNullable == null || named.TypeArguments[0].NullableAnnotation == (isNullable.Value ? NullableAnnotation.Annotated : NullableAnnotation.NotAnnotated); + } public bool IsValueTask(ITypeSymbol? type) => EqualsType(type, ValueTask); - public bool IsValueTaskT(ITypeSymbol? type) => EqualsDefinition(type, ValueTaskT); + public bool IsValueTaskT(ITypeSymbol? type, bool? isNullable = null) + { + if (type is not INamedTypeSymbol named || !SymbolEqualityComparer.Default.Equals(named.ConstructedFrom, ValueTaskT)) return false; + return isNullable == null || named.TypeArguments[0].NullableAnnotation == (isNullable.Value ? NullableAnnotation.Annotated : NullableAnnotation.NotAnnotated); + } public bool IsPipeReader(ITypeSymbol? type) => EqualsType(type, PipeReader); public bool IsPipeWriter(ITypeSymbol? type) => EqualsType(type, PipeWriter); public bool IsTextReader(ITypeSymbol? type) => EqualsType(type, TextReader); public bool IsTextWriter(ITypeSymbol? type) => EqualsType(type, TextWriter); public bool IsCancellationToken(ITypeSymbol? type) => EqualsType(type, CancellationToken); - // Brainfuck compatibility helpers - public bool IsTaskInt(ITypeSymbol? type) => EqualsType(type, TaskInt); - public bool IsTaskString(ITypeSymbol? type) => EqualsType(type, TaskString); - public bool IsValueTaskInt(ITypeSymbol? type) => EqualsType(type, ValueTaskInt); - public bool IsValueTaskString(ITypeSymbol? type) => EqualsType(type, ValueTaskString); - public bool IsIEnumerableByte(ITypeSymbol? type) => EqualsType(type, IEnumerableByte); - public bool IsIAsyncEnumerableByte(ITypeSymbol? type) => EqualsType(type, IAsyncEnumerableByte); + public bool IsTaskString(ITypeSymbol? type, bool? isNullable = null) => IsTaskT(type, isNullable) && ((INamedTypeSymbol)type!).TypeArguments[0].SpecialType == SpecialType.System_String; + public bool IsValueTaskString(ITypeSymbol? type, bool? isNullable = null) => IsValueTaskT(type, isNullable) && ((INamedTypeSymbol)type!).TypeArguments[0].SpecialType == SpecialType.System_String; #pragma warning restore CS1591 } From 681c5540663fe565b8f85ed40fb76165db7b5326 Mon Sep 17 00:00:00 2001 From: juner Date: Wed, 27 May 2026 18:50:51 +0900 Subject: [PATCH 10/49] dotnet format --- Generator.Abstractions/KnownTypes.cs | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/Generator.Abstractions/KnownTypes.cs b/Generator.Abstractions/KnownTypes.cs index 1fb1fee..32d2130 100644 --- a/Generator.Abstractions/KnownTypes.cs +++ b/Generator.Abstractions/KnownTypes.cs @@ -26,7 +26,7 @@ public readonly struct KnownTypes public KnownTypes(Compilation compilation) { String = compilation.GetSpecialType(SpecialType.System_String); - + Task = compilation.GetBestTypeByMetadataName("System.Threading.Tasks.Task"); TaskT = compilation.GetBestTypeByMetadataName("System.Threading.Tasks.Task`1"); ValueTask = compilation.GetBestTypeByMetadataName("System.Threading.Tasks.ValueTask"); @@ -42,13 +42,13 @@ public KnownTypes(Compilation compilation) ILoggerT = compilation.GetBestTypeByMetadataName("Microsoft.Extensions.Logging.ILogger`1"); } - private static bool EqualsDefinition(ITypeSymbol? type, ISymbol? symbol) => + private static bool EqualsDefinition(ITypeSymbol? type, ISymbol? symbol) => type != null && symbol != null && SymbolEqualityComparer.Default.Equals(type.OriginalDefinition, symbol); - - private static bool EqualsType(ITypeSymbol? type, ISymbol? symbol) => + + private static bool EqualsType(ITypeSymbol? type, ISymbol? symbol) => type != null && symbol != null && SymbolEqualityComparer.Default.Equals(type, symbol); - public bool IsString(ITypeSymbol? type, bool? isNullable = null) => + public bool IsString(ITypeSymbol? type, bool? isNullable = null) => type != null && SymbolEqualityComparer.Default.Equals(type, String) && (isNullable == null || type.NullableAnnotation == (isNullable.Value ? NullableAnnotation.Annotated : NullableAnnotation.NotAnnotated)); public bool IsTask(ITypeSymbol? type) => EqualsType(type, Task); @@ -68,7 +68,7 @@ public bool IsValueTaskT(ITypeSymbol? type, bool? isNullable = null) public bool IsTextReader(ITypeSymbol? type) => EqualsType(type, TextReader); public bool IsTextWriter(ITypeSymbol? type) => EqualsType(type, TextWriter); public bool IsCancellationToken(ITypeSymbol? type) => EqualsType(type, CancellationToken); - + public bool IsTaskString(ITypeSymbol? type, bool? isNullable = null) => IsTaskT(type, isNullable) && ((INamedTypeSymbol)type!).TypeArguments[0].SpecialType == SpecialType.System_String; public bool IsValueTaskString(ITypeSymbol? type, bool? isNullable = null) => IsValueTaskT(type, isNullable) && ((INamedTypeSymbol)type!).TypeArguments[0].SpecialType == SpecialType.System_String; #pragma warning restore CS1591 From 12ae5588beabf9c4578e0d633664bf858a1ef0dd Mon Sep 17 00:00:00 2001 From: juner Date: Thu, 28 May 2026 00:46:21 +0900 Subject: [PATCH 11/49] Add common generator abstractions for method signature binding and type resolution --- Generator.Abstractions/KnownTypes.cs | 31 ++- Generator.Abstractions/MethodInputKind.cs | 16 ++ Generator.Abstractions/MethodOutputKind.cs | 20 ++ Generator.Abstractions/MethodReturnKind.cs | 38 +++ .../MethodSignatureBinder.cs | 218 ++++++++++++++++++ .../MethodSignatureBinding.cs | 43 ++++ 6 files changed, 364 insertions(+), 2 deletions(-) create mode 100644 Generator.Abstractions/MethodInputKind.cs create mode 100644 Generator.Abstractions/MethodOutputKind.cs create mode 100644 Generator.Abstractions/MethodReturnKind.cs create mode 100644 Generator.Abstractions/MethodSignatureBinder.cs create mode 100644 Generator.Abstractions/MethodSignatureBinding.cs diff --git a/Generator.Abstractions/KnownTypes.cs b/Generator.Abstractions/KnownTypes.cs index 32d2130..930bcf8 100644 --- a/Generator.Abstractions/KnownTypes.cs +++ b/Generator.Abstractions/KnownTypes.cs @@ -9,6 +9,8 @@ public readonly struct KnownTypes { #pragma warning disable CS1591 public readonly INamedTypeSymbol? String; + public readonly INamedTypeSymbol? Byte; + public readonly INamedTypeSymbol? Int32; public readonly INamedTypeSymbol? Task; public readonly INamedTypeSymbol? TaskT; public readonly INamedTypeSymbol? ValueTask; @@ -26,6 +28,8 @@ public readonly struct KnownTypes public KnownTypes(Compilation compilation) { String = compilation.GetSpecialType(SpecialType.System_String); + Byte = compilation.GetSpecialType(SpecialType.System_Byte); + Int32 = compilation.GetSpecialType(SpecialType.System_Int32); Task = compilation.GetBestTypeByMetadataName("System.Threading.Tasks.Task"); TaskT = compilation.GetBestTypeByMetadataName("System.Threading.Tasks.Task`1"); @@ -51,18 +55,24 @@ private static bool EqualsType(ITypeSymbol? type, ISymbol? symbol) => public bool IsString(ITypeSymbol? type, bool? isNullable = null) => type != null && SymbolEqualityComparer.Default.Equals(type, String) && (isNullable == null || type.NullableAnnotation == (isNullable.Value ? NullableAnnotation.Annotated : NullableAnnotation.NotAnnotated)); + public bool IsByte(ITypeSymbol? type) => EqualsType(type, Byte); + public bool IsInt32(ITypeSymbol? type) => EqualsType(type, Int32); + public bool IsTask(ITypeSymbol? type) => EqualsType(type, Task); public bool IsTaskT(ITypeSymbol? type, bool? isNullable = null) { - if (type is not INamedTypeSymbol named || !SymbolEqualityComparer.Default.Equals(named.ConstructedFrom, TaskT)) return false; + if (type is not INamedTypeSymbol named || !EqualsDefinition(named, TaskT)) return false; return isNullable == null || named.TypeArguments[0].NullableAnnotation == (isNullable.Value ? NullableAnnotation.Annotated : NullableAnnotation.NotAnnotated); } public bool IsValueTask(ITypeSymbol? type) => EqualsType(type, ValueTask); public bool IsValueTaskT(ITypeSymbol? type, bool? isNullable = null) { - if (type is not INamedTypeSymbol named || !SymbolEqualityComparer.Default.Equals(named.ConstructedFrom, ValueTaskT)) return false; + if (type is not INamedTypeSymbol named || !EqualsDefinition(named, ValueTaskT)) return false; return isNullable == null || named.TypeArguments[0].NullableAnnotation == (isNullable.Value ? NullableAnnotation.Annotated : NullableAnnotation.NotAnnotated); } + public bool IsIEnumerableT(ITypeSymbol? type) => EqualsDefinition(type, IEnumerableT); + public bool IsIAsyncEnumerableT(ITypeSymbol? type) => EqualsDefinition(type, IAsyncEnumerableT); + public bool IsPipeReader(ITypeSymbol? type) => EqualsType(type, PipeReader); public bool IsPipeWriter(ITypeSymbol? type) => EqualsType(type, PipeWriter); public bool IsTextReader(ITypeSymbol? type) => EqualsType(type, TextReader); @@ -71,6 +81,23 @@ public bool IsValueTaskT(ITypeSymbol? type, bool? isNullable = null) public bool IsTaskString(ITypeSymbol? type, bool? isNullable = null) => IsTaskT(type, isNullable) && ((INamedTypeSymbol)type!).TypeArguments[0].SpecialType == SpecialType.System_String; public bool IsValueTaskString(ITypeSymbol? type, bool? isNullable = null) => IsValueTaskT(type, isNullable) && ((INamedTypeSymbol)type!).TypeArguments[0].SpecialType == SpecialType.System_String; + + public bool IsTaskInt32(ITypeSymbol? type) => IsTaskT(type) && ((INamedTypeSymbol)type!).TypeArguments[0].SpecialType == SpecialType.System_Int32; + public bool IsValueTaskInt32(ITypeSymbol? type) => IsValueTaskT(type) && ((INamedTypeSymbol)type!).TypeArguments[0].SpecialType == SpecialType.System_Int32; + + public bool IsIEnumerableByte(ITypeSymbol? type) => IsIEnumerableT(type) && ((INamedTypeSymbol)type!).TypeArguments[0].SpecialType == SpecialType.System_Byte; + public bool IsIAsyncEnumerableByte(ITypeSymbol? type) => IsIAsyncEnumerableT(type) && ((INamedTypeSymbol)type!).TypeArguments[0].SpecialType == SpecialType.System_Byte; + + public bool IsLogger(ITypeSymbol? type) + { + if (type == null) return false; + if (EqualsType(type, ILogger) || EqualsDefinition(type, ILoggerT)) return true; + foreach (var iface in type.AllInterfaces) + { + if (EqualsType(iface, ILogger) || EqualsDefinition(iface, ILoggerT)) return true; + } + return false; + } #pragma warning restore CS1591 } diff --git a/Generator.Abstractions/MethodInputKind.cs b/Generator.Abstractions/MethodInputKind.cs new file mode 100644 index 0000000..940f224 --- /dev/null +++ b/Generator.Abstractions/MethodInputKind.cs @@ -0,0 +1,16 @@ +namespace Esolang.Generator; + +/// +/// Specifies the input mechanism of the generated method. +/// +public enum MethodInputKind +{ + /// No explicit input mechanism. + None, + /// Input is provided via a string parameter. + String, + /// Input is provided via a TextReader parameter. + TextReader, + /// Input is provided via a PipeReader parameter. + PipeReader, +} diff --git a/Generator.Abstractions/MethodOutputKind.cs b/Generator.Abstractions/MethodOutputKind.cs new file mode 100644 index 0000000..b6d46d2 --- /dev/null +++ b/Generator.Abstractions/MethodOutputKind.cs @@ -0,0 +1,20 @@ +namespace Esolang.Generator; + +/// +/// Specifies the output mechanism of the generated method. +/// +public enum MethodOutputKind +{ + /// No explicit output mechanism. + None, + /// Output is written to a TextWriter parameter. + TextWriter, + /// Output is written to a PipeWriter parameter. + PipeWriter, + /// Output is returned as a string. + ReturnString, + /// Output is yielded via IEnumerable<byte>. + ReturnIEnumerable, + /// Output is yielded via IAsyncEnumerable<byte>. + ReturnIAsyncEnumerable, +} diff --git a/Generator.Abstractions/MethodReturnKind.cs b/Generator.Abstractions/MethodReturnKind.cs new file mode 100644 index 0000000..e0c7f13 --- /dev/null +++ b/Generator.Abstractions/MethodReturnKind.cs @@ -0,0 +1,38 @@ +namespace Esolang.Generator; + +/// +/// Specifies the return type of the generated method. +/// +public enum MethodReturnKind +{ + /// The return type is invalid or unsupported. + Invalid, + /// The method returns void. + Void, + /// The method returns int. + Int32, + /// The method returns string. + String, + /// The method returns string (nullable). + NullableString, + /// The method returns Task. + Task, + /// The method returns Task<int>. + TaskInt32, + /// The method returns Task<string>. + TaskString, + /// The method returns Task<string?>. + TaskNullableString, + /// The method returns ValueTask. + ValueTask, + /// The method returns ValueTask<int>. + ValueTaskInt32, + /// The method returns ValueTask<string>. + ValueTaskString, + /// The method returns ValueTask<string?>. + ValueTaskNullableString, + /// The method returns IEnumerable<byte>. + IEnumerableByte, + /// The method returns IAsyncEnumerable<byte>. + IAsyncEnumerableByte, +} diff --git a/Generator.Abstractions/MethodSignatureBinder.cs b/Generator.Abstractions/MethodSignatureBinder.cs new file mode 100644 index 0000000..06ba843 --- /dev/null +++ b/Generator.Abstractions/MethodSignatureBinder.cs @@ -0,0 +1,218 @@ +using Microsoft.CodeAnalysis; +using System; +using System.Collections.Generic; +using System.Linq; + +namespace Esolang.Generator; + +/// +/// Provides utility methods for binding method signatures to . +/// +public static class MethodSignatureBinder +{ + /// + /// Binds the specified method symbol to a . + /// + /// The method symbol to bind. + /// The known types for the compilation. + /// The error ID to use if the return type is invalid. + /// The error ID to use if a parameter is invalid. + /// The error ID to use if a parameter type is duplicated. + /// The error ID to use if there is a conflict between the return type and output parameters. + /// The result of the binding. + public static MethodSignatureBinding Bind( + IMethodSymbol method, + KnownTypes types, + string invalidReturnTypeErrorId = "ES0001", + string invalidParameterErrorId = "ES0002", + string duplicateParameterErrorId = "ES0003", + string returnOutputConflictErrorId = "ES0004") + { + var returnKind = BindReturnKind(method.ReturnType, types); + if (returnKind == MethodReturnKind.Invalid) + { + return new MethodSignatureBinding(false, returnKind, MethodInputKind.None, MethodOutputKind.None, "", "", null, null, false, method.Parameters, invalidReturnTypeErrorId); + } + + var outputKind = BindDefaultOutputKind(returnKind); + var inputKind = MethodInputKind.None; + var inputExpr = ""; + var outputExpr = ""; + string? cancellationTokenName = null; + string? loggerExpression = null; + var isLoggerFromParameter = false; + var unhandledParameters = new List(); + + foreach (var p in method.Parameters) + { + if (p.RefKind != RefKind.None) + { + return new MethodSignatureBinding(false, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, invalidParameterErrorId, p.Locations.FirstOrDefault()); + } + + if (types.IsString(p.Type, false)) + { + if (inputKind != MethodInputKind.None) + return new MethodSignatureBinding(false, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, duplicateParameterErrorId, p.Locations.FirstOrDefault()); + + inputKind = MethodInputKind.String; + inputExpr = p.Name; + continue; + } + + if (types.IsTextReader(p.Type)) + { + if (inputKind != MethodInputKind.None) + return new MethodSignatureBinding(false, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, duplicateParameterErrorId, p.Locations.FirstOrDefault()); + + inputKind = MethodInputKind.TextReader; + inputExpr = p.Name; + continue; + } + + if (types.IsPipeReader(p.Type)) + { + if (inputKind != MethodInputKind.None) + return new MethodSignatureBinding(false, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, duplicateParameterErrorId, p.Locations.FirstOrDefault()); + + inputKind = MethodInputKind.PipeReader; + inputExpr = p.Name; + continue; + } + + if (types.IsTextWriter(p.Type)) + { + if (IsOutputReturning(returnKind)) + return new MethodSignatureBinding(false, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, returnOutputConflictErrorId, p.Locations.FirstOrDefault()); + + if (outputKind != MethodOutputKind.None) + return new MethodSignatureBinding(false, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, duplicateParameterErrorId, p.Locations.FirstOrDefault()); + + outputKind = MethodOutputKind.TextWriter; + outputExpr = p.Name; + continue; + } + + if (types.IsPipeWriter(p.Type)) + { + if (IsOutputReturning(returnKind)) + return new MethodSignatureBinding(false, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, returnOutputConflictErrorId, p.Locations.FirstOrDefault()); + + if (outputKind != MethodOutputKind.None) + return new MethodSignatureBinding(false, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, duplicateParameterErrorId, p.Locations.FirstOrDefault()); + + outputKind = MethodOutputKind.PipeWriter; + outputExpr = p.Name; + continue; + } + + if (types.IsCancellationToken(p.Type)) + { + if (cancellationTokenName != null) + return new MethodSignatureBinding(false, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, duplicateParameterErrorId, p.Locations.FirstOrDefault()); + + cancellationTokenName = p.Name; + continue; + } + + if (types.IsLogger(p.Type)) + { + if (loggerExpression != null) + return new MethodSignatureBinding(false, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, duplicateParameterErrorId, p.Locations.FirstOrDefault()); + + loggerExpression = p.Name; + isLoggerFromParameter = true; + continue; + } + + unhandledParameters.Add(p); + } + + loggerExpression ??= FindLoggerInContainingType(method.ContainingType, method.IsStatic, types, out isLoggerFromParameter); + + return new MethodSignatureBinding(true, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, unhandledParameters); + } + + private static MethodReturnKind BindReturnKind(ITypeSymbol returnType, KnownTypes types) + { + if (returnType.SpecialType == SpecialType.System_Void) return MethodReturnKind.Void; + if (returnType.SpecialType == SpecialType.System_Int32) return MethodReturnKind.Int32; + if (types.IsString(returnType, false)) return MethodReturnKind.String; + if (types.IsString(returnType, true)) return MethodReturnKind.NullableString; + if (types.IsTask(returnType)) return MethodReturnKind.Task; + if (types.IsTaskInt32(returnType)) return MethodReturnKind.TaskInt32; + if (types.IsTaskString(returnType, false)) return MethodReturnKind.TaskString; + if (types.IsTaskString(returnType, true)) return MethodReturnKind.TaskNullableString; + if (types.IsValueTask(returnType)) return MethodReturnKind.ValueTask; + if (types.IsValueTaskInt32(returnType)) return MethodReturnKind.ValueTaskInt32; + if (types.IsValueTaskString(returnType, false)) return MethodReturnKind.ValueTaskString; + if (types.IsValueTaskString(returnType, true)) return MethodReturnKind.ValueTaskNullableString; + if (types.IsIEnumerableByte(returnType)) return MethodReturnKind.IEnumerableByte; + if (types.IsIAsyncEnumerableByte(returnType)) return MethodReturnKind.IAsyncEnumerableByte; + + return MethodReturnKind.Invalid; + } + + private static MethodOutputKind BindDefaultOutputKind(MethodReturnKind returnKind) => returnKind switch + { + MethodReturnKind.String or MethodReturnKind.NullableString or MethodReturnKind.TaskString or MethodReturnKind.TaskNullableString or MethodReturnKind.ValueTaskString or MethodReturnKind.ValueTaskNullableString => MethodOutputKind.ReturnString, + MethodReturnKind.IEnumerableByte => MethodOutputKind.ReturnIEnumerable, + MethodReturnKind.IAsyncEnumerableByte => MethodOutputKind.ReturnIAsyncEnumerable, + _ => MethodOutputKind.None + }; + + private static bool IsOutputReturning(MethodReturnKind returnKind) => returnKind switch + { + MethodReturnKind.String or MethodReturnKind.NullableString or MethodReturnKind.TaskString or MethodReturnKind.TaskNullableString or MethodReturnKind.ValueTaskString or MethodReturnKind.ValueTaskNullableString or MethodReturnKind.IEnumerableByte or MethodReturnKind.IAsyncEnumerableByte => true, + _ => false + }; + + private static string? FindLoggerInContainingType(ITypeSymbol? type, bool isStatic, KnownTypes types, out bool isFromParameter) + { + isFromParameter = false; + var currentType = type; + var shadowedNames = new HashSet(StringComparer.Ordinal); + var isBaseType = false; + + while (currentType != null) + { + foreach (var field in currentType.GetMembers().OfType()) + { + if (isStatic && !field.IsStatic) continue; + + // If searching in a base type, the field must be accessible (protected or public) + if (isBaseType && field.DeclaredAccessibility is not (Accessibility.Protected or Accessibility.ProtectedOrInternal or Accessibility.Public or Accessibility.Internal)) + continue; + + if (types.IsLogger(field.Type)) + { + return field.Name; + } + + if (field.CanBeReferencedByName) + { + shadowedNames.Add(field.Name); + } + } + currentType = currentType.BaseType; + isBaseType = true; + } + + if (type is INamedTypeSymbol namedType) + { + foreach (var constructor in namedType.InstanceConstructors) + { + foreach (var parameter in constructor.Parameters) + { + if (types.IsLogger(parameter.Type) && !shadowedNames.Contains(parameter.Name)) + { + isFromParameter = true; + return parameter.Name; + } + } + } + } + + return null; + } +} diff --git a/Generator.Abstractions/MethodSignatureBinding.cs b/Generator.Abstractions/MethodSignatureBinding.cs new file mode 100644 index 0000000..b96c265 --- /dev/null +++ b/Generator.Abstractions/MethodSignatureBinding.cs @@ -0,0 +1,43 @@ +using Microsoft.CodeAnalysis; +using System.Collections.Generic; + +namespace Esolang.Generator; + +/// +/// Represents the result of binding a method signature for generation. +/// +public record struct MethodSignatureBinding( + bool IsValid, + MethodReturnKind ReturnKind, + MethodInputKind InputKind, + MethodOutputKind OutputKind, + string InputExpression, + string OutputExpression, + string? CancellationTokenName, + string? LoggerExpression, + bool IsLoggerFromParameter, + IReadOnlyList UnhandledParameters, + string? ErrorId = null, + Location? Location = null) +{ + /// Gets a value indicating whether the method has an explicit input mechanism. + public readonly bool HasExplicitInput => InputKind != MethodInputKind.None; + + /// Gets a value indicating whether the method has an explicit output mechanism. + public readonly bool HasExplicitOutput => OutputKind != MethodOutputKind.None; + + /// Gets a value indicating whether the method is asynchronous. + public readonly bool IsAsync => ReturnKind switch + { + MethodReturnKind.Task or MethodReturnKind.TaskInt32 or MethodReturnKind.TaskString or MethodReturnKind.TaskNullableString or + MethodReturnKind.ValueTask or MethodReturnKind.ValueTaskInt32 or MethodReturnKind.ValueTaskString or MethodReturnKind.ValueTaskNullableString or + MethodReturnKind.IAsyncEnumerableByte => true, + _ => false + }; + + /// Gets a value indicating whether the method returns an enumerable. + public readonly bool IsEnumerable => ReturnKind == MethodReturnKind.IEnumerableByte; + + /// Gets a value indicating whether the method returns an async enumerable. + public readonly bool IsAsyncEnumerable => ReturnKind == MethodReturnKind.IAsyncEnumerableByte; +} From a69c30273b0af0c2c7931c7e3b0b753afbdac05c Mon Sep 17 00:00:00 2001 From: juner Date: Thu, 28 May 2026 00:50:25 +0900 Subject: [PATCH 12/49] Add XML documentation comments in English to generator abstractions --- Generator.Abstractions/KnownTypes.cs | 45 ++++++++++++++++++- .../MethodSignatureBinder.cs | 17 +++++++ .../MethodSignatureBinding.cs | 12 +++++ 3 files changed, 72 insertions(+), 2 deletions(-) diff --git a/Generator.Abstractions/KnownTypes.cs b/Generator.Abstractions/KnownTypes.cs index 930bcf8..f1b1b52 100644 --- a/Generator.Abstractions/KnownTypes.cs +++ b/Generator.Abstractions/KnownTypes.cs @@ -7,24 +7,43 @@ namespace Esolang.Generator; /// public readonly struct KnownTypes { -#pragma warning disable CS1591 + /// The type symbol. public readonly INamedTypeSymbol? String; + /// The type symbol. public readonly INamedTypeSymbol? Byte; + /// The type symbol. public readonly INamedTypeSymbol? Int32; + /// The type symbol. public readonly INamedTypeSymbol? Task; + /// The type symbol. public readonly INamedTypeSymbol? TaskT; + /// The type symbol. public readonly INamedTypeSymbol? ValueTask; + /// The type symbol. public readonly INamedTypeSymbol? ValueTaskT; + /// The type symbol. public readonly INamedTypeSymbol? IEnumerableT; + /// The System.Collections.Generic.IAsyncEnumerable{T} type symbol. public readonly INamedTypeSymbol? IAsyncEnumerableT; + /// The System.IO.Pipelines.PipeReader type symbol. public readonly INamedTypeSymbol? PipeReader; + /// The System.IO.Pipelines.PipeWriter type symbol. public readonly INamedTypeSymbol? PipeWriter; + /// The type symbol. public readonly INamedTypeSymbol? TextReader; + /// The type symbol. public readonly INamedTypeSymbol? TextWriter; + /// The System.Threading.CancellationToken type symbol. public readonly INamedTypeSymbol? CancellationToken; + /// The Microsoft.Extensions.Logging.ILogger type symbol. public readonly INamedTypeSymbol? ILogger; + /// The Microsoft.Extensions.Logging.ILogger{T} type symbol. public readonly INamedTypeSymbol? ILoggerT; + /// + /// Initializes a new instance of the struct. + /// + /// The compilation to resolve types from. public KnownTypes(Compilation compilation) { String = compilation.GetSpecialType(SpecialType.System_String); @@ -52,42 +71,65 @@ private static bool EqualsDefinition(ITypeSymbol? type, ISymbol? symbol) => private static bool EqualsType(ITypeSymbol? type, ISymbol? symbol) => type != null && symbol != null && SymbolEqualityComparer.Default.Equals(type, symbol); + /// Gets a value indicating whether the type is . + /// The type to check. + /// Optional: Whether to check for nullability. public bool IsString(ITypeSymbol? type, bool? isNullable = null) => type != null && SymbolEqualityComparer.Default.Equals(type, String) && (isNullable == null || type.NullableAnnotation == (isNullable.Value ? NullableAnnotation.Annotated : NullableAnnotation.NotAnnotated)); + /// Gets a value indicating whether the type is . public bool IsByte(ITypeSymbol? type) => EqualsType(type, Byte); + /// Gets a value indicating whether the type is . public bool IsInt32(ITypeSymbol? type) => EqualsType(type, Int32); + /// Gets a value indicating whether the type is . public bool IsTask(ITypeSymbol? type) => EqualsType(type, Task); + /// Gets a value indicating whether the type is . public bool IsTaskT(ITypeSymbol? type, bool? isNullable = null) { if (type is not INamedTypeSymbol named || !EqualsDefinition(named, TaskT)) return false; return isNullable == null || named.TypeArguments[0].NullableAnnotation == (isNullable.Value ? NullableAnnotation.Annotated : NullableAnnotation.NotAnnotated); } + /// Gets a value indicating whether the type is . public bool IsValueTask(ITypeSymbol? type) => EqualsType(type, ValueTask); + /// Gets a value indicating whether the type is . public bool IsValueTaskT(ITypeSymbol? type, bool? isNullable = null) { if (type is not INamedTypeSymbol named || !EqualsDefinition(named, ValueTaskT)) return false; return isNullable == null || named.TypeArguments[0].NullableAnnotation == (isNullable.Value ? NullableAnnotation.Annotated : NullableAnnotation.NotAnnotated); } + /// Gets a value indicating whether the type is . public bool IsIEnumerableT(ITypeSymbol? type) => EqualsDefinition(type, IEnumerableT); + /// Gets a value indicating whether the type is System.Collections.Generic.IAsyncEnumerable{T}. public bool IsIAsyncEnumerableT(ITypeSymbol? type) => EqualsDefinition(type, IAsyncEnumerableT); + /// Gets a value indicating whether the type is System.IO.Pipelines.PipeReader. public bool IsPipeReader(ITypeSymbol? type) => EqualsType(type, PipeReader); + /// Gets a value indicating whether the type is System.IO.Pipelines.PipeWriter. public bool IsPipeWriter(ITypeSymbol? type) => EqualsType(type, PipeWriter); + /// Gets a value indicating whether the type is . public bool IsTextReader(ITypeSymbol? type) => EqualsType(type, TextReader); + /// Gets a value indicating whether the type is . public bool IsTextWriter(ITypeSymbol? type) => EqualsType(type, TextWriter); + /// Gets a value indicating whether the type is System.Threading.CancellationToken. public bool IsCancellationToken(ITypeSymbol? type) => EqualsType(type, CancellationToken); + /// Gets a value indicating whether the type is . public bool IsTaskString(ITypeSymbol? type, bool? isNullable = null) => IsTaskT(type, isNullable) && ((INamedTypeSymbol)type!).TypeArguments[0].SpecialType == SpecialType.System_String; + /// Gets a value indicating whether the type is . public bool IsValueTaskString(ITypeSymbol? type, bool? isNullable = null) => IsValueTaskT(type, isNullable) && ((INamedTypeSymbol)type!).TypeArguments[0].SpecialType == SpecialType.System_String; + /// Gets a value indicating whether the type is . public bool IsTaskInt32(ITypeSymbol? type) => IsTaskT(type) && ((INamedTypeSymbol)type!).TypeArguments[0].SpecialType == SpecialType.System_Int32; + /// Gets a value indicating whether the type is . public bool IsValueTaskInt32(ITypeSymbol? type) => IsValueTaskT(type) && ((INamedTypeSymbol)type!).TypeArguments[0].SpecialType == SpecialType.System_Int32; + /// Gets a value indicating whether the type is . public bool IsIEnumerableByte(ITypeSymbol? type) => IsIEnumerableT(type) && ((INamedTypeSymbol)type!).TypeArguments[0].SpecialType == SpecialType.System_Byte; + /// Gets a value indicating whether the type is System.Collections.Generic.IAsyncEnumerable{Byte}. public bool IsIAsyncEnumerableByte(ITypeSymbol? type) => IsIAsyncEnumerableT(type) && ((INamedTypeSymbol)type!).TypeArguments[0].SpecialType == SpecialType.System_Byte; + /// Gets a value indicating whether the type is a logger type (ILogger or ILogger{T}). public bool IsLogger(ITypeSymbol? type) { if (type == null) return false; @@ -98,7 +140,6 @@ public bool IsLogger(ITypeSymbol? type) } return false; } -#pragma warning restore CS1591 } /// diff --git a/Generator.Abstractions/MethodSignatureBinder.cs b/Generator.Abstractions/MethodSignatureBinder.cs index 06ba843..8499209 100644 --- a/Generator.Abstractions/MethodSignatureBinder.cs +++ b/Generator.Abstractions/MethodSignatureBinder.cs @@ -133,6 +133,9 @@ public static MethodSignatureBinding Bind( return new MethodSignatureBinding(true, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, unhandledParameters); } + /// + /// Binds the return type symbol to a . + /// private static MethodReturnKind BindReturnKind(ITypeSymbol returnType, KnownTypes types) { if (returnType.SpecialType == SpecialType.System_Void) return MethodReturnKind.Void; @@ -153,6 +156,9 @@ private static MethodReturnKind BindReturnKind(ITypeSymbol returnType, KnownType return MethodReturnKind.Invalid; } + /// + /// Gets the default output kind based on the return kind. + /// private static MethodOutputKind BindDefaultOutputKind(MethodReturnKind returnKind) => returnKind switch { MethodReturnKind.String or MethodReturnKind.NullableString or MethodReturnKind.TaskString or MethodReturnKind.TaskNullableString or MethodReturnKind.ValueTaskString or MethodReturnKind.ValueTaskNullableString => MethodOutputKind.ReturnString, @@ -161,12 +167,23 @@ private static MethodReturnKind BindReturnKind(ITypeSymbol returnType, KnownType _ => MethodOutputKind.None }; + /// + /// Gets a value indicating whether the return kind implies output is returned. + /// private static bool IsOutputReturning(MethodReturnKind returnKind) => returnKind switch { MethodReturnKind.String or MethodReturnKind.NullableString or MethodReturnKind.TaskString or MethodReturnKind.TaskNullableString or MethodReturnKind.ValueTaskString or MethodReturnKind.ValueTaskNullableString or MethodReturnKind.IEnumerableByte or MethodReturnKind.IAsyncEnumerableByte => true, _ => false }; + /// + /// Searches for a logger in the containing type (fields or constructor parameters). + /// + /// The type to search in. + /// Whether the target method is static. + /// The known types for the compilation. + /// Output: Whether the logger was found in a constructor parameter. + /// The expression to access the logger, or null if not found. private static string? FindLoggerInContainingType(ITypeSymbol? type, bool isStatic, KnownTypes types, out bool isFromParameter) { isFromParameter = false; diff --git a/Generator.Abstractions/MethodSignatureBinding.cs b/Generator.Abstractions/MethodSignatureBinding.cs index b96c265..5586a0e 100644 --- a/Generator.Abstractions/MethodSignatureBinding.cs +++ b/Generator.Abstractions/MethodSignatureBinding.cs @@ -6,6 +6,18 @@ namespace Esolang.Generator; /// /// Represents the result of binding a method signature for generation. /// +/// Whether the binding is successful. +/// The return kind of the method. +/// The input kind of the method. +/// The output kind of the method. +/// The expression to access the input (e.g., parameter name). +/// The expression to access the output (e.g., parameter name). +/// The name of the cancellation token parameter, if any. +/// The expression to access the logger (e.g., "loggerParam", "this._logger"). +/// Whether the logger is obtained from a method parameter. +/// Parameters that were not handled by the common binding logic. +/// The diagnostic error ID if the binding failed. +/// The location associated with the error. public record struct MethodSignatureBinding( bool IsValid, MethodReturnKind ReturnKind, From c52a47edb406e7159664d79da83a4745719afcf3 Mon Sep 17 00:00:00 2001 From: juner Date: Thu, 28 May 2026 13:56:18 +0900 Subject: [PATCH 13/49] =?UTF-8?q?feat(generator):=20Esolang.Brainfuck?= =?UTF-8?q?=E3=81=AE=E5=AF=BE=E5=BF=9C=E3=81=AB=E4=BC=B4=E3=81=86Generator?= =?UTF-8?q?.Abstractions=E3=81=AE=E4=BF=AE=E6=AD=A3?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - KnownTypes: XMLドキュメントの調整およびIsString, IsTaskT, IsValueTaskTの判定ロジックの修正 - MethodSignatureBinder: パラメータバインディング時のエラーID判定の修正およびBindReturnKindの公開化 --- Generator.Abstractions/KnownTypes.cs | 67 +++++++++++-------- .../MethodSignatureBinder.cs | 12 ++-- 2 files changed, 44 insertions(+), 35 deletions(-) diff --git a/Generator.Abstractions/KnownTypes.cs b/Generator.Abstractions/KnownTypes.cs index f1b1b52..93e824b 100644 --- a/Generator.Abstractions/KnownTypes.cs +++ b/Generator.Abstractions/KnownTypes.cs @@ -7,21 +7,21 @@ namespace Esolang.Generator; /// public readonly struct KnownTypes { - /// The type symbol. + /// The string type symbol. public readonly INamedTypeSymbol? String; - /// The type symbol. + /// The byte type symbol. public readonly INamedTypeSymbol? Byte; - /// The type symbol. + /// The int type symbol. public readonly INamedTypeSymbol? Int32; - /// The type symbol. + /// The System.Threading.Tasks.Task type symbol. public readonly INamedTypeSymbol? Task; - /// The type symbol. + /// The System.Threading.Tasks.Task{TResult} type symbol. public readonly INamedTypeSymbol? TaskT; - /// The type symbol. + /// The System.Threading.Tasks.ValueTask type symbol. public readonly INamedTypeSymbol? ValueTask; - /// The type symbol. + /// The System.Threading.Tasks.ValueTask{TResult} type symbol. public readonly INamedTypeSymbol? ValueTaskT; - /// The type symbol. + /// The System.Collections.Generic.IEnumerable{T} type symbol. public readonly INamedTypeSymbol? IEnumerableT; /// The System.Collections.Generic.IAsyncEnumerable{T} type symbol. public readonly INamedTypeSymbol? IAsyncEnumerableT; @@ -29,9 +29,9 @@ public readonly struct KnownTypes public readonly INamedTypeSymbol? PipeReader; /// The System.IO.Pipelines.PipeWriter type symbol. public readonly INamedTypeSymbol? PipeWriter; - /// The type symbol. + /// The System.IO.TextReader type symbol. public readonly INamedTypeSymbol? TextReader; - /// The type symbol. + /// The System.IO.TextWriter type symbol. public readonly INamedTypeSymbol? TextWriter; /// The System.Threading.CancellationToken type symbol. public readonly INamedTypeSymbol? CancellationToken; @@ -71,34 +71,43 @@ private static bool EqualsDefinition(ITypeSymbol? type, ISymbol? symbol) => private static bool EqualsType(ITypeSymbol? type, ISymbol? symbol) => type != null && symbol != null && SymbolEqualityComparer.Default.Equals(type, symbol); - /// Gets a value indicating whether the type is . + /// Gets a value indicating whether the type is string. /// The type to check. /// Optional: Whether to check for nullability. - public bool IsString(ITypeSymbol? type, bool? isNullable = null) => - type != null && SymbolEqualityComparer.Default.Equals(type, String) && (isNullable == null || type.NullableAnnotation == (isNullable.Value ? NullableAnnotation.Annotated : NullableAnnotation.NotAnnotated)); + public bool IsString(ITypeSymbol? type, bool? isNullable = null) + { + if (type is not INamedTypeSymbol named || !SymbolEqualityComparer.Default.Equals(named, String)) return false; + if (isNullable == null) return true; + if (isNullable.Value) return type.NullableAnnotation == NullableAnnotation.Annotated; + return type.NullableAnnotation is NullableAnnotation.NotAnnotated or NullableAnnotation.None; + } - /// Gets a value indicating whether the type is . + /// Gets a value indicating whether the type is byte. public bool IsByte(ITypeSymbol? type) => EqualsType(type, Byte); - /// Gets a value indicating whether the type is . + /// Gets a value indicating whether the type is int. public bool IsInt32(ITypeSymbol? type) => EqualsType(type, Int32); - /// Gets a value indicating whether the type is . + /// Gets a value indicating whether the type is System.Threading.Tasks.Task. public bool IsTask(ITypeSymbol? type) => EqualsType(type, Task); - /// Gets a value indicating whether the type is . + /// Gets a value indicating whether the type is System.Threading.Tasks.Task{TResult}. public bool IsTaskT(ITypeSymbol? type, bool? isNullable = null) { if (type is not INamedTypeSymbol named || !EqualsDefinition(named, TaskT)) return false; - return isNullable == null || named.TypeArguments[0].NullableAnnotation == (isNullable.Value ? NullableAnnotation.Annotated : NullableAnnotation.NotAnnotated); + if (isNullable == null) return true; + var annotation = named.TypeArguments[0].NullableAnnotation; + return isNullable.Value ? annotation == NullableAnnotation.Annotated : annotation is NullableAnnotation.NotAnnotated or NullableAnnotation.None; } - /// Gets a value indicating whether the type is . + /// Gets a value indicating whether the type is System.Threading.Tasks.ValueTask. public bool IsValueTask(ITypeSymbol? type) => EqualsType(type, ValueTask); - /// Gets a value indicating whether the type is . + /// Gets a value indicating whether the type is System.Threading.Tasks.ValueTask{TResult}. public bool IsValueTaskT(ITypeSymbol? type, bool? isNullable = null) { if (type is not INamedTypeSymbol named || !EqualsDefinition(named, ValueTaskT)) return false; - return isNullable == null || named.TypeArguments[0].NullableAnnotation == (isNullable.Value ? NullableAnnotation.Annotated : NullableAnnotation.NotAnnotated); + if (isNullable == null) return true; + var annotation = named.TypeArguments[0].NullableAnnotation; + return isNullable.Value ? annotation == NullableAnnotation.Annotated : annotation is NullableAnnotation.NotAnnotated or NullableAnnotation.None; } - /// Gets a value indicating whether the type is . + /// Gets a value indicating whether the type is System.Collections.Generic.IEnumerable{T}. public bool IsIEnumerableT(ITypeSymbol? type) => EqualsDefinition(type, IEnumerableT); /// Gets a value indicating whether the type is System.Collections.Generic.IAsyncEnumerable{T}. public bool IsIAsyncEnumerableT(ITypeSymbol? type) => EqualsDefinition(type, IAsyncEnumerableT); @@ -107,24 +116,24 @@ public bool IsValueTaskT(ITypeSymbol? type, bool? isNullable = null) public bool IsPipeReader(ITypeSymbol? type) => EqualsType(type, PipeReader); /// Gets a value indicating whether the type is System.IO.Pipelines.PipeWriter. public bool IsPipeWriter(ITypeSymbol? type) => EqualsType(type, PipeWriter); - /// Gets a value indicating whether the type is . + /// Gets a value indicating whether the type is System.IO.TextReader. public bool IsTextReader(ITypeSymbol? type) => EqualsType(type, TextReader); - /// Gets a value indicating whether the type is . + /// Gets a value indicating whether the type is System.IO.TextWriter. public bool IsTextWriter(ITypeSymbol? type) => EqualsType(type, TextWriter); /// Gets a value indicating whether the type is System.Threading.CancellationToken. public bool IsCancellationToken(ITypeSymbol? type) => EqualsType(type, CancellationToken); - /// Gets a value indicating whether the type is . + /// Gets a value indicating whether the type is System.Threading.Tasks.Task{String}. public bool IsTaskString(ITypeSymbol? type, bool? isNullable = null) => IsTaskT(type, isNullable) && ((INamedTypeSymbol)type!).TypeArguments[0].SpecialType == SpecialType.System_String; - /// Gets a value indicating whether the type is . + /// Gets a value indicating whether the type is System.Threading.Tasks.ValueTask{String}. public bool IsValueTaskString(ITypeSymbol? type, bool? isNullable = null) => IsValueTaskT(type, isNullable) && ((INamedTypeSymbol)type!).TypeArguments[0].SpecialType == SpecialType.System_String; - /// Gets a value indicating whether the type is . + /// Gets a value indicating whether the type is System.Threading.Tasks.Task{Int32}. public bool IsTaskInt32(ITypeSymbol? type) => IsTaskT(type) && ((INamedTypeSymbol)type!).TypeArguments[0].SpecialType == SpecialType.System_Int32; - /// Gets a value indicating whether the type is . + /// Gets a value indicating whether the type is System.Threading.Tasks.ValueTask{Int32}. public bool IsValueTaskInt32(ITypeSymbol? type) => IsValueTaskT(type) && ((INamedTypeSymbol)type!).TypeArguments[0].SpecialType == SpecialType.System_Int32; - /// Gets a value indicating whether the type is . + /// Gets a value indicating whether the type is System.Collections.Generic.IEnumerable{Byte}. public bool IsIEnumerableByte(ITypeSymbol? type) => IsIEnumerableT(type) && ((INamedTypeSymbol)type!).TypeArguments[0].SpecialType == SpecialType.System_Byte; /// Gets a value indicating whether the type is System.Collections.Generic.IAsyncEnumerable{Byte}. public bool IsIAsyncEnumerableByte(ITypeSymbol? type) => IsIAsyncEnumerableT(type) && ((INamedTypeSymbol)type!).TypeArguments[0].SpecialType == SpecialType.System_Byte; diff --git a/Generator.Abstractions/MethodSignatureBinder.cs b/Generator.Abstractions/MethodSignatureBinder.cs index 8499209..2ec7c65 100644 --- a/Generator.Abstractions/MethodSignatureBinder.cs +++ b/Generator.Abstractions/MethodSignatureBinder.cs @@ -53,7 +53,7 @@ public static MethodSignatureBinding Bind( if (types.IsString(p.Type, false)) { if (inputKind != MethodInputKind.None) - return new MethodSignatureBinding(false, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, duplicateParameterErrorId, p.Locations.FirstOrDefault()); + return new MethodSignatureBinding(false, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, inputKind == MethodInputKind.String ? duplicateParameterErrorId : invalidParameterErrorId, p.Locations.FirstOrDefault()); inputKind = MethodInputKind.String; inputExpr = p.Name; @@ -63,7 +63,7 @@ public static MethodSignatureBinding Bind( if (types.IsTextReader(p.Type)) { if (inputKind != MethodInputKind.None) - return new MethodSignatureBinding(false, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, duplicateParameterErrorId, p.Locations.FirstOrDefault()); + return new MethodSignatureBinding(false, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, inputKind == MethodInputKind.TextReader ? duplicateParameterErrorId : invalidParameterErrorId, p.Locations.FirstOrDefault()); inputKind = MethodInputKind.TextReader; inputExpr = p.Name; @@ -73,7 +73,7 @@ public static MethodSignatureBinding Bind( if (types.IsPipeReader(p.Type)) { if (inputKind != MethodInputKind.None) - return new MethodSignatureBinding(false, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, duplicateParameterErrorId, p.Locations.FirstOrDefault()); + return new MethodSignatureBinding(false, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, inputKind == MethodInputKind.PipeReader ? duplicateParameterErrorId : invalidParameterErrorId, p.Locations.FirstOrDefault()); inputKind = MethodInputKind.PipeReader; inputExpr = p.Name; @@ -86,7 +86,7 @@ public static MethodSignatureBinding Bind( return new MethodSignatureBinding(false, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, returnOutputConflictErrorId, p.Locations.FirstOrDefault()); if (outputKind != MethodOutputKind.None) - return new MethodSignatureBinding(false, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, duplicateParameterErrorId, p.Locations.FirstOrDefault()); + return new MethodSignatureBinding(false, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, outputKind == MethodOutputKind.TextWriter ? duplicateParameterErrorId : invalidParameterErrorId, p.Locations.FirstOrDefault()); outputKind = MethodOutputKind.TextWriter; outputExpr = p.Name; @@ -99,7 +99,7 @@ public static MethodSignatureBinding Bind( return new MethodSignatureBinding(false, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, returnOutputConflictErrorId, p.Locations.FirstOrDefault()); if (outputKind != MethodOutputKind.None) - return new MethodSignatureBinding(false, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, duplicateParameterErrorId, p.Locations.FirstOrDefault()); + return new MethodSignatureBinding(false, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, outputKind == MethodOutputKind.PipeWriter ? duplicateParameterErrorId : invalidParameterErrorId, p.Locations.FirstOrDefault()); outputKind = MethodOutputKind.PipeWriter; outputExpr = p.Name; @@ -136,7 +136,7 @@ public static MethodSignatureBinding Bind( /// /// Binds the return type symbol to a . /// - private static MethodReturnKind BindReturnKind(ITypeSymbol returnType, KnownTypes types) + public static MethodReturnKind BindReturnKind(ITypeSymbol returnType, KnownTypes types) { if (returnType.SpecialType == SpecialType.System_Void) return MethodReturnKind.Void; if (returnType.SpecialType == SpecialType.System_Int32) return MethodReturnKind.Int32; From 18b78788e5b1a953a520c088f1700014b54cca5d Mon Sep 17 00:00:00 2001 From: juner Date: Thu, 28 May 2026 14:52:55 +0900 Subject: [PATCH 14/49] =?UTF-8?q?test(generator):=20KnownTypes=20=E3=81=AE?= =?UTF-8?q?=E3=83=A6=E3=83=8B=E3=83=83=E3=83=88=E3=83=86=E3=82=B9=E3=83=88?= =?UTF-8?q?=E8=BF=BD=E5=8A=A0=E3=81=8A=E3=82=88=E3=81=B3=E7=92=B0=E5=A2=83?= =?UTF-8?q?=E6=95=B4=E5=82=99?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - KnownTypesTests.cs: 各型判定ロジックおよび Nullable コンテキストのテストを実装 - csproj/Directory.Build.targets: 必要なテスト用アセンブリ参照およびツールの整備 - .gitignore/GEMINI.md: カバレッジレポート出力先および生成手順の追加 --- .gitignore | 968 +++++++++--------- Directory.Build.targets | 7 + GEMINI.md | 15 + ...solang.Generator.Abstractions.Tests.csproj | 35 + .../KnownTypesTests.cs | 166 +++ dotnet-tools.json | 2 +- 6 files changed, 708 insertions(+), 485 deletions(-) create mode 100644 Generator.Abstractions.Tests/Esolang.Generator.Abstractions.Tests.csproj create mode 100644 Generator.Abstractions.Tests/KnownTypesTests.cs diff --git a/.gitignore b/.gitignore index 400ec62..d83b6fb 100644 --- a/.gitignore +++ b/.gitignore @@ -1,484 +1,484 @@ -## Ignore Visual Studio temporary files, build results, and -## files generated by popular Visual Studio add-ons. -## -## Get latest from `dotnet new gitignore` - -# dotenv files -.env - -# User-specific files -*.rsuser -*.suo -*.user -*.userosscache -*.sln.docstates - -# User-specific files (MonoDevelop/Xamarin Studio) -*.userprefs - -# Mono auto generated files -mono_crash.* - -# Build results -[Dd]ebug/ -[Dd]ebugPublic/ -[Rr]elease/ -[Rr]eleases/ -x64/ -x86/ -[Ww][Ii][Nn]32/ -[Aa][Rr][Mm]/ -[Aa][Rr][Mm]64/ -bld/ -[Bb]in/ -[Oo]bj/ -[Ll]og/ -[Ll]ogs/ - -# Visual Studio 2015/2017 cache/options directory -.vs/ -# Uncomment if you have tasks that create the project's static files in wwwroot -#wwwroot/ - -# Visual Studio 2017 auto generated files -Generated\ Files/ - -# MSTest test Results -[Tt]est[Rr]esult*/ -[Bb]uild[Ll]og.* - -# NUnit -*.VisualState.xml -TestResult.xml -nunit-*.xml - -# Build Results of an ATL Project -[Dd]ebugPS/ -[Rr]eleasePS/ -dlldata.c - -# Benchmark Results -BenchmarkDotNet.Artifacts/ - -# .NET -project.lock.json -project.fragment.lock.json -artifacts/ - -# Tye -.tye/ - -# ASP.NET Scaffolding -ScaffoldingReadMe.txt - -# StyleCop -StyleCopReport.xml - -# Files built by Visual Studio -*_i.c -*_p.c -*_h.h -*.ilk -*.meta -*.obj -*.iobj -*.pch -*.pdb -*.ipdb -*.pgc -*.pgd -*.rsp -# but not Directory.Build.rsp, as it configures directory-level build defaults -!Directory.Build.rsp -*.sbr -*.tlb -*.tli -*.tlh -*.tmp -*.tmp_proj -*_wpftmp.csproj -*.log -*.tlog -*.vspscc -*.vssscc -.builds -*.pidb -*.svclog -*.scc - -# Chutzpah Test files -_Chutzpah* - -# Visual C++ cache files -ipch/ -*.aps -*.ncb -*.opendb -*.opensdf -*.sdf -*.cachefile -*.VC.db -*.VC.VC.opendb - -# Visual Studio profiler -*.psess -*.vsp -*.vspx -*.sap - -# Visual Studio Trace Files -*.e2e - -# TFS 2012 Local Workspace -$tf/ - -# Guidance Automation Toolkit -*.gpState - -# ReSharper is a .NET coding add-in -_ReSharper*/ -*.[Rr]e[Ss]harper -*.DotSettings.user - -# TeamCity is a build add-in -_TeamCity* - -# DotCover is a Code Coverage Tool -*.dotCover - -# AxoCover is a Code Coverage Tool -.axoCover/* -!.axoCover/settings.json - -# Coverlet is a free, cross platform Code Coverage Tool -coverage*.json -coverage*.xml -coverage*.info - -# Visual Studio code coverage results -*.coverage -*.coveragexml - -# NCrunch -_NCrunch_* -.*crunch*.local.xml -nCrunchTemp_* - -# MightyMoose -*.mm.* -AutoTest.Net/ - -# Web workbench (sass) -.sass-cache/ - -# Installshield output folder -[Ee]xpress/ - -# DocProject is a documentation generator add-in -DocProject/buildhelp/ -DocProject/Help/*.HxT -DocProject/Help/*.HxC -DocProject/Help/*.hhc -DocProject/Help/*.hhk -DocProject/Help/*.hhp -DocProject/Help/Html2 -DocProject/Help/html - -# Click-Once directory -publish/ - -# Publish Web Output -*.[Pp]ublish.xml -*.azurePubxml -# Note: Comment the next line if you want to checkin your web deploy settings, -# but database connection strings (with potential passwords) will be unencrypted -*.pubxml -*.publishproj - -# Microsoft Azure Web App publish settings. Comment the next line if you want to -# checkin your Azure Web App publish settings, but sensitive information contained -# in these scripts will be unencrypted -PublishScripts/ - -# NuGet Packages -*.nupkg -# NuGet Symbol Packages -*.snupkg -# The packages folder can be ignored because of Package Restore -**/[Pp]ackages/* -# except build/, which is used as an MSBuild target. -!**/[Pp]ackages/build/ -# Uncomment if necessary however generally it will be regenerated when needed -#!**/[Pp]ackages/repositories.config -# NuGet v3's project.json files produces more ignorable files -*.nuget.props -*.nuget.targets - -# Microsoft Azure Build Output -csx/ -*.build.csdef - -# Microsoft Azure Emulator -ecf/ -rcf/ - -# Windows Store app package directories and files -AppPackages/ -BundleArtifacts/ -Package.StoreAssociation.xml -_pkginfo.txt -*.appx -*.appxbundle -*.appxupload - -# Visual Studio cache files -# files ending in .cache can be ignored -*.[Cc]ache -# but keep track of directories ending in .cache -!?*.[Cc]ache/ - -# Others -ClientBin/ -~$* -*~ -*.dbmdl -*.dbproj.schemaview -*.jfm -*.pfx -*.publishsettings -orleans.codegen.cs - -# Including strong name files can present a security risk -# (https://github.com/github/gitignore/pull/2483#issue-259490424) -#*.snk - -# Since there are multiple workflows, uncomment next line to ignore bower_components -# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622) -#bower_components/ - -# RIA/Silverlight projects -Generated_Code/ - -# Backup & report files from converting an old project file -# to a newer Visual Studio version. Backup files are not needed, -# because we have git ;-) -_UpgradeReport_Files/ -Backup*/ -UpgradeLog*.XML -UpgradeLog*.htm -ServiceFabricBackup/ -*.rptproj.bak - -# SQL Server files -*.mdf -*.ldf -*.ndf - -# Business Intelligence projects -*.rdl.data -*.bim.layout -*.bim_*.settings -*.rptproj.rsuser -*- [Bb]ackup.rdl -*- [Bb]ackup ([0-9]).rdl -*- [Bb]ackup ([0-9][0-9]).rdl - -# Microsoft Fakes -FakesAssemblies/ - -# GhostDoc plugin setting file -*.GhostDoc.xml - -# Node.js Tools for Visual Studio -.ntvs_analysis.dat -node_modules/ - -# Visual Studio 6 build log -*.plg - -# Visual Studio 6 workspace options file -*.opt - -# Visual Studio 6 auto-generated workspace file (contains which files were open etc.) -*.vbw - -# Visual Studio 6 auto-generated project file (contains which files were open etc.) -*.vbp - -# Visual Studio 6 workspace and project file (working project files containing files to include in project) -*.dsw -*.dsp - -# Visual Studio 6 technical files -*.ncb -*.aps - -# Visual Studio LightSwitch build output -**/*.HTMLClient/GeneratedArtifacts -**/*.DesktopClient/GeneratedArtifacts -**/*.DesktopClient/ModelManifest.xml -**/*.Server/GeneratedArtifacts -**/*.Server/ModelManifest.xml -_Pvt_Extensions - -# Paket dependency manager -.paket/paket.exe -paket-files/ - -# FAKE - F# Make -.fake/ - -# CodeRush personal settings -.cr/personal - -# Python Tools for Visual Studio (PTVS) -__pycache__/ -*.pyc - -# Cake - Uncomment if you are using it -# tools/** -# !tools/packages.config - -# Tabs Studio -*.tss - -# Telerik's JustMock configuration file -*.jmconfig - -# BizTalk build output -*.btp.cs -*.btm.cs -*.odx.cs -*.xsd.cs - -# OpenCover UI analysis results -OpenCover/ - -# Azure Stream Analytics local run output -ASALocalRun/ - -# MSBuild Binary and Structured Log -*.binlog - -# NVidia Nsight GPU debugger configuration file -*.nvuser - -# MFractors (Xamarin productivity tool) working folder -.mfractor/ - -# Local History for Visual Studio -.localhistory/ - -# Visual Studio History (VSHistory) files -.vshistory/ - -# BeatPulse healthcheck temp database -healthchecksdb - -# Backup folder for Package Reference Convert tool in Visual Studio 2017 -MigrationBackup/ - -# Ionide (cross platform F# VS Code tools) working folder -.ionide/ - -# Fody - auto-generated XML schema -FodyWeavers.xsd - -# VS Code files for those working on multiple tools -.vscode/* -!.vscode/settings.json -!.vscode/tasks.json -!.vscode/launch.json -!.vscode/extensions.json -*.code-workspace - -# Local History for Visual Studio Code -.history/ - -# Windows Installer files from build outputs -*.cab -*.msi -*.msix -*.msm -*.msp - -# JetBrains Rider -*.sln.iml -.idea/ - -## -## Visual studio for Mac -## - - -# globs -Makefile.in -*.userprefs -*.usertasks -config.make -config.status -aclocal.m4 -install-sh -autom4te.cache/ -*.tar.gz -tarballs/ -test-results/ - -# content below from: https://github.com/github/gitignore/blob/main/Global/macOS.gitignore -# General -.DS_Store -.AppleDouble -.LSOverride - -# Icon must end with two \r -Icon - - -# Thumbnails -._* - -# Files that might appear in the root of a volume -.DocumentRevisions-V100 -.fseventsd -.Spotlight-V100 -.TemporaryItems -.Trashes -.VolumeIcon.icns -.com.apple.timemachine.donotpresent - -# Directories potentially created on remote AFP share -.AppleDB -.AppleDesktop -Network Trash Folder -Temporary Items -.apdisk - -# content below from: https://github.com/github/gitignore/blob/main/Global/Windows.gitignore -# Windows thumbnail cache files -Thumbs.db -ehthumbs.db -ehthumbs_vista.db - -# Dump file -*.stackdump - -# Folder config file -[Dd]esktop.ini - -# Recycle Bin used on file shares -$RECYCLE.BIN/ - -# Windows Installer files -*.cab -*.msi -*.msix -*.msm -*.msp - -# Windows shortcuts -*.lnk - -# Vim temporary swap files -*.swp - -coveragereport \ No newline at end of file +## Ignore Visual Studio temporary files, build results, and +## files generated by popular Visual Studio add-ons. +## +## Get latest from `dotnet new gitignore` + +# dotenv files +.env + +# User-specific files +*.rsuser +*.suo +*.user +*.userosscache +*.sln.docstates + +# User-specific files (MonoDevelop/Xamarin Studio) +*.userprefs + +# Mono auto generated files +mono_crash.* + +# Build results +[Dd]ebug/ +[Dd]ebugPublic/ +[Rr]elease/ +[Rr]eleases/ +x64/ +x86/ +[Ww][Ii][Nn]32/ +[Aa][Rr][Mm]/ +[Aa][Rr][Mm]64/ +bld/ +[Bb]in/ +[Oo]bj/ +[Ll]og/ +[Ll]ogs/ + +# Visual Studio 2015/2017 cache/options directory +.vs/ +# Uncomment if you have tasks that create the project's static files in wwwroot +#wwwroot/ + +# Visual Studio 2017 auto generated files +Generated\ Files/ + +# MSTest test Results +[Tt]est[Rr]esult*/ +[Bb]uild[Ll]og.* + +# NUnit +*.VisualState.xml +TestResult.xml +nunit-*.xml + +# Build Results of an ATL Project +[Dd]ebugPS/ +[Rr]eleasePS/ +dlldata.c + +# Benchmark Results +BenchmarkDotNet.Artifacts/ + +# .NET +project.lock.json +project.fragment.lock.json +artifacts/ + +# Tye +.tye/ + +# ASP.NET Scaffolding +ScaffoldingReadMe.txt + +# StyleCop +StyleCopReport.xml + +# Files built by Visual Studio +*_i.c +*_p.c +*_h.h +*.ilk +*.meta +*.obj +*.iobj +*.pch +*.pdb +*.ipdb +*.pgc +*.pgd +*.rsp +# but not Directory.Build.rsp, as it configures directory-level build defaults +!Directory.Build.rsp +*.sbr +*.tlb +*.tli +*.tlh +*.tmp +*.tmp_proj +*_wpftmp.csproj +*.log +*.tlog +*.vspscc +*.vssscc +.builds +*.pidb +*.svclog +*.scc + +# Chutzpah Test files +_Chutzpah* + +# Visual C++ cache files +ipch/ +*.aps +*.ncb +*.opendb +*.opensdf +*.sdf +*.cachefile +*.VC.db +*.VC.VC.opendb + +# Visual Studio profiler +*.psess +*.vsp +*.vspx +*.sap + +# Visual Studio Trace Files +*.e2e + +# TFS 2012 Local Workspace +$tf/ + +# Guidance Automation Toolkit +*.gpState + +# ReSharper is a .NET coding add-in +_ReSharper*/ +*.[Rr]e[Ss]harper +*.DotSettings.user + +# TeamCity is a build add-in +_TeamCity* + +# DotCover is a Code Coverage Tool +*.dotCover + +# AxoCover is a Code Coverage Tool +.axoCover/* +!.axoCover/settings.json + +# Coverlet is a free, cross platform Code Coverage Tool +coverage*.json +coverage*.xml +coverage*.info + +# Visual Studio code coverage results +*.coverage +*.coveragexml + +# NCrunch +_NCrunch_* +.*crunch*.local.xml +nCrunchTemp_* + +# MightyMoose +*.mm.* +AutoTest.Net/ + +# Web workbench (sass) +.sass-cache/ + +# Installshield output folder +[Ee]xpress/ + +# DocProject is a documentation generator add-in +DocProject/buildhelp/ +DocProject/Help/*.HxT +DocProject/Help/*.HxC +DocProject/Help/*.hhc +DocProject/Help/*.hhk +DocProject/Help/*.hhp +DocProject/Help/Html2 +DocProject/Help/html + +# Click-Once directory +publish/ + +# Publish Web Output +*.[Pp]ublish.xml +*.azurePubxml +# Note: Comment the next line if you want to checkin your web deploy settings, +# but database connection strings (with potential passwords) will be unencrypted +*.pubxml +*.publishproj + +# Microsoft Azure Web App publish settings. Comment the next line if you want to +# checkin your Azure Web App publish settings, but sensitive information contained +# in these scripts will be unencrypted +PublishScripts/ + +# NuGet Packages +*.nupkg +# NuGet Symbol Packages +*.snupkg +# The packages folder can be ignored because of Package Restore +**/[Pp]ackages/* +# except build/, which is used as an MSBuild target. +!**/[Pp]ackages/build/ +# Uncomment if necessary however generally it will be regenerated when needed +#!**/[Pp]ackages/repositories.config +# NuGet v3's project.json files produces more ignorable files +*.nuget.props +*.nuget.targets + +# Microsoft Azure Build Output +csx/ +*.build.csdef + +# Microsoft Azure Emulator +ecf/ +rcf/ + +# Windows Store app package directories and files +AppPackages/ +BundleArtifacts/ +Package.StoreAssociation.xml +_pkginfo.txt +*.appx +*.appxbundle +*.appxupload + +# Visual Studio cache files +# files ending in .cache can be ignored +*.[Cc]ache +# but keep track of directories ending in .cache +!?*.[Cc]ache/ + +# Others +ClientBin/ +~$* +*~ +*.dbmdl +*.dbproj.schemaview +*.jfm +*.pfx +*.publishsettings +orleans.codegen.cs + +# Including strong name files can present a security risk +# (https://github.com/github/gitignore/pull/2483#issue-259490424) +#*.snk + +# Since there are multiple workflows, uncomment next line to ignore bower_components +# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622) +#bower_components/ + +# RIA/Silverlight projects +Generated_Code/ + +# Backup & report files from converting an old project file +# to a newer Visual Studio version. Backup files are not needed, +# because we have git ;-) +_UpgradeReport_Files/ +Backup*/ +UpgradeLog*.XML +UpgradeLog*.htm +ServiceFabricBackup/ +*.rptproj.bak + +# SQL Server files +*.mdf +*.ldf +*.ndf + +# Business Intelligence projects +*.rdl.data +*.bim.layout +*.bim_*.settings +*.rptproj.rsuser +*- [Bb]ackup.rdl +*- [Bb]ackup ([0-9]).rdl +*- [Bb]ackup ([0-9][0-9]).rdl + +# Microsoft Fakes +FakesAssemblies/ + +# GhostDoc plugin setting file +*.GhostDoc.xml + +# Node.js Tools for Visual Studio +.ntvs_analysis.dat +node_modules/ + +# Visual Studio 6 build log +*.plg + +# Visual Studio 6 workspace options file +*.opt + +# Visual Studio 6 auto-generated workspace file (contains which files were open etc.) +*.vbw + +# Visual Studio 6 auto-generated project file (contains which files were open etc.) +*.vbp + +# Visual Studio 6 workspace and project file (working project files containing files to include in project) +*.dsw +*.dsp + +# Visual Studio 6 technical files +*.ncb +*.aps + +# Visual Studio LightSwitch build output +**/*.HTMLClient/GeneratedArtifacts +**/*.DesktopClient/GeneratedArtifacts +**/*.DesktopClient/ModelManifest.xml +**/*.Server/GeneratedArtifacts +**/*.Server/ModelManifest.xml +_Pvt_Extensions + +# Paket dependency manager +.paket/paket.exe +paket-files/ + +# FAKE - F# Make +.fake/ + +# CodeRush personal settings +.cr/personal + +# Python Tools for Visual Studio (PTVS) +__pycache__/ +*.pyc + +# Cake - Uncomment if you are using it +# tools/** +# !tools/packages.config + +# Tabs Studio +*.tss + +# Telerik's JustMock configuration file +*.jmconfig + +# BizTalk build output +*.btp.cs +*.btm.cs +*.odx.cs +*.xsd.cs + +# OpenCover UI analysis results +OpenCover/ + +# Azure Stream Analytics local run output +ASALocalRun/ + +# MSBuild Binary and Structured Log +*.binlog + +# NVidia Nsight GPU debugger configuration file +*.nvuser + +# MFractors (Xamarin productivity tool) working folder +.mfractor/ + +# Local History for Visual Studio +.localhistory/ + +# Visual Studio History (VSHistory) files +.vshistory/ + +# BeatPulse healthcheck temp database +healthchecksdb + +# Backup folder for Package Reference Convert tool in Visual Studio 2017 +MigrationBackup/ + +# Ionide (cross platform F# VS Code tools) working folder +.ionide/ + +# Fody - auto-generated XML schema +FodyWeavers.xsd + +# VS Code files for those working on multiple tools +.vscode/* +!.vscode/settings.json +!.vscode/tasks.json +!.vscode/launch.json +!.vscode/extensions.json +*.code-workspace + +# Local History for Visual Studio Code +.history/ + +# Windows Installer files from build outputs +*.cab +*.msi +*.msix +*.msm +*.msp + +# JetBrains Rider +*.sln.iml +.idea/ + +## +## Visual studio for Mac +## + + +# globs +Makefile.in +*.userprefs +*.usertasks +config.make +config.status +aclocal.m4 +install-sh +autom4te.cache/ +*.tar.gz +tarballs/ +test-results/ + +# content below from: https://github.com/github/gitignore/blob/main/Global/macOS.gitignore +# General +.DS_Store +.AppleDouble +.LSOverride + +# Icon must end with two \r +Icon + + +# Thumbnails +._* + +# Files that might appear in the root of a volume +.DocumentRevisions-V100 +.fseventsd +.Spotlight-V100 +.TemporaryItems +.Trashes +.VolumeIcon.icns +.com.apple.timemachine.donotpresent + +# Directories potentially created on remote AFP share +.AppleDB +.AppleDesktop +Network Trash Folder +Temporary Items +.apdisk + +# content below from: https://github.com/github/gitignore/blob/main/Global/Windows.gitignore +# Windows thumbnail cache files +Thumbs.db +ehthumbs.db +ehthumbs_vista.db + +# Dump file +*.stackdump + +# Folder config file +[Dd]esktop.ini + +# Recycle Bin used on file shares +$RECYCLE.BIN/ + +# Windows Installer files +*.cab +*.msi +*.msix +*.msm +*.msp + +# Windows shortcuts +*.lnk + +# Vim temporary swap files +*.swp + +coveragereport/ diff --git a/Directory.Build.targets b/Directory.Build.targets index 6e3b325..25b214d 100644 --- a/Directory.Build.targets +++ b/Directory.Build.targets @@ -1,5 +1,12 @@ + + + + + + + diff --git a/GEMINI.md b/GEMINI.md index 6844ead..e48be57 100644 --- a/GEMINI.md +++ b/GEMINI.md @@ -1,3 +1,18 @@ # Workflow Guidelines - **Working Directory**: Always ensure the current working directory is the solution root (containing `global.json` and the `.slnx` solution file) before executing `dotnet` commands. This is critical for correct SDK version resolution and dependency management. + +### Collecting Code Coverage + +To run tests and collect code coverage: + +```bash +dotnet test --coverage --coverage-output-format cobertura +``` + +To generate an HTML coverage report using ReportGenerator: + +```bash +dotnet reportgenerator "-reports:**/*.cobertura.xml" "-targetdir:coveragereport" -reporttypes:Html +``` +The report will be generated in the `coveragereport` directory. diff --git a/Generator.Abstractions.Tests/Esolang.Generator.Abstractions.Tests.csproj b/Generator.Abstractions.Tests/Esolang.Generator.Abstractions.Tests.csproj new file mode 100644 index 0000000..3d10bda --- /dev/null +++ b/Generator.Abstractions.Tests/Esolang.Generator.Abstractions.Tests.csproj @@ -0,0 +1,35 @@ + + + + net48;net9.0;net10.0 + net9.0;net10.0 + Esolang.Generator.Tests + Esolang.Generator.Abstractions.Tests + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Generator.Abstractions.Tests/KnownTypesTests.cs b/Generator.Abstractions.Tests/KnownTypesTests.cs new file mode 100644 index 0000000..7021ddd --- /dev/null +++ b/Generator.Abstractions.Tests/KnownTypesTests.cs @@ -0,0 +1,166 @@ +using Microsoft.CodeAnalysis; +using Microsoft.CodeAnalysis.CSharp; +using System.Linq; +using Microsoft.VisualStudio.TestTools.UnitTesting; + +namespace Esolang.Generator.Tests; + +[TestClass] +public class KnownTypesTests +{ + private static Compilation CreateCompilation(string code) + { + var assemblies = new[] + { + typeof(object).Assembly, + typeof(System.Threading.Tasks.Task).Assembly, + typeof(System.Threading.Tasks.ValueTask).Assembly, + typeof(System.Linq.Enumerable).Assembly + }; + var references = assemblies + .Select(a => MetadataReference.CreateFromFile(a.Location)) + .ToList(); + + return CSharpCompilation.Create("TestCompilation", + new[] { CSharpSyntaxTree.ParseText(code) }, + references, + new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary, nullableContextOptions: NullableContextOptions.Enable)); + } + + [TestMethod] + public void Constructor_ResolvesSpecialTypes() + { + var compilation = CreateCompilation("class C {}"); + var knownTypes = new KnownTypes(compilation); + + Assert.IsNotNull(knownTypes.String); + Assert.AreEqual(SpecialType.System_String, knownTypes.String.SpecialType); + Assert.IsNotNull(knownTypes.Byte); + Assert.AreEqual(SpecialType.System_Byte, knownTypes.Byte.SpecialType); + Assert.IsNotNull(knownTypes.Int32); + Assert.AreEqual(SpecialType.System_Int32, knownTypes.Int32.SpecialType); + } + + [TestMethod] + public void IsByte_ChecksCorrectly() + { + var compilation = CreateCompilation("class C { byte b; }"); + var knownTypes = new KnownTypes(compilation); + var byteType = compilation.GetSpecialType(SpecialType.System_Byte); + var intType = compilation.GetSpecialType(SpecialType.System_Int32); + + Assert.IsTrue(knownTypes.IsByte(byteType)); + Assert.IsFalse(knownTypes.IsByte(intType)); + Assert.IsFalse(knownTypes.IsByte(null)); + } + + [TestMethod] + public void IsInt32_ChecksCorrectly() + { + var compilation = CreateCompilation("class C { int i; }"); + var knownTypes = new KnownTypes(compilation); + var intType = compilation.GetSpecialType(SpecialType.System_Int32); + var byteType = compilation.GetSpecialType(SpecialType.System_Byte); + + Assert.IsTrue(knownTypes.IsInt32(intType)); + Assert.IsFalse(knownTypes.IsInt32(byteType)); + Assert.IsFalse(knownTypes.IsInt32(null)); + } + + [TestMethod] + public void IsTask_ChecksCorrectly() + { + var compilation = CreateCompilation("using System.Threading.Tasks; class C { Task T() => Task.CompletedTask; }"); + var knownTypes = new KnownTypes(compilation); + var taskType = knownTypes.Task; + + Assert.IsNotNull(taskType); + Assert.IsTrue(knownTypes.IsTask(taskType)); + Assert.IsFalse(knownTypes.IsTask(compilation.GetSpecialType(SpecialType.System_String))); + Assert.IsFalse(knownTypes.IsTask(null)); + } + + [TestMethod] + public void IsString_NullableEnabledChecksCorrectly() + { + var compilation = CreateCompilation(""" + #nullable enable + class C { string? s; } + """); + var knownTypes = new KnownTypes(compilation); + var classC = compilation.GetTypeByMetadataName("C"); + var field = classC?.GetMembers("s").OfType().FirstOrDefault(); + + Assert.IsNotNull(field); + Assert.IsTrue(knownTypes.IsString(field.Type, isNullable: true)); + Assert.IsFalse(knownTypes.IsString(field.Type, isNullable: false)); + } + + [TestMethod] + public void IsString_NullableDisabledChecksCorrectly() + { + var compilation = CreateCompilation(""" + #nullable disable + class C { string s; } + """); + var knownTypes = new KnownTypes(compilation); + var classC = compilation.GetTypeByMetadataName("C"); + var field = classC?.GetMembers("s").OfType().FirstOrDefault(); + + Assert.IsNotNull(field); + Assert.IsTrue(knownTypes.IsString(field.Type, isNullable: false)); + Assert.IsFalse(knownTypes.IsString(field.Type, isNullable: true)); + } + + [TestMethod] + public void IsTaskT_NullableChecksCorrectly() + { + var compilation = CreateCompilation(""" + #nullable enable + using System.Threading.Tasks; + class C { + Task T1() => Task.FromResult(""); + Task T2() => Task.FromResult(null); + } + """); + var knownTypes = new KnownTypes(compilation); + var classC = compilation.GetTypeByMetadataName("C"); + var method1 = classC?.GetMembers("T1").OfType().FirstOrDefault(); + var method2 = classC?.GetMembers("T2").OfType().FirstOrDefault(); + + Assert.IsNotNull(method1); + Assert.IsNotNull(method2); + + Assert.IsTrue(knownTypes.IsTaskT(method1.ReturnType, isNullable: false)); + Assert.IsFalse(knownTypes.IsTaskT(method1.ReturnType, isNullable: true)); + + Assert.IsTrue(knownTypes.IsTaskT(method2.ReturnType, isNullable: true)); + Assert.IsFalse(knownTypes.IsTaskT(method2.ReturnType, isNullable: false)); + } + + [TestMethod] + public void IsValueTaskT_NullableChecksCorrectly() + { + var compilation = CreateCompilation(""" + #nullable enable + using System.Threading.Tasks; + class C { + ValueTask T1() => new ValueTask(""); + ValueTask T2() => new ValueTask(null); + } + """); + var knownTypes = new KnownTypes(compilation); + var classC = compilation.GetTypeByMetadataName("C"); + var method1 = classC?.GetMembers("T1").OfType().FirstOrDefault(); + var method2 = classC?.GetMembers("T2").OfType().FirstOrDefault(); + + Assert.IsNotNull(method1); + Assert.IsNotNull(method2); + + Assert.IsTrue(knownTypes.IsValueTaskT(method1.ReturnType, isNullable: false)); + Assert.IsFalse(knownTypes.IsValueTaskT(method1.ReturnType, isNullable: true)); + + Assert.IsTrue(knownTypes.IsValueTaskT(method2.ReturnType, isNullable: true)); + Assert.IsFalse(knownTypes.IsValueTaskT(method2.ReturnType, isNullable: false)); + } +} diff --git a/dotnet-tools.json b/dotnet-tools.json index 307b712..9c0ab1b 100644 --- a/dotnet-tools.json +++ b/dotnet-tools.json @@ -10,4 +10,4 @@ "rollForward": false } } -} \ No newline at end of file +} From 9cfe7460c21d15643ab44d9391eb8dac4a276ddc Mon Sep 17 00:00:00 2001 From: juner Date: Thu, 28 May 2026 16:05:54 +0900 Subject: [PATCH 15/49] =?UTF-8?q?test(generator):=20MethodSignatureBinder?= =?UTF-8?q?=20=E3=81=AE=E9=9D=9E=E5=90=8C=E6=9C=9F=E3=83=A1=E3=82=BD?= =?UTF-8?q?=E3=83=83=E3=83=89=E3=83=90=E3=82=A4=E3=83=B3=E3=83=87=E3=82=A3?= =?UTF-8?q?=E3=83=B3=E3=82=B0=E3=83=86=E3=82=B9=E3=83=88=E3=82=92=E8=BF=BD?= =?UTF-8?q?=E5=8A=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - MethodSignatureBinderTests.cs: Funge を参考に、より堅牢な Compilation 初期化ロジックを導入し、非同期メソッド（Task/ValueTask/Task/ValueTask）のバインディングテストを実装 - Directory.Build.targets: 必要な依存パッケージおよびバージョンを統一 --- Directory.Build.targets | 1 + .../MethodSignatureBinderTests.cs | 187 ++++++++++++++++++ 2 files changed, 188 insertions(+) create mode 100644 Generator.Abstractions.Tests/MethodSignatureBinderTests.cs diff --git a/Directory.Build.targets b/Directory.Build.targets index 25b214d..3257744 100644 --- a/Directory.Build.targets +++ b/Directory.Build.targets @@ -14,6 +14,7 @@ + diff --git a/Generator.Abstractions.Tests/MethodSignatureBinderTests.cs b/Generator.Abstractions.Tests/MethodSignatureBinderTests.cs new file mode 100644 index 0000000..933996b --- /dev/null +++ b/Generator.Abstractions.Tests/MethodSignatureBinderTests.cs @@ -0,0 +1,187 @@ +using Microsoft.CodeAnalysis; +using Microsoft.CodeAnalysis.CSharp; +using System.Linq; +using System.IO; +using System.Threading; +using System.Threading.Tasks; +using System.Collections.Generic; +using System; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using Esolang.Generator; +using Basic.Reference.Assemblies; +using System.Text; + +namespace Esolang.Generator.Tests; + +[TestClass] +public class MethodSignatureBinderTests(TestContext TestContext) +{ + private Compilation baseCompilation = default!; + + void WriteLine(string message) => TestContext.WriteLine(message); + + [TestInitialize] + public void InitializeCompilation() + { + IEnumerable references = +#if NET10_0_OR_GREATER + Net100.References.All; +#elif NET9_0_OR_GREATER + Net90.References.All; +#elif NET472_OR_GREATER + Net472.References.All; +#else + throw new InvalidOperationException("Unsupported target framework for generator tests."); +#endif + + var referenceList = references.ToList(); + var extraTypes = new[] { + typeof(System.IO.Pipelines.PipeReader), + typeof(Microsoft.Extensions.Logging.ILogger), + typeof(ValueTask), + typeof(IAsyncEnumerable<>) + }; + + foreach (var type in extraTypes) + { + var location = type.Assembly.Location; + if (!string.IsNullOrWhiteSpace(location) && !referenceList.Any(r => Path.GetFileName(r.FilePath) == Path.GetFileName(location))) + { + referenceList.Add(MetadataReference.CreateFromFile(location)); + } + } + + baseCompilation = CSharpCompilation.Create("generatortest", + references: referenceList, + options: new CSharpCompilationOptions( + OutputKind.DynamicallyLinkedLibrary, + nullableContextOptions: NullableContextOptions.Enable)); + } + + private (IMethodSymbol, Compilation) GetMethodAndCompilation(string code, string methodName) + { + // コード全体に対して nullable enable を適用する + var tree = CSharpSyntaxTree.ParseText("#nullable enable\n" + code, cancellationToken: TestContext.CancellationToken); + var compilation = baseCompilation.AddSyntaxTrees(tree); + var classC = compilation.GetTypeByMetadataName("C"); + return (classC!.GetMembers(methodName).OfType().First(), compilation); + } + static string ToString(ITypeSymbol? symbol) + { + var builder = new StringBuilder(); + if (symbol is null) return string.Empty; + builder.Append('('); + builder.Append(symbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat)); + builder.Append(", "); + builder.Append(nameof(symbol.NullableAnnotation)); + builder.Append(':'); + builder.Append(symbol.NullableAnnotation); + builder.Append(')'); + return builder.ToString(); + } + + [TestMethod] + public void Bind_VoidMethod_ReturnsValidBinding() + { + var (method, compilation) = GetMethodAndCompilation("class C { void M() {} }", "M"); + var knownTypes = new KnownTypes(compilation); + + var binding = MethodSignatureBinder.Bind(method, knownTypes); + try + { + Assert.IsTrue(binding.IsValid); + Assert.AreEqual(MethodReturnKind.Void, binding.ReturnKind); + } + catch (AssertFailedException) + { + WriteLine($"binding: {binding}"); + WriteLine($"knownTypes: {knownTypes}"); + WriteLine($"returnType: {ToString(method.ReturnType)}"); + throw; + } + } + + [TestMethod] + public void Bind_TaskMethod_ReturnsValidBinding() + { + var (method, compilation) = GetMethodAndCompilation("using System.Threading.Tasks; class C { Task M() => Task.CompletedTask; }", "M"); + var knownTypes = new KnownTypes(compilation); + + var binding = MethodSignatureBinder.Bind(method, knownTypes); + try + { + Assert.IsTrue(binding.IsValid); + Assert.AreEqual(MethodReturnKind.Task, binding.ReturnKind); + } + catch (AssertFailedException) + { + WriteLine($"binding: {binding}"); + WriteLine($"knownTypes: {knownTypes}"); + WriteLine($"returnType: {ToString(method.ReturnType)}"); + throw; + } + } + + [TestMethod] + public void Bind_ValueTaskMethod_ReturnsValidBinding() + { + var (method, compilation) = GetMethodAndCompilation("using System.Threading.Tasks; class C { ValueTask M() => default; }", "M"); + var knownTypes = new KnownTypes(compilation); + + var binding = MethodSignatureBinder.Bind(method, knownTypes); + try + { + Assert.IsTrue(binding.IsValid); + Assert.AreEqual(MethodReturnKind.ValueTask, binding.ReturnKind); + } + catch (AssertFailedException) + { + WriteLine($"binding: {binding}"); + WriteLine($"knownTypes: {knownTypes}"); + WriteLine($"returnType: {ToString(method.ReturnType)}"); + throw; + } + } + + [TestMethod] + public void Bind_TaskTMethod_ReturnsValidBinding() + { + var (method, compilation) = GetMethodAndCompilation("using System.Threading.Tasks; class C { Task M() => Task.FromResult(0); }", "M"); + var knownTypes = new KnownTypes(compilation); + + var binding = MethodSignatureBinder.Bind(method, knownTypes); + try + { + Assert.IsTrue(binding.IsValid, $"binding: {binding}"); + Assert.AreEqual(MethodReturnKind.TaskInt32, binding.ReturnKind, $"binding: {binding}"); + } + catch (AssertFailedException) + { + WriteLine($"binding: {binding}"); + WriteLine($"knownTypes: {knownTypes}"); + WriteLine($"returnType: {ToString(method.ReturnType)}"); + throw; + } + } + + [TestMethod] + public void Bind_ValueTaskTMethod_ReturnsValidBinding() + { + var (method, compilation) = GetMethodAndCompilation("using System.Threading.Tasks; class C { ValueTask M() => default; }", "M"); + var knownTypes = new KnownTypes(compilation); + + var binding = MethodSignatureBinder.Bind(method, knownTypes); + try + { + Assert.IsTrue(binding.IsValid, $"binding: {binding}"); + Assert.AreEqual(MethodReturnKind.ValueTaskInt32, binding.ReturnKind, $"binding: {binding}"); + } + catch (AssertFailedException) + { + WriteLine($"binding: {binding}"); + WriteLine($"knownTypes: {knownTypes}"); + WriteLine($"returnType: {ToString(method.ReturnType)}"); + throw; + } + } +} From d20baa1e4977a7042792bef2c2cc242361d5d3ca Mon Sep 17 00:00:00 2001 From: juner Date: Thu, 28 May 2026 16:11:47 +0900 Subject: [PATCH 16/49] =?UTF-8?q?test(generator):=20=E6=AE=8B=E3=82=8A?= =?UTF-8?q?=E3=81=AE=E3=83=86=E3=82=B9=E3=83=88=E5=AE=9F=E8=A3=85=E3=83=95?= =?UTF-8?q?=E3=82=A1=E3=82=A4=E3=83=AB=E3=81=A8=E9=96=A2=E9=80=A3=E3=83=97?= =?UTF-8?q?=E3=83=AD=E3=82=B8=E3=82=A7=E3=82=AF=E3=83=88=E8=A8=AD=E5=AE=9A?= =?UTF-8?q?=E3=82=92=E3=82=B3=E3=83=9F=E3=83=83=E3=83=88?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Esolang.Abstractions.code-workspace | 10 ++ Esolang.Abstractions.slnx | 3 + ...solang.Generator.Abstractions.Tests.csproj | 9 +- Generator.Abstractions.Tests/KindTests.cs | 49 ++++++ .../KnownTypesTests.cs | 6 +- .../MethodSignatureBindingTests.cs | 33 ++++ Generator.Abstractions.Tests/NullableTest.cs | 24 +++ .../Esolang.Generator.Abstractions.csproj | 3 +- Generator.Abstractions/KnownTypes.cs | 132 +++++++++++++--- .../MethodSignatureBinding.cs | 148 +++++++++++------- 10 files changed, 333 insertions(+), 84 deletions(-) create mode 100644 Generator.Abstractions.Tests/KindTests.cs create mode 100644 Generator.Abstractions.Tests/MethodSignatureBindingTests.cs create mode 100644 Generator.Abstractions.Tests/NullableTest.cs diff --git a/Esolang.Abstractions.code-workspace b/Esolang.Abstractions.code-workspace index 7bdfe17..41b56d8 100644 --- a/Esolang.Abstractions.code-workspace +++ b/Esolang.Abstractions.code-workspace @@ -4,6 +4,14 @@ "path": ".", "name": "root" }, + { + "path": "Generator.Abstractions", + "name": "Esolang.Generator.Abstractions" + }, + { + "path": "Generator.Abstractions.Tests", + "name": "Esolang.Generator.Abstractions.Tests" + }, { "path": "Processor.Abstractions", "name": "Esolang.Processor.Abstractions" @@ -20,6 +28,8 @@ "**/.hg": true, "**/.DS_Store": true, "**/Thumbs.db": true, + "Generator.Abstractions": true, + "Generator.Abstractions.Tests": true, "Processor.Abstractions": true, "Processor.Abstractions.Tests": true } diff --git a/Esolang.Abstractions.slnx b/Esolang.Abstractions.slnx index 1489e2e..6b4eaa0 100644 --- a/Esolang.Abstractions.slnx +++ b/Esolang.Abstractions.slnx @@ -2,6 +2,9 @@ + + + diff --git a/Generator.Abstractions.Tests/Esolang.Generator.Abstractions.Tests.csproj b/Generator.Abstractions.Tests/Esolang.Generator.Abstractions.Tests.csproj index 3d10bda..f6d2571 100644 --- a/Generator.Abstractions.Tests/Esolang.Generator.Abstractions.Tests.csproj +++ b/Generator.Abstractions.Tests/Esolang.Generator.Abstractions.Tests.csproj @@ -14,11 +14,14 @@ - - - + + + + + + diff --git a/Generator.Abstractions.Tests/KindTests.cs b/Generator.Abstractions.Tests/KindTests.cs new file mode 100644 index 0000000..58574f3 --- /dev/null +++ b/Generator.Abstractions.Tests/KindTests.cs @@ -0,0 +1,49 @@ +using System.Diagnostics.CodeAnalysis; +using Esolang.Generator; +using Microsoft.VisualStudio.TestTools.UnitTesting; + +namespace Esolang.Generator.Tests; + +[TestClass] +public class KindTests +{ + [TestMethod] + [SuppressMessage("MSTest", "MSTEST0032")] + public void MethodInputKind_HasExpectedValues() + { + Assert.AreEqual(0, (int)MethodInputKind.None); + Assert.AreEqual(1, (int)MethodInputKind.String); + Assert.AreEqual(2, (int)MethodInputKind.TextReader); + Assert.AreEqual(3, (int)MethodInputKind.PipeReader); + } + + [TestMethod] + [SuppressMessage("MSTest", "MSTEST0032")] + public void MethodOutputKind_HasExpectedValues() + { + Assert.AreEqual(0, (int)MethodOutputKind.None); + Assert.AreEqual(1, (int)MethodOutputKind.TextWriter); + Assert.AreEqual(2, (int)MethodOutputKind.PipeWriter); + } + + [TestMethod] + [SuppressMessage("MSTest", "MSTEST0032")] + public void MethodReturnKind_HasExpectedValues() + { + Assert.AreEqual(0, (int)MethodReturnKind.Invalid); + Assert.AreEqual(1, (int)MethodReturnKind.Void); + Assert.AreEqual(2, (int)MethodReturnKind.Int32); + Assert.AreEqual(3, (int)MethodReturnKind.String); + Assert.AreEqual(4, (int)MethodReturnKind.NullableString); + Assert.AreEqual(5, (int)MethodReturnKind.Task); + Assert.AreEqual(6, (int)MethodReturnKind.TaskInt32); + Assert.AreEqual(7, (int)MethodReturnKind.TaskString); + Assert.AreEqual(8, (int)MethodReturnKind.TaskNullableString); + Assert.AreEqual(9, (int)MethodReturnKind.ValueTask); + Assert.AreEqual(10, (int)MethodReturnKind.ValueTaskInt32); + Assert.AreEqual(11, (int)MethodReturnKind.ValueTaskString); + Assert.AreEqual(12, (int)MethodReturnKind.ValueTaskNullableString); + Assert.AreEqual(13, (int)MethodReturnKind.IEnumerableByte); + Assert.AreEqual(14, (int)MethodReturnKind.IAsyncEnumerableByte); + } +} diff --git a/Generator.Abstractions.Tests/KnownTypesTests.cs b/Generator.Abstractions.Tests/KnownTypesTests.cs index 7021ddd..f6df287 100644 --- a/Generator.Abstractions.Tests/KnownTypesTests.cs +++ b/Generator.Abstractions.Tests/KnownTypesTests.cs @@ -13,9 +13,9 @@ private static Compilation CreateCompilation(string code) var assemblies = new[] { typeof(object).Assembly, - typeof(System.Threading.Tasks.Task).Assembly, - typeof(System.Threading.Tasks.ValueTask).Assembly, - typeof(System.Linq.Enumerable).Assembly + typeof(Task).Assembly, + typeof(ValueTask).Assembly, + typeof(Enumerable).Assembly }; var references = assemblies .Select(a => MetadataReference.CreateFromFile(a.Location)) diff --git a/Generator.Abstractions.Tests/MethodSignatureBindingTests.cs b/Generator.Abstractions.Tests/MethodSignatureBindingTests.cs new file mode 100644 index 0000000..1115d23 --- /dev/null +++ b/Generator.Abstractions.Tests/MethodSignatureBindingTests.cs @@ -0,0 +1,33 @@ +using Esolang.Generator; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using Microsoft.CodeAnalysis; + +namespace Esolang.Generator.Tests; + +[TestClass] +public class MethodSignatureBindingTests +{ + [TestMethod] + public void PropertiesWorkAsExpected() + { + var binding = new MethodSignatureBinding( + IsValid: true, + ReturnKind: MethodReturnKind.Void, + InputKind: MethodInputKind.None, + OutputKind: MethodOutputKind.None, + InputExpression: "", + OutputExpression: "", + CancellationTokenName: null, + LoggerExpression: null, + IsLoggerFromParameter: false, + UnhandledParameters: [] + ); + + Assert.IsTrue(binding.IsValid); + Assert.IsFalse(binding.HasExplicitInput); + Assert.IsFalse(binding.HasExplicitOutput); + Assert.IsFalse(binding.IsAsync); + Assert.IsFalse(binding.IsEnumerable); + Assert.IsFalse(binding.IsAsyncEnumerable); + } +} diff --git a/Generator.Abstractions.Tests/NullableTest.cs b/Generator.Abstractions.Tests/NullableTest.cs new file mode 100644 index 0000000..d6fcaf1 --- /dev/null +++ b/Generator.Abstractions.Tests/NullableTest.cs @@ -0,0 +1,24 @@ +using Microsoft.CodeAnalysis; +using Microsoft.CodeAnalysis.CSharp; +using Microsoft.VisualStudio.TestTools.UnitTesting; + +namespace Esolang.Generator.Tests; + +[TestClass] +public class NullableTest(TestContext TestContext) +{ +#pragma warning disable MSTEST0054 // TestContext.CancellationTokenSource.Token の代わりに TestContext.CancellationToken を使用する + CancellationToken CancellationToken => TestContext.CancellationTokenSource.Token; +#pragma warning restore MSTEST0054 // TestContext.CancellationTokenSource.Token の代わりに TestContext.CancellationToken を使用する + [TestMethod] + public void CheckNullableContext() + { + var compilation = CSharpCompilation.Create("Test", + new[] { CSharpSyntaxTree.ParseText("class C {}", cancellationToken: CancellationToken) }, + null, + new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)); + + // デフォルトは Disable であるはず + Assert.AreEqual(NullableContextOptions.Disable, compilation.Options.NullableContextOptions); + } +} diff --git a/Generator.Abstractions/Esolang.Generator.Abstractions.csproj b/Generator.Abstractions/Esolang.Generator.Abstractions.csproj index 0df5328..9807533 100644 --- a/Generator.Abstractions/Esolang.Generator.Abstractions.csproj +++ b/Generator.Abstractions/Esolang.Generator.Abstractions.csproj @@ -2,8 +2,7 @@ netstandard2.0;netstandard2.1 - enable - enable + Esolang.Generator true diff --git a/Generator.Abstractions/KnownTypes.cs b/Generator.Abstractions/KnownTypes.cs index 93e824b..624e099 100644 --- a/Generator.Abstractions/KnownTypes.cs +++ b/Generator.Abstractions/KnownTypes.cs @@ -1,4 +1,5 @@ using Microsoft.CodeAnalysis; +using System.Text; namespace Esolang.Generator; @@ -74,7 +75,7 @@ private static bool EqualsType(ITypeSymbol? type, ISymbol? symbol) => /// Gets a value indicating whether the type is string. /// The type to check. /// Optional: Whether to check for nullability. - public bool IsString(ITypeSymbol? type, bool? isNullable = null) + public readonly bool IsString(ITypeSymbol? type, bool? isNullable = null) { if (type is not INamedTypeSymbol named || !SymbolEqualityComparer.Default.Equals(named, String)) return false; if (isNullable == null) return true; @@ -83,14 +84,14 @@ public bool IsString(ITypeSymbol? type, bool? isNullable = null) } /// Gets a value indicating whether the type is byte. - public bool IsByte(ITypeSymbol? type) => EqualsType(type, Byte); + public readonly bool IsByte(ITypeSymbol? type) => EqualsType(type, Byte); /// Gets a value indicating whether the type is int. - public bool IsInt32(ITypeSymbol? type) => EqualsType(type, Int32); + public readonly bool IsInt32(ITypeSymbol? type) => EqualsType(type, Int32); /// Gets a value indicating whether the type is System.Threading.Tasks.Task. - public bool IsTask(ITypeSymbol? type) => EqualsType(type, Task); + public readonly bool IsTask(ITypeSymbol? type) => EqualsType(type, Task); /// Gets a value indicating whether the type is System.Threading.Tasks.Task{TResult}. - public bool IsTaskT(ITypeSymbol? type, bool? isNullable = null) + public readonly bool IsTaskT(ITypeSymbol? type, bool? isNullable = null) { if (type is not INamedTypeSymbol named || !EqualsDefinition(named, TaskT)) return false; if (isNullable == null) return true; @@ -98,9 +99,9 @@ public bool IsTaskT(ITypeSymbol? type, bool? isNullable = null) return isNullable.Value ? annotation == NullableAnnotation.Annotated : annotation is NullableAnnotation.NotAnnotated or NullableAnnotation.None; } /// Gets a value indicating whether the type is System.Threading.Tasks.ValueTask. - public bool IsValueTask(ITypeSymbol? type) => EqualsType(type, ValueTask); + public readonly bool IsValueTask(ITypeSymbol? type) => EqualsType(type, ValueTask); /// Gets a value indicating whether the type is System.Threading.Tasks.ValueTask{TResult}. - public bool IsValueTaskT(ITypeSymbol? type, bool? isNullable = null) + public readonly bool IsValueTaskT(ITypeSymbol? type, bool? isNullable = null) { if (type is not INamedTypeSymbol named || !EqualsDefinition(named, ValueTaskT)) return false; if (isNullable == null) return true; @@ -108,38 +109,38 @@ public bool IsValueTaskT(ITypeSymbol? type, bool? isNullable = null) return isNullable.Value ? annotation == NullableAnnotation.Annotated : annotation is NullableAnnotation.NotAnnotated or NullableAnnotation.None; } /// Gets a value indicating whether the type is System.Collections.Generic.IEnumerable{T}. - public bool IsIEnumerableT(ITypeSymbol? type) => EqualsDefinition(type, IEnumerableT); + public readonly bool IsIEnumerableT(ITypeSymbol? type) => EqualsDefinition(type, IEnumerableT); /// Gets a value indicating whether the type is System.Collections.Generic.IAsyncEnumerable{T}. - public bool IsIAsyncEnumerableT(ITypeSymbol? type) => EqualsDefinition(type, IAsyncEnumerableT); + public readonly bool IsIAsyncEnumerableT(ITypeSymbol? type) => EqualsDefinition(type, IAsyncEnumerableT); /// Gets a value indicating whether the type is System.IO.Pipelines.PipeReader. - public bool IsPipeReader(ITypeSymbol? type) => EqualsType(type, PipeReader); + public readonly bool IsPipeReader(ITypeSymbol? type) => EqualsType(type, PipeReader); /// Gets a value indicating whether the type is System.IO.Pipelines.PipeWriter. - public bool IsPipeWriter(ITypeSymbol? type) => EqualsType(type, PipeWriter); + public readonly bool IsPipeWriter(ITypeSymbol? type) => EqualsType(type, PipeWriter); /// Gets a value indicating whether the type is System.IO.TextReader. - public bool IsTextReader(ITypeSymbol? type) => EqualsType(type, TextReader); + public readonly bool IsTextReader(ITypeSymbol? type) => EqualsType(type, TextReader); /// Gets a value indicating whether the type is System.IO.TextWriter. - public bool IsTextWriter(ITypeSymbol? type) => EqualsType(type, TextWriter); + public readonly bool IsTextWriter(ITypeSymbol? type) => EqualsType(type, TextWriter); /// Gets a value indicating whether the type is System.Threading.CancellationToken. - public bool IsCancellationToken(ITypeSymbol? type) => EqualsType(type, CancellationToken); + public readonly bool IsCancellationToken(ITypeSymbol? type) => EqualsType(type, CancellationToken); /// Gets a value indicating whether the type is System.Threading.Tasks.Task{String}. - public bool IsTaskString(ITypeSymbol? type, bool? isNullable = null) => IsTaskT(type, isNullable) && ((INamedTypeSymbol)type!).TypeArguments[0].SpecialType == SpecialType.System_String; + public readonly bool IsTaskString(ITypeSymbol? type, bool? isNullable = null) => IsTaskT(type, isNullable) && ((INamedTypeSymbol)type!).TypeArguments[0].SpecialType == SpecialType.System_String; /// Gets a value indicating whether the type is System.Threading.Tasks.ValueTask{String}. - public bool IsValueTaskString(ITypeSymbol? type, bool? isNullable = null) => IsValueTaskT(type, isNullable) && ((INamedTypeSymbol)type!).TypeArguments[0].SpecialType == SpecialType.System_String; + public readonly bool IsValueTaskString(ITypeSymbol? type, bool? isNullable = null) => IsValueTaskT(type, isNullable) && ((INamedTypeSymbol)type!).TypeArguments[0].SpecialType == SpecialType.System_String; /// Gets a value indicating whether the type is System.Threading.Tasks.Task{Int32}. - public bool IsTaskInt32(ITypeSymbol? type) => IsTaskT(type) && ((INamedTypeSymbol)type!).TypeArguments[0].SpecialType == SpecialType.System_Int32; + public readonly bool IsTaskInt32(ITypeSymbol? type) => IsTaskT(type) && ((INamedTypeSymbol)type!).TypeArguments[0].SpecialType == SpecialType.System_Int32; /// Gets a value indicating whether the type is System.Threading.Tasks.ValueTask{Int32}. - public bool IsValueTaskInt32(ITypeSymbol? type) => IsValueTaskT(type) && ((INamedTypeSymbol)type!).TypeArguments[0].SpecialType == SpecialType.System_Int32; + public readonly bool IsValueTaskInt32(ITypeSymbol? type) => IsValueTaskT(type) && ((INamedTypeSymbol)type!).TypeArguments[0].SpecialType == SpecialType.System_Int32; /// Gets a value indicating whether the type is System.Collections.Generic.IEnumerable{Byte}. - public bool IsIEnumerableByte(ITypeSymbol? type) => IsIEnumerableT(type) && ((INamedTypeSymbol)type!).TypeArguments[0].SpecialType == SpecialType.System_Byte; + public readonly bool IsIEnumerableByte(ITypeSymbol? type) => IsIEnumerableT(type) && ((INamedTypeSymbol)type!).TypeArguments[0].SpecialType == SpecialType.System_Byte; /// Gets a value indicating whether the type is System.Collections.Generic.IAsyncEnumerable{Byte}. - public bool IsIAsyncEnumerableByte(ITypeSymbol? type) => IsIAsyncEnumerableT(type) && ((INamedTypeSymbol)type!).TypeArguments[0].SpecialType == SpecialType.System_Byte; + public readonly bool IsIAsyncEnumerableByte(ITypeSymbol? type) => IsIAsyncEnumerableT(type) && ((INamedTypeSymbol)type!).TypeArguments[0].SpecialType == SpecialType.System_Byte; /// Gets a value indicating whether the type is a logger type (ILogger or ILogger{T}). - public bool IsLogger(ITypeSymbol? type) + public readonly bool IsLogger(ITypeSymbol? type) { if (type == null) return false; if (EqualsType(type, ILogger) || EqualsDefinition(type, ILoggerT)) return true; @@ -149,6 +150,95 @@ public bool IsLogger(ITypeSymbol? type) } return false; } + readonly bool PrintMembers(StringBuilder builder) + { + builder.Append(nameof(String)).Append('='); + AppendNamedTypeSymbol(String, builder); + builder.Append(", "); + + builder.Append(nameof(Byte)).Append('='); + AppendNamedTypeSymbol(Byte, builder); + builder.Append(", "); + + builder.Append(nameof(Int32)).Append('='); + AppendNamedTypeSymbol(Int32, builder); + builder.Append(", "); + + builder.Append(nameof(Task)).Append('='); + AppendNamedTypeSymbol(Task, builder); + builder.Append(", "); + + builder.Append(nameof(TaskT)).Append('='); + AppendNamedTypeSymbol(TaskT, builder); + builder.Append(", "); + + builder.Append(nameof(ValueTask)).Append('='); + AppendNamedTypeSymbol(ValueTask, builder); + builder.Append(", "); + + builder.Append(nameof(ValueTaskT)).Append('='); + AppendNamedTypeSymbol(ValueTaskT, builder); + builder.Append(", "); + + builder.Append(nameof(IEnumerableT)).Append('='); + AppendNamedTypeSymbol(IEnumerableT, builder); + builder.Append(", "); + + builder.Append(nameof(IAsyncEnumerableT)).Append('='); + AppendNamedTypeSymbol(IAsyncEnumerableT, builder); + builder.Append(", "); + + builder.Append(nameof(PipeReader)).Append('='); + AppendNamedTypeSymbol(PipeReader, builder); + builder.Append(", "); + + builder.Append(nameof(PipeWriter)).Append('='); + AppendNamedTypeSymbol(PipeWriter, builder); + builder.Append(", "); + + builder.Append(nameof(TextReader)).Append('='); + AppendNamedTypeSymbol(TextReader, builder); + builder.Append(", "); + + builder.Append(nameof(TextWriter)).Append('='); + AppendNamedTypeSymbol(TextWriter, builder); + builder.Append(", "); + + builder.Append(nameof(CancellationToken)).Append('='); + AppendNamedTypeSymbol(CancellationToken, builder); + builder.Append(", "); + + builder.Append(nameof(ILogger)).Append('='); + AppendNamedTypeSymbol(ILogger, builder); + builder.Append(", "); + + builder.Append(nameof(ILoggerT)).Append('='); + AppendNamedTypeSymbol(ILoggerT, builder); + + return true; + static void AppendNamedTypeSymbol(INamedTypeSymbol? symbol, StringBuilder builder) + { + if (symbol == null) return; + builder.Append('('); + builder.Append(symbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat)); + builder.Append(", "); + builder.Append(nameof(symbol.NullableAnnotation)).Append('=').Append(symbol.NullableAnnotation); + builder.Append(')'); + } + } + + /// + public override string ToString() + { + var builder = new StringBuilder(); + builder.Append(nameof(KnownTypes)).Append(" {"); + if (!PrintMembers(builder)) + { + builder.Append(' '); + } + builder.Append('}'); + return builder.ToString(); + } } /// diff --git a/Generator.Abstractions/MethodSignatureBinding.cs b/Generator.Abstractions/MethodSignatureBinding.cs index 5586a0e..7d81cff 100644 --- a/Generator.Abstractions/MethodSignatureBinding.cs +++ b/Generator.Abstractions/MethodSignatureBinding.cs @@ -1,55 +1,93 @@ -using Microsoft.CodeAnalysis; -using System.Collections.Generic; - -namespace Esolang.Generator; - -/// -/// Represents the result of binding a method signature for generation. -/// -/// Whether the binding is successful. -/// The return kind of the method. -/// The input kind of the method. -/// The output kind of the method. -/// The expression to access the input (e.g., parameter name). -/// The expression to access the output (e.g., parameter name). -/// The name of the cancellation token parameter, if any. -/// The expression to access the logger (e.g., "loggerParam", "this._logger"). -/// Whether the logger is obtained from a method parameter. -/// Parameters that were not handled by the common binding logic. -/// The diagnostic error ID if the binding failed. -/// The location associated with the error. -public record struct MethodSignatureBinding( - bool IsValid, - MethodReturnKind ReturnKind, - MethodInputKind InputKind, - MethodOutputKind OutputKind, - string InputExpression, - string OutputExpression, - string? CancellationTokenName, - string? LoggerExpression, - bool IsLoggerFromParameter, - IReadOnlyList UnhandledParameters, - string? ErrorId = null, - Location? Location = null) -{ - /// Gets a value indicating whether the method has an explicit input mechanism. - public readonly bool HasExplicitInput => InputKind != MethodInputKind.None; - - /// Gets a value indicating whether the method has an explicit output mechanism. - public readonly bool HasExplicitOutput => OutputKind != MethodOutputKind.None; - - /// Gets a value indicating whether the method is asynchronous. - public readonly bool IsAsync => ReturnKind switch - { - MethodReturnKind.Task or MethodReturnKind.TaskInt32 or MethodReturnKind.TaskString or MethodReturnKind.TaskNullableString or - MethodReturnKind.ValueTask or MethodReturnKind.ValueTaskInt32 or MethodReturnKind.ValueTaskString or MethodReturnKind.ValueTaskNullableString or - MethodReturnKind.IAsyncEnumerableByte => true, - _ => false - }; - - /// Gets a value indicating whether the method returns an enumerable. - public readonly bool IsEnumerable => ReturnKind == MethodReturnKind.IEnumerableByte; - - /// Gets a value indicating whether the method returns an async enumerable. - public readonly bool IsAsyncEnumerable => ReturnKind == MethodReturnKind.IAsyncEnumerableByte; -} +using Microsoft.CodeAnalysis; +using System.Collections.Generic; +using System.Diagnostics; +using System.Text; + +namespace Esolang.Generator; + +/// +/// Represents the result of binding a method signature for generation. +/// +/// Whether the binding is successful. +/// The return kind of the method. +/// The input kind of the method. +/// The output kind of the method. +/// The expression to access the input (e.g., parameter name). +/// The expression to access the output (e.g., parameter name). +/// The name of the cancellation token parameter, if any. +/// The expression to access the logger (e.g., "loggerParam", "this._logger"). +/// Whether the logger is obtained from a method parameter. +/// Parameters that were not handled by the common binding logic. +/// The diagnostic error ID if the binding failed. +/// The location associated with the error. +[DebuggerDisplay("{ToString(),nq}")] +public record struct MethodSignatureBinding( + bool IsValid, + MethodReturnKind ReturnKind, + MethodInputKind InputKind, + MethodOutputKind OutputKind, + string InputExpression, + string OutputExpression, + string? CancellationTokenName, + string? LoggerExpression, + bool IsLoggerFromParameter, + IReadOnlyList UnhandledParameters, + string? ErrorId = null, + Location? Location = null) +{ + /// Gets a value indicating whether the method has an explicit input mechanism. + public readonly bool HasExplicitInput => InputKind != MethodInputKind.None; + + /// Gets a value indicating whether the method has an explicit output mechanism. + public readonly bool HasExplicitOutput => OutputKind != MethodOutputKind.None; + + /// Gets a value indicating whether the method is asynchronous. + public readonly bool IsAsync => ReturnKind switch + { + MethodReturnKind.Task or MethodReturnKind.TaskInt32 or MethodReturnKind.TaskString or MethodReturnKind.TaskNullableString or + MethodReturnKind.ValueTask or MethodReturnKind.ValueTaskInt32 or MethodReturnKind.ValueTaskString or MethodReturnKind.ValueTaskNullableString or + MethodReturnKind.IAsyncEnumerableByte => true, + _ => false + }; + + /// Gets a value indicating whether the method returns an enumerable. + public readonly bool IsEnumerable => ReturnKind == MethodReturnKind.IEnumerableByte; + + /// Gets a value indicating whether the method returns an async enumerable. + public readonly bool IsAsyncEnumerable => ReturnKind == MethodReturnKind.IAsyncEnumerableByte; + + readonly bool PrintMembers(StringBuilder builder) + { + builder.Append(nameof(IsValid)).Append('=').Append(IsValid).Append(", "); + builder.Append(nameof(ReturnKind)).Append('=').Append(ReturnKind).Append(", "); + builder.Append(nameof(InputKind)).Append('=').Append(InputKind).Append(", "); + builder.Append(nameof(OutputKind)).Append('=').Append(OutputKind).Append(", "); + builder.Append(nameof(InputExpression)).Append('=').Append(InputExpression).Append(", "); + builder.Append(nameof(OutputExpression)).Append('=').Append(OutputExpression).Append(", "); + builder.Append(nameof(CancellationTokenName)).Append('=').Append(CancellationTokenName).Append(", "); + builder.Append(nameof(LoggerExpression)).Append('=').Append(LoggerExpression).Append(", "); + builder.Append(nameof(IsLoggerFromParameter)).Append('=').Append(IsLoggerFromParameter).Append(", "); + builder.Append(nameof(UnhandledParameters)).Append("=["); + for (var i = 0; i < UnhandledParameters.Count; i++) + { + if (i > 0) builder.Append(", "); + builder.Append(UnhandledParameters[i].ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat)); + } + builder.Append(']'); + return true; + } + + /// + public override readonly string ToString() + { + var builder = new StringBuilder(); + builder.Append(nameof(MethodSignatureBinding)).Append(" {"); + if (!PrintMembers(builder)) + { + builder.Append(' '); + } + builder.Append('}'); + return builder.ToString(); + } + +} From 7f0f6a9c05394da260c7b848f8a91504449c0e39 Mon Sep 17 00:00:00 2001 From: juner Date: Thu, 28 May 2026 16:41:18 +0900 Subject: [PATCH 17/49] =?UTF-8?q?test(generator):=20MethodSignatureBinder?= =?UTF-8?q?=20=E3=81=AE=E5=85=A8=E7=B6=B2=E7=BE=85=E3=83=86=E3=82=B9?= =?UTF-8?q?=E3=83=88=E5=AE=9F=E8=A3=85=E3=81=A8=E3=83=86=E3=82=B9=E3=83=88?= =?UTF-8?q?=E7=92=B0=E5=A2=83=E3=81=AE=E5=AE=89=E5=AE=9A=E5=8C=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - MethodSignatureBinderTests.cs: パラメータ・戻り値バインディング、エラーケース、Logger/CancellationToken 対応等、全網羅的なテスト実装 - Directory.Build.targets: パッケージバージョン管理の最適化 - KnownTypes.cs: ToString に ExcludeFromCodeCoverage 属性を追加 --- .../MethodSignatureBinderTests.cs | 184 ++++++++++-------- 1 file changed, 107 insertions(+), 77 deletions(-) diff --git a/Generator.Abstractions.Tests/MethodSignatureBinderTests.cs b/Generator.Abstractions.Tests/MethodSignatureBinderTests.cs index 933996b..3b4f14b 100644 --- a/Generator.Abstractions.Tests/MethodSignatureBinderTests.cs +++ b/Generator.Abstractions.Tests/MethodSignatureBinderTests.cs @@ -38,8 +38,10 @@ public void InitializeCompilation() var extraTypes = new[] { typeof(System.IO.Pipelines.PipeReader), typeof(Microsoft.Extensions.Logging.ILogger), +#if NET472_OR_GREATER typeof(ValueTask), typeof(IAsyncEnumerable<>) +#endif }; foreach (var type in extraTypes) @@ -53,32 +55,16 @@ public void InitializeCompilation() baseCompilation = CSharpCompilation.Create("generatortest", references: referenceList, - options: new CSharpCompilationOptions( - OutputKind.DynamicallyLinkedLibrary, - nullableContextOptions: NullableContextOptions.Enable)); + options: new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary, nullableContextOptions: NullableContextOptions.Enable)); } private (IMethodSymbol, Compilation) GetMethodAndCompilation(string code, string methodName) { - // コード全体に対して nullable enable を適用する var tree = CSharpSyntaxTree.ParseText("#nullable enable\n" + code, cancellationToken: TestContext.CancellationToken); var compilation = baseCompilation.AddSyntaxTrees(tree); var classC = compilation.GetTypeByMetadataName("C"); return (classC!.GetMembers(methodName).OfType().First(), compilation); } - static string ToString(ITypeSymbol? symbol) - { - var builder = new StringBuilder(); - if (symbol is null) return string.Empty; - builder.Append('('); - builder.Append(symbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat)); - builder.Append(", "); - builder.Append(nameof(symbol.NullableAnnotation)); - builder.Append(':'); - builder.Append(symbol.NullableAnnotation); - builder.Append(')'); - return builder.ToString(); - } [TestMethod] public void Bind_VoidMethod_ReturnsValidBinding() @@ -87,18 +73,8 @@ public void Bind_VoidMethod_ReturnsValidBinding() var knownTypes = new KnownTypes(compilation); var binding = MethodSignatureBinder.Bind(method, knownTypes); - try - { - Assert.IsTrue(binding.IsValid); - Assert.AreEqual(MethodReturnKind.Void, binding.ReturnKind); - } - catch (AssertFailedException) - { - WriteLine($"binding: {binding}"); - WriteLine($"knownTypes: {knownTypes}"); - WriteLine($"returnType: {ToString(method.ReturnType)}"); - throw; - } + Assert.IsTrue(binding.IsValid, $"binding: {binding}"); + Assert.AreEqual(MethodReturnKind.Void, binding.ReturnKind, $"binding: {binding}"); } [TestMethod] @@ -106,20 +82,22 @@ public void Bind_TaskMethod_ReturnsValidBinding() { var (method, compilation) = GetMethodAndCompilation("using System.Threading.Tasks; class C { Task M() => Task.CompletedTask; }", "M"); var knownTypes = new KnownTypes(compilation); - - var binding = MethodSignatureBinder.Bind(method, knownTypes); - try + + Assert.IsNotNull(knownTypes.Task, "KnownTypes.Task is null"); + + var equality = SymbolEqualityComparer.Default.Equals(method.ReturnType, knownTypes.Task); + if (!equality) { - Assert.IsTrue(binding.IsValid); - Assert.AreEqual(MethodReturnKind.Task, binding.ReturnKind); - } - catch (AssertFailedException) - { - WriteLine($"binding: {binding}"); - WriteLine($"knownTypes: {knownTypes}"); - WriteLine($"returnType: {ToString(method.ReturnType)}"); - throw; + WriteLine($"SymbolEqualityComparer failed: ReturnType={method.ReturnType}, KnownTypes.Task={knownTypes.Task}"); + WriteLine($"ReturnType Assembly: {method.ReturnType.ContainingAssembly?.Name}"); + WriteLine($"KnownTypes.Task Assembly: {knownTypes.Task?.ContainingAssembly?.Name}"); } + + Assert.IsTrue(equality, $"SymbolEqualityComparer failed: ReturnType={method.ReturnType}, KnownTypes.Task={knownTypes.Task}"); + + var binding = MethodSignatureBinder.Bind(method, knownTypes); + Assert.IsTrue(binding.IsValid, $"binding: {binding}"); + Assert.AreEqual(MethodReturnKind.Task, binding.ReturnKind, $"binding: {binding}"); } [TestMethod] @@ -129,18 +107,8 @@ public void Bind_ValueTaskMethod_ReturnsValidBinding() var knownTypes = new KnownTypes(compilation); var binding = MethodSignatureBinder.Bind(method, knownTypes); - try - { - Assert.IsTrue(binding.IsValid); - Assert.AreEqual(MethodReturnKind.ValueTask, binding.ReturnKind); - } - catch (AssertFailedException) - { - WriteLine($"binding: {binding}"); - WriteLine($"knownTypes: {knownTypes}"); - WriteLine($"returnType: {ToString(method.ReturnType)}"); - throw; - } + Assert.IsTrue(binding.IsValid, $"binding: {binding}"); + Assert.AreEqual(MethodReturnKind.ValueTask, binding.ReturnKind, $"binding: {binding}"); } [TestMethod] @@ -150,18 +118,8 @@ public void Bind_TaskTMethod_ReturnsValidBinding() var knownTypes = new KnownTypes(compilation); var binding = MethodSignatureBinder.Bind(method, knownTypes); - try - { - Assert.IsTrue(binding.IsValid, $"binding: {binding}"); - Assert.AreEqual(MethodReturnKind.TaskInt32, binding.ReturnKind, $"binding: {binding}"); - } - catch (AssertFailedException) - { - WriteLine($"binding: {binding}"); - WriteLine($"knownTypes: {knownTypes}"); - WriteLine($"returnType: {ToString(method.ReturnType)}"); - throw; - } + Assert.IsTrue(binding.IsValid, $"binding: {binding}"); + Assert.AreEqual(MethodReturnKind.TaskInt32, binding.ReturnKind, $"binding: {binding}"); } [TestMethod] @@ -171,17 +129,89 @@ public void Bind_ValueTaskTMethod_ReturnsValidBinding() var knownTypes = new KnownTypes(compilation); var binding = MethodSignatureBinder.Bind(method, knownTypes); - try - { - Assert.IsTrue(binding.IsValid, $"binding: {binding}"); - Assert.AreEqual(MethodReturnKind.ValueTaskInt32, binding.ReturnKind, $"binding: {binding}"); - } - catch (AssertFailedException) - { - WriteLine($"binding: {binding}"); - WriteLine($"knownTypes: {knownTypes}"); - WriteLine($"returnType: {ToString(method.ReturnType)}"); - throw; - } + Assert.IsTrue(binding.IsValid, $"binding: {binding}"); + Assert.AreEqual(MethodReturnKind.ValueTaskInt32, binding.ReturnKind, $"binding: {binding}"); + } + + [TestMethod] + public void Bind_StringInput_ReturnsValidBinding() + { + var (method, compilation) = GetMethodAndCompilation("class C { void M(string s) {} }", "M"); + var knownTypes = new KnownTypes(compilation); + + var binding = MethodSignatureBinder.Bind(method, knownTypes); + Assert.IsTrue(binding.IsValid, $"binding: {binding}"); + Assert.AreEqual(MethodInputKind.String, binding.InputKind); + Assert.AreEqual("s", binding.InputExpression); + } + + [TestMethod] + public void Bind_TextReaderInput_ReturnsValidBinding() + { + var (method, compilation) = GetMethodAndCompilation("using System.IO; class C { void M(TextReader r) {} }", "M"); + var knownTypes = new KnownTypes(compilation); + + var binding = MethodSignatureBinder.Bind(method, knownTypes); + Assert.IsTrue(binding.IsValid, $"binding: {binding}"); + Assert.AreEqual(MethodInputKind.TextReader, binding.InputKind); + Assert.AreEqual("r", binding.InputExpression); + } + + [TestMethod] + public void Bind_TextWriterOutput_ReturnsValidBinding() + { + var (method, compilation) = GetMethodAndCompilation("using System.IO; class C { void M(TextWriter w) {} }", "M"); + var knownTypes = new KnownTypes(compilation); + + var binding = MethodSignatureBinder.Bind(method, knownTypes); + Assert.IsTrue(binding.IsValid, $"binding: {binding}"); + Assert.AreEqual(MethodOutputKind.TextWriter, binding.OutputKind); + Assert.AreEqual("w", binding.OutputExpression); + } + + [TestMethod] + public void Bind_DuplicateParameters_ReturnsInvalidBinding() + { + var (method, compilation) = GetMethodAndCompilation("class C { void M(string s1, string s2) {} }", "M"); + var knownTypes = new KnownTypes(compilation); + + var binding = MethodSignatureBinder.Bind(method, knownTypes); + Assert.IsFalse(binding.IsValid); + Assert.AreEqual("ES0003", binding.ErrorId); // DuplicateParameterErrorId + } + + [TestMethod] + public void Bind_CancellationToken_ReturnsValidBinding() + { + var (method, compilation) = GetMethodAndCompilation("using System.Threading; class C { void M(CancellationToken ct) {} }", "M"); + var knownTypes = new KnownTypes(compilation); + + var binding = MethodSignatureBinder.Bind(method, knownTypes); + Assert.IsTrue(binding.IsValid); + Assert.AreEqual("ct", binding.CancellationTokenName); + } + + [TestMethod] + public void Bind_LoggerParameter_ReturnsValidBinding() + { + var (method, compilation) = GetMethodAndCompilation("using Microsoft.Extensions.Logging; class C { void M(ILogger logger) {} }", "M"); + var knownTypes = new KnownTypes(compilation); + + var binding = MethodSignatureBinder.Bind(method, knownTypes); + Assert.IsTrue(binding.IsValid); + Assert.IsTrue(binding.IsLoggerFromParameter); + Assert.AreEqual("logger", binding.LoggerExpression); + } + + [TestMethod] + public void Bind_UnhandledParameters_AddedToUnhandledList() + { + var (method, compilation) = GetMethodAndCompilation("class C { void M(int i, string s) {} }", "M"); + var knownTypes = new KnownTypes(compilation); + + var binding = MethodSignatureBinder.Bind(method, knownTypes); + Assert.IsTrue(binding.IsValid); + Assert.AreEqual(1, binding.UnhandledParameters.Count); + Assert.AreEqual("i", binding.UnhandledParameters[0].Name); } } From bf5133fa470628b38ba1d336fd608c0a61bebe86 Mon Sep 17 00:00:00 2001 From: juner Date: Thu, 28 May 2026 16:41:49 +0900 Subject: [PATCH 18/49] =?UTF-8?q?test(generator):=20NullableAnnotation=20?= =?UTF-8?q?=E5=91=A8=E3=82=8A=E3=81=AE=E4=BF=AE=E6=AD=A3=E3=81=A8=E3=82=AB?= =?UTF-8?q?=E3=83=90=E3=83=AC=E3=83=83=E3=82=B8=E8=AA=BF=E6=95=B4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - KnownTypes.cs: ToString に ExcludeFromCodeCoverage を追加 - KnownTypesTests.cs: シンボル比較の堅牢化 --- Generator.Abstractions.Tests/KnownTypesTests.cs | 10 ++++++---- Generator.Abstractions/KnownTypes.cs | 4 ++++ Generator.Abstractions/MethodSignatureBinding.cs | 3 +++ 3 files changed, 13 insertions(+), 4 deletions(-) diff --git a/Generator.Abstractions.Tests/KnownTypesTests.cs b/Generator.Abstractions.Tests/KnownTypesTests.cs index f6df287..86171ed 100644 --- a/Generator.Abstractions.Tests/KnownTypesTests.cs +++ b/Generator.Abstractions.Tests/KnownTypesTests.cs @@ -13,10 +13,12 @@ private static Compilation CreateCompilation(string code) var assemblies = new[] { typeof(object).Assembly, - typeof(Task).Assembly, - typeof(ValueTask).Assembly, - typeof(Enumerable).Assembly - }; + typeof(System.Threading.Tasks.Task).Assembly, + typeof(System.Linq.Enumerable).Assembly + }.ToList(); +#if NET472_OR_GREATER + assemblies.Add(typeof(System.Threading.Tasks.ValueTask).Assembly); +#endif var references = assemblies .Select(a => MetadataReference.CreateFromFile(a.Location)) .ToList(); diff --git a/Generator.Abstractions/KnownTypes.cs b/Generator.Abstractions/KnownTypes.cs index 624e099..94131f9 100644 --- a/Generator.Abstractions/KnownTypes.cs +++ b/Generator.Abstractions/KnownTypes.cs @@ -1,4 +1,5 @@ using Microsoft.CodeAnalysis; +using System.Diagnostics.CodeAnalysis; using System.Text; namespace Esolang.Generator; @@ -150,6 +151,8 @@ public readonly bool IsLogger(ITypeSymbol? type) } return false; } + + [ExcludeFromCodeCoverage] readonly bool PrintMembers(StringBuilder builder) { builder.Append(nameof(String)).Append('='); @@ -228,6 +231,7 @@ static void AppendNamedTypeSymbol(INamedTypeSymbol? symbol, StringBuilder builde } /// + [ExcludeFromCodeCoverage] public override string ToString() { var builder = new StringBuilder(); diff --git a/Generator.Abstractions/MethodSignatureBinding.cs b/Generator.Abstractions/MethodSignatureBinding.cs index 7d81cff..680b756 100644 --- a/Generator.Abstractions/MethodSignatureBinding.cs +++ b/Generator.Abstractions/MethodSignatureBinding.cs @@ -1,6 +1,7 @@ using Microsoft.CodeAnalysis; using System.Collections.Generic; using System.Diagnostics; +using System.Diagnostics.CodeAnalysis; using System.Text; namespace Esolang.Generator; @@ -56,6 +57,7 @@ MethodReturnKind.ValueTask or MethodReturnKind.ValueTaskInt32 or MethodReturnKin /// Gets a value indicating whether the method returns an async enumerable. public readonly bool IsAsyncEnumerable => ReturnKind == MethodReturnKind.IAsyncEnumerableByte; + [ExcludeFromCodeCoverage] readonly bool PrintMembers(StringBuilder builder) { builder.Append(nameof(IsValid)).Append('=').Append(IsValid).Append(", "); @@ -78,6 +80,7 @@ readonly bool PrintMembers(StringBuilder builder) } /// + [ExcludeFromCodeCoverage] public override readonly string ToString() { var builder = new StringBuilder(); From 969590418f9805b606b59aad6685ce3b84bc70e9 Mon Sep 17 00:00:00 2001 From: juner Date: Thu, 28 May 2026 17:04:51 +0900 Subject: [PATCH 19/49] =?UTF-8?q?test(generator):=20MethodSignatureBinder?= =?UTF-8?q?=20=E3=81=AE=E3=83=90=E3=82=A4=E3=83=B3=E3=83=87=E3=82=A3?= =?UTF-8?q?=E3=83=B3=E3=82=B0=E7=B6=B2=E7=BE=85=E3=83=86=E3=82=B9=E3=83=88?= =?UTF-8?q?=E3=81=AE=E8=BF=BD=E5=8A=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - MethodSignatureBinderTests.cs: Bind メソッドの分岐網羅（Invalid系, PipeReader/Writer, Logger, Refパラメータ, 重複エラー）を完了 --- .../MethodSignatureBinderTests.cs | 174 ++++++++++++++++-- 1 file changed, 155 insertions(+), 19 deletions(-) diff --git a/Generator.Abstractions.Tests/MethodSignatureBinderTests.cs b/Generator.Abstractions.Tests/MethodSignatureBinderTests.cs index 3b4f14b..49f2961 100644 --- a/Generator.Abstractions.Tests/MethodSignatureBinderTests.cs +++ b/Generator.Abstractions.Tests/MethodSignatureBinderTests.cs @@ -85,16 +85,6 @@ public void Bind_TaskMethod_ReturnsValidBinding() Assert.IsNotNull(knownTypes.Task, "KnownTypes.Task is null"); - var equality = SymbolEqualityComparer.Default.Equals(method.ReturnType, knownTypes.Task); - if (!equality) - { - WriteLine($"SymbolEqualityComparer failed: ReturnType={method.ReturnType}, KnownTypes.Task={knownTypes.Task}"); - WriteLine($"ReturnType Assembly: {method.ReturnType.ContainingAssembly?.Name}"); - WriteLine($"KnownTypes.Task Assembly: {knownTypes.Task?.ContainingAssembly?.Name}"); - } - - Assert.IsTrue(equality, $"SymbolEqualityComparer failed: ReturnType={method.ReturnType}, KnownTypes.Task={knownTypes.Task}"); - var binding = MethodSignatureBinder.Bind(method, knownTypes); Assert.IsTrue(binding.IsValid, $"binding: {binding}"); Assert.AreEqual(MethodReturnKind.Task, binding.ReturnKind, $"binding: {binding}"); @@ -170,31 +160,50 @@ public void Bind_TextWriterOutput_ReturnsValidBinding() } [TestMethod] - public void Bind_DuplicateParameters_ReturnsInvalidBinding() + public void Bind_LoggerInField_ReturnsValidBinding() { - var (method, compilation) = GetMethodAndCompilation("class C { void M(string s1, string s2) {} }", "M"); + var (method, compilation) = GetMethodAndCompilation(""" + using Microsoft.Extensions.Logging; + class C { + ILogger _logger; + C(ILogger logger) => _logger = logger; + void M() {} + } + """, "M"); var knownTypes = new KnownTypes(compilation); var binding = MethodSignatureBinder.Bind(method, knownTypes); - Assert.IsFalse(binding.IsValid); - Assert.AreEqual("ES0003", binding.ErrorId); // DuplicateParameterErrorId + Assert.IsTrue(binding.IsValid); + Assert.IsFalse(binding.IsLoggerFromParameter); + Assert.AreEqual("_logger", binding.LoggerExpression); } [TestMethod] - public void Bind_CancellationToken_ReturnsValidBinding() + public void Bind_LoggerInBaseClass_ReturnsValidBinding() { - var (method, compilation) = GetMethodAndCompilation("using System.Threading; class C { void M(CancellationToken ct) {} }", "M"); + var (method, compilation) = GetMethodAndCompilation(""" + using Microsoft.Extensions.Logging; + class B { protected ILogger _logger; } + class C : B { void M() {} } + """, "M"); var knownTypes = new KnownTypes(compilation); var binding = MethodSignatureBinder.Bind(method, knownTypes); Assert.IsTrue(binding.IsValid); - Assert.AreEqual("ct", binding.CancellationTokenName); + Assert.IsFalse(binding.IsLoggerFromParameter); + Assert.AreEqual("_logger", binding.LoggerExpression); } [TestMethod] - public void Bind_LoggerParameter_ReturnsValidBinding() + public void Bind_LoggerInConstructorParameter_ReturnsValidBinding() { - var (method, compilation) = GetMethodAndCompilation("using Microsoft.Extensions.Logging; class C { void M(ILogger logger) {} }", "M"); + var (method, compilation) = GetMethodAndCompilation(""" + using Microsoft.Extensions.Logging; + class C { + C(ILogger logger) { } + void M() {} + } + """, "M"); var knownTypes = new KnownTypes(compilation); var binding = MethodSignatureBinder.Bind(method, knownTypes); @@ -203,6 +212,17 @@ public void Bind_LoggerParameter_ReturnsValidBinding() Assert.AreEqual("logger", binding.LoggerExpression); } + [TestMethod] + public void Bind_CancellationToken_ReturnsValidBinding() + { + var (method, compilation) = GetMethodAndCompilation("using System.Threading; class C { void M(CancellationToken ct) {} }", "M"); + var knownTypes = new KnownTypes(compilation); + + var binding = MethodSignatureBinder.Bind(method, knownTypes); + Assert.IsTrue(binding.IsValid); + Assert.AreEqual("ct", binding.CancellationTokenName); + } + [TestMethod] public void Bind_UnhandledParameters_AddedToUnhandledList() { @@ -214,4 +234,120 @@ public void Bind_UnhandledParameters_AddedToUnhandledList() Assert.AreEqual(1, binding.UnhandledParameters.Count); Assert.AreEqual("i", binding.UnhandledParameters[0].Name); } + + [TestMethod] + public void Bind_Integrated_ReturnsValidBinding() + { + var (method, compilation) = GetMethodAndCompilation(""" + using System.Threading; + using System.Threading.Tasks; + using Microsoft.Extensions.Logging; + class C { + ILogger _logger; + C(ILogger logger) { _logger = logger; } + Task M(string input, CancellationToken ct) => Task.FromResult(0); + } + """, "M"); + var knownTypes = new KnownTypes(compilation); + + var binding = MethodSignatureBinder.Bind(method, knownTypes); + + Assert.IsTrue(binding.IsValid, $"binding: {binding}"); + Assert.AreEqual(MethodReturnKind.TaskInt32, binding.ReturnKind); + Assert.AreEqual(MethodInputKind.String, binding.InputKind); + Assert.AreEqual("input", binding.InputExpression); + Assert.AreEqual("ct", binding.CancellationTokenName); + Assert.IsFalse(binding.IsLoggerFromParameter); + Assert.AreEqual("_logger", binding.LoggerExpression); + } + + [TestMethod] + public void Bind_InvalidReturnKind_ReturnsInvalidBinding() + { + var (method, compilation) = GetMethodAndCompilation("class C { float M() => 0.0f; }", "M"); + var knownTypes = new KnownTypes(compilation); + + var binding = MethodSignatureBinder.Bind(method, knownTypes); + Assert.IsFalse(binding.IsValid); + Assert.AreEqual("ES0001", binding.ErrorId); // invalidReturnTypeErrorId + } + + [TestMethod] + public void Bind_PipeReaderInput_ReturnsValidBinding() + { + var (method, compilation) = GetMethodAndCompilation("using System.IO.Pipelines; class C { void M(PipeReader r) {} }", "M"); + var knownTypes = new KnownTypes(compilation); + + var binding = MethodSignatureBinder.Bind(method, knownTypes); + Assert.IsTrue(binding.IsValid); + Assert.AreEqual(MethodInputKind.PipeReader, binding.InputKind); + Assert.AreEqual("r", binding.InputExpression); + } + + [TestMethod] + public void Bind_PipeWriterOutput_ReturnsValidBinding() + { + var (method, compilation) = GetMethodAndCompilation("using System.IO.Pipelines; class C { void M(PipeWriter w) {} }", "M"); + var knownTypes = new KnownTypes(compilation); + + var binding = MethodSignatureBinder.Bind(method, knownTypes); + Assert.IsTrue(binding.IsValid); + Assert.AreEqual(MethodOutputKind.PipeWriter, binding.OutputKind); + Assert.AreEqual("w", binding.OutputExpression); + } + + [TestMethod] + public void Bind_RefParameter_ReturnsInvalidBinding() + { + var (method, compilation) = GetMethodAndCompilation("class C { void M(ref string s) {} }", "M"); + var knownTypes = new KnownTypes(compilation); + + var binding = MethodSignatureBinder.Bind(method, knownTypes); + Assert.IsFalse(binding.IsValid); + Assert.AreEqual("ES0002", binding.ErrorId); // invalidParameterErrorId + } + + [TestMethod] + public void Bind_DuplicateStringInput_ReturnsInvalidBinding() + { + var (method, compilation) = GetMethodAndCompilation("class C { void M(string s1, string s2) {} }", "M"); + var knownTypes = new KnownTypes(compilation); + + var binding = MethodSignatureBinder.Bind(method, knownTypes); + Assert.IsFalse(binding.IsValid); + Assert.AreEqual("ES0003", binding.ErrorId); // DuplicateParameterErrorId + } + + [TestMethod] + public void Bind_DuplicateTextReaderInput_ReturnsInvalidBinding() + { + var (method, compilation) = GetMethodAndCompilation("using System.IO; class C { void M(TextReader r1, TextReader r2) {} }", "M"); + var knownTypes = new KnownTypes(compilation); + + var binding = MethodSignatureBinder.Bind(method, knownTypes); + Assert.IsFalse(binding.IsValid); + Assert.AreEqual("ES0003", binding.ErrorId); // DuplicateParameterErrorId + } + + [TestMethod] + public void Bind_DuplicateTextWriterOutput_ReturnsInvalidBinding() + { + var (method, compilation) = GetMethodAndCompilation("using System.IO; class C { void M(TextWriter w1, TextWriter w2) {} }", "M"); + var knownTypes = new KnownTypes(compilation); + + var binding = MethodSignatureBinder.Bind(method, knownTypes); + Assert.IsFalse(binding.IsValid); + Assert.AreEqual("ES0003", binding.ErrorId); // DuplicateParameterErrorId + } + + [TestMethod] + public void Bind_ReturnOutputConflict_ReturnsInvalidBinding() + { + var (method, compilation) = GetMethodAndCompilation("using System.IO; class C { string M(TextWriter w) => \"\"; }", "M"); + var knownTypes = new KnownTypes(compilation); + + var binding = MethodSignatureBinder.Bind(method, knownTypes); + Assert.IsFalse(binding.IsValid); + Assert.AreEqual("ES0004", binding.ErrorId); // ReturnOutputConflictErrorId + } } From c5e63b921ff9f78e90332fbd724de9f07a62448f Mon Sep 17 00:00:00 2001 From: juner Date: Thu, 28 May 2026 17:36:34 +0900 Subject: [PATCH 20/49] =?UTF-8?q?test(generator):=20MethodSignatureBinder?= =?UTF-8?q?=20=E3=81=AE=20Logger=20=E6=8E=A2=E7=B4=A2=E3=81=8A=E3=82=88?= =?UTF-8?q?=E3=81=B3=E3=83=91=E3=83=A9=E3=83=A1=E3=83=BC=E3=82=BF=E9=96=A2?= =?UTF-8?q?=E9=80=A3=E3=81=AE=E7=B6=B2=E7=BE=85=E3=83=86=E3=82=B9=E3=83=88?= =?UTF-8?q?=E3=82=92=E5=AE=9F=E8=A3=85=E3=81=97=E3=80=81=E3=82=AB=E3=83=90?= =?UTF-8?q?=E3=83=AC=E3=83=83=E3=82=B8=2095%=20=E3=82=92=E9=81=94=E6=88=90?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - MethodSignatureBinderTests.cs: Logger 重複エラーやフィールド名による探索等の未テスト条件分岐を網羅 - カバレッジ目標 (95%) を達成 --- .../MethodSignatureBinderTests.cs | 34 +++++++++++++++++++ 1 file changed, 34 insertions(+) diff --git a/Generator.Abstractions.Tests/MethodSignatureBinderTests.cs b/Generator.Abstractions.Tests/MethodSignatureBinderTests.cs index 49f2961..6fe1420 100644 --- a/Generator.Abstractions.Tests/MethodSignatureBinderTests.cs +++ b/Generator.Abstractions.Tests/MethodSignatureBinderTests.cs @@ -350,4 +350,38 @@ public void Bind_ReturnOutputConflict_ReturnsInvalidBinding() Assert.IsFalse(binding.IsValid); Assert.AreEqual("ES0004", binding.ErrorId); // ReturnOutputConflictErrorId } + + [TestMethod] + public void Bind_DuplicateLoggerParameter_ReturnsInvalidBinding() + { + var (method, compilation) = GetMethodAndCompilation(""" + using Microsoft.Extensions.Logging; + class C { + void M(ILogger l1, ILogger l2) {} + } + """, "M"); + var knownTypes = new KnownTypes(compilation); + + var binding = MethodSignatureBinder.Bind(method, knownTypes); + Assert.IsFalse(binding.IsValid); + Assert.AreEqual("ES0003", binding.ErrorId); // DuplicateParameterErrorId + } + + [TestMethod] + public void Bind_LoggerInField_CanBeReferencedByName_ReturnsValidBinding() + { + var (method, compilation) = GetMethodAndCompilation(""" + using Microsoft.Extensions.Logging; + class C { + public ILogger loggerField; + void M() {} + } + """, "M"); + var knownTypes = new KnownTypes(compilation); + + var binding = MethodSignatureBinder.Bind(method, knownTypes); + Assert.IsTrue(binding.IsValid); + Assert.IsFalse(binding.IsLoggerFromParameter); + Assert.AreEqual("loggerField", binding.LoggerExpression); + } } From 0426647200ffdcb98c83b84243493b027732f49e Mon Sep 17 00:00:00 2001 From: juner Date: Thu, 28 May 2026 17:37:29 +0900 Subject: [PATCH 21/49] =?UTF-8?q?test(generator):=20MethodSignatureBinding?= =?UTF-8?q?Tests=20=E3=81=AE=E4=BF=AE=E6=AD=A3=E3=82=92=E3=82=B3=E3=83=9F?= =?UTF-8?q?=E3=83=83=E3=83=88?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../MethodSignatureBindingTests.cs | 44 +++++++++++-------- 1 file changed, 25 insertions(+), 19 deletions(-) diff --git a/Generator.Abstractions.Tests/MethodSignatureBindingTests.cs b/Generator.Abstractions.Tests/MethodSignatureBindingTests.cs index 1115d23..277de68 100644 --- a/Generator.Abstractions.Tests/MethodSignatureBindingTests.cs +++ b/Generator.Abstractions.Tests/MethodSignatureBindingTests.cs @@ -8,26 +8,32 @@ namespace Esolang.Generator.Tests; public class MethodSignatureBindingTests { [TestMethod] - public void PropertiesWorkAsExpected() + public void Properties_CheckCorrectly() { - var binding = new MethodSignatureBinding( - IsValid: true, - ReturnKind: MethodReturnKind.Void, - InputKind: MethodInputKind.None, - OutputKind: MethodOutputKind.None, - InputExpression: "", - OutputExpression: "", - CancellationTokenName: null, - LoggerExpression: null, - IsLoggerFromParameter: false, - UnhandledParameters: [] - ); + // IsAsync: Task 系 + var bindingTask = new MethodSignatureBinding(true, MethodReturnKind.Task, MethodInputKind.None, MethodOutputKind.None, "", "", null, null, false, []); + Assert.IsTrue(bindingTask.IsAsync); + + // IsAsync: ValueTask 系 + var bindingValueTask = new MethodSignatureBinding(true, MethodReturnKind.ValueTask, MethodInputKind.None, MethodOutputKind.None, "", "", null, null, false, []); + Assert.IsTrue(bindingValueTask.IsAsync); - Assert.IsTrue(binding.IsValid); - Assert.IsFalse(binding.HasExplicitInput); - Assert.IsFalse(binding.HasExplicitOutput); - Assert.IsFalse(binding.IsAsync); - Assert.IsFalse(binding.IsEnumerable); - Assert.IsFalse(binding.IsAsyncEnumerable); + // IsEnumerable + var bindingEnum = new MethodSignatureBinding(true, MethodReturnKind.IEnumerableByte, MethodInputKind.None, MethodOutputKind.None, "", "", null, null, false, []); + Assert.IsTrue(bindingEnum.IsEnumerable); + Assert.IsFalse(bindingEnum.IsAsync); + + // IsAsyncEnumerable + var bindingAsyncEnum = new MethodSignatureBinding(true, MethodReturnKind.IAsyncEnumerableByte, MethodInputKind.None, MethodOutputKind.None, "", "", null, null, false, []); + Assert.IsTrue(bindingAsyncEnum.IsAsyncEnumerable); + Assert.IsTrue(bindingAsyncEnum.IsAsync); + + // HasExplicitInput + var bindingInput = new MethodSignatureBinding(true, MethodReturnKind.Void, MethodInputKind.String, MethodOutputKind.None, "s", "", null, null, false, []); + Assert.IsTrue(bindingInput.HasExplicitInput); + + // HasExplicitOutput + var bindingOutput = new MethodSignatureBinding(true, MethodReturnKind.Void, MethodInputKind.None, MethodOutputKind.TextWriter, "", "w", null, null, false, []); + Assert.IsTrue(bindingOutput.HasExplicitOutput); } } From d3ae696bf8b428015fe2b62b51a5b04b6e7a1754 Mon Sep 17 00:00:00 2001 From: juner Date: Thu, 28 May 2026 17:44:07 +0900 Subject: [PATCH 22/49] =?UTF-8?q?=E3=83=97=E3=83=A9=E3=82=A4=E3=83=9E?= =?UTF-8?q?=E3=83=AA=E3=82=B3=E3=83=B3=E3=82=B9=E3=83=88=E3=83=A9=E5=8C=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Generator.Abstractions/KnownTypes.cs | 63 ++++++++++------------------ 1 file changed, 21 insertions(+), 42 deletions(-) diff --git a/Generator.Abstractions/KnownTypes.cs b/Generator.Abstractions/KnownTypes.cs index 94131f9..6e8a269 100644 --- a/Generator.Abstractions/KnownTypes.cs +++ b/Generator.Abstractions/KnownTypes.cs @@ -7,65 +7,44 @@ namespace Esolang.Generator; /// /// Holds resolved type symbols for a compilation. /// -public readonly struct KnownTypes +/// +/// Initializes a new instance of the struct. +/// +/// The compilation to resolve types from. +public readonly struct KnownTypes(Compilation compilation) { /// The string type symbol. - public readonly INamedTypeSymbol? String; + public readonly INamedTypeSymbol? String = compilation.GetSpecialType(SpecialType.System_String); /// The byte type symbol. - public readonly INamedTypeSymbol? Byte; + public readonly INamedTypeSymbol? Byte = compilation.GetSpecialType(SpecialType.System_Byte); /// The int type symbol. - public readonly INamedTypeSymbol? Int32; + public readonly INamedTypeSymbol? Int32 = compilation.GetSpecialType(SpecialType.System_Int32); /// The System.Threading.Tasks.Task type symbol. - public readonly INamedTypeSymbol? Task; + public readonly INamedTypeSymbol? Task = compilation.GetBestTypeByMetadataName("System.Threading.Tasks.Task"); /// The System.Threading.Tasks.Task{TResult} type symbol. - public readonly INamedTypeSymbol? TaskT; + public readonly INamedTypeSymbol? TaskT = compilation.GetBestTypeByMetadataName("System.Threading.Tasks.Task`1"); /// The System.Threading.Tasks.ValueTask type symbol. - public readonly INamedTypeSymbol? ValueTask; + public readonly INamedTypeSymbol? ValueTask = compilation.GetBestTypeByMetadataName("System.Threading.Tasks.ValueTask"); /// The System.Threading.Tasks.ValueTask{TResult} type symbol. - public readonly INamedTypeSymbol? ValueTaskT; + public readonly INamedTypeSymbol? ValueTaskT = compilation.GetBestTypeByMetadataName("System.Threading.Tasks.ValueTask`1"); /// The System.Collections.Generic.IEnumerable{T} type symbol. - public readonly INamedTypeSymbol? IEnumerableT; + public readonly INamedTypeSymbol? IEnumerableT = compilation.GetBestTypeByMetadataName("System.Collections.Generic.IEnumerable`1"); /// The System.Collections.Generic.IAsyncEnumerable{T} type symbol. - public readonly INamedTypeSymbol? IAsyncEnumerableT; + public readonly INamedTypeSymbol? IAsyncEnumerableT = compilation.GetBestTypeByMetadataName("System.Collections.Generic.IAsyncEnumerable`1"); /// The System.IO.Pipelines.PipeReader type symbol. - public readonly INamedTypeSymbol? PipeReader; + public readonly INamedTypeSymbol? PipeReader = compilation.GetBestTypeByMetadataName("System.IO.Pipelines.PipeReader"); /// The System.IO.Pipelines.PipeWriter type symbol. - public readonly INamedTypeSymbol? PipeWriter; + public readonly INamedTypeSymbol? PipeWriter = compilation.GetBestTypeByMetadataName("System.IO.Pipelines.PipeWriter"); /// The System.IO.TextReader type symbol. - public readonly INamedTypeSymbol? TextReader; + public readonly INamedTypeSymbol? TextReader = compilation.GetBestTypeByMetadataName("System.IO.TextReader"); /// The System.IO.TextWriter type symbol. - public readonly INamedTypeSymbol? TextWriter; + public readonly INamedTypeSymbol? TextWriter = compilation.GetBestTypeByMetadataName("System.IO.TextWriter"); /// The System.Threading.CancellationToken type symbol. - public readonly INamedTypeSymbol? CancellationToken; + public readonly INamedTypeSymbol? CancellationToken = compilation.GetBestTypeByMetadataName("System.Threading.CancellationToken"); /// The Microsoft.Extensions.Logging.ILogger type symbol. - public readonly INamedTypeSymbol? ILogger; + public readonly INamedTypeSymbol? ILogger = compilation.GetBestTypeByMetadataName("Microsoft.Extensions.Logging.ILogger"); /// The Microsoft.Extensions.Logging.ILogger{T} type symbol. - public readonly INamedTypeSymbol? ILoggerT; - - /// - /// Initializes a new instance of the struct. - /// - /// The compilation to resolve types from. - public KnownTypes(Compilation compilation) - { - String = compilation.GetSpecialType(SpecialType.System_String); - Byte = compilation.GetSpecialType(SpecialType.System_Byte); - Int32 = compilation.GetSpecialType(SpecialType.System_Int32); - - Task = compilation.GetBestTypeByMetadataName("System.Threading.Tasks.Task"); - TaskT = compilation.GetBestTypeByMetadataName("System.Threading.Tasks.Task`1"); - ValueTask = compilation.GetBestTypeByMetadataName("System.Threading.Tasks.ValueTask"); - ValueTaskT = compilation.GetBestTypeByMetadataName("System.Threading.Tasks.ValueTask`1"); - IEnumerableT = compilation.GetBestTypeByMetadataName("System.Collections.Generic.IEnumerable`1"); - IAsyncEnumerableT = compilation.GetBestTypeByMetadataName("System.Collections.Generic.IAsyncEnumerable`1"); - PipeReader = compilation.GetBestTypeByMetadataName("System.IO.Pipelines.PipeReader"); - PipeWriter = compilation.GetBestTypeByMetadataName("System.IO.Pipelines.PipeWriter"); - TextReader = compilation.GetBestTypeByMetadataName("System.IO.TextReader"); - TextWriter = compilation.GetBestTypeByMetadataName("System.IO.TextWriter"); - CancellationToken = compilation.GetBestTypeByMetadataName("System.Threading.CancellationToken"); - ILogger = compilation.GetBestTypeByMetadataName("Microsoft.Extensions.Logging.ILogger"); - ILoggerT = compilation.GetBestTypeByMetadataName("Microsoft.Extensions.Logging.ILogger`1"); - } + public readonly INamedTypeSymbol? ILoggerT = compilation.GetBestTypeByMetadataName("Microsoft.Extensions.Logging.ILogger`1"); private static bool EqualsDefinition(ITypeSymbol? type, ISymbol? symbol) => type != null && symbol != null && SymbolEqualityComparer.Default.Equals(type.OriginalDefinition, symbol); From dc8e1b013b838bd53e3c789970d16144f35adf49 Mon Sep 17 00:00:00 2001 From: juner Date: Fri, 29 May 2026 06:32:48 +0900 Subject: [PATCH 23/49] dotnet format --- Generator.Abstractions.Tests/KindTests.cs | 2 +- .../KnownTypesTests.cs | 12 +++++------ .../MethodSignatureBinderTests.cs | 20 +++++++++---------- .../MethodSignatureBindingTests.cs | 4 ++-- Generator.Abstractions.Tests/NullableTest.cs | 2 +- Generator.Abstractions/KnownTypes.cs | 2 +- 6 files changed, 21 insertions(+), 21 deletions(-) diff --git a/Generator.Abstractions.Tests/KindTests.cs b/Generator.Abstractions.Tests/KindTests.cs index 58574f3..d831e93 100644 --- a/Generator.Abstractions.Tests/KindTests.cs +++ b/Generator.Abstractions.Tests/KindTests.cs @@ -1,6 +1,6 @@ -using System.Diagnostics.CodeAnalysis; using Esolang.Generator; using Microsoft.VisualStudio.TestTools.UnitTesting; +using System.Diagnostics.CodeAnalysis; namespace Esolang.Generator.Tests; diff --git a/Generator.Abstractions.Tests/KnownTypesTests.cs b/Generator.Abstractions.Tests/KnownTypesTests.cs index 86171ed..9f85531 100644 --- a/Generator.Abstractions.Tests/KnownTypesTests.cs +++ b/Generator.Abstractions.Tests/KnownTypesTests.cs @@ -1,7 +1,7 @@ using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; -using System.Linq; using Microsoft.VisualStudio.TestTools.UnitTesting; +using System.Linq; namespace Esolang.Generator.Tests; @@ -92,7 +92,7 @@ class C { string? s; } var knownTypes = new KnownTypes(compilation); var classC = compilation.GetTypeByMetadataName("C"); var field = classC?.GetMembers("s").OfType().FirstOrDefault(); - + Assert.IsNotNull(field); Assert.IsTrue(knownTypes.IsString(field.Type, isNullable: true)); Assert.IsFalse(knownTypes.IsString(field.Type, isNullable: false)); @@ -132,10 +132,10 @@ class C { Assert.IsNotNull(method1); Assert.IsNotNull(method2); - + Assert.IsTrue(knownTypes.IsTaskT(method1.ReturnType, isNullable: false)); Assert.IsFalse(knownTypes.IsTaskT(method1.ReturnType, isNullable: true)); - + Assert.IsTrue(knownTypes.IsTaskT(method2.ReturnType, isNullable: true)); Assert.IsFalse(knownTypes.IsTaskT(method2.ReturnType, isNullable: false)); } @@ -158,10 +158,10 @@ class C { Assert.IsNotNull(method1); Assert.IsNotNull(method2); - + Assert.IsTrue(knownTypes.IsValueTaskT(method1.ReturnType, isNullable: false)); Assert.IsFalse(knownTypes.IsValueTaskT(method1.ReturnType, isNullable: true)); - + Assert.IsTrue(knownTypes.IsValueTaskT(method2.ReturnType, isNullable: true)); Assert.IsFalse(knownTypes.IsValueTaskT(method2.ReturnType, isNullable: false)); } diff --git a/Generator.Abstractions.Tests/MethodSignatureBinderTests.cs b/Generator.Abstractions.Tests/MethodSignatureBinderTests.cs index 6fe1420..72f63de 100644 --- a/Generator.Abstractions.Tests/MethodSignatureBinderTests.cs +++ b/Generator.Abstractions.Tests/MethodSignatureBinderTests.cs @@ -1,15 +1,15 @@ +using Basic.Reference.Assemblies; +using Esolang.Generator; using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; -using System.Linq; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using System; +using System.Collections.Generic; using System.IO; +using System.Linq; +using System.Text; using System.Threading; using System.Threading.Tasks; -using System.Collections.Generic; -using System; -using Microsoft.VisualStudio.TestTools.UnitTesting; -using Esolang.Generator; -using Basic.Reference.Assemblies; -using System.Text; namespace Esolang.Generator.Tests; @@ -82,9 +82,9 @@ public void Bind_TaskMethod_ReturnsValidBinding() { var (method, compilation) = GetMethodAndCompilation("using System.Threading.Tasks; class C { Task M() => Task.CompletedTask; }", "M"); var knownTypes = new KnownTypes(compilation); - + Assert.IsNotNull(knownTypes.Task, "KnownTypes.Task is null"); - + var binding = MethodSignatureBinder.Bind(method, knownTypes); Assert.IsTrue(binding.IsValid, $"binding: {binding}"); Assert.AreEqual(MethodReturnKind.Task, binding.ReturnKind, $"binding: {binding}"); @@ -251,7 +251,7 @@ class C { var knownTypes = new KnownTypes(compilation); var binding = MethodSignatureBinder.Bind(method, knownTypes); - + Assert.IsTrue(binding.IsValid, $"binding: {binding}"); Assert.AreEqual(MethodReturnKind.TaskInt32, binding.ReturnKind); Assert.AreEqual(MethodInputKind.String, binding.InputKind); diff --git a/Generator.Abstractions.Tests/MethodSignatureBindingTests.cs b/Generator.Abstractions.Tests/MethodSignatureBindingTests.cs index 277de68..fea40f3 100644 --- a/Generator.Abstractions.Tests/MethodSignatureBindingTests.cs +++ b/Generator.Abstractions.Tests/MethodSignatureBindingTests.cs @@ -1,6 +1,6 @@ using Esolang.Generator; -using Microsoft.VisualStudio.TestTools.UnitTesting; using Microsoft.CodeAnalysis; +using Microsoft.VisualStudio.TestTools.UnitTesting; namespace Esolang.Generator.Tests; @@ -13,7 +13,7 @@ public void Properties_CheckCorrectly() // IsAsync: Task 系 var bindingTask = new MethodSignatureBinding(true, MethodReturnKind.Task, MethodInputKind.None, MethodOutputKind.None, "", "", null, null, false, []); Assert.IsTrue(bindingTask.IsAsync); - + // IsAsync: ValueTask 系 var bindingValueTask = new MethodSignatureBinding(true, MethodReturnKind.ValueTask, MethodInputKind.None, MethodOutputKind.None, "", "", null, null, false, []); Assert.IsTrue(bindingValueTask.IsAsync); diff --git a/Generator.Abstractions.Tests/NullableTest.cs b/Generator.Abstractions.Tests/NullableTest.cs index d6fcaf1..153f596 100644 --- a/Generator.Abstractions.Tests/NullableTest.cs +++ b/Generator.Abstractions.Tests/NullableTest.cs @@ -17,7 +17,7 @@ public void CheckNullableContext() new[] { CSharpSyntaxTree.ParseText("class C {}", cancellationToken: CancellationToken) }, null, new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)); - + // デフォルトは Disable であるはず Assert.AreEqual(NullableContextOptions.Disable, compilation.Options.NullableContextOptions); } diff --git a/Generator.Abstractions/KnownTypes.cs b/Generator.Abstractions/KnownTypes.cs index 6e8a269..d737840 100644 --- a/Generator.Abstractions/KnownTypes.cs +++ b/Generator.Abstractions/KnownTypes.cs @@ -196,7 +196,7 @@ readonly bool PrintMembers(StringBuilder builder) builder.Append(nameof(ILoggerT)).Append('='); AppendNamedTypeSymbol(ILoggerT, builder); - + return true; static void AppendNamedTypeSymbol(INamedTypeSymbol? symbol, StringBuilder builder) { From cae66a5c19fdb85b5c9aa95766e015319e1545aa Mon Sep 17 00:00:00 2001 From: juner Date: Sat, 30 May 2026 08:35:33 +0900 Subject: [PATCH 24/49] refactor(generator): Replace string ErrorId with type-safe BindingError record hierarchy - Introduced BindingError record hierarchy and BindingErrorKind enum for semantic error reporting. - Updated MethodSignatureBinder.Bind to return specific error records instead of string IDs. - Removed customizable error ID parameters from Bind method (breaking change). - Added IsExternalInit.cs for record compatibility with .NET Standard 2.0/2.1. - Updated test suite to verify results using BindingErrorKind and pattern matching. --- .../MethodSignatureBinderTests.cs | 14 +-- Generator.Abstractions/BindingError.cs | 89 +++++++++++++++++++ Generator.Abstractions/IsExternalInit.cs | 11 +++ .../MethodSignatureBinder.cs | 32 +++---- .../MethodSignatureBinding.cs | 9 +- 5 files changed, 123 insertions(+), 32 deletions(-) create mode 100644 Generator.Abstractions/BindingError.cs create mode 100644 Generator.Abstractions/IsExternalInit.cs diff --git a/Generator.Abstractions.Tests/MethodSignatureBinderTests.cs b/Generator.Abstractions.Tests/MethodSignatureBinderTests.cs index 72f63de..8c0658c 100644 --- a/Generator.Abstractions.Tests/MethodSignatureBinderTests.cs +++ b/Generator.Abstractions.Tests/MethodSignatureBinderTests.cs @@ -269,7 +269,7 @@ public void Bind_InvalidReturnKind_ReturnsInvalidBinding() var binding = MethodSignatureBinder.Bind(method, knownTypes); Assert.IsFalse(binding.IsValid); - Assert.AreEqual("ES0001", binding.ErrorId); // invalidReturnTypeErrorId + Assert.AreEqual(BindingErrorKind.UnsupportedReturnType, binding.Error!.Kind); // invalidReturnTypeErrorId } [TestMethod] @@ -304,7 +304,7 @@ public void Bind_RefParameter_ReturnsInvalidBinding() var binding = MethodSignatureBinder.Bind(method, knownTypes); Assert.IsFalse(binding.IsValid); - Assert.AreEqual("ES0002", binding.ErrorId); // invalidParameterErrorId + Assert.AreEqual(BindingErrorKind.InvalidParameterModifier, binding.Error!.Kind); // invalidParameterErrorId } [TestMethod] @@ -315,7 +315,7 @@ public void Bind_DuplicateStringInput_ReturnsInvalidBinding() var binding = MethodSignatureBinder.Bind(method, knownTypes); Assert.IsFalse(binding.IsValid); - Assert.AreEqual("ES0003", binding.ErrorId); // DuplicateParameterErrorId + Assert.AreEqual(BindingErrorKind.DuplicateInput, binding.Error!.Kind); // DuplicateParameterErrorId } [TestMethod] @@ -326,7 +326,7 @@ public void Bind_DuplicateTextReaderInput_ReturnsInvalidBinding() var binding = MethodSignatureBinder.Bind(method, knownTypes); Assert.IsFalse(binding.IsValid); - Assert.AreEqual("ES0003", binding.ErrorId); // DuplicateParameterErrorId + Assert.AreEqual(BindingErrorKind.DuplicateInput, binding.Error!.Kind); // DuplicateParameterErrorId } [TestMethod] @@ -337,7 +337,7 @@ public void Bind_DuplicateTextWriterOutput_ReturnsInvalidBinding() var binding = MethodSignatureBinder.Bind(method, knownTypes); Assert.IsFalse(binding.IsValid); - Assert.AreEqual("ES0003", binding.ErrorId); // DuplicateParameterErrorId + Assert.AreEqual(BindingErrorKind.DuplicateOutput, binding.Error!.Kind); // DuplicateParameterErrorId } [TestMethod] @@ -348,7 +348,7 @@ public void Bind_ReturnOutputConflict_ReturnsInvalidBinding() var binding = MethodSignatureBinder.Bind(method, knownTypes); Assert.IsFalse(binding.IsValid); - Assert.AreEqual("ES0004", binding.ErrorId); // ReturnOutputConflictErrorId + Assert.AreEqual(BindingErrorKind.ReturnOutputConflict, binding.Error!.Kind); // ReturnOutputConflictErrorId } [TestMethod] @@ -364,7 +364,7 @@ void M(ILogger l1, ILogger l2) {} var binding = MethodSignatureBinder.Bind(method, knownTypes); Assert.IsFalse(binding.IsValid); - Assert.AreEqual("ES0003", binding.ErrorId); // DuplicateParameterErrorId + Assert.AreEqual(BindingErrorKind.DuplicateLogger, binding.Error!.Kind); // DuplicateParameterErrorId } [TestMethod] diff --git a/Generator.Abstractions/BindingError.cs b/Generator.Abstractions/BindingError.cs new file mode 100644 index 0000000..28f842c --- /dev/null +++ b/Generator.Abstractions/BindingError.cs @@ -0,0 +1,89 @@ +using Microsoft.CodeAnalysis; + +namespace Esolang.Generator; + +/// +/// Specifies the kind of diagnostic error that occurred during method signature binding. +/// +public enum BindingErrorKind +{ + /// The return type of the method is not supported. + UnsupportedReturnType, + /// A parameter has an invalid modifier (e.g., ref, out, in). + InvalidParameterModifier, + /// More than one parameter is competing for the same input role. + DuplicateInput, + /// More than one parameter is competing for the same output role. + DuplicateOutput, + /// More than one cancellation token parameter was found. + DuplicateCancellationToken, + /// More than one logger parameter was found. + DuplicateLogger, + /// A conflict exists between the return type and an output parameter. + ReturnOutputConflict, +} + +/// +/// Represents a diagnostic error that occurred during method signature binding. +/// +/// The kind of error. +/// The location associated with the error. +public abstract record BindingError(BindingErrorKind Kind, Location? Location); + +/// +/// The return type of the method is not supported. +/// +/// The unsupported return type symbol. +/// The location of the return type. +public sealed record UnsupportedReturnType(ITypeSymbol Type, Location? Location) + : BindingError(BindingErrorKind.UnsupportedReturnType, Location); + +/// +/// A parameter has an invalid modifier (e.g., ref, out, in). +/// +/// The parameter with the invalid modifier. +/// The location of the parameter. +public sealed record InvalidParameterModifier(IParameterSymbol Parameter, Location? Location) + : BindingError(BindingErrorKind.InvalidParameterModifier, Location); + +/// +/// More than one parameter is competing for the same input role. +/// +/// The parameter that caused the duplication. +/// The kind of input that was already assigned. +/// The location of the duplicate parameter. +public sealed record DuplicateInput(IParameterSymbol Parameter, MethodInputKind ExistingKind, Location? Location) + : BindingError(BindingErrorKind.DuplicateInput, Location); + +/// +/// More than one parameter is competing for the same output role. +/// +/// The parameter that caused the duplication. +/// The kind of output that was already assigned. +/// The location of the duplicate parameter. +public sealed record DuplicateOutput(IParameterSymbol Parameter, MethodOutputKind ExistingKind, Location? Location) + : BindingError(BindingErrorKind.DuplicateOutput, Location); + +/// +/// More than one cancellation token parameter was found. +/// +/// The duplicate cancellation token parameter. +/// The location of the duplicate parameter. +public sealed record DuplicateCancellationToken(IParameterSymbol Parameter, Location? Location) + : BindingError(BindingErrorKind.DuplicateCancellationToken, Location); + +/// +/// More than one logger parameter was found. +/// +/// The duplicate logger parameter. +/// The location of the duplicate parameter. +public sealed record DuplicateLogger(IParameterSymbol Parameter, Location? Location) + : BindingError(BindingErrorKind.DuplicateLogger, Location); + +/// +/// A conflict exists between the return type and an output parameter. +/// +/// The output parameter that conflicts with the return type. +/// The location of the conflicting parameter. +public sealed record ReturnOutputConflict(IParameterSymbol Parameter, Location? Location) + : BindingError(BindingErrorKind.ReturnOutputConflict, Location); diff --git a/Generator.Abstractions/IsExternalInit.cs b/Generator.Abstractions/IsExternalInit.cs new file mode 100644 index 0000000..54990f4 --- /dev/null +++ b/Generator.Abstractions/IsExternalInit.cs @@ -0,0 +1,11 @@ +namespace System.Runtime.CompilerServices; + +#if !NET5_0_OR_GREATER +/// +/// Reserved to be used by the compiler for tracking metadata. +/// This class should not be used by developers in source code. +/// +internal static class IsExternalInit +{ +} +#endif diff --git a/Generator.Abstractions/MethodSignatureBinder.cs b/Generator.Abstractions/MethodSignatureBinder.cs index 2ec7c65..6939607 100644 --- a/Generator.Abstractions/MethodSignatureBinder.cs +++ b/Generator.Abstractions/MethodSignatureBinder.cs @@ -15,23 +15,15 @@ public static class MethodSignatureBinder /// /// The method symbol to bind. /// The known types for the compilation. - /// The error ID to use if the return type is invalid. - /// The error ID to use if a parameter is invalid. - /// The error ID to use if a parameter type is duplicated. - /// The error ID to use if there is a conflict between the return type and output parameters. /// The result of the binding. public static MethodSignatureBinding Bind( IMethodSymbol method, - KnownTypes types, - string invalidReturnTypeErrorId = "ES0001", - string invalidParameterErrorId = "ES0002", - string duplicateParameterErrorId = "ES0003", - string returnOutputConflictErrorId = "ES0004") + KnownTypes types) { var returnKind = BindReturnKind(method.ReturnType, types); if (returnKind == MethodReturnKind.Invalid) { - return new MethodSignatureBinding(false, returnKind, MethodInputKind.None, MethodOutputKind.None, "", "", null, null, false, method.Parameters, invalidReturnTypeErrorId); + return new MethodSignatureBinding(false, returnKind, MethodInputKind.None, MethodOutputKind.None, "", "", null, null, false, method.Parameters, new UnsupportedReturnType(method.ReturnType, method.Locations.FirstOrDefault())); } var outputKind = BindDefaultOutputKind(returnKind); @@ -47,13 +39,13 @@ public static MethodSignatureBinding Bind( { if (p.RefKind != RefKind.None) { - return new MethodSignatureBinding(false, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, invalidParameterErrorId, p.Locations.FirstOrDefault()); + return new MethodSignatureBinding(false, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, new InvalidParameterModifier(p, p.Locations.FirstOrDefault())); } if (types.IsString(p.Type, false)) { if (inputKind != MethodInputKind.None) - return new MethodSignatureBinding(false, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, inputKind == MethodInputKind.String ? duplicateParameterErrorId : invalidParameterErrorId, p.Locations.FirstOrDefault()); + return new MethodSignatureBinding(false, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, new DuplicateInput(p, inputKind, p.Locations.FirstOrDefault())); inputKind = MethodInputKind.String; inputExpr = p.Name; @@ -63,7 +55,7 @@ public static MethodSignatureBinding Bind( if (types.IsTextReader(p.Type)) { if (inputKind != MethodInputKind.None) - return new MethodSignatureBinding(false, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, inputKind == MethodInputKind.TextReader ? duplicateParameterErrorId : invalidParameterErrorId, p.Locations.FirstOrDefault()); + return new MethodSignatureBinding(false, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, new DuplicateInput(p, inputKind, p.Locations.FirstOrDefault())); inputKind = MethodInputKind.TextReader; inputExpr = p.Name; @@ -73,7 +65,7 @@ public static MethodSignatureBinding Bind( if (types.IsPipeReader(p.Type)) { if (inputKind != MethodInputKind.None) - return new MethodSignatureBinding(false, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, inputKind == MethodInputKind.PipeReader ? duplicateParameterErrorId : invalidParameterErrorId, p.Locations.FirstOrDefault()); + return new MethodSignatureBinding(false, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, new DuplicateInput(p, inputKind, p.Locations.FirstOrDefault())); inputKind = MethodInputKind.PipeReader; inputExpr = p.Name; @@ -83,10 +75,10 @@ public static MethodSignatureBinding Bind( if (types.IsTextWriter(p.Type)) { if (IsOutputReturning(returnKind)) - return new MethodSignatureBinding(false, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, returnOutputConflictErrorId, p.Locations.FirstOrDefault()); + return new MethodSignatureBinding(false, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, new ReturnOutputConflict(p, p.Locations.FirstOrDefault())); if (outputKind != MethodOutputKind.None) - return new MethodSignatureBinding(false, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, outputKind == MethodOutputKind.TextWriter ? duplicateParameterErrorId : invalidParameterErrorId, p.Locations.FirstOrDefault()); + return new MethodSignatureBinding(false, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, new DuplicateOutput(p, outputKind, p.Locations.FirstOrDefault())); outputKind = MethodOutputKind.TextWriter; outputExpr = p.Name; @@ -96,10 +88,10 @@ public static MethodSignatureBinding Bind( if (types.IsPipeWriter(p.Type)) { if (IsOutputReturning(returnKind)) - return new MethodSignatureBinding(false, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, returnOutputConflictErrorId, p.Locations.FirstOrDefault()); + return new MethodSignatureBinding(false, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, new ReturnOutputConflict(p, p.Locations.FirstOrDefault())); if (outputKind != MethodOutputKind.None) - return new MethodSignatureBinding(false, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, outputKind == MethodOutputKind.PipeWriter ? duplicateParameterErrorId : invalidParameterErrorId, p.Locations.FirstOrDefault()); + return new MethodSignatureBinding(false, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, new DuplicateOutput(p, outputKind, p.Locations.FirstOrDefault())); outputKind = MethodOutputKind.PipeWriter; outputExpr = p.Name; @@ -109,7 +101,7 @@ public static MethodSignatureBinding Bind( if (types.IsCancellationToken(p.Type)) { if (cancellationTokenName != null) - return new MethodSignatureBinding(false, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, duplicateParameterErrorId, p.Locations.FirstOrDefault()); + return new MethodSignatureBinding(false, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, new DuplicateCancellationToken(p, p.Locations.FirstOrDefault())); cancellationTokenName = p.Name; continue; @@ -118,7 +110,7 @@ public static MethodSignatureBinding Bind( if (types.IsLogger(p.Type)) { if (loggerExpression != null) - return new MethodSignatureBinding(false, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, duplicateParameterErrorId, p.Locations.FirstOrDefault()); + return new MethodSignatureBinding(false, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, new DuplicateLogger(p, p.Locations.FirstOrDefault())); loggerExpression = p.Name; isLoggerFromParameter = true; diff --git a/Generator.Abstractions/MethodSignatureBinding.cs b/Generator.Abstractions/MethodSignatureBinding.cs index 680b756..2796c09 100644 --- a/Generator.Abstractions/MethodSignatureBinding.cs +++ b/Generator.Abstractions/MethodSignatureBinding.cs @@ -19,8 +19,7 @@ namespace Esolang.Generator; /// The expression to access the logger (e.g., "loggerParam", "this._logger"). /// Whether the logger is obtained from a method parameter. /// Parameters that were not handled by the common binding logic. -/// The diagnostic error ID if the binding failed. -/// The location associated with the error. +/// The diagnostic error if the binding failed. [DebuggerDisplay("{ToString(),nq}")] public record struct MethodSignatureBinding( bool IsValid, @@ -33,8 +32,7 @@ public record struct MethodSignatureBinding( string? LoggerExpression, bool IsLoggerFromParameter, IReadOnlyList UnhandledParameters, - string? ErrorId = null, - Location? Location = null) + BindingError? Error = null) { /// Gets a value indicating whether the method has an explicit input mechanism. public readonly bool HasExplicitInput => InputKind != MethodInputKind.None; @@ -75,7 +73,8 @@ readonly bool PrintMembers(StringBuilder builder) if (i > 0) builder.Append(", "); builder.Append(UnhandledParameters[i].ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat)); } - builder.Append(']'); + builder.Append("], "); + builder.Append(nameof(Error)).Append('=').Append(Error); return true; } From b1a572d1f7874714ad049852f79e72498e76ba5b Mon Sep 17 00:00:00 2001 From: juner Date: Sat, 30 May 2026 09:03:15 +0900 Subject: [PATCH 25/49] add dotnet_style_prefer_collection_expression = when_types_loosely_match:error / dotnet_diagnostic.IDE0005.severity = error --- .editorconfig | 4 ++++ Directory.Build.props | 3 ++- Generator.Abstractions.Tests/KindTests.cs | 2 -- Generator.Abstractions.Tests/KnownTypesTests.cs | 4 +--- .../MethodSignatureBinderTests.cs | 9 --------- .../MethodSignatureBindingTests.cs | 4 ---- Generator.Abstractions.Tests/NullableTest.cs | 3 +-- Generator.Abstractions/BindingError.cs | 14 +++++++------- Generator.Abstractions/MethodSignatureBinder.cs | 3 --- Generator.Abstractions/MethodSignatureBinding.cs | 1 - .../PipeProcessorExtensionsTests.cs | 8 ++++---- .../TextProcessorExtensionsTests.cs | 4 ---- Processor.Abstractions/PipeProcessorExtensions.cs | 2 +- 13 files changed, 20 insertions(+), 41 deletions(-) diff --git a/.editorconfig b/.editorconfig index 7a8f4c4..96552b8 100644 --- a/.editorconfig +++ b/.editorconfig @@ -240,3 +240,7 @@ dotnet_style_parentheses_in_arithmetic_binary_operators = always_for_clarity:war dotnet_style_parentheses_in_other_binary_operators = always_for_clarity:warning dotnet_style_parentheses_in_relational_binary_operators = always_for_clarity:warning dotnet_style_parentheses_in_other_operators = never_if_unnecessary:warning + +dotnet_style_prefer_collection_expression = when_types_loosely_match:error + +dotnet_diagnostic.IDE0005.severity = error diff --git a/Directory.Build.props b/Directory.Build.props index fab8aef..57569ca 100644 --- a/Directory.Build.props +++ b/Directory.Build.props @@ -16,6 +16,7 @@ $(NoWarn);NETSDK1213;CS9057 snupkg True + true @@ -46,7 +47,7 @@ false true false - $(NoWarn);RS1035 + $(NoWarn);RS1035;CS1591 Exe true true diff --git a/Generator.Abstractions.Tests/KindTests.cs b/Generator.Abstractions.Tests/KindTests.cs index d831e93..516026c 100644 --- a/Generator.Abstractions.Tests/KindTests.cs +++ b/Generator.Abstractions.Tests/KindTests.cs @@ -1,5 +1,3 @@ -using Esolang.Generator; -using Microsoft.VisualStudio.TestTools.UnitTesting; using System.Diagnostics.CodeAnalysis; namespace Esolang.Generator.Tests; diff --git a/Generator.Abstractions.Tests/KnownTypesTests.cs b/Generator.Abstractions.Tests/KnownTypesTests.cs index 9f85531..16aa216 100644 --- a/Generator.Abstractions.Tests/KnownTypesTests.cs +++ b/Generator.Abstractions.Tests/KnownTypesTests.cs @@ -1,7 +1,5 @@ using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; -using Microsoft.VisualStudio.TestTools.UnitTesting; -using System.Linq; namespace Esolang.Generator.Tests; @@ -24,7 +22,7 @@ private static Compilation CreateCompilation(string code) .ToList(); return CSharpCompilation.Create("TestCompilation", - new[] { CSharpSyntaxTree.ParseText(code) }, + [CSharpSyntaxTree.ParseText(code)], references, new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary, nullableContextOptions: NullableContextOptions.Enable)); } diff --git a/Generator.Abstractions.Tests/MethodSignatureBinderTests.cs b/Generator.Abstractions.Tests/MethodSignatureBinderTests.cs index 8c0658c..aa10eda 100644 --- a/Generator.Abstractions.Tests/MethodSignatureBinderTests.cs +++ b/Generator.Abstractions.Tests/MethodSignatureBinderTests.cs @@ -1,15 +1,6 @@ using Basic.Reference.Assemblies; -using Esolang.Generator; using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; -using Microsoft.VisualStudio.TestTools.UnitTesting; -using System; -using System.Collections.Generic; -using System.IO; -using System.Linq; -using System.Text; -using System.Threading; -using System.Threading.Tasks; namespace Esolang.Generator.Tests; diff --git a/Generator.Abstractions.Tests/MethodSignatureBindingTests.cs b/Generator.Abstractions.Tests/MethodSignatureBindingTests.cs index fea40f3..29889aa 100644 --- a/Generator.Abstractions.Tests/MethodSignatureBindingTests.cs +++ b/Generator.Abstractions.Tests/MethodSignatureBindingTests.cs @@ -1,7 +1,3 @@ -using Esolang.Generator; -using Microsoft.CodeAnalysis; -using Microsoft.VisualStudio.TestTools.UnitTesting; - namespace Esolang.Generator.Tests; [TestClass] diff --git a/Generator.Abstractions.Tests/NullableTest.cs b/Generator.Abstractions.Tests/NullableTest.cs index 153f596..ee9e01f 100644 --- a/Generator.Abstractions.Tests/NullableTest.cs +++ b/Generator.Abstractions.Tests/NullableTest.cs @@ -1,6 +1,5 @@ using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; -using Microsoft.VisualStudio.TestTools.UnitTesting; namespace Esolang.Generator.Tests; @@ -14,7 +13,7 @@ public class NullableTest(TestContext TestContext) public void CheckNullableContext() { var compilation = CSharpCompilation.Create("Test", - new[] { CSharpSyntaxTree.ParseText("class C {}", cancellationToken: CancellationToken) }, + [CSharpSyntaxTree.ParseText("class C {}", cancellationToken: CancellationToken)], null, new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)); diff --git a/Generator.Abstractions/BindingError.cs b/Generator.Abstractions/BindingError.cs index 28f842c..67547a9 100644 --- a/Generator.Abstractions/BindingError.cs +++ b/Generator.Abstractions/BindingError.cs @@ -35,7 +35,7 @@ public abstract record BindingError(BindingErrorKind Kind, Location? Location); /// /// The unsupported return type symbol. /// The location of the return type. -public sealed record UnsupportedReturnType(ITypeSymbol Type, Location? Location) +public sealed record UnsupportedReturnType(ITypeSymbol Type, Location? Location) : BindingError(BindingErrorKind.UnsupportedReturnType, Location); /// @@ -43,7 +43,7 @@ public sealed record UnsupportedReturnType(ITypeSymbol Type, Location? Location) /// /// The parameter with the invalid modifier. /// The location of the parameter. -public sealed record InvalidParameterModifier(IParameterSymbol Parameter, Location? Location) +public sealed record InvalidParameterModifier(IParameterSymbol Parameter, Location? Location) : BindingError(BindingErrorKind.InvalidParameterModifier, Location); /// @@ -52,7 +52,7 @@ public sealed record InvalidParameterModifier(IParameterSymbol Parameter, Locati /// The parameter that caused the duplication. /// The kind of input that was already assigned. /// The location of the duplicate parameter. -public sealed record DuplicateInput(IParameterSymbol Parameter, MethodInputKind ExistingKind, Location? Location) +public sealed record DuplicateInput(IParameterSymbol Parameter, MethodInputKind ExistingKind, Location? Location) : BindingError(BindingErrorKind.DuplicateInput, Location); /// @@ -61,7 +61,7 @@ public sealed record DuplicateInput(IParameterSymbol Parameter, MethodInputKind /// The parameter that caused the duplication. /// The kind of output that was already assigned. /// The location of the duplicate parameter. -public sealed record DuplicateOutput(IParameterSymbol Parameter, MethodOutputKind ExistingKind, Location? Location) +public sealed record DuplicateOutput(IParameterSymbol Parameter, MethodOutputKind ExistingKind, Location? Location) : BindingError(BindingErrorKind.DuplicateOutput, Location); /// @@ -69,7 +69,7 @@ public sealed record DuplicateOutput(IParameterSymbol Parameter, MethodOutputKin /// /// The duplicate cancellation token parameter. /// The location of the duplicate parameter. -public sealed record DuplicateCancellationToken(IParameterSymbol Parameter, Location? Location) +public sealed record DuplicateCancellationToken(IParameterSymbol Parameter, Location? Location) : BindingError(BindingErrorKind.DuplicateCancellationToken, Location); /// @@ -77,7 +77,7 @@ public sealed record DuplicateCancellationToken(IParameterSymbol Parameter, Loca /// /// The duplicate logger parameter. /// The location of the duplicate parameter. -public sealed record DuplicateLogger(IParameterSymbol Parameter, Location? Location) +public sealed record DuplicateLogger(IParameterSymbol Parameter, Location? Location) : BindingError(BindingErrorKind.DuplicateLogger, Location); /// @@ -85,5 +85,5 @@ public sealed record DuplicateLogger(IParameterSymbol Parameter, Location? Locat /// /// The output parameter that conflicts with the return type. /// The location of the conflicting parameter. -public sealed record ReturnOutputConflict(IParameterSymbol Parameter, Location? Location) +public sealed record ReturnOutputConflict(IParameterSymbol Parameter, Location? Location) : BindingError(BindingErrorKind.ReturnOutputConflict, Location); diff --git a/Generator.Abstractions/MethodSignatureBinder.cs b/Generator.Abstractions/MethodSignatureBinder.cs index 6939607..91c729c 100644 --- a/Generator.Abstractions/MethodSignatureBinder.cs +++ b/Generator.Abstractions/MethodSignatureBinder.cs @@ -1,7 +1,4 @@ using Microsoft.CodeAnalysis; -using System; -using System.Collections.Generic; -using System.Linq; namespace Esolang.Generator; diff --git a/Generator.Abstractions/MethodSignatureBinding.cs b/Generator.Abstractions/MethodSignatureBinding.cs index 2796c09..181502e 100644 --- a/Generator.Abstractions/MethodSignatureBinding.cs +++ b/Generator.Abstractions/MethodSignatureBinding.cs @@ -1,5 +1,4 @@ using Microsoft.CodeAnalysis; -using System.Collections.Generic; using System.Diagnostics; using System.Diagnostics.CodeAnalysis; using System.Text; diff --git a/Processor.Abstractions.Tests/PipeProcessorExtensionsTests.cs b/Processor.Abstractions.Tests/PipeProcessorExtensionsTests.cs index 200f75b..23c8b0a 100644 --- a/Processor.Abstractions.Tests/PipeProcessorExtensionsTests.cs +++ b/Processor.Abstractions.Tests/PipeProcessorExtensionsTests.cs @@ -25,7 +25,7 @@ public async IAsyncEnumerable RunAsyncEnumerable([System.Runtime.Compil [Timeout(Constants.Timeout, CooperativeCancellation = true)] public async Task RunToEndAsync_HandlesEndEvent() { - var processor = new MockEventProcessor(new List { new EndEvent(42) }); + var processor = new MockEventProcessor([new EndEvent(42)]); var exitCode = await PipeProcessorExtensions.RunToEndAsync(processor, null, null, CancellationToken); Assert.AreEqual(42, exitCode); } @@ -34,7 +34,7 @@ public async Task RunToEndAsync_HandlesEndEvent() [Timeout(Constants.Timeout, CooperativeCancellation = true)] public async Task RunToEndAsync_HandlesOutputCharEvent() { - var processor = new MockEventProcessor(new List { new OutputCharEvent('A'), new EndEvent(0) }); + var processor = new MockEventProcessor([new OutputCharEvent('A'), new EndEvent(0)]); var pipe = new Pipe(); var readTask = Task.Run(async () => @@ -79,10 +79,10 @@ public async Task RunToEndAsync_HandlesOutputIntEvent() public async Task RunToEndAsync_HandlesInputCharEvent() { var capturedChar = ' '; - var processor = new MockEventProcessor(new List { + var processor = new MockEventProcessor([ new TestInputCharEvent(c => capturedChar = c), new EndEvent(0) - }); + ]); var pipe = new Pipe(); await pipe.Writer.WriteAsync(Encoding.UTF8.GetBytes("X"), CancellationToken); diff --git a/Processor.Abstractions.Tests/TextProcessorExtensionsTests.cs b/Processor.Abstractions.Tests/TextProcessorExtensionsTests.cs index 47e12c9..575d373 100644 --- a/Processor.Abstractions.Tests/TextProcessorExtensionsTests.cs +++ b/Processor.Abstractions.Tests/TextProcessorExtensionsTests.cs @@ -1,7 +1,3 @@ -using Esolang.Processor; -using Microsoft.VisualStudio.TestTools.UnitTesting; -using System.Text; - namespace Esolang.Processor.Tests; [TestClass] diff --git a/Processor.Abstractions/PipeProcessorExtensions.cs b/Processor.Abstractions/PipeProcessorExtensions.cs index bf2c70e..197e666 100644 --- a/Processor.Abstractions/PipeProcessorExtensions.cs +++ b/Processor.Abstractions/PipeProcessorExtensions.cs @@ -71,7 +71,7 @@ public static async ValueTask RunToEndAsync( case OutputCharEvent outputChar: if (output == null) throw new ArgumentNullException(nameof(output)); - output.Write(Encoding.UTF8.GetBytes(new[] { outputChar.Output })); + output.Write(Encoding.UTF8.GetBytes([outputChar.Output])); await output.FlushAsync(cancellationToken); break; case OutputIntEvent outputInt: From 34b3023a7bc873b0c882feb9238fb683f516dff7 Mon Sep 17 00:00:00 2001 From: juner Date: Sat, 30 May 2026 09:12:36 +0900 Subject: [PATCH 26/49] add csharp_style_pattern_matching_over_is_with_cast_check = true:error / dotnet_style_require_accessibility_modifiers = omit_if_default:error --- .editorconfig | 4 ++-- Generator.Abstractions.Tests/KnownTypesTests.cs | 2 +- .../MethodSignatureBinderTests.cs | 4 ++-- Generator.Abstractions/IsExternalInit.cs | 2 +- Generator.Abstractions/KnownTypes.cs | 4 ++-- Generator.Abstractions/MethodSignatureBinder.cs | 6 +++--- .../PipeProcessorExtensionsTests.cs | 10 +++++----- .../TextProcessorExtensionsTests.cs | 10 +++++----- 8 files changed, 21 insertions(+), 21 deletions(-) diff --git a/.editorconfig b/.editorconfig index 96552b8..922df05 100644 --- a/.editorconfig +++ b/.editorconfig @@ -240,7 +240,7 @@ dotnet_style_parentheses_in_arithmetic_binary_operators = always_for_clarity:war dotnet_style_parentheses_in_other_binary_operators = always_for_clarity:warning dotnet_style_parentheses_in_relational_binary_operators = always_for_clarity:warning dotnet_style_parentheses_in_other_operators = never_if_unnecessary:warning - dotnet_style_prefer_collection_expression = when_types_loosely_match:error - dotnet_diagnostic.IDE0005.severity = error +csharp_style_pattern_matching_over_is_with_cast_check = true:error +dotnet_style_require_accessibility_modifiers = omit_if_default:error diff --git a/Generator.Abstractions.Tests/KnownTypesTests.cs b/Generator.Abstractions.Tests/KnownTypesTests.cs index 16aa216..285697c 100644 --- a/Generator.Abstractions.Tests/KnownTypesTests.cs +++ b/Generator.Abstractions.Tests/KnownTypesTests.cs @@ -6,7 +6,7 @@ namespace Esolang.Generator.Tests; [TestClass] public class KnownTypesTests { - private static Compilation CreateCompilation(string code) + static Compilation CreateCompilation(string code) { var assemblies = new[] { diff --git a/Generator.Abstractions.Tests/MethodSignatureBinderTests.cs b/Generator.Abstractions.Tests/MethodSignatureBinderTests.cs index aa10eda..a8f144e 100644 --- a/Generator.Abstractions.Tests/MethodSignatureBinderTests.cs +++ b/Generator.Abstractions.Tests/MethodSignatureBinderTests.cs @@ -7,7 +7,7 @@ namespace Esolang.Generator.Tests; [TestClass] public class MethodSignatureBinderTests(TestContext TestContext) { - private Compilation baseCompilation = default!; + Compilation baseCompilation = default!; void WriteLine(string message) => TestContext.WriteLine(message); @@ -49,7 +49,7 @@ public void InitializeCompilation() options: new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary, nullableContextOptions: NullableContextOptions.Enable)); } - private (IMethodSymbol, Compilation) GetMethodAndCompilation(string code, string methodName) + (IMethodSymbol, Compilation) GetMethodAndCompilation(string code, string methodName) { var tree = CSharpSyntaxTree.ParseText("#nullable enable\n" + code, cancellationToken: TestContext.CancellationToken); var compilation = baseCompilation.AddSyntaxTrees(tree); diff --git a/Generator.Abstractions/IsExternalInit.cs b/Generator.Abstractions/IsExternalInit.cs index 54990f4..f76ff9f 100644 --- a/Generator.Abstractions/IsExternalInit.cs +++ b/Generator.Abstractions/IsExternalInit.cs @@ -5,7 +5,7 @@ namespace System.Runtime.CompilerServices; /// Reserved to be used by the compiler for tracking metadata. /// This class should not be used by developers in source code. /// -internal static class IsExternalInit +static class IsExternalInit { } #endif diff --git a/Generator.Abstractions/KnownTypes.cs b/Generator.Abstractions/KnownTypes.cs index d737840..376d83f 100644 --- a/Generator.Abstractions/KnownTypes.cs +++ b/Generator.Abstractions/KnownTypes.cs @@ -46,10 +46,10 @@ public readonly struct KnownTypes(Compilation compilation) /// The Microsoft.Extensions.Logging.ILogger{T} type symbol. public readonly INamedTypeSymbol? ILoggerT = compilation.GetBestTypeByMetadataName("Microsoft.Extensions.Logging.ILogger`1"); - private static bool EqualsDefinition(ITypeSymbol? type, ISymbol? symbol) => + static bool EqualsDefinition(ITypeSymbol? type, ISymbol? symbol) => type != null && symbol != null && SymbolEqualityComparer.Default.Equals(type.OriginalDefinition, symbol); - private static bool EqualsType(ITypeSymbol? type, ISymbol? symbol) => + static bool EqualsType(ITypeSymbol? type, ISymbol? symbol) => type != null && symbol != null && SymbolEqualityComparer.Default.Equals(type, symbol); /// Gets a value indicating whether the type is string. diff --git a/Generator.Abstractions/MethodSignatureBinder.cs b/Generator.Abstractions/MethodSignatureBinder.cs index 91c729c..14d68a3 100644 --- a/Generator.Abstractions/MethodSignatureBinder.cs +++ b/Generator.Abstractions/MethodSignatureBinder.cs @@ -148,7 +148,7 @@ public static MethodReturnKind BindReturnKind(ITypeSymbol returnType, KnownTypes /// /// Gets the default output kind based on the return kind. /// - private static MethodOutputKind BindDefaultOutputKind(MethodReturnKind returnKind) => returnKind switch + static MethodOutputKind BindDefaultOutputKind(MethodReturnKind returnKind) => returnKind switch { MethodReturnKind.String or MethodReturnKind.NullableString or MethodReturnKind.TaskString or MethodReturnKind.TaskNullableString or MethodReturnKind.ValueTaskString or MethodReturnKind.ValueTaskNullableString => MethodOutputKind.ReturnString, MethodReturnKind.IEnumerableByte => MethodOutputKind.ReturnIEnumerable, @@ -159,7 +159,7 @@ public static MethodReturnKind BindReturnKind(ITypeSymbol returnType, KnownTypes /// /// Gets a value indicating whether the return kind implies output is returned. /// - private static bool IsOutputReturning(MethodReturnKind returnKind) => returnKind switch + static bool IsOutputReturning(MethodReturnKind returnKind) => returnKind switch { MethodReturnKind.String or MethodReturnKind.NullableString or MethodReturnKind.TaskString or MethodReturnKind.TaskNullableString or MethodReturnKind.ValueTaskString or MethodReturnKind.ValueTaskNullableString or MethodReturnKind.IEnumerableByte or MethodReturnKind.IAsyncEnumerableByte => true, _ => false @@ -173,7 +173,7 @@ public static MethodReturnKind BindReturnKind(ITypeSymbol returnType, KnownTypes /// The known types for the compilation. /// Output: Whether the logger was found in a constructor parameter. /// The expression to access the logger, or null if not found. - private static string? FindLoggerInContainingType(ITypeSymbol? type, bool isStatic, KnownTypes types, out bool isFromParameter) + static string? FindLoggerInContainingType(ITypeSymbol? type, bool isStatic, KnownTypes types, out bool isFromParameter) { isFromParameter = false; var currentType = type; diff --git a/Processor.Abstractions.Tests/PipeProcessorExtensionsTests.cs b/Processor.Abstractions.Tests/PipeProcessorExtensionsTests.cs index 23c8b0a..527ce10 100644 --- a/Processor.Abstractions.Tests/PipeProcessorExtensionsTests.cs +++ b/Processor.Abstractions.Tests/PipeProcessorExtensionsTests.cs @@ -9,7 +9,7 @@ public class PipeProcessorExtensionsTests(TestContext TestContext) { CancellationToken CancellationToken => TestContext.CancellationToken; - private class MockEventProcessor(List events) : IEventProcessor + class MockEventProcessor(List events) : IEventProcessor { public async IAsyncEnumerable RunAsyncEnumerable([System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken cancellationToken = default) { @@ -153,22 +153,22 @@ public async Task RunToEndAsync_ThrowsArgumentNullExceptionOnNullWriter_OutputIn await Assert.ThrowsAsync(() => PipeProcessorExtensions.RunToEndAsync(processor, null, null, CancellationToken).AsTask()); } - private class TestInputCharEvent(Action write) : InputCharEvent + class TestInputCharEvent(Action write) : InputCharEvent { public override void Write(char c) => write(c); } - private class TestInputIntEvent(Action write) : InputIntEvent + class TestInputIntEvent(Action write) : InputIntEvent { public override void Write(int i) => write(i); } - private class InputCharEventMock : InputCharEvent + class InputCharEventMock : InputCharEvent { public override void Write(char c) { } } - private class InputIntEventMock : InputIntEvent + class InputIntEventMock : InputIntEvent { public override void Write(int i) { } } diff --git a/Processor.Abstractions.Tests/TextProcessorExtensionsTests.cs b/Processor.Abstractions.Tests/TextProcessorExtensionsTests.cs index 575d373..3cb09fa 100644 --- a/Processor.Abstractions.Tests/TextProcessorExtensionsTests.cs +++ b/Processor.Abstractions.Tests/TextProcessorExtensionsTests.cs @@ -5,7 +5,7 @@ public class TextProcessorExtensionsTests(TestContext TestContext) { CancellationToken CancellationToken => TestContext.CancellationToken; - private class MockEventProcessor(List events) : IEventProcessor + class MockEventProcessor(List events) : IEventProcessor { public async IAsyncEnumerable RunAsyncEnumerable([System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken cancellationToken = default) { @@ -118,22 +118,22 @@ public void RunToEnd_HandlesEndEvent() Assert.AreEqual(88, exitCode); } - private class TestInputCharEvent(Action write) : InputCharEvent + class TestInputCharEvent(Action write) : InputCharEvent { public override void Write(char c) => write(c); } - private class TestInputIntEvent(Action write) : InputIntEvent + class TestInputIntEvent(Action write) : InputIntEvent { public override void Write(int i) => write(i); } - private class InputCharEventMock : InputCharEvent + class InputCharEventMock : InputCharEvent { public override void Write(char c) { } } - private class InputIntEventMock : InputIntEvent + class InputIntEventMock : InputIntEvent { public override void Write(int i) { } } From e2324b223664f00b17e640494805d6afe0102991 Mon Sep 17 00:00:00 2001 From: juner Date: Sat, 30 May 2026 09:24:06 +0900 Subject: [PATCH 27/49] add dotnet_diagnostic.MSTEST0020.severity = error / dotnet_diagnostic.IDE0051.severity = error --- .editorconfig | 3 +++ .../MethodSignatureBinderTests.cs | 18 +++++++++++------- 2 files changed, 14 insertions(+), 7 deletions(-) diff --git a/.editorconfig b/.editorconfig index 922df05..ebcb1c6 100644 --- a/.editorconfig +++ b/.editorconfig @@ -244,3 +244,6 @@ dotnet_style_prefer_collection_expression = when_types_loosely_match:error dotnet_diagnostic.IDE0005.severity = error csharp_style_pattern_matching_over_is_with_cast_check = true:error dotnet_style_require_accessibility_modifiers = omit_if_default:error + +dotnet_diagnostic.MSTEST0020.severity = error +dotnet_diagnostic.IDE0051.severity = error diff --git a/Generator.Abstractions.Tests/MethodSignatureBinderTests.cs b/Generator.Abstractions.Tests/MethodSignatureBinderTests.cs index a8f144e..ff0a902 100644 --- a/Generator.Abstractions.Tests/MethodSignatureBinderTests.cs +++ b/Generator.Abstractions.Tests/MethodSignatureBinderTests.cs @@ -5,15 +5,16 @@ namespace Esolang.Generator.Tests; [TestClass] -public class MethodSignatureBinderTests(TestContext TestContext) +public class MethodSignatureBinderTests { - Compilation baseCompilation = default!; + readonly TestContext TestContext; + readonly Compilation baseCompilation = default!; - void WriteLine(string message) => TestContext.WriteLine(message); + CancellationToken CancellationToken => TestContext.CancellationToken; - [TestInitialize] - public void InitializeCompilation() + public MethodSignatureBinderTests(TestContext TestContext) { + this.TestContext = TestContext; IEnumerable references = #if NET10_0_OR_GREATER Net100.References.All; @@ -51,10 +52,13 @@ public void InitializeCompilation() (IMethodSymbol, Compilation) GetMethodAndCompilation(string code, string methodName) { - var tree = CSharpSyntaxTree.ParseText("#nullable enable\n" + code, cancellationToken: TestContext.CancellationToken); + var tree = CSharpSyntaxTree.ParseText("#nullable enable\n" + code, cancellationToken: CancellationToken); var compilation = baseCompilation.AddSyntaxTrees(tree); var classC = compilation.GetTypeByMetadataName("C"); - return (classC!.GetMembers(methodName).OfType().First(), compilation); + Assert.IsNotNull(classC, "Failed to get symbol for class C"); + var methodSymbol = classC.GetMembers(methodName).OfType().FirstOrDefault(); + Assert.IsNotNull(methodSymbol, $"Failed to get symbol for method {methodName}"); + return (methodSymbol, compilation); } [TestMethod] From 4aa1f4b986d15cd35839e0b3b28e1d5a62965870 Mon Sep 17 00:00:00 2001 From: juner Date: Sat, 30 May 2026 09:46:30 +0900 Subject: [PATCH 28/49] add dotnet_diagnostic.MSTEST0037.severity = error --- .editorconfig | 33 ++++++++++++++++++- .../MethodSignatureBinderTests.cs | 2 +- 2 files changed, 33 insertions(+), 2 deletions(-) diff --git a/.editorconfig b/.editorconfig index ebcb1c6..b4b0da9 100644 --- a/.editorconfig +++ b/.editorconfig @@ -244,6 +244,37 @@ dotnet_style_prefer_collection_expression = when_types_loosely_match:error dotnet_diagnostic.IDE0005.severity = error csharp_style_pattern_matching_over_is_with_cast_check = true:error dotnet_style_require_accessibility_modifiers = omit_if_default:error +dotnet_diagnostic.IDE0051.severity = error + +#region MSTest Analyzers +# MSTEST0017: アサーション引数は正しい順序で渡す必要があります +dotnet_diagnostic.MSTEST0017.severity = error +# MSTEST0020: TestInitialize メソッドよりもコンストラクターを優先する dotnet_diagnostic.MSTEST0020.severity = error -dotnet_diagnostic.IDE0051.severity = error +# MSTEST0021: TestCleanup メソッドよりも Dispose を優先する +dotnet_diagnostic.MSTEST0021.severity = error +# MSTEST0022: Dispose メソッドよりも TestCleanup を優先する +dotnet_diagnostic.MSTEST0022.severity = none +# MSTEST0023: ブール アサーションを否定しないこと +dotnet_diagnostic.MSTEST0023.severity = error +# MSTEST0024: TestContext を静的メンバーに格納しない +dotnet_diagnostic.MSTEST0024.severity = error +# MSTEST0025: 常に失敗するアサートではなく 'Assert.Fail' を使う +dotnet_diagnostic.MSTEST0025.severity = error +# MSTEST0026: アサーションでの条件付きアクセスを回避する +dotnet_diagnostic.MSTEST0026.severity = error +# MSTEST0029: パブリック メソッドをテスト メソッドにする必要がある +dotnet_diagnostic.MSTEST0029.severity = error +# MSTEST0032: 条件が常に真であることがわかっているため、アサーションを確認するか削除してください +dotnet_diagnostic.MSTEST0032.severity = error +# MSTEST0036: テスト クラス内でシャドウイングを使用しない +dotnet_diagnostic.MSTEST0036.severity = error +# MSTEST0037: 適切な 'Assert' メソッドを使用する +dotnet_diagnostic.MSTEST0037.severity = error +# MSTEST0044: DataTestMethod よりも TestMethod を優先する +dotnet_diagnostic.MSTEST0044.severity = error +# MSTEST0045: タイムアウトに協調キャンセルを使用する +dotnet_diagnostic.MSTEST0045.severity = error + +#endregion \ No newline at end of file diff --git a/Generator.Abstractions.Tests/MethodSignatureBinderTests.cs b/Generator.Abstractions.Tests/MethodSignatureBinderTests.cs index ff0a902..f56fd45 100644 --- a/Generator.Abstractions.Tests/MethodSignatureBinderTests.cs +++ b/Generator.Abstractions.Tests/MethodSignatureBinderTests.cs @@ -226,7 +226,7 @@ public void Bind_UnhandledParameters_AddedToUnhandledList() var binding = MethodSignatureBinder.Bind(method, knownTypes); Assert.IsTrue(binding.IsValid); - Assert.AreEqual(1, binding.UnhandledParameters.Count); + Assert.HasCount(1, binding.UnhandledParameters); Assert.AreEqual("i", binding.UnhandledParameters[0].Name); } From c0d33884c4fa917b2d6aba80c95995bbacb1e5ee Mon Sep 17 00:00:00 2001 From: juner Date: Sat, 30 May 2026 09:59:47 +0900 Subject: [PATCH 29/49] add MSTEST analyzers --- .editorconfig | 20 ++++++++++++++++++-- 1 file changed, 18 insertions(+), 2 deletions(-) diff --git a/.editorconfig b/.editorconfig index b4b0da9..8182f7b 100644 --- a/.editorconfig +++ b/.editorconfig @@ -272,9 +272,25 @@ dotnet_diagnostic.MSTEST0032.severity = error dotnet_diagnostic.MSTEST0036.severity = error # MSTEST0037: 適切な 'Assert' メソッドを使用する dotnet_diagnostic.MSTEST0037.severity = error +# MSTEST0038: 値型では 'Assert.AreSame' または 'Assert.AreNotSame' を使用しない +dotnet_diagnostic.MSTEST0038.severity = error +# MSTEST0040: 'async void' コンテキスト内でアサートしない +dotnet_diagnostic.MSTEST0040.severity = error # MSTEST0044: DataTestMethod よりも TestMethod を優先する dotnet_diagnostic.MSTEST0044.severity = error # MSTEST0045: タイムアウトに協調キャンセルを使用する dotnet_diagnostic.MSTEST0045.severity = error - -#endregion \ No newline at end of file +# MSTEST0046: StringAssertではなくAssertを使います +dotnet_diagnostic.MSTEST0046.severity = error +# MSTEST0049: Flow TestContext キャンセル トークンを使用する +dotnet_diagnostic.MSTEST0049.severity = error +# MSTEST0051: Assert.Throws には 1 つのステートメントのみを含める必要があります +dotnet_diagnostic.MSTEST0051.severity = error +# MSTEST0054: TestContext.CancellationToken からのキャンセル トークンを使用する +dotnet_diagnostic.MSTEST0054.severity = error +# MSTEST0058: catch ブロック内の assert を避ける +dotnet_diagnostic.MSTEST0058.severity = error +# MSTEST0061: ランタイム チェックの代わりに OSCondition 属性を使用する +dotnet_diagnostic.MSTEST0061.severity = error + +##endregion \ No newline at end of file From 85ac35161334ec04c643127a658e3d4bbcb9e5a8 Mon Sep 17 00:00:00 2001 From: juner Date: Sat, 30 May 2026 11:29:14 +0900 Subject: [PATCH 30/49] editorconig editing... --- .editorconfig | 82 ++++++++++++++++++++++++++++++++------------------- 1 file changed, 51 insertions(+), 31 deletions(-) diff --git a/.editorconfig b/.editorconfig index 8182f7b..fcd8f86 100644 --- a/.editorconfig +++ b/.editorconfig @@ -236,61 +236,81 @@ dotnet_style_qualification_for_field = false:silent dotnet_style_qualification_for_property = false:warning dotnet_style_qualification_for_method = false:warning dotnet_style_qualification_for_event = false:warning -dotnet_style_parentheses_in_arithmetic_binary_operators = always_for_clarity:warning -dotnet_style_parentheses_in_other_binary_operators = always_for_clarity:warning -dotnet_style_parentheses_in_relational_binary_operators = always_for_clarity:warning +# 関係演算子の優先順位が明確な場合は、かっこを使用しない +dotnet_style_parentheses_in_arithmetic_binary_operators = never_if_unnecessary:warning +# 関係演算子の優先順位が明確な場合は、かっこを使用しない +dotnet_style_parentheses_in_other_binary_operators = never_if_unnecessary:warning +# 関係演算子の優先順位が明確な場合は、かっこを使用しない +dotnet_style_parentheses_in_relational_binary_operators = never_if_unnecessary:warning +# 算術演算子の優先順位が明確な場合はかっこを使用しない dotnet_style_parentheses_in_other_operators = never_if_unnecessary:warning -dotnet_style_prefer_collection_expression = when_types_loosely_match:error -dotnet_diagnostic.IDE0005.severity = error -csharp_style_pattern_matching_over_is_with_cast_check = true:error -dotnet_style_require_accessibility_modifiers = omit_if_default:error -dotnet_diagnostic.IDE0051.severity = error +# IEnumerable list = new List() { 1, 2 };など、型が緩やかに一致する場合でもコレクション式を使用することを好みます。 対象となる型は、右側の型と一致するか、IEnumerable、ICollection、IList、IReadOnlyCollection、IReadOnlyListのいずれかの型である必要があります。 +dotnet_style_prefer_collection_expression = when_types_loosely_match:warning +# 不要な using ディレクティブを削除する (IDE0005) +dotnet_diagnostic.IDE0005.severity = warning +# is 式と型キャストの代わりにパターン マッチングを使用します。 +csharp_style_pattern_matching_over_is_with_cast_check = true:warning +# 既定の修飾子である場合を除き、アクセシビリティ修飾子を優先します。 +dotnet_style_require_accessibility_modifiers = omit_if_default:warning +# 未使用のプライベート メンバーを削除する (IDE0051) +dotnet_diagnostic.IDE0051.severity = warning + +#region +# CA2012: ValueTask を正しく使用する必要があります +dotnet_diagnostic.CA2012.severity = warning +# CA2016: CancellationToken パラメーターを受け取るメソッドに渡す +dotnet_diagnostic.CA2016.severity = warning +# CA2200: スタックの詳細を保持するために再スローします。 +dotnet_diagnostic.CA2200.severity = warning +# CA2217: 列挙型に FlagsAttributeを付与しないでください。 +dotnet_diagnostic.CA2217.severity = warning +#endregion #region MSTest Analyzers # MSTEST0017: アサーション引数は正しい順序で渡す必要があります -dotnet_diagnostic.MSTEST0017.severity = error +dotnet_diagnostic.MSTEST0017.severity = warning # MSTEST0020: TestInitialize メソッドよりもコンストラクターを優先する -dotnet_diagnostic.MSTEST0020.severity = error +dotnet_diagnostic.MSTEST0020.severity = warning # MSTEST0021: TestCleanup メソッドよりも Dispose を優先する -dotnet_diagnostic.MSTEST0021.severity = error +dotnet_diagnostic.MSTEST0021.severity = warning # MSTEST0022: Dispose メソッドよりも TestCleanup を優先する -dotnet_diagnostic.MSTEST0022.severity = none +dotnet_diagnostic.MSTEST0022.severity = warning # MSTEST0023: ブール アサーションを否定しないこと -dotnet_diagnostic.MSTEST0023.severity = error +dotnet_diagnostic.MSTEST0023.severity = warning # MSTEST0024: TestContext を静的メンバーに格納しない -dotnet_diagnostic.MSTEST0024.severity = error +dotnet_diagnostic.MSTEST0024.severity = warning # MSTEST0025: 常に失敗するアサートではなく 'Assert.Fail' を使う -dotnet_diagnostic.MSTEST0025.severity = error +dotnet_diagnostic.MSTEST0025.severity = warning # MSTEST0026: アサーションでの条件付きアクセスを回避する -dotnet_diagnostic.MSTEST0026.severity = error +dotnet_diagnostic.MSTEST0026.severity = warning # MSTEST0029: パブリック メソッドをテスト メソッドにする必要がある -dotnet_diagnostic.MSTEST0029.severity = error +dotnet_diagnostic.MSTEST0029.severity = warning # MSTEST0032: 条件が常に真であることがわかっているため、アサーションを確認するか削除してください -dotnet_diagnostic.MSTEST0032.severity = error +dotnet_diagnostic.MSTEST0032.severity = warning # MSTEST0036: テスト クラス内でシャドウイングを使用しない -dotnet_diagnostic.MSTEST0036.severity = error +dotnet_diagnostic.MSTEST0036.severity = warning # MSTEST0037: 適切な 'Assert' メソッドを使用する -dotnet_diagnostic.MSTEST0037.severity = error +dotnet_diagnostic.MSTEST0037.severity = warning # MSTEST0038: 値型では 'Assert.AreSame' または 'Assert.AreNotSame' を使用しない -dotnet_diagnostic.MSTEST0038.severity = error +dotnet_diagnostic.MSTEST0038.severity = warning # MSTEST0040: 'async void' コンテキスト内でアサートしない -dotnet_diagnostic.MSTEST0040.severity = error +dotnet_diagnostic.MSTEST0040.severity = warning # MSTEST0044: DataTestMethod よりも TestMethod を優先する -dotnet_diagnostic.MSTEST0044.severity = error +dotnet_diagnostic.MSTEST0044.severity = warning # MSTEST0045: タイムアウトに協調キャンセルを使用する -dotnet_diagnostic.MSTEST0045.severity = error +dotnet_diagnostic.MSTEST0045.severity = warning # MSTEST0046: StringAssertではなくAssertを使います -dotnet_diagnostic.MSTEST0046.severity = error +dotnet_diagnostic.MSTEST0046.severity = warning # MSTEST0049: Flow TestContext キャンセル トークンを使用する -dotnet_diagnostic.MSTEST0049.severity = error +dotnet_diagnostic.MSTEST0049.severity = warning # MSTEST0051: Assert.Throws には 1 つのステートメントのみを含める必要があります -dotnet_diagnostic.MSTEST0051.severity = error +dotnet_diagnostic.MSTEST0051.severity = warning # MSTEST0054: TestContext.CancellationToken からのキャンセル トークンを使用する -dotnet_diagnostic.MSTEST0054.severity = error +dotnet_diagnostic.MSTEST0054.severity = warning # MSTEST0058: catch ブロック内の assert を避ける -dotnet_diagnostic.MSTEST0058.severity = error +dotnet_diagnostic.MSTEST0058.severity = warning # MSTEST0061: ランタイム チェックの代わりに OSCondition 属性を使用する -dotnet_diagnostic.MSTEST0061.severity = error +dotnet_diagnostic.MSTEST0061.severity = warning -##endregion \ No newline at end of file +#endregion \ No newline at end of file From c3c5e5b85bf6900e6f50456552d83869424710a3 Mon Sep 17 00:00:00 2001 From: juner Date: Sat, 30 May 2026 20:55:03 +0900 Subject: [PATCH 31/49] =?UTF-8?q?BindingError=20=E3=81=AF=20=E3=83=A9?= =?UTF-8?q?=E3=82=A4=E3=83=96=E3=83=A9=E3=83=AA=E5=88=A9=E7=94=A8=E5=81=B4?= =?UTF-8?q?=E3=81=8B=E3=82=89=E7=B6=99=E6=89=BF=E3=81=A7=E3=81=8D=E3=81=AA?= =?UTF-8?q?=E3=81=84=E3=82=88=E3=81=86=E3=81=AB=E3=81=99=E3=82=8B=20/=20Me?= =?UTF-8?q?thodSignatureBinding=20=E3=81=AE=E3=82=B3=E3=83=B3=E3=82=B9?= =?UTF-8?q?=E3=83=88=E3=83=A9=E3=82=AF=E3=82=BF=E7=AC=AC=E4=B8=80=E5=BC=95?= =?UTF-8?q?=E6=95=B0=20IsValid=20=E3=82=92=20=E6=9C=AB=E5=B0=BE=E5=BC=95?= =?UTF-8?q?=E6=95=B0=E3=81=8B=E3=82=89=E6=8E=A8=E6=B8=AC=E3=81=99=E3=82=8B?= =?UTF-8?q?=E5=BD=A2=E3=81=AB?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../MethodSignatureBindingTests.cs | 12 +- Generator.Abstractions/BindingError.cs | 126 ++++++++++-------- .../MethodSignatureBinder.cs | 25 ++-- .../MethodSignatureBinding.cs | 5 +- 4 files changed, 94 insertions(+), 74 deletions(-) diff --git a/Generator.Abstractions.Tests/MethodSignatureBindingTests.cs b/Generator.Abstractions.Tests/MethodSignatureBindingTests.cs index 29889aa..3400ada 100644 --- a/Generator.Abstractions.Tests/MethodSignatureBindingTests.cs +++ b/Generator.Abstractions.Tests/MethodSignatureBindingTests.cs @@ -7,29 +7,29 @@ public class MethodSignatureBindingTests public void Properties_CheckCorrectly() { // IsAsync: Task 系 - var bindingTask = new MethodSignatureBinding(true, MethodReturnKind.Task, MethodInputKind.None, MethodOutputKind.None, "", "", null, null, false, []); + var bindingTask = new MethodSignatureBinding(MethodReturnKind.Task, MethodInputKind.None, MethodOutputKind.None, "", "", null, null, false, []); Assert.IsTrue(bindingTask.IsAsync); // IsAsync: ValueTask 系 - var bindingValueTask = new MethodSignatureBinding(true, MethodReturnKind.ValueTask, MethodInputKind.None, MethodOutputKind.None, "", "", null, null, false, []); + var bindingValueTask = new MethodSignatureBinding(MethodReturnKind.ValueTask, MethodInputKind.None, MethodOutputKind.None, "", "", null, null, false, []); Assert.IsTrue(bindingValueTask.IsAsync); // IsEnumerable - var bindingEnum = new MethodSignatureBinding(true, MethodReturnKind.IEnumerableByte, MethodInputKind.None, MethodOutputKind.None, "", "", null, null, false, []); + var bindingEnum = new MethodSignatureBinding(MethodReturnKind.IEnumerableByte, MethodInputKind.None, MethodOutputKind.None, "", "", null, null, false, []); Assert.IsTrue(bindingEnum.IsEnumerable); Assert.IsFalse(bindingEnum.IsAsync); // IsAsyncEnumerable - var bindingAsyncEnum = new MethodSignatureBinding(true, MethodReturnKind.IAsyncEnumerableByte, MethodInputKind.None, MethodOutputKind.None, "", "", null, null, false, []); + var bindingAsyncEnum = new MethodSignatureBinding(MethodReturnKind.IAsyncEnumerableByte, MethodInputKind.None, MethodOutputKind.None, "", "", null, null, false, []); Assert.IsTrue(bindingAsyncEnum.IsAsyncEnumerable); Assert.IsTrue(bindingAsyncEnum.IsAsync); // HasExplicitInput - var bindingInput = new MethodSignatureBinding(true, MethodReturnKind.Void, MethodInputKind.String, MethodOutputKind.None, "s", "", null, null, false, []); + var bindingInput = new MethodSignatureBinding(MethodReturnKind.Void, MethodInputKind.String, MethodOutputKind.None, "s", "", null, null, false, []); Assert.IsTrue(bindingInput.HasExplicitInput); // HasExplicitOutput - var bindingOutput = new MethodSignatureBinding(true, MethodReturnKind.Void, MethodInputKind.None, MethodOutputKind.TextWriter, "", "w", null, null, false, []); + var bindingOutput = new MethodSignatureBinding(MethodReturnKind.Void, MethodInputKind.None, MethodOutputKind.TextWriter, "", "w", null, null, false, []); Assert.IsTrue(bindingOutput.HasExplicitOutput); } } diff --git a/Generator.Abstractions/BindingError.cs b/Generator.Abstractions/BindingError.cs index 67547a9..ab269d8 100644 --- a/Generator.Abstractions/BindingError.cs +++ b/Generator.Abstractions/BindingError.cs @@ -26,64 +26,82 @@ public enum BindingErrorKind /// /// Represents a diagnostic error that occurred during method signature binding. /// -/// The kind of error. -/// The location associated with the error. -public abstract record BindingError(BindingErrorKind Kind, Location? Location); +public abstract record BindingError +{ + /// + /// + /// + /// The kind of error. + /// The location associated with the error. + BindingError(BindingErrorKind Kind, Location? Location) : base() + => (this.Kind, this.Location) = (Kind, Location); -/// -/// The return type of the method is not supported. -/// -/// The unsupported return type symbol. -/// The location of the return type. -public sealed record UnsupportedReturnType(ITypeSymbol Type, Location? Location) - : BindingError(BindingErrorKind.UnsupportedReturnType, Location); + /// + /// The kind of error. + /// + public BindingErrorKind Kind { get; } -/// -/// A parameter has an invalid modifier (e.g., ref, out, in). -/// -/// The parameter with the invalid modifier. -/// The location of the parameter. -public sealed record InvalidParameterModifier(IParameterSymbol Parameter, Location? Location) - : BindingError(BindingErrorKind.InvalidParameterModifier, Location); + /// + /// The location associated with the error. + /// + public Location? Location { get; } -/// -/// More than one parameter is competing for the same input role. -/// -/// The parameter that caused the duplication. -/// The kind of input that was already assigned. -/// The location of the duplicate parameter. -public sealed record DuplicateInput(IParameterSymbol Parameter, MethodInputKind ExistingKind, Location? Location) - : BindingError(BindingErrorKind.DuplicateInput, Location); + /// + /// The return type of the method is not supported. + /// + /// The unsupported return type symbol. + /// The location of the return type. + public sealed record UnsupportedReturnType(ITypeSymbol ReturnType, Location? Location) + : BindingError(BindingErrorKind.UnsupportedReturnType, Location); -/// -/// More than one parameter is competing for the same output role. -/// -/// The parameter that caused the duplication. -/// The kind of output that was already assigned. -/// The location of the duplicate parameter. -public sealed record DuplicateOutput(IParameterSymbol Parameter, MethodOutputKind ExistingKind, Location? Location) - : BindingError(BindingErrorKind.DuplicateOutput, Location); + /// + /// A parameter has an invalid modifier (e.g., ref, out, in). + /// + /// The parameter with the invalid modifier. + /// The location of the parameter. + public sealed record InvalidParameterModifier(IParameterSymbol Parameter, Location? Location) + : BindingError(BindingErrorKind.InvalidParameterModifier, Location); -/// -/// More than one cancellation token parameter was found. -/// -/// The duplicate cancellation token parameter. -/// The location of the duplicate parameter. -public sealed record DuplicateCancellationToken(IParameterSymbol Parameter, Location? Location) - : BindingError(BindingErrorKind.DuplicateCancellationToken, Location); + /// + /// More than one parameter is competing for the same input role. + /// + /// The parameter that caused the duplication. + /// The kind of input that was already assigned. + /// The location of the duplicate parameter. + public sealed record DuplicateInput(IParameterSymbol Parameter, MethodInputKind ExistingKind, Location? Location) + : BindingError(BindingErrorKind.DuplicateInput, Location); -/// -/// More than one logger parameter was found. -/// -/// The duplicate logger parameter. -/// The location of the duplicate parameter. -public sealed record DuplicateLogger(IParameterSymbol Parameter, Location? Location) - : BindingError(BindingErrorKind.DuplicateLogger, Location); + /// + /// More than one parameter is competing for the same output role. + /// + /// The parameter that caused the duplication. + /// The kind of output that was already assigned. + /// The location of the duplicate parameter. + public sealed record DuplicateOutput(IParameterSymbol Parameter, MethodOutputKind ExistingKind, Location? Location) + : BindingError(BindingErrorKind.DuplicateOutput, Location); -/// -/// A conflict exists between the return type and an output parameter. -/// -/// The output parameter that conflicts with the return type. -/// The location of the conflicting parameter. -public sealed record ReturnOutputConflict(IParameterSymbol Parameter, Location? Location) - : BindingError(BindingErrorKind.ReturnOutputConflict, Location); + /// + /// More than one cancellation token parameter was found. + /// + /// The duplicate cancellation token parameter. + /// The location of the duplicate parameter. + public sealed record DuplicateCancellationToken(IParameterSymbol Parameter, Location? Location) + : BindingError(BindingErrorKind.DuplicateCancellationToken, Location); + + /// + /// More than one logger parameter was found. + /// + /// The duplicate logger parameter. + /// The location of the duplicate parameter. + public sealed record DuplicateLogger(IParameterSymbol Parameter, Location? Location) + : BindingError(BindingErrorKind.DuplicateLogger, Location); + + /// + /// A conflict exists between the return type and an output parameter. + /// + /// The output parameter that conflicts with the return type. + /// The location of the conflicting parameter. + public sealed record ReturnOutputConflict(IParameterSymbol Parameter, Location? Location) + : BindingError(BindingErrorKind.ReturnOutputConflict, Location); + +} diff --git a/Generator.Abstractions/MethodSignatureBinder.cs b/Generator.Abstractions/MethodSignatureBinder.cs index 14d68a3..5e90b8c 100644 --- a/Generator.Abstractions/MethodSignatureBinder.cs +++ b/Generator.Abstractions/MethodSignatureBinder.cs @@ -1,4 +1,5 @@ using Microsoft.CodeAnalysis; +using static Esolang.Generator.BindingError; namespace Esolang.Generator; @@ -20,7 +21,7 @@ public static MethodSignatureBinding Bind( var returnKind = BindReturnKind(method.ReturnType, types); if (returnKind == MethodReturnKind.Invalid) { - return new MethodSignatureBinding(false, returnKind, MethodInputKind.None, MethodOutputKind.None, "", "", null, null, false, method.Parameters, new UnsupportedReturnType(method.ReturnType, method.Locations.FirstOrDefault())); + return new MethodSignatureBinding(returnKind, MethodInputKind.None, MethodOutputKind.None, "", "", null, null, false, method.Parameters, new UnsupportedReturnType(method.ReturnType, method.Locations.FirstOrDefault())); } var outputKind = BindDefaultOutputKind(returnKind); @@ -36,13 +37,13 @@ public static MethodSignatureBinding Bind( { if (p.RefKind != RefKind.None) { - return new MethodSignatureBinding(false, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, new InvalidParameterModifier(p, p.Locations.FirstOrDefault())); + return new MethodSignatureBinding(returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, new InvalidParameterModifier(p, p.Locations.FirstOrDefault())); } if (types.IsString(p.Type, false)) { if (inputKind != MethodInputKind.None) - return new MethodSignatureBinding(false, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, new DuplicateInput(p, inputKind, p.Locations.FirstOrDefault())); + return new MethodSignatureBinding(returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, new DuplicateInput(p, inputKind, p.Locations.FirstOrDefault())); inputKind = MethodInputKind.String; inputExpr = p.Name; @@ -52,7 +53,7 @@ public static MethodSignatureBinding Bind( if (types.IsTextReader(p.Type)) { if (inputKind != MethodInputKind.None) - return new MethodSignatureBinding(false, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, new DuplicateInput(p, inputKind, p.Locations.FirstOrDefault())); + return new MethodSignatureBinding(returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, new DuplicateInput(p, inputKind, p.Locations.FirstOrDefault())); inputKind = MethodInputKind.TextReader; inputExpr = p.Name; @@ -62,7 +63,7 @@ public static MethodSignatureBinding Bind( if (types.IsPipeReader(p.Type)) { if (inputKind != MethodInputKind.None) - return new MethodSignatureBinding(false, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, new DuplicateInput(p, inputKind, p.Locations.FirstOrDefault())); + return new MethodSignatureBinding(returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, new DuplicateInput(p, inputKind, p.Locations.FirstOrDefault())); inputKind = MethodInputKind.PipeReader; inputExpr = p.Name; @@ -72,10 +73,10 @@ public static MethodSignatureBinding Bind( if (types.IsTextWriter(p.Type)) { if (IsOutputReturning(returnKind)) - return new MethodSignatureBinding(false, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, new ReturnOutputConflict(p, p.Locations.FirstOrDefault())); + return new MethodSignatureBinding(returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, new ReturnOutputConflict(p, p.Locations.FirstOrDefault())); if (outputKind != MethodOutputKind.None) - return new MethodSignatureBinding(false, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, new DuplicateOutput(p, outputKind, p.Locations.FirstOrDefault())); + return new MethodSignatureBinding(returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, new DuplicateOutput(p, outputKind, p.Locations.FirstOrDefault())); outputKind = MethodOutputKind.TextWriter; outputExpr = p.Name; @@ -85,10 +86,10 @@ public static MethodSignatureBinding Bind( if (types.IsPipeWriter(p.Type)) { if (IsOutputReturning(returnKind)) - return new MethodSignatureBinding(false, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, new ReturnOutputConflict(p, p.Locations.FirstOrDefault())); + return new MethodSignatureBinding(returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, new ReturnOutputConflict(p, p.Locations.FirstOrDefault())); if (outputKind != MethodOutputKind.None) - return new MethodSignatureBinding(false, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, new DuplicateOutput(p, outputKind, p.Locations.FirstOrDefault())); + return new MethodSignatureBinding(returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, new DuplicateOutput(p, outputKind, p.Locations.FirstOrDefault())); outputKind = MethodOutputKind.PipeWriter; outputExpr = p.Name; @@ -98,7 +99,7 @@ public static MethodSignatureBinding Bind( if (types.IsCancellationToken(p.Type)) { if (cancellationTokenName != null) - return new MethodSignatureBinding(false, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, new DuplicateCancellationToken(p, p.Locations.FirstOrDefault())); + return new MethodSignatureBinding(returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, new DuplicateCancellationToken(p, p.Locations.FirstOrDefault())); cancellationTokenName = p.Name; continue; @@ -107,7 +108,7 @@ public static MethodSignatureBinding Bind( if (types.IsLogger(p.Type)) { if (loggerExpression != null) - return new MethodSignatureBinding(false, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, new DuplicateLogger(p, p.Locations.FirstOrDefault())); + return new MethodSignatureBinding(returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, new DuplicateLogger(p, p.Locations.FirstOrDefault())); loggerExpression = p.Name; isLoggerFromParameter = true; @@ -119,7 +120,7 @@ public static MethodSignatureBinding Bind( loggerExpression ??= FindLoggerInContainingType(method.ContainingType, method.IsStatic, types, out isLoggerFromParameter); - return new MethodSignatureBinding(true, returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, unhandledParameters); + return new MethodSignatureBinding(returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, unhandledParameters); } /// diff --git a/Generator.Abstractions/MethodSignatureBinding.cs b/Generator.Abstractions/MethodSignatureBinding.cs index 181502e..7ba77ef 100644 --- a/Generator.Abstractions/MethodSignatureBinding.cs +++ b/Generator.Abstractions/MethodSignatureBinding.cs @@ -8,7 +8,6 @@ namespace Esolang.Generator; /// /// Represents the result of binding a method signature for generation. /// -/// Whether the binding is successful. /// The return kind of the method. /// The input kind of the method. /// The output kind of the method. @@ -20,8 +19,8 @@ namespace Esolang.Generator; /// Parameters that were not handled by the common binding logic. /// The diagnostic error if the binding failed. [DebuggerDisplay("{ToString(),nq}")] +[ExcludeFromCodeCoverage] public record struct MethodSignatureBinding( - bool IsValid, MethodReturnKind ReturnKind, MethodInputKind InputKind, MethodOutputKind OutputKind, @@ -33,6 +32,8 @@ public record struct MethodSignatureBinding( IReadOnlyList UnhandledParameters, BindingError? Error = null) { + /// Whether the binding is successful. + public readonly bool IsValid => Error is null; /// Gets a value indicating whether the method has an explicit input mechanism. public readonly bool HasExplicitInput => InputKind != MethodInputKind.None; From 3605fb23b868dd5d847ccd4d83f300827afdbf24 Mon Sep 17 00:00:00 2001 From: juner Date: Sat, 30 May 2026 21:40:24 +0900 Subject: [PATCH 32/49] editorconfig editing... --- .editorconfig | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.editorconfig b/.editorconfig index fcd8f86..2703074 100644 --- a/.editorconfig +++ b/.editorconfig @@ -39,7 +39,7 @@ dotnet_style_parentheses_in_other_operators = never_if_unnecessary:warning dotnet_style_parentheses_in_relational_binary_operators = always_for_clarity:warning # Accessibility modifier settings -dotnet_style_require_accessibility_modifiers = for_non_interface_members +dotnet_style_require_accessibility_modifiers = omit_if_default # Expression-level preferences dotnet_style_coalesce_expression = true:warning From a597e2bf00b71fbf73f5637a1cf6a978f58f1e5f Mon Sep 17 00:00:00 2001 From: juner Date: Sat, 30 May 2026 21:51:12 +0900 Subject: [PATCH 33/49] =?UTF-8?q?IsValid=20=E3=81=AB=20MemberNotNullWhen?= =?UTF-8?q?=20=E3=81=AE=E4=BB=98=E4=B8=8E?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Directory.Build.targets | 1 + .../Esolang.Generator.Abstractions.csproj | 6 +++++- Generator.Abstractions/MethodSignatureBinding.cs | 1 + 3 files changed, 7 insertions(+), 1 deletion(-) diff --git a/Directory.Build.targets b/Directory.Build.targets index 3257744..23125f1 100644 --- a/Directory.Build.targets +++ b/Directory.Build.targets @@ -15,6 +15,7 @@ + diff --git a/Generator.Abstractions/Esolang.Generator.Abstractions.csproj b/Generator.Abstractions/Esolang.Generator.Abstractions.csproj index 9807533..8d6feff 100644 --- a/Generator.Abstractions/Esolang.Generator.Abstractions.csproj +++ b/Generator.Abstractions/Esolang.Generator.Abstractions.csproj @@ -7,7 +7,11 @@ - + + + all + runtime; build; native; contentfiles; analyzers + diff --git a/Generator.Abstractions/MethodSignatureBinding.cs b/Generator.Abstractions/MethodSignatureBinding.cs index 7ba77ef..77925ba 100644 --- a/Generator.Abstractions/MethodSignatureBinding.cs +++ b/Generator.Abstractions/MethodSignatureBinding.cs @@ -33,6 +33,7 @@ public record struct MethodSignatureBinding( BindingError? Error = null) { /// Whether the binding is successful. + [MemberNotNullWhen(false, nameof(Error))] public readonly bool IsValid => Error is null; /// Gets a value indicating whether the method has an explicit input mechanism. public readonly bool HasExplicitInput => InputKind != MethodInputKind.None; From 8e0d5c29fecb0fdd04c48008301e5786d7700d68 Mon Sep 17 00:00:00 2001 From: juner Date: Sat, 30 May 2026 21:53:26 +0900 Subject: [PATCH 34/49] =?UTF-8?q?=E4=B8=8D=E5=82=99=E3=81=AE=E4=BF=AE?= =?UTF-8?q?=E6=AD=A3?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Generator.Abstractions/MethodSignatureBinding.cs | 1 - 1 file changed, 1 deletion(-) diff --git a/Generator.Abstractions/MethodSignatureBinding.cs b/Generator.Abstractions/MethodSignatureBinding.cs index 77925ba..c3d594e 100644 --- a/Generator.Abstractions/MethodSignatureBinding.cs +++ b/Generator.Abstractions/MethodSignatureBinding.cs @@ -19,7 +19,6 @@ namespace Esolang.Generator; /// Parameters that were not handled by the common binding logic. /// The diagnostic error if the binding failed. [DebuggerDisplay("{ToString(),nq}")] -[ExcludeFromCodeCoverage] public record struct MethodSignatureBinding( MethodReturnKind ReturnKind, MethodInputKind InputKind, From 19015d2833e2d641d9930517df070faa3a3882ab Mon Sep 17 00:00:00 2001 From: juner Date: Sat, 30 May 2026 21:55:06 +0900 Subject: [PATCH 35/49] =?UTF-8?q?=E6=94=B9=E8=A1=8C=E3=81=AE=E8=BF=BD?= =?UTF-8?q?=E5=8A=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Generator.Abstractions/MethodSignatureBinding.cs | 1 + 1 file changed, 1 insertion(+) diff --git a/Generator.Abstractions/MethodSignatureBinding.cs b/Generator.Abstractions/MethodSignatureBinding.cs index c3d594e..fd59eef 100644 --- a/Generator.Abstractions/MethodSignatureBinding.cs +++ b/Generator.Abstractions/MethodSignatureBinding.cs @@ -34,6 +34,7 @@ public record struct MethodSignatureBinding( /// Whether the binding is successful. [MemberNotNullWhen(false, nameof(Error))] public readonly bool IsValid => Error is null; + /// Gets a value indicating whether the method has an explicit input mechanism. public readonly bool HasExplicitInput => InputKind != MethodInputKind.None; From a6518b2fc3d8b35a867106a9bb9336fcd763aea4 Mon Sep 17 00:00:00 2001 From: juner Date: Mon, 1 Jun 2026 05:51:09 +0900 Subject: [PATCH 36/49] =?UTF-8?q?=E3=82=BD=E3=83=BC=E3=83=88?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Directory.Build.targets | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/Directory.Build.targets b/Directory.Build.targets index 23125f1..86613d0 100644 --- a/Directory.Build.targets +++ b/Directory.Build.targets @@ -5,9 +5,6 @@ - - - @@ -16,6 +13,9 @@ + + + From d803cc2ee2663b43863d72b73ca3c01a34ff45c2 Mon Sep 17 00:00:00 2001 From: juner Date: Mon, 1 Jun 2026 10:54:43 +0900 Subject: [PATCH 37/49] Refactor: IO extensions into Esolang.Processor.Extensions.IO project - Moved Pipe, Text, and String extensions to new project - Separated System.IO.Pipelines dependency - Updated documentation and solution configuration --- Esolang.Abstractions.code-workspace | 12 +- Esolang.Abstractions.slnx | 15 +- .../TextProcessorExtensionsTests.cs | 145 ------------------ .../Esolang.Processor.Abstractions.csproj | 2 +- Processor.Abstractions/README.md | 12 +- ...olang.Processor.Extensions.IO.Tests.csproj | 4 +- .../PipeProcessorExtensionsTests.cs | 2 + .../Esolang.Processor.Extensions.IO.csproj | 21 +++ .../PipeProcessorExtensions.cs | 1 + .../StringProcessorExtensions.cs | 85 ++++++++++ .../TextProcessorExtensions.cs | 2 +- Processor.Extensions.Pipelines/README.md | 23 +++ 12 files changed, 157 insertions(+), 167 deletions(-) delete mode 100644 Processor.Abstractions.Tests/TextProcessorExtensionsTests.cs rename Processor.Abstractions.Tests/Esolang.Processor.Abstractions.Tests.csproj => Processor.Extensions.IO.Tests/Esolang.Processor.Extensions.IO.Tests.csproj (78%) rename {Processor.Abstractions.Tests => Processor.Extensions.IO.Tests}/PipeProcessorExtensionsTests.cs (95%) create mode 100644 Processor.Extensions.IO/Esolang.Processor.Extensions.IO.csproj rename {Processor.Abstractions => Processor.Extensions.IO}/PipeProcessorExtensions.cs (96%) create mode 100644 Processor.Extensions.IO/StringProcessorExtensions.cs rename {Processor.Abstractions => Processor.Extensions.IO}/TextProcessorExtensions.cs (96%) create mode 100644 Processor.Extensions.Pipelines/README.md diff --git a/Esolang.Abstractions.code-workspace b/Esolang.Abstractions.code-workspace index 41b56d8..510d596 100644 --- a/Esolang.Abstractions.code-workspace +++ b/Esolang.Abstractions.code-workspace @@ -17,8 +17,12 @@ "name": "Esolang.Processor.Abstractions" }, { - "path": "Processor.Abstractions.Tests", - "name": "Esolang.Processor.Abstractions.Tests" + "path": "Processor.Extensions.IO", + "name": "Esolang.Processor.Extensions.IO" + }, + { + "path": "Processor.Extensions.IO.Tests", + "name": "Esolang.Processor.Extensions.IO.Tests" } ], "settings": { @@ -31,7 +35,9 @@ "Generator.Abstractions": true, "Generator.Abstractions.Tests": true, "Processor.Abstractions": true, - "Processor.Abstractions.Tests": true + "Processor.Abstractions.Tests": true, + "Processor.Extensions.IO": true, + "Processor.Extensions.IO.Tests": true } } } \ No newline at end of file diff --git a/Esolang.Abstractions.slnx b/Esolang.Abstractions.slnx index 6b4eaa0..6765720 100644 --- a/Esolang.Abstractions.slnx +++ b/Esolang.Abstractions.slnx @@ -1,11 +1,5 @@ - - - - - - - + @@ -17,6 +11,9 @@ - + + - \ No newline at end of file + + + diff --git a/Processor.Abstractions.Tests/TextProcessorExtensionsTests.cs b/Processor.Abstractions.Tests/TextProcessorExtensionsTests.cs deleted file mode 100644 index 3cb09fa..0000000 --- a/Processor.Abstractions.Tests/TextProcessorExtensionsTests.cs +++ /dev/null @@ -1,145 +0,0 @@ -namespace Esolang.Processor.Tests; - -[TestClass] -public class TextProcessorExtensionsTests(TestContext TestContext) -{ - CancellationToken CancellationToken => TestContext.CancellationToken; - - class MockEventProcessor(List events) : IEventProcessor - { - public async IAsyncEnumerable RunAsyncEnumerable([System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken cancellationToken = default) - { - foreach (var ev in events) - { - yield return ev; - } - await Task.CompletedTask; - } - } - - [TestMethod] - [Timeout(Constants.Timeout, CooperativeCancellation = true)] - public async Task RunToEndAsync_HandlesOutputCharEvent() - { - var processor = new MockEventProcessor([new OutputCharEvent('A'), new EndEvent(0)]); - using var writer = new StringWriter(); - - var exitCode = await TextProcessorExtensions.RunToEndAsync(processor, null, writer, CancellationToken); - - Assert.AreEqual("A", writer.ToString()); - Assert.AreEqual(0, exitCode); - } - - [TestMethod] - [Timeout(Constants.Timeout, CooperativeCancellation = true)] - public async Task RunToEndAsync_HandlesOutputIntEvent() - { - var processor = new MockEventProcessor([new OutputIntEvent(123), new EndEvent(0)]); - using var writer = new StringWriter(); - - var exitCode = await TextProcessorExtensions.RunToEndAsync(processor, null, writer, CancellationToken); - - Assert.AreEqual("123" + Environment.NewLine, writer.ToString()); - Assert.AreEqual(0, exitCode); - } - - [TestMethod] - [Timeout(Constants.Timeout, CooperativeCancellation = true)] - public async Task RunToEndAsync_HandlesInputCharEvent() - { - var capturedChar = ' '; - var processor = new MockEventProcessor([ - new TestInputCharEvent(c => capturedChar = c), - new EndEvent(0) - ]); - - using var reader = new StringReader("X"); - await TextProcessorExtensions.RunToEndAsync(processor, reader, null, CancellationToken); - - Assert.AreEqual('X', capturedChar); - } - - [TestMethod] - [Timeout(Constants.Timeout, CooperativeCancellation = true)] - public async Task RunToEndAsync_HandlesInputIntEvent() - { - var capturedInt = 0; - var processor = new MockEventProcessor([ - new TestInputIntEvent(i => capturedInt = i), - new EndEvent(0) - ]); - - using var reader = new StringReader("123"); - await TextProcessorExtensions.RunToEndAsync(processor, reader, null, CancellationToken); - - Assert.AreEqual(123, capturedInt); - } - - [TestMethod] - [Timeout(Constants.Timeout, CooperativeCancellation = true)] - public async Task RunToEndAsync_ThrowsArgumentNullExceptionOnNullInput() - { - var processor = new MockEventProcessor([new InputCharEventMock()]); - await Assert.ThrowsAsync(() => TextProcessorExtensions.RunToEndAsync(processor, null, null, CancellationToken).AsTask()); - } - - [TestMethod] - [Timeout(Constants.Timeout, CooperativeCancellation = true)] - public async Task RunToEndAsync_ThrowsArgumentNullExceptionOnNullOutput() - { - var processor = new MockEventProcessor([new OutputCharEvent('A')]); - await Assert.ThrowsAsync(() => TextProcessorExtensions.RunToEndAsync(processor, null, null, CancellationToken).AsTask()); - } - - [TestMethod] - [Timeout(Constants.Timeout, CooperativeCancellation = true)] - public async Task RunToEndAsync_ThrowsArgumentNullExceptionOnNullInput_InputInt() - { - var processor = new MockEventProcessor([new InputIntEventMock()]); - await Assert.ThrowsAsync(() => TextProcessorExtensions.RunToEndAsync(processor, null, null, CancellationToken).AsTask()); - } - - [TestMethod] - [Timeout(Constants.Timeout, CooperativeCancellation = true)] - public async Task RunToEndAsync_ThrowsArgumentNullExceptionOnNullOutput_OutputInt() - { - var processor = new MockEventProcessor([new OutputIntEvent(123)]); - await Assert.ThrowsAsync(() => TextProcessorExtensions.RunToEndAsync(processor, null, null, CancellationToken).AsTask()); - } - - [TestMethod] - [Timeout(Constants.Timeout, CooperativeCancellation = true)] - public void RunToEnd_HandlesEndEvent() - { - var processor = new MockEventProcessor([new EndEvent(88)]); -#pragma warning disable CS0618 - var exitCode = TextProcessorExtensions.RunToEnd(processor, null, null, CancellationToken); -#pragma warning restore CS0618 - Assert.AreEqual(88, exitCode); - } - - class TestInputCharEvent(Action write) : InputCharEvent - { - public override void Write(char c) => write(c); - } - - class TestInputIntEvent(Action write) : InputIntEvent - { - public override void Write(int i) => write(i); - } - - class InputCharEventMock : InputCharEvent - { - public override void Write(char c) { } - } - - class InputIntEventMock : InputIntEvent - { - public override void Write(int i) { } - } -} - -file static class Constants -{ - public const int Timeout = 2000; -} diff --git a/Processor.Abstractions/Esolang.Processor.Abstractions.csproj b/Processor.Abstractions/Esolang.Processor.Abstractions.csproj index b9fa140..c68fdac 100644 --- a/Processor.Abstractions/Esolang.Processor.Abstractions.csproj +++ b/Processor.Abstractions/Esolang.Processor.Abstractions.csproj @@ -12,7 +12,7 @@ - + diff --git a/Processor.Abstractions/README.md b/Processor.Abstractions/README.md index 135db93..8c59973 100644 --- a/Processor.Abstractions/README.md +++ b/Processor.Abstractions/README.md @@ -42,10 +42,9 @@ public interface IEventProcessor : IProcessor ## Extension Methods -To facilitate running processors with common I/O types, we provide extension methods: +To facilitate running processors, common extension methods are provided in separate packages: -- **`TextProcessorExtensions`**: For `TextReader` and `TextWriter`. -- **`PipeProcessorExtensions`**: For `PipeReader` and `PipeWriter`. +- **`Esolang.Processor.Extensions.IO`**: Contains `TextProcessorExtensions` (for `TextReader`/`TextWriter`), `StringProcessorExtensions` (for `string`/`StringBuilder`), and `PipeProcessorExtensions` (for `PipeReader`/`PipeWriter`). ```csharp // Example using TextReader/TextWriter @@ -53,6 +52,9 @@ await processor.RunToEndAsync(inputReader, outputWriter, cancellationToken); // Example using PipeReader/PipeWriter await processor.RunToEndAsync(inputPipe, outputPipe, cancellationToken); + +// Example using string input/output +var result = await processor.RunToStringAsync(input: "your_input", cancellationToken); ``` ## Usage Example @@ -77,10 +79,6 @@ public class MyEsolangProcessor : IEventProcessor - **netstandard2.0** — Compatible with .NET Framework 4.6.1+ and .NET Core 2.0+ -## Dependencies - -- **System.IO.Pipelines** — High-performance I/O primitives - ## See Also - [Esolang.Funge](https://github.com/Esolang-NET/Funge) — Funge-98 implementation diff --git a/Processor.Abstractions.Tests/Esolang.Processor.Abstractions.Tests.csproj b/Processor.Extensions.IO.Tests/Esolang.Processor.Extensions.IO.Tests.csproj similarity index 78% rename from Processor.Abstractions.Tests/Esolang.Processor.Abstractions.Tests.csproj rename to Processor.Extensions.IO.Tests/Esolang.Processor.Extensions.IO.Tests.csproj index 3767fcf..6e2157f 100644 --- a/Processor.Abstractions.Tests/Esolang.Processor.Abstractions.Tests.csproj +++ b/Processor.Extensions.IO.Tests/Esolang.Processor.Extensions.IO.Tests.csproj @@ -4,7 +4,7 @@ net48;net9.0;net10.0 net9.0;net10.0 Esolang.Processor.Tests - Esolang.Processor.Abstractions.Tests + Esolang.Processor.Extensions.IO.Tests @@ -13,6 +13,7 @@ + @@ -20,6 +21,7 @@ + diff --git a/Processor.Abstractions.Tests/PipeProcessorExtensionsTests.cs b/Processor.Extensions.IO.Tests/PipeProcessorExtensionsTests.cs similarity index 95% rename from Processor.Abstractions.Tests/PipeProcessorExtensionsTests.cs rename to Processor.Extensions.IO.Tests/PipeProcessorExtensionsTests.cs index 527ce10..6288cb4 100644 --- a/Processor.Abstractions.Tests/PipeProcessorExtensionsTests.cs +++ b/Processor.Extensions.IO.Tests/PipeProcessorExtensionsTests.cs @@ -117,7 +117,9 @@ public async Task RunToEndAsync_HandlesInputIntEvent() public void RunToEnd_HandlesEndEvent() { var processor = new MockEventProcessor([new EndEvent(99)]); +#pragma warning disable CS0618 // 型またはメンバーが旧型式です var exitCode = PipeProcessorExtensions.RunToEnd(processor, null, null, CancellationToken); +#pragma warning restore CS0618 // 型またはメンバーが旧型式です Assert.AreEqual(99, exitCode); } diff --git a/Processor.Extensions.IO/Esolang.Processor.Extensions.IO.csproj b/Processor.Extensions.IO/Esolang.Processor.Extensions.IO.csproj new file mode 100644 index 0000000..bced797 --- /dev/null +++ b/Processor.Extensions.IO/Esolang.Processor.Extensions.IO.csproj @@ -0,0 +1,21 @@ + + + + netstandard2.0;netstandard2.1 + enable + true + System.IO.Pipelines, Text and String extension methods for esolang processors. + Esolang.Processor.Extensions.IO + esolang;processor;io;pipelines;text;abstractions + Esolang.Processor + + + + + + + + + + + diff --git a/Processor.Abstractions/PipeProcessorExtensions.cs b/Processor.Extensions.IO/PipeProcessorExtensions.cs similarity index 96% rename from Processor.Abstractions/PipeProcessorExtensions.cs rename to Processor.Extensions.IO/PipeProcessorExtensions.cs index 197e666..3d6e968 100644 --- a/Processor.Abstractions/PipeProcessorExtensions.cs +++ b/Processor.Extensions.IO/PipeProcessorExtensions.cs @@ -95,6 +95,7 @@ public static async ValueTask RunToEndAsync( /// The output pipe writer. /// The cancellation token. /// The exit code. + [Obsolete($"Use {nameof(RunToEndAsync)} instead.")] public static int RunToEnd( this IEventProcessor processor, PipeReader? input = null, diff --git a/Processor.Extensions.IO/StringProcessorExtensions.cs b/Processor.Extensions.IO/StringProcessorExtensions.cs new file mode 100644 index 0000000..4b0b313 --- /dev/null +++ b/Processor.Extensions.IO/StringProcessorExtensions.cs @@ -0,0 +1,85 @@ +using System.Text; + +namespace Esolang.Processor; + +/// +/// Provides extension methods for running using and . +/// +public static class StringProcessorExtensions +{ + /// + /// Executes the processor until it reaches an and returns the output as a string. + /// + /// The event processor. + /// The input string. + /// The cancellation token. + /// The output string. + public static async ValueTask RunToStringAsync( + this IEventProcessor processor, + string? input = null, + CancellationToken cancellationToken = default) + { + var output = new StringBuilder(); + await processor.RunToEndAsync(input, output, cancellationToken); + return output.ToString(); + } + + /// + /// Executes the processor synchronously until it reaches an and returns the output as a string. + /// + /// The event processor. + /// The input string. + /// The cancellation token. + /// The output string. + [Obsolete($"Use {nameof(RunToStringAsync)} instead.")] + public static string? RunToString( + this IEventProcessor processor, + string? input = null, + CancellationToken cancellationToken = default) + { + var result = processor.RunToStringAsync(input, cancellationToken); + if (result.IsCompleted) + return result.GetAwaiter().GetResult(); + return result.AsTask().GetAwaiter().GetResult(); + } + + /// + /// Executes the processor until it reaches an . + /// + /// The event processor. + /// The input string. + /// The output string builder. + /// The cancellation token. + /// The exit code. + public static async ValueTask RunToEndAsync( + this IEventProcessor processor, + string? input = null, + StringBuilder? output = null, + CancellationToken cancellationToken = default) + { + using var reader = input != null ? new StringReader(input) : null; + using var writer = output != null ? new StringWriter(output) : null; + return await processor.RunToEndAsync(reader, writer, cancellationToken); + } + + /// + /// Executes the processor synchronously until it reaches an . + /// + /// The event processor. + /// The input string. + /// The output string builder. + /// The cancellation token. + /// The exit code. + [Obsolete($"Use {nameof(RunToEndAsync)} instead.")] + public static int RunToEnd( + this IEventProcessor processor, + string? input = null, + StringBuilder? output = null, + CancellationToken cancellationToken = default) + { + var result = processor.RunToEndAsync(input, output, cancellationToken); + if (result.IsCompleted) + return result.GetAwaiter().GetResult(); + return result.AsTask().GetAwaiter().GetResult(); + } +} diff --git a/Processor.Abstractions/TextProcessorExtensions.cs b/Processor.Extensions.IO/TextProcessorExtensions.cs similarity index 96% rename from Processor.Abstractions/TextProcessorExtensions.cs rename to Processor.Extensions.IO/TextProcessorExtensions.cs index ba9bf71..e41ecc6 100644 --- a/Processor.Abstractions/TextProcessorExtensions.cs +++ b/Processor.Extensions.IO/TextProcessorExtensions.cs @@ -94,7 +94,7 @@ public static async ValueTask RunToEndAsync( /// The output text writer. /// The cancellation token. /// The exit code. - [Obsolete("Use RunToEndAsync instead.")] + [Obsolete($"Use {nameof(RunToEndAsync)} instead.")] public static int RunToEnd( this IEventProcessor processor, TextReader? input = null, diff --git a/Processor.Extensions.Pipelines/README.md b/Processor.Extensions.Pipelines/README.md new file mode 100644 index 0000000..230c3cb --- /dev/null +++ b/Processor.Extensions.Pipelines/README.md @@ -0,0 +1,23 @@ +# Esolang.Processor.Extensions.IO + +Provides extension methods for running `IEventProcessor` using various I/O abstractions. + +## Features + +- **Text I/O**: Extension methods for `TextReader` and `TextWriter`. +- **String I/O**: Convenient extension methods for handling `string` input and `StringBuilder` output. +- **Pipe I/O**: Extension methods for high-performance `PipeReader` and `PipeWriter` from `System.IO.Pipelines`. + +## Usage + +Depending on your needs, you can use these extensions to run processors seamlessly: + +```csharp +// Example using string input/output +var exitCode = await processor.RunToEndAsync(input: "your_input", output: stringBuilder); + +// Example using string result +var result = await processor.RunToStringAsync(input: "your_input"); +``` + +For more advanced I/O, utilize the text or pipe extensions. From a348edeba737303ff920d7580f09c3b539fe8578 Mon Sep 17 00:00:00 2001 From: juner Date: Mon, 1 Jun 2026 13:27:02 +0900 Subject: [PATCH 38/49] Fix: Re-integrate tests for IO extensions - Corrected namespace and reference issues - Disabled IDE0005 for test project to resolve build conflicts - Re-verified test pass status --- Processor.Abstractions/IOEvent.cs | 106 ++++++++++++++++++ Processor.Abstractions/IProcessor.cs | 68 ----------- ...olang.Processor.Extensions.IO.Tests.csproj | 1 + .../PipeProcessorExtensionsTests.cs | 53 ++++----- .../StringProcessorExtensionsTests.cs | 68 +++++++++++ .../TextProcessorExtensionsTests.cs | 95 ++++++++++++++++ .../PipeProcessorExtensions.cs | 3 +- .../StringProcessorExtensions.cs | 3 +- .../TextProcessorExtensions.cs | 5 +- 9 files changed, 298 insertions(+), 104 deletions(-) create mode 100644 Processor.Abstractions/IOEvent.cs create mode 100644 Processor.Extensions.IO.Tests/StringProcessorExtensionsTests.cs create mode 100644 Processor.Extensions.IO.Tests/TextProcessorExtensionsTests.cs diff --git a/Processor.Abstractions/IOEvent.cs b/Processor.Abstractions/IOEvent.cs new file mode 100644 index 0000000..5c4ba58 --- /dev/null +++ b/Processor.Abstractions/IOEvent.cs @@ -0,0 +1,106 @@ +namespace Esolang.Processor; + +/// +/// Represents an I/O event. +/// +public abstract class IOEvent +{ + IOEvent() {} + + /// + /// Creates an event requesting a character input. + /// + /// The action to write the input character to the processor. + /// An event requesting a character input. + public static InputCharEvent InputChar(Action write) => new(write); + + /// + /// Creates an event requesting an integer input. + /// + /// The action to write the input integer to the processor. + /// An event requesting an integer input. + public static InputIntEvent InputInt(Action write) => new(write); + + /// + /// Creates an event that outputs a character. + /// + /// The character to output. + /// An event that outputs a character. + public static OutputCharEvent OutputChar(char output) => new(output); + + /// + /// Creates an event that outputs an integer. + /// + /// The integer to output. + /// An event that outputs an integer. + public static OutputIntEvent OutputInt(int output) => new(output); + + /// + /// Creates an event indicating the end of execution. + /// + /// The exit code. + /// An event indicating the end of execution. + public static EndEvent End(int exitCode) => new(exitCode); + + /// + /// Represents an event requesting a character input. + /// + public sealed class InputCharEvent(Action write) : IOEvent + { + /// + /// Writes the input character to the processor. + /// + /// The input character. + public void Write(char c) => write(c); + } + + /// + /// Represents an event requesting an integer input. + /// + /// The action to write the input integer to the processor. + public sealed class InputIntEvent(Action write) : IOEvent + { + /// + /// Writes the input integer to the processor. + /// + /// The input integer. + public void Write(int i) => write(i); + } + + /// + /// Represents an event that outputs a character. + /// + /// The character to output. + public sealed class OutputCharEvent(char Output) : IOEvent + { + /// + /// The character to output. + /// + public char Output { get; } = Output; + } + + /// + /// Represents an event that outputs an integer. + /// + /// The integer to output. + public sealed class OutputIntEvent(int Output) : IOEvent + { + /// + /// The integer to output. + /// + public int Output { get; } = Output; + } + + /// + /// Represents an event indicating the end of execution. + /// + /// The exit code. + public sealed class EndEvent(int exitCode) : IOEvent + { + /// + /// The exit code. + /// + public int ExitCode { get; } = exitCode; + } + +} diff --git a/Processor.Abstractions/IProcessor.cs b/Processor.Abstractions/IProcessor.cs index 8b097bf..3ec3464 100644 --- a/Processor.Abstractions/IProcessor.cs +++ b/Processor.Abstractions/IProcessor.cs @@ -28,71 +28,3 @@ public interface IEventProcessor : IProcessor IAsyncEnumerable RunAsyncEnumerable( CancellationToken cancellationToken = default); } - -/// -/// Represents an I/O event. -/// -public interface IOEvent -{ - -} - -/// -/// Represents an event requesting a character input. -/// -public abstract class InputCharEvent : IOEvent -{ - /// - /// Writes the input character to the processor. - /// - /// The input character. - public abstract void Write(char c); -} - -/// -/// Represents an event requesting an integer input. -/// -public abstract class InputIntEvent : IOEvent -{ - /// - /// Writes the input integer to the processor. - /// - /// The input integer. - public abstract void Write(int i); -} - -/// -/// Represents an event that outputs a character. -/// -/// The character to output. -public sealed class OutputCharEvent(char Output) : IOEvent -{ - /// - /// The character to output. - /// - public char Output { get; } = Output; -} - -/// -/// Represents an event that outputs an integer. -/// -/// The integer to output. -public sealed class OutputIntEvent(int Output) : IOEvent -{ - /// - /// The integer to output. - /// - public int Output { get; } = Output; -} - -/// -/// Represents an event indicating the end of execution. -/// -/// The exit code. -public sealed class EndEvent(int exitCode) : IOEvent -{ - /// - /// The exit code. - /// - public int ExitCode { get; } = exitCode; -} diff --git a/Processor.Extensions.IO.Tests/Esolang.Processor.Extensions.IO.Tests.csproj b/Processor.Extensions.IO.Tests/Esolang.Processor.Extensions.IO.Tests.csproj index 6e2157f..c48bbe9 100644 --- a/Processor.Extensions.IO.Tests/Esolang.Processor.Extensions.IO.Tests.csproj +++ b/Processor.Extensions.IO.Tests/Esolang.Processor.Extensions.IO.Tests.csproj @@ -5,6 +5,7 @@ net9.0;net10.0 Esolang.Processor.Tests Esolang.Processor.Extensions.IO.Tests + $(NoWarn);IDE0005 diff --git a/Processor.Extensions.IO.Tests/PipeProcessorExtensionsTests.cs b/Processor.Extensions.IO.Tests/PipeProcessorExtensionsTests.cs index 6288cb4..6d33bb9 100644 --- a/Processor.Extensions.IO.Tests/PipeProcessorExtensionsTests.cs +++ b/Processor.Extensions.IO.Tests/PipeProcessorExtensionsTests.cs @@ -1,6 +1,9 @@ +using Esolang.Processor; +using Esolang.Processor.Extensions.IO; using System.Buffers; using System.IO.Pipelines; using System.Text; +using static Esolang.Processor.IOEvent; namespace Esolang.Processor.Tests; @@ -25,7 +28,7 @@ public async IAsyncEnumerable RunAsyncEnumerable([System.Runtime.Compil [Timeout(Constants.Timeout, CooperativeCancellation = true)] public async Task RunToEndAsync_HandlesEndEvent() { - var processor = new MockEventProcessor([new EndEvent(42)]); + var processor = new MockEventProcessor([End(42)]); var exitCode = await PipeProcessorExtensions.RunToEndAsync(processor, null, null, CancellationToken); Assert.AreEqual(42, exitCode); } @@ -34,7 +37,7 @@ public async Task RunToEndAsync_HandlesEndEvent() [Timeout(Constants.Timeout, CooperativeCancellation = true)] public async Task RunToEndAsync_HandlesOutputCharEvent() { - var processor = new MockEventProcessor([new OutputCharEvent('A'), new EndEvent(0)]); + var processor = new MockEventProcessor([OutputChar('A'), End(0)]); var pipe = new Pipe(); var readTask = Task.Run(async () => @@ -56,7 +59,7 @@ public async Task RunToEndAsync_HandlesOutputCharEvent() [Timeout(Constants.Timeout, CooperativeCancellation = true)] public async Task RunToEndAsync_HandlesOutputIntEvent() { - var processor = new MockEventProcessor([new OutputIntEvent(123), new EndEvent(0)]); + var processor = new MockEventProcessor([OutputInt(123), End(0)]); var pipe = new Pipe(); var readTask = Task.Run(async () => @@ -80,8 +83,8 @@ public async Task RunToEndAsync_HandlesInputCharEvent() { var capturedChar = ' '; var processor = new MockEventProcessor([ - new TestInputCharEvent(c => capturedChar = c), - new EndEvent(0) + InputChar(c => capturedChar = c), + End(0) ]); var pipe = new Pipe(); @@ -99,8 +102,8 @@ public async Task RunToEndAsync_HandlesInputIntEvent() { var capturedInt = 0; var processor = new MockEventProcessor([ - new TestInputIntEvent(i => capturedInt = i), - new EndEvent(0) + InputInt(i => capturedInt = i), + End(0) ]); var pipe = new Pipe(); @@ -116,7 +119,7 @@ public async Task RunToEndAsync_HandlesInputIntEvent() [Timeout(Constants.Timeout, CooperativeCancellation = true)] public void RunToEnd_HandlesEndEvent() { - var processor = new MockEventProcessor([new EndEvent(99)]); + var processor = new MockEventProcessor([End(99)]); #pragma warning disable CS0618 // 型またはメンバーが旧型式です var exitCode = PipeProcessorExtensions.RunToEnd(processor, null, null, CancellationToken); #pragma warning restore CS0618 // 型またはメンバーが旧型式です @@ -127,7 +130,10 @@ public void RunToEnd_HandlesEndEvent() [Timeout(Constants.Timeout, CooperativeCancellation = true)] public async Task RunToEndAsync_ThrowsArgumentNullExceptionOnNullReader() { - var processor = new MockEventProcessor([new InputCharEventMock()]); + var capturedChar = ' '; + var processor = new MockEventProcessor([ + InputChar(c => capturedChar = c) + ]); await Assert.ThrowsAsync(() => PipeProcessorExtensions.RunToEndAsync(processor, null, null, CancellationToken).AsTask()); } @@ -135,7 +141,7 @@ public async Task RunToEndAsync_ThrowsArgumentNullExceptionOnNullReader() [Timeout(Constants.Timeout, CooperativeCancellation = true)] public async Task RunToEndAsync_ThrowsArgumentNullExceptionOnNullWriter() { - var processor = new MockEventProcessor([new OutputCharEvent('A')]); + var processor = new MockEventProcessor([OutputChar('A')]); await Assert.ThrowsAsync(() => PipeProcessorExtensions.RunToEndAsync(processor, null, null, CancellationToken).AsTask()); } @@ -143,7 +149,10 @@ public async Task RunToEndAsync_ThrowsArgumentNullExceptionOnNullWriter() [Timeout(Constants.Timeout, CooperativeCancellation = true)] public async Task RunToEndAsync_ThrowsArgumentNullExceptionOnNullReader_InputInt() { - var processor = new MockEventProcessor([new InputIntEventMock()]); + var capturedInt = 0; + var processor = new MockEventProcessor([ + InputInt(i => capturedInt = i) + ]); await Assert.ThrowsAsync(() => PipeProcessorExtensions.RunToEndAsync(processor, null, null, CancellationToken).AsTask()); } @@ -151,29 +160,9 @@ public async Task RunToEndAsync_ThrowsArgumentNullExceptionOnNullReader_InputInt [Timeout(Constants.Timeout, CooperativeCancellation = true)] public async Task RunToEndAsync_ThrowsArgumentNullExceptionOnNullWriter_OutputInt() { - var processor = new MockEventProcessor([new OutputIntEvent(123)]); + var processor = new MockEventProcessor([OutputInt(123)]); await Assert.ThrowsAsync(() => PipeProcessorExtensions.RunToEndAsync(processor, null, null, CancellationToken).AsTask()); } - - class TestInputCharEvent(Action write) : InputCharEvent - { - public override void Write(char c) => write(c); - } - - class TestInputIntEvent(Action write) : InputIntEvent - { - public override void Write(int i) => write(i); - } - - class InputCharEventMock : InputCharEvent - { - public override void Write(char c) { } - } - - class InputIntEventMock : InputIntEvent - { - public override void Write(int i) { } - } } file static class Constants diff --git a/Processor.Extensions.IO.Tests/StringProcessorExtensionsTests.cs b/Processor.Extensions.IO.Tests/StringProcessorExtensionsTests.cs new file mode 100644 index 0000000..b2fcd80 --- /dev/null +++ b/Processor.Extensions.IO.Tests/StringProcessorExtensionsTests.cs @@ -0,0 +1,68 @@ +using Esolang.Processor; +using Esolang.Processor.Extensions.IO; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using System.Text; + +namespace Esolang.Processor.Tests; + +[TestClass] +public class StringProcessorExtensionsTests(TestContext TestContext) +{ + CancellationToken CancellationToken => TestContext.CancellationToken; + + class MockEventProcessor(List events) : IEventProcessor + { + public async IAsyncEnumerable RunAsyncEnumerable([System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken cancellationToken = default) + { + foreach (var ev in events) + { + yield return ev; + } + await Task.CompletedTask; + } + } + + [TestMethod] + [Timeout(2000, CooperativeCancellation = true)] + public async Task RunToStringAsync_ReturnsCorrectOutput() + { + var processor = new MockEventProcessor([ + IOEvent.OutputChar('H'), + IOEvent.OutputChar('i'), + IOEvent.End(0) + ]); + + var result = await StringProcessorExtensions.RunToStringAsync(processor, null, CancellationToken); + + Assert.AreEqual("Hi", result); + } + + [TestMethod] + [Timeout(2000, CooperativeCancellation = true)] + public void RunToString_ReturnsCorrectOutput() + { + var processor = new MockEventProcessor([ + IOEvent.OutputChar('A'), + IOEvent.OutputChar('B'), + IOEvent.End(0) + ]); + +#pragma warning disable CS0618 + var result = StringProcessorExtensions.RunToString(processor, null, CancellationToken); +#pragma warning restore CS0618 + Assert.AreEqual("AB", result); + } + + [TestMethod] + [Timeout(2000, CooperativeCancellation = true)] + public async Task RunToEndAsync_HandlesOutputCharEvent() + { + var processor = new MockEventProcessor([IOEvent.OutputChar('A'), IOEvent.End(0)]); + var output = new StringBuilder(); + + var exitCode = await StringProcessorExtensions.RunToEndAsync(processor, null, output, CancellationToken); + + Assert.AreEqual("A", output.ToString()); + Assert.AreEqual(0, exitCode); + } +} diff --git a/Processor.Extensions.IO.Tests/TextProcessorExtensionsTests.cs b/Processor.Extensions.IO.Tests/TextProcessorExtensionsTests.cs new file mode 100644 index 0000000..247bd26 --- /dev/null +++ b/Processor.Extensions.IO.Tests/TextProcessorExtensionsTests.cs @@ -0,0 +1,95 @@ +using Esolang.Processor; +using Esolang.Processor.Extensions.IO; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using System.IO; +using System.Text; +using static Esolang.Processor.IOEvent; + +namespace Esolang.Processor.Tests; + +[TestClass] +public class TextProcessorExtensionsTests(TestContext TestContext) +{ + CancellationToken CancellationToken => TestContext.CancellationToken; + + class MockEventProcessor(List events) : IEventProcessor + { + public async IAsyncEnumerable RunAsyncEnumerable([System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken cancellationToken = default) + { + foreach (var ev in events) + { + yield return ev; + } + await Task.CompletedTask; + } + } + + [TestMethod] + [Timeout(2000, CooperativeCancellation = true)] + public async Task RunToEndAsync_HandlesOutputCharEvent() + { + var processor = new MockEventProcessor([OutputChar('A'), End(0)]); + using var output = new StringWriter(); + + var exitCode = await TextProcessorExtensions.RunToEndAsync(processor, null, output, CancellationToken); + + Assert.AreEqual("A", output.ToString()); + Assert.AreEqual(0, exitCode); + } + + [TestMethod] + [Timeout(2000, CooperativeCancellation = true)] + public async Task RunToEndAsync_HandlesOutputIntEvent() + { + var processor = new MockEventProcessor([OutputInt(123), End(0)]); + using var output = new StringWriter(); + + var exitCode = await TextProcessorExtensions.RunToEndAsync(processor, null, output, CancellationToken); + + Assert.AreEqual("123", output.ToString()); + Assert.AreEqual(0, exitCode); + } + + [TestMethod] + [Timeout(2000, CooperativeCancellation = true)] + public async Task RunToEndAsync_HandlesInputCharEvent() + { + var capturedChar = ' '; + var processor = new MockEventProcessor([ + InputChar(c => capturedChar = c), + End(0) + ]); + using var input = new StringReader("X"); + + await TextProcessorExtensions.RunToEndAsync(processor, input, null, CancellationToken); + + Assert.AreEqual('X', capturedChar); + } + + [TestMethod] + [Timeout(2000, CooperativeCancellation = true)] + public async Task RunToEndAsync_HandlesInputIntEvent() + { + var capturedInt = 0; + var processor = new MockEventProcessor([ + InputInt(i => capturedInt = i), + End(0) + ]); + using var input = new StringReader("123"); + + await TextProcessorExtensions.RunToEndAsync(processor, input, null, CancellationToken); + + Assert.AreEqual(123, capturedInt); + } + + [TestMethod] + [Timeout(2000, CooperativeCancellation = true)] + public void RunToEnd_HandlesEndEvent() + { + var processor = new MockEventProcessor([End(88)]); +#pragma warning disable CS0618 + var exitCode = TextProcessorExtensions.RunToEnd(processor, null, null, CancellationToken); +#pragma warning restore CS0618 + Assert.AreEqual(88, exitCode); + } +} diff --git a/Processor.Extensions.IO/PipeProcessorExtensions.cs b/Processor.Extensions.IO/PipeProcessorExtensions.cs index 3d6e968..8946eff 100644 --- a/Processor.Extensions.IO/PipeProcessorExtensions.cs +++ b/Processor.Extensions.IO/PipeProcessorExtensions.cs @@ -1,8 +1,9 @@ using System.Buffers; using System.IO.Pipelines; using System.Text; +using static Esolang.Processor.IOEvent; -namespace Esolang.Processor; +namespace Esolang.Processor.Extensions.IO; /// /// Provides extension methods for running using and . diff --git a/Processor.Extensions.IO/StringProcessorExtensions.cs b/Processor.Extensions.IO/StringProcessorExtensions.cs index 4b0b313..8c8bcc1 100644 --- a/Processor.Extensions.IO/StringProcessorExtensions.cs +++ b/Processor.Extensions.IO/StringProcessorExtensions.cs @@ -1,6 +1,7 @@ using System.Text; +using static Esolang.Processor.IOEvent; -namespace Esolang.Processor; +namespace Esolang.Processor.Extensions.IO; /// /// Provides extension methods for running using and . diff --git a/Processor.Extensions.IO/TextProcessorExtensions.cs b/Processor.Extensions.IO/TextProcessorExtensions.cs index e41ecc6..4d61bac 100644 --- a/Processor.Extensions.IO/TextProcessorExtensions.cs +++ b/Processor.Extensions.IO/TextProcessorExtensions.cs @@ -1,6 +1,7 @@ using System.Buffers; +using static Esolang.Processor.IOEvent; -namespace Esolang.Processor; +namespace Esolang.Processor.Extensions.IO; /// /// Provides extension methods for running using and . @@ -75,7 +76,7 @@ public static async ValueTask RunToEndAsync( if (output is null) throw new ArgumentNullException(nameof(output)); { - await output.WriteLineAsync(intOutput.Output.ToString()).ConfigureAwait(false); + await output.WriteAsync(intOutput.Output.ToString()).ConfigureAwait(false); await output.FlushAsync().ConfigureAwait(false); } break; From 4e30134993968c93a5637d5796ea71d2a5520425 Mon Sep 17 00:00:00 2001 From: juner Date: Mon, 1 Jun 2026 13:28:44 +0900 Subject: [PATCH 39/49] =?UTF-8?q?=E5=90=8D=E5=89=8D=E7=A9=BA=E9=96=93?= =?UTF-8?q?=E3=81=AE=E8=AA=BF=E6=95=B4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Processor.Extensions.IO/Esolang.Processor.Extensions.IO.csproj | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Processor.Extensions.IO/Esolang.Processor.Extensions.IO.csproj b/Processor.Extensions.IO/Esolang.Processor.Extensions.IO.csproj index bced797..e0f37e2 100644 --- a/Processor.Extensions.IO/Esolang.Processor.Extensions.IO.csproj +++ b/Processor.Extensions.IO/Esolang.Processor.Extensions.IO.csproj @@ -7,7 +7,7 @@ System.IO.Pipelines, Text and String extension methods for esolang processors. Esolang.Processor.Extensions.IO esolang;processor;io;pipelines;text;abstractions - Esolang.Processor + Esolang.Processor.Extensions.IO From d18cfa5c87cbf124263794c104c880a25ef74eb2 Mon Sep 17 00:00:00 2001 From: juner Date: Mon, 1 Jun 2026 14:21:01 +0900 Subject: [PATCH 40/49] Feat: Add Esolang.Interpreter.Abstractions - Implemented InterpreterExtensions with RunToConsoleAsync - Integrated InteractiveConsoleReader for robust I/O handling - Added unit tests for interpreter extensions --- Esolang.Abstractions.code-workspace | 10 ++++ Esolang.Abstractions.slnx | 17 +++++-- ...lang.Interpreter.Abstractions.Tests.csproj | 27 ++++++++++ .../InterpreterExtensionsTests.cs | 47 +++++++++++++++++ .../Esolang.Interpreter.Abstractions.csproj | 18 +++++++ .../InterpreterExtensions.cs | 51 +++++++++++++++++++ 6 files changed, 165 insertions(+), 5 deletions(-) create mode 100644 Interpreter.Abstractions.Tests/Esolang.Interpreter.Abstractions.Tests.csproj create mode 100644 Interpreter.Abstractions.Tests/InterpreterExtensionsTests.cs create mode 100644 Interpreter.Abstractions/Esolang.Interpreter.Abstractions.csproj create mode 100644 Interpreter.Abstractions/InterpreterExtensions.cs diff --git a/Esolang.Abstractions.code-workspace b/Esolang.Abstractions.code-workspace index 510d596..34e7e66 100644 --- a/Esolang.Abstractions.code-workspace +++ b/Esolang.Abstractions.code-workspace @@ -12,6 +12,14 @@ "path": "Generator.Abstractions.Tests", "name": "Esolang.Generator.Abstractions.Tests" }, + { + "path": "Interpreter.Abstractions", + "name": "Esolang.Interpreter.Abstractions" + }, + { + "path": "Interpreter.Abstractions.Tests", + "name": "Esolang.Interpreter.Abstractions.Tests" + }, { "path": "Processor.Abstractions", "name": "Esolang.Processor.Abstractions" @@ -34,6 +42,8 @@ "**/Thumbs.db": true, "Generator.Abstractions": true, "Generator.Abstractions.Tests": true, + "Interpreter.Abstractions": true, + "Interpreter.Abstractions.Tests": true, "Processor.Abstractions": true, "Processor.Abstractions.Tests": true, "Processor.Extensions.IO": true, diff --git a/Esolang.Abstractions.slnx b/Esolang.Abstractions.slnx index 6765720..e275f57 100644 --- a/Esolang.Abstractions.slnx +++ b/Esolang.Abstractions.slnx @@ -1,5 +1,4 @@ - @@ -11,9 +10,17 @@ - - + + + + + + + + + + + - - + diff --git a/Interpreter.Abstractions.Tests/Esolang.Interpreter.Abstractions.Tests.csproj b/Interpreter.Abstractions.Tests/Esolang.Interpreter.Abstractions.Tests.csproj new file mode 100644 index 0000000..6f10817 --- /dev/null +++ b/Interpreter.Abstractions.Tests/Esolang.Interpreter.Abstractions.Tests.csproj @@ -0,0 +1,27 @@ + + + + net48;net9.0;net10.0 + net9.0;net10.0 + Esolang.Interpreter.Tests + Esolang.Interpreter.Abstractions.Tests + + + + + + + + + + + + + + + + + + + + diff --git a/Interpreter.Abstractions.Tests/InterpreterExtensionsTests.cs b/Interpreter.Abstractions.Tests/InterpreterExtensionsTests.cs new file mode 100644 index 0000000..2778ccf --- /dev/null +++ b/Interpreter.Abstractions.Tests/InterpreterExtensionsTests.cs @@ -0,0 +1,47 @@ +using Esolang.Processor; + +namespace Esolang.Interpreter.Tests; + +[TestClass] +public class InterpreterExtensionsTests(TestContext TestContext) +{ + CancellationToken CancellationToken => TestContext.CancellationToken; + + class MockEventProcessor(List events) : IEventProcessor + { + public async IAsyncEnumerable RunAsyncEnumerable([System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken cancellationToken = default) + { + foreach (var ev in events) + { + yield return ev; + } + await Task.CompletedTask; + } + } + + [TestMethod] + [Timeout(2000, CooperativeCancellation = true)] + public async Task RunToConsoleAsync_HandlesEndEvent() + { + var processor = new MockEventProcessor([IOEvent.End(0)]); + + // Redirect Console + using var stringReader = new StringReader(""); + using var stringWriter = new StringWriter(); + var originalIn = Console.In; + var originalOut = Console.Out; + Console.SetIn(stringReader); + Console.SetOut(stringWriter); + + try + { + var exitCode = await processor.RunToConsoleAsync(CancellationToken); + Assert.AreEqual(0, exitCode); + } + finally + { + Console.SetIn(originalIn); + Console.SetOut(originalOut); + } + } +} diff --git a/Interpreter.Abstractions/Esolang.Interpreter.Abstractions.csproj b/Interpreter.Abstractions/Esolang.Interpreter.Abstractions.csproj new file mode 100644 index 0000000..37f6081 --- /dev/null +++ b/Interpreter.Abstractions/Esolang.Interpreter.Abstractions.csproj @@ -0,0 +1,18 @@ + + + + netstandard2.0;netstandard2.1 + enable + true + Interpreter abstractions for Esolang processors. + Esolang.Interpreter.Abstractions + esolang;interpreter;abstractions + Esolang.Interpreter + + + + + + + + diff --git a/Interpreter.Abstractions/InterpreterExtensions.cs b/Interpreter.Abstractions/InterpreterExtensions.cs new file mode 100644 index 0000000..8f52c3b --- /dev/null +++ b/Interpreter.Abstractions/InterpreterExtensions.cs @@ -0,0 +1,51 @@ +using Esolang.Processor; +using Esolang.Processor.Extensions.IO; + +namespace Esolang.Interpreter; + +/// +/// Provides extension methods for running in an interpreter context. +/// +public static class InterpreterExtensions +{ + /// + /// Executes the processor using standard I/O (Console.In, Console.Out). + /// + /// The event processor. + /// The cancellation token. + /// The exit code. + public static async ValueTask RunToConsoleAsync( + this IEventProcessor processor, + CancellationToken cancellationToken = default) + { + // リダイレクトされていれば標準のReaderをそのまま使い、そうでなければカスタムリーダーを使う + using var reader = Console.IsInputRedirected ? Console.In : new InteractiveConsoleReader(cancellationToken); + return await processor.RunToEndAsync(reader, Console.Out, cancellationToken); + } +} + +sealed class InteractiveConsoleReader(CancellationToken cancellationToken) : TextReader +{ + public override int Read() + { + // キーが押されるまでループ待機 + while (!Console.KeyAvailable) + { + if (cancellationToken.IsCancellationRequested) return -1; + Thread.Sleep(10); + } + return Console.ReadKey(true).KeyChar; + } + + public override async Task ReadAsync(char[] buffer, int index, int count) + { + // 非同期コンテキストでも同様に待機 + while (!Console.KeyAvailable) + { + if (cancellationToken.IsCancellationRequested) return -1; + await Task.Delay(10, cancellationToken); + } + buffer[index] = Console.ReadKey(true).KeyChar; + return 1; + } +} From bd72f32f20bfc6a3323ebbb06a9e02f48c3c92cb Mon Sep 17 00:00:00 2001 From: juner Date: Mon, 1 Jun 2026 16:59:03 +0900 Subject: [PATCH 41/49] feat: ensure cooperative cancellation in RunToConsoleAsync --- ...lang.Interpreter.Abstractions.Tests.csproj | 3 +- .../InterpreterExtensionsTests.cs | 57 ++++++++++--------- .../Esolang.Interpreter.Abstractions.csproj | 5 +- .../InterpreterExtensions.cs | 55 ++++++++++-------- 4 files changed, 63 insertions(+), 57 deletions(-) diff --git a/Interpreter.Abstractions.Tests/Esolang.Interpreter.Abstractions.Tests.csproj b/Interpreter.Abstractions.Tests/Esolang.Interpreter.Abstractions.Tests.csproj index 6f10817..c7fc2e9 100644 --- a/Interpreter.Abstractions.Tests/Esolang.Interpreter.Abstractions.Tests.csproj +++ b/Interpreter.Abstractions.Tests/Esolang.Interpreter.Abstractions.Tests.csproj @@ -1,8 +1,7 @@ - net48;net9.0;net10.0 - net9.0;net10.0 + net10.0 Esolang.Interpreter.Tests Esolang.Interpreter.Abstractions.Tests diff --git a/Interpreter.Abstractions.Tests/InterpreterExtensionsTests.cs b/Interpreter.Abstractions.Tests/InterpreterExtensionsTests.cs index 2778ccf..2323018 100644 --- a/Interpreter.Abstractions.Tests/InterpreterExtensionsTests.cs +++ b/Interpreter.Abstractions.Tests/InterpreterExtensionsTests.cs @@ -1,4 +1,5 @@ using Esolang.Processor; +using static Esolang.Processor.IOEvent; namespace Esolang.Interpreter.Tests; @@ -7,6 +8,36 @@ public class InterpreterExtensionsTests(TestContext TestContext) { CancellationToken CancellationToken => TestContext.CancellationToken; + [TestMethod] + [Timeout(2000, CooperativeCancellation = true)] + public async Task RunToConsoleAsync_ProcessesAllEvents() + { + var output = new StringWriter(); + Console.SetOut(output); + + var capturedChar = ' '; + var capturedInt = 0; + + var processor = new MockEventProcessor([ + OutputChar('A'), + OutputInt(123), + InputChar(c => capturedChar = c), + InputInt(i => capturedInt = i), + End(0) + ]); + + // Input simulation for interactive mode + using var input = new StringReader("B" + "456" + Environment.NewLine); + Console.SetIn(input); + + var exitCode = await processor.RunToConsoleAsync(cancellationToken: CancellationToken); + + Assert.AreEqual(0, exitCode); + Assert.AreEqual("A123", output.ToString()); + Assert.AreEqual('B', capturedChar); + Assert.AreEqual(456, capturedInt); + } + class MockEventProcessor(List events) : IEventProcessor { public async IAsyncEnumerable RunAsyncEnumerable([System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken cancellationToken = default) @@ -18,30 +49,4 @@ public async IAsyncEnumerable RunAsyncEnumerable([System.Runtime.Compil await Task.CompletedTask; } } - - [TestMethod] - [Timeout(2000, CooperativeCancellation = true)] - public async Task RunToConsoleAsync_HandlesEndEvent() - { - var processor = new MockEventProcessor([IOEvent.End(0)]); - - // Redirect Console - using var stringReader = new StringReader(""); - using var stringWriter = new StringWriter(); - var originalIn = Console.In; - var originalOut = Console.Out; - Console.SetIn(stringReader); - Console.SetOut(stringWriter); - - try - { - var exitCode = await processor.RunToConsoleAsync(CancellationToken); - Assert.AreEqual(0, exitCode); - } - finally - { - Console.SetIn(originalIn); - Console.SetOut(originalOut); - } - } } diff --git a/Interpreter.Abstractions/Esolang.Interpreter.Abstractions.csproj b/Interpreter.Abstractions/Esolang.Interpreter.Abstractions.csproj index 37f6081..3d59745 100644 --- a/Interpreter.Abstractions/Esolang.Interpreter.Abstractions.csproj +++ b/Interpreter.Abstractions/Esolang.Interpreter.Abstractions.csproj @@ -1,9 +1,7 @@ - netstandard2.0;netstandard2.1 - enable - true + net10.0 Interpreter abstractions for Esolang processors. Esolang.Interpreter.Abstractions esolang;interpreter;abstractions @@ -12,7 +10,6 @@ - diff --git a/Interpreter.Abstractions/InterpreterExtensions.cs b/Interpreter.Abstractions/InterpreterExtensions.cs index 8f52c3b..8703575 100644 --- a/Interpreter.Abstractions/InterpreterExtensions.cs +++ b/Interpreter.Abstractions/InterpreterExtensions.cs @@ -1,5 +1,5 @@ using Esolang.Processor; -using Esolang.Processor.Extensions.IO; +using static Esolang.Processor.IOEvent; namespace Esolang.Interpreter; @@ -18,34 +18,39 @@ public static async ValueTask RunToConsoleAsync( this IEventProcessor processor, CancellationToken cancellationToken = default) { - // リダイレクトされていれば標準のReaderをそのまま使い、そうでなければカスタムリーダーを使う - using var reader = Console.IsInputRedirected ? Console.In : new InteractiveConsoleReader(cancellationToken); - return await processor.RunToEndAsync(reader, Console.Out, cancellationToken); - } -} - -sealed class InteractiveConsoleReader(CancellationToken cancellationToken) : TextReader -{ - public override int Read() - { - // キーが押されるまでループ待機 - while (!Console.KeyAvailable) + await foreach (var ioEvent in processor.RunAsyncEnumerable(cancellationToken)) { - if (cancellationToken.IsCancellationRequested) return -1; - Thread.Sleep(10); + switch (ioEvent) + { + case InputCharEvent charInput: + charInput.Write(await ReadCharFromConsoleAsync(cancellationToken)); + break; + case InputIntEvent intInput: + var line = await ReadLineFromConsoleAsync(cancellationToken); + if (int.TryParse(line, out var i)) + { + intInput.Write(i); + } + break; + case OutputCharEvent charOutput: + Console.Write(charOutput.Output); + break; + case OutputIntEvent intOutput: + Console.Write(intOutput.Output); + break; + case EndEvent end: + return end.ExitCode; + } } - return Console.ReadKey(true).KeyChar; + return 0; } - public override async Task ReadAsync(char[] buffer, int index, int count) + static async ValueTask ReadCharFromConsoleAsync(CancellationToken ct) { - // 非同期コンテキストでも同様に待機 - while (!Console.KeyAvailable) - { - if (cancellationToken.IsCancellationRequested) return -1; - await Task.Delay(10, cancellationToken); - } - buffer[index] = Console.ReadKey(true).KeyChar; - return 1; + ct.ThrowIfCancellationRequested(); + var c = Console.In.Read(); + return c == -1 ? '\0' : (char)c; } + + static async ValueTask ReadLineFromConsoleAsync(CancellationToken ct) => await Console.In.ReadLineAsync(ct); } From 67fe9a8b998689174b7c0abf3ebb219a910a9a2b Mon Sep 17 00:00:00 2001 From: juner Date: Mon, 1 Jun 2026 17:00:25 +0900 Subject: [PATCH 42/49] refactor: cleanup generator and processor abstractions --- Generator.Abstractions/BindingError.cs | 214 ++++----- Generator.Abstractions/IsExternalInit.cs | 22 +- Generator.Abstractions/MethodInputKind.cs | 32 +- Generator.Abstractions/MethodOutputKind.cs | 40 +- Generator.Abstractions/MethodReturnKind.cs | 76 +-- .../MethodSignatureBinder.cs | 450 +++++++++--------- Processor.Abstractions/IOEvent.cs | 2 +- 7 files changed, 418 insertions(+), 418 deletions(-) diff --git a/Generator.Abstractions/BindingError.cs b/Generator.Abstractions/BindingError.cs index ab269d8..e3823c1 100644 --- a/Generator.Abstractions/BindingError.cs +++ b/Generator.Abstractions/BindingError.cs @@ -1,107 +1,107 @@ -using Microsoft.CodeAnalysis; - -namespace Esolang.Generator; - -/// -/// Specifies the kind of diagnostic error that occurred during method signature binding. -/// -public enum BindingErrorKind -{ - /// The return type of the method is not supported. - UnsupportedReturnType, - /// A parameter has an invalid modifier (e.g., ref, out, in). - InvalidParameterModifier, - /// More than one parameter is competing for the same input role. - DuplicateInput, - /// More than one parameter is competing for the same output role. - DuplicateOutput, - /// More than one cancellation token parameter was found. - DuplicateCancellationToken, - /// More than one logger parameter was found. - DuplicateLogger, - /// A conflict exists between the return type and an output parameter. - ReturnOutputConflict, -} - -/// -/// Represents a diagnostic error that occurred during method signature binding. -/// -public abstract record BindingError -{ - /// - /// - /// - /// The kind of error. - /// The location associated with the error. - BindingError(BindingErrorKind Kind, Location? Location) : base() - => (this.Kind, this.Location) = (Kind, Location); - - /// - /// The kind of error. - /// - public BindingErrorKind Kind { get; } - - /// - /// The location associated with the error. - /// - public Location? Location { get; } - - /// - /// The return type of the method is not supported. - /// - /// The unsupported return type symbol. - /// The location of the return type. - public sealed record UnsupportedReturnType(ITypeSymbol ReturnType, Location? Location) - : BindingError(BindingErrorKind.UnsupportedReturnType, Location); - - /// - /// A parameter has an invalid modifier (e.g., ref, out, in). - /// - /// The parameter with the invalid modifier. - /// The location of the parameter. - public sealed record InvalidParameterModifier(IParameterSymbol Parameter, Location? Location) - : BindingError(BindingErrorKind.InvalidParameterModifier, Location); - - /// - /// More than one parameter is competing for the same input role. - /// - /// The parameter that caused the duplication. - /// The kind of input that was already assigned. - /// The location of the duplicate parameter. - public sealed record DuplicateInput(IParameterSymbol Parameter, MethodInputKind ExistingKind, Location? Location) - : BindingError(BindingErrorKind.DuplicateInput, Location); - - /// - /// More than one parameter is competing for the same output role. - /// - /// The parameter that caused the duplication. - /// The kind of output that was already assigned. - /// The location of the duplicate parameter. - public sealed record DuplicateOutput(IParameterSymbol Parameter, MethodOutputKind ExistingKind, Location? Location) - : BindingError(BindingErrorKind.DuplicateOutput, Location); - - /// - /// More than one cancellation token parameter was found. - /// - /// The duplicate cancellation token parameter. - /// The location of the duplicate parameter. - public sealed record DuplicateCancellationToken(IParameterSymbol Parameter, Location? Location) - : BindingError(BindingErrorKind.DuplicateCancellationToken, Location); - - /// - /// More than one logger parameter was found. - /// - /// The duplicate logger parameter. - /// The location of the duplicate parameter. - public sealed record DuplicateLogger(IParameterSymbol Parameter, Location? Location) - : BindingError(BindingErrorKind.DuplicateLogger, Location); - - /// - /// A conflict exists between the return type and an output parameter. - /// - /// The output parameter that conflicts with the return type. - /// The location of the conflicting parameter. - public sealed record ReturnOutputConflict(IParameterSymbol Parameter, Location? Location) - : BindingError(BindingErrorKind.ReturnOutputConflict, Location); - -} +using Microsoft.CodeAnalysis; + +namespace Esolang.Generator; + +/// +/// Specifies the kind of diagnostic error that occurred during method signature binding. +/// +public enum BindingErrorKind +{ + /// The return type of the method is not supported. + UnsupportedReturnType, + /// A parameter has an invalid modifier (e.g., ref, out, in). + InvalidParameterModifier, + /// More than one parameter is competing for the same input role. + DuplicateInput, + /// More than one parameter is competing for the same output role. + DuplicateOutput, + /// More than one cancellation token parameter was found. + DuplicateCancellationToken, + /// More than one logger parameter was found. + DuplicateLogger, + /// A conflict exists between the return type and an output parameter. + ReturnOutputConflict, +} + +/// +/// Represents a diagnostic error that occurred during method signature binding. +/// +public abstract record BindingError +{ + /// + /// + /// + /// The kind of error. + /// The location associated with the error. + BindingError(BindingErrorKind Kind, Location? Location) : base() + => (this.Kind, this.Location) = (Kind, Location); + + /// + /// The kind of error. + /// + public BindingErrorKind Kind { get; } + + /// + /// The location associated with the error. + /// + public Location? Location { get; } + + /// + /// The return type of the method is not supported. + /// + /// The unsupported return type symbol. + /// The location of the return type. + public sealed record UnsupportedReturnType(ITypeSymbol ReturnType, Location? Location) + : BindingError(BindingErrorKind.UnsupportedReturnType, Location); + + /// + /// A parameter has an invalid modifier (e.g., ref, out, in). + /// + /// The parameter with the invalid modifier. + /// The location of the parameter. + public sealed record InvalidParameterModifier(IParameterSymbol Parameter, Location? Location) + : BindingError(BindingErrorKind.InvalidParameterModifier, Location); + + /// + /// More than one parameter is competing for the same input role. + /// + /// The parameter that caused the duplication. + /// The kind of input that was already assigned. + /// The location of the duplicate parameter. + public sealed record DuplicateInput(IParameterSymbol Parameter, MethodInputKind ExistingKind, Location? Location) + : BindingError(BindingErrorKind.DuplicateInput, Location); + + /// + /// More than one parameter is competing for the same output role. + /// + /// The parameter that caused the duplication. + /// The kind of output that was already assigned. + /// The location of the duplicate parameter. + public sealed record DuplicateOutput(IParameterSymbol Parameter, MethodOutputKind ExistingKind, Location? Location) + : BindingError(BindingErrorKind.DuplicateOutput, Location); + + /// + /// More than one cancellation token parameter was found. + /// + /// The duplicate cancellation token parameter. + /// The location of the duplicate parameter. + public sealed record DuplicateCancellationToken(IParameterSymbol Parameter, Location? Location) + : BindingError(BindingErrorKind.DuplicateCancellationToken, Location); + + /// + /// More than one logger parameter was found. + /// + /// The duplicate logger parameter. + /// The location of the duplicate parameter. + public sealed record DuplicateLogger(IParameterSymbol Parameter, Location? Location) + : BindingError(BindingErrorKind.DuplicateLogger, Location); + + /// + /// A conflict exists between the return type and an output parameter. + /// + /// The output parameter that conflicts with the return type. + /// The location of the conflicting parameter. + public sealed record ReturnOutputConflict(IParameterSymbol Parameter, Location? Location) + : BindingError(BindingErrorKind.ReturnOutputConflict, Location); + +} diff --git a/Generator.Abstractions/IsExternalInit.cs b/Generator.Abstractions/IsExternalInit.cs index f76ff9f..9c1044d 100644 --- a/Generator.Abstractions/IsExternalInit.cs +++ b/Generator.Abstractions/IsExternalInit.cs @@ -1,11 +1,11 @@ -namespace System.Runtime.CompilerServices; - -#if !NET5_0_OR_GREATER -/// -/// Reserved to be used by the compiler for tracking metadata. -/// This class should not be used by developers in source code. -/// -static class IsExternalInit -{ -} -#endif +namespace System.Runtime.CompilerServices; + +#if !NET5_0_OR_GREATER +/// +/// Reserved to be used by the compiler for tracking metadata. +/// This class should not be used by developers in source code. +/// +static class IsExternalInit +{ +} +#endif diff --git a/Generator.Abstractions/MethodInputKind.cs b/Generator.Abstractions/MethodInputKind.cs index 940f224..30bea45 100644 --- a/Generator.Abstractions/MethodInputKind.cs +++ b/Generator.Abstractions/MethodInputKind.cs @@ -1,16 +1,16 @@ -namespace Esolang.Generator; - -/// -/// Specifies the input mechanism of the generated method. -/// -public enum MethodInputKind -{ - /// No explicit input mechanism. - None, - /// Input is provided via a string parameter. - String, - /// Input is provided via a TextReader parameter. - TextReader, - /// Input is provided via a PipeReader parameter. - PipeReader, -} +namespace Esolang.Generator; + +/// +/// Specifies the input mechanism of the generated method. +/// +public enum MethodInputKind +{ + /// No explicit input mechanism. + None, + /// Input is provided via a string parameter. + String, + /// Input is provided via a TextReader parameter. + TextReader, + /// Input is provided via a PipeReader parameter. + PipeReader, +} diff --git a/Generator.Abstractions/MethodOutputKind.cs b/Generator.Abstractions/MethodOutputKind.cs index b6d46d2..4d48f81 100644 --- a/Generator.Abstractions/MethodOutputKind.cs +++ b/Generator.Abstractions/MethodOutputKind.cs @@ -1,20 +1,20 @@ -namespace Esolang.Generator; - -/// -/// Specifies the output mechanism of the generated method. -/// -public enum MethodOutputKind -{ - /// No explicit output mechanism. - None, - /// Output is written to a TextWriter parameter. - TextWriter, - /// Output is written to a PipeWriter parameter. - PipeWriter, - /// Output is returned as a string. - ReturnString, - /// Output is yielded via IEnumerable<byte>. - ReturnIEnumerable, - /// Output is yielded via IAsyncEnumerable<byte>. - ReturnIAsyncEnumerable, -} +namespace Esolang.Generator; + +/// +/// Specifies the output mechanism of the generated method. +/// +public enum MethodOutputKind +{ + /// No explicit output mechanism. + None, + /// Output is written to a TextWriter parameter. + TextWriter, + /// Output is written to a PipeWriter parameter. + PipeWriter, + /// Output is returned as a string. + ReturnString, + /// Output is yielded via IEnumerable<byte>. + ReturnIEnumerable, + /// Output is yielded via IAsyncEnumerable<byte>. + ReturnIAsyncEnumerable, +} diff --git a/Generator.Abstractions/MethodReturnKind.cs b/Generator.Abstractions/MethodReturnKind.cs index e0c7f13..f2ae6f6 100644 --- a/Generator.Abstractions/MethodReturnKind.cs +++ b/Generator.Abstractions/MethodReturnKind.cs @@ -1,38 +1,38 @@ -namespace Esolang.Generator; - -/// -/// Specifies the return type of the generated method. -/// -public enum MethodReturnKind -{ - /// The return type is invalid or unsupported. - Invalid, - /// The method returns void. - Void, - /// The method returns int. - Int32, - /// The method returns string. - String, - /// The method returns string (nullable). - NullableString, - /// The method returns Task. - Task, - /// The method returns Task<int>. - TaskInt32, - /// The method returns Task<string>. - TaskString, - /// The method returns Task<string?>. - TaskNullableString, - /// The method returns ValueTask. - ValueTask, - /// The method returns ValueTask<int>. - ValueTaskInt32, - /// The method returns ValueTask<string>. - ValueTaskString, - /// The method returns ValueTask<string?>. - ValueTaskNullableString, - /// The method returns IEnumerable<byte>. - IEnumerableByte, - /// The method returns IAsyncEnumerable<byte>. - IAsyncEnumerableByte, -} +namespace Esolang.Generator; + +/// +/// Specifies the return type of the generated method. +/// +public enum MethodReturnKind +{ + /// The return type is invalid or unsupported. + Invalid, + /// The method returns void. + Void, + /// The method returns int. + Int32, + /// The method returns string. + String, + /// The method returns string (nullable). + NullableString, + /// The method returns Task. + Task, + /// The method returns Task<int>. + TaskInt32, + /// The method returns Task<string>. + TaskString, + /// The method returns Task<string?>. + TaskNullableString, + /// The method returns ValueTask. + ValueTask, + /// The method returns ValueTask<int>. + ValueTaskInt32, + /// The method returns ValueTask<string>. + ValueTaskString, + /// The method returns ValueTask<string?>. + ValueTaskNullableString, + /// The method returns IEnumerable<byte>. + IEnumerableByte, + /// The method returns IAsyncEnumerable<byte>. + IAsyncEnumerableByte, +} diff --git a/Generator.Abstractions/MethodSignatureBinder.cs b/Generator.Abstractions/MethodSignatureBinder.cs index 5e90b8c..fe45969 100644 --- a/Generator.Abstractions/MethodSignatureBinder.cs +++ b/Generator.Abstractions/MethodSignatureBinder.cs @@ -1,225 +1,225 @@ -using Microsoft.CodeAnalysis; -using static Esolang.Generator.BindingError; - -namespace Esolang.Generator; - -/// -/// Provides utility methods for binding method signatures to . -/// -public static class MethodSignatureBinder -{ - /// - /// Binds the specified method symbol to a . - /// - /// The method symbol to bind. - /// The known types for the compilation. - /// The result of the binding. - public static MethodSignatureBinding Bind( - IMethodSymbol method, - KnownTypes types) - { - var returnKind = BindReturnKind(method.ReturnType, types); - if (returnKind == MethodReturnKind.Invalid) - { - return new MethodSignatureBinding(returnKind, MethodInputKind.None, MethodOutputKind.None, "", "", null, null, false, method.Parameters, new UnsupportedReturnType(method.ReturnType, method.Locations.FirstOrDefault())); - } - - var outputKind = BindDefaultOutputKind(returnKind); - var inputKind = MethodInputKind.None; - var inputExpr = ""; - var outputExpr = ""; - string? cancellationTokenName = null; - string? loggerExpression = null; - var isLoggerFromParameter = false; - var unhandledParameters = new List(); - - foreach (var p in method.Parameters) - { - if (p.RefKind != RefKind.None) - { - return new MethodSignatureBinding(returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, new InvalidParameterModifier(p, p.Locations.FirstOrDefault())); - } - - if (types.IsString(p.Type, false)) - { - if (inputKind != MethodInputKind.None) - return new MethodSignatureBinding(returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, new DuplicateInput(p, inputKind, p.Locations.FirstOrDefault())); - - inputKind = MethodInputKind.String; - inputExpr = p.Name; - continue; - } - - if (types.IsTextReader(p.Type)) - { - if (inputKind != MethodInputKind.None) - return new MethodSignatureBinding(returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, new DuplicateInput(p, inputKind, p.Locations.FirstOrDefault())); - - inputKind = MethodInputKind.TextReader; - inputExpr = p.Name; - continue; - } - - if (types.IsPipeReader(p.Type)) - { - if (inputKind != MethodInputKind.None) - return new MethodSignatureBinding(returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, new DuplicateInput(p, inputKind, p.Locations.FirstOrDefault())); - - inputKind = MethodInputKind.PipeReader; - inputExpr = p.Name; - continue; - } - - if (types.IsTextWriter(p.Type)) - { - if (IsOutputReturning(returnKind)) - return new MethodSignatureBinding(returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, new ReturnOutputConflict(p, p.Locations.FirstOrDefault())); - - if (outputKind != MethodOutputKind.None) - return new MethodSignatureBinding(returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, new DuplicateOutput(p, outputKind, p.Locations.FirstOrDefault())); - - outputKind = MethodOutputKind.TextWriter; - outputExpr = p.Name; - continue; - } - - if (types.IsPipeWriter(p.Type)) - { - if (IsOutputReturning(returnKind)) - return new MethodSignatureBinding(returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, new ReturnOutputConflict(p, p.Locations.FirstOrDefault())); - - if (outputKind != MethodOutputKind.None) - return new MethodSignatureBinding(returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, new DuplicateOutput(p, outputKind, p.Locations.FirstOrDefault())); - - outputKind = MethodOutputKind.PipeWriter; - outputExpr = p.Name; - continue; - } - - if (types.IsCancellationToken(p.Type)) - { - if (cancellationTokenName != null) - return new MethodSignatureBinding(returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, new DuplicateCancellationToken(p, p.Locations.FirstOrDefault())); - - cancellationTokenName = p.Name; - continue; - } - - if (types.IsLogger(p.Type)) - { - if (loggerExpression != null) - return new MethodSignatureBinding(returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, new DuplicateLogger(p, p.Locations.FirstOrDefault())); - - loggerExpression = p.Name; - isLoggerFromParameter = true; - continue; - } - - unhandledParameters.Add(p); - } - - loggerExpression ??= FindLoggerInContainingType(method.ContainingType, method.IsStatic, types, out isLoggerFromParameter); - - return new MethodSignatureBinding(returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, unhandledParameters); - } - - /// - /// Binds the return type symbol to a . - /// - public static MethodReturnKind BindReturnKind(ITypeSymbol returnType, KnownTypes types) - { - if (returnType.SpecialType == SpecialType.System_Void) return MethodReturnKind.Void; - if (returnType.SpecialType == SpecialType.System_Int32) return MethodReturnKind.Int32; - if (types.IsString(returnType, false)) return MethodReturnKind.String; - if (types.IsString(returnType, true)) return MethodReturnKind.NullableString; - if (types.IsTask(returnType)) return MethodReturnKind.Task; - if (types.IsTaskInt32(returnType)) return MethodReturnKind.TaskInt32; - if (types.IsTaskString(returnType, false)) return MethodReturnKind.TaskString; - if (types.IsTaskString(returnType, true)) return MethodReturnKind.TaskNullableString; - if (types.IsValueTask(returnType)) return MethodReturnKind.ValueTask; - if (types.IsValueTaskInt32(returnType)) return MethodReturnKind.ValueTaskInt32; - if (types.IsValueTaskString(returnType, false)) return MethodReturnKind.ValueTaskString; - if (types.IsValueTaskString(returnType, true)) return MethodReturnKind.ValueTaskNullableString; - if (types.IsIEnumerableByte(returnType)) return MethodReturnKind.IEnumerableByte; - if (types.IsIAsyncEnumerableByte(returnType)) return MethodReturnKind.IAsyncEnumerableByte; - - return MethodReturnKind.Invalid; - } - - /// - /// Gets the default output kind based on the return kind. - /// - static MethodOutputKind BindDefaultOutputKind(MethodReturnKind returnKind) => returnKind switch - { - MethodReturnKind.String or MethodReturnKind.NullableString or MethodReturnKind.TaskString or MethodReturnKind.TaskNullableString or MethodReturnKind.ValueTaskString or MethodReturnKind.ValueTaskNullableString => MethodOutputKind.ReturnString, - MethodReturnKind.IEnumerableByte => MethodOutputKind.ReturnIEnumerable, - MethodReturnKind.IAsyncEnumerableByte => MethodOutputKind.ReturnIAsyncEnumerable, - _ => MethodOutputKind.None - }; - - /// - /// Gets a value indicating whether the return kind implies output is returned. - /// - static bool IsOutputReturning(MethodReturnKind returnKind) => returnKind switch - { - MethodReturnKind.String or MethodReturnKind.NullableString or MethodReturnKind.TaskString or MethodReturnKind.TaskNullableString or MethodReturnKind.ValueTaskString or MethodReturnKind.ValueTaskNullableString or MethodReturnKind.IEnumerableByte or MethodReturnKind.IAsyncEnumerableByte => true, - _ => false - }; - - /// - /// Searches for a logger in the containing type (fields or constructor parameters). - /// - /// The type to search in. - /// Whether the target method is static. - /// The known types for the compilation. - /// Output: Whether the logger was found in a constructor parameter. - /// The expression to access the logger, or null if not found. - static string? FindLoggerInContainingType(ITypeSymbol? type, bool isStatic, KnownTypes types, out bool isFromParameter) - { - isFromParameter = false; - var currentType = type; - var shadowedNames = new HashSet(StringComparer.Ordinal); - var isBaseType = false; - - while (currentType != null) - { - foreach (var field in currentType.GetMembers().OfType()) - { - if (isStatic && !field.IsStatic) continue; - - // If searching in a base type, the field must be accessible (protected or public) - if (isBaseType && field.DeclaredAccessibility is not (Accessibility.Protected or Accessibility.ProtectedOrInternal or Accessibility.Public or Accessibility.Internal)) - continue; - - if (types.IsLogger(field.Type)) - { - return field.Name; - } - - if (field.CanBeReferencedByName) - { - shadowedNames.Add(field.Name); - } - } - currentType = currentType.BaseType; - isBaseType = true; - } - - if (type is INamedTypeSymbol namedType) - { - foreach (var constructor in namedType.InstanceConstructors) - { - foreach (var parameter in constructor.Parameters) - { - if (types.IsLogger(parameter.Type) && !shadowedNames.Contains(parameter.Name)) - { - isFromParameter = true; - return parameter.Name; - } - } - } - } - - return null; - } -} +using Microsoft.CodeAnalysis; +using static Esolang.Generator.BindingError; + +namespace Esolang.Generator; + +/// +/// Provides utility methods for binding method signatures to . +/// +public static class MethodSignatureBinder +{ + /// + /// Binds the specified method symbol to a . + /// + /// The method symbol to bind. + /// The known types for the compilation. + /// The result of the binding. + public static MethodSignatureBinding Bind( + IMethodSymbol method, + KnownTypes types) + { + var returnKind = BindReturnKind(method.ReturnType, types); + if (returnKind == MethodReturnKind.Invalid) + { + return new MethodSignatureBinding(returnKind, MethodInputKind.None, MethodOutputKind.None, "", "", null, null, false, method.Parameters, new UnsupportedReturnType(method.ReturnType, method.Locations.FirstOrDefault())); + } + + var outputKind = BindDefaultOutputKind(returnKind); + var inputKind = MethodInputKind.None; + var inputExpr = ""; + var outputExpr = ""; + string? cancellationTokenName = null; + string? loggerExpression = null; + var isLoggerFromParameter = false; + var unhandledParameters = new List(); + + foreach (var p in method.Parameters) + { + if (p.RefKind != RefKind.None) + { + return new MethodSignatureBinding(returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, new InvalidParameterModifier(p, p.Locations.FirstOrDefault())); + } + + if (types.IsString(p.Type, false)) + { + if (inputKind != MethodInputKind.None) + return new MethodSignatureBinding(returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, new DuplicateInput(p, inputKind, p.Locations.FirstOrDefault())); + + inputKind = MethodInputKind.String; + inputExpr = p.Name; + continue; + } + + if (types.IsTextReader(p.Type)) + { + if (inputKind != MethodInputKind.None) + return new MethodSignatureBinding(returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, new DuplicateInput(p, inputKind, p.Locations.FirstOrDefault())); + + inputKind = MethodInputKind.TextReader; + inputExpr = p.Name; + continue; + } + + if (types.IsPipeReader(p.Type)) + { + if (inputKind != MethodInputKind.None) + return new MethodSignatureBinding(returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, new DuplicateInput(p, inputKind, p.Locations.FirstOrDefault())); + + inputKind = MethodInputKind.PipeReader; + inputExpr = p.Name; + continue; + } + + if (types.IsTextWriter(p.Type)) + { + if (IsOutputReturning(returnKind)) + return new MethodSignatureBinding(returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, new ReturnOutputConflict(p, p.Locations.FirstOrDefault())); + + if (outputKind != MethodOutputKind.None) + return new MethodSignatureBinding(returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, new DuplicateOutput(p, outputKind, p.Locations.FirstOrDefault())); + + outputKind = MethodOutputKind.TextWriter; + outputExpr = p.Name; + continue; + } + + if (types.IsPipeWriter(p.Type)) + { + if (IsOutputReturning(returnKind)) + return new MethodSignatureBinding(returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, new ReturnOutputConflict(p, p.Locations.FirstOrDefault())); + + if (outputKind != MethodOutputKind.None) + return new MethodSignatureBinding(returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, new DuplicateOutput(p, outputKind, p.Locations.FirstOrDefault())); + + outputKind = MethodOutputKind.PipeWriter; + outputExpr = p.Name; + continue; + } + + if (types.IsCancellationToken(p.Type)) + { + if (cancellationTokenName != null) + return new MethodSignatureBinding(returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, new DuplicateCancellationToken(p, p.Locations.FirstOrDefault())); + + cancellationTokenName = p.Name; + continue; + } + + if (types.IsLogger(p.Type)) + { + if (loggerExpression != null) + return new MethodSignatureBinding(returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, method.Parameters, new DuplicateLogger(p, p.Locations.FirstOrDefault())); + + loggerExpression = p.Name; + isLoggerFromParameter = true; + continue; + } + + unhandledParameters.Add(p); + } + + loggerExpression ??= FindLoggerInContainingType(method.ContainingType, method.IsStatic, types, out isLoggerFromParameter); + + return new MethodSignatureBinding(returnKind, inputKind, outputKind, inputExpr, outputExpr, cancellationTokenName, loggerExpression, isLoggerFromParameter, unhandledParameters); + } + + /// + /// Binds the return type symbol to a . + /// + public static MethodReturnKind BindReturnKind(ITypeSymbol returnType, KnownTypes types) + { + if (returnType.SpecialType == SpecialType.System_Void) return MethodReturnKind.Void; + if (returnType.SpecialType == SpecialType.System_Int32) return MethodReturnKind.Int32; + if (types.IsString(returnType, false)) return MethodReturnKind.String; + if (types.IsString(returnType, true)) return MethodReturnKind.NullableString; + if (types.IsTask(returnType)) return MethodReturnKind.Task; + if (types.IsTaskInt32(returnType)) return MethodReturnKind.TaskInt32; + if (types.IsTaskString(returnType, false)) return MethodReturnKind.TaskString; + if (types.IsTaskString(returnType, true)) return MethodReturnKind.TaskNullableString; + if (types.IsValueTask(returnType)) return MethodReturnKind.ValueTask; + if (types.IsValueTaskInt32(returnType)) return MethodReturnKind.ValueTaskInt32; + if (types.IsValueTaskString(returnType, false)) return MethodReturnKind.ValueTaskString; + if (types.IsValueTaskString(returnType, true)) return MethodReturnKind.ValueTaskNullableString; + if (types.IsIEnumerableByte(returnType)) return MethodReturnKind.IEnumerableByte; + if (types.IsIAsyncEnumerableByte(returnType)) return MethodReturnKind.IAsyncEnumerableByte; + + return MethodReturnKind.Invalid; + } + + /// + /// Gets the default output kind based on the return kind. + /// + static MethodOutputKind BindDefaultOutputKind(MethodReturnKind returnKind) => returnKind switch + { + MethodReturnKind.String or MethodReturnKind.NullableString or MethodReturnKind.TaskString or MethodReturnKind.TaskNullableString or MethodReturnKind.ValueTaskString or MethodReturnKind.ValueTaskNullableString => MethodOutputKind.ReturnString, + MethodReturnKind.IEnumerableByte => MethodOutputKind.ReturnIEnumerable, + MethodReturnKind.IAsyncEnumerableByte => MethodOutputKind.ReturnIAsyncEnumerable, + _ => MethodOutputKind.None + }; + + /// + /// Gets a value indicating whether the return kind implies output is returned. + /// + static bool IsOutputReturning(MethodReturnKind returnKind) => returnKind switch + { + MethodReturnKind.String or MethodReturnKind.NullableString or MethodReturnKind.TaskString or MethodReturnKind.TaskNullableString or MethodReturnKind.ValueTaskString or MethodReturnKind.ValueTaskNullableString or MethodReturnKind.IEnumerableByte or MethodReturnKind.IAsyncEnumerableByte => true, + _ => false + }; + + /// + /// Searches for a logger in the containing type (fields or constructor parameters). + /// + /// The type to search in. + /// Whether the target method is static. + /// The known types for the compilation. + /// Output: Whether the logger was found in a constructor parameter. + /// The expression to access the logger, or null if not found. + static string? FindLoggerInContainingType(ITypeSymbol? type, bool isStatic, KnownTypes types, out bool isFromParameter) + { + isFromParameter = false; + var currentType = type; + var shadowedNames = new HashSet(StringComparer.Ordinal); + var isBaseType = false; + + while (currentType != null) + { + foreach (var field in currentType.GetMembers().OfType()) + { + if (isStatic && !field.IsStatic) continue; + + // If searching in a base type, the field must be accessible (protected or public) + if (isBaseType && field.DeclaredAccessibility is not (Accessibility.Protected or Accessibility.ProtectedOrInternal or Accessibility.Public or Accessibility.Internal)) + continue; + + if (types.IsLogger(field.Type)) + { + return field.Name; + } + + if (field.CanBeReferencedByName) + { + shadowedNames.Add(field.Name); + } + } + currentType = currentType.BaseType; + isBaseType = true; + } + + if (type is INamedTypeSymbol namedType) + { + foreach (var constructor in namedType.InstanceConstructors) + { + foreach (var parameter in constructor.Parameters) + { + if (types.IsLogger(parameter.Type) && !shadowedNames.Contains(parameter.Name)) + { + isFromParameter = true; + return parameter.Name; + } + } + } + } + + return null; + } +} diff --git a/Processor.Abstractions/IOEvent.cs b/Processor.Abstractions/IOEvent.cs index 5c4ba58..a0b3987 100644 --- a/Processor.Abstractions/IOEvent.cs +++ b/Processor.Abstractions/IOEvent.cs @@ -5,7 +5,7 @@ namespace Esolang.Processor; /// public abstract class IOEvent { - IOEvent() {} + IOEvent() { } /// /// Creates an event requesting a character input. From 7ecc373c2056bd267f971e9bc08ebc1f7f670ef6 Mon Sep 17 00:00:00 2001 From: juner Date: Tue, 2 Jun 2026 06:46:09 +0900 Subject: [PATCH 43/49] docs: finalize v2.0.0 documentation and changelog --- CHANGELOG.md | 18 +++++++++++++++--- Generator.Abstractions/README.md | 17 +++++++++++++++++ Interpreter.Abstractions/README.md | 17 +++++++++++++++++ Processor.Extensions.IO/README.md | 17 +++++++++++++++++ 4 files changed, 66 insertions(+), 3 deletions(-) create mode 100644 Generator.Abstractions/README.md create mode 100644 Interpreter.Abstractions/README.md create mode 100644 Processor.Extensions.IO/README.md diff --git a/CHANGELOG.md b/CHANGELOG.md index 62abc23..b28dc1d 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4,11 +4,23 @@ All notable changes to this repository are documented in this file. The format is based on Keep a Changelog. -## [Unreleased] +## [2.0.0] - 2026-06-01 -### Changed +### Added +- **Esolang.Generator.Abstractions**: Added comprehensive abstractions for method signature binding and type resolution. +- **Esolang.Interpreter.Abstractions**: Added new common abstractions for esolang interpreters. +- **Esolang.Processor.Extensions.IO**: Extracted and standardized IO extension methods (supporting `TextReader`, `TextWriter`, and `System.IO.Pipelines`) into a dedicated project. +- Enhanced testing infrastructure across all abstraction projects, significantly improving code coverage. -- `Esolang.Processor.Abstractions`: refined NuGet `PackageTags` to improve discoverability (`esolang;processor;abstractions`). +### Changed +- Refactored `Generator.Abstractions` to utilize type-safe `BindingError` record hierarchy instead of string-based error IDs. +- Standardized `KnownTypes` implementation and nullable handling in generator abstractions. +- Refactored processor abstractions for improved architectural cleanliness. +- Updated `.editorconfig` with stricter C# style and MSTest diagnostic rules. + +### Fixed +- Improved cooperative cancellation support in `RunToConsoleAsync`. +- Addressed various issues in `MethodSignatureBinder` and `MethodSignatureBinding`. ## [1.0.0] - 2026-05-07 diff --git a/Generator.Abstractions/README.md b/Generator.Abstractions/README.md new file mode 100644 index 0000000..3c845c6 --- /dev/null +++ b/Generator.Abstractions/README.md @@ -0,0 +1,17 @@ +# Esolang.Generator.Abstractions + +Common abstractions for esolang code generators. + +## Installation + +```bash +dotnet add package Esolang.Generator.Abstractions +``` + +## Overview + +This package provides common interfaces, types, and binder utilities for implementing esolang code generators within the Esolang.NET ecosystem. + +## License + +See [LICENSE](../LICENSE) for details. diff --git a/Interpreter.Abstractions/README.md b/Interpreter.Abstractions/README.md new file mode 100644 index 0000000..67c69b2 --- /dev/null +++ b/Interpreter.Abstractions/README.md @@ -0,0 +1,17 @@ +# Esolang.Interpreter.Abstractions + +Common abstractions for esolang interpreters. + +## Installation + +```bash +dotnet add package Esolang.Interpreter.Abstractions +``` + +## Overview + +This package provides common interfaces and extensions for implementing esolang interpreters within the Esolang.NET ecosystem. + +## License + +See [LICENSE](../LICENSE) for details. diff --git a/Processor.Extensions.IO/README.md b/Processor.Extensions.IO/README.md new file mode 100644 index 0000000..dcffd83 --- /dev/null +++ b/Processor.Extensions.IO/README.md @@ -0,0 +1,17 @@ +# Esolang.Processor.Extensions.IO + +Provides extension methods for running `IEventProcessor` using various I/O abstractions. + +## Installation + +```bash +dotnet add package Esolang.Processor.Extensions.IO +``` + +## Overview + +This package provides extension methods to facilitate running processors (interpreters) based on an event-driven I/O model, supporting `TextReader`/`TextWriter`, `string` input/output, and `PipeReader`/`PipeWriter` from `System.IO.Pipelines`. + +## License + +See [LICENSE](../LICENSE) for details. From 099978844bd655c2f8df639ba26a38fe0e9bf042 Mon Sep 17 00:00:00 2001 From: juner Date: Tue, 2 Jun 2026 08:10:38 +0900 Subject: [PATCH 44/49] =?UTF-8?q?CHANGELOG=20=E3=81=AE=E6=95=B4=E7=90=86?= =?UTF-8?q?=EF=BC=88=20v1.0.0=20-=20v2.0.0=20=E3=81=A8=E3=81=84=E3=81=86?= =?UTF-8?q?=E3=83=8B=E3=83=A5=E3=82=A2=E3=83=B3=E3=82=B9=E3=81=A7=E3=81=AF?= =?UTF-8?q?=E4=B8=8D=E8=A6=81=E3=81=AA=E5=86=85=E5=AE=B9=E3=81=AE=E5=89=8A?= =?UTF-8?q?=E9=99=A4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- CHANGELOG.md | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index b28dc1d..2c8223f 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4,23 +4,20 @@ All notable changes to this repository are documented in this file. The format is based on Keep a Changelog. -## [2.0.0] - 2026-06-01 +## [Unreleased] + +## [2.0.0] - 2026-06-02 ### Added + - **Esolang.Generator.Abstractions**: Added comprehensive abstractions for method signature binding and type resolution. - **Esolang.Interpreter.Abstractions**: Added new common abstractions for esolang interpreters. - **Esolang.Processor.Extensions.IO**: Extracted and standardized IO extension methods (supporting `TextReader`, `TextWriter`, and `System.IO.Pipelines`) into a dedicated project. - Enhanced testing infrastructure across all abstraction projects, significantly improving code coverage. ### Changed -- Refactored `Generator.Abstractions` to utilize type-safe `BindingError` record hierarchy instead of string-based error IDs. -- Standardized `KnownTypes` implementation and nullable handling in generator abstractions. -- Refactored processor abstractions for improved architectural cleanliness. -- Updated `.editorconfig` with stricter C# style and MSTest diagnostic rules. -### Fixed -- Improved cooperative cancellation support in `RunToConsoleAsync`. -- Addressed various issues in `MethodSignatureBinder` and `MethodSignatureBinding`. +- Updated `.editorconfig` with stricter C# style and MSTest diagnostic rules. ## [1.0.0] - 2026-05-07 @@ -32,3 +29,7 @@ The format is based on Keep a Changelog. - `IPipeProcessor` — Execution interface using `PipeReader` and `PipeWriter` for high-performance pipe-based I/O. - Both text and pipe processors return exit codes (`int`) from execution. - Support for optional `CancellationToken` on all execution methods. + +[Unreleased]: https://github.com/Esolang-NET/Abstractions/compare/v2.0.0...HEAD +[2.0.0]: https://github.com/Esolang-NET/Abstractions/tree/v2.0.0 +[1.0.0]: https://github.com/Esolang-NET/Abstractions/tree/v1.0.0 \ No newline at end of file From b64817723bcc06729657006baf0fbd4a852bce87 Mon Sep 17 00:00:00 2001 From: juner Date: Tue, 2 Jun 2026 08:36:53 +0900 Subject: [PATCH 45/49] chore: update NuGet package metadata (Description, PackageTags, PackageReadmeFile) --- .../Esolang.Generator.Abstractions.csproj | 10 ++++++++++ .../Esolang.Interpreter.Abstractions.csproj | 11 +++++++++-- .../Esolang.Processor.Abstractions.csproj | 4 ++-- .../Esolang.Processor.Extensions.IO.csproj | 11 +++++++++-- 4 files changed, 30 insertions(+), 6 deletions(-) diff --git a/Generator.Abstractions/Esolang.Generator.Abstractions.csproj b/Generator.Abstractions/Esolang.Generator.Abstractions.csproj index 8d6feff..9c4d9ac 100644 --- a/Generator.Abstractions/Esolang.Generator.Abstractions.csproj +++ b/Generator.Abstractions/Esolang.Generator.Abstractions.csproj @@ -4,6 +4,10 @@ netstandard2.0;netstandard2.1 Esolang.Generator true + Esolang.Generator.Abstractions + Common abstractions and binder utilities for implementing esolang code generators and Roslyn-based source generators. + README.md + esolang;generator;sourcegenerator;abstractions;roslyn;binder @@ -14,4 +18,10 @@ + + + + + + diff --git a/Interpreter.Abstractions/Esolang.Interpreter.Abstractions.csproj b/Interpreter.Abstractions/Esolang.Interpreter.Abstractions.csproj index 3d59745..346f679 100644 --- a/Interpreter.Abstractions/Esolang.Interpreter.Abstractions.csproj +++ b/Interpreter.Abstractions/Esolang.Interpreter.Abstractions.csproj @@ -2,9 +2,10 @@ net10.0 - Interpreter abstractions for Esolang processors. + Common abstraction interfaces for implementing esolang interpreters, facilitating integration with the unified processor model. Esolang.Interpreter.Abstractions - esolang;interpreter;abstractions + README.md + esolang;interpreter;abstractions;interface;execution;runtime Esolang.Interpreter @@ -12,4 +13,10 @@ + + + + + + diff --git a/Processor.Abstractions/Esolang.Processor.Abstractions.csproj b/Processor.Abstractions/Esolang.Processor.Abstractions.csproj index c68fdac..023ced3 100644 --- a/Processor.Abstractions/Esolang.Processor.Abstractions.csproj +++ b/Processor.Abstractions/Esolang.Processor.Abstractions.csproj @@ -4,10 +4,10 @@ netstandard2.0;netstandard2.1 enable true - Unified processor abstractions for esolang execution. + Core interfaces and unified abstractions for esolang execution models, providing event-driven I/O processing standards. Esolang.Processor.Abstractions README.md - esolang;processor;abstractions + esolang;processor;abstractions;interface;execution;event-driven;io Esolang.Processor diff --git a/Processor.Extensions.IO/Esolang.Processor.Extensions.IO.csproj b/Processor.Extensions.IO/Esolang.Processor.Extensions.IO.csproj index e0f37e2..ebbab3b 100644 --- a/Processor.Extensions.IO/Esolang.Processor.Extensions.IO.csproj +++ b/Processor.Extensions.IO/Esolang.Processor.Extensions.IO.csproj @@ -4,9 +4,10 @@ netstandard2.0;netstandard2.1 enable true - System.IO.Pipelines, Text and String extension methods for esolang processors. + Comprehensive I/O extension methods for IEventProcessor, supporting TextReader/Writer, System.IO.Pipelines, and string-based execution. Esolang.Processor.Extensions.IO - esolang;processor;io;pipelines;text;abstractions + README.md + esolang;processor;io;pipelines;text;string;extensions;abstractions Esolang.Processor.Extensions.IO @@ -18,4 +19,10 @@ + + + + + + From 9ce778e28d5fcbd2f9ecdb0696de4520d054c85d Mon Sep 17 00:00:00 2001 From: juner Date: Tue, 2 Jun 2026 08:41:23 +0900 Subject: [PATCH 46/49] ci: update GitHub Actions workflows for build, test, and release --- .github/workflows/dotnet.yml | 23 +++++++++++++---------- .github/workflows/release.yml | 32 ++++++++++++++++++++++++-------- 2 files changed, 37 insertions(+), 18 deletions(-) diff --git a/.github/workflows/dotnet.yml b/.github/workflows/dotnet.yml index 9c4f64d..bfeb2e1 100644 --- a/.github/workflows/dotnet.yml +++ b/.github/workflows/dotnet.yml @@ -1,4 +1,4 @@ -name: build +name: build and test on: push: @@ -12,35 +12,38 @@ on: env: DOTNET_VERSION: '10.0.x' - NUGET_SOURCE: 'https://api.nuget.org/v3/index.json' jobs: - build: - name: build-${{matrix.os}} + build-and-test: + + name: build-and-test-${{matrix.os}} runs-on: ${{ matrix.os }} strategy: matrix: os: [ubuntu-latest, windows-latest, macOS-latest] steps: - - uses: actions/checkout@v4 + - uses: actions/checkout@v6 - name: Setup .NET Core - uses: actions/setup-dotnet@v4 + uses: actions/setup-dotnet@v5 with: dotnet-version: ${{ env.DOTNET_VERSION }} - name: Install dependencies - run: dotnet restore --source "${{ env.NUGET_SOURCE }}" - + run: dotnet restore + - name: Build run: dotnet build --no-restore + + - name: Test + run: dotnet test --no-restore --verbosity normal - name: Pack if: ${{ matrix.os == 'ubuntu-latest' }} run: | dotnet pack -o artifacts/ - - - uses: actions/upload-artifact@v4 + + - uses: actions/upload-artifact@v7 if: ${{ matrix.os == 'ubuntu-latest' }} with: name: artifacts diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 45de965..a725457 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -17,28 +17,32 @@ permissions: env: DOTNET_VERSION: '10.0.x' - NUGET_SOURCE: 'https://api.nuget.org/v3/index.json' jobs: publish: name: publish-packages-and-release runs-on: ubuntu-latest steps: - - uses: actions/checkout@v4 + - uses: actions/checkout@v6 with: ref: ${{ github.event_name == 'workflow_dispatch' && github.event.inputs.tag || github.ref }} fetch-depth: 0 - name: Setup .NET - uses: actions/setup-dotnet@v4 + uses: actions/setup-dotnet@v5 with: dotnet-version: ${{ env.DOTNET_VERSION }} - name: Restore - run: dotnet restore --source "${{ env.NUGET_SOURCE }}" + run: dotnet restore - name: Build run: dotnet build --configuration Release --no-restore + - name: Test + run: dotnet test --configuration Release --no-build --verbosity normal - name: Pack run: | + dotnet pack Generator.Abstractions/Esolang.Generator.Abstractions.csproj -c Release -o artifacts/nuget + dotnet pack Interpreter.Abstractions/Esolang.Interpreter.Abstractions.csproj -c Release -o artifacts/nuget dotnet pack Processor.Abstractions/Esolang.Processor.Abstractions.csproj -c Release -o artifacts/nuget + dotnet pack Processor.Extensions.IO/Esolang.Processor.Extensions.IO.csproj -c Release -o artifacts/nuget - name: Publish to NuGet.org env: NUGET_API_KEY: ${{ secrets.NUGET_API_KEY }} @@ -93,7 +97,19 @@ jobs: set -euo pipefail tag="${{ github.event.inputs.tag || github.ref_name }}" shopt -s nullglob - gh release create "$tag" \ - --repo "${{ github.repository }}" \ - --title "$tag" \ - artifacts/nuget/*.nupkg artifacts/nuget/*.snupkg || true + assets=(artifacts/nuget/*.nupkg artifacts/nuget/*.snupkg) + prerelease_flag="" + if [[ "$tag" == *-* ]]; then + prerelease_flag="--prerelease" + fi + if gh release view "$tag" >/dev/null 2>&1; then + if [ ${#assets[@]} -gt 0 ]; then + gh release upload "$tag" "${assets[@]}" --clobber + fi + else + gh release create "$tag" \ + "${assets[@]}" \ + --title "$tag" \ + --generate-notes \ + $prerelease_flag + fi From 93092d39a56dd272b0aff02f73abdeef25fcd72d Mon Sep 17 00:00:00 2001 From: juner Date: Tue, 2 Jun 2026 09:17:54 +0900 Subject: [PATCH 47/49] docs: update root README.md with package summaries and NuGet links --- README.md | 70 ++++++++++++++++++++++++++++--------------------------- 1 file changed, 36 insertions(+), 34 deletions(-) diff --git a/README.md b/README.md index 81ae5a6..58c75f6 100644 --- a/README.md +++ b/README.md @@ -1,57 +1,59 @@ # Esolang.Abstractions -Shared abstraction interfaces for Esolang.NET projects (Funge-98, Brainfuck, Piet). +[![.NET](https://github.com/Esolang-NET/Abstractions/actions/workflows/dotnet.yml/badge.svg)](https://github.com/Esolang-NET/Abstractions/actions/workflows/dotnet.yml) -## Overview +Unified abstractions and interfaces for the Esolang.NET ecosystem. -This repository provides common abstractions used across multiple esolang interpreter and code generator projects: +## Overview -- **Esolang.Funge** — Funge-98 parser, processor, and generator -- **Esolang.Brainfuck** — Brainfuck interpreter and generator -- **Esolang.Piet** — Piet parser, processor, and generator +This repository provides common abstractions used across multiple esolang interpreter and code generator projects such as Funge-98, Brainfuck, and Piet. It defines a unified model for execution, I/O processing, and source generation. -## Packages +## Choose Package -### Esolang.Processor.Abstractions +| Want to do | Package | +| --- | --- | +| Create code generators or binders | [Esolang.Generator.Abstractions](./Generator.Abstractions/README.md) | +| Implement a new esolang interpreter | [Esolang.Interpreter.Abstractions](./Interpreter.Abstractions/README.md) | +| Define core execution and I/O models | [Esolang.Processor.Abstractions](./Processor.Abstractions/README.md) | +| Add I/O extensions (Text, Pipelines, etc.) | [Esolang.Processor.Extensions.IO](./Processor.Extensions.IO/README.md) | -Unified processor abstractions for esolang execution. +## Install ```bash +dotnet add package Esolang.Generator.Abstractions +dotnet add package Esolang.Interpreter.Abstractions dotnet add package Esolang.Processor.Abstractions +dotnet add package Esolang.Processor.Extensions.IO ``` -Provides: +## NuGet -- **`IProcessor`** — Base interface holding a parsed program -- **`ITextProcessor`** — Execution via `TextReader`/`TextWriter` -- **`IPipeProcessor`** — Execution via `PipeReader`/`PipeWriter` +| Project | NuGet | Summary | +| --- | --- | --- | +| [Esolang.Generator.Abstractions](./Generator.Abstractions/README.md) | [![NuGet: Esolang.Generator.Abstractions](https://img.shields.io/nuget/v/Esolang.Generator.Abstractions?logo=nuget&label=2.0.0)](https://www.nuget.org/packages/Esolang.Generator.Abstractions/) | Code generator and Roslyn binder abstractions. | +| [Esolang.Interpreter.Abstractions](./Interpreter.Abstractions/README.md) | [![NuGet: Esolang.Interpreter.Abstractions](https://img.shields.io/nuget/v/Esolang.Interpreter.Abstractions?logo=nuget&label=2.0.0)](https://www.nuget.org/packages/Esolang.Interpreter.Abstractions/) | Base abstractions for interpreters. | +| [Esolang.Processor.Abstractions](./Processor.Abstractions/README.md) | [![NuGet: Esolang.Processor.Abstractions](https://img.shields.io/nuget/v/Esolang.Processor.Abstractions?logo=nuget&label=2.0.0)](https://www.nuget.org/packages/Esolang.Processor.Abstractions/) | Core processor and I/O event abstractions. | +| [Esolang.Processor.Extensions.IO](./Processor.Extensions.IO/README.md) | [![NuGet: Esolang.Processor.Extensions.IO](https://img.shields.io/nuget/v/Esolang.Processor.Extensions.IO?logo=nuget&label=2.0.0)](https://www.nuget.org/packages/Esolang.Processor.Extensions.IO/) | I/O extensions for event processors. | -#### Usage +## Framework Support -```csharp -using Esolang.Processor; +| Project | Target frameworks | +| --- | --- | +| Esolang.Generator.Abstractions | netstandard2.0, netstandard2.1 | +| Esolang.Interpreter.Abstractions | net10.0 | +| Esolang.Processor.Abstractions | netstandard2.0, netstandard2.1 | +| Esolang.Processor.Extensions.IO | netstandard2.0, netstandard2.1 | -// Implement in your processor -public class MyProcessor : ITextProcessor -{ - public MyProgram Program { get; } +## Changelog - public int RunToEnd(TextReader? input = null, TextWriter? output = null, CancellationToken ct = default) - { - // Execute program and return exit code - } - - public ValueTask RunToEndAsync(TextReader? input = null, TextWriter? output = null, CancellationToken ct = default) - { - // Async variant - } -} -``` +- [CHANGELOG](./CHANGELOG.md) -## Contributing +## See also -Contributions are welcome. Please ensure code follows the project's `.editorconfig` and coding standards. +- [Esolang.Funge](https://github.com/Esolang-NET/Funge) — Funge-98 implementation +- [Esolang.Brainfuck](https://github.com/Esolang-NET/Brainfuck) — Brainfuck implementation +- [Esolang.Piet](https://github.com/Esolang-NET/Piet) — Piet implementation ## License -See [LICENSE](LICENSE) for details. +This project is licensed under the MIT License - see the [LICENSE](./LICENSE) file for details. From cdbf74db7f0b2296d05b2923791763cec83bf738 Mon Sep 17 00:00:00 2001 From: juner Date: Tue, 2 Jun 2026 10:22:35 +0900 Subject: [PATCH 48/49] docs: improve project READMEs and sync with source implementation --- Generator.Abstractions/README.md | 16 +++++++-- Interpreter.Abstractions/README.md | 15 +++++++-- Processor.Abstractions/README.md | 20 ++++++++++-- Processor.Extensions.IO/README.md | 41 ++++++++++++++++++++++-- Processor.Extensions.Pipelines/README.md | 23 ------------- 5 files changed, 81 insertions(+), 34 deletions(-) delete mode 100644 Processor.Extensions.Pipelines/README.md diff --git a/Generator.Abstractions/README.md b/Generator.Abstractions/README.md index 3c845c6..4c685fa 100644 --- a/Generator.Abstractions/README.md +++ b/Generator.Abstractions/README.md @@ -10,8 +10,18 @@ dotnet add package Esolang.Generator.Abstractions ## Overview -This package provides common interfaces, types, and binder utilities for implementing esolang code generators within the Esolang.NET ecosystem. +This package provides common interfaces, types, and binder utilities for implementing esolang code generators and Roslyn-based source generators within the Esolang.NET ecosystem. -## License +## Key Components -See [LICENSE](../LICENSE) for details. +### MethodSignatureBinder + +The `MethodSignatureBinder` is a core utility that facilitates mapping esolang source code to C# partial method signatures. It handles the identification of input, output, and return patterns to generate appropriate boilerplate. + +### Binding Kinds + +To support diverse esolang execution models, several "Kind" enums are provided to classify method signatures: + +- **MethodInputKind**: Classifies how the esolang receives input (e.g., `TextReader`, `PipeReader`, `byte[]`, or none). +- **MethodOutputKind**: Classifies how the esolang sends output (e.g., `TextWriter`, `PipeWriter`, `StringBuilder`, or none). +- **MethodReturnKind**: Determines the method's return pattern (e.g., `void`, `string`, `int`, `Task`, `IEnumerable`, `IAsyncEnumerable`). diff --git a/Interpreter.Abstractions/README.md b/Interpreter.Abstractions/README.md index 67c69b2..38bcda0 100644 --- a/Interpreter.Abstractions/README.md +++ b/Interpreter.Abstractions/README.md @@ -10,8 +10,17 @@ dotnet add package Esolang.Interpreter.Abstractions ## Overview -This package provides common interfaces and extensions for implementing esolang interpreters within the Esolang.NET ecosystem. +This package provides common interfaces and extensions for implementing esolang interpreters within the Esolang.NET ecosystem. It focuses on facilitating the execution of any `IEventProcessor` using standard console I/O. -## License +## Usage -See [LICENSE](../LICENSE) for details. +### Run to Console + +The `RunToConsoleAsync` extension method allows you to execute an `IEventProcessor` directly using `Console.In` and `Console.Out`. + +```csharp +using Esolang.Interpreter; + +// Run your processor using standard I/O +int exitCode = await processor.RunToConsoleAsync(); +``` diff --git a/Processor.Abstractions/README.md b/Processor.Abstractions/README.md index 8c59973..7f08594 100644 --- a/Processor.Abstractions/README.md +++ b/Processor.Abstractions/README.md @@ -40,6 +40,18 @@ public interface IEventProcessor : IProcessor } ``` +## IO Events + +The `IEventProcessor` communicates with the outside world through a stream of `IOEvent` objects. + +| Event Type | Purpose | Factory Method | +| --- | --- | --- | +| `InputCharEvent` | Requests a single character from the input. | `IOEvent.InputChar(Action write)` | +| `InputIntEvent` | Requests a single integer from the input. | `IOEvent.InputInt(Action write)` | +| `OutputCharEvent` | Sends a single character to the output. | `IOEvent.OutputChar(char output)` | +| `OutputIntEvent` | Sends a single integer to the output. | `IOEvent.OutputInt(int output)` | +| `EndEvent` | Signals the end of execution and provides an exit code. | `IOEvent.End(int exitCode)` | + ## Extension Methods To facilitate running processors, common extension methods are provided in separate packages: @@ -68,9 +80,12 @@ public class MyEsolangProcessor : IEventProcessor { public MyProgram Program { get; } - public IAsyncEnumerable RunAsyncEnumerable(CancellationToken cancellationToken = default) + public async IAsyncEnumerable RunAsyncEnumerable(CancellationToken cancellationToken = default) { - // Implement the execution logic yielding IOEvents (InputCharEvent, OutputCharEvent, etc.) + // Implement the execution logic yielding IOEvents + yield return IOEvent.OutputChar('H'); + yield return IOEvent.OutputChar('i'); + yield return IOEvent.End(0); } } ``` @@ -78,6 +93,7 @@ public class MyEsolangProcessor : IEventProcessor ## Target Framework - **netstandard2.0** — Compatible with .NET Framework 4.6.1+ and .NET Core 2.0+ +- **netstandard2.1** — Compatible with .NET Core 3.0+ and .NET 5+ ## See Also diff --git a/Processor.Extensions.IO/README.md b/Processor.Extensions.IO/README.md index dcffd83..057999d 100644 --- a/Processor.Extensions.IO/README.md +++ b/Processor.Extensions.IO/README.md @@ -10,8 +10,43 @@ dotnet add package Esolang.Processor.Extensions.IO ## Overview -This package provides extension methods to facilitate running processors (interpreters) based on an event-driven I/O model, supporting `TextReader`/`TextWriter`, `string` input/output, and `PipeReader`/`PipeWriter` from `System.IO.Pipelines`. +This package provides extension methods to facilitate running processors based on an event-driven I/O model. It bridges the gap between the core `IOEvent` stream and common .NET I/O types. -## License +## Features -See [LICENSE](../LICENSE) for details. +- **Text I/O**: Run processors using `TextReader` for input and `TextWriter` for output. +- **String I/O**: Convenient methods for executing with `string` input and capturing output as a `string` or `StringBuilder`. +- **Pipe I/O**: High-performance I/O using `PipeReader` and `PipeWriter` from `System.IO.Pipelines`. + +## Usage Examples + +### String I/O + +```csharp +using Esolang.Processor.Extensions.IO; + +// Run and get the output as a string +string? result = await processor.RunToStringAsync(input: "your_input"); + +// Run and write output to a StringBuilder +var sb = new StringBuilder(); +int exitCode = await processor.RunToEndAsync(input: "your_input", output: sb); +``` + +### Text I/O + +```csharp +using Esolang.Processor.Extensions.IO; + +// Run using TextReader and TextWriter +int exitCode = await processor.RunToEndAsync(Console.In, Console.Out); +``` + +### Pipe I/O + +```csharp +using Esolang.Processor.Extensions.IO; + +// Run using System.IO.Pipelines +int exitCode = await processor.RunToEndAsync(pipeReader, pipeWriter); +``` diff --git a/Processor.Extensions.Pipelines/README.md b/Processor.Extensions.Pipelines/README.md deleted file mode 100644 index 230c3cb..0000000 --- a/Processor.Extensions.Pipelines/README.md +++ /dev/null @@ -1,23 +0,0 @@ -# Esolang.Processor.Extensions.IO - -Provides extension methods for running `IEventProcessor` using various I/O abstractions. - -## Features - -- **Text I/O**: Extension methods for `TextReader` and `TextWriter`. -- **String I/O**: Convenient extension methods for handling `string` input and `StringBuilder` output. -- **Pipe I/O**: Extension methods for high-performance `PipeReader` and `PipeWriter` from `System.IO.Pipelines`. - -## Usage - -Depending on your needs, you can use these extensions to run processors seamlessly: - -```csharp -// Example using string input/output -var exitCode = await processor.RunToEndAsync(input: "your_input", output: stringBuilder); - -// Example using string result -var result = await processor.RunToStringAsync(input: "your_input"); -``` - -For more advanced I/O, utilize the text or pipe extensions. From 30560c7623b27eca628d893c6dcc374e6ac048f9 Mon Sep 17 00:00:00 2001 From: juner Date: Tue, 2 Jun 2026 10:34:13 +0900 Subject: [PATCH 49/49] docs: complete v2.0.0 changelog with detailed changes and breaking updates --- CHANGELOG.md | 23 +++++++++++++++++++---- 1 file changed, 19 insertions(+), 4 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 2c8223f..68d7971 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -10,13 +10,28 @@ The format is based on Keep a Changelog. ### Added -- **Esolang.Generator.Abstractions**: Added comprehensive abstractions for method signature binding and type resolution. -- **Esolang.Interpreter.Abstractions**: Added new common abstractions for esolang interpreters. -- **Esolang.Processor.Extensions.IO**: Extracted and standardized IO extension methods (supporting `TextReader`, `TextWriter`, and `System.IO.Pipelines`) into a dedicated project. +- **Esolang.Processor.Abstractions**: + - Introduced `IEventProcessor` for a unified, event-driven execution model. + - Added `IOEvent` and its subtypes (`InputChar`, `InputInt`, `OutputChar`, `OutputInt`, `End`) to represent I/O operations. + - Added `IProcessor` as a non-generic base interface. +- **Esolang.Generator.Abstractions**: + - Added comprehensive abstractions for method signature binding and type resolution. + - Introduced `MethodSignatureBinder` for mapping esolang source to C# partial methods. + - Added `MethodInputKind`, `MethodOutputKind`, and `MethodReturnKind` for signature classification. +- **Esolang.Interpreter.Abstractions**: + - Added new project for common interpreter utilities. + - Introduced `RunToConsoleAsync` extension method for running processors with standard console I/O. +- **Esolang.Processor.Extensions.IO**: + - Extracted and standardized I/O extension methods into a dedicated project. + - Added support for `TextReader`/`TextWriter`, `string`/`StringBuilder`, and `System.IO.Pipelines` (`PipeReader`/`PipeWriter`). - Enhanced testing infrastructure across all abstraction projects, significantly improving code coverage. ### Changed +- **Esolang.Processor.Abstractions** (Breaking Changes): + - Removed `ITextProcessor` and `IPipeProcessor` interfaces in favor of the event-driven `IEventProcessor`. + - Modernized interfaces to use `IAsyncEnumerable` for execution. + - Standardized naming and namespaces. - Updated `.editorconfig` with stricter C# style and MSTest diagnostic rules. ## [1.0.0] - 2026-05-07 @@ -32,4 +47,4 @@ The format is based on Keep a Changelog. [Unreleased]: https://github.com/Esolang-NET/Abstractions/compare/v2.0.0...HEAD [2.0.0]: https://github.com/Esolang-NET/Abstractions/tree/v2.0.0 -[1.0.0]: https://github.com/Esolang-NET/Abstractions/tree/v1.0.0 \ No newline at end of file +[1.0.0]: https://github.com/Esolang-NET/Abstractions/tree/v1.0.0