Added analyzer/fixer to convert from Resharper annotations to C# builtin syntax

Author: Bart Koelman

README.md

@@ -5,6 +5,8 @@
 
 This Visual Studio analyzer supports you in consequently annotating your codebase with Resharpers nullability attributes. Doing so improves the [nullability analysis engine in Resharper](https://www.jetbrains.com/resharper/help/Code_Analysis__Code_Annotations.html), so `NullReferenceException`s at runtime will become something from the past.
 
+**Update:** When used on a project that has C# nullable reference types enabled, this analyzer suppresses its original behavior and turns into a utility to convert existing Resharper nullability attributes to C# 8 syntax. See [documentation](doc/reference/CNUL_ResharperNullabilityAnnotationsCanBeConvertedToCSharpSyntax.md) for details.
+
 ## Get started
 
 * You need [Visual Studio](https://www.visualstudio.com/) 2015/2017/2019 and [Resharper](https://www.jetbrains.com/resharper/) v9 (or higher) to use this analyzer. See [here](https://github.com/bkoelman/ResharperCodeContractNullabilityFxCop/) if you use Visual Studio 2013 or lower.

doc/reference/CNUL_ResharperNullabilityAnnotationsCanBeConvertedToCSharpSyntax.md

@@ -0,0 +1,84 @@
+# CNUL: Resharper nullability annotation(s) can be converted to C# syntax
+
+## Cause
+A member or parameter contains Resharper nullability annotations, while the project is configured to enable C# nullable reference types.
+
+## Rule description
+Nullable reference types are a new language feature in C# v8. It supersedes the nullability annotations that were introduced by Resharper. This rule offers to convert existing code that uses the Resharper attribute to the new C# syntax.
+
+## How to fix violations
+Run the associated code fixer by selecting "Convert to C# syntax". It is recommended to run on entire document, project or solution (if memory allows).
+Remember to uninstall the ResharperCodeContractNullability package after all your code has been converted.
+
+## When to suppress warnings
+There is no technical reason to suppress this warning.
+
+## Example of a violation
+
+### Description
+The type `C` defines members and parameters that are decorated with Resharper annotations.
+
+### Code
+```csharp
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using JetBrains.Annotations;
+
+namespace N
+{
+    public class C
+    {
+        [CanBeNull]
+        [ItemNotNull]
+        private readonly List<string> _f = new List<string>();
+
+        [CanBeNull]
+        [ItemNotNull]
+        public ICollection<string> P => _f?.AsReadOnly();
+
+        [NotNull]
+        [ItemNotNull]
+        public Lazy<string> M([NotNull] [ItemNotNull] Task<string> p)
+        {
+            _f?.Add(p.Result);
+            return new Lazy<string>(() => p.Result);
+        }
+    }
+}
+```
+
+## Example of how to fix
+
+### Description
+All annotated members and parameters of the type `C` are now converted.
+
+### Code
+
+```csharp
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace N
+{
+    public class C
+    {
+        private readonly List<string>? _f = new List<string>();
+
+        public ICollection<string>? P => _f?.AsReadOnly();
+
+        public Lazy<string> M(Task<string> p)
+        {
+            _f?.Add(p.Result);
+            return new Lazy<string>(() => p.Result);
+        }
+    }
+}
+```
+
+## Related rules
+
+RNUL: [Member is missing nullability annotation](RNUL_MemberIsMissingNullabilityAnnotation.md)
+
+RINUL: [Member is missing item nullability annotation](RINUL_MemberIsMissingItemNullabilityAnnotation.md)

src/CodeContractNullability/CodeContractNullability.Test/CodeContractNullability.Test.csproj

@@ -1,6 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFrameworks>net46;net452</TargetFrameworks>
+    <TargetFrameworks>net472;net452</TargetFrameworks>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
     <DefineConstants>TRACE;DEBUG;JETBRAINS_ANNOTATIONS</DefineConstants>
@@ -33,8 +33,8 @@
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
   </ItemGroup>
-  <ItemGroup Condition="'$(TargetFramework)' == 'net46'">
-    <PackageReference Include="Microsoft.CodeAnalysis" Version="2.10.0" />
+  <ItemGroup Condition="'$(TargetFramework)' == 'net472'">
+    <PackageReference Include="Microsoft.CodeAnalysis" Version="3.0.0-beta4-final" />
   </ItemGroup>
   <ItemGroup Condition="'$(TargetFramework)' == 'net452'">
     <PackageReference Include="Microsoft.CodeAnalysis" Version="1.0.1" />

src/CodeContractNullability/CodeContractNullability.Test/ConversionNullabilityTest.cs

@@ -0,0 +1,95 @@
+using CodeContractNullability.NullabilityAttributes;
+using CodeContractNullability.Test.TestDataBuilders;
+using CodeContractNullability.Utilities;
+using JetBrains.Annotations;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.Diagnostics;
+using RoslynTestFramework;
+
+namespace CodeContractNullability.Test
+{
+    public abstract class ConversionNullabilityTest : AnalysisTestFixture
+    {
+        protected override string DiagnosticId => NullableReferenceTypeConversionAnalyzer.DiagnosticId;
+
+        protected override DiagnosticAnalyzer CreateAnalyzer()
+        {
+            var analyzer = new NullableReferenceTypeConversionAnalyzer();
+            analyzer.NullabilityAttributeProvider.Override(new SimpleNullabilityAttributeProvider());
+            return analyzer;
+        }
+
+        protected override CodeFixProvider CreateFixProvider()
+        {
+            return new NullableReferenceTypeConversionCodeFixProvider();
+        }
+
+        private protected void VerifyDiagnostics([NotNull] ParsedSourceCode source,
+            [NotNull] [ItemNotNull] params string[] messages)
+        {
+            Guard.NotNull(source, nameof(source));
+
+            AssertDiagnostics(source.TestContext, messages);
+        }
+
+        private protected void VerifyFix([NotNull] ParsedSourceCode source,
+            [NotNull] [ItemNotNull] params string[] messages)
+        {
+            Guard.NotNull(source, nameof(source));
+
+            string[] expectedCode =
+            {
+                source.ExpectedText
+            };
+            var fixContext = new FixProviderTestContext(source.TestContext, expectedCode,
+                source.CodeComparisonMode);
+
+            AssertDiagnosticsWithCodeFixes(fixContext, messages);
+        }
+
+        [NotNull]
+        protected static string CreateMessageForField([NotNull] string name)
+        {
+            return new ConversionDiagnosticMessageBuilder()
+                .OfType(SymbolType.Field)
+                .Named(name)
+                .Build();
+        }
+
+        [NotNull]
+        protected static string CreateMessageForProperty([NotNull] string name)
+        {
+            return new ConversionDiagnosticMessageBuilder()
+                .OfType(SymbolType.Property)
+                .Named(name)
+                .Build();
+        }
+
+        [NotNull]
+        protected static string CreateMessageForMethod([NotNull] string name)
+        {
+            return new ConversionDiagnosticMessageBuilder()
+                .OfType(SymbolType.Method)
+                .Named(name)
+                .Build();
+        }
+
+        [NotNull]
+        protected static string CreateMessageForDelegate([NotNull] string name)
+        {
+            return new ConversionDiagnosticMessageBuilder()
+                .OfType(SymbolType.Delegate)
+                .Named(name)
+                .Build();
+        }
+
+        [NotNull]
+        protected static string CreateMessageForParameter([NotNull] string name)
+        {
+            return new ConversionDiagnosticMessageBuilder()
+                .OfType(SymbolType.Parameter)
+                .Named(name)
+                .Build();
+        }
+    }
+}