some small refactoring (#23)

.omnisharp/omnisharp.json

@@ -0,0 +1,9 @@
+{
+  "RoslynExtensionsOptions": {
+    "enableImportCompletion": true,
+    "enableAnalyzersSupport": true,
+    "locationPaths": [
+      "../src/ImmutableAnalyzer/ImmutableAnalyzer/bin/Release/netstandard2.0/publish/ImmutableAnalyzer.dll"
+    ]
+  }
+}

src/.vscode/launch.json

@@ -0,0 +1,26 @@
+{
+    "version": "0.2.0",
+    "configurations": [
+        {
+            // Use IntelliSense to find out which attributes exist for C# debugging
+            // Use hover for the description of the existing attributes
+            // For further information visit https://github.com/dotnet/vscode-csharp/blob/main/debugger-launchjson.md
+            "name": ".NET Core Launch (console)",
+            "type": "coreclr",
+            "request": "launch",
+            "preLaunchTask": "build",
+            // If you have changed target frameworks, make sure to update the program path.
+            "program": "${workspaceFolder}/ImmutableAnalyzer/ImmutableAnalyzer.Tests/bin/Debug/net6.0/ImmutableAnalyzer.Tests.dll",
+            "args": [],
+            "cwd": "${workspaceFolder}/ImmutableAnalyzer/ImmutableAnalyzer.Tests",
+            // For more information about the 'console' field, see https://aka.ms/VSCode-CS-LaunchJson-Console
+            "console": "internalConsole",
+            "stopAtEntry": false
+        },
+        {
+            "name": ".NET Core Attach",
+            "type": "coreclr",
+            "request": "attach"
+        }
+    ]
+}

src/.vscode/tasks.json

@@ -0,0 +1,41 @@
+{
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "build",
+            "command": "dotnet",
+            "type": "process",
+            "args": [
+                "build",
+                "${workspaceFolder}/ImmutableAnalyzer.sln",
+                "/property:GenerateFullPaths=true",
+                "/consoleloggerparameters:NoSummary;ForceNoAlign"
+            ],
+            "problemMatcher": "$msCompile"
+        },
+        {
+            "label": "publish",
+            "command": "dotnet",
+            "type": "process",
+            "args": [
+                "publish",
+                "${workspaceFolder}/ImmutableAnalyzer.sln",
+                "/property:GenerateFullPaths=true",
+                "/consoleloggerparameters:NoSummary;ForceNoAlign"
+            ],
+            "problemMatcher": "$msCompile"
+        },
+        {
+            "label": "watch",
+            "command": "dotnet",
+            "type": "process",
+            "args": [
+                "watch",
+                "run",
+                "--project",
+                "${workspaceFolder}/ImmutableAnalyzer.sln"
+            ],
+            "problemMatcher": "$msCompile"
+        }
+    ]
+}

src/ImmutableAnalyzer/ImmutableAnalyzer.Tests/Factories/SourceFactory.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Linq;
 
 namespace ImmutableAnalyzer.Tests.Factories;
@@ -114,4 +114,4 @@ private static (int Line, int Column) GetLineAndColumn(string source, string tex
 
         return (line + 1, column + 1);
     }
-}
+}

src/ImmutableAnalyzer/ImmutableAnalyzer.Tests/PropertyAnalyzersTests/SetAccessorTests/SetAccessorAnalyzerTests.cs

@@ -1,4 +1,4 @@
-using System.Threading.Tasks;
+using System.Threading.Tasks;
 using ImmutableAnalyzer.PropertyAnalyzers.SetAccessor;
 using ImmutableAnalyzer.Tests.Factories;
 using Xunit;
@@ -44,4 +44,4 @@ public async Task Immutable_class_property_could_have_no_setter()
         var source = SourceFactory.ImmutableClassWithGetOnlyPropertyAccessor();
         await Verifier.VerifyAnalyzerAsync(source);
     }
-}
+}

src/ImmutableAnalyzer/ImmutableAnalyzer.Tests/PropertyAnalyzersTests/SetAccessorTests/SetAccessorCodeFixTests.cs

@@ -5,15 +5,15 @@
 using Microsoft.CodeAnalysis.Testing;
 using Xunit;
 using FixStrategy = ImmutableAnalyzer.PropertyAnalyzers.SetAccessor.SetAccessorCodeFixProvider.FixStrategy;
-using Verifier = Microsoft.CodeAnalysis.CSharp.Testing.XUnit.CodeFixVerifier<
-    ImmutableAnalyzer.PropertyAnalyzers.SetAccessor.SetAccessorAnalyzer,
-    ImmutableAnalyzer.PropertyAnalyzers.SetAccessor.SetAccessorCodeFixProvider
->;
 using SetAccessorCodeFixTest = Microsoft.CodeAnalysis.CSharp.Testing.CSharpCodeFixTest<
     ImmutableAnalyzer.PropertyAnalyzers.SetAccessor.SetAccessorAnalyzer,
     ImmutableAnalyzer.PropertyAnalyzers.SetAccessor.SetAccessorCodeFixProvider,
     Microsoft.CodeAnalysis.Testing.Verifiers.XUnitVerifier
 >;
+using Verifier = Microsoft.CodeAnalysis.CSharp.Testing.XUnit.CodeFixVerifier<
+    ImmutableAnalyzer.PropertyAnalyzers.SetAccessor.SetAccessorAnalyzer,
+    ImmutableAnalyzer.PropertyAnalyzers.SetAccessor.SetAccessorCodeFixProvider
+>;
 
 namespace ImmutableAnalyzer.Tests.PropertyAnalyzersTests.SetAccessorTests;
 
@@ -60,10 +60,10 @@ private static SetAccessorCodeFixTest CreateTest(FixStrategy fixStrategy)
 
         var fixedSource = fixStrategy switch
         {
-            FixStrategy.Remove    => SourceFactory.ImmutableClassWithGetOnlyPropertyAccessor(),
-            FixStrategy.ToInit    => SourceFactory.ImmutableClassWithPropertyAccessor("init", out _, out _),
+            FixStrategy.Remove => SourceFactory.ImmutableClassWithGetOnlyPropertyAccessor(),
+            FixStrategy.ToInit => SourceFactory.ImmutableClassWithPropertyAccessor("init", out _, out _),
             FixStrategy.ToPrivate => SourceFactory.ImmutableClassWithPropertyAccessor("private set", out _, out _),
-            _                     => throw new ArgumentOutOfRangeException(nameof(fixStrategy), fixStrategy, null)
+            _ => throw new ArgumentOutOfRangeException(nameof(fixStrategy), fixStrategy, null)
         };
 
         return new SetAccessorCodeFixTest

src/ImmutableAnalyzer/ImmutableAnalyzer.Tests/RecordAnalyzersTests/ParameterTypeAnalyzerTests.cs

@@ -1,4 +1,4 @@
-using System.Threading.Tasks;
+using System.Threading.Tasks;
 using ImmutableAnalyzer.ParameterAnalyzers;
 using ImmutableAnalyzer.Tests.Factories;
 using Xunit;
@@ -31,4 +31,4 @@ public async Task Record_with_mutable_property_should_not_be_immutable(string pr
         var expected = Verifier.Diagnostic().WithLocation(line, column).WithArguments(property);
         await Verifier.VerifyAnalyzerAsync(source, expected);
     }
-}
+}

src/ImmutableAnalyzer/ImmutableAnalyzer.Tests/TestData.cs

@@ -2,7 +2,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using Xunit;
-using TypeCheckerConst = ImmutableAnalyzer.Utils.TypeChecking.Const.TypeCheckerConst;
+using Types = ImmutableAnalyzer.Utils.TypeChecking.Const.Types;
 
 namespace ImmutableAnalyzer.Tests;
 
@@ -13,26 +13,26 @@ public static class TestData
 {
     /// <summary>
     /// Represent immutable built-in types.
-    /// <seealso cref="TypeCheckerConst.ImmutableTypes"/>
+    /// <seealso cref="Types.ImmutableTypes"/>
     /// </summary>
     public class ImmutableTypes : TheoryData<string>
     {
         public ImmutableTypes()
         {
-            foreach (var typeName in TypeCheckerConst.ImmutableTypes)
+            foreach (var typeName in Types.ImmutableTypes)
                 Add(typeName);
         }
     }
 
     /// <summary>
     /// Represent immutable built-in generic types.
-    /// <seealso cref="TypeCheckerConst.ImmutableGenericTypes"/>
+    /// <seealso cref="Types.Generic"/>
     /// </summary>
     public class ImmutableGenericsTypes : TheoryData<string>
     {
         public ImmutableGenericsTypes()
         {
-            foreach (var typeName in TypeCheckerConst.ImmutableGenericTypes)
+            foreach (var typeName in Types.Generic)
                 Add(CreateGenericTypeStringWithParams(typeName, nameof(Int32)));
         }
 

src/ImmutableAnalyzer/ImmutableAnalyzer/AssemblyInfo.cs

@@ -1,3 +1,3 @@
-using System.Runtime.CompilerServices;
+using System.Runtime.CompilerServices;
 
-[assembly:InternalsVisibleTo("ImmutableAnalyzer.Tests")]
+[assembly: InternalsVisibleTo("ImmutableAnalyzer.Tests")]

src/ImmutableAnalyzer/ImmutableAnalyzer/Abstractions/MemberAnalyzer.cs → src/ImmutableAnalyzer/ImmutableAnalyzer/Common/MemberAnalyzer.cs

@@ -1,13 +1,14 @@
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 
-namespace ImmutableAnalyzer.Abstractions;
+namespace ImmutableAnalyzer.Common;
 
 /// <summary>
 /// Base class for member analyzers in immutable class.
 /// <typeparam name="TMemberSyntax">Type of class member to analyze.</typeparam>
 /// </summary>
-internal abstract class MemberAnalyzer<TMemberSyntax> : TypeDeclarationAnalyzer<TypeDeclarationSyntax>
+internal abstract class MemberAnalyzer<TMemberSyntax>
+    : TypeDeclarationAnalyzer<TypeDeclarationSyntax>
 {
     /// <summary>
     /// Execute analyzer.
@@ -18,8 +19,7 @@ internal abstract class MemberAnalyzer<TMemberSyntax> : TypeDeclarationAnalyzer<
 
     /// <summary>
     /// Execute analyzer.
-    /// Executes <see cref="AnalyzeMember"/> only if class declaration
-    /// marked by <see cref="ImmutableAttribute"/>.
+    /// Executes <see cref="AnalyzeMember"/> only if class declaration marked by <see cref="ImmutableAttribute"/>.
     /// </summary>
     /// <param name="typeDeclaration">Type declaration node.</param>
     /// <param name="ctx">Analysis context.</param>

src/ImmutableAnalyzer/ImmutableAnalyzer/Abstractions/ParameterAnalyzer.cs → src/ImmutableAnalyzer/ImmutableAnalyzer/Common/ParameterAnalyzer.cs

@@ -1,7 +1,7 @@
-using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 
-namespace ImmutableAnalyzer.Abstractions;
+namespace ImmutableAnalyzer.Common;
 
 /// <summary>
 /// Base class for parameter analyzer in immutable records.

src/ImmutableAnalyzer/ImmutableAnalyzer/Abstractions/TypeDeclarationAnalyzer.cs → src/ImmutableAnalyzer/ImmutableAnalyzer/Common/TypeDeclarationAnalyzer.cs

@@ -1,9 +1,9 @@
-using ImmutableAnalyzer.Extensions;
+using ImmutableAnalyzer.Extensions;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 
-namespace ImmutableAnalyzer.Abstractions;
+namespace ImmutableAnalyzer.Common;
 
 /// <summary>
 /// Base class for type declaration analyzer.
@@ -40,7 +40,9 @@ private void AnalyzeSyntax(SyntaxNodeAnalysisContext context)
         if (context.ContainingSymbol is { } symbol && !symbol.HasAttribute<ImmutableAttribute>())
             return;
 
-        if (context.Node is TDeclarationSyntax typeDeclarationSyntax)
-            AnalyzeTypeDeclaration(typeDeclarationSyntax, context);
+        if (context.Node is not TDeclarationSyntax typeDeclarationSyntax)
+            return;
+
+        AnalyzeTypeDeclaration(typeDeclarationSyntax, context);
     }
 }

src/ImmutableAnalyzer/ImmutableAnalyzer/Extensions/SymbolExtensions.cs

@@ -10,15 +10,15 @@ namespace ImmutableAnalyzer.Extensions;
 internal static class SymbolExtensions
 {
     /// <summary>
-    /// Checks if <see cref="symbol"/> marked by given attribute.
+    /// Checks if <paramref name="symbol"/> marked by given attribute.
     /// </summary>
     /// <param name="symbol">Symbol, exposed by compiler.</param>
-    /// <returns>true - if symbol marked by given attribute, otherwise - false.</returns>
+    /// <returns>true - if <paramref name="symbol"/> marked by given attribute, otherwise - false.</returns>
     public static bool HasAttribute<T>(this ISymbol symbol) =>
         symbol.GetAttributes().Any(data => data.AttributeClass?.Name == typeof(T).Name);
 
     /// <summary>
-    /// Returns symbol from type and context.
+    /// Returns symbol from type.
     /// </summary>
     /// <param name="type">Type syntax expression.</param>
     /// <param name="semanticModel">Semantic model.</param>
@@ -30,8 +30,8 @@ public static ITypeSymbol GetTypeSymbolFromSyntaxNode(this SemanticModel semanti
         return symbol switch
         {
             IArrayTypeSymbol arrayTypeSymbol => arrayTypeSymbol.ElementType, // detect arrays e.g. int[] -> int
-            not null                         => symbol,                      // just return type symbol
-            _                                => throw new NotSupportedException("Not supported symbol")
+            not null => symbol,                                              // just return type symbol
+            _ => throw new NotSupportedException("Not supported symbol")
         };
     }
 }

src/ImmutableAnalyzer/ImmutableAnalyzer/ImmutableAttribute.cs

@@ -1,9 +1,9 @@
-using System;
+using System;
 
 namespace ImmutableAnalyzer;
 
 /// <summary>
 /// Attribute, that represent immutable class.
 /// </summary>
 [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Interface)]
-public class ImmutableAttribute : Attribute { }
+public class ImmutableAttribute : Attribute { }

src/ImmutableAnalyzer/ImmutableAnalyzer/ParameterAnalyzers/ParameterTypeAnalyzer.cs

@@ -1,5 +1,5 @@
 using System.Collections.Immutable;
-using ImmutableAnalyzer.Abstractions;
+using ImmutableAnalyzer.Common;
 using ImmutableAnalyzer.Extensions;
 using ImmutableAnalyzer.Utils.TypeChecking;
 using Microsoft.CodeAnalysis;
@@ -20,20 +20,22 @@ internal class ParameterTypeAnalyzer : ParameterAnalyzer
     private static readonly TypeChecker Checker = TypeCheckerFactory.GetOrCreate();
 
     /// <inheritdoc />
-    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = ImmutableArray.Create(Rule);
+    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } =
+        ImmutableArray.Create(Rule);
 
     /// <summary>
     /// Diagnostic descriptor.
     /// </summary>
-    private static readonly DiagnosticDescriptor Rule = new DiagnosticDescriptor(
-        id:                 "IM0003",
-        title:              "Mutable parameter in record parameter list",
-        messageFormat:      "Immutable record can't have parameter of type '{0}'",
-        category:           "Design",
-        defaultSeverity:    DiagnosticSeverity.Error,
-        isEnabledByDefault: true,
-        description:        "Record parameter must have immutable type."
-    );
+    private static readonly DiagnosticDescriptor Rule =
+        new(
+            id: "IM0003",
+            title: "Mutable parameter in record parameter list",
+            messageFormat: "Immutable record can't have parameter of type '{0}'",
+            category: "Design",
+            defaultSeverity: DiagnosticSeverity.Error,
+            isEnabledByDefault: true,
+            description: "Record parameter must have immutable type."
+        );
 
     /// <inheritdoc />
     protected override void AnalyzeParameter(ParameterSyntax node, SyntaxNodeAnalysisContext ctx)
@@ -42,7 +44,8 @@ protected override void AnalyzeParameter(ParameterSyntax node, SyntaxNodeAnalysi
             return;
 
         var diagnostic = Diagnostic.Create(
-            Rule, node.Type!.GetLocation(),
+            Rule,
+            node.Type!.GetLocation(),
             node.Type.ToFullString().Trim()
         );
 

src/ImmutableAnalyzer/ImmutableAnalyzer/PropertyAnalyzers/PropertyAnalyzer.cs

@@ -1,9 +1,9 @@
-using ImmutableAnalyzer.Abstractions;
+using ImmutableAnalyzer.Common;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 
 namespace ImmutableAnalyzer.PropertyAnalyzers;
 
 /// <summary>
 /// Base class for property analyzer in immutable type.
 /// </summary>
-internal abstract class PropertyAnalyzer : MemberAnalyzer<PropertyDeclarationSyntax> { }
+internal abstract class PropertyAnalyzer : MemberAnalyzer<PropertyDeclarationSyntax> { }

src/ImmutableAnalyzer/ImmutableAnalyzer/PropertyAnalyzers/PropertyType/PropertyTypeAnalyzer.cs

@@ -1,4 +1,4 @@
-using System.Collections.Immutable;
+using System.Collections.Immutable;
 using ImmutableAnalyzer.Extensions;
 using ImmutableAnalyzer.Utils.TypeChecking;
 using Microsoft.CodeAnalysis;
@@ -24,14 +24,14 @@ internal sealed class PropertyTypeAnalyzer : PropertyAnalyzer
     /// <summary>
     /// Diagnostic descriptor.
     /// </summary>
-    private static readonly DiagnosticDescriptor Rule = new DiagnosticDescriptor(
-        id:                 "IM0001",
-        title:              "Mutable property in immutable type",
-        messageFormat:      "Immutable type can't have property of type '{0}'",
-        category:           "Design",
-        defaultSeverity:    DiagnosticSeverity.Error,
+    private static readonly DiagnosticDescriptor Rule = new(
+        id: "IM0001",
+        title: "Mutable property in immutable type",
+        messageFormat: "Immutable type can't have property of type '{0}'",
+        category: "Design",
+        defaultSeverity: DiagnosticSeverity.Error,
         isEnabledByDefault: true,
-        description:        "Class member must have immutable type."
+        description: "Class member must have immutable type."
     );
 
     /// <inheritdoc/>