Core,Tests: apply TupleParentheses rule suggestions

Author: knocte

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

@@ -22,12 +22,12 @@ let rec checkExpression (expression: SynExpr) (range: range) (continuation: unit
         | SynExpr.For (_, _, _, _, _, _, _, innerExpression, range) -> checkExpression innerExpression range returnEmptyArray
         | SynExpr.ForEach (_, _, _, _, _, _, innerExpression, range) -> checkExpression innerExpression range returnEmptyArray
         | SynExpr.Match (_, _, clauses, range, _) ->
-            let subExpressions = clauses |> List.map (fun (SynMatchClause (_, _, clause, range, _, _)) -> clause, range)
+            let subExpressions = clauses |> List.map (fun (SynMatchClause (_, _, clause, range, _, _)) -> (clause, range))
             checkMultipleExpressions subExpressions returnEmptyArray
         | SynExpr.Do (innerExpression, range) -> checkExpression innerExpression range returnEmptyArray
         | SynExpr.TryWith (tryExpression, withCases, tryRange, _, _, _) ->
             let subExpressions =
-                withCases |> List.map (fun (SynMatchClause (_, _, withCase, withRange, _, _)) -> withCase, withRange)
+                withCases |> List.map (fun (SynMatchClause (_, _, withCase, withRange, _, _)) -> (withCase, withRange))
             checkMultipleExpressions subExpressions (fun () -> checkExpression tryExpression tryRange returnEmptyArray)
         | SynExpr.TryFinally (tryExpression, finallyExpr, range, _, _, _) ->
             checkExpression tryExpression range (fun () -> checkExpression finallyExpr range returnEmptyArray)

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

@@ -46,7 +46,7 @@ let runner (args: AstNodeRuleParams) =
                             let suggestedFix = lazy(
                                 let maybeFuncText = ExpressionUtilities.tryFindTextOfRange outerArgExpr.Range args.FileContent
                                 let maybeArgText = ExpressionUtilities.tryFindTextOfRange argExpr.Range args.FileContent
-                                match maybeFuncText, maybeArgText with
+                                match (maybeFuncText, maybeArgText) with
                                 | Some(funcText), Some(argText) ->
                                     let replacementText = sprintf "%s %s" funcText argText
                                     Some { FromText=args.FileContent; FromRange=range; ToText=replacementText }

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

@@ -32,8 +32,8 @@ type private BindingScopeComparer() =
         member this.Compare(left, right) =
             let leftStart = left.Binding.RangeOfBindingWithoutRhs.Start
             let rightStart = right.Binding.RangeOfBindingWithoutRhs.Start
-            let leftTuple : ValueTuple<int, int, int> = leftStart.Line, leftStart.Column, left.Complexity
-            let rightTuple : ValueTuple<int, int, int> = rightStart.Line, rightStart.Column, right.Complexity
+            let leftTuple : ValueTuple<int, int, int> = (leftStart.Line, leftStart.Column, left.Complexity)
+            let rightTuple : ValueTuple<int, int, int> = (rightStart.Line, rightStart.Column, right.Complexity)
             leftTuple.CompareTo rightTuple
 
 ///  A two-tiered stack-like structure for containing BindingScopes.
@@ -190,7 +190,7 @@ let runner (config:Config) (args:AstNodeRuleParams) : WarningDetails[] =
             let fromStack = bindingStack
                             |> Seq.sortBy (fun scope -> // sort by order of start position, for reporting
                                  let pos = scope.Binding.RangeOfBindingWithRhs.Start
-                                 pos.Column, pos.Line)
+                                 (pos.Column, pos.Line))
                             |> Seq.map (fun scope -> // transform into WarningDetails
                                 let errMsg = String.Format(Resources.GetString("RulesCyclomaticComplexityError"), scope.Complexity, config.MaxComplexity)
                                 { Range = scope.Binding.RangeOfBindingWithRhs; Message = errMsg; SuggestedFix = None; TypeChecks = List.Empty })

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

@@ -19,7 +19,7 @@ let private emitWarning (func: UnneededRecKeyword.RecursiveFunctionInfo) =
       TypeChecks = list.Empty }
 
 let runner (args: AstNodeRuleParams) =
-    match args.AstNode, args.CheckInfo with
+    match (args.AstNode, args.CheckInfo) with
     | UnneededRecKeyword.RecursiveFunctions(funcs), Some checkInfo ->
         let processFunction functionInfo =
             if UnneededRecKeyword.functionIsCalledInOneOf checkInfo functionInfo funcs then

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

@@ -44,7 +44,7 @@ let private generateFix (text:string) range = lazy(
 
 
 let runner args =
-    match args.AstNode, args.CheckInfo with
+    match (args.AstNode, args.CheckInfo) with
     | AstNode.Expression(SynExpr.New(_, SynType.LongIdent(identifier), _, range)), Some checkInfo
     | AstNode.Expression(SynExpr.New(_, SynType.App(SynType.LongIdent(identifier), _, _, _, _, _, _), _, range)), Some checkInfo ->
         Array.singleton

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

@@ -101,7 +101,7 @@ let private runner (args: AstNodeRuleParams) =
                     memberRange
                 )
         ) when memberFlags.IsInstance ->
-        match expr, argPats with
+        match (expr, argPats) with
         | _, SynArgPats.Pats pats when pats.Length > 0 -> // non-property member
             Array.empty
         | expression, _ when isImmutableValueExpression args expression id ->

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

@@ -56,7 +56,7 @@ let private emitWarning (func: RecursiveFunctionInfo) =
       TypeChecks = list.Empty }
 
 let runner (args: AstNodeRuleParams) =
-    match args.AstNode, args.CheckInfo with
+    match (args.AstNode, args.CheckInfo) with
     | RecursiveFunctions(funcs), Some checkInfo ->
         funcs 
             |> List.choose 

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

@@ -135,18 +135,18 @@ type TestConventionsCyclomaticComplexity() =
     static member private FailureCasesSource =
         seq {
             let num = MaxComplexity + 1
-            let errorLocation = 2, 4
-            yield ifElseExpressions num, errorLocation
-            yield forExpressions num, errorLocation
-            yield foreachExpressions num, errorLocation
-            yield whileExpressions num, errorLocation
-            yield matchExpression num, errorLocation
-            yield matchExpressionWithCombinedPatterns num, errorLocation
-            yield matchFunction num, errorLocation
-            yield matchBang num, errorLocation
-            yield ifThenExpressionWithMultipleAndConditionals num, errorLocation
-            yield ifThenExpressionWithMultipleOrConditionals num, errorLocation
-            yield whileWithBooleanOperatorsInConditionExpressions num, errorLocation
+            let errorLocation = (2, 4)
+            yield (ifElseExpressions num, errorLocation)
+            yield (forExpressions num, errorLocation)
+            yield (foreachExpressions num, errorLocation)
+            yield (whileExpressions num, errorLocation)
+            yield (matchExpression num, errorLocation)
+            yield (matchExpressionWithCombinedPatterns num, errorLocation)
+            yield (matchFunction num, errorLocation)
+            yield (matchBang num, errorLocation)
+            yield (ifThenExpressionWithMultipleAndConditionals num, errorLocation)
+            yield (ifThenExpressionWithMultipleOrConditionals num, errorLocation)
+            yield (whileWithBooleanOperatorsInConditionExpressions num, errorLocation)
         } |> Seq.map (fun (x, y) -> [| box x; box y |])
 
     /// Verifies that no cyclomatic complexity over-maximum flags are raised on source that has cyclomatic complexity <= maxComplexity.
@@ -254,4 +254,4 @@ let f() =
 let f (str: string) =
     match str with""" + NewLine + matchClauses
         this.Parse code
-        Assert.AreEqual(1, this.ErrorRanges.Length)
+        Assert.AreEqual(1, this.ErrorRanges.Length)