Add new rule FavourSingleton

Fixes #526

Author: su8898

docs/content/how-tos/rule-configuration.md

@@ -114,4 +114,5 @@ The following rules can be specified for linting.
 - [CyclomaticComplexity (FL0071)](rules/FL0071.html)
 - [FailwithBadUsage (FL0072)](rules/FL0072.html)
 - [FavourReRaise (FL0073)](rules/FL0073.html)
-- [FavourConsistentThis (FL0074)](rules/FL0074.html)
+- [FavourConsistentThis (FL0074)](rules/FL0074.html)
+- [FavourSingleton (FL0075)](rules/FL0075.html)

docs/content/how-tos/rules/FL0075.md

@@ -0,0 +1,30 @@
+---
+title: FL0075
+category: how-to
+hide_menu: true
+---
+
+# FavourSingleton (FL0075)
+
+*Introduced in `0.21.1`*
+
+## Cause
+
+Rule to detect usage of lists or arrays with only one item.
+
+## Rationale
+
+List.singleton/Array.singleton is more readable and explicit than [ foo]/[| foo |].
+
+## How To Fix
+
+Replace all occurrences of single member lists/arrays with a call to List.singleton/Array.singleton.
+
+## Rule Settings
+
+    {
+        "favourSingleton": {
+            "enabled": false
+        }
+    }
+

src/FSharpLint.Core/Application/Configuration.fs

@@ -433,7 +433,8 @@ type Configuration =
       MaxLinesInFile:RuleConfig<MaxLinesInFile.Config> option
       TrailingNewLineInFile:EnabledConfig option
       NoTabCharacters:EnabledConfig option
-      NoPartialFunctions:RuleConfig<NoPartialFunctions.Config> option }
+      NoPartialFunctions:RuleConfig<NoPartialFunctions.Config> option
+      FavourSingleton:EnabledConfig option }
 with
     static member Zero = {
         Global = None
@@ -511,6 +512,7 @@ with
         TrailingNewLineInFile = None
         NoTabCharacters = None
         NoPartialFunctions = None
+        FavourSingleton = None
     }
 
 // fsharplint:enable RecordFieldNames
@@ -652,6 +654,7 @@ let flattenConfig (config:Configuration) =
             config.TrailingNewLineInFile |> Option.bind (constructRuleIfEnabled TrailingNewLineInFile.rule)
             config.NoTabCharacters |> Option.bind (constructRuleIfEnabled NoTabCharacters.rule)
             config.NoPartialFunctions |> Option.bind (constructRuleWithConfig NoPartialFunctions.rule)
+            config.FavourSingleton |> Option.bind (constructRuleIfEnabled FavourSingleton.rule)
         |] |> Array.choose id
 
     if config.NonPublicValuesNames.IsSome &&

src/FSharpLint.Core/FSharpLint.Core.fsproj

@@ -49,6 +49,7 @@
     <Compile Include="Rules\Conventions\CyclomaticComplexity.fs" />
     <Compile Include="Rules\Conventions\FavourReRaise.fs" />
     <Compile Include="Rules\Conventions\FavourConsistentThis.fs" />
+    <Compile Include="Rules\Conventions\FavourSingleton.fs" />
     <Compile Include="Rules\Conventions\RaiseWithTooManyArguments\RaiseWithTooManyArgumentsHelper.fs" />
     <Compile Include="Rules\Conventions\RaiseWithTooManyArguments\FailwithWithSingleArgument.fs" />
     <Compile Include="Rules\Conventions\RaiseWithTooManyArguments\RaiseWithSingleArgument.fs" />

src/FSharpLint.Core/Rules/Conventions/FavourSingleton.fs

@@ -0,0 +1,38 @@
+module FSharpLint.Rules.FavourSingleton
+
+open FSharpLint.Framework
+open FSharpLint.Framework.Suggestion
+open FSharp.Compiler.Syntax
+open FSharp.Compiler.Text
+open FSharpLint.Framework.Ast
+open FSharpLint.Framework.Rules
+open System
+
+let runner args =
+    match args.AstNode with
+    | AstNode.Binding(SynBinding(_, _, _, _, _, _, _, _, _, expression, _, _)) ->
+        match expression with
+        | SynExpr.ArrayOrListOfSeqExpr(_, SynExpr.CompExpr(_, _, expr,range), _) ->
+            match expr with
+            | SynExpr.Const(_, range) ->
+                { Range = range
+                  Message = String.Format(Resources.GetString "RulesFavourSingleton")
+                  SuggestedFix = None
+                  TypeChecks = List.Empty }
+                  |> Array.singleton
+            | SynExpr.Ident _ ->
+              { Range = range
+                Message = String.Format(Resources.GetString "RulesFavourSingleton")
+                SuggestedFix = None
+                TypeChecks = List.Empty }
+                |> Array.singleton
+              | _ -> Array.empty
+        | _ -> Array.empty
+    | _ -> Array.empty
+let rule =
+    { Name = "FavourSingleton"
+      Identifier = Identifiers.FavourSingleton
+      RuleConfig =
+        { AstNodeRuleConfig.Runner = runner
+          Cleanup = ignore } }
+    |> AstNodeRule

src/FSharpLint.Core/Rules/Identifiers.fs

@@ -79,3 +79,4 @@ let CyclomaticComplexity = identifier 71
 let FailwithBadUsage = identifier 72
 let FavourReRaise = identifier 73
 let FavourConsistentThis = identifier 74
+let FavourSingleton = identifier 75

src/FSharpLint.Core/Text.resx

@@ -333,4 +333,7 @@
   <data name="RulesFavourConsistentThis" xml:space="preserve">
     <value>Prefer using '{0}' consistently.</value>
   </data>
+  <data name="RulesFavourSingleton" xml:space="preserve">
+    <value>Consider using List.singleton/Array.singleton instead of single member list/array.</value>
+  </data>
 </root>

src/FSharpLint.Core/fsharplint.json

@@ -261,6 +261,7 @@
         }
     },
     "favourIgnoreOverLetWild": { "enabled": true },
+    "favourSingleton": { "enabled": false },
     "wildcardNamedWithAsPattern": { "enabled": true },
     "uselessBinding": { "enabled": true },
     "tupleOfWildcards": { "enabled": true },

tests/FSharpLint.Core.Tests/FSharpLint.Core.Tests.fsproj

@@ -37,6 +37,7 @@
     <Compile Include="Rules\Conventions\NoPartialFunctions.fs" />
     <Compile Include="Rules\Conventions\FavourReRaise.fs" />
     <Compile Include="Rules\Conventions\FavourConsistentThis.fs" />
+    <Compile Include="Rules\Conventions\FavourSingleton.fs" />
     <Compile Include="Rules\Conventions\Naming\NamingHelpers.fs" />
     <Compile Include="Rules\Conventions\Naming\InterfaceNames.fs" />
     <Compile Include="Rules\Conventions\Naming\ExceptionNames.fs" />

tests/FSharpLint.Core.Tests/Rules/Conventions/FavourSingleton.fs

@@ -0,0 +1,93 @@
+module FSharpLint.Core.Tests.Rules.Conventions.FavourSingleton
+
+open NUnit.Framework
+open FSharpLint.Rules
+open System
+
+[<TestFixture>]
+type TestConventionsFavourSingleton() =
+    inherit TestAstNodeRuleBase.TestAstNodeRuleBase(FavourSingleton.rule)
+
+    [<Test>]
+    member this.ListWithManyItemsShouldNotProduceError() =
+        this.Parse """
+let foo = [ 10; 20 ]"""
+
+        this.AssertNoWarnings()
+
+    [<Test>]
+    member this.ListWithASingleConstantShouldProduceError() =
+        this.Parse """
+let foo = [ 10 ]"""
+
+        Assert.IsTrue this.ErrorsExist
+        Assert.IsTrue(this.ErrorExistsAt(2, 12))
+
+    [<Test>]
+    member this.ListWithASingleIdentShouldProduceError() =
+        this.Parse """
+let bar = true
+let foo = [ bar ]"""
+
+        Assert.IsTrue this.ErrorsExist
+        Assert.IsTrue(this.ErrorExistsAt(3, 12))
+
+    [<Test>]
+    member this.ListWithMultipleIdentsShouldNotProduceError() =
+        this.Parse """
+let bar = true
+let foo = [ bar; false; true ]"""
+
+        this.AssertNoWarnings()
+
+    [<Test>]
+    member this.ListWithManyItemsShouldNotProduceError_Arrays() =
+        this.Parse """
+let foo = [| 10; 20 |]"""
+
+        Assert.IsTrue this.NoErrorsExist
+
+    [<Test>]
+    member this.ListWithASingleConstantShouldProduceError_Arrays() =
+        this.Parse """
+let foo = [| 10 |]"""
+
+        Assert.IsTrue this.ErrorsExist
+        Assert.IsTrue(this.ErrorExistsAt(2, 13))
+
+    [<Test>]
+    member this.ListWithASingleIdentShouldProduceError_Arrays() =
+        this.Parse """
+let bar = true
+let foo = [| bar |]"""
+
+        Assert.IsTrue this.ErrorsExist
+        Assert.IsTrue(this.ErrorExistsAt(3, 13))
+
+    [<Test>]
+    member this.ListWithMultipleIdentsShouldNotProduceError_Arrays() =
+        this.Parse """
+let bar = true
+let foo = [| bar; false; true |]"""
+
+        this.AssertNoWarnings()
+
+    [<Test>]
+    member this.SingletonListWithMatchCaseShouldNotProduceError() =
+        this.Parse """
+let foo = List.empty
+match foo with
+| [x] -> printf x
+| _ -> printf "baz" """
+
+        this.AssertNoWarnings()
+
+    [<Test>]
+    member this.SingletonArrayWithMatchCaseShouldNotProduceError() =
+        this.Parse """
+let foo = Array.empty
+match foo with
+| [| x |] -> printf x
+| _ -> printf "baz" """
+
+        this.AssertNoWarnings()