Code fix for DisposeAsync when not null.

JohanLarsson · JohanLarsson · commit b14ffe89008a · 2020-02-05T08:47:44.000+01:00
No fix when possibly null for now, not sure what ideal code gen is.
diff --git a/IDisposableAnalyzers.NetCoreTests/IDISP002DisposeMemberTests/CodeFix.cs b/IDisposableAnalyzers.NetCoreTests/IDISP002DisposeMemberTests/CodeFix.cs
@@ -5,7 +5,6 @@
     using Microsoft.CodeAnalysis.Diagnostics;
     using NUnit.Framework;
 
-    [Ignore("Not sure how we want the code gen.")]
     public static class CodeFix
     {
         private static readonly DiagnosticAnalyzer Analyzer = new FieldAndPropertyDeclarationAnalyzer();
@@ -16,6 +15,7 @@ public static class CodeFix
         public static void FieldIAsyncDisposable()
         {
             var before = @"
+#nullable enable
 namespace N
 {
     using System;
@@ -32,7 +32,8 @@ public ValueTask DisposeAsync()
     }
 }";
 
-            var code = @"
+            var after = @"
+#nullable enable
 namespace N
 {
     using System;
@@ -49,13 +50,14 @@ public async ValueTask DisposeAsync()
         }
     }
 }";
-            RoslynAssert.CodeFix(Analyzer, Fix, ExpectedDiagnostic, before, code);
+            RoslynAssert.CodeFix(Analyzer, Fix, ExpectedDiagnostic, before, after);
         }
 
         [Test]
         public static void FieldOfTypeObjectIAsyncDisposable()
         {
             var before = @"
+#nullable enable
 namespace N
 {
     using System;
@@ -72,7 +74,8 @@ public ValueTask DisposeAsync()
     }
 }";
 
-            var code = @"
+            var after = @"
+#nullable enable
 namespace N
 {
     using System;
@@ -89,13 +92,14 @@ public async ValueTask DisposeAsync()
         }
     }
 }";
-            RoslynAssert.CodeFix(Analyzer, Fix, ExpectedDiagnostic, before, code);
+            RoslynAssert.CodeFix(Analyzer, Fix, ExpectedDiagnostic, before, after);
         }
 
         [Test]
         public static void FieldIAsyncDisposableAndIDisposable1()
         {
             var before = @"
+#nullable enable
 namespace N
 {
     using System;
@@ -117,7 +121,8 @@ public ValueTask DisposeAsync()
     }
 }";
 
-            var code = @"
+            var after = @"
+#nullable enable
 namespace N
 {
     using System;
@@ -126,7 +131,7 @@ namespace N
 
     sealed class C : IDisposable, IAsyncDisposable
     {
-        private readonly IAsyncDisposable disposable = File.OpenRead(string.Empty);
+        private readonly Stream disposable = File.OpenRead(string.Empty);
 
         public void Dispose()
         {
@@ -139,13 +144,14 @@ public async ValueTask DisposeAsync()
         }
     }
 }";
-            RoslynAssert.CodeFix(Analyzer, Fix, ExpectedDiagnostic, before, code);
+            RoslynAssert.CodeFix(Analyzer, Fix, ExpectedDiagnostic, before, after);
         }
 
         [Test]
         public static void FieldIAsyncDisposableAndIDisposable2()
         {
             var before = @"
+#nullable enable
 namespace N
 {
     using System;
@@ -167,7 +173,8 @@ public async ValueTask DisposeAsync()
     }
 }";
 
-            var code = @"
+            var after = @"
+#nullable enable
 namespace N
 {
     using System;
@@ -189,7 +196,32 @@ public async ValueTask DisposeAsync()
         }
     }
 }";
-            RoslynAssert.CodeFix(Analyzer, Fix, ExpectedDiagnostic, before, code);
+            RoslynAssert.CodeFix(Analyzer, Fix, ExpectedDiagnostic, before, after);
+        }
+
+        [Test]
+        public static void NullableFieldIAsyncDisposable()
+        {
+            var code = @"
+#nullable enable
+namespace N
+{
+    using System;
+    using System.IO;
+    using System.Threading.Tasks;
+
+    public class C : IAsyncDisposable
+    {
+        ↓private readonly IAsyncDisposable? disposable = File.OpenRead(string.Empty);
+
+        public ValueTask DisposeAsync()
+        {
+            return default(ValueTask);
+        }
+    }
+}";
+
+            RoslynAssert.NoFix(Analyzer, Fix, ExpectedDiagnostic, code);
         }
     }
 }
diff --git a/IDisposableAnalyzers/CodeFixes/DisposeMemberFix.cs b/IDisposableAnalyzers/CodeFixes/DisposeMemberFix.cs
@@ -39,30 +39,32 @@ protected override async Task RegisterCodeFixesAsync(DocumentEditorCodeFixContex
                     {
                         switch (method)
                         {
-                            case { Identifier: { ValueText: "DisposeAsync" } }:
-                                // Not sure how we want the code gen.
-                                ////context.RegisterCodeFix(
-                                ////    $"{symbol.Name}.DisposeAsync() in {method}",
-                                ////    (editor, cancellationToken) => editor.ReplaceNode(
-                                ////        method,
-                                ////        x => DisposeAsync(x, editor, cancellationToken)),
-                                ////    "DisposeAsync",
-                                ////    diagnostic);
-
-                                ////MethodDeclarationSyntax DisposeAsync(MethodDeclarationSyntax old, DocumentEditor editor, CancellationToken cancellationToken)
-                                ////{
-                                ////    return old switch
-                                ////    {
-                                ////        { ExpressionBody: { Expression: { } expression } }
-                                ////        => old.AsBlockBody(
-                                ////            SyntaxFactory.ExpressionStatement(expression),
-                                ////            IDisposableFactory.DisposeAsyncStatement(disposable, editor.SemanticModel, cancellationToken)),
-                                ////        { Body: { } body }
-                                ////        => old.WithBody(
-                                ////            body.AddStatements(IDisposableFactory.DisposeAsyncStatement(disposable, editor.SemanticModel, cancellationToken))),
-                                ////        _ => throw new InvalidOperationException("Error generating DisposeAsync"),
-                                ////    };
-                                ////}
+                            case { Identifier: { ValueText: "DisposeAsync" } }
+                                when IDisposableFactory.MemberAccessContext.Create(disposable, method, semanticModel, context.CancellationToken) is { NotNull: { } }:
+                                context.RegisterCodeFix(
+                                    $"{symbol.Name}.DisposeAsync() in {method}",
+                                    (editor, cancellationToken) => editor.ReplaceNode(
+                                        method,
+                                        x => DisposeAsync(x, editor, cancellationToken)),
+                                    "DisposeAsync",
+                                    diagnostic);
+
+                                MethodDeclarationSyntax DisposeAsync(MethodDeclarationSyntax old, DocumentEditor editor, CancellationToken cancellationToken)
+                                {
+                                    return old switch
+                                    {
+                                        { ExpressionBody: { Expression: { } expression } }
+                                        => old.AsBlockBody(
+                                            SyntaxFactory.ExpressionStatement(expression),
+                                            IDisposableFactory.DisposeAsyncStatement(disposable, method!, editor.SemanticModel, cancellationToken))
+                                              .WithAsync(),
+                                        { Body: { } body }
+                                        => old.WithBody(
+                                            body.AddStatements(IDisposableFactory.DisposeAsyncStatement(disposable, method!, editor.SemanticModel, cancellationToken)))
+                                              .WithAsync(),
+                                        _ => throw new InvalidOperationException("Error generating DisposeAsync"),
+                                    };
+                                }
 
                                 break;
                             case { Identifier: { ValueText: "Dispose" }, ParameterList: { Parameters: { Count: 1 } parameters }, Body: { } body }:
@@ -79,21 +81,21 @@ void DisposeInVirtual(DocumentEditor editor, CancellationToken cancellationToken
                                     {
                                         editor.InsertAfter(
                                             ifNotDisposingReturn,
-                                            IDisposableFactory.DisposeStatement(disposable, editor.SemanticModel, cancellationToken));
+                                            IDisposableFactory.DisposeStatement(disposable, method!, editor.SemanticModel, cancellationToken));
                                     }
                                     else if (TryFindIfDisposing(method!, out var ifDisposing))
                                     {
                                         _ = editor.ReplaceNode(
                                             ifDisposing.Statement,
                                             x => x is BlockSyntax ifBlock
-                                                ? ifBlock.AddStatements(IDisposableFactory.DisposeStatement(disposable, editor.SemanticModel, cancellationToken))
-                                                : SyntaxFactory.Block(x, IDisposableFactory.DisposeStatement(disposable, editor.SemanticModel, cancellationToken)));
+                                                ? ifBlock.AddStatements(IDisposableFactory.DisposeStatement(disposable, method!, editor.SemanticModel, cancellationToken))
+                                                : SyntaxFactory.Block(x, IDisposableFactory.DisposeStatement(disposable, method!, editor.SemanticModel, cancellationToken)));
                                     }
                                     else
                                     {
                                         ifDisposing = SyntaxFactory.IfStatement(
                                             SyntaxFactory.IdentifierName(parameters[0].Identifier),
-                                            SyntaxFactory.Block(IDisposableFactory.DisposeStatement(disposable, editor.SemanticModel, cancellationToken)));
+                                            SyntaxFactory.Block(IDisposableFactory.DisposeStatement(disposable, method!, editor.SemanticModel, cancellationToken)));
                                         if (DisposeMethod.TryFindBaseCall(method!, editor.SemanticModel, cancellationToken, out var baseCall))
                                         {
                                             editor.InsertBefore(baseCall.Parent, ifDisposing);
@@ -119,13 +121,13 @@ void DisposeWhenNoParameter(DocumentEditor editor, CancellationToken cancellatio
                                     {
                                         editor.InsertBefore(
                                             baseCall.Parent,
-                                            IDisposableFactory.DisposeStatement(disposable, editor.SemanticModel, cancellationToken));
+                                            IDisposableFactory.DisposeStatement(disposable, method!, editor.SemanticModel, cancellationToken));
                                     }
                                     else
                                     {
                                         _ = editor.ReplaceNode(
                                             body,
-                                            x => x.AddStatements(IDisposableFactory.DisposeStatement(disposable, editor.SemanticModel, cancellationToken)));
+                                            x => x.AddStatements(IDisposableFactory.DisposeStatement(disposable, method!, editor.SemanticModel, cancellationToken)));
                                     }
                                 }
 
@@ -138,11 +140,12 @@ void DisposeWhenNoParameter(DocumentEditor editor, CancellationToken cancellatio
                                         method,
                                         x => x.AsBlockBody(
                                             SyntaxFactory.ExpressionStatement(expression),
-                                            IDisposableFactory.DisposeStatement(disposable, editor.SemanticModel, cancellationToken))),
+                                            IDisposableFactory.DisposeStatement(disposable, method!, editor.SemanticModel, cancellationToken))),
                                     "Dispose member.",
                                     diagnostic);
                                 break;
                             case { Identifier: { ValueText: "Dispose" } }:
+                            case { Identifier: { ValueText: "DisposeAsync" } }:
                                 break;
                             default:
                                 context.RegisterCodeFix(
@@ -160,10 +163,10 @@ MethodDeclarationSyntax Dispose(MethodDeclarationSyntax old, DocumentEditor edit
                                         { ExpressionBody: { Expression: { } expression } }
                                         => old.AsBlockBody(
                                             SyntaxFactory.ExpressionStatement(expression),
-                                            IDisposableFactory.DisposeStatement(disposable, editor.SemanticModel, cancellationToken)),
+                                            IDisposableFactory.DisposeStatement(disposable, method!, editor.SemanticModel, cancellationToken)),
                                         { Body: { } body }
                                         => old.WithBody(body.AddStatements(
-                                                            IDisposableFactory.DisposeStatement(disposable, editor.SemanticModel, cancellationToken))),
+                                                            IDisposableFactory.DisposeStatement(disposable, method!, editor.SemanticModel, cancellationToken))),
                                         _ => throw new InvalidOperationException("Error generating Dispose"),
                                     };
                                 }
diff --git a/IDisposableAnalyzers/CodeFixes/Helpers/IDisposableFactory.cs b/IDisposableAnalyzers/CodeFixes/Helpers/IDisposableFactory.cs

Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,6 @@`
`5`	`5`	`using Microsoft.CodeAnalysis.Diagnostics;`
`6`	`6`	`using NUnit.Framework;`
`7`	`7`
`8`		`- [Ignore("Not sure how we want the code gen.")]`
`9`	`8`	`public static class CodeFix`
`10`	`9`	`{`
`11`	`10`	`private static readonly DiagnosticAnalyzer Analyzer = new FieldAndPropertyDeclarationAnalyzer();`
`@@ -16,6 +15,7 @@ public static class CodeFix`
`16`	`15`	`public static void FieldIAsyncDisposable()`
`17`	`16`	`{`
`18`	`17`	`var before = @"`
	`18`	`+#nullable enable`
`19`	`19`	`namespace N`
`20`	`20`	`{`
`21`	`21`	`using System;`
`@@ -32,7 +32,8 @@ public ValueTask DisposeAsync()`
`32`	`32`	`}`
`33`	`33`	`}";`
`34`	`34`
`35`		`- var code = @"`
	`35`	`+ var after = @"`
	`36`	`+#nullable enable`
`36`	`37`	`namespace N`
`37`	`38`	`{`
`38`	`39`	`using System;`
`@@ -49,13 +50,14 @@ public async ValueTask DisposeAsync()`
`49`	`50`	`}`
`50`	`51`	`}`
`51`	`52`	`}";`
`52`		`- RoslynAssert.CodeFix(Analyzer, Fix, ExpectedDiagnostic, before, code);`
	`53`	`+ RoslynAssert.CodeFix(Analyzer, Fix, ExpectedDiagnostic, before, after);`
`53`	`54`	`}`
`54`	`55`
`55`	`56`	`[Test]`
`56`	`57`	`public static void FieldOfTypeObjectIAsyncDisposable()`
`57`	`58`	`{`
`58`	`59`	`var before = @"`
	`60`	`+#nullable enable`
`59`	`61`	`namespace N`
`60`	`62`	`{`
`61`	`63`	`using System;`
`@@ -72,7 +74,8 @@ public ValueTask DisposeAsync()`
`72`	`74`	`}`
`73`	`75`	`}";`
`74`	`76`
`75`		`- var code = @"`
	`77`	`+ var after = @"`
	`78`	`+#nullable enable`
`76`	`79`	`namespace N`
`77`	`80`	`{`
`78`	`81`	`using System;`
`@@ -89,13 +92,14 @@ public async ValueTask DisposeAsync()`
`89`	`92`	`}`
`90`	`93`	`}`
`91`	`94`	`}";`
`92`		`- RoslynAssert.CodeFix(Analyzer, Fix, ExpectedDiagnostic, before, code);`
	`95`	`+ RoslynAssert.CodeFix(Analyzer, Fix, ExpectedDiagnostic, before, after);`
`93`	`96`	`}`
`94`	`97`
`95`	`98`	`[Test]`
`96`	`99`	`public static void FieldIAsyncDisposableAndIDisposable1()`
`97`	`100`	`{`
`98`	`101`	`var before = @"`
	`102`	`+#nullable enable`
`99`	`103`	`namespace N`
`100`	`104`	`{`
`101`	`105`	`using System;`
`@@ -117,7 +121,8 @@ public ValueTask DisposeAsync()`
`117`	`121`	`}`
`118`	`122`	`}";`
`119`	`123`
`120`		`- var code = @"`
	`124`	`+ var after = @"`
	`125`	`+#nullable enable`
`121`	`126`	`namespace N`
`122`	`127`	`{`
`123`	`128`	`using System;`
`@@ -126,7 +131,7 @@ namespace N`
`126`	`131`
`127`	`132`	`sealed class C : IDisposable, IAsyncDisposable`
`128`	`133`	`{`
`129`		`- private readonly IAsyncDisposable disposable = File.OpenRead(string.Empty);`
	`134`	`+ private readonly Stream disposable = File.OpenRead(string.Empty);`
`130`	`135`
`131`	`136`	`public void Dispose()`
`132`	`137`	`{`
`@@ -139,13 +144,14 @@ public async ValueTask DisposeAsync()`
`139`	`144`	`}`
`140`	`145`	`}`
`141`	`146`	`}";`
`142`		`- RoslynAssert.CodeFix(Analyzer, Fix, ExpectedDiagnostic, before, code);`
	`147`	`+ RoslynAssert.CodeFix(Analyzer, Fix, ExpectedDiagnostic, before, after);`
`143`	`148`	`}`
`144`	`149`
`145`	`150`	`[Test]`
`146`	`151`	`public static void FieldIAsyncDisposableAndIDisposable2()`
`147`	`152`	`{`
`148`	`153`	`var before = @"`
	`154`	`+#nullable enable`
`149`	`155`	`namespace N`
`150`	`156`	`{`
`151`	`157`	`using System;`
`@@ -167,7 +173,8 @@ public async ValueTask DisposeAsync()`
`167`	`173`	`}`
`168`	`174`	`}";`
`169`	`175`
`170`		`- var code = @"`
	`176`	`+ var after = @"`
	`177`	`+#nullable enable`
`171`	`178`	`namespace N`
`172`	`179`	`{`
`173`	`180`	`using System;`
`@@ -189,7 +196,32 @@ public async ValueTask DisposeAsync()`
`189`	`196`	`}`
`190`	`197`	`}`
`191`	`198`	`}";`
`192`		`- RoslynAssert.CodeFix(Analyzer, Fix, ExpectedDiagnostic, before, code);`
	`199`	`+ RoslynAssert.CodeFix(Analyzer, Fix, ExpectedDiagnostic, before, after);`
	`200`	`+ }`
	`201`	`+`
	`202`	`+ [Test]`
	`203`	`+ public static void NullableFieldIAsyncDisposable()`
	`204`	`+ {`
	`205`	`+ var code = @"`
	`206`	`+#nullable enable`
	`207`	`+namespace N`
	`208`	`+{`
	`209`	`+ using System;`
	`210`	`+ using System.IO;`
	`211`	`+ using System.Threading.Tasks;`
	`212`	`+`
	`213`	`+ public class C : IAsyncDisposable`
	`214`	`+ {`
	`215`	`+ ↓private readonly IAsyncDisposable? disposable = File.OpenRead(string.Empty);`
	`216`	`+`
	`217`	`+ public ValueTask DisposeAsync()`
	`218`	`+ {`
	`219`	`+ return default(ValueTask);`
	`220`	`+ }`
	`221`	`+ }`
	`222`	`+}";`
	`223`	`+`
	`224`	`+ RoslynAssert.NoFix(Analyzer, Fix, ExpectedDiagnostic, code);`
`193`	`225`	`}`
`194`	`226`	`}`
`195`	`227`	`}`