From 44792edf3fecbfd8e69f5692dc361c33a723f016 Mon Sep 17 00:00:00 2001 From: James McMahon Date: Thu, 12 Nov 2026 19:44:35 +0000 Subject: [PATCH 01/16] test: configure Microsoft Roslyn testing framework --- .../DimensionalQuantities.Roslyn.Tests.csproj | 4 +++ .../Testing/QuantityAnalyzerTest.cs | 19 ++++++++++++ .../Testing/QuantityCodeFixTest.cs | 17 +++++++++++ .../Testing/QuantityGeneratorReference.cs | 22 ++++++++++++++ .../Testing/QuantityGeneratorTest.cs | 30 +++++++++++++++++++ .../Testing/QuantityTestConfiguration.cs | 18 +++++++++++ 6 files changed, 110 insertions(+) create mode 100644 src/DimensionalQuantities.Roslyn.Tests/Testing/QuantityAnalyzerTest.cs create mode 100644 src/DimensionalQuantities.Roslyn.Tests/Testing/QuantityCodeFixTest.cs create mode 100644 src/DimensionalQuantities.Roslyn.Tests/Testing/QuantityGeneratorReference.cs create mode 100644 src/DimensionalQuantities.Roslyn.Tests/Testing/QuantityGeneratorTest.cs create mode 100644 src/DimensionalQuantities.Roslyn.Tests/Testing/QuantityTestConfiguration.cs diff --git a/src/DimensionalQuantities.Roslyn.Tests/DimensionalQuantities.Roslyn.Tests.csproj b/src/DimensionalQuantities.Roslyn.Tests/DimensionalQuantities.Roslyn.Tests.csproj index 8766356..16b7df2 100644 --- a/src/DimensionalQuantities.Roslyn.Tests/DimensionalQuantities.Roslyn.Tests.csproj +++ b/src/DimensionalQuantities.Roslyn.Tests/DimensionalQuantities.Roslyn.Tests.csproj @@ -16,6 +16,10 @@ + + + + diff --git a/src/DimensionalQuantities.Roslyn.Tests/Testing/QuantityAnalyzerTest.cs b/src/DimensionalQuantities.Roslyn.Tests/Testing/QuantityAnalyzerTest.cs new file mode 100644 index 0000000..8e16c60 --- /dev/null +++ b/src/DimensionalQuantities.Roslyn.Tests/Testing/QuantityAnalyzerTest.cs @@ -0,0 +1,19 @@ +using DimensionalQuantities.Roslyn.Generators; +using Microsoft.CodeAnalysis.CSharp.Testing; +using Microsoft.CodeAnalysis.Diagnostics; +using Microsoft.CodeAnalysis.Testing; + +namespace DimensionalQuantities.Roslyn.Tests.Testing; + +internal sealed class QuantityAnalyzerTest : CSharpAnalyzerTest where TAnalyzer : DiagnosticAnalyzer, new() +{ + public QuantityAnalyzerTest() + { + QuantityTestConfiguration.Apply(this); + TestBehaviors |= TestBehaviors.SkipGeneratedSourcesCheck; + } + + public bool Generate { get; init; } = true; + + protected override IEnumerable GetSourceGenerators() => Generate ? [typeof(QuantityGenerator)] : []; +} diff --git a/src/DimensionalQuantities.Roslyn.Tests/Testing/QuantityCodeFixTest.cs b/src/DimensionalQuantities.Roslyn.Tests/Testing/QuantityCodeFixTest.cs new file mode 100644 index 0000000..975bbcd --- /dev/null +++ b/src/DimensionalQuantities.Roslyn.Tests/Testing/QuantityCodeFixTest.cs @@ -0,0 +1,17 @@ +using DimensionalQuantities.Roslyn.Analyzers; +using DimensionalQuantities.Roslyn.CodeFixes; +using Microsoft.CodeAnalysis.CSharp.Testing; +using Microsoft.CodeAnalysis.Testing; + +namespace DimensionalQuantities.Roslyn.Tests.Testing; + +internal sealed class QuantityCodeFixTest : CSharpCodeFixTest +{ + public QuantityCodeFixTest() + { + QuantityTestConfiguration.Apply(this); + // The fix resolves aliases through its Document, so generation must run in the workspace. + SolutionTransforms.Add((solution, projectId) => solution.AddAnalyzerReference(projectId, new QuantityGeneratorReference())); + } + +} diff --git a/src/DimensionalQuantities.Roslyn.Tests/Testing/QuantityGeneratorReference.cs b/src/DimensionalQuantities.Roslyn.Tests/Testing/QuantityGeneratorReference.cs new file mode 100644 index 0000000..7c675f2 --- /dev/null +++ b/src/DimensionalQuantities.Roslyn.Tests/Testing/QuantityGeneratorReference.cs @@ -0,0 +1,22 @@ +using System.Collections.Immutable; +using DimensionalQuantities.Roslyn.Generators; +using Microsoft.CodeAnalysis; +using Microsoft.CodeAnalysis.Diagnostics; + +namespace DimensionalQuantities.Roslyn.Tests.Testing; + +internal sealed class QuantityGeneratorReference : AnalyzerReference +{ + private readonly ImmutableArray _generators = [new QuantityGenerator().AsSourceGenerator()]; + + public override string? FullPath => null; + + public override object Id => typeof(QuantityGenerator); + + public override ImmutableArray GetAnalyzers(string language) => []; + + public override ImmutableArray GetAnalyzersForAllLanguages() => []; + + public override ImmutableArray GetGenerators(string language) => language == LanguageNames.CSharp + ? _generators : []; +} diff --git a/src/DimensionalQuantities.Roslyn.Tests/Testing/QuantityGeneratorTest.cs b/src/DimensionalQuantities.Roslyn.Tests/Testing/QuantityGeneratorTest.cs new file mode 100644 index 0000000..62a1ddc --- /dev/null +++ b/src/DimensionalQuantities.Roslyn.Tests/Testing/QuantityGeneratorTest.cs @@ -0,0 +1,30 @@ +using System.Collections.Immutable; +using DimensionalQuantities.Roslyn.Generators; +using Microsoft.CodeAnalysis; +using Microsoft.CodeAnalysis.CSharp.Testing; +using Microsoft.CodeAnalysis.Testing; + +namespace DimensionalQuantities.Roslyn.Tests.Testing; + +internal sealed class QuantityGeneratorTest : CSharpSourceGeneratorTest +{ + public QuantityGeneratorTest() + { + QuantityTestConfiguration.Apply(this); + } + + public Compilation Compilation { get; private set; } = null!; + + public Type? AdditionalGenerator { get; init; } + + protected override IEnumerable GetSourceGenerators() => AdditionalGenerator is null + ? [typeof(QuantityGenerator)] : [typeof(QuantityGenerator), AdditionalGenerator]; + + protected override async Task<(Compilation compilation, ImmutableArray generatorDiagnostics)> GetProjectCompilationAsync( + Project project, IVerifier verifier, CancellationToken cancellationToken) + { + (Compilation compilation, ImmutableArray generatorDiagnostics) result = await base.GetProjectCompilationAsync(project, verifier, cancellationToken); + Compilation = result.compilation; + return result; + } +} diff --git a/src/DimensionalQuantities.Roslyn.Tests/Testing/QuantityTestConfiguration.cs b/src/DimensionalQuantities.Roslyn.Tests/Testing/QuantityTestConfiguration.cs new file mode 100644 index 0000000..37577da --- /dev/null +++ b/src/DimensionalQuantities.Roslyn.Tests/Testing/QuantityTestConfiguration.cs @@ -0,0 +1,18 @@ +using DimensionalQuantities.TypeSystem; +using Microsoft.CodeAnalysis; +using Microsoft.CodeAnalysis.CSharp; +using Microsoft.CodeAnalysis.Testing; + +namespace DimensionalQuantities.Roslyn.Tests.Testing; + +internal static class QuantityTestConfiguration +{ + public static void Apply(AnalyzerTest test) where TVerifier : IVerifier, new() + { + test.ReferenceAssemblies = new ReferenceAssemblies("net11.0"); + test.TestState.AdditionalReferences.AddRange(((string)AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES")!) + .Split(Path.PathSeparator).Select(path => MetadataReference.CreateFromFile(path))); + test.TestState.AdditionalReferences.Add(MetadataReference.CreateFromFile(typeof(Quantity<>).Assembly.Location)); + test.SolutionTransforms.Add((solution, projectId) => solution.WithProjectParseOptions(projectId, new CSharpParseOptions(LanguageVersion.Preview))); + } +} From 2ef9380b70a5b45ce352bf66acc67713e07b3c0c Mon Sep 17 00:00:00 2001 From: James McMahon Date: Thu, 12 Nov 2026 19:44:35 +0000 Subject: [PATCH 02/16] test: migrate analyser and code-fix verification --- .../Analyzers/AnalyzerTestCompilation.cs | 35 ------- .../DimensionMismatchAnalyzerTests.cs | 97 +++++++++++-------- .../QuantityEncodingAnalyzerTests.cs | 55 ++++++----- .../QuantityAliasCodeFixProviderTests.cs | 96 ++++++++---------- 4 files changed, 128 insertions(+), 155 deletions(-) delete mode 100644 src/DimensionalQuantities.Roslyn.Tests/Analyzers/AnalyzerTestCompilation.cs diff --git a/src/DimensionalQuantities.Roslyn.Tests/Analyzers/AnalyzerTestCompilation.cs b/src/DimensionalQuantities.Roslyn.Tests/Analyzers/AnalyzerTestCompilation.cs deleted file mode 100644 index 3a584f5..0000000 --- a/src/DimensionalQuantities.Roslyn.Tests/Analyzers/AnalyzerTestCompilation.cs +++ /dev/null @@ -1,35 +0,0 @@ -using System.Collections.Immutable; -using DimensionalQuantities.Roslyn.Generators; -using DimensionalQuantities.TypeSystem; -using Microsoft.CodeAnalysis; -using Microsoft.CodeAnalysis.CSharp; -using Microsoft.CodeAnalysis.Diagnostics; - -namespace DimensionalQuantities.Roslyn.Tests.Analyzers; - -internal static class AnalyzerTestCompilation -{ - public static CSharpCompilation Create(string source, bool generate = true) - { - CSharpParseOptions options = new(LanguageVersion.Preview); - string[] assemblies = ((string)AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES")!).Split(Path.PathSeparator); - IEnumerable references = assemblies.Select(path => MetadataReference.CreateFromFile(path)) - .Append(MetadataReference.CreateFromFile(typeof(Quantity<>).Assembly.Location)); - CSharpCompilation compilation = CSharpCompilation.Create("AnalyzerConsumer", - [CSharpSyntaxTree.ParseText(source, options, "Consumer.cs")], references, new(OutputKind.DynamicallyLinkedLibrary)); - if (!generate) - { - return compilation; - } - - GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: options); - driver.RunGeneratorsAndUpdateCompilation(compilation, out Compilation generated, out _); - return (CSharpCompilation)generated; - } - - public static async Task> Analyze(string source, DiagnosticAnalyzer analyzer, bool generate = true) - { - CSharpCompilation compilation = Create(source, generate); - return await compilation.WithAnalyzers([analyzer]).GetAnalyzerDiagnosticsAsync(Xunit.TestContext.Current.CancellationToken); - } -} diff --git a/src/DimensionalQuantities.Roslyn.Tests/Analyzers/DimensionMismatchAnalyzerTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Analyzers/DimensionMismatchAnalyzerTests.cs index c7368cb..210eaff 100644 --- a/src/DimensionalQuantities.Roslyn.Tests/Analyzers/DimensionMismatchAnalyzerTests.cs +++ b/src/DimensionalQuantities.Roslyn.Tests/Analyzers/DimensionMismatchAnalyzerTests.cs @@ -1,6 +1,8 @@ -using System.Collections.Immutable; using DimensionalQuantities.Roslyn.Analyzers; using Microsoft.CodeAnalysis; +using Microsoft.CodeAnalysis.Testing; +using Microsoft.CodeAnalysis.CSharp.Testing; +using DimensionalQuantities.Roslyn.Tests.Testing; using Xunit; namespace DimensionalQuantities.Roslyn.Tests.Analyzers; @@ -21,41 +23,39 @@ public async Task IncompatibleOperandsExplainTheirDimensions(string operation) string source = $$""" public class Consumer { - public object Calculate(Length length, Current current) => length {{operation}} current; + public object Calculate(Length length, Current current) => {|#0:length {{operation}} current|}; } """; - Diagnostic result = Assert.Single(await AnalyzerTestCompilation.Analyze(source, new DimensionMismatchAnalyzer())); - Assert.Multiple( - () => Assert.Equal("DQ0001", result.Id), - () => Assert.Equal(DiagnosticSeverity.Error, result.Severity), - () => Assert.Contains("Length", result.GetMessage()), - () => Assert.Contains("Current", result.GetMessage()), - () => Assert.Equal($"length {operation} current", source.Substring(result.Location.SourceSpan.Start, result.Location.SourceSpan.Length))); + await new QuantityAnalyzerTest + { + TestCode = source, + CompilerDiagnostics = CompilerDiagnostics.None, + ExpectedDiagnostics = { new DiagnosticResult(DimensionMismatchAnalyzer.IncompatibleOperands).WithLocation(0).WithArguments(operation, "Length", "Current") }, + }.RunAsync(TestContext.Current.CancellationToken); } [Theory] - [InlineData("public void Calculate(Length length) { Current current = length; }")] - [InlineData("public void Calculate(Length length, Current current) { current = length; }")] - [InlineData("public Current Calculate(Length length) => length;")] - [InlineData("public Current Calculate(Length length) { return length; }")] - [InlineData("public void Calculate(Length length) { Accept(length); } private void Accept(Current current) { }")] - [InlineData("public void Calculate(Length length) { Accept(current: length); } private void Accept(Current current) { }")] - [InlineData("public object Calculate(Length length, Current current) => Current.Min(current, length);")] - [InlineData("public object Calculate(Length length, Current current) => Current.Clamp(current, current, length);")] - [InlineData("public Current Value { get; } = Length.FromMetres(1);")] - [InlineData("public Current Value => Length.FromMetres(1);")] - [InlineData("public Current this[int index] => Length.FromMetres(1);")] - [InlineData("public Consumer(Current current) { } public object Calculate(Length length) => new Consumer(length);")] + [InlineData("public void Calculate(Length length) { Current current = {|#0:length|}; }")] + [InlineData("public void Calculate(Length length, Current current) { current = {|#0:length|}; }")] + [InlineData("public Current Calculate(Length length) => {|#0:length|};")] + [InlineData("public Current Calculate(Length length) { return {|#0:length|}; }")] + [InlineData("public void Calculate(Length length) { Accept({|#0:length|}); } private void Accept(Current current) { }")] + [InlineData("public void Calculate(Length length) { Accept(current: {|#0:length|}); } private void Accept(Current current) { }")] + [InlineData("public object Calculate(Length length, Current current) => Current.Min(current, {|#0:length|});")] + [InlineData("public object Calculate(Length length, Current current) => Current.Clamp(current, current, {|#0:length|});")] + [InlineData("public Current Value { get; } = {|#0:Length.FromMetres(1)|};")] + [InlineData("public Current Value => {|#0:Length.FromMetres(1)|};")] + [InlineData("public Current this[int index] => {|#0:Length.FromMetres(1)|};")] + [InlineData("public Consumer(Current current) { } public object Calculate(Length length) => new Consumer({|#0:length|});")] public async Task WrongDestinationExplainsExpectedAndActualDimensions(string member) { string source = $"public class Consumer {{ {member} }}"; - Diagnostic result = Assert.Single(await AnalyzerTestCompilation.Analyze(source, new DimensionMismatchAnalyzer())); - Assert.Multiple( - () => Assert.Equal("DQ0002", result.Id), - () => Assert.Equal(DiagnosticSeverity.Error, result.Severity), - () => Assert.Contains("Expected Current", result.GetMessage()), - () => Assert.Contains("Length", result.GetMessage()), - () => Assert.Equal("Consumer.cs", result.Location.SourceTree!.FilePath)); + await new QuantityAnalyzerTest + { + TestCode = source, + CompilerDiagnostics = CompilerDiagnostics.None, + ExpectedDiagnostics = { new DiagnosticResult(DimensionMismatchAnalyzer.WrongDestination).WithLocation(0).WithArguments("Current", "Length") }, + }.RunAsync(TestContext.Current.CancellationToken); } [Theory] @@ -70,8 +70,12 @@ public async Task WrongDestinationExplainsExpectedAndActualDimensions(string mem [InlineData("public void Calculate(Length length) { Accept(length); } private void Accept(Length value) { } private void Accept(Current value) { }")] public async Task ValidOrUnrelatedCodeDoesNotProduceDiagnostics(string member) { - ImmutableArray result = await AnalyzerTestCompilation.Analyze($"public class Consumer {{ {member} }}", new DimensionMismatchAnalyzer()); - Assert.Empty(result); + string source = $"public class Consumer {{ {member} }}"; + await new QuantityAnalyzerTest + { + TestCode = source, + CompilerDiagnostics = CompilerDiagnostics.None, + }.RunAsync(TestContext.Current.CancellationToken); } [Theory] @@ -79,17 +83,25 @@ public async Task ValidOrUnrelatedCodeDoesNotProduceDiagnostics(string member) [InlineData("-=")] public async Task CompoundAssignmentsExplainIncompatibleDimensions(string operation) { - string source = $"public class Consumer {{ public void Calculate(Length length, Current current) {{ length {operation} current; }} }}"; - Diagnostic result = Assert.Single(await AnalyzerTestCompilation.Analyze(source, new DimensionMismatchAnalyzer())); - Assert.Equal("DQ0001", result.Id); + string source = $"public class Consumer {{ public void Calculate(Length length, Current current) {{ {{|#0:length {operation} current|}}; }} }}"; + await new QuantityAnalyzerTest + { + TestCode = source, + CompilerDiagnostics = CompilerDiagnostics.None, + ExpectedDiagnostics = { new DiagnosticResult(DimensionMismatchAnalyzer.IncompatibleOperands).WithLocation(0).WithArguments(operation, "Length", "Current") }, + }.RunAsync(TestContext.Current.CancellationToken); } [Fact] public async Task NullableOperandsStillExplainDimensions() { - const string source = "public class Consumer { public object Calculate(Length? length, Current? current) => length + current; }"; - Diagnostic result = Assert.Single(await AnalyzerTestCompilation.Analyze(source, new DimensionMismatchAnalyzer())); - Assert.Equal("DQ0001", result.Id); + const string source = "public class Consumer { public object Calculate(Length? length, Current? current) => {|#0:length + current|}; }"; + await new QuantityAnalyzerTest + { + TestCode = source, + CompilerDiagnostics = CompilerDiagnostics.None, + ExpectedDiagnostics = { new DiagnosticResult(DimensionMismatchAnalyzer.IncompatibleOperands).WithLocation(0).WithArguments("+", "Length", "Current") }, + }.RunAsync(TestContext.Current.CancellationToken); } [Fact] @@ -105,16 +117,17 @@ public static class Custom } public class Consumer { public double Calculate(Length length, Current current) => length + current; } """; - ImmutableArray result = await AnalyzerTestCompilation.Analyze(source, new DimensionMismatchAnalyzer()); - Assert.Empty(result); + await new QuantityAnalyzerTest + { + TestCode = source, + CompilerDiagnostics = CompilerDiagnostics.None, + }.RunAsync(TestContext.Current.CancellationToken); } [Fact] public async Task UnrelatedCompilationWithoutLibraryDoesNotCrash() { - Microsoft.CodeAnalysis.CSharp.CSharpCompilation compilation = Microsoft.CodeAnalysis.CSharp.CSharpCompilation.Create("Empty"); - ImmutableArray result = await Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzerExtensions.WithAnalyzers(compilation, - [new DimensionMismatchAnalyzer()], options: null).GetAnalyzerDiagnosticsAsync(Xunit.TestContext.Current.CancellationToken); - Assert.Empty(result); + await new CSharpAnalyzerTest { TestCode = "class Consumer { }" } + .RunAsync(TestContext.Current.CancellationToken); } } diff --git a/src/DimensionalQuantities.Roslyn.Tests/Analyzers/QuantityEncodingAnalyzerTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Analyzers/QuantityEncodingAnalyzerTests.cs index 36010d3..ba3bf9d 100644 --- a/src/DimensionalQuantities.Roslyn.Tests/Analyzers/QuantityEncodingAnalyzerTests.cs +++ b/src/DimensionalQuantities.Roslyn.Tests/Analyzers/QuantityEncodingAnalyzerTests.cs @@ -1,6 +1,7 @@ -using System.Collections.Immutable; using DimensionalQuantities.Roslyn.Analyzers; using Microsoft.CodeAnalysis; +using Microsoft.CodeAnalysis.Testing; +using DimensionalQuantities.Roslyn.Tests.Testing; using Xunit; namespace DimensionalQuantities.Roslyn.Tests.Analyzers; @@ -12,12 +13,12 @@ public sealed class QuantityEncodingAnalyzerTests [Fact] public async Task RawQuantitySuggestsReadableAlias() { - string source = $"using DimensionalQuantities.TypeSystem; public class Consumer {{ public {LengthType} Value {{ get; }} }}"; - Diagnostic result = Assert.Single(await AnalyzerTestCompilation.Analyze(source, new QuantityEncodingAnalyzer())); - Assert.Multiple( - () => Assert.Equal("DQ0003", result.Id), - () => Assert.Contains("Length", result.GetMessage()), - () => Assert.Equal(LengthType, source.Substring(result.Location.SourceSpan.Start, result.Location.SourceSpan.Length))); + string source = $"using DimensionalQuantities.TypeSystem; public class Consumer {{ public {{|#0:{LengthType}|}} Value {{ get; }} }}"; + await new QuantityAnalyzerTest + { + TestCode = source, + ExpectedDiagnostics = { new DiagnosticResult(QuantityEncodingAnalyzer.ReadableAlias).WithLocation(0).WithArguments("Length") }, + }.RunAsync(TestContext.Current.CancellationToken); } [Theory] @@ -28,12 +29,13 @@ public async Task NonCanonicalEncodingExplainsDistinctTypeIdentity(string expone string type = $"global::DimensionalQuantities.TypeSystem.Quantity>"; - string source = $"using MyLength = {type}; public class Consumer {{ }}"; - ImmutableArray results = await AnalyzerTestCompilation.Analyze(source, new QuantityEncodingAnalyzer()); - Diagnostic result = Assert.Single(results); - Assert.Multiple( - () => Assert.Equal("DQ0004", result.Id), - () => Assert.Equal(DiagnosticSeverity.Warning, result.Severity)); + string markedType = type.Replace("Quantity<", "{|#0:Quantity<") + "|}"; + string source = $"using MyLength = {markedType}; public class Consumer {{ }}"; + await new QuantityAnalyzerTest + { + TestCode = source, + ExpectedDiagnostics = { new DiagnosticResult(QuantityEncodingAnalyzer.NonCanonical).WithLocation(0) }, + }.RunAsync(TestContext.Current.CancellationToken); } [Theory] @@ -42,11 +44,14 @@ public async Task NonCanonicalEncodingExplainsDistinctTypeIdentity(string expone [InlineData("Quantity, TerminalHex0, TerminalHex0, TerminalHex0, TerminalHex0, TerminalHex0, TerminalHex0>>")] public async Task InvalidClosedEncodingIsDiagnosedWithoutAnalyzerCrash(string type) { - string source = $"using DimensionalQuantities.TypeSystem; public class Consumer {{ public {type} Value {{ get; }} }}"; - Diagnostic result = Assert.Single(await AnalyzerTestCompilation.Analyze(source, new QuantityEncodingAnalyzer(), generate: false)); - Assert.Multiple( - () => Assert.Equal("DQ0005", result.Id), - () => Assert.Equal(DiagnosticSeverity.Error, result.Severity)); + string source = $"using DimensionalQuantities.TypeSystem; public class Consumer {{ public {{|#0:{type}|}} Value {{ get; }} }}"; + await new QuantityAnalyzerTest + { + TestCode = source, + Generate = false, + CompilerDiagnostics = CompilerDiagnostics.None, + ExpectedDiagnostics = { new DiagnosticResult(QuantityEncodingAnalyzer.Invalid).WithLocation(0) }, + }.RunAsync(TestContext.Current.CancellationToken); } [Theory] @@ -55,8 +60,12 @@ public async Task InvalidClosedEncodingIsDiagnosedWithoutAnalyzerCrash(string ty public async Task UnresolvedArgumentsDoNotProduceEncodingDiagnostics(string type) { string source = $"using DimensionalQuantities.TypeSystem; public class Consumer {{ public {type} Value {{ get; }} }}"; - ImmutableArray result = await AnalyzerTestCompilation.Analyze(source, new QuantityEncodingAnalyzer(), generate: false); - Assert.Empty(result); + await new QuantityAnalyzerTest + { + TestCode = source, + Generate = false, + CompilerDiagnostics = CompilerDiagnostics.None, + }.RunAsync(TestContext.Current.CancellationToken); } [Theory] @@ -66,7 +75,9 @@ public async Task UnresolvedArgumentsDoNotProduceEncodingDiagnostics(string type [InlineData("public class Quantity { } public class Consumer { public Quantity Value { get; } }")] public async Task DeliberateAliasesOpenGenericsAndUnrelatedTypesAreAllowed(string source) { - ImmutableArray result = await AnalyzerTestCompilation.Analyze(source, new QuantityEncodingAnalyzer()); - Assert.Empty(result); + await new QuantityAnalyzerTest + { + TestCode = source, + }.RunAsync(TestContext.Current.CancellationToken); } } diff --git a/src/DimensionalQuantities.Roslyn.Tests/CodeFixes/QuantityAliasCodeFixProviderTests.cs b/src/DimensionalQuantities.Roslyn.Tests/CodeFixes/QuantityAliasCodeFixProviderTests.cs index e2e6779..4c1f9cb 100644 --- a/src/DimensionalQuantities.Roslyn.Tests/CodeFixes/QuantityAliasCodeFixProviderTests.cs +++ b/src/DimensionalQuantities.Roslyn.Tests/CodeFixes/QuantityAliasCodeFixProviderTests.cs @@ -1,13 +1,6 @@ -using System.Collections.Immutable; using DimensionalQuantities.Roslyn.Analyzers; -using DimensionalQuantities.Roslyn.CodeFixes; -using DimensionalQuantities.Roslyn.Tests.Analyzers; -using Microsoft.CodeAnalysis; -using Microsoft.CodeAnalysis.CodeActions; -using Microsoft.CodeAnalysis.CodeFixes; -using Microsoft.CodeAnalysis.CSharp; -using Microsoft.CodeAnalysis.Diagnostics; -using Microsoft.CodeAnalysis.Text; +using DimensionalQuantities.Roslyn.Tests.Testing; +using Microsoft.CodeAnalysis.Testing; using Xunit; namespace DimensionalQuantities.Roslyn.Tests.CodeFixes; @@ -29,66 +22,57 @@ public sealed class QuantityAliasCodeFixProviderTests [InlineData("public class Consumer { public TYPE Value { get; } }", "public class Consumer { public LengthCurrent Value { get; } }", LengthCurrentType)] public async Task FixUsesAliasAndPreservesSurroundingSource(string template, string expected, string? rawType = null) { - string source = template.Replace("TYPE", rawType ?? LengthType); - using AdhocWorkspace workspace = new(); - Document document = CreateDocument(workspace, source); - Compilation compilation = (await document.Project.GetCompilationAsync(TestContext.Current.CancellationToken))!; - Diagnostic diagnostic = Assert.Single(await compilation.WithAnalyzers([new QuantityEncodingAnalyzer()]).GetAnalyzerDiagnosticsAsync(TestContext.Current.CancellationToken)); - List actions = []; - QuantityAliasCodeFixProvider provider = new(); - await provider.RegisterCodeFixesAsync(new(document, diagnostic, (action, _) => actions.Add(action), TestContext.Current.CancellationToken)); - CodeAction action = Assert.Single(actions); - ImmutableArray operations = await action.GetOperationsAsync(TestContext.Current.CancellationToken); - ApplyChangesOperation changes = Assert.Single(operations.OfType()); - Document changed = changes.ChangedSolution.GetDocument(document.Id)!; - string result = (await changed.GetTextAsync(TestContext.Current.CancellationToken)).ToString(); - CSharpCompilation finalCompilation = AnalyzerTestCompilation.Create(result); - Assert.Multiple( - () => Assert.Equal(expected, result), - () => Assert.DoesNotContain(finalCompilation.GetDiagnostics(TestContext.Current.CancellationToken), diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)); + string marked = template.Replace("TYPE", (rawType ?? LengthType).Replace("Quantity<", "{|#0:Quantity<") + "|}"); + await new QuantityCodeFixTest + { + TestCode = marked, + FixedCode = expected, + ExpectedDiagnostics = { new DiagnosticResult(QuantityEncodingAnalyzer.ReadableAlias).WithLocation(0).WithArguments(rawType is null ? "Length" : "LengthCurrent") }, + }.RunAsync(TestContext.Current.CancellationToken); } [Fact] public async Task NameOfDoesNotOfferFixThatChangesTheReturnedName() { string source = $"public class Consumer {{ public string Value() => nameof({LengthType}); }}"; - using AdhocWorkspace workspace = new(); - Document document = CreateDocument(workspace, source); - Compilation compilation = (await document.Project.GetCompilationAsync(TestContext.Current.CancellationToken))!; - Diagnostic diagnostic = Assert.Single(await compilation.WithAnalyzers([new QuantityEncodingAnalyzer()]).GetAnalyzerDiagnosticsAsync(TestContext.Current.CancellationToken)); - List actions = []; - QuantityAliasCodeFixProvider provider = new(); - await provider.RegisterCodeFixesAsync(new(document, diagnostic, (action, _) => actions.Add(action), TestContext.Current.CancellationToken)); - Assert.Empty(actions); + string marked = source.Replace(LengthType, LengthType.Replace("Quantity<", "{|#0:Quantity<") + "|}"); + await new QuantityCodeFixTest + { + TestCode = marked, + FixedCode = source, + FixedState = + { + ExpectedDiagnostics = + { + new DiagnosticResult(QuantityEncodingAnalyzer.ReadableAlias) + .WithSpan(1, source.IndexOf("Quantity<", StringComparison.Ordinal) + 1, + 1, source.IndexOf(LengthType, StringComparison.Ordinal) + LengthType.Length + 1).WithArguments("Length"), + }, + }, + ExpectedDiagnostics = { new DiagnosticResult(QuantityEncodingAnalyzer.ReadableAlias).WithLocation(0).WithArguments("Length") }, + }.RunAsync(TestContext.Current.CancellationToken); } [Fact] public async Task ShadowedAliasDoesNotOfferUnsafeFix() { string source = $"namespace ConsumerNamespace {{ public class Length {{ }} public class Consumer {{ public {LengthType} Value {{ get; }} }} }}"; - using AdhocWorkspace workspace = new(); - Document document = CreateDocument(workspace, source); - Compilation compilation = (await document.Project.GetCompilationAsync(TestContext.Current.CancellationToken))!; - ImmutableArray diagnostics = await compilation.WithAnalyzers([new QuantityEncodingAnalyzer()]).GetAnalyzerDiagnosticsAsync(TestContext.Current.CancellationToken); - List actions = []; - QuantityAliasCodeFixProvider provider = new(); - foreach (Diagnostic diagnostic in diagnostics.Where(diagnostic => diagnostic.Id == "DQ0003")) + string marked = source.Replace(LengthType, LengthType.Replace("Quantity<", "{|#0:Quantity<") + "|}"); + await new QuantityCodeFixTest { - await provider.RegisterCodeFixesAsync(new(document, diagnostic, (action, _) => actions.Add(action), TestContext.Current.CancellationToken)); - } - Assert.Empty(actions); + TestCode = marked, + FixedCode = source, + FixedState = + { + ExpectedDiagnostics = + { + new DiagnosticResult(QuantityEncodingAnalyzer.ReadableAlias) + .WithSpan(1, source.IndexOf("Quantity<", StringComparison.Ordinal) + 1, + 1, source.IndexOf(LengthType, StringComparison.Ordinal) + LengthType.Length + 1).WithArguments("Length"), + }, + }, + ExpectedDiagnostics = { new DiagnosticResult(QuantityEncodingAnalyzer.ReadableAlias).WithLocation(0).WithArguments("Length") }, + }.RunAsync(TestContext.Current.CancellationToken); } - private static Document CreateDocument(AdhocWorkspace workspace, string source) - { - CSharpCompilation compilation = AnalyzerTestCompilation.Create(source); - Project project = workspace.AddProject(ProjectInfo.Create(ProjectId.CreateNewId(), VersionStamp.Create(), "Consumer", "Consumer", LanguageNames.CSharp, - compilationOptions: compilation.Options, parseOptions: new CSharpParseOptions(LanguageVersion.Preview), metadataReferences: compilation.References)); - Document userDocument = workspace.AddDocument(project.Id, "Consumer.cs", SourceText.From(source)); - foreach (SyntaxTree tree in compilation.SyntaxTrees.Where(tree => tree.FilePath != "Consumer.cs")) - { - workspace.AddDocument(project.Id, Path.GetFileName(tree.FilePath), tree.GetText()); - } - return workspace.CurrentSolution.GetDocument(userDocument.Id)!; - } } From 13aff7e538d4ef88eedb9b6de02c4378e7933848 Mon Sep 17 00:00:00 2001 From: James McMahon Date: Thu, 12 Nov 2026 19:44:35 +0000 Subject: [PATCH 03/16] test: migrate generator verification and consumer execution --- .../Packaging/PackagedArithmeticTests.cs | 529 ++++++ .../Packaging/PackagedGeneratorTests.cs | 2 +- .../Packaging/PackagedUnitProviderTests.cs | 271 +++ .../Generators/CoreConversionBoundaryTests.cs | 41 +- .../Generators/GenerationDiagnosticTests.cs | 201 +- .../Generators/QuantityGeneratorTests.cs | 1633 +++++++++-------- .../Generators/UnitProviderGenerationTests.cs | 333 +--- 7 files changed, 1792 insertions(+), 1218 deletions(-) create mode 100644 src/DimensionalQuantities.IntegrationTests/Packaging/PackagedArithmeticTests.cs create mode 100644 src/DimensionalQuantities.IntegrationTests/Packaging/PackagedUnitProviderTests.cs diff --git a/src/DimensionalQuantities.IntegrationTests/Packaging/PackagedArithmeticTests.cs b/src/DimensionalQuantities.IntegrationTests/Packaging/PackagedArithmeticTests.cs new file mode 100644 index 0000000..caf5bfc --- /dev/null +++ b/src/DimensionalQuantities.IntegrationTests/Packaging/PackagedArithmeticTests.cs @@ -0,0 +1,529 @@ +using Microsoft.Build.Utilities.ProjectCreation; +using Xunit; + +namespace DimensionalQuantities.IntegrationTests.Packaging; + +public sealed partial class PackagedGeneratorTests +{ + + [Theory] + [InlineData("Length.FromMetres(2) * Length.FromMetres(3)", "Area", 6)] + [InlineData("Current.FromAmps(2) * Current.FromAmps(3)", "CurrentSquared", 6)] + [InlineData("Current.FromAmps(2) * Current.FromAmps(3) * Resistance.FromSiBaseUnit(4)", "Power", 24)] + [InlineData("Current.FromAmps(2) * (Current.FromAmps(3) * Resistance.FromSiBaseUnit(4))", "Power", 24)] + [InlineData("Voltage.FromSiBaseUnit(12) / Current.FromAmps(3)", "Resistance", 4)] + [InlineData("Current.FromAmps(3) * Time.FromSeconds(2)", "TimeCurrent", 6)] + [InlineData("(Current.FromAmps(2) * Time.FromSeconds(3)) / Time.FromSeconds(3)", "Current", 2)] + [InlineData("(Voltage.FromSiBaseUnit(4) * Current.FromAmps(3)) / Current.FromAmps(2)", "Voltage", 6)] + [InlineData("Current.FromAmps(3) * 2d", "Current", 6)] + [InlineData("2 * Current.FromAmps(3)", "Current", 6)] + [InlineData("Current.FromAmps(6) / 2f", "Current", 3)] + [InlineData("2d / Time.FromSeconds(4)", "Frequency", 0.5)] + [InlineData("2f / Current.FromAmps(4)", "InverseCurrent", 0.5)] + [InlineData("(2 / Current.FromAmps(4)) * Time.FromSeconds(3)", "TimePerCurrent", 1.5)] + [InlineData("(Current.FromAmps(2) * 2) * Current.FromAmps(3)", "CurrentSquared", 12)] + [InlineData("2 * (Current.FromAmps(2) * Current.FromAmps(3))", "CurrentSquared", 12)] + [InlineData("(Current.FromAmps(2) * Current.FromAmps(3)) / 2", "CurrentSquared", 3)] + [InlineData("(2 + 3) * Current.FromAmps(2) * Current.FromAmps(3)", "CurrentSquared", 30)] + [InlineData("(2 * 3) * Current.FromAmps(2) * Current.FromAmps(3)", "CurrentSquared", 36)] + public void QuantityArithmeticProducesTheExpectedTypeAndSiMagnitude(string arithmetic, string resultType, double expected) + { + string expression = $"(({resultType})({arithmetic})).AsSiBaseUnit()"; + double result = Evaluate(expression); + + Assert.Equal(expected, result); + } + + + [Theory] + [InlineData("Current.FromAmps(2) + Current.FromMilliAmps(500)", "AsAmps", 2.5)] + [InlineData("Current.FromAmps(2) - Current.FromMilliAmps(500)", "AsAmps", 1.5)] + [InlineData("-Current.FromMilliAmps(500)", "AsAmps", -0.5)] + [InlineData("Energy.FromSiBaseUnit(2) + Torque.FromSiBaseUnit(3)", "AsSiBaseUnit", 5)] + public void SameDimensionArithmeticUsesCoreOperatorsWithoutGeneratedOverloads(string expression, string accessor, double expected) + { + string source = $$""" + public static class Consumer + { + public static double Value() => ({{expression}}).{{accessor}}(); + } + """; + double result = EvaluateSource(source); + + Assert.Equal(expected, result); + } + + [Theory] + [InlineData("firstSquared + secondSquared", 52)] + [InlineData("firstSquared - secondSquared", 20)] + [InlineData("-firstSquared", -36)] + public void SameDimensionArithmeticThroughInferredLocalsCompilesAndExecutes(string expression, double expected) + { + string source = $$""" + public static class Consumer + { + public static double Value() + { + Current first = Current.FromAmps(3); + Current second = Current.FromAmps(2); + Resistance resistance = Resistance.FromSiBaseUnit(4); + var firstSquared = first * first; + var secondSquared = second * second; + var combined = {{expression}}; + var heating = combined * resistance; + return ((Power)heating).AsSiBaseUnit(); + } + } + """; + double result = EvaluateSource(source); + + Assert.Equal(expected, result); + } + + [Theory] + [InlineData("((Current.FromAmps(3) * Current.FromAmps(3) + Current.FromAmps(2) * Current.FromAmps(2)) * Resistance.FromSiBaseUnit(4)).AsSiBaseUnit()", 52)] + [InlineData("((Current.FromAmps(3) * Current.FromAmps(3) - Current.FromAmps(2) * Current.FromAmps(2)) * Resistance.FromSiBaseUnit(4)).AsSiBaseUnit()", 20)] + [InlineData("(-(Current.FromAmps(3) * Current.FromAmps(3))).AsSiBaseUnit()", -9)] + public void SameDimensionArithmeticAroundNestedProductsCompilesAndExecutes(string expression, double expected) + { + double result = Evaluate(expression); + + Assert.Equal(expected, result); + } + + [Theory] + [InlineData("Length.FromMetres(3) / Length.FromMilliMetres(500)", 6)] + [InlineData("Energy.FromSiBaseUnit(6) / Torque.FromSiBaseUnit(2)", 3)] + [InlineData("Current.FromAmps(3) * (2 / Current.FromAmps(3))", 2)] + [InlineData("(2 / Current.FromAmps(3)) * Current.FromAmps(3)", 2)] + [InlineData("(Current.FromAmps(3) * Current.FromAmps(3)) / (Current.FromAmps(2) * Current.FromAmps(2))", 2.25)] + [InlineData("(Length.FromMetres(3) / Length.FromMetres(1)) + (Current.FromAmps(4) / Current.FromAmps(2))", 5)] + public void CancelledDimensionsCompileAndExecuteAsDouble(string expression, double expected) + { + double result = Evaluate(expression); + + Assert.Equal(expected, result); + } + + [Theory] + [InlineData("var ratio = first / second;", "(ratio * time).AsSeconds()", 6)] + [InlineData("var firstSquared = first * first; var secondSquared = second * second; var ratio = firstSquared / secondSquared;", "(ratio * time).AsSeconds()", 9)] + [InlineData("var inverse = 2 / first; var ratio = first * inverse; var copy = ratio;", "(copy * time).AsSeconds()", 8)] + [InlineData("var inverse = 2 / first; var ratio = first * inverse;", "(time / ratio).AsSeconds()", 2)] + [InlineData("var inverse = 2 / first; var ratio = first * inverse; var scaled = (ratio + 1) * first;", "(scaled * time).AsSiBaseUnit()", 36)] + [InlineData("var ratio = first / second; var inverseTime = ratio / time;", "inverseTime.AsSiBaseUnit()", 0.375)] + public void CancelledLocalsCanBeUsedAsScalarOperands(string declarations, string expression, double expected) + { + string source = $$""" + public static class Consumer + { + public static double Value() + { + Current first = Current.FromAmps(3); + Current second = Current.FromAmps(2); + Time time = Time.FromSeconds(4); + {{declarations}} + return {{expression}}; + } + } + """; + double result = EvaluateSource(source); + + Assert.Equal(expected, result); + } + + [Theory] + [InlineData("TerminalHex2", 3, 9)] + [InlineData("TerminalHex3", 3, 27)] + [InlineData("TerminalHex1", 3, 3)] + [InlineData("Hex", 2, 65536)] + [InlineData("Negative", 2, 0.25)] + [InlineData("Fraction", 9, 3)] + [InlineData("Fraction", 9, 3)] + [InlineData("Fraction", -8, -2)] + [InlineData("Fraction", -8, 4)] + [InlineData("Fraction, TerminalHex3>", -8, -0.5)] + public void EncodedPowersCompileAndExecute(string exponent, double value, double expected) + { + string source = $$""" + using DimensionalQuantities.TypeSystem; + public static class Consumer + { + public static double Value() => Power<{{exponent}}>.Of(Length.FromMetres({{value.ToString(System.Globalization.CultureInfo.InvariantCulture)}})).AsSiBaseUnit(); + } + """; + double result = EvaluateSource(source); + + Assert.Equal(expected, result, 12); + } + + [Theory] + [InlineData("NumberTwo", 3, 9)] + [InlineData("NumberSeventeen", 2, 131072)] + [InlineData("NumberMinusTwo", 2, 0.25)] + [InlineData("NumberHalf", 9, 3)] + [InlineData("NumberTwoQuarters", 9, 3)] + [InlineData("NumberTwoOverThree", -8, 4)] + [InlineData("NumberMinusOneOverThree", -8, -0.5)] + [InlineData("NumberMillionth", 1, 1)] + public void EnglishPowersCompileAndExecute(string exponent, double value, double expected) + { + string source = $$""" + using DimensionalQuantities.TypeSystem; + public static class Consumer + { + public static double Value() => Power<{{exponent}}>.Of(Length.FromMetres({{value.ToString(System.Globalization.CultureInfo.InvariantCulture)}})).AsSiBaseUnit(); + } + """; + double result = EvaluateSource(source); + + Assert.Equal(expected, result, 12); + } + + [Fact] + public void EnglishPowersWorkWithNestedCallsArithmeticAndLocals() + { + const string source = """ + using DimensionalQuantities.TypeSystem; + public static class Consumer + { + public static double Value() + { + var squared = Power.Of(Current.FromAmps(3)); + var root = Power.Of(squared); + Voltage voltage = root * Resistance.FromSiBaseUnit(4); + Current nested = Power.Of(Power.Of(root)); + return voltage.AsSiBaseUnit() + nested.AsAmps(); + } + } + """; + double result = EvaluateSource(source); + + Assert.Equal(15, result); + } + + [Fact] + public void EnglishLookingUserAliasKeepsItsDeclaredExponent() + { + const string source = """ + using DimensionalQuantities.TypeSystem; + using NumberTwo = DimensionalQuantities.TypeSystem.TerminalHex3; + public static class Consumer + { + public static double Value() => Power.Of(Length.FromMetres(3)).AsSiBaseUnit(); + } + """; + double result = EvaluateSource(source); + + Assert.Equal(27, result); + } + + [Fact] + public void EquivalentEnglishNamesShareTheEncodedTypeAndPowerOverload() + { + const string source = """ + using DimensionalQuantities.TypeSystem; + public static class Consumer + { + public static bool Value() + { + Length first = Power.Of(Area.FromSiBaseUnit(9)); + Length second = Power.Of(Area.FromSiBaseUnit(9)); + Length third = Power>.Of(Area.FromSiBaseUnit(9)); + return first == second && second == third && typeof(NumberHalf) == typeof(NumberTwoQuarters) + && typeof(NumberHalf) == typeof(Fraction); + } + } + """; + + Assert.True(EvaluateSource(source)); + } + + [Fact] + public void EnglishZerothPowerReturnsDouble() + { + const string source = """ + using DimensionalQuantities.TypeSystem; + public static class Consumer + { + public static double Value() => Power.Of(Length.FromMetres(3)); + } + """; + + Assert.Equal(1, EvaluateSource(source)); + } + + [Fact] + public void PowersReturnExistingQuantityTypesWhenCalledThroughAliases() + { + const string source = """ + using DimensionalQuantities.TypeSystem; + using Two = DimensionalQuantities.TypeSystem.TerminalHex2; + using Half = DimensionalQuantities.TypeSystem.Fraction; + using Squaring = DimensionalQuantities.TypeSystem.Power; + public static class Consumer + { + public static double Value() + { + Length length = Length.FromMetres(3); + Area first = Power.Of(length); + Area second = Squaring.Of(length); + Length root = Power.Of(first); + Length equivalent = Power>.Of(second); + Volume volume = Power.Of(length); + return first.AsSiBaseUnit() + second.AsSiBaseUnit() + root.AsSiBaseUnit() + equivalent.AsSiBaseUnit() + volume.AsSiBaseUnit(); + } + } + """; + double result = EvaluateSource(source); + double expected = 51; + + Assert.Equal(expected, result); + } + + [Theory] + [InlineData("var squared = Power.Of(current); var result = squared * resistance;", "((Power)result).AsSiBaseUnit()", 36)] + [InlineData("var squared = current * current; var result = Power>.Of(squared);", "((Current)result).AsAmps()", 3)] + [InlineData("var squared = Power.Of(current); var copy = squared; var result = Power>.Of(copy);", "((Current)result).AsAmps()", 3)] + [InlineData("var result = Power.Of(current * resistance);", "result.AsSiBaseUnit()", 144)] + [InlineData("var result = Power>.Of(Power.Of(current));", "((Current)result).AsAmps()", 3)] + [InlineData("var identity = Power.Of(current); var result = identity * current * resistance;", "((Voltage)result).AsSiBaseUnit()", 12)] + public void PowersWorkWithArithmeticAndLocalVariables(string declarations, string expression, double expected) + { + string source = $$""" + using DimensionalQuantities.TypeSystem; + public static class Consumer + { + public static double Value() + { + Current current = Current.FromAmps(3); + Resistance resistance = Resistance.FromSiBaseUnit(4); + {{declarations}} + return {{expression}}; + } + } + """; + double result = EvaluateSource(source); + + Assert.Equal(expected, result, 12); + } + + [Fact] + public void ZerothPowerReturnsDouble() + { + const string source = """ + using DimensionalQuantities.TypeSystem; + public static class Consumer + { + public static double Value() => Power.Of(Length.FromMetres(3)); + } + """; + double result = EvaluateSource(source); + + Assert.Equal(1, result); + } + + [Theory] + [InlineData("Squared", 3, 9)] + [InlineData("Cubed", 3, 27)] + [InlineData("Pow4", 2, 16)] + [InlineData("Pow5", 2, 32)] + [InlineData("Pow6", 2, 64)] + [InlineData("SquareRoot", 9, 3)] + [InlineData("CubeRoot", 27, 3)] + [InlineData("Root4", 16, 2)] + [InlineData("Root5", 32, 2)] + [InlineData("Root6", 64, 2)] + public void ConveniencePowersCompileAndExecute(string method, double value, double expected) + { + string source = $$""" + public static class Consumer + { + public static double Value() => Length.FromMetres({{value.ToString(System.Globalization.CultureInfo.InvariantCulture)}}).{{method}}().AsSiBaseUnit(); + } + """; + double result = EvaluateSource(source); + + Assert.Equal(expected, result, 12); + } + + [Fact] + public void ConveniencePowersShareQuantityTypesWithGenericPowersAndArithmetic() + { + const string source = """ + using DimensionalQuantities.TypeSystem; + public static class Consumer + { + public static double Value() + { + Length length = Length.FromMetres(3); + Area area = length.Squared(); + Volume volume = length.Cubed(); + Length root = area.SquareRoot(); + Length cubeRoot = volume.CubeRoot(); + var fourthPower = length.Pow4(); + Length fourthRoot = fourthPower.Root4(); + Area fromGeneric = Power.Of(root); + Area fromProduct = root * cubeRoot; + return area.AsSiBaseUnit() + volume.AsSiBaseUnit() + fourthRoot.AsMetres() + + fromGeneric.AsSiBaseUnit() + fromProduct.AsSiBaseUnit(); + } + } + """; + double result = EvaluateSource(source); + + Assert.Equal(57, result, 12); + } + + [Theory] + [InlineData("current.Squared().SquareRoot() * resistance", 12)] + [InlineData("Power.Of(current.Squared()) * resistance", 12)] + [InlineData("Power.Of(current).SquareRoot() * resistance", 12)] + [InlineData("(current * resistance).Squared().SquareRoot()", 12)] + public void ConveniencePowersWorkInsideNestedExpressions(string expression, double expected) + { + string source = $$""" + using DimensionalQuantities.TypeSystem; + public static class Consumer + { + public static double Value() + { + Current current = Current.FromAmps(3); + Resistance resistance = Resistance.FromSiBaseUnit(4); + Voltage voltage = {{expression}}; + return voltage.AsSiBaseUnit(); + } + } + """; + double result = EvaluateSource(source); + + Assert.Equal(expected, result, 12); + } + + [Fact] + public void InferredCatalogueQuantityReusesItsDefaultConvenienceMethod() + { + const string source = """ + public static class Consumer + { + public static double Value() + { + Length length = Length.FromMetres(3); + var area = length * length; + return area.Squared().AsSiBaseUnit(); + } + } + """; + double result = EvaluateSource(source); + + Assert.Equal(81, result); + } + + [Fact] + public void ExistingQuantityExtensionMethodKeepsItsBehaviour() + { + const string source = """ + public static class UserMethods { public static double Squared(this Length value) => 42; } + public static class Consumer { public static double Value() => Length.FromMetres(3).Squared(); } + """; + double result = EvaluateSource(source); + + Assert.Equal(42, result); + } + + [Fact] + public void ConvenienceMethodCoexistsWithAnExistingOverload() + { + const string source = """ + public static class UserMethods { public static double Squared(this Length value, int factor) => value.AsMetres() * factor; } + public static class Consumer + { + public static double[] Value() + { + Length length = Length.FromMetres(3); + return [length.Squared().AsSiBaseUnit(), length.Squared(4)]; + } + } + """; + double[] result = EvaluateSource(source); + double[] expected = [9, 12]; + + Assert.Equal(expected, result); + } + + [Theory] + [InlineData(false, 216)] + [InlineData(true, 72)] + public void WindingLossHelpersPreserveUnitsAndRoundTripResistance(bool delta, double expectedLoss) + { + string source = $$""" + public static class Consumer + { + private static Current PhaseCurrent(Current line, bool delta) => delta ? line / System.Math.Sqrt(3) : line; + private static Power Loss(Resistance resistance, Current line, bool delta) + { + Current phase = PhaseCurrent(line, delta); + CurrentSquared squared = phase.Squared(); + return 3 * squared * resistance; + } + private static Resistance Recover(Power loss, Current line, bool delta) + { + Current phase = PhaseCurrent(line, delta); + CurrentSquared denominator = 3 * phase.Squared(); + return loss / denominator; + } + public static double[] Value() + { + Current line = Current.FromAmps(12); + Resistance resistance = Resistance.FromSiBaseUnit(0.5); + Power loss = Loss(resistance, line, {{delta.ToString().ToLowerInvariant()}}); + Resistance recovered = Recover(loss, line, {{delta.ToString().ToLowerInvariant()}}); + return [loss.AsSiBaseUnit(), recovered.AsSiBaseUnit()]; + } + } + """; + double[] result = EvaluateSource(source); + + Assert.Multiple( + () => Assert.Equal(expectedLoss, result[0], 12), + () => Assert.Equal(0.5, result[1], 12)); + } + + [Fact] + public void TypeOnlyParameterSuppliesDimensionsToArithmeticWithoutAnInitialiser() + { + const string source = """ + public static class Consumer + { + private static LengthTimeCurrent Multiply(LengthCurrent input, Time time) => input * time; + public static double Value() => Multiply(LengthCurrent.FromSiBaseUnit(6), Time.FromSeconds(4)).AsSiBaseUnit(); + } + """; + double result = EvaluateSource(source); + + Assert.Equal(24, result); + } + + private T Evaluate(string expression) + { + string source = $$""" + public static class Consumer + { + public static global::{{typeof(T).FullName}} Value() => {{expression}}; + } + """; + return EvaluateSource(source); + } + + private T EvaluateSource(string source) + { + using PackageRepository repository = PackageRepository.Create(_scratch, new Uri("https://api.nuget.org/v3/index.json")); + Package core = PackCore(repository); + ProjectCreator consumer = CreateProject("GeneratedConsumer", source, core); + Build(consumer); + string output = OutputDirectory("GeneratedConsumer"); + using PackageAssemblyContext context = new(output); + Type type = context.LoadFromAssemblyPath(Path.Combine(output, "GeneratedConsumer.dll")).GetType("Consumer", throwOnError: true)!; + return Assert.IsType(type.GetMethod("Value")!.Invoke(null, null)); + } +} diff --git a/src/DimensionalQuantities.IntegrationTests/Packaging/PackagedGeneratorTests.cs b/src/DimensionalQuantities.IntegrationTests/Packaging/PackagedGeneratorTests.cs index 3413f08..b23a307 100644 --- a/src/DimensionalQuantities.IntegrationTests/Packaging/PackagedGeneratorTests.cs +++ b/src/DimensionalQuantities.IntegrationTests/Packaging/PackagedGeneratorTests.cs @@ -6,7 +6,7 @@ namespace DimensionalQuantities.IntegrationTests.Packaging; [Collection("MSBuild")] -public sealed class PackagedGeneratorTests : IDisposable +public sealed partial class PackagedGeneratorTests : IDisposable { private readonly string _scratch = Directory.CreateTempSubdirectory("dimensional-quantities-").FullName; diff --git a/src/DimensionalQuantities.IntegrationTests/Packaging/PackagedUnitProviderTests.cs b/src/DimensionalQuantities.IntegrationTests/Packaging/PackagedUnitProviderTests.cs new file mode 100644 index 0000000..e92c5df --- /dev/null +++ b/src/DimensionalQuantities.IntegrationTests/Packaging/PackagedUnitProviderTests.cs @@ -0,0 +1,271 @@ +using Microsoft.Build.Utilities.ProjectCreation; +using Xunit; + +namespace DimensionalQuantities.IntegrationTests.Packaging; + +public sealed partial class PackagedGeneratorTests +{ + + private const string FootProvider = """ + using DimensionalQuantities.Units.Declarations; + namespace Independent.Units; + + [UnitProvider] + internal static class CustomUnits + { + [QuantityUnit(typeof(Length))] + [UnitFactor(typeof(Foot))] + private sealed class LengthUnit; + + [UnitSymbol("Foot", "Feet", "ft", Scale = 0.3048)] + private sealed class Foot; + } + """; + + [Fact] + public void IndependentProviderGeneratesScaledFactoriesAndAccessors() + { + const string consumer = """ + namespace Independent.Units; + public static class Consumer + { + public static double[] Values() => [Length.FromFeet(10).AsMetres(), Length.FromMetres(0.6096).AsFeet()]; + } + """; + double[] result = EvaluateProvider(FootProvider, consumer, "Independent.Units.Consumer"); + Assert.Multiple( + () => Assert.Equal(3.048, result[0], 12), + () => Assert.Equal(2, result[1], 12)); + } + + [Fact] + public void AffineConversionsApplyOffsetOnlyToAbsoluteQuantities() + { + const string source = """ + using DimensionalQuantities.Units.Declarations; + [UnitProvider(GenerateSiPrefixes = true, GeneratePrefixConversions = true)] + internal static class CustomUnits + { + [QuantityUnit(typeof(Length))] + [UnitFactor(typeof(OffsetMetre))] + private sealed class LengthUnit; + [UnitSymbol("OffsetMetre", "OffsetMetres", "om", Scale = 2)] + [AffineUnit(5)] + private sealed class OffsetMetre; + } + public static class Consumer + { + public static double[] Values() + { + Length first = Length.FromOffsetMetres(3); + Length second = Length.FromOffsetMetres(2); + return [first.AsMetres(), first.AsOffsetMetres(), (first - second).AsDelta().AsOffsetMetres()]; + } + } + """; + Assert.Equal([16d, 3d, 1d], EvaluateProvider(source, "", "Consumer")); + } + + [Fact] + public void ProviderCanOptIntoNamedAndParameterisedSiPrefixes() + { + const string source = """ + using DimensionalQuantities.Units.Declarations; + namespace Independent.Units; + [UnitProvider(GenerateSiPrefixes = true, GeneratePrefixConversions = true)] + internal static class CustomUnits + { + [QuantityUnit(typeof(Voltage))] + [UnitFactor(typeof(Spark))] + private sealed class VoltageUnit; + [UnitSymbol("Spark", "Sparks", "sp")] + private sealed class Spark; + } + public static class Consumer + { + public static double[] Values() => [Voltage.FromMilliSparks(500).AsSiBaseUnit(), Voltage.FromSiBaseUnit(2000).AsKiloSparks(), + Voltage.FromPrefixedUnits(3, sparkPrefixExponent: 3).AsSiBaseUnit(), Voltage.FromSiBaseUnit(0.004).AsPrefixedUnits(-3)]; + } + """; + double[] result = EvaluateProvider(source, "", "Independent.Units.Consumer"); + Assert.Equal([0.5, 2, 3000, 4], result); + } + + [Fact] + public void CompoundFactorsPreserveOrderPowersAndAdditionalConversions() + { + const string source = """ + using DimensionalQuantities.Units.Declarations; + namespace Independent.Units; + [UnitProvider(GenerateSiPrefixes = true, GeneratePrefixConversions = true)] + internal static class CustomUnits + { + [QuantityUnit(typeof(CurrentDensity))] + [UnitFactor(typeof(Amp))] + [UnitFactor(typeof(Metre), Power = -2)] + [AdditionalUnit(typeof(PerSquareMillimetre))] + private sealed class CurrentDensityUnit; + [UnitFactor(typeof(Amp))] + [UnitFactor(typeof(Metre), Power = -2, PrefixExponent = -3)] + private sealed class PerSquareMillimetre; + [UnitSymbol("Amp", "Amps", "A")] + private sealed class Amp; + [UnitSymbol("Metre", "Metres", "m")] + private sealed class Metre; + } + public static class Consumer + { + public static double[] Values() => [CurrentDensity.FromAmpsPerSquareMilliMetre(1).AsSiBaseUnit(), + CurrentDensity.FromPrefixedUnits(2, ampPrefixExponent: 0, metrePrefixExponent: -3).AsSiBaseUnit(), + CurrentDensity.FromSiBaseUnit(1000000).AsAmpsPerSquareMilliMetre()]; + } + """; + double[] result = EvaluateProvider(source, "", "Independent.Units.Consumer"); + Assert.Equal([1000000d, 2000000d, 1d], result); + } + + [Fact] + public void ProviderUsesCoreSiSymbolsAcrossAssemblyBoundary() + { + const string source = """ + using DimensionalQuantities.Units.Declarations; + using DimensionalQuantities.Units.Symbols; + namespace Independent.Units; + [UnitProvider(GenerateSiPrefixes = true, GeneratePrefixConversions = true)] + internal static class CompoundUnits + { + [QuantityUnit(typeof(CurrentDensity))] + [UnitFactor(typeof(Amp))] + [UnitFactor(typeof(Metre), Power = -2)] + private sealed class CurrentDensityUnit; + [QuantityUnit(typeof(Density))] + [UnitFactor(typeof(Gram), PrefixExponent = 3)] + [UnitFactor(typeof(Metre), Power = -3)] + private sealed class DensityUnit; + } + public static class Consumer + { + public static double[] Values() => + [CurrentDensity.FromAmpsPerSquareMetre(2).AsSiBaseUnit(), + CurrentDensity.FromPrefixedUnits(2, ampPrefixExponent: 0, metrePrefixExponent: -3).AsSiBaseUnit(), + Density.FromGramsPerCubicMetre(2).AsSiBaseUnit(), + Density.FromPrefixedUnits(2, gramPrefixExponent: 0, metrePrefixExponent: 0).AsSiBaseUnit()]; + } + """; + Assert.Equal([2d, 2000000d, 0.002d, 0.002d], EvaluateProvider(source, "", "Independent.Units.Consumer")); + } + + [Fact] + public void OneUnitDeclarationCanServeDistinctQuantityTypes() + { + const string source = """ + using DimensionalQuantities.Units.Declarations; + namespace Independent.Units; + [UnitProvider] + internal static class CommonUnits + { + [QuantityUnit(typeof(Length))] + [QuantityUnit(typeof(Time))] + [UnitFactor(typeof(Token))] + private sealed class TokenUnit; + [UnitSymbol("Token", "Tokens", "token")] + private sealed class Token; + } + public static class Consumer + { + public static double[] Values() => + [Length.FromTokens(2).AsSiBaseUnit(), Time.FromTokens(3).AsSiBaseUnit()]; + } + """; + Assert.Equal([2d, 3d], EvaluateProvider(source, "", "Independent.Units.Consumer")); + } + + [Fact] + public void ProviderFactoriesCanBeUsedInArithmeticInTheirOwnAssembly() + { + const string consumer = """ + namespace Independent.Units; + public static class Consumer + { + public static double[] Values() => [(Length.FromFeet(2) * Length.FromFeet(3)).AsSiBaseUnit()]; + } + """; + double[] result = EvaluateProvider(FootProvider, consumer, "Independent.Units.Consumer"); + Assert.Equal(0.55741824, Assert.Single(result), 12); + } + + [Fact] + public void RecordClassProvidersGenerateConversions() + { + const string provider = """ + using DimensionalQuantities.Units.Declarations; + namespace Independent.Units; + [UnitProvider] + internal record class CustomUnits + { + [QuantityUnit(typeof(Length))] + [UnitFactor(typeof(Foot))] + private sealed class LengthUnit; + [UnitSymbol("Foot", "Feet", "ft", Scale = 0.3048)] + private sealed class Foot; + } + """; + const string consumer = """ + namespace Independent.Units; + public static class Consumer + { + public static double[] Values() => [Length.FromFeet(1).AsMetres()]; + } + """; + double[] result = EvaluateProvider(provider, consumer, "Independent.Units.Consumer"); + Assert.Equal(0.3048, Assert.Single(result), 12); + } + + [Fact] + public void ProvidersInSameNamespaceCanConvertSameQuantity() + { + const string source = """ + using DimensionalQuantities.Units.Declarations; + namespace Independent.Units; + [UnitProvider] + internal static class ImperialUnits + { + [QuantityUnit(typeof(Length))] + [UnitFactor(typeof(Foot))] + private sealed class LengthUnit; + [UnitSymbol("Foot", "Feet", "ft", Scale = 0.3048)] + private sealed class Foot; + } + [UnitProvider] + internal static class SurveyUnits + { + [QuantityUnit(typeof(Length))] + [UnitFactor(typeof(Yard))] + private sealed class LengthUnit; + [UnitSymbol("Yard", "Yards", "yd", Scale = 0.9144)] + private sealed class Yard; + } + public static class Consumer + { + public static double[] Values() => [Length.FromFeet(3).AsYards(), Length.FromYards(2).AsFeet()]; + } + """; + double[] result = EvaluateProvider(source, "", "Independent.Units.Consumer"); + Assert.Multiple( + () => Assert.Equal(1, result[0], 12), + () => Assert.Equal(6, result[1], 12)); + } + + private double[] EvaluateProvider(string provider, string consumer, string consumerType) + { + using PackageRepository repository = PackageRepository.Create(_scratch, new Uri("https://api.nuget.org/v3/index.json")); + Package core = PackCore(repository); + ProjectCreator project = CreateProject("ProviderConsumer", consumer, core); + File.WriteAllText(Path.Combine(_scratch, "ProviderConsumer", "Provider.cs"), provider); + Build(project); + string output = OutputDirectory("ProviderConsumer"); + using PackageAssemblyContext context = new(output); + Type type = context.LoadFromAssemblyPath(Path.Combine(output, "ProviderConsumer.dll")).GetType(consumerType, throwOnError: true)!; + return Assert.IsType(type.GetMethod("Values")!.Invoke(null, null)); + } +} diff --git a/src/DimensionalQuantities.Roslyn.Tests/Generators/CoreConversionBoundaryTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Generators/CoreConversionBoundaryTests.cs index 7c633c0..c5aed19 100644 --- a/src/DimensionalQuantities.Roslyn.Tests/Generators/CoreConversionBoundaryTests.cs +++ b/src/DimensionalQuantities.Roslyn.Tests/Generators/CoreConversionBoundaryTests.cs @@ -1,8 +1,6 @@ -using System.Collections.Immutable; -using DimensionalQuantities.Roslyn.Generators; -using DimensionalQuantities.TypeSystem; +using DimensionalQuantities.Roslyn.Tests.Testing; using Microsoft.CodeAnalysis; -using Microsoft.CodeAnalysis.CSharp; +using Microsoft.CodeAnalysis.Testing; using Xunit; namespace DimensionalQuantities.Roslyn.Tests.Generators; @@ -14,9 +12,16 @@ public sealed class CoreConversionBoundaryTests [InlineData("Voltage.FromPrefixedUnits(12, 0)")] [InlineData("Voltage.FromSiBaseUnit(12).AsVolts()")] [InlineData("Voltage.FromSiBaseUnit(12).AsPrefixedUnits(0)")] - public void CatalogueConversionsRequireAnExtensionPackage(string expression) + public async Task CatalogueConversionsRequireAnExtensionPackage(string expression) { - Diagnostic[] result = Compile($"public class Consumer {{ public object Value() => {expression}; }}"); + QuantityGeneratorTest test = new() + { + TestCode = $"public class Consumer {{ public object Value() => {expression}; }}", + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + CompilerDiagnostics = CompilerDiagnostics.None, + }; + await test.RunAsync(TestContext.Current.CancellationToken); + Diagnostic[] result = test.Compilation.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error).ToArray(); Assert.Contains(result, diagnostic => diagnostic.Id is "CS0117" or "CS1061" or "CS1929"); } @@ -28,25 +33,17 @@ public void CatalogueConversionsRequireAnExtensionPackage(string expression) [InlineData("Voltage.FromArbitrarySiComponents(12).AsArbitrarySiComponents()")] [InlineData("(Length.FromMetres(2) * Current.FromAmps(3)).AsPrefixedUnits(3, 0)")] [InlineData("Voltage.FromSiBaseUnit(12).Squared().AsSiBaseUnit()")] - public void BaseGenericAndIntermediateConversionsRemainAvailable(string expression) + public async Task BaseGenericAndIntermediateConversionsRemainAvailable(string expression) { - Diagnostic[] result = Compile($"public class Consumer {{ public object Value() => {expression}; }}"); + QuantityGeneratorTest test = new() + { + TestCode = $"public class Consumer {{ public object Value() => {expression}; }}", + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + }; + await test.RunAsync(TestContext.Current.CancellationToken); + Diagnostic[] result = test.Compilation.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error).ToArray(); Assert.Empty(result); } - private static Diagnostic[] Compile(string source) - { - CSharpParseOptions options = new(LanguageVersion.Preview); - string[] assemblies = ((string)AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES")!).Split(Path.PathSeparator); - IEnumerable references = assemblies.Select(path => MetadataReference.CreateFromFile(path)) - .Append(MetadataReference.CreateFromFile(typeof(Quantity<>).Assembly.Location)); - CSharpCompilation compilation = CSharpCompilation.Create("Consumer", [CSharpSyntaxTree.ParseText(source, options)], - references, new(OutputKind.DynamicallyLinkedLibrary)); - GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: options); - driver.RunGeneratorsAndUpdateCompilation(compilation, out Compilation result, out ImmutableArray diagnostics, - TestContext.Current.CancellationToken); - return diagnostics.Concat(result.GetDiagnostics(TestContext.Current.CancellationToken)) - .Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error).ToArray(); - } } diff --git a/src/DimensionalQuantities.Roslyn.Tests/Generators/GenerationDiagnosticTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Generators/GenerationDiagnosticTests.cs index c175137..13674b1 100644 --- a/src/DimensionalQuantities.Roslyn.Tests/Generators/GenerationDiagnosticTests.cs +++ b/src/DimensionalQuantities.Roslyn.Tests/Generators/GenerationDiagnosticTests.cs @@ -1,8 +1,8 @@ -using System.Collections.Immutable; -using DimensionalQuantities.Roslyn.Generators; +using DimensionalQuantities.Roslyn.Tests.Testing; using DimensionalQuantities.TypeSystem; using Microsoft.CodeAnalysis; -using Microsoft.CodeAnalysis.CSharp; +using Microsoft.CodeAnalysis.Emit; +using Microsoft.CodeAnalysis.Testing; using Xunit; namespace DimensionalQuantities.Roslyn.Tests.Generators; @@ -10,53 +10,62 @@ namespace DimensionalQuantities.Roslyn.Tests.Generators; public sealed class GenerationDiagnosticTests { [Fact] - public void GeneratedAliasWarnsWhenItShadowsAnImportedType() + public async Task GeneratedAliasWarnsWhenItShadowsAnImportedType() { const string source = """ using Other; namespace Other { public class Current { } } public class Consumer { public Current Value { get; } } """; - Diagnostic result = Assert.Single(Generate(source)); - Assert.Multiple( - () => Assert.Equal("DQ0006", result.Id), - () => Assert.Equal(DiagnosticSeverity.Warning, result.Severity), - () => Assert.Contains("Current", result.GetMessage()), - () => Assert.Equal("Consumer.cs", result.Location.SourceTree!.FilePath)); + await new QuantityGeneratorTest + { + TestCode = source.Replace("public Current Value", "public {|#0:Current|} Value"), + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + ExpectedDiagnostics = { new DiagnosticResult("DQ0006", DiagnosticSeverity.Warning).WithLocation(0).WithArguments("Current") }, + }.RunAsync(TestContext.Current.CancellationToken); } [Fact] - public void ImportedMetadataTypeShadowingIsDiagnosed() + public async Task ImportedMetadataTypeShadowingIsDiagnosed() { - CSharpCompilation library = CreateCompilation("namespace Other { public class Current { } }").WithAssemblyName("OtherLibrary"); + QuantityGeneratorTest library = new() + { + TestCode = "namespace Other { public class Current { } }", + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + }; + await library.RunAsync(TestContext.Current.CancellationToken); using MemoryStream bytes = new(); - Microsoft.CodeAnalysis.Emit.EmitResult emitted = library.Emit(bytes, cancellationToken: TestContext.Current.CancellationToken); + EmitResult emitted = library.Compilation.WithAssemblyName("OtherLibrary").Emit(bytes, cancellationToken: TestContext.Current.CancellationToken); if (!emitted.Success) { throw new InvalidOperationException(string.Join(Environment.NewLine, emitted.Diagnostics)); } - CSharpCompilation consumer = CreateCompilation("using Other; public class Consumer { public Current Value { get; } }") - .AddReferences(MetadataReference.CreateFromImage(bytes.ToArray())); - GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: new CSharpParseOptions(LanguageVersion.Preview)); - driver = driver.RunGenerators(consumer, TestContext.Current.CancellationToken); - Diagnostic result = Assert.Single(driver.GetRunResult().Diagnostics); - - Assert.Equal("DQ0006", result.Id); + await new QuantityGeneratorTest + { + TestCode = "using Other; public class Consumer { public {|#0:Current|} Value { get; } }", + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + TestState = { AdditionalReferences = { MetadataReference.CreateFromImage(bytes.ToArray()) } }, + ExpectedDiagnostics = { new DiagnosticResult("DQ0006", DiagnosticSeverity.Warning).WithLocation(0).WithArguments("Current") }, + }.RunAsync(TestContext.Current.CancellationToken); } [Fact] - public void CollisionWarningPreservesTheGeneratedAliasBinding() + public async Task CollisionWarningPreservesTheGeneratedAliasBinding() { const string source = "using Other; namespace Other { public class Current { } } public class Consumer { public Current Value { get; } }"; - CSharpCompilation original = CreateCompilation(source); - GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: new CSharpParseOptions(LanguageVersion.Preview)); - driver.RunGeneratorsAndUpdateCompilation(original, out Compilation generated, out ImmutableArray diagnostics, TestContext.Current.CancellationToken); + QuantityGeneratorTest test = new() + { + TestCode = source.Replace("public Current Value", "public {|#0:Current|} Value"), + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + ExpectedDiagnostics = { new DiagnosticResult("DQ0006", DiagnosticSeverity.Warning).WithLocation(0).WithArguments("Current") }, + }; + await test.RunAsync(TestContext.Current.CancellationToken); + Compilation generated = test.Compilation; IPropertySymbol property = (IPropertySymbol)generated.GetTypeByMetadataName("Consumer")!.GetMembers("Value").Single(); INamedTypeSymbol result = ((INamedTypeSymbol)property.Type).OriginalDefinition; INamedTypeSymbol expected = generated.GetTypeByMetadataName(typeof(Quantity<>).FullName!)!; Assert.Multiple( - () => Assert.Contains(diagnostics, diagnostic => diagnostic.Id == "DQ0006"), () => Assert.True(SymbolEqualityComparer.Default.Equals(expected, result))); } @@ -64,69 +73,92 @@ public void CollisionWarningPreservesTheGeneratedAliasBinding() [InlineData("public class Current { } public class Consumer { }")] [InlineData("public delegate void Current();")] [InlineData("using Current = Other.Current; namespace Other { public class Current { } } public class Consumer { public Current Value { get; } }")] - public void ConflictingDeclarationsAndExplicitAliasesWarn(string source) + public async Task ConflictingDeclarationsAndExplicitAliasesWarn(string source) { - ImmutableArray results = Generate(source); - Assert.Contains(results, diagnostic => diagnostic.Id == "DQ0006" && diagnostic.Severity == DiagnosticSeverity.Warning); + await new QuantityGeneratorTest + { + TestCode = source.Insert(source.IndexOf("Current", StringComparison.Ordinal) + "Current".Length, "|}").Insert(source.IndexOf("Current", StringComparison.Ordinal), "{|#0:"), + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + CompilerDiagnostics = CompilerDiagnostics.None, + ExpectedDiagnostics = { new DiagnosticResult("DQ0006", DiagnosticSeverity.Warning).WithLocation(0).WithArguments("Current") }, + }.RunAsync(TestContext.Current.CancellationToken); } [Fact] - public void StaticMemberUseOfImportedTypeWarnsWhenShadowed() + public async Task StaticMemberUseOfImportedTypeWarnsWhenShadowed() { const string source = """ using Other; namespace Other { public class Current { public static int Create() => 1; } } public class Consumer { public int Value => Current.Create(); } """; - Diagnostic result = Assert.Single(Generate(source)); - Assert.Equal("DQ0006", result.Id); + await new QuantityGeneratorTest + { + TestCode = source.Replace("=> Current.Create()", "=> {|#0:Current|}.Create()"), + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + CompilerDiagnostics = CompilerDiagnostics.None, + ExpectedDiagnostics = { new DiagnosticResult("DQ0006", DiagnosticSeverity.Warning).WithLocation(0).WithArguments("Current") }, + }.RunAsync(TestContext.Current.CancellationToken); } [Fact] - public void UnusedSameNamedTypeInAnotherNamespaceDoesNotWarn() + public async Task UnusedSameNamedTypeInAnotherNamespaceDoesNotWarn() { const string source = "namespace Other { public class Current { } } public class Consumer { public Current Value { get; } }"; - Assert.Empty(Generate(source)); + await new QuantityGeneratorTest + { + TestCode = source, + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + }.RunAsync(TestContext.Current.CancellationToken); } [Fact] - public void QualifiedReferenceToSameNamedTypeDoesNotWarn() + public async Task QualifiedReferenceToSameNamedTypeDoesNotWarn() { const string source = "namespace Other { public class Current { } } public class Consumer { public Other.Current Value { get; } }"; - Assert.Empty(Generate(source)); + await new QuantityGeneratorTest + { + TestCode = source, + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + }.RunAsync(TestContext.Current.CancellationToken); } [Theory] [InlineData("NumberTwoOverZero")] [InlineData("NumberBanana")] - public void InvalidEnglishExponentExplainsUnresolvedRequest(string name) + public async Task InvalidEnglishExponentExplainsUnresolvedRequest(string name) { string source = $$""" using DimensionalQuantities.TypeSystem; public class Consumer { public object Calculate(Length length) => Power<{{name}}>.Of(length); } """; - Diagnostic result = Assert.Single(Generate(source)); - Assert.Multiple( - () => Assert.Equal("DQ0007", result.Id), - () => Assert.Equal(DiagnosticSeverity.Error, result.Severity), - () => Assert.Contains(name, result.GetMessage()), - () => Assert.Equal(name, source.Substring(result.Location.SourceSpan.Start, result.Location.SourceSpan.Length))); + await new QuantityGeneratorTest + { + TestCode = source.Replace(name, "{|#0:" + name + "|}"), + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + CompilerDiagnostics = CompilerDiagnostics.None, + ExpectedDiagnostics = { new DiagnosticResult("DQ0007", DiagnosticSeverity.Error).WithLocation(0).WithArguments(name) }, + }.RunAsync(TestContext.Current.CancellationToken); } [Fact] - public void FileLocalAliasElsewhereDoesNotHideInvalidEnglishExponent() + public async Task FileLocalAliasElsewhereDoesNotHideInvalidEnglishExponent() { const string source = "using DimensionalQuantities.TypeSystem; public class Consumer { public object Calculate(Length length) => Power.Of(length); }"; - CSharpCompilation compilation = CreateCompilation(source).AddSyntaxTrees(CSharpSyntaxTree.ParseText( - "using NumberBanana = System.Int32; public class OtherConsumer { }", - new CSharpParseOptions(LanguageVersion.Preview), "OtherConsumer.cs", cancellationToken: TestContext.Current.CancellationToken)); - GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: new CSharpParseOptions(LanguageVersion.Preview)); - driver = driver.RunGenerators(compilation, TestContext.Current.CancellationToken); - Diagnostic diagnostic = Assert.Single(driver.GetRunResult().Diagnostics); - - Assert.Multiple( - () => Assert.Equal("DQ0007", diagnostic.Id), - () => Assert.Equal("Consumer.cs", diagnostic.Location.SourceTree!.FilePath)); + await new QuantityGeneratorTest + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + CompilerDiagnostics = CompilerDiagnostics.None, + TestState = + { + Sources = + { + ("Consumer.cs", source.Replace("NumberBanana", "{|#0:NumberBanana|}")), + ("OtherConsumer.cs", "using NumberBanana = System.Int32; public class OtherConsumer { }"), + }, + }, + ExpectedDiagnostics = { new DiagnosticResult("DQ0007", DiagnosticSeverity.Error).WithLocation(0).WithArguments("NumberBanana") }, + }.RunAsync(TestContext.Current.CancellationToken); } [Theory] @@ -135,13 +167,18 @@ public void FileLocalAliasElsewhereDoesNotHideInvalidEnglishExponent() [InlineData("public class Power { public static double Of(double value) => value; } public class Consumer { public object Calculate() => Power.Of(2); }")] [InlineData("using NumberTwo = DimensionalQuantities.TypeSystem.TerminalHex2; using DimensionalQuantities.TypeSystem; public class Consumer { public object Calculate(Length length) => Power.Of(length); }")] [InlineData("using DimensionalQuantities.TypeSystem; public class NumberBanana { } public class Consumer { public object Calculate(Length length) => Power.Of(length); }")] - public void BoundNamesAndUnrelatedRequestsDoNotProduceGenerationDiagnostics(string source) + public async Task BoundNamesAndUnrelatedRequestsDoNotProduceGenerationDiagnostics(string source) { - Assert.Empty(Generate(source)); + await new QuantityGeneratorTest + { + TestCode = source, + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + CompilerDiagnostics = CompilerDiagnostics.None, + }.RunAsync(TestContext.Current.CancellationToken); } [Fact] - public void InvalidNumericEncodingDoesNotCrashGenerator() + public async Task InvalidNumericEncodingDoesNotCrashGenerator() { const string source = """ using DimensionalQuantities.TypeSystem; @@ -150,41 +187,35 @@ public class Consumer public object Calculate(Length length) => Power>.Of(length); } """; - ImmutableArray results = Generate(source); - Assert.DoesNotContain(results, diagnostic => diagnostic.Id == "CS8785"); + await new QuantityGeneratorTest + { + TestCode = source, + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + CompilerDiagnostics = CompilerDiagnostics.None, + }.RunAsync(TestContext.Current.CancellationToken); } [Fact] - public void CorrectingAnEnglishExponentRemovesItsDiagnostic() + public async Task InvalidEnglishExponentHasAResolutionDiagnostic() { - const string source = "using DimensionalQuantities.TypeSystem; public class Consumer { public object Calculate(Length length) => Power.Of(length); }"; - CSharpCompilation original = CreateCompilation(source); - GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: new CSharpParseOptions(LanguageVersion.Preview)); - driver = driver.RunGenerators(original, TestContext.Current.CancellationToken); - ImmutableArray initial = driver.GetRunResult().Diagnostics; - CSharpCompilation edited = CreateCompilation(source.Replace("NumberBanana", "NumberTwo")); - driver = driver.RunGenerators(edited, TestContext.Current.CancellationToken); - ImmutableArray result = driver.GetRunResult().Diagnostics; - - Assert.Multiple( - () => Assert.Contains(initial, diagnostic => diagnostic.Id == "DQ0007"), - () => Assert.Empty(result)); - } - - private static ImmutableArray Generate(string source) - { - GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: new CSharpParseOptions(LanguageVersion.Preview)); - driver = driver.RunGenerators(CreateCompilation(source), TestContext.Current.CancellationToken); - return driver.GetRunResult().Diagnostics; + const string source = "using DimensionalQuantities.TypeSystem; public class Consumer { public object Calculate(Length length) => Power<{|#0:NumberBanana|}>.Of(length); }"; + await new QuantityGeneratorTest + { + TestCode = source, + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + CompilerDiagnostics = CompilerDiagnostics.None, + ExpectedDiagnostics = { new DiagnosticResult("DQ0007", DiagnosticSeverity.Error).WithLocation(0).WithArguments("NumberBanana") }, + }.RunAsync(TestContext.Current.CancellationToken); } - private static CSharpCompilation CreateCompilation(string source) + [Fact] + public async Task ValidEnglishExponentHasNoResolutionDiagnostic() { - string[] assemblies = ((string)AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES")!).Split(Path.PathSeparator); - IEnumerable references = assemblies.Select(path => MetadataReference.CreateFromFile(path)) - .Append(MetadataReference.CreateFromFile(typeof(Quantity<>).Assembly.Location)); - return CSharpCompilation.Create("Consumer", [CSharpSyntaxTree.ParseText(source, - new CSharpParseOptions(LanguageVersion.Preview), "Consumer.cs", cancellationToken: TestContext.Current.CancellationToken)], - references, new(OutputKind.DynamicallyLinkedLibrary)); + const string source = "using DimensionalQuantities.TypeSystem; public class Consumer { public object Calculate(Length length) => Power.Of(length); }"; + await new QuantityGeneratorTest + { + TestCode = source, + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + }.RunAsync(TestContext.Current.CancellationToken); } } diff --git a/src/DimensionalQuantities.Roslyn.Tests/Generators/QuantityGeneratorTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Generators/QuantityGeneratorTests.cs index 32849f3..b45241f 100644 --- a/src/DimensionalQuantities.Roslyn.Tests/Generators/QuantityGeneratorTests.cs +++ b/src/DimensionalQuantities.Roslyn.Tests/Generators/QuantityGeneratorTests.cs @@ -1,14 +1,13 @@ -using System.Collections.Immutable; -using System.Reflection; using System.Text; +using DimensionalQuantities.TypeSystem; +using DimensionalQuantities.Roslyn.Generators; using DimensionalQuantities.Dimensions; using DimensionalQuantities.Roslyn.Discovery; -using DimensionalQuantities.Roslyn.Generators; -using DimensionalQuantities.TypeSystem; +using DimensionalQuantities.Roslyn.Tests.Testing; using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.CSharp.Syntax; -using Microsoft.CodeAnalysis.Emit; +using Microsoft.CodeAnalysis.Testing; using Microsoft.CodeAnalysis.Text; using Xunit; @@ -16,10 +15,9 @@ namespace DimensionalQuantities.Roslyn.Tests.Generators; public sealed class QuantityGeneratorTests { - private static readonly CSharpParseOptions _parseOptions = new(LanguageVersion.Preview); [Fact] - public void BaseAliasesHaveUnprefixedFactoriesAndAccessors() + public async Task BaseAliasesHaveUnprefixedFactoriesAndAccessors() { const string source = """ public static class Consumer @@ -39,11 +37,15 @@ public static double UseBaseQuantities() } """; - Compile(source); + await new QuantityGeneratorTest + { + TestCode = source, + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + }.RunAsync(TestContext.Current.CancellationToken); } [Fact] - public void SemanticPipelineResolvesPostInitialisationQuantityAliasesAndFactories() + public async Task SemanticPipelineResolvesPostInitialisationQuantityAliasesAndFactories() { const string source = """ public static class Consumer @@ -51,7 +53,18 @@ public static class Consumer public static Length Use(Length input) => Length.FromMetres(2); } """; - CSharpCompilation result = Compile(source, new SemanticProbeGenerator()); + + QuantityGeneratorTest resultTest = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + AdditionalGenerator = typeof(SemanticProbeGenerator), + TestState = + { + Sources = { ("Consumer.cs", source) }, + }, + }; + await resultTest.RunAsync(TestContext.Current.CancellationToken); + Compilation result = resultTest.Compilation; INamedTypeSymbol probe = result.GetTypeByMetadataName("SemanticProbe")!; IFieldSymbol aliasResolved = Assert.IsAssignableFrom(Assert.Single(probe.GetMembers("AliasResolved"))); IFieldSymbol factoryResolved = Assert.IsAssignableFrom(Assert.Single(probe.GetMembers("FactoryResolved"))); @@ -62,7 +75,7 @@ public static class Consumer } [Fact] - public void CatalogueAliasesAreAvailableToConsumers() + public async Task CatalogueAliasesAreAvailableToConsumers() { const string source = """ public static class Consumer @@ -81,39 +94,15 @@ public static class Consumer } """; - Compile(source); - } - - [Theory] - [InlineData("Length.FromMetres(2) * Length.FromMetres(3)", "Area", 6)] - [InlineData("Current.FromAmps(2) * Current.FromAmps(3)", "CurrentSquared", 6)] - [InlineData("Current.FromAmps(2) * Current.FromAmps(3) * Resistance.FromSiBaseUnit(4)", "Power", 24)] - [InlineData("Current.FromAmps(2) * (Current.FromAmps(3) * Resistance.FromSiBaseUnit(4))", "Power", 24)] - [InlineData("Voltage.FromSiBaseUnit(12) / Current.FromAmps(3)", "Resistance", 4)] - [InlineData("Current.FromAmps(3) * Time.FromSeconds(2)", "TimeCurrent", 6)] - [InlineData("(Current.FromAmps(2) * Time.FromSeconds(3)) / Time.FromSeconds(3)", "Current", 2)] - [InlineData("(Voltage.FromSiBaseUnit(4) * Current.FromAmps(3)) / Current.FromAmps(2)", "Voltage", 6)] - [InlineData("Current.FromAmps(3) * 2d", "Current", 6)] - [InlineData("2 * Current.FromAmps(3)", "Current", 6)] - [InlineData("Current.FromAmps(6) / 2f", "Current", 3)] - [InlineData("2d / Time.FromSeconds(4)", "Frequency", 0.5)] - [InlineData("2f / Current.FromAmps(4)", "InverseCurrent", 0.5)] - [InlineData("(2 / Current.FromAmps(4)) * Time.FromSeconds(3)", "TimePerCurrent", 1.5)] - [InlineData("(Current.FromAmps(2) * 2) * Current.FromAmps(3)", "CurrentSquared", 12)] - [InlineData("2 * (Current.FromAmps(2) * Current.FromAmps(3))", "CurrentSquared", 12)] - [InlineData("(Current.FromAmps(2) * Current.FromAmps(3)) / 2", "CurrentSquared", 3)] - [InlineData("(2 + 3) * Current.FromAmps(2) * Current.FromAmps(3)", "CurrentSquared", 30)] - [InlineData("(2 * 3) * Current.FromAmps(2) * Current.FromAmps(3)", "CurrentSquared", 36)] - public void QuantityArithmeticProducesTheExpectedTypeAndSiMagnitude(string arithmetic, string resultType, double expected) - { - string expression = $"(({resultType})({arithmetic})).AsSiBaseUnit()"; - double result = Evaluate(expression); - - Assert.Equal(expected, result); + await new QuantityGeneratorTest + { + TestCode = source, + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + }.RunAsync(TestContext.Current.CancellationToken); } [Fact] - public void QuantityArithmeticAcceptsTypedMethodParametersAndReturns() + public async Task QuantityArithmeticAcceptsTypedMethodParametersAndReturns() { const string source = """ public static class Consumer @@ -124,11 +113,15 @@ public static class Consumer } """; - Compile(source); + await new QuantityGeneratorTest + { + TestCode = source, + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + }.RunAsync(TestContext.Current.CancellationToken); } [Fact] - public void RepeatedConsumerOperationIsEmittedOnce() + public async Task RepeatedConsumerOperationIsEmittedOnce() { const string source = """ public static class Consumer @@ -137,14 +130,24 @@ public static class Consumer public static Area Second(Length left, Length right) => left * right; } """; - CSharpCompilation compilation = Compile(source); + + QuantityGeneratorTest compilationTest = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + TestState = + { + Sources = { ("Consumer.cs", source) }, + }, + }; + await compilationTest.RunAsync(TestContext.Current.CancellationToken); + Compilation compilation = compilationTest.Compilation; INamedTypeSymbol extensions = compilation.GetTypeByMetadataName("DimensionalQuantities.Generated.ArithmeticExtensions")!; Assert.Single(extensions.GetMembers().OfType(), method => method.MetadataName == "op_Multiply"); } [Fact] - public void ArithmeticReadsFieldAndMethodReturnTypes() + public async Task ArithmeticReadsFieldAndMethodReturnTypes() { const string source = """ public static class Consumer @@ -154,11 +157,15 @@ public static class Consumer public static Power Calculate() => Input * Input * GetResistance(); } """; - Compile(source); + await new QuantityGeneratorTest + { + TestCode = source, + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + }.RunAsync(TestContext.Current.CancellationToken); } [Fact] - public void DimensionPreservingScalarArithmeticUsesCoreOperatorsOnly() + public async Task DimensionPreservingScalarArithmeticUsesCoreOperatorsOnly() { const string source = """ public static class Consumer @@ -166,13 +173,47 @@ public static class Consumer public static Current Scale(Current original, double factor) => factor * original / 2; } """; - CSharpCompilation compilation = Compile(source); + + QuantityGeneratorTest compilationTest = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + TestState = + { + Sources = { ("Consumer.cs", source) }, + }, + }; + await compilationTest.RunAsync(TestContext.Current.CancellationToken); + Compilation compilation = compilationTest.Compilation; Assert.Null(compilation.GetTypeByMetadataName("DimensionalQuantities.Generated.ArithmeticExtensions")); } [Fact] - public void GeneratorRefreshesArithmeticAfterAddingEditingAndRemovingConsumerTrees() + public async Task SingleConsumerRequestsLengthCurrentArithmetic() + { + const string firstSource = """ + public static class Consumer + { + public static LengthCurrent Value() => Current.FromAmps(2) * Length.FromMetres(3); + } + """; + + QuantityGeneratorTest firstOutputTest = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + TestState = + { + Sources = { ("Consumer.cs", firstSource) }, + }, + }; + await firstOutputTest.RunAsync(TestContext.Current.CancellationToken); + Compilation firstOutput = firstOutputTest.Compilation; + + Assert.NotNull(firstOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")); + } + + [Fact] + public async Task MultipleConsumersRequestBothProductQuantities() { const string firstSource = """ public static class Consumer @@ -186,37 +227,38 @@ public static class Added public static LengthTime Value() => Length.FromMetres(2) * Time.FromSeconds(3); } """; - const string editedSource = """ - public static class Consumer + + QuantityGeneratorTest addedOutputTest = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + TestState = { - public static Resistance Value() => Voltage.FromSiBaseUnit(12) / Current.FromAmps(3); - } - """; - CSharpCompilation initialInput = CreateInputCompilation(firstSource); - SyntaxTree initialTree = Assert.Single(initialInput.SyntaxTrees); - SyntaxTree addedTree = CSharpSyntaxTree.ParseText(addedSource, _parseOptions, path: "Added.cs", cancellationToken: TestContext.Current.CancellationToken); - SyntaxTree editedTree = CSharpSyntaxTree.ParseText(editedSource, _parseOptions, path: "Consumer.cs", cancellationToken: TestContext.Current.CancellationToken); - GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: _parseOptions); - - driver = driver.RunGeneratorsAndUpdateCompilation(initialInput, out Compilation firstOutput, out ImmutableArray firstDiagnostics, - TestContext.Current.CancellationToken); - Assert.Multiple( - () => Assert.Empty(firstDiagnostics), - () => Assert.Empty(firstOutput.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)), - () => Assert.NotNull(firstOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions"))); + Sources = { ("Consumer.cs", firstSource), ("Added.cs", addedSource) }, + }, + }; + await addedOutputTest.RunAsync(TestContext.Current.CancellationToken); + Compilation addedOutput = addedOutputTest.Compilation; - CSharpCompilation addedInput = initialInput.AddSyntaxTrees(addedTree); - driver = driver.RunGeneratorsAndUpdateCompilation(addedInput, out Compilation addedOutput, out ImmutableArray addedDiagnostics, - TestContext.Current.CancellationToken); Assert.Multiple( - () => Assert.Empty(addedDiagnostics), - () => Assert.Empty(addedOutput.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)), () => Assert.NotNull(addedOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")), () => Assert.NotNull(addedOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeExtensions"))); + } - CSharpCompilation editedInput = addedInput.ReplaceSyntaxTree(initialTree, editedTree); - driver = driver.RunGeneratorsAndUpdateCompilation(editedInput, out Compilation editedOutput, out ImmutableArray editedDiagnostics, - TestContext.Current.CancellationToken); + [Fact] + public async Task DivisionAndProductRequestOnlyTheirOwnOperators() + { + const string addedSource = """ + public static class Added + { + public static LengthTime Value() => Length.FromMetres(2) * Time.FromSeconds(3); + } + """; + const string editedSource = """ + public static class Consumer + { + public static Resistance Value() => Voltage.FromSiBaseUnit(12) / Current.FromAmps(3); + } + """; Dimension length = new(Length: 1); Dimension time = new(Time: 1); Dimension lengthTime = new(Length: 1, Time: 1); @@ -225,40 +267,81 @@ public static class Consumer Dimension resistance = new(Length: 2, Mass: 1, Time: -3, ElectricCurrent: -2); ArithmeticOperation addedOperation = new(ArithmeticOperationKind.Multiply, length, time, lengthTime); ArithmeticOperation editedOperation = new(ArithmeticOperationKind.Divide, voltage, current, resistance); + + QuantityGeneratorTest editedOutputTest = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + TestState = + { + Sources = { ("Consumer.cs", editedSource), ("Added.cs", addedSource) }, + }, + }; + await editedOutputTest.RunAsync(TestContext.Current.CancellationToken); + Compilation editedOutput = editedOutputTest.Compilation; ArithmeticOperation[] editedOperators = ReadOperators(editedOutput); + Assert.Multiple( - () => Assert.Empty(editedDiagnostics), - () => Assert.Empty(editedOutput.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)), () => Assert.Null(editedOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")), () => Assert.NotNull(editedOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeExtensions")), () => Assert.Equal(2, editedOperators.Length), () => Assert.Contains(addedOperation, editedOperators), () => Assert.Contains(editedOperation, editedOperators)); + } + + [Fact] + public async Task DivisionConsumerRequestsOnlyItsDivisionOperator() + { + const string editedSource = """ + public static class Consumer + { + public static Resistance Value() => Voltage.FromSiBaseUnit(12) / Current.FromAmps(3); + } + """; + Dimension voltage = new(Length: 2, Mass: 1, Time: -3, ElectricCurrent: -1); + Dimension current = new(ElectricCurrent: 1); + Dimension resistance = new(Length: 2, Mass: 1, Time: -3, ElectricCurrent: -2); + ArithmeticOperation editedOperation = new(ArithmeticOperationKind.Divide, voltage, current, resistance); - CSharpCompilation removedInput = editedInput.RemoveSyntaxTrees(addedTree); - driver = driver.RunGeneratorsAndUpdateCompilation(removedInput, out Compilation removedOutput, out ImmutableArray removedDiagnostics, - TestContext.Current.CancellationToken); + QuantityGeneratorTest removedOutputTest = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + TestState = + { + Sources = { ("Consumer.cs", editedSource) }, + }, + }; + await removedOutputTest.RunAsync(TestContext.Current.CancellationToken); + Compilation removedOutput = removedOutputTest.Compilation; ArithmeticOperation[] removedOperators = ReadOperators(removedOutput); + Assert.Multiple( - () => Assert.Empty(removedDiagnostics), - () => Assert.Empty(removedOutput.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)), () => Assert.Null(removedOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")), () => Assert.Null(removedOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeExtensions")), () => Assert.Equal(editedOperation, Assert.Single(removedOperators))); + } + + [Fact] + public async Task EmptyConsumerHasNoDemandGeneratedArithmetic() + { + QuantityGeneratorTest emptyOutputTest = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + TestState = + { + Sources = { ("Consumer.cs", string.Empty) }, + }, + }; + await emptyOutputTest.RunAsync(TestContext.Current.CancellationToken); + Compilation emptyOutput = emptyOutputTest.Compilation; - CSharpCompilation emptyInput = removedInput.RemoveSyntaxTrees(editedTree); - driver.RunGeneratorsAndUpdateCompilation(emptyInput, out Compilation emptyOutput, out ImmutableArray emptyDiagnostics, - TestContext.Current.CancellationToken); Assert.Multiple( - () => Assert.Empty(emptyDiagnostics), - () => Assert.Empty(emptyOutput.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)), () => Assert.Null(emptyOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.ArithmeticExtensions")), () => Assert.Null(emptyOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")), () => Assert.Null(emptyOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeExtensions"))); } [Fact] - public void GeneratorIgnoresUnrelatedAndIncompleteArithmetic() + public async Task GeneratorIgnoresUnrelatedAndIncompleteArithmetic() { const string source = """ public static class Consumer @@ -267,20 +350,26 @@ public static class Consumer public static object Incomplete(Length length) => length * Missing; } """; - CSharpCompilation input = CreateInputCompilation(source); - GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: _parseOptions); - driver.RunGeneratorsAndUpdateCompilation(input, out Compilation output, out ImmutableArray generatorDiagnostics, - TestContext.Current.CancellationToken); - Assert.Multiple( - () => Assert.Empty(generatorDiagnostics), - () => Assert.Null(output.GetTypeByMetadataName("DimensionalQuantities.Generated.ArithmeticExtensions"))); + QuantityGeneratorTest outputTest = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + CompilerDiagnostics = CompilerDiagnostics.None, + TestState = + { + Sources = { ("Consumer.cs", source) }, + }, + }; + await outputTest.RunAsync(TestContext.Current.CancellationToken); + Compilation output = outputTest.Compilation; + + Assert.Null(output.GetTypeByMetadataName("DimensionalQuantities.Generated.ArithmeticExtensions")); } [Fact] - public void LocalInitialiserEditsRefreshDependentOperatorsAndRemoveObsoleteOutput() + public async Task InferredLengthCurrentLocalDeterminesDependentOperators() { const string source = """ public static class Consumer @@ -293,111 +382,123 @@ public static double Value(Current current, Length length, Time time) } } """; - string editedSource = source.Replace("current * length", "length * length", StringComparison.Ordinal); - const string removedSource = "public static class Consumer { public static double Value() => 0; }"; - CSharpCompilation input = CreateInputCompilation(source); - SyntaxTree originalTree = Assert.Single(input.SyntaxTrees); - SyntaxTree editedTree = CSharpSyntaxTree.ParseText(editedSource, _parseOptions, path: "Consumer.cs", cancellationToken: TestContext.Current.CancellationToken); - SyntaxTree removedTree = CSharpSyntaxTree.ParseText(removedSource, _parseOptions, path: "Consumer.cs", cancellationToken: TestContext.Current.CancellationToken); - GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: _parseOptions); Dimension current = new(ElectricCurrent: 1); Dimension lengthCurrent = new(Length: 1, ElectricCurrent: 1); Dimension length = new(Length: 1); - Dimension area = new(Length: 2); Dimension time = new(Time: 1); ArithmeticOperation[] originalExpected = [ new(ArithmeticOperationKind.Multiply, current, length, lengthCurrent), new(ArithmeticOperationKind.Multiply, lengthCurrent, time, new(Length: 1, Time: 1, ElectricCurrent: 1)) ]; + + QuantityGeneratorTest originalOutputTest = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + TestState = + { + Sources = { ("Consumer.cs", source) }, + }, + }; + await originalOutputTest.RunAsync(TestContext.Current.CancellationToken); + Compilation originalOutput = originalOutputTest.Compilation; + + Assert.Equal(originalExpected, ReadOperators(originalOutput)); + } + + + + [Fact] + public async Task InferredAreaLocalDeterminesDependentOperators() + { + const string source = """ + public static class Consumer + { + public static double Value(Current current, Length length, Time time) + { + var product = current * length; + var result = product * time; + return result.AsSiBaseUnit(); + } + } + """; + string editedSource = source.Replace("current * length", "length * length", StringComparison.Ordinal); + Dimension length = new(Length: 1); + Dimension area = new(Length: 2); + Dimension time = new(Time: 1); ArithmeticOperation[] editedExpected = [ new(ArithmeticOperationKind.Multiply, length, length, area), new(ArithmeticOperationKind.Multiply, area, time, new(Length: 2, Time: 1)) ]; - driver = driver.RunGeneratorsAndUpdateCompilation(input, out Compilation originalOutput, out ImmutableArray originalDiagnostics, TestContext.Current.CancellationToken); - Assert.Multiple( - () => Assert.Empty(originalDiagnostics), - () => Assert.Empty(originalOutput.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)), - () => Assert.Equal(originalExpected, ReadOperators(originalOutput))); + QuantityGeneratorTest editedOutputTest = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + TestState = + { + Sources = { ("Consumer.cs", editedSource) }, + }, + }; + await editedOutputTest.RunAsync(TestContext.Current.CancellationToken); + Compilation editedOutput = editedOutputTest.Compilation; - CSharpCompilation editedInput = input.ReplaceSyntaxTree(originalTree, editedTree); - driver = driver.RunGeneratorsAndUpdateCompilation(editedInput, out Compilation editedOutput, out ImmutableArray editedDiagnostics, TestContext.Current.CancellationToken); Assert.Multiple( - () => Assert.Empty(editedDiagnostics), - () => Assert.Empty(editedOutput.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)), () => Assert.Equal(editedExpected, ReadOperators(editedOutput)), () => Assert.Null(editedOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")), () => Assert.Null(editedOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeCurrentExtensions"))); - - CSharpCompilation removedInput = editedInput.ReplaceSyntaxTree(editedTree, removedTree); - driver.RunGeneratorsAndUpdateCompilation(removedInput, out Compilation removedOutput, out ImmutableArray removedDiagnostics, TestContext.Current.CancellationToken); - Assert.Multiple( - () => Assert.Empty(removedDiagnostics), - () => Assert.Empty(removedOutput.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)), - () => Assert.Null(removedOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.ArithmeticExtensions")), - () => Assert.Null(removedOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthSquaredTimeExtensions"))); } - [Theory] - [InlineData("Current.FromAmps(2) + Current.FromMilliAmps(500)", "AsAmps", 2.5)] - [InlineData("Current.FromAmps(2) - Current.FromMilliAmps(500)", "AsAmps", 1.5)] - [InlineData("-Current.FromMilliAmps(500)", "AsAmps", -0.5)] - [InlineData("Energy.FromSiBaseUnit(2) + Torque.FromSiBaseUnit(3)", "AsSiBaseUnit", 5)] - public void SameDimensionArithmeticUsesCoreOperatorsWithoutGeneratedOverloads(string expression, string accessor, double expected) + + [Fact] + public async Task ConsumerWithoutArithmeticHasNoDemandGeneratedOperators() { - string source = $$""" - public static class Consumer + const string removedSource = "public static class Consumer { public static double Value() => 0; }"; + + QuantityGeneratorTest removedOutputTest = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + TestState = { - public static double Value() => ({{expression}}).{{accessor}}(); - } - """; - double result = EvaluateSource(source); - CSharpCompilation compilation = Compile(source); + Sources = { ("Consumer.cs", removedSource) }, + }, + }; + await removedOutputTest.RunAsync(TestContext.Current.CancellationToken); + Compilation removedOutput = removedOutputTest.Compilation; Assert.Multiple( - () => Assert.Equal(expected, result), - () => Assert.Null(compilation.GetTypeByMetadataName("DimensionalQuantities.Generated.ArithmeticExtensions"))); + () => Assert.Null(removedOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.ArithmeticExtensions")), + () => Assert.Null(removedOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthSquaredTimeExtensions"))); } + [Theory] - [InlineData("firstSquared + secondSquared", 52)] - [InlineData("firstSquared - secondSquared", 20)] - [InlineData("-firstSquared", -36)] - public void SameDimensionArithmeticThroughInferredLocalsCompilesAndExecutes(string expression, double expected) + [InlineData("Current.FromAmps(2) + Current.FromMilliAmps(500)", "AsAmps")] + [InlineData("Current.FromAmps(2) - Current.FromMilliAmps(500)", "AsAmps")] + [InlineData("-Current.FromMilliAmps(500)", "AsAmps")] + [InlineData("Energy.FromSiBaseUnit(2) + Torque.FromSiBaseUnit(3)", "AsSiBaseUnit")] + public async Task SameDimensionArithmeticDoesNotGenerateOverloads(string expression, string accessor) { string source = $$""" public static class Consumer { - public static double Value() - { - Current first = Current.FromAmps(3); - Current second = Current.FromAmps(2); - Resistance resistance = Resistance.FromSiBaseUnit(4); - var firstSquared = first * first; - var secondSquared = second * second; - var combined = {{expression}}; - var heating = combined * resistance; - return ((Power)heating).AsSiBaseUnit(); - } + public static double Value() => ({{expression}}).{{accessor}}(); } """; - double result = EvaluateSource(source); - - Assert.Equal(expected, result); - } - [Theory] - [InlineData("((Current.FromAmps(3) * Current.FromAmps(3) + Current.FromAmps(2) * Current.FromAmps(2)) * Resistance.FromSiBaseUnit(4)).AsSiBaseUnit()", 52)] - [InlineData("((Current.FromAmps(3) * Current.FromAmps(3) - Current.FromAmps(2) * Current.FromAmps(2)) * Resistance.FromSiBaseUnit(4)).AsSiBaseUnit()", 20)] - [InlineData("(-(Current.FromAmps(3) * Current.FromAmps(3))).AsSiBaseUnit()", -9)] - public void SameDimensionArithmeticAroundNestedProductsCompilesAndExecutes(string expression, double expected) - { - double result = Evaluate(expression); + QuantityGeneratorTest compilationTest = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + TestState = + { + Sources = { ("Consumer.cs", source) }, + }, + }; + await compilationTest.RunAsync(TestContext.Current.CancellationToken); + Compilation compilation = compilationTest.Compilation; - Assert.Equal(expected, result); + Assert.Null(compilation.GetTypeByMetadataName("DimensionalQuantities.Generated.ArithmeticExtensions")); } [Theory] @@ -405,7 +506,7 @@ public void SameDimensionArithmeticAroundNestedProductsCompilesAndExecutes(strin [InlineData("current - length")] [InlineData("current + 2")] [InlineData("2 - current")] - public void InvalidSameDimensionArithmeticRemainsACompilerError(string expression) + public async Task InvalidSameDimensionArithmeticRemainsACompilerError(string expression) { string source = $$""" public static class Consumer @@ -413,114 +514,51 @@ public static class Consumer public static object Value(Current current, Length length) => {{expression}}; } """; - CSharpCompilation input = CreateInputCompilation(source); - GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: _parseOptions); - driver.RunGeneratorsAndUpdateCompilation(input, out Compilation output, out ImmutableArray diagnostics, TestContext.Current.CancellationToken); - Diagnostic[] errors = output.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error).ToArray(); - - Assert.Multiple( - () => Assert.Empty(diagnostics), - () => Assert.Equal("CS0019", Assert.Single(errors).Id)); - } - - [Theory] - [InlineData("Length.FromMetres(3) / Length.FromMilliMetres(500)", 6)] - [InlineData("Energy.FromSiBaseUnit(6) / Torque.FromSiBaseUnit(2)", 3)] - [InlineData("Current.FromAmps(3) * (2 / Current.FromAmps(3))", 2)] - [InlineData("(2 / Current.FromAmps(3)) * Current.FromAmps(3)", 2)] - [InlineData("(Current.FromAmps(3) * Current.FromAmps(3)) / (Current.FromAmps(2) * Current.FromAmps(2))", 2.25)] - [InlineData("(Length.FromMetres(3) / Length.FromMetres(1)) + (Current.FromAmps(4) / Current.FromAmps(2))", 5)] - public void CancelledDimensionsCompileAndExecuteAsDouble(string expression, double expected) - { - double result = Evaluate(expression); - - Assert.Equal(expected, result); - } - - [Theory] - [InlineData("var ratio = first / second;", "(ratio * time).AsSeconds()", 6)] - [InlineData("var firstSquared = first * first; var secondSquared = second * second; var ratio = firstSquared / secondSquared;", "(ratio * time).AsSeconds()", 9)] - [InlineData("var inverse = 2 / first; var ratio = first * inverse; var copy = ratio;", "(copy * time).AsSeconds()", 8)] - [InlineData("var inverse = 2 / first; var ratio = first * inverse;", "(time / ratio).AsSeconds()", 2)] - [InlineData("var inverse = 2 / first; var ratio = first * inverse; var scaled = (ratio + 1) * first;", "(scaled * time).AsSiBaseUnit()", 36)] - [InlineData("var ratio = first / second; var inverseTime = ratio / time;", "inverseTime.AsSiBaseUnit()", 0.375)] - public void CancelledLocalsCanBeUsedAsScalarOperands(string declarations, string expression, double expected) - { - string source = $$""" - public static class Consumer - { - public static double Value() - { - Current first = Current.FromAmps(3); - Current second = Current.FromAmps(2); - Time time = Time.FromSeconds(4); - {{declarations}} - return {{expression}}; - } - } - """; - double result = EvaluateSource(source); - - Assert.Equal(expected, result); - } - - [Theory] - [InlineData("TerminalHex2", 3, 9)] - [InlineData("TerminalHex3", 3, 27)] - [InlineData("TerminalHex1", 3, 3)] - [InlineData("Hex", 2, 65536)] - [InlineData("Negative", 2, 0.25)] - [InlineData("Fraction", 9, 3)] - [InlineData("Fraction", 9, 3)] - [InlineData("Fraction", -8, -2)] - [InlineData("Fraction", -8, 4)] - [InlineData("Fraction, TerminalHex3>", -8, -0.5)] - public void EncodedPowersCompileAndExecute(string exponent, double value, double expected) - { - string source = $$""" - using DimensionalQuantities.TypeSystem; - public static class Consumer - { - public static double Value() => Power<{{exponent}}>.Of(Length.FromMetres({{value.ToString(System.Globalization.CultureInfo.InvariantCulture)}})).AsSiBaseUnit(); - } - """; - double result = EvaluateSource(source); - Assert.Equal(expected, result, 12); - } - - [Theory] - [InlineData("NumberTwo", 3, 9)] - [InlineData("NumberSeventeen", 2, 131072)] - [InlineData("NumberMinusTwo", 2, 0.25)] - [InlineData("NumberHalf", 9, 3)] - [InlineData("NumberTwoQuarters", 9, 3)] - [InlineData("NumberTwoOverThree", -8, 4)] - [InlineData("NumberMinusOneOverThree", -8, -0.5)] - [InlineData("NumberMillionth", 1, 1)] - public void EnglishPowersCompileAndExecute(string exponent, double value, double expected) - { - string source = $$""" - using DimensionalQuantities.TypeSystem; - public static class Consumer + QuantityGeneratorTest outputTest = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + CompilerDiagnostics = CompilerDiagnostics.None, + TestState = { - public static double Value() => Power<{{exponent}}>.Of(Length.FromMetres({{value.ToString(System.Globalization.CultureInfo.InvariantCulture)}})).AsSiBaseUnit(); - } - """; - double result = EvaluateSource(source); + Sources = { ("Consumer.cs", source) }, + }, + }; + await outputTest.RunAsync(TestContext.Current.CancellationToken); + Compilation output = outputTest.Compilation; + Diagnostic[] errors = output.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error).ToArray(); - Assert.Equal(expected, result, 12); + Assert.Equal("CS0019", Assert.Single(errors).Id); } [Fact] - public void GeneratesEnglishAliasesOnlyWhenUsedByPowerCalls() + public async Task GeneratesEnglishAliasesOnlyWhenUsedByPowerCalls() { - CSharpCompilation unused = Compile("class Consumer { }"); + QuantityGeneratorTest unusedTest = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + TestState = + { + Sources = { ("Consumer.cs", "class Consumer { }") }, + }, + }; + await unusedTest.RunAsync(TestContext.Current.CancellationToken); + Compilation unused = unusedTest.Compilation; const string source = """ using DimensionalQuantities.TypeSystem; class Consumer { object Value(Length value) => Power.Of(value); } """; - CSharpCompilation used = Compile(source); + + QuantityGeneratorTest usedTest = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + TestState = + { + Sources = { ("Consumer.cs", source) }, + }, + }; + await usedTest.RunAsync(TestContext.Current.CancellationToken); + Compilation used = usedTest.Compilation; string[] unusedNames = unused.SyntaxTrees.SelectMany(tree => tree.GetCompilationUnitRoot(TestContext.Current.CancellationToken).Usings) .Where(directive => directive.Alias is not null).Select(directive => directive.Alias!.Name.Identifier.ValueText).ToArray(); string[] usedNames = used.SyntaxTrees.SelectMany(tree => tree.GetCompilationUnitRoot(TestContext.Current.CancellationToken).Usings) @@ -538,89 +576,78 @@ class Consumer { object Value(Length value) => Power.Of(value); } [InlineData("typeof(NumberTwo)")] [InlineData("Power.Other(value)")] [InlineData("Other.Power.Of(value)")] - public void EnglishNamesOutsideSupportedPowerCallsRemainUnresolved(string expression) + public async Task EnglishNamesOutsideSupportedPowerCallsRemainUnresolved(string expression) { string source = $$""" using DimensionalQuantities.TypeSystem; namespace Other { public struct Power { public static object Of(object value) => value; } } class Consumer { object Value(Length value) => {{expression}}; } """; - CSharpCompilation input = CreateInputCompilation(source); - GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: _parseOptions); - driver.RunGeneratorsAndUpdateCompilation(input, out Compilation output, out ImmutableArray diagnostics, TestContext.Current.CancellationToken); + + QuantityGeneratorTest outputTest = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + CompilerDiagnostics = CompilerDiagnostics.None, + TestState = + { + Sources = { ("Consumer.cs", source) }, + }, + }; + await outputTest.RunAsync(TestContext.Current.CancellationToken); + Compilation output = outputTest.Compilation; string[] aliases = output.SyntaxTrees.SelectMany(tree => tree.GetCompilationUnitRoot(TestContext.Current.CancellationToken).Usings) .Where(directive => directive.Alias is not null).Select(directive => directive.Alias!.Name.Identifier.ValueText).ToArray(); Assert.Multiple( - () => Assert.Empty(diagnostics), () => Assert.DoesNotContain("NumberTwo", aliases), () => Assert.Contains(output.GetDiagnostics(TestContext.Current.CancellationToken), diagnostic => diagnostic.Id == "CS0246" && diagnostic.GetMessage().Contains("NumberTwo", StringComparison.Ordinal))); } [Fact] - public void RemovingEnglishPowerCallsRemovesTheirAliases() + public async Task EnglishPowerCallRequestsItsAlias() { const string source = """ using DimensionalQuantities.TypeSystem; class Consumer { object Value(Length value) => Power.Of(value); } """; - CSharpCompilation input = CreateInputCompilation(source); - GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: _parseOptions); - driver = driver.RunGeneratorsAndUpdateCompilation(input, out Compilation original, out _, TestContext.Current.CancellationToken); - CSharpCompilation emptyInput = input.RemoveAllSyntaxTrees(); - driver.RunGeneratorsAndUpdateCompilation(emptyInput, out Compilation removed, out ImmutableArray diagnostics, TestContext.Current.CancellationToken); - string[] originalNames = original.SyntaxTrees.SelectMany(tree => tree.GetCompilationUnitRoot(TestContext.Current.CancellationToken).Usings) - .Where(directive => directive.Alias is not null).Select(directive => directive.Alias!.Name.Identifier.ValueText).ToArray(); - string[] remainingNames = removed.SyntaxTrees.SelectMany(tree => tree.GetCompilationUnitRoot(TestContext.Current.CancellationToken).Usings) - .Where(directive => directive.Alias is not null).Select(directive => directive.Alias!.Name.Identifier.ValueText).ToArray(); - - Assert.Multiple( - () => Assert.Contains("NumberTwo", originalNames), - () => Assert.DoesNotContain("NumberTwo", remainingNames), - () => Assert.Empty(diagnostics), - () => Assert.Empty(removed.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error))); - } - [Fact] - public void EnglishPowersWorkWithNestedCallsArithmeticAndLocals() - { - const string source = """ - using DimensionalQuantities.TypeSystem; - public static class Consumer + QuantityGeneratorTest originalTest = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + TestState = { - public static double Value() - { - var squared = Power.Of(Current.FromAmps(3)); - var root = Power.Of(squared); - Voltage voltage = root * Resistance.FromSiBaseUnit(4); - Current nested = Power.Of(Power.Of(root)); - return voltage.AsSiBaseUnit() + nested.AsAmps(); - } - } - """; - double result = EvaluateSource(source); + Sources = { ("Consumer.cs", source) }, + }, + }; + await originalTest.RunAsync(TestContext.Current.CancellationToken); + Compilation original = originalTest.Compilation; + string[] originalNames = original.SyntaxTrees.SelectMany(tree => tree.GetCompilationUnitRoot(TestContext.Current.CancellationToken).Usings) + .Where(directive => directive.Alias is not null).Select(directive => directive.Alias!.Name.Identifier.ValueText).ToArray(); - Assert.Equal(15, result); + Assert.Contains("NumberTwo", originalNames); } [Fact] - public void EnglishLookingUserAliasKeepsItsDeclaredExponent() + public async Task ConsumerWithoutPowerCallsHasNoEnglishAliases() { - const string source = """ - using DimensionalQuantities.TypeSystem; - using NumberTwo = DimensionalQuantities.TypeSystem.TerminalHex3; - public static class Consumer + QuantityGeneratorTest removedTest = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + TestState = { - public static double Value() => Power.Of(Length.FromMetres(3)).AsSiBaseUnit(); - } - """; - double result = EvaluateSource(source); + Sources = { ("Consumer.cs", string.Empty) }, + }, + }; + await removedTest.RunAsync(TestContext.Current.CancellationToken); + Compilation removed = removedTest.Compilation; + string[] remainingNames = removed.SyntaxTrees.SelectMany(tree => tree.GetCompilationUnitRoot(TestContext.Current.CancellationToken).Usings) + .Where(directive => directive.Alias is not null).Select(directive => directive.Alias!.Name.Identifier.ValueText).ToArray(); - Assert.Equal(27, result); + Assert.DoesNotContain("NumberTwo", remainingNames); } [Fact] - public void ExplicitAliasInAnotherFileReservesTheName() + public async Task ExplicitAliasInAnotherFileReservesTheName() { const string generatedAliasSource = """ using DimensionalQuantities.TypeSystem; @@ -631,150 +658,91 @@ class First { public Area Value(Length value) => Power.Of(value); } using NumberTwo = DimensionalQuantities.TypeSystem.TerminalHex3; class Second { public Volume Value(Length value) => Power.Of(value); } """; - CSharpCompilation input = CreateInputCompilation(generatedAliasSource).AddSyntaxTrees( - CSharpSyntaxTree.ParseText(explicitAliasSource, _parseOptions, path: "Second.cs", cancellationToken: TestContext.Current.CancellationToken)); - GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: _parseOptions); - driver.RunGeneratorsAndUpdateCompilation(input, out Compilation output, out ImmutableArray diagnostics, TestContext.Current.CancellationToken); + + QuantityGeneratorTest outputTest = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + CompilerDiagnostics = CompilerDiagnostics.None, + TestState = + { + Sources = { ("Consumer.cs", generatedAliasSource), ("Second.cs", explicitAliasSource) }, + }, + }; + await outputTest.RunAsync(TestContext.Current.CancellationToken); + Compilation output = outputTest.Compilation; Diagnostic[] errors = output.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error).ToArray(); Assert.Multiple( - () => Assert.Empty(diagnostics), () => Assert.Contains(errors, diagnostic => diagnostic.Id == "CS0246" && diagnostic.GetMessage().Contains("NumberTwo", StringComparison.Ordinal)), () => Assert.DoesNotContain(errors, diagnostic => diagnostic.Location.SourceTree?.FilePath == "Second.cs"), () => Assert.DoesNotContain(output.SyntaxTrees.SelectMany(tree => tree.GetCompilationUnitRoot(TestContext.Current.CancellationToken).Usings), directive => directive.Alias?.Name.Identifier.ValueText == "NumberTwo" && directive.GlobalKeyword.IsKind(SyntaxKind.GlobalKeyword))); } - [Fact] - public void EquivalentEnglishNamesShareTheEncodedTypeAndPowerOverload() + [Theory] + [InlineData("Two")] + [InlineData("NumberNotANumber", "DQ0007")] + public async Task UnsupportedExponentNamesRemainCompilerErrors(string name, params string[] expectedDiagnosticIds) { - const string source = """ + string source = $$""" using DimensionalQuantities.TypeSystem; public static class Consumer { - public static bool Value() - { - Length first = Power.Of(Area.FromSiBaseUnit(9)); - Length second = Power.Of(Area.FromSiBaseUnit(9)); - Length third = Power>.Of(Area.FromSiBaseUnit(9)); - return first == second && second == third && typeof(NumberHalf) == typeof(NumberTwoQuarters) - && typeof(NumberHalf) == typeof(Fraction); - } + public static object Value(Length length) => Power<{{name}}>.Of(length); } """; - Assert.True(EvaluateSource(source)); + QuantityGeneratorTest outputTest = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + CompilerDiagnostics = CompilerDiagnostics.None, + TestState = + { + Sources = { ("Consumer.cs", source) }, + }, + }; + if (expectedDiagnosticIds.Length != 0) + { + outputTest.ExpectedDiagnostics.Add(new DiagnosticResult("DQ0007", DiagnosticSeverity.Error) + .WithSpan("Consumer.cs", 4, 53, 4, 53 + name.Length).WithArguments(name)); + } + await outputTest.RunAsync(TestContext.Current.CancellationToken); + Compilation output = outputTest.Compilation; + + Assert.Contains(output.GetDiagnostics(TestContext.Current.CancellationToken), diagnostic => diagnostic.Id == "CS0246" && diagnostic.GetMessage().Contains(name, StringComparison.Ordinal)); } - [Fact] - public void EnglishZerothPowerReturnsDouble() + [Theory] + [InlineData("TerminalHex2")] + [InlineData("NumberTwo")] + public async Task SquaredProductRequestsSquaredQuantity(string originalExponent) { - const string source = """ + string source = $$""" using DimensionalQuantities.TypeSystem; public static class Consumer { - public static double Value() => Power.Of(Length.FromMetres(3)); + public static object Value(Current current) => Power<{{originalExponent}}>.Of(current * Length.FromMetres(1)); } """; - Assert.Equal(1, EvaluateSource(source)); - } - - [Fact] - public void PowersReturnExistingQuantityTypesWhenCalledThroughAliases() - { - const string source = """ - using DimensionalQuantities.TypeSystem; - using Two = DimensionalQuantities.TypeSystem.TerminalHex2; - using Half = DimensionalQuantities.TypeSystem.Fraction; - using Squaring = DimensionalQuantities.TypeSystem.Power; - public static class Consumer - { - public static double Value() - { - Length length = Length.FromMetres(3); - Area first = Power.Of(length); - Area second = Squaring.Of(length); - Length root = Power.Of(first); - Length equivalent = Power>.Of(second); - Volume volume = Power.Of(length); - return first.AsSiBaseUnit() + second.AsSiBaseUnit() + root.AsSiBaseUnit() + equivalent.AsSiBaseUnit() + volume.AsSiBaseUnit(); - } - } - """; - double result = EvaluateSource(source); - double expected = 51; - - Assert.Equal(expected, result); - } - - [Theory] - [InlineData("var squared = Power.Of(current); var result = squared * resistance;", "((Power)result).AsSiBaseUnit()", 36)] - [InlineData("var squared = current * current; var result = Power>.Of(squared);", "((Current)result).AsAmps()", 3)] - [InlineData("var squared = Power.Of(current); var copy = squared; var result = Power>.Of(copy);", "((Current)result).AsAmps()", 3)] - [InlineData("var result = Power.Of(current * resistance);", "result.AsSiBaseUnit()", 144)] - [InlineData("var result = Power>.Of(Power.Of(current));", "((Current)result).AsAmps()", 3)] - [InlineData("var identity = Power.Of(current); var result = identity * current * resistance;", "((Voltage)result).AsSiBaseUnit()", 12)] - public void PowersWorkWithArithmeticAndLocalVariables(string declarations, string expression, double expected) - { - string source = $$""" - using DimensionalQuantities.TypeSystem; - public static class Consumer - { - public static double Value() - { - Current current = Current.FromAmps(3); - Resistance resistance = Resistance.FromSiBaseUnit(4); - {{declarations}} - return {{expression}}; - } - } - """; - double result = EvaluateSource(source); - - Assert.Equal(expected, result, 12); - } - - [Fact] - public void ZerothPowerReturnsDouble() - { - const string source = """ - using DimensionalQuantities.TypeSystem; - public static class Consumer - { - public static double Value() => Power.Of(Length.FromMetres(3)); - } - """; - double result = EvaluateSource(source); - - Assert.Equal(1, result); - } - - [Theory] - [InlineData("Two")] - [InlineData("NumberNotANumber", "DQ0007")] - public void UnsupportedExponentNamesRemainCompilerErrors(string name, params string[] expectedDiagnosticIds) - { - string source = $$""" - using DimensionalQuantities.TypeSystem; - public static class Consumer - { - public static object Value(Length length) => Power<{{name}}>.Of(length); - } - """; - CSharpCompilation input = CreateInputCompilation(source); - GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: _parseOptions); - driver.RunGeneratorsAndUpdateCompilation(input, out Compilation output, out ImmutableArray diagnostics, TestContext.Current.CancellationToken); - - Assert.Multiple( - () => Assert.Equal(expectedDiagnosticIds, diagnostics.Select(diagnostic => diagnostic.Id)), - () => Assert.Contains(output.GetDiagnostics(TestContext.Current.CancellationToken), diagnostic => diagnostic.Id == "CS0246" && diagnostic.GetMessage().Contains(name, StringComparison.Ordinal))); + QuantityGeneratorTest originalOutputTest = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + TestState = + { + Sources = { ("Consumer.cs", source) }, + }, + }; + await originalOutputTest.RunAsync(TestContext.Current.CancellationToken); + Compilation originalOutput = originalOutputTest.Compilation; + + Assert.NotNull(originalOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthSquaredCurrentSquaredExtensions")); } [Theory] [InlineData("TerminalHex2", "TerminalHex3")] [InlineData("NumberTwo", "NumberThree")] - public void EditingAndRemovingPowerCallsRemovesObsoleteGeneratedTypes(string originalExponent, string editedExponent) + public async Task CubedProductRequestsOnlyItsCubedQuantity(string originalExponent, string editedExponent) { string source = $$""" using DimensionalQuantities.TypeSystem; @@ -783,112 +751,42 @@ public static class Consumer public static object Value(Current current) => Power<{{originalExponent}}>.Of(current * Length.FromMetres(1)); } """; - CSharpCompilation input = CreateInputCompilation(source); - SyntaxTree originalTree = input.SyntaxTrees.Single(); - SyntaxTree editedTree = CSharpSyntaxTree.ParseText(source.Replace(originalExponent, editedExponent, StringComparison.Ordinal), _parseOptions, path: "Consumer.cs", cancellationToken: TestContext.Current.CancellationToken); - GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: _parseOptions); - driver = driver.RunGeneratorsAndUpdateCompilation(input, out Compilation originalOutput, out ImmutableArray originalDiagnostics, TestContext.Current.CancellationToken); - Assert.Multiple( - () => Assert.Empty(originalDiagnostics), - () => Assert.Empty(originalOutput.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)), - () => Assert.NotNull(originalOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthSquaredCurrentSquaredExtensions"))); + QuantityGeneratorTest editedOutputTest = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + TestState = + { + Sources = { ("Consumer.cs", source.Replace(originalExponent, editedExponent, StringComparison.Ordinal)) }, + }, + }; + await editedOutputTest.RunAsync(TestContext.Current.CancellationToken); + Compilation editedOutput = editedOutputTest.Compilation; - CSharpCompilation editedInput = input.ReplaceSyntaxTree(originalTree, editedTree); - driver = driver.RunGeneratorsAndUpdateCompilation(editedInput, out Compilation editedOutput, out ImmutableArray editedDiagnostics, TestContext.Current.CancellationToken); Assert.Multiple( - () => Assert.Empty(editedDiagnostics), - () => Assert.Empty(editedOutput.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)), () => Assert.Null(editedOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthSquaredCurrentSquaredExtensions")), () => Assert.NotNull(editedOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCubedCurrentCubedExtensions"))); - - CSharpCompilation emptyInput = editedInput.RemoveSyntaxTrees(editedTree); - driver.RunGeneratorsAndUpdateCompilation(emptyInput, out Compilation emptyOutput, out ImmutableArray emptyDiagnostics, TestContext.Current.CancellationToken); - Assert.Multiple( - () => Assert.Empty(emptyDiagnostics), - () => Assert.Empty(emptyOutput.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)), - () => Assert.Null(emptyOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCubedCurrentCubedExtensions"))); - } - - [Theory] - [InlineData("Squared", 3, 9)] - [InlineData("Cubed", 3, 27)] - [InlineData("Pow4", 2, 16)] - [InlineData("Pow5", 2, 32)] - [InlineData("Pow6", 2, 64)] - [InlineData("SquareRoot", 9, 3)] - [InlineData("CubeRoot", 27, 3)] - [InlineData("Root4", 16, 2)] - [InlineData("Root5", 32, 2)] - [InlineData("Root6", 64, 2)] - public void ConveniencePowersCompileAndExecute(string method, double value, double expected) - { - string source = $$""" - public static class Consumer - { - public static double Value() => Length.FromMetres({{value.ToString(System.Globalization.CultureInfo.InvariantCulture)}}).{{method}}().AsSiBaseUnit(); - } - """; - double result = EvaluateSource(source); - - Assert.Equal(expected, result, 12); } [Fact] - public void ConveniencePowersShareQuantityTypesWithGenericPowersAndArithmetic() - { - const string source = """ - using DimensionalQuantities.TypeSystem; - public static class Consumer - { - public static double Value() - { - Length length = Length.FromMetres(3); - Area area = length.Squared(); - Volume volume = length.Cubed(); - Length root = area.SquareRoot(); - Length cubeRoot = volume.CubeRoot(); - var fourthPower = length.Pow4(); - Length fourthRoot = fourthPower.Root4(); - Area fromGeneric = Power.Of(root); - Area fromProduct = root * cubeRoot; - return area.AsSiBaseUnit() + volume.AsSiBaseUnit() + fourthRoot.AsMetres() - + fromGeneric.AsSiBaseUnit() + fromProduct.AsSiBaseUnit(); - } - } - """; - double result = EvaluateSource(source); - - Assert.Equal(57, result, 12); - } - - [Theory] - [InlineData("current.Squared().SquareRoot() * resistance", 12)] - [InlineData("Power.Of(current.Squared()) * resistance", 12)] - [InlineData("Power.Of(current).SquareRoot() * resistance", 12)] - [InlineData("(current * resistance).Squared().SquareRoot()", 12)] - public void ConveniencePowersWorkInsideNestedExpressions(string expression, double expected) + public async Task ConsumerWithoutPowerCallsHasNoDemandGeneratedPowerQuantity() { - string source = $$""" - using DimensionalQuantities.TypeSystem; - public static class Consumer + QuantityGeneratorTest emptyOutputTest = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + TestState = { - public static double Value() - { - Current current = Current.FromAmps(3); - Resistance resistance = Resistance.FromSiBaseUnit(4); - Voltage voltage = {{expression}}; - return voltage.AsSiBaseUnit(); - } - } - """; - double result = EvaluateSource(source); + Sources = { ("Consumer.cs", string.Empty) }, + }, + }; + await emptyOutputTest.RunAsync(TestContext.Current.CancellationToken); + Compilation emptyOutput = emptyOutputTest.Compilation; - Assert.Equal(expected, result, 12); + Assert.Null(emptyOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCubedCurrentCubedExtensions")); } [Fact] - public void GeneratesOnlyTheRequestedIntermediateConvenienceOverloadOnce() + public async Task GeneratesOnlyTheRequestedIntermediateConvenienceOverloadOnce() { const string source = """ class Consumer @@ -897,7 +795,17 @@ class Consumer object Second(Length length, Current current) => (length * current).Squared(); } """; - CSharpCompilation output = Compile(source); + + QuantityGeneratorTest outputTest = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + TestState = + { + Sources = { ("Consumer.cs", source) }, + }, + }; + await outputTest.RunAsync(TestContext.Current.CancellationToken); + Compilation output = outputTest.Compilation; string[] convenienceNames = ["Squared", "Cubed", "Pow4", "Pow5", "Pow6", "SquareRoot", "CubeRoot", "Root4", "Root5", "Root6"]; string[] result = ReadConvenienceMethods(output, new(Length: 1, ElectricCurrent: 1)).Where(convenienceNames.Contains).ToArray(); string[] expected = ["Squared"]; @@ -906,9 +814,18 @@ class Consumer } [Fact] - public void BaseAndCatalogueHelpersAreAvailableWithoutConsumerCode() + public async Task BaseAndCatalogueHelpersAreAvailableWithoutConsumerCode() { - CSharpCompilation result = Compile(string.Empty); + QuantityGeneratorTest resultTest = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + TestState = + { + Sources = { ("Consumer.cs", string.Empty) }, + }, + }; + await resultTest.RunAsync(TestContext.Current.CancellationToken); + Compilation result = resultTest.Compilation; string[] expected = ["Squared", "Cubed", "Pow4", "Pow5", "Pow6", "SquareRoot", "CubeRoot", "Root4", "Root5", "Root6"]; Dimension[] dimensions = QuantityDiscovery.Discover([]).KnownQuantities.Select(quantity => quantity.Dimension).ToArray(); @@ -916,108 +833,123 @@ public void BaseAndCatalogueHelpersAreAvailableWithoutConsumerCode() } [Fact] - public void InferredCatalogueQuantityReusesItsDefaultConvenienceMethod() + public async Task CatalogueConvenienceMethodsAreBoundBeforeDemandGeneration() { const string source = """ public static class Consumer { - public static double Value() - { - Length length = Length.FromMetres(3); - var area = length * length; - return area.Squared().AsSiBaseUnit(); - } + public static object Value(Voltage voltage) => voltage.Squared(); } """; - double result = EvaluateSource(source); - Assert.Equal(81, result); - } - - [Fact] - public void CatalogueConvenienceMethodsAreBoundBeforeDemandGeneration() - { - const string source = """ - public static class Consumer + QuantityGeneratorTest resultTest = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + AdditionalGenerator = typeof(SemanticProbeGenerator), + TestState = { - public static object Value(Voltage voltage) => voltage.Squared(); - } - """; - CSharpCompilation result = Compile(source, new SemanticProbeGenerator()); + Sources = { ("Consumer.cs", source) }, + }, + }; + await resultTest.RunAsync(TestContext.Current.CancellationToken); + Compilation result = resultTest.Compilation; INamedTypeSymbol probe = result.GetTypeByMetadataName("SemanticProbe")!; IFieldSymbol resolved = Assert.IsAssignableFrom(Assert.Single(probe.GetMembers("FactoryResolved"))); Assert.Equal(true, resolved.ConstantValue); } - [Fact] - public void ExistingQuantityExtensionMethodKeepsItsBehaviour() + [Theory] + [InlineData("(3d).Squared()", "CS1929")] + [InlineData("Length.FromMetres(3).Pow7()", "CS1061")] + public async Task UnsupportedConvenienceCallsRemainCompilerErrors(string expression, string diagnosticId) { - const string source = """ - public static class UserMethods { public static double Squared(this Length value) => 42; } - public static class Consumer { public static double Value() => Length.FromMetres(3).Squared(); } - """; - double result = EvaluateSource(source); + string source = $$"""class Consumer { object Value() => {{expression}}; }"""; - Assert.Equal(42, result); + QuantityGeneratorTest outputTest = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + CompilerDiagnostics = CompilerDiagnostics.None, + TestState = + { + Sources = { ("Consumer.cs", source) }, + }, + }; + await outputTest.RunAsync(TestContext.Current.CancellationToken); + Compilation output = outputTest.Compilation; + + Assert.Contains(output.GetDiagnostics(TestContext.Current.CancellationToken), diagnostic => diagnostic.Id == diagnosticId); } [Fact] - public void ConvenienceMethodCoexistsWithAnExistingOverload() + public async Task IntermediateConvenienceCallRequestsItsMethod() { - const string source = """ - public static class UserMethods { public static double Squared(this Length value, int factor) => value.AsMetres() * factor; } - public static class Consumer + const string source = "class Consumer { object Value(Length length, Current current) => (length * current).Squared(); }"; + + QuantityGeneratorTest originalTest = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + TestState = { - public static double[] Value() - { - Length length = Length.FromMetres(3); - return [length.Squared().AsSiBaseUnit(), length.Squared(4)]; - } - } - """; - double[] result = EvaluateSource(source); - double[] expected = [9, 12]; + Sources = { ("Consumer.cs", source) }, + }, + }; + await originalTest.RunAsync(TestContext.Current.CancellationToken); + Compilation original = originalTest.Compilation; + string[] originalMethods = ReadConvenienceMethods(original, new(Length: 1, ElectricCurrent: 1)); - Assert.Equal(expected, result); + Assert.Contains("Squared", originalMethods); } - [Theory] - [InlineData("(3d).Squared()", "CS1929")] - [InlineData("Length.FromMetres(3).Pow7()", "CS1061")] - public void UnsupportedConvenienceCallsRemainCompilerErrors(string expression, string diagnosticId) + [Fact] + public async Task ConsumerWithoutConvenienceCallsHasNoIntermediateMethods() { - string source = $$"""class Consumer { object Value() => {{expression}}; }"""; - CSharpCompilation input = CreateInputCompilation(source); - GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: _parseOptions); - driver.RunGeneratorsAndUpdateCompilation(input, out Compilation output, out ImmutableArray diagnostics, TestContext.Current.CancellationToken); + QuantityGeneratorTest removedTest = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + TestState = + { + Sources = { ("Consumer.cs", string.Empty) }, + }, + }; + await removedTest.RunAsync(TestContext.Current.CancellationToken); + Compilation removed = removedTest.Compilation; + string[] remainingMethods = ReadConvenienceMethods(removed, new(Length: 1, ElectricCurrent: 1)); - Assert.Multiple( - () => Assert.Empty(diagnostics), - () => Assert.Contains(output.GetDiagnostics(TestContext.Current.CancellationToken), diagnostic => diagnostic.Id == diagnosticId)); + Assert.DoesNotContain("Squared", remainingMethods); } + + [Fact] - public void RemovingIntermediateConvenienceCallsRemovesTheirGeneratedMethods() + public async Task ExplicitLengthCurrentLocalSupportsDependentArithmetic() { - const string source = "class Consumer { object Value(Length length, Current current) => (length * current).Squared(); }"; - CSharpCompilation input = CreateInputCompilation(source); - GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: _parseOptions); - driver = driver.RunGeneratorsAndUpdateCompilation(input, out Compilation original, out _, TestContext.Current.CancellationToken); - driver.RunGeneratorsAndUpdateCompilation(input.RemoveAllSyntaxTrees(), out Compilation removed, out ImmutableArray diagnostics, TestContext.Current.CancellationToken); - string[] originalMethods = ReadConvenienceMethods(original, new(Length: 1, ElectricCurrent: 1)); - string[] remainingMethods = ReadConvenienceMethods(removed, new(Length: 1, ElectricCurrent: 1)); + const string source = """ + class Consumer + { + object Value(Length length, Current current, Time time) + { + LengthCurrent value = length * current; + return value * time; + } + } + """; - Assert.Multiple( - () => Assert.Contains("Squared", originalMethods), - () => Assert.DoesNotContain("Squared", remainingMethods), - () => Assert.Empty(diagnostics)); + QuantityGeneratorTest initial1Test = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + TestState = + { + Sources = { ("Consumer.cs", source) }, + }, + }; + await initial1Test.RunAsync(TestContext.Current.CancellationToken); } [Fact] - public void EditingExplicitLocalUpdatesItsDependentArithmetic() + public async Task ExplicitLengthTimeLocalDeterminesDependentArithmetic() { const string source = """ class Consumer @@ -1030,15 +962,19 @@ object Value(Length length, Current current, Time time) } """; string edited = source.Replace("LengthCurrent value = length * current", "LengthTime value = length * time", StringComparison.Ordinal); - CSharpCompilation input = CreateInputCompilation(source); - GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: _parseOptions); - driver = driver.RunGeneratorsAndUpdateCompilation(input, out _, out _, TestContext.Current.CancellationToken); - CSharpCompilation changed = input.ReplaceSyntaxTree(input.SyntaxTrees.Single(), CSharpSyntaxTree.ParseText(edited, _parseOptions, path: "Consumer.cs", cancellationToken: TestContext.Current.CancellationToken)); - driver.RunGeneratorsAndUpdateCompilation(changed, out Compilation result, out ImmutableArray diagnostics, TestContext.Current.CancellationToken); + + QuantityGeneratorTest resultTest = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + TestState = + { + Sources = { ("Consumer.cs", edited) }, + }, + }; + await resultTest.RunAsync(TestContext.Current.CancellationToken); + Compilation result = resultTest.Compilation; Assert.Multiple( - () => Assert.Empty(diagnostics), - () => Assert.Empty(result.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)), () => Assert.Null(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")), () => Assert.Null(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeCurrentExtensions")), () => Assert.NotNull(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeSquaredExtensions"))); @@ -1046,7 +982,33 @@ object Value(Length length, Current current, Time time) [Fact] - public void EditingConditionalBranchesRemovesObsoleteDependentOperations() + public async Task LengthCurrentConditionalLocalSupportsDependentArithmetic() + { + const string source = """ + class Consumer + { + object Value(bool choose, Length length, Current current, Time time) + { + var product = choose ? length * current : length * current; + return product * time; + } + } + """; + + QuantityGeneratorTest initial1Test = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + TestState = + { + Sources = { ("Consumer.cs", source) }, + }, + }; + await initial1Test.RunAsync(TestContext.Current.CancellationToken); + } + + + [Fact] + public async Task LengthTimeConditionalLocalDeterminesDependentArithmetic() { const string source = """ class Consumer @@ -1059,102 +1021,110 @@ object Value(bool choose, Length length, Current current, Time time) } """; string edited = source.Replace("length * current", "length * time", StringComparison.Ordinal); - CSharpCompilation input = CreateInputCompilation(source); - GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: _parseOptions); - driver = driver.RunGeneratorsAndUpdateCompilation(input, out _, out _, TestContext.Current.CancellationToken); - SyntaxTree replacement = CSharpSyntaxTree.ParseText(edited, _parseOptions, path: "Consumer.cs", cancellationToken: TestContext.Current.CancellationToken); - driver.RunGeneratorsAndUpdateCompilation(input.ReplaceSyntaxTree(input.SyntaxTrees.Single(), replacement), out Compilation result, out ImmutableArray diagnostics, TestContext.Current.CancellationToken); + + QuantityGeneratorTest resultTest = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + TestState = + { + Sources = { ("Consumer.cs", edited) }, + }, + }; + await resultTest.RunAsync(TestContext.Current.CancellationToken); + Compilation result = resultTest.Compilation; Assert.Multiple( - () => Assert.Empty(diagnostics), - () => Assert.Empty(result.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)), () => Assert.Null(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeCurrentExtensions")), () => Assert.NotNull(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeSquaredExtensions"))); } [Fact] - public void EditingMemberDefinitionRemovesObsoleteDependentOperations() + public async Task LengthCurrentMemberSupportsDependentArithmetic() + { + const string source = "class Inputs { public static LengthCurrent Stored => Length.FromMetres(2) * Current.FromAmps(3); }"; + const string consumer = "class Consumer { object Value(Time time) => Inputs.Stored * time; }"; + + QuantityGeneratorTest initial1Test = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + TestState = + { + Sources = { ("Consumer.cs", consumer), ("Inputs.cs", source) }, + }, + }; + await initial1Test.RunAsync(TestContext.Current.CancellationToken); + } + + + [Fact] + public async Task LengthTimeMemberDeterminesDependentArithmetic() { const string source = "class Inputs { public static LengthCurrent Stored => Length.FromMetres(2) * Current.FromAmps(3); }"; const string consumer = "class Consumer { object Value(Time time) => Inputs.Stored * time; }"; string edited = source.Replace("LengthCurrent", "LengthTime", StringComparison.Ordinal).Replace("Current.FromAmps", "Time.FromSeconds", StringComparison.Ordinal); - SyntaxTree memberTree = CSharpSyntaxTree.ParseText(source, _parseOptions, path: "Inputs.cs", cancellationToken: TestContext.Current.CancellationToken); - CSharpCompilation input = CreateInputCompilation(consumer).AddSyntaxTrees(memberTree); - GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: _parseOptions); - driver = driver.RunGeneratorsAndUpdateCompilation(input, out _, out _, TestContext.Current.CancellationToken); - SyntaxTree replacement = CSharpSyntaxTree.ParseText(edited, _parseOptions, path: "Inputs.cs", cancellationToken: TestContext.Current.CancellationToken); - driver.RunGeneratorsAndUpdateCompilation(input.ReplaceSyntaxTree(memberTree, replacement), out Compilation result, out ImmutableArray diagnostics, TestContext.Current.CancellationToken); + + QuantityGeneratorTest resultTest = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + TestState = + { + Sources = { ("Consumer.cs", consumer), ("Inputs.cs", edited) }, + }, + }; + await resultTest.RunAsync(TestContext.Current.CancellationToken); + Compilation result = resultTest.Compilation; Assert.Multiple( - () => Assert.Empty(diagnostics), - () => Assert.Empty(result.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)), () => Assert.Null(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeCurrentExtensions")), () => Assert.NotNull(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeSquaredExtensions"))); } [Fact] - public void EditingMethodDefinitionRefreshesUnchangedConsumers() + public async Task LengthCurrentMethodSupportsConsumerArithmetic() { const string source = "class Inputs { public static LengthCurrent Make() => Length.FromMetres(2) * Current.FromAmps(3); }"; const string consumer = "class Consumer { object Value(Time time) => Inputs.Make() * time; }"; - string edited = source.Replace("LengthCurrent", "LengthTime", StringComparison.Ordinal).Replace("Current.FromAmps", "Time.FromSeconds", StringComparison.Ordinal); - SyntaxTree memberTree = CSharpSyntaxTree.ParseText(source, _parseOptions, path: "Inputs.cs", cancellationToken: TestContext.Current.CancellationToken); - CSharpCompilation input = CreateInputCompilation(consumer).AddSyntaxTrees(memberTree); - GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: _parseOptions); - driver = driver.RunGeneratorsAndUpdateCompilation(input, out _, out _, TestContext.Current.CancellationToken); - SyntaxTree replacement = CSharpSyntaxTree.ParseText(edited, _parseOptions, path: "Inputs.cs", cancellationToken: TestContext.Current.CancellationToken); - driver.RunGeneratorsAndUpdateCompilation(input.ReplaceSyntaxTree(memberTree, replacement), out Compilation result, out ImmutableArray diagnostics, TestContext.Current.CancellationToken); - Assert.Multiple( - () => Assert.Empty(diagnostics), - () => Assert.Empty(result.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)), - () => Assert.Null(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeCurrentExtensions")), - () => Assert.NotNull(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeSquaredExtensions"))); + QuantityGeneratorTest initial1Test = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + TestState = + { + Sources = { ("Consumer.cs", consumer), ("Inputs.cs", source) }, + }, + }; + await initial1Test.RunAsync(TestContext.Current.CancellationToken); } - [Theory] - [InlineData(false, 216)] - [InlineData(true, 72)] - public void WindingLossHelpersPreserveUnitsAndRoundTripResistance(bool delta, double expectedLoss) + + [Fact] + public async Task LengthTimeMethodDeterminesConsumerArithmetic() { - string source = $$""" - public static class Consumer + const string source = "class Inputs { public static LengthCurrent Make() => Length.FromMetres(2) * Current.FromAmps(3); }"; + const string consumer = "class Consumer { object Value(Time time) => Inputs.Make() * time; }"; + string edited = source.Replace("LengthCurrent", "LengthTime", StringComparison.Ordinal).Replace("Current.FromAmps", "Time.FromSeconds", StringComparison.Ordinal); + + QuantityGeneratorTest resultTest = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + TestState = { - private static Current PhaseCurrent(Current line, bool delta) => delta ? line / System.Math.Sqrt(3) : line; - private static Power Loss(Resistance resistance, Current line, bool delta) - { - Current phase = PhaseCurrent(line, delta); - CurrentSquared squared = phase.Squared(); - return 3 * squared * resistance; - } - private static Resistance Recover(Power loss, Current line, bool delta) - { - Current phase = PhaseCurrent(line, delta); - CurrentSquared denominator = 3 * phase.Squared(); - return loss / denominator; - } - public static double[] Value() - { - Current line = Current.FromAmps(12); - Resistance resistance = Resistance.FromSiBaseUnit(0.5); - Power loss = Loss(resistance, line, {{delta.ToString().ToLowerInvariant()}}); - Resistance recovered = Recover(loss, line, {{delta.ToString().ToLowerInvariant()}}); - return [loss.AsSiBaseUnit(), recovered.AsSiBaseUnit()]; - } - } - """; - double[] result = EvaluateSource(source); + Sources = { ("Consumer.cs", consumer), ("Inputs.cs", edited) }, + }, + }; + await resultTest.RunAsync(TestContext.Current.CancellationToken); + Compilation result = resultTest.Compilation; Assert.Multiple( - () => Assert.Equal(expectedLoss, result[0], 12), - () => Assert.Equal(0.5, result[1], 12)); + () => Assert.Null(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeCurrentExtensions")), + () => Assert.NotNull(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeSquaredExtensions"))); } [Fact] - public void TypeOnlyDeclarationsGenerateQuantitiesInPublicApisAndCollections() + public async Task TypeOnlyDeclarationsGenerateQuantitiesInPublicApisAndCollections() { const string source = """ public record Measurement(LengthCurrent Value); @@ -1167,24 +1137,19 @@ public class Consumer public LengthCurrent Identity(LengthCurrent value) => value; } """; - CSharpCompilation result = Compile(source); - Assert.NotNull(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")); - } - - [Fact] - public void TypeOnlyParameterSuppliesDimensionsToArithmeticWithoutAnInitialiser() - { - const string source = """ - public static class Consumer + QuantityGeneratorTest resultTest = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + TestState = { - private static LengthTimeCurrent Multiply(LengthCurrent input, Time time) => input * time; - public static double Value() => Multiply(LengthCurrent.FromSiBaseUnit(6), Time.FromSeconds(4)).AsSiBaseUnit(); - } - """; - double result = EvaluateSource(source); + Sources = { ("Consumer.cs", source) }, + }, + }; + await resultTest.RunAsync(TestContext.Current.CancellationToken); + Compilation result = resultTest.Compilation; - Assert.Equal(24, result); + Assert.NotNull(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")); } @@ -1195,52 +1160,101 @@ public static class Consumer [Theory] [InlineData("public class LengthCurrent { }")] [InlineData("using LengthCurrent = System.Int32;")] - public void ExistingTypesAndAliasesAreNotReplacedByQuantityNames(string declaration) + public async Task ExistingTypesAndAliasesAreNotReplacedByQuantityNames(string declaration) { string source = $$"""{{declaration}} class Consumer { object Value(LengthCurrent value) => value; }"""; - CSharpCompilation result = Compile(source); + + QuantityGeneratorTest resultTest = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + TestState = + { + Sources = { ("Consumer.cs", source) }, + }, + }; + await resultTest.RunAsync(TestContext.Current.CancellationToken); + Compilation result = resultTest.Compilation; Assert.Null(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")); } [Fact] - public void QuantityLookingVariableNamesDoNotRequestTypes() + public async Task QuantityLookingVariableNamesDoNotRequestTypes() { const string source = "class Consumer { int Value() { int LengthCurrent = 7; return LengthCurrent; } }"; - CSharpCompilation result = Compile(source); + + QuantityGeneratorTest resultTest = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + TestState = + { + Sources = { ("Consumer.cs", source) }, + }, + }; + await resultTest.RunAsync(TestContext.Current.CancellationToken); + Compilation result = resultTest.Compilation; Assert.Null(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")); } [Fact] - public void TypeNameDiscoveryPreservesExplicitAliasesInOtherFiles() + public async Task TypeNameDiscoveryPreservesExplicitAliasesInOtherFiles() { const string source = "class First { public LengthCurrent Value; }"; const string aliasSource = "using LengthCurrent = System.Int32; class Second { public int Value(LengthCurrent value) => value; }"; - CSharpCompilation input = CreateInputCompilation(source).AddSyntaxTrees(CSharpSyntaxTree.ParseText(aliasSource, _parseOptions, path: "Alias.cs", cancellationToken: TestContext.Current.CancellationToken)); - GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: _parseOptions); - driver.RunGeneratorsAndUpdateCompilation(input, out Compilation result, out ImmutableArray diagnostics, TestContext.Current.CancellationToken); + + QuantityGeneratorTest resultTest = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + CompilerDiagnostics = CompilerDiagnostics.None, + TestState = + { + Sources = { ("Consumer.cs", source), ("Alias.cs", aliasSource) }, + }, + }; + await resultTest.RunAsync(TestContext.Current.CancellationToken); + Compilation result = resultTest.Compilation; Diagnostic[] errors = result.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error).ToArray(); Assert.Multiple( - () => Assert.Empty(diagnostics), () => Assert.Contains(errors, error => error.Id == "CS0246" && error.Location.SourceTree?.FilePath == "Consumer.cs"), () => Assert.DoesNotContain(errors, error => error.Location.SourceTree?.FilePath == "Alias.cs")); } [Fact] - public void RemovingTypeOnlyDeclarationsRemovesTheirQuantities() + public async Task TypeOnlyDeclarationsRequestLocalConversions() { const string source = "class Consumer { public LengthCurrent Identity(LengthCurrent value) => value; }"; - CSharpCompilation input = CreateInputCompilation(source); - GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: _parseOptions); - driver = driver.RunGeneratorsAndUpdateCompilation(input, out Compilation original, out _, TestContext.Current.CancellationToken); - driver.RunGeneratorsAndUpdateCompilation(input.RemoveAllSyntaxTrees(), out Compilation result, out ImmutableArray diagnostics, TestContext.Current.CancellationToken); - Assert.Multiple( - () => Assert.NotNull(original.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")), - () => Assert.Null(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")), - () => Assert.Empty(diagnostics)); + QuantityGeneratorTest originalTest = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + TestState = + { + Sources = { ("Consumer.cs", source) }, + }, + }; + await originalTest.RunAsync(TestContext.Current.CancellationToken); + Compilation original = originalTest.Compilation; + + Assert.NotNull(original.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")); + } + + [Fact] + public async Task ConsumerWithoutTypeDeclarationsHasNoDemandGeneratedQuantities() + { + QuantityGeneratorTest resultTest = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + TestState = + { + Sources = { ("Consumer.cs", string.Empty) }, + }, + }; + await resultTest.RunAsync(TestContext.Current.CancellationToken); + Compilation result = resultTest.Compilation; + + Assert.Null(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")); } [Theory] @@ -1249,9 +1263,9 @@ public void RemovingTypeOnlyDeclarationsRemovesTheirQuantities() [InlineData("Library.Property")] [InlineData("Library.Values()[0]")] [InlineData("Library.Measure().Value")] - public void ReferencedQuantityValuesGetLocalConversionsWithoutArithmetic(string expression) + public async Task ReferencedQuantityValuesGetLocalConversionsWithoutArithmetic(string expression) { - PortableExecutableReference library = CreateLibraryReference(""" + PortableExecutableReference library = await CreateLibraryReference(""" public static class Library { public static LengthCurrent Create() => Length.FromMetres(2) * Current.FromAmps(3); @@ -1262,122 +1276,177 @@ public static class Library } public sealed class Measurement { public LengthCurrent Value => Library.Create(); } """); - CSharpCompilation input = CreateInputCompilation($"public class Consumer {{ public double Value() => {expression}.AsPrefixedUnits(3, 0); }}").AddReferences(library); - GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: _parseOptions); - driver.RunGeneratorsAndUpdateCompilation(input, out Compilation result, out ImmutableArray diagnostics, TestContext.Current.CancellationToken); - Diagnostic[] errors = result.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error).ToArray(); + QuantityGeneratorTest resultTest = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + TestState = + { + Sources = { ("Consumer.cs", $"public class Consumer {{ public double Value() => {expression}.AsPrefixedUnits(3, 0); }}") }, + AdditionalReferences = { library }, + }, + }; + await resultTest.RunAsync(TestContext.Current.CancellationToken); + Compilation result = resultTest.Compilation; - Assert.Multiple( - () => Assert.Empty(diagnostics), - () => Assert.Empty(errors), - () => Assert.NotNull(result.Assembly.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions"))); + Assert.NotNull(result.Assembly.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")); } [Fact] - public void ReferencedCollectionTypesRequestTheirNestedQuantity() + public async Task ReferencedCollectionTypesRequestTheirNestedQuantity() { - PortableExecutableReference library = CreateLibraryReference("public static class Library { public static System.Collections.Generic.List Values() => new(); }"); - CSharpCompilation input = CreateInputCompilation("public class Consumer { public object Value() => Library.Values(); }").AddReferences(library); - GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: _parseOptions); + PortableExecutableReference library = await CreateLibraryReference("public static class Library { public static System.Collections.Generic.List Values() => new(); }"); - driver.RunGeneratorsAndUpdateCompilation(input, out Compilation result, out ImmutableArray diagnostics, TestContext.Current.CancellationToken); + QuantityGeneratorTest resultTest = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + TestState = + { + Sources = { ("Consumer.cs", "public class Consumer { public object Value() => Library.Values(); }") }, + AdditionalReferences = { library }, + }, + }; + await resultTest.RunAsync(TestContext.Current.CancellationToken); + Compilation result = resultTest.Compilation; - Assert.Multiple( - () => Assert.Empty(diagnostics), - () => Assert.NotNull(result.Assembly.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions"))); + Assert.NotNull(result.Assembly.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")); } [Fact] - public void RemovingMetadataUsageRemovesItsLocallyGeneratedConversions() + public async Task ReferencedQuantityUsageRequestsLocalConversions() { - PortableExecutableReference library = CreateLibraryReference("public static class Library { public static LengthCurrent Create() => default; }"); - CSharpCompilation input = CreateInputCompilation("public class Consumer { public object Value() => Library.Create(); }").AddReferences(library); - GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: _parseOptions); - driver = driver.RunGeneratorsAndUpdateCompilation(input, out Compilation original, out _, TestContext.Current.CancellationToken); + PortableExecutableReference library = await CreateLibraryReference("public static class Library { public static LengthCurrent Create() => default; }"); - driver.RunGeneratorsAndUpdateCompilation(input.RemoveAllSyntaxTrees(), out Compilation result, out ImmutableArray diagnostics, TestContext.Current.CancellationToken); + QuantityGeneratorTest originalTest = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + TestState = + { + Sources = { ("Consumer.cs", "public class Consumer { public object Value() => Library.Create(); }") }, + AdditionalReferences = { library }, + }, + }; + await originalTest.RunAsync(TestContext.Current.CancellationToken); + Compilation original = originalTest.Compilation; - Assert.Multiple( - () => Assert.NotNull(original.Assembly.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")), - () => Assert.Null(result.Assembly.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")), - () => Assert.Empty(diagnostics)); + Assert.NotNull(original.Assembly.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")); } [Fact] - public void ReferencedClassesWithQuantityNamesAreNotTreatedAsQuantities() + public async Task UnusedReferencedQuantityHasNoLocalConversions() { - PortableExecutableReference library = CreateLibraryReference("public class LengthCurrent { } public static class Library { public static LengthCurrent Create() => new(); }"); - CSharpCompilation input = CreateInputCompilation("public class Consumer { public object Value() => Library.Create(); }").AddReferences(library); - GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: _parseOptions); + PortableExecutableReference library = await CreateLibraryReference("public static class Library { public static LengthCurrent Create() => default; }"); - driver.RunGeneratorsAndUpdateCompilation(input, out Compilation result, out ImmutableArray diagnostics, TestContext.Current.CancellationToken); + QuantityGeneratorTest resultTest = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + TestState = + { + Sources = { ("Consumer.cs", string.Empty) }, + AdditionalReferences = { library }, + }, + }; + await resultTest.RunAsync(TestContext.Current.CancellationToken); + Compilation result = resultTest.Compilation; - Assert.Multiple( - () => Assert.Empty(diagnostics), - () => Assert.Null(result.Assembly.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions"))); + Assert.Null(result.Assembly.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")); } [Fact] - public void MetadataDiscoveryPreservesExplicitConsumerAliases() + public async Task ReferencedClassesWithQuantityNamesAreNotTreatedAsQuantities() { - PortableExecutableReference library = CreateLibraryReference("public static class Library { public static LengthCurrent Create() => default; }"); - CSharpCompilation input = CreateInputCompilation("using LengthCurrent = System.Int32; public class Consumer { public object Value() => Library.Create(); public LengthCurrent Count => 1; }").AddReferences(library); - GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: _parseOptions); + PortableExecutableReference library = await CreateLibraryReference("public class LengthCurrent { } public static class Library { public static LengthCurrent Create() => new(); }"); - driver.RunGeneratorsAndUpdateCompilation(input, out Compilation result, out ImmutableArray diagnostics, TestContext.Current.CancellationToken); - Diagnostic[] errors = result.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error).ToArray(); + QuantityGeneratorTest resultTest = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + TestState = + { + Sources = { ("Consumer.cs", "public class Consumer { public object Value() => Library.Create(); }") }, + AdditionalReferences = { library }, + }, + }; + await resultTest.RunAsync(TestContext.Current.CancellationToken); + Compilation result = resultTest.Compilation; - Assert.Multiple( - () => Assert.Empty(diagnostics), - () => Assert.Empty(errors)); + Assert.Null(result.Assembly.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")); + } + + [Fact] + public async Task MetadataDiscoveryPreservesExplicitConsumerAliases() + { + PortableExecutableReference library = await CreateLibraryReference("public static class Library { public static LengthCurrent Create() => default; }"); + + QuantityGeneratorTest resultTest = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + TestState = + { + Sources = { ("Consumer.cs", "using LengthCurrent = System.Int32; public class Consumer { public object Value() => Library.Create(); public LengthCurrent Count => 1; }") }, + AdditionalReferences = { library }, + }, + }; + await resultTest.RunAsync(TestContext.Current.CancellationToken); + Compilation result = resultTest.Compilation; } [Theory] [InlineData("public class LengthCurrent { public int Marker { get; init; } }", "LengthCurrent", "new() { Marker = 7 }")] [InlineData("namespace LengthCurrent { public class Item { } }", "LengthCurrent.Item", "new()")] - public void MetadataDiscoveryPreservesExistingConsumerTypesAndNamespaces(string declaration, string type, string value) + public async Task MetadataDiscoveryPreservesExistingConsumerTypesAndNamespaces(string declaration, string type, string value) { - PortableExecutableReference library = CreateLibraryReference("public static class Library { public static LengthCurrent Create() => default; }"); + PortableExecutableReference library = await CreateLibraryReference("public static class Library { public static LengthCurrent Create() => default; }"); string source = $$"""{{declaration}} public class Consumer { public object Value() => Library.Create(); public {{type}} Item => {{value}}; }"""; - CSharpCompilation input = CreateInputCompilation(source).AddReferences(library); - GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: _parseOptions); - driver.RunGeneratorsAndUpdateCompilation(input, out Compilation result, out ImmutableArray diagnostics, TestContext.Current.CancellationToken); - Diagnostic[] errors = result.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error).ToArray(); - - Assert.Multiple( - () => Assert.Empty(diagnostics), - () => Assert.Empty(errors)); + QuantityGeneratorTest resultTest = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + TestState = + { + Sources = { ("Consumer.cs", source) }, + AdditionalReferences = { library }, + }, + }; + await resultTest.RunAsync(TestContext.Current.CancellationToken); + Compilation result = resultTest.Compilation; } [Fact] - public void ReferencedGenericResultsGetConversionsAfterTheirArgumentsResolve() + public async Task ReferencedGenericResultsGetConversionsAfterTheirArgumentsResolve() { - PortableExecutableReference library = CreateLibraryReference("public static class Library { public static LengthTime Convert(T value) => default; }"); + PortableExecutableReference library = await CreateLibraryReference("public static class Library { public static LengthTime Convert(T value) => default; }"); const string source = """ public static class Consumer { public static double Value(Length length, Current current) => Library.Convert(length * current).AsPrefixedUnits(0, 0); } """; - CSharpCompilation input = CreateInputCompilation(source).AddReferences(library); - GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: _parseOptions); - driver.RunGeneratorsAndUpdateCompilation(input, out Compilation result, out ImmutableArray diagnostics, TestContext.Current.CancellationToken); - Diagnostic[] errors = result.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error).ToArray(); + QuantityGeneratorTest resultTest = new() + { + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + TestState = + { + Sources = { ("Consumer.cs", source) }, + AdditionalReferences = { library }, + }, + }; + await resultTest.RunAsync(TestContext.Current.CancellationToken); + Compilation result = resultTest.Compilation; - Assert.Multiple( - () => Assert.Empty(diagnostics), - () => Assert.Empty(errors), - () => Assert.NotNull(result.Assembly.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeExtensions"))); + Assert.NotNull(result.Assembly.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeExtensions")); } - private static PortableExecutableReference CreateLibraryReference(string source) + private static async Task CreateLibraryReference(string source) { - CSharpCompilation library = Compile(source).WithAssemblyName("ReferencedQuantities"); + QuantityGeneratorTest test = new() + { + TestCode = source, + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + }; + await test.RunAsync(TestContext.Current.CancellationToken); using MemoryStream stream = new(); - EmitResult emitted = library.Emit(stream, cancellationToken: TestContext.Current.CancellationToken); + Microsoft.CodeAnalysis.Emit.EmitResult emitted = test.Compilation.WithAssemblyName("ReferencedQuantities").Emit(stream, cancellationToken: TestContext.Current.CancellationToken); if (!emitted.Success) { throw new InvalidOperationException(string.Join(Environment.NewLine, emitted.Diagnostics)); @@ -1397,56 +1466,6 @@ private static string[] ReadConvenienceMethods(Compilation compilation, Dimensio .Select(method => method.Identifier.ValueText).ToArray(); } - private static T Evaluate(string expression) - { - string source = $$""" - public static class Consumer - { - public static global::{{typeof(T).FullName}} Value() => {{expression}}; - } - """; - return EvaluateSource(source); - } - - private static T EvaluateSource(string source) - { - CSharpCompilation compilation = Compile(source); - using MemoryStream assemblyBytes = new(); - EmitResult emitResult = compilation.Emit(assemblyBytes, cancellationToken: TestContext.Current.CancellationToken); - Assert.True(emitResult.Success, string.Join(Environment.NewLine, emitResult.Diagnostics)); - Assembly assembly = Assembly.Load(assemblyBytes.ToArray()); - MethodInfo method = assembly.GetType("Consumer")!.GetMethod("Value")!; - return Assert.IsType(method.Invoke(null, null)); - } - - private static CSharpCompilation Compile(string source, IIncrementalGenerator? additionalGenerator = null) - { - CSharpCompilation input = CreateInputCompilation(source); - ISourceGenerator[] generators = additionalGenerator is null - ? [new QuantityGenerator().AsSourceGenerator()] - : [new QuantityGenerator().AsSourceGenerator(), additionalGenerator.AsSourceGenerator()]; - GeneratorDriver driver = CSharpGeneratorDriver.Create(generators, parseOptions: _parseOptions); - driver.RunGeneratorsAndUpdateCompilation(input, out Compilation output, out ImmutableArray generatorDiagnostics); - Diagnostic[] compilationErrors = output.GetDiagnostics(TestContext.Current.CancellationToken) - .Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error).ToArray(); - Assert.Multiple( - () => Assert.True(generatorDiagnostics.IsEmpty, string.Join(Environment.NewLine, generatorDiagnostics)), - () => Assert.True(compilationErrors.Length == 0, string.Join(Environment.NewLine, compilationErrors))); - return (CSharpCompilation)output; - } - - private static CSharpCompilation CreateInputCompilation(string source) - { - string[] platformAssemblies = ((string)AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES")!).Split(Path.PathSeparator); - IEnumerable references = platformAssemblies.Select(path => MetadataReference.CreateFromFile(path)) - .Append(MetadataReference.CreateFromFile(typeof(Quantity<>).Assembly.Location)); - return CSharpCompilation.Create( - "GeneratedQuantityConsumer", - [CSharpSyntaxTree.ParseText(source, _parseOptions, path: "Consumer.cs")], - references, - new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)); - } - private sealed class SemanticProbeGenerator : IIncrementalGenerator { public void Initialize(IncrementalGeneratorInitializationContext context) diff --git a/src/DimensionalQuantities.Roslyn.Tests/Generators/UnitProviderGenerationTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Generators/UnitProviderGenerationTests.cs index cb7f06e..5e0664a 100644 --- a/src/DimensionalQuantities.Roslyn.Tests/Generators/UnitProviderGenerationTests.cs +++ b/src/DimensionalQuantities.Roslyn.Tests/Generators/UnitProviderGenerationTests.cs @@ -1,16 +1,14 @@ -using System.Collections.Immutable; -using System.Reflection; -using DimensionalQuantities.Roslyn.Generators; -using DimensionalQuantities.TypeSystem; +using DimensionalQuantities.Roslyn.Tests.Testing; using Microsoft.CodeAnalysis; -using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.Emit; +using Microsoft.CodeAnalysis.Testing; using Xunit; namespace DimensionalQuantities.Roslyn.Tests.Generators; public sealed class UnitProviderGenerationTests { + private const string FootProvider = """ using DimensionalQuantities.Units.Declarations; namespace Independent.Units; @@ -28,59 +26,20 @@ private sealed class Foot; """; [Fact] - public void IndependentProviderGeneratesScaledFactoriesAndAccessors() - { - const string consumer = """ - namespace Independent.Units; - public static class Consumer - { - public static double[] Values() => [Length.FromFeet(10).AsMetres(), Length.FromMetres(0.6096).AsFeet()]; - } - """; - (Compilation compilation, ImmutableArray diagnostics) = Generate(FootProvider, consumer); - Assert.Empty(diagnostics); - double[] result = Evaluate(compilation, "Independent.Units.Consumer"); - Assert.Multiple( - () => Assert.Equal(3.048, result[0], 12), - () => Assert.Equal(2, result[1], 12)); - } - - [Fact] - public void AffineConversionsApplyOffsetOnlyToAbsoluteQuantities() - { - const string source = """ - using DimensionalQuantities.Units.Declarations; - [UnitProvider(GenerateSiPrefixes = true, GeneratePrefixConversions = true)] - internal static class CustomUnits - { - [QuantityUnit(typeof(Length))] - [UnitFactor(typeof(OffsetMetre))] - private sealed class LengthUnit; - [UnitSymbol("OffsetMetre", "OffsetMetres", "om", Scale = 2)] - [AffineUnit(5)] - private sealed class OffsetMetre; - } - public static class Consumer - { - public static double[] Values() - { - Length first = Length.FromOffsetMetres(3); - Length second = Length.FromOffsetMetres(2); - return [first.AsMetres(), first.AsOffsetMetres(), (first - second).AsDelta().AsOffsetMetres()]; - } - } - """; - (Compilation compilation, ImmutableArray diagnostics) = Generate(source, ""); - Assert.Empty(diagnostics); - Assert.Equal([16d, 3d, 1d], Evaluate(compilation, "Consumer")); - } - - [Fact] - public void ProviderConversionsArePublicAndNotRegeneratedByConsumers() + public async Task ProviderConversionsArePublicAndNotRegeneratedByConsumers() { - (Compilation provider, ImmutableArray providerDiagnostics) = Generate(FootProvider, ""); - Assert.Empty(providerDiagnostics); - MetadataReference reference = MetadataReference.CreateFromImage(Emit(provider)); + QuantityGeneratorTest providerTest = new() + { + TestCode = FootProvider, + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + }; + await providerTest.RunAsync(TestContext.Current.CancellationToken); + using MemoryStream bytes = new(); + EmitResult emitted = providerTest.Compilation.Emit(bytes, cancellationToken: TestContext.Current.CancellationToken); + if (!emitted.Success) + { + throw new InvalidOperationException(string.Join(Environment.NewLine, emitted.Diagnostics)); + } const string consumer = """ using Independent.Units; public static class Consumer @@ -88,187 +47,20 @@ public static class Consumer public static Area Value() => Length.FromFeet(1) * Length.FromFeet(2); } """; - (Compilation compilation, ImmutableArray diagnostics) = Generate("", consumer, reference); - INamespaceSymbol? localNamespace = compilation.Assembly.GlobalNamespace.GetNamespaceMembers() - .SingleOrDefault(symbol => symbol.Name == "Independent"); - - Assert.Multiple( - () => Assert.Empty(diagnostics), - () => Assert.Empty(compilation.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)), - () => Assert.Null(localNamespace)); - } - - [Fact] - public void ProviderCanOptIntoNamedAndParameterisedSiPrefixes() - { - const string source = """ - using DimensionalQuantities.Units.Declarations; - namespace Independent.Units; - [UnitProvider(GenerateSiPrefixes = true, GeneratePrefixConversions = true)] - internal static class CustomUnits - { - [QuantityUnit(typeof(Voltage))] - [UnitFactor(typeof(Spark))] - private sealed class VoltageUnit; - [UnitSymbol("Spark", "Sparks", "sp")] - private sealed class Spark; - } - public static class Consumer - { - public static double[] Values() => [Voltage.FromMilliSparks(500).AsSiBaseUnit(), Voltage.FromSiBaseUnit(2000).AsKiloSparks(), - Voltage.FromPrefixedUnits(3, sparkPrefixExponent: 3).AsSiBaseUnit(), Voltage.FromSiBaseUnit(0.004).AsPrefixedUnits(-3)]; - } - """; - (Compilation compilation, ImmutableArray diagnostics) = Generate(source, ""); - Assert.Empty(diagnostics); - double[] result = Evaluate(compilation, "Independent.Units.Consumer"); - Assert.Equal([0.5, 2, 3000, 4], result); - } - - [Fact] - public void CompoundFactorsPreserveOrderPowersAndAdditionalConversions() - { - const string source = """ - using DimensionalQuantities.Units.Declarations; - namespace Independent.Units; - [UnitProvider(GenerateSiPrefixes = true, GeneratePrefixConversions = true)] - internal static class CustomUnits - { - [QuantityUnit(typeof(CurrentDensity))] - [UnitFactor(typeof(Amp))] - [UnitFactor(typeof(Metre), Power = -2)] - [AdditionalUnit(typeof(PerSquareMillimetre))] - private sealed class CurrentDensityUnit; - [UnitFactor(typeof(Amp))] - [UnitFactor(typeof(Metre), Power = -2, PrefixExponent = -3)] - private sealed class PerSquareMillimetre; - [UnitSymbol("Amp", "Amps", "A")] - private sealed class Amp; - [UnitSymbol("Metre", "Metres", "m")] - private sealed class Metre; - } - public static class Consumer - { - public static double[] Values() => [CurrentDensity.FromAmpsPerSquareMilliMetre(1).AsSiBaseUnit(), - CurrentDensity.FromPrefixedUnits(2, ampPrefixExponent: 0, metrePrefixExponent: -3).AsSiBaseUnit(), - CurrentDensity.FromSiBaseUnit(1000000).AsAmpsPerSquareMilliMetre()]; - } - """; - (Compilation compilation, ImmutableArray diagnostics) = Generate(source, ""); - Assert.Empty(diagnostics); - double[] result = Evaluate(compilation, "Independent.Units.Consumer"); - Assert.Equal([1000000d, 2000000d, 1d], result); - } - - [Fact] - public void ProviderUsesCoreSiSymbolsAcrossAssemblyBoundary() - { - const string source = """ - using DimensionalQuantities.Units.Declarations; - using DimensionalQuantities.Units.Symbols; - namespace Independent.Units; - [UnitProvider(GenerateSiPrefixes = true, GeneratePrefixConversions = true)] - internal static class CompoundUnits - { - [QuantityUnit(typeof(CurrentDensity))] - [UnitFactor(typeof(Amp))] - [UnitFactor(typeof(Metre), Power = -2)] - private sealed class CurrentDensityUnit; - [QuantityUnit(typeof(Density))] - [UnitFactor(typeof(Gram), PrefixExponent = 3)] - [UnitFactor(typeof(Metre), Power = -3)] - private sealed class DensityUnit; - } - public static class Consumer - { - public static double[] Values() => - [CurrentDensity.FromAmpsPerSquareMetre(2).AsSiBaseUnit(), - CurrentDensity.FromPrefixedUnits(2, ampPrefixExponent: 0, metrePrefixExponent: -3).AsSiBaseUnit(), - Density.FromGramsPerCubicMetre(2).AsSiBaseUnit(), - Density.FromPrefixedUnits(2, gramPrefixExponent: 0, metrePrefixExponent: 0).AsSiBaseUnit()]; - } - """; - (Compilation compilation, ImmutableArray diagnostics) = Generate(source, ""); - Assert.Empty(diagnostics); - Assert.Equal([2d, 2000000d, 0.002d, 0.002d], Evaluate(compilation, "Independent.Units.Consumer")); - } - - [Fact] - public void OneUnitDeclarationCanServeDistinctQuantityTypes() - { - const string source = """ - using DimensionalQuantities.Units.Declarations; - namespace Independent.Units; - [UnitProvider] - internal static class CommonUnits - { - [QuantityUnit(typeof(Length))] - [QuantityUnit(typeof(Time))] - [UnitFactor(typeof(Token))] - private sealed class TokenUnit; - [UnitSymbol("Token", "Tokens", "token")] - private sealed class Token; - } - public static class Consumer - { - public static double[] Values() => - [Length.FromTokens(2).AsSiBaseUnit(), Time.FromTokens(3).AsSiBaseUnit()]; - } - """; - (Compilation compilation, ImmutableArray diagnostics) = Generate(source, ""); - Assert.Empty(diagnostics); - Assert.Equal([2d, 3d], Evaluate(compilation, "Independent.Units.Consumer")); - } - - [Fact] - public void ProviderFactoriesCanBeUsedInArithmeticInTheirOwnAssembly() - { - const string consumer = """ - namespace Independent.Units; - public static class Consumer - { - public static double[] Values() => [(Length.FromFeet(2) * Length.FromFeet(3)).AsSiBaseUnit()]; - } - """; - (Compilation compilation, ImmutableArray diagnostics) = Generate(FootProvider, consumer); - Assert.Empty(diagnostics); - double[] result = Evaluate(compilation, "Independent.Units.Consumer"); - Assert.Equal(0.55741824, Assert.Single(result), 12); - } - - [Fact] - public void RecordClassProvidersGenerateConversions() - { - const string provider = """ - using DimensionalQuantities.Units.Declarations; - namespace Independent.Units; - [UnitProvider] - internal record class CustomUnits - { - [QuantityUnit(typeof(Length))] - [UnitFactor(typeof(Foot))] - private sealed class LengthUnit; - [UnitSymbol("Foot", "Feet", "ft", Scale = 0.3048)] - private sealed class Foot; - } - """; - const string consumer = """ - namespace Independent.Units; - public static class Consumer - { - public static double[] Values() => [Length.FromFeet(1).AsMetres()]; - } - """; - (Compilation compilation, ImmutableArray diagnostics) = Generate(provider, consumer); - Assert.Empty(diagnostics); - double[] result = Evaluate(compilation, "Independent.Units.Consumer"); - Assert.Equal(0.3048, Assert.Single(result), 12); + QuantityGeneratorTest consumerTest = new() + { + TestCode = consumer, + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + TestState = { AdditionalReferences = { MetadataReference.CreateFromImage(bytes.ToArray()) } }, + }; + await consumerTest.RunAsync(TestContext.Current.CancellationToken); + Assert.DoesNotContain(consumerTest.Compilation.Assembly.GlobalNamespace.GetNamespaceMembers(), symbol => symbol.Name == "Independent"); } [Theory] [InlineData("Bad name", "Feet")] [InlineData("Foot", "Bad names")] - public void InvalidUnitNamesReportDeclarationDiagnostics(string singular, string plural) + public async Task InvalidUnitNamesReportDeclarationDiagnostics(string singular, string plural) { string source = $$""" using DimensionalQuantities.Units.Declarations; @@ -282,76 +74,11 @@ private sealed class LengthUnit; private sealed class Foot; } """; - (Compilation compilation, ImmutableArray diagnostics) = Generate(source, ""); - Assert.Multiple( - () => Assert.Empty(compilation.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)), - () => Assert.Equal("DQ0008", Assert.Single(diagnostics).Id)); - } - - [Fact] - public void ProvidersInSameNamespaceCanConvertSameQuantity() - { - const string source = """ - using DimensionalQuantities.Units.Declarations; - namespace Independent.Units; - [UnitProvider] - internal static class ImperialUnits - { - [QuantityUnit(typeof(Length))] - [UnitFactor(typeof(Foot))] - private sealed class LengthUnit; - [UnitSymbol("Foot", "Feet", "ft", Scale = 0.3048)] - private sealed class Foot; - } - [UnitProvider] - internal static class SurveyUnits - { - [QuantityUnit(typeof(Length))] - [UnitFactor(typeof(Yard))] - private sealed class LengthUnit; - [UnitSymbol("Yard", "Yards", "yd", Scale = 0.9144)] - private sealed class Yard; - } - public static class Consumer - { - public static double[] Values() => [Length.FromFeet(3).AsYards(), Length.FromYards(2).AsFeet()]; - } - """; - (Compilation compilation, ImmutableArray diagnostics) = Generate(source, ""); - Assert.Empty(diagnostics); - double[] result = Evaluate(compilation, "Independent.Units.Consumer"); - Assert.Multiple( - () => Assert.Equal(1, result[0], 12), - () => Assert.Equal(6, result[1], 12)); - } - - private static (Compilation Compilation, ImmutableArray Diagnostics) Generate(string provider, string consumer, params MetadataReference[] additionalReferences) - { - CSharpParseOptions options = new(LanguageVersion.Preview); - string[] assemblies = ((string)AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES")!).Split(Path.PathSeparator); - IEnumerable references = assemblies.Select(path => MetadataReference.CreateFromFile(path)) - .Append(MetadataReference.CreateFromFile(typeof(Quantity<>).Assembly.Location)).Concat(additionalReferences); - CSharpCompilation input = CSharpCompilation.Create("ProviderTest" + Guid.NewGuid().ToString("N"), - [CSharpSyntaxTree.ParseText(provider, options), CSharpSyntaxTree.ParseText(consumer, options)], references, new(OutputKind.DynamicallyLinkedLibrary)); - GeneratorDriver driver = CSharpGeneratorDriver.Create([new QuantityGenerator().AsSourceGenerator()], parseOptions: options); - driver.RunGeneratorsAndUpdateCompilation(input, out Compilation output, out ImmutableArray diagnostics, TestContext.Current.CancellationToken); - return (output, diagnostics); - } - - private static double[] Evaluate(Compilation compilation, string consumerType) - { - Assembly assembly = Assembly.Load(Emit(compilation)); - return (double[])assembly.GetType(consumerType)!.GetMethod("Values")!.Invoke(null, null)!; - } - - private static byte[] Emit(Compilation compilation) - { - using MemoryStream stream = new(); - EmitResult result = compilation.Emit(stream, cancellationToken: TestContext.Current.CancellationToken); - if (!result.Success) + await new QuantityGeneratorTest { - throw new InvalidOperationException(string.Join(Environment.NewLine, result.Diagnostics)); - } - return stream.ToArray(); + TestCode = source, + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, + ExpectedDiagnostics = { new DiagnosticResult("DQ0008", DiagnosticSeverity.Error).WithSpan(3, 23, 3, 28).WithMessage("Unit provider for Length produces an invalid C# identifier.") }, + }.RunAsync(TestContext.Current.CancellationToken); } } From b4d370711c934de11c97601ea866eb8d7e0ce1b2 Mon Sep 17 00:00:00 2001 From: James McMahon Date: Fri, 13 Nov 2026 10:16:59 +0000 Subject: [PATCH 04/16] test: remove Roslyn and integration suites for rewrite --- docs/testing-behaviour-catalogue.md | 413 +++++ ...ensionalQuantities.IntegrationTests.csproj | 23 - .../Packaging/MsbuildCollection.cs | 6 - .../Packaging/PackageTestSupport.cs | 53 - .../Packaging/PackagedArithmeticTests.cs | 529 ------ .../Packaging/PackagedGeneratorTests.cs | 493 ------ .../Packaging/PackagedUnitProviderTests.cs | 271 --- .../Packaging/SymbolPackageTests.cs | 173 -- .../DimensionMismatchAnalyzerTests.cs | 133 -- .../QuantityEncodingAnalyzerTests.cs | 83 - .../QuantityAliasCodeFixProviderTests.cs | 78 - .../DimensionalQuantities.Roslyn.Tests.csproj | 26 - .../Discovery/ArithmeticDiscoveryTests.cs | 183 -- .../Discovery/DiscoverySeedCollectorTests.cs | 33 - .../EnglishExponentDiscoveryTests.cs | 99 -- .../MetadataQuantityDiscoveryTests.cs | 88 - .../Discovery/PowerDiscoveryTests.cs | 108 -- .../Discovery/PowerMethodDiscoveryTests.cs | 129 -- .../QuantityDiscoveryCoordinatorTests.cs | 1283 -------------- .../Discovery/QuantityNameDiscoveryTests.cs | 60 - .../Discovery/QuantityTypeReaderTests.cs | 84 - .../Discovery/TypeSystemNumberReaderTests.cs | 65 - .../ArithmeticSourceEmitterTests.cs | 102 -- .../Generators/CoreConversionBoundaryTests.cs | 49 - .../DefaultQuantityDiscoveryTests.cs | 48 - .../EnglishExponentAliasEmitterTests.cs | 71 - .../Generators/GenerationDiagnosticTests.cs | 221 --- .../PowerMethodSourceEmitterTests.cs | 104 -- .../Generators/PowerSourceEmitterTests.cs | 75 - .../Generators/QuantityDiscoveryTests.cs | 202 --- .../Generators/QuantityGeneratorTests.cs | 1517 ----------------- .../Generators/QuantitySourceEmitterTests.cs | 138 -- .../UnitConversionSourceEmitterTests.cs | 142 -- .../Generators/UnitProviderGenerationTests.cs | 84 - .../Generators/UnitProviderReaderTests.cs | 184 -- .../Testing/QuantityAnalyzerTest.cs | 19 - .../Testing/QuantityCodeFixTest.cs | 17 - .../Testing/QuantityGeneratorReference.cs | 22 - .../Testing/QuantityGeneratorTest.cs | 30 - .../Testing/QuantityTestConfiguration.cs | 18 - src/DimensionalQuantities.slnx | 2 - 41 files changed, 413 insertions(+), 7045 deletions(-) create mode 100644 docs/testing-behaviour-catalogue.md delete mode 100644 src/DimensionalQuantities.IntegrationTests/DimensionalQuantities.IntegrationTests.csproj delete mode 100644 src/DimensionalQuantities.IntegrationTests/Packaging/MsbuildCollection.cs delete mode 100644 src/DimensionalQuantities.IntegrationTests/Packaging/PackageTestSupport.cs delete mode 100644 src/DimensionalQuantities.IntegrationTests/Packaging/PackagedArithmeticTests.cs delete mode 100644 src/DimensionalQuantities.IntegrationTests/Packaging/PackagedGeneratorTests.cs delete mode 100644 src/DimensionalQuantities.IntegrationTests/Packaging/PackagedUnitProviderTests.cs delete mode 100644 src/DimensionalQuantities.IntegrationTests/Packaging/SymbolPackageTests.cs delete mode 100644 src/DimensionalQuantities.Roslyn.Tests/Analyzers/DimensionMismatchAnalyzerTests.cs delete mode 100644 src/DimensionalQuantities.Roslyn.Tests/Analyzers/QuantityEncodingAnalyzerTests.cs delete mode 100644 src/DimensionalQuantities.Roslyn.Tests/CodeFixes/QuantityAliasCodeFixProviderTests.cs delete mode 100644 src/DimensionalQuantities.Roslyn.Tests/DimensionalQuantities.Roslyn.Tests.csproj delete mode 100644 src/DimensionalQuantities.Roslyn.Tests/Discovery/ArithmeticDiscoveryTests.cs delete mode 100644 src/DimensionalQuantities.Roslyn.Tests/Discovery/DiscoverySeedCollectorTests.cs delete mode 100644 src/DimensionalQuantities.Roslyn.Tests/Discovery/EnglishExponentDiscoveryTests.cs delete mode 100644 src/DimensionalQuantities.Roslyn.Tests/Discovery/MetadataQuantityDiscoveryTests.cs delete mode 100644 src/DimensionalQuantities.Roslyn.Tests/Discovery/PowerDiscoveryTests.cs delete mode 100644 src/DimensionalQuantities.Roslyn.Tests/Discovery/PowerMethodDiscoveryTests.cs delete mode 100644 src/DimensionalQuantities.Roslyn.Tests/Discovery/QuantityDiscoveryCoordinatorTests.cs delete mode 100644 src/DimensionalQuantities.Roslyn.Tests/Discovery/QuantityNameDiscoveryTests.cs delete mode 100644 src/DimensionalQuantities.Roslyn.Tests/Discovery/QuantityTypeReaderTests.cs delete mode 100644 src/DimensionalQuantities.Roslyn.Tests/Discovery/TypeSystemNumberReaderTests.cs delete mode 100644 src/DimensionalQuantities.Roslyn.Tests/Generators/ArithmeticSourceEmitterTests.cs delete mode 100644 src/DimensionalQuantities.Roslyn.Tests/Generators/CoreConversionBoundaryTests.cs delete mode 100644 src/DimensionalQuantities.Roslyn.Tests/Generators/DefaultQuantityDiscoveryTests.cs delete mode 100644 src/DimensionalQuantities.Roslyn.Tests/Generators/EnglishExponentAliasEmitterTests.cs delete mode 100644 src/DimensionalQuantities.Roslyn.Tests/Generators/GenerationDiagnosticTests.cs delete mode 100644 src/DimensionalQuantities.Roslyn.Tests/Generators/PowerMethodSourceEmitterTests.cs delete mode 100644 src/DimensionalQuantities.Roslyn.Tests/Generators/PowerSourceEmitterTests.cs delete mode 100644 src/DimensionalQuantities.Roslyn.Tests/Generators/QuantityDiscoveryTests.cs delete mode 100644 src/DimensionalQuantities.Roslyn.Tests/Generators/QuantityGeneratorTests.cs delete mode 100644 src/DimensionalQuantities.Roslyn.Tests/Generators/QuantitySourceEmitterTests.cs delete mode 100644 src/DimensionalQuantities.Roslyn.Tests/Generators/UnitConversionSourceEmitterTests.cs delete mode 100644 src/DimensionalQuantities.Roslyn.Tests/Generators/UnitProviderGenerationTests.cs delete mode 100644 src/DimensionalQuantities.Roslyn.Tests/Generators/UnitProviderReaderTests.cs delete mode 100644 src/DimensionalQuantities.Roslyn.Tests/Testing/QuantityAnalyzerTest.cs delete mode 100644 src/DimensionalQuantities.Roslyn.Tests/Testing/QuantityCodeFixTest.cs delete mode 100644 src/DimensionalQuantities.Roslyn.Tests/Testing/QuantityGeneratorReference.cs delete mode 100644 src/DimensionalQuantities.Roslyn.Tests/Testing/QuantityGeneratorTest.cs delete mode 100644 src/DimensionalQuantities.Roslyn.Tests/Testing/QuantityTestConfiguration.cs diff --git a/docs/testing-behaviour-catalogue.md b/docs/testing-behaviour-catalogue.md new file mode 100644 index 0000000..4123956 --- /dev/null +++ b/docs/testing-behaviour-catalogue.md @@ -0,0 +1,413 @@ +# DimensionalQuantities testing behaviour catalogue + +This catalogue defines the behaviours to cover when redesigning the compiler-tooling tests and their consumer integration tests. It covers generated quantity APIs, discovery, dimensional operations, diagnostics, alias fixes, unit providers and delivered packages. Runtime contracts used by those APIs are included. Standalone internal numerical utilities are outside the proposed rewrite unless they are needed to establish one of these behaviours. + +The requirements come from current production code and the README at `881f0fcebfe0d205e26bb672ba71b865d0cbd87d`. Existing test names, assertions, helpers and test history were not used as requirements. The examples are proposed inputs and expected outcomes, not results of new executions. The previous Roslyn and consumer integration test suites have been removed for a fresh implementation from this catalogue. Runtime and extension unit-test suites remain outside that replacement. The fresh author must use this catalogue and production code, without consulting the deleted tests, their helpers or their Git history. + +This is a catalogue of existing behaviour, not a product feature review. It does not authorise new functionality, broader syntax support or additional defensive machinery. A current implementation detail is not automatically a requirement. The review-decision section records accepted behaviour and excludes speculative extensions; only concrete failures of supported contracts warrant separate defect reports. + +## Test allocation + +There are two destinations. Both are run by the ordinary test runner; the distinction is whether a test needs an extra temporary consumer project. + +| Destination | What belongs here | +| --- | --- | +| Normal testing framework | Microsoft.CodeAnalysis.Testing for generated source, diagnostics, fixes, compilation and semantic binding. Ordinary xUnit tests for directly callable public runtime code, real package archive/symbol inspection and loading the delivered fix provider into a workspace. Referenced assemblies/multiple compiler projects remain framework fixtures; they do not by themselves require a standalone project. | +| Ephemeral project | An isolated temporary consumer project for the representative generated-code executions below or for proving real PackageReference activation/dependencies. Invalid-build cases stop at the expected build failure. Package archive/symbol inspection and workspace loading remain normal tests against actual packaged assets. | + +An ID ending in `-F` is a normal-framework check. An ID ending in `-E` needs an ephemeral project. Both refer to the original catalogue ID below. Mixed entries are split by observable outcome: for example, G09-F checks multiplication result dimensions/signatures, while G09-E checks the resulting numerical value. These are distinct assertions, not a requirement to duplicate the full scenario in both suites. Shared numerical rules have one owner; another behaviour that uses the same rule does not acquire a second execution requirement. C# lifting is checked through compiler semantics rather than a separate nullable execution matrix. + +Executing an ordinary public runtime method does not require an ephemeral project. This applies to R01-R03, U15, the direct AsDelta portion of U14 and the handwritten RPM helper U22. Runtime-only portions of U12 can also use normal tests. When a generated body needs a numerical execution check, execute it through an ephemeral project. Not every generated body or source variation needs such a check; framework output/semantic checks and direct tests of already-compiled shared code cover the other cases. A public method already compiled into a shipped extension assembly can be called directly in a normal test, even if a generator originally produced it. Shipped Metric, Imperial, Nautical and CGS conversion values therefore stay in normal tests; their package delivery is covered by P01-P04. + +Package checks must obtain their assets through the actual pack/restore route. P03-F/P04-F can inspect/load the resulting artifacts without another consumer project. An in-memory compiler test with hand-added source references cannot establish that a package delivers the correct assets. Conversely, multi-file or metadata binding alone stays in the normal framework. Preserve the agreed isolation: each case tests one behaviour, and inputs are not grouped to reduce build time. + +### Normal testing framework + +| Check | Behaviour to verify | +| --- | --- | +| R01-F | Call the public SI factory/accessor directly; check stored magnitude, zero defaults and unchanged values. | +| R02-F | Call runtime arithmetic directly; check values and return types. Use compiler cases for incompatible types. | +| R03-F | Call comparisons, Abs/Min/Max/Clamp directly, including reversed-bound exceptions; compile incompatible-type controls. | +| G01-F | Check all aliases, canonical target types, synonym identity and availability without preceding demand. | +| G02-F | Check canonical type-name requests, generated aliases and rejected spellings in each required type position. | +| G03-F | Check factory-only discovery, inferred types, method availability and unrelated member-use controls. | +| G04-F | Check bound user names, explicit aliases and the accepted reservation policy without replacing their meaning. | +| G05-F | Check intermediate/result types and binding throughout each arithmetic chain; numerical operator/power rules are covered by the execution checks below. | +| G06-F | Check quantity propagation across each required C# binding boundary, including multiple source files. | +| G07-F | Use referenced-assembly/metadata fixtures to check discovered types, local helpers, identity and further binding. Package delivery is P01-E/P02-E. | +| G08-F | Check genuine library symbol recognition, exact encoded dimensions and absence of lookalike-generated operations. | +| G09-F | Check result dimensions, operand signatures, ordering and partial cancellation. | +| G10-F | Check cancellation returns double, subsequent scalar binding and no duplicate/dimensionless declarations; verify the emitted multiplication expression. | +| G11-F | Check scalar/inverse types and numeric conversion forms; verify the emitted left/right SI division and result construction. | +| G12-F | Verify selected operators, lifted operation semantics and nullable result types for each required nullable/nonnullable combination; no nullable-specific body is emitted. | +| G13-F | Check the selected user operator/method symbol and absence of generated competing operations; no execution of consumer-written method bodies is required. | +| G14-F | Check exact rational result dimensions, actual return types and zeroth-power double signatures. | +| G15-F | Check explicit Power aliases/encodings, actual closed receiver signatures and unrelated/unreadable controls. | +| G16-F | Check on-demand English aliases, canonical targets, cross-file scope and non-request controls. | +| G17-F | Check all ten predefined helpers, including their signatures and emitted delegation to the correct Power.Of call, plus availability/rejection cases. | +| G18-F | Check discovered helper chains, emitted delegation, further result dimensions and conditional-access binding; shared power values are G14-E/G19-E. | +| G20-F | Check declaration/signature uniqueness and absence of ambiguity across repeated/equivalent requests. | +| G21-F | Check compiler/DQ diagnostics, ordinary incomplete-source tolerance and absence of fabricated output. | +| G22-F | Check incompatible assignments, returns, arguments, branches and element types remain compiler errors. | +| D01-F | Check diagnostic identity, category, severity, message arguments and complete expected sets. | +| D02-F | Check incompatible binary-operator diagnostics, exact spans and valid controls. | +| D03-F | Check compound-assignment diagnostics, exact spans and valid controls. | +| D04-F | Check diagnostic suppression for successfully bound user operators and accepted native binding. | +| D05-F | Check diagnostic quantity identity, nullable/metadata cases and unrelated/unreadable controls. | +| D06-F | Check assignment/initialiser diagnostics and supported valid/incomplete controls. | +| D07-F | Check diagnostics for the supported block and expression-bodied return destinations. | +| D08-F | Check supported argument mapping, constructor/method diagnostics and ambiguous/unknown controls. | +| D09-F | Check readable preferred/canonical dimension names in diagnostic messages and alias properties. | +| D10-F | Check incomplete/open source and library-free compilations do not crash or receive false encoding errors. | +| D11-F | Check recognised generated-code exclusion for analysers and ordinary-source controls. | +| D12-F | Check raw canonical quantity suggestions, properties and exact generic-name spans. | +| D13-F | Check using-alias/dimensionless suggestion exclusions without bypassing encoding validation. | +| D14-F | Check noncanonical encoding warnings, canonical controls and suggestion precedence. | +| D15-F | Check invalid closed encoding errors, precedence and ordinary Roslyn recovery cases. | +| D16-F | Check Power encoding diagnostics independently of invocation and unrelated-type controls. | +| D17-F | Check declared-name collision warnings, locations, resulting output and accepted alias policy. | +| D18-F | Check actual displaced versus unchanged bindings using metadata/source fixtures. | +| D19-F | Check invalid unresolved English requests, locations/messages and valid requests. | +| D20-F | Check bound aliases and non-request syntax do not receive false English-request diagnostics. | +| D21-F | Check alias-fix eligibility, action title/equivalence key and unsupported diagnostic IDs. | +| D22-F | Check existing speculative type-identity safeguards and safe/unsafe alias visibility cases. | +| D23-F | Check ordinary type-use replacement, wrappers, qualification and exterior trivia under the agreed best-effort policy. | +| D24-F | Check the actual nameof-operation exclusion and ordinary invocation controls. | +| D25-F | Check actual Fix All application across eligible/ineligible occurrences and documents, using alias-specific actions. | +| U01-F | Check generated public accessibility, namespace/import binding and unmarked-provider absence using compiler fixtures. | +| U02-F | Check associations, receiver types, invalid-target diagnostics and unassociated declaration controls. | +| U03-F | Check same-runtime-type association consolidation, available alternatives and no duplicate overloads. | +| U04-F | Check alternative method availability, receiver/association rules, expected conversion expressions and invalid references. | +| U05-F | Check public method names/signatures for ordered factors, irregular plurals, powers, roots and inverse forms. | +| U06-F | Check both options and their four combinations, defaults, affine exclusions and fixed-prefix declarations. | +| U07-F | Check named-prefix APIs, absent variants and expected factor-placement/scale expressions; call shipped conversions directly for their values. | +| U08-F | Check generic-prefix signatures/defaults; call already-compiled shipped conversion methods directly for their values. | +| U09-F | Check identical-name coalescing and conflicting-semantics DQ0008 diagnostics. | +| U10-F | Check partial-provider deduplication, ordinary container identity and no valid-association output controls. | +| U11-F | Check shipped numerical values directly and independently expected custom scale/power expressions; the common emitter does not require another custom-conversion execution test. | +| U12-F | Check helper spellings, expected generated mass-scale expressions and direct runtime baseline; call shipped mass conversions directly. | +| U13-F | Call shipped Celsius/Fahrenheit/Rankine conversions directly; inspect expected custom affine factory/accessor expressions. | +| U14-F | Call AsDelta and shipped delta accessors directly; inspect expected custom scale-only accessor expressions and compile type controls. | +| U15-F | Call the public runtime SI-component APIs directly using explicit quantity types; check prefixes, dimensions and overall scale. | +| U16-F | Check generated literal text/semantic constant values and successful compilation under required cultures; no separate consumer execution is needed. | +| U17-F | Check invalid-factor DQ0008 cases, locations and accepted factor-boundary controls. | +| U18-F | Check existing affine restrictions/diagnostics and independent valid declarations. | +| U19-F | Check missing expressions, invalid generated identifiers and existing recovery/output behaviour. | +| U20-F | Check core/optional API presence and absence with controlled references/imports; actual core-only delivery is P01-E. | +| U21-F | Call the compiled Metric APIs directly for numerical results; use compiler fixtures for signatures, shared receivers and namespace/prefix rules. | +| U22-F | Call handwritten FromRpm/ToRpm directly; check numerical values, sign, zero and actual API spelling. | +| U23-F | Call the compiled Imperial APIs directly against customary definitions; use compiler fixtures for names, namespace and absent-prefix rules. | +| U24-F | Call the compiled Nautical APIs directly for length/area/speed values; check shared types and absent-prefix rules. | +| U25-F | Call the compiled CGS APIs directly for scales and synonyms; check shared types, namespace and absent-prefix rules. | +| U26-F | Use producer/consumer metadata fixtures to check public methods, shared types and no provider regeneration; real package composition is P02-E. | +| P03-F | Inspect genuinely packed archives, dependency metadata and matching DLL/PDB/symbol assets using normal tests. Runtime closure uses P01-E/P02-E; no new consumer project is needed for archive assertions. | +| P04-F | Discover/load the delivered fix provider from real package assets in a compatible workspace and invoke an ordinary supported fix. This is a normal workspace/package-asset test, not another consumer project or a broader host matrix. | + +### Ephemeral projects + +Execution covers the distinct numerical rules below, not every source shape that requests them. Discovery paths, aliases, helper delegation and provider options stay in source/semantic framework checks. Shipped conversion values stay in direct normal tests. Package checks cover delivery separately. This narrows duplicated execution requirements; it does not combine unrelated behaviours into a shared test. + +| Check | Behaviour to verify | +| --- | --- | +| G09-E | Execute representative generated multiplication and division calculations; dimension/operand-shape matrices stay in G09-F. | +| G14-E | Execute representative ordinary generated rational-power values; encoding/discovery variations stay in framework cases, and negative-base odd-root cases belong only to G19-E. | +| G19-E | Execute the distinct negative-base odd-denominator numerical cases and an even-root control; do not retest the full Math.Pow domain. | +| U08-E | Execute a representative generated parameterised compound-prefix formula; API/options/default-expression variations remain in framework cases. | +| P01-E | Restore only core; run a valid consumer and check an invalid build receives the packaged analyser diagnostic. Includes actual core-only API delivery from U20. | +| P02-E | Verify each optional package supplies matching core transitively and is usable by a consumer; use a representative cross-assembly composition for shared runtime identity. | + +The engineering-alias table, power-helper list and conversion data are parameter data for these checks. Q01-Q14 are recorded scope decisions, not extra tests or a third destination. Apply them to the corresponding F/E cases. + +A catalogue ID identifies a behaviour, not a mandated test method or count. Different semantic boundaries can require separate cases. Each case has isolated source and tests one behaviour. Combined inputs belong only where their interaction is the behaviour under test. There is no grouping or runtime-optimisation objective. + +Compilation success alone does not prove the result has the correct type or value. A round trip alone does not prove a conversion has the correct physical scale. Generated text checks do not replace compiler-semantic checks of binding, nullable lifting or cross-assembly identity. + +Full generated-source snapshots are not required. Verify the relevant declarations, expressions and binding. Formatting, generated container numbering and hint-file organisation are not public contracts. Diagnostic-only cases need no full source comparison; output behaviours still need their own relevant output assertions. + +Tests must not use production emitters, dimension readers or conversion calculators to compute their expected answers. Internal helpers may be exercised as the subject of a test, but cannot also supply its oracle. + +## Runtime contracts exposed through quantities + +These contracts support the generated APIs. Existing runtime coverage can satisfy them; they are not a request to duplicate a separate runtime suite. + +| ID | Behaviour and required cases | Production evidence | +| --- | --- | --- | +| R01 | A quantity stores a coherent SI magnitude. `Length.FromSiBaseUnit(2.5).AsSiBaseUnit()` is 2.5; default quantity values represent zero. Assigning through a same-dimension alias preserves the magnitude. Cover zero, negative and non-round finite values. | [runtime quantity][quantity]. | +| R02 | Same-dimension addition, subtraction and unary negation preserve the type and operate on SI magnitudes. Multiplication by a scalar in either order and division by a scalar preserve the dimension. Same-dimension division returns `double`. Aliases such as Energy/Torque participate as the same type. | [runtime operators][quantity-operators]. | +| R03 | Comparisons use SI magnitudes of the same dimension. `Abs`, `Min`, `Max` and `Clamp` return the appropriate same-dimension quantity. Clamp covers below, inside and above the inclusive bounds and throws `ArgumentException` for reversed bounds. Incompatible dimension arguments are rejected by the compiler; diagnostic wording belongs to D06-D08. | [runtime comparisons and helpers][quantity-helpers]. | + +## Quantity discovery and generated operations + +| ID | Behaviour and required cases | Production evidence | +| --- | --- | --- | +| G01 | Core consumers have all seven base aliases and the engineering aliases in the mapping below, without Metric or a preceding arithmetic expression. Canonical mechanical names and engineering synonyms for one dimension denote the same closed runtime type. For example, `LengthSquared`/Area and Energy/Torque are interchangeable; different dimensions are not. | [default discovery][defaults], [quantity planning][planning], [aliases][aliases]. | +| G02 | An unresolved canonical name in a type position requests that quantity. `LengthCurrent` in a parameter or return type and `SquareRootLength` in a declaration become usable aliases. Cover signatures, locals, generic arguments, arrays and nullable types. Reject noncanonical axis order, repeated axes and alternative spellings such as `CurrentLength`, `Length1` and `Root2Length`. | [name discovery][name-discovery], [canonical parser][name-parser]. | +| G03 | A recognised factory on an unresolved canonical name can request its type without a type declaration. `var x = LengthCurrent.FromSiBaseUnit(6)` and a valid `FromPrefixedUnits` call infer the proper quantity. An arbitrary unknown static member is not a factory request. | [discovery seeds][seeds]. | +| G04 | Bound user types, namespaces and aliases retain their meaning during name-based discovery. A user `LengthCurrent` or `using LengthCurrent = Example.Custom` is not replaced merely because its spelling is dimensional. Qualified user names are respected. Genuine arithmetic requests and collision diagnostics are a separate interaction; alias scope questions are Q01. | [name discovery][name-discovery], [alias reservations][reservations]. | +| G05 | Arithmetic chains discover the intermediates needed by later expressions. With current 3 A and resistance 4 SI, `i*i*r` binds through current-squared to Power and evaluates to 36. Cover parenthesised chains, repeated operations and mixed multiplication, division and powers. No particular discovery round count is required. | [discovery coordination][coordination], [operation discovery][bound-operations]. | +| G06 | Quantity types flow through ordinary C# binding. Cover explicit and inferred locals, compatible conditional/switch branches, fields/properties/helper returns and parameters, arrays/collections/spans/indexers, generic interface or constrained calls, out/ref results, patterns/deconstruction, awaited results and iterator/async-iterator elements. Use separate cases for distinct binding boundaries, including cross-file definitions. Incompatible branches remain errors; arbitrary reassignment-based type inference is not promised. | [documented discovery][readme-discovery], [bound operations][bound-operations], [discovery seeds][seeds]. | +| G07 | Referenced quantity values seed local aliases/conversions and further arithmetic. A producer returning a length-current quantity, directly or through a member/collection/containing object, can be consumed and multiplied by Time. Independent producers exchange the same runtime type. An unused quantity elsewhere in an assembly does not export all aliases. | [metadata discovery][metadata], [documented interoperability][readme-interoperability]. | +| G08 | Discovery recognises actual library symbols and all seven encoded exponents. Unrelated lookalike Quantity, Dimension, Power and number types do not acquire the library's operators or aliases. Unresolved/open dimensions are not guessed. Canonical negative and fractional exponents retain their exact dimension meaning. | [quantity reader][quantity-reader], [number reader][number-reader]. | +| G09 | Multiplication adds dimension exponents and multiplies SI magnitudes; division subtracts exponents and divides magnitudes. For length 6 and current 2, product is length-current 12 and ratio is length-per-current 3. Cover both written multiplication orders, reversed division, all axes and partial cancellation. Do not require unrequested reverse operators. | [arithmetic discovery][arithmetic-discovery], [arithmetic generation][arithmetic-emitter], [exact dimensions][dimensions]. | +| G10 | Complete dimensional cancellation returns `double`, including reciprocal multiplication and same-dimension division. A cancellation result remains usable as a scalar in subsequent arithmetic. There is no invented dimensionless quantity alias or duplicate generated same-dimension division operator. | [arithmetic generation][arithmetic-emitter], [runtime operators][quantity-operators]. | +| G11 | Scalar operations use normal C# numeric conversion rules. `2*l`, `l*2` and `l/2` preserve length; `1/Time.FromSiBaseUnit(0.02)` produces frequency 50. Cover standard implicit numeric conversions to double and nullable forms. Decimal is not silently accepted; a user conversion to double alone does not trigger generated scalar-inverse arithmetic. | [scalar recognition][arithmetic-discovery], [arithmetic generation][arithmetic-emitter]. | +| G12 | Nullable arithmetic lifts the dimensional operators. Non-null nullable length 2 and current 3 produce nullable length-current 6; null on either side produces null. Cover mixed nullable/nonnullable operands, nullable scalars, inverse division, cancellation to `double?` and chained lifted operations. | [nullable discovery][quantity-reader], [nullable contract][readme-nullable]. | +| G13 | Already bound user operations retain their selected implementation and result type. Existing multiply/divide operators and methods such as a consumer-defined `Squared()` must not be replaced by generated competitors. Their results can feed later quantity expressions when those results are genuine quantity types. | [arithmetic discovery][arithmetic-discovery], [power discovery][power-discovery], [helper discovery][helper-discovery]. | +| G14 | `Power.Of(quantity)` multiplies dimension exponents by an exact rational and computes the magnitude using double exponentiation. Square root of area 9 returns Length 3; power 2/3 of volume 8 returns Area approximately 4. Cover zero, one, negative, proper/improper rational exponents and quantities already containing rational/negative dimensions. Zeroth power returns `double` 1. | [power discovery][power-discovery], [power generation][power-emitter]. | +| G15 | Explicit exponent encodings and aliases to the actual Power type work. Terminal digits, hexadecimal composites, negatives and fractions specify powers; a type alias to `Power` supports `.Of`. Preserve the actual closed exponent receiver type when equivalent values have different valid encodings. Unrelated Power APIs or undecodable custom marker types do not get guessed overloads. | [power discovery][power-discovery], [number reader][number-reader], [number encoding][number-encoding]. | +| G16 | Valid unresolved English exponent requests generate global aliases to canonical encodings. Cover integers, negative integers, named fractions and numerator/denominator forms such as NumberHalf, NumberTwoOverThree and NumberTwentyOne. Equivalent rational spellings share the canonical encoded type. The alias is usable across files. A standalone unresolved number name or a lookalike Power call is not sufficient demand. | [English request discovery][english-discovery], [English parser][english-parser], [alias generation][english-emitter]. | +| G17 | Base/catalogue quantities have the ten zero-argument power helpers listed below, without earlier demand. Each has the appropriate result dimension and numerical meaning. Misspellings, extra arguments and unrelated receivers do not receive invented helper overloads. | [default powers][defaults], [helper discovery][helper-discovery], [helper generation][helper-emitter]. | +| G18 | Named power/root calls on discovered quantities request their own further results. A length-current product can be squared and rooted, including after member, helper or metadata flow. Nullable receivers use conditional access, such as `x?.Squared()`, with null propagation. Direct nullable calls without conditional access are not promised equivalents. | [bound operations][bound-operations], [helper discovery][helper-discovery], [helper generation][helper-emitter]. | +| G19 | Rational powers of negative magnitudes preserve real odd-root results. For -8, exponent 1/3 gives -2, 2/3 gives approximately 4 and -1/3 gives approximately -0.5. An even reduced denominator follows Math.Pow and gives NaN for a negative finite base. Cover the distinct numerator/denominator parity and negative-exponent rules, with representative positive-zero/nonfinite controls. Reduction and encoding belong in framework cases; exhaustive Math.Pow overflow/underflow/input-domain checks are not required. Dimension algebra remains exact even when magnitude evaluation is approximate. Signed-zero preservation is outside scope under Q07. | [power numerical rule][power-emitter]. | +| G20 | Repetition and synonymous requests do not create duplicate or ambiguous declarations. Repeated operations across files, equivalent English exponents, catalogue synonyms and default/discovered helper interactions retain one usable signature per operation. Verify signatures/binding and meaningful output uniqueness, not source ordering or private class names. | [quantity planning][planning], [default powers][defaults], [power generation][power-emitter]. | +| G21 | Unsupported or incomplete expressions do not acquire fabricated result types or crash generation. Incompatible addition/comparison, nonquantity operands, unresolved overloads and malformed requests remain compiler failures. Independent valid quantity expressions in the same input can still be generated. Ordinary incomplete editor source is relevant; arbitrary resource-exhaustion guarantees are not. | [arithmetic discovery][arithmetic-discovery], [bound operations][bound-operations], [quantity reader][quantity-reader]. | +| G22 | Generation preserves dimensional type safety. A length-current result cannot be assigned to Length, passed as Time or returned as Area. Cover explicit intermediate annotations, incompatible branches, overload arguments and collection element types. Same-dimension aliases remain interchangeable. | [encoded quantity types][quantity-format], [quantity aliases][quantity-emitter]. | + +### Quantity and power data + +The seven base aliases are Length, Mass, Time, Current, Temperature, AmountOfSubstance and LuminousIntensity. Their coherent SI bases are metre, kilogram, second, ampere, kelvin, mole and candela. Named mass helpers still use grams with the appropriate scale correction. + +In the engineering mapping, L is length, M mass, T time, I current and Theta temperature. Omitted axes have exponent zero. Each row also has the canonical mechanical alias dictated by the naming rules. + +| Engineering aliases sharing one runtime type | Dimension | +| --- | --- | +| Area | `L^2` | +| Volume | `L^3` | +| Speed | `L T^-1` | +| Acceleration | `L T^-2` | +| Frequency, AngularVelocity | `T^-1` | +| Force | `L M T^-2` | +| Density | `L^-3 M` | +| Pressure, Stress, YoungsModulus | `L^-1 M T^-2` | +| Energy, Torque | `L^2 M T^-2` | +| Power | `L^2 M T^-3` | +| SpecificPower, SpecificPowerLoss | `L^2 T^-3` | +| TemperatureCoefficient | `Theta^-1` | +| PowerDensity, VolumetricPowerLoss | `L^-1 M T^-3` | +| ElectricCharge | `T I` | +| Voltage | `L^2 M T^-3 I^-1` | +| Capacitance | `L^-2 M^-1 T^4 I^2` | +| Resistance | `L^2 M T^-3 I^-2` | +| Inductance | `L^2 M T^-2 I^-2` | +| MagneticFlux, FluxLinkage | `L^2 M T^-2 I^-1` | +| MagneticFluxDensity, MagneticPolarisation, RemanentFluxDensity | `M T^-2 I^-1` | +| MagneticFieldStrength, CoerciveFieldStrength | `L^-1 I` | +| CurrentDensity | `L^-2 I` | +| Permeability | `L M T^-2 I^-2` | +| Resistivity | `L^3 M T^-3 I^-2` | +| Conductivity | `L^-3 M^-1 T^3 I^2` | +| MagneticReluctivity | `L^-1 M^-1 T^2 I^2` | +| MagneticVectorPotential | `L M T^-2 I^-1` | + +The supported convenience powers are Squared=2, Cubed=3, Pow4=4, Pow5=5, Pow6=6, SquareRoot=1/2, CubeRoot=1/3, Root4=1/4, Root5=1/5 and Root6=1/6. These are case data for G17, not ten unrelated behaviour categories. + +Canonical generated names order the seven axes consistently, use numerator/Per/denominator or Inverse forms, and express reduced rational powers using the documented root/power spelling. Canonical number encodings use least-significant hexadecimal digits first, a single sign and reduced fractions. Equivalent dimension calculations must yield the same closed runtime type; mechanically equal values represented by noncanonical user-written types are Q02. + +## Diagnostics and alias fixes + +### Diagnostic data + +Default severity is the contract below. User configuration may override effective severity. DQ0001-DQ0005 come from analysers; DQ0006-DQ0008 come from generation. All use category `DimensionalQuantities` and are enabled by default. + +| ID | Default severity | Message contract | +| --- | --- | --- | +| DQ0001 | Error | `Cannot apply '{operation}' to {leftDimension} and {rightDimension}` | +| DQ0002 | Error | `Expected {expectedDimension}, but expression has {actualDimension}` | +| DQ0003 | Info | `Use the readable alias '{alias}' for this quantity`; carries `AliasName` for the fix. | +| DQ0004 | Warning | `This encoding is noncanonical; equivalent values have distinct type identity` | +| DQ0005 | Error | `This closed type-system encoding is invalid` | +| DQ0006 | Warning | `Generated alias '{alias}' conflicts with a name in this source` | +| DQ0007 | Error | `English exponent '{name}' cannot be resolved` | +| DQ0008 | Error | Concrete unit-declaration/conversion failure. Its exact prose is not a separate physical behaviour requirement. | + +Evidence: [mismatch descriptors][mismatch], [encoding descriptors][encoding], [generator descriptors][generator-diagnostics]. Compiler errors and DQ diagnostics are distinct observable results. Cases with deliberate C# errors must not suppress unexpected DQ diagnostics or accidentally claim successful compilation. + +| ID | Behaviour and required cases | Production evidence | +| --- | --- | --- | +| D01 | Each diagnostic has the correct identity, category, default severity and relevant message arguments. One complete expected set is checked for an ordinary triggering case, including absence of extra DQ diagnostics. Do not assume a universal diagnostic ordering. | descriptors above. | +| D02 | Unbound incompatible `+`, `-`, `<`, `>`, `<=`, `>=`, `==` and `!=` expressions produce DQ0001 over the whole expression, preserving operator spelling and operand order in the message. Matching dimensions and unrelated built-in operands do not. Multiplication/division combine dimensions instead of invoking this equality rule. | [binary analysis][binary-analysis]. | +| D03 | Unbound incompatible `+=` and `-=` produce DQ0001 over the assignment with the compound operator spelling. Matching dimensions are clear. Multiplicative assignments are not reinterpreted as requiring equal dimensions. | [binary analysis][binary-analysis]. | +| D04 | A successfully bound user operator suppresses a dimensional-mismatch claim, including an explicitly supported cross-dimension operator. Merely having unresolved/ambiguous candidates does not prove successful binding. Pair with G13 where generation could introduce a competitor. Valid native binding/conversion controls must remain accepted. | [binary analysis][binary-analysis]. | +| D05 | Mismatch diagnostics use genuine library quantity identity, including nullable quantities, aliases and metadata-origin values. Lookalike types, wrappers, collections, Delta wrappers, unreadable dimensions and error types are not guessed as direct quantities. Mathematically equal readable dimensions do not receive a false mismatch solely because their generic encoding differs; DQ0004 addresses noncanonical identity. | [quantity reader][quantity-reader], [destination analysis][destination-analysis]. | +| D06 | Incompatible assignment or initialisation produces DQ0002 at the source expression. Cover locals, fields, properties, ordinary assignments and independent initialisers in a multi-variable declaration. Inferred var, matching dimensions, nonquantity destinations and missing types do not produce a guessed mismatch. Valid same-dimension nullable/implicit assignments remain accepted; tests need not fabricate a cross-dimension conversion to cover a private guard. | [destination analysis][destination-analysis]. | +| D07 | Incompatible declared return destinations produce DQ0002 at the returned expression. Cover method/local-function/getter blocks and expression-bodied methods/properties/indexers. Matching returns and `return;` are clear. Additional destination contexts remain outside the required scope under Q05. | [destination analysis][destination-analysis]. | +| D08 | Incompatible method, delegate or constructor arguments produce DQ0002 at the offending expression. Cover positional and reordered named arguments, explicit and target-typed construction, and a single recoverable candidate method. Multiple ambiguous candidates or an unknown named argument must not yield guessed expected dimensions. Preserve the current argument-mapping coverage under Q05; no expanded-params support is required. | [argument analysis][destination-analysis]. | +| D09 | Dimension display names are stable and readable: preferred engineering alias when defined, canonical mechanical name otherwise, and Dimensionless for zero dimensions. Messages and `AliasName` use the same preferred name. | [display names][display-names], [engineering mapping][aliases]. | +| D10 | Ordinary incomplete editor code and open/unresolved generic arguments do not crash analysers or produce a false invalid-closed-encoding error. With the library absent, an unrelated compilation remains unaffected. Do not add counterfeit partial-library or resource-exhaustion obligations without a separate requirement. | [analyser setup and encoding guards][encoding], [mismatch setup][mismatch]. | +| D11 | DQ0001-DQ0005 are not reported on source Roslyn recognises as generated; equivalent ordinary user source is analysed. Verify actual generated-code classification rather than inventing a filename-only rule. Current generator diagnostic scope is retained under Q13. | [analyser registration][mismatch], [encoding registration][encoding]. | +| D12 | A canonical non-dimensionless raw library `Quantity>` produces DQ0003 at the Quantity generic itself, including qualified names and occurrences inside containers. The message and `AliasName` identify the readable alias. A suggestion can exist even when the fix is unsafe or unavailable. | [encoding analysis][encoding]. | +| D13 | An intentional using-alias declaration and a canonical dimensionless raw quantity do not receive DQ0003. Validation still reports invalid or noncanonical encodings inside alias declarations. Power types are not quantity-alias suggestions. | [encoding analysis][encoding]. | +| D14 | Valid noncanonical encodings produce DQ0004 at their enclosing Quantity or Power generic. Cover unreduced fractions, denominator-one fractions and zero fractions with valid generic constraints. Canonical equivalents do not warn. A noncanonical quantity gets no DQ0003 for that generic. | [canonicality inspection][canonicality], [encoding analysis][encoding], [number contract][number-encoding]. | +| D15 | Closed invalid quantity/power encodings produce DQ0005, not a readable-alias suggestion. Cover a non-dimension type, unsupported closed number-marker type, and malformed built-in encodings where Roslyn retains the bound generic. Invalid exponents take precedence over noncanonical exponents within one quantity. Do not demand separate analyser diagnostics for standalone Hex/Fraction/Dimension types. | [encoding analysis][encoding], [number reader][number-reader]. | +| D16 | Canonical Power types are accepted without an Of invocation; noncanonical/invalid bound Power types diagnose even in declarations. An unrelated consumer Power type is outside these rules. | [encoding analysis][encoding]. | +| D17 | A generated-name conflict with an explicit alias or nongeneric global type/delegate produces DQ0006 at the declared identifier. The warning does not suppress or rename a genuinely required generated alias. Generic and namespace-contained names are not automatically global declaration collisions. The accepted scope policy is Q01. | [collision diagnostics][collisions]. | +| D18 | A generated alias displacing an imported type produces DQ0006 at the affected unqualified use, including static member access where the receiver was a type. Qualified names, value identifiers, already-unresolved names and genuinely unchanged bindings do not warn. Establish the semantic before/after meaning, not just a matching spelling. | [displaced-use analysis][collisions]. | +| D19 | An invalid unresolved English exponent in a recognised real Power.Of request produces DQ0007 at that exponent identifier. Valid requests proceed without DQ0007. Cover malformed words and a zero denominator; message includes the requested spelling. | [English diagnostics][generator-diagnostics], [request recognition][english-discovery]. | +| D20 | Bound exponent names and actual aliases are not invalid unresolved requests. A lookalike Power API, wrong method/arity, non-Number prefix, qualified/generic exponent spelling or standalone unresolved Power type does not gain a DQ0007 diagnosis merely by resemblance. Closed bound invalid encodings remain DQ0005's domain. | [English request recognition][english-discovery]. | +| D21 | The alias fix applies to DQ0003 and uses its proposed alias. A genuine safe Length replacement offers `Use Length` with equivalence key `UseAlias:Length`. Other diagnostic families have no fix from this provider. | [fix provider][fix]. | +| D22 | A fix is offered only when the proposed alias resolves at the use site to the same quantity type. Missing, inaccessible, ambiguous or differently shadowed aliases withhold it. A visible same-type alias can be valid. The best-effort expression-context boundary is resolved in Q04; interior-comment handling is resolved in Q03. | [speculative binding][fix]. | +| D23 | In ordinary type-use contexts, the fix replaces the complete qualified quantity name while preserving nullable/array wrappers, containing generic types, declarations and surrounding syntax. Leading/trailing trivia survives. Check representative declarations and intentional text preservation. Expression-context replacements remain best-effort under Q04; there is no general post-fix binding/compilation guarantee. | [replacement bounds and edit][fix]. | +| D24 | The fix is withheld inside a real C# nameof operation, including nested occurrences, because the returned string could change. A user invocation merely spelled nameof is distinguished by actual operation binding. DQ0003 itself can remain present. | [nameof guard][fix]. | +| D25 | Fix All uses the selected alias-specific action consistently across multiple eligible occurrences/documents, preserving ineligible and nameof sites. A Length action does not silently select unrelated Time actions. Use the provider's actual BatchFixer; do not invent custom aggregation or scope guarantees beyond it. | [provider and equivalence key][fix]. | + +## Unit providers and conversions + +| ID | Behaviour and required cases | Production evidence | +| --- | --- | --- | +| U01 | A real UnitProvider publishes public factory/accessor extensions in its namespace, even when its ordinary provider and symbol declarations are internal/private. A separate consumer imports the namespace and calls the methods without accessing declaration types. Unmarked declarations do not publish conversions. Global namespace and ordinary nongeneric nesting are relevant boundaries. | [provider discovery/generation][providers], [conversion surface][conversion-emitter], [extension contract][readme-extension]. | +| U02 | Only valid associated quantity declarations create receiver conversion sets. Multiple associations can target distinct valid closed quantities. Unassociated factor/symbol declarations supply data rather than independent methods. Invalid or unrelated quantity targets produce DQ0008. No expansion to deeper/generic declaration shapes is required under Q08. | [association reading][provider-reader], [quantity identity][quantity-reader]. | +| U03 | Associations that name the same runtime quantity type consolidate into one callable surface. Pressure/Stress/YoungsModulus share Pascal methods; Energy/Torque share their declared alternatives. Repeated identical associations do not create ambiguous duplicates. Distinct noncanonical runtime types are not merged merely by numeric dimension. | [association consolidation][provider-reader], [conversion collection][conversion-emitter]. | +| U04 | AdditionalUnit contributes a valid alternative expression to the owning receiver; it need not have its own association. A Feet receiver with an Inch alternative provides both methods, with 12 inches equal to one foot. An alternative outside the provider or with invalid factors diagnoses. Recursive alternatives are not a new requirement under Q08. | [alternative reading][provider-reader], [alternative generation][conversion-emitter]. | +| U05 | Public conversion names express ordered factors and powers rather than declaration-class spelling. Cover irregular Feet, square/cubic and rational powers, mixed numerator/Per/denominator and inverse-only forms. Amp times metre^-2 yields AmpsPerSquareMetre. Invalid generated identifiers produce DQ0008. | [unit naming][unit-expression], [method construction][conversion-emitter]. | +| U06 | GenerateSiPrefixes and GeneratePrefixConversions default off and are independently selectable. Their four combinations expose the appropriate named and parameterised APIs. Affine expressions do not get automatic prefix families; explicitly declared fixed prefixes remain meaningful when automatic generation is off. | [provider options][provider-options], [conversion selection][conversion-emitter]. | +| U07 | Named prefixes cover the supported finite SI set, plus the unprefixed form. Automatic compound prefix variation applies to the first positive factor; other factors retain their declared prefixes. A reciprocal-only expression does not gain invented numerator-prefix variants. Explicit alternative units can supply separately prefixed denominator spellings. | [prefix data][prefixes], [prefix expansion][conversion-emitter], [factor naming][unit-expression]. | +| U08 | Parameterised prefixes accept decimal exponents for each declared unit factor, weighted by that factor's power and SI base-prefix adjustment. Voltage at -3 means millivolts; metre at -3 in a denominator squared means a factor of 10^6. Runtime prefix arguments need not belong to the finite named-prefix set. Declared defaults, reverse conversion and delta accessors agree. Retain first-expression selection under Q10. | [generic method construction][conversion-emitter], [unit scaling][unit-expression]. | +| U09 | Identical named conversions for one receiver coalesce; the same generated name with different scale, decimal exponent or affine offset reports DQ0008 instead of choosing a definition silently. No additional cross-provider coordination is required under Q09. | [conflict detection][conversion-emitter]. | +| U10 | Partial providers are not emitted repeatedly. Providers with the same short name in ordinary different namespaces/containing types can coexist when their public method signatures do not conflict. A provider with no valid associated declarations publishes no callable conversion surface. Private generated class-name mangling is not a contract. | [provider identity][providers]. | +| U11 | Linear conversion applies the product of atomic scales and decimal-prefix factors, each raised to its signed rational power. Accessors apply the inverse. Cover 6 ft=1.8288 m, square-foot scale 0.3048^2, mile/hour scale 1609.344/3600, rational and reciprocal factors, and zero/negative readings. Assert both directions against independent numerical expectations. | [unit scaling][unit-expression], [conversion formulas][conversion-emitter]. | +| U12 | Mass prefixes account for kilogram as coherent SI mass. 1000 grams and one kilogram both store 1 SI; powers and denominator occurrences apply the same correction. Cover automatic KiloGrams versus explicitly declared Kilograms spellings and compound density or specific-power defaults. | [base prefix exponents][base-prefixes], [runtime prefix formula][quantity-prefixes]. | +| U13 | Absolute affine conversion applies `(reading + offsetBeforeScale) * scale` and reverses as `SI/scale - offset`. Celsius 20 and Fahrenheit 68 store 293.15 K. Celsius -273.15 and Fahrenheit -459.67 store zero. Rankine is linear. Cover non-unit scale, zero offset, negative readings and cross-package accessors. No absolute-zero input rejection is promised. | [affine formulas][conversion-emitter], [temperature contract][readme-temperature]. | +| U14 | AsDelta preserves the stored SI magnitude and changes its interpretation, without tracking subtraction provenance. Delta accessors omit affine offsets. A 10 K difference is 10 Celsius and 18 Fahrenheit/Rankine; an absolute Celsius-20 reading reinterpreted as a delta is 293.15 Celsius. Cover negative/zero/default deltas, prefixes and wrong-dimension accessors. There is no implied delta factory. | [delta runtime][delta], [delta accessors][conversion-emitter], [documented provenance][readme-temperature]. | +| U15 | Runtime SI and arbitrary-component factories/accessors are available without optional conversions or generated aliases. Each chosen base-component prefix is weighted by its dimension exponent; irrelevant components have zero effect; overallScaleExponent is additive. For current density, a -3 length prefix gives 10^6 SI. Defaults are coherent SI, including kilogram. | [runtime prefix API/formula][quantity-prefixes]. | +| U16 | Generated numerical literals are culture independent and preserve the supplied finite double constants. A comma-decimal generator culture must still produce valid C# with the correct scale/offset. Cover small/large finite constants and rational exponent expressions. No aggregate-overflow guarantee is added under Q11. | [literal formatting][conversion-emitter]. | +| U17 | Invalid factors report DQ0008 at useful source locations, without fabricated conversion semantics. Cover missing real UnitSymbol, empty symbol spellings, nonpositive/nonfinite scale, zero power, nonpositive denominator, and unsupported declared named prefixes/base prefixes. A positive finite scale, negative numerator power and positive denominator remain valid. Ordinary compiler attribute errors are separate. | [factor validation][provider-reader], [symbol attributes][symbol-attribute], [factor attributes][factor-attribute]. | +| U18 | Affine declarations require a finite offset and one unprefixed factor of power one. Affine powers, inverses, prefixed factors, multiple factors and nonfinite offsets diagnose with DQ0008. A valid independent declaration remains useful. Additional affine encoding forms are not required under Q08. | [affine validation][provider-reader]. | +| U19 | Missing factor expressions, unusable public method names and conflicting conversions fail through DQ0008 rather than a generator exception or invented defaults. An independent valid provider can still generate. Reader-level and emission-level errors need useful locations; arbitrary diagnostic ordering or every incidental partial-output choice is not a requirement. No special declaration-label handling is added under Q08. | [declaration validation][provider-reader], [emission diagnostics][providers]. | +| U20 | Core provides the seven base quantities' named SI helpers, all generic runtime SI APIs, aliases and arithmetic. Optional named catalogue methods require their package and namespace. Core alone must not supply FromVolts, FromCelsius, FromFeet, FromKnots or FromGauss. Existing engineering aliases do not thereby acquire every optional generic named-factor conversion. | [core planning][planning], [quantity emission][quantity-emitter], [package contract][readme-core]. | +| U21 | Metric supplies its documented mechanical, electrical and magnetic named conversions, prefixes and explicit compound alternatives on shared types. Cover volts*amps=watts, Pascal/Joule synonyms, 1 g/cm^3=1000 SI, 1 A/mm^2=10^6 SI and reciprocal-only units. Celsius is a separate affine family, without automatic prefixes. | [Metric declarations][metric], [Metric temperature][metric-temperature]. | +| U22 | Metric's handwritten angular helper uses its actual FromRpm/ToRpm API. 60 rpm stores 2*pi rad/s; pi rad/s converts to 30 rpm; zero and negative speeds preserve sign. Do not invent AsRpm, delta-RPM or prefixed-RPM APIs. | [RPM helper][rpm]. | +| U23 | Imperial uses distinct customary definitions on shared SI types, with no automatic SI-prefix family. Cover length/area/volume powers, speed/force/pressure, short versus long tons, US versus Imperial liquid volume, mechanical horsepower and IT BTU definitions. Fahrenheit/Rankine follow U13-U14. Representative numerical data is below. | [Imperial declarations][imperial], [Imperial symbols][imperial-symbols]. | +| U24 | Nautical converts nautical miles, fathoms, square nautical miles and knots into the same Length/Area/Speed types. One nautical mile is 1852 m and one knot is 1852/3600 m/s. Helpers require the namespace; automatic prefixed nautical methods are absent. | [Nautical declarations][nautical], [Nautical symbols][nautical-symbols]. | +| U25 | CgsEmag converts its named mechanical, ab-electrical and magnetic units into coherent SI types; it does not introduce a separate electromagnetic dimension system. Cover magnetic and electrical scales, synonyms such as Biot/Abampere, extreme scales and the absence of automatic prefixes. | [CGS declarations][cgs], [CGS symbols][cgs-symbols]. | +| U26 | Provider libraries publish compiled public conversion methods targeting shared runtime types. Consumers need the assembly/package and namespace, not private declaration sources or producer-local aliases. Metadata references do not regenerate the provider's declarations locally. Fresh consumer tooling can still generate its own aliases and further arithmetic. | [provider generation][providers], [documented extension consumption][readme-extension], G07. | + +### Conversion data boundaries + +Named SI prefixes span exponents -30 through 30 at the supported SI positions: +/-1, +/-2, +/-3, then multiples of three through +/-30. Zero is unprefixed. Case data includes the extreme Quetta/Ronna and Ronto/Quecto names, not arbitrary prefix-name invention. Parameterised runtime exponents follow U08 instead. + +These independent numerical examples anchor the conversion families; round trips are additional evidence, not substitutes for these scale checks. + +| Family | Representative expected values | +| --- | --- | +| Linear custom or customary | 6 feet = 1.8288 m; one square foot = 0.3048^2 m^2; one mile/hour = 1609.344/3600 m/s. | +| Custom rational factor | A symbol scale of 4 at power 1/2 gives factor 2; at power -1/2 gives factor 0.5. | +| Prefixes and mass | 1 gram = 0.001 kg; 1 gram/cm^3 = 1000 kg/m^3; 1 A/mm^2 = 1,000,000 A/m^2. | +| Absolute temperature | 20 Celsius = 68 Fahrenheit = 293.15 K; 491.67 Rankine = 273.15 K. | +| Temperature difference | 10 K = 10 Celsius difference = 18 Fahrenheit difference = 18 Rankine difference. | +| Customary liquid volumes | US gallon = 0.003785411784 m^3; Imperial gallon = 0.00454609 m^3. | +| Customary mass and pressure | Short ton = 907.18474 kg; long ton = 1016.0469088 kg; psi = 4.4482216152605 / 0.0254^2 Pa. | +| Energy | IT BTU = 1055.05585262 J; 10^7 ergs = 1 J. | +| Nautical | Nautical mile = 1852 m; fathom = 1.8288 m; knot = 1852/3600 m/s. | +| Magnetic/electrical CGS | 10,000 gauss = 1 T; oersted = 79.57747154594767 A/m; abampere or biot = 10 A; abvolt = 10^-8 V; abfarad = 10^9 F; maxwell = 10^-8 Wb. | + +Catalogue membership and alias mappings are parameter data. Test each distinct conversion mechanism and preserve the independently specified definitions of shipped units. Do not make one giant consumer that happens to make every conversion compile, or derive all expected values by asking the production catalogue to calculate them. + +## Package and assembly delivery + +| ID | Behaviour and required cases | Production evidence | +| --- | --- | --- | +| P01 | A clean PackageReference to core delivers the runtime and activates quantity generation and analysers under a compatible compiler. A valid calculation compiles and runs; an invalid dimensional expression receives its DQ diagnostic. No repository ProjectReference, manual analyser wiring, inherited repository props or stale generated files are allowed to supply the result. | [core package layout][core-project], [consumer requirement][readme-core]. | +| P02 | Metric, Imperial, Nautical and CgsEmag each supply the exact matching core version transitively. Each can be the consumer's sole direct package reference; several compatible extensions still share one runtime type identity. Verify the exact dependency range and namespace absent/present separately from package absent/present. | [Metric package dependency][metric-project] and corresponding production extension projects. | +| P03 | Advertised package assets and symbols correspond to the shipped binaries: netstandard2.0 runtime/extension assets, compiler DLL dependencies and DLL/PDB pairs, portable symbol packages and available source provenance. Consumer applications do not gain Roslyn/Workspaces/annotation build tooling as application runtime requirements just to use quantities. Archive success does not substitute for execution. Source Link completeness is not assumed from a repository URL property. | [core assets][core-project], [tooling assets][tooling-project], [code-fix assets][codefix-project]. | +| P04 | The bundled alias-fix provider is loadable by a compatible workspace host and offers its documented safe fix. A CLI generator smoke build alone cannot prove that the IDE/code-fix assembly and exports load. No expanded host matrix is requested under Q14. | [code-fix export][fix], [bundled assets][core-project]. | + +## Review decisions and implementation boundaries + +Q01-Q07 record the agreed behaviour. Q08-Q14 originally mixed hypothetical limitations with possible product extensions; those extensions are excluded from this rewrite. They are not a backlog or further decisions for the user. Tests should cover the existing supported contracts without turning every private guard or unsupported spelling into a requirement. + +| ID | Recorded contract or scope boundary | Production evidence | +| --- | --- | --- | +| Q01 | Resolved: retain the current conservative alias policy. Top-level explicit aliases reserve their spelling compilation-wide for unresolved-name/factory/English-exponent discovery; predefined and arithmetic-required aliases remain generated. Namespace aliases are protected by normal binding rather than global reservation. Any explicit alias matching a generated name receives DQ0006, even with the same target or namespace-local scope, and suppresses displaced-use checks for that spelling throughout its file. These rules are accepted behaviour, not a requested scope correction. | [reservations][reservations], [name discovery][name-discovery], [English discovery][english-discovery], [collisions][collisions]. | +| Q02 | Resolved: retain the current behaviour. Generated values and type encodings are normalised to canonical forms. Manually written noncanonical encodings receive DQ0004; their mathematical equality does not make them the same C# type. No automatic conversion or arithmetic-interoperability guarantee is required for such manually constructed quantity types. | [quantity reader][quantity-reader], [canonicality][canonicality], [quantity formatting][quantity-format]. | +| Q03 | Resolved: retain the current replacement behaviour. Comments inside the generic/qualified type being replaced may be discarded. Do not withhold the fix or add relocation/preservation logic solely for interior comments. Leading/trailing trivia remains preserved under D23. | [replacement edit][fix]. | +| Q04 | Resolved: the alias quick fix is best-effort, not guaranteed to preserve every expression binding or compilation result. Retain the existing speculative type-identity and nameof checks; do not add general rewritten-document semantic/compilation validation. Rare cases such as a value named Length shadowing the replacement in a static factory expression may need manual cleanup. Acceptance of this limitation is not a requirement to reproduce the failure in tests. | [speculative type check and outer-name selection][fix]. | +| Q05 | Resolved: retain the current DQ0002 scope: assignments/initialisers, supported return destinations, and method/constructor arguments. No expansion is required for params elements, constructor initialisers, indexer/attribute arguments, collection/deconstruction elements or additional lambda/async/yield destinations. Ordinary C# errors remain sufficient where DQ0002 is not supplied. | [registered destination syntax and mapping][destination-analysis]. | +| Q06 | Resolved: retain the documented invocation-based discovery forms: ordinary quantity helper calls, Power.Of(quantity), and conditional access for nullable helper receivers. No new discovery support is required for method-group-only requests, qualified unresolved factory spellings or direct nullable Power/helper alternatives. Already-generated methods remain usable through normal C# binding. Do not add machinery or tests promising these additional forms. | [power discovery][power-discovery], [helper discovery][helper-discovery], [discovery seeds][seeds]. | +| Q07 | Resolved: signed-zero preservation is outside the required mathematical contract. Retain the current power implementation; do not add special handling or assertions distinguishing positive/negative zero or resulting infinity signs solely for this case. Ordinary finite negative-base rational-power behaviour remains G19. | [power numerical rule][power-emitter]. | +| Q08 | Outside rewrite scope: no expansion of provider declaration shapes is requested. Cover the documented ordinary providers and existing supported forms. Do not add requirements for generic containers, deeper/recursive declaration discovery, special handling of unusual internal labels or additional affine encodings merely because the implementation has limits. | [provider shape handling][providers], [declaration/factor validation][provider-reader]. | +| Q09 | Retain existing conversion-conflict handling within a receiver conversion set. Do not add cross-provider coordination, automatic disambiguation or parameter-name repair. Only a reproduced failure of documented valid provider composition should be raised as a defect; hypothetical collisions are not new acceptance requirements. | [conversion collection and parameters][conversion-emitter]. | +| Q10 | Retain the existing first-expression selection for parameterised prefix conversions. Cover the callable API produced by supported declarations. No new canonical-selection scheme or declaration-reordering invariance is requested without a demonstrated contradiction of an existing contract. | [association grouping][provider-reader], [first expression selection][conversion-emitter]. | +| Q11 | No new aggregate-overflow validation or universal finite-result guarantee is requested. Cover ordinary supported conversion scales and existing invalid-factor diagnostics. Hypothetical extreme combined constants do not authorise new diagnostics or resilience machinery. | [unit scale product][unit-expression], [literal formatting][conversion-emitter], [factor checks][provider-reader]. | +| Q12 | Retain the current provider-author responsibility for matching unit factors to quantity dimensions; no dimensional metadata schema or new physical-consistency validation is requested. QuantityUnit associations must resolve under the current provider-generation contract. Do not require additional support for associations depending on later unresolved-alias discovery. | [symbol schema][symbol-attribute], [quantity association reading][provider-reader], [generation sequence][generator]. | +| Q13 | Retain current generator input selection and diagnostic scope. The explicit analyser generated-code exclusion remains D11. Do not add a blanket generator exclusion or broader cross-generator visibility contract. Raise only a reproduced violation of an existing supported input/diagnostic behaviour. | [generator input selection][generator], [collision traversal][collisions], [English diagnostics][generator-diagnostics]. | +| Q14 | Verify existing advertised package delivery and compatibility, not an expanded host matrix or new debugging features. No new compiler/IDE support or Source Link guarantee is requested. If a clean consumer under an explicitly documented supported compiler cannot load the shipped tooling, report that concrete compatibility defect separately. | [runtime package][core-project], [Roslyn dependency][tooling-project], [Workspaces dependency][codefix-project], [README requirement][readme-core]. | + +D18 covers warnings for actual changed bindings. The comparer used by [collision analysis][collisions] does not create an additional acceptance requirement or a separate product-design question. + +## Exclusions from the proposed rewrite + +- Same-driver edit history, incremental cache reuse and stale-output lifecycle guarantees remain outside scope, as previously agreed. Fresh input states still have to satisfy the contracts above. +- Discovery iteration budgets, mutable collection choices, helper call order, generated private class names, hint-file layout and incidental diagnostic ordering are not acceptance requirements. +- This catalogue does not add performance targets, test grouping, broad counterfeit-runtime resilience or speculative resource-exhaustion requirements. +- Existing tests and history are not implementation instructions for the fresh test author. A later coverage review can consult the old suite to find omissions, but should not silently promote its assumptions into requirements. + +## Production evidence + +[quantity]: ../src/DimensionalQuantities/TypeSystem/Quantity.cs#L8 +[quantity-operators]: ../src/DimensionalQuantities/TypeSystem/Quantity.cs#L65 +[quantity-helpers]: ../src/DimensionalQuantities/TypeSystem/Quantity.cs#L73 +[quantity-prefixes]: ../src/DimensionalQuantities/TypeSystem/Quantity.cs#L26 +[delta]: ../src/DimensionalQuantities/TypeSystem/Delta.cs#L3 +[dimensions]: ../src/DimensionalQuantities/Dimensions/Dimension.cs#L66 +[aliases]: ../src/DimensionalQuantities/Units/EngineeringQuantityAliases.cs#L7 +[defaults]: ../src/DimensionalQuantities.Roslyn/Generators/DefaultQuantityDiscovery.cs#L8 +[planning]: ../src/DimensionalQuantities.Roslyn/Generators/QuantityDiscovery.cs#L38 +[generator]: ../src/DimensionalQuantities.Roslyn/Generators/QuantityGenerator.cs#L12 +[quantity-emitter]: ../src/DimensionalQuantities.Roslyn/Generators/QuantitySourceEmitter.cs#L7 +[quantity-format]: ../src/DimensionalQuantities.Roslyn/Generators/QuantityTypeNameFormatter.cs#L9 +[name-discovery]: ../src/DimensionalQuantities.Roslyn/Discovery/QuantityNameDiscovery.cs#L11 +[name-parser]: ../src/DimensionalQuantities/Naming/DimensionNameParser.cs#L10 +[seeds]: ../src/DimensionalQuantities.Roslyn/Discovery/DiscoverySeedCollector.cs#L12 +[reservations]: ../src/DimensionalQuantities.Roslyn/Discovery/ExplicitAliasReservation.cs#L8 +[coordination]: ../src/DimensionalQuantities.Roslyn/Discovery/QuantityDiscoveryCoordinator.cs#L12 +[bound-operations]: ../src/DimensionalQuantities.Roslyn/Discovery/BoundOperationDiscovery.cs#L18 +[metadata]: ../src/DimensionalQuantities.Roslyn/Discovery/MetadataQuantityDiscovery.cs#L19 +[quantity-reader]: ../src/DimensionalQuantities.Roslyn/Discovery/QuantityTypeReader.cs#L14 +[number-reader]: ../src/DimensionalQuantities.Roslyn/Discovery/TypeSystemNumberReader.cs#L14 +[number-encoding]: ../src/DimensionalQuantities/TypeSystem/TypeSystemNumbers.cs#L5 +[arithmetic-discovery]: ../src/DimensionalQuantities.Roslyn/Discovery/ArithmeticDiscovery.cs#L13 +[arithmetic-emitter]: ../src/DimensionalQuantities.Roslyn/Generators/ArithmeticSourceEmitter.cs#L21 +[power-discovery]: ../src/DimensionalQuantities.Roslyn/Discovery/PowerDiscovery.cs#L23 +[power-emitter]: ../src/DimensionalQuantities.Roslyn/Generators/PowerSourceEmitter.cs#L37 +[helper-discovery]: ../src/DimensionalQuantities.Roslyn/Discovery/PowerMethodDiscovery.cs#L9 +[helper-emitter]: ../src/DimensionalQuantities.Roslyn/Generators/PowerMethodSourceEmitter.cs#L24 +[english-discovery]: ../src/DimensionalQuantities.Roslyn/Discovery/EnglishExponentDiscovery.cs#L20 +[english-parser]: ../src/DimensionalQuantities/Numerics/EnglishRationalParser.cs#L7 +[english-emitter]: ../src/DimensionalQuantities.Roslyn/Generators/EnglishExponentAliasEmitter.cs#L7 +[mismatch]: ../src/DimensionalQuantities.Roslyn/Analyzers/DimensionMismatchAnalyzer.cs#L13 +[binary-analysis]: ../src/DimensionalQuantities.Roslyn/Analyzers/BinaryDimensionAnalysis.cs#L11 +[destination-analysis]: ../src/DimensionalQuantities.Roslyn/Analyzers/DestinationDimensionAnalysis.cs#L12 +[encoding]: ../src/DimensionalQuantities.Roslyn/Analyzers/QuantityEncodingAnalyzer.cs#L17 +[canonicality]: ../src/DimensionalQuantities.Roslyn/Analyzers/CanonicalTypeEncoding.cs#L10 +[display-names]: ../src/DimensionalQuantities.Roslyn/Analyzers/DimensionNames.cs#L9 +[generator-diagnostics]: ../src/DimensionalQuantities.Roslyn/Generators/GenerationDiagnostics.cs#L11 +[collisions]: ../src/DimensionalQuantities.Roslyn/Generators/AliasCollisionDiagnostics.cs#L12 +[fix]: ../src/DimensionalQuantities.Roslyn.CodeFixes/QuantityAliasCodeFixProvider.cs#L12 +[providers]: ../src/DimensionalQuantities.Roslyn/Generators/UnitProviderGenerationCoordinator.cs#L10 +[provider-reader]: ../src/DimensionalQuantities.Roslyn/Generators/UnitProviderReader.cs#L30 +[conversion-emitter]: ../src/DimensionalQuantities.Roslyn/Generators/UnitConversionSourceEmitter.cs#L27 +[provider-options]: ../src/DimensionalQuantities/Units/Declarations/UnitProviderAttribute.cs#L3 +[symbol-attribute]: ../src/DimensionalQuantities/Units/Declarations/UnitSymbolAttribute.cs#L3 +[factor-attribute]: ../src/DimensionalQuantities/Units/Declarations/UnitFactorAttribute.cs#L3 +[unit-expression]: ../src/DimensionalQuantities/Units/UnitExpression.cs#L24 +[prefixes]: ../src/DimensionalQuantities/Units/SiPrefixes.cs#L5 +[base-prefixes]: ../src/DimensionalQuantities/Units/SiBasePrefixExponents.cs#L5 +[metric]: ../src/DimensionalQuantities.Extensions.Metric/MetricUnits.cs#L6 +[metric-temperature]: ../src/DimensionalQuantities.Extensions.Metric/MetricTemperatureUnits.cs#L6 +[rpm]: ../src/DimensionalQuantities.Extensions.Metric/AngularVelocityRpmExtensions.cs#L3 +[imperial]: ../src/DimensionalQuantities.Extensions.Imperial/ImperialUnits.cs#L6 +[imperial-symbols]: ../src/DimensionalQuantities.Extensions.Imperial/ImperialSymbols.cs#L7 +[nautical]: ../src/DimensionalQuantities.Extensions.Nautical/NauticalUnits.cs#L5 +[nautical-symbols]: ../src/DimensionalQuantities.Extensions.Nautical/NauticalSymbols.cs#L7 +[cgs]: ../src/DimensionalQuantities.Extensions.CgsEmag/CgsEmagUnits.cs#L5 +[cgs-symbols]: ../src/DimensionalQuantities.Extensions.CgsEmag/CgsEmagSymbols.cs#L7 +[core-project]: ../src/DimensionalQuantities/DimensionalQuantities.csproj#L3 +[tooling-project]: ../src/DimensionalQuantities.Roslyn/DimensionalQuantities.Roslyn.csproj#L3 +[codefix-project]: ../src/DimensionalQuantities.Roslyn.CodeFixes/DimensionalQuantities.Roslyn.CodeFixes.csproj#L3 +[metric-project]: ../src/DimensionalQuantities.Extensions.Metric/DimensionalQuantities.Extensions.Metric.csproj#L20 +[readme-core]: ../README.md#getting-started +[readme-nullable]: ../README.md#nullable-quantities +[readme-discovery]: ../README.md#discovery-through-your-code +[readme-interoperability]: ../README.md#sharing-quantities-between-packages +[readme-temperature]: ../README.md#affine-temperature-units-and-deltas +[readme-extension]: ../README.md#defining-an-extension diff --git a/src/DimensionalQuantities.IntegrationTests/DimensionalQuantities.IntegrationTests.csproj b/src/DimensionalQuantities.IntegrationTests/DimensionalQuantities.IntegrationTests.csproj deleted file mode 100644 index c73a812..0000000 --- a/src/DimensionalQuantities.IntegrationTests/DimensionalQuantities.IntegrationTests.csproj +++ /dev/null @@ -1,23 +0,0 @@ - - - net11.0 - false - true - Exe - true - - - - - - - - - - - - - - - - diff --git a/src/DimensionalQuantities.IntegrationTests/Packaging/MsbuildCollection.cs b/src/DimensionalQuantities.IntegrationTests/Packaging/MsbuildCollection.cs deleted file mode 100644 index 28343f7..0000000 --- a/src/DimensionalQuantities.IntegrationTests/Packaging/MsbuildCollection.cs +++ /dev/null @@ -1,6 +0,0 @@ -using Xunit; - -namespace DimensionalQuantities.IntegrationTests.Packaging; - -[CollectionDefinition("MSBuild", DisableParallelization = true)] -public sealed class MsbuildCollection; diff --git a/src/DimensionalQuantities.IntegrationTests/Packaging/PackageTestSupport.cs b/src/DimensionalQuantities.IntegrationTests/Packaging/PackageTestSupport.cs deleted file mode 100644 index 5762478..0000000 --- a/src/DimensionalQuantities.IntegrationTests/Packaging/PackageTestSupport.cs +++ /dev/null @@ -1,53 +0,0 @@ -using System.IO.Compression; -using System.Reflection; -using Microsoft.Build.Evaluation; -using Microsoft.Build.Execution; -using Microsoft.Build.Utilities.ProjectCreation; - -namespace DimensionalQuantities.IntegrationTests.Packaging; - -internal static class PackageTestSupport -{ - public static Package AddPackedPackage(PackageRepository repository, FileInfo archive) - { - repository.Package(archive, out Package package); - // ProjectCreation rewrites the nuspec without dependency groups; restore the packed manifest for transitive consumers. - using ZipArchive zip = ZipFile.OpenRead(archive.FullName); - ZipArchiveEntry manifest = zip.Entries.Single(entry => entry.Name.EndsWith(".nuspec", StringComparison.OrdinalIgnoreCase)); - using Stream source = manifest.Open(); - using Stream destination = File.Create(repository.GetManifestFilePath(package.Id, package.Version)); - source.CopyTo(destination); - return package; - } - - public static FileInfo PackLibrary(string sourceProject, string scratch) - { - string packageOutput = Path.Combine(scratch, "package"); - Directory.CreateDirectory(packageOutput); - Dictionary properties = new() - { - ["Configuration"] = typeof(PackageTestSupport).Assembly.GetCustomAttribute()!.Configuration, - ["NoBuild"] = "true", - ["PackageOutputPath"] = packageOutput, - ["NuGetAudit"] = "false", - }; - using ProjectCollection collection = new(properties); - Project project = collection.LoadProject(sourceProject); - string packageId = project.GetPropertyValue("PackageId"); - string packageVersion = project.GetPropertyValue("PackageVersion"); - using BuildOutput output = BuildOutput.Create(); - BuildParameters parameters = new(collection) { Loggers = [output] }; - BuildRequestData request = new(project.CreateProjectInstance(), ["Pack"]); - BuildResult result = BuildManager.DefaultBuildManager.Build(parameters, request); - if (result.OverallResult != BuildResultCode.Success) - { - throw new InvalidOperationException($"Pack failed.{Environment.NewLine}{output.GetConsoleLog()}"); - } - FileInfo nupkg = new(Path.Combine(packageOutput, $"{packageId}.{packageVersion}.nupkg")); - if (!nupkg.Exists) - { - throw new FileNotFoundException("Pack did not create the expected package", nupkg.FullName); - } - return nupkg; - } -} diff --git a/src/DimensionalQuantities.IntegrationTests/Packaging/PackagedArithmeticTests.cs b/src/DimensionalQuantities.IntegrationTests/Packaging/PackagedArithmeticTests.cs deleted file mode 100644 index caf5bfc..0000000 --- a/src/DimensionalQuantities.IntegrationTests/Packaging/PackagedArithmeticTests.cs +++ /dev/null @@ -1,529 +0,0 @@ -using Microsoft.Build.Utilities.ProjectCreation; -using Xunit; - -namespace DimensionalQuantities.IntegrationTests.Packaging; - -public sealed partial class PackagedGeneratorTests -{ - - [Theory] - [InlineData("Length.FromMetres(2) * Length.FromMetres(3)", "Area", 6)] - [InlineData("Current.FromAmps(2) * Current.FromAmps(3)", "CurrentSquared", 6)] - [InlineData("Current.FromAmps(2) * Current.FromAmps(3) * Resistance.FromSiBaseUnit(4)", "Power", 24)] - [InlineData("Current.FromAmps(2) * (Current.FromAmps(3) * Resistance.FromSiBaseUnit(4))", "Power", 24)] - [InlineData("Voltage.FromSiBaseUnit(12) / Current.FromAmps(3)", "Resistance", 4)] - [InlineData("Current.FromAmps(3) * Time.FromSeconds(2)", "TimeCurrent", 6)] - [InlineData("(Current.FromAmps(2) * Time.FromSeconds(3)) / Time.FromSeconds(3)", "Current", 2)] - [InlineData("(Voltage.FromSiBaseUnit(4) * Current.FromAmps(3)) / Current.FromAmps(2)", "Voltage", 6)] - [InlineData("Current.FromAmps(3) * 2d", "Current", 6)] - [InlineData("2 * Current.FromAmps(3)", "Current", 6)] - [InlineData("Current.FromAmps(6) / 2f", "Current", 3)] - [InlineData("2d / Time.FromSeconds(4)", "Frequency", 0.5)] - [InlineData("2f / Current.FromAmps(4)", "InverseCurrent", 0.5)] - [InlineData("(2 / Current.FromAmps(4)) * Time.FromSeconds(3)", "TimePerCurrent", 1.5)] - [InlineData("(Current.FromAmps(2) * 2) * Current.FromAmps(3)", "CurrentSquared", 12)] - [InlineData("2 * (Current.FromAmps(2) * Current.FromAmps(3))", "CurrentSquared", 12)] - [InlineData("(Current.FromAmps(2) * Current.FromAmps(3)) / 2", "CurrentSquared", 3)] - [InlineData("(2 + 3) * Current.FromAmps(2) * Current.FromAmps(3)", "CurrentSquared", 30)] - [InlineData("(2 * 3) * Current.FromAmps(2) * Current.FromAmps(3)", "CurrentSquared", 36)] - public void QuantityArithmeticProducesTheExpectedTypeAndSiMagnitude(string arithmetic, string resultType, double expected) - { - string expression = $"(({resultType})({arithmetic})).AsSiBaseUnit()"; - double result = Evaluate(expression); - - Assert.Equal(expected, result); - } - - - [Theory] - [InlineData("Current.FromAmps(2) + Current.FromMilliAmps(500)", "AsAmps", 2.5)] - [InlineData("Current.FromAmps(2) - Current.FromMilliAmps(500)", "AsAmps", 1.5)] - [InlineData("-Current.FromMilliAmps(500)", "AsAmps", -0.5)] - [InlineData("Energy.FromSiBaseUnit(2) + Torque.FromSiBaseUnit(3)", "AsSiBaseUnit", 5)] - public void SameDimensionArithmeticUsesCoreOperatorsWithoutGeneratedOverloads(string expression, string accessor, double expected) - { - string source = $$""" - public static class Consumer - { - public static double Value() => ({{expression}}).{{accessor}}(); - } - """; - double result = EvaluateSource(source); - - Assert.Equal(expected, result); - } - - [Theory] - [InlineData("firstSquared + secondSquared", 52)] - [InlineData("firstSquared - secondSquared", 20)] - [InlineData("-firstSquared", -36)] - public void SameDimensionArithmeticThroughInferredLocalsCompilesAndExecutes(string expression, double expected) - { - string source = $$""" - public static class Consumer - { - public static double Value() - { - Current first = Current.FromAmps(3); - Current second = Current.FromAmps(2); - Resistance resistance = Resistance.FromSiBaseUnit(4); - var firstSquared = first * first; - var secondSquared = second * second; - var combined = {{expression}}; - var heating = combined * resistance; - return ((Power)heating).AsSiBaseUnit(); - } - } - """; - double result = EvaluateSource(source); - - Assert.Equal(expected, result); - } - - [Theory] - [InlineData("((Current.FromAmps(3) * Current.FromAmps(3) + Current.FromAmps(2) * Current.FromAmps(2)) * Resistance.FromSiBaseUnit(4)).AsSiBaseUnit()", 52)] - [InlineData("((Current.FromAmps(3) * Current.FromAmps(3) - Current.FromAmps(2) * Current.FromAmps(2)) * Resistance.FromSiBaseUnit(4)).AsSiBaseUnit()", 20)] - [InlineData("(-(Current.FromAmps(3) * Current.FromAmps(3))).AsSiBaseUnit()", -9)] - public void SameDimensionArithmeticAroundNestedProductsCompilesAndExecutes(string expression, double expected) - { - double result = Evaluate(expression); - - Assert.Equal(expected, result); - } - - [Theory] - [InlineData("Length.FromMetres(3) / Length.FromMilliMetres(500)", 6)] - [InlineData("Energy.FromSiBaseUnit(6) / Torque.FromSiBaseUnit(2)", 3)] - [InlineData("Current.FromAmps(3) * (2 / Current.FromAmps(3))", 2)] - [InlineData("(2 / Current.FromAmps(3)) * Current.FromAmps(3)", 2)] - [InlineData("(Current.FromAmps(3) * Current.FromAmps(3)) / (Current.FromAmps(2) * Current.FromAmps(2))", 2.25)] - [InlineData("(Length.FromMetres(3) / Length.FromMetres(1)) + (Current.FromAmps(4) / Current.FromAmps(2))", 5)] - public void CancelledDimensionsCompileAndExecuteAsDouble(string expression, double expected) - { - double result = Evaluate(expression); - - Assert.Equal(expected, result); - } - - [Theory] - [InlineData("var ratio = first / second;", "(ratio * time).AsSeconds()", 6)] - [InlineData("var firstSquared = first * first; var secondSquared = second * second; var ratio = firstSquared / secondSquared;", "(ratio * time).AsSeconds()", 9)] - [InlineData("var inverse = 2 / first; var ratio = first * inverse; var copy = ratio;", "(copy * time).AsSeconds()", 8)] - [InlineData("var inverse = 2 / first; var ratio = first * inverse;", "(time / ratio).AsSeconds()", 2)] - [InlineData("var inverse = 2 / first; var ratio = first * inverse; var scaled = (ratio + 1) * first;", "(scaled * time).AsSiBaseUnit()", 36)] - [InlineData("var ratio = first / second; var inverseTime = ratio / time;", "inverseTime.AsSiBaseUnit()", 0.375)] - public void CancelledLocalsCanBeUsedAsScalarOperands(string declarations, string expression, double expected) - { - string source = $$""" - public static class Consumer - { - public static double Value() - { - Current first = Current.FromAmps(3); - Current second = Current.FromAmps(2); - Time time = Time.FromSeconds(4); - {{declarations}} - return {{expression}}; - } - } - """; - double result = EvaluateSource(source); - - Assert.Equal(expected, result); - } - - [Theory] - [InlineData("TerminalHex2", 3, 9)] - [InlineData("TerminalHex3", 3, 27)] - [InlineData("TerminalHex1", 3, 3)] - [InlineData("Hex", 2, 65536)] - [InlineData("Negative", 2, 0.25)] - [InlineData("Fraction", 9, 3)] - [InlineData("Fraction", 9, 3)] - [InlineData("Fraction", -8, -2)] - [InlineData("Fraction", -8, 4)] - [InlineData("Fraction, TerminalHex3>", -8, -0.5)] - public void EncodedPowersCompileAndExecute(string exponent, double value, double expected) - { - string source = $$""" - using DimensionalQuantities.TypeSystem; - public static class Consumer - { - public static double Value() => Power<{{exponent}}>.Of(Length.FromMetres({{value.ToString(System.Globalization.CultureInfo.InvariantCulture)}})).AsSiBaseUnit(); - } - """; - double result = EvaluateSource(source); - - Assert.Equal(expected, result, 12); - } - - [Theory] - [InlineData("NumberTwo", 3, 9)] - [InlineData("NumberSeventeen", 2, 131072)] - [InlineData("NumberMinusTwo", 2, 0.25)] - [InlineData("NumberHalf", 9, 3)] - [InlineData("NumberTwoQuarters", 9, 3)] - [InlineData("NumberTwoOverThree", -8, 4)] - [InlineData("NumberMinusOneOverThree", -8, -0.5)] - [InlineData("NumberMillionth", 1, 1)] - public void EnglishPowersCompileAndExecute(string exponent, double value, double expected) - { - string source = $$""" - using DimensionalQuantities.TypeSystem; - public static class Consumer - { - public static double Value() => Power<{{exponent}}>.Of(Length.FromMetres({{value.ToString(System.Globalization.CultureInfo.InvariantCulture)}})).AsSiBaseUnit(); - } - """; - double result = EvaluateSource(source); - - Assert.Equal(expected, result, 12); - } - - [Fact] - public void EnglishPowersWorkWithNestedCallsArithmeticAndLocals() - { - const string source = """ - using DimensionalQuantities.TypeSystem; - public static class Consumer - { - public static double Value() - { - var squared = Power.Of(Current.FromAmps(3)); - var root = Power.Of(squared); - Voltage voltage = root * Resistance.FromSiBaseUnit(4); - Current nested = Power.Of(Power.Of(root)); - return voltage.AsSiBaseUnit() + nested.AsAmps(); - } - } - """; - double result = EvaluateSource(source); - - Assert.Equal(15, result); - } - - [Fact] - public void EnglishLookingUserAliasKeepsItsDeclaredExponent() - { - const string source = """ - using DimensionalQuantities.TypeSystem; - using NumberTwo = DimensionalQuantities.TypeSystem.TerminalHex3; - public static class Consumer - { - public static double Value() => Power.Of(Length.FromMetres(3)).AsSiBaseUnit(); - } - """; - double result = EvaluateSource(source); - - Assert.Equal(27, result); - } - - [Fact] - public void EquivalentEnglishNamesShareTheEncodedTypeAndPowerOverload() - { - const string source = """ - using DimensionalQuantities.TypeSystem; - public static class Consumer - { - public static bool Value() - { - Length first = Power.Of(Area.FromSiBaseUnit(9)); - Length second = Power.Of(Area.FromSiBaseUnit(9)); - Length third = Power>.Of(Area.FromSiBaseUnit(9)); - return first == second && second == third && typeof(NumberHalf) == typeof(NumberTwoQuarters) - && typeof(NumberHalf) == typeof(Fraction); - } - } - """; - - Assert.True(EvaluateSource(source)); - } - - [Fact] - public void EnglishZerothPowerReturnsDouble() - { - const string source = """ - using DimensionalQuantities.TypeSystem; - public static class Consumer - { - public static double Value() => Power.Of(Length.FromMetres(3)); - } - """; - - Assert.Equal(1, EvaluateSource(source)); - } - - [Fact] - public void PowersReturnExistingQuantityTypesWhenCalledThroughAliases() - { - const string source = """ - using DimensionalQuantities.TypeSystem; - using Two = DimensionalQuantities.TypeSystem.TerminalHex2; - using Half = DimensionalQuantities.TypeSystem.Fraction; - using Squaring = DimensionalQuantities.TypeSystem.Power; - public static class Consumer - { - public static double Value() - { - Length length = Length.FromMetres(3); - Area first = Power.Of(length); - Area second = Squaring.Of(length); - Length root = Power.Of(first); - Length equivalent = Power>.Of(second); - Volume volume = Power.Of(length); - return first.AsSiBaseUnit() + second.AsSiBaseUnit() + root.AsSiBaseUnit() + equivalent.AsSiBaseUnit() + volume.AsSiBaseUnit(); - } - } - """; - double result = EvaluateSource(source); - double expected = 51; - - Assert.Equal(expected, result); - } - - [Theory] - [InlineData("var squared = Power.Of(current); var result = squared * resistance;", "((Power)result).AsSiBaseUnit()", 36)] - [InlineData("var squared = current * current; var result = Power>.Of(squared);", "((Current)result).AsAmps()", 3)] - [InlineData("var squared = Power.Of(current); var copy = squared; var result = Power>.Of(copy);", "((Current)result).AsAmps()", 3)] - [InlineData("var result = Power.Of(current * resistance);", "result.AsSiBaseUnit()", 144)] - [InlineData("var result = Power>.Of(Power.Of(current));", "((Current)result).AsAmps()", 3)] - [InlineData("var identity = Power.Of(current); var result = identity * current * resistance;", "((Voltage)result).AsSiBaseUnit()", 12)] - public void PowersWorkWithArithmeticAndLocalVariables(string declarations, string expression, double expected) - { - string source = $$""" - using DimensionalQuantities.TypeSystem; - public static class Consumer - { - public static double Value() - { - Current current = Current.FromAmps(3); - Resistance resistance = Resistance.FromSiBaseUnit(4); - {{declarations}} - return {{expression}}; - } - } - """; - double result = EvaluateSource(source); - - Assert.Equal(expected, result, 12); - } - - [Fact] - public void ZerothPowerReturnsDouble() - { - const string source = """ - using DimensionalQuantities.TypeSystem; - public static class Consumer - { - public static double Value() => Power.Of(Length.FromMetres(3)); - } - """; - double result = EvaluateSource(source); - - Assert.Equal(1, result); - } - - [Theory] - [InlineData("Squared", 3, 9)] - [InlineData("Cubed", 3, 27)] - [InlineData("Pow4", 2, 16)] - [InlineData("Pow5", 2, 32)] - [InlineData("Pow6", 2, 64)] - [InlineData("SquareRoot", 9, 3)] - [InlineData("CubeRoot", 27, 3)] - [InlineData("Root4", 16, 2)] - [InlineData("Root5", 32, 2)] - [InlineData("Root6", 64, 2)] - public void ConveniencePowersCompileAndExecute(string method, double value, double expected) - { - string source = $$""" - public static class Consumer - { - public static double Value() => Length.FromMetres({{value.ToString(System.Globalization.CultureInfo.InvariantCulture)}}).{{method}}().AsSiBaseUnit(); - } - """; - double result = EvaluateSource(source); - - Assert.Equal(expected, result, 12); - } - - [Fact] - public void ConveniencePowersShareQuantityTypesWithGenericPowersAndArithmetic() - { - const string source = """ - using DimensionalQuantities.TypeSystem; - public static class Consumer - { - public static double Value() - { - Length length = Length.FromMetres(3); - Area area = length.Squared(); - Volume volume = length.Cubed(); - Length root = area.SquareRoot(); - Length cubeRoot = volume.CubeRoot(); - var fourthPower = length.Pow4(); - Length fourthRoot = fourthPower.Root4(); - Area fromGeneric = Power.Of(root); - Area fromProduct = root * cubeRoot; - return area.AsSiBaseUnit() + volume.AsSiBaseUnit() + fourthRoot.AsMetres() - + fromGeneric.AsSiBaseUnit() + fromProduct.AsSiBaseUnit(); - } - } - """; - double result = EvaluateSource(source); - - Assert.Equal(57, result, 12); - } - - [Theory] - [InlineData("current.Squared().SquareRoot() * resistance", 12)] - [InlineData("Power.Of(current.Squared()) * resistance", 12)] - [InlineData("Power.Of(current).SquareRoot() * resistance", 12)] - [InlineData("(current * resistance).Squared().SquareRoot()", 12)] - public void ConveniencePowersWorkInsideNestedExpressions(string expression, double expected) - { - string source = $$""" - using DimensionalQuantities.TypeSystem; - public static class Consumer - { - public static double Value() - { - Current current = Current.FromAmps(3); - Resistance resistance = Resistance.FromSiBaseUnit(4); - Voltage voltage = {{expression}}; - return voltage.AsSiBaseUnit(); - } - } - """; - double result = EvaluateSource(source); - - Assert.Equal(expected, result, 12); - } - - [Fact] - public void InferredCatalogueQuantityReusesItsDefaultConvenienceMethod() - { - const string source = """ - public static class Consumer - { - public static double Value() - { - Length length = Length.FromMetres(3); - var area = length * length; - return area.Squared().AsSiBaseUnit(); - } - } - """; - double result = EvaluateSource(source); - - Assert.Equal(81, result); - } - - [Fact] - public void ExistingQuantityExtensionMethodKeepsItsBehaviour() - { - const string source = """ - public static class UserMethods { public static double Squared(this Length value) => 42; } - public static class Consumer { public static double Value() => Length.FromMetres(3).Squared(); } - """; - double result = EvaluateSource(source); - - Assert.Equal(42, result); - } - - [Fact] - public void ConvenienceMethodCoexistsWithAnExistingOverload() - { - const string source = """ - public static class UserMethods { public static double Squared(this Length value, int factor) => value.AsMetres() * factor; } - public static class Consumer - { - public static double[] Value() - { - Length length = Length.FromMetres(3); - return [length.Squared().AsSiBaseUnit(), length.Squared(4)]; - } - } - """; - double[] result = EvaluateSource(source); - double[] expected = [9, 12]; - - Assert.Equal(expected, result); - } - - [Theory] - [InlineData(false, 216)] - [InlineData(true, 72)] - public void WindingLossHelpersPreserveUnitsAndRoundTripResistance(bool delta, double expectedLoss) - { - string source = $$""" - public static class Consumer - { - private static Current PhaseCurrent(Current line, bool delta) => delta ? line / System.Math.Sqrt(3) : line; - private static Power Loss(Resistance resistance, Current line, bool delta) - { - Current phase = PhaseCurrent(line, delta); - CurrentSquared squared = phase.Squared(); - return 3 * squared * resistance; - } - private static Resistance Recover(Power loss, Current line, bool delta) - { - Current phase = PhaseCurrent(line, delta); - CurrentSquared denominator = 3 * phase.Squared(); - return loss / denominator; - } - public static double[] Value() - { - Current line = Current.FromAmps(12); - Resistance resistance = Resistance.FromSiBaseUnit(0.5); - Power loss = Loss(resistance, line, {{delta.ToString().ToLowerInvariant()}}); - Resistance recovered = Recover(loss, line, {{delta.ToString().ToLowerInvariant()}}); - return [loss.AsSiBaseUnit(), recovered.AsSiBaseUnit()]; - } - } - """; - double[] result = EvaluateSource(source); - - Assert.Multiple( - () => Assert.Equal(expectedLoss, result[0], 12), - () => Assert.Equal(0.5, result[1], 12)); - } - - [Fact] - public void TypeOnlyParameterSuppliesDimensionsToArithmeticWithoutAnInitialiser() - { - const string source = """ - public static class Consumer - { - private static LengthTimeCurrent Multiply(LengthCurrent input, Time time) => input * time; - public static double Value() => Multiply(LengthCurrent.FromSiBaseUnit(6), Time.FromSeconds(4)).AsSiBaseUnit(); - } - """; - double result = EvaluateSource(source); - - Assert.Equal(24, result); - } - - private T Evaluate(string expression) - { - string source = $$""" - public static class Consumer - { - public static global::{{typeof(T).FullName}} Value() => {{expression}}; - } - """; - return EvaluateSource(source); - } - - private T EvaluateSource(string source) - { - using PackageRepository repository = PackageRepository.Create(_scratch, new Uri("https://api.nuget.org/v3/index.json")); - Package core = PackCore(repository); - ProjectCreator consumer = CreateProject("GeneratedConsumer", source, core); - Build(consumer); - string output = OutputDirectory("GeneratedConsumer"); - using PackageAssemblyContext context = new(output); - Type type = context.LoadFromAssemblyPath(Path.Combine(output, "GeneratedConsumer.dll")).GetType("Consumer", throwOnError: true)!; - return Assert.IsType(type.GetMethod("Value")!.Invoke(null, null)); - } -} diff --git a/src/DimensionalQuantities.IntegrationTests/Packaging/PackagedGeneratorTests.cs b/src/DimensionalQuantities.IntegrationTests/Packaging/PackagedGeneratorTests.cs deleted file mode 100644 index b23a307..0000000 --- a/src/DimensionalQuantities.IntegrationTests/Packaging/PackagedGeneratorTests.cs +++ /dev/null @@ -1,493 +0,0 @@ -using System.Reflection; -using Microsoft.Build.Locator; -using Microsoft.Build.Utilities.ProjectCreation; -using Xunit; - -namespace DimensionalQuantities.IntegrationTests.Packaging; - -[Collection("MSBuild")] -public sealed partial class PackagedGeneratorTests : IDisposable -{ - private readonly string _scratch = Directory.CreateTempSubdirectory("dimensional-quantities-").FullName; - - static PackagedGeneratorTests() - { - // MSBuild must be located before any Microsoft.Build type is loaded. - if (!MSBuildLocator.IsRegistered) - { - MSBuildLocator.RegisterDefaults(); - } - } - - [Fact] - public void CorePackageProvidesBaseUnitsCatalogueAliasesAndArithmetic() - { - using PackageRepository repository = PackageRepository.Create(_scratch, new Uri("https://api.nuget.org/v3/index.json")); - Package core = PackCore(repository); - ProjectCreator consumer = CreateProject("CoreConsumer", """ - public static class Consumer - { - public static double ConvertLength() => Length.FromMetres(2.5).AsMetres(); - public static double ConvertCurrent() => Current.FromAmps(3).AsAmps(); - public static double CalculateArea() => (Length.FromMetres(2) * Length.FromMetres(3)).AsSiBaseUnit(); - public static double NamedArea() => Area.FromSiBaseUnit(6).AsSiBaseUnit(); - } - """, core); - Build(consumer); - - using PackageAssemblyContext context = new(OutputDirectory("CoreConsumer")); - Type type = context.LoadFromAssemblyPath(Path.Combine(OutputDirectory("CoreConsumer"), "CoreConsumer.dll")) - .GetType("Consumer", throwOnError: true)!; - Assert.Multiple( - () => Assert.Equal(2.5, InvokeDouble(type, "ConvertLength")), - () => Assert.Equal(3, InvokeDouble(type, "ConvertCurrent")), - () => Assert.Equal(6, InvokeDouble(type, "CalculateArea")), - () => Assert.Equal(6, InvokeDouble(type, "NamedArea"))); - } - - [Fact] - public void MetricPackageProvidesNamedConversionsAndArithmeticThroughCoreDependency() - { - using PackageRepository repository = PackageRepository.Create(_scratch, new Uri("https://api.nuget.org/v3/index.json")); - PackCore(repository); - Package metric = PackMetric(repository); - ProjectCreator consumer = CreateProject("MetricConsumer", """ - using DimensionalQuantities.Extensions.Metric; - - public static class Consumer - { - public static double ConvertVoltage(double volts) => Voltage.FromVolts(volts).AsVolts(); - public static double MultiplyVoltageCurrent(double volts, double amps) - { - Power power = Voltage.FromVolts(volts) * Current.FromAmps(amps); - return power.AsWatts(); - } - } - """, metric); - Build(consumer); - - using PackageAssemblyContext context = new(OutputDirectory("MetricConsumer")); - Type type = context.LoadFromAssemblyPath(Path.Combine(OutputDirectory("MetricConsumer"), "MetricConsumer.dll")) - .GetType("Consumer", throwOnError: true)!; - Assert.Multiple( - () => Assert.Equal(12.5, InvokeDouble(type, "ConvertVoltage", 12.5)), - () => Assert.Equal(25, InvokeDouble(type, "MultiplyVoltageCurrent", 12.5, 2.0))); - } - - [Fact] - public void ImperialPackageProvidesConversionsThroughCoreDependency() - { - using PackageRepository repository = PackageRepository.Create(_scratch, new Uri("https://api.nuget.org/v3/index.json")); - PackCore(repository); - Package imperial = PackSourceProject(repository, "DimensionalQuantities.Extensions.Imperial"); - ProjectCreator consumer = CreateProject("ImperialConsumer", """ - using DimensionalQuantities.Extensions.Imperial; - - public static class Consumer - { - public static double ConvertLength() => Length.FromFeet(6).AsSiBaseUnit(); - public static double ConvertTemperature() => Temperature.FromRankine(491.67).AsSiBaseUnit(); - } - """, imperial); - Build(consumer); - - using PackageAssemblyContext context = new(OutputDirectory("ImperialConsumer")); - Type type = context.LoadFromAssemblyPath(Path.Combine(OutputDirectory("ImperialConsumer"), "ImperialConsumer.dll")) - .GetType("Consumer", throwOnError: true)!; - Assert.Multiple( - () => Assert.Equal(1.8288, InvokeDouble(type, "ConvertLength"), 12), - () => Assert.Equal(273.15, InvokeDouble(type, "ConvertTemperature"), 12)); - } - - [Fact] - public void AffineTemperatureConversionsAndDeltasWorkAcrossPackages() - { - using PackageRepository repository = PackageRepository.Create(_scratch, new Uri("https://api.nuget.org/v3/index.json")); - PackCore(repository); - Package metric = PackMetric(repository); - Package imperial = PackSourceProject(repository, "DimensionalQuantities.Extensions.Imperial"); - - ProjectCreator measurements = CreateProject("TemperatureMeasurements", """ - using DimensionalQuantities.Extensions.Metric; - using DimensionalQuantities.TypeSystem; - - namespace TemperatureMeasurements; - public static class Readings - { - public static Delta Difference() => - (Temperature.FromCelsius(20) - Temperature.FromCelsius(10)).AsDelta(); - } - """, metric); - Pack(measurements, "TemperatureMeasurements", repository, out Package measurementPackage); - - ProjectCreator consumer = CreateProject("TemperatureConsumer", """ - using DimensionalQuantities.Extensions.Imperial; - using DimensionalQuantities.Extensions.Metric; - using TemperatureMeasurements; - - public static class Consumer - { - public static double[] DifferenceInEachUnit() - { - var delta = Readings.Difference(); - return [delta.AsCelsius(), delta.AsFahrenheit(), delta.AsKelvin(), delta.AsRankine()]; - } - - public static double[] AbsoluteRoundTrips() => - [ - Temperature.FromCelsius(20).AsCelsius(), - Temperature.FromFahrenheit(68).AsFahrenheit(), - Temperature.FromKelvin(293.15).AsCelsius(), - Temperature.FromRankine(527.67).AsFahrenheit() - ]; - } - """, metric, imperial, measurementPackage); - Build(consumer); - - string outputDirectory = OutputDirectory("TemperatureConsumer"); - using PackageAssemblyContext context = new(outputDirectory); - Type type = context.LoadFromAssemblyPath(Path.Combine(outputDirectory, "TemperatureConsumer.dll")) - .GetType("Consumer", throwOnError: true)!; - double[] difference = (double[])type.GetMethod("DifferenceInEachUnit")!.Invoke(null, null)!; - double[] absolute = (double[])type.GetMethod("AbsoluteRoundTrips")!.Invoke(null, null)!; - - Assert.Multiple( - () => Assert.Equal([10d, 18d, 10d, 18d], difference), - () => Assert.Equal(20d, absolute[0], 12), - () => Assert.Equal(68d, absolute[1], 12), - () => Assert.Equal(20d, absolute[2], 12), - () => Assert.Equal(68d, absolute[3], 12)); - } - - [Fact] - public void NauticalPackageProvidesConversionsThroughCoreDependency() - { - using PackageRepository repository = PackageRepository.Create(_scratch, new Uri("https://api.nuget.org/v3/index.json")); - PackCore(repository); - Package nautical = PackSourceProject(repository, "DimensionalQuantities.Extensions.Nautical"); - ProjectCreator consumer = CreateProject("NauticalConsumer", """ - using DimensionalQuantities.Extensions.Nautical; - - public static class Consumer - { - public static double ConvertLength() => Length.FromNauticalMiles(1).AsSiBaseUnit(); - public static double ConvertSpeed() => Speed.FromKnots(1).AsSiBaseUnit(); - } - """, nautical); - Build(consumer); - - using PackageAssemblyContext context = new(OutputDirectory("NauticalConsumer")); - Type type = context.LoadFromAssemblyPath(Path.Combine(OutputDirectory("NauticalConsumer"), "NauticalConsumer.dll")) - .GetType("Consumer", throwOnError: true)!; - Assert.Multiple( - () => Assert.Equal(1852, InvokeDouble(type, "ConvertLength")), - () => Assert.Equal(1852d / 3600d, InvokeDouble(type, "ConvertSpeed"))); - } - - [Fact] - public void CgsEmagPackageProvidesConversionsThroughCoreDependency() - { - using PackageRepository repository = PackageRepository.Create(_scratch, new Uri("https://api.nuget.org/v3/index.json")); - PackCore(repository); - Package cgsEmag = PackSourceProject(repository, "DimensionalQuantities.Extensions.CgsEmag"); - ProjectCreator consumer = CreateProject("CgsEmagConsumer", """ - using DimensionalQuantities.Extensions.CgsEmag; - - public static class Consumer - { - public static double ConvertFluxDensity() => MagneticFluxDensity.FromGauss(10_000).AsSiBaseUnit(); - public static double ConvertCurrent() => Current.FromAbamperes(1).AsSiBaseUnit(); - public static double ConvertCharge() => ElectricCharge.FromAbcoulombs(1).AsSiBaseUnit(); - } - """, cgsEmag); - Build(consumer); - - using PackageAssemblyContext context = new(OutputDirectory("CgsEmagConsumer")); - Type type = context.LoadFromAssemblyPath(Path.Combine(OutputDirectory("CgsEmagConsumer"), "CgsEmagConsumer.dll")) - .GetType("Consumer", throwOnError: true)!; - Assert.Multiple( - () => Assert.Equal(1, InvokeDouble(type, "ConvertFluxDensity")), - () => Assert.Equal(10, InvokeDouble(type, "ConvertCurrent")), - () => Assert.Equal(10, InvokeDouble(type, "ConvertCharge"))); - } - - [Fact] - public void MetricNamedConversionsRequireNamespaceImport() - { - using PackageRepository repository = PackageRepository.Create(_scratch, new Uri("https://api.nuget.org/v3/index.json")); - PackCore(repository); - Package metric = PackMetric(repository); - ProjectCreator consumer = CreateProject("MissingMetricImport", """ - public static class Consumer - { - public static double Convert() => Voltage.FromVolts(12.5).AsVolts(); - } - """, metric); - consumer.TryBuild(restore: true, out bool built, out BuildOutput output); - using (output) - { - string log = output.GetConsoleLog(); - Assert.Multiple( - () => Assert.False(built, log), - () => Assert.Contains(output.ErrorEvents, error => error.Code == "CS0117" && error.Message!.Contains("FromVolts", StringComparison.Ordinal)), - () => Assert.DoesNotContain(output.ErrorEvents, error => error.Code is "CS8032" or "CS8785" or "AD0001"), - () => Assert.DoesNotContain(output.WarningEvents, warning => warning.Code is "CS8032" or "CS8785" or "AD0001")); - } - } - - [Fact] - public void IndependentPackagesShareQuantitiesAndConsumerCanExtendArithmetic() - { - using PackageRepository repository = PackageRepository.Create(_scratch, new Uri("https://api.nuget.org/v3/index.json")); - Package core = PackCore(repository); - Package metric = PackMetric(repository); - - ProjectCreator projectA = CreateProject("ProjectA", """ - namespace PackageA; - public static class Producer - { - public static Voltage Create() => Voltage.FromSiBaseUnit(6); - public static LengthCurrent CreateIntermediate() => Length.FromMetres(2) * Current.FromAmps(3); - public static System.Collections.Generic.List Values() => new() { Create(), Create() }; - public static Measurement Measure() => new(); - } - public sealed class Measurement - { - public Voltage Value => Producer.Create(); - } - """, core); - Pack(projectA, "ProjectA", repository, out Package packageA); - - ProjectCreator projectB = CreateProject("ProjectB", """ - using DimensionalQuantities.Extensions.Metric; - namespace PackageB; - public static class Consumer - { - public static Voltage Create() => Voltage.FromVolts(10); - public static LengthCurrent CreateIntermediate() => Length.FromMetres(5) * Current.FromAmps(2); - public static double ReadIntermediate(LengthCurrent value) => value.AsSiBaseUnit(); - public static double Read(Voltage value) => value.AsVolts(); - public static double Sum(System.Collections.Generic.IEnumerable values) - { - double total = 0; - foreach (Voltage value in values) - { - total += value.AsVolts(); - } - return total; - } - } - """, metric); - Pack(projectB, "ProjectB", repository, out Package packageB); - - ProjectCreator projectC = CreateProject("ProjectC", """ - using DimensionalQuantities.Extensions.Metric; - using PackageA; - public static class Application - { - public static double Direct() => PackageB.Consumer.Read(Producer.Create()); - public static double Collection() => PackageB.Consumer.Sum(Producer.Values()); - public static double Contained() => PackageB.Consumer.Read(Producer.Measure().Value); - public static double Prefixed() => Producer.Create().AsPrefixedUnits(3); - public static double Product() => (Producer.Create() * Current.FromAmps(4)).AsWatts(); - public static double Intermediate() => PackageB.Consumer.ReadIntermediate(Producer.CreateIntermediate()); - public static double IntermediateProduct() => (Producer.CreateIntermediate() * Time.FromSeconds(4)).AsSiBaseUnit(); - } - """, metric, packageA, packageB); - Build(projectC); - - string outputDirectory = OutputDirectory("ProjectC"); - using PackageAssemblyContext context = new(outputDirectory); - Assembly assemblyA = context.LoadFromAssemblyPath(Path.Combine(outputDirectory, "ProjectA.dll")); - Assembly assemblyB = context.LoadFromAssemblyPath(Path.Combine(outputDirectory, "ProjectB.dll")); - Assembly assemblyC = context.LoadFromAssemblyPath(Path.Combine(outputDirectory, "ProjectC.dll")); - Type producer = assemblyA.GetType("PackageA.Producer", throwOnError: true)!; - Type consumer = assemblyB.GetType("PackageB.Consumer", throwOnError: true)!; - Type application = assemblyC.GetType("Application", throwOnError: true)!; - Type producedType = producer.GetMethod("Create")!.ReturnType; - Type independentlyProducedType = consumer.GetMethod("Create")!.ReturnType; - Type acceptedType = consumer.GetMethod("Read")!.GetParameters().Single().ParameterType; - Type intermediateFromA = producer.GetMethod("CreateIntermediate")!.ReturnType; - Type intermediateFromB = consumer.GetMethod("CreateIntermediate")!.ReturnType; - Type intermediateAccepted = consumer.GetMethod("ReadIntermediate")!.GetParameters().Single().ParameterType; - - Assert.Multiple( - () => Assert.Equal(producedType, independentlyProducedType), - () => Assert.Equal(producedType, acceptedType), - () => Assert.Equal(intermediateFromA, intermediateFromB), - () => Assert.Equal(intermediateFromA, intermediateAccepted), - () => Assert.Equal(6, InvokeDouble(application, "Direct")), - () => Assert.Equal(12, InvokeDouble(application, "Collection")), - () => Assert.Equal(6, InvokeDouble(application, "Contained")), - () => Assert.Equal(0.006, InvokeDouble(application, "Prefixed"), 12), - () => Assert.Equal(24, InvokeDouble(application, "Product")), - () => Assert.Equal(6, InvokeDouble(application, "Intermediate")), - () => Assert.Equal(24, InvokeDouble(application, "IntermediateProduct"))); - } - - [Fact] - public void AllUnitPackagesWorkInALibraryAndItsPackagedConsumer() - { - using PackageRepository repository = PackageRepository.Create(_scratch, new Uri("https://api.nuget.org/v3/index.json")); - PackCore(repository); - Package metric = PackMetric(repository); - Package imperial = PackSourceProject(repository, "DimensionalQuantities.Extensions.Imperial"); - Package nautical = PackSourceProject(repository, "DimensionalQuantities.Extensions.Nautical"); - Package cgsEmag = PackSourceProject(repository, "DimensionalQuantities.Extensions.CgsEmag"); - - ProjectCreator library = CreateProject("AllUnitsLibrary", """ - using DimensionalQuantities.Extensions.Metric; - using DimensionalQuantities.Extensions.Imperial; - using DimensionalQuantities.Extensions.Nautical; - using DimensionalQuantities.Extensions.CgsEmag; - - namespace AllUnitsLibrary; - public static class Measurements - { - public static Voltage Supply() => Voltage.FromVolts(0.00000001); - public static Length Depth() => Length.FromFeet(6); - public static Speed Travel() => Speed.FromKnots(1); - public static MagneticFluxDensity Field() => MagneticFluxDensity.FromGauss(10_000); - public static double[] LocalValues() => [Supply().AsVolts(), Depth().AsFeet(), Travel().AsKnots(), Field().AsGauss()]; - } - """, metric, imperial, nautical, cgsEmag); - Pack(library, "AllUnitsLibrary", repository, out Package libraryPackage); - - ProjectCreator downstream = CreateProject("AllUnitsDownstream", """ - using DimensionalQuantities.Extensions.Metric; - using DimensionalQuantities.Extensions.Imperial; - using DimensionalQuantities.Extensions.Nautical; - using DimensionalQuantities.Extensions.CgsEmag; - using AllUnitsLibrary; - - namespace AllUnitsDownstream; - public static class Reader - { - public static double[] LocalValues() => Measurements.LocalValues(); - public static double[] ConvertedValues() => - [ - Measurements.Supply().AsAbvolts(), - Measurements.Depth().AsFathoms(), - Measurements.Depth().AsFeet(), - Measurements.Travel().AsKnots(), - Measurements.Field().AsTeslas() - ]; - } - """, libraryPackage); - Pack(downstream, "AllUnitsDownstream", repository, out Package downstreamPackage); - - ProjectCreator application = CreateProject("AllUnitsApplication", """ - public static class Application - { - public static double[] LocalValues() => AllUnitsDownstream.Reader.LocalValues(); - public static double[] ConvertedValues() => AllUnitsDownstream.Reader.ConvertedValues(); - } - """, downstreamPackage); - Build(application); - - string outputDirectory = OutputDirectory("AllUnitsApplication"); - using PackageAssemblyContext context = new(outputDirectory); - Type type = context.LoadFromAssemblyPath(Path.Combine(outputDirectory, "AllUnitsApplication.dll")) - .GetType("Application", throwOnError: true)!; - double[] local = (double[])type.GetMethod("LocalValues")!.Invoke(null, null)!; - double[] converted = (double[])type.GetMethod("ConvertedValues")!.Invoke(null, null)!; - - Assert.Multiple( - () => Assert.Equal([0.00000001d, 6d, 1d, 10_000d], local), - () => Assert.Equal(5, converted.Length), - () => Assert.Equal(1d, converted[0]), - () => Assert.Equal(1d, converted[1], 12), - () => Assert.Equal(6d, converted[2]), - () => Assert.Equal(1d, converted[3]), - () => Assert.Equal(1d, converted[4])); - } - - private Package PackCore(PackageRepository repository) - { - return PackSourceProject(repository, "DimensionalQuantities"); - } - - private Package PackMetric(PackageRepository repository) - { - return PackSourceProject(repository, "DimensionalQuantities.Extensions.Metric"); - } - - private Package PackSourceProject(PackageRepository repository, string projectName) - { - string sourceDirectory = Path.GetFullPath(Path.Combine(AppContext.BaseDirectory, "..", "..", "..", "..")); - FileInfo packageFile = PackageTestSupport.PackLibrary(Path.Combine(sourceDirectory, projectName, projectName + ".csproj"), _scratch); - return PackageTestSupport.AddPackedPackage(repository, packageFile); - } - - private static void Build(ProjectCreator project) - { - project.TryBuild(restore: true, out bool built, out BuildOutput output); - using (output) - { - if (!built) - { - throw new InvalidOperationException(output.GetConsoleLog()); - } - } - } - - private void Pack(ProjectCreator project, string name, PackageRepository repository, out Package package) - { - project.TryBuild(restore: true, target: "Pack", out bool built, out BuildOutput output); - using (output) - { - if (!built) - { - throw new InvalidOperationException(output.GetConsoleLog()); - } - } - package = PackageTestSupport.AddPackedPackage(repository, new FileInfo(Path.Combine(_scratch, name, "packages", $"{name}.1.0.0.nupkg"))); - } - - private string OutputDirectory(string project) => Path.Combine(_scratch, project, "bin", "Debug", "netstandard2.0"); - - private static double InvokeDouble(Type type, string method, params object[] arguments) - => (double)type.GetMethod(method)!.Invoke(null, arguments)!; - - private ProjectCreator CreateProject(string name, string source, params Package[] packages) - { - string directory = Path.Combine(_scratch, name); - Directory.CreateDirectory(directory); - File.WriteAllText(Path.Combine(directory, name + ".cs"), source); - ProjectCreator creator = ProjectCreator.Templates.SdkCsproj(path: Path.Combine(directory, name + ".csproj"), targetFramework: "netstandard2.0") - .Property("LangVersion", "preview") - .Property("WarningsAsErrors", "CS8032;CS8785;AD0001") - .Property("Version", "1.0.0") - .Property("PackageOutputPath", Path.Combine(directory, "packages")) - .Property("CopyLocalLockFileAssemblies", "true"); - foreach (Package package in packages) - { - creator.ItemPackageReference(package); - } - return creator.Save(); - } - - private sealed class PackageAssemblyContext : System.Runtime.Loader.AssemblyLoadContext, IDisposable - { - private readonly string _directory; - - public PackageAssemblyContext(string directory) : base(isCollectible: true) - { - _directory = directory; - } - - protected override Assembly? Load(AssemblyName assemblyName) - { - string path = Path.Combine(_directory, assemblyName.Name + ".dll"); - return File.Exists(path) ? LoadFromAssemblyPath(path) : null; - } - - public void Dispose() => Unload(); - } - - public void Dispose() - { - Directory.Delete(_scratch, recursive: true); - } - -} diff --git a/src/DimensionalQuantities.IntegrationTests/Packaging/PackagedUnitProviderTests.cs b/src/DimensionalQuantities.IntegrationTests/Packaging/PackagedUnitProviderTests.cs deleted file mode 100644 index e92c5df..0000000 --- a/src/DimensionalQuantities.IntegrationTests/Packaging/PackagedUnitProviderTests.cs +++ /dev/null @@ -1,271 +0,0 @@ -using Microsoft.Build.Utilities.ProjectCreation; -using Xunit; - -namespace DimensionalQuantities.IntegrationTests.Packaging; - -public sealed partial class PackagedGeneratorTests -{ - - private const string FootProvider = """ - using DimensionalQuantities.Units.Declarations; - namespace Independent.Units; - - [UnitProvider] - internal static class CustomUnits - { - [QuantityUnit(typeof(Length))] - [UnitFactor(typeof(Foot))] - private sealed class LengthUnit; - - [UnitSymbol("Foot", "Feet", "ft", Scale = 0.3048)] - private sealed class Foot; - } - """; - - [Fact] - public void IndependentProviderGeneratesScaledFactoriesAndAccessors() - { - const string consumer = """ - namespace Independent.Units; - public static class Consumer - { - public static double[] Values() => [Length.FromFeet(10).AsMetres(), Length.FromMetres(0.6096).AsFeet()]; - } - """; - double[] result = EvaluateProvider(FootProvider, consumer, "Independent.Units.Consumer"); - Assert.Multiple( - () => Assert.Equal(3.048, result[0], 12), - () => Assert.Equal(2, result[1], 12)); - } - - [Fact] - public void AffineConversionsApplyOffsetOnlyToAbsoluteQuantities() - { - const string source = """ - using DimensionalQuantities.Units.Declarations; - [UnitProvider(GenerateSiPrefixes = true, GeneratePrefixConversions = true)] - internal static class CustomUnits - { - [QuantityUnit(typeof(Length))] - [UnitFactor(typeof(OffsetMetre))] - private sealed class LengthUnit; - [UnitSymbol("OffsetMetre", "OffsetMetres", "om", Scale = 2)] - [AffineUnit(5)] - private sealed class OffsetMetre; - } - public static class Consumer - { - public static double[] Values() - { - Length first = Length.FromOffsetMetres(3); - Length second = Length.FromOffsetMetres(2); - return [first.AsMetres(), first.AsOffsetMetres(), (first - second).AsDelta().AsOffsetMetres()]; - } - } - """; - Assert.Equal([16d, 3d, 1d], EvaluateProvider(source, "", "Consumer")); - } - - [Fact] - public void ProviderCanOptIntoNamedAndParameterisedSiPrefixes() - { - const string source = """ - using DimensionalQuantities.Units.Declarations; - namespace Independent.Units; - [UnitProvider(GenerateSiPrefixes = true, GeneratePrefixConversions = true)] - internal static class CustomUnits - { - [QuantityUnit(typeof(Voltage))] - [UnitFactor(typeof(Spark))] - private sealed class VoltageUnit; - [UnitSymbol("Spark", "Sparks", "sp")] - private sealed class Spark; - } - public static class Consumer - { - public static double[] Values() => [Voltage.FromMilliSparks(500).AsSiBaseUnit(), Voltage.FromSiBaseUnit(2000).AsKiloSparks(), - Voltage.FromPrefixedUnits(3, sparkPrefixExponent: 3).AsSiBaseUnit(), Voltage.FromSiBaseUnit(0.004).AsPrefixedUnits(-3)]; - } - """; - double[] result = EvaluateProvider(source, "", "Independent.Units.Consumer"); - Assert.Equal([0.5, 2, 3000, 4], result); - } - - [Fact] - public void CompoundFactorsPreserveOrderPowersAndAdditionalConversions() - { - const string source = """ - using DimensionalQuantities.Units.Declarations; - namespace Independent.Units; - [UnitProvider(GenerateSiPrefixes = true, GeneratePrefixConversions = true)] - internal static class CustomUnits - { - [QuantityUnit(typeof(CurrentDensity))] - [UnitFactor(typeof(Amp))] - [UnitFactor(typeof(Metre), Power = -2)] - [AdditionalUnit(typeof(PerSquareMillimetre))] - private sealed class CurrentDensityUnit; - [UnitFactor(typeof(Amp))] - [UnitFactor(typeof(Metre), Power = -2, PrefixExponent = -3)] - private sealed class PerSquareMillimetre; - [UnitSymbol("Amp", "Amps", "A")] - private sealed class Amp; - [UnitSymbol("Metre", "Metres", "m")] - private sealed class Metre; - } - public static class Consumer - { - public static double[] Values() => [CurrentDensity.FromAmpsPerSquareMilliMetre(1).AsSiBaseUnit(), - CurrentDensity.FromPrefixedUnits(2, ampPrefixExponent: 0, metrePrefixExponent: -3).AsSiBaseUnit(), - CurrentDensity.FromSiBaseUnit(1000000).AsAmpsPerSquareMilliMetre()]; - } - """; - double[] result = EvaluateProvider(source, "", "Independent.Units.Consumer"); - Assert.Equal([1000000d, 2000000d, 1d], result); - } - - [Fact] - public void ProviderUsesCoreSiSymbolsAcrossAssemblyBoundary() - { - const string source = """ - using DimensionalQuantities.Units.Declarations; - using DimensionalQuantities.Units.Symbols; - namespace Independent.Units; - [UnitProvider(GenerateSiPrefixes = true, GeneratePrefixConversions = true)] - internal static class CompoundUnits - { - [QuantityUnit(typeof(CurrentDensity))] - [UnitFactor(typeof(Amp))] - [UnitFactor(typeof(Metre), Power = -2)] - private sealed class CurrentDensityUnit; - [QuantityUnit(typeof(Density))] - [UnitFactor(typeof(Gram), PrefixExponent = 3)] - [UnitFactor(typeof(Metre), Power = -3)] - private sealed class DensityUnit; - } - public static class Consumer - { - public static double[] Values() => - [CurrentDensity.FromAmpsPerSquareMetre(2).AsSiBaseUnit(), - CurrentDensity.FromPrefixedUnits(2, ampPrefixExponent: 0, metrePrefixExponent: -3).AsSiBaseUnit(), - Density.FromGramsPerCubicMetre(2).AsSiBaseUnit(), - Density.FromPrefixedUnits(2, gramPrefixExponent: 0, metrePrefixExponent: 0).AsSiBaseUnit()]; - } - """; - Assert.Equal([2d, 2000000d, 0.002d, 0.002d], EvaluateProvider(source, "", "Independent.Units.Consumer")); - } - - [Fact] - public void OneUnitDeclarationCanServeDistinctQuantityTypes() - { - const string source = """ - using DimensionalQuantities.Units.Declarations; - namespace Independent.Units; - [UnitProvider] - internal static class CommonUnits - { - [QuantityUnit(typeof(Length))] - [QuantityUnit(typeof(Time))] - [UnitFactor(typeof(Token))] - private sealed class TokenUnit; - [UnitSymbol("Token", "Tokens", "token")] - private sealed class Token; - } - public static class Consumer - { - public static double[] Values() => - [Length.FromTokens(2).AsSiBaseUnit(), Time.FromTokens(3).AsSiBaseUnit()]; - } - """; - Assert.Equal([2d, 3d], EvaluateProvider(source, "", "Independent.Units.Consumer")); - } - - [Fact] - public void ProviderFactoriesCanBeUsedInArithmeticInTheirOwnAssembly() - { - const string consumer = """ - namespace Independent.Units; - public static class Consumer - { - public static double[] Values() => [(Length.FromFeet(2) * Length.FromFeet(3)).AsSiBaseUnit()]; - } - """; - double[] result = EvaluateProvider(FootProvider, consumer, "Independent.Units.Consumer"); - Assert.Equal(0.55741824, Assert.Single(result), 12); - } - - [Fact] - public void RecordClassProvidersGenerateConversions() - { - const string provider = """ - using DimensionalQuantities.Units.Declarations; - namespace Independent.Units; - [UnitProvider] - internal record class CustomUnits - { - [QuantityUnit(typeof(Length))] - [UnitFactor(typeof(Foot))] - private sealed class LengthUnit; - [UnitSymbol("Foot", "Feet", "ft", Scale = 0.3048)] - private sealed class Foot; - } - """; - const string consumer = """ - namespace Independent.Units; - public static class Consumer - { - public static double[] Values() => [Length.FromFeet(1).AsMetres()]; - } - """; - double[] result = EvaluateProvider(provider, consumer, "Independent.Units.Consumer"); - Assert.Equal(0.3048, Assert.Single(result), 12); - } - - [Fact] - public void ProvidersInSameNamespaceCanConvertSameQuantity() - { - const string source = """ - using DimensionalQuantities.Units.Declarations; - namespace Independent.Units; - [UnitProvider] - internal static class ImperialUnits - { - [QuantityUnit(typeof(Length))] - [UnitFactor(typeof(Foot))] - private sealed class LengthUnit; - [UnitSymbol("Foot", "Feet", "ft", Scale = 0.3048)] - private sealed class Foot; - } - [UnitProvider] - internal static class SurveyUnits - { - [QuantityUnit(typeof(Length))] - [UnitFactor(typeof(Yard))] - private sealed class LengthUnit; - [UnitSymbol("Yard", "Yards", "yd", Scale = 0.9144)] - private sealed class Yard; - } - public static class Consumer - { - public static double[] Values() => [Length.FromFeet(3).AsYards(), Length.FromYards(2).AsFeet()]; - } - """; - double[] result = EvaluateProvider(source, "", "Independent.Units.Consumer"); - Assert.Multiple( - () => Assert.Equal(1, result[0], 12), - () => Assert.Equal(6, result[1], 12)); - } - - private double[] EvaluateProvider(string provider, string consumer, string consumerType) - { - using PackageRepository repository = PackageRepository.Create(_scratch, new Uri("https://api.nuget.org/v3/index.json")); - Package core = PackCore(repository); - ProjectCreator project = CreateProject("ProviderConsumer", consumer, core); - File.WriteAllText(Path.Combine(_scratch, "ProviderConsumer", "Provider.cs"), provider); - Build(project); - string output = OutputDirectory("ProviderConsumer"); - using PackageAssemblyContext context = new(output); - Type type = context.LoadFromAssemblyPath(Path.Combine(output, "ProviderConsumer.dll")).GetType(consumerType, throwOnError: true)!; - return Assert.IsType(type.GetMethod("Values")!.Invoke(null, null)); - } -} diff --git a/src/DimensionalQuantities.IntegrationTests/Packaging/SymbolPackageTests.cs b/src/DimensionalQuantities.IntegrationTests/Packaging/SymbolPackageTests.cs deleted file mode 100644 index 03ce449..0000000 --- a/src/DimensionalQuantities.IntegrationTests/Packaging/SymbolPackageTests.cs +++ /dev/null @@ -1,173 +0,0 @@ -using System.Buffers.Binary; -using System.Diagnostics; -using System.Reflection; -using System.IO.Compression; -using System.Reflection.Metadata; -using System.Reflection.PortableExecutable; -using System.Text; -using System.Text.Json; -using Microsoft.Build.Locator; -using Xunit; - -namespace DimensionalQuantities.IntegrationTests.Packaging; - -[Collection("MSBuild")] -public sealed class SymbolPackageTests : IDisposable -{ - private static readonly Guid _sourceLinkKind = new("CC110556-A091-4D38-9FEC-25AB9A351A6A"); - private static readonly Guid _embeddedSourceKind = new("0E8A571B-6926-466E-B4AD-8AB04611F5FE"); - private readonly string _scratch = Directory.CreateTempSubdirectory("dimensional-quantities-symbols-").FullName; - - static SymbolPackageTests() - { - if (!MSBuildLocator.IsRegistered) - { - MSBuildLocator.RegisterDefaults(); - } - } - - [Fact] - public void CoreSymbolPackageMatchesRuntimeAndAnalyzerAssemblies() - { - (FileInfo package, FileInfo symbols) = Pack("DimensionalQuantities"); - using ZipArchive binaries = ZipFile.OpenRead(package.FullName); - using ZipArchive symbolArchive = ZipFile.OpenRead(symbols.FullName); - string commit = GetCurrentCommit(); - foreach (string stem in new[] - { - "lib/netstandard2.0/DimensionalQuantities", - "analyzers/dotnet/cs/DimensionalQuantities", - "analyzers/dotnet/cs/DimensionalQuantities.Roslyn", - "analyzers/dotnet/cs/DimensionalQuantities.Roslyn.CodeFixes", - }) - { - SymbolDetails details = ReadSymbolDetails(binaries, symbolArchive, stem); - Assert.Multiple( - () => Assert.Equal(details.AssemblyGuid, details.PdbGuid), - () => Assert.Equal(details.AssemblyStamp, details.PdbStamp), - () => Assert.Contains($"https://raw.githubusercontent.com/GoSimulate/DimensionalQuantities/{commit}/*", details.SourceUrls)); - } - } - - [Theory] - [InlineData("Metric")] - [InlineData("Imperial")] - [InlineData("Nautical")] - [InlineData("CgsEmag")] - public void ExtensionSymbolPackageMatchesAssemblyAndEmbedsGeneratedSource(string extension) - { - string projectName = "DimensionalQuantities.Extensions." + extension; - (FileInfo package, FileInfo symbols) = Pack(projectName); - using ZipArchive binaries = ZipFile.OpenRead(package.FullName); - using ZipArchive symbolArchive = ZipFile.OpenRead(symbols.FullName); - SymbolDetails details = ReadSymbolDetails(binaries, symbolArchive, "lib/netstandard2.0/" + projectName, - projectName + "." + extension + "Units.g.cs"); - string commit = GetCurrentCommit(); - string sourceDirectory = Path.GetFullPath(Path.Combine(AppContext.BaseDirectory, "..", "..", "..", "..")); - string configuration = typeof(SymbolPackageTests).Assembly.GetCustomAttribute()!.Configuration; - byte[] generatedSource = File.ReadAllBytes(Path.Combine(sourceDirectory, projectName, "obj", configuration, "netstandard2.0", - "generated", "DimensionalQuantities.Roslyn", "DimensionalQuantities.Roslyn.Generators.QuantityGenerator", projectName + "." + extension + "Units.g.cs")); - Assert.Multiple( - () => Assert.Equal(details.AssemblyGuid, details.PdbGuid), - () => Assert.Equal(details.AssemblyStamp, details.PdbStamp), - () => Assert.Contains($"https://raw.githubusercontent.com/GoSimulate/DimensionalQuantities/{commit}/*", details.SourceUrls), - () => Assert.Equal(generatedSource, details.EmbeddedGeneratedSource)); - } - - private (FileInfo Package, FileInfo Symbols) Pack(string projectName) - { - string sourceDirectory = Path.GetFullPath(Path.Combine(AppContext.BaseDirectory, "..", "..", "..", "..")); - FileInfo package = PackageTestSupport.PackLibrary(Path.Combine(sourceDirectory, projectName, projectName + ".csproj"), _scratch); - FileInfo symbols = new(Path.ChangeExtension(package.FullName, ".snupkg")); - if (!symbols.Exists) - { - throw new FileNotFoundException("Pack did not create the expected symbol package.", symbols.FullName); - } - return (package, symbols); - } - - private static SymbolDetails ReadSymbolDetails(ZipArchive binaries, ZipArchive symbols, string stem, string? generatedFileName = null) - { - byte[] assemblyBytes = ReadEntry(binaries, stem + ".dll"); - byte[] pdbBytes = ReadEntry(symbols, stem + ".pdb"); - using PEReader assembly = new(new MemoryStream(assemblyBytes)); - using MetadataReaderProvider pdb = MetadataReaderProvider.FromPortablePdbStream(new MemoryStream(pdbBytes)); - DebugDirectoryEntry codeView = assembly.ReadDebugDirectory().Single(entry => entry.Type == DebugDirectoryEntryType.CodeView); - CodeViewDebugDirectoryData codeViewData = assembly.ReadCodeViewDebugDirectoryData(codeView); - MetadataReader reader = pdb.GetMetadataReader(); - byte[] pdbId = reader.DebugMetadataHeader!.Id.ToArray(); - string sourceLink = reader.CustomDebugInformation - .Select(reader.GetCustomDebugInformation) - .Where(info => reader.GetGuid(info.Kind) == _sourceLinkKind) - .Select(info => Encoding.UTF8.GetString(reader.GetBlobBytes(info.Value))) - .Single(); - using JsonDocument sourceLinkDocument = JsonDocument.Parse(sourceLink); - string[] sourceUrls = sourceLinkDocument.RootElement.GetProperty("documents").EnumerateObject() - .Select(mapping => mapping.Value.GetString()!).ToArray(); - byte[]? embeddedGeneratedSource = reader.Documents - .Where(handle => generatedFileName is not null && reader.GetString(reader.GetDocument(handle).Name).EndsWith(generatedFileName, StringComparison.Ordinal)) - .SelectMany(handle => reader.GetCustomDebugInformation(handle)) - .Select(reader.GetCustomDebugInformation) - .Where(info => reader.GetGuid(info.Kind) == _embeddedSourceKind) - .Select(info => DecodeEmbeddedSource(reader.GetBlobBytes(info.Value))) - .SingleOrDefault(); - return new(codeViewData.Guid, codeView.Stamp, new Guid(pdbId.AsSpan(0, 16)), BitConverter.ToUInt32(pdbId, 16), sourceUrls, embeddedGeneratedSource); - } - - private static byte[] DecodeEmbeddedSource(byte[] blob) - { - if (blob.Length < sizeof(int)) - { - throw new InvalidDataException("Embedded source blob is too short."); - } - int uncompressedSize = BinaryPrimitives.ReadInt32LittleEndian(blob); - if (uncompressedSize == 0) - { - return blob[sizeof(int)..]; - } - if (uncompressedSize < 0) - { - throw new InvalidDataException("Embedded source has an invalid uncompressed size."); - } - using MemoryStream compressed = new(blob, sizeof(int), blob.Length - sizeof(int)); - using DeflateStream deflate = new(compressed, CompressionMode.Decompress); - using MemoryStream source = new(); - deflate.CopyTo(source); - byte[] bytes = source.ToArray(); - if (bytes.Length != uncompressedSize) - { - throw new InvalidDataException("Embedded source length does not match its header."); - } - return bytes; - } - - private static byte[] ReadEntry(ZipArchive archive, string path) - { - ZipArchiveEntry entry = archive.GetEntry(path) ?? throw new InvalidOperationException($"Package does not contain {path}."); - using Stream stream = entry.Open(); - using MemoryStream bytes = new(); - stream.CopyTo(bytes); - return bytes.ToArray(); - } - - private static string GetCurrentCommit() - { - string sourceDirectory = Path.GetFullPath(Path.Combine(AppContext.BaseDirectory, "..", "..", "..", "..", "..")); - ProcessStartInfo start = new("git") { WorkingDirectory = sourceDirectory, RedirectStandardOutput = true, RedirectStandardError = true }; - start.ArgumentList.Add("rev-parse"); - start.ArgumentList.Add("HEAD"); - using Process process = Process.Start(start) ?? throw new InvalidOperationException("Could not start git."); - string commit = process.StandardOutput.ReadToEnd().Trim(); - string error = process.StandardError.ReadToEnd(); - process.WaitForExit(); - if (process.ExitCode != 0) - { - throw new InvalidOperationException($"git rev-parse HEAD failed: {error}"); - } - return commit; - } - - private sealed record SymbolDetails(Guid AssemblyGuid, uint AssemblyStamp, Guid PdbGuid, uint PdbStamp, string[] SourceUrls, byte[]? EmbeddedGeneratedSource); - - public void Dispose() => Directory.Delete(_scratch, recursive: true); -} diff --git a/src/DimensionalQuantities.Roslyn.Tests/Analyzers/DimensionMismatchAnalyzerTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Analyzers/DimensionMismatchAnalyzerTests.cs deleted file mode 100644 index 210eaff..0000000 --- a/src/DimensionalQuantities.Roslyn.Tests/Analyzers/DimensionMismatchAnalyzerTests.cs +++ /dev/null @@ -1,133 +0,0 @@ -using DimensionalQuantities.Roslyn.Analyzers; -using Microsoft.CodeAnalysis; -using Microsoft.CodeAnalysis.Testing; -using Microsoft.CodeAnalysis.CSharp.Testing; -using DimensionalQuantities.Roslyn.Tests.Testing; -using Xunit; - -namespace DimensionalQuantities.Roslyn.Tests.Analyzers; - -public sealed class DimensionMismatchAnalyzerTests -{ - [Theory] - [InlineData("+")] - [InlineData("-")] - [InlineData("<")] - [InlineData(">")] - [InlineData("<=")] - [InlineData(">=")] - [InlineData("==")] - [InlineData("!=")] - public async Task IncompatibleOperandsExplainTheirDimensions(string operation) - { - string source = $$""" - public class Consumer - { - public object Calculate(Length length, Current current) => {|#0:length {{operation}} current|}; - } - """; - await new QuantityAnalyzerTest - { - TestCode = source, - CompilerDiagnostics = CompilerDiagnostics.None, - ExpectedDiagnostics = { new DiagnosticResult(DimensionMismatchAnalyzer.IncompatibleOperands).WithLocation(0).WithArguments(operation, "Length", "Current") }, - }.RunAsync(TestContext.Current.CancellationToken); - } - - [Theory] - [InlineData("public void Calculate(Length length) { Current current = {|#0:length|}; }")] - [InlineData("public void Calculate(Length length, Current current) { current = {|#0:length|}; }")] - [InlineData("public Current Calculate(Length length) => {|#0:length|};")] - [InlineData("public Current Calculate(Length length) { return {|#0:length|}; }")] - [InlineData("public void Calculate(Length length) { Accept({|#0:length|}); } private void Accept(Current current) { }")] - [InlineData("public void Calculate(Length length) { Accept(current: {|#0:length|}); } private void Accept(Current current) { }")] - [InlineData("public object Calculate(Length length, Current current) => Current.Min(current, {|#0:length|});")] - [InlineData("public object Calculate(Length length, Current current) => Current.Clamp(current, current, {|#0:length|});")] - [InlineData("public Current Value { get; } = {|#0:Length.FromMetres(1)|};")] - [InlineData("public Current Value => {|#0:Length.FromMetres(1)|};")] - [InlineData("public Current this[int index] => {|#0:Length.FromMetres(1)|};")] - [InlineData("public Consumer(Current current) { } public object Calculate(Length length) => new Consumer({|#0:length|});")] - public async Task WrongDestinationExplainsExpectedAndActualDimensions(string member) - { - string source = $"public class Consumer {{ {member} }}"; - await new QuantityAnalyzerTest - { - TestCode = source, - CompilerDiagnostics = CompilerDiagnostics.None, - ExpectedDiagnostics = { new DiagnosticResult(DimensionMismatchAnalyzer.WrongDestination).WithLocation(0).WithArguments("Current", "Length") }, - }.RunAsync(TestContext.Current.CancellationToken); - } - - [Theory] - [InlineData("public object Calculate(Length length, Length other) => length + other;")] - [InlineData("public object Calculate(Length length, Current current) => length * current;")] - [InlineData("public object Calculate(Length length, Current current) => length / current;")] - [InlineData("public object Calculate(Energy energy, Torque torque) => energy + torque;")] - [InlineData("public Current? Calculate() => null;")] - [InlineData("public Current Calculate() => default;")] - [InlineData("public object Calculate(Length length) => length;")] - [InlineData("public object Calculate(Length length) => length + missing;")] - [InlineData("public void Calculate(Length length) { Accept(length); } private void Accept(Length value) { } private void Accept(Current value) { }")] - public async Task ValidOrUnrelatedCodeDoesNotProduceDiagnostics(string member) - { - string source = $"public class Consumer {{ {member} }}"; - await new QuantityAnalyzerTest - { - TestCode = source, - CompilerDiagnostics = CompilerDiagnostics.None, - }.RunAsync(TestContext.Current.CancellationToken); - } - - [Theory] - [InlineData("+=")] - [InlineData("-=")] - public async Task CompoundAssignmentsExplainIncompatibleDimensions(string operation) - { - string source = $"public class Consumer {{ public void Calculate(Length length, Current current) {{ {{|#0:length {operation} current|}}; }} }}"; - await new QuantityAnalyzerTest - { - TestCode = source, - CompilerDiagnostics = CompilerDiagnostics.None, - ExpectedDiagnostics = { new DiagnosticResult(DimensionMismatchAnalyzer.IncompatibleOperands).WithLocation(0).WithArguments(operation, "Length", "Current") }, - }.RunAsync(TestContext.Current.CancellationToken); - } - - [Fact] - public async Task NullableOperandsStillExplainDimensions() - { - const string source = "public class Consumer { public object Calculate(Length? length, Current? current) => {|#0:length + current|}; }"; - await new QuantityAnalyzerTest - { - TestCode = source, - CompilerDiagnostics = CompilerDiagnostics.None, - ExpectedDiagnostics = { new DiagnosticResult(DimensionMismatchAnalyzer.IncompatibleOperands).WithLocation(0).WithArguments("+", "Length", "Current") }, - }.RunAsync(TestContext.Current.CancellationToken); - } - - [Fact] - public async Task ExistingUserOperatorIsRespected() - { - const string source = """ - public static class Custom - { - extension(Length) - { - public static double operator +(Length length, Current current) => 1; - } - } - public class Consumer { public double Calculate(Length length, Current current) => length + current; } - """; - await new QuantityAnalyzerTest - { - TestCode = source, - CompilerDiagnostics = CompilerDiagnostics.None, - }.RunAsync(TestContext.Current.CancellationToken); - } - - [Fact] - public async Task UnrelatedCompilationWithoutLibraryDoesNotCrash() - { - await new CSharpAnalyzerTest { TestCode = "class Consumer { }" } - .RunAsync(TestContext.Current.CancellationToken); - } -} diff --git a/src/DimensionalQuantities.Roslyn.Tests/Analyzers/QuantityEncodingAnalyzerTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Analyzers/QuantityEncodingAnalyzerTests.cs deleted file mode 100644 index ba3bf9d..0000000 --- a/src/DimensionalQuantities.Roslyn.Tests/Analyzers/QuantityEncodingAnalyzerTests.cs +++ /dev/null @@ -1,83 +0,0 @@ -using DimensionalQuantities.Roslyn.Analyzers; -using Microsoft.CodeAnalysis; -using Microsoft.CodeAnalysis.Testing; -using DimensionalQuantities.Roslyn.Tests.Testing; -using Xunit; - -namespace DimensionalQuantities.Roslyn.Tests.Analyzers; - -public sealed class QuantityEncodingAnalyzerTests -{ - private const string LengthType = "Quantity>"; - - [Fact] - public async Task RawQuantitySuggestsReadableAlias() - { - string source = $"using DimensionalQuantities.TypeSystem; public class Consumer {{ public {{|#0:{LengthType}|}} Value {{ get; }} }}"; - await new QuantityAnalyzerTest - { - TestCode = source, - ExpectedDiagnostics = { new DiagnosticResult(QuantityEncodingAnalyzer.ReadableAlias).WithLocation(0).WithArguments("Length") }, - }.RunAsync(TestContext.Current.CancellationToken); - } - - [Theory] - [InlineData("global::DimensionalQuantities.TypeSystem.Fraction")] - [InlineData("global::DimensionalQuantities.TypeSystem.Fraction")] - public async Task NonCanonicalEncodingExplainsDistinctTypeIdentity(string exponent) - { - string type = $"global::DimensionalQuantities.TypeSystem.Quantity>"; - string markedType = type.Replace("Quantity<", "{|#0:Quantity<") + "|}"; - string source = $"using MyLength = {markedType}; public class Consumer {{ }}"; - await new QuantityAnalyzerTest - { - TestCode = source, - ExpectedDiagnostics = { new DiagnosticResult(QuantityEncodingAnalyzer.NonCanonical).WithLocation(0) }, - }.RunAsync(TestContext.Current.CancellationToken); - } - - [Theory] - [InlineData("Quantity")] - [InlineData("Quantity, TerminalHex0, TerminalHex0, TerminalHex0, TerminalHex0, TerminalHex0, TerminalHex0>>")] - [InlineData("Quantity, TerminalHex0, TerminalHex0, TerminalHex0, TerminalHex0, TerminalHex0, TerminalHex0>>")] - public async Task InvalidClosedEncodingIsDiagnosedWithoutAnalyzerCrash(string type) - { - string source = $"using DimensionalQuantities.TypeSystem; public class Consumer {{ public {{|#0:{type}|}} Value {{ get; }} }}"; - await new QuantityAnalyzerTest - { - TestCode = source, - Generate = false, - CompilerDiagnostics = CompilerDiagnostics.None, - ExpectedDiagnostics = { new DiagnosticResult(QuantityEncodingAnalyzer.Invalid).WithLocation(0) }, - }.RunAsync(TestContext.Current.CancellationToken); - } - - [Theory] - [InlineData("Quantity")] - [InlineData("Power")] - public async Task UnresolvedArgumentsDoNotProduceEncodingDiagnostics(string type) - { - string source = $"using DimensionalQuantities.TypeSystem; public class Consumer {{ public {type} Value {{ get; }} }}"; - await new QuantityAnalyzerTest - { - TestCode = source, - Generate = false, - CompilerDiagnostics = CompilerDiagnostics.None, - }.RunAsync(TestContext.Current.CancellationToken); - } - - [Theory] - [InlineData("using MyLength = DimensionalQuantities.TypeSystem.Quantity>; public class Consumer { public MyLength Value { get; } }")] - [InlineData("public class Consumer { public Length Value { get; } }")] - [InlineData("using DimensionalQuantities.TypeSystem; public class Consumer { public Quantity Value { get; } }")] - [InlineData("public class Quantity { } public class Consumer { public Quantity Value { get; } }")] - public async Task DeliberateAliasesOpenGenericsAndUnrelatedTypesAreAllowed(string source) - { - await new QuantityAnalyzerTest - { - TestCode = source, - }.RunAsync(TestContext.Current.CancellationToken); - } -} diff --git a/src/DimensionalQuantities.Roslyn.Tests/CodeFixes/QuantityAliasCodeFixProviderTests.cs b/src/DimensionalQuantities.Roslyn.Tests/CodeFixes/QuantityAliasCodeFixProviderTests.cs deleted file mode 100644 index 4c1f9cb..0000000 --- a/src/DimensionalQuantities.Roslyn.Tests/CodeFixes/QuantityAliasCodeFixProviderTests.cs +++ /dev/null @@ -1,78 +0,0 @@ -using DimensionalQuantities.Roslyn.Analyzers; -using DimensionalQuantities.Roslyn.Tests.Testing; -using Microsoft.CodeAnalysis.Testing; -using Xunit; - -namespace DimensionalQuantities.Roslyn.Tests.CodeFixes; - -public sealed class QuantityAliasCodeFixProviderTests -{ - private const string LengthType = "global::DimensionalQuantities.TypeSystem.Quantity>"; - - private const string LengthCurrentType = "global::DimensionalQuantities.TypeSystem.Quantity>"; - - [Theory] - [InlineData("public class Consumer { public TYPE Value { get; } }", "public class Consumer { public Length Value { get; } }")] - [InlineData("public class Consumer { public TYPE? Value { get; } }", "public class Consumer { public Length? Value { get; } }")] - [InlineData("public class Consumer { public /* measurement */ TYPE Value { get; } }", "public class Consumer { public /* measurement */ Length Value { get; } }")] - [InlineData("public class Consumer { public TYPE Value { get; } }", "public class Consumer { public LengthCurrent Value { get; } }", LengthCurrentType)] - public async Task FixUsesAliasAndPreservesSurroundingSource(string template, string expected, string? rawType = null) - { - string marked = template.Replace("TYPE", (rawType ?? LengthType).Replace("Quantity<", "{|#0:Quantity<") + "|}"); - await new QuantityCodeFixTest - { - TestCode = marked, - FixedCode = expected, - ExpectedDiagnostics = { new DiagnosticResult(QuantityEncodingAnalyzer.ReadableAlias).WithLocation(0).WithArguments(rawType is null ? "Length" : "LengthCurrent") }, - }.RunAsync(TestContext.Current.CancellationToken); - } - - [Fact] - public async Task NameOfDoesNotOfferFixThatChangesTheReturnedName() - { - string source = $"public class Consumer {{ public string Value() => nameof({LengthType}); }}"; - string marked = source.Replace(LengthType, LengthType.Replace("Quantity<", "{|#0:Quantity<") + "|}"); - await new QuantityCodeFixTest - { - TestCode = marked, - FixedCode = source, - FixedState = - { - ExpectedDiagnostics = - { - new DiagnosticResult(QuantityEncodingAnalyzer.ReadableAlias) - .WithSpan(1, source.IndexOf("Quantity<", StringComparison.Ordinal) + 1, - 1, source.IndexOf(LengthType, StringComparison.Ordinal) + LengthType.Length + 1).WithArguments("Length"), - }, - }, - ExpectedDiagnostics = { new DiagnosticResult(QuantityEncodingAnalyzer.ReadableAlias).WithLocation(0).WithArguments("Length") }, - }.RunAsync(TestContext.Current.CancellationToken); - } - - [Fact] - public async Task ShadowedAliasDoesNotOfferUnsafeFix() - { - string source = $"namespace ConsumerNamespace {{ public class Length {{ }} public class Consumer {{ public {LengthType} Value {{ get; }} }} }}"; - string marked = source.Replace(LengthType, LengthType.Replace("Quantity<", "{|#0:Quantity<") + "|}"); - await new QuantityCodeFixTest - { - TestCode = marked, - FixedCode = source, - FixedState = - { - ExpectedDiagnostics = - { - new DiagnosticResult(QuantityEncodingAnalyzer.ReadableAlias) - .WithSpan(1, source.IndexOf("Quantity<", StringComparison.Ordinal) + 1, - 1, source.IndexOf(LengthType, StringComparison.Ordinal) + LengthType.Length + 1).WithArguments("Length"), - }, - }, - ExpectedDiagnostics = { new DiagnosticResult(QuantityEncodingAnalyzer.ReadableAlias).WithLocation(0).WithArguments("Length") }, - }.RunAsync(TestContext.Current.CancellationToken); - } - -} diff --git a/src/DimensionalQuantities.Roslyn.Tests/DimensionalQuantities.Roslyn.Tests.csproj b/src/DimensionalQuantities.Roslyn.Tests/DimensionalQuantities.Roslyn.Tests.csproj deleted file mode 100644 index 16b7df2..0000000 --- a/src/DimensionalQuantities.Roslyn.Tests/DimensionalQuantities.Roslyn.Tests.csproj +++ /dev/null @@ -1,26 +0,0 @@ - - - net11.0 - false - true - Exe - true - - - - - - - - - - - - - - - - - - - diff --git a/src/DimensionalQuantities.Roslyn.Tests/Discovery/ArithmeticDiscoveryTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Discovery/ArithmeticDiscoveryTests.cs deleted file mode 100644 index 4d2d94a..0000000 --- a/src/DimensionalQuantities.Roslyn.Tests/Discovery/ArithmeticDiscoveryTests.cs +++ /dev/null @@ -1,183 +0,0 @@ -using System.Collections.Immutable; -using DimensionalQuantities.Dimensions; -using DimensionalQuantities.Roslyn.Discovery; -using DimensionalQuantities.Roslyn.Generators; -using Microsoft.CodeAnalysis; -using Microsoft.CodeAnalysis.CSharp; -using Microsoft.CodeAnalysis.CSharp.Syntax; -using Xunit; - -namespace DimensionalQuantities.Roslyn.Tests.Discovery; - -public sealed class ArithmeticDiscoveryTests -{ - private static readonly CSharpParseOptions _parseOptions = new(LanguageVersion.Preview); - - [Theory] - [InlineData("length * time", true)] - [InlineData("length / time", false)] - public void ReadsBoundQuantityOperands(string expression, bool multiply) - { - ArithmeticOperation operation = Assert.Single(Discover(expression)); - Dimension left = new(Length: 1); - Dimension right = new(Time: 1); - Assert.Equal(new(multiply ? ArithmeticOperationKind.Multiply : ArithmeticOperationKind.Divide, - left, right, multiply ? left * right : left / right), operation); - } - - [Theory] - [InlineData("length * time", true)] - [InlineData("length / time", false)] - public void ReadsNullableQuantityOperands(string expression, bool multiply) - { - string source = $$""" - public static class Consumer - { - public static object Value(Length? length, Time? time) => {{expression}}; - } - """; - ArithmeticOperation operation = Assert.Single(DiscoverFromSource(source)); - Dimension left = new(Length: 1); - Dimension right = new(Time: 1); - Assert.Equal(new(multiply ? ArithmeticOperationKind.Multiply : ArithmeticOperationKind.Divide, - left, right, multiply ? left * right : left / right), operation); - } - - [Fact] - public void NullableQuantityDivisorRequestsTheInverseDimension() - { - const string source = """ - public static class Consumer - { - public static object Value(Length? length) => 2d / length; - } - """; - ArithmeticOperation operation = Assert.Single(DiscoverFromSource(source)); - Assert.Equal(new(ArithmeticOperationKind.ScalarDivide, default, new(Length: 1), new(Length: -1)), operation); - } - - [Theory] - [InlineData("double?", "Time")] - [InlineData("double?", "Time?")] - [InlineData("float?", "Time")] - [InlineData("float?", "Time?")] - [InlineData("int?", "Time")] - [InlineData("int?", "Time?")] - public void NullableNumericScalarDivisionRequestsTheInverseDimension(string scalarType, string quantityType) - { - string source = $$""" - public static class Consumer - { - public static object Value({{scalarType}} scalar, {{quantityType}} time) => scalar / time; - } - """; - ArithmeticOperation operation = Assert.Single(DiscoverFromSource(source)); - Assert.Equal(new(ArithmeticOperationKind.ScalarDivide, default, new(Time: 1), new(Time: -1)), operation); - } - - [Theory] - [InlineData("length * missing")] - [InlineData("length * 1m")] - [InlineData("length * \"text\"")] - [InlineData("length + time")] - [InlineData("length * scalar")] - public void RejectsUnsupportedOperands(string expression) - { - Assert.Empty(Discover(expression)); - } - - [Fact] - public void ExistingBoundOperatorControlsTheResult() - { - const string source = """ - public static class Custom - { - extension(Length) - { - public static double operator *(Length length, Time time) => 7; - } - } - public static class Consumer - { - public static object Value(Length length, Time time) => length * time; - } - """; - Assert.Empty(DiscoverFromSource(source)); - } - - [Fact] - public void ScalarDivisionRequestsTheInverseDimension() - { - const string source = """ - public static class Consumer - { - public static object Value(Length length) => 2d / length; - } - """; - ArithmeticOperation operation = Assert.Single(DiscoverFromSource(source)); - Assert.Equal(new(ArithmeticOperationKind.ScalarDivide, default, new(Length: 1), new(Length: -1)), operation); - } - - [Fact] - public void DecimalDoesNotBecomeAnImplicitDoubleScalar() - { - const string source = """ - public static class Consumer - { - public static object Value(Length length) => 2m / length; - } - """; - Assert.Empty(DiscoverFromSource(source)); - } - - [Fact] - public void NullableDecimalDoesNotBecomeAnImplicitDoubleScalar() - { - const string source = """ - public static class Consumer - { - public static object Value(decimal? scalar, Time? time) => scalar / time; - } - """; - Assert.Empty(DiscoverFromSource(source)); - } - - private static ImmutableArray Discover(string expression) - { - string source = $$""" - using DimensionalQuantities.TypeSystem; - public static class Consumer - { - public static object Value(Length length, Time time, - Quantity> scalar) - => {{expression}}; - } - """; - return DiscoverFromSource(source); - } - - private static ImmutableArray DiscoverFromSource(string source) - { - SyntaxTree tree = CSharpSyntaxTree.ParseText(source, _parseOptions); - QuantityGenerationPlan defaults = DefaultQuantityDiscovery.Discover(); - string defaultSource = QuantitySourceEmitter.Emit([.. defaults.KnownQuantities, .. defaults.AdditionalQuantities]); - SyntaxTree defaultsTree = CSharpSyntaxTree.ParseText(defaultSource, _parseOptions); - MetadataReference[] references = [MetadataReference.CreateFromFile(typeof(object).Assembly.Location), - MetadataReference.CreateFromFile(typeof(Enumerable).Assembly.Location), - MetadataReference.CreateFromFile(typeof(DimensionalQuantities.TypeSystem.Quantity<>).Assembly.Location)]; - CSharpCompilation compilation = CSharpCompilation.Create("ArithmeticDiscoveryTests", [tree, defaultsTree], references, - new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)); - SemanticModel model = compilation.GetSemanticModel(tree); - QuantityTypeReader reader = new(compilation); - ImmutableArray.Builder operations = ImmutableArray.CreateBuilder(); - foreach (BinaryExpressionSyntax binary in tree.GetRoot().DescendantNodes().OfType()) - { - if (ArithmeticDiscovery.TryRead(binary, model, reader, out ArithmeticOperation operation, TestContext.Current.CancellationToken)) - { - operations.Add(operation); - } - } - - return operations.ToImmutable(); - } -} diff --git a/src/DimensionalQuantities.Roslyn.Tests/Discovery/DiscoverySeedCollectorTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Discovery/DiscoverySeedCollectorTests.cs deleted file mode 100644 index 2c50818..0000000 --- a/src/DimensionalQuantities.Roslyn.Tests/Discovery/DiscoverySeedCollectorTests.cs +++ /dev/null @@ -1,33 +0,0 @@ -using System.Collections.Immutable; -using DimensionalQuantities.Dimensions; -using DimensionalQuantities.Roslyn.Discovery; -using DimensionalQuantities.TypeSystem; -using Microsoft.CodeAnalysis; -using Microsoft.CodeAnalysis.CSharp; -using Xunit; - -namespace DimensionalQuantities.Roslyn.Tests.Discovery; - -public sealed class DiscoverySeedCollectorTests -{ - [Fact] - public void RawQuantityDeclarationRequestsItsDimension() - { - const string source = """ - using DimensionalQuantities.TypeSystem; - public class Consumer - { - public Quantity> Value { get; } - } - """; - SyntaxTree tree = CSharpSyntaxTree.ParseText(source, new CSharpParseOptions(LanguageVersion.Preview), cancellationToken: TestContext.Current.CancellationToken); - string[] assemblies = ((string)AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES")!).Split(Path.PathSeparator); - IEnumerable references = assemblies.Select(path => MetadataReference.CreateFromFile(path)) - .Append(MetadataReference.CreateFromFile(typeof(Quantity<>).Assembly.Location)); - CSharpCompilation compilation = CSharpCompilation.Create("Consumer", [tree], references, new(OutputKind.DynamicallyLinkedLibrary)); - ImmutableArray result = DiscoverySeedCollector.FindRequestedDimensions(compilation, [tree], TestContext.Current.CancellationToken); - Dimension expected = new(Length: 1, ElectricCurrent: 1); - - Assert.Equal(expected, Assert.Single(result)); - } -} diff --git a/src/DimensionalQuantities.Roslyn.Tests/Discovery/EnglishExponentDiscoveryTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Discovery/EnglishExponentDiscoveryTests.cs deleted file mode 100644 index 4c6ef49..0000000 --- a/src/DimensionalQuantities.Roslyn.Tests/Discovery/EnglishExponentDiscoveryTests.cs +++ /dev/null @@ -1,99 +0,0 @@ -using DimensionalQuantities.Numerics; -using DimensionalQuantities.Roslyn.Discovery; -using DimensionalQuantities.TypeSystem; -using Microsoft.CodeAnalysis; -using Microsoft.CodeAnalysis.CSharp; -using Microsoft.CodeAnalysis.CSharp.Syntax; -using Xunit; - -namespace DimensionalQuantities.Roslyn.Tests.Discovery; - -public sealed class EnglishExponentDiscoveryTests -{ - [Theory] - [InlineData("NumberTwo", 2, 1)] - [InlineData("NumberHalf", 1, 2)] - [InlineData("NumberTwoQuarters", 1, 2)] - [InlineData("NumberMinusThreeOverTwo", -3, 2)] - [InlineData("NumberMillionth", 1, 1000000)] - public void DiscoversOnlyTheRequestedEnglishName(string name, int numerator, int denominator) - { - string source = $$""" - using DimensionalQuantities.TypeSystem; - class Consumer { object Value(object quantity) => Power<{{name}}>.Of(quantity); } - """; - CSharpCompilation compilation = Compile(source); - SyntaxTree tree = compilation.SyntaxTrees.Single(); - InvocationExpressionSyntax invocation = tree.GetRoot(TestContext.Current.CancellationToken).DescendantNodes().OfType().Single(); - EnglishExponentDiscovery discovery = new(compilation.GetSemanticModel(tree)); - - bool success = discovery.TryRead(invocation, out EnglishExponentAlias result, TestContext.Current.CancellationToken); - Rational expected = new(numerator, denominator); - - Assert.Multiple( - () => Assert.True(success), - () => Assert.Equal(name, result.Name), - () => Assert.Equal(expected, result.Value)); - } - - [Theory] - [InlineData("Power.Of(quantity)", "")] - [InlineData("Power.Of(quantity)", "")] - [InlineData("Power.Of(quantity)", "")] - [InlineData("Power.Of(quantity)", "")] - [InlineData("Power.Of(quantity)", "")] - [InlineData("Power.Of(quantity)", "")] - [InlineData("Power>.Of(quantity)", "")] - [InlineData("Power.Of(quantity)", "struct NumberTwo { }")] - [InlineData("Power.Of(quantity)", "using NumberTwo = DimensionalQuantities.TypeSystem.TerminalHex3;")] - [InlineData("Power.Of(quantity)", "")] - [InlineData("Other.Power.Of(quantity)", "namespace Other { struct Power { } }")] - [InlineData("Power.Other(quantity)", "")] - [InlineData("Power.Of(quantity, quantity)", "")] - public void IgnoresNamesThatShouldNotBecomeGeneratedAliases(string expression, string declarations) - { - string source = $$""" - using DimensionalQuantities.TypeSystem; - {{declarations}} - class Consumer { object Value(object quantity) => {{expression}}; } - """; - CSharpCompilation compilation = Compile(source); - SyntaxTree tree = compilation.SyntaxTrees.Single(); - InvocationExpressionSyntax invocation = tree.GetRoot(TestContext.Current.CancellationToken).DescendantNodes().OfType().Single(); - EnglishExponentDiscovery discovery = new(compilation.GetSemanticModel(tree)); - - bool result = discovery.TryRead(invocation, out _, TestContext.Current.CancellationToken); - - Assert.False(result); - } - - [Fact] - public void DoesNotReplaceAnAmbiguousExistingType() - { - const string source = """ - using DimensionalQuantities.TypeSystem; - using First; - using Second; - namespace First { public struct NumberTwo { } } - namespace Second { public struct NumberTwo { } } - class Consumer { object Value(object quantity) => Power.Of(quantity); } - """; - CSharpCompilation compilation = Compile(source); - SyntaxTree tree = compilation.SyntaxTrees.Single(); - InvocationExpressionSyntax invocation = tree.GetRoot(TestContext.Current.CancellationToken).DescendantNodes().OfType().Single(); - EnglishExponentDiscovery discovery = new(compilation.GetSemanticModel(tree)); - - bool result = discovery.TryRead(invocation, out _, TestContext.Current.CancellationToken); - - Assert.False(result); - } - - private static CSharpCompilation Compile(string source) - { - string[] assemblies = ((string)AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES")!).Split(Path.PathSeparator); - IEnumerable references = assemblies.Select(path => MetadataReference.CreateFromFile(path)) - .Append(MetadataReference.CreateFromFile(typeof(Quantity<>).Assembly.Location)); - return CSharpCompilation.Create("EnglishExponentConsumer", [CSharpSyntaxTree.ParseText(source, new CSharpParseOptions(LanguageVersion.Preview))], - references, new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)); - } -} diff --git a/src/DimensionalQuantities.Roslyn.Tests/Discovery/MetadataQuantityDiscoveryTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Discovery/MetadataQuantityDiscoveryTests.cs deleted file mode 100644 index b49900f..0000000 --- a/src/DimensionalQuantities.Roslyn.Tests/Discovery/MetadataQuantityDiscoveryTests.cs +++ /dev/null @@ -1,88 +0,0 @@ -using System.Collections.Immutable; -using DimensionalQuantities.Dimensions; -using DimensionalQuantities.Roslyn.Discovery; -using DimensionalQuantities.TypeSystem; -using Microsoft.CodeAnalysis; -using Microsoft.CodeAnalysis.CSharp; -using Microsoft.CodeAnalysis.CSharp.Syntax; -using Microsoft.CodeAnalysis.Emit; -using Xunit; - -namespace DimensionalQuantities.Roslyn.Tests.Discovery; - -public sealed class MetadataQuantityDiscoveryTests -{ - [Theory] - [InlineData("Library.Create()")] - [InlineData("Library.Field")] - [InlineData("Library.Property")] - [InlineData("Library.Values()")] - [InlineData("Library.Values()[0]")] - [InlineData("Library.Pair()")] - public void DiscoversQuantityTypesInReferencedResultsAndCollections(string expression) - { - CSharpCompilation compilation = CompileConsumer(expression); - SyntaxTree tree = compilation.SyntaxTrees.Single(); - ExpressionSyntax value = tree.GetRoot(TestContext.Current.CancellationToken).DescendantNodes().OfType().Single().Expression; - MetadataQuantityDiscovery discovery = new(compilation.GetSemanticModel(tree)); - - ImmutableArray result = discovery.Discover(value, TestContext.Current.CancellationToken); - Dimension expected = new(Length: 1, ElectricCurrent: 1); - - Assert.Equal(expected, Assert.Single(result)); - } - - [Theory] - [InlineData("Library.Other()")] - [InlineData("Library.Missing()")] - [InlineData("Library.Zero()")] - public void IgnoresUnrelatedUnresolvedAndDimensionlessTypes(string expression) - { - CSharpCompilation compilation = CompileConsumer(expression); - SyntaxTree tree = compilation.SyntaxTrees.Single(); - ExpressionSyntax value = tree.GetRoot(TestContext.Current.CancellationToken).DescendantNodes().OfType().Single().Expression; - MetadataQuantityDiscovery discovery = new(compilation.GetSemanticModel(tree)); - - ImmutableArray result = discovery.Discover(value, TestContext.Current.CancellationToken); - - Assert.Empty(result); - } - - private static CSharpCompilation CompileConsumer(string expression) - { - const string librarySource = """ - using DimensionalQuantities.TypeSystem; - using Q = DimensionalQuantities.TypeSystem.Quantity>; - public static class Library - { - public static Q Create() => default; - public static Q Field; - public static Q Property => default; - public static System.Collections.Generic.List Values() => new(); - public static (Q, Q) Pair() => default; - public static string Other() => "text"; - public static Quantity> Zero() => default; - } - """; - string[] platformAssemblies = ((string)AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES")!).Split(Path.PathSeparator); - MetadataReference[] references = platformAssemblies.Select(path => MetadataReference.CreateFromFile(path)) - .Append(MetadataReference.CreateFromFile(typeof(Quantity<>).Assembly.Location)).ToArray(); - CSharpParseOptions options = new(LanguageVersion.Preview); - CSharpCompilation library = CSharpCompilation.Create("MetadataLibrary", [CSharpSyntaxTree.ParseText(librarySource, options)], references, - new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)); - using MemoryStream stream = new(); - EmitResult emitted = library.Emit(stream, cancellationToken: TestContext.Current.CancellationToken); - if (!emitted.Success) - { - throw new InvalidOperationException(string.Join(Environment.NewLine, emitted.Diagnostics)); - } - - return CSharpCompilation.Create("MetadataConsumer", - [CSharpSyntaxTree.ParseText($"public class Consumer {{ public object Value() => {expression}; }}", options)], - [.. references, MetadataReference.CreateFromImage(stream.ToArray())], new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)); - } -} diff --git a/src/DimensionalQuantities.Roslyn.Tests/Discovery/PowerDiscoveryTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Discovery/PowerDiscoveryTests.cs deleted file mode 100644 index 83fa21c..0000000 --- a/src/DimensionalQuantities.Roslyn.Tests/Discovery/PowerDiscoveryTests.cs +++ /dev/null @@ -1,108 +0,0 @@ -using DimensionalQuantities.Numerics; -using DimensionalQuantities.Roslyn.Discovery; -using DimensionalQuantities.TypeSystem; -using Microsoft.CodeAnalysis; -using Microsoft.CodeAnalysis.CSharp; -using Microsoft.CodeAnalysis.CSharp.Syntax; -using Xunit; - -namespace DimensionalQuantities.Roslyn.Tests.Discovery; - -public sealed class PowerDiscoveryTests -{ - [Fact] - public void MissingRuntimeReferenceThrowsWithTheRequiredTypeName() - { - SyntaxTree tree = CSharpSyntaxTree.ParseText("class Consumer { }", cancellationToken: TestContext.Current.CancellationToken); - CSharpCompilation compilation = CSharpCompilation.Create("MissingRuntimeConsumer", [tree]); - SemanticModel model = compilation.GetSemanticModel(tree); - - InvalidOperationException result = Assert.Throws(() => new PowerDiscovery(model)); - - Assert.Contains(typeof(Power<>).FullName!, result.Message); - } - - [Theory] - [InlineData("Power>", "", "global::DimensionalQuantities.TypeSystem.Fraction")] - [InlineData("Power", "using Half = DimensionalQuantities.TypeSystem.Fraction;", "global::DimensionalQuantities.TypeSystem.Fraction")] - [InlineData("Root", "using Root = DimensionalQuantities.TypeSystem.Power>;", "global::DimensionalQuantities.TypeSystem.Fraction")] - public void ReadsTheExponentWithoutChangingItsDeclaredType(string powerTypeName, string alias, string expectedExponentTypeName) - { - string source = $$""" - using DimensionalQuantities.TypeSystem; - {{alias}} - public class Consumer { public object Value(object quantity) => {{powerTypeName}}.Of(quantity); } - """; - CSharpCompilation compilation = Compile(source); - SyntaxTree tree = compilation.SyntaxTrees.Single(); - InvocationExpressionSyntax invocation = tree.GetRoot(TestContext.Current.CancellationToken).DescendantNodes().OfType().Single(); - PowerDiscovery discovery = new(compilation.GetSemanticModel(tree)); - bool read = discovery.TryRead(invocation, out Rational result, out string exponentTypeName, TestContext.Current.CancellationToken); - Rational expected = new(1, 2); - - Assert.Multiple( - () => Assert.True(read), - () => Assert.Equal(expected, result), - () => Assert.Equal(expectedExponentTypeName, exponentTypeName)); - } - - [Theory] - [InlineData("NumberTwo", 2, 1, "global::DimensionalQuantities.TypeSystem.TerminalHex2")] - [InlineData("NumberHalf", 1, 2, "global::DimensionalQuantities.TypeSystem.Fraction")] - [InlineData("NumberTwoQuarters", 1, 2, "global::DimensionalQuantities.TypeSystem.Fraction")] - [InlineData("NumberMinusTwo", -2, 1, "global::DimensionalQuantities.TypeSystem.Negative")] - public void ReadsUnresolvedEnglishExponentNames(string name, int numerator, int denominator, string expectedTypeName) - { - string source = $$""" - using DimensionalQuantities.TypeSystem; - public class Consumer { public object Value(object quantity) => Power<{{name}}>.Of(quantity); } - """; - CSharpCompilation compilation = Compile(source); - SyntaxTree tree = compilation.SyntaxTrees.Single(); - InvocationExpressionSyntax invocation = tree.GetRoot(TestContext.Current.CancellationToken).DescendantNodes().OfType().Single(); - PowerDiscovery discovery = new(compilation.GetSemanticModel(tree)); - - bool read = discovery.TryRead(invocation, out Rational result, out string typeName, TestContext.Current.CancellationToken); - Rational expected = new(numerator, denominator); - - Assert.Multiple( - () => Assert.True(read), - () => Assert.Equal(expected, result), - () => Assert.Equal(expectedTypeName, typeName)); - } - - [Theory] - [InlineData("Other.Power.Of(quantity)")] - [InlineData("Power.Of(quantity)")] - [InlineData("Power.Of(quantity)")] - [InlineData("Power.Of(quantity)")] - [InlineData("Power.Of(quantity)")] - [InlineData("Power.Other(quantity)")] - [InlineData("Power.Of(quantity, quantity)")] - [InlineData("Power.Of()")] - public void RejectsUnrelatedAndUnsupportedCalls(string expression) - { - string source = $$""" - using DimensionalQuantities.TypeSystem; - public struct NumberThree { } - namespace Other { public struct Power { public static object Of(object value) => value; } } - public class Consumer { public object Value(object quantity) => {{expression}}; } - """; - CSharpCompilation compilation = Compile(source); - SyntaxTree tree = compilation.SyntaxTrees.Single(); - InvocationExpressionSyntax invocation = tree.GetRoot(TestContext.Current.CancellationToken).DescendantNodes().OfType().Single(); - PowerDiscovery discovery = new(compilation.GetSemanticModel(tree)); - bool result = discovery.TryRead(invocation, out _, out _, TestContext.Current.CancellationToken); - - Assert.False(result); - } - - private static CSharpCompilation Compile(string source) - { - string[] assemblies = ((string)AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES")!).Split(Path.PathSeparator); - IEnumerable references = assemblies.Select(path => MetadataReference.CreateFromFile(path)) - .Append(MetadataReference.CreateFromFile(typeof(Quantity<>).Assembly.Location)); - return CSharpCompilation.Create("PowerDiscoveryConsumer", [CSharpSyntaxTree.ParseText(source, new CSharpParseOptions(LanguageVersion.Preview))], - references, new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)); - } -} diff --git a/src/DimensionalQuantities.Roslyn.Tests/Discovery/PowerMethodDiscoveryTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Discovery/PowerMethodDiscoveryTests.cs deleted file mode 100644 index f379f2d..0000000 --- a/src/DimensionalQuantities.Roslyn.Tests/Discovery/PowerMethodDiscoveryTests.cs +++ /dev/null @@ -1,129 +0,0 @@ -using DimensionalQuantities.Numerics; -using DimensionalQuantities.Roslyn.Discovery; -using DimensionalQuantities.TypeSystem; -using Microsoft.CodeAnalysis; -using Microsoft.CodeAnalysis.CSharp; -using Microsoft.CodeAnalysis.CSharp.Syntax; -using Xunit; - -namespace DimensionalQuantities.Roslyn.Tests.Discovery; - -public sealed class PowerMethodDiscoveryTests -{ - [Theory] - [InlineData("Squared", 2, 1)] - [InlineData("Cubed", 3, 1)] - [InlineData("Pow4", 4, 1)] - [InlineData("Pow5", 5, 1)] - [InlineData("Pow6", 6, 1)] - [InlineData("SquareRoot", 1, 2)] - [InlineData("CubeRoot", 1, 3)] - [InlineData("Root4", 1, 4)] - [InlineData("Root5", 1, 5)] - [InlineData("Root6", 1, 6)] - public void ReadsTheExponentForEachConvenienceMethod(string name, int numerator, int denominator) - { - string source = $$""" - class Consumer { object Value(object quantity) => quantity.{{name}}(); } - """; - CSharpCompilation compilation = Compile(source); - SyntaxTree tree = compilation.SyntaxTrees.Single(); - InvocationExpressionSyntax invocation = tree.GetRoot(TestContext.Current.CancellationToken).DescendantNodes().OfType().Single(); - PowerMethodDiscovery discovery = new(compilation.GetSemanticModel(tree)); - - bool success = discovery.TryRead(invocation, out Rational result, out string methodName, TestContext.Current.CancellationToken); - Rational expected = new(numerator, denominator); - - Assert.Multiple( - () => Assert.True(success), - () => Assert.Equal(expected, result), - () => Assert.Equal(name, methodName)); - } - - [Theory] - [InlineData("quantity.Pow7()")] - [InlineData("quantity.Root7()")] - [InlineData("quantity.Squared(2)")] - [InlineData("quantity.Squared()")] - [InlineData("quantity.squared()")] - public void RejectsUnsupportedMethodCalls(string expression) - { - string source = $$"""class Consumer { object Value(object quantity) => {{expression}}; }"""; - CSharpCompilation compilation = Compile(source); - SyntaxTree tree = compilation.SyntaxTrees.Single(); - InvocationExpressionSyntax invocation = tree.GetRoot(TestContext.Current.CancellationToken).DescendantNodes().OfType().Single(); - PowerMethodDiscovery discovery = new(compilation.GetSemanticModel(tree)); - - bool result = discovery.TryRead(invocation, out _, out _, TestContext.Current.CancellationToken); - - Assert.False(result); - } - - [Theory] - [InlineData("class Other { public int Squared() => 7; }", "quantity.Squared()")] - [InlineData("class Other { public int Squared() => 7; }", "quantity?.Squared()")] - [InlineData("class Other { } static class Extensions { public static int Squared(this Other value) => 7; }", "quantity.Squared()")] - [InlineData("class Other { } static class Extensions { public static int Squared(this Other value) => 7; }", "quantity?.Squared()")] - public void PreservesAlreadyBoundMethods(string declaration, string expression) - { - string source = $$"""{{declaration}} class Consumer { object Value(Other quantity) => {{expression}}; }"""; - CSharpCompilation compilation = Compile(source); - SyntaxTree tree = compilation.SyntaxTrees.Single(); - InvocationExpressionSyntax invocation = tree.GetRoot(TestContext.Current.CancellationToken).DescendantNodes().OfType().Single(); - PowerMethodDiscovery discovery = new(compilation.GetSemanticModel(tree)); - - bool result = discovery.TryRead(invocation, out _, out _, TestContext.Current.CancellationToken); - - Assert.False(result); - } - - [Fact] - public void ReadsConditionalMemberBindingWithinAChain() - { - const string source = "class Consumer { object Value(object quantity) => quantity?.Squared().ToString(); }"; - CSharpCompilation compilation = Compile(source); - SyntaxTree tree = compilation.SyntaxTrees.Single(); - InvocationExpressionSyntax invocation = tree.GetRoot(TestContext.Current.CancellationToken).DescendantNodes() - .OfType().Single(call => call.Expression is MemberBindingExpressionSyntax); - PowerMethodDiscovery discovery = new(compilation.GetSemanticModel(tree)); - - bool success = discovery.TryRead(invocation, out Rational exponent, out string methodName, TestContext.Current.CancellationToken); - - Assert.Multiple( - () => Assert.True(success), - () => Assert.Equal(new Rational(2), exponent), - () => Assert.Equal("Squared", methodName)); - } - - [Fact] - public void AllowsAConvenienceMethodAlongsideAnOverloadWithRequiredArguments() - { - const string source = """ - class Other { } - static class Extensions { public static int Squared(this Other value, int factor) => factor; } - class Consumer { object Value(Other quantity) => quantity.Squared(); } - """; - CSharpCompilation compilation = Compile(source); - SyntaxTree tree = compilation.SyntaxTrees.Single(); - InvocationExpressionSyntax invocation = tree.GetRoot(TestContext.Current.CancellationToken).DescendantNodes().OfType().Single(); - PowerMethodDiscovery discovery = new(compilation.GetSemanticModel(tree)); - - bool success = discovery.TryRead(invocation, out Rational result, out string methodName, TestContext.Current.CancellationToken); - Rational expected = new(2); - - Assert.Multiple( - () => Assert.True(success), - () => Assert.Equal(expected, result), - () => Assert.Equal("Squared", methodName)); - } - - private static CSharpCompilation Compile(string source) - { - string[] assemblies = ((string)AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES")!).Split(Path.PathSeparator); - IEnumerable references = assemblies.Select(path => MetadataReference.CreateFromFile(path)) - .Append(MetadataReference.CreateFromFile(typeof(Quantity<>).Assembly.Location)); - return CSharpCompilation.Create("PowerMethodConsumer", - [CSharpSyntaxTree.ParseText(source, new CSharpParseOptions(LanguageVersion.Preview), cancellationToken: TestContext.Current.CancellationToken)], - references, new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)); - } -} diff --git a/src/DimensionalQuantities.Roslyn.Tests/Discovery/QuantityDiscoveryCoordinatorTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Discovery/QuantityDiscoveryCoordinatorTests.cs deleted file mode 100644 index db61ae3..0000000 --- a/src/DimensionalQuantities.Roslyn.Tests/Discovery/QuantityDiscoveryCoordinatorTests.cs +++ /dev/null @@ -1,1283 +0,0 @@ -using System.Reflection; -using DimensionalQuantities.Roslyn.Discovery; -using DimensionalQuantities.Roslyn.Generators; -using DimensionalQuantities.TypeSystem; -using Microsoft.CodeAnalysis; -using Microsoft.CodeAnalysis.CSharp; -using Microsoft.CodeAnalysis.Emit; -using Xunit; - -namespace DimensionalQuantities.Roslyn.Tests.Discovery; - -public sealed class QuantityDiscoveryCoordinatorTests -{ - private static readonly CSharpParseOptions _parseOptions = new(LanguageVersion.Preview); - - [Theory] - [InlineData("var make = () => length * current; return make() * time;")] - [InlineData("var pair = (length * current, time); return pair.Item1 * pair.Item2;")] - [InlineData("var (value, duration) = (length * current, time); return value * duration;")] - [InlineData("return Identity(length * current) * time;")] - [InlineData("LengthCurrent? value = null; var fallback = length * current; return (value ?? fallback) * time;")] - [InlineData("object value = length * current; return ((LengthCurrent)value) * time;")] - [InlineData("var values = new[] { length }.Select(item => item * current); return values.First() * time;")] - [InlineData("var values = new[] { length * current }; LengthTimeCurrent result = default; foreach (var value in values) { result += value * time; } return result;")] - public void IntermediateResultsComposeThroughOrdinaryCSharp(string body) - { - string source = $$""" - using System.Linq; - public static class Consumer - { - private static T Identity(T value) => value; - public static LengthTimeCurrent Calculate() - { - Length length = Length.FromMetres(2); - Current current = Current.FromAmps(3); - Time time = Time.FromSeconds(4); - {{body}} - } - public static double Value() => Calculate().AsSiBaseUnit(); - } - """; - QuantityDiscoveryResult discovery = Discover(source); - double result = Evaluate(discovery.Compilation); - double expected = 24; - - Assert.Equal(expected, result); - } - - [Fact] - public void ForeachArithmeticOverTypedInputRetainsItsResultDimension() - { - const string source = """ - using System.Collections.Generic; - public static class Consumer - { - public static LengthTimeCurrent Calculate(IEnumerable values) - { - LengthTimeCurrent total = default; - foreach (var value in values) - { - total = total + value * Time.FromSeconds(4); - } - return total; - } - public static double Value() => Calculate(new[] { LengthCurrent.FromSiBaseUnit(2), LengthCurrent.FromSiBaseUnit(3) }).AsSiBaseUnit(); - } - """; - QuantityDiscoveryResult discovery = Discover(source); - double result = Evaluate(discovery.Compilation); - - Assert.Equal(20, result); - } - - [Fact] - public void ConstrainedProviderResultsComposeWithArithmetic() - { - const string source = """ - public interface IProvider { T Get(); } - public sealed class Provider : IProvider - { - LengthCurrent IProvider.Get() => Length.FromMetres(2) * Current.FromAmps(3); - } - public static class Consumer - { - private static LengthTimeCurrent Calculate(TProvider provider) where TProvider : IProvider - { - var value = provider.Get(); - return value * Time.FromSeconds(4); - } - public static double Value() => Calculate(new Provider()).AsSiBaseUnit(); - } - """; - QuantityDiscoveryResult discovery = Discover(source); - double result = Evaluate(discovery.Compilation); - double expected = 24; - - Assert.Equal(expected, result); - } - - [Fact] - public void OutVariablesComposeWithArithmetic() - { - const string source = """ - public static class Consumer - { - private static bool TryGet(out LengthCurrent value) - { - value = LengthCurrent.FromSiBaseUnit(6); - return true; - } - private static LengthTimeCurrent Calculate() - { - if (TryGet(out var value)) return value * Time.FromSeconds(4); - throw new System.Exception(); - } - public static double Value() => Calculate().AsSiBaseUnit(); - } - """; - QuantityDiscoveryResult discovery = Discover(source); - double result = Evaluate(discovery.Compilation); - double expected = 24; - - Assert.Equal(expected, result); - } - - [Theory] - [InlineData("ref", "return Get() * Time.FromSeconds(4);")] - [InlineData("ref", "ref var value = ref Get(); return value * Time.FromSeconds(4);")] - [InlineData("ref readonly", "ref readonly var value = ref Get(); return value * Time.FromSeconds(4);")] - public void RefReturnsComposeWithArithmetic(string returnModifier, string body) - { - string source = $$""" - public static class Consumer - { - private static LengthCurrent stored = LengthCurrent.FromSiBaseUnit(6); - private static {{returnModifier}} LengthCurrent Get() => ref stored; - private static LengthTimeCurrent Calculate() - { - {{body}} - } - public static double Value() => Calculate().AsSiBaseUnit(); - } - """; - QuantityDiscoveryResult discovery = Discover(source); - double result = Evaluate(discovery.Compilation); - double expected = 24; - - Assert.Equal(expected, result); - } - - [Theory] - [InlineData("Span")] - [InlineData("ReadOnlySpan")] - public void SpanElementsComposeWithArithmetic(string spanType) - { - string source = $$""" - using System; - public static class Consumer - { - private static LengthTimeCurrent Calculate({{spanType}} values) => values[0] * Time.FromSeconds(4); - public static double Value() => Calculate(new[] { LengthCurrent.FromSiBaseUnit(6) }).AsSiBaseUnit(); - } - """; - QuantityDiscoveryResult discovery = Discover(source); - double result = Evaluate(discovery.Compilation); - double expected = 24; - - Assert.Equal(expected, result); - } - - [Fact] - public void PropertyPatternVariablesComposeWithArithmetic() - { - const string source = """ - public sealed class Measurement - { - public LengthCurrent Value => LengthCurrent.FromSiBaseUnit(6); - } - public static class Consumer - { - private static LengthTimeCurrent Calculate(Measurement input) - { - if (input is { Value: var value }) return value * Time.FromSeconds(4); - throw new System.Exception(); - } - public static double Value() => Calculate(new Measurement()).AsSiBaseUnit(); - } - """; - QuantityDiscoveryResult discovery = Discover(source); - double result = Evaluate(discovery.Compilation); - double expected = 24; - - Assert.Equal(expected, result); - } - - [Fact] - public void ListPatternVariablesComposeWithArithmetic() - { - const string source = """ - public static class Consumer - { - private static LengthTimeCurrent Calculate(LengthCurrent[] input) - { - if (input is [var value]) return value * Time.FromSeconds(4); - throw new System.Exception(); - } - public static double Value() => Calculate(new[] { LengthCurrent.FromSiBaseUnit(6) }).AsSiBaseUnit(); - } - """; - QuantityDiscoveryResult discovery = Discover(source); - double result = Evaluate(discovery.Compilation); - double expected = 24; - - Assert.Equal(expected, result); - } - - [Fact] - public void CustomDeconstructionResultsComposeWithArithmetic() - { - const string source = """ - public sealed class Measurement - { - public void Deconstruct(out LengthCurrent value, out Time duration) - { - value = LengthCurrent.FromSiBaseUnit(6); - duration = Time.FromSeconds(4); - } - } - public static class Consumer - { - private static LengthTimeCurrent Calculate(Measurement input) - { - var (value, duration) = input; - return value * duration; - } - public static double Value() => Calculate(new Measurement()).AsSiBaseUnit(); - } - """; - QuantityDiscoveryResult discovery = Discover(source); - double result = Evaluate(discovery.Compilation); - double expected = 24; - - Assert.Equal(expected, result); - } - - [Theory] - [InlineData("public LengthCurrent Get() => Length.FromMetres(2) * Current.FromAmps(3);")] - [InlineData("LengthCurrent IProvider.Get() => Length.FromMetres(2) * Current.FromAmps(3);")] - public void GenericInterfaceResultsComposeWithArithmetic(string implementation) - { - string source = $$""" - public interface IProvider { T Get(); } - public sealed class Provider : IProvider - { - {{implementation}} - } - public static class Consumer - { - private static LengthTimeCurrent Calculate(IProvider provider) - { - var value = provider.Get(); - return value * Time.FromSeconds(4); - } - public static double Value() => Calculate(new Provider()).AsSiBaseUnit(); - } - """; - QuantityDiscoveryResult discovery = Discover(source); - double result = Evaluate(discovery.Compilation); - double expected = 24; - - Assert.Equal(expected, result); - } - - [Theory] - [InlineData("if (input is LengthCurrent value) return value * Time.FromSeconds(4); throw new System.Exception();")] - [InlineData("switch (input) { case LengthCurrent value: return value * Time.FromSeconds(4); default: throw new System.Exception(); }")] - [InlineData("return input switch { LengthCurrent value => value * Time.FromSeconds(4), _ => throw new System.Exception() };")] - public void PatternVariablesComposeWithArithmetic(string body) - { - string source = $$""" - public static class Consumer - { - private static LengthTimeCurrent Calculate(object input) - { - {{body}} - } - public static double Value() => Calculate(Length.FromMetres(2) * Current.FromAmps(3)).AsSiBaseUnit(); - } - """; - QuantityDiscoveryResult discovery = Discover(source); - double result = Evaluate(discovery.Compilation); - double expected = 24; - - Assert.Equal(expected, result); - } - - [Fact] - public void IteratorResultsComposeWithArithmetic() - { - const string source = """ - using System.Collections.Generic; - public static class Consumer - { - private static IEnumerable Values() - { - yield return Length.FromMetres(2) * Current.FromAmps(3); - yield return Length.FromMetres(3) * Current.FromAmps(3); - } - private static LengthTimeCurrent Calculate() - { - LengthTimeCurrent total = default; - foreach (var value in Values()) - { - total += value * Time.FromSeconds(4); - } - return total; - } - public static double Value() => Calculate().AsSiBaseUnit(); - } - """; - QuantityDiscoveryResult discovery = Discover(source); - double result = Evaluate(discovery.Compilation); - double expected = 60; - - Assert.Equal(expected, result); - } - - [Theory] - [InlineData("if (input is LengthCurrent value) return value * Time.FromSeconds(4); throw new System.Exception();")] - [InlineData("return input switch { LengthCurrent value => value * Time.FromSeconds(4), _ => throw new System.Exception() };")] - public void UnionCaseVariablesComposeWithArithmetic(string body) - { - string source = $$""" - public union Measurement(LengthCurrent, Time); - public static class Consumer - { - private static LengthTimeCurrent Calculate(Measurement input) - { - {{body}} - } - public static double Value() => Calculate(Length.FromMetres(2) * Current.FromAmps(3)).AsSiBaseUnit(); - } - """; - QuantityDiscoveryResult discovery = Discover(source); - double result = Evaluate(discovery.Compilation); - double expected = 24; - - Assert.Equal(expected, result); - } - - [Fact] - public void IncompatibleUnionCasesDoNotSupplyDimensionsToArithmetic() - { - const string source = """ - public union Measurement(LengthCurrent, Time); - public static class Consumer - { - public static object Calculate(Measurement input, Current current) - { - var value = input switch - { - LengthCurrent product => product, - Time duration => duration, - _ => throw new System.Exception() - }; - return value * current; - } - } - """; - QuantityDiscoveryResult result = Discover(source); - Diagnostic[] errors = result.Compilation.GetDiagnostics(TestContext.Current.CancellationToken) - .Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error).ToArray(); - - Assert.Multiple( - () => Assert.Contains(errors, diagnostic => diagnostic.Id == "CS8506"), - () => Assert.DoesNotContain(result.Sources, source => source.HintName == "Arithmetic.g.cs")); - } - - [Fact] - public void AsyncIteratorResultsComposeWithArithmetic() - { - const string source = """ - using System.Collections.Generic; - using System.Threading.Tasks; - public static class Consumer - { - private static async IAsyncEnumerable Values() - { - await Task.Yield(); - yield return Length.FromMetres(2) * Current.FromAmps(3); - await Task.Yield(); - yield return Length.FromMetres(3) * Current.FromAmps(3); - } - private static async Task Calculate() - { - LengthTimeCurrent total = default; - await foreach (var value in Values()) - { - total += value * Time.FromSeconds(4); - } - return total; - } - public static double Value() => Calculate().GetAwaiter().GetResult().AsSiBaseUnit(); - } - """; - QuantityDiscoveryResult discovery = Discover(source); - double result = Evaluate(discovery.Compilation); - double expected = 60; - - Assert.Equal(expected, result); - } - - [Fact] - public void AwaitedIntermediateResultsComposeWithArithmetic() - { - const string source = """ - using System.Threading.Tasks; - public static class Consumer - { - private static async Task Make() - { - await Task.Yield(); - return Length.FromMetres(2) * Current.FromAmps(3); - } - private static async Task Calculate() => (await Make()) * Time.FromSeconds(4); - public static double Value() => Calculate().GetAwaiter().GetResult().AsSiBaseUnit(); - } - """; - QuantityDiscoveryResult discovery = Discover(source); - double result = Evaluate(discovery.Compilation); - - Assert.Equal(24, result); - } - - [Fact] - public void BlockGetterResultsComposeAcrossSourceFiles() - { - const string member = """ - public static class Measurements - { - public static LengthCurrent Value - { - get { return Length.FromMetres(2) * Current.FromAmps(3); } - } - } - """; - const string consumer = """ - public static class Consumer - { - public static LengthTimeCurrent Calculate() => Measurements.Value * Time.FromSeconds(4); - public static double Value() => Calculate().AsSiBaseUnit(); - } - """; - QuantityDiscoveryResult discovery = Discover(consumer, member); - double result = Evaluate(discovery.Compilation); - - Assert.Equal(24, result); - } - - [Theory] - [InlineData("new LengthCurrent()")] - [InlineData("default(LengthCurrent)")] - [InlineData("Make()")] - public void ExplicitIntermediateTypesSupplyDimensionsWithoutInitialisers(string expression) - { - string source = $$""" - public static class Consumer - { - private static LengthCurrent Make() => default; - public static LengthTimeCurrent Calculate() => {{expression}} * Time.FromSeconds(4); - public static double Value() => Calculate().AsSiBaseUnit(); - } - """; - QuantityDiscoveryResult discovery = Discover(source); - double result = Evaluate(discovery.Compilation); - - Assert.Equal(0, result); - } - - [Theory] - [InlineData("FromSiBaseUnit(6000)")] - [InlineData("FromPrefixedUnits(6, 3, 0)")] - public void StandaloneCanonicalFactoryRequestsAQuantityAndItsConversions(string factory) - { - string source = $$""" - public static class Consumer - { - public static double Value() => LengthCurrent.{{factory}}.AsPrefixedUnits(3, 0); - } - """; - QuantityDiscoveryResult discovery = Discover(source); - double result = Evaluate(discovery.Compilation); - - Assert.Equal(6, result); - } - - [Theory] - [InlineData("(Length.FromMetres(2) * Current.FromAmps(3)).Squared()", "LengthSquaredTimeCurrentSquared", 144)] - [InlineData("Power.Of(Length.FromMetres(2) * Current.FromAmps(3))", "LengthSquaredTimeCurrentSquared", 144)] - [InlineData("Power.Of(Length.FromMetres(3) * Current.FromAmps(3))", "SquareRootLengthTimeSquareRootCurrent", 12)] - public void PowerResultsComposeThroughInferredDelegates(string expression, string resultType, double expected) - { - string source = $$""" - using DimensionalQuantities.TypeSystem; - public static class Consumer - { - public static {{resultType}} Calculate() - { - var make = () => {{expression}}; - return make() * Time.FromSeconds(4); - } - public static double Value() => Calculate().AsSiBaseUnit(); - } - """; - QuantityDiscoveryResult discovery = Discover(source); - double result = Evaluate(discovery.Compilation); - - Assert.Equal(expected, result); - } - - [Fact] - public void ExistingMultiplicationOperatorKeepsItsBehaviour() - { - const string source = """ - public static class CustomOperators - { - extension(Length) - { - public static double operator *(Length length, Current current) => 42; - } - } - public static class Consumer - { - public static Time Calculate() => (Length.FromMetres(2) * Current.FromAmps(3)) * Time.FromSeconds(4); - public static double Value() => Calculate().AsSiBaseUnit(); - } - """; - QuantityDiscoveryResult discovery = Discover(source); - double result = Evaluate(discovery.Compilation); - - Assert.Equal(168, result); - } - - [Fact] - public void ExistingConvenienceMethodKeepsItsBehaviourAfterItsReceiverResolves() - { - const string source = """ - public static class CustomMethods - { - public static Time Squared(this LengthCurrent value) => Time.FromSeconds(7); - } - public static class Consumer - { - public static TimeCurrent Calculate() => (Length.FromMetres(2) * Current.FromAmps(3)).Squared() * Current.FromAmps(3); - public static double Value() => Calculate().AsSiBaseUnit(); - } - """; - QuantityDiscoveryResult discovery = Discover(source); - double result = Evaluate(discovery.Compilation); - - Assert.Equal(21, result); - } - - [Theory] - [InlineData("wrapper + wrapper")] - [InlineData("wrapper - wrapper")] - [InlineData("-wrapper")] - public void BoundOperatorResultsComposeWithDimensionalArithmetic(string expression) - { - string source = $$""" - public sealed class Wrapper - { - public static Current operator +(Wrapper left, Wrapper right) => Current.FromAmps(3); - public static Current operator -(Wrapper left, Wrapper right) => Current.FromAmps(3); - public static Current operator -(Wrapper value) => Current.FromAmps(3); - } - public static class Consumer - { - public static TimeCurrent Calculate() - { - Wrapper wrapper = new(); - return ({{expression}}) * Time.FromSeconds(4); - } - public static double Value() => Calculate().AsSiBaseUnit(); - } - """; - QuantityDiscoveryResult discovery = Discover(source); - double result = Evaluate(discovery.Compilation); - - Assert.Equal(12, result); - } - - [Theory] - [InlineData("choose ? length * current : length * time", "CS0173")] - [InlineData("choose switch { true => length * current, false => length * time }", "CS8506")] - public void ConflictingBranchesDoNotSupplyDimensionsToFurtherArithmetic(string expression, string expectedDiagnostic) - { - string source = $$""" - public static class Consumer - { - public static object Value(bool choose, Length length, Current current, Time time) - { - var value = {{expression}}; - return value * current; - } - } - """; - QuantityDiscoveryResult result = Discover(source); - Diagnostic[] errors = result.Compilation.GetDiagnostics(TestContext.Current.CancellationToken) - .Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error).ToArray(); - - Assert.Multiple( - () => Assert.Contains(errors, diagnostic => diagnostic.Id == expectedDiagnostic), - () => Assert.Null(result.Compilation.Assembly.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentSquaredExtensions")), - () => Assert.Null(result.Compilation.Assembly.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeCurrentExtensions"))); - } - - [Fact] - public void AmbiguousMethodCallsRemainCompilerErrors() - { - const string source = """ - public static class Consumer - { - private static LengthCurrent Make(int first, long second) => default; - private static LengthTime Make(long first, int second) => default; - public static object Value(Current current) => Make(1, 1) * current; - } - """; - QuantityDiscoveryResult result = Discover(source); - Diagnostic[] errors = result.Compilation.GetDiagnostics(TestContext.Current.CancellationToken) - .Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error).ToArray(); - - Assert.Multiple( - () => Assert.Contains(errors, diagnostic => diagnostic.Id == "CS0121"), - () => Assert.Null(result.Compilation.Assembly.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentSquaredExtensions")), - () => Assert.Null(result.Compilation.Assembly.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeCurrentExtensions"))); - } - - [Theory] - [InlineData("var value = value * current; return value;", "CS0841")] - [InlineData("return (length + current) * time;", "CS0019")] - [InlineData("return LengthCurrent.FromBananas(6);", "CS0103")] - public void InvalidConsumerCodeRemainsACompilerError(string body, string expectedDiagnostic) - { - string source = $$""" - public static class Consumer - { - public static object Value(Length length, Current current, Time time) { {{body}} } - } - """; - QuantityDiscoveryResult result = Discover(source); - Diagnostic[] errors = result.Compilation.GetDiagnostics(TestContext.Current.CancellationToken) - .Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error).ToArray(); - - Assert.Contains(errors, diagnostic => diagnostic.Id == expectedDiagnostic); - } - - [Fact] - public void LongDependentExpressionsCompleteWithoutAnArbitrarySmallPassLimit() - { - string expression = string.Join(" * ", Enumerable.Repeat("Current.FromAmps(1)", 20)); - string source = $$""" - public static class Consumer - { - public static LengthCurrent20 Calculate() => Length.FromMetres(2) * {{expression}}; - public static double Value() => Calculate().AsSiBaseUnit(); - } - """; - QuantityDiscoveryResult discovery = Discover(source); - double result = Evaluate(discovery.Compilation); - - Assert.Equal(2, result); - } - - [Theory] - [InlineData("var squared = current * current; var heating = squared * resistance;", "Power", "heating", 36)] - [InlineData("var squared = current * current; var copy = squared; var heating = copy * resistance; var energy = heating * time;", "Energy", "energy", 72)] - [InlineData("var squared = (2 * current) * current / 2; var heating = squared * resistance;", "Power", "heating", 36)] - [InlineData("var squared = current * current; var fourth = squared * squared;", "Current4", "fourth", 81)] - public void ArithmeticThroughLocalInitialisersCompilesAndExecutes(string declarations, string resultType, string resultName, double expected) - { - string source = $$""" - public static class Consumer - { - public static {{resultType}} Calculate() - { - Current current = Current.FromAmps(3); - Resistance resistance = Resistance.FromSiBaseUnit(4); - Time time = Time.FromSeconds(2); - {{declarations}} - return {{resultName}}; - } - public static double Value() => Calculate().AsSiBaseUnit(); - } - """; - double result = Evaluate(Discover(source).Compilation); - - Assert.Equal(expected, result); - } - - [Fact] - public void IdenticallyNamedLocalsInSeparateScopesRetainTheirOwnDimensions() - { - const string source = """ - public static class Consumer - { - public static double Value() - { - Current current = Current.FromAmps(3); - Resistance resistance = Resistance.FromSiBaseUnit(4); - Time time = Time.FromSeconds(2); - double first; - double second; - { - var intermediate = current * current; - var result = intermediate * resistance; - Power typedResult = result; - first = typedResult.AsSiBaseUnit(); - } - { - var intermediate = time * time; - var result = intermediate * current; - TimeSquaredCurrent typedResult = result; - second = typedResult.AsSiBaseUnit(); - } - return first + second; - } - } - """; - double result = Evaluate(Discover(source).Compilation); - double expected = 48; - - Assert.Equal(expected, result); - } - - [Fact] - public void CyclicLocalInitialisersDoNotCrashDiscovery() - { - const string source = """ - public static class Consumer - { - public static object Value(Current current) - { - var first = second * current; - var second = first * current; - return second; - } - } - """; - QuantityDiscoveryResult result = Discover(source); - - Assert.Multiple( - () => Assert.Null(result.Compilation.GetTypeByMetadataName("DimensionalQuantities.Generated.ArithmeticExtensions")), - () => Assert.DoesNotContain(result.Sources, generated => generated.HintName == "ArithmeticExtensions.g.cs")); - } - - [Theory] - [InlineData("LengthCurrent value = length * current;")] - [InlineData("LengthCurrent first = length * current; LengthCurrent value = first;")] - [InlineData("LengthCurrent first = length * current; var value = first;")] - public void ExplicitIntermediateLocalsComposeWithFurtherArithmetic(string declarations) - { - string source = $$""" - public static class Consumer - { - public static LengthTimeCurrent Calculate() - { - Length length = Length.FromMetres(2); - Current current = Current.FromAmps(3); - Time time = Time.FromSeconds(4); - {{declarations}} - return value * time; - } - public static double Value() => Calculate().AsSiBaseUnit(); - } - """; - double result = Evaluate(Discover(source).Compilation); - - Assert.Equal(24, result); - } - - [Fact] - public void IncorrectExplicitIntermediateTypeRemainsACompilerError() - { - const string source = """ - class Consumer - { - object Value(Length length, Current current, Time time) - { - LengthCurrent wrong = length * time; - return wrong * current; - } - } - """; - QuantityDiscoveryResult result = Discover(source); - Diagnostic[] errors = result.Compilation.GetDiagnostics(TestContext.Current.CancellationToken) - .Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error).ToArray(); - - Assert.Contains(errors, diagnostic => diagnostic.Severity == DiagnosticSeverity.Error); - } - - [Theory] - [InlineData("choose ? length * current : length * current")] - [InlineData("choose ? length * current : throw new System.Exception()")] - [InlineData("choose switch { true => length * current, false => length * current }")] - [InlineData("choose switch { true => length * current, _ => throw new System.Exception() }")] - [InlineData("choose ? (choose switch { true => length * current, _ => length * current }) : length * current")] - public void ConditionalIntermediateResultsComposeWithArithmetic(string expression) - { - string source = $$""" - public static class Consumer - { - public static LengthTimeCurrent Calculate() - { - bool choose = true; - Length length = Length.FromMetres(2); - Current current = Current.FromAmps(3); - Time time = Time.FromSeconds(4); - var product = {{expression}}; - return product * time; - } - public static double Value() => Calculate().AsSiBaseUnit(); - } - """; - double result = Evaluate(Discover(source).Compilation); - - Assert.Equal(24, result); - } - - [Theory] - [InlineData("public LengthCurrent Stored = Length.FromMetres(2) * Current.FromAmps(3);")] - [InlineData("public LengthCurrent Stored => Length.FromMetres(2) * Current.FromAmps(3);")] - [InlineData("public LengthCurrent Stored { get => Length.FromMetres(2) * Current.FromAmps(3); }")] - [InlineData("public LengthCurrent Stored { get; } = Length.FromMetres(2) * Current.FromAmps(3);")] - [InlineData("private LengthCurrent Seed = Length.FromMetres(2) * Current.FromAmps(3); public LengthCurrent Stored => Seed;")] - public void IntermediateFieldsAndPropertiesComposeWithArithmetic(string declaration) - { - string source = $$""" - public class Inputs { {{declaration}} } - public static class Consumer - { - public static LengthTimeCurrent Calculate() => new Inputs().Stored * Time.FromSeconds(4); - public static double Value() => Calculate().AsSiBaseUnit(); - } - """; - double result = Evaluate(Discover(source).Compilation); - - Assert.Equal(24, result); - } - - [Theory] - [InlineData("public LengthCurrent Make(Length length, Current current) => length * current;")] - [InlineData("public LengthCurrent Make(Length length, Current current) { LengthCurrent product = length * current; return product; }")] - [InlineData("public LengthCurrent Make(Length length, Current current) { if (length.AsSiBaseUnit() > 0) return length * current; return length * current * 2; }")] - [InlineData("public LengthCurrent Make(Length length, Current current) { if (length.AsSiBaseUnit() < 0) throw new System.Exception(); return length * current; }")] - [InlineData("public LengthCurrent Make(Length length, Current current) { LengthCurrent Local(Length l, Current c) => l * c; return Local(length, current); }")] - [InlineData("public LengthTime Make(Length length, Time time) => length * time; public LengthCurrent Make(Length length, Current current) => length * current;")] - public void IntermediateMethodResultsComposeWithArithmetic(string declaration) - { - string source = $$""" - public class Inputs { {{declaration}} } - public static class Consumer - { - public static LengthTimeCurrent Calculate() => new Inputs().Make(Length.FromMetres(2), Current.FromAmps(3)) * Time.FromSeconds(4); - public static double Value() => Calculate().AsSiBaseUnit(); - } - """; - double result = Evaluate(Discover(source).Compilation); - - Assert.Equal(24, result); - } - - [Fact] - public void ExtensionMethodIntermediateReturnComposesWithArithmetic() - { - const string source = """ - public static class Helpers - { - public static LengthCurrent Make(this Length length, Current current) => length * current; - } - public static class Consumer - { - public static LengthTimeCurrent Calculate() => Length.FromMetres(2).Make(Current.FromAmps(3)) * Time.FromSeconds(4); - public static double Value() => Calculate().AsSiBaseUnit(); - } - """; - double result = Evaluate(Discover(source).Compilation); - - Assert.Equal(24, result); - } - - [Theory] - [InlineData("public static LengthCurrent Field;", "Field")] - [InlineData("public static LengthCurrent Field = default;", "Field")] - [InlineData("public static LengthCurrent Property { get; } = new();", "Property")] - [InlineData("public static LengthCurrent Property { get; set; }", "Property")] - [InlineData("public static LengthCurrent[] Values = new LengthCurrent[1];", "Values[0]")] - [InlineData("public static System.Collections.Generic.List Values = new() { default };", "Values[0]")] - public void TypeOnlyMemberAndCollectionValuesParticipateInArithmetic(string declaration, string operand) - { - string source = $$""" - public static class Consumer - { - {{declaration}} - public static LengthTimeCurrent Calculate() => {{operand}} * Time.FromSeconds(4); - public static double Value() => Calculate().AsSiBaseUnit(); - } - """; - double result = Evaluate(Discover(source).Compilation); - - Assert.Equal(0, result); - } - - [Theory] - [InlineData("new LengthCurrent[1]")] - [InlineData("new System.Collections.Generic.List { default }")] - public void InferredCollectionsRetainTheirExplicitElementDimensions(string initializer) - { - string source = $$""" - public static class Consumer - { - public static LengthTimeCurrent Calculate() - { - var values = {{initializer}}; - return values[0] * Time.FromSeconds(4); - } - public static double Value() => Calculate().AsSiBaseUnit(); - } - """; - double result = Evaluate(Discover(source).Compilation); - - Assert.Equal(0, result); - } - - [Fact] - public void SourceIndexerCanDeclareAnIntermediateQuantityResult() - { - const string source = """ - public sealed class Measurements - { - public LengthCurrent this[int index] => LengthCurrent.FromSiBaseUnit(6); - } - public static class Consumer - { - public static LengthTimeCurrent Calculate() - { - Measurements values = new(); - return values[0] * Time.FromSeconds(4); - } - public static double Value() => Calculate().AsSiBaseUnit(); - } - """; - double result = Evaluate(Discover(source).Compilation); - - Assert.Equal(24, result); - } - - [Fact] - public void ExplicitLocalCanBeAssignedAfterItsDeclaration() - { - const string source = """ - public static class Consumer - { - public static LengthTimeCurrent Calculate() - { - LengthCurrent value; - value = LengthCurrent.FromSiBaseUnit(6); - return value * Time.FromSeconds(4); - } - public static double Value() => Calculate().AsSiBaseUnit(); - } - """; - double result = Evaluate(Discover(source).Compilation); - - Assert.Equal(24, result); - } - - [Theory] - [InlineData("default")] - [InlineData("new()")] - public void ExplicitDefaultQuantityLocalParticipatesInArithmetic(string initializer) - { - string source = $$""" - public static class Consumer - { - public static LengthTimeCurrent Calculate() - { - LengthCurrent value = {{initializer}}; - return value * Time.FromSeconds(4); - } - public static double Value() => Calculate().AsSiBaseUnit(); - } - """; - double result = Evaluate(Discover(source).Compilation); - - Assert.Equal(0, result); - } - - [Fact] - public void EmptyInputNeedsNoDynamicSource() - { - QuantityDiscoveryResult result = Discover(); - - Assert.Empty(result.Sources); - } - - [Fact] - public void CancellationStopsDiscovery() - { - using CancellationTokenSource cancellation = new(); - cancellation.Cancel(); - QuantityGenerationPlan defaults = DefaultQuantityDiscovery.Discover(); - CSharpCompilation compilation = CreateCompilation([]); - - Assert.Throws(() => QuantityDiscoveryCoordinator.Discover(compilation, [], defaults, cancellation.Token)); - } - - [Theory] - [InlineData("Length?", "Current", "Length.FromMetres(6)", "Current.FromAmps(3)", 18)] - [InlineData("Length", "Current?", "Length.FromMetres(6)", "Current.FromAmps(3)", 18)] - [InlineData("Length?", "Current?", "Length.FromMetres(6)", "Current.FromAmps(3)", 18)] - [InlineData("Length?", "Current", "null", "Current.FromAmps(3)", -1)] - [InlineData("Length", "Current?", "Length.FromMetres(6)", "null", -1)] - [InlineData("Length?", "Current?", "Length.FromMetres(6)", "null", -1)] - public void NullableMultiplicationDiscoveryPreservesNullableResults(string leftType, string rightType, string leftValue, string rightValue, double expectedValue) - { - string source = $$""" - public static class Consumer - { - public static LengthCurrent? Calculate() - { - {{leftType}} left = {{leftValue}}; - {{rightType}} right = {{rightValue}}; - return left * right; - } - public static double Value() => Calculate()?.AsSiBaseUnit() ?? -1; - } - """; - QuantityDiscoveryResult discovery = Discover(source); - double result = Evaluate(discovery.Compilation); - - Assert.Equal(expectedValue, result); - } - - [Theory] - [InlineData("Length?", "Current", "Length.FromMetres(6)", "Current.FromAmps(3)", 2)] - [InlineData("Length", "Current?", "Length.FromMetres(6)", "Current.FromAmps(3)", 2)] - [InlineData("Length?", "Current?", "Length.FromMetres(6)", "Current.FromAmps(3)", 2)] - [InlineData("Length?", "Current", "null", "Current.FromAmps(3)", -1)] - [InlineData("Length", "Current?", "Length.FromMetres(6)", "null", -1)] - [InlineData("Length?", "Current?", "Length.FromMetres(6)", "null", -1)] - public void NullableDivisionDiscoveryPreservesNullableResults(string leftType, string rightType, string leftValue, string rightValue, double expectedValue) - { - string source = $$""" - public static class Consumer - { - public static LengthPerCurrent? Calculate() - { - {{leftType}} left = {{leftValue}}; - {{rightType}} right = {{rightValue}}; - return left / right; - } - public static double Value() => Calculate()?.AsSiBaseUnit() ?? -1; - } - """; - QuantityDiscoveryResult discovery = Discover(source); - double result = Evaluate(discovery.Compilation); - - Assert.Equal(expectedValue, result); - } - - [Theory] - [InlineData("Length.FromMetres(6)", 18)] - [InlineData("null", -1)] - public void NullableArithmeticUsesOperatorDiscoveredFromNonNullableOperands(string leftValue, double expectedValue) - { - string source = $$""" - public static class Consumer - { - public static LengthCurrent? Calculate() - { - LengthCurrent seed = Length.FromMetres(1) * Current.FromAmps(1); - Length? left = {{leftValue}}; - Current right = Current.FromAmps(3); - return left * right; - } - public static double Value() => Calculate()?.AsSiBaseUnit() ?? -1; - } - """; - double result = Evaluate(Discover(source).Compilation); - - Assert.Equal(expectedValue, result); - } - - [Theory] - [InlineData("Current.FromAmps(3)", 2)] - [InlineData("null", -1)] - public void NullableScalarReciprocalDiscoveryPreservesNullableResults(string value, double expectedValue) - { - string source = $$""" - public static class Consumer - { - public static InverseCurrent? Calculate() - { - Current? current = {{value}}; - return 6d / current; - } - public static double Value() => Calculate()?.AsSiBaseUnit() ?? -1; - } - """; - double result = Evaluate(Discover(source).Compilation); - - Assert.Equal(expectedValue, result); - } - - [Theory] - [InlineData("Time?", "6d", "Time.FromSeconds(3)", 2)] - [InlineData("Time?", "null", "Time.FromSeconds(3)", -1)] - [InlineData("Time?", "6d", "null", -1)] - [InlineData("Time?", "null", "null", -1)] - [InlineData("Time", "6d", "Time.FromSeconds(3)", 2)] - [InlineData("Time", "null", "Time.FromSeconds(3)", -1)] - public void NullableScalarNumeratorDiscoveryPreservesNullableResults(string timeType, string scalarValue, string timeValue, double expectedValue) - { - string source = $$""" - public static class Consumer - { - public static Frequency? Calculate() - { - double? scalar = {{scalarValue}}; - {{timeType}} time = {{timeValue}}; - return scalar / time; - } - public static double Value() => Calculate()?.AsSiBaseUnit() ?? -1; - } - """; - QuantityDiscoveryResult discovery = Discover(source); - double result = Evaluate(discovery.Compilation); - - Assert.Equal(expectedValue, result); - } - - [Theory] - [InlineData("LengthCurrent.FromSiBaseUnit(12)", 144)] - [InlineData("null", -1)] - public void NullablePowerDiscoveryAddsNullConditionalSquaredMethod(string value, double expectedValue) - { - string source = $$""" - public static class Consumer - { - public static LengthSquaredCurrentSquared? Calculate() - { - LengthCurrent? value = {{value}}; - return value?.Squared(); - } - public static double Value() => Calculate()?.AsSiBaseUnit() ?? -1; - } - """; - double result = Evaluate(Discover(source).Compilation); - - Assert.Equal(expectedValue, result); - } - - [Theory] - [InlineData("LengthCurrent.FromSiBaseUnit(144)", 12)] - [InlineData("null", -1)] - public void NullablePowerDiscoveryAddsNullConditionalSquareRootMethod(string value, double expectedValue) - { - string source = $$""" - public static class Consumer - { - public static SquareRootLengthSquareRootCurrent? Calculate() - { - LengthCurrent? value = {{value}}; - return value?.SquareRoot(); - } - public static double Value() => Calculate()?.AsSiBaseUnit() ?? -1; - } - """; - double result = Evaluate(Discover(source).Compilation); - - Assert.Equal(expectedValue, result); - } - - [Theory] - [InlineData("Length.FromMetres(3)", 9)] - [InlineData("null", -1)] - public void BaseNullablePowerKeepsPregeneratedSquaredMethod(string value, double expectedValue) - { - string source = $$""" - public static class Consumer - { - public static Area? Calculate() - { - Length? value = {{value}}; - return value?.Squared(); - } - public static double Value() => Calculate()?.AsSiBaseUnit() ?? -1; - } - """; - double result = Evaluate(Discover(source).Compilation); - - Assert.Equal(expectedValue, result); - } - - [Theory] - [InlineData("value?.Squared().AsSiBaseUnit()", 36)] - [InlineData("value?.Squared().Squared().AsSiBaseUnit()", 1296)] - [InlineData("(value?.Squared())?.SquareRoot().AsSiBaseUnit()", 6)] - public void NullablePowerDiscoveryHandlesConditionalAccessChains(string expression, double expectedValue) - { - string source = $$""" - public static class Consumer - { - public static double Value() - { - LengthCurrent? value = Length.FromMetres(2) * Current.FromAmps(3); - return {{expression}} ?? -1; - } - } - """; - double result = Evaluate(Discover(source).Compilation); - - Assert.Equal(expectedValue, result); - } - - [Fact] - public void NullablePowerDiscoveryUsesTheNearestConditionalReceiver() - { - const string source = """ - public sealed class Holder - { - public LengthCurrent? Value { get; } - public Holder(LengthCurrent? value) => Value = value; - } - public static class Consumer - { - public static double Value() - { - Holder? holder = new(Length.FromMetres(2) * Current.FromAmps(3)); - return holder?.Value?.Squared().AsSiBaseUnit() ?? -1; - } - } - """; - double result = Evaluate(Discover(source).Compilation); - - Assert.Equal(36, result); - } - - private static QuantityDiscoveryResult Discover(params string[] sources) - { - CSharpCompilation original = CreateCompilation(sources); - QuantityGenerationPlan defaults = DefaultQuantityDiscovery.Discover(); - SyntaxTree[] defaultTrees = - [ - CSharpSyntaxTree.ParseText(QuantitySourceEmitter.Emit([.. defaults.KnownQuantities, .. defaults.AdditionalQuantities]), _parseOptions, path: "Quantities.g.cs"), - CSharpSyntaxTree.ParseText(PowerSourceEmitter.Emit(defaults, "DefaultPowerExtensions"), _parseOptions, path: "DefaultPowers.g.cs"), - CSharpSyntaxTree.ParseText(PowerMethodSourceEmitter.Emit(defaults, "DefaultPowerMethodExtensions"), _parseOptions, path: "DefaultPowerMethods.g.cs") - ]; - return QuantityDiscoveryCoordinator.Discover(original.AddSyntaxTrees(defaultTrees), [.. original.SyntaxTrees], defaults, TestContext.Current.CancellationToken); - } - - private static CSharpCompilation CreateCompilation(string[] sources) - { - string[] platformAssemblies = ((string)AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES")!).Split(Path.PathSeparator); - IEnumerable references = platformAssemblies.Select(path => MetadataReference.CreateFromFile(path)) - .Append(MetadataReference.CreateFromFile(typeof(Quantity<>).Assembly.Location)); - return CSharpCompilation.Create("DiscoveryConsumer", sources.Select((source, index) => CSharpSyntaxTree.ParseText(source, _parseOptions, path: $"Consumer{index}.cs")), - references, new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)); - } - - private static double Evaluate(CSharpCompilation compilation) - { - using MemoryStream bytes = new(); - EmitResult emitted = compilation.Emit(bytes, cancellationToken: TestContext.Current.CancellationToken); - if (!emitted.Success) - { - throw new InvalidOperationException(string.Join(Environment.NewLine, emitted.Diagnostics)); - } - Assembly assembly = Assembly.Load(bytes.ToArray()); - return (double)assembly.GetType("Consumer")!.GetMethod("Value")!.Invoke(null, null)!; - } -} diff --git a/src/DimensionalQuantities.Roslyn.Tests/Discovery/QuantityNameDiscoveryTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Discovery/QuantityNameDiscoveryTests.cs deleted file mode 100644 index 7a55c38..0000000 --- a/src/DimensionalQuantities.Roslyn.Tests/Discovery/QuantityNameDiscoveryTests.cs +++ /dev/null @@ -1,60 +0,0 @@ -using DimensionalQuantities.Dimensions; -using DimensionalQuantities.Roslyn.Discovery; -using Microsoft.CodeAnalysis; -using Microsoft.CodeAnalysis.CSharp; -using Microsoft.CodeAnalysis.CSharp.Syntax; -using Xunit; - -namespace DimensionalQuantities.Roslyn.Tests.Discovery; - -public sealed class QuantityNameDiscoveryTests -{ - [Theory] - [InlineData("class Consumer { void Read(LengthCurrent value) { } }")] - [InlineData("class Consumer { LengthCurrent Value; }")] - [InlineData("class Consumer { LengthCurrent Value { get; set; } }")] - [InlineData("class Consumer { LengthCurrent Value() => default; }")] - [InlineData("class Consumer { System.Collections.Generic.List Values; }")] - [InlineData("class Consumer { LengthCurrent[] Values; }")] - [InlineData("class Consumer { System.Type Value() => typeof(LengthCurrent); }")] - public void ReadsUnresolvedNamesInTypePositions(string source) - { - CSharpCompilation compilation = Compile(source); - SyntaxTree tree = compilation.SyntaxTrees.Single(); - IdentifierNameSyntax name = tree.GetRoot(TestContext.Current.CancellationToken).DescendantNodes().OfType() - .Single(identifier => identifier.Identifier.ValueText == "LengthCurrent"); - - bool success = QuantityNameDiscovery.TryRead(name, compilation.GetSemanticModel(tree), out Dimension result, TestContext.Current.CancellationToken); - Dimension expected = new(Length: 1, ElectricCurrent: 1); - - Assert.Multiple( - () => Assert.True(success), - () => Assert.Equal(expected, result)); - } - - [Theory] - [InlineData("class LengthCurrent { } class Consumer { LengthCurrent Value; }")] - [InlineData("using LengthCurrent = System.Int32; class Consumer { LengthCurrent Value; }")] - [InlineData("class Consumer { object Value() => LengthCurrent; }")] - [InlineData("class Consumer { Missing.LengthCurrent Value; }")] - public void IgnoresBoundSymbolsAndNamesOutsideSimpleTypePositions(string source) - { - CSharpCompilation compilation = Compile(source); - SyntaxTree tree = compilation.SyntaxTrees.Single(); - IdentifierNameSyntax name = tree.GetRoot(TestContext.Current.CancellationToken).DescendantNodes().OfType() - .Last(identifier => identifier.Identifier.ValueText == "LengthCurrent"); - - bool result = QuantityNameDiscovery.TryRead(name, compilation.GetSemanticModel(tree), out _, TestContext.Current.CancellationToken); - - Assert.False(result); - } - - private static CSharpCompilation Compile(string source) - { - string[] assemblies = ((string)AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES")!).Split(Path.PathSeparator); - IEnumerable references = assemblies.Select(path => MetadataReference.CreateFromFile(path)); - return CSharpCompilation.Create("TypeNameConsumer", - [CSharpSyntaxTree.ParseText(source, new CSharpParseOptions(LanguageVersion.Preview), cancellationToken: TestContext.Current.CancellationToken)], - references, new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)); - } -} diff --git a/src/DimensionalQuantities.Roslyn.Tests/Discovery/QuantityTypeReaderTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Discovery/QuantityTypeReaderTests.cs deleted file mode 100644 index dba7079..0000000 --- a/src/DimensionalQuantities.Roslyn.Tests/Discovery/QuantityTypeReaderTests.cs +++ /dev/null @@ -1,84 +0,0 @@ -using DimensionalQuantities.Dimensions; -using DimensionalQuantities.Numerics; -using DimensionalQuantities.Roslyn.Discovery; -using DimensionalQuantities.TypeSystem; -using Microsoft.CodeAnalysis; -using Microsoft.CodeAnalysis.CSharp; -using Xunit; - -namespace DimensionalQuantities.Roslyn.Tests.Discovery; - -public sealed class QuantityTypeReaderTests -{ - private static readonly CSharpParseOptions _parseOptions = new(LanguageVersion.Preview); - - [Fact] - public void MissingRuntimeReferenceThrowsWithTheRequiredTypeName() - { - CSharpCompilation compilation = CSharpCompilation.Create("MissingRuntimeConsumer"); - - InvalidOperationException result = Assert.Throws(() => new QuantityTypeReader(compilation)); - - Assert.Contains(typeof(Quantity<>).FullName!, result.Message); - } - - [Fact] - public void ReaderDecodesEveryAxisAndRationalMarker() - { - const string source = """ - using DimensionalQuantities.TypeSystem; - public static class Consumer - { - public static Quantity, Negative, - Fraction, TerminalHex4, TerminalHex5, TerminalHex6, TerminalHex7>> Value; - } - """; - CSharpCompilation compilation = Compile(source); - IFieldSymbol field = GetField(compilation, "Value"); - QuantityTypeReader reader = new(compilation); - bool read = reader.TryRead(field.Type, out Dimension result, TestContext.Current.CancellationToken); - Dimension expected = new(19, -2, new Rational(1, 2), 4, 5, 6, 7); - - Assert.Multiple( - () => Assert.True(read), - () => Assert.Equal(expected, result)); - } - - [Fact] - public void ReaderRejectsUnrelatedAndUnresolvedTypes() - { - const string source = """ - namespace Other { public class Quantity { } } - public static class Consumer - { - public static Other.Quantity Unrelated; - public static string Plain; - public static Missing Unresolved; - } - """; - CSharpCompilation compilation = Compile(source); - QuantityTypeReader reader = new(compilation); - bool unrelated = reader.TryRead(GetField(compilation, "Unrelated").Type, out _, TestContext.Current.CancellationToken); - bool plain = reader.TryRead(GetField(compilation, "Plain").Type, out _, TestContext.Current.CancellationToken); - bool unresolved = reader.TryRead(GetField(compilation, "Unresolved").Type, out _, TestContext.Current.CancellationToken); - - Assert.Multiple( - () => Assert.False(unrelated), - () => Assert.False(plain), - () => Assert.False(unresolved)); - } - - private static IFieldSymbol GetField(CSharpCompilation compilation, string name) => - Assert.IsAssignableFrom(Assert.Single(compilation.GetTypeByMetadataName("Consumer")!.GetMembers(name))); - - private static CSharpCompilation Compile(string source) - { - string[] assemblies = ((string)AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES")!).Split(Path.PathSeparator); - IEnumerable references = assemblies.Select(path => MetadataReference.CreateFromFile(path)) - .Append(MetadataReference.CreateFromFile(typeof(Quantity<>).Assembly.Location)); - CSharpCompilation compilation = CSharpCompilation.Create("DiscoveryConsumer", - [CSharpSyntaxTree.ParseText(source, _parseOptions, path: "Consumer.cs")], references, - new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)); - return compilation; - } -} diff --git a/src/DimensionalQuantities.Roslyn.Tests/Discovery/TypeSystemNumberReaderTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Discovery/TypeSystemNumberReaderTests.cs deleted file mode 100644 index f1d12f3..0000000 --- a/src/DimensionalQuantities.Roslyn.Tests/Discovery/TypeSystemNumberReaderTests.cs +++ /dev/null @@ -1,65 +0,0 @@ -using DimensionalQuantities.Numerics; -using DimensionalQuantities.Roslyn.Discovery; -using DimensionalQuantities.TypeSystem; -using Microsoft.CodeAnalysis; -using Microsoft.CodeAnalysis.CSharp; -using Xunit; - -namespace DimensionalQuantities.Roslyn.Tests.Discovery; - -public sealed class TypeSystemNumberReaderTests -{ - [Fact] - public void MissingRuntimeReferenceThrowsWithTheRequiredTypeName() - { - CSharpCompilation compilation = CSharpCompilation.Create("MissingRuntimeConsumer"); - - InvalidOperationException result = Assert.Throws(() => new TypeSystemNumberReader(compilation)); - - Assert.Contains(typeof(Hex<,>).FullName!, result.Message); - } - - [Theory] - [InlineData("TerminalHex0", 0, 1)] - [InlineData("TerminalHexF", 15, 1)] - [InlineData("Hex", 16, 1)] - [InlineData("Negative", -3, 1)] - [InlineData("Fraction", 1, 2)] - [InlineData("Fraction, TerminalHex2>", -3, 2)] - public void ReadsNumbersFromTheirTypes(string encoding, int numerator, int denominator) - { - CSharpCompilation compilation = Compile($"using DimensionalQuantities.TypeSystem; public class Consumer {{ public {encoding} Value; }}"); - IFieldSymbol field = (IFieldSymbol)compilation.GetTypeByMetadataName("Consumer")!.GetMembers("Value").Single(); - TypeSystemNumberReader reader = new(compilation); - bool read = reader.TryRead(field.Type, out Rational result, TestContext.Current.CancellationToken); - Rational expected = new(numerator, denominator); - - Assert.Multiple( - () => Assert.True(read), - () => Assert.Equal(expected, result)); - } - - [Theory] - [InlineData("int")] - [InlineData("Missing")] - [InlineData("Fraction")] - [InlineData("Custom")] - public void RejectsUnrecognisedNumbersAndZeroDenominators(string encoding) - { - CSharpCompilation compilation = Compile($"using DimensionalQuantities.TypeSystem; public struct Custom : ITypeSystemNumber {{ }} public class Consumer {{ public {encoding} Value; }}"); - IFieldSymbol field = (IFieldSymbol)compilation.GetTypeByMetadataName("Consumer")!.GetMembers("Value").Single(); - TypeSystemNumberReader reader = new(compilation); - bool result = reader.TryRead(field.Type, out _, TestContext.Current.CancellationToken); - - Assert.False(result); - } - - private static CSharpCompilation Compile(string source) - { - string[] assemblies = ((string)AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES")!).Split(Path.PathSeparator); - IEnumerable references = assemblies.Select(path => MetadataReference.CreateFromFile(path)) - .Append(MetadataReference.CreateFromFile(typeof(Quantity<>).Assembly.Location)); - return CSharpCompilation.Create("PowerDiscoveryConsumer", [CSharpSyntaxTree.ParseText(source, new CSharpParseOptions(LanguageVersion.Preview))], - references, new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)); - } -} diff --git a/src/DimensionalQuantities.Roslyn.Tests/Generators/ArithmeticSourceEmitterTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Generators/ArithmeticSourceEmitterTests.cs deleted file mode 100644 index 6b7c2ff..0000000 --- a/src/DimensionalQuantities.Roslyn.Tests/Generators/ArithmeticSourceEmitterTests.cs +++ /dev/null @@ -1,102 +0,0 @@ -using System.Reflection; -using DimensionalQuantities.Dimensions; -using DimensionalQuantities.Roslyn.Discovery; -using DimensionalQuantities.Roslyn.Generators; -using DimensionalQuantities.TypeSystem; -using Microsoft.CodeAnalysis; -using Microsoft.CodeAnalysis.CSharp; -using Microsoft.CodeAnalysis.Emit; -using Xunit; - -namespace DimensionalQuantities.Roslyn.Tests.Generators; - -public sealed class ArithmeticSourceEmitterTests -{ - private static readonly CSharpParseOptions _parseOptions = new(LanguageVersion.Preview); - - [Fact] - public void ExplicitPlanEmitsUsableArithmetic() - { - Dimension current = new(ElectricCurrent: 1); - Dimension currentSquared = new(ElectricCurrent: 2); - Dimension resistance = new(Length: 2, Mass: 1, Time: -3, ElectricCurrent: -2); - Dimension currentResistance = current * resistance; - Dimension power = new(Length: 2, Mass: 1, Time: -3); - Dimension voltage = new(Length: 2, Mass: 1, Time: -3, ElectricCurrent: -1); - ArithmeticOperation[] operations = - [ - new(ArithmeticOperationKind.Multiply, current, current, currentSquared), - new(ArithmeticOperationKind.Multiply, currentSquared, resistance, power), - new(ArithmeticOperationKind.Multiply, current, resistance, currentResistance), - new(ArithmeticOperationKind.Multiply, current, currentResistance, power), - new(ArithmeticOperationKind.Divide, voltage, current, resistance) - ]; - QuantityGenerationPlan plan = QuantityDiscovery.Discover(operations); - const string source = """ - public static class Consumer - { - public static double Left() => (Current.FromAmps(2) * Current.FromAmps(3) * Resistance.FromSiBaseUnit(4)).AsSiBaseUnit(); - public static double Right() => (Current.FromAmps(2) * (Current.FromAmps(3) * Resistance.FromSiBaseUnit(4))).AsSiBaseUnit(); - public static double Divided() => (Voltage.FromSiBaseUnit(12) / Current.FromAmps(3)).AsSiBaseUnit(); - } - """; - Assembly assembly = CompileAndEmit(source, plan); - Type consumer = assembly.GetType("Consumer")!; - double left = (double)consumer.GetMethod("Left")!.Invoke(null, null)!; - double right = (double)consumer.GetMethod("Right")!.Invoke(null, null)!; - double divided = (double)consumer.GetMethod("Divided")!.Invoke(null, null)!; - - Assert.Multiple( - () => Assert.Equal(24, left), - () => Assert.Equal(24, right), - () => Assert.Equal(4, divided)); - } - - [Theory] - [InlineData("Current.FromAmps(3) * InverseCurrent.FromSiBaseUnit(2)", false)] - [InlineData("InverseCurrent.FromSiBaseUnit(2) * Current.FromAmps(3)", true)] - public void CancellingProductEmitsAnOperatorReturningDouble(string expression, bool inverseFirst) - { - Dimension current = new(ElectricCurrent: 1); - Dimension inverse = new(ElectricCurrent: -1); - ArithmeticOperation operation = inverseFirst - ? new(ArithmeticOperationKind.Multiply, inverse, current, default) - : new(ArithmeticOperationKind.Multiply, current, inverse, default); - QuantityGenerationPlan plan = QuantityDiscovery.Discover([operation]); - string source = $$""" - public static class Consumer - { - public static double Value() => {{expression}}; - } - """; - Assembly assembly = CompileAndEmit(source, plan); - double result = (double)assembly.GetType("Consumer")!.GetMethod("Value")!.Invoke(null, null)!; - double expected = 6; - - Assert.Equal(expected, result); - } - - private static Assembly CompileAndEmit(string source, QuantityGenerationPlan plan) - { - string[] assemblies = ((string)AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES")!).Split(Path.PathSeparator); - IEnumerable references = assemblies.Select(path => MetadataReference.CreateFromFile(path)) - .Append(MetadataReference.CreateFromFile(typeof(Quantity<>).Assembly.Location)); - CSharpCompilation input = CSharpCompilation.Create( - "ExplicitArithmeticConsumer", - [CSharpSyntaxTree.ParseText(source, _parseOptions, path: "Consumer.cs")], - references, - new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)); - SyntaxTree knownQuantities = CSharpSyntaxTree.ParseText(QuantitySourceEmitter.Emit(plan.KnownQuantities), _parseOptions, path: "KnownQuantities.g.cs"); - SyntaxTree additionalQuantities = CSharpSyntaxTree.ParseText(QuantitySourceEmitter.Emit(plan.AdditionalQuantities), _parseOptions, path: "AdditionalQuantities.g.cs"); - SyntaxTree arithmetic = CSharpSyntaxTree.ParseText(ArithmeticSourceEmitter.Emit(plan), _parseOptions, path: "Arithmetic.g.cs"); - CSharpCompilation compilation = input.AddSyntaxTrees(knownQuantities, additionalQuantities, arithmetic); - Diagnostic[] errors = compilation.GetDiagnostics(TestContext.Current.CancellationToken) - .Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error).ToArray(); - Assert.Empty(errors); - - using MemoryStream assemblyBytes = new(); - EmitResult emit = compilation.Emit(assemblyBytes, cancellationToken: TestContext.Current.CancellationToken); - Assert.True(emit.Success, string.Join(Environment.NewLine, emit.Diagnostics)); - return Assembly.Load(assemblyBytes.ToArray()); - } -} diff --git a/src/DimensionalQuantities.Roslyn.Tests/Generators/CoreConversionBoundaryTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Generators/CoreConversionBoundaryTests.cs deleted file mode 100644 index c5aed19..0000000 --- a/src/DimensionalQuantities.Roslyn.Tests/Generators/CoreConversionBoundaryTests.cs +++ /dev/null @@ -1,49 +0,0 @@ -using DimensionalQuantities.Roslyn.Tests.Testing; -using Microsoft.CodeAnalysis; -using Microsoft.CodeAnalysis.Testing; -using Xunit; - -namespace DimensionalQuantities.Roslyn.Tests.Generators; - -public sealed class CoreConversionBoundaryTests -{ - [Theory] - [InlineData("Voltage.FromVolts(12)")] - [InlineData("Voltage.FromPrefixedUnits(12, 0)")] - [InlineData("Voltage.FromSiBaseUnit(12).AsVolts()")] - [InlineData("Voltage.FromSiBaseUnit(12).AsPrefixedUnits(0)")] - public async Task CatalogueConversionsRequireAnExtensionPackage(string expression) - { - QuantityGeneratorTest test = new() - { - TestCode = $"public class Consumer {{ public object Value() => {expression}; }}", - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - CompilerDiagnostics = CompilerDiagnostics.None, - }; - await test.RunAsync(TestContext.Current.CancellationToken); - Diagnostic[] result = test.Compilation.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error).ToArray(); - - Assert.Contains(result, diagnostic => diagnostic.Id is "CS0117" or "CS1061" or "CS1929"); - } - - [Theory] - [InlineData("Length.FromMilliMetres(12).AsMetres()")] - [InlineData("Mass.FromKiloGrams(12).AsGrams()")] - [InlineData("Voltage.FromSiBaseUnit(12).AsSiBaseUnit()")] - [InlineData("Voltage.FromArbitrarySiComponents(12).AsArbitrarySiComponents()")] - [InlineData("(Length.FromMetres(2) * Current.FromAmps(3)).AsPrefixedUnits(3, 0)")] - [InlineData("Voltage.FromSiBaseUnit(12).Squared().AsSiBaseUnit()")] - public async Task BaseGenericAndIntermediateConversionsRemainAvailable(string expression) - { - QuantityGeneratorTest test = new() - { - TestCode = $"public class Consumer {{ public object Value() => {expression}; }}", - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - }; - await test.RunAsync(TestContext.Current.CancellationToken); - Diagnostic[] result = test.Compilation.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error).ToArray(); - - Assert.Empty(result); - } - -} diff --git a/src/DimensionalQuantities.Roslyn.Tests/Generators/DefaultQuantityDiscoveryTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Generators/DefaultQuantityDiscoveryTests.cs deleted file mode 100644 index 74cc02f..0000000 --- a/src/DimensionalQuantities.Roslyn.Tests/Generators/DefaultQuantityDiscoveryTests.cs +++ /dev/null @@ -1,48 +0,0 @@ -using DimensionalQuantities.Dimensions; -using DimensionalQuantities.Numerics; -using DimensionalQuantities.Roslyn.Discovery; -using DimensionalQuantities.Roslyn.Generators; -using Xunit; - -namespace DimensionalQuantities.Roslyn.Tests.Generators; - -public sealed class DefaultQuantityDiscoveryTests -{ - [Theory] - [InlineData("Squared", 2, 1)] - [InlineData("Cubed", 3, 1)] - [InlineData("Pow4", 4, 1)] - [InlineData("Pow5", 5, 1)] - [InlineData("Pow6", 6, 1)] - [InlineData("SquareRoot", 1, 2)] - [InlineData("CubeRoot", 1, 3)] - [InlineData("Root4", 1, 4)] - [InlineData("Root5", 1, 5)] - [InlineData("Root6", 1, 6)] - public void PlansEachConvenienceMethodForEveryBaseAndCatalogueDimension(string method, int numerator, int denominator) - { - Rational exponent = new(numerator, denominator); - Dimension[] dimensions = QuantityDiscovery.Discover([]).KnownQuantities.Select(quantity => quantity.Dimension).ToArray(); - PowerMethodOperation[] expected = dimensions.Select(dimension => new PowerMethodOperation(dimension, exponent, dimension.Pow(exponent), method)).ToArray(); - - QuantityGenerationPlan plan = DefaultQuantityDiscovery.Discover(); - PowerMethodOperation[] result = plan.PowerMethodOperations.Where(operation => operation.MethodName == method).ToArray(); - - Assert.Equal(expected, result); - } - - [Fact] - public void PlansReturnTypesWithoutRecursivelyAddingTheirConvenienceMethods() - { - QuantityGenerationPlan result = DefaultQuantityDiscovery.Discover(); - Dimension[] originalDimensions = result.KnownQuantities.Select(quantity => quantity.Dimension).ToArray(); - Dimension[] allDimensions = result.KnownQuantities.Concat(result.AdditionalQuantities).Select(quantity => quantity.Dimension).ToArray(); - - Assert.Multiple( - () => Assert.Equal(originalDimensions.Length * 10, result.PowerMethodOperations.Length), - () => Assert.All(result.PowerMethodOperations, operation => Assert.Contains(operation.Operand, originalDimensions)), - () => Assert.All(result.PowerMethodOperations, operation => Assert.Contains(operation.Result, allDimensions)), - () => Assert.Equal(allDimensions.Length, allDimensions.Distinct().Count()), - () => Assert.NotEmpty(result.AdditionalQuantities)); - } -} diff --git a/src/DimensionalQuantities.Roslyn.Tests/Generators/EnglishExponentAliasEmitterTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Generators/EnglishExponentAliasEmitterTests.cs deleted file mode 100644 index 5bcf85c..0000000 --- a/src/DimensionalQuantities.Roslyn.Tests/Generators/EnglishExponentAliasEmitterTests.cs +++ /dev/null @@ -1,71 +0,0 @@ -using DimensionalQuantities.Numerics; -using DimensionalQuantities.Roslyn.Discovery; -using DimensionalQuantities.Roslyn.Generators; -using DimensionalQuantities.TypeSystem; -using Microsoft.CodeAnalysis; -using Microsoft.CodeAnalysis.CSharp; -using Xunit; - -namespace DimensionalQuantities.Roslyn.Tests.Generators; - -public sealed class EnglishExponentAliasEmitterTests -{ - [Fact] - public void EmitsOnlyRequestedAliasesWithoutDuplicates() - { - EnglishExponentAlias[] aliases = - [ - new("NumberTwo", new Rational(2), "global::DimensionalQuantities.TypeSystem.TerminalHex2"), - new("NumberHalf", new Rational(1, 2), "global::DimensionalQuantities.TypeSystem.Fraction"), - new("NumberTwo", new Rational(2), "global::DimensionalQuantities.TypeSystem.TerminalHex2") - ]; - - string result = EnglishExponentAliasEmitter.Emit(aliases); - SyntaxTree tree = CSharpSyntaxTree.ParseText(result, new CSharpParseOptions(LanguageVersion.Preview), cancellationToken: TestContext.Current.CancellationToken); - string[] names = tree.GetCompilationUnitRoot(TestContext.Current.CancellationToken).Usings.Select(directive => directive.Alias!.Name.Identifier.ValueText).OrderBy(name => name).ToArray(); - string[] expected = ["NumberHalf", "NumberTwo"]; - - Assert.Equal(expected, names); - } - - [Fact] - public void AliasesResolveToTheirEncodedTypesInAnotherFile() - { - EnglishExponentAlias[] aliases = - [ - new("NumberTwo", new Rational(2), "global::DimensionalQuantities.TypeSystem.TerminalHex2"), - new("NumberHalf", new Rational(1, 2), "global::DimensionalQuantities.TypeSystem.Fraction") - ]; - const string source = "class Consumer { public NumberTwo Integer; public NumberHalf Fraction; }"; - CSharpParseOptions options = new(LanguageVersion.Preview); - string[] assemblies = ((string)AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES")!).Split(Path.PathSeparator); - IEnumerable references = assemblies.Select(path => MetadataReference.CreateFromFile(path)) - .Append(MetadataReference.CreateFromFile(typeof(Quantity<>).Assembly.Location)); - CSharpCompilation compilation = CSharpCompilation.Create("AliasConsumer", - [CSharpSyntaxTree.ParseText(EnglishExponentAliasEmitter.Emit(aliases), options, cancellationToken: TestContext.Current.CancellationToken), CSharpSyntaxTree.ParseText(source, options, cancellationToken: TestContext.Current.CancellationToken)], - references, new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)); - - INamedTypeSymbol consumer = compilation.GetTypeByMetadataName("Consumer")!; - IFieldSymbol integer = Assert.IsAssignableFrom(Assert.Single(consumer.GetMembers("Integer"))); - IFieldSymbol fraction = Assert.IsAssignableFrom(Assert.Single(consumer.GetMembers("Fraction"))); - TypeSystemNumberReader reader = new(compilation); - bool integerRead = reader.TryRead(integer.Type, out Rational integerResult, TestContext.Current.CancellationToken); - bool fractionRead = reader.TryRead(fraction.Type, out Rational fractionResult, TestContext.Current.CancellationToken); - - Assert.Multiple( - () => Assert.Empty(compilation.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)), - () => Assert.True(integerRead), - () => Assert.True(fractionRead), - () => Assert.Equal(new Rational(2), integerResult), - () => Assert.Equal(new Rational(1, 2), fractionResult)); - } - - [Fact] - public void NoRequestedNamesProducesNoAliases() - { - string result = EnglishExponentAliasEmitter.Emit([]); - SyntaxTree tree = CSharpSyntaxTree.ParseText(result, new CSharpParseOptions(LanguageVersion.Preview), cancellationToken: TestContext.Current.CancellationToken); - - Assert.Empty(tree.GetCompilationUnitRoot(TestContext.Current.CancellationToken).Usings); - } -} diff --git a/src/DimensionalQuantities.Roslyn.Tests/Generators/GenerationDiagnosticTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Generators/GenerationDiagnosticTests.cs deleted file mode 100644 index 13674b1..0000000 --- a/src/DimensionalQuantities.Roslyn.Tests/Generators/GenerationDiagnosticTests.cs +++ /dev/null @@ -1,221 +0,0 @@ -using DimensionalQuantities.Roslyn.Tests.Testing; -using DimensionalQuantities.TypeSystem; -using Microsoft.CodeAnalysis; -using Microsoft.CodeAnalysis.Emit; -using Microsoft.CodeAnalysis.Testing; -using Xunit; - -namespace DimensionalQuantities.Roslyn.Tests.Generators; - -public sealed class GenerationDiagnosticTests -{ - [Fact] - public async Task GeneratedAliasWarnsWhenItShadowsAnImportedType() - { - const string source = """ - using Other; - namespace Other { public class Current { } } - public class Consumer { public Current Value { get; } } - """; - await new QuantityGeneratorTest - { - TestCode = source.Replace("public Current Value", "public {|#0:Current|} Value"), - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - ExpectedDiagnostics = { new DiagnosticResult("DQ0006", DiagnosticSeverity.Warning).WithLocation(0).WithArguments("Current") }, - }.RunAsync(TestContext.Current.CancellationToken); - } - - [Fact] - public async Task ImportedMetadataTypeShadowingIsDiagnosed() - { - QuantityGeneratorTest library = new() - { - TestCode = "namespace Other { public class Current { } }", - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - }; - await library.RunAsync(TestContext.Current.CancellationToken); - using MemoryStream bytes = new(); - EmitResult emitted = library.Compilation.WithAssemblyName("OtherLibrary").Emit(bytes, cancellationToken: TestContext.Current.CancellationToken); - if (!emitted.Success) - { - throw new InvalidOperationException(string.Join(Environment.NewLine, emitted.Diagnostics)); - } - await new QuantityGeneratorTest - { - TestCode = "using Other; public class Consumer { public {|#0:Current|} Value { get; } }", - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - TestState = { AdditionalReferences = { MetadataReference.CreateFromImage(bytes.ToArray()) } }, - ExpectedDiagnostics = { new DiagnosticResult("DQ0006", DiagnosticSeverity.Warning).WithLocation(0).WithArguments("Current") }, - }.RunAsync(TestContext.Current.CancellationToken); - } - - [Fact] - public async Task CollisionWarningPreservesTheGeneratedAliasBinding() - { - const string source = "using Other; namespace Other { public class Current { } } public class Consumer { public Current Value { get; } }"; - QuantityGeneratorTest test = new() - { - TestCode = source.Replace("public Current Value", "public {|#0:Current|} Value"), - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - ExpectedDiagnostics = { new DiagnosticResult("DQ0006", DiagnosticSeverity.Warning).WithLocation(0).WithArguments("Current") }, - }; - await test.RunAsync(TestContext.Current.CancellationToken); - Compilation generated = test.Compilation; - IPropertySymbol property = (IPropertySymbol)generated.GetTypeByMetadataName("Consumer")!.GetMembers("Value").Single(); - INamedTypeSymbol result = ((INamedTypeSymbol)property.Type).OriginalDefinition; - INamedTypeSymbol expected = generated.GetTypeByMetadataName(typeof(Quantity<>).FullName!)!; - - Assert.Multiple( - () => Assert.True(SymbolEqualityComparer.Default.Equals(expected, result))); - } - - [Theory] - [InlineData("public class Current { } public class Consumer { }")] - [InlineData("public delegate void Current();")] - [InlineData("using Current = Other.Current; namespace Other { public class Current { } } public class Consumer { public Current Value { get; } }")] - public async Task ConflictingDeclarationsAndExplicitAliasesWarn(string source) - { - await new QuantityGeneratorTest - { - TestCode = source.Insert(source.IndexOf("Current", StringComparison.Ordinal) + "Current".Length, "|}").Insert(source.IndexOf("Current", StringComparison.Ordinal), "{|#0:"), - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - CompilerDiagnostics = CompilerDiagnostics.None, - ExpectedDiagnostics = { new DiagnosticResult("DQ0006", DiagnosticSeverity.Warning).WithLocation(0).WithArguments("Current") }, - }.RunAsync(TestContext.Current.CancellationToken); - } - - [Fact] - public async Task StaticMemberUseOfImportedTypeWarnsWhenShadowed() - { - const string source = """ - using Other; - namespace Other { public class Current { public static int Create() => 1; } } - public class Consumer { public int Value => Current.Create(); } - """; - await new QuantityGeneratorTest - { - TestCode = source.Replace("=> Current.Create()", "=> {|#0:Current|}.Create()"), - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - CompilerDiagnostics = CompilerDiagnostics.None, - ExpectedDiagnostics = { new DiagnosticResult("DQ0006", DiagnosticSeverity.Warning).WithLocation(0).WithArguments("Current") }, - }.RunAsync(TestContext.Current.CancellationToken); - } - - [Fact] - public async Task UnusedSameNamedTypeInAnotherNamespaceDoesNotWarn() - { - const string source = "namespace Other { public class Current { } } public class Consumer { public Current Value { get; } }"; - await new QuantityGeneratorTest - { - TestCode = source, - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - }.RunAsync(TestContext.Current.CancellationToken); - } - - [Fact] - public async Task QualifiedReferenceToSameNamedTypeDoesNotWarn() - { - const string source = "namespace Other { public class Current { } } public class Consumer { public Other.Current Value { get; } }"; - await new QuantityGeneratorTest - { - TestCode = source, - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - }.RunAsync(TestContext.Current.CancellationToken); - } - - [Theory] - [InlineData("NumberTwoOverZero")] - [InlineData("NumberBanana")] - public async Task InvalidEnglishExponentExplainsUnresolvedRequest(string name) - { - string source = $$""" - using DimensionalQuantities.TypeSystem; - public class Consumer { public object Calculate(Length length) => Power<{{name}}>.Of(length); } - """; - await new QuantityGeneratorTest - { - TestCode = source.Replace(name, "{|#0:" + name + "|}"), - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - CompilerDiagnostics = CompilerDiagnostics.None, - ExpectedDiagnostics = { new DiagnosticResult("DQ0007", DiagnosticSeverity.Error).WithLocation(0).WithArguments(name) }, - }.RunAsync(TestContext.Current.CancellationToken); - } - - [Fact] - public async Task FileLocalAliasElsewhereDoesNotHideInvalidEnglishExponent() - { - const string source = "using DimensionalQuantities.TypeSystem; public class Consumer { public object Calculate(Length length) => Power.Of(length); }"; - await new QuantityGeneratorTest - { - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - CompilerDiagnostics = CompilerDiagnostics.None, - TestState = - { - Sources = - { - ("Consumer.cs", source.Replace("NumberBanana", "{|#0:NumberBanana|}")), - ("OtherConsumer.cs", "using NumberBanana = System.Int32; public class OtherConsumer { }"), - }, - }, - ExpectedDiagnostics = { new DiagnosticResult("DQ0007", DiagnosticSeverity.Error).WithLocation(0).WithArguments("NumberBanana") }, - }.RunAsync(TestContext.Current.CancellationToken); - } - - [Theory] - [InlineData("using DimensionalQuantities.TypeSystem; public class Consumer { public object Calculate(Length length) => Power.Of(length); }")] - [InlineData("using DimensionalQuantities.TypeSystem; public class Consumer { public object Calculate(Length length) => Power.Of(length); }")] - [InlineData("public class Power { public static double Of(double value) => value; } public class Consumer { public object Calculate() => Power.Of(2); }")] - [InlineData("using NumberTwo = DimensionalQuantities.TypeSystem.TerminalHex2; using DimensionalQuantities.TypeSystem; public class Consumer { public object Calculate(Length length) => Power.Of(length); }")] - [InlineData("using DimensionalQuantities.TypeSystem; public class NumberBanana { } public class Consumer { public object Calculate(Length length) => Power.Of(length); }")] - public async Task BoundNamesAndUnrelatedRequestsDoNotProduceGenerationDiagnostics(string source) - { - await new QuantityGeneratorTest - { - TestCode = source, - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - CompilerDiagnostics = CompilerDiagnostics.None, - }.RunAsync(TestContext.Current.CancellationToken); - } - - [Fact] - public async Task InvalidNumericEncodingDoesNotCrashGenerator() - { - const string source = """ - using DimensionalQuantities.TypeSystem; - public class Consumer - { - public object Calculate(Length length) => Power>.Of(length); - } - """; - await new QuantityGeneratorTest - { - TestCode = source, - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - CompilerDiagnostics = CompilerDiagnostics.None, - }.RunAsync(TestContext.Current.CancellationToken); - } - - [Fact] - public async Task InvalidEnglishExponentHasAResolutionDiagnostic() - { - const string source = "using DimensionalQuantities.TypeSystem; public class Consumer { public object Calculate(Length length) => Power<{|#0:NumberBanana|}>.Of(length); }"; - await new QuantityGeneratorTest - { - TestCode = source, - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - CompilerDiagnostics = CompilerDiagnostics.None, - ExpectedDiagnostics = { new DiagnosticResult("DQ0007", DiagnosticSeverity.Error).WithLocation(0).WithArguments("NumberBanana") }, - }.RunAsync(TestContext.Current.CancellationToken); - } - - [Fact] - public async Task ValidEnglishExponentHasNoResolutionDiagnostic() - { - const string source = "using DimensionalQuantities.TypeSystem; public class Consumer { public object Calculate(Length length) => Power.Of(length); }"; - await new QuantityGeneratorTest - { - TestCode = source, - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - }.RunAsync(TestContext.Current.CancellationToken); - } -} diff --git a/src/DimensionalQuantities.Roslyn.Tests/Generators/PowerMethodSourceEmitterTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Generators/PowerMethodSourceEmitterTests.cs deleted file mode 100644 index f465fd7..0000000 --- a/src/DimensionalQuantities.Roslyn.Tests/Generators/PowerMethodSourceEmitterTests.cs +++ /dev/null @@ -1,104 +0,0 @@ -using System.Reflection; -using DimensionalQuantities.Dimensions; -using DimensionalQuantities.Numerics; -using DimensionalQuantities.Roslyn.Discovery; -using DimensionalQuantities.Roslyn.Generators; -using DimensionalQuantities.TypeSystem; -using Microsoft.CodeAnalysis; -using Microsoft.CodeAnalysis.CSharp; -using Microsoft.CodeAnalysis.Emit; -using Xunit; - -namespace DimensionalQuantities.Roslyn.Tests.Generators; - -public sealed class PowerMethodSourceEmitterTests -{ - [Theory] - [InlineData("Squared", 2, 1)] - [InlineData("SquareRoot", 1, 2)] - public void ConvenienceMethodDelegatesToTheEncodedPowerOverload(string method, int numerator, int denominator) - { - Dimension operand = new(Length: 1); - Rational exponent = new(numerator, denominator); - PowerMethodOperation operation = new(operand, exponent, operand.Pow(exponent), method); - QuantityGenerationPlan plan = QuantityDiscovery.Discover([], [], [operation]); - string exponentType = TypeSystemTypeNameFormatter.Format(TypeSystemNumberCodec.CreateType(exponent)); - string resultType = plan.GetQuantityName(operation.Result); - string source = $$""" - namespace DimensionalQuantities.Generated; - public static class StubPowerExtensions - { - extension(global::DimensionalQuantities.TypeSystem.Power<{{exponentType}}>) - { - public static {{resultType}} Of(Length value) => {{resultType}}.FromSiBaseUnit(value.AsSiBaseUnit() + 100); - } - } - public static class Consumer - { - public static double Value() => Length.FromMetres(9).{{method}}().AsSiBaseUnit(); - } - """; - CSharpParseOptions options = new(LanguageVersion.Preview); - string[] assemblies = ((string)AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES")!).Split(Path.PathSeparator); - IEnumerable references = assemblies.Select(path => MetadataReference.CreateFromFile(path)) - .Append(MetadataReference.CreateFromFile(typeof(Quantity<>).Assembly.Location)); - SyntaxTree[] trees = - [ - CSharpSyntaxTree.ParseText(source, options, cancellationToken: TestContext.Current.CancellationToken), - CSharpSyntaxTree.ParseText(QuantitySourceEmitter.Emit(plan.KnownQuantities), options, cancellationToken: TestContext.Current.CancellationToken), - CSharpSyntaxTree.ParseText(QuantitySourceEmitter.Emit(plan.AdditionalQuantities), options, cancellationToken: TestContext.Current.CancellationToken), - CSharpSyntaxTree.ParseText(PowerMethodSourceEmitter.Emit(plan), options, cancellationToken: TestContext.Current.CancellationToken) - ]; - CSharpCompilation compilation = CSharpCompilation.Create("DelegatingPowerConsumer", trees, references, new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)); - using MemoryStream assemblyBytes = new(); - EmitResult emit = compilation.Emit(assemblyBytes, cancellationToken: TestContext.Current.CancellationToken); - Assert.True(emit.Success, string.Join(Environment.NewLine, emit.Diagnostics)); - Assembly assembly = Assembly.Load(assemblyBytes.ToArray()); - - double result = (double)assembly.GetType("DimensionalQuantities.Generated.Consumer")!.GetMethod("Value")!.Invoke(null, null)!; - - Assert.Equal(109, result); - } - - [Theory] - [InlineData("Squared", 2, 1, -3, 9)] - [InlineData("CubeRoot", 1, 3, -8, -2)] - [InlineData("Root5", 1, 5, -32, -2)] - [InlineData("SquareRoot", 1, 2, -9, double.NaN)] - [InlineData("Root4", 1, 4, -16, double.NaN)] - public void EmittedMethodsUseTheRealOddRootAndPreserveEvenRootBehaviour(string method, int numerator, int denominator, double value, double expected) - { - Dimension operand = new(Length: 1); - Rational exponent = new(numerator, denominator); - Dimension resultDimension = operand.Pow(exponent); - PowerMethodOperation operation = new(operand, exponent, resultDimension, method); - QuantityGenerationPlan plan = QuantityDiscovery.Discover([], [], [operation]); - string source = $$""" - public static class Consumer - { - public static double Value() => Length.FromMetres({{value.ToString(System.Globalization.CultureInfo.InvariantCulture)}}).{{method}}().AsSiBaseUnit(); - } - """; - CSharpParseOptions options = new(LanguageVersion.Preview); - string[] assemblies = ((string)AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES")!).Split(Path.PathSeparator); - IEnumerable references = assemblies.Select(path => MetadataReference.CreateFromFile(path)) - .Append(MetadataReference.CreateFromFile(typeof(Quantity<>).Assembly.Location)); - SyntaxTree[] trees = - [ - CSharpSyntaxTree.ParseText(source, options, cancellationToken: TestContext.Current.CancellationToken), - CSharpSyntaxTree.ParseText(QuantitySourceEmitter.Emit(plan.KnownQuantities), options, cancellationToken: TestContext.Current.CancellationToken), - CSharpSyntaxTree.ParseText(QuantitySourceEmitter.Emit(plan.AdditionalQuantities), options, cancellationToken: TestContext.Current.CancellationToken), - CSharpSyntaxTree.ParseText(PowerMethodSourceEmitter.Emit(plan), options, cancellationToken: TestContext.Current.CancellationToken), - CSharpSyntaxTree.ParseText(PowerSourceEmitter.Emit(plan), options, cancellationToken: TestContext.Current.CancellationToken) - ]; - CSharpCompilation compilation = CSharpCompilation.Create("PowerMethodConsumer", trees, references, new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)); - using MemoryStream assemblyBytes = new(); - EmitResult emit = compilation.Emit(assemblyBytes, cancellationToken: TestContext.Current.CancellationToken); - Assert.True(emit.Success, string.Join(Environment.NewLine, emit.Diagnostics)); - Assembly assembly = Assembly.Load(assemblyBytes.ToArray()); - - double result = (double)assembly.GetType("Consumer")!.GetMethod("Value")!.Invoke(null, null)!; - - Assert.Equal(expected, result, 12); - } -} diff --git a/src/DimensionalQuantities.Roslyn.Tests/Generators/PowerSourceEmitterTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Generators/PowerSourceEmitterTests.cs deleted file mode 100644 index 8e1c06d..0000000 --- a/src/DimensionalQuantities.Roslyn.Tests/Generators/PowerSourceEmitterTests.cs +++ /dev/null @@ -1,75 +0,0 @@ -using System.Reflection; -using DimensionalQuantities.Dimensions; -using DimensionalQuantities.Numerics; -using DimensionalQuantities.Roslyn.Discovery; -using DimensionalQuantities.Roslyn.Generators; -using DimensionalQuantities.TypeSystem; -using Microsoft.CodeAnalysis; -using Microsoft.CodeAnalysis.CSharp; -using Microsoft.CodeAnalysis.Emit; -using Xunit; - -namespace DimensionalQuantities.Roslyn.Tests.Generators; - -public sealed class PowerSourceEmitterTests -{ - private static readonly CSharpParseOptions _parseOptions = new(LanguageVersion.Preview); - - [Fact] - public void DifferentPowersReturnTheExpectedQuantityTypes() - { - Dimension length = new(Length: 1); - PowerOperation[] operations = - [ - new(length, 2, new(Length: 2), "global::DimensionalQuantities.TypeSystem.TerminalHex2"), - new(length, 3, new(Length: 3), "global::DimensionalQuantities.TypeSystem.TerminalHex3"), - new(new(Length: 2), new Rational(1, 2), length, "global::DimensionalQuantities.TypeSystem.Fraction"), - new(length, 0, default, "global::DimensionalQuantities.TypeSystem.TerminalHex0") - ]; - QuantityGenerationPlan plan = QuantityDiscovery.Discover([], operations); - const string source = """ - using DimensionalQuantities.TypeSystem; - public static class Consumer - { - public static double Value() - { - Length length = Length.FromMetres(3); - Area area = Power.Of(length); - Volume volume = Power.Of(length); - Length root = Power>.Of(area); - double identity = Power.Of(length); - return area.AsSiBaseUnit() + volume.AsSiBaseUnit() + root.AsSiBaseUnit() + identity; - } - } - """; - Assembly assembly = CompileAndEmit(source, plan); - double result = (double)assembly.GetType("Consumer")!.GetMethod("Value")!.Invoke(null, null)!; - double expected = 40; - - Assert.Equal(expected, result); - } - - private static Assembly CompileAndEmit(string source, QuantityGenerationPlan plan) - { - string[] assemblies = ((string)AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES")!).Split(Path.PathSeparator); - IEnumerable references = assemblies.Select(path => MetadataReference.CreateFromFile(path)) - .Append(MetadataReference.CreateFromFile(typeof(Quantity<>).Assembly.Location)); - CSharpCompilation input = CSharpCompilation.Create( - "ExplicitPowerConsumer", - [CSharpSyntaxTree.ParseText(source, _parseOptions, path: "Consumer.cs")], - references, - new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)); - SyntaxTree knownQuantities = CSharpSyntaxTree.ParseText(QuantitySourceEmitter.Emit(plan.KnownQuantities), _parseOptions, path: "KnownQuantities.g.cs"); - SyntaxTree additionalQuantities = CSharpSyntaxTree.ParseText(QuantitySourceEmitter.Emit(plan.AdditionalQuantities), _parseOptions, path: "AdditionalQuantities.g.cs"); - SyntaxTree powers = CSharpSyntaxTree.ParseText(PowerSourceEmitter.Emit(plan), _parseOptions, path: "Powers.g.cs"); - CSharpCompilation compilation = input.AddSyntaxTrees(knownQuantities, additionalQuantities, powers); - Diagnostic[] errors = compilation.GetDiagnostics(TestContext.Current.CancellationToken) - .Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error).ToArray(); - Assert.Empty(errors); - - using MemoryStream assemblyBytes = new(); - EmitResult emit = compilation.Emit(assemblyBytes, cancellationToken: TestContext.Current.CancellationToken); - Assert.True(emit.Success, string.Join(Environment.NewLine, emit.Diagnostics)); - return Assembly.Load(assemblyBytes.ToArray()); - } -} diff --git a/src/DimensionalQuantities.Roslyn.Tests/Generators/QuantityDiscoveryTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Generators/QuantityDiscoveryTests.cs deleted file mode 100644 index ab22999..0000000 --- a/src/DimensionalQuantities.Roslyn.Tests/Generators/QuantityDiscoveryTests.cs +++ /dev/null @@ -1,202 +0,0 @@ -using DimensionalQuantities.Dimensions; -using DimensionalQuantities.Numerics; -using DimensionalQuantities.Roslyn.Discovery; -using DimensionalQuantities.Roslyn.Generators; -using DimensionalQuantities.Units; -using DimensionalQuantities.TypeSystem; -using Xunit; - -namespace DimensionalQuantities.Roslyn.Tests.Generators; - -public sealed class QuantityDiscoveryTests -{ - [Fact] - public void TypeRequestsAddOnlyMissingQuantitiesWithoutInventingOperations() - { - QuantityGenerationPlan predefined = DefaultQuantityDiscovery.Discover(); - Dimension requested = new(Length: 1, ElectricCurrent: 1); - - QuantityGenerationPlan result = QuantityDiscovery.DiscoverWithPredefinedQuantities(predefined, [], [], [], - [requested, requested, new(ElectricCurrent: 1), new(ElectricCurrent: 2), default]); - - Assert.Multiple( - () => Assert.Equal(requested, Assert.Single(result.AdditionalQuantities).Dimension), - () => Assert.Equal("LengthCurrent", result.GetQuantityName(requested)), - () => Assert.Empty(result.Operations), - () => Assert.Empty(result.PowerOperations), - () => Assert.Empty(result.PowerMethodOperations)); - } - - [Fact] - public void ReusesPredefinedQuantitiesAndOnlyAddsNewResults() - { - Dimension currentSquared = new(ElectricCurrent: 2); - Dimension length = new(Length: 1); - Dimension product = new(Length: 1, ElectricCurrent: 2); - PlannedQuantity predefined = new(currentSquared, [new("CurrentSquared", [new(AtomicUnits.Amp, 2)])], false); - ArithmeticOperation operation = new(ArithmeticOperationKind.Multiply, currentSquared, length, product); - - QuantityGenerationPlan predefinedPlan = new([], [predefined, predefined], [], [], []); - - QuantityGenerationPlan result = QuantityDiscovery.DiscoverWithPredefinedQuantities(predefinedPlan, [operation], [], []); - - Assert.Multiple( - () => Assert.Equal(predefined, Assert.Single(result.KnownQuantities.Where(quantity => quantity.Dimension == currentSquared))), - () => Assert.Equal(product, Assert.Single(result.AdditionalQuantities).Dimension), - () => Assert.Equal("CurrentSquared", result.GetQuantityName(currentSquared)), - () => Assert.Equal(operation, Assert.Single(result.Operations))); - } - - [Fact] - public void ReusesPredefinedMethodsWhilePlanningNewConvenienceMethods() - { - Dimension current = new(ElectricCurrent: 1); - Dimension squared = new(ElectricCurrent: 2); - Dimension cubed = new(ElectricCurrent: 3); - PlannedQuantity predefined = new(squared, [new("CurrentSquared", [new(AtomicUnits.Amp, 2)])], false); - PowerMethodOperation square = new(current, 2, squared, "Squared"); - PowerMethodOperation cube = new(current, 3, cubed, "Cubed"); - - QuantityGenerationPlan predefinedPlan = new([], [predefined], [], [], [square]); - - QuantityGenerationPlan result = QuantityDiscovery.DiscoverWithPredefinedQuantities(predefinedPlan, [], [], [square, cube]); - - Assert.Multiple( - () => Assert.Equal(cube, Assert.Single(result.PowerMethodOperations)), - () => Assert.Equal(cubed, Assert.Single(result.AdditionalQuantities).Dimension)); - } - - [Theory] - [InlineData("Squared", 2, 1)] - [InlineData("SquareRoot", 1, 2)] - public void ConvenienceMethodsReuseExplicitCanonicalPowerOperations(string method, int numerator, int denominator) - { - Dimension current = new(ElectricCurrent: 1); - Rational exponent = new(numerator, denominator); - Dimension resultDimension = current.Pow(exponent); - string exponentType = TypeSystemTypeNameFormatter.Format(TypeSystemNumberCodec.CreateType(exponent)); - PowerOperation expected = new(current, exponent, resultDimension, exponentType); - PowerMethodOperation convenience = new(current, exponent, resultDimension, method); - - QuantityGenerationPlan result = QuantityDiscovery.Discover([], [expected], [convenience]); - - Assert.Multiple( - () => Assert.Equal(expected, Assert.Single(result.PowerOperations)), - () => Assert.Equal(convenience, Assert.Single(result.PowerMethodOperations))); - } - - [Fact] - public void ConvenienceMethodAddsCanonicalPowerAlongsideAnExplicitAlternativeEncoding() - { - Dimension current = new(ElectricCurrent: 1); - Dimension squared = new(ElectricCurrent: 2); - string alternativeType = TypeSystemTypeNameFormatter.Format(typeof(Fraction)); - string canonicalType = TypeSystemTypeNameFormatter.Format(typeof(TerminalHex2)); - PowerOperation alternative = new(current, 2, squared, alternativeType); - PowerOperation canonical = new(current, 2, squared, canonicalType); - PowerMethodOperation convenience = new(current, 2, squared, "Squared"); - - QuantityGenerationPlan result = QuantityDiscovery.Discover([], [alternative], [convenience]); - - Assert.Multiple( - () => Assert.Equal(2, result.PowerOperations.Length), - () => Assert.Contains(alternative, result.PowerOperations), - () => Assert.Contains(canonical, result.PowerOperations)); - } - - [Fact] - public void ConvenienceMethodsDeduplicateByOperandAndNameAndPlanTheirDimensions() - { - Dimension current = new(ElectricCurrent: 1); - Dimension squared = new(ElectricCurrent: 2); - Dimension cubed = new(ElectricCurrent: 3); - PowerMethodOperation square = new(current, 2, squared, "Squared"); - PowerMethodOperation cube = new(current, 3, cubed, "Cubed"); - PowerMethodOperation squareAgain = new(squared, 2, new(ElectricCurrent: 4), "Squared"); - PowerMethodOperation[] expected = [square, cube, squareAgain]; - - QuantityGenerationPlan result = QuantityDiscovery.Discover([], [], [square, square, cube, squareAgain]); - - Assert.Multiple( - () => Assert.Equal(expected, result.PowerMethodOperations), - () => Assert.Equal("CurrentSquared", result.GetQuantityName(squared)), - () => Assert.Equal("CurrentCubed", result.GetQuantityName(cubed)), - () => Assert.Equal(3, result.AdditionalQuantities.Length)); - } - - [Fact] - public void PlanKeepsCatalogueNameAndDeduplicatesOrderedOperations() - { - Dimension current = new(ElectricCurrent: 1); - Dimension currentSquared = new(ElectricCurrent: 2); - Dimension resistance = new(Length: 2, Mass: 1, Time: -3, ElectricCurrent: -2); - Dimension power = new(Length: 2, Mass: 1, Time: -3); - Dimension energy = new(Length: 2, Mass: 1, Time: -2); - ArithmeticOperation square = new(ArithmeticOperationKind.Multiply, current, current, currentSquared); - ArithmeticOperation heat = new(ArithmeticOperationKind.Multiply, currentSquared, resistance, power); - ArithmeticOperation[] operations = [square, square, heat]; - QuantityGenerationPlan plan = QuantityDiscovery.Discover(operations); - ArithmeticOperation[] expected = [square, heat]; - - Assert.Multiple( - () => Assert.Equal(expected, plan.Operations), - () => Assert.Equal("Power", plan.GetQuantityName(power)), - () => Assert.Equal("Energy", plan.GetQuantityName(energy)), - () => Assert.Equal("CurrentSquared", plan.GetQuantityName(currentSquared)), - () => Assert.Single(plan.AdditionalQuantities)); - } - - [Fact] - public void CancellingProductPlansOperandsWithoutADimensionlessQuantity() - { - Dimension current = new(ElectricCurrent: 1); - Dimension inverse = new(ElectricCurrent: -1); - ArithmeticOperation operation = new(ArithmeticOperationKind.Multiply, current, inverse, default); - QuantityGenerationPlan result = QuantityDiscovery.Discover([operation, operation]); - - Assert.Multiple( - () => Assert.Equal(operation, Assert.Single(result.Operations)), - () => Assert.Equal(inverse, Assert.Single(result.AdditionalQuantities).Dimension), - () => Assert.DoesNotContain(result.KnownQuantities, quantity => quantity.Dimension == default)); - } - - [Fact] - public void EquivalentExponentsKeepTheirOverloadsAndShareOneResultType() - { - Dimension current = new(ElectricCurrent: 1); - Dimension rootCurrent = new(ElectricCurrent: new Rational(1, 2)); - PowerOperation half = new(current, new Rational(1, 2), rootCurrent, - "global::DimensionalQuantities.TypeSystem.Fraction"); - PowerOperation twoQuarters = half with - { - ExponentTypeName = "global::DimensionalQuantities.TypeSystem.Fraction" - }; - PowerOperation zero = new(current, Rational.Zero, default, "global::DimensionalQuantities.TypeSystem.TerminalHex0"); - QuantityGenerationPlan result = QuantityDiscovery.Discover([], [half, half, twoQuarters, zero]); - PowerOperation[] expected = [half, twoQuarters, zero]; - - Assert.Multiple( - () => Assert.Equal(expected, result.PowerOperations), - () => Assert.Equal(rootCurrent, Assert.Single(result.AdditionalQuantities).Dimension), - () => Assert.Empty(result.Operations)); - } - - [Fact] - public void UnknownQuantityUsesSiComponentPowersAndBasePrefixes() - { - Dimension mass = new(Mass: 1); - Dimension massSquared = new(Mass: 2); - ArithmeticOperation operation = new(ArithmeticOperationKind.Multiply, mass, mass, massSquared); - QuantityGenerationPlan plan = QuantityDiscovery.Discover([operation]); - PlannedQuantity quantity = Assert.Single(plan.AdditionalQuantities); - UnitDefinition unit = Assert.Single(quantity.Units); - UnitTerm term = Assert.Single(unit.Expression.Terms); - - Assert.Multiple( - () => Assert.Equal(massSquared, quantity.Dimension), - () => Assert.False(quantity.IncludeNamedConversions), - () => Assert.Equal("MassSquared", unit.Name), - () => Assert.Equal(2, term.Power), - () => Assert.Equal(SiBasePrefixExponents.Mass, term.PrefixExponent)); - } -} diff --git a/src/DimensionalQuantities.Roslyn.Tests/Generators/QuantityGeneratorTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Generators/QuantityGeneratorTests.cs deleted file mode 100644 index b45241f..0000000 --- a/src/DimensionalQuantities.Roslyn.Tests/Generators/QuantityGeneratorTests.cs +++ /dev/null @@ -1,1517 +0,0 @@ -using System.Text; -using DimensionalQuantities.TypeSystem; -using DimensionalQuantities.Roslyn.Generators; -using DimensionalQuantities.Dimensions; -using DimensionalQuantities.Roslyn.Discovery; -using DimensionalQuantities.Roslyn.Tests.Testing; -using Microsoft.CodeAnalysis; -using Microsoft.CodeAnalysis.CSharp; -using Microsoft.CodeAnalysis.CSharp.Syntax; -using Microsoft.CodeAnalysis.Testing; -using Microsoft.CodeAnalysis.Text; -using Xunit; - -namespace DimensionalQuantities.Roslyn.Tests.Generators; - -public sealed class QuantityGeneratorTests -{ - - [Fact] - public async Task BaseAliasesHaveUnprefixedFactoriesAndAccessors() - { - const string source = """ - public static class Consumer - { - public static double UseBaseQuantities() - { - Length length = Length.FromMetres(1); - Mass mass = Mass.FromGrams(1000); - Time time = Time.FromSeconds(1); - Current current = Current.FromAmps(1); - Temperature temperature = Temperature.FromKelvin(1); - AmountOfSubstance amount = AmountOfSubstance.FromMoles(1); - LuminousIntensity intensity = LuminousIntensity.FromCandelas(1); - return length.AsMetres() + mass.AsGrams() + time.AsSeconds() + current.AsAmps() - + temperature.AsKelvin() + amount.AsMoles() + intensity.AsCandelas(); - } - } - """; - - await new QuantityGeneratorTest - { - TestCode = source, - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - }.RunAsync(TestContext.Current.CancellationToken); - } - - [Fact] - public async Task SemanticPipelineResolvesPostInitialisationQuantityAliasesAndFactories() - { - const string source = """ - public static class Consumer - { - public static Length Use(Length input) => Length.FromMetres(2); - } - """; - - QuantityGeneratorTest resultTest = new() - { - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - AdditionalGenerator = typeof(SemanticProbeGenerator), - TestState = - { - Sources = { ("Consumer.cs", source) }, - }, - }; - await resultTest.RunAsync(TestContext.Current.CancellationToken); - Compilation result = resultTest.Compilation; - INamedTypeSymbol probe = result.GetTypeByMetadataName("SemanticProbe")!; - IFieldSymbol aliasResolved = Assert.IsAssignableFrom(Assert.Single(probe.GetMembers("AliasResolved"))); - IFieldSymbol factoryResolved = Assert.IsAssignableFrom(Assert.Single(probe.GetMembers("FactoryResolved"))); - - Assert.Multiple( - () => Assert.Equal(true, aliasResolved.ConstantValue), - () => Assert.Equal(true, factoryResolved.ConstantValue)); - } - - [Fact] - public async Task CatalogueAliasesAreAvailableToConsumers() - { - const string source = """ - public static class Consumer - { - public static global::System.Type[] Types() => - [ - typeof(Area), typeof(Volume), typeof(Frequency), typeof(AngularVelocity), typeof(Density), - typeof(Pressure), typeof(Stress), typeof(YoungsModulus), typeof(Energy), typeof(Torque), - typeof(Power), typeof(SpecificPower), typeof(SpecificPowerLoss), typeof(TemperatureCoefficient), - typeof(PowerDensity), typeof(VolumetricPowerLoss), typeof(Voltage), typeof(Resistance), - typeof(Inductance), typeof(MagneticFlux), typeof(FluxLinkage), typeof(MagneticFluxDensity), - typeof(MagneticPolarisation), typeof(RemanentFluxDensity), typeof(MagneticFieldStrength), - typeof(CoerciveFieldStrength), typeof(CurrentDensity), typeof(Permeability), typeof(Resistivity), - typeof(Conductivity), typeof(MagneticReluctivity), typeof(MagneticVectorPotential) - ]; - } - """; - - await new QuantityGeneratorTest - { - TestCode = source, - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - }.RunAsync(TestContext.Current.CancellationToken); - } - - [Fact] - public async Task QuantityArithmeticAcceptsTypedMethodParametersAndReturns() - { - const string source = """ - public static class Consumer - { - public static Area Multiply(Length left, Length right) => left * right; - public static Voltage Divide(Power power, Current current) => power / current; - public static InverseCurrent Invert(double numerator, Current current) => numerator / current; - } - """; - - await new QuantityGeneratorTest - { - TestCode = source, - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - }.RunAsync(TestContext.Current.CancellationToken); - } - - [Fact] - public async Task RepeatedConsumerOperationIsEmittedOnce() - { - const string source = """ - public static class Consumer - { - public static Area First(Length left, Length right) => left * right; - public static Area Second(Length left, Length right) => left * right; - } - """; - - QuantityGeneratorTest compilationTest = new() - { - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - TestState = - { - Sources = { ("Consumer.cs", source) }, - }, - }; - await compilationTest.RunAsync(TestContext.Current.CancellationToken); - Compilation compilation = compilationTest.Compilation; - INamedTypeSymbol extensions = compilation.GetTypeByMetadataName("DimensionalQuantities.Generated.ArithmeticExtensions")!; - Assert.Single(extensions.GetMembers().OfType(), method => method.MetadataName == "op_Multiply"); - } - - - [Fact] - public async Task ArithmeticReadsFieldAndMethodReturnTypes() - { - const string source = """ - public static class Consumer - { - public static Current Input = Current.FromAmps(2); - public static Resistance GetResistance() => Resistance.FromSiBaseUnit(4); - public static Power Calculate() => Input * Input * GetResistance(); - } - """; - await new QuantityGeneratorTest - { - TestCode = source, - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - }.RunAsync(TestContext.Current.CancellationToken); - } - - [Fact] - public async Task DimensionPreservingScalarArithmeticUsesCoreOperatorsOnly() - { - const string source = """ - public static class Consumer - { - public static Current Scale(Current original, double factor) => factor * original / 2; - } - """; - - QuantityGeneratorTest compilationTest = new() - { - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - TestState = - { - Sources = { ("Consumer.cs", source) }, - }, - }; - await compilationTest.RunAsync(TestContext.Current.CancellationToken); - Compilation compilation = compilationTest.Compilation; - - Assert.Null(compilation.GetTypeByMetadataName("DimensionalQuantities.Generated.ArithmeticExtensions")); - } - - [Fact] - public async Task SingleConsumerRequestsLengthCurrentArithmetic() - { - const string firstSource = """ - public static class Consumer - { - public static LengthCurrent Value() => Current.FromAmps(2) * Length.FromMetres(3); - } - """; - - QuantityGeneratorTest firstOutputTest = new() - { - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - TestState = - { - Sources = { ("Consumer.cs", firstSource) }, - }, - }; - await firstOutputTest.RunAsync(TestContext.Current.CancellationToken); - Compilation firstOutput = firstOutputTest.Compilation; - - Assert.NotNull(firstOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")); - } - - [Fact] - public async Task MultipleConsumersRequestBothProductQuantities() - { - const string firstSource = """ - public static class Consumer - { - public static LengthCurrent Value() => Current.FromAmps(2) * Length.FromMetres(3); - } - """; - const string addedSource = """ - public static class Added - { - public static LengthTime Value() => Length.FromMetres(2) * Time.FromSeconds(3); - } - """; - - QuantityGeneratorTest addedOutputTest = new() - { - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - TestState = - { - Sources = { ("Consumer.cs", firstSource), ("Added.cs", addedSource) }, - }, - }; - await addedOutputTest.RunAsync(TestContext.Current.CancellationToken); - Compilation addedOutput = addedOutputTest.Compilation; - - Assert.Multiple( - () => Assert.NotNull(addedOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")), - () => Assert.NotNull(addedOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeExtensions"))); - } - - [Fact] - public async Task DivisionAndProductRequestOnlyTheirOwnOperators() - { - const string addedSource = """ - public static class Added - { - public static LengthTime Value() => Length.FromMetres(2) * Time.FromSeconds(3); - } - """; - const string editedSource = """ - public static class Consumer - { - public static Resistance Value() => Voltage.FromSiBaseUnit(12) / Current.FromAmps(3); - } - """; - Dimension length = new(Length: 1); - Dimension time = new(Time: 1); - Dimension lengthTime = new(Length: 1, Time: 1); - Dimension voltage = new(Length: 2, Mass: 1, Time: -3, ElectricCurrent: -1); - Dimension current = new(ElectricCurrent: 1); - Dimension resistance = new(Length: 2, Mass: 1, Time: -3, ElectricCurrent: -2); - ArithmeticOperation addedOperation = new(ArithmeticOperationKind.Multiply, length, time, lengthTime); - ArithmeticOperation editedOperation = new(ArithmeticOperationKind.Divide, voltage, current, resistance); - - QuantityGeneratorTest editedOutputTest = new() - { - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - TestState = - { - Sources = { ("Consumer.cs", editedSource), ("Added.cs", addedSource) }, - }, - }; - await editedOutputTest.RunAsync(TestContext.Current.CancellationToken); - Compilation editedOutput = editedOutputTest.Compilation; - ArithmeticOperation[] editedOperators = ReadOperators(editedOutput); - - Assert.Multiple( - () => Assert.Null(editedOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")), - () => Assert.NotNull(editedOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeExtensions")), - () => Assert.Equal(2, editedOperators.Length), - () => Assert.Contains(addedOperation, editedOperators), - () => Assert.Contains(editedOperation, editedOperators)); - } - - [Fact] - public async Task DivisionConsumerRequestsOnlyItsDivisionOperator() - { - const string editedSource = """ - public static class Consumer - { - public static Resistance Value() => Voltage.FromSiBaseUnit(12) / Current.FromAmps(3); - } - """; - Dimension voltage = new(Length: 2, Mass: 1, Time: -3, ElectricCurrent: -1); - Dimension current = new(ElectricCurrent: 1); - Dimension resistance = new(Length: 2, Mass: 1, Time: -3, ElectricCurrent: -2); - ArithmeticOperation editedOperation = new(ArithmeticOperationKind.Divide, voltage, current, resistance); - - QuantityGeneratorTest removedOutputTest = new() - { - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - TestState = - { - Sources = { ("Consumer.cs", editedSource) }, - }, - }; - await removedOutputTest.RunAsync(TestContext.Current.CancellationToken); - Compilation removedOutput = removedOutputTest.Compilation; - ArithmeticOperation[] removedOperators = ReadOperators(removedOutput); - - Assert.Multiple( - () => Assert.Null(removedOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")), - () => Assert.Null(removedOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeExtensions")), - () => Assert.Equal(editedOperation, Assert.Single(removedOperators))); - } - - [Fact] - public async Task EmptyConsumerHasNoDemandGeneratedArithmetic() - { - QuantityGeneratorTest emptyOutputTest = new() - { - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - TestState = - { - Sources = { ("Consumer.cs", string.Empty) }, - }, - }; - await emptyOutputTest.RunAsync(TestContext.Current.CancellationToken); - Compilation emptyOutput = emptyOutputTest.Compilation; - - Assert.Multiple( - () => Assert.Null(emptyOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.ArithmeticExtensions")), - () => Assert.Null(emptyOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")), - () => Assert.Null(emptyOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeExtensions"))); - } - - [Fact] - public async Task GeneratorIgnoresUnrelatedAndIncompleteArithmetic() - { - const string source = """ - public static class Consumer - { - public static int Number(int left, int right) => left * right; - public static object Incomplete(Length length) => length * Missing; - } - """; - - QuantityGeneratorTest outputTest = new() - { - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - CompilerDiagnostics = CompilerDiagnostics.None, - TestState = - { - Sources = { ("Consumer.cs", source) }, - }, - }; - await outputTest.RunAsync(TestContext.Current.CancellationToken); - Compilation output = outputTest.Compilation; - - Assert.Null(output.GetTypeByMetadataName("DimensionalQuantities.Generated.ArithmeticExtensions")); - } - - - - [Fact] - public async Task InferredLengthCurrentLocalDeterminesDependentOperators() - { - const string source = """ - public static class Consumer - { - public static double Value(Current current, Length length, Time time) - { - var product = current * length; - var result = product * time; - return result.AsSiBaseUnit(); - } - } - """; - Dimension current = new(ElectricCurrent: 1); - Dimension lengthCurrent = new(Length: 1, ElectricCurrent: 1); - Dimension length = new(Length: 1); - Dimension time = new(Time: 1); - ArithmeticOperation[] originalExpected = - [ - new(ArithmeticOperationKind.Multiply, current, length, lengthCurrent), - new(ArithmeticOperationKind.Multiply, lengthCurrent, time, new(Length: 1, Time: 1, ElectricCurrent: 1)) - ]; - - QuantityGeneratorTest originalOutputTest = new() - { - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - TestState = - { - Sources = { ("Consumer.cs", source) }, - }, - }; - await originalOutputTest.RunAsync(TestContext.Current.CancellationToken); - Compilation originalOutput = originalOutputTest.Compilation; - - Assert.Equal(originalExpected, ReadOperators(originalOutput)); - } - - - - [Fact] - public async Task InferredAreaLocalDeterminesDependentOperators() - { - const string source = """ - public static class Consumer - { - public static double Value(Current current, Length length, Time time) - { - var product = current * length; - var result = product * time; - return result.AsSiBaseUnit(); - } - } - """; - string editedSource = source.Replace("current * length", "length * length", StringComparison.Ordinal); - Dimension length = new(Length: 1); - Dimension area = new(Length: 2); - Dimension time = new(Time: 1); - ArithmeticOperation[] editedExpected = - [ - new(ArithmeticOperationKind.Multiply, length, length, area), - new(ArithmeticOperationKind.Multiply, area, time, new(Length: 2, Time: 1)) - ]; - - QuantityGeneratorTest editedOutputTest = new() - { - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - TestState = - { - Sources = { ("Consumer.cs", editedSource) }, - }, - }; - await editedOutputTest.RunAsync(TestContext.Current.CancellationToken); - Compilation editedOutput = editedOutputTest.Compilation; - - Assert.Multiple( - () => Assert.Equal(editedExpected, ReadOperators(editedOutput)), - () => Assert.Null(editedOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")), - () => Assert.Null(editedOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeCurrentExtensions"))); - } - - - - [Fact] - public async Task ConsumerWithoutArithmeticHasNoDemandGeneratedOperators() - { - const string removedSource = "public static class Consumer { public static double Value() => 0; }"; - - QuantityGeneratorTest removedOutputTest = new() - { - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - TestState = - { - Sources = { ("Consumer.cs", removedSource) }, - }, - }; - await removedOutputTest.RunAsync(TestContext.Current.CancellationToken); - Compilation removedOutput = removedOutputTest.Compilation; - - Assert.Multiple( - () => Assert.Null(removedOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.ArithmeticExtensions")), - () => Assert.Null(removedOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthSquaredTimeExtensions"))); - } - - - [Theory] - [InlineData("Current.FromAmps(2) + Current.FromMilliAmps(500)", "AsAmps")] - [InlineData("Current.FromAmps(2) - Current.FromMilliAmps(500)", "AsAmps")] - [InlineData("-Current.FromMilliAmps(500)", "AsAmps")] - [InlineData("Energy.FromSiBaseUnit(2) + Torque.FromSiBaseUnit(3)", "AsSiBaseUnit")] - public async Task SameDimensionArithmeticDoesNotGenerateOverloads(string expression, string accessor) - { - string source = $$""" - public static class Consumer - { - public static double Value() => ({{expression}}).{{accessor}}(); - } - """; - - QuantityGeneratorTest compilationTest = new() - { - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - TestState = - { - Sources = { ("Consumer.cs", source) }, - }, - }; - await compilationTest.RunAsync(TestContext.Current.CancellationToken); - Compilation compilation = compilationTest.Compilation; - - Assert.Null(compilation.GetTypeByMetadataName("DimensionalQuantities.Generated.ArithmeticExtensions")); - } - - [Theory] - [InlineData("current + length")] - [InlineData("current - length")] - [InlineData("current + 2")] - [InlineData("2 - current")] - public async Task InvalidSameDimensionArithmeticRemainsACompilerError(string expression) - { - string source = $$""" - public static class Consumer - { - public static object Value(Current current, Length length) => {{expression}}; - } - """; - - QuantityGeneratorTest outputTest = new() - { - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - CompilerDiagnostics = CompilerDiagnostics.None, - TestState = - { - Sources = { ("Consumer.cs", source) }, - }, - }; - await outputTest.RunAsync(TestContext.Current.CancellationToken); - Compilation output = outputTest.Compilation; - Diagnostic[] errors = output.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error).ToArray(); - - Assert.Equal("CS0019", Assert.Single(errors).Id); - } - - [Fact] - public async Task GeneratesEnglishAliasesOnlyWhenUsedByPowerCalls() - { - QuantityGeneratorTest unusedTest = new() - { - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - TestState = - { - Sources = { ("Consumer.cs", "class Consumer { }") }, - }, - }; - await unusedTest.RunAsync(TestContext.Current.CancellationToken); - Compilation unused = unusedTest.Compilation; - const string source = """ - using DimensionalQuantities.TypeSystem; - class Consumer { object Value(Length value) => Power.Of(value); } - """; - - QuantityGeneratorTest usedTest = new() - { - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - TestState = - { - Sources = { ("Consumer.cs", source) }, - }, - }; - await usedTest.RunAsync(TestContext.Current.CancellationToken); - Compilation used = usedTest.Compilation; - string[] unusedNames = unused.SyntaxTrees.SelectMany(tree => tree.GetCompilationUnitRoot(TestContext.Current.CancellationToken).Usings) - .Where(directive => directive.Alias is not null).Select(directive => directive.Alias!.Name.Identifier.ValueText).ToArray(); - string[] usedNames = used.SyntaxTrees.SelectMany(tree => tree.GetCompilationUnitRoot(TestContext.Current.CancellationToken).Usings) - .Where(directive => directive.Alias is not null).Select(directive => directive.Alias!.Name.Identifier.ValueText).ToArray(); - string[] result = usedNames.Except(unusedNames).ToArray(); - string[] expected = ["NumberTwo"]; - - Assert.Multiple( - () => Assert.DoesNotContain("NumberTwo", unusedNames), - () => Assert.DoesNotContain("NumberHalf", unusedNames), - () => Assert.Equal(expected, result)); - } - - [Theory] - [InlineData("typeof(NumberTwo)")] - [InlineData("Power.Other(value)")] - [InlineData("Other.Power.Of(value)")] - public async Task EnglishNamesOutsideSupportedPowerCallsRemainUnresolved(string expression) - { - string source = $$""" - using DimensionalQuantities.TypeSystem; - namespace Other { public struct Power { public static object Of(object value) => value; } } - class Consumer { object Value(Length value) => {{expression}}; } - """; - - QuantityGeneratorTest outputTest = new() - { - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - CompilerDiagnostics = CompilerDiagnostics.None, - TestState = - { - Sources = { ("Consumer.cs", source) }, - }, - }; - await outputTest.RunAsync(TestContext.Current.CancellationToken); - Compilation output = outputTest.Compilation; - string[] aliases = output.SyntaxTrees.SelectMany(tree => tree.GetCompilationUnitRoot(TestContext.Current.CancellationToken).Usings) - .Where(directive => directive.Alias is not null).Select(directive => directive.Alias!.Name.Identifier.ValueText).ToArray(); - - Assert.Multiple( - () => Assert.DoesNotContain("NumberTwo", aliases), - () => Assert.Contains(output.GetDiagnostics(TestContext.Current.CancellationToken), diagnostic => diagnostic.Id == "CS0246" && diagnostic.GetMessage().Contains("NumberTwo", StringComparison.Ordinal))); - } - - [Fact] - public async Task EnglishPowerCallRequestsItsAlias() - { - const string source = """ - using DimensionalQuantities.TypeSystem; - class Consumer { object Value(Length value) => Power.Of(value); } - """; - - QuantityGeneratorTest originalTest = new() - { - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - TestState = - { - Sources = { ("Consumer.cs", source) }, - }, - }; - await originalTest.RunAsync(TestContext.Current.CancellationToken); - Compilation original = originalTest.Compilation; - string[] originalNames = original.SyntaxTrees.SelectMany(tree => tree.GetCompilationUnitRoot(TestContext.Current.CancellationToken).Usings) - .Where(directive => directive.Alias is not null).Select(directive => directive.Alias!.Name.Identifier.ValueText).ToArray(); - - Assert.Contains("NumberTwo", originalNames); - } - - [Fact] - public async Task ConsumerWithoutPowerCallsHasNoEnglishAliases() - { - QuantityGeneratorTest removedTest = new() - { - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - TestState = - { - Sources = { ("Consumer.cs", string.Empty) }, - }, - }; - await removedTest.RunAsync(TestContext.Current.CancellationToken); - Compilation removed = removedTest.Compilation; - string[] remainingNames = removed.SyntaxTrees.SelectMany(tree => tree.GetCompilationUnitRoot(TestContext.Current.CancellationToken).Usings) - .Where(directive => directive.Alias is not null).Select(directive => directive.Alias!.Name.Identifier.ValueText).ToArray(); - - Assert.DoesNotContain("NumberTwo", remainingNames); - } - - [Fact] - public async Task ExplicitAliasInAnotherFileReservesTheName() - { - const string generatedAliasSource = """ - using DimensionalQuantities.TypeSystem; - class First { public Area Value(Length value) => Power.Of(value); } - """; - const string explicitAliasSource = """ - using DimensionalQuantities.TypeSystem; - using NumberTwo = DimensionalQuantities.TypeSystem.TerminalHex3; - class Second { public Volume Value(Length value) => Power.Of(value); } - """; - - QuantityGeneratorTest outputTest = new() - { - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - CompilerDiagnostics = CompilerDiagnostics.None, - TestState = - { - Sources = { ("Consumer.cs", generatedAliasSource), ("Second.cs", explicitAliasSource) }, - }, - }; - await outputTest.RunAsync(TestContext.Current.CancellationToken); - Compilation output = outputTest.Compilation; - Diagnostic[] errors = output.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error).ToArray(); - - Assert.Multiple( - () => Assert.Contains(errors, diagnostic => diagnostic.Id == "CS0246" && diagnostic.GetMessage().Contains("NumberTwo", StringComparison.Ordinal)), - () => Assert.DoesNotContain(errors, diagnostic => diagnostic.Location.SourceTree?.FilePath == "Second.cs"), - () => Assert.DoesNotContain(output.SyntaxTrees.SelectMany(tree => tree.GetCompilationUnitRoot(TestContext.Current.CancellationToken).Usings), - directive => directive.Alias?.Name.Identifier.ValueText == "NumberTwo" && directive.GlobalKeyword.IsKind(SyntaxKind.GlobalKeyword))); - } - - [Theory] - [InlineData("Two")] - [InlineData("NumberNotANumber", "DQ0007")] - public async Task UnsupportedExponentNamesRemainCompilerErrors(string name, params string[] expectedDiagnosticIds) - { - string source = $$""" - using DimensionalQuantities.TypeSystem; - public static class Consumer - { - public static object Value(Length length) => Power<{{name}}>.Of(length); - } - """; - - QuantityGeneratorTest outputTest = new() - { - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - CompilerDiagnostics = CompilerDiagnostics.None, - TestState = - { - Sources = { ("Consumer.cs", source) }, - }, - }; - if (expectedDiagnosticIds.Length != 0) - { - outputTest.ExpectedDiagnostics.Add(new DiagnosticResult("DQ0007", DiagnosticSeverity.Error) - .WithSpan("Consumer.cs", 4, 53, 4, 53 + name.Length).WithArguments(name)); - } - await outputTest.RunAsync(TestContext.Current.CancellationToken); - Compilation output = outputTest.Compilation; - - Assert.Contains(output.GetDiagnostics(TestContext.Current.CancellationToken), diagnostic => diagnostic.Id == "CS0246" && diagnostic.GetMessage().Contains(name, StringComparison.Ordinal)); - } - - [Theory] - [InlineData("TerminalHex2")] - [InlineData("NumberTwo")] - public async Task SquaredProductRequestsSquaredQuantity(string originalExponent) - { - string source = $$""" - using DimensionalQuantities.TypeSystem; - public static class Consumer - { - public static object Value(Current current) => Power<{{originalExponent}}>.Of(current * Length.FromMetres(1)); - } - """; - - QuantityGeneratorTest originalOutputTest = new() - { - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - TestState = - { - Sources = { ("Consumer.cs", source) }, - }, - }; - await originalOutputTest.RunAsync(TestContext.Current.CancellationToken); - Compilation originalOutput = originalOutputTest.Compilation; - - Assert.NotNull(originalOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthSquaredCurrentSquaredExtensions")); - } - - [Theory] - [InlineData("TerminalHex2", "TerminalHex3")] - [InlineData("NumberTwo", "NumberThree")] - public async Task CubedProductRequestsOnlyItsCubedQuantity(string originalExponent, string editedExponent) - { - string source = $$""" - using DimensionalQuantities.TypeSystem; - public static class Consumer - { - public static object Value(Current current) => Power<{{originalExponent}}>.Of(current * Length.FromMetres(1)); - } - """; - - QuantityGeneratorTest editedOutputTest = new() - { - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - TestState = - { - Sources = { ("Consumer.cs", source.Replace(originalExponent, editedExponent, StringComparison.Ordinal)) }, - }, - }; - await editedOutputTest.RunAsync(TestContext.Current.CancellationToken); - Compilation editedOutput = editedOutputTest.Compilation; - - Assert.Multiple( - () => Assert.Null(editedOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthSquaredCurrentSquaredExtensions")), - () => Assert.NotNull(editedOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCubedCurrentCubedExtensions"))); - } - - [Fact] - public async Task ConsumerWithoutPowerCallsHasNoDemandGeneratedPowerQuantity() - { - QuantityGeneratorTest emptyOutputTest = new() - { - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - TestState = - { - Sources = { ("Consumer.cs", string.Empty) }, - }, - }; - await emptyOutputTest.RunAsync(TestContext.Current.CancellationToken); - Compilation emptyOutput = emptyOutputTest.Compilation; - - Assert.Null(emptyOutput.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCubedCurrentCubedExtensions")); - } - - [Fact] - public async Task GeneratesOnlyTheRequestedIntermediateConvenienceOverloadOnce() - { - const string source = """ - class Consumer - { - object First(Length length, Current current) => (length * current).Squared(); - object Second(Length length, Current current) => (length * current).Squared(); - } - """; - - QuantityGeneratorTest outputTest = new() - { - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - TestState = - { - Sources = { ("Consumer.cs", source) }, - }, - }; - await outputTest.RunAsync(TestContext.Current.CancellationToken); - Compilation output = outputTest.Compilation; - string[] convenienceNames = ["Squared", "Cubed", "Pow4", "Pow5", "Pow6", "SquareRoot", "CubeRoot", "Root4", "Root5", "Root6"]; - string[] result = ReadConvenienceMethods(output, new(Length: 1, ElectricCurrent: 1)).Where(convenienceNames.Contains).ToArray(); - string[] expected = ["Squared"]; - - Assert.Equal(expected, result); - } - - [Fact] - public async Task BaseAndCatalogueHelpersAreAvailableWithoutConsumerCode() - { - QuantityGeneratorTest resultTest = new() - { - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - TestState = - { - Sources = { ("Consumer.cs", string.Empty) }, - }, - }; - await resultTest.RunAsync(TestContext.Current.CancellationToken); - Compilation result = resultTest.Compilation; - string[] expected = ["Squared", "Cubed", "Pow4", "Pow5", "Pow6", "SquareRoot", "CubeRoot", "Root4", "Root5", "Root6"]; - Dimension[] dimensions = QuantityDiscovery.Discover([]).KnownQuantities.Select(quantity => quantity.Dimension).ToArray(); - - Assert.All(dimensions, dimension => Assert.Equal(expected.Order(), ReadConvenienceMethods(result, dimension).Where(expected.Contains).Order())); - } - - [Fact] - public async Task CatalogueConvenienceMethodsAreBoundBeforeDemandGeneration() - { - const string source = """ - public static class Consumer - { - public static object Value(Voltage voltage) => voltage.Squared(); - } - """; - - QuantityGeneratorTest resultTest = new() - { - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - AdditionalGenerator = typeof(SemanticProbeGenerator), - TestState = - { - Sources = { ("Consumer.cs", source) }, - }, - }; - await resultTest.RunAsync(TestContext.Current.CancellationToken); - Compilation result = resultTest.Compilation; - INamedTypeSymbol probe = result.GetTypeByMetadataName("SemanticProbe")!; - IFieldSymbol resolved = Assert.IsAssignableFrom(Assert.Single(probe.GetMembers("FactoryResolved"))); - - Assert.Equal(true, resolved.ConstantValue); - } - - [Theory] - [InlineData("(3d).Squared()", "CS1929")] - [InlineData("Length.FromMetres(3).Pow7()", "CS1061")] - public async Task UnsupportedConvenienceCallsRemainCompilerErrors(string expression, string diagnosticId) - { - string source = $$"""class Consumer { object Value() => {{expression}}; }"""; - - QuantityGeneratorTest outputTest = new() - { - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - CompilerDiagnostics = CompilerDiagnostics.None, - TestState = - { - Sources = { ("Consumer.cs", source) }, - }, - }; - await outputTest.RunAsync(TestContext.Current.CancellationToken); - Compilation output = outputTest.Compilation; - - Assert.Contains(output.GetDiagnostics(TestContext.Current.CancellationToken), diagnostic => diagnostic.Id == diagnosticId); - } - - [Fact] - public async Task IntermediateConvenienceCallRequestsItsMethod() - { - const string source = "class Consumer { object Value(Length length, Current current) => (length * current).Squared(); }"; - - QuantityGeneratorTest originalTest = new() - { - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - TestState = - { - Sources = { ("Consumer.cs", source) }, - }, - }; - await originalTest.RunAsync(TestContext.Current.CancellationToken); - Compilation original = originalTest.Compilation; - string[] originalMethods = ReadConvenienceMethods(original, new(Length: 1, ElectricCurrent: 1)); - - Assert.Contains("Squared", originalMethods); - } - - [Fact] - public async Task ConsumerWithoutConvenienceCallsHasNoIntermediateMethods() - { - QuantityGeneratorTest removedTest = new() - { - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - TestState = - { - Sources = { ("Consumer.cs", string.Empty) }, - }, - }; - await removedTest.RunAsync(TestContext.Current.CancellationToken); - Compilation removed = removedTest.Compilation; - string[] remainingMethods = ReadConvenienceMethods(removed, new(Length: 1, ElectricCurrent: 1)); - - Assert.DoesNotContain("Squared", remainingMethods); - } - - - - [Fact] - public async Task ExplicitLengthCurrentLocalSupportsDependentArithmetic() - { - const string source = """ - class Consumer - { - object Value(Length length, Current current, Time time) - { - LengthCurrent value = length * current; - return value * time; - } - } - """; - - QuantityGeneratorTest initial1Test = new() - { - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - TestState = - { - Sources = { ("Consumer.cs", source) }, - }, - }; - await initial1Test.RunAsync(TestContext.Current.CancellationToken); - } - - - - [Fact] - public async Task ExplicitLengthTimeLocalDeterminesDependentArithmetic() - { - const string source = """ - class Consumer - { - object Value(Length length, Current current, Time time) - { - LengthCurrent value = length * current; - return value * time; - } - } - """; - string edited = source.Replace("LengthCurrent value = length * current", "LengthTime value = length * time", StringComparison.Ordinal); - - QuantityGeneratorTest resultTest = new() - { - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - TestState = - { - Sources = { ("Consumer.cs", edited) }, - }, - }; - await resultTest.RunAsync(TestContext.Current.CancellationToken); - Compilation result = resultTest.Compilation; - - Assert.Multiple( - () => Assert.Null(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")), - () => Assert.Null(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeCurrentExtensions")), - () => Assert.NotNull(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeSquaredExtensions"))); - } - - - [Fact] - public async Task LengthCurrentConditionalLocalSupportsDependentArithmetic() - { - const string source = """ - class Consumer - { - object Value(bool choose, Length length, Current current, Time time) - { - var product = choose ? length * current : length * current; - return product * time; - } - } - """; - - QuantityGeneratorTest initial1Test = new() - { - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - TestState = - { - Sources = { ("Consumer.cs", source) }, - }, - }; - await initial1Test.RunAsync(TestContext.Current.CancellationToken); - } - - - [Fact] - public async Task LengthTimeConditionalLocalDeterminesDependentArithmetic() - { - const string source = """ - class Consumer - { - object Value(bool choose, Length length, Current current, Time time) - { - var product = choose ? length * current : length * current; - return product * time; - } - } - """; - string edited = source.Replace("length * current", "length * time", StringComparison.Ordinal); - - QuantityGeneratorTest resultTest = new() - { - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - TestState = - { - Sources = { ("Consumer.cs", edited) }, - }, - }; - await resultTest.RunAsync(TestContext.Current.CancellationToken); - Compilation result = resultTest.Compilation; - - Assert.Multiple( - () => Assert.Null(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeCurrentExtensions")), - () => Assert.NotNull(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeSquaredExtensions"))); - } - - - [Fact] - public async Task LengthCurrentMemberSupportsDependentArithmetic() - { - const string source = "class Inputs { public static LengthCurrent Stored => Length.FromMetres(2) * Current.FromAmps(3); }"; - const string consumer = "class Consumer { object Value(Time time) => Inputs.Stored * time; }"; - - QuantityGeneratorTest initial1Test = new() - { - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - TestState = - { - Sources = { ("Consumer.cs", consumer), ("Inputs.cs", source) }, - }, - }; - await initial1Test.RunAsync(TestContext.Current.CancellationToken); - } - - - [Fact] - public async Task LengthTimeMemberDeterminesDependentArithmetic() - { - const string source = "class Inputs { public static LengthCurrent Stored => Length.FromMetres(2) * Current.FromAmps(3); }"; - const string consumer = "class Consumer { object Value(Time time) => Inputs.Stored * time; }"; - string edited = source.Replace("LengthCurrent", "LengthTime", StringComparison.Ordinal).Replace("Current.FromAmps", "Time.FromSeconds", StringComparison.Ordinal); - - QuantityGeneratorTest resultTest = new() - { - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - TestState = - { - Sources = { ("Consumer.cs", consumer), ("Inputs.cs", edited) }, - }, - }; - await resultTest.RunAsync(TestContext.Current.CancellationToken); - Compilation result = resultTest.Compilation; - - Assert.Multiple( - () => Assert.Null(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeCurrentExtensions")), - () => Assert.NotNull(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeSquaredExtensions"))); - } - - - [Fact] - public async Task LengthCurrentMethodSupportsConsumerArithmetic() - { - const string source = "class Inputs { public static LengthCurrent Make() => Length.FromMetres(2) * Current.FromAmps(3); }"; - const string consumer = "class Consumer { object Value(Time time) => Inputs.Make() * time; }"; - - QuantityGeneratorTest initial1Test = new() - { - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - TestState = - { - Sources = { ("Consumer.cs", consumer), ("Inputs.cs", source) }, - }, - }; - await initial1Test.RunAsync(TestContext.Current.CancellationToken); - } - - - [Fact] - public async Task LengthTimeMethodDeterminesConsumerArithmetic() - { - const string source = "class Inputs { public static LengthCurrent Make() => Length.FromMetres(2) * Current.FromAmps(3); }"; - const string consumer = "class Consumer { object Value(Time time) => Inputs.Make() * time; }"; - string edited = source.Replace("LengthCurrent", "LengthTime", StringComparison.Ordinal).Replace("Current.FromAmps", "Time.FromSeconds", StringComparison.Ordinal); - - QuantityGeneratorTest resultTest = new() - { - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - TestState = - { - Sources = { ("Consumer.cs", consumer), ("Inputs.cs", edited) }, - }, - }; - await resultTest.RunAsync(TestContext.Current.CancellationToken); - Compilation result = resultTest.Compilation; - - Assert.Multiple( - () => Assert.Null(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeCurrentExtensions")), - () => Assert.NotNull(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeSquaredExtensions"))); - } - - - [Fact] - public async Task TypeOnlyDeclarationsGenerateQuantitiesInPublicApisAndCollections() - { - const string source = """ - public record Measurement(LengthCurrent Value); - public class Consumer - { - public LengthCurrent Field; - public LengthCurrent Property { get; set; } - public System.Collections.Generic.List Values { get; } = new(); - public LengthCurrent[] Copy(LengthCurrent[] values) => values; - public LengthCurrent Identity(LengthCurrent value) => value; - } - """; - - QuantityGeneratorTest resultTest = new() - { - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - TestState = - { - Sources = { ("Consumer.cs", source) }, - }, - }; - await resultTest.RunAsync(TestContext.Current.CancellationToken); - Compilation result = resultTest.Compilation; - - Assert.NotNull(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")); - } - - - - - - - [Theory] - [InlineData("public class LengthCurrent { }")] - [InlineData("using LengthCurrent = System.Int32;")] - public async Task ExistingTypesAndAliasesAreNotReplacedByQuantityNames(string declaration) - { - string source = $$"""{{declaration}} class Consumer { object Value(LengthCurrent value) => value; }"""; - - QuantityGeneratorTest resultTest = new() - { - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - TestState = - { - Sources = { ("Consumer.cs", source) }, - }, - }; - await resultTest.RunAsync(TestContext.Current.CancellationToken); - Compilation result = resultTest.Compilation; - - Assert.Null(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")); - } - - [Fact] - public async Task QuantityLookingVariableNamesDoNotRequestTypes() - { - const string source = "class Consumer { int Value() { int LengthCurrent = 7; return LengthCurrent; } }"; - - QuantityGeneratorTest resultTest = new() - { - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - TestState = - { - Sources = { ("Consumer.cs", source) }, - }, - }; - await resultTest.RunAsync(TestContext.Current.CancellationToken); - Compilation result = resultTest.Compilation; - - Assert.Null(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")); - } - - [Fact] - public async Task TypeNameDiscoveryPreservesExplicitAliasesInOtherFiles() - { - const string source = "class First { public LengthCurrent Value; }"; - const string aliasSource = "using LengthCurrent = System.Int32; class Second { public int Value(LengthCurrent value) => value; }"; - - QuantityGeneratorTest resultTest = new() - { - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - CompilerDiagnostics = CompilerDiagnostics.None, - TestState = - { - Sources = { ("Consumer.cs", source), ("Alias.cs", aliasSource) }, - }, - }; - await resultTest.RunAsync(TestContext.Current.CancellationToken); - Compilation result = resultTest.Compilation; - Diagnostic[] errors = result.GetDiagnostics(TestContext.Current.CancellationToken).Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error).ToArray(); - - Assert.Multiple( - () => Assert.Contains(errors, error => error.Id == "CS0246" && error.Location.SourceTree?.FilePath == "Consumer.cs"), - () => Assert.DoesNotContain(errors, error => error.Location.SourceTree?.FilePath == "Alias.cs")); - } - - [Fact] - public async Task TypeOnlyDeclarationsRequestLocalConversions() - { - const string source = "class Consumer { public LengthCurrent Identity(LengthCurrent value) => value; }"; - - QuantityGeneratorTest originalTest = new() - { - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - TestState = - { - Sources = { ("Consumer.cs", source) }, - }, - }; - await originalTest.RunAsync(TestContext.Current.CancellationToken); - Compilation original = originalTest.Compilation; - - Assert.NotNull(original.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")); - } - - [Fact] - public async Task ConsumerWithoutTypeDeclarationsHasNoDemandGeneratedQuantities() - { - QuantityGeneratorTest resultTest = new() - { - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - TestState = - { - Sources = { ("Consumer.cs", string.Empty) }, - }, - }; - await resultTest.RunAsync(TestContext.Current.CancellationToken); - Compilation result = resultTest.Compilation; - - Assert.Null(result.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")); - } - - [Theory] - [InlineData("Library.Create()")] - [InlineData("Library.Field")] - [InlineData("Library.Property")] - [InlineData("Library.Values()[0]")] - [InlineData("Library.Measure().Value")] - public async Task ReferencedQuantityValuesGetLocalConversionsWithoutArithmetic(string expression) - { - PortableExecutableReference library = await CreateLibraryReference(""" - public static class Library - { - public static LengthCurrent Create() => Length.FromMetres(2) * Current.FromAmps(3); - public static LengthCurrent Field; - public static LengthCurrent Property => Create(); - public static System.Collections.Generic.List Values() => new() { Create() }; - public static Measurement Measure() => new(); - } - public sealed class Measurement { public LengthCurrent Value => Library.Create(); } - """); - - QuantityGeneratorTest resultTest = new() - { - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - TestState = - { - Sources = { ("Consumer.cs", $"public class Consumer {{ public double Value() => {expression}.AsPrefixedUnits(3, 0); }}") }, - AdditionalReferences = { library }, - }, - }; - await resultTest.RunAsync(TestContext.Current.CancellationToken); - Compilation result = resultTest.Compilation; - - Assert.NotNull(result.Assembly.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")); - } - - [Fact] - public async Task ReferencedCollectionTypesRequestTheirNestedQuantity() - { - PortableExecutableReference library = await CreateLibraryReference("public static class Library { public static System.Collections.Generic.List Values() => new(); }"); - - QuantityGeneratorTest resultTest = new() - { - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - TestState = - { - Sources = { ("Consumer.cs", "public class Consumer { public object Value() => Library.Values(); }") }, - AdditionalReferences = { library }, - }, - }; - await resultTest.RunAsync(TestContext.Current.CancellationToken); - Compilation result = resultTest.Compilation; - - Assert.NotNull(result.Assembly.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")); - } - - [Fact] - public async Task ReferencedQuantityUsageRequestsLocalConversions() - { - PortableExecutableReference library = await CreateLibraryReference("public static class Library { public static LengthCurrent Create() => default; }"); - - QuantityGeneratorTest originalTest = new() - { - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - TestState = - { - Sources = { ("Consumer.cs", "public class Consumer { public object Value() => Library.Create(); }") }, - AdditionalReferences = { library }, - }, - }; - await originalTest.RunAsync(TestContext.Current.CancellationToken); - Compilation original = originalTest.Compilation; - - Assert.NotNull(original.Assembly.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")); - } - - [Fact] - public async Task UnusedReferencedQuantityHasNoLocalConversions() - { - PortableExecutableReference library = await CreateLibraryReference("public static class Library { public static LengthCurrent Create() => default; }"); - - QuantityGeneratorTest resultTest = new() - { - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - TestState = - { - Sources = { ("Consumer.cs", string.Empty) }, - AdditionalReferences = { library }, - }, - }; - await resultTest.RunAsync(TestContext.Current.CancellationToken); - Compilation result = resultTest.Compilation; - - Assert.Null(result.Assembly.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")); - } - - [Fact] - public async Task ReferencedClassesWithQuantityNamesAreNotTreatedAsQuantities() - { - PortableExecutableReference library = await CreateLibraryReference("public class LengthCurrent { } public static class Library { public static LengthCurrent Create() => new(); }"); - - QuantityGeneratorTest resultTest = new() - { - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - TestState = - { - Sources = { ("Consumer.cs", "public class Consumer { public object Value() => Library.Create(); }") }, - AdditionalReferences = { library }, - }, - }; - await resultTest.RunAsync(TestContext.Current.CancellationToken); - Compilation result = resultTest.Compilation; - - Assert.Null(result.Assembly.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthCurrentExtensions")); - } - - [Fact] - public async Task MetadataDiscoveryPreservesExplicitConsumerAliases() - { - PortableExecutableReference library = await CreateLibraryReference("public static class Library { public static LengthCurrent Create() => default; }"); - - QuantityGeneratorTest resultTest = new() - { - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - TestState = - { - Sources = { ("Consumer.cs", "using LengthCurrent = System.Int32; public class Consumer { public object Value() => Library.Create(); public LengthCurrent Count => 1; }") }, - AdditionalReferences = { library }, - }, - }; - await resultTest.RunAsync(TestContext.Current.CancellationToken); - Compilation result = resultTest.Compilation; - } - - [Theory] - [InlineData("public class LengthCurrent { public int Marker { get; init; } }", "LengthCurrent", "new() { Marker = 7 }")] - [InlineData("namespace LengthCurrent { public class Item { } }", "LengthCurrent.Item", "new()")] - public async Task MetadataDiscoveryPreservesExistingConsumerTypesAndNamespaces(string declaration, string type, string value) - { - PortableExecutableReference library = await CreateLibraryReference("public static class Library { public static LengthCurrent Create() => default; }"); - string source = $$"""{{declaration}} public class Consumer { public object Value() => Library.Create(); public {{type}} Item => {{value}}; }"""; - - QuantityGeneratorTest resultTest = new() - { - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - TestState = - { - Sources = { ("Consumer.cs", source) }, - AdditionalReferences = { library }, - }, - }; - await resultTest.RunAsync(TestContext.Current.CancellationToken); - Compilation result = resultTest.Compilation; - } - - [Fact] - public async Task ReferencedGenericResultsGetConversionsAfterTheirArgumentsResolve() - { - PortableExecutableReference library = await CreateLibraryReference("public static class Library { public static LengthTime Convert(T value) => default; }"); - const string source = """ - public static class Consumer - { - public static double Value(Length length, Current current) => Library.Convert(length * current).AsPrefixedUnits(0, 0); - } - """; - - QuantityGeneratorTest resultTest = new() - { - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - TestState = - { - Sources = { ("Consumer.cs", source) }, - AdditionalReferences = { library }, - }, - }; - await resultTest.RunAsync(TestContext.Current.CancellationToken); - Compilation result = resultTest.Compilation; - - Assert.NotNull(result.Assembly.GetTypeByMetadataName("DimensionalQuantities.Generated.LengthTimeExtensions")); - } - - private static async Task CreateLibraryReference(string source) - { - QuantityGeneratorTest test = new() - { - TestCode = source, - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - }; - await test.RunAsync(TestContext.Current.CancellationToken); - using MemoryStream stream = new(); - Microsoft.CodeAnalysis.Emit.EmitResult emitted = test.Compilation.WithAssemblyName("ReferencedQuantities").Emit(stream, cancellationToken: TestContext.Current.CancellationToken); - if (!emitted.Success) - { - throw new InvalidOperationException(string.Join(Environment.NewLine, emitted.Diagnostics)); - } - return MetadataReference.CreateFromImage(stream.ToArray()); - } - - private static string[] ReadConvenienceMethods(Compilation compilation, Dimension dimension) - { - QuantityTypeReader reader = new(compilation); - return compilation.SyntaxTrees.SelectMany(tree => tree.GetRoot(TestContext.Current.CancellationToken).DescendantNodes().OfType()) - .Where(block => block.ParameterList is { Parameters.Count: 1 } parameters && parameters.Parameters[0].Type is { } type - && reader.TryRead(compilation.GetSemanticModel(block.SyntaxTree).GetTypeInfo(type).Type, out Dimension receiver, TestContext.Current.CancellationToken) - && receiver == dimension) - .SelectMany(block => block.Members.OfType()) - .Where(method => method.ParameterList.Parameters.Count == 0 && !method.Modifiers.Any(SyntaxKind.StaticKeyword)) - .Select(method => method.Identifier.ValueText).ToArray(); - } - - private sealed class SemanticProbeGenerator : IIncrementalGenerator - { - public void Initialize(IncrementalGeneratorInitializationContext context) - { - IncrementalValuesProvider<(bool IsInvocation, bool Resolved)> observed = context.SyntaxProvider.CreateSyntaxProvider( - static (node, _) => node.SyntaxTree.FilePath == "Consumer.cs" && node is (ParameterSyntax or InvocationExpressionSyntax), - static (syntaxContext, _) => - { - bool isInvocation = syntaxContext.Node is InvocationExpressionSyntax; - ITypeSymbol? type = syntaxContext.Node switch - { - ParameterSyntax parameter => (syntaxContext.SemanticModel.GetDeclaredSymbol(parameter) as IParameterSymbol)?.Type, - InvocationExpressionSyntax invocation => (syntaxContext.SemanticModel.GetSymbolInfo(invocation).Symbol as IMethodSymbol)?.ReturnType, - _ => null - }; - INamedTypeSymbol? quantity = syntaxContext.SemanticModel.Compilation.GetTypeByMetadataName(typeof(Quantity<>).FullName!); - bool resolved = type is INamedTypeSymbol named && SymbolEqualityComparer.Default.Equals(named.OriginalDefinition, quantity); - return (isInvocation, resolved); - }); - context.RegisterSourceOutput(observed.Collect(), static (output, symbols) => - { - bool aliasResolved = symbols.Any(symbol => !symbol.IsInvocation && symbol.Resolved); - bool factoryResolved = symbols.Any(symbol => symbol.IsInvocation && symbol.Resolved); - string source = $"internal static class SemanticProbe {{ public const bool AliasResolved = {aliasResolved.ToString().ToLowerInvariant()}; public const bool FactoryResolved = {factoryResolved.ToString().ToLowerInvariant()}; }}"; - output.AddSource("SemanticProbe.g.cs", SourceText.From(source, Encoding.UTF8)); - }); - } - } - - private static ArithmeticOperation[] ReadOperators(Compilation compilation) - { - INamedTypeSymbol extensions = compilation.GetTypeByMetadataName("DimensionalQuantities.Generated.ArithmeticExtensions")!; - QuantityTypeReader reader = new(compilation); - return extensions.GetMembers().OfType() - .Where(method => method.MetadataName is "op_Multiply" or "op_Division") - .Select(method => - { - if (!reader.TryRead(method.Parameters[0].Type, out Dimension left, TestContext.Current.CancellationToken) - || !reader.TryRead(method.Parameters[1].Type, out Dimension right, TestContext.Current.CancellationToken) - || !reader.TryRead(method.ReturnType, out Dimension result, TestContext.Current.CancellationToken)) - { - throw new InvalidOperationException("Generated operator has an unreadable quantity signature."); - } - - ArithmeticOperationKind kind = method.MetadataName == "op_Multiply" ? ArithmeticOperationKind.Multiply : ArithmeticOperationKind.Divide; - return new ArithmeticOperation(kind, left, right, result); - }).ToArray(); - } -} diff --git a/src/DimensionalQuantities.Roslyn.Tests/Generators/QuantitySourceEmitterTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Generators/QuantitySourceEmitterTests.cs deleted file mode 100644 index d18a506..0000000 --- a/src/DimensionalQuantities.Roslyn.Tests/Generators/QuantitySourceEmitterTests.cs +++ /dev/null @@ -1,138 +0,0 @@ -using System.Reflection; -using DimensionalQuantities.Dimensions; -using DimensionalQuantities.Roslyn.Discovery; -using DimensionalQuantities.Roslyn.Generators; -using DimensionalQuantities.TypeSystem; -using Microsoft.CodeAnalysis; -using Microsoft.CodeAnalysis.CSharp; -using Microsoft.CodeAnalysis.Emit; -using Xunit; - -namespace DimensionalQuantities.Roslyn.Tests.Generators; - -public sealed class QuantitySourceEmitterTests -{ - private static readonly CSharpParseOptions _parseOptions = new(LanguageVersion.Preview); - - [Fact] - public void StandaloneTemperatureUsesTheDimensionAlias() - { - string source = QuantitySourceEmitter.Emit(QuantityDiscovery.Discover([]).KnownQuantities); - Assert.Contains("global using Temperature =", source); - } - - [Fact] - public void DiscoveredMechanicalQuantityUsesItsGenericPrefixConversion() - { - Dimension mass = new(Mass: 1); - Dimension massSquared = new(Mass: 2); - ArithmeticOperation operation = new(ArithmeticOperationKind.Multiply, mass, mass, massSquared); - QuantityGenerationPlan plan = QuantityDiscovery.Discover([operation]); - const string source = "public static class Consumer { public static double Value() => MassSquared.FromPrefixedUnits(2, gramPrefixExponent: 0).AsSiBaseUnit(); }"; - Assembly assembly = CompileAndEmit(source, plan.KnownQuantities, plan.AdditionalQuantities); - Type consumer = assembly.GetType("Consumer")!; - double result = (double)consumer.GetMethod("Value")!.Invoke(null, null)!; - - Assert.Equal(0.000002, result, 12); - } - - [Fact] - public void DiscoveredQuantityOnlyHasGenericPrefixConversions() - { - Dimension current = new(ElectricCurrent: 1); - Dimension currentSquared = new(ElectricCurrent: 2); - ArithmeticOperation operation = new(ArithmeticOperationKind.Multiply, current, current, currentSquared); - QuantityGenerationPlan plan = QuantityDiscovery.Discover([operation]); - CSharpCompilation compilation = Compile(QuantitySourceEmitter.Emit(plan.AdditionalQuantities)); - INamedTypeSymbol extensions = compilation.GetTypeByMetadataName("DimensionalQuantities.Generated.CurrentSquaredExtensions")!; - string[] methods = extensions.GetMembers().OfType().Select(method => method.Name).ToArray(); - - Assert.Multiple( - () => Assert.Contains("FromPrefixedUnits", methods), - () => Assert.Contains("AsPrefixedUnits", methods), - () => Assert.DoesNotContain(methods, method => method.StartsWith("FromSquare", StringComparison.Ordinal)), - () => Assert.DoesNotContain(methods, method => method.StartsWith("AsSquare", StringComparison.Ordinal))); - } - - [Fact] - public void VoltageAndMechanicalAliasAreTheSameType() - { - const string expression = "typeof(Voltage) == typeof(LengthSquaredMassPerTimeCubedCurrent)"; - bool result = Evaluate(expression); - Assert.True(result); - } - - [Theory] - [InlineData("Area", "LengthSquared")] - [InlineData("CurrentDensity", "CurrentPerLengthSquared")] - [InlineData("Pressure", "Stress")] - [InlineData("Pressure", "YoungsModulus")] - [InlineData("Energy", "Torque")] - public void CatalogueAliasesShareTheCanonicalDimensionType(string alias, string equivalent) - { - bool result = Evaluate($"typeof({alias}) == typeof({equivalent})"); - Assert.True(result); - } - - private static T Evaluate(string expression) - { - string source = $$""" - public static class Consumer - { - public static global::{{typeof(T).FullName}} Value() => {{expression}}; - } - """; - Assembly assembly = CompileAndEmit(source, QuantityDiscovery.Discover([]).KnownQuantities, []); - MethodInfo method = assembly.GetType("Consumer")!.GetMethod("Value")!; - return (T)method.Invoke(null, null)!; - } - - private static CSharpCompilation Compile(string source) - { - SyntaxTree generated = CSharpSyntaxTree.ParseText( - QuantitySourceEmitter.Emit(QuantityDiscovery.Discover([]).KnownQuantities), - _parseOptions, - path: "KnownQuantities.g.cs"); - CSharpCompilation compilation = CreateInputCompilation(source).AddSyntaxTrees(generated); - Diagnostic[] errors = compilation.GetDiagnostics(TestContext.Current.CancellationToken) - .Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error).ToArray(); - if (errors.Length != 0) - { - throw new InvalidOperationException(string.Join(Environment.NewLine, errors.Select(error => error.ToString()))); - } - return compilation; - } - - private static Assembly CompileAndEmit(string source, IReadOnlyList known, IReadOnlyList additional) - { - SyntaxTree knownQuantities = CSharpSyntaxTree.ParseText(QuantitySourceEmitter.Emit(known), _parseOptions, path: "KnownQuantities.g.cs"); - SyntaxTree additionalQuantities = CSharpSyntaxTree.ParseText(QuantitySourceEmitter.Emit(additional), _parseOptions, path: "AdditionalQuantities.g.cs"); - CSharpCompilation compilation = CreateInputCompilation(source).AddSyntaxTrees(knownQuantities, additionalQuantities); - Diagnostic[] errors = compilation.GetDiagnostics(TestContext.Current.CancellationToken) - .Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error).ToArray(); - if (errors.Length != 0) - { - throw new InvalidOperationException(string.Join(Environment.NewLine, errors.Select(error => error.ToString()))); - } - - using MemoryStream assemblyBytes = new(); - EmitResult emit = compilation.Emit(assemblyBytes, cancellationToken: TestContext.Current.CancellationToken); - if (!emit.Success) - { - throw new InvalidOperationException(string.Join(Environment.NewLine, emit.Diagnostics.Select(diagnostic => diagnostic.ToString()))); - } - return Assembly.Load(assemblyBytes.ToArray()); - } - - private static CSharpCompilation CreateInputCompilation(string source) - { - string[] platformAssemblies = ((string)AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES")!).Split(Path.PathSeparator); - IEnumerable references = platformAssemblies.Select(path => MetadataReference.CreateFromFile(path)) - .Append(MetadataReference.CreateFromFile(typeof(Quantity<>).Assembly.Location)); - return CSharpCompilation.Create( - "QuantitySourceEmitterConsumer", - [CSharpSyntaxTree.ParseText(source, _parseOptions, path: "Consumer.cs")], - references, - new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)); - } -} diff --git a/src/DimensionalQuantities.Roslyn.Tests/Generators/UnitConversionSourceEmitterTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Generators/UnitConversionSourceEmitterTests.cs deleted file mode 100644 index a1b0d98..0000000 --- a/src/DimensionalQuantities.Roslyn.Tests/Generators/UnitConversionSourceEmitterTests.cs +++ /dev/null @@ -1,142 +0,0 @@ -using System.Reflection; -using DimensionalQuantities.Dimensions; -using DimensionalQuantities.Roslyn.Generators; -using DimensionalQuantities.TypeSystem; -using DimensionalQuantities.Units; -using Microsoft.CodeAnalysis; -using Microsoft.CodeAnalysis.CSharp; -using Microsoft.CodeAnalysis.Emit; -using Xunit; - -namespace DimensionalQuantities.Roslyn.Tests.Generators; - -public sealed class UnitConversionSourceEmitterTests -{ - private static readonly CSharpParseOptions _parseOptions = new(LanguageVersion.Preview); - private static readonly UnitConversionSpec[] _units = - [ - new("Length", "Length", [new UnitDefinition("Length", [new(AtomicUnits.Metre, prefixExponent: SiBasePrefixExponents.Length)])], true), - new("Mass", "Mass", [new UnitDefinition("Mass", [new(AtomicUnits.Gram, prefixExponent: SiBasePrefixExponents.Mass)])], true) - ]; - private static readonly string[] _prefixes = - [ - "Quetta", "Ronna", "Yotta", "Zetta", "Exa", "Peta", "Tera", "Giga", "Mega", "Kilo", "Hecto", "Deca", - "Deci", "Centi", "Milli", "Micro", "Nano", "Pico", "Femto", "Atto", "Zepto", "Yocto", "Ronto", "Quecto" - ]; - - [Fact] - public void EverySiPrefixHasUsableFactoryAndAccessor() - { - string calls = string.Join("\n", _prefixes.Select(prefix => - $"Length value{prefix} = Length.From{prefix}Metres(1); double output{prefix} = value{prefix}.As{prefix}Metres();")); - string source = $$""" - public static class Consumer - { - public static void UsePrefixes() - { - {{calls}} - } - } - """; - - CSharpCompilation compilation = Compile(source); - Assert.Empty(compilation.GetDiagnostics(TestContext.Current.CancellationToken) - .Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error)); - } - - [Theory] - [InlineData("Length.FromMilliMetres(2500).AsSiBaseUnit()", 2.5)] - [InlineData("Mass.FromKiloGrams(2.5).AsSiBaseUnit()", 2.5)] - [InlineData("Mass.FromPrefixedUnits(2).AsSiBaseUnit()", 2)] - [InlineData("Mass.FromSiBaseUnit(1).AsPrefixedUnits(gramPrefixExponent: 0)", 1000)] - [InlineData("Length.FromMilliMetres(2500).AsDelta().AsMilliMetres()", 2500)] - public void BaseUnitPrefixesKeepTheirSiScales(string expression, double expected) - { - string source = $$""" - public static class Consumer - { - public static double Value() => {{expression}}; - } - """; - CSharpCompilation compilation = Compile(source); - using MemoryStream assemblyBytes = new(); - EmitResult emit = compilation.Emit(assemblyBytes, cancellationToken: TestContext.Current.CancellationToken); - if (!emit.Success) - { - throw new InvalidOperationException(string.Join(Environment.NewLine, emit.Diagnostics.Select(diagnostic => diagnostic.ToString()))); - } - - Assembly assembly = Assembly.Load(assemblyBytes.ToArray()); - MethodInfo method = assembly.GetType("Consumer")!.GetMethod("Value")!; - double result = (double)method.Invoke(null, null)!; - Assert.Equal(expected, result); - } - - [Fact] - public void AffineReadingsAndScaleOnlyDeltasUseTheirOwnConversionRules() - { - AtomicUnit celsius = new("Celsius", "Celsius", "°C"); - AtomicUnit rankine = new("Rankine", "Rankine", "°R", Scale: 5d / 9d); - AtomicUnit fahrenheit = new("Fahrenheit", "Fahrenheit", "°F", Scale: 5d / 9d); - UnitConversionSpec[] units = - [ - new("Temperature", "Temperature", - [ - new UnitDefinition("Celsius", new UnitExpression(new UnitTerm(celsius)), offsetBeforeScale: 273.15), - new UnitDefinition("Rankine", new UnitExpression(new UnitTerm(rankine)), - [new(new UnitExpression(new UnitTerm(fahrenheit)), 459.67)]) - ], true, false, false) - ]; - CSharpCompilation compilation = Compile(""" - public static class Consumer - { - public static double AbsoluteCelsius() => Temperature.FromCelsius(20).AsCelsius(); - public static double AbsoluteFahrenheit() => Temperature.FromFahrenheit(68).AsCelsius(); - public static double DifferenceCelsius() => (Temperature.FromCelsius(20) - Temperature.FromCelsius(10)).AsDelta().AsCelsius(); - public static double DifferenceFahrenheit() => (Temperature.FromCelsius(20) - Temperature.FromCelsius(10)).AsDelta().AsFahrenheit(); - public static double DifferenceRankine() => (Temperature.FromCelsius(20) - Temperature.FromCelsius(10)).AsDelta().AsRankine(); - public static double ZeroDifference() => (Temperature.FromCelsius(20) - Temperature.FromCelsius(20)).AsDelta().AsFahrenheit(); - public static double NegativeDifference() => (Temperature.FromCelsius(10) - Temperature.FromCelsius(20)).AsDelta().AsFahrenheit(); - } - """, units); - using MemoryStream assemblyBytes = new(); - EmitResult emit = compilation.Emit(assemblyBytes, cancellationToken: TestContext.Current.CancellationToken); - Assert.True(emit.Success, string.Join(Environment.NewLine, emit.Diagnostics)); - Assembly assembly = Assembly.Load(assemblyBytes.ToArray()); - Type consumer = assembly.GetType("Consumer")!; - Assert.Multiple( - () => Assert.Equal(20, Invoke(consumer, "AbsoluteCelsius"), 10), - () => Assert.Equal(20, Invoke(consumer, "AbsoluteFahrenheit"), 10), - () => Assert.Equal(10, Invoke(consumer, "DifferenceCelsius"), 10), - () => Assert.Equal(18, Invoke(consumer, "DifferenceFahrenheit"), 10), - () => Assert.Equal(18, Invoke(consumer, "DifferenceRankine"), 10), - () => Assert.Equal(0, Invoke(consumer, "ZeroDifference"), 10), - () => Assert.Equal(-18, Invoke(consumer, "NegativeDifference"), 10)); - } - - private static double Invoke(Type consumer, string method) => (double)consumer.GetMethod(method)!.Invoke(null, null)!; - - private static CSharpCompilation Compile(string source, UnitConversionSpec[]? units = null) - { - string lengthType = QuantityTypeNameFormatter.Format(new Dimension(Length: 1)); - string massType = QuantityTypeNameFormatter.Format(new Dimension(Mass: 1)); - string temperatureType = QuantityTypeNameFormatter.Format(new Dimension(Temperature: 1)); - string generatedSource = $""" - global using Length = {lengthType}; - global using Mass = {massType}; - global using Temperature = {temperatureType}; - global using DimensionalQuantities.Generated; - - {UnitConversionSourceEmitter.Emit(units ?? _units, "DimensionalQuantities.Generated", "internal")} - """; - string[] platformAssemblies = ((string)AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES")!).Split(Path.PathSeparator); - IEnumerable references = platformAssemblies.Select(path => MetadataReference.CreateFromFile(path)) - .Append(MetadataReference.CreateFromFile(typeof(Quantity<>).Assembly.Location)); - CSharpCompilation compilation = CSharpCompilation.Create("UnitConversionSourceEmitterConsumer", - [ - CSharpSyntaxTree.ParseText(source, _parseOptions, path: "Consumer.cs"), - CSharpSyntaxTree.ParseText(generatedSource, _parseOptions, path: "Conversions.g.cs") - ], references, new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)); - return compilation; - } -} diff --git a/src/DimensionalQuantities.Roslyn.Tests/Generators/UnitProviderGenerationTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Generators/UnitProviderGenerationTests.cs deleted file mode 100644 index 5e0664a..0000000 --- a/src/DimensionalQuantities.Roslyn.Tests/Generators/UnitProviderGenerationTests.cs +++ /dev/null @@ -1,84 +0,0 @@ -using DimensionalQuantities.Roslyn.Tests.Testing; -using Microsoft.CodeAnalysis; -using Microsoft.CodeAnalysis.Emit; -using Microsoft.CodeAnalysis.Testing; -using Xunit; - -namespace DimensionalQuantities.Roslyn.Tests.Generators; - -public sealed class UnitProviderGenerationTests -{ - - private const string FootProvider = """ - using DimensionalQuantities.Units.Declarations; - namespace Independent.Units; - - [UnitProvider] - internal static class CustomUnits - { - [QuantityUnit(typeof(Length))] - [UnitFactor(typeof(Foot))] - private sealed class LengthUnit; - - [UnitSymbol("Foot", "Feet", "ft", Scale = 0.3048)] - private sealed class Foot; - } - """; - - [Fact] - public async Task ProviderConversionsArePublicAndNotRegeneratedByConsumers() - { - QuantityGeneratorTest providerTest = new() - { - TestCode = FootProvider, - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - }; - await providerTest.RunAsync(TestContext.Current.CancellationToken); - using MemoryStream bytes = new(); - EmitResult emitted = providerTest.Compilation.Emit(bytes, cancellationToken: TestContext.Current.CancellationToken); - if (!emitted.Success) - { - throw new InvalidOperationException(string.Join(Environment.NewLine, emitted.Diagnostics)); - } - const string consumer = """ - using Independent.Units; - public static class Consumer - { - public static Area Value() => Length.FromFeet(1) * Length.FromFeet(2); - } - """; - QuantityGeneratorTest consumerTest = new() - { - TestCode = consumer, - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - TestState = { AdditionalReferences = { MetadataReference.CreateFromImage(bytes.ToArray()) } }, - }; - await consumerTest.RunAsync(TestContext.Current.CancellationToken); - Assert.DoesNotContain(consumerTest.Compilation.Assembly.GlobalNamespace.GetNamespaceMembers(), symbol => symbol.Name == "Independent"); - } - - [Theory] - [InlineData("Bad name", "Feet")] - [InlineData("Foot", "Bad names")] - public async Task InvalidUnitNamesReportDeclarationDiagnostics(string singular, string plural) - { - string source = $$""" - using DimensionalQuantities.Units.Declarations; - [UnitProvider(GeneratePrefixConversions = true)] - internal static class Units - { - [QuantityUnit(typeof(Length))] - [UnitFactor(typeof(Foot))] - private sealed class LengthUnit; - [UnitSymbol("{{singular}}", "{{plural}}", "ft")] - private sealed class Foot; - } - """; - await new QuantityGeneratorTest - { - TestCode = source, - TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck, - ExpectedDiagnostics = { new DiagnosticResult("DQ0008", DiagnosticSeverity.Error).WithSpan(3, 23, 3, 28).WithMessage("Unit provider for Length produces an invalid C# identifier.") }, - }.RunAsync(TestContext.Current.CancellationToken); - } -} diff --git a/src/DimensionalQuantities.Roslyn.Tests/Generators/UnitProviderReaderTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Generators/UnitProviderReaderTests.cs deleted file mode 100644 index a556e11..0000000 --- a/src/DimensionalQuantities.Roslyn.Tests/Generators/UnitProviderReaderTests.cs +++ /dev/null @@ -1,184 +0,0 @@ -using DimensionalQuantities.Roslyn.Generators; -using DimensionalQuantities.TypeSystem; -using DimensionalQuantities.Numerics; -using DimensionalQuantities.Units; -using Microsoft.CodeAnalysis; -using Microsoft.CodeAnalysis.CSharp; -using Xunit; - -namespace DimensionalQuantities.Roslyn.Tests.Generators; - -public sealed class UnitProviderReaderTests -{ - [Fact] - public void InvalidPowerDenominatorReportsDiagnostic() - { - const string source = """ - using DimensionalQuantities.Units.Declarations; - [UnitProvider] - internal static class Units - { - [QuantityUnit(typeof(Length))] - [UnitFactor(typeof(Foot), PowerDenominator = 0)] - private sealed class LengthUnit; - [UnitSymbol("Foot", "Feet", "ft")] - private sealed class Foot; - } - """; - (IReadOnlyList units, List diagnostics) = Read(source); - Assert.Multiple( - () => Assert.Empty(units), - () => Assert.Equal("DQ0008", Assert.Single(diagnostics).Id)); - } - - [Fact] - public void RationalFactorPowerAndScaleAreReadFromDeclarations() - { - const string source = """ - using DimensionalQuantities.Units.Declarations; - [UnitProvider] - internal static class Units - { - [QuantityUnit(typeof(Length))] - [UnitFactor(typeof(SquareMetre), PowerDenominator = 2)] - private sealed class LengthUnit; - [UnitSymbol("SquareMetre", "SquareMetres", "m²", Scale = 4)] - private sealed class SquareMetre; - } - """; - (IReadOnlyList units, List diagnostics) = Read(source); - UnitConversionSpec result = Assert.Single(units); - Assert.Multiple( - () => Assert.Empty(diagnostics), - () => Assert.Equal(new Rational(1, 2), result.Units[0].Expression.Terms[0].Power), - () => Assert.Equal(4, result.Units[0].Expression.Terms[0].Unit.Scale)); - } - - [Fact] - public void MultipleAliasesForSameQuantityShareOneUnitDefinition() - { - const string source = """ - using DimensionalQuantities.Units.Declarations; - [UnitProvider] - internal static class Units - { - [QuantityUnit(typeof(Pressure))] - [QuantityUnit(typeof(Stress))] - [UnitFactor(typeof(Pascal))] - private sealed class PascalUnit; - [UnitSymbol("Pascal", "Pascals", "Pa")] - private sealed class Pascal; - } - """; - (IReadOnlyList units, List diagnostics) = Read(source); - UnitConversionSpec result = Assert.Single(units); - Assert.Multiple( - () => Assert.Empty(diagnostics), - () => Assert.Single(result.Units), - () => Assert.Equal("Pascal", result.ExtensionName)); - } - - [Fact] - public void AffineOffsetIsReadForAnAdditionalUnit() - { - const string source = """ - using DimensionalQuantities.Units.Declarations; - [UnitProvider] - internal static class Units - { - [QuantityUnit(typeof(Temperature))] - [UnitFactor(typeof(Rankine))] - [AdditionalUnit(typeof(FahrenheitUnit))] - private sealed class TemperatureUnit; - [UnitFactor(typeof(Fahrenheit))] - private sealed class FahrenheitUnit; - [UnitSymbol("Rankine", "Rankine", "°R", Scale = 5d / 9d)] - private sealed class Rankine; - [UnitSymbol("Fahrenheit", "Fahrenheit", "°F", Scale = 5d / 9d)] - [AffineUnit(459.67)] - private sealed class Fahrenheit; - } - """; - (IReadOnlyList units, List diagnostics) = Read(source); - UnitDefinition unit = Assert.Single(Assert.Single(units).Units); - Assert.Multiple( - () => Assert.Empty(diagnostics), - () => Assert.Null(unit.OffsetBeforeScale), - () => Assert.Equal(459.67, Assert.Single(unit.AdditionalConversions).OffsetBeforeScale)); - } - - [Theory] - [InlineData("[UnitFactor(typeof(Celsius), Power = 2)]", "")] - [InlineData("[UnitFactor(typeof(Celsius), PrefixExponent = 3)]", "")] - [InlineData("[UnitFactor(typeof(Celsius))]", "[UnitFactor(typeof(Metre))]")] - public void AffineUnitsRejectPoweredPrefixedAndCompoundDeclarations(string factor, string additionalFactor) - { - string source = $$""" - using DimensionalQuantities.Units.Declarations; - [UnitProvider] - internal static class Units - { - [QuantityUnit(typeof(Temperature))] - {{factor}} - {{additionalFactor}} - private sealed class TemperatureUnit; - [UnitSymbol("Celsius", "Celsius", "°C")] - [AffineUnit(273.15)] - private sealed class Celsius; - [UnitSymbol("Metre", "Metres", "m")] - private sealed class Metre; - } - """; - (IReadOnlyList units, List diagnostics) = Read(source); - Assert.Multiple( - () => Assert.Empty(units), - () => Assert.Equal("DQ0008", Assert.Single(diagnostics).Id)); - } - - [Fact] - public void OneDeclarationCanAssociateDistinctQuantityTypes() - { - const string source = """ - using DimensionalQuantities.Units.Declarations; - [UnitProvider] - internal static class Units - { - [QuantityUnit(typeof(Length))] - [QuantityUnit(typeof(Time))] - [UnitFactor(typeof(Token))] - private sealed class TokenUnit; - [UnitSymbol("Token", "Tokens", "token")] - private sealed class Token; - } - """; - (IReadOnlyList units, List diagnostics) = Read(source); - string[] expected = - [ - QuantityTypeNameFormatter.Format(new DimensionalQuantities.Dimensions.Dimension(Length: 1)), - QuantityTypeNameFormatter.Format(new DimensionalQuantities.Dimensions.Dimension(Time: 1)) - ]; - Assert.Multiple( - () => Assert.Empty(diagnostics), - () => Assert.All(units, unit => Assert.Equal("Token", unit.ExtensionName)), - () => Assert.Equal(expected.Order(StringComparer.Ordinal), units.Select(unit => unit.ReceiverType).Order(StringComparer.Ordinal))); - } - - private static (IReadOnlyList Units, List Diagnostics) Read(string source) - { - CSharpParseOptions options = new(LanguageVersion.Preview); - string[] assemblies = ((string)AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES")!).Split(Path.PathSeparator); - IEnumerable references = assemblies.Select(path => MetadataReference.CreateFromFile(path)) - .Append(MetadataReference.CreateFromFile(typeof(Quantity<>).Assembly.Location)); - string lengthType = QuantityTypeNameFormatter.Format(new DimensionalQuantities.Dimensions.Dimension(Length: 1)); - string timeType = QuantityTypeNameFormatter.Format(new DimensionalQuantities.Dimensions.Dimension(Time: 1)); - string pressureType = QuantityTypeNameFormatter.Format(new DimensionalQuantities.Dimensions.Dimension(Length: -1, Mass: 1, Time: -2)); - string temperatureType = QuantityTypeNameFormatter.Format(new DimensionalQuantities.Dimensions.Dimension(Temperature: 1)); - source = $"global using Length = {lengthType};\nglobal using Time = {timeType};\nglobal using Pressure = {pressureType};\nglobal using Stress = {pressureType};\nglobal using Temperature = {temperatureType};\n" + source; - CSharpCompilation input = CSharpCompilation.Create("UnitProviderReaderTest" + Guid.NewGuid().ToString("N"), - [CSharpSyntaxTree.ParseText(source, options)], references, new(OutputKind.DynamicallyLinkedLibrary)); - UnitProviderReader reader = new(input); - List diagnostics = []; - IReadOnlyList units = reader.Read(input.GetTypeByMetadataName("Units")!, diagnostics.Add); - return (units, diagnostics); - } -} diff --git a/src/DimensionalQuantities.Roslyn.Tests/Testing/QuantityAnalyzerTest.cs b/src/DimensionalQuantities.Roslyn.Tests/Testing/QuantityAnalyzerTest.cs deleted file mode 100644 index 8e16c60..0000000 --- a/src/DimensionalQuantities.Roslyn.Tests/Testing/QuantityAnalyzerTest.cs +++ /dev/null @@ -1,19 +0,0 @@ -using DimensionalQuantities.Roslyn.Generators; -using Microsoft.CodeAnalysis.CSharp.Testing; -using Microsoft.CodeAnalysis.Diagnostics; -using Microsoft.CodeAnalysis.Testing; - -namespace DimensionalQuantities.Roslyn.Tests.Testing; - -internal sealed class QuantityAnalyzerTest : CSharpAnalyzerTest where TAnalyzer : DiagnosticAnalyzer, new() -{ - public QuantityAnalyzerTest() - { - QuantityTestConfiguration.Apply(this); - TestBehaviors |= TestBehaviors.SkipGeneratedSourcesCheck; - } - - public bool Generate { get; init; } = true; - - protected override IEnumerable GetSourceGenerators() => Generate ? [typeof(QuantityGenerator)] : []; -} diff --git a/src/DimensionalQuantities.Roslyn.Tests/Testing/QuantityCodeFixTest.cs b/src/DimensionalQuantities.Roslyn.Tests/Testing/QuantityCodeFixTest.cs deleted file mode 100644 index 975bbcd..0000000 --- a/src/DimensionalQuantities.Roslyn.Tests/Testing/QuantityCodeFixTest.cs +++ /dev/null @@ -1,17 +0,0 @@ -using DimensionalQuantities.Roslyn.Analyzers; -using DimensionalQuantities.Roslyn.CodeFixes; -using Microsoft.CodeAnalysis.CSharp.Testing; -using Microsoft.CodeAnalysis.Testing; - -namespace DimensionalQuantities.Roslyn.Tests.Testing; - -internal sealed class QuantityCodeFixTest : CSharpCodeFixTest -{ - public QuantityCodeFixTest() - { - QuantityTestConfiguration.Apply(this); - // The fix resolves aliases through its Document, so generation must run in the workspace. - SolutionTransforms.Add((solution, projectId) => solution.AddAnalyzerReference(projectId, new QuantityGeneratorReference())); - } - -} diff --git a/src/DimensionalQuantities.Roslyn.Tests/Testing/QuantityGeneratorReference.cs b/src/DimensionalQuantities.Roslyn.Tests/Testing/QuantityGeneratorReference.cs deleted file mode 100644 index 7c675f2..0000000 --- a/src/DimensionalQuantities.Roslyn.Tests/Testing/QuantityGeneratorReference.cs +++ /dev/null @@ -1,22 +0,0 @@ -using System.Collections.Immutable; -using DimensionalQuantities.Roslyn.Generators; -using Microsoft.CodeAnalysis; -using Microsoft.CodeAnalysis.Diagnostics; - -namespace DimensionalQuantities.Roslyn.Tests.Testing; - -internal sealed class QuantityGeneratorReference : AnalyzerReference -{ - private readonly ImmutableArray _generators = [new QuantityGenerator().AsSourceGenerator()]; - - public override string? FullPath => null; - - public override object Id => typeof(QuantityGenerator); - - public override ImmutableArray GetAnalyzers(string language) => []; - - public override ImmutableArray GetAnalyzersForAllLanguages() => []; - - public override ImmutableArray GetGenerators(string language) => language == LanguageNames.CSharp - ? _generators : []; -} diff --git a/src/DimensionalQuantities.Roslyn.Tests/Testing/QuantityGeneratorTest.cs b/src/DimensionalQuantities.Roslyn.Tests/Testing/QuantityGeneratorTest.cs deleted file mode 100644 index 62a1ddc..0000000 --- a/src/DimensionalQuantities.Roslyn.Tests/Testing/QuantityGeneratorTest.cs +++ /dev/null @@ -1,30 +0,0 @@ -using System.Collections.Immutable; -using DimensionalQuantities.Roslyn.Generators; -using Microsoft.CodeAnalysis; -using Microsoft.CodeAnalysis.CSharp.Testing; -using Microsoft.CodeAnalysis.Testing; - -namespace DimensionalQuantities.Roslyn.Tests.Testing; - -internal sealed class QuantityGeneratorTest : CSharpSourceGeneratorTest -{ - public QuantityGeneratorTest() - { - QuantityTestConfiguration.Apply(this); - } - - public Compilation Compilation { get; private set; } = null!; - - public Type? AdditionalGenerator { get; init; } - - protected override IEnumerable GetSourceGenerators() => AdditionalGenerator is null - ? [typeof(QuantityGenerator)] : [typeof(QuantityGenerator), AdditionalGenerator]; - - protected override async Task<(Compilation compilation, ImmutableArray generatorDiagnostics)> GetProjectCompilationAsync( - Project project, IVerifier verifier, CancellationToken cancellationToken) - { - (Compilation compilation, ImmutableArray generatorDiagnostics) result = await base.GetProjectCompilationAsync(project, verifier, cancellationToken); - Compilation = result.compilation; - return result; - } -} diff --git a/src/DimensionalQuantities.Roslyn.Tests/Testing/QuantityTestConfiguration.cs b/src/DimensionalQuantities.Roslyn.Tests/Testing/QuantityTestConfiguration.cs deleted file mode 100644 index 37577da..0000000 --- a/src/DimensionalQuantities.Roslyn.Tests/Testing/QuantityTestConfiguration.cs +++ /dev/null @@ -1,18 +0,0 @@ -using DimensionalQuantities.TypeSystem; -using Microsoft.CodeAnalysis; -using Microsoft.CodeAnalysis.CSharp; -using Microsoft.CodeAnalysis.Testing; - -namespace DimensionalQuantities.Roslyn.Tests.Testing; - -internal static class QuantityTestConfiguration -{ - public static void Apply(AnalyzerTest test) where TVerifier : IVerifier, new() - { - test.ReferenceAssemblies = new ReferenceAssemblies("net11.0"); - test.TestState.AdditionalReferences.AddRange(((string)AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES")!) - .Split(Path.PathSeparator).Select(path => MetadataReference.CreateFromFile(path))); - test.TestState.AdditionalReferences.Add(MetadataReference.CreateFromFile(typeof(Quantity<>).Assembly.Location)); - test.SolutionTransforms.Add((solution, projectId) => solution.WithProjectParseOptions(projectId, new CSharpParseOptions(LanguageVersion.Preview))); - } -} diff --git a/src/DimensionalQuantities.slnx b/src/DimensionalQuantities.slnx index 2c6c5ff..6d70b1b 100644 --- a/src/DimensionalQuantities.slnx +++ b/src/DimensionalQuantities.slnx @@ -21,8 +21,6 @@ - - From 5c327d1dbe1bd42296df38a1ee3ad6706ccd3a03 Mon Sep 17 00:00:00 2001 From: James McMahon Date: Fri, 13 Nov 2026 10:52:53 +0000 Subject: [PATCH 05/16] test: rebuild catalogue-based Roslyn and consumer suites --- .../DeliveredCodeFixTests.cs | 75 +++++ .../Delivery/PackageSandbox.cs | 105 +++++++ ...ensionalQuantities.IntegrationTests.csproj | 23 ++ .../GeneratedExecutionTests.cs | 85 ++++++ .../PackageArchiveTests.cs | 121 +++++++++ .../PackageReferenceTests.cs | 104 +++++++ .../CodeFixes/QuantityAliasFixTests.cs | 147 ++++++++++ .../Diagnostics/DimensionMismatchTests.cs | 175 ++++++++++++ .../Diagnostics/GeneratorDiagnosticTests.cs | 156 +++++++++++ .../Diagnostics/QuantityEncodingTests.cs | 157 +++++++++++ .../Diagnostics/QuantityIdentityTests.cs | 75 +++++ .../UnitDeclarationDiagnosticTests.cs | 145 ++++++++++ .../DimensionalQuantities.Roslyn.Tests.csproj | 27 ++ .../Framework/QuantityAnalyzerTest.cs | 14 + .../Framework/QuantityCodeFixTest.cs | 16 ++ .../Framework/QuantityGeneratorTest.cs | 33 +++ .../Framework/QuantitySourceReference.cs | 17 ++ .../Framework/QuantityTestEnvironment.cs | 16 ++ .../Generation/AdditionalDiscoveryTests.cs | 144 ++++++++++ .../Generation/BindingBoundaryTests.cs | 78 ++++++ .../Generation/DiscoveryBehaviourTests.cs | 257 ++++++++++++++++++ .../Generation/GenerationControlTests.cs | 126 +++++++++ .../Generation/MetadataDiscoveryTests.cs | 69 +++++ .../Generation/SymbolIdentityTests.cs | 35 +++ .../Generation/UnsupportedRequestTests.cs | 37 +++ .../Providers/CompoundFactorTests.cs | 32 +++ .../Providers/CoreHelperTests.cs | 53 ++++ .../Providers/NamedPrefixTests.cs | 49 ++++ .../Providers/ProviderBehaviourTests.cs | 179 ++++++++++++ .../Providers/ProviderBoundaryTests.cs | 102 +++++++ .../Providers/ProviderDeclarationTests.cs | 111 ++++++++ .../Providers/ProviderFinalContractTests.cs | 59 ++++ .../Providers/ProviderMetadataTests.cs | 106 ++++++++ .../Runtime/AdditionalShippedContractTests.cs | 23 ++ .../Runtime/RuntimeQuantityBehaviourTests.cs | 140 ++++++++++ .../ShippedConversionBehaviourTests.cs | 229 ++++++++++++++++ src/DimensionalQuantities.slnx | 2 + 37 files changed, 3322 insertions(+) create mode 100644 src/DimensionalQuantities.IntegrationTests/DeliveredCodeFixTests.cs create mode 100644 src/DimensionalQuantities.IntegrationTests/Delivery/PackageSandbox.cs create mode 100644 src/DimensionalQuantities.IntegrationTests/DimensionalQuantities.IntegrationTests.csproj create mode 100644 src/DimensionalQuantities.IntegrationTests/GeneratedExecutionTests.cs create mode 100644 src/DimensionalQuantities.IntegrationTests/PackageArchiveTests.cs create mode 100644 src/DimensionalQuantities.IntegrationTests/PackageReferenceTests.cs create mode 100644 src/DimensionalQuantities.Roslyn.Tests/CodeFixes/QuantityAliasFixTests.cs create mode 100644 src/DimensionalQuantities.Roslyn.Tests/Diagnostics/DimensionMismatchTests.cs create mode 100644 src/DimensionalQuantities.Roslyn.Tests/Diagnostics/GeneratorDiagnosticTests.cs create mode 100644 src/DimensionalQuantities.Roslyn.Tests/Diagnostics/QuantityEncodingTests.cs create mode 100644 src/DimensionalQuantities.Roslyn.Tests/Diagnostics/QuantityIdentityTests.cs create mode 100644 src/DimensionalQuantities.Roslyn.Tests/Diagnostics/UnitDeclarationDiagnosticTests.cs create mode 100644 src/DimensionalQuantities.Roslyn.Tests/DimensionalQuantities.Roslyn.Tests.csproj create mode 100644 src/DimensionalQuantities.Roslyn.Tests/Framework/QuantityAnalyzerTest.cs create mode 100644 src/DimensionalQuantities.Roslyn.Tests/Framework/QuantityCodeFixTest.cs create mode 100644 src/DimensionalQuantities.Roslyn.Tests/Framework/QuantityGeneratorTest.cs create mode 100644 src/DimensionalQuantities.Roslyn.Tests/Framework/QuantitySourceReference.cs create mode 100644 src/DimensionalQuantities.Roslyn.Tests/Framework/QuantityTestEnvironment.cs create mode 100644 src/DimensionalQuantities.Roslyn.Tests/Generation/AdditionalDiscoveryTests.cs create mode 100644 src/DimensionalQuantities.Roslyn.Tests/Generation/BindingBoundaryTests.cs create mode 100644 src/DimensionalQuantities.Roslyn.Tests/Generation/DiscoveryBehaviourTests.cs create mode 100644 src/DimensionalQuantities.Roslyn.Tests/Generation/GenerationControlTests.cs create mode 100644 src/DimensionalQuantities.Roslyn.Tests/Generation/MetadataDiscoveryTests.cs create mode 100644 src/DimensionalQuantities.Roslyn.Tests/Generation/SymbolIdentityTests.cs create mode 100644 src/DimensionalQuantities.Roslyn.Tests/Generation/UnsupportedRequestTests.cs create mode 100644 src/DimensionalQuantities.Roslyn.Tests/Providers/CompoundFactorTests.cs create mode 100644 src/DimensionalQuantities.Roslyn.Tests/Providers/CoreHelperTests.cs create mode 100644 src/DimensionalQuantities.Roslyn.Tests/Providers/NamedPrefixTests.cs create mode 100644 src/DimensionalQuantities.Roslyn.Tests/Providers/ProviderBehaviourTests.cs create mode 100644 src/DimensionalQuantities.Roslyn.Tests/Providers/ProviderBoundaryTests.cs create mode 100644 src/DimensionalQuantities.Roslyn.Tests/Providers/ProviderDeclarationTests.cs create mode 100644 src/DimensionalQuantities.Roslyn.Tests/Providers/ProviderFinalContractTests.cs create mode 100644 src/DimensionalQuantities.Roslyn.Tests/Providers/ProviderMetadataTests.cs create mode 100644 src/DimensionalQuantities.Roslyn.Tests/Runtime/AdditionalShippedContractTests.cs create mode 100644 src/DimensionalQuantities.Roslyn.Tests/Runtime/RuntimeQuantityBehaviourTests.cs create mode 100644 src/DimensionalQuantities.Roslyn.Tests/Runtime/ShippedConversionBehaviourTests.cs diff --git a/src/DimensionalQuantities.IntegrationTests/DeliveredCodeFixTests.cs b/src/DimensionalQuantities.IntegrationTests/DeliveredCodeFixTests.cs new file mode 100644 index 0000000..8d778c7 --- /dev/null +++ b/src/DimensionalQuantities.IntegrationTests/DeliveredCodeFixTests.cs @@ -0,0 +1,75 @@ +using System.Collections.Immutable; +using System.Composition.Hosting; +using System.IO.Compression; +using System.Reflection; +using System.Runtime.Loader; +using DimensionalQuantities.IntegrationTests.Delivery; +using Microsoft.CodeAnalysis; +using Microsoft.CodeAnalysis.CodeActions; +using Microsoft.CodeAnalysis.CodeFixes; +using Microsoft.CodeAnalysis.CSharp; +using Microsoft.CodeAnalysis.CSharp.Syntax; +using Microsoft.CodeAnalysis.Text; +using Xunit; + +namespace DimensionalQuantities.IntegrationTests; + +public sealed class DeliveredCodeFixTests +{ + [Fact] + public async Task PackagedMefExportLoadsAndReplacesRawQuantityWithSafeAlias() + { + using PackageSandbox sandbox = new(); + await sandbox.Pack(); + string extracted = Path.Combine(sandbox.Root, "extracted"); + ZipFile.ExtractToDirectory(sandbox.ArchivePath("DimensionalQuantities"), extracted); + string codeFixPath = Path.Combine(extracted, "analyzers/dotnet/cs/DimensionalQuantities.Roslyn.CodeFixes.dll"); + AssemblyLoadContext loadContext = new("delivered-fix-" + Guid.NewGuid(), isCollectible: true); + loadContext.Resolving += (_, name) => AssemblyLoadContext.Default.LoadFromAssemblyName(name); + try + { + Assembly delivered = loadContext.LoadFromAssemblyPath(codeFixPath); + using CompositionHost exports = new ContainerConfiguration().WithAssembly(delivered).CreateContainer(); + CodeFixProvider provider = Assert.Single(exports.GetExports()); + Assert.Multiple( + () => Assert.Equal(codeFixPath, delivered.Location), + () => Assert.Equal(["DQ0003"], provider.FixableDiagnosticIds)); + + const string source = """ + using DimensionalQuantities.TypeSystem; + using Length = DimensionalQuantities.TypeSystem.Quantity>; + class Example { Quantity> value; } + """; + using AdhocWorkspace workspace = new(); + Project project = workspace.AddProject("Consumer", LanguageNames.CSharp) + .WithParseOptions(new CSharpParseOptions(LanguageVersion.Preview)) + .WithCompilationOptions(new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)) + .AddMetadataReferences(((string)AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES")!).Split(Path.PathSeparator) + .Where(path => !Path.GetFileName(path).StartsWith("DimensionalQuantities", StringComparison.Ordinal)) + .Select(path => MetadataReference.CreateFromFile(path))) + .AddMetadataReference(MetadataReference.CreateFromFile(Path.Combine(extracted, "lib/netstandard2.0/DimensionalQuantities.dll"))); + Document document = project.AddDocument("Consumer.cs", SourceText.From(source)); + Compilation compilation = (await document.Project.GetCompilationAsync(TestContext.Current.CancellationToken))!; + Assert.Empty(compilation.GetDiagnostics(TestContext.Current.CancellationToken).Where(d => d.Severity == DiagnosticSeverity.Error)); + SyntaxNode root = (await document.GetSyntaxRootAsync(TestContext.Current.CancellationToken))!; + GenericNameSyntax quantity = root.DescendantNodes().OfType().Single().Declaration.Type.DescendantNodesAndSelf().OfType().First(); + Diagnostic diagnostic = Diagnostic.Create(new DiagnosticDescriptor("DQ0003", "Alias", "Use alias", "Usage", DiagnosticSeverity.Info, true), + quantity.GetLocation(), ImmutableDictionary.Empty.Add("AliasName", "Length")); + List actions = []; + await provider.RegisterCodeFixesAsync(new CodeFixContext(document, diagnostic, (action, _) => actions.Add(action), TestContext.Current.CancellationToken)); + CodeAction action = Assert.Single(actions); + ApplyChangesOperation operation = Assert.Single((await action.GetOperationsAsync(TestContext.Current.CancellationToken)).OfType()); + string updated = (await operation.ChangedSolution.GetDocument(document.Id)!.GetTextAsync(TestContext.Current.CancellationToken)).ToString(); + Compilation updatedCompilation = (await operation.ChangedSolution.GetDocument(document.Id)!.Project.GetCompilationAsync(TestContext.Current.CancellationToken))!; + Assert.Multiple( + () => Assert.Equal("Use Length", action.Title), + () => Assert.Contains("class Example { Length value; }", updated), + () => Assert.Empty(updatedCompilation.GetDiagnostics(TestContext.Current.CancellationToken).Where(d => d.Severity == DiagnosticSeverity.Error))); + } + finally { loadContext.Unload(); } + } +} diff --git a/src/DimensionalQuantities.IntegrationTests/Delivery/PackageSandbox.cs b/src/DimensionalQuantities.IntegrationTests/Delivery/PackageSandbox.cs new file mode 100644 index 0000000..1751f8d --- /dev/null +++ b/src/DimensionalQuantities.IntegrationTests/Delivery/PackageSandbox.cs @@ -0,0 +1,105 @@ +using System.Diagnostics; +using System.IO.Compression; +using System.Xml.Linq; + +namespace DimensionalQuantities.IntegrationTests.Delivery; + +internal sealed class PackageSandbox : IDisposable +{ + public string Root { get; } = Path.Combine(Path.GetTempPath(), "dq-consumer-" + Guid.NewGuid().ToString("N")); + public string Feed => Path.Combine(Root, "feed"); + public string Consumer => Path.Combine(Root, "consumer"); + public string Cache => Path.Combine(Root, "packages"); + public string Version { get; private set; } = ""; + + public PackageSandbox() + { + Directory.CreateDirectory(Feed); + Directory.CreateDirectory(Consumer); + File.WriteAllText(Path.Combine(Root, "NuGet.Config"), $""); + } + + public async Task Pack(params string[] optionalPackages) + { + string repository = AppContext.BaseDirectory; + while (!File.Exists(Path.Combine(repository, "global.json"))) + { + repository = Directory.GetParent(repository)!.FullName; + } + + File.Copy(Path.Combine(repository, "global.json"), Path.Combine(Root, "global.json"), overwrite: true); + + foreach (string id in new[] { "DimensionalQuantities" }.Concat(optionalPackages).Distinct()) + { + ProcessResult result = await Run(repository, "pack", Path.Combine(repository, "src", id, id + ".csproj"), "-c", "Release", "--no-build", "--no-restore", "-o", Feed, "-p:NuspecOutputPath=" + Path.Combine(Root, "nuspec", id), "--nologo"); + result.EnsureSuccess(); + } + + using ZipArchive archive = ZipFile.OpenRead(ArchivePath("DimensionalQuantities")); + using Stream stream = archive.Entries.Single(e => e.FullName.EndsWith(".nuspec", StringComparison.Ordinal)).Open(); + Version = XDocument.Load(stream).Descendants().Single(e => e.Name.LocalName == "version").Value; + } + + public string ArchivePath(string id, bool symbols = false) => Directory.GetFiles(Feed, id + ".*." + (symbols ? "snupkg" : "nupkg")) + .Single(path => Path.GetFileName(path).StartsWith(id + ".", StringComparison.Ordinal) && + !Path.GetFileName(path)[(id.Length + 1)..].StartsWith("Extensions.", StringComparison.Ordinal)); + + public void WriteConsumer(string source, params string[] packageIds) + { + string references = string.Join("\n", packageIds.Select(id => $"")); + File.WriteAllText(Path.Combine(Consumer, "Consumer.csproj"), $$""" + + net11.0Exepreviewenable + {{references}} + + """); + File.WriteAllText(Path.Combine(Consumer, "Program.cs"), source); + } + + public async Task BuildConsumer() + { + (await Run(Consumer, "restore", "--configfile", Path.Combine(Root, "NuGet.Config"), "--packages", Cache, "--nologo")).EnsureSuccess(); + return await Run(Consumer, "build", "-c", "Release", "--no-restore", "--nologo"); + } + + public async Task ExecuteConsumer() + { + (await BuildConsumer()).EnsureSuccess(); + ProcessResult result = await Run(Consumer, Path.Combine(Consumer, "bin", "Release", "net11.0", "Consumer.dll")); + result.EnsureSuccess(); + return result.Output.Trim(); + } + + public async Task Run(string workingDirectory, params string[] arguments) + { + ProcessStartInfo start = new("dotnet") { WorkingDirectory = workingDirectory, RedirectStandardOutput = true, RedirectStandardError = true }; + foreach (string argument in arguments) + { + start.ArgumentList.Add(argument); + } + + if (workingDirectory == Consumer) + { + start.Environment["NUGET_PACKAGES"] = Cache; + } + + using Process process = Process.Start(start)!; + Task stdout = process.StandardOutput.ReadToEndAsync(); + Task stderr = process.StandardError.ReadToEndAsync(); + await process.WaitForExitAsync(); + return new(process.ExitCode, await stdout + "\n" + await stderr); + } + + public void Dispose() => Directory.Delete(Root, recursive: true); + + internal sealed record ProcessResult(int ExitCode, string Output) + { + public void EnsureSuccess() + { + if (ExitCode != 0) + { + throw new InvalidOperationException($"dotnet exited {ExitCode}:\n{Output}"); + } + } + } +} diff --git a/src/DimensionalQuantities.IntegrationTests/DimensionalQuantities.IntegrationTests.csproj b/src/DimensionalQuantities.IntegrationTests/DimensionalQuantities.IntegrationTests.csproj new file mode 100644 index 0000000..f016e87 --- /dev/null +++ b/src/DimensionalQuantities.IntegrationTests/DimensionalQuantities.IntegrationTests.csproj @@ -0,0 +1,23 @@ + + + net11.0 + false + true + Exe + true + + + + + + + + + + + + + + + + diff --git a/src/DimensionalQuantities.IntegrationTests/GeneratedExecutionTests.cs b/src/DimensionalQuantities.IntegrationTests/GeneratedExecutionTests.cs new file mode 100644 index 0000000..e6fc401 --- /dev/null +++ b/src/DimensionalQuantities.IntegrationTests/GeneratedExecutionTests.cs @@ -0,0 +1,85 @@ +using System.Globalization; +using DimensionalQuantities.IntegrationTests.Delivery; +using Xunit; + +namespace DimensionalQuantities.IntegrationTests; + +public sealed class GeneratedExecutionTests +{ + [Theory] + [InlineData("Length.FromSiBaseUnit(6) * Current.FromSiBaseUnit(2)", 12)] + [InlineData("Length.FromSiBaseUnit(6) / Current.FromSiBaseUnit(2)", 3)] + public async Task GeneratedArithmeticComputesSiMagnitude(string expression, double expected) + { + using PackageSandbox sandbox = new(); + await sandbox.Pack(); + sandbox.WriteConsumer($"Console.WriteLine(({expression}).AsSiBaseUnit().ToString(\"R\", System.Globalization.CultureInfo.InvariantCulture));", "DimensionalQuantities"); + Assert.Equal(expected, double.Parse(await sandbox.ExecuteConsumer(), CultureInfo.InvariantCulture), 12); + } + + [Theory] + [InlineData("NumberHalf", "Area", "9", 3)] + [InlineData("NumberTwoOverThree", "Volume", "8", 4)] + [InlineData("NumberMinusOne", "Length", "4", 0.25)] + public async Task OrdinaryRationalPowerComputesMagnitude(string exponent, string quantity, string value, double expected) + { + using PackageSandbox sandbox = new(); + await sandbox.Pack(); + sandbox.WriteConsumer($"using DimensionalQuantities.TypeSystem; Console.WriteLine(Power<{exponent}>.Of({quantity}.FromSiBaseUnit({value})).AsSiBaseUnit().ToString(\"R\", System.Globalization.CultureInfo.InvariantCulture));", "DimensionalQuantities"); + Assert.Equal(expected, double.Parse(await sandbox.ExecuteConsumer(), CultureInfo.InvariantCulture), 12); + } + + [Theory] + [InlineData("NumberOneOverThree", "-8", -2)] + [InlineData("NumberTwoOverThree", "-8", 4)] + [InlineData("NumberMinusOneOverThree", "-8", -0.5)] + [InlineData("NumberMinusTwoOverThree", "-8", 0.25)] + [InlineData("NumberHalf", "-8", double.NaN)] + [InlineData("NumberOneOverThree", "0", 0)] + [InlineData("NumberOneOverThree", "double.NegativeInfinity", double.NegativeInfinity)] + public async Task OddDenominatorPowerHandlesSignAndReciprocal(string exponent, string value, double expected) + { + using PackageSandbox sandbox = new(); + await sandbox.Pack(); + sandbox.WriteConsumer($"using DimensionalQuantities.TypeSystem; Console.WriteLine(Power<{exponent}>.Of(Length.FromSiBaseUnit({value})).AsSiBaseUnit().ToString(\"R\", System.Globalization.CultureInfo.InvariantCulture));", "DimensionalQuantities"); + double actual = double.Parse(await sandbox.ExecuteConsumer(), CultureInfo.InvariantCulture); + if (double.IsNaN(expected)) + { + Assert.True(double.IsNaN(actual)); + } + else if (double.IsInfinity(expected)) + { + Assert.Equal(expected, actual); + } + else + { + Assert.Equal(expected, actual, 12); + } + } + + [Fact] + public async Task GeneratedCompoundPrefixFormulaWeightsEachFactorPower() + { + using PackageSandbox sandbox = new(); + await sandbox.Pack(); + sandbox.WriteConsumer(""" + using DimensionalQuantities.Units.Declarations; + using DimensionalQuantities.Units.Symbols; + using ConsumerUnits; + var value = CurrentDensity.FromPrefixedUnits(2, ampPrefixExponent: 1, metrePrefixExponent: -4); + Console.WriteLine(value.AsSiBaseUnit().ToString("R", System.Globalization.CultureInfo.InvariantCulture)); + namespace ConsumerUnits + { + [UnitProvider(GeneratePrefixConversions = true)] + internal static class Units + { + [QuantityUnit(typeof(CurrentDensity))] + [UnitFactor(typeof(Amp))] + [UnitFactor(typeof(Metre), Power = -2)] + private sealed class Density; + } + } + """, "DimensionalQuantities"); + Assert.Equal(2e9, double.Parse(await sandbox.ExecuteConsumer(), CultureInfo.InvariantCulture), 6); + } +} diff --git a/src/DimensionalQuantities.IntegrationTests/PackageArchiveTests.cs b/src/DimensionalQuantities.IntegrationTests/PackageArchiveTests.cs new file mode 100644 index 0000000..f229fec --- /dev/null +++ b/src/DimensionalQuantities.IntegrationTests/PackageArchiveTests.cs @@ -0,0 +1,121 @@ +using System.IO.Compression; +using System.Reflection.Metadata; +using System.Reflection.PortableExecutable; +using System.Xml.Linq; +using DimensionalQuantities.IntegrationTests.Delivery; +using Xunit; + +namespace DimensionalQuantities.IntegrationTests; + +public sealed class PackageArchiveTests +{ + [Theory] + [InlineData("DimensionalQuantities")] + [InlineData("DimensionalQuantities.Extensions.Metric")] + [InlineData("DimensionalQuantities.Extensions.Imperial")] + [InlineData("DimensionalQuantities.Extensions.Nautical")] + [InlineData("DimensionalQuantities.Extensions.CgsEmag")] + public async Task RuntimePackagesShipNetstandardBinaryAndExactDependencyClosure(string id) + { + using PackageSandbox sandbox = new(); + await sandbox.Pack(id); + using ZipArchive archive = ZipFile.OpenRead(sandbox.ArchivePath(id)); + ZipArchiveEntry binary = archive.GetEntry($"lib/netstandard2.0/{id}.dll")!; + Assert.NotNull(binary); + using (MemoryStream contents = new()) + { + using (Stream stream = binary.Open()) + { + stream.CopyTo(contents); + } + + contents.Position = 0; + using PEReader pe = new(contents); + MetadataReader metadata = pe.GetMetadataReader(); + Assert.Multiple( + () => Assert.Equal(id, metadata.GetString(metadata.GetAssemblyDefinition().Name)), + () => Assert.DoesNotContain(metadata.AssemblyReferences.Select(handle => metadata.GetString(metadata.GetAssemblyReference(handle).Name)), + name => name.StartsWith("Microsoft.CodeAnalysis", StringComparison.Ordinal) || name is "JetBrains.Annotations" or "PolySharp")); + } + using Stream manifest = archive.Entries.Single(e => e.FullName.EndsWith(".nuspec", StringComparison.Ordinal)).Open(); + XDocument nuspec = XDocument.Load(manifest); + XElement[] dependencies = nuspec.Descendants().Where(e => e.Name.LocalName == "dependency").ToArray(); + if (id == "DimensionalQuantities") + { + Assert.Empty(dependencies); + } + else + { + XElement dependency = Assert.Single(dependencies); + Assert.Multiple( + () => Assert.Equal("DimensionalQuantities", (string?)dependency.Attribute("id")), + () => Assert.Equal($"[{sandbox.Version}]", (string?)dependency.Attribute("version"))); + } + Assert.Contains(nuspec.Descendants(), e => e.Name.LocalName == "repository" && (string?)e.Attribute("type") == "git"); + } + + [Theory] + [InlineData("DimensionalQuantities")] + [InlineData("DimensionalQuantities.Extensions.Metric")] + [InlineData("DimensionalQuantities.Extensions.Imperial")] + [InlineData("DimensionalQuantities.Extensions.Nautical")] + [InlineData("DimensionalQuantities.Extensions.CgsEmag")] + public async Task SymbolPackageContainsPortableSymbolsMatchingRuntimeBinary(string id) + { + using PackageSandbox sandbox = new(); + await sandbox.Pack(id); + using ZipArchive archive = ZipFile.OpenRead(sandbox.ArchivePath(id)); + using ZipArchive symbols = ZipFile.OpenRead(sandbox.ArchivePath(id, symbols: true)); + AssertPortablePair(archive.GetEntry($"lib/netstandard2.0/{id}.dll")!, symbols.GetEntry($"lib/netstandard2.0/{id}.pdb")!); + } + + [Theory] + [InlineData("DimensionalQuantities")] + [InlineData("DimensionalQuantities.Roslyn")] + [InlineData("DimensionalQuantities.Roslyn.CodeFixes")] + public async Task CorePackageShipsCompilerAssetsWithMatchingPortableSymbols(string name) + { + using PackageSandbox sandbox = new(); + await sandbox.Pack(); + using ZipArchive archive = ZipFile.OpenRead(sandbox.ArchivePath("DimensionalQuantities")); + AssertPortablePair(archive.GetEntry($"analyzers/dotnet/cs/{name}.dll")!, archive.GetEntry($"analyzers/dotnet/cs/{name}.pdb")!); + } + + private static void AssertPortablePair(ZipArchiveEntry dll, ZipArchiveEntry pdb) + { + Assert.Multiple( + () => Assert.NotNull(dll), + () => Assert.NotNull(pdb)); + using MemoryStream binary = new(); + using (Stream stream = dll.Open()) + { + stream.CopyTo(binary); + } + + binary.Position = 0; + using PEReader pe = new(binary); + using MemoryStream symbolStream = new(); + using (Stream stream = pdb.Open()) + { + stream.CopyTo(symbolStream); + } + + symbolStream.Position = 0; + using MetadataReaderProvider provider = MetadataReaderProvider.FromPortablePdbStream(symbolStream); + MetadataReader metadata = provider.GetMetadataReader(); + CodeViewDebugDirectoryData codeView = pe.ReadCodeViewDebugDirectoryData(Assert.Single(pe.ReadDebugDirectory(), entry => entry.Type == DebugDirectoryEntryType.CodeView)); + Assert.Multiple( + () => Assert.Equal(new Guid(metadata.DebugMetadataHeader!.Id.Take(16).ToArray()), codeView.Guid), + () => Assert.Equal(BitConverter.ToUInt32(metadata.DebugMetadataHeader!.Id.AsSpan()[16..]), + Assert.Single(pe.ReadDebugDirectory(), entry => entry.Type == DebugDirectoryEntryType.CodeView).Stamp), + () => Assert.NotEmpty(metadata.Documents), + () => Assert.All(metadata.Documents, handle => + { + Document document = metadata.GetDocument(handle); + Assert.Multiple( + () => Assert.NotEmpty(metadata.GetString(document.Name)), + () => Assert.NotEmpty(metadata.GetBlobBytes(document.Hash)), + () => Assert.NotEqual(Guid.Empty, metadata.GetGuid(document.HashAlgorithm))); + })); + } +} diff --git a/src/DimensionalQuantities.IntegrationTests/PackageReferenceTests.cs b/src/DimensionalQuantities.IntegrationTests/PackageReferenceTests.cs new file mode 100644 index 0000000..a1ec066 --- /dev/null +++ b/src/DimensionalQuantities.IntegrationTests/PackageReferenceTests.cs @@ -0,0 +1,104 @@ +using System.Text.Json; +using DimensionalQuantities.IntegrationTests.Delivery; +using Xunit; + +namespace DimensionalQuantities.IntegrationTests; + +public sealed class PackageReferenceTests +{ + [Fact] + public async Task CorePackageActivatesGeneratorAndRunsWithoutToolingRuntimeDependencies() + { + using PackageSandbox sandbox = new(); + await sandbox.Pack(); + sandbox.WriteConsumer("Console.WriteLine((Length.FromMetres(6) * Current.FromAmps(2)).AsSiBaseUnit());", "DimensionalQuantities"); + string output = await sandbox.ExecuteConsumer(); + using JsonDocument dependencies = JsonDocument.Parse(File.ReadAllText(Path.Combine(sandbox.Consumer, "bin/Release/net11.0/Consumer.deps.json"))); + Assert.Multiple( + () => Assert.Equal("12", output), + () => Assert.Equal(["Consumer", "DimensionalQuantities"], dependencies.RootElement.GetProperty("libraries").EnumerateObject().Select(p => p.Name.Split('/')[0]).Order().ToArray())); + } + + [Fact] + public async Task CorePackageDeliversDimensionalMismatchAnalyzer() + { + using PackageSandbox sandbox = new(); + await sandbox.Pack(); + sandbox.WriteConsumer("Console.WriteLine(Length.FromMetres(1) + Time.FromSeconds(1));", "DimensionalQuantities"); + PackageSandbox.ProcessResult result = await sandbox.BuildConsumer(); + Assert.Multiple( + () => Assert.NotEqual(0, result.ExitCode), + () => Assert.Contains("error DQ0001:", result.Output)); + } + + [Theory] + [InlineData("Metric", "Voltage.FromVolts(2)")] + [InlineData("Imperial", "Length.FromFeet(2)")] + [InlineData("Nautical", "Length.FromNauticalMiles(2)")] + [InlineData("CgsEmag", "MagneticFluxDensity.FromGauss(2)")] + public async Task OptionalPackageAloneSuppliesMatchingCoreAndCallableConversions(string extension, string expression) + { + string id = "DimensionalQuantities.Extensions." + extension; + using PackageSandbox sandbox = new(); + await sandbox.Pack(id); + sandbox.WriteConsumer($"using {id}; Console.WriteLine(({expression}).AsSiBaseUnit() > 0);", id); + string output = await sandbox.ExecuteConsumer(); + using JsonDocument assets = JsonDocument.Parse(File.ReadAllText(Path.Combine(sandbox.Consumer, "obj/project.assets.json"))); + string[] direct = assets.RootElement.GetProperty("project").GetProperty("frameworks").EnumerateObject().Single().Value.GetProperty("dependencies").EnumerateObject().Select(p => p.Name).ToArray(); + Assert.Multiple( + () => Assert.Equal("True", output), + () => Assert.True(assets.RootElement.GetProperty("libraries").TryGetProperty("DimensionalQuantities/" + sandbox.Version, out _)), + () => Assert.Equal([id], direct)); + } + + [Theory] + [InlineData("Metric", "Voltage.FromVolts(2)")] + [InlineData("Imperial", "Length.FromFeet(2)")] + [InlineData("Nautical", "Length.FromNauticalMiles(2)")] + [InlineData("CgsEmag", "MagneticFluxDensity.FromGauss(2)")] + public async Task OptionalConversionsRequireNamespaceImport(string extension, string expression) + { + string id = "DimensionalQuantities.Extensions." + extension; + using PackageSandbox sandbox = new(); + await sandbox.Pack(id); + sandbox.WriteConsumer($"Console.WriteLine(({expression}).AsSiBaseUnit());", id); + PackageSandbox.ProcessResult result = await sandbox.BuildConsumer(); + Assert.Multiple( + () => Assert.NotEqual(0, result.ExitCode), + () => Assert.Contains("error CS0117:", result.Output)); + } + + [Theory] + [InlineData("Voltage.FromVolts(2)")] + [InlineData("Length.FromFeet(2)")] + [InlineData("Length.FromNauticalMiles(2)")] + [InlineData("MagneticFluxDensity.FromGauss(2)")] + public async Task CorePackageDoesNotSupplyOptionalConversions(string expression) + { + using PackageSandbox sandbox = new(); + await sandbox.Pack(); + sandbox.WriteConsumer($"Console.WriteLine(({expression}).AsSiBaseUnit());", "DimensionalQuantities"); + PackageSandbox.ProcessResult result = await sandbox.BuildConsumer(); + Assert.Multiple( + () => Assert.NotEqual(0, result.ExitCode), + () => Assert.Contains("error CS0117:", result.Output)); + } + + [Fact] + public async Task CompatibleOptionalPackagesComposeThroughOneRuntimeType() + { + using PackageSandbox sandbox = new(); + string[] ids = ["DimensionalQuantities.Extensions.Metric", "DimensionalQuantities.Extensions.Imperial", "DimensionalQuantities.Extensions.Nautical", "DimensionalQuantities.Extensions.CgsEmag"]; + await sandbox.Pack(ids); + sandbox.WriteConsumer(""" + using DimensionalQuantities.Extensions.Metric; + using DimensionalQuantities.Extensions.Imperial; + using DimensionalQuantities.Extensions.Nautical; + using DimensionalQuantities.Extensions.CgsEmag; + Length total = Length.FromFeet(1) + Length.FromNauticalMiles(1); + Energy work = Energy.FromJoules(2) + Energy.FromErgs(10_000_000); + Console.WriteLine(total.AsSiBaseUnit() > 1852 && work.AsSiBaseUnit() == 3); + """, ids); + Assert.Equal("True", await sandbox.ExecuteConsumer()); + } +} diff --git a/src/DimensionalQuantities.Roslyn.Tests/CodeFixes/QuantityAliasFixTests.cs b/src/DimensionalQuantities.Roslyn.Tests/CodeFixes/QuantityAliasFixTests.cs new file mode 100644 index 0000000..4d3edb8 --- /dev/null +++ b/src/DimensionalQuantities.Roslyn.Tests/CodeFixes/QuantityAliasFixTests.cs @@ -0,0 +1,147 @@ +using DimensionalQuantities.Roslyn.CodeFixes; +using DimensionalQuantities.Roslyn.Analyzers; +using Microsoft.CodeAnalysis.CSharp.Testing; +using DimensionalQuantities.Roslyn.Tests.Framework; +using Microsoft.CodeAnalysis; +using Microsoft.CodeAnalysis.Testing; +using Xunit; + +namespace DimensionalQuantities.Roslyn.Tests.CodeFixes; + +public sealed class QuantityAliasFixTests +{ + private const string Imports = "using DimensionalQuantities.TypeSystem;\n"; + private const string RawLength = "Quantity>"; + private const string RawTime = "Quantity>"; + + [Fact] + public void ProviderAdvertisesOnlyAliasSuggestionAndActualBatchFixer() + { + QuantityAliasCodeFixProvider provider = new(); + Assert.Multiple( + () => Assert.Equal(new[] { "DQ0003" }, provider.FixableDiagnosticIds), + () => Assert.Same(Microsoft.CodeAnalysis.CodeFixes.WellKnownFixAllProviders.BatchFixer, provider.GetFixAllProvider())); + } + + [Theory] + [InlineData("{0} field;", "Length field;")] + [InlineData("{0}?[] field;", "Length?[] field;")] + [InlineData("System.Collections.Generic.List<{0}> field;", "System.Collections.Generic.List field;")] + [InlineData("global::DimensionalQuantities.TypeSystem.{0} field;", "Length field;")] + [InlineData("/* before */ {0} /* after */ field;", "/* before */ Length /* after */ field;")] + public async Task TypeReplacementPreservesWrappersAndExteriorSyntax(string declaration, string fixedDeclaration) + { + QuantityCodeFixTest test = new() + { + TestCode = Imports + "class Measurement { " + string.Format(declaration, "{|#0:" + RawLength + "|}") + " }", + FixedCode = Imports + "class Measurement { " + fixedDeclaration + " }", + CodeActionEquivalenceKey = "UseAlias:Length", + CodeActionVerifier = (action, verifier) => Assert.Equal("Use Length", action.Title) + }; + test.ExpectedDiagnostics.Add(Suggestion(0, "Length")); + await test.RunAsync(TestContext.Current.CancellationToken); + } + + [Theory] + [InlineData("class Length {}")] + [InlineData("using Length = System.String;")] + public async Task DifferentlyBoundAliasWithholdsFix(string shadow) + { + QuantityCodeFixTest test = new() + { + TestCode = Imports + "namespace Consumer { " + shadow + " class Measurement { {|#0:" + RawLength + "|} field; } }", + NumberOfIncrementalIterations = 0, + NumberOfFixAllIterations = 0 + }; + test.ExpectedDiagnostics.Add(Suggestion(0, "Length")); + await test.RunAsync(TestContext.Current.CancellationToken); + } + + [Fact] + public async Task SameTypeVisibleAliasIsEligible() + { + string prefix = Imports + "namespace Consumer { using Length = " + RawLength + "; class Measurement { "; + QuantityCodeFixTest test = new() + { + TestCode = prefix + "{|#0:" + RawLength + "|} field; } }", + FixedCode = prefix + "Length field; } }", + CodeActionEquivalenceKey = "UseAlias:Length", + CodeActionVerifier = (action, verifier) => Assert.Equal("Use Length", action.Title) + }; + test.ExpectedDiagnostics.Add(Suggestion(0, "Length")); + await test.RunAsync(TestContext.Current.CancellationToken); + } + + [Theory] + [InlineData("nameof({0})")] + [InlineData("nameof(System.Collections.Generic.List<{0}>)")] + public async Task RealNameofOperationWithholdsFix(string expression) + { + QuantityCodeFixTest test = new() + { + TestCode = Imports + "class Measurement { string name = " + string.Format(expression, "{|#0:" + RawLength + "|}") + "; }", + NumberOfIncrementalIterations = 0, + NumberOfFixAllIterations = 0 + }; + test.ExpectedDiagnostics.Add(Suggestion(0, "Length")); + await test.RunAsync(TestContext.Current.CancellationToken); + } + + [Fact] + public async Task OrdinaryInvocationNamedNameofIsEligible() + { + QuantityCodeFixTest test = new() + { + TestCode = Imports + "class Measurement { static string @nameof(System.Type type) => type.Name; string name = @nameof(typeof({|#0:" + RawLength + "|})); }", + FixedCode = Imports + "class Measurement { static string @nameof(System.Type type) => type.Name; string name = @nameof(typeof(Length)); }", + CodeActionEquivalenceKey = "UseAlias:Length", + CodeActionVerifier = (action, verifier) => Assert.Equal("Use Length", action.Title) + }; + test.ExpectedDiagnostics.Add(Suggestion(0, "Length")); + await test.RunAsync(TestContext.Current.CancellationToken); + } + + [Fact] + public async Task LengthFixAllChangesEligibleSitesAcrossDocumentsAndKeepsOtherAliases() + { + QuantityCodeFixTest test = new() + { + CodeActionEquivalenceKey = "UseAlias:Length", + NumberOfIncrementalIterations = 3, + NumberOfFixAllIterations = 1, + NumberOfFixAllInDocumentIterations = 2 + }; + test.TestState.Sources.Add(("Measurements.cs", Imports + "class Measurement { {|#0:" + RawLength + "|} first; {|#1:" + RawLength + "|} second; {|#2:" + RawTime + "|} time; string name = nameof({|#3:" + RawLength + "|}); }")); + test.TestState.Sources.Add(("Other.cs", Imports + "class Other { {|#4:" + RawLength + "|} value; } namespace Hidden { class Length {} class Shadowed { {|#5:" + RawLength + "|} value; } }")); + test.FixedState.Sources.Add(("Measurements.cs", Imports + "class Measurement { Length first; Length second; {|#2:" + RawTime + "|} time; string name = nameof({|#3:" + RawLength + "|}); }")); + test.FixedState.Sources.Add(("Other.cs", Imports + "class Other { Length value; } namespace Hidden { class Length {} class Shadowed { {|#5:" + RawLength + "|} value; } }")); + foreach (int location in new[] { 0, 1, 3, 4, 5 }) + { + test.ExpectedDiagnostics.Add(Suggestion(location, "Length")); + } + + test.ExpectedDiagnostics.Add(Suggestion(2, "Time")); + test.FixedState.ExpectedDiagnostics.AddRange(new[] { Suggestion(2, "Time"), Suggestion(3, "Length"), Suggestion(5, "Length") }); + await test.RunAsync(TestContext.Current.CancellationToken); + } + + [Theory] + [InlineData("", "")] + [InlineData("using First; using Second;", "namespace First { public class Length {} } namespace Second { public class Length {} }")] + [InlineData("using Length = Hidden.Container.Length;", "namespace Hidden { public class Container { private class Length {} } }")] + public async Task MissingAmbiguousOrInaccessibleReplacementWithholdsFix(string directives, string declarations) + { + CSharpCodeFixTest test = new() + { + TestCode = Imports + directives + " class Measurement { {|#0:" + RawLength + "|} field; } " + declarations, + CompilerDiagnostics = CompilerDiagnostics.None, + NumberOfIncrementalIterations = 0, + NumberOfFixAllIterations = 0 + }; + QuantityTestEnvironment.Configure(test); + test.ExpectedDiagnostics.Add(Suggestion(0, "Length")); + await test.RunAsync(TestContext.Current.CancellationToken); + } + + private static DiagnosticResult Suggestion(int location, string alias) => new DiagnosticResult("DQ0003", DiagnosticSeverity.Info).WithLocation(location).WithArguments(alias); +} diff --git a/src/DimensionalQuantities.Roslyn.Tests/Diagnostics/DimensionMismatchTests.cs b/src/DimensionalQuantities.Roslyn.Tests/Diagnostics/DimensionMismatchTests.cs new file mode 100644 index 0000000..9bdb050 --- /dev/null +++ b/src/DimensionalQuantities.Roslyn.Tests/Diagnostics/DimensionMismatchTests.cs @@ -0,0 +1,175 @@ +using DimensionalQuantities.Roslyn.Analyzers; +using DimensionalQuantities.Roslyn.Tests.Framework; +using Microsoft.CodeAnalysis; +using Microsoft.CodeAnalysis.Testing; +using Xunit; + +namespace DimensionalQuantities.Roslyn.Tests.Diagnostics; + +public sealed class DimensionMismatchTests +{ + [Theory] + [InlineData("+")] + [InlineData("-")] + [InlineData("<")] + [InlineData(">")] + [InlineData("<=")] + [InlineData(">=")] + [InlineData("==")] + [InlineData("!=")] + public async Task IncompatibleBinaryOperandsReportWholeExpression(string operation) + { + QuantityAnalyzerTest test = Invalid($"class Calculation {{ object Apply(Length distance, Time duration) => {{|#0:distance {operation} duration|}}; }}"); + test.ExpectedDiagnostics.Add(new DiagnosticResult("DQ0001", DiagnosticSeverity.Error).WithLocation(0).WithArguments(operation, "Length", "Time")); + await test.RunAsync(TestContext.Current.CancellationToken); + } + + [Theory] + [InlineData("+=")] + [InlineData("-=")] + public async Task IncompatibleCompoundAssignmentReportsWholeAssignment(string operation) + { + QuantityAnalyzerTest test = Invalid($"class Calculation {{ void Apply(Length distance, Time duration) {{ {{|#0:distance {operation} duration|}}; }} }}"); + test.ExpectedDiagnostics.Add(new DiagnosticResult("DQ0001", DiagnosticSeverity.Error).WithLocation(0).WithArguments(operation, "Length", "Time")); + await test.RunAsync(TestContext.Current.CancellationToken); + } + + [Theory] + [InlineData("Length value = {|#0:Time.FromSiBaseUnit(2)|};")] + [InlineData("Length Value { get; } = {|#0:Time.FromSiBaseUnit(2)|};")] + [InlineData("void Apply(Time duration) { Length value = {|#0:duration|}; }")] + [InlineData("void Apply(Length value, Time duration) { value = {|#0:duration|}; }")] + [InlineData("void Apply(Time duration) { Length first = default, second = {|#0:duration|}; }")] + public async Task DestinationMismatchReportsSourceExpression(string member) + { + QuantityAnalyzerTest test = Invalid("class Calculation { " + member + " }"); + test.ExpectedDiagnostics.Add(WrongDestination()); + await test.RunAsync(TestContext.Current.CancellationToken); + } + + [Theory] + [InlineData("Length Apply(Time duration) { return {|#0:duration|}; }")] + [InlineData("void Apply(Time duration) { Length Local() { return {|#0:duration|}; } }")] + [InlineData("Time duration; Length Value { get { return {|#0:duration|}; } }")] + [InlineData("Length Apply(Time duration) => {|#0:duration|};")] + [InlineData("Time duration; Length Value => {|#0:duration|};")] + [InlineData("Time duration; Length this[int index] => {|#0:duration|};")] + public async Task ReturnMismatchUsesDeclaredDestination(string member) + { + QuantityAnalyzerTest test = Invalid("class Calculation { " + member + " }"); + test.ExpectedDiagnostics.Add(WrongDestination()); + await test.RunAsync(TestContext.Current.CancellationToken); + } + + [Theory] + [InlineData("Accept({|#0:duration|});", "void Accept(Length value) {}")] + [InlineData("Accept(other: 1, value: {|#0:duration|});", "void Accept(Length value, int other) {}")] + [InlineData("System.Action accept = _ => {}; accept({|#0:duration|});", "")] + [InlineData("_ = new Parcel({|#0:duration|});", "class Parcel { public Parcel(Length value) {} }")] + [InlineData("Parcel parcel = new({|#0:duration|});", "class Parcel { public Parcel(Length value) {} }")] + public async Task RecoverableArgumentMappingReportsExpectedDimension(string statement, string declaration) + { + QuantityAnalyzerTest test = Invalid($"class Calculation {{ void Apply(Time duration) {{ {statement} }} {declaration} }}"); + test.ExpectedDiagnostics.Add(WrongDestination()); + await test.RunAsync(TestContext.Current.CancellationToken); + } + + [Theory] + [InlineData("Accept(duration);", "void Accept(Length value) {} void Accept(Mass value) {}")] + [InlineData("Accept(missing: duration);", "void Accept(Length value) {}")] + public async Task UnknownOrAmbiguousArgumentsDoNotGuessDestination(string call, string declarations) + { + await Invalid($"class Calculation {{ void Apply(Time duration) {{ {call} }} {declarations} }}").RunAsync(TestContext.Current.CancellationToken); + } + + [Fact] + public async Task NullableQuantitiesRetainTheirDimensions() + { + QuantityAnalyzerTest test = Invalid("class Calculation { Length? Apply(Time? duration) => {|#0:duration|}; }"); + test.ExpectedDiagnostics.Add(WrongDestination()); + await test.RunAsync(TestContext.Current.CancellationToken); + } + + [Theory] + [InlineData("var sum = a + b;")] + [InlineData("a += b;")] + [InlineData("var same = a <= b;")] + [InlineData("Length? lifted = a;")] + [InlineData("var product = a * t;")] + [InlineData("var ratio = a / t;")] + [InlineData("var native = 1 + 2;")] + [InlineData("object boxed = a;")] + public async Task SameDimensionAndNativeBindingRemainAccepted(string statement) + { + QuantityAnalyzerTest test = new() + { + TestCode = $"class Calculation {{ void Apply(Length a, Length b, Time t) {{ {statement} }} }}" + }; + await test.RunAsync(TestContext.Current.CancellationToken); + } + + [Fact] + public async Task SupportedUserOperatorKeepsItsOwnBinding() + { + QuantityAnalyzerTest test = new() + { + TestCode = "class Calculation { public static string operator +(Calculation value, Time duration) => \"supported\"; string Apply(Calculation value, Time duration) => value + duration; }" + }; + await test.RunAsync(TestContext.Current.CancellationToken); + } + + [Theory] + [InlineData("System.Collections.Generic.List