{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE ViewPatterns, MultiParamTypeClasses, FlexibleInstances, FlexibleContexts #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE TupleSections #-}

module GHC.Util.HsExpr (
    dotApps, lambda
  , simplifyExp, niceLambda, niceLambdaR
  , Brackets(..)
  , rebracket1, appsBracket, transformAppsM, fromApps, apps, universeApps, universeParentExp
  , paren
  , replaceBranches
  , needBracketOld, transformBracketOld, fromParen1
  , allowLeftSection, allowRightSection
) where

import GHC.Hs
import GHC.Types.Basic
import GHC.Types.SrcLoc
import GHC.Data.FastString
import GHC.Types.Name.Reader
import GHC.Types.Name.Occurrence
import GHC.Data.Bag(bagToList)

import GHC.Util.Brackets
import GHC.Util.FreeVars
import GHC.Util.View

import Control.Applicative
import Control.Monad.Trans.Class
import Control.Monad.Trans.State
import Control.Monad.Trans.Writer.CPS

import Data.Data
import Data.Generics.Uniplate.DataOnly
import Data.List.Extra
import Data.Tuple.Extra
import Data.Maybe

import Refact (substVars, toSSA)
import Refact.Types hiding (SrcSpan, Match)
import qualified Refact.Types as R (SrcSpan)

import Language.Haskell.GhclibParserEx.GHC.Hs.Pat
import Language.Haskell.GhclibParserEx.GHC.Hs.Expr
import Language.Haskell.GhclibParserEx.GHC.Hs.ExtendInstances
import Language.Haskell.GhclibParserEx.GHC.Utils.Outputable
import Language.Haskell.GhclibParserEx.GHC.Types.Name.Reader

-- | 'dotApp a b' makes 'a . b'.
dotApp :: LHsExpr GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs
dotApp :: LHsExpr GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs
dotApp LHsExpr GhcPs
x LHsExpr GhcPs
y = HsExpr GhcPs -> LocatedAn AnnListItem (HsExpr GhcPs)
forall a an. a -> LocatedAn an a
noLocA (HsExpr GhcPs -> LocatedAn AnnListItem (HsExpr GhcPs))
-> HsExpr GhcPs -> LocatedAn AnnListItem (HsExpr GhcPs)
forall a b. (a -> b) -> a -> b
$ XOpApp GhcPs
-> LHsExpr GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs -> HsExpr GhcPs
forall p.
XOpApp p -> LHsExpr p -> LHsExpr p -> LHsExpr p -> HsExpr p
OpApp XOpApp GhcPs
forall ann. EpAnn ann
EpAnnNotUsed LHsExpr GhcPs
x (HsExpr GhcPs -> LocatedAn AnnListItem (HsExpr GhcPs)
forall a an. a -> LocatedAn an a
noLocA (HsExpr GhcPs -> LocatedAn AnnListItem (HsExpr GhcPs))
-> HsExpr GhcPs -> LocatedAn AnnListItem (HsExpr GhcPs)
forall a b. (a -> b) -> a -> b
$ XVar GhcPs -> LIdP GhcPs -> HsExpr GhcPs
forall p. XVar p -> LIdP p -> HsExpr p
HsVar NoExtField
XVar GhcPs
noExtField (RdrName -> LocatedAn NameAnn RdrName
forall a an. a -> LocatedAn an a
noLocA (RdrName -> LocatedAn NameAnn RdrName)
-> RdrName -> LocatedAn NameAnn RdrName
forall a b. (a -> b) -> a -> b
$ FastString -> RdrName
mkVarUnqual (String -> FastString
fsLit String
"."))) LHsExpr GhcPs
y

dotApps :: [LHsExpr GhcPs] -> LHsExpr GhcPs
dotApps :: [LHsExpr GhcPs] -> LHsExpr GhcPs
dotApps [] = String -> LocatedAn AnnListItem (HsExpr GhcPs)
forall a. HasCallStack => String -> a
error String
"GHC.Util.HsExpr.dotApps', does not work on an empty list"
dotApps [LHsExpr GhcPs
x] = LHsExpr GhcPs
x
dotApps (LHsExpr GhcPs
x : [LHsExpr GhcPs]
xs) = LHsExpr GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs
dotApp LHsExpr GhcPs
x ([LHsExpr GhcPs] -> LHsExpr GhcPs
dotApps [LHsExpr GhcPs]
xs)

-- | @lambda [p0, p1..pn] body@ makes @\p1 p1 .. pn -> body@
lambda :: [LPat GhcPs] -> LHsExpr GhcPs -> LHsExpr GhcPs
lambda :: [LPat GhcPs] -> LHsExpr GhcPs -> LHsExpr GhcPs
lambda [LPat GhcPs]
vs LHsExpr GhcPs
body = HsExpr GhcPs -> LocatedAn AnnListItem (HsExpr GhcPs)
forall a an. a -> LocatedAn an a
noLocA (HsExpr GhcPs -> LocatedAn AnnListItem (HsExpr GhcPs))
-> HsExpr GhcPs -> LocatedAn AnnListItem (HsExpr GhcPs)
forall a b. (a -> b) -> a -> b
$ XLam GhcPs -> MatchGroup GhcPs (LHsExpr GhcPs) -> HsExpr GhcPs
forall p. XLam p -> MatchGroup p (LHsExpr p) -> HsExpr p
HsLam NoExtField
XLam GhcPs
noExtField (XMG GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
-> XRec GhcPs [LMatch GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))]
-> Origin
-> MatchGroup GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
forall p body.
XMG p body -> XRec p [LMatch p body] -> Origin -> MatchGroup p body
MG NoExtField
XMG GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
noExtField ([LocatedAn
   AnnListItem (Match GhcPs (LocatedAn AnnListItem (HsExpr GhcPs)))]
-> LocatedAn
     AnnList
     [LocatedAn
        AnnListItem (Match GhcPs (LocatedAn AnnListItem (HsExpr GhcPs)))]
forall a an. a -> LocatedAn an a
noLocA [Match GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
-> LocatedAn
     AnnListItem (Match GhcPs (LocatedAn AnnListItem (HsExpr GhcPs)))
forall a an. a -> LocatedAn an a
noLocA (Match GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
 -> LocatedAn
      AnnListItem (Match GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))))
-> Match GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
-> LocatedAn
     AnnListItem (Match GhcPs (LocatedAn AnnListItem (HsExpr GhcPs)))
forall a b. (a -> b) -> a -> b
$ XCMatch GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
-> HsMatchContext (NoGhcTc GhcPs)
-> [LPat GhcPs]
-> GRHSs GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
-> Match GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
forall p body.
XCMatch p body
-> HsMatchContext (NoGhcTc p)
-> [LPat p]
-> GRHSs p body
-> Match p body
Match XCMatch GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
forall ann. EpAnn ann
EpAnnNotUsed HsMatchContext (NoGhcTc GhcPs)
forall p. HsMatchContext p
LambdaExpr [LPat GhcPs]
vs (XCGRHSs GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
-> [LGRHS GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))]
-> HsLocalBinds GhcPs
-> GRHSs GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
forall p body.
XCGRHSs p body -> [LGRHS p body] -> HsLocalBinds p -> GRHSs p body
GRHSs XCGRHSs GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
EpAnnComments
emptyComments [GRHS GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
-> Located (GRHS GhcPs (LocatedAn AnnListItem (HsExpr GhcPs)))
forall e. e -> Located e
noLoc (GRHS GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
 -> Located (GRHS GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))))
-> GRHS GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
-> Located (GRHS GhcPs (LocatedAn AnnListItem (HsExpr GhcPs)))
forall a b. (a -> b) -> a -> b
$ XCGRHS GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
-> [GuardLStmt GhcPs]
-> LocatedAn AnnListItem (HsExpr GhcPs)
-> GRHS GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
forall p body.
XCGRHS p body -> [GuardLStmt p] -> body -> GRHS p body
GRHS XCGRHS GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
forall ann. EpAnn ann
EpAnnNotUsed [] LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
body] (XEmptyLocalBinds GhcPs GhcPs -> HsLocalBinds GhcPs
forall idL idR. XEmptyLocalBinds idL idR -> HsLocalBindsLR idL idR
EmptyLocalBinds NoExtField
XEmptyLocalBinds GhcPs GhcPs
noExtField))]) Origin
Generated)

-- | 'paren e' wraps 'e' in parens if 'e' is non-atomic.
paren :: LHsExpr GhcPs -> LHsExpr GhcPs
paren :: LHsExpr GhcPs -> LHsExpr GhcPs
paren LHsExpr GhcPs
x
  | LocatedAn AnnListItem (HsExpr GhcPs) -> Bool
forall a. Brackets a => a -> Bool
isAtom LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
x  = LHsExpr GhcPs
x
  | Bool
otherwise = LocatedAn AnnListItem (HsExpr GhcPs)
-> LocatedAn AnnListItem (HsExpr GhcPs)
forall a. Brackets a => a -> a
addParen LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
x

universeParentExp :: Data a => a -> [(Maybe (Int, LHsExpr GhcPs), LHsExpr GhcPs)]
universeParentExp :: a -> [(Maybe (Int, LHsExpr GhcPs), LHsExpr GhcPs)]
universeParentExp a
xs = [[(Maybe (Int, LocatedAn AnnListItem (HsExpr GhcPs)),
   LocatedAn AnnListItem (HsExpr GhcPs))]]
-> [(Maybe (Int, LocatedAn AnnListItem (HsExpr GhcPs)),
     LocatedAn AnnListItem (HsExpr GhcPs))]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [(Maybe (Int, LocatedAn AnnListItem (HsExpr GhcPs))
forall a. Maybe a
Nothing, LocatedAn AnnListItem (HsExpr GhcPs)
x) (Maybe (Int, LocatedAn AnnListItem (HsExpr GhcPs)),
 LocatedAn AnnListItem (HsExpr GhcPs))
-> [(Maybe (Int, LocatedAn AnnListItem (HsExpr GhcPs)),
     LocatedAn AnnListItem (HsExpr GhcPs))]
-> [(Maybe (Int, LocatedAn AnnListItem (HsExpr GhcPs)),
     LocatedAn AnnListItem (HsExpr GhcPs))]
forall a. a -> [a] -> [a]
: LocatedAn AnnListItem (HsExpr GhcPs)
-> [(Maybe (Int, LocatedAn AnnListItem (HsExpr GhcPs)),
     LocatedAn AnnListItem (HsExpr GhcPs))]
forall a t. (Enum a, Num a, Data t) => t -> [(Maybe (a, t), t)]
f LocatedAn AnnListItem (HsExpr GhcPs)
x | LocatedAn AnnListItem (HsExpr GhcPs)
x <- a -> [LocatedAn AnnListItem (HsExpr GhcPs)]
forall from to. Biplate from to => from -> [to]
childrenBi a
xs]
    where f :: t -> [(Maybe (a, t), t)]
f t
p = [[(Maybe (a, t), t)]] -> [(Maybe (a, t), t)]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [((a, t) -> Maybe (a, t)
forall a. a -> Maybe a
Just (a
i,t
p), t
c) (Maybe (a, t), t) -> [(Maybe (a, t), t)] -> [(Maybe (a, t), t)]
forall a. a -> [a] -> [a]
: t -> [(Maybe (a, t), t)]
f t
c | (a
i,t
c) <- a -> [t] -> [(a, t)]
forall a b. Enum a => a -> [b] -> [(a, b)]
zipFrom a
0 ([t] -> [(a, t)]) -> [t] -> [(a, t)]
forall a b. (a -> b) -> a -> b
$ t -> [t]
forall on. Uniplate on => on -> [on]
children t
p]


apps :: [LHsExpr GhcPs] -> LHsExpr GhcPs
apps :: [LHsExpr GhcPs] -> LHsExpr GhcPs
apps = (LocatedAn AnnListItem (HsExpr GhcPs)
 -> LocatedAn AnnListItem (HsExpr GhcPs)
 -> LocatedAn AnnListItem (HsExpr GhcPs))
-> [LocatedAn AnnListItem (HsExpr GhcPs)]
-> LocatedAn AnnListItem (HsExpr GhcPs)
forall a. (a -> a -> a) -> [a] -> a
foldl1' LocatedAn AnnListItem (HsExpr GhcPs)
-> LocatedAn AnnListItem (HsExpr GhcPs)
-> LocatedAn AnnListItem (HsExpr GhcPs)
forall p ann an.
(XApp p ~ EpAnn ann) =>
XRec p (HsExpr p) -> XRec p (HsExpr p) -> LocatedAn an (HsExpr p)
mkApp where mkApp :: XRec p (HsExpr p) -> XRec p (HsExpr p) -> LocatedAn an (HsExpr p)
mkApp XRec p (HsExpr p)
x XRec p (HsExpr p)
y = HsExpr p -> LocatedAn an (HsExpr p)
forall a an. a -> LocatedAn an a
noLocA (XApp p -> XRec p (HsExpr p) -> XRec p (HsExpr p) -> HsExpr p
forall p. XApp p -> LHsExpr p -> LHsExpr p -> HsExpr p
HsApp XApp p
forall ann. EpAnn ann
EpAnnNotUsed XRec p (HsExpr p)
x XRec p (HsExpr p)
y)

fromApps :: LHsExpr GhcPs  -> [LHsExpr GhcPs]
fromApps :: LHsExpr GhcPs -> [LHsExpr GhcPs]
fromApps (L _ (HsApp _ x y)) = LHsExpr GhcPs -> [LHsExpr GhcPs]
fromApps LHsExpr GhcPs
x [LocatedAn AnnListItem (HsExpr GhcPs)]
-> [LocatedAn AnnListItem (HsExpr GhcPs)]
-> [LocatedAn AnnListItem (HsExpr GhcPs)]
forall a. [a] -> [a] -> [a]
++ [LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
y]
fromApps LHsExpr GhcPs
x = [LHsExpr GhcPs
x]

childrenApps :: LHsExpr GhcPs -> [LHsExpr GhcPs]
childrenApps :: LHsExpr GhcPs -> [LHsExpr GhcPs]
childrenApps (L _ (HsApp _ x y)) = LHsExpr GhcPs -> [LHsExpr GhcPs]
childrenApps LHsExpr GhcPs
x [LocatedAn AnnListItem (HsExpr GhcPs)]
-> [LocatedAn AnnListItem (HsExpr GhcPs)]
-> [LocatedAn AnnListItem (HsExpr GhcPs)]
forall a. [a] -> [a] -> [a]
++ [LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
y]
childrenApps LHsExpr GhcPs
x = LocatedAn AnnListItem (HsExpr GhcPs)
-> [LocatedAn AnnListItem (HsExpr GhcPs)]
forall on. Uniplate on => on -> [on]
children LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
x

universeApps :: LHsExpr GhcPs -> [LHsExpr GhcPs]
universeApps :: LHsExpr GhcPs -> [LHsExpr GhcPs]
universeApps LHsExpr GhcPs
x = LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
x LocatedAn AnnListItem (HsExpr GhcPs)
-> [LocatedAn AnnListItem (HsExpr GhcPs)]
-> [LocatedAn AnnListItem (HsExpr GhcPs)]
forall a. a -> [a] -> [a]
: (LocatedAn AnnListItem (HsExpr GhcPs)
 -> [LocatedAn AnnListItem (HsExpr GhcPs)])
-> [LocatedAn AnnListItem (HsExpr GhcPs)]
-> [LocatedAn AnnListItem (HsExpr GhcPs)]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap LHsExpr GhcPs -> [LHsExpr GhcPs]
LocatedAn AnnListItem (HsExpr GhcPs)
-> [LocatedAn AnnListItem (HsExpr GhcPs)]
universeApps (LHsExpr GhcPs -> [LHsExpr GhcPs]
childrenApps LHsExpr GhcPs
x)

descendAppsM :: Monad m => (LHsExpr GhcPs  -> m (LHsExpr GhcPs)) -> LHsExpr GhcPs -> m (LHsExpr GhcPs)
descendAppsM :: (LHsExpr GhcPs -> m (LHsExpr GhcPs))
-> LHsExpr GhcPs -> m (LHsExpr GhcPs)
descendAppsM LHsExpr GhcPs -> m (LHsExpr GhcPs)
f (L l (HsApp _ x y)) = (LocatedAn AnnListItem (HsExpr GhcPs)
 -> LocatedAn AnnListItem (HsExpr GhcPs)
 -> LocatedAn AnnListItem (HsExpr GhcPs))
-> m (LocatedAn AnnListItem (HsExpr GhcPs))
-> m (LocatedAn AnnListItem (HsExpr GhcPs))
-> m (LocatedAn AnnListItem (HsExpr GhcPs))
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 (\LocatedAn AnnListItem (HsExpr GhcPs)
x LocatedAn AnnListItem (HsExpr GhcPs)
y -> SrcSpanAnnA -> HsExpr GhcPs -> LocatedAn AnnListItem (HsExpr GhcPs)
forall l e. l -> e -> GenLocated l e
L SrcSpanAnnA
l (HsExpr GhcPs -> LocatedAn AnnListItem (HsExpr GhcPs))
-> HsExpr GhcPs -> LocatedAn AnnListItem (HsExpr GhcPs)
forall a b. (a -> b) -> a -> b
$ XApp GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs -> HsExpr GhcPs
forall p. XApp p -> LHsExpr p -> LHsExpr p -> HsExpr p
HsApp XApp GhcPs
forall ann. EpAnn ann
EpAnnNotUsed LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
x LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
y) ((LHsExpr GhcPs -> m (LHsExpr GhcPs))
-> LHsExpr GhcPs -> m (LHsExpr GhcPs)
forall (m :: * -> *).
Monad m =>
(LHsExpr GhcPs -> m (LHsExpr GhcPs))
-> LHsExpr GhcPs -> m (LHsExpr GhcPs)
descendAppsM LHsExpr GhcPs -> m (LHsExpr GhcPs)
f LHsExpr GhcPs
x) (LHsExpr GhcPs -> m (LHsExpr GhcPs)
f LHsExpr GhcPs
y)
descendAppsM LHsExpr GhcPs -> m (LHsExpr GhcPs)
f LHsExpr GhcPs
x = (LocatedAn AnnListItem (HsExpr GhcPs)
 -> m (LocatedAn AnnListItem (HsExpr GhcPs)))
-> LocatedAn AnnListItem (HsExpr GhcPs)
-> m (LocatedAn AnnListItem (HsExpr GhcPs))
forall on (m :: * -> *).
(Uniplate on, Applicative m) =>
(on -> m on) -> on -> m on
descendM LHsExpr GhcPs -> m (LHsExpr GhcPs)
LocatedAn AnnListItem (HsExpr GhcPs)
-> m (LocatedAn AnnListItem (HsExpr GhcPs))
f LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
x

transformAppsM :: Monad m => (LHsExpr GhcPs -> m (LHsExpr GhcPs)) -> LHsExpr GhcPs -> m (LHsExpr GhcPs)
transformAppsM :: (LHsExpr GhcPs -> m (LHsExpr GhcPs))
-> LHsExpr GhcPs -> m (LHsExpr GhcPs)
transformAppsM LHsExpr GhcPs -> m (LHsExpr GhcPs)
f LHsExpr GhcPs
x = LHsExpr GhcPs -> m (LHsExpr GhcPs)
LocatedAn AnnListItem (HsExpr GhcPs)
-> m (LocatedAn AnnListItem (HsExpr GhcPs))
f (LocatedAn AnnListItem (HsExpr GhcPs)
 -> m (LocatedAn AnnListItem (HsExpr GhcPs)))
-> m (LocatedAn AnnListItem (HsExpr GhcPs))
-> m (LocatedAn AnnListItem (HsExpr GhcPs))
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< (LHsExpr GhcPs -> m (LHsExpr GhcPs))
-> LHsExpr GhcPs -> m (LHsExpr GhcPs)
forall (m :: * -> *).
Monad m =>
(LHsExpr GhcPs -> m (LHsExpr GhcPs))
-> LHsExpr GhcPs -> m (LHsExpr GhcPs)
descendAppsM ((LHsExpr GhcPs -> m (LHsExpr GhcPs))
-> LHsExpr GhcPs -> m (LHsExpr GhcPs)
forall (m :: * -> *).
Monad m =>
(LHsExpr GhcPs -> m (LHsExpr GhcPs))
-> LHsExpr GhcPs -> m (LHsExpr GhcPs)
transformAppsM LHsExpr GhcPs -> m (LHsExpr GhcPs)
f) LHsExpr GhcPs
x

descendIndex :: Data a => (Int -> a -> a) -> a -> a
descendIndex :: (Int -> a -> a) -> a -> a
descendIndex Int -> a -> a
f = (a, ()) -> a
forall a b. (a, b) -> a
fst ((a, ()) -> a) -> (a -> (a, ())) -> a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> a -> Writer () a) -> a -> (a, ())
forall a w.
(Data a, Monoid w) =>
(Int -> a -> Writer w a) -> a -> (a, w)
descendIndex' (\Int
x a
a -> (a, ()) -> Writer () a
forall w (m :: * -> *) a.
(Monoid w, Monad m) =>
(a, w) -> WriterT w m a
writer (Int -> a -> a
f Int
x a
a, ()))

descendIndex' :: (Data a, Monoid w) => (Int -> a -> Writer w a) -> a -> (a, w)
descendIndex' :: (Int -> a -> Writer w a) -> a -> (a, w)
descendIndex' Int -> a -> Writer w a
f a
x = Writer w a -> (a, w)
forall w a. Monoid w => Writer w a -> (a, w)
runWriter (Writer w a -> (a, w)) -> Writer w a -> (a, w)
forall a b. (a -> b) -> a -> b
$ (StateT Int (WriterT w Identity) a -> Int -> Writer w a)
-> Int -> StateT Int (WriterT w Identity) a -> Writer w a
forall a b c. (a -> b -> c) -> b -> a -> c
flip StateT Int (WriterT w Identity) a -> Int -> Writer w a
forall (m :: * -> *) s a. Monad m => StateT s m a -> s -> m a
evalStateT Int
0 (StateT Int (WriterT w Identity) a -> Writer w a)
-> StateT Int (WriterT w Identity) a -> Writer w a
forall a b. (a -> b) -> a -> b
$ ((a -> StateT Int (WriterT w Identity) a)
 -> a -> StateT Int (WriterT w Identity) a)
-> a
-> (a -> StateT Int (WriterT w Identity) a)
-> StateT Int (WriterT w Identity) a
forall a b c. (a -> b -> c) -> b -> a -> c
flip (a -> StateT Int (WriterT w Identity) a)
-> a -> StateT Int (WriterT w Identity) a
forall on (m :: * -> *).
(Uniplate on, Applicative m) =>
(on -> m on) -> on -> m on
descendM a
x ((a -> StateT Int (WriterT w Identity) a)
 -> StateT Int (WriterT w Identity) a)
-> (a -> StateT Int (WriterT w Identity) a)
-> StateT Int (WriterT w Identity) a
forall a b. (a -> b) -> a -> b
$ \a
y -> do
    Int
i <- StateT Int (WriterT w Identity) Int
forall (m :: * -> *) s. Monad m => StateT s m s
get
    (Int -> Int) -> StateT Int (WriterT w Identity) ()
forall (m :: * -> *) s. Monad m => (s -> s) -> StateT s m ()
modify (Int -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1)
    Writer w a -> StateT Int (WriterT w Identity) a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (Writer w a -> StateT Int (WriterT w Identity) a)
-> Writer w a -> StateT Int (WriterT w Identity) a
forall a b. (a -> b) -> a -> b
$ Int -> a -> Writer w a
f Int
i a
y

--  There are differences in pretty-printing between GHC and HSE. This
--  version never removes brackets.
descendBracket :: (LHsExpr GhcPs -> (Bool, LHsExpr GhcPs)) -> LHsExpr GhcPs -> LHsExpr GhcPs
descendBracket :: (LHsExpr GhcPs -> (Bool, LHsExpr GhcPs))
-> LHsExpr GhcPs -> LHsExpr GhcPs
descendBracket LHsExpr GhcPs -> (Bool, LHsExpr GhcPs)
op LHsExpr GhcPs
x = (Int
 -> LocatedAn AnnListItem (HsExpr GhcPs)
 -> LocatedAn AnnListItem (HsExpr GhcPs))
-> LocatedAn AnnListItem (HsExpr GhcPs)
-> LocatedAn AnnListItem (HsExpr GhcPs)
forall a. Data a => (Int -> a -> a) -> a -> a
descendIndex Int
-> LocatedAn AnnListItem (HsExpr GhcPs)
-> LocatedAn AnnListItem (HsExpr GhcPs)
g LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
x
    where
        g :: Int
-> LocatedAn AnnListItem (HsExpr GhcPs)
-> LocatedAn AnnListItem (HsExpr GhcPs)
g Int
i LocatedAn AnnListItem (HsExpr GhcPs)
y = if Bool
a then Int
-> LocatedAn AnnListItem (HsExpr GhcPs)
-> LocatedAn AnnListItem (HsExpr GhcPs)
f Int
i LocatedAn AnnListItem (HsExpr GhcPs)
b else LocatedAn AnnListItem (HsExpr GhcPs)
b
            where (Bool
a, LocatedAn AnnListItem (HsExpr GhcPs)
b) = LHsExpr GhcPs -> (Bool, LHsExpr GhcPs)
op LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
y
        f :: Int
-> LocatedAn AnnListItem (HsExpr GhcPs)
-> LocatedAn AnnListItem (HsExpr GhcPs)
f Int
i LocatedAn AnnListItem (HsExpr GhcPs)
y = if Int
-> LocatedAn AnnListItem (HsExpr GhcPs)
-> LocatedAn AnnListItem (HsExpr GhcPs)
-> Bool
forall a. Brackets a => Int -> a -> a -> Bool
needBracket Int
i LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
x LocatedAn AnnListItem (HsExpr GhcPs)
y then LocatedAn AnnListItem (HsExpr GhcPs)
-> LocatedAn AnnListItem (HsExpr GhcPs)
forall a. Brackets a => a -> a
addParen LocatedAn AnnListItem (HsExpr GhcPs)
y else LocatedAn AnnListItem (HsExpr GhcPs)
y

-- Add brackets as suggested 'needBracket at 1-level of depth.
rebracket1 :: LHsExpr GhcPs -> LHsExpr GhcPs
rebracket1 :: LHsExpr GhcPs -> LHsExpr GhcPs
rebracket1 = (LHsExpr GhcPs -> (Bool, LHsExpr GhcPs))
-> LHsExpr GhcPs -> LHsExpr GhcPs
descendBracket (Bool
True, )

-- A list of application, with any necessary brackets.
appsBracket :: [LHsExpr GhcPs] -> LHsExpr GhcPs
appsBracket :: [LHsExpr GhcPs] -> LHsExpr GhcPs
appsBracket = (LocatedAn AnnListItem (HsExpr GhcPs)
 -> LocatedAn AnnListItem (HsExpr GhcPs)
 -> LocatedAn AnnListItem (HsExpr GhcPs))
-> [LocatedAn AnnListItem (HsExpr GhcPs)]
-> LocatedAn AnnListItem (HsExpr GhcPs)
forall (t :: * -> *) a. Foldable t => (a -> a -> a) -> t a -> a
foldl1 LocatedAn AnnListItem (HsExpr GhcPs)
-> LocatedAn AnnListItem (HsExpr GhcPs)
-> LocatedAn AnnListItem (HsExpr GhcPs)
mkApp
  where mkApp :: LocatedAn AnnListItem (HsExpr GhcPs)
-> LocatedAn AnnListItem (HsExpr GhcPs) -> LHsExpr GhcPs
mkApp LocatedAn AnnListItem (HsExpr GhcPs)
x LocatedAn AnnListItem (HsExpr GhcPs)
y = LHsExpr GhcPs -> LHsExpr GhcPs
rebracket1 (HsExpr GhcPs -> LocatedAn AnnListItem (HsExpr GhcPs)
forall a an. a -> LocatedAn an a
noLocA (HsExpr GhcPs -> LocatedAn AnnListItem (HsExpr GhcPs))
-> HsExpr GhcPs -> LocatedAn AnnListItem (HsExpr GhcPs)
forall a b. (a -> b) -> a -> b
$ XApp GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs -> HsExpr GhcPs
forall p. XApp p -> LHsExpr p -> LHsExpr p -> HsExpr p
HsApp XApp GhcPs
forall ann. EpAnn ann
EpAnnNotUsed LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
x LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
y)

simplifyExp :: LHsExpr GhcPs -> LHsExpr GhcPs
-- Replace appliciations 'f $ x' with 'f (x)'.
simplifyExp :: LHsExpr GhcPs -> LHsExpr GhcPs
simplifyExp (L l (OpApp _ x op y)) | LHsExpr GhcPs -> Bool
isDol LHsExpr GhcPs
op = SrcSpanAnnA -> HsExpr GhcPs -> LocatedAn AnnListItem (HsExpr GhcPs)
forall l e. l -> e -> GenLocated l e
L SrcSpanAnnA
l (XApp GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs -> HsExpr GhcPs
forall p. XApp p -> LHsExpr p -> LHsExpr p -> HsExpr p
HsApp XApp GhcPs
forall ann. EpAnn ann
EpAnnNotUsed LHsExpr GhcPs
x (HsExpr GhcPs -> LocatedAn AnnListItem (HsExpr GhcPs)
forall a an. a -> LocatedAn an a
noLocA (XPar GhcPs -> LHsExpr GhcPs -> HsExpr GhcPs
forall p. XPar p -> LHsExpr p -> HsExpr p
HsPar XPar GhcPs
forall ann. EpAnn ann
EpAnnNotUsed LHsExpr GhcPs
y)))
simplifyExp e :: LHsExpr GhcPs
e@(L _ (HsLet _ ((HsValBinds _ (ValBinds _ binds []))) z)) =
  -- An expression of the form, 'let x = y in z'.
  case Bag (GenLocated SrcSpanAnnA (HsBindLR GhcPs GhcPs))
-> [GenLocated SrcSpanAnnA (HsBindLR GhcPs GhcPs)]
forall a. Bag a -> [a]
bagToList LHsBindsLR GhcPs GhcPs
Bag (GenLocated SrcSpanAnnA (HsBindLR GhcPs GhcPs))
binds of
    [L SrcSpanAnnA
_ (FunBind XFunBind GhcPs GhcPs
_ LIdP GhcPs
_ (MG XMG GhcPs (LHsExpr GhcPs)
_ (L _ [L _ (Match _(FunRhs (L _ x) _ _) [] (GRHSs _[L _ (GRHS _ [] y)] ((EmptyLocalBinds _))))]) Origin
_) [CoreTickish]
_)]
         -- If 'x' is not in the free variables of 'y', beta-reduce to
         -- 'z[(y)/x]'.
      | RdrName -> String
occNameStr RdrName
x String -> [String] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` LocatedAn AnnListItem (HsExpr GhcPs) -> [String]
forall a. FreeVars a => a -> [String]
vars LocatedAn AnnListItem (HsExpr GhcPs)
y Bool -> Bool -> Bool
&& [()] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [() | Unqual OccName
a <- LocatedAn AnnListItem (HsExpr GhcPs) -> [RdrName]
forall from to. Biplate from to => from -> [to]
universeBi LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
z, OccName
a OccName -> OccName -> Bool
forall a. Eq a => a -> a -> Bool
== RdrName -> OccName
rdrNameOcc RdrName
x] Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
1 ->
          (LocatedAn AnnListItem (HsExpr GhcPs)
 -> LocatedAn AnnListItem (HsExpr GhcPs))
-> LocatedAn AnnListItem (HsExpr GhcPs)
-> LocatedAn AnnListItem (HsExpr GhcPs)
forall on. Uniplate on => (on -> on) -> on -> on
transform LocatedAn AnnListItem (HsExpr GhcPs)
-> LocatedAn AnnListItem (HsExpr GhcPs)
f LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
z
          where f :: LocatedAn AnnListItem (HsExpr GhcPs)
-> LocatedAn AnnListItem (HsExpr GhcPs)
f (LocatedAn AnnListItem (HsExpr GhcPs) -> Var_
forall a b. View a b => a -> b
view -> Var_ String
x') | RdrName -> String
occNameStr RdrName
x String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
x' = LHsExpr GhcPs -> LHsExpr GhcPs
paren LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
y
                f LocatedAn AnnListItem (HsExpr GhcPs)
x = LocatedAn AnnListItem (HsExpr GhcPs)
x
    [GenLocated SrcSpanAnnA (HsBindLR GhcPs GhcPs)]
_ -> LHsExpr GhcPs
e
simplifyExp LHsExpr GhcPs
e = LHsExpr GhcPs
e

-- Rewrite '($) . b' as 'b'.
niceDotApp :: LHsExpr GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs
niceDotApp :: LHsExpr GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs
niceDotApp (L _ (HsVar _ (L _ r))) LHsExpr GhcPs
b | RdrName -> String
occNameStr RdrName
r String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"$" = LHsExpr GhcPs
b
niceDotApp LHsExpr GhcPs
a LHsExpr GhcPs
b = LHsExpr GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs
dotApp LHsExpr GhcPs
a LHsExpr GhcPs
b

-- Generate a lambda expression but prettier if possible.
niceLambda :: [String] -> LHsExpr GhcPs -> LHsExpr GhcPs
niceLambda :: [String] -> LHsExpr GhcPs -> LHsExpr GhcPs
niceLambda [String]
ss LHsExpr GhcPs
e = (LocatedAn AnnListItem (HsExpr GhcPs),
 SrcSpan -> [Refactoring SrcSpan])
-> LocatedAn AnnListItem (HsExpr GhcPs)
forall a b. (a, b) -> a
fst ([String]
-> LHsExpr GhcPs
-> (LHsExpr GhcPs, SrcSpan -> [Refactoring SrcSpan])
niceLambdaR [String]
ss LHsExpr GhcPs
e)-- We don't support refactorings yet.

allowRightSection :: String -> Bool
allowRightSection :: String -> Bool
allowRightSection String
x = String
x String -> [String] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` [String
"-",String
"#"]
allowLeftSection :: String -> Bool
allowLeftSection :: String -> Bool
allowLeftSection String
x = String
x String -> String -> Bool
forall a. Eq a => a -> a -> Bool
/= String
"#"

-- Implementation. Try to produce special forms (e.g. sections,
-- compositions) where we can.
niceLambdaR :: [String]
            -> LHsExpr GhcPs
            -> (LHsExpr GhcPs, R.SrcSpan -> [Refactoring R.SrcSpan])
-- Rewrite @\ -> e@ as @e@
-- These are encountered as recursive calls.
niceLambdaR :: [String]
-> LHsExpr GhcPs
-> (LHsExpr GhcPs, SrcSpan -> [Refactoring SrcSpan])
niceLambdaR [String]
xs (SimpleLambda [] x) = [String]
-> LHsExpr GhcPs
-> (LHsExpr GhcPs, SrcSpan -> [Refactoring SrcSpan])
niceLambdaR [String]
xs LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
x

-- Rewrite @\xs -> (e)@ as @\xs -> e@.
niceLambdaR [String]
xs (L _ (HsPar _ x)) = [String]
-> LHsExpr GhcPs
-> (LHsExpr GhcPs, SrcSpan -> [Refactoring SrcSpan])
niceLambdaR [String]
xs LHsExpr GhcPs
x

-- @\vs v -> ($) e v@ ==> @\vs -> e@
-- @\vs v -> e $ v@ ==> @\vs -> e@
niceLambdaR ([String] -> Maybe ([String], String)
forall a. [a] -> Maybe ([a], a)
unsnoc -> Just ([String]
vs, String
v)) (LHsExpr GhcPs -> App2
forall a b. View a b => a -> b
view -> App2 LocatedAn AnnListItem (HsExpr GhcPs)
f LocatedAn AnnListItem (HsExpr GhcPs)
e (LocatedAn AnnListItem (HsExpr GhcPs) -> Var_
forall a b. View a b => a -> b
view -> Var_ String
v'))
  | LHsExpr GhcPs -> Bool
isDol LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
f
  , String
v String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
v'
  , LocatedAn AnnListItem (HsExpr GhcPs) -> [String]
forall a. FreeVars a => a -> [String]
vars LocatedAn AnnListItem (HsExpr GhcPs)
e [String] -> [String] -> Bool
forall a. Eq a => [a] -> [a] -> Bool
`disjoint` [String
v]
  = [String]
-> LHsExpr GhcPs
-> (LHsExpr GhcPs, SrcSpan -> [Refactoring SrcSpan])
niceLambdaR [String]
vs LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
e

-- @\v -> thing + v@ ==> @\v -> (thing +)@  (heuristic: @v@ must be a single
-- lexeme, or it all gets too complex)
niceLambdaR [String
v] (L _ (OpApp _ e f (view -> Var_ v')))
  | LHsExpr GhcPs -> Bool
isLexeme LHsExpr GhcPs
e
  , String
v String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
v'
  , LocatedAn AnnListItem (HsExpr GhcPs) -> [String]
forall a. FreeVars a => a -> [String]
vars LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
e [String] -> [String] -> Bool
forall a. Eq a => [a] -> [a] -> Bool
`disjoint` [String
v]
  , L _ (HsVar _ (L _ fname)) <- LHsExpr GhcPs
f
  , OccName -> Bool
isSymOcc (OccName -> Bool) -> OccName -> Bool
forall a b. (a -> b) -> a -> b
$ RdrName -> OccName
rdrNameOcc RdrName
fname
  = let res :: LocatedAn AnnListItem (HsExpr GhcPs)
res = HsExpr GhcPs -> LocatedAn AnnListItem (HsExpr GhcPs)
forall a an. a -> LocatedAn an a
noLocA (HsExpr GhcPs -> LocatedAn AnnListItem (HsExpr GhcPs))
-> HsExpr GhcPs -> LocatedAn AnnListItem (HsExpr GhcPs)
forall a b. (a -> b) -> a -> b
$ XPar GhcPs -> LHsExpr GhcPs -> HsExpr GhcPs
forall p. XPar p -> LHsExpr p -> HsExpr p
HsPar XPar GhcPs
forall ann. EpAnn ann
EpAnnNotUsed (LHsExpr GhcPs -> HsExpr GhcPs) -> LHsExpr GhcPs -> HsExpr GhcPs
forall a b. (a -> b) -> a -> b
$ HsExpr GhcPs -> LocatedAn AnnListItem (HsExpr GhcPs)
forall a an. a -> LocatedAn an a
noLocA (HsExpr GhcPs -> LocatedAn AnnListItem (HsExpr GhcPs))
-> HsExpr GhcPs -> LocatedAn AnnListItem (HsExpr GhcPs)
forall a b. (a -> b) -> a -> b
$ XSectionL GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs -> HsExpr GhcPs
forall p. XSectionL p -> LHsExpr p -> LHsExpr p -> HsExpr p
SectionL XSectionL GhcPs
forall ann. EpAnn ann
EpAnnNotUsed LHsExpr GhcPs
e LHsExpr GhcPs
f
     in (LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
res, \SrcSpan
s -> [RType
-> SrcSpan -> [(String, SrcSpan)] -> String -> Refactoring SrcSpan
forall a. RType -> a -> [(String, a)] -> String -> Refactoring a
Replace RType
Expr SrcSpan
s [] (LocatedAn AnnListItem (HsExpr GhcPs) -> String
forall a. Outputable a => a -> String
unsafePrettyPrint LocatedAn AnnListItem (HsExpr GhcPs)
res)])

-- @\vs v -> f x v@ ==> @\vs -> f x@
niceLambdaR ([String] -> Maybe ([String], String)
forall a. [a] -> Maybe ([a], a)
unsnoc -> Just ([String]
vs, String
v)) (L _ (HsApp _ f (view -> Var_ v')))
  | String
v String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
v'
  , LocatedAn AnnListItem (HsExpr GhcPs) -> [String]
forall a. FreeVars a => a -> [String]
vars LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
f [String] -> [String] -> Bool
forall a. Eq a => [a] -> [a] -> Bool
`disjoint` [String
v]
  = [String]
-> LHsExpr GhcPs
-> (LHsExpr GhcPs, SrcSpan -> [Refactoring SrcSpan])
niceLambdaR [String]
vs LHsExpr GhcPs
f

-- @\vs v -> (v `f`)@ ==> @\vs -> f@
niceLambdaR ([String] -> Maybe ([String], String)
forall a. [a] -> Maybe ([a], a)
unsnoc -> Just ([String]
vs, String
v)) (L _ (SectionL _ (view -> Var_ v') f))
  | String
v String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
v' = [String]
-> LHsExpr GhcPs
-> (LHsExpr GhcPs, SrcSpan -> [Refactoring SrcSpan])
niceLambdaR [String]
vs LHsExpr GhcPs
f

-- Strip one variable pattern from the end of a lambdas match, and place it in our list of factoring variables.
niceLambdaR [String]
xs (SimpleLambda ((view -> PVar_ v):vs) x)
  | String
v String -> [String] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` [String]
xs = [String]
-> LHsExpr GhcPs
-> (LHsExpr GhcPs, SrcSpan -> [Refactoring SrcSpan])
niceLambdaR ([String]
xs[String] -> [String] -> [String]
forall a. [a] -> [a] -> [a]
++[String
v]) (LHsExpr GhcPs
 -> (LHsExpr GhcPs, SrcSpan -> [Refactoring SrcSpan]))
-> LHsExpr GhcPs
-> (LHsExpr GhcPs, SrcSpan -> [Refactoring SrcSpan])
forall a b. (a -> b) -> a -> b
$ [LPat GhcPs] -> LHsExpr GhcPs -> LHsExpr GhcPs
lambda [LPat GhcPs]
[LocatedA (Pat GhcPs)]
vs LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
x

-- Rewrite @\x -> x + a@ as @(+ a)@ (heuristic: @a@ must be a single
-- lexeme, or it all gets too complex).
niceLambdaR [String
x] (LHsExpr GhcPs -> App2
forall a b. View a b => a -> b
view -> App2 op :: LocatedAn AnnListItem (HsExpr GhcPs)
op@(L SrcSpanAnnA
_ (HsVar XVar GhcPs
_ (L _ tag))) LocatedAn AnnListItem (HsExpr GhcPs)
l LocatedAn AnnListItem (HsExpr GhcPs)
r)
  | LHsExpr GhcPs -> Bool
isLexeme LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
r, LocatedAn AnnListItem (HsExpr GhcPs) -> Var_
forall a b. View a b => a -> b
view LocatedAn AnnListItem (HsExpr GhcPs)
l Var_ -> Var_ -> Bool
forall a. Eq a => a -> a -> Bool
== String -> Var_
Var_ String
x, String
x String -> [String] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` LocatedAn AnnListItem (HsExpr GhcPs) -> [String]
forall a. FreeVars a => a -> [String]
vars LocatedAn AnnListItem (HsExpr GhcPs)
r, String -> Bool
allowRightSection (RdrName -> String
occNameStr RdrName
tag) =
      let e :: LHsExpr GhcPs
e = LHsExpr GhcPs -> LHsExpr GhcPs
rebracket1 (LHsExpr GhcPs -> LHsExpr GhcPs) -> LHsExpr GhcPs -> LHsExpr GhcPs
forall a b. (a -> b) -> a -> b
$ LocatedAn AnnListItem (HsExpr GhcPs)
-> LocatedAn AnnListItem (HsExpr GhcPs)
forall a. Brackets a => a -> a
addParen (HsExpr GhcPs -> LocatedAn AnnListItem (HsExpr GhcPs)
forall a an. a -> LocatedAn an a
noLocA (HsExpr GhcPs -> LocatedAn AnnListItem (HsExpr GhcPs))
-> HsExpr GhcPs -> LocatedAn AnnListItem (HsExpr GhcPs)
forall a b. (a -> b) -> a -> b
$ XSectionR GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs -> HsExpr GhcPs
forall p. XSectionR p -> LHsExpr p -> LHsExpr p -> HsExpr p
SectionR XSectionR GhcPs
forall ann. EpAnn ann
EpAnnNotUsed LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
op LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
r)
      in (LHsExpr GhcPs
e, \SrcSpan
s -> [RType
-> SrcSpan -> [(String, SrcSpan)] -> String -> Refactoring SrcSpan
forall a. RType -> a -> [(String, a)] -> String -> Refactoring a
Replace RType
Expr SrcSpan
s [] (LocatedAn AnnListItem (HsExpr GhcPs) -> String
forall a. Outputable a => a -> String
unsafePrettyPrint LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
e)])
-- Rewrite (1) @\x -> f (b x)@ as @f . b@, (2) @\x -> f $ b x@ as @f . b@.
niceLambdaR [String
x] LHsExpr GhcPs
y
  | Just (LHsExpr GhcPs
z, [LHsExpr GhcPs]
subts) <- LHsExpr GhcPs -> Maybe (LHsExpr GhcPs, [LHsExpr GhcPs])
factor LHsExpr GhcPs
y, String
x String -> [String] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` LocatedAn AnnListItem (HsExpr GhcPs) -> [String]
forall a. FreeVars a => a -> [String]
vars LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
z = (LHsExpr GhcPs
z, \SrcSpan
s -> [[LHsExpr GhcPs] -> SrcSpan -> Refactoring SrcSpan
mkRefact [LHsExpr GhcPs]
subts SrcSpan
s])
  where
    -- Factor the expression with respect to x.
    factor :: LHsExpr GhcPs -> Maybe (LHsExpr GhcPs, [LHsExpr GhcPs])
    factor :: LHsExpr GhcPs -> Maybe (LHsExpr GhcPs, [LHsExpr GhcPs])
factor (L _ (HsApp _ ini lst)) | LocatedAn AnnListItem (HsExpr GhcPs) -> Var_
forall a b. View a b => a -> b
view LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
lst Var_ -> Var_ -> Bool
forall a. Eq a => a -> a -> Bool
== String -> Var_
Var_ String
x = (LocatedAn AnnListItem (HsExpr GhcPs),
 [LocatedAn AnnListItem (HsExpr GhcPs)])
-> Maybe
     (LocatedAn AnnListItem (HsExpr GhcPs),
      [LocatedAn AnnListItem (HsExpr GhcPs)])
forall a. a -> Maybe a
Just (LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
ini, [LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
ini])
    factor (L _ (HsApp _ ini lst)) | Just (LHsExpr GhcPs
z, [LHsExpr GhcPs]
ss) <- LHsExpr GhcPs -> Maybe (LHsExpr GhcPs, [LHsExpr GhcPs])
factor LHsExpr GhcPs
lst
      = let r :: LHsExpr GhcPs
r = LHsExpr GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs
niceDotApp LHsExpr GhcPs
ini LHsExpr GhcPs
z
        in if LocatedAn AnnListItem (HsExpr GhcPs)
-> LocatedAn AnnListItem (HsExpr GhcPs) -> Bool
forall a. Data a => a -> a -> Bool
astEq LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
r LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
z then (LocatedAn AnnListItem (HsExpr GhcPs),
 [LocatedAn AnnListItem (HsExpr GhcPs)])
-> Maybe
     (LocatedAn AnnListItem (HsExpr GhcPs),
      [LocatedAn AnnListItem (HsExpr GhcPs)])
forall a. a -> Maybe a
Just (LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
r, [LHsExpr GhcPs]
[LocatedAn AnnListItem (HsExpr GhcPs)]
ss) else (LocatedAn AnnListItem (HsExpr GhcPs),
 [LocatedAn AnnListItem (HsExpr GhcPs)])
-> Maybe
     (LocatedAn AnnListItem (HsExpr GhcPs),
      [LocatedAn AnnListItem (HsExpr GhcPs)])
forall a. a -> Maybe a
Just (LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
r, LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
ini LocatedAn AnnListItem (HsExpr GhcPs)
-> [LocatedAn AnnListItem (HsExpr GhcPs)]
-> [LocatedAn AnnListItem (HsExpr GhcPs)]
forall a. a -> [a] -> [a]
: [LHsExpr GhcPs]
[LocatedAn AnnListItem (HsExpr GhcPs)]
ss)
    factor (L _ (OpApp _ y op (factor -> Just (z, ss))))| LHsExpr GhcPs -> Bool
isDol LHsExpr GhcPs
op
      = let r :: LHsExpr GhcPs
r = LHsExpr GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs
niceDotApp LHsExpr GhcPs
y LHsExpr GhcPs
z
        in if LocatedAn AnnListItem (HsExpr GhcPs)
-> LocatedAn AnnListItem (HsExpr GhcPs) -> Bool
forall a. Data a => a -> a -> Bool
astEq LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
r LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
z then (LocatedAn AnnListItem (HsExpr GhcPs),
 [LocatedAn AnnListItem (HsExpr GhcPs)])
-> Maybe
     (LocatedAn AnnListItem (HsExpr GhcPs),
      [LocatedAn AnnListItem (HsExpr GhcPs)])
forall a. a -> Maybe a
Just (LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
r, [LHsExpr GhcPs]
[LocatedAn AnnListItem (HsExpr GhcPs)]
ss) else (LocatedAn AnnListItem (HsExpr GhcPs),
 [LocatedAn AnnListItem (HsExpr GhcPs)])
-> Maybe
     (LocatedAn AnnListItem (HsExpr GhcPs),
      [LocatedAn AnnListItem (HsExpr GhcPs)])
forall a. a -> Maybe a
Just (LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
r, LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
y LocatedAn AnnListItem (HsExpr GhcPs)
-> [LocatedAn AnnListItem (HsExpr GhcPs)]
-> [LocatedAn AnnListItem (HsExpr GhcPs)]
forall a. a -> [a] -> [a]
: [LHsExpr GhcPs]
[LocatedAn AnnListItem (HsExpr GhcPs)]
ss)
    factor (L _ (HsPar _ y@(L _ HsApp{}))) = LHsExpr GhcPs -> Maybe (LHsExpr GhcPs, [LHsExpr GhcPs])
factor LHsExpr GhcPs
y
    factor LHsExpr GhcPs
_ = Maybe (LHsExpr GhcPs, [LHsExpr GhcPs])
forall a. Maybe a
Nothing
    mkRefact :: [LHsExpr GhcPs] -> R.SrcSpan -> Refactoring R.SrcSpan
    mkRefact :: [LHsExpr GhcPs] -> SrcSpan -> Refactoring SrcSpan
mkRefact [LHsExpr GhcPs]
subts SrcSpan
s =
      let tempSubts :: [(String, SrcSpan)]
tempSubts = (String
 -> LocatedAn AnnListItem (HsExpr GhcPs) -> (String, SrcSpan))
-> [String]
-> [LocatedAn AnnListItem (HsExpr GhcPs)]
-> [(String, SrcSpan)]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith (\String
a LocatedAn AnnListItem (HsExpr GhcPs)
b -> (String
a, LocatedAn AnnListItem (HsExpr GhcPs) -> SrcSpan
forall a e. GenLocated (SrcSpanAnn' a) e -> SrcSpan
toSSA LocatedAn AnnListItem (HsExpr GhcPs)
b)) [String]
substVars [LHsExpr GhcPs]
[LocatedAn AnnListItem (HsExpr GhcPs)]
subts
          template :: LHsExpr GhcPs
template = [LHsExpr GhcPs] -> LHsExpr GhcPs
dotApps (((String, SrcSpan) -> LocatedAn AnnListItem (HsExpr GhcPs))
-> [(String, SrcSpan)] -> [LocatedAn AnnListItem (HsExpr GhcPs)]
forall a b. (a -> b) -> [a] -> [b]
map (String -> LHsExpr GhcPs
String -> LocatedAn AnnListItem (HsExpr GhcPs)
strToVar (String -> LocatedAn AnnListItem (HsExpr GhcPs))
-> ((String, SrcSpan) -> String)
-> (String, SrcSpan)
-> LocatedAn AnnListItem (HsExpr GhcPs)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (String, SrcSpan) -> String
forall a b. (a, b) -> a
fst) [(String, SrcSpan)]
tempSubts)
      in RType
-> SrcSpan -> [(String, SrcSpan)] -> String -> Refactoring SrcSpan
forall a. RType -> a -> [(String, a)] -> String -> Refactoring a
Replace RType
Expr SrcSpan
s [(String, SrcSpan)]
tempSubts (LocatedAn AnnListItem (HsExpr GhcPs) -> String
forall a. Outputable a => a -> String
unsafePrettyPrint LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
template)
-- Rewrite @\x y -> x + y@ as @(+)@.
niceLambdaR [String
x,String
y] (L _ (OpApp _ (view -> Var_ x1) op@(L _ HsVar {}) (view -> Var_ y1)))
    | String
x String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
x1, String
y String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
y1, LocatedAn AnnListItem (HsExpr GhcPs) -> [String]
forall a. FreeVars a => a -> [String]
vars LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
op [String] -> [String] -> Bool
forall a. Eq a => [a] -> [a] -> Bool
`disjoint` [String
x, String
y] = (LHsExpr GhcPs
op, \SrcSpan
s -> [RType
-> SrcSpan -> [(String, SrcSpan)] -> String -> Refactoring SrcSpan
forall a. RType -> a -> [(String, a)] -> String -> Refactoring a
Replace RType
Expr SrcSpan
s [] (LocatedAn AnnListItem (HsExpr GhcPs) -> String
forall a. Outputable a => a -> String
unsafePrettyPrint LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
op)])
-- Rewrite @\x y -> f y x@ as @flip f@.
niceLambdaR [String
x, String
y] (LHsExpr GhcPs -> App2
forall a b. View a b => a -> b
view -> App2 LocatedAn AnnListItem (HsExpr GhcPs)
op (LocatedAn AnnListItem (HsExpr GhcPs) -> Var_
forall a b. View a b => a -> b
view -> Var_ String
y1) (LocatedAn AnnListItem (HsExpr GhcPs) -> Var_
forall a b. View a b => a -> b
view -> Var_ String
x1))
  | String
x String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
x1, String
y String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
y1, LocatedAn AnnListItem (HsExpr GhcPs) -> [String]
forall a. FreeVars a => a -> [String]
vars LocatedAn AnnListItem (HsExpr GhcPs)
op [String] -> [String] -> Bool
forall a. Eq a => [a] -> [a] -> Bool
`disjoint` [String
x, String
y] =
      ( LHsExpr GhcPs -> LHsExpr GhcPs
gen LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
op
      , \SrcSpan
s -> [RType
-> SrcSpan -> [(String, SrcSpan)] -> String -> Refactoring SrcSpan
forall a. RType -> a -> [(String, a)] -> String -> Refactoring a
Replace RType
Expr SrcSpan
s [(String
"x", LocatedAn AnnListItem (HsExpr GhcPs) -> SrcSpan
forall a e. GenLocated (SrcSpanAnn' a) e -> SrcSpan
toSSA LocatedAn AnnListItem (HsExpr GhcPs)
op)] (LocatedAn AnnListItem (HsExpr GhcPs) -> String
forall a. Outputable a => a -> String
unsafePrettyPrint (LocatedAn AnnListItem (HsExpr GhcPs) -> String)
-> LocatedAn AnnListItem (HsExpr GhcPs) -> String
forall a b. (a -> b) -> a -> b
$ LHsExpr GhcPs -> LHsExpr GhcPs
gen (String -> LHsExpr GhcPs
strToVar String
"x"))]
      )
  where
    gen :: LHsExpr GhcPs -> LHsExpr GhcPs
    gen :: LHsExpr GhcPs -> LHsExpr GhcPs
gen = HsExpr GhcPs -> LocatedAn AnnListItem (HsExpr GhcPs)
forall a an. a -> LocatedAn an a
noLocA (HsExpr GhcPs -> LocatedAn AnnListItem (HsExpr GhcPs))
-> (LocatedAn AnnListItem (HsExpr GhcPs) -> HsExpr GhcPs)
-> LocatedAn AnnListItem (HsExpr GhcPs)
-> LocatedAn AnnListItem (HsExpr GhcPs)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. XApp GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs -> HsExpr GhcPs
forall p. XApp p -> LHsExpr p -> LHsExpr p -> HsExpr p
HsApp XApp GhcPs
forall ann. EpAnn ann
EpAnnNotUsed (String -> LHsExpr GhcPs
strToVar String
"flip")
        (LocatedAn AnnListItem (HsExpr GhcPs) -> HsExpr GhcPs)
-> (LocatedAn AnnListItem (HsExpr GhcPs)
    -> LocatedAn AnnListItem (HsExpr GhcPs))
-> LocatedAn AnnListItem (HsExpr GhcPs)
-> HsExpr GhcPs
forall b c a. (b -> c) -> (a -> b) -> a -> c
. if LocatedAn AnnListItem (HsExpr GhcPs) -> Bool
forall a. Brackets a => a -> Bool
isAtom LocatedAn AnnListItem (HsExpr GhcPs)
op then LocatedAn AnnListItem (HsExpr GhcPs)
-> LocatedAn AnnListItem (HsExpr GhcPs)
forall a. a -> a
id else LocatedAn AnnListItem (HsExpr GhcPs)
-> LocatedAn AnnListItem (HsExpr GhcPs)
forall a. Brackets a => a -> a
addParen

-- We're done factoring, but have no variables left, so we shouldn't make a lambda.
-- @\ -> e@ ==> @e@
niceLambdaR [] LHsExpr GhcPs
e = (LHsExpr GhcPs
e, \SrcSpan
s -> [RType
-> SrcSpan -> [(String, SrcSpan)] -> String -> Refactoring SrcSpan
forall a. RType -> a -> [(String, a)] -> String -> Refactoring a
Replace RType
Expr SrcSpan
s [(String
"a", LocatedAn AnnListItem (HsExpr GhcPs) -> SrcSpan
forall a e. GenLocated (SrcSpanAnn' a) e -> SrcSpan
toSSA LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
e)] String
"a"])
-- Base case. Just a good old fashioned lambda.
niceLambdaR [String]
ss LHsExpr GhcPs
e =
  let grhs :: LGRHS GhcPs (LHsExpr GhcPs)
grhs = GRHS GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
-> Located (GRHS GhcPs (LocatedAn AnnListItem (HsExpr GhcPs)))
forall e. e -> Located e
noLoc (GRHS GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
 -> Located (GRHS GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))))
-> GRHS GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
-> Located (GRHS GhcPs (LocatedAn AnnListItem (HsExpr GhcPs)))
forall a b. (a -> b) -> a -> b
$ XCGRHS GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
-> [GuardLStmt GhcPs]
-> LocatedAn AnnListItem (HsExpr GhcPs)
-> GRHS GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
forall p body.
XCGRHS p body -> [GuardLStmt p] -> body -> GRHS p body
GRHS XCGRHS GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
forall ann. EpAnn ann
EpAnnNotUsed [] LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
e :: LGRHS GhcPs (LHsExpr GhcPs)
      grhss :: GRHSs GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
grhss = GRHSs :: forall p body.
XCGRHSs p body -> [LGRHS p body] -> HsLocalBinds p -> GRHSs p body
GRHSs {grhssExt :: XCGRHSs GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
grhssExt = XCGRHSs GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
EpAnnComments
emptyComments, grhssGRHSs :: [LGRHS GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))]
grhssGRHSs=[LGRHS GhcPs (LHsExpr GhcPs)
LGRHS GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
grhs], grhssLocalBinds :: HsLocalBinds GhcPs
grhssLocalBinds=XEmptyLocalBinds GhcPs GhcPs -> HsLocalBinds GhcPs
forall idL idR. XEmptyLocalBinds idL idR -> HsLocalBindsLR idL idR
EmptyLocalBinds NoExtField
XEmptyLocalBinds GhcPs GhcPs
noExtField}
      match :: LMatch GhcPs (LHsExpr GhcPs)
match = Match GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
-> LocatedAn
     AnnListItem (Match GhcPs (LocatedAn AnnListItem (HsExpr GhcPs)))
forall a an. a -> LocatedAn an a
noLocA (Match GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
 -> LocatedAn
      AnnListItem (Match GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))))
-> Match GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
-> LocatedAn
     AnnListItem (Match GhcPs (LocatedAn AnnListItem (HsExpr GhcPs)))
forall a b. (a -> b) -> a -> b
$ Match :: forall p body.
XCMatch p body
-> HsMatchContext (NoGhcTc p)
-> [LPat p]
-> GRHSs p body
-> Match p body
Match {m_ext :: XCMatch GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
m_ext=XCMatch GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
forall ann. EpAnn ann
EpAnnNotUsed, m_ctxt :: HsMatchContext (NoGhcTc GhcPs)
m_ctxt=HsMatchContext (NoGhcTc GhcPs)
forall p. HsMatchContext p
LambdaExpr, m_pats :: [LPat GhcPs]
m_pats=(String -> LocatedA (Pat GhcPs))
-> [String] -> [LocatedA (Pat GhcPs)]
forall a b. (a -> b) -> [a] -> [b]
map String -> LPat GhcPs
String -> LocatedA (Pat GhcPs)
strToPat [String]
ss, m_grhss :: GRHSs GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
m_grhss=GRHSs GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
grhss} :: LMatch GhcPs (LHsExpr GhcPs)
      matchGroup :: MatchGroup GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
matchGroup = MG :: forall p body.
XMG p body -> XRec p [LMatch p body] -> Origin -> MatchGroup p body
MG {mg_ext :: XMG GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
mg_ext=NoExtField
XMG GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
noExtField, mg_origin :: Origin
mg_origin=Origin
Generated, mg_alts :: XRec GhcPs [LMatch GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))]
mg_alts=[LocatedAn
   AnnListItem (Match GhcPs (LocatedAn AnnListItem (HsExpr GhcPs)))]
-> LocatedAn
     AnnList
     [LocatedAn
        AnnListItem (Match GhcPs (LocatedAn AnnListItem (HsExpr GhcPs)))]
forall a an. a -> LocatedAn an a
noLocA [LMatch GhcPs (LHsExpr GhcPs)
LocatedAn
  AnnListItem (Match GhcPs (LocatedAn AnnListItem (HsExpr GhcPs)))
match]}
  in (HsExpr GhcPs -> LocatedAn AnnListItem (HsExpr GhcPs)
forall a an. a -> LocatedAn an a
noLocA (HsExpr GhcPs -> LocatedAn AnnListItem (HsExpr GhcPs))
-> HsExpr GhcPs -> LocatedAn AnnListItem (HsExpr GhcPs)
forall a b. (a -> b) -> a -> b
$ XLam GhcPs -> MatchGroup GhcPs (LHsExpr GhcPs) -> HsExpr GhcPs
forall p. XLam p -> MatchGroup p (LHsExpr p) -> HsExpr p
HsLam NoExtField
XLam GhcPs
noExtField MatchGroup GhcPs (LHsExpr GhcPs)
MatchGroup GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
matchGroup, [Refactoring SrcSpan] -> SrcSpan -> [Refactoring SrcSpan]
forall a b. a -> b -> a
const [])


-- 'case' and 'if' expressions have branches, nothing else does (this
-- doesn't consider 'HsMultiIf' perhaps it should?).
replaceBranches :: LHsExpr GhcPs -> ([LHsExpr GhcPs], [LHsExpr GhcPs] -> LHsExpr GhcPs)
replaceBranches :: LHsExpr GhcPs
-> ([LHsExpr GhcPs], [LHsExpr GhcPs] -> LHsExpr GhcPs)
replaceBranches (L l (HsIf _ a b c)) = ([LHsExpr GhcPs
b, LHsExpr GhcPs
c], \[LHsExpr GhcPs
b, LHsExpr GhcPs
c] -> SrcSpanAnnA -> HsExpr GhcPs -> LocatedAn AnnListItem (HsExpr GhcPs)
forall l e. l -> e -> GenLocated l e
L SrcSpanAnnA
l (XIf GhcPs
-> LHsExpr GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs -> HsExpr GhcPs
forall p. XIf p -> LHsExpr p -> LHsExpr p -> LHsExpr p -> HsExpr p
HsIf XIf GhcPs
forall ann. EpAnn ann
EpAnnNotUsed LHsExpr GhcPs
a LHsExpr GhcPs
b LHsExpr GhcPs
c))

replaceBranches (L s (HsCase _ a (MG _ (L l bs) FromSource))) =
  ((LocatedAn
   AnnListItem (Match GhcPs (LocatedAn AnnListItem (HsExpr GhcPs)))
 -> [LocatedAn AnnListItem (HsExpr GhcPs)])
-> [LocatedAn
      AnnListItem (Match GhcPs (LocatedAn AnnListItem (HsExpr GhcPs)))]
-> [LocatedAn AnnListItem (HsExpr GhcPs)]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap LMatch GhcPs (LHsExpr GhcPs) -> [LHsExpr GhcPs]
LocatedAn
  AnnListItem (Match GhcPs (LocatedAn AnnListItem (HsExpr GhcPs)))
-> [LocatedAn AnnListItem (HsExpr GhcPs)]
f [LocatedAn
   AnnListItem (Match GhcPs (LocatedAn AnnListItem (HsExpr GhcPs)))]
bs, \[LHsExpr GhcPs]
xs -> SrcSpanAnnA -> HsExpr GhcPs -> LocatedAn AnnListItem (HsExpr GhcPs)
forall l e. l -> e -> GenLocated l e
L SrcSpanAnnA
s (XCase GhcPs
-> LHsExpr GhcPs
-> MatchGroup GhcPs (LHsExpr GhcPs)
-> HsExpr GhcPs
forall p.
XCase p -> LHsExpr p -> MatchGroup p (LHsExpr p) -> HsExpr p
HsCase XCase GhcPs
forall ann. EpAnn ann
EpAnnNotUsed LHsExpr GhcPs
a (XMG GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
-> XRec GhcPs [LMatch GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))]
-> Origin
-> MatchGroup GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
forall p body.
XMG p body -> XRec p [LMatch p body] -> Origin -> MatchGroup p body
MG NoExtField
XMG GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
noExtField (SrcSpanAnnL
-> [LocatedAn
      AnnListItem (Match GhcPs (LocatedAn AnnListItem (HsExpr GhcPs)))]
-> LocatedAn
     AnnList
     [LocatedAn
        AnnListItem (Match GhcPs (LocatedAn AnnListItem (HsExpr GhcPs)))]
forall l e. l -> e -> GenLocated l e
L SrcSpanAnnL
l ([LMatch GhcPs (LHsExpr GhcPs)]
-> [LHsExpr GhcPs] -> [LMatch GhcPs (LHsExpr GhcPs)]
g [LMatch GhcPs (LHsExpr GhcPs)]
[LocatedAn
   AnnListItem (Match GhcPs (LocatedAn AnnListItem (HsExpr GhcPs)))]
bs [LHsExpr GhcPs]
xs)) Origin
Generated)))
  where
    f :: LMatch GhcPs (LHsExpr GhcPs) -> [LHsExpr GhcPs]
    f :: LMatch GhcPs (LHsExpr GhcPs) -> [LHsExpr GhcPs]
f (L _ (Match _ CaseAlt _ (GRHSs _ xs _))) = [LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
x | (L SrcSpan
_ (GRHS XCGRHS GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
_ [GuardLStmt GhcPs]
_ LocatedAn AnnListItem (HsExpr GhcPs)
x)) <- [LGRHS GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))]
[Located (GRHS GhcPs (LocatedAn AnnListItem (HsExpr GhcPs)))]
xs]
    f LMatch GhcPs (LHsExpr GhcPs)
_ = String -> [LocatedAn AnnListItem (HsExpr GhcPs)]
forall a. HasCallStack => String -> a
error String
"GHC.Util.HsExpr.replaceBranches: unexpected XMatch"

    g :: [LMatch GhcPs (LHsExpr GhcPs)] -> [LHsExpr GhcPs] -> [LMatch GhcPs (LHsExpr GhcPs)]
    g :: [LMatch GhcPs (LHsExpr GhcPs)]
-> [LHsExpr GhcPs] -> [LMatch GhcPs (LHsExpr GhcPs)]
g (L s1 (Match _ CaseAlt a (GRHSs _ ns b)) : [LMatch GhcPs (LHsExpr GhcPs)]
rest) [LHsExpr GhcPs]
xs =
      SrcSpanAnnA
-> Match GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
-> LocatedAn
     AnnListItem (Match GhcPs (LocatedAn AnnListItem (HsExpr GhcPs)))
forall l e. l -> e -> GenLocated l e
L SrcSpanAnnA
s1 (XCMatch GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
-> HsMatchContext (NoGhcTc GhcPs)
-> [LPat GhcPs]
-> GRHSs GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
-> Match GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
forall p body.
XCMatch p body
-> HsMatchContext (NoGhcTc p)
-> [LPat p]
-> GRHSs p body
-> Match p body
Match XCMatch GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
forall ann. EpAnn ann
EpAnnNotUsed HsMatchContext (NoGhcTc GhcPs)
forall p. HsMatchContext p
CaseAlt [LPat GhcPs]
a (XCGRHSs GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
-> [LGRHS GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))]
-> HsLocalBinds GhcPs
-> GRHSs GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
forall p body.
XCGRHSs p body -> [LGRHS p body] -> HsLocalBinds p -> GRHSs p body
GRHSs XCGRHSs GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
EpAnnComments
emptyComments [SrcSpan
-> GRHS GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
-> Located (GRHS GhcPs (LocatedAn AnnListItem (HsExpr GhcPs)))
forall l e. l -> e -> GenLocated l e
L SrcSpan
a (XCGRHS GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
-> [GuardLStmt GhcPs]
-> LocatedAn AnnListItem (HsExpr GhcPs)
-> GRHS GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
forall p body.
XCGRHS p body -> [GuardLStmt p] -> body -> GRHS p body
GRHS XCGRHS GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
forall ann. EpAnn ann
EpAnnNotUsed [GuardLStmt GhcPs]
gs LocatedAn AnnListItem (HsExpr GhcPs)
x) | (L SrcSpan
a (GRHS XCGRHS GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))
_ [GuardLStmt GhcPs]
gs LocatedAn AnnListItem (HsExpr GhcPs)
_), LocatedAn AnnListItem (HsExpr GhcPs)
x) <- [Located (GRHS GhcPs (LocatedAn AnnListItem (HsExpr GhcPs)))]
-> [LocatedAn AnnListItem (HsExpr GhcPs)]
-> [(Located (GRHS GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))),
     LocatedAn AnnListItem (HsExpr GhcPs))]
forall a b. [a] -> [b] -> [(a, b)]
zip [LGRHS GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))]
[Located (GRHS GhcPs (LocatedAn AnnListItem (HsExpr GhcPs)))]
ns [LocatedAn AnnListItem (HsExpr GhcPs)]
as] HsLocalBinds GhcPs
b)) LocatedAn
  AnnListItem (Match GhcPs (LocatedAn AnnListItem (HsExpr GhcPs)))
-> [LocatedAn
      AnnListItem (Match GhcPs (LocatedAn AnnListItem (HsExpr GhcPs)))]
-> [LocatedAn
      AnnListItem (Match GhcPs (LocatedAn AnnListItem (HsExpr GhcPs)))]
forall a. a -> [a] -> [a]
: [LMatch GhcPs (LHsExpr GhcPs)]
-> [LHsExpr GhcPs] -> [LMatch GhcPs (LHsExpr GhcPs)]
g [LMatch GhcPs (LHsExpr GhcPs)]
rest [LHsExpr GhcPs]
[LocatedAn AnnListItem (HsExpr GhcPs)]
bs
      where  ([LocatedAn AnnListItem (HsExpr GhcPs)]
as, [LocatedAn AnnListItem (HsExpr GhcPs)]
bs) = Int
-> [LocatedAn AnnListItem (HsExpr GhcPs)]
-> ([LocatedAn AnnListItem (HsExpr GhcPs)],
    [LocatedAn AnnListItem (HsExpr GhcPs)])
forall a. Int -> [a] -> ([a], [a])
splitAt ([Located (GRHS GhcPs (LocatedAn AnnListItem (HsExpr GhcPs)))]
-> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [LGRHS GhcPs (LocatedAn AnnListItem (HsExpr GhcPs))]
[Located (GRHS GhcPs (LocatedAn AnnListItem (HsExpr GhcPs)))]
ns) [LHsExpr GhcPs]
[LocatedAn AnnListItem (HsExpr GhcPs)]
xs
    g [] [] = []
    g [LMatch GhcPs (LHsExpr GhcPs)]
_ [LHsExpr GhcPs]
_ = String
-> [LocatedAn
      AnnListItem (Match GhcPs (LocatedAn AnnListItem (HsExpr GhcPs)))]
forall a. HasCallStack => String -> a
error String
"GHC.Util.HsExpr.replaceBranches': internal invariant failed, lists are of differing lengths"

replaceBranches LHsExpr GhcPs
x = ([], \[] -> LHsExpr GhcPs
x)


-- Like needBracket, but with a special case for 'a . b . b', which was
-- removed from haskell-src-exts-util-0.2.2.
needBracketOld :: Int -> LHsExpr GhcPs -> LHsExpr GhcPs -> Bool
needBracketOld :: Int -> LHsExpr GhcPs -> LHsExpr GhcPs -> Bool
needBracketOld Int
i LHsExpr GhcPs
parent LHsExpr GhcPs
child
  | LHsExpr GhcPs -> Bool
isDotApp LHsExpr GhcPs
parent, LHsExpr GhcPs -> Bool
isDotApp LHsExpr GhcPs
child, Int
i Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
2 = Bool
False
  | Bool
otherwise = Int
-> LocatedAn AnnListItem (HsExpr GhcPs)
-> LocatedAn AnnListItem (HsExpr GhcPs)
-> Bool
forall a. Brackets a => Int -> a -> a -> Bool
needBracket Int
i LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
parent LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
child

transformBracketOld :: (LHsExpr GhcPs -> Maybe (LHsExpr GhcPs))
                    -> LHsExpr GhcPs
                    -> (LHsExpr GhcPs, (LHsExpr GhcPs, [String]))
transformBracketOld :: (LHsExpr GhcPs -> Maybe (LHsExpr GhcPs))
-> LHsExpr GhcPs -> (LHsExpr GhcPs, (LHsExpr GhcPs, [String]))
transformBracketOld LHsExpr GhcPs -> Maybe (LHsExpr GhcPs)
op = ((Bool, LocatedAn AnnListItem (HsExpr GhcPs))
 -> LocatedAn AnnListItem (HsExpr GhcPs))
-> ((Bool, LocatedAn AnnListItem (HsExpr GhcPs)),
    (LocatedAn AnnListItem (HsExpr GhcPs), [String]))
-> (LocatedAn AnnListItem (HsExpr GhcPs),
    (LocatedAn AnnListItem (HsExpr GhcPs), [String]))
forall a a' b. (a -> a') -> (a, b) -> (a', b)
first (Bool, LocatedAn AnnListItem (HsExpr GhcPs))
-> LocatedAn AnnListItem (HsExpr GhcPs)
forall a b. (a, b) -> b
snd (((Bool, LocatedAn AnnListItem (HsExpr GhcPs)),
  (LocatedAn AnnListItem (HsExpr GhcPs), [String]))
 -> (LocatedAn AnnListItem (HsExpr GhcPs),
     (LocatedAn AnnListItem (HsExpr GhcPs), [String])))
-> (LocatedAn AnnListItem (HsExpr GhcPs)
    -> ((Bool, LocatedAn AnnListItem (HsExpr GhcPs)),
        (LocatedAn AnnListItem (HsExpr GhcPs), [String])))
-> LocatedAn AnnListItem (HsExpr GhcPs)
-> (LocatedAn AnnListItem (HsExpr GhcPs),
    (LocatedAn AnnListItem (HsExpr GhcPs), [String]))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LocatedAn AnnListItem (HsExpr GhcPs)
-> ((Bool, LocatedAn AnnListItem (HsExpr GhcPs)),
    (LocatedAn AnnListItem (HsExpr GhcPs), [String]))
g
  where
    g :: LocatedAn AnnListItem (HsExpr GhcPs)
-> ((Bool, LocatedAn AnnListItem (HsExpr GhcPs)),
    (LocatedAn AnnListItem (HsExpr GhcPs), [String]))
g = (LocatedAn AnnListItem (HsExpr GhcPs)
 -> (Bool, LocatedAn AnnListItem (HsExpr GhcPs)))
-> (LocatedAn AnnListItem (HsExpr GhcPs),
    (LocatedAn AnnListItem (HsExpr GhcPs), [String]))
-> ((Bool, LocatedAn AnnListItem (HsExpr GhcPs)),
    (LocatedAn AnnListItem (HsExpr GhcPs), [String]))
forall a a' b. (a -> a') -> (a, b) -> (a', b)
first LocatedAn AnnListItem (HsExpr GhcPs)
-> (Bool, LocatedAn AnnListItem (HsExpr GhcPs))
f ((LocatedAn AnnListItem (HsExpr GhcPs),
  (LocatedAn AnnListItem (HsExpr GhcPs), [String]))
 -> ((Bool, LocatedAn AnnListItem (HsExpr GhcPs)),
     (LocatedAn AnnListItem (HsExpr GhcPs), [String])))
-> (LocatedAn AnnListItem (HsExpr GhcPs)
    -> (LocatedAn AnnListItem (HsExpr GhcPs),
        (LocatedAn AnnListItem (HsExpr GhcPs), [String])))
-> LocatedAn AnnListItem (HsExpr GhcPs)
-> ((Bool, LocatedAn AnnListItem (HsExpr GhcPs)),
    (LocatedAn AnnListItem (HsExpr GhcPs), [String]))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (LHsExpr GhcPs
 -> ((Bool, LHsExpr GhcPs), (LHsExpr GhcPs, [String])))
-> LHsExpr GhcPs -> (LHsExpr GhcPs, (LHsExpr GhcPs, [String]))
descendBracketOld LHsExpr GhcPs -> ((Bool, LHsExpr GhcPs), (LHsExpr GhcPs, [String]))
LocatedAn AnnListItem (HsExpr GhcPs)
-> ((Bool, LocatedAn AnnListItem (HsExpr GhcPs)),
    (LocatedAn AnnListItem (HsExpr GhcPs), [String]))
g
    f :: LocatedAn AnnListItem (HsExpr GhcPs)
-> (Bool, LocatedAn AnnListItem (HsExpr GhcPs))
f LocatedAn AnnListItem (HsExpr GhcPs)
x = (Bool, LocatedAn AnnListItem (HsExpr GhcPs))
-> (LocatedAn AnnListItem (HsExpr GhcPs)
    -> (Bool, LocatedAn AnnListItem (HsExpr GhcPs)))
-> Maybe (LocatedAn AnnListItem (HsExpr GhcPs))
-> (Bool, LocatedAn AnnListItem (HsExpr GhcPs))
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (Bool
False, LocatedAn AnnListItem (HsExpr GhcPs)
x) (Bool
True, ) (LHsExpr GhcPs -> Maybe (LHsExpr GhcPs)
op LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
x)

-- Descend, and if something changes then add/remove brackets
-- appropriately. Returns (suggested replacement, (refactor template, no bracket vars)),
-- where "no bracket vars" is a list of substitution variables which, when expanded,
-- should have the brackets stripped.
descendBracketOld :: (LHsExpr GhcPs -> ((Bool, LHsExpr GhcPs), (LHsExpr GhcPs, [String])))
                  -> LHsExpr GhcPs
                  -> (LHsExpr GhcPs, (LHsExpr GhcPs, [String]))
descendBracketOld :: (LHsExpr GhcPs
 -> ((Bool, LHsExpr GhcPs), (LHsExpr GhcPs, [String])))
-> LHsExpr GhcPs -> (LHsExpr GhcPs, (LHsExpr GhcPs, [String]))
descendBracketOld LHsExpr GhcPs -> ((Bool, LHsExpr GhcPs), (LHsExpr GhcPs, [String]))
op LHsExpr GhcPs
x = ((Int
 -> LocatedAn AnnListItem (HsExpr GhcPs)
 -> LocatedAn AnnListItem (HsExpr GhcPs))
-> LocatedAn AnnListItem (HsExpr GhcPs)
-> LocatedAn AnnListItem (HsExpr GhcPs)
forall a. Data a => (Int -> a -> a) -> a -> a
descendIndex Int
-> LocatedAn AnnListItem (HsExpr GhcPs)
-> LocatedAn AnnListItem (HsExpr GhcPs)
g1 LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
x, (Int
 -> LocatedAn AnnListItem (HsExpr GhcPs)
 -> Writer [String] (LocatedAn AnnListItem (HsExpr GhcPs)))
-> LocatedAn AnnListItem (HsExpr GhcPs)
-> (LocatedAn AnnListItem (HsExpr GhcPs), [String])
forall a w.
(Data a, Monoid w) =>
(Int -> a -> Writer w a) -> a -> (a, w)
descendIndex' Int
-> LocatedAn AnnListItem (HsExpr GhcPs)
-> Writer [String] (LocatedAn AnnListItem (HsExpr GhcPs))
g2 LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
x)
  where
    g :: Int
-> LocatedAn AnnListItem (HsExpr GhcPs)
-> (LocatedAn AnnListItem (HsExpr GhcPs),
    (LocatedAn AnnListItem (HsExpr GhcPs), [String]))
g Int
i LocatedAn AnnListItem (HsExpr GhcPs)
y = if Bool
a then (Int
-> LocatedAn AnnListItem (HsExpr GhcPs)
-> LocatedAn AnnListItem (HsExpr GhcPs)
-> [String]
-> LocatedAn AnnListItem (HsExpr GhcPs)
f1 Int
i LocatedAn AnnListItem (HsExpr GhcPs)
b LocatedAn AnnListItem (HsExpr GhcPs)
z [String]
w, Int
-> LocatedAn AnnListItem (HsExpr GhcPs)
-> LocatedAn AnnListItem (HsExpr GhcPs)
-> [String]
-> (LocatedAn AnnListItem (HsExpr GhcPs), [String])
f2 Int
i LocatedAn AnnListItem (HsExpr GhcPs)
b LocatedAn AnnListItem (HsExpr GhcPs)
z [String]
w) else (LocatedAn AnnListItem (HsExpr GhcPs)
b, (LocatedAn AnnListItem (HsExpr GhcPs)
z, [String]
w))
      where ((Bool
a, LocatedAn AnnListItem (HsExpr GhcPs)
b), (LocatedAn AnnListItem (HsExpr GhcPs)
z, [String]
w)) = LHsExpr GhcPs -> ((Bool, LHsExpr GhcPs), (LHsExpr GhcPs, [String]))
op LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
y

    g1 :: Int
-> LocatedAn AnnListItem (HsExpr GhcPs)
-> LocatedAn AnnListItem (HsExpr GhcPs)
g1 Int
a LocatedAn AnnListItem (HsExpr GhcPs)
b = (LocatedAn AnnListItem (HsExpr GhcPs),
 (LocatedAn AnnListItem (HsExpr GhcPs), [String]))
-> LocatedAn AnnListItem (HsExpr GhcPs)
forall a b. (a, b) -> a
fst (Int
-> LocatedAn AnnListItem (HsExpr GhcPs)
-> (LocatedAn AnnListItem (HsExpr GhcPs),
    (LocatedAn AnnListItem (HsExpr GhcPs), [String]))
g Int
a LocatedAn AnnListItem (HsExpr GhcPs)
b)
    g2 :: Int
-> LocatedAn AnnListItem (HsExpr GhcPs)
-> Writer [String] (LocatedAn AnnListItem (HsExpr GhcPs))
g2 Int
a LocatedAn AnnListItem (HsExpr GhcPs)
b = (LocatedAn AnnListItem (HsExpr GhcPs), [String])
-> Writer [String] (LocatedAn AnnListItem (HsExpr GhcPs))
forall w (m :: * -> *) a.
(Monoid w, Monad m) =>
(a, w) -> WriterT w m a
writer ((LocatedAn AnnListItem (HsExpr GhcPs), [String])
 -> Writer [String] (LocatedAn AnnListItem (HsExpr GhcPs)))
-> (LocatedAn AnnListItem (HsExpr GhcPs), [String])
-> Writer [String] (LocatedAn AnnListItem (HsExpr GhcPs))
forall a b. (a -> b) -> a -> b
$ (LocatedAn AnnListItem (HsExpr GhcPs),
 (LocatedAn AnnListItem (HsExpr GhcPs), [String]))
-> (LocatedAn AnnListItem (HsExpr GhcPs), [String])
forall a b. (a, b) -> b
snd (Int
-> LocatedAn AnnListItem (HsExpr GhcPs)
-> (LocatedAn AnnListItem (HsExpr GhcPs),
    (LocatedAn AnnListItem (HsExpr GhcPs), [String]))
g Int
a LocatedAn AnnListItem (HsExpr GhcPs)
b)

    f :: Int
-> LocatedAn AnnListItem (HsExpr GhcPs)
-> LocatedAn AnnListItem (HsExpr GhcPs)
-> [String]
-> (LocatedAn AnnListItem (HsExpr GhcPs),
    (LocatedAn AnnListItem (HsExpr GhcPs), [String]))
f Int
i (L SrcSpanAnnA
_ (HsPar XPar GhcPs
_ LHsExpr GhcPs
y)) LocatedAn AnnListItem (HsExpr GhcPs)
z [String]
w
      | Bool -> Bool
not (Bool -> Bool) -> Bool -> Bool
forall a b. (a -> b) -> a -> b
$ Int -> LHsExpr GhcPs -> LHsExpr GhcPs -> Bool
needBracketOld Int
i LHsExpr GhcPs
x LHsExpr GhcPs
y = (LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
y, LocatedAn AnnListItem (HsExpr GhcPs)
-> (LocatedAn AnnListItem (HsExpr GhcPs), [String])
removeBracket LocatedAn AnnListItem (HsExpr GhcPs)
z)
      where
        -- If the template expr is a Var, record it so that we can remove the brackets
        -- later when expanding it. Otherwise, remove the enclosing brackets (if any).
        removeBracket :: LocatedAn AnnListItem (HsExpr GhcPs)
-> (LocatedAn AnnListItem (HsExpr GhcPs), [String])
removeBracket = \case
          var :: LocatedAn AnnListItem (HsExpr GhcPs)
var@(L SrcSpanAnnA
_ HsVar{}) -> (LocatedAn AnnListItem (HsExpr GhcPs)
z, LHsExpr GhcPs -> String
varToStr LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
var String -> [String] -> [String]
forall a. a -> [a] -> [a]
: [String]
w)
          LocatedAn AnnListItem (HsExpr GhcPs)
other -> (LocatedAn AnnListItem (HsExpr GhcPs)
-> LocatedAn AnnListItem (HsExpr GhcPs)
fromParen LocatedAn AnnListItem (HsExpr GhcPs)
z, [String]
w)
    f Int
i LocatedAn AnnListItem (HsExpr GhcPs)
y LocatedAn AnnListItem (HsExpr GhcPs)
z [String]
w
      | Int -> LHsExpr GhcPs -> LHsExpr GhcPs -> Bool
needBracketOld Int
i LHsExpr GhcPs
x LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
y = (LocatedAn AnnListItem (HsExpr GhcPs)
-> LocatedAn AnnListItem (HsExpr GhcPs)
forall a. Brackets a => a -> a
addParen LocatedAn AnnListItem (HsExpr GhcPs)
y, (LocatedAn AnnListItem (HsExpr GhcPs)
-> LocatedAn AnnListItem (HsExpr GhcPs)
forall a. Brackets a => a -> a
addParen LocatedAn AnnListItem (HsExpr GhcPs)
z, [String]
w))
      -- https://github.com/mpickering/apply-refact/issues/7
      | LocatedAn AnnListItem (HsExpr GhcPs) -> Bool
forall l. GenLocated l (HsExpr GhcPs) -> Bool
isOp LocatedAn AnnListItem (HsExpr GhcPs)
y = (LocatedAn AnnListItem (HsExpr GhcPs)
y, (LocatedAn AnnListItem (HsExpr GhcPs)
-> LocatedAn AnnListItem (HsExpr GhcPs)
forall a. Brackets a => a -> a
addParen LocatedAn AnnListItem (HsExpr GhcPs)
z, [String]
w))
    f Int
_ LocatedAn AnnListItem (HsExpr GhcPs)
y LocatedAn AnnListItem (HsExpr GhcPs)
z [String]
w = (LocatedAn AnnListItem (HsExpr GhcPs)
y, (LocatedAn AnnListItem (HsExpr GhcPs)
z, [String]
w))

    f1 :: Int
-> LocatedAn AnnListItem (HsExpr GhcPs)
-> LocatedAn AnnListItem (HsExpr GhcPs)
-> [String]
-> LocatedAn AnnListItem (HsExpr GhcPs)
f1 Int
a LocatedAn AnnListItem (HsExpr GhcPs)
b LocatedAn AnnListItem (HsExpr GhcPs)
c [String]
d = (LocatedAn AnnListItem (HsExpr GhcPs),
 (LocatedAn AnnListItem (HsExpr GhcPs), [String]))
-> LocatedAn AnnListItem (HsExpr GhcPs)
forall a b. (a, b) -> a
fst (Int
-> LocatedAn AnnListItem (HsExpr GhcPs)
-> LocatedAn AnnListItem (HsExpr GhcPs)
-> [String]
-> (LocatedAn AnnListItem (HsExpr GhcPs),
    (LocatedAn AnnListItem (HsExpr GhcPs), [String]))
f Int
a LocatedAn AnnListItem (HsExpr GhcPs)
b LocatedAn AnnListItem (HsExpr GhcPs)
c [String]
d)
    f2 :: Int
-> LocatedAn AnnListItem (HsExpr GhcPs)
-> LocatedAn AnnListItem (HsExpr GhcPs)
-> [String]
-> (LocatedAn AnnListItem (HsExpr GhcPs), [String])
f2 Int
a LocatedAn AnnListItem (HsExpr GhcPs)
b LocatedAn AnnListItem (HsExpr GhcPs)
c [String]
d = (LocatedAn AnnListItem (HsExpr GhcPs),
 (LocatedAn AnnListItem (HsExpr GhcPs), [String]))
-> (LocatedAn AnnListItem (HsExpr GhcPs), [String])
forall a b. (a, b) -> b
snd (Int
-> LocatedAn AnnListItem (HsExpr GhcPs)
-> LocatedAn AnnListItem (HsExpr GhcPs)
-> [String]
-> (LocatedAn AnnListItem (HsExpr GhcPs),
    (LocatedAn AnnListItem (HsExpr GhcPs), [String]))
f Int
a LocatedAn AnnListItem (HsExpr GhcPs)
b LocatedAn AnnListItem (HsExpr GhcPs)
c [String]
d)

    isOp :: GenLocated l (HsExpr GhcPs) -> Bool
isOp = \case
      L l
_ (HsVar XVar GhcPs
_ (L _ name)) -> RdrName -> Bool
isSymbolRdrName RdrName
name
      GenLocated l (HsExpr GhcPs)
_ -> Bool
False

fromParen1 :: LHsExpr GhcPs -> LHsExpr GhcPs
fromParen1 :: LHsExpr GhcPs -> LHsExpr GhcPs
fromParen1 LHsExpr GhcPs
x = LocatedAn AnnListItem (HsExpr GhcPs)
-> Maybe (LocatedAn AnnListItem (HsExpr GhcPs))
-> LocatedAn AnnListItem (HsExpr GhcPs)
forall a. a -> Maybe a -> a
fromMaybe LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
x (Maybe (LocatedAn AnnListItem (HsExpr GhcPs))
 -> LocatedAn AnnListItem (HsExpr GhcPs))
-> Maybe (LocatedAn AnnListItem (HsExpr GhcPs))
-> LocatedAn AnnListItem (HsExpr GhcPs)
forall a b. (a -> b) -> a -> b
$ LocatedAn AnnListItem (HsExpr GhcPs)
-> Maybe (LocatedAn AnnListItem (HsExpr GhcPs))
forall a. Brackets a => a -> Maybe a
remParen LHsExpr GhcPs
LocatedAn AnnListItem (HsExpr GhcPs)
x