Add new rule FavourSingleton

Fixes #526

Co-authored-by: Parham Saremi <[email protected]>

Author: 2 people

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

@@ -129,3 +129,4 @@ The following rules can be specified for linting.
 - [FavourAsKeyword (FL0086)](rules/FL0086.html)
 - [InterpolatedStringWithNoSubstitution (FL0087)](rules/FL0087.html)
 - [IndexerAccessorStyleConsistency (FL0088)](rules/FL0088.html)
+- [FavourSingleton (FL0089)](rules/FL0089.html)

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

@@ -0,0 +1,29 @@
+---
+title: FL0089
+category: how-to
+hide_menu: true
+---
+
+# FavourSingleton (FL0089)
+
+*Introduced in `0.26.10`*
+
+## 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

@@ -513,7 +513,8 @@ type Configuration =
       SuggestUseAutoProperty:EnabledConfig option
       EnsureTailCallDiagnosticsInRecursiveFunctions:EnabledConfig option
       FavourAsKeyword:EnabledConfig option 
-      InterpolatedStringWithNoSubstitution:EnabledConfig option }
+      InterpolatedStringWithNoSubstitution:EnabledConfig option
+      FavourSingleton:EnabledConfig option }
 with
     static member Zero = {
         Global = None
@@ -610,6 +611,7 @@ with
         EnsureTailCallDiagnosticsInRecursiveFunctions = None
         FavourAsKeyword = None
         InterpolatedStringWithNoSubstitution = None
+        FavourSingleton = None
     }
 
 // fsharplint:enable RecordFieldNames
@@ -807,6 +809,7 @@ let flattenConfig (config:Configuration) =
                 config.EnsureTailCallDiagnosticsInRecursiveFunctions |> Option.bind (constructRuleIfEnabled EnsureTailCallDiagnosticsInRecursiveFunctions.rule)
                 config.FavourAsKeyword |> Option.bind (constructRuleIfEnabled FavourAsKeyword.rule)
                 config.InterpolatedStringWithNoSubstitution |> Option.bind (constructRuleIfEnabled InterpolatedStringWithNoSubstitution.rule)
+                config.FavourSingleton |> Option.bind (constructRuleIfEnabled FavourSingleton.rule)
             |]
 
     findDeprecation config deprecatedAllRules allRules

src/FSharpLint.Core/FSharpLint.Core.fsproj

@@ -69,6 +69,7 @@
     <Compile Include="Rules\Smells\RaiseWithTooManyArguments\InvalidArgWithTwoArguments.fs" />
     <Compile Include="Rules\Smells\RaiseWithTooManyArguments\FailwithfWithArgumentsMatchingFormatString.fs" />
     <Compile Include="Rules\Conventions\FailwithBadUsage.fs" />
+    <Compile Include="Rules\Conventions\FavourSingleton.fs" />
     <Compile Include="Rules\Conventions\SourceLength\SourceLengthHelper.fs" />
     <Compile Include="Rules\Conventions\SourceLength\MaxLinesInLambdaFunction.fs" />
     <Compile Include="Rules\Conventions\SourceLength\MaxLinesInMatchLambdaFunction.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

@@ -93,3 +93,4 @@ let EnsureTailCallDiagnosticsInRecursiveFunctions = identifier 85
 let FavourAsKeyword = identifier 86
 let InterpolatedStringWithNoSubstitution = identifier 87
 let IndexerAccessorStyleConsistency = identifier 88
+let FavourSingleton = identifier 89

src/FSharpLint.Core/Text.resx

@@ -387,4 +387,7 @@
   <data name="RulesIndexerAccessorStyleConsistency" xml:space="preserve">
     <value>Consider switching the indexer accessor to {0} style.</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

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

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

@@ -48,6 +48,7 @@
     <Compile Include="Rules\Conventions\FavourNonMutablePropertyInitialization.fs" />
     <Compile Include="Rules\Conventions\EnsureTailCallDiagnosticsInRecursiveFunctions.fs" />
     <Compile Include="Rules\Conventions\IndexerAccessorStyleConsistency.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()