Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Add fixer for converting to GeneratedDllImport #564

Merged
merged 2 commits into from
Jan 20, 2021
Merged

Add fixer for converting to GeneratedDllImport #564

Show file tree
Hide file tree
Changes from 1 commit
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
1dcaaac
Add fixer for converting to GeneratedDllImport
elinor-fung Jan 15, 2021
b6b1468
Add warning annotation
elinor-fung Jan 20, 2021
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
280 changes: 280 additions & 0 deletions DllImportGenerator/DllImportGenerator.UnitTests/ConvertToGeneratedDllImportFixerTests.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,280 @@
using System.Threading.Tasks;
using Xunit;
using static Microsoft.Interop.Analyzers.ConvertToGeneratedDllImportFixer;

using VerifyCS = DllImportGenerator.UnitTests.Verifiers.CSharpCodeFixVerifier<
Microsoft.Interop.Analyzers.ConvertToGeneratedDllImportAnalyzer,
Microsoft.Interop.Analyzers.ConvertToGeneratedDllImportFixer>;

namespace DllImportGenerator.UnitTests
{
public class ConvertToGeneratedDllImportFixerTests
{
[Theory]
[InlineData(true)]
[InlineData(false)]
public async Task Basic(bool usePreprocessorDefines)
{
string source = @$"
using System.Runtime.InteropServices;
partial class Test
{{
[DllImport(""DoesNotExist"")]
public static extern int [|Method|](out int ret);
}}";
// Fixed source will have CS8795 (Partial method must have an implementation) without generator run
string fixedSource = usePreprocessorDefines
? @$"
using System.Runtime.InteropServices;
partial class Test
{{
#if NET
[GeneratedDllImport(""DoesNotExist"")]
public static partial int {{|CS8795:Method|}}(out int ret);
#else
[DllImport(""DoesNotExist"")]
public static extern int Method(out int ret);
#endif
}}"
: @$"
using System.Runtime.InteropServices;
partial class Test
{{
[GeneratedDllImport(""DoesNotExist"")]
public static partial int {{|CS8795:Method|}}(out int ret);
}}";
await VerifyCS.VerifyCodeFixAsync(
source,
fixedSource,
usePreprocessorDefines ? WithPreprocessorDefinesKey : NoPreprocessorDefinesKey);
}

[Theory]
[InlineData(true)]
[InlineData(false)]
public async Task Comments(bool usePreprocessorDefines)
{
string source = @$"
using System.Runtime.InteropServices;
partial class Test
{{
// P/Invoke
[DllImport(/*name*/""DoesNotExist"")] // comment
public static extern int [|Method1|](out int ret);

/** P/Invoke **/
[DllImport(""DoesNotExist"") /*name*/]
// < ... >
public static extern int [|Method2|](out int ret);
}}";
// Fixed source will have CS8795 (Partial method must have an implementation) without generator run
string fixedSource = usePreprocessorDefines
? @$"
using System.Runtime.InteropServices;
partial class Test
{{
// P/Invoke
#if NET
[GeneratedDllImport(/*name*/""DoesNotExist"")] // comment
public static partial int {{|CS8795:Method1|}}(out int ret);
#else
[DllImport(/*name*/""DoesNotExist"")] // comment
public static extern int Method1(out int ret);
#endif

/** P/Invoke **/
#if NET
[GeneratedDllImport(""DoesNotExist"") /*name*/]
// < ... >
public static partial int {{|CS8795:Method2|}}(out int ret);
#else
[DllImport(""DoesNotExist"") /*name*/]
// < ... >
public static extern int Method2(out int ret);
#endif
}}"
: @$"
using System.Runtime.InteropServices;
partial class Test
{{
// P/Invoke
[GeneratedDllImport(/*name*/""DoesNotExist"")] // comment
public static partial int {{|CS8795:Method1|}}(out int ret);

/** P/Invoke **/
[GeneratedDllImport(""DoesNotExist"") /*name*/]
// < ... >
public static partial int {{|CS8795:Method2|}}(out int ret);
}}";
await VerifyCS.VerifyCodeFixAsync(
source,
fixedSource,
usePreprocessorDefines ? WithPreprocessorDefinesKey : NoPreprocessorDefinesKey);
}

[Theory]
[InlineData(true)]
[InlineData(false)]
public async Task MultipleAttributes(bool usePreprocessorDefines)
{
string source = @$"
using System.Runtime.InteropServices;
partial class Test
{{
[System.ComponentModel.Description(""Test""), DllImport(""DoesNotExist"")]
public static extern int [|Method1|](out int ret);

[System.ComponentModel.Description(""Test"")]
[DllImport(""DoesNotExist"")]
[return: MarshalAs(UnmanagedType.I4)]
public static extern int [|Method2|](out int ret);
}}";
// Fixed source will have CS8795 (Partial method must have an implementation) without generator run
string fixedSource = usePreprocessorDefines
? @$"
using System.Runtime.InteropServices;
partial class Test
{{
#if NET
[System.ComponentModel.Description(""Test""), GeneratedDllImport(""DoesNotExist"")]
public static partial int {{|CS8795:Method1|}}(out int ret);
#else
[System.ComponentModel.Description(""Test""), DllImport(""DoesNotExist"")]
public static extern int Method1(out int ret);
#endif

#if NET
[System.ComponentModel.Description(""Test"")]
[GeneratedDllImport(""DoesNotExist"")]
[return: MarshalAs(UnmanagedType.I4)]
public static partial int {{|CS8795:Method2|}}(out int ret);
#else
[System.ComponentModel.Description(""Test"")]
[DllImport(""DoesNotExist"")]
[return: MarshalAs(UnmanagedType.I4)]
public static extern int Method2(out int ret);
#endif
}}"
: @$"
using System.Runtime.InteropServices;
partial class Test
{{
[System.ComponentModel.Description(""Test""), GeneratedDllImport(""DoesNotExist"")]
public static partial int {{|CS8795:Method1|}}(out int ret);

[System.ComponentModel.Description(""Test"")]
[GeneratedDllImport(""DoesNotExist"")]
[return: MarshalAs(UnmanagedType.I4)]
public static partial int {{|CS8795:Method2|}}(out int ret);
}}";
await VerifyCS.VerifyCodeFixAsync(
source,
fixedSource,
usePreprocessorDefines ? WithPreprocessorDefinesKey : NoPreprocessorDefinesKey);
}

[Theory]
[InlineData(true)]
[InlineData(false)]
public async Task NamedArguments(bool usePreprocessorDefines)
{
string source = @$"
using System.Runtime.InteropServices;
partial class Test
{{
[DllImport(""DoesNotExist"", EntryPoint = ""Entry"")]
public static extern int [|Method1|](out int ret);

[DllImport(""DoesNotExist"", EntryPoint = ""Entry"", CharSet = CharSet.Unicode)]
public static extern int [|Method2|](out int ret);
}}";
// Fixed source will have CS8795 (Partial method must have an implementation) without generator run
string fixedSource = usePreprocessorDefines
? @$"
using System.Runtime.InteropServices;
partial class Test
{{
#if NET
[GeneratedDllImport(""DoesNotExist"", EntryPoint = ""Entry"")]
public static partial int {{|CS8795:Method1|}}(out int ret);
#else
[DllImport(""DoesNotExist"", EntryPoint = ""Entry"")]
public static extern int Method1(out int ret);
#endif

#if NET
[GeneratedDllImport(""DoesNotExist"", EntryPoint = ""Entry"", CharSet = CharSet.Unicode)]
public static partial int {{|CS8795:Method2|}}(out int ret);
#else
[DllImport(""DoesNotExist"", EntryPoint = ""Entry"", CharSet = CharSet.Unicode)]
public static extern int Method2(out int ret);
#endif
}}" : @$"
using System.Runtime.InteropServices;
partial class Test
{{
[GeneratedDllImport(""DoesNotExist"", EntryPoint = ""Entry"")]
public static partial int {{|CS8795:Method1|}}(out int ret);

[GeneratedDllImport(""DoesNotExist"", EntryPoint = ""Entry"", CharSet = CharSet.Unicode)]
public static partial int {{|CS8795:Method2|}}(out int ret);
}}";
await VerifyCS.VerifyCodeFixAsync(
source,
fixedSource,
usePreprocessorDefines ? WithPreprocessorDefinesKey : NoPreprocessorDefinesKey);
}

[Theory]
[InlineData(true)]
[InlineData(false)]
public async Task RemoveableNamedArguments(bool usePreprocessorDefines)
{
string source = @$"
using System.Runtime.InteropServices;
partial class Test
{{
[DllImport(""DoesNotExist"", BestFitMapping = false, EntryPoint = ""Entry"")]
public static extern int [|Method1|](out int ret);

[DllImport(""DoesNotExist"", ThrowOnUnmappableChar = false)]
public static extern int [|Method2|](out int ret);
}}";
// Fixed source will have CS8795 (Partial method must have an implementation) without generator run
string fixedSource = usePreprocessorDefines
? @$"
using System.Runtime.InteropServices;
partial class Test
{{
#if NET
[GeneratedDllImport(""DoesNotExist"", EntryPoint = ""Entry"")]
public static partial int {{|CS8795:Method1|}}(out int ret);
#else
[DllImport(""DoesNotExist"", BestFitMapping = false, EntryPoint = ""Entry"")]
public static extern int Method1(out int ret);
#endif

#if NET
[GeneratedDllImport(""DoesNotExist"")]
public static partial int {{|CS8795:Method2|}}(out int ret);
#else
[DllImport(""DoesNotExist"", ThrowOnUnmappableChar = false)]
public static extern int Method2(out int ret);
#endif
}}" : @$"
using System.Runtime.InteropServices;
partial class Test
{{
[GeneratedDllImport(""DoesNotExist"", EntryPoint = ""Entry"")]
public static partial int {{|CS8795:Method1|}}(out int ret);

[GeneratedDllImport(""DoesNotExist"")]
public static partial int {{|CS8795:Method2|}}(out int ret);
}}";
await VerifyCS.VerifyCodeFixAsync(
source,
fixedSource,
usePreprocessorDefines ? WithPreprocessorDefinesKey : NoPreprocessorDefinesKey);
}
}
}
1 change: 1 addition & 0 deletions DllImportGenerator/DllImportGenerator.UnitTests/DllImportGenerator.UnitTests.csproj
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -11,6 +11,7 @@
<PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="$(CompilerPlatformVersion)" PrivateAssets="all" />
<PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.0" PrivateAssets="all" />
<PackageReference Include="Microsoft.CodeAnalysis.CSharp.Analyzer.Testing.XUnit" Version="1.0.1-beta1.20478.1" PrivateAssets="all" />
<PackageReference Include="Microsoft.CodeAnalysis.CSharp.CodeFix.Testing.XUnit" Version="1.0.1-beta1.20478.1" PrivateAssets="all" />
<PackageReference Include="Microsoft.Net.Compilers.Toolset" Version="$(CompilerPlatformVersion)">
<PrivateAssets>all</PrivateAssets>
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
Expand Down
58 changes: 4 additions & 54 deletions DllImportGenerator/DllImportGenerator.UnitTests/Verifiers/CSharpAnalyzerVerifier.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,15 +1,10 @@

using System.Collections.Immutable;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Testing;
using Microsoft.CodeAnalysis.CSharp.Testing.XUnit;
using Microsoft.CodeAnalysis.Diagnostics;
using Microsoft.CodeAnalysis.Testing;
using Microsoft.CodeAnalysis.Testing.Verifiers;

namespace DllImportGenerator.UnitTests.Verifiers
{
Expand Down Expand Up @@ -40,54 +35,9 @@ public static async Task VerifyAnalyzerAsync(string source, params DiagnosticRes
await test.RunAsync(CancellationToken.None);
}

internal class Test : CSharpAnalyzerTest<TAnalyzer, XUnitVerifier>
{
public Test()
{
var (refAssem, ancillary) = TestUtils.GetReferenceAssemblies();
ReferenceAssemblies = refAssem;
SolutionTransforms.Add((solution, projectId) =>
{
var project = solution.GetProject(projectId)!;
var compilationOptions = project.CompilationOptions!;

var diagnosticOptions = compilationOptions.SpecificDiagnosticOptions.SetItems(CSharpVerifierHelper.NullableWarnings);

// Explicitly enable diagnostics that are not enabled by default
var enableAnalyzersOptions = new System.Collections.Generic.Dictionary<string, ReportDiagnostic>();
foreach (var analyzer in GetDiagnosticAnalyzers().ToImmutableArray())
{
foreach (var diagnostic in analyzer.SupportedDiagnostics)
{
if (diagnostic.IsEnabledByDefault)
continue;

// Map the default severity to the reporting behaviour.
// We cannot simply use ReportDiagnostic.Default here, as diagnostics that are not enabled by default
// are treated as suppressed (regardless of their default severity).
var report = diagnostic.DefaultSeverity switch
{
DiagnosticSeverity.Error => ReportDiagnostic.Error,
DiagnosticSeverity.Warning => ReportDiagnostic.Warn,
DiagnosticSeverity.Info => ReportDiagnostic.Info,
DiagnosticSeverity.Hidden => ReportDiagnostic.Hidden,
_ => ReportDiagnostic.Default
};
enableAnalyzersOptions.Add(diagnostic.Id, report);
}
}

compilationOptions = compilationOptions.WithSpecificDiagnosticOptions(
compilationOptions.SpecificDiagnosticOptions
.SetItems(CSharpVerifierHelper.NullableWarnings)
.AddRange(enableAnalyzersOptions));
solution = solution.WithProjectCompilationOptions(projectId, compilationOptions);
solution = solution.WithProjectMetadataReferences(projectId, project.MetadataReferences.Concat(ImmutableArray.Create(ancillary)));
solution = solution.WithProjectParseOptions(projectId, ((CSharpParseOptions)project.ParseOptions!).WithLanguageVersion(LanguageVersion.Preview));

return solution;
});
}
}
// Code fix tests support both analyzer and code fix testing. This test class is derived from the code fix test
// to avoid the need to maintain duplicate copies of the customization work.
internal class Test : CSharpCodeFixVerifier<TAnalyzer, EmptyCodeFixProvider>.Test
{ }
}
}
Loading