Core,Console,Tests: fix selfCheck

Author: webwarrior-ws

src/FSharpLint.Console/Program.fs

@@ -54,10 +54,10 @@ with
             | Lint_Config _ -> "Path to the config for the lint."
 // fsharplint:enable UnionCasesNames
 
-let private validTargetFileExtensions = [ ".fs"; ".fsx"; ".fsproj"; ".sln"; ".slnx" ]
 /// Expands a wildcard pattern to a list of matching files.
 /// Supports recursive search using ** (e.g., "**/*.fs" or "src/**/*.fs")
 let internal expandWildcard (pattern:string) =
+    let validTargetFileExtensions = [ ".fs"; ".fsx"; ".fsproj"; ".sln"; ".slnx" ]
     let isValidTargetFile (filePath:string) =
         validTargetFileExtensions |> List.exists filePath.EndsWith
 

src/FSharpLint.Core/Rules/Conventions/Binding/FavourAsKeyword.fs

@@ -8,48 +8,48 @@ open FSharp.Compiler.Text
 open FSharpLint.Framework.Ast
 open FSharpLint.Framework.Rules
 
-let private runner (args:AstNodeRuleParams) =
-    let checkForNamedPatternEqualsConstant pattern whenExpr (range:Range) =
-        let patternIdent =
-            match pattern with
-            | SynPat.Named(SynIdent.SynIdent(ident, _), _, _, _) -> Some(ident.idText)
-            | _ -> None
-
-
-        match whenExpr with
-        | SynExpr.App(_, _, funcExpr, SynExpr.Const(_, constRange), _) ->
-            match funcExpr with
-            | SynExpr.App(_, _, ExpressionUtilities.Identifier([opIdent], _), SynExpr.Ident(ident), _)
-                when opIdent.idText = "op_Equality" && Option.contains ident.idText patternIdent ->
-
-                let fromRange = Range.mkRange String.Empty range.Start constRange.End
-
-                let suggestedFix =
-                    ExpressionUtilities.tryFindTextOfRange fromRange args.FileContent
-                    |> Option.bind (fun text ->
-
-                        ExpressionUtilities.tryFindTextOfRange constRange args.FileContent
-                        |> Option.bind (fun constText ->
-                            Some (lazy (Some { FromText = text; FromRange = fromRange; ToText = $"{constText} as {ident.idText}"}))
+let rule =
+    let runner (args:AstNodeRuleParams) =
+        let checkForNamedPatternEqualsConstant pattern whenExpr (range:Range) =
+            let patternIdent =
+                match pattern with
+                | SynPat.Named(SynIdent.SynIdent(ident, _), _, _, _) -> Some(ident.idText)
+                | _ -> None
+
+
+            match whenExpr with
+            | SynExpr.App(_, _, funcExpr, SynExpr.Const(_, constRange), _) ->
+                match funcExpr with
+                | SynExpr.App(_, _, ExpressionUtilities.Identifier([opIdent], _), SynExpr.Ident(ident), _)
+                    when opIdent.idText = "op_Equality" && Option.contains ident.idText patternIdent ->
+
+                    let fromRange = Range.mkRange String.Empty range.Start constRange.End
+
+                    let suggestedFix =
+                        ExpressionUtilities.tryFindTextOfRange fromRange args.FileContent
+                        |> Option.bind (fun text ->
+
+                            ExpressionUtilities.tryFindTextOfRange constRange args.FileContent
+                            |> Option.bind (fun constText ->
+                                Some (lazy (Some { FromText = text; FromRange = fromRange; ToText = $"{constText} as {ident.idText}"}))
+                            )
                         )
-                    )
 
-                Array.singleton
-                    { Range = fromRange
-                      Message = Resources.GetString("RulesFavourAsKeyword")
-                      SuggestedFix = suggestedFix
-                      TypeChecks = List.Empty }
+                    Array.singleton
+                        { Range = fromRange
+                          Message = Resources.GetString("RulesFavourAsKeyword")
+                          SuggestedFix = suggestedFix
+                          TypeChecks = List.Empty }
 
+                | _ -> Array.empty
             | _ -> Array.empty
-        | _ -> Array.empty
 
-    match args.AstNode with
-    | AstNode.Match(SynMatchClause.SynMatchClause(pat, Some(whenExpr), _, range, _, _)) ->
-        checkForNamedPatternEqualsConstant pat whenExpr range
+        match args.AstNode with
+        | AstNode.Match(SynMatchClause.SynMatchClause(pat, Some(whenExpr), _, range, _, _)) ->
+            checkForNamedPatternEqualsConstant pat whenExpr range
 
-    | _ -> Array.empty
+        | _ -> Array.empty
 
-let rule =
     AstNodeRule
         { Name = "FavourAsKeyword"
           Identifier = Identifiers.FavourAsKeyword

src/FSharpLint.Core/Rules/Conventions/Binding/FavourIgnoreOverLetWild.fs

@@ -7,44 +7,44 @@ open FSharp.Compiler.Syntax
 open FSharpLint.Framework.Ast
 open FSharpLint.Framework.Rules
 
-let private runner (args:AstNodeRuleParams) =
-    let checkForBindingToAWildcard pattern range fileContent (expr: SynExpr) letBindingRange =
-        let rec findWildAndIgnoreParens = function
-            | SynPat.Paren(pat, _) -> findWildAndIgnoreParens pat
-            | SynPat.Wild(_) -> true
-            | _ -> false
+/// Checks if any code uses 'let _ = ...' and suggests to use the ignore function.
+let rule =
+    let runner (args:AstNodeRuleParams) =
+        let checkForBindingToAWildcard pattern range fileContent (expr: SynExpr) letBindingRange =
+            let rec findWildAndIgnoreParens = function
+                | SynPat.Paren(pat, _) -> findWildAndIgnoreParens pat
+                | SynPat.Wild(_) -> true
+                | _ -> false
 
-        match ExpressionUtilities.tryFindTextOfRange expr.Range fileContent with
-        | Some exprText -> 
-            if findWildAndIgnoreParens pattern then
-                Array.singleton
-                    { Range = range
-                      Message = Resources.GetString("RulesFavourIgnoreOverLetWildError")
-                      SuggestedFix = Some (lazy (Some({ FromRange = letBindingRange
-                                                        FromText = fileContent
-                                                        ToText = sprintf "(%s) |> ignore" exprText })))
-                      TypeChecks = List.Empty }
-            else
-                Array.empty
-        | None -> Array.empty
+            match ExpressionUtilities.tryFindTextOfRange expr.Range fileContent with
+            | Some exprText -> 
+                if findWildAndIgnoreParens pattern then
+                    Array.singleton
+                        { Range = range
+                          Message = Resources.GetString("RulesFavourIgnoreOverLetWildError")
+                          SuggestedFix = Some (lazy (Some({ FromRange = letBindingRange
+                                                            FromText = fileContent
+                                                            ToText = sprintf "(%s) |> ignore" exprText })))
+                          TypeChecks = List.Empty }
+                else
+                    Array.empty
+            | None -> Array.empty
 
-    match args.AstNode with
-    | AstNode.Binding(SynBinding(_, _, _, _, _, _, _, pattern, _, expr, range, _, _)) ->
-        let bindingRange  = 
-            match args.GetParents(args.NodeIndex) with
-            | AstNode.ModuleDeclaration(SynModuleDecl.Let(_, _, range)) :: _
-            | AstNode.Expression(SynExpr.LetOrUse(_, false, _, _, range, _)) :: _ -> 
-                Some(range)
-            | _ -> None
+        match args.AstNode with
+        | AstNode.Binding(SynBinding(_, _, _, _, _, _, _, pattern, _, expr, range, _, _)) ->
+            let bindingRange  = 
+                match args.GetParents(args.NodeIndex) with
+                | AstNode.ModuleDeclaration(SynModuleDecl.Let(_, _, range)) :: _
+                | AstNode.Expression(SynExpr.LetOrUse(_, false, _, _, range, _)) :: _ -> 
+                    Some(range)
+                | _ -> None
 
-        match bindingRange with
-        | Some letBindingRange -> 
-            checkForBindingToAWildcard pattern range args.FileContent expr letBindingRange
-        | None -> Array.empty
-    | _ -> Array.empty
+            match bindingRange with
+            | Some letBindingRange -> 
+                checkForBindingToAWildcard pattern range args.FileContent expr letBindingRange
+            | None -> Array.empty
+        | _ -> Array.empty
 
-/// Checks if any code uses 'let _ = ...' and suggests to use the ignore function.
-let rule =
     AstNodeRule
         {
             Name = "FavourIgnoreOverLetWild"

src/FSharpLint.Core/Rules/Conventions/Binding/FavourTypedIgnore.fs

@@ -7,51 +7,51 @@ open FSharp.Compiler.Syntax
 open FSharpLint.Framework.Ast
 open FSharpLint.Framework.Rules
 
-let private runner (args: AstNodeRuleParams) =
-    let generateError identifier range text =
+/// Checks if any code uses untyped ignore
+let rule =
+    let runner (args: AstNodeRuleParams) =
+        let generateError identifier range text =
 
-        let suggestedFix =
-            lazy
-                (ExpressionUtilities.tryFindTextOfRange range text
-                 |> Option.map
-                     (fun fromText ->
-                         { FromText = fromText
-                           FromRange = range
-                           ToText = identifier }))
+            let suggestedFix =
+                lazy
+                    (ExpressionUtilities.tryFindTextOfRange range text
+                     |> Option.map
+                         (fun fromText ->
+                             { FromText = fromText
+                               FromRange = range
+                               ToText = identifier }))
 
-        {
-            Range = range
-            Message = String.Format(Resources.GetString "RulesFavourTypedIgnore", identifier)
-            SuggestedFix = Some suggestedFix
-            TypeChecks = List.Empty
-        }
+            {
+                Range = range
+                Message = String.Format(Resources.GetString "RulesFavourTypedIgnore", identifier)
+                SuggestedFix = Some suggestedFix
+                TypeChecks = List.Empty
+            }
 
-    let isTyped expression identifier range text =
-        match expression with
-        | SynExpr.Typed (_id, _synType, _range) -> Array.empty
-        | _ ->
-            generateError identifier range text
-            |> Array.singleton
+        let isTyped expression identifier range text =
+            match expression with
+            | SynExpr.Typed (_id, _synType, _range) -> Array.empty
+            | _ ->
+                generateError identifier range text
+                |> Array.singleton
 
-    let ignoreFunc = "ignore"
+        let ignoreFunc = "ignore"
 
-    match args.AstNode with
-    | AstNode.Expression (SynExpr.App (_, _, expression, SynExpr.Ident identifier, range)) when
-        identifier.idText = ignoreFunc
-        ->
-        isTyped expression identifier.idText range identifier.idText
-    | AstNode.Expression (SynExpr.App (_, _, SynExpr.Ident identifier, expression, range)) when
-        identifier.idText = ignoreFunc
-        ->
-        match expression with
-        | SynExpr.Paren (expr, _, _, _) -> isTyped expr identifier.idText range identifier.idText
-        | _ ->
-            generateError identifier.idText range identifier.idText
-            |> Array.singleton
-    | _ -> Array.empty
+        match args.AstNode with
+        | AstNode.Expression (SynExpr.App (_, _, expression, SynExpr.Ident identifier, range)) when
+            identifier.idText = ignoreFunc
+            ->
+            isTyped expression identifier.idText range identifier.idText
+        | AstNode.Expression (SynExpr.App (_, _, SynExpr.Ident identifier, expression, range)) when
+            identifier.idText = ignoreFunc
+            ->
+            match expression with
+            | SynExpr.Paren (expr, _, _, _) -> isTyped expr identifier.idText range identifier.idText
+            | _ ->
+                generateError identifier.idText range identifier.idText
+                |> Array.singleton
+        | _ -> Array.empty
 
-/// Checks if any code uses untyped ignore
-let rule =
     AstNodeRule
         {
             Name = "FavourTypedIgnore"

src/FSharpLint.Core/Rules/Conventions/Binding/TupleOfWildcards.fs

@@ -7,64 +7,64 @@ open FSharpLint.Framework.Suggestion
 open FSharpLint.Framework.Ast
 open FSharpLint.Framework.Rules
 
-let private runner (args:AstNodeRuleParams) =
-    let checkTupleOfWildcards fileContents pattern identifier identifierRange =
-        let rec isWildcard = function
-            | SynPat.Paren(innerPattern, _) -> isWildcard innerPattern
-            | SynPat.Wild(_) -> true
-            | _ -> false
+let rule =
+    let runner (args:AstNodeRuleParams) =
+        let checkTupleOfWildcards fileContents pattern identifier identifierRange =
+            let rec isWildcard = function
+                | SynPat.Paren(innerPattern, _) -> isWildcard innerPattern
+                | SynPat.Wild(_) -> true
+                | _ -> false
 
-        let constructorString numberOfWildcards =
-            let constructorName = String.concat "." identifier
-            let arguments = Array.create numberOfWildcards "_" |> String.concat ", "
-            if numberOfWildcards = 1 then
-                $"%s{constructorName} _"
-            else
-                $"%s{constructorName}(%s{arguments})"
+            let constructorString numberOfWildcards =
+                let constructorName = String.concat "." identifier
+                let arguments = Array.create numberOfWildcards "_" |> String.concat ", "
+                if numberOfWildcards = 1 then
+                    $"%s{constructorName} _"
+                else
+                    $"%s{constructorName}(%s{arguments})"
 
-        match pattern with
-        | SynPat.Tuple(_isStruct, patterns, _, range) when List.length patterns > 1 && patterns |> List.forall isWildcard ->
-            let errorFormat = Resources.GetString("RulesTupleOfWildcardsError")
-            let refactorFrom = constructorString (List.length patterns)
-            let refactorTo = constructorString 1
-            let error = String.Format(errorFormat, refactorFrom, refactorTo)
-            let suggestedFix = lazy(
-                Some { SuggestedFix.FromRange = identifierRange; FromText = fileContents; ToText = refactorTo })
-            Array.singleton
-                {
-                    Range = range
-                    Message = error
-                    SuggestedFix = Some suggestedFix
-                    TypeChecks = List.Empty
-                }
-        | _ -> Array.empty
+            match pattern with
+            | SynPat.Tuple(_isStruct, patterns, _, range) when List.length patterns > 1 && patterns |> List.forall isWildcard ->
+                let errorFormat = Resources.GetString("RulesTupleOfWildcardsError")
+                let refactorFrom = constructorString (List.length patterns)
+                let refactorTo = constructorString 1
+                let error = String.Format(errorFormat, refactorFrom, refactorTo)
+                let suggestedFix = lazy(
+                    Some { SuggestedFix.FromRange = identifierRange; FromText = fileContents; ToText = refactorTo })
+                Array.singleton
+                    {
+                        Range = range
+                        Message = error
+                        SuggestedFix = Some suggestedFix
+                        TypeChecks = List.Empty
+                    }
+            | _ -> Array.empty
 
-    let isTupleMemberArgs breadcrumbs tupleRange =
-        let (|MemberBindingArgs|_|) bindingPattern =
-            match bindingPattern with
-            | SynBinding(_, _, _, _, _, _, _, SynPat.LongIdent(_, _, _, argPats, _, _), _, _, _, _, _) ->
-                match argPats with
-                | SynArgPats.Pats([SynPat.Paren(SynPat.Tuple(_) as tuple, _)]) -> Some(tuple)
+        let isTupleMemberArgs breadcrumbs tupleRange =
+            let (|MemberBindingArgs|_|) bindingPattern =
+                match bindingPattern with
+                | SynBinding(_, _, _, _, _, _, _, SynPat.LongIdent(_, _, _, argPats, _, _), _, _, _, _, _) ->
+                    match argPats with
+                    | SynArgPats.Pats([SynPat.Paren(SynPat.Tuple(_) as tuple, _)]) -> Some(tuple)
+                    | _ -> None
                 | _ -> None
-            | _ -> None
 
-        match breadcrumbs with
-        | AstNode.Binding(MemberBindingArgs(SynPat.Tuple(_, _, _, range)))::AstNode.Expression(SynExpr.ObjExpr(_))::_
-        | AstNode.Binding(MemberBindingArgs(SynPat.Tuple(_, _, _, range)))::AstNode.MemberDefinition(_)::_ ->
-            tupleRange = range
-        | _ -> false
+            match breadcrumbs with
+            | AstNode.Binding(MemberBindingArgs(SynPat.Tuple(_, _, _, range)))::AstNode.Expression(SynExpr.ObjExpr(_))::_
+            | AstNode.Binding(MemberBindingArgs(SynPat.Tuple(_, _, _, range)))::AstNode.MemberDefinition(_)::_ ->
+                tupleRange = range
+            | _ -> false
 
-    match args.AstNode with
-    | AstNode.Pattern(SynPat.LongIdent(identifier, _, _, SynArgPats.Pats([SynPat.Paren(SynPat.Tuple(_, _, _, range) as pattern, _)]), _, identRange)) ->
-        let breadcrumbs = args.GetParents 2
-        if (not << isTupleMemberArgs breadcrumbs) range then
-            let identifier = identifier.LongIdent |> List.map (fun ident -> ident.idText)
-            checkTupleOfWildcards args.FileContent pattern identifier identRange
-        else
-            Array.empty
-    | _ -> Array.empty
+        match args.AstNode with
+        | AstNode.Pattern(SynPat.LongIdent(identifier, _, _, SynArgPats.Pats([SynPat.Paren(SynPat.Tuple(_, _, _, range) as pattern, _)]), _, identRange)) ->
+            let breadcrumbs = args.GetParents 2
+            if (not << isTupleMemberArgs breadcrumbs) range then
+                let identifier = identifier.LongIdent |> List.map (fun ident -> ident.idText)
+                checkTupleOfWildcards args.FileContent pattern identifier identRange
+            else
+                Array.empty
+        | _ -> Array.empty
 
-let rule =
     AstNodeRule
         {
             Name = "TupleOfWildcards"