Handle ref struct

fix #480

Author: JohanLarsson

IDisposableAnalyzers.Test/Helpers/DisposableTests.IsCreation.cs

@@ -755,6 +755,28 @@ public void Update()
             Assert.AreEqual(true, Disposable.IsCreation(value, semanticModel, CancellationToken.None));
         }
 
+        [TestCase("new S()")]
+        public static void RefStruct(string expression)
+        {
+            var syntaxTree = CSharpSyntaxTree.ParseText("""
+                namespace N;
+
+                public ref struct S
+                {
+                    public static S M() => new S();
+            
+                    public void Dispose()
+                    {
+                    }
+                }
+                """.AssertReplace("new S()", expression));
+
+            var compilation = CSharpCompilation.Create("test", new[] { syntaxTree });
+            var semanticModel = compilation.GetSemanticModel(syntaxTree);
+            var value = syntaxTree.FindExpression(expression);
+            Assert.AreEqual(true, Disposable.IsCreation(value, semanticModel, CancellationToken.None));
+        }
+
         [Ignore("Script")]
         [Test]
         public static void Dump()

IDisposableAnalyzers.Test/IDISP001DisposeCreatedTests/CodeFix.AddUsing.AddUsingDeclaration.cs

@@ -700,5 +700,45 @@ private static Kernel Create()
             RoslynAssert.CodeFix(Analyzer, Fix, ExpectedDiagnostic, new[] { disposable, before }, after, fixTitle: "using");
             RoslynAssert.FixAll(Analyzer, Fix, ExpectedDiagnostic, new[] { disposable, before }, after, fixTitle: "using");
         }
+
+        [TestCase("new S()")]
+        public static void LocalRefStructToUsingDeclaration(string expression)
+        {
+            var refStruct = """
+                namespace N;
+
+                public ref struct S
+                {
+                    public void Dispose()
+                    {
+                    }
+                }
+                """;
+            var before = """
+                namespace N;
+           
+                public sealed class C
+                {
+                    public void M()
+                    {
+                        ↓S s = new S();
+                    }
+                }
+                """.AssertReplace("new S()", expression);
+
+            var after = """
+                namespace N;
+            
+                public sealed class C
+                {
+                    public void M()
+                    {
+                        using S s = new S();
+                    }
+                }
+                """.AssertReplace("new S()", expression);
+
+            RoslynAssert.CodeFix(Analyzer, Fix, ExpectedDiagnostic, new[] { refStruct, before }, after, fixTitle: "using");
+        }
     }
 }

IDisposableAnalyzers/Helpers/Disposable.cs

@@ -9,19 +9,16 @@
 
 internal static partial class Disposable
 {
-    internal static bool IsPotentiallyAssignableFrom(ExpressionSyntax candidate, SemanticModel semanticModel, CancellationToken cancellationToken)
+    internal static bool IsPotentiallyAssignableFrom(ExpressionSyntax candidate, SemanticModel semanticModel, CancellationToken cancellationToken) => candidate switch
     {
-        return candidate switch
-        {
-            { IsMissing: true } => false,
-            LiteralExpressionSyntax _ => false,
-            ObjectCreationExpressionSyntax objectCreation
-                => semanticModel.TryGetType(objectCreation, cancellationToken, out var type) &&
-                   IsAssignableFrom(type, semanticModel.Compilation),
-            _ => semanticModel.TryGetType(candidate, cancellationToken, out var type) &&
-                 IsPotentiallyAssignableFrom(type, semanticModel.Compilation),
-        };
-    }
+        { IsMissing: true } => false,
+        LiteralExpressionSyntax _ => false,
+        ObjectCreationExpressionSyntax objectCreation
+            => semanticModel.TryGetType(objectCreation, cancellationToken, out var type) &&
+               IsAssignableFrom(type, semanticModel.Compilation),
+        _ => semanticModel.TryGetType(candidate, cancellationToken, out var type) &&
+             IsPotentiallyAssignableFrom(type, semanticModel.Compilation),
+    };
 
     internal static bool IsPotentiallyAssignableFrom(ITypeSymbol type, Compilation compilation)
     {
@@ -45,18 +42,16 @@ internal static bool IsPotentiallyAssignableFrom(ITypeSymbol type, Compilation c
         return true;
     }
 
-    internal static bool IsAssignableFrom(ITypeSymbol type, Compilation compilation)
+    internal static bool IsAssignableFrom(ITypeSymbol type, Compilation compilation) => type switch
     {
-        return type switch
-        {
-            null => false,
-            //// https://blogs.msdn.microsoft.com/pfxteam/2012/03/25/do-i-need-to-dispose-of-tasks/
-            { ContainingNamespace: { MetadataName: "Tasks", ContainingNamespace: { MetadataName: "Threading", ContainingNamespace.MetadataName: "System" } }, MetadataName: "Task" } => false,
-            INamedTypeSymbol { ContainingNamespace: { MetadataName: "Tasks", ContainingNamespace: { MetadataName: "Threading", ContainingNamespace.MetadataName: "System" } }, MetadataName: "Task`1", TypeArguments: { Length: 1 } arguments }
-                => IsAssignableFrom(arguments[0], compilation),
-            _ => type.IsAssignableTo(KnownSymbols.IDisposable, compilation),
-        };
-    }
+        null => false,
+        //// https://blogs.msdn.microsoft.com/pfxteam/2012/03/25/do-i-need-to-dispose-of-tasks/
+        { ContainingNamespace: { MetadataName: "Tasks", ContainingNamespace: { MetadataName: "Threading", ContainingNamespace.MetadataName: "System" } }, MetadataName: "Task" } => false,
+        INamedTypeSymbol { ContainingNamespace: { MetadataName: "Tasks", ContainingNamespace: { MetadataName: "Threading", ContainingNamespace.MetadataName: "System" } }, MetadataName: "Task`1", TypeArguments: { Length: 1 } arguments }
+            => IsAssignableFrom(arguments[0], compilation),
+        { IsRefLikeType: true } => DisposeMethod.IsAccessibleOn(type, compilation),
+        _ => type.IsAssignableTo(KnownSymbols.IDisposable, compilation),
+    };
 
     internal static bool IsNop(ExpressionSyntax candidate, SemanticModel semanticModel, CancellationToken cancellationToken)
     {

IDisposableAnalyzers/Helpers/DisposeMethod.cs

@@ -11,7 +11,8 @@ internal static class DisposeMethod
 {
     internal static IMethodSymbol? Find(ITypeSymbol type, Compilation compilation, Search search)
     {
-        if (!type.IsAssignableTo(KnownSymbols.IDisposable, compilation))
+        if (!type.IsAssignableTo(KnownSymbols.IDisposable, compilation) &&
+            !type.IsRefLikeType)
         {
             return null;
         }