Call pipingIntoCompositionChecks

Author: jfmengels

CHANGELOG.md

@@ -20,6 +20,9 @@ The rule now simplifies:
 - `(\()) -> x) <| f <| y` to `x` (previously not always applied in pipelines)
 - `(\a _ -> x) y z` to `(\a -> x) y` (previously only the first argument would get removed)
 - `f >> (\_ -> x)` to `(\_ -> x)`
+- `(f >> g) data` to `g <| f data`
+- `(f >> g) <| data` to `g <| f <| data`
+- `data |> (g << f)` to `data |> f |> g`
 - `List.map f (List.repeat n a)` to `List.repeat n (f a)`
 - `Array.map f (Array.repeat n a)` to `Array.repeat n (f a)`
 - `String.map f (String.repeat n (String.fromChar c))` to `String.repeat n (String.fromChar (f c))`

src/Simplify.elm

@@ -324,6 +324,15 @@ Destructuring using case expressions
     a |> f >> g
     --> a |> f |> g
 
+    (f >> g) a
+    --> g <| f a
+
+    (f >> g) <| a
+    --> g <| f <| a
+
+    a |> (g << f)
+    --> a |> g |> f
+
 
 ### Numbers
 
@@ -3345,6 +3354,26 @@ expressionVisitorHelp (Node expressionRange expression) config context =
                             , moduleCustomTypes = context.moduleCustomTypes
                             }
 
+                    Node parens (Expression.ParenthesizedExpression ((Node _ (Expression.OperatorApplication "<<" _ _ _)) as operationNode)) ->
+                        pipingIntoCompositionChecks
+                            { commentRanges = context.commentRanges
+                            , extractSourceCode = context.extractSourceCode
+                            , direction = CallStyle.RightToLeft
+                            }
+                            (\() ->
+                                if List.isEmpty argsAfterFirst then
+                                    removeBoundariesFix applied
+
+                                else
+                                    [ Fix.removeRange
+                                        { start = { row = parens.end.row, column = parens.end.column - 1 }
+                                        , end = parens.end
+                                        }
+                                    , Fix.insertAt (Node.range firstArg).end ")"
+                                    ]
+                            )
+                            operationNode
+
                     Node parens (Expression.ParenthesizedExpression ((Node _ (Expression.OperatorApplication ">>" _ _ _)) as operationNode)) ->
                         reversedCompositionChecks
                             { commentRanges = context.commentRanges
@@ -17755,7 +17784,7 @@ pipelineChecks :
     }
     -> Maybe (Error {})
 pipelineChecks checkInfo =
-    pipingIntoCompositionChecks { commentRanges = checkInfo.commentRanges, extractSourceCode = checkInfo.extractSourceCode } checkInfo.direction checkInfo.pipedInto
+    pipingIntoCompositionChecks checkInfo (always []) checkInfo.pipedInto
         |> onNothing
             (\() ->
                 reversedCompositionChecks checkInfo (\() -> []) checkInfo.pipedInto
@@ -17825,22 +17854,26 @@ fullyAppliedLambdaInPipelineChecks checkInfo =
 
 
 pipingIntoCompositionChecks :
-    { commentRanges : List Range, extractSourceCode : Range -> String }
-    -> CallStyle.LeftOrRightDirection
+    { context
+        | commentRanges : List Range
+        , extractSourceCode : Range -> String
+        , direction : CallStyle.LeftOrRightDirection
+    }
+    -> (() -> List Fix)
     -> Node Expression
     -> Maybe (Error {})
-pipingIntoCompositionChecks context compositionDirection expressionNode =
+pipingIntoCompositionChecks context fixesFromParent expressionNode =
     let
         targetAndReplacement : { opToFind : String, replacement : String }
         targetAndReplacement =
-            case compositionDirection of
+            case context.direction of
                 CallStyle.RightToLeft ->
                     { opToFind = "<<", replacement = "<|" }
 
                 CallStyle.LeftToRight ->
                     { opToFind = ">>", replacement = "|>" }
     in
-    case pipingIntoCompositionChecksHelp context targetAndReplacement compositionDirection expressionNode of
+    case pipingIntoCompositionChecksHelp context targetAndReplacement expressionNode of
         Nothing ->
             Nothing
 
@@ -17852,7 +17885,7 @@ pipingIntoCompositionChecks context compositionDirection expressionNode =
                         [ "Because of the precedence of operators, using " ++ targetAndReplacement.opToFind ++ " at this location is the same as using " ++ targetAndReplacement.replacement ++ "."
                         , "To make it more idiomatic in Elm and generally easier to read, please use " ++ targetAndReplacement.replacement ++ " instead. You may need to remove some parentheses to do this."
                         , "Here is an example:"
-                            ++ (case compositionDirection of
+                            ++ (case context.direction of
                                     CallStyle.RightToLeft ->
                                         leftPipeExample
 
@@ -17862,20 +17895,23 @@ pipingIntoCompositionChecks context compositionDirection expressionNode =
                         ]
                     }
                     error.opToReplaceRange
-                    error.fixes
+                    (fixesFromParent () ++ error.fixes)
                 )
 
 
 pipingIntoCompositionChecksHelp :
-    { commentRanges : List Range, extractSourceCode : Range -> String }
+    { context
+        | commentRanges : List Range
+        , extractSourceCode : Range -> String
+        , direction : CallStyle.LeftOrRightDirection
+    }
     -> { opToFind : String, replacement : String }
-    -> CallStyle.LeftOrRightDirection
     -> Node Expression
     -> Maybe { opToReplaceRange : Range, fixes : List Fix, firstStepIsComposition : Bool }
-pipingIntoCompositionChecksHelp context targetAndReplacement compositionDirection subExpression =
+pipingIntoCompositionChecksHelp context targetAndReplacement subExpression =
     case Node.value subExpression of
         Expression.ParenthesizedExpression inParens ->
-            case pipingIntoCompositionChecksHelp context targetAndReplacement compositionDirection inParens of
+            case pipingIntoCompositionChecksHelp context targetAndReplacement inParens of
                 Nothing ->
                     Nothing
 
@@ -17898,12 +17934,12 @@ pipingIntoCompositionChecksHelp context targetAndReplacement compositionDirectio
             let
                 continuedSearch : Maybe { opToReplaceRange : Range, fixes : List Fix, firstStepIsComposition : Bool }
                 continuedSearch =
-                    case compositionDirection of
+                    case context.direction of
                         CallStyle.RightToLeft ->
-                            pipingIntoCompositionChecksHelp context targetAndReplacement compositionDirection left
+                            pipingIntoCompositionChecksHelp context targetAndReplacement left
 
                         CallStyle.LeftToRight ->
-                            pipingIntoCompositionChecksHelp context targetAndReplacement compositionDirection right
+                            pipingIntoCompositionChecksHelp context targetAndReplacement right
             in
             if symbol == targetAndReplacement.replacement then
                 Maybe.map (\errors -> { errors | firstStepIsComposition = False })

tests/Simplify/PipelineTest.elm

@@ -472,7 +472,7 @@ After:  data |> fn1 |> fn2"""
 a = g <| f b
 """
                         ]
-        , test "should reverse >> when used in a plain application call and add parens if there are more arguments" <|
+        , test "should reverse >> when used in a plain application call, and add parens if there are more arguments" <|
             \() ->
                 """module A exposing (..)
 a = (f >> g) b c
@@ -492,6 +492,50 @@ After:  data |> fn1 |> fn2"""
                             }
                             |> Review.Test.whenFixed """module A exposing (..)
 a = (g <| f b) c
+"""
+                        ]
+        , test "should convert from << to <| when used in a plain application call" <|
+            \() ->
+                """module A exposing (..)
+a = (g << f) b
+"""
+                    |> Review.Test.run ruleWithDefaults
+                    |> Review.Test.expectErrors
+                        [ Review.Test.error
+                            { message = "Use <| instead of <<"
+                            , details =
+                                [ "Because of the precedence of operators, using << at this location is the same as using <|."
+                                , "To make it more idiomatic in Elm and generally easier to read, please use <| instead. You may need to remove some parentheses to do this."
+                                , """Here is an example:
+Before: (fn3 << fn2) <| fn1 <| data
+After:   fn3 <| fn2  <| fn1 <| data"""
+                                ]
+                            , under = "<<"
+                            }
+                            |> Review.Test.whenFixed """module A exposing (..)
+a = g <| f b
+"""
+                        ]
+        , test "should convert from << to <| when used in a plain application call, and add parens if there are more arguments" <|
+            \() ->
+                """module A exposing (..)
+a = (g << f) b c
+"""
+                    |> Review.Test.run ruleWithDefaults
+                    |> Review.Test.expectErrors
+                        [ Review.Test.error
+                            { message = "Use <| instead of <<"
+                            , details =
+                                [ "Because of the precedence of operators, using << at this location is the same as using <|."
+                                , "To make it more idiomatic in Elm and generally easier to read, please use <| instead. You may need to remove some parentheses to do this."
+                                , """Here is an example:
+Before: (fn3 << fn2) <| fn1 <| data
+After:   fn3 <| fn2  <| fn1 <| data"""
+                                ]
+                            , under = "<<"
+                            }
+                            |> Review.Test.whenFixed """module A exposing (..)
+a = (g <| f b) c
 """
                         ]
         ]