Create an analyser package that looks for collection initialiser usage with immutable language-ext types (the results of the "Add" methods are discarded, which is bad)

LanguageExt.Core/LanguageExt.Core.csproj

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup Label="Configuration" Condition="'$(Configuration)'=='Debug'">
     <DefineConstants>TRACE;DEBUG</DefineConstants>
   </PropertyGroup>
@@ -16,7 +16,7 @@
     <DefineConstants>NETSTANDARD21</DefineConstants>
   </PropertyGroup>
   <PropertyGroup>
-    <PackageVersion>3.5.26-beta</PackageVersion>
+    <PackageVersion>3.5.30-dan</PackageVersion>
     <PackageId>LanguageExt.Core</PackageId>
     <Title>LanguageExt.Core</Title>
     <Authors>Paul Louth</Authors>
@@ -43,7 +43,6 @@
     </None>
   </ItemGroup>
 
-
   <ItemGroup>
     <Compile Include="**\*.cs" />
     <EmbeddedResource Include="**\*.resx" />
@@ -54,6 +53,7 @@
     <None Remove="obj\**" />
   </ItemGroup>
   <ItemGroup>
+    <PackageReference Include="LanguageExtAnalysers" Version="1.0.1" />
     <PackageReference Include="System.Reflection.Emit" Version="[4.3.0,)" />
     <PackageReference Include="System.Threading.Tasks.Extensions" Version="4.5.2" />
     <PackageReference Include="System.ValueTuple" Version="[4.5.0,)" />

LanguageExtAnalysers.Package/LanguageExtAnalysers.Package.csproj

@@ -0,0 +1,48 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netstandard2.0</TargetFramework>
+    <IncludeBuildOutput>false</IncludeBuildOutput>
+    <SuppressDependenciesWhenPacking>true</SuppressDependenciesWhenPacking>
+    <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <PackageId>LanguageExtAnalysers</PackageId>
+    <PackageVersion>1.0.1.0</PackageVersion>
+    <Authors>Paul Louth</Authors>
+    <Copyright>Copyright (c) Paul Louth. All rights reserved.</Copyright>
+    <Summary>Analysers for language-ext</Summary>
+    <Description>Analysers to identify common mistakes made when using the language-ext library</Description>
+    <PackageTags>C#, Functional, Language Extension, Monad, Option, Either, Reader, Writer, State, List, Set, Map, Queue, Memo, Memoization, Immutable, Lambda, Pattern Matching, Tuple</PackageTags>
+    <PackageIcon>lang-ext-small.png</PackageIcon>
+    <PackageProjectUrl>https://github.com/louthy/language-ext</PackageProjectUrl>
+    <PackageLicenseExpression>MIT</PackageLicenseExpression>
+    <PackageRequireLicenseAcceptance>false</PackageRequireLicenseAcceptance>
+    <NoPackageAnalysis>true</NoPackageAnalysis>
+
+    <TargetsForTfmSpecificContentInPackage>$(TargetsForTfmSpecificContentInPackage);_AddAnalyzersToOutput</TargetsForTfmSpecificContentInPackage>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\LanguageExtAnalysers\LanguageExtAnalysers.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Include="..\Images\lang-ext-small.png">
+      <Pack>True</Pack>
+      <PackagePath></PackagePath>
+    </None>
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Update="tools\*.ps1" CopyToOutputDirectory="Always" Pack="true" PackagePath="" />
+  </ItemGroup>
+
+  <Target Name="_AddAnalyzersToOutput">
+    <ItemGroup>
+      <TfmSpecificPackageFile Include="$(OutputPath)\LanguageExtAnalysers.dll" PackagePath="analyzers/dotnet/cs" />
+     </ItemGroup>
+  </Target>
+
+</Project>

LanguageExtAnalysers.Package/tools/install.ps1

@@ -0,0 +1,58 @@
+param($installPath, $toolsPath, $package, $project)
+
+if($project.Object.SupportsPackageDependencyResolution)
+{
+    if($project.Object.SupportsPackageDependencyResolution())
+    {
+        # Do not install analyzers via install.ps1, instead let the project system handle it.
+        return
+    }
+}
+
+$analyzersPaths = Join-Path (Join-Path (Split-Path -Path $toolsPath -Parent) "analyzers") * -Resolve
+
+foreach($analyzersPath in $analyzersPaths)
+{
+    if (Test-Path $analyzersPath)
+    {
+        # Install the language agnostic analyzers.
+        foreach ($analyzerFilePath in Get-ChildItem -Path "$analyzersPath\*.dll" -Exclude *.resources.dll)
+        {
+            if($project.Object.AnalyzerReferences)
+            {
+                $project.Object.AnalyzerReferences.Add($analyzerFilePath.FullName)
+            }
+        }
+    }
+}
+
+# $project.Type gives the language name like (C# or VB.NET)
+$languageFolder = ""
+if($project.Type -eq "C#")
+{
+    $languageFolder = "cs"
+}
+if($project.Type -eq "VB.NET")
+{
+    $languageFolder = "vb"
+}
+if($languageFolder -eq "")
+{
+    return
+}
+
+foreach($analyzersPath in $analyzersPaths)
+{
+    # Install language specific analyzers.
+    $languageAnalyzersPath = join-path $analyzersPath $languageFolder
+    if (Test-Path $languageAnalyzersPath)
+    {
+        foreach ($analyzerFilePath in Get-ChildItem -Path "$languageAnalyzersPath\*.dll" -Exclude *.resources.dll)
+        {
+            if($project.Object.AnalyzerReferences)
+            {
+                $project.Object.AnalyzerReferences.Add($analyzerFilePath.FullName)
+            }
+        }
+    }
+}

LanguageExtAnalysers.Package/tools/uninstall.ps1

@@ -0,0 +1,65 @@
+param($installPath, $toolsPath, $package, $project)
+
+if($project.Object.SupportsPackageDependencyResolution)
+{
+    if($project.Object.SupportsPackageDependencyResolution())
+    {
+        # Do not uninstall analyzers via uninstall.ps1, instead let the project system handle it.
+        return
+    }
+}
+
+$analyzersPaths = Join-Path (Join-Path (Split-Path -Path $toolsPath -Parent) "analyzers") * -Resolve
+
+foreach($analyzersPath in $analyzersPaths)
+{
+    # Uninstall the language agnostic analyzers.
+    if (Test-Path $analyzersPath)
+    {
+        foreach ($analyzerFilePath in Get-ChildItem -Path "$analyzersPath\*.dll" -Exclude *.resources.dll)
+        {
+            if($project.Object.AnalyzerReferences)
+            {
+                $project.Object.AnalyzerReferences.Remove($analyzerFilePath.FullName)
+            }
+        }
+    }
+}
+
+# $project.Type gives the language name like (C# or VB.NET)
+$languageFolder = ""
+if($project.Type -eq "C#")
+{
+    $languageFolder = "cs"
+}
+if($project.Type -eq "VB.NET")
+{
+    $languageFolder = "vb"
+}
+if($languageFolder -eq "")
+{
+    return
+}
+
+foreach($analyzersPath in $analyzersPaths)
+{
+    # Uninstall language specific analyzers.
+    $languageAnalyzersPath = join-path $analyzersPath $languageFolder
+    if (Test-Path $languageAnalyzersPath)
+    {
+        foreach ($analyzerFilePath in Get-ChildItem -Path "$languageAnalyzersPath\*.dll" -Exclude *.resources.dll)
+        {
+            if($project.Object.AnalyzerReferences)
+            {
+                try
+                {
+                    $project.Object.AnalyzerReferences.Remove($analyzerFilePath.FullName)
+                }
+                catch
+                {
+
+                }
+            }
+        }
+    }
+}

LanguageExtAnalysers.Tests/CollectionInitialisationAnalyserUnitTests.cs

@@ -0,0 +1,126 @@
+using System.Threading.Tasks;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using VerifyCS = LanguageExtAnalysers.Tests.CSharpAnalyzerVerifier<LanguageExtAnalysers.CollectionInitialisationAnalyser>;
+
+namespace LanguageExtAnalysers.Tests
+{
+    [TestClass]
+    public class CollectionInitialisationAnalyserUnitTest
+    {
+        [TestMethod]
+        public async Task EmptyCode() => await VerifyCS.VerifyAnalyzerAsync("");
+
+        [TestMethod]
+        public async Task FailForCollectionInitialiserWithLstFromLanguageExt()
+        {
+            var test = @"
+                using System.Collections.Generic;
+                using LanguageExt;
+
+                namespace ConsoleApplication1
+                {
+                    class Test
+                    {
+                        public void Test1()
+                        {
+                            var immutableList = new Lst<int> { 4, 5, 6 };
+                        }
+                    }
+                }
+            ";
+
+            var expected = VerifyCS.Diagnostic(CollectionInitialisationAnalyser.DiagnosticId)
+                .WithLocation(line: 11, column: 62)
+                .WithMessage(CollectionInitialisationAnalyser.MessageFormat);
+
+            await VerifyCS.VerifyAnalyzerAsync(test, expected);
+        }
+
+        /// <summary>
+        /// If there are no items in the initialiser then it doesn't actually do any harm
+        /// </summary>
+        [TestMethod]
+        public async Task AllowEmptyCollectionInitialiserWithLstFromLanguageExt()
+        {
+            var test = @"
+                using System.Collections.Generic;
+                using LanguageExt;
+
+                namespace ConsoleApplication1
+                {
+                    class Test
+                    {
+                        public void Test1()
+                        {
+                            var immutableList = new Lst<int> { };
+                        }
+                    }
+                }
+            ";
+
+            await VerifyCS.VerifyAnalyzerAsync(test);
+        }
+
+        [TestMethod]
+        public async Task AllowCollectionInitialiserWithListFromBCL()
+        {
+            var test = @"
+                using System.Collections.Generic;
+
+                namespace ConsoleApplication1
+                {
+                    class Test
+                    {
+                        public void Test1()
+                        {
+                            var list1 = new List<int> { 1, 2, 3 };
+                        }
+                    }
+                }
+            ";
+
+            await VerifyCS.VerifyAnalyzerAsync(test);
+        }
+
+        [TestMethod]
+        public async Task AllowCustomImmutableTypeWithCollectionInitialiser()
+        {
+            var test = @"
+                using System;
+                using System.Collections;
+                using System.Collections.Generic;
+                using System.Linq;
+
+                namespace ConsoleApplication1
+                {
+                    class Test
+                    {
+                        public void Test1()
+                        {
+                            var list1 = new MyImmutableList<int> { 1, 2, 3 };
+                        }
+                    }
+
+                    public class MyImmutableList<T> : IEnumerable<T>
+                    {
+                        private readonly T[] _items;
+                        private MyImmutableList(T[] items) => _items = items;
+                        public MyImmutableList() : this(Array.Empty<T>()) { }
+
+                        public MyImmutableList<T> Add(T item) => new MyImmutableList<T>(_items.Append(item).ToArray());
+
+                        public IEnumerator<T> GetEnumerator()
+                        {
+                            foreach (var item in _items)
+                                yield return item;
+                        }
+
+                        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+                    }
+                }
+            ";
+
+            await VerifyCS.VerifyAnalyzerAsync(test);
+        }
+    }
+}

LanguageExtAnalysers.Tests/LanguageExtAnalysers.Tests.csproj

@@ -0,0 +1,26 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
+    <LangVersion>latest</LangVersion>
+    <Nullable>enable</Nullable>
+    <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
+    <GenerateBindingRedirectsOutputType>true</GenerateBindingRedirectsOutputType>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.9.0" />
+    <PackageReference Include="MSTest.TestAdapter" Version="1.3.2" />
+    <PackageReference Include="MSTest.TestFramework" Version="1.3.2" />
+    <PackageReference Include="Microsoft.CodeAnalysis" Version="3.3.1" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Analyzer.Testing.MSTest" Version="1.0.1-beta1.*" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.CodeFix.Testing.MSTest" Version="1.0.1-beta1.*" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.CodeRefactoring.Testing.MSTest" Version="1.0.1-beta1.*" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\LanguageExt.Core\LanguageExt.Core.csproj" />
+    <ProjectReference Include="..\LanguageExtAnalysers\LanguageExtAnalysers.csproj" />
+  </ItemGroup>
+
+</Project>