More tests.

Author: JohanLarsson

IDisposableAnalyzers.Test/Helpers/DisposableWalkerTests.DisposedByReturnValue.cs

@@ -1,7 +1,6 @@
 namespace IDisposableAnalyzers.Test.Helpers
 {
     using System.Threading;
-    using Gu.Roslyn.AnalyzerExtensions;
     using Gu.Roslyn.Asserts;
     using Microsoft.CodeAnalysis.CSharp;
     using NUnit.Framework;

IDisposableAnalyzers.Test/Helpers/DisposableWalkerTests.Disposes.cs

@@ -87,7 +87,7 @@ internal C(string fileName)
                 var syntaxTree = CSharpSyntaxTree.ParseText(code);
                 var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
                 var semanticModel = compilation.GetSemanticModel(syntaxTree);
-                var value = syntaxTree.FindVariableDeclaration("disposable = File.OpenRead(fileName)");
+                var value = syntaxTree.FindVariableDeclaration("disposable");
                 Assert.AreEqual(true, semanticModel.TryGetSymbol(value, CancellationToken.None, out ILocalSymbol symbol));
                 Assert.AreEqual(true, DisposableWalker.Disposes(symbol, semanticModel, CancellationToken.None));
             }

IDisposableAnalyzers.Test/Helpers/DisposableWalkerTests.Ignores.cs

@@ -652,6 +652,33 @@ internal object M(string fileName)
                 var value = syntaxTree.FindExpression("File.OpenRead(fileName)");
                 Assert.AreEqual(false, DisposableWalker.Ignores(value, semanticModel, CancellationToken.None));
             }
+
+            [TestCase("File.OpenRead(fileName)")]
+            [TestCase("Task.FromResult(File.OpenRead(fileName)).Result")]
+            [TestCase("Task.FromResult(File.OpenRead(fileName)).GetAwaiter().GetResult()")]
+            public static void WhenUsingDeclaration(string expression)
+            {
+                var code = @"
+namespace N
+{
+    using System;
+    using System.IO;
+    using System.Threading.Tasks;
+
+    class C
+    {
+        C(string fileName)
+        {
+            using var disposable = File.OpenRead(fileName);
+        }
+    }
+}".AssertReplace("File.OpenRead(fileName)", expression);
+                var syntaxTree = CSharpSyntaxTree.ParseText(code);
+                var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
+                var semanticModel = compilation.GetSemanticModel(syntaxTree);
+                var value = syntaxTree.FindExpression("File.OpenRead(fileName)");
+                Assert.AreEqual(false, DisposableWalker.Ignores(value, semanticModel, CancellationToken.None));
+            }
         }
     }
 }

IDisposableAnalyzers.Test/IDISP004DoNotIgnoreCreatedTests/Valid.Using.cs

@@ -79,6 +79,7 @@ public async Task M()
 
         [TestCase("await Task.FromResult(new Disposable())")]
         [TestCase("await Task.FromResult(new Disposable()).ConfigureAwait(false)")]
+        [TestCase("Task.FromResult(new Disposable()).GetAwaiter().GetResult()")]
         [TestCase("await Task.Run(() => new Disposable())")]
         [TestCase("await Task.Run(() => new Disposable()).ConfigureAwait(false)")]
         [TestCase("Task.Run(() => new Disposable()).Result")]

IDisposableAnalyzers/Analyzers/CreationAnalyzer.cs

@@ -11,12 +11,10 @@
     [DiagnosticAnalyzer(LanguageNames.CSharp)]
     internal class CreationAnalyzer : DiagnosticAnalyzer
     {
-        /// <inheritdoc/>
         public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = ImmutableArray.Create(
             Descriptors.IDISP004DoNotIgnoreCreated,
             Descriptors.IDISP014UseSingleInstanceOfHttpClient);
 
-        /// <inheritdoc/>
         public override void Initialize(AnalysisContext context)
         {
             context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);

IDisposableAnalyzers/Helpers/Walkers/DisposableWalker.DisposedByReturnValue.cs

@@ -119,7 +119,7 @@ leaveOpenArgument.Expression is LiteralExpressionSyntax literal &&
                     }
 
                     break;
-                case { Symbol: { ContainingSymbol: IMethodSymbol method } parameter, Source: { Parent: ArgumentListSyntax { Parent: InvocationExpressionSyntax invocation } } }:
+                case { Symbol: { ContainingSymbol: IMethodSymbol method } , Source: { Parent: ArgumentListSyntax { Parent: InvocationExpressionSyntax invocation } } }:
                     if (method == KnownSymbol.Task.FromResult)
                     {
                         creation = invocation;