Figure out if member is disposed.

Fix #192.

Author: JohanLarsson

IDisposableAnalyzers.Test/Helpers/DisposableMemberTests.cs

@@ -27,6 +27,42 @@ public void Dispose()
             this.stream.Dispose();
         }
     }
+}");
+            var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
+            var semanticModel = compilation.GetSemanticModel(syntaxTree);
+            var field = syntaxTree.FindFieldDeclaration("stream");
+            var fieldSymbol = semanticModel.GetDeclaredSymbolSafe(field, CancellationToken.None);
+            Assert.AreEqual(Result.Yes, DisposableMember.IsDisposed(new FieldOrProperty(fieldSymbol), (TypeDeclarationSyntax)field.Parent, semanticModel, CancellationToken.None));
+        }
+
+        [Test]
+        public static void DiposedInOverridden()
+        {
+            var syntaxTree = CSharpSyntaxTree.ParseText(@"
+namespace N
+{
+    using System;
+    using System.IO;
+
+    abstract class BaseClass : IDisposable
+    {
+        public void Dispose()
+        {
+            this.M();
+        }
+
+        protected abstract void M();
+    }
+
+    class C : BaseClass
+    {
+        private readonly IDisposable stream = File.OpenRead(string.Empty);
+
+        protected override void M()
+        {
+            this.stream.Dispose();
+        }
+    }
 }");
             var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
             var semanticModel = compilation.GetSemanticModel(syntaxTree);

IDisposableAnalyzers.Test/IDISP002DisposeMemberTests/Valid.cs

@@ -1024,5 +1024,45 @@ public void Dispose()
 
             RoslynAssert.Valid(Analyzer, pairOfT, staticPairCode, code);
         }
+
+        [Test]
+        public static void WhenOverriddenIsNotVirtualDispose()
+        {
+            var baseClass = @"
+namespace N
+{
+    using System;
+    using System.IO;
+
+    abstract class BaseClass : IDisposable
+    {
+        public void Dispose()
+        {
+            this.M();
+        }
+
+        protected abstract void M();
+    }
+}";
+
+            var code = @"
+namespace N
+{
+    using System;
+    using System.IO;
+
+    class C : BaseClass
+    {
+        private readonly Stream stream = File.OpenRead(string.Empty);
+
+        protected override void M()
+        {
+            this.stream.Dispose();
+        }
+    }
+}";
+
+            RoslynAssert.Valid(Analyzer, baseClass, code);
+        }
     }
 }

IDisposableAnalyzers.Test/IDISP006ImplementIDisposableTests/ValidCode.Inheritance.cs

@@ -173,6 +173,46 @@ protected override void Dispose(bool disposing)
 
                 RoslynAssert.Valid(Analyzer, Descriptor, DisposableCode, baseClass, code);
             }
+
+            [Test]
+            public static void WhenOverriddenIsNotVirtualDispose()
+            {
+                var baseClass = @"
+namespace N
+{
+    using System;
+    using System.IO;
+
+    abstract class BaseClass : IDisposable
+    {
+        public void Dispose()
+        {
+            this.M();
+        }
+
+        protected abstract void M();
+    }
+}";
+
+                var code = @"
+namespace N
+{
+    using System;
+    using System.IO;
+
+    class C : BaseClass
+    {
+        private readonly Stream stream = File.OpenRead(string.Empty);
+
+        protected override void M()
+        {
+            this.stream.Dispose();
+        }
+    }
+}";
+
+                RoslynAssert.Valid(Analyzer, Descriptor, baseClass, code);
+            }
         }
     }
 }

IDisposableAnalyzers/Helpers/DisposableMember.cs

@@ -9,15 +9,15 @@ internal static class DisposableMember
     {
         internal static Result IsDisposed(FieldOrProperty member, TypeDeclarationSyntax context, SemanticModel semanticModel, CancellationToken cancellationToken)
         {
-            if (semanticModel.TryGetSymbol(context, cancellationToken, out var symbol))
+            if (semanticModel.TryGetNamedType(context, cancellationToken, out var symbol))
             {
                 return IsDisposed(member, symbol, semanticModel, cancellationToken);
             }
 
             return Result.Unknown;
         }
 
-        internal static Result IsDisposed(FieldOrProperty member, ITypeSymbol context, SemanticModel semanticModel, CancellationToken cancellationToken)
+        internal static Result IsDisposed(FieldOrProperty member, INamedTypeSymbol context, SemanticModel semanticModel, CancellationToken cancellationToken)
         {
             if (context == null)
             {

IDisposableAnalyzers/Helpers/Walkers/DisposeWalker.cs

@@ -37,12 +37,13 @@ public override void VisitIdentifierName(IdentifierNameSyntax node)
             base.VisitIdentifierName(node);
         }
 
-        internal static DisposeWalker Borrow(ITypeSymbol type, SemanticModel semanticModel, CancellationToken cancellationToken)
+        internal static DisposeWalker Borrow(INamedTypeSymbol type, SemanticModel semanticModel, CancellationToken cancellationToken)
         {
             if (type.IsAssignableTo(KnownSymbol.IDisposable, semanticModel.Compilation) &&
-                DisposeMethod.TryFindFirst(type, semanticModel.Compilation, Search.Recursive, out var disposeMethod))
+                DisposeMethod.TryFindFirst(type, semanticModel.Compilation, Search.Recursive, out var disposeMethod) &&
+                disposeMethod.TrySingleDeclaration(cancellationToken, out MethodDeclarationSyntax? declaration))
             {
-                return Borrow(disposeMethod, semanticModel, cancellationToken);
+                return BorrowAndVisit(declaration, SearchScope.Instance, type, semanticModel, () => new DisposeWalker(), cancellationToken);
             }
 
             return Borrow(() => new DisposeWalker());