{-
(c) The University of Glasgow 2006
(c) The GRASP/AQUA Project, Glasgow University, 1992-1998
-}

{-# LANGUAGE CPP, DeriveDataTypeable, ScopedTypeVariables #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE UndecidableInstances #-} -- Note [Pass sensitive types]
                                      -- in module PlaceHolder
{-# LANGUAGE ConstraintKinds #-}
{-# LANGUAGE ExistentialQuantification #-}
{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE TypeFamilies #-}

-- | Abstract Haskell syntax for expressions.
module HsExpr where

#include "HsVersions.h"

-- friends:
import GhcPrelude

import HsDecls
import HsPat
import HsLit
import PlaceHolder ( NameOrRdrName )
import HsExtension
import HsTypes
import HsBinds

-- others:
import TcEvidence
import CoreSyn
import DynFlags ( gopt, GeneralFlag(Opt_PrintExplicitCoercions) )
import Name
import NameSet
import RdrName  ( GlobalRdrEnv )
import BasicTypes
import ConLike
import SrcLoc
import Util
import Outputable
import FastString
import Type
import TcType (TcType)
import {-# SOURCE #-} TcRnTypes (TcLclEnv)

-- libraries:
import Data.Data hiding (Fixity(..))
import qualified Data.Data as Data (Fixity(..))
import Data.Maybe (isNothing)

import GHCi.RemoteTypes ( ForeignRef )
import qualified Language.Haskell.TH as TH (Q)

{-
************************************************************************
*                                                                      *
\subsection{Expressions proper}
*                                                                      *
************************************************************************
-}

-- * Expressions proper

-- | Located Haskell Expression
type LHsExpr p = Located (HsExpr p)
  -- ^ May have 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnComma' when
  --   in a list

  -- For details on above see note [Api annotations] in ApiAnnotation

-------------------------
-- | Post-Type checking Expression
--
-- PostTcExpr is an evidence expression attached to the syntax tree by the
-- type checker (c.f. postTcType).
type PostTcExpr  = HsExpr GhcTc

-- | Post-Type checking Table
--
-- We use a PostTcTable where there are a bunch of pieces of evidence, more
-- than is convenient to keep individually.
type PostTcTable = [(Name, PostTcExpr)]

-------------------------
-- | Syntax Expression
--
-- SyntaxExpr is like 'PostTcExpr', but it's filled in a little earlier,
-- by the renamer.  It's used for rebindable syntax.
--
-- E.g. @(>>=)@ is filled in before the renamer by the appropriate 'Name' for
--      @(>>=)@, and then instantiated by the type checker with its type args
--      etc
--
-- This should desugar to
--
-- > syn_res_wrap $ syn_expr (syn_arg_wraps[0] arg0)
-- >                         (syn_arg_wraps[1] arg1) ...
--
-- where the actual arguments come from elsewhere in the AST.
-- This could be defined using @GhcPass p@ and such, but it's
-- harder to get it all to work out that way. ('noSyntaxExpr' is hard to
-- write, for example.)
data SyntaxExpr p = SyntaxExpr { SyntaxExpr p -> HsExpr p
syn_expr      :: HsExpr p
                               , SyntaxExpr p -> [HsWrapper]
syn_arg_wraps :: [HsWrapper]
                               , SyntaxExpr p -> HsWrapper
syn_res_wrap  :: HsWrapper }

-- | This is used for rebindable-syntax pieces that are too polymorphic
-- for tcSyntaxOp (trS_fmap and the mzip in ParStmt)
noExpr :: HsExpr (GhcPass p)
noExpr :: HsExpr (GhcPass p)
noExpr = XLitE (GhcPass p) -> HsLit (GhcPass p) -> HsExpr (GhcPass p)
forall p. XLitE p -> HsLit p -> HsExpr p
HsLit XLitE (GhcPass p)
NoExt
noExt (XHsString (GhcPass p) -> FastString -> HsLit (GhcPass p)
forall x. XHsString x -> FastString -> HsLit x
HsString (String -> SourceText
SourceText  "noExpr") (String -> FastString
fsLit "noExpr"))

noSyntaxExpr :: SyntaxExpr (GhcPass p)
                              -- Before renaming, and sometimes after,
                              -- (if the syntax slot makes no sense)
noSyntaxExpr :: SyntaxExpr (GhcPass p)
noSyntaxExpr = SyntaxExpr :: forall p. HsExpr p -> [HsWrapper] -> HsWrapper -> SyntaxExpr p
SyntaxExpr { syn_expr :: HsExpr (GhcPass p)
syn_expr      = XLitE (GhcPass p) -> HsLit (GhcPass p) -> HsExpr (GhcPass p)
forall p. XLitE p -> HsLit p -> HsExpr p
HsLit XLitE (GhcPass p)
NoExt
noExt (XHsString (GhcPass p) -> FastString -> HsLit (GhcPass p)
forall x. XHsString x -> FastString -> HsLit x
HsString SourceText
XHsString (GhcPass p)
NoSourceText
                                                        (String -> FastString
fsLit "noSyntaxExpr"))
                          , syn_arg_wraps :: [HsWrapper]
syn_arg_wraps = []
                          , syn_res_wrap :: HsWrapper
syn_res_wrap  = HsWrapper
WpHole }

-- | Make a 'SyntaxExpr (HsExpr _)', missing its HsWrappers.
mkSyntaxExpr :: HsExpr (GhcPass p) -> SyntaxExpr (GhcPass p)
mkSyntaxExpr :: HsExpr (GhcPass p) -> SyntaxExpr (GhcPass p)
mkSyntaxExpr expr :: HsExpr (GhcPass p)
expr = SyntaxExpr :: forall p. HsExpr p -> [HsWrapper] -> HsWrapper -> SyntaxExpr p
SyntaxExpr { syn_expr :: HsExpr (GhcPass p)
syn_expr      = HsExpr (GhcPass p)
expr
                               , syn_arg_wraps :: [HsWrapper]
syn_arg_wraps = []
                               , syn_res_wrap :: HsWrapper
syn_res_wrap  = HsWrapper
WpHole }

-- | Make a 'SyntaxExpr Name' (the "rn" is because this is used in the
-- renamer), missing its HsWrappers.
mkRnSyntaxExpr :: Name -> SyntaxExpr GhcRn
mkRnSyntaxExpr :: Name -> SyntaxExpr GhcRn
mkRnSyntaxExpr name :: Name
name = HsExpr GhcRn -> SyntaxExpr GhcRn
forall (p :: Pass). HsExpr (GhcPass p) -> SyntaxExpr (GhcPass p)
mkSyntaxExpr (HsExpr GhcRn -> SyntaxExpr GhcRn)
-> HsExpr GhcRn -> SyntaxExpr GhcRn
forall a b. (a -> b) -> a -> b
$ XVar GhcRn -> Located (IdP GhcRn) -> HsExpr GhcRn
forall p. XVar p -> Located (IdP p) -> HsExpr p
HsVar XVar GhcRn
NoExt
noExt (Located (IdP GhcRn) -> HsExpr GhcRn)
-> Located (IdP GhcRn) -> HsExpr GhcRn
forall a b. (a -> b) -> a -> b
$ SrcSpanLess (Located Name) -> Located Name
forall a. HasSrcSpan a => SrcSpanLess a -> a
noLoc Name
SrcSpanLess (Located Name)
name
  -- don't care about filling in syn_arg_wraps because we're clearly
  -- not past the typechecker

instance (p ~ GhcPass pass, OutputableBndrId p)
       => Outputable (SyntaxExpr p) where
  ppr :: SyntaxExpr p -> SDoc
ppr (SyntaxExpr { syn_expr :: forall p. SyntaxExpr p -> HsExpr p
syn_expr      = HsExpr p
expr
                  , syn_arg_wraps :: forall p. SyntaxExpr p -> [HsWrapper]
syn_arg_wraps = [HsWrapper]
arg_wraps
                  , syn_res_wrap :: forall p. SyntaxExpr p -> HsWrapper
syn_res_wrap  = HsWrapper
res_wrap })
    = (DynFlags -> SDoc) -> SDoc
sdocWithDynFlags ((DynFlags -> SDoc) -> SDoc) -> (DynFlags -> SDoc) -> SDoc
forall a b. (a -> b) -> a -> b
$ \ dflags :: DynFlags
dflags ->
      (PprStyle -> SDoc) -> SDoc
getPprStyle ((PprStyle -> SDoc) -> SDoc) -> (PprStyle -> SDoc) -> SDoc
forall a b. (a -> b) -> a -> b
$ \s :: PprStyle
s ->
      if PprStyle -> Bool
debugStyle PprStyle
s Bool -> Bool -> Bool
|| GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_PrintExplicitCoercions DynFlags
dflags
      then HsExpr p -> SDoc
forall a. Outputable a => a -> SDoc
ppr HsExpr p
expr SDoc -> SDoc -> SDoc
<> SDoc -> SDoc
braces ((HsWrapper -> SDoc) -> [HsWrapper] -> SDoc
forall a. (a -> SDoc) -> [a] -> SDoc
pprWithCommas HsWrapper -> SDoc
forall a. Outputable a => a -> SDoc
ppr [HsWrapper]
arg_wraps)
                    SDoc -> SDoc -> SDoc
<> SDoc -> SDoc
braces (HsWrapper -> SDoc
forall a. Outputable a => a -> SDoc
ppr HsWrapper
res_wrap)
      else HsExpr p -> SDoc
forall a. Outputable a => a -> SDoc
ppr HsExpr p
expr

-- | Command Syntax Table (for Arrow syntax)
type CmdSyntaxTable p = [(Name, HsExpr p)]
-- See Note [CmdSyntaxTable]

{-
Note [CmdSyntaxtable]
~~~~~~~~~~~~~~~~~~~~~
Used only for arrow-syntax stuff (HsCmdTop), the CmdSyntaxTable keeps
track of the methods needed for a Cmd.

* Before the renamer, this list is an empty list

* After the renamer, it takes the form @[(std_name, HsVar actual_name)]@
  For example, for the 'arr' method
   * normal case:            (GHC.Control.Arrow.arr, HsVar GHC.Control.Arrow.arr)
   * with rebindable syntax: (GHC.Control.Arrow.arr, arr_22)
             where @arr_22@ is whatever 'arr' is in scope

* After the type checker, it takes the form [(std_name, <expression>)]
  where <expression> is the evidence for the method.  This evidence is
  instantiated with the class, but is still polymorphic in everything
  else.  For example, in the case of 'arr', the evidence has type
         forall b c. (b->c) -> a b c
  where 'a' is the ambient type of the arrow.  This polymorphism is
  important because the desugarer uses the same evidence at multiple
  different types.

This is Less Cool than what we normally do for rebindable syntax, which is to
make fully-instantiated piece of evidence at every use site.  The Cmd way
is Less Cool because
  * The renamer has to predict which methods are needed.
    See the tedious RnExpr.methodNamesCmd.

  * The desugarer has to know the polymorphic type of the instantiated
    method. This is checked by Inst.tcSyntaxName, but is less flexible
    than the rest of rebindable syntax, where the type is less
    pre-ordained.  (And this flexibility is useful; for example we can
    typecheck do-notation with (>>=) :: m1 a -> (a -> m2 b) -> m2 b.)
-}

-- | An unbound variable; used for treating
-- out-of-scope variables as expression holes
--
-- Either "x", "y"     Plain OutOfScope
-- or     "_", "_x"    A TrueExprHole
--
-- Both forms indicate an out-of-scope variable,  but the latter
-- indicates that the user /expects/ it to be out of scope, and
-- just wants GHC to report its type
data UnboundVar
  = OutOfScope OccName GlobalRdrEnv  -- ^ An (unqualified) out-of-scope
                                     -- variable, together with the GlobalRdrEnv
                                     -- with respect to which it is unbound

                                     -- See Note [OutOfScope and GlobalRdrEnv]

  | TrueExprHole OccName             -- ^ A "true" expression hole (_ or _x)

  deriving Typeable UnboundVar
DataType
Constr
Typeable UnboundVar =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> UnboundVar -> c UnboundVar)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c UnboundVar)
-> (UnboundVar -> Constr)
-> (UnboundVar -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c UnboundVar))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c UnboundVar))
-> ((forall b. Data b => b -> b) -> UnboundVar -> UnboundVar)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> UnboundVar -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> UnboundVar -> r)
-> (forall u. (forall d. Data d => d -> u) -> UnboundVar -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> UnboundVar -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> UnboundVar -> m UnboundVar)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> UnboundVar -> m UnboundVar)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> UnboundVar -> m UnboundVar)
-> Data UnboundVar
UnboundVar -> DataType
UnboundVar -> Constr
(forall b. Data b => b -> b) -> UnboundVar -> UnboundVar
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UnboundVar -> c UnboundVar
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UnboundVar
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> UnboundVar -> u
forall u. (forall d. Data d => d -> u) -> UnboundVar -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UnboundVar -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UnboundVar -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> UnboundVar -> m UnboundVar
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UnboundVar -> m UnboundVar
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UnboundVar
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UnboundVar -> c UnboundVar
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UnboundVar)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UnboundVar)
$cTrueExprHole :: Constr
$cOutOfScope :: Constr
$tUnboundVar :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> UnboundVar -> m UnboundVar
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UnboundVar -> m UnboundVar
gmapMp :: (forall d. Data d => d -> m d) -> UnboundVar -> m UnboundVar
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UnboundVar -> m UnboundVar
gmapM :: (forall d. Data d => d -> m d) -> UnboundVar -> m UnboundVar
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> UnboundVar -> m UnboundVar
gmapQi :: Int -> (forall d. Data d => d -> u) -> UnboundVar -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> UnboundVar -> u
gmapQ :: (forall d. Data d => d -> u) -> UnboundVar -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> UnboundVar -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UnboundVar -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UnboundVar -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UnboundVar -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UnboundVar -> r
gmapT :: (forall b. Data b => b -> b) -> UnboundVar -> UnboundVar
$cgmapT :: (forall b. Data b => b -> b) -> UnboundVar -> UnboundVar
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UnboundVar)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UnboundVar)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c UnboundVar)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UnboundVar)
dataTypeOf :: UnboundVar -> DataType
$cdataTypeOf :: UnboundVar -> DataType
toConstr :: UnboundVar -> Constr
$ctoConstr :: UnboundVar -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UnboundVar
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UnboundVar
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UnboundVar -> c UnboundVar
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UnboundVar -> c UnboundVar
$cp1Data :: Typeable UnboundVar
Data

instance Outputable UnboundVar where
    ppr :: UnboundVar -> SDoc
ppr (OutOfScope occ :: OccName
occ _) = String -> SDoc
text "OutOfScope" SDoc -> SDoc -> SDoc
<> SDoc -> SDoc
parens (OccName -> SDoc
forall a. Outputable a => a -> SDoc
ppr OccName
occ)
    ppr (TrueExprHole occ :: OccName
occ) = String -> SDoc
text "ExprHole"   SDoc -> SDoc -> SDoc
<> SDoc -> SDoc
parens (OccName -> SDoc
forall a. Outputable a => a -> SDoc
ppr OccName
occ)

unboundVarOcc :: UnboundVar -> OccName
unboundVarOcc :: UnboundVar -> OccName
unboundVarOcc (OutOfScope occ :: OccName
occ _) = OccName
occ
unboundVarOcc (TrueExprHole occ :: OccName
occ) = OccName
occ

{-
Note [OutOfScope and GlobalRdrEnv]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
To understand why we bundle a GlobalRdrEnv with an out-of-scope variable,
consider the following module:

    module A where

    foo :: ()
    foo = bar

    bat :: [Double]
    bat = [1.2, 3.4]

    $(return [])

    bar = ()
    bad = False

When A is compiled, the renamer determines that `bar` is not in scope in the
declaration of `foo` (since `bar` is declared in the following inter-splice
group).  Once it has finished typechecking the entire module, the typechecker
then generates the associated error message, which specifies both the type of
`bar` and a list of possible in-scope alternatives:

    A.hs:6:7: error:
        • Variable not in scope: bar :: ()
        • ‘bar’ (line 13) is not in scope before the splice on line 11
          Perhaps you meant ‘bat’ (line 9)

When it calls RnEnv.unknownNameSuggestions to identify these alternatives, the
typechecker must provide a GlobalRdrEnv.  If it provided the current one, which
contains top-level declarations for the entire module, the error message would
incorrectly suggest the out-of-scope `bar` and `bad` as possible alternatives
for `bar` (see Trac #11680).  Instead, the typechecker must use the same
GlobalRdrEnv the renamer used when it determined that `bar` is out-of-scope.

To obtain this GlobalRdrEnv, can the typechecker simply use the out-of-scope
`bar`'s location to either reconstruct it (from the current GlobalRdrEnv) or to
look it up in some global store?  Unfortunately, no.  The problem is that
location information is not always sufficient for this task.  This is most
apparent when dealing with the TH function addTopDecls, which adds its
declarations to the FOLLOWING inter-splice group.  Consider these declarations:

    ex9 = cat               -- cat is NOT in scope here

    $(do -------------------------------------------------------------
        ds <- [d| f = cab   -- cat and cap are both in scope here
                  cat = ()
                |]
        addTopDecls ds
        [d| g = cab         -- only cap is in scope here
            cap = True
          |])

    ex10 = cat              -- cat is NOT in scope here

    $(return []) -----------------------------------------------------

    ex11 = cat              -- cat is in scope

Here, both occurrences of `cab` are out-of-scope, and so the typechecker needs
the GlobalRdrEnvs which were used when they were renamed.  These GlobalRdrEnvs
are different (`cat` is present only in the GlobalRdrEnv for f's `cab'), but the
locations of the two `cab`s are the same (they are both created in the same
splice).  Thus, we must include some additional information with each `cab` to
allow the typechecker to obtain the correct GlobalRdrEnv.  Clearly, the simplest
information to use is the GlobalRdrEnv itself.
-}

-- | A Haskell expression.
data HsExpr p
  = HsVar     (XVar p)
              (Located (IdP p)) -- ^ Variable

                             -- See Note [Located RdrNames]

  | HsUnboundVar (XUnboundVar p)
                 UnboundVar  -- ^ Unbound variable; also used for "holes"
                             --   (_ or _x).
                             -- Turned from HsVar to HsUnboundVar by the
                             --   renamer, when it finds an out-of-scope
                             --   variable or hole.
                             -- Turned into HsVar by type checker, to support
                             --   deferred type errors.

  | HsConLikeOut (XConLikeOut p)
                 ConLike     -- ^ After typechecker only; must be different
                             -- HsVar for pretty printing

  | HsRecFld  (XRecFld p)
              (AmbiguousFieldOcc p) -- ^ Variable pointing to record selector
                                    -- Not in use after typechecking

  | HsOverLabel (XOverLabel p)
                (Maybe (IdP p)) FastString
     -- ^ Overloaded label (Note [Overloaded labels] in GHC.OverloadedLabels)
     --   @Just id@ means @RebindableSyntax@ is in use, and gives the id of the
     --   in-scope 'fromLabel'.
     --   NB: Not in use after typechecking

  | HsIPVar   (XIPVar p)
              HsIPName   -- ^ Implicit parameter (not in use after typechecking)
  | HsOverLit (XOverLitE p)
              (HsOverLit p)  -- ^ Overloaded literals

  | HsLit     (XLitE p)
              (HsLit p)      -- ^ Simple (non-overloaded) literals

  | HsLam     (XLam p)
              (MatchGroup p (LHsExpr p))
                       -- ^ Lambda abstraction. Currently always a single match
       --
       -- - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnLam',
       --       'ApiAnnotation.AnnRarrow',

       -- For details on above see note [Api annotations] in ApiAnnotation

  | HsLamCase (XLamCase p) (MatchGroup p (LHsExpr p)) -- ^ Lambda-case
       --
       -- - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnLam',
       --           'ApiAnnotation.AnnCase','ApiAnnotation.AnnOpen',
       --           'ApiAnnotation.AnnClose'

       -- For details on above see note [Api annotations] in ApiAnnotation

  | HsApp     (XApp p) (LHsExpr p) (LHsExpr p) -- ^ Application

  | HsAppType (XAppTypeE p) (LHsExpr p) (LHsWcType (NoGhcTc p))  -- ^ Visible type application
       --
       -- Explicit type argument; e.g  f @Int x y
       -- NB: Has wildcards, but no implicit quantification
       --
       -- - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnAt',

  -- | Operator applications:
  -- NB Bracketed ops such as (+) come out as Vars.

  -- NB We need an expr for the operator in an OpApp/Section since
  -- the typechecker may need to apply the operator to a few types.

  | OpApp       (XOpApp p)
                (LHsExpr p)       -- left operand
                (LHsExpr p)       -- operator
                (LHsExpr p)       -- right operand

  -- | Negation operator. Contains the negated expression and the name
  -- of 'negate'
  --
  --  - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnMinus'

  -- For details on above see note [Api annotations] in ApiAnnotation
  | NegApp      (XNegApp p)
                (LHsExpr p)
                (SyntaxExpr p)

  -- | - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen' @'('@,
  --             'ApiAnnotation.AnnClose' @')'@

  -- For details on above see note [Api annotations] in ApiAnnotation
  | HsPar       (XPar p)
                (LHsExpr p)  -- ^ Parenthesised expr; see Note [Parens in HsSyn]

  | SectionL    (XSectionL p)
                (LHsExpr p)    -- operand; see Note [Sections in HsSyn]
                (LHsExpr p)    -- operator
  | SectionR    (XSectionR p)
                (LHsExpr p)    -- operator; see Note [Sections in HsSyn]
                (LHsExpr p)    -- operand

  -- | Used for explicit tuples and sections thereof
  --
  --  - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen',
  --         'ApiAnnotation.AnnClose'

  -- For details on above see note [Api annotations] in ApiAnnotation
  | ExplicitTuple
        (XExplicitTuple p)
        [LHsTupArg p]
        Boxity

  -- | Used for unboxed sum types
  --
  --  - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen' @'(#'@,
  --          'ApiAnnotation.AnnVbar', 'ApiAnnotation.AnnClose' @'#)'@,
  --
  --  There will be multiple 'ApiAnnotation.AnnVbar', (1 - alternative) before
  --  the expression, (arity - alternative) after it
  | ExplicitSum
          (XExplicitSum p)
          ConTag --  Alternative (one-based)
          Arity  --  Sum arity
          (LHsExpr p)

  -- | - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnCase',
  --       'ApiAnnotation.AnnOf','ApiAnnotation.AnnOpen' @'{'@,
  --       'ApiAnnotation.AnnClose' @'}'@

  -- For details on above see note [Api annotations] in ApiAnnotation
  | HsCase      (XCase p)
                (LHsExpr p)
                (MatchGroup p (LHsExpr p))

  -- | - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnIf',
  --       'ApiAnnotation.AnnSemi',
  --       'ApiAnnotation.AnnThen','ApiAnnotation.AnnSemi',
  --       'ApiAnnotation.AnnElse',

  -- For details on above see note [Api annotations] in ApiAnnotation
  | HsIf        (XIf p)
                (Maybe (SyntaxExpr p)) -- cond function
                                        -- Nothing => use the built-in 'if'
                                        -- See Note [Rebindable if]
                (LHsExpr p)    --  predicate
                (LHsExpr p)    --  then part
                (LHsExpr p)    --  else part

  -- | Multi-way if
  --
  -- - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnIf'
  --       'ApiAnnotation.AnnOpen','ApiAnnotation.AnnClose',

  -- For details on above see note [Api annotations] in ApiAnnotation
  | HsMultiIf   (XMultiIf p) [LGRHS p (LHsExpr p)]

  -- | let(rec)
  --
  -- - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnLet',
  --       'ApiAnnotation.AnnOpen' @'{'@,
  --       'ApiAnnotation.AnnClose' @'}'@,'ApiAnnotation.AnnIn'

  -- For details on above see note [Api annotations] in ApiAnnotation
  | HsLet       (XLet p)
                (LHsLocalBinds p)
                (LHsExpr  p)

  -- | - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnDo',
  --             'ApiAnnotation.AnnOpen', 'ApiAnnotation.AnnSemi',
  --             'ApiAnnotation.AnnVbar',
  --             'ApiAnnotation.AnnClose'

  -- For details on above see note [Api annotations] in ApiAnnotation
  | HsDo        (XDo p)                  -- Type of the whole expression
                (HsStmtContext Name)     -- The parameterisation is unimportant
                                         -- because in this context we never use
                                         -- the PatGuard or ParStmt variant
                (Located [ExprLStmt p]) -- "do":one or more stmts

  -- | Syntactic list: [a,b,c,...]
  --
  --  - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen' @'['@,
  --              'ApiAnnotation.AnnClose' @']'@

  -- For details on above see note [Api annotations] in ApiAnnotation
  | ExplicitList
                (XExplicitList p)  -- Gives type of components of list
                (Maybe (SyntaxExpr p))
                                   -- For OverloadedLists, the fromListN witness
                [LHsExpr p]

  -- | Record construction
  --
  --  - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen' @'{'@,
  --         'ApiAnnotation.AnnDotdot','ApiAnnotation.AnnClose' @'}'@

  -- For details on above see note [Api annotations] in ApiAnnotation
  | RecordCon
      { HsExpr p -> XRecordCon p
rcon_ext      :: XRecordCon p
      , HsExpr p -> Located (IdP p)
rcon_con_name :: Located (IdP p)    -- The constructor name;
                                            --  not used after type checking
      , HsExpr p -> HsRecordBinds p
rcon_flds     :: HsRecordBinds p }  -- The fields

  -- | Record update
  --
  --  - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen' @'{'@,
  --         'ApiAnnotation.AnnDotdot','ApiAnnotation.AnnClose' @'}'@

  -- For details on above see note [Api annotations] in ApiAnnotation
  | RecordUpd
      { HsExpr p -> XRecordUpd p
rupd_ext  :: XRecordUpd p
      , HsExpr p -> LHsExpr p
rupd_expr :: LHsExpr p
      , HsExpr p -> [LHsRecUpdField p]
rupd_flds :: [LHsRecUpdField p]
      }
  -- For a type family, the arg types are of the *instance* tycon,
  -- not the family tycon

  -- | Expression with an explicit type signature. @e :: type@
  --
  --  - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnDcolon'

  -- For details on above see note [Api annotations] in ApiAnnotation
  | ExprWithTySig
                (XExprWithTySig p)

                (LHsExpr p)
                (LHsSigWcType (NoGhcTc p))

  -- | Arithmetic sequence
  --
  --  - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen' @'['@,
  --              'ApiAnnotation.AnnComma','ApiAnnotation.AnnDotdot',
  --              'ApiAnnotation.AnnClose' @']'@

  -- For details on above see note [Api annotations] in ApiAnnotation
  | ArithSeq
                (XArithSeq p)
                (Maybe (SyntaxExpr p))
                                  -- For OverloadedLists, the fromList witness
                (ArithSeqInfo p)

  -- For details on above see note [Api annotations] in ApiAnnotation
  | HsSCC       (XSCC p)
                SourceText            -- Note [Pragma source text] in BasicTypes
                StringLiteral         -- "set cost centre" SCC pragma
                (LHsExpr p)           -- expr whose cost is to be measured

  -- | - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen' @'{-\# CORE'@,
  --             'ApiAnnotation.AnnVal', 'ApiAnnotation.AnnClose' @'\#-}'@

  -- For details on above see note [Api annotations] in ApiAnnotation
  | HsCoreAnn   (XCoreAnn p)
                SourceText            -- Note [Pragma source text] in BasicTypes
                StringLiteral         -- hdaume: core annotation
                (LHsExpr p)

  -----------------------------------------------------------
  -- MetaHaskell Extensions

  -- | - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen',
  --         'ApiAnnotation.AnnOpenE','ApiAnnotation.AnnOpenEQ',
  --         'ApiAnnotation.AnnClose','ApiAnnotation.AnnCloseQ'

  -- For details on above see note [Api annotations] in ApiAnnotation
  | HsBracket    (XBracket p) (HsBracket p)

    -- See Note [Pending Splices]
  | HsRnBracketOut
      (XRnBracketOut p)
      (HsBracket GhcRn)    -- Output of the renamer is the *original* renamed
                           -- expression, plus
      [PendingRnSplice]    -- _renamed_ splices to be type checked

  | HsTcBracketOut
      (XTcBracketOut p)
      (HsBracket GhcRn)    -- Output of the type checker is the *original*
                           -- renamed expression, plus
      [PendingTcSplice]    -- _typechecked_ splices to be
                           -- pasted back in by the desugarer

  -- | - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen',
  --         'ApiAnnotation.AnnClose'

  -- For details on above see note [Api annotations] in ApiAnnotation
  | HsSpliceE  (XSpliceE p) (HsSplice p)

  -----------------------------------------------------------
  -- Arrow notation extension

  -- | @proc@ notation for Arrows
  --
  --  - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnProc',
  --          'ApiAnnotation.AnnRarrow'

  -- For details on above see note [Api annotations] in ApiAnnotation
  | HsProc      (XProc p)
                (LPat p)               -- arrow abstraction, proc
                (LHsCmdTop p)          -- body of the abstraction
                                       -- always has an empty stack

  ---------------------------------------
  -- static pointers extension
  -- | - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnStatic',

  -- For details on above see note [Api annotations] in ApiAnnotation
  | HsStatic (XStatic p) -- Free variables of the body
             (LHsExpr p)        -- Body

  ---------------------------------------
  -- The following are commands, not expressions proper
  -- They are only used in the parsing stage and are removed
  --    immediately in parser.RdrHsSyn.checkCommand

  -- | - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.Annlarrowtail',
  --          'ApiAnnotation.Annrarrowtail','ApiAnnotation.AnnLarrowtail',
  --          'ApiAnnotation.AnnRarrowtail'

  -- For details on above see note [Api annotations] in ApiAnnotation
  | HsArrApp             -- Arrow tail, or arrow application (f -< arg)
        (XArrApp p)     -- type of the arrow expressions f,
                        -- of the form a t t', where arg :: t
        (LHsExpr p)     -- arrow expression, f
        (LHsExpr p)     -- input expression, arg
        HsArrAppType    -- higher-order (-<<) or first-order (-<)
        Bool            -- True => right-to-left (f -< arg)
                        -- False => left-to-right (arg >- f)

  -- | - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpenB' @'(|'@,
  --         'ApiAnnotation.AnnCloseB' @'|)'@

  -- For details on above see note [Api annotations] in ApiAnnotation
  | HsArrForm            -- Command formation,  (| e cmd1 .. cmdn |)
        (XArrForm p)
        (LHsExpr p)      -- the operator
                         -- after type-checking, a type abstraction to be
                         -- applied to the type of the local environment tuple
        (Maybe Fixity)   -- fixity (filled in by the renamer), for forms that
                         -- were converted from OpApp's by the renamer
        [LHsCmdTop p]    -- argument commands

  ---------------------------------------
  -- Haskell program coverage (Hpc) Support

  | HsTick
     (XTick p)
     (Tickish (IdP p))
     (LHsExpr p)                       -- sub-expression

  | HsBinTick
     (XBinTick p)
     Int                                -- module-local tick number for True
     Int                                -- module-local tick number for False
     (LHsExpr p)                        -- sub-expression

  -- | - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen',
  --       'ApiAnnotation.AnnOpen' @'{-\# GENERATED'@,
  --       'ApiAnnotation.AnnVal','ApiAnnotation.AnnVal',
  --       'ApiAnnotation.AnnColon','ApiAnnotation.AnnVal',
  --       'ApiAnnotation.AnnMinus',
  --       'ApiAnnotation.AnnVal','ApiAnnotation.AnnColon',
  --       'ApiAnnotation.AnnVal',
  --       'ApiAnnotation.AnnClose' @'\#-}'@

  -- For details on above see note [Api annotations] in ApiAnnotation
  | HsTickPragma                      -- A pragma introduced tick
     (XTickPragma p)
     SourceText                       -- Note [Pragma source text] in BasicTypes
     (StringLiteral,(Int,Int),(Int,Int))
                                      -- external span for this tick
     ((SourceText,SourceText),(SourceText,SourceText))
        -- Source text for the four integers used in the span.
        -- See note [Pragma source text] in BasicTypes
     (LHsExpr p)

  ---------------------------------------
  -- These constructors only appear temporarily in the parser.
  -- The renamer translates them into the Right Thing.

  | EWildPat (XEWildPat p)        -- wildcard

  -- | - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnAt'

  -- For details on above see note [Api annotations] in ApiAnnotation
  | EAsPat      (XEAsPat p)
                (Located (IdP p)) -- as pattern
                (LHsExpr p)

  -- | - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnRarrow'

  -- For details on above see note [Api annotations] in ApiAnnotation
  | EViewPat    (XEViewPat p)
                (LHsExpr p) -- view pattern
                (LHsExpr p)

  -- | - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnTilde'

  -- For details on above see note [Api annotations] in ApiAnnotation
  | ELazyPat    (XELazyPat p) (LHsExpr p) -- ~ pattern


  ---------------------------------------
  -- Finally, HsWrap appears only in typechecker output
  -- The contained Expr is *NOT* itself an HsWrap.
  -- See Note [Detecting forced eta expansion] in DsExpr. This invariant
  -- is maintained by HsUtils.mkHsWrap.

  |  HsWrap     (XWrap p)
                HsWrapper    -- TRANSLATION
                (HsExpr p)

  | XExpr       (XXExpr p) -- Note [Trees that Grow] extension constructor


-- | Extra data fields for a 'RecordCon', added by the type checker
data RecordConTc = RecordConTc
      { RecordConTc -> ConLike
rcon_con_like :: ConLike      -- The data constructor or pattern synonym
      , RecordConTc -> PostTcExpr
rcon_con_expr :: PostTcExpr   -- Instantiated constructor function
      }

-- | Extra data fields for a 'RecordUpd', added by the type checker
data RecordUpdTc = RecordUpdTc
      { RecordUpdTc -> [ConLike]
rupd_cons :: [ConLike]
                -- Filled in by the type checker to the
                -- _non-empty_ list of DataCons that have
                -- all the upd'd fields

      , RecordUpdTc -> [Type]
rupd_in_tys  :: [Type] -- Argument types of *input* record type
      , RecordUpdTc -> [Type]
rupd_out_tys :: [Type] --             and  *output* record type
                               -- The original type can be reconstructed
                               -- with conLikeResTy
      , RecordUpdTc -> HsWrapper
rupd_wrap :: HsWrapper -- See note [Record Update HsWrapper]
      } deriving Typeable RecordUpdTc
DataType
Constr
Typeable RecordUpdTc =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> RecordUpdTc -> c RecordUpdTc)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c RecordUpdTc)
-> (RecordUpdTc -> Constr)
-> (RecordUpdTc -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c RecordUpdTc))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c RecordUpdTc))
-> ((forall b. Data b => b -> b) -> RecordUpdTc -> RecordUpdTc)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RecordUpdTc -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RecordUpdTc -> r)
-> (forall u. (forall d. Data d => d -> u) -> RecordUpdTc -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> RecordUpdTc -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> RecordUpdTc -> m RecordUpdTc)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RecordUpdTc -> m RecordUpdTc)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RecordUpdTc -> m RecordUpdTc)
-> Data RecordUpdTc
RecordUpdTc -> DataType
RecordUpdTc -> Constr
(forall b. Data b => b -> b) -> RecordUpdTc -> RecordUpdTc
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RecordUpdTc -> c RecordUpdTc
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RecordUpdTc
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> RecordUpdTc -> u
forall u. (forall d. Data d => d -> u) -> RecordUpdTc -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RecordUpdTc -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RecordUpdTc -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RecordUpdTc -> m RecordUpdTc
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RecordUpdTc -> m RecordUpdTc
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RecordUpdTc
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RecordUpdTc -> c RecordUpdTc
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RecordUpdTc)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c RecordUpdTc)
$cRecordUpdTc :: Constr
$tRecordUpdTc :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> RecordUpdTc -> m RecordUpdTc
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RecordUpdTc -> m RecordUpdTc
gmapMp :: (forall d. Data d => d -> m d) -> RecordUpdTc -> m RecordUpdTc
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RecordUpdTc -> m RecordUpdTc
gmapM :: (forall d. Data d => d -> m d) -> RecordUpdTc -> m RecordUpdTc
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RecordUpdTc -> m RecordUpdTc
gmapQi :: Int -> (forall d. Data d => d -> u) -> RecordUpdTc -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RecordUpdTc -> u
gmapQ :: (forall d. Data d => d -> u) -> RecordUpdTc -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> RecordUpdTc -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RecordUpdTc -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RecordUpdTc -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RecordUpdTc -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RecordUpdTc -> r
gmapT :: (forall b. Data b => b -> b) -> RecordUpdTc -> RecordUpdTc
$cgmapT :: (forall b. Data b => b -> b) -> RecordUpdTc -> RecordUpdTc
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c RecordUpdTc)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c RecordUpdTc)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c RecordUpdTc)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RecordUpdTc)
dataTypeOf :: RecordUpdTc -> DataType
$cdataTypeOf :: RecordUpdTc -> DataType
toConstr :: RecordUpdTc -> Constr
$ctoConstr :: RecordUpdTc -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RecordUpdTc
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RecordUpdTc
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RecordUpdTc -> c RecordUpdTc
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RecordUpdTc -> c RecordUpdTc
$cp1Data :: Typeable RecordUpdTc
Data

-- ---------------------------------------------------------------------

type instance XVar           (GhcPass _) = NoExt
type instance XUnboundVar    (GhcPass _) = NoExt
type instance XConLikeOut    (GhcPass _) = NoExt
type instance XRecFld        (GhcPass _) = NoExt
type instance XOverLabel     (GhcPass _) = NoExt
type instance XIPVar         (GhcPass _) = NoExt
type instance XOverLitE      (GhcPass _) = NoExt
type instance XLitE          (GhcPass _) = NoExt
type instance XLam           (GhcPass _) = NoExt
type instance XLamCase       (GhcPass _) = NoExt
type instance XApp           (GhcPass _) = NoExt

type instance XAppTypeE      (GhcPass _) = NoExt

type instance XOpApp         GhcPs = NoExt
type instance XOpApp         GhcRn = Fixity
type instance XOpApp         GhcTc = Fixity

type instance XNegApp        (GhcPass _) = NoExt
type instance XPar           (GhcPass _) = NoExt
type instance XSectionL      (GhcPass _) = NoExt
type instance XSectionR      (GhcPass _) = NoExt
type instance XExplicitTuple (GhcPass _) = NoExt

type instance XExplicitSum   GhcPs = NoExt
type instance XExplicitSum   GhcRn = NoExt
type instance XExplicitSum   GhcTc = [Type]

type instance XCase          (GhcPass _) = NoExt
type instance XIf            (GhcPass _) = NoExt

type instance XMultiIf       GhcPs = NoExt
type instance XMultiIf       GhcRn = NoExt
type instance XMultiIf       GhcTc = Type

type instance XLet           (GhcPass _) = NoExt

type instance XDo            GhcPs = NoExt
type instance XDo            GhcRn = NoExt
type instance XDo            GhcTc = Type

type instance XExplicitList  GhcPs = NoExt
type instance XExplicitList  GhcRn = NoExt
type instance XExplicitList  GhcTc = Type

type instance XRecordCon     GhcPs = NoExt
type instance XRecordCon     GhcRn = NoExt
type instance XRecordCon     GhcTc = RecordConTc

type instance XRecordUpd     GhcPs = NoExt
type instance XRecordUpd     GhcRn = NoExt
type instance XRecordUpd     GhcTc = RecordUpdTc

type instance XExprWithTySig (GhcPass _) = NoExt

type instance XArithSeq      GhcPs = NoExt
type instance XArithSeq      GhcRn = NoExt
type instance XArithSeq      GhcTc = PostTcExpr

type instance XSCC           (GhcPass _) = NoExt
type instance XCoreAnn       (GhcPass _) = NoExt
type instance XBracket       (GhcPass _) = NoExt

type instance XRnBracketOut  (GhcPass _) = NoExt
type instance XTcBracketOut  (GhcPass _) = NoExt

type instance XSpliceE       (GhcPass _) = NoExt
type instance XProc          (GhcPass _) = NoExt

type instance XStatic        GhcPs = NoExt
type instance XStatic        GhcRn = NameSet
type instance XStatic        GhcTc = NameSet

type instance XArrApp        GhcPs = NoExt
type instance XArrApp        GhcRn = NoExt
type instance XArrApp        GhcTc = Type

type instance XArrForm       (GhcPass _) = NoExt
type instance XTick          (GhcPass _) = NoExt
type instance XBinTick       (GhcPass _) = NoExt
type instance XTickPragma    (GhcPass _) = NoExt
type instance XEWildPat      (GhcPass _) = NoExt
type instance XEAsPat        (GhcPass _) = NoExt
type instance XEViewPat      (GhcPass _) = NoExt
type instance XELazyPat      (GhcPass _) = NoExt
type instance XWrap          (GhcPass _) = NoExt
type instance XXExpr         (GhcPass _) = NoExt

-- ---------------------------------------------------------------------

-- | Located Haskell Tuple Argument
--
-- 'HsTupArg' is used for tuple sections
-- @(,a,)@ is represented by
-- @ExplicitTuple [Missing ty1, Present a, Missing ty3]@
-- Which in turn stands for @(\x:ty1 \y:ty2. (x,a,y))@
type LHsTupArg id = Located (HsTupArg id)
-- | - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnComma'

-- For details on above see note [Api annotations] in ApiAnnotation

-- | Haskell Tuple Argument
data HsTupArg id
  = Present (XPresent id) (LHsExpr id)     -- ^ The argument
  | Missing (XMissing id)    -- ^ The argument is missing, but this is its type
  | XTupArg (XXTupArg id)    -- ^ Note [Trees that Grow] extension point

type instance XPresent         (GhcPass _) = NoExt

type instance XMissing         GhcPs = NoExt
type instance XMissing         GhcRn = NoExt
type instance XMissing         GhcTc = Type

type instance XXTupArg         (GhcPass _) = NoExt

tupArgPresent :: LHsTupArg id -> Bool
tupArgPresent :: LHsTupArg id -> Bool
tupArgPresent (L _ (Present {})) = Bool
True
tupArgPresent (L _ (Missing {})) = Bool
False
tupArgPresent (L _ (XTupArg {})) = Bool
False

{-
Note [Parens in HsSyn]
~~~~~~~~~~~~~~~~~~~~~~
HsPar (and ParPat in patterns, HsParTy in types) is used as follows

  * HsPar is required; the pretty printer does not add parens.

  * HsPars are respected when rearranging operator fixities.
    So   a * (b + c)  means what it says (where the parens are an HsPar)

  * For ParPat and HsParTy the pretty printer does add parens but this should be
    a no-op for ParsedSource, based on the pretty printer round trip feature
    introduced in
    https://phabricator.haskell.org/rGHC499e43824bda967546ebf95ee33ec1f84a114a7c

  * ParPat and HsParTy are pretty printed as '( .. )' regardless of whether or
    not they are strictly necessary. This should be addressed when #13238 is
    completed, to be treated the same as HsPar.


Note [Sections in HsSyn]
~~~~~~~~~~~~~~~~~~~~~~~~
Sections should always appear wrapped in an HsPar, thus
         HsPar (SectionR ...)
The parser parses sections in a wider variety of situations
(See Note [Parsing sections]), but the renamer checks for those
parens.  This invariant makes pretty-printing easier; we don't need
a special case for adding the parens round sections.

Note [Rebindable if]
~~~~~~~~~~~~~~~~~~~~
The rebindable syntax for 'if' is a bit special, because when
rebindable syntax is *off* we do not want to treat
   (if c then t else e)
as if it was an application (ifThenElse c t e).  Why not?
Because we allow an 'if' to return *unboxed* results, thus
  if blah then 3# else 4#
whereas that would not be possible using a all to a polymorphic function
(because you can't call a polymorphic function at an unboxed type).

So we use Nothing to mean "use the old built-in typing rule".

Note [Record Update HsWrapper]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
There is a wrapper in RecordUpd which is used for the *required*
constraints for pattern synonyms. This wrapper is created in the
typechecking and is then directly used in the desugaring without
modification.

For example, if we have the record pattern synonym P,
  pattern P :: (Show a) => a -> Maybe a
  pattern P{x} = Just x

  foo = (Just True) { x = False }
then `foo` desugars to something like
  foo = case Just True of
          P x -> P False
hence we need to provide the correct dictionaries to P's matcher on
the RHS so that we can build the expression.

Note [Located RdrNames]
~~~~~~~~~~~~~~~~~~~~~~~
A number of syntax elements have seemingly redundant locations attached to them.
This is deliberate, to allow transformations making use of the API Annotations
to easily correlate a Located Name in the RenamedSource with a Located RdrName
in the ParsedSource.

There are unfortunately enough differences between the ParsedSource and the
RenamedSource that the API Annotations cannot be used directly with
RenamedSource, so this allows a simple mapping to be used based on the location.
-}

instance (p ~ GhcPass pass, OutputableBndrId p) => Outputable (HsExpr p) where
    ppr :: HsExpr p -> SDoc
ppr expr :: HsExpr p
expr = HsExpr (GhcPass pass) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
HsExpr (GhcPass p) -> SDoc
pprExpr HsExpr p
HsExpr (GhcPass pass)
expr

-----------------------
-- pprExpr, pprLExpr, pprBinds call pprDeeper;
-- the underscore versions do not
pprLExpr :: (OutputableBndrId (GhcPass p)) => LHsExpr (GhcPass p) -> SDoc
pprLExpr :: LHsExpr (GhcPass p) -> SDoc
pprLExpr (L _ e :: HsExpr (GhcPass p)
e) = HsExpr (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
HsExpr (GhcPass p) -> SDoc
pprExpr HsExpr (GhcPass p)
e

pprExpr :: (OutputableBndrId (GhcPass p)) => HsExpr (GhcPass p) -> SDoc
pprExpr :: HsExpr (GhcPass p) -> SDoc
pprExpr e :: HsExpr (GhcPass p)
e | HsExpr (GhcPass p) -> Bool
forall id. HsExpr id -> Bool
isAtomicHsExpr HsExpr (GhcPass p)
e Bool -> Bool -> Bool
|| HsExpr (GhcPass p) -> Bool
forall id. HsExpr id -> Bool
isQuietHsExpr HsExpr (GhcPass p)
e =            HsExpr (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
HsExpr (GhcPass p) -> SDoc
ppr_expr HsExpr (GhcPass p)
e
          | Bool
otherwise                           = SDoc -> SDoc
pprDeeper (HsExpr (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
HsExpr (GhcPass p) -> SDoc
ppr_expr HsExpr (GhcPass p)
e)

isQuietHsExpr :: HsExpr id -> Bool
-- Parentheses do display something, but it gives little info and
-- if we go deeper when we go inside them then we get ugly things
-- like (...)
isQuietHsExpr :: HsExpr id -> Bool
isQuietHsExpr (HsPar {})        = Bool
True
-- applications don't display anything themselves
isQuietHsExpr (HsApp {})        = Bool
True
isQuietHsExpr (HsAppType {})    = Bool
True
isQuietHsExpr (OpApp {})        = Bool
True
isQuietHsExpr _ = Bool
False

pprBinds :: (OutputableBndrId (GhcPass idL), OutputableBndrId (GhcPass idR))
         => HsLocalBindsLR (GhcPass idL) (GhcPass idR) -> SDoc
pprBinds :: HsLocalBindsLR (GhcPass idL) (GhcPass idR) -> SDoc
pprBinds b :: HsLocalBindsLR (GhcPass idL) (GhcPass idR)
b = SDoc -> SDoc
pprDeeper (HsLocalBindsLR (GhcPass idL) (GhcPass idR) -> SDoc
forall a. Outputable a => a -> SDoc
ppr HsLocalBindsLR (GhcPass idL) (GhcPass idR)
b)

-----------------------
ppr_lexpr :: (OutputableBndrId (GhcPass p)) => LHsExpr (GhcPass p) -> SDoc
ppr_lexpr :: LHsExpr (GhcPass p) -> SDoc
ppr_lexpr e :: LHsExpr (GhcPass p)
e = HsExpr (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
HsExpr (GhcPass p) -> SDoc
ppr_expr (LHsExpr (GhcPass p) -> SrcSpanLess (LHsExpr (GhcPass p))
forall a. HasSrcSpan a => a -> SrcSpanLess a
unLoc LHsExpr (GhcPass p)
e)

ppr_expr :: forall p. (OutputableBndrId (GhcPass p))
         => HsExpr (GhcPass p) -> SDoc
ppr_expr :: HsExpr (GhcPass p) -> SDoc
ppr_expr (HsVar _ (L _ v :: IdP (GhcPass p)
v))  = IdP (GhcPass p) -> SDoc
forall a. OutputableBndr a => a -> SDoc
pprPrefixOcc IdP (GhcPass p)
v
ppr_expr (HsUnboundVar _ uv :: UnboundVar
uv)= OccName -> SDoc
forall a. OutputableBndr a => a -> SDoc
pprPrefixOcc (UnboundVar -> OccName
unboundVarOcc UnboundVar
uv)
ppr_expr (HsConLikeOut _ c :: ConLike
c) = ConLike -> SDoc
forall a. OutputableBndr a => a -> SDoc
pprPrefixOcc ConLike
c
ppr_expr (HsIPVar _ v :: HsIPName
v)      = HsIPName -> SDoc
forall a. Outputable a => a -> SDoc
ppr HsIPName
v
ppr_expr (HsOverLabel _ _ l :: FastString
l)= Char -> SDoc
char '#' SDoc -> SDoc -> SDoc
<> FastString -> SDoc
forall a. Outputable a => a -> SDoc
ppr FastString
l
ppr_expr (HsLit _ lit :: HsLit (GhcPass p)
lit)      = HsLit (GhcPass p) -> SDoc
forall a. Outputable a => a -> SDoc
ppr HsLit (GhcPass p)
lit
ppr_expr (HsOverLit _ lit :: HsOverLit (GhcPass p)
lit)  = HsOverLit (GhcPass p) -> SDoc
forall a. Outputable a => a -> SDoc
ppr HsOverLit (GhcPass p)
lit
ppr_expr (HsPar _ e :: LHsExpr (GhcPass p)
e)        = SDoc -> SDoc
parens (LHsExpr (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
LHsExpr (GhcPass p) -> SDoc
ppr_lexpr LHsExpr (GhcPass p)
e)

ppr_expr (HsCoreAnn _ stc :: SourceText
stc (StringLiteral sta :: SourceText
sta s :: FastString
s) e :: LHsExpr (GhcPass p)
e)
  = [SDoc] -> SDoc
vcat [SourceText -> SDoc -> SDoc
pprWithSourceText SourceText
stc (String -> SDoc
text "{-# CORE")
          SDoc -> SDoc -> SDoc
<+> SourceText -> SDoc -> SDoc
pprWithSourceText SourceText
sta (SDoc -> SDoc
doubleQuotes (SDoc -> SDoc) -> SDoc -> SDoc
forall a b. (a -> b) -> a -> b
$ FastString -> SDoc
ftext FastString
s) SDoc -> SDoc -> SDoc
<+> String -> SDoc
text "#-}"
         , LHsExpr (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
LHsExpr (GhcPass p) -> SDoc
ppr_lexpr LHsExpr (GhcPass p)
e]

ppr_expr e :: HsExpr (GhcPass p)
e@(HsApp {})        = HsExpr (GhcPass p)
-> [Either (LHsExpr (GhcPass p)) (LHsWcType (NoGhcTc (GhcPass p)))]
-> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
HsExpr (GhcPass p)
-> [Either (LHsExpr (GhcPass p)) (LHsWcType (NoGhcTc (GhcPass p)))]
-> SDoc
ppr_apps HsExpr (GhcPass p)
e []
ppr_expr e :: HsExpr (GhcPass p)
e@(HsAppType {})    = HsExpr (GhcPass p)
-> [Either (LHsExpr (GhcPass p)) (LHsWcType (NoGhcTc (GhcPass p)))]
-> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
HsExpr (GhcPass p)
-> [Either (LHsExpr (GhcPass p)) (LHsWcType (NoGhcTc (GhcPass p)))]
-> SDoc
ppr_apps HsExpr (GhcPass p)
e []

ppr_expr (OpApp _ e1 :: LHsExpr (GhcPass p)
e1 op :: LHsExpr (GhcPass p)
op e2 :: LHsExpr (GhcPass p)
e2)
  | Just pp_op :: SDoc
pp_op <- HsExpr (GhcPass p) -> Maybe SDoc
forall (pass :: Pass).
OutputableBndr (IdP (GhcPass pass)) =>
HsExpr (GhcPass pass) -> Maybe SDoc
should_print_infix (LHsExpr (GhcPass p) -> SrcSpanLess (LHsExpr (GhcPass p))
forall a. HasSrcSpan a => a -> SrcSpanLess a
unLoc LHsExpr (GhcPass p)
op)
  = SDoc -> SDoc
pp_infixly SDoc
pp_op
  | Bool
otherwise
  = SDoc
pp_prefixly

  where
    should_print_infix :: HsExpr (GhcPass pass) -> Maybe SDoc
should_print_infix (HsVar _ (L _ v :: IdP (GhcPass pass)
v)) = SDoc -> Maybe SDoc
forall a. a -> Maybe a
Just (IdP (GhcPass pass) -> SDoc
forall a. OutputableBndr a => a -> SDoc
pprInfixOcc IdP (GhcPass pass)
v)
    should_print_infix (HsConLikeOut _ c :: ConLike
c)= SDoc -> Maybe SDoc
forall a. a -> Maybe a
Just (Name -> SDoc
forall a. OutputableBndr a => a -> SDoc
pprInfixOcc (ConLike -> Name
conLikeName ConLike
c))
    should_print_infix (HsRecFld _ f :: AmbiguousFieldOcc (GhcPass pass)
f)    = SDoc -> Maybe SDoc
forall a. a -> Maybe a
Just (AmbiguousFieldOcc (GhcPass pass) -> SDoc
forall a. OutputableBndr a => a -> SDoc
pprInfixOcc AmbiguousFieldOcc (GhcPass pass)
f)
    should_print_infix (HsUnboundVar _ h :: UnboundVar
h@TrueExprHole{})
                                       = SDoc -> Maybe SDoc
forall a. a -> Maybe a
Just (OccName -> SDoc
forall a. OutputableBndr a => a -> SDoc
pprInfixOcc (UnboundVar -> OccName
unboundVarOcc UnboundVar
h))
    should_print_infix (EWildPat _)    = SDoc -> Maybe SDoc
forall a. a -> Maybe a
Just (String -> SDoc
text "`_`")
    should_print_infix (HsWrap _ _ e :: HsExpr (GhcPass pass)
e)  = HsExpr (GhcPass pass) -> Maybe SDoc
should_print_infix HsExpr (GhcPass pass)
e
    should_print_infix _               = Maybe SDoc
forall a. Maybe a
Nothing

    pp_e1 :: SDoc
pp_e1 = PprPrec -> LHsExpr (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
PprPrec -> LHsExpr (GhcPass p) -> SDoc
pprDebugParendExpr PprPrec
opPrec LHsExpr (GhcPass p)
e1   -- In debug mode, add parens
    pp_e2 :: SDoc
pp_e2 = PprPrec -> LHsExpr (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
PprPrec -> LHsExpr (GhcPass p) -> SDoc
pprDebugParendExpr PprPrec
opPrec LHsExpr (GhcPass p)
e2   -- to make precedence clear

    pp_prefixly :: SDoc
pp_prefixly
      = SDoc -> Int -> SDoc -> SDoc
hang (LHsExpr (GhcPass p) -> SDoc
forall a. Outputable a => a -> SDoc
ppr LHsExpr (GhcPass p)
op) 2 ([SDoc] -> SDoc
sep [SDoc
pp_e1, SDoc
pp_e2])

    pp_infixly :: SDoc -> SDoc
pp_infixly pp_op :: SDoc
pp_op
      = SDoc -> Int -> SDoc -> SDoc
hang SDoc
pp_e1 2 ([SDoc] -> SDoc
sep [SDoc
pp_op, Int -> SDoc -> SDoc
nest 2 SDoc
pp_e2])

ppr_expr (NegApp _ e :: LHsExpr (GhcPass p)
e _) = Char -> SDoc
char '-' SDoc -> SDoc -> SDoc
<+> PprPrec -> LHsExpr (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
PprPrec -> LHsExpr (GhcPass p) -> SDoc
pprDebugParendExpr PprPrec
appPrec LHsExpr (GhcPass p)
e

ppr_expr (SectionL _ expr :: LHsExpr (GhcPass p)
expr op :: LHsExpr (GhcPass p)
op)
  = case LHsExpr (GhcPass p) -> SrcSpanLess (LHsExpr (GhcPass p))
forall a. HasSrcSpan a => a -> SrcSpanLess a
unLoc LHsExpr (GhcPass p)
op of
      HsVar _ (L _ v)  -> IdP (GhcPass p) -> SDoc
forall a. OutputableBndr a => a -> SDoc
pp_infixly IdP (GhcPass p)
v
      HsConLikeOut _ c -> Name -> SDoc
forall a. OutputableBndr a => a -> SDoc
pp_infixly (ConLike -> Name
conLikeName ConLike
c)
      HsUnboundVar _ h@TrueExprHole{}
                       -> OccName -> SDoc
forall a. OutputableBndr a => a -> SDoc
pp_infixly (UnboundVar -> OccName
unboundVarOcc UnboundVar
h)
      _                -> SDoc
pp_prefixly
  where
    pp_expr :: SDoc
pp_expr = PprPrec -> LHsExpr (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
PprPrec -> LHsExpr (GhcPass p) -> SDoc
pprDebugParendExpr PprPrec
opPrec LHsExpr (GhcPass p)
expr

    pp_prefixly :: SDoc
pp_prefixly = SDoc -> Int -> SDoc -> SDoc
hang ([SDoc] -> SDoc
hsep [String -> SDoc
text " \\ x_ ->", LHsExpr (GhcPass p) -> SDoc
forall a. Outputable a => a -> SDoc
ppr LHsExpr (GhcPass p)
op])
                       4 ([SDoc] -> SDoc
hsep [SDoc
pp_expr, String -> SDoc
text "x_ )"])

    pp_infixly :: forall a. (OutputableBndr a) => a -> SDoc
    pp_infixly :: a -> SDoc
pp_infixly v :: a
v = ([SDoc] -> SDoc
sep [SDoc
pp_expr, a -> SDoc
forall a. OutputableBndr a => a -> SDoc
pprInfixOcc a
v])

ppr_expr (SectionR _ op :: LHsExpr (GhcPass p)
op expr :: LHsExpr (GhcPass p)
expr)
  = case LHsExpr (GhcPass p) -> SrcSpanLess (LHsExpr (GhcPass p))
forall a. HasSrcSpan a => a -> SrcSpanLess a
unLoc LHsExpr (GhcPass p)
op of
      HsVar _ (L _ v)  -> IdP (GhcPass p) -> SDoc
forall a. OutputableBndr a => a -> SDoc
pp_infixly IdP (GhcPass p)
v
      HsConLikeOut _ c -> Name -> SDoc
forall a. OutputableBndr a => a -> SDoc
pp_infixly (ConLike -> Name
conLikeName ConLike
c)
      HsUnboundVar _ h@TrueExprHole{}
                       -> OccName -> SDoc
forall a. OutputableBndr a => a -> SDoc
pp_infixly (UnboundVar -> OccName
unboundVarOcc UnboundVar
h)
      _                -> SDoc
pp_prefixly
  where
    pp_expr :: SDoc
pp_expr = PprPrec -> LHsExpr (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
PprPrec -> LHsExpr (GhcPass p) -> SDoc
pprDebugParendExpr PprPrec
opPrec LHsExpr (GhcPass p)
expr

    pp_prefixly :: SDoc
pp_prefixly = SDoc -> Int -> SDoc -> SDoc
hang ([SDoc] -> SDoc
hsep [String -> SDoc
text "( \\ x_ ->", LHsExpr (GhcPass p) -> SDoc
forall a. Outputable a => a -> SDoc
ppr LHsExpr (GhcPass p)
op, String -> SDoc
text "x_"])
                       4 (SDoc
pp_expr SDoc -> SDoc -> SDoc
<> SDoc
rparen)

    pp_infixly :: forall a. (OutputableBndr a) => a -> SDoc
    pp_infixly :: a -> SDoc
pp_infixly v :: a
v = [SDoc] -> SDoc
sep [a -> SDoc
forall a. OutputableBndr a => a -> SDoc
pprInfixOcc a
v, SDoc
pp_expr]

ppr_expr (ExplicitTuple _ exprs :: [LHsTupArg (GhcPass p)]
exprs boxity :: Boxity
boxity)
  = TupleSort -> SDoc -> SDoc
tupleParens (Boxity -> TupleSort
boxityTupleSort Boxity
boxity) ([SDoc] -> SDoc
fcat ([HsTupArg (GhcPass p)] -> [SDoc]
forall (p :: Pass).
(OutputableBndr (IdP (GhcPass (NoGhcTcPass p))),
 OutputableBndr (NameOrRdrName (IdP (GhcPass (NoGhcTcPass p)))),
 OutputableBndr (IdP (GhcPass p)),
 OutputableBndr (NameOrRdrName (IdP (GhcPass p))),
 Outputable (XIPBinds (GhcPass p)),
 Outputable (XViaStrategy (GhcPass p)),
 Outputable (XIPBinds (GhcPass (NoGhcTcPass p))),
 Outputable (XViaStrategy (GhcPass (NoGhcTcPass p))),
 NoGhcTcPass p ~ NoGhcTcPass (NoGhcTcPass p)) =>
[HsTupArg (GhcPass p)] -> [SDoc]
ppr_tup_args ([HsTupArg (GhcPass p)] -> [SDoc])
-> [HsTupArg (GhcPass p)] -> [SDoc]
forall a b. (a -> b) -> a -> b
$ (LHsTupArg (GhcPass p) -> HsTupArg (GhcPass p))
-> [LHsTupArg (GhcPass p)] -> [HsTupArg (GhcPass p)]
forall a b. (a -> b) -> [a] -> [b]
map LHsTupArg (GhcPass p) -> HsTupArg (GhcPass p)
forall a. HasSrcSpan a => a -> SrcSpanLess a
unLoc [LHsTupArg (GhcPass p)]
exprs))
  where
    ppr_tup_args :: [HsTupArg (GhcPass p)] -> [SDoc]
ppr_tup_args []               = []
    ppr_tup_args (Present _ e :: LHsExpr (GhcPass p)
e : es :: [HsTupArg (GhcPass p)]
es) = (LHsExpr (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
LHsExpr (GhcPass p) -> SDoc
ppr_lexpr LHsExpr (GhcPass p)
e SDoc -> SDoc -> SDoc
<> [HsTupArg (GhcPass p)] -> SDoc
forall id. [HsTupArg id] -> SDoc
punc [HsTupArg (GhcPass p)]
es) SDoc -> [SDoc] -> [SDoc]
forall a. a -> [a] -> [a]
: [HsTupArg (GhcPass p)] -> [SDoc]
ppr_tup_args [HsTupArg (GhcPass p)]
es
    ppr_tup_args (Missing _   : es :: [HsTupArg (GhcPass p)]
es) = [HsTupArg (GhcPass p)] -> SDoc
forall id. [HsTupArg id] -> SDoc
punc [HsTupArg (GhcPass p)]
es SDoc -> [SDoc] -> [SDoc]
forall a. a -> [a] -> [a]
: [HsTupArg (GhcPass p)] -> [SDoc]
ppr_tup_args [HsTupArg (GhcPass p)]
es
    ppr_tup_args (XTupArg x :: XXTupArg (GhcPass p)
x   : es :: [HsTupArg (GhcPass p)]
es) = (NoExt -> SDoc
forall a. Outputable a => a -> SDoc
ppr XXTupArg (GhcPass p)
NoExt
x SDoc -> SDoc -> SDoc
<> [HsTupArg (GhcPass p)] -> SDoc
forall id. [HsTupArg id] -> SDoc
punc [HsTupArg (GhcPass p)]
es) SDoc -> [SDoc] -> [SDoc]
forall a. a -> [a] -> [a]
: [HsTupArg (GhcPass p)] -> [SDoc]
ppr_tup_args [HsTupArg (GhcPass p)]
es

    punc :: [HsTupArg id] -> SDoc
punc (Present {} : _) = SDoc
comma SDoc -> SDoc -> SDoc
<> SDoc
space
    punc (Missing {} : _) = SDoc
comma
    punc (XTupArg {} : _) = SDoc
comma SDoc -> SDoc -> SDoc
<> SDoc
space
    punc []               = SDoc
empty

ppr_expr (ExplicitSum _ alt :: Int
alt arity :: Int
arity expr :: LHsExpr (GhcPass p)
expr)
  = String -> SDoc
text "(#" SDoc -> SDoc -> SDoc
<+> Int -> SDoc
ppr_bars (Int
alt Int -> Int -> Int
forall a. Num a => a -> a -> a
- 1) SDoc -> SDoc -> SDoc
<+> LHsExpr (GhcPass p) -> SDoc
forall a. Outputable a => a -> SDoc
ppr LHsExpr (GhcPass p)
expr SDoc -> SDoc -> SDoc
<+> Int -> SDoc
ppr_bars (Int
arity Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
alt) SDoc -> SDoc -> SDoc
<+> String -> SDoc
text "#)"
  where
    ppr_bars :: Int -> SDoc
ppr_bars n :: Int
n = [SDoc] -> SDoc
hsep (Int -> SDoc -> [SDoc]
forall a. Int -> a -> [a]
replicate Int
n (Char -> SDoc
char '|'))

ppr_expr (HsLam _ matches :: MatchGroup (GhcPass p) (LHsExpr (GhcPass p))
matches)
  = MatchGroup (GhcPass p) (LHsExpr (GhcPass p)) -> SDoc
forall (idR :: Pass) body.
(OutputableBndrId (GhcPass idR), Outputable body) =>
MatchGroup (GhcPass idR) body -> SDoc
pprMatches MatchGroup (GhcPass p) (LHsExpr (GhcPass p))
matches

ppr_expr (HsLamCase _ matches :: MatchGroup (GhcPass p) (LHsExpr (GhcPass p))
matches)
  = [SDoc] -> SDoc
sep [ [SDoc] -> SDoc
sep [String -> SDoc
text "\\case"],
          Int -> SDoc -> SDoc
nest 2 (MatchGroup (GhcPass p) (LHsExpr (GhcPass p)) -> SDoc
forall (idR :: Pass) body.
(OutputableBndrId (GhcPass idR), Outputable body) =>
MatchGroup (GhcPass idR) body -> SDoc
pprMatches MatchGroup (GhcPass p) (LHsExpr (GhcPass p))
matches) ]

ppr_expr (HsCase _ expr :: LHsExpr (GhcPass p)
expr matches :: MatchGroup (GhcPass p) (LHsExpr (GhcPass p))
matches@(MG { mg_alts :: forall p body. MatchGroup p body -> Located [LMatch p body]
mg_alts = L _ [_] }))
  = [SDoc] -> SDoc
sep [ [SDoc] -> SDoc
sep [String -> SDoc
text "case", Int -> SDoc -> SDoc
nest 4 (LHsExpr (GhcPass p) -> SDoc
forall a. Outputable a => a -> SDoc
ppr LHsExpr (GhcPass p)
expr), PtrString -> SDoc
ptext (String -> PtrString
sLit "of {")],
          Int -> SDoc -> SDoc
nest 2 (MatchGroup (GhcPass p) (LHsExpr (GhcPass p)) -> SDoc
forall (idR :: Pass) body.
(OutputableBndrId (GhcPass idR), Outputable body) =>
MatchGroup (GhcPass idR) body -> SDoc
pprMatches MatchGroup (GhcPass p) (LHsExpr (GhcPass p))
matches) SDoc -> SDoc -> SDoc
<+> Char -> SDoc
char '}']
ppr_expr (HsCase _ expr :: LHsExpr (GhcPass p)
expr matches :: MatchGroup (GhcPass p) (LHsExpr (GhcPass p))
matches)
  = [SDoc] -> SDoc
sep [ [SDoc] -> SDoc
sep [String -> SDoc
text "case", Int -> SDoc -> SDoc
nest 4 (LHsExpr (GhcPass p) -> SDoc
forall a. Outputable a => a -> SDoc
ppr LHsExpr (GhcPass p)
expr), PtrString -> SDoc
ptext (String -> PtrString
sLit "of")],
          Int -> SDoc -> SDoc
nest 2 (MatchGroup (GhcPass p) (LHsExpr (GhcPass p)) -> SDoc
forall (idR :: Pass) body.
(OutputableBndrId (GhcPass idR), Outputable body) =>
MatchGroup (GhcPass idR) body -> SDoc
pprMatches MatchGroup (GhcPass p) (LHsExpr (GhcPass p))
matches) ]

ppr_expr (HsIf _ _ e1 :: LHsExpr (GhcPass p)
e1 e2 :: LHsExpr (GhcPass p)
e2 e3 :: LHsExpr (GhcPass p)
e3)
  = [SDoc] -> SDoc
sep [[SDoc] -> SDoc
hsep [String -> SDoc
text "if", Int -> SDoc -> SDoc
nest 2 (LHsExpr (GhcPass p) -> SDoc
forall a. Outputable a => a -> SDoc
ppr LHsExpr (GhcPass p)
e1), PtrString -> SDoc
ptext (String -> PtrString
sLit "then")],
         Int -> SDoc -> SDoc
nest 4 (LHsExpr (GhcPass p) -> SDoc
forall a. Outputable a => a -> SDoc
ppr LHsExpr (GhcPass p)
e2),
         String -> SDoc
text "else",
         Int -> SDoc -> SDoc
nest 4 (LHsExpr (GhcPass p) -> SDoc
forall a. Outputable a => a -> SDoc
ppr LHsExpr (GhcPass p)
e3)]

ppr_expr (HsMultiIf _ alts :: [LGRHS (GhcPass p) (LHsExpr (GhcPass p))]
alts)
  = SDoc -> Int -> SDoc -> SDoc
hang (String -> SDoc
text "if") 3  ([SDoc] -> SDoc
vcat ((LGRHS (GhcPass p) (LHsExpr (GhcPass p)) -> SDoc)
-> [LGRHS (GhcPass p) (LHsExpr (GhcPass p))] -> [SDoc]
forall a b. (a -> b) -> [a] -> [b]
map LGRHS (GhcPass p) (LHsExpr (GhcPass p)) -> SDoc
forall (pass :: Pass) a l.
(OutputableBndr (NameOrRdrName (IdP (GhcPass (NoGhcTcPass pass)))),
 OutputableBndr (IdP (GhcPass pass)),
 OutputableBndr (NameOrRdrName (IdP (GhcPass pass))),
 OutputableBndr (IdP (GhcPass (NoGhcTcPass pass))),
 Outputable (XIPBinds (GhcPass (NoGhcTcPass pass))),
 Outputable (XViaStrategy (GhcPass (NoGhcTcPass pass))),
 Outputable (XIPBinds (GhcPass pass)),
 Outputable (XViaStrategy (GhcPass pass)), Outputable a,
 NoGhcTcPass pass ~ NoGhcTcPass (NoGhcTcPass pass)) =>
GenLocated l (GRHS (GhcPass pass) a) -> SDoc
ppr_alt [LGRHS (GhcPass p) (LHsExpr (GhcPass p))]
alts))
  where ppr_alt :: GenLocated l (GRHS (GhcPass pass) a) -> SDoc
ppr_alt (L _ (GRHS _ guards :: [GuardLStmt (GhcPass pass)]
guards expr :: a
expr)) =
          SDoc -> Int -> SDoc -> SDoc
hang SDoc
vbar 2 ([SDoc] -> SDoc
ppr_one [SDoc]
one_alt)
          where
            ppr_one :: [SDoc] -> SDoc
ppr_one [] = String -> SDoc
forall a. String -> a
panic "ppr_exp HsMultiIf"
            ppr_one (h :: SDoc
h:t :: [SDoc]
t) = SDoc -> Int -> SDoc -> SDoc
hang SDoc
h 2 ([SDoc] -> SDoc
sep [SDoc]
t)
            one_alt :: [SDoc]
one_alt = [ [GuardLStmt (GhcPass pass)] -> SDoc
forall a. Outputable a => [a] -> SDoc
interpp'SP [GuardLStmt (GhcPass pass)]
guards
                      , String -> SDoc
text "->" SDoc -> SDoc -> SDoc
<+> SDoc -> SDoc
pprDeeper (a -> SDoc
forall a. Outputable a => a -> SDoc
ppr a
expr) ]
        ppr_alt (L _ (XGRHS x :: XXGRHS (GhcPass pass) a
x)) = NoExt -> SDoc
forall a. Outputable a => a -> SDoc
ppr XXGRHS (GhcPass pass) a
NoExt
x

-- special case: let ... in let ...
ppr_expr (HsLet _ (L _ binds :: HsLocalBinds (GhcPass p)
binds) expr :: LHsExpr (GhcPass p)
expr@(L _ (HsLet _ _ _)))
  = [SDoc] -> SDoc
sep [SDoc -> Int -> SDoc -> SDoc
hang (String -> SDoc
text "let") 2 ([SDoc] -> SDoc
hsep [HsLocalBinds (GhcPass p) -> SDoc
forall (idL :: Pass) (idR :: Pass).
(OutputableBndrId (GhcPass idL), OutputableBndrId (GhcPass idR)) =>
HsLocalBindsLR (GhcPass idL) (GhcPass idR) -> SDoc
pprBinds HsLocalBinds (GhcPass p)
binds, PtrString -> SDoc
ptext (String -> PtrString
sLit "in")]),
         LHsExpr (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
LHsExpr (GhcPass p) -> SDoc
ppr_lexpr LHsExpr (GhcPass p)
expr]

ppr_expr (HsLet _ (L _ binds :: HsLocalBinds (GhcPass p)
binds) expr :: LHsExpr (GhcPass p)
expr)
  = [SDoc] -> SDoc
sep [SDoc -> Int -> SDoc -> SDoc
hang (String -> SDoc
text "let") 2 (HsLocalBinds (GhcPass p) -> SDoc
forall (idL :: Pass) (idR :: Pass).
(OutputableBndrId (GhcPass idL), OutputableBndrId (GhcPass idR)) =>
HsLocalBindsLR (GhcPass idL) (GhcPass idR) -> SDoc
pprBinds HsLocalBinds (GhcPass p)
binds),
         SDoc -> Int -> SDoc -> SDoc
hang (String -> SDoc
text "in")  2 (LHsExpr (GhcPass p) -> SDoc
forall a. Outputable a => a -> SDoc
ppr LHsExpr (GhcPass p)
expr)]

ppr_expr (HsDo _ do_or_list_comp :: HsStmtContext Name
do_or_list_comp (L _ stmts :: [ExprLStmt (GhcPass p)]
stmts)) = HsStmtContext Name -> [ExprLStmt (GhcPass p)] -> SDoc
forall (p :: Pass) body any.
(OutputableBndrId (GhcPass p), Outputable body) =>
HsStmtContext any -> [LStmt (GhcPass p) body] -> SDoc
pprDo HsStmtContext Name
do_or_list_comp [ExprLStmt (GhcPass p)]
stmts

ppr_expr (ExplicitList _ _ exprs :: [LHsExpr (GhcPass p)]
exprs)
  = SDoc -> SDoc
brackets (([SDoc] -> SDoc) -> [SDoc] -> SDoc
pprDeeperList [SDoc] -> SDoc
fsep (SDoc -> [SDoc] -> [SDoc]
punctuate SDoc
comma ((LHsExpr (GhcPass p) -> SDoc) -> [LHsExpr (GhcPass p)] -> [SDoc]
forall a b. (a -> b) -> [a] -> [b]
map LHsExpr (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
LHsExpr (GhcPass p) -> SDoc
ppr_lexpr [LHsExpr (GhcPass p)]
exprs)))

ppr_expr (RecordCon { rcon_con_name :: forall p. HsExpr p -> Located (IdP p)
rcon_con_name = GenLocated SrcSpan (IdP (GhcPass p))
con_id, rcon_flds :: forall p. HsExpr p -> HsRecordBinds p
rcon_flds = HsRecordBinds (GhcPass p)
rbinds })
  = SDoc -> Int -> SDoc -> SDoc
hang (GenLocated SrcSpan (IdP (GhcPass p)) -> SDoc
forall a. Outputable a => a -> SDoc
ppr GenLocated SrcSpan (IdP (GhcPass p))
con_id) 2 (HsRecordBinds (GhcPass p) -> SDoc
forall a. Outputable a => a -> SDoc
ppr HsRecordBinds (GhcPass p)
rbinds)

ppr_expr (RecordUpd { rupd_expr :: forall p. HsExpr p -> LHsExpr p
rupd_expr = L _ aexp :: HsExpr (GhcPass p)
aexp, rupd_flds :: forall p. HsExpr p -> [LHsRecUpdField p]
rupd_flds = [LHsRecUpdField (GhcPass p)]
rbinds })
  = SDoc -> Int -> SDoc -> SDoc
hang (HsExpr (GhcPass p) -> SDoc
forall a. Outputable a => a -> SDoc
ppr HsExpr (GhcPass p)
aexp) 2 (SDoc -> SDoc
braces ([SDoc] -> SDoc
fsep (SDoc -> [SDoc] -> [SDoc]
punctuate SDoc
comma ((LHsRecUpdField (GhcPass p) -> SDoc)
-> [LHsRecUpdField (GhcPass p)] -> [SDoc]
forall a b. (a -> b) -> [a] -> [b]
map LHsRecUpdField (GhcPass p) -> SDoc
forall a. Outputable a => a -> SDoc
ppr [LHsRecUpdField (GhcPass p)]
rbinds))))

ppr_expr (ExprWithTySig _ expr :: LHsExpr (GhcPass p)
expr sig :: LHsSigWcType (NoGhcTc (GhcPass p))
sig)
  = SDoc -> Int -> SDoc -> SDoc
hang (Int -> SDoc -> SDoc
nest 2 (LHsExpr (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
LHsExpr (GhcPass p) -> SDoc
ppr_lexpr LHsExpr (GhcPass p)
expr) SDoc -> SDoc -> SDoc
<+> SDoc
dcolon)
         4 (LHsSigWcType (GhcPass (NoGhcTcPass (NoGhcTcPass p))) -> SDoc
forall a. Outputable a => a -> SDoc
ppr LHsSigWcType (NoGhcTc (GhcPass p))
LHsSigWcType (GhcPass (NoGhcTcPass (NoGhcTcPass p)))
sig)

ppr_expr (ArithSeq _ _ info :: ArithSeqInfo (GhcPass p)
info) = SDoc -> SDoc
brackets (ArithSeqInfo (GhcPass p) -> SDoc
forall a. Outputable a => a -> SDoc
ppr ArithSeqInfo (GhcPass p)
info)

ppr_expr (EWildPat _)     = Char -> SDoc
char '_'
ppr_expr (ELazyPat _ e :: LHsExpr (GhcPass p)
e)   = Char -> SDoc
char '~' SDoc -> SDoc -> SDoc
<> LHsExpr (GhcPass p) -> SDoc
forall a. Outputable a => a -> SDoc
ppr LHsExpr (GhcPass p)
e
ppr_expr (EAsPat _ (L _ v :: IdP (GhcPass p)
v) e :: LHsExpr (GhcPass p)
e) = IdP (GhcPass p) -> SDoc
forall a. OutputableBndr a => a -> SDoc
pprPrefixOcc IdP (GhcPass p)
v SDoc -> SDoc -> SDoc
<> Char -> SDoc
char '@' SDoc -> SDoc -> SDoc
<> LHsExpr (GhcPass p) -> SDoc
forall a. Outputable a => a -> SDoc
ppr LHsExpr (GhcPass p)
e
ppr_expr (EViewPat _ p :: LHsExpr (GhcPass p)
p e :: LHsExpr (GhcPass p)
e) = LHsExpr (GhcPass p) -> SDoc
forall a. Outputable a => a -> SDoc
ppr LHsExpr (GhcPass p)
p SDoc -> SDoc -> SDoc
<+> String -> SDoc
text "->" SDoc -> SDoc -> SDoc
<+> LHsExpr (GhcPass p) -> SDoc
forall a. Outputable a => a -> SDoc
ppr LHsExpr (GhcPass p)
e

ppr_expr (HsSCC _ st :: SourceText
st (StringLiteral stl :: SourceText
stl lbl :: FastString
lbl) expr :: LHsExpr (GhcPass p)
expr)
  = [SDoc] -> SDoc
sep [ SourceText -> SDoc -> SDoc
pprWithSourceText SourceText
st (String -> SDoc
text "{-# SCC")
         -- no doublequotes if stl empty, for the case where the SCC was written
         -- without quotes.
          SDoc -> SDoc -> SDoc
<+> SourceText -> SDoc -> SDoc
pprWithSourceText SourceText
stl (FastString -> SDoc
ftext FastString
lbl) SDoc -> SDoc -> SDoc
<+> String -> SDoc
text "#-}",
          LHsExpr (GhcPass p) -> SDoc
forall a. Outputable a => a -> SDoc
ppr LHsExpr (GhcPass p)
expr ]

ppr_expr (HsWrap _ co_fn :: HsWrapper
co_fn e :: HsExpr (GhcPass p)
e)
  = HsWrapper -> (Bool -> SDoc) -> SDoc
pprHsWrapper HsWrapper
co_fn (\parens :: Bool
parens -> if Bool
parens then HsExpr (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
HsExpr (GhcPass p) -> SDoc
pprExpr HsExpr (GhcPass p)
e
                                             else HsExpr (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
HsExpr (GhcPass p) -> SDoc
pprExpr HsExpr (GhcPass p)
e)

ppr_expr (HsSpliceE _ s :: HsSplice (GhcPass p)
s)         = HsSplice (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
HsSplice (GhcPass p) -> SDoc
pprSplice HsSplice (GhcPass p)
s
ppr_expr (HsBracket _ b :: HsBracket (GhcPass p)
b)         = HsBracket (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
HsBracket (GhcPass p) -> SDoc
pprHsBracket HsBracket (GhcPass p)
b
ppr_expr (HsRnBracketOut _ e :: HsBracket GhcRn
e []) = HsBracket GhcRn -> SDoc
forall a. Outputable a => a -> SDoc
ppr HsBracket GhcRn
e
ppr_expr (HsRnBracketOut _ e :: HsBracket GhcRn
e ps :: [PendingRnSplice]
ps) = HsBracket GhcRn -> SDoc
forall a. Outputable a => a -> SDoc
ppr HsBracket GhcRn
e SDoc -> SDoc -> SDoc
$$ String -> SDoc
text "pending(rn)" SDoc -> SDoc -> SDoc
<+> [PendingRnSplice] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [PendingRnSplice]
ps
ppr_expr (HsTcBracketOut _ e :: HsBracket GhcRn
e []) = HsBracket GhcRn -> SDoc
forall a. Outputable a => a -> SDoc
ppr HsBracket GhcRn
e
ppr_expr (HsTcBracketOut _ e :: HsBracket GhcRn
e ps :: [PendingTcSplice]
ps) = HsBracket GhcRn -> SDoc
forall a. Outputable a => a -> SDoc
ppr HsBracket GhcRn
e SDoc -> SDoc -> SDoc
$$ String -> SDoc
text "pending(tc)" SDoc -> SDoc -> SDoc
<+> [PendingTcSplice] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [PendingTcSplice]
ps

ppr_expr (HsProc _ pat :: LPat (GhcPass p)
pat (L _ (HsCmdTop _ cmd :: LHsCmd (GhcPass p)
cmd)))
  = [SDoc] -> SDoc
hsep [String -> SDoc
text "proc", LPat (GhcPass p) -> SDoc
forall a. Outputable a => a -> SDoc
ppr LPat (GhcPass p)
pat, PtrString -> SDoc
ptext (String -> PtrString
sLit "->"), LHsCmd (GhcPass p) -> SDoc
forall a. Outputable a => a -> SDoc
ppr LHsCmd (GhcPass p)
cmd]
ppr_expr (HsProc _ pat :: LPat (GhcPass p)
pat (L _ (XCmdTop x :: XXCmdTop (GhcPass p)
x)))
  = [SDoc] -> SDoc
hsep [String -> SDoc
text "proc", LPat (GhcPass p) -> SDoc
forall a. Outputable a => a -> SDoc
ppr LPat (GhcPass p)
pat, PtrString -> SDoc
ptext (String -> PtrString
sLit "->"), NoExt -> SDoc
forall a. Outputable a => a -> SDoc
ppr XXCmdTop (GhcPass p)
NoExt
x]

ppr_expr (HsStatic _ e :: LHsExpr (GhcPass p)
e)
  = [SDoc] -> SDoc
hsep [String -> SDoc
text "static", LHsExpr (GhcPass p) -> SDoc
forall a. Outputable a => a -> SDoc
ppr LHsExpr (GhcPass p)
e]

ppr_expr (HsTick _ tickish :: Tickish (IdP (GhcPass p))
tickish exp :: LHsExpr (GhcPass p)
exp)
  = SDoc -> SDoc -> SDoc
pprTicks (LHsExpr (GhcPass p) -> SDoc
forall a. Outputable a => a -> SDoc
ppr LHsExpr (GhcPass p)
exp) (SDoc -> SDoc) -> SDoc -> SDoc
forall a b. (a -> b) -> a -> b
$
    Tickish (IdP (GhcPass p)) -> SDoc
forall a. Outputable a => a -> SDoc
ppr Tickish (IdP (GhcPass p))
tickish SDoc -> SDoc -> SDoc
<+> LHsExpr (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
LHsExpr (GhcPass p) -> SDoc
ppr_lexpr LHsExpr (GhcPass p)
exp
ppr_expr (HsBinTick _ tickIdTrue :: Int
tickIdTrue tickIdFalse :: Int
tickIdFalse exp :: LHsExpr (GhcPass p)
exp)
  = SDoc -> SDoc -> SDoc
pprTicks (LHsExpr (GhcPass p) -> SDoc
forall a. Outputable a => a -> SDoc
ppr LHsExpr (GhcPass p)
exp) (SDoc -> SDoc) -> SDoc -> SDoc
forall a b. (a -> b) -> a -> b
$
    [SDoc] -> SDoc
hcat [String -> SDoc
text "bintick<",
          Int -> SDoc
forall a. Outputable a => a -> SDoc
ppr Int
tickIdTrue,
          String -> SDoc
text ",",
          Int -> SDoc
forall a. Outputable a => a -> SDoc
ppr Int
tickIdFalse,
          String -> SDoc
text ">(",
          LHsExpr (GhcPass p) -> SDoc
forall a. Outputable a => a -> SDoc
ppr LHsExpr (GhcPass p)
exp, String -> SDoc
text ")"]
ppr_expr (HsTickPragma _ _ externalSrcLoc :: (StringLiteral, (Int, Int), (Int, Int))
externalSrcLoc _ exp :: LHsExpr (GhcPass p)
exp)
  = SDoc -> SDoc -> SDoc
pprTicks (LHsExpr (GhcPass p) -> SDoc
forall a. Outputable a => a -> SDoc
ppr LHsExpr (GhcPass p)
exp) (SDoc -> SDoc) -> SDoc -> SDoc
forall a b. (a -> b) -> a -> b
$
    [SDoc] -> SDoc
hcat [String -> SDoc
text "tickpragma<",
          (StringLiteral, (Int, Int), (Int, Int)) -> SDoc
pprExternalSrcLoc (StringLiteral, (Int, Int), (Int, Int))
externalSrcLoc,
          String -> SDoc
text ">(",
          LHsExpr (GhcPass p) -> SDoc
forall a. Outputable a => a -> SDoc
ppr LHsExpr (GhcPass p)
exp,
          String -> SDoc
text ")"]

ppr_expr (HsArrApp _ arrow :: LHsExpr (GhcPass p)
arrow arg :: LHsExpr (GhcPass p)
arg HsFirstOrderApp True)
  = [SDoc] -> SDoc
hsep [LHsExpr (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
LHsExpr (GhcPass p) -> SDoc
ppr_lexpr LHsExpr (GhcPass p)
arrow, SDoc
larrowt, LHsExpr (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
LHsExpr (GhcPass p) -> SDoc
ppr_lexpr LHsExpr (GhcPass p)
arg]
ppr_expr (HsArrApp _ arrow :: LHsExpr (GhcPass p)
arrow arg :: LHsExpr (GhcPass p)
arg HsFirstOrderApp False)
  = [SDoc] -> SDoc
hsep [LHsExpr (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
LHsExpr (GhcPass p) -> SDoc
ppr_lexpr LHsExpr (GhcPass p)
arg, SDoc
arrowt, LHsExpr (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
LHsExpr (GhcPass p) -> SDoc
ppr_lexpr LHsExpr (GhcPass p)
arrow]
ppr_expr (HsArrApp _ arrow :: LHsExpr (GhcPass p)
arrow arg :: LHsExpr (GhcPass p)
arg HsHigherOrderApp True)
  = [SDoc] -> SDoc
hsep [LHsExpr (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
LHsExpr (GhcPass p) -> SDoc
ppr_lexpr LHsExpr (GhcPass p)
arrow, SDoc
larrowtt, LHsExpr (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
LHsExpr (GhcPass p) -> SDoc
ppr_lexpr LHsExpr (GhcPass p)
arg]
ppr_expr (HsArrApp _ arrow :: LHsExpr (GhcPass p)
arrow arg :: LHsExpr (GhcPass p)
arg HsHigherOrderApp False)
  = [SDoc] -> SDoc
hsep [LHsExpr (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
LHsExpr (GhcPass p) -> SDoc
ppr_lexpr LHsExpr (GhcPass p)
arg, SDoc
arrowtt, LHsExpr (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
LHsExpr (GhcPass p) -> SDoc
ppr_lexpr LHsExpr (GhcPass p)
arrow]

ppr_expr (HsArrForm _ (L _ (HsVar _ (L _ v :: IdP (GhcPass p)
v))) (Just _) [arg1 :: GenLocated SrcSpan (HsCmdTop (GhcPass p))
arg1, arg2 :: GenLocated SrcSpan (HsCmdTop (GhcPass p))
arg2])
  = [SDoc] -> SDoc
sep [HsCmdTop (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
HsCmdTop (GhcPass p) -> SDoc
pprCmdArg (GenLocated SrcSpan (HsCmdTop (GhcPass p))
-> SrcSpanLess (GenLocated SrcSpan (HsCmdTop (GhcPass p)))
forall a. HasSrcSpan a => a -> SrcSpanLess a
unLoc GenLocated SrcSpan (HsCmdTop (GhcPass p))
arg1), [SDoc] -> SDoc
hsep [IdP (GhcPass p) -> SDoc
forall a. OutputableBndr a => a -> SDoc
pprInfixOcc IdP (GhcPass p)
v, HsCmdTop (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
HsCmdTop (GhcPass p) -> SDoc
pprCmdArg (GenLocated SrcSpan (HsCmdTop (GhcPass p))
-> SrcSpanLess (GenLocated SrcSpan (HsCmdTop (GhcPass p)))
forall a. HasSrcSpan a => a -> SrcSpanLess a
unLoc GenLocated SrcSpan (HsCmdTop (GhcPass p))
arg2)]]
ppr_expr (HsArrForm _ (L _ (HsConLikeOut _ c :: ConLike
c)) (Just _) [arg1 :: GenLocated SrcSpan (HsCmdTop (GhcPass p))
arg1, arg2 :: GenLocated SrcSpan (HsCmdTop (GhcPass p))
arg2])
  = [SDoc] -> SDoc
sep [HsCmdTop (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
HsCmdTop (GhcPass p) -> SDoc
pprCmdArg (GenLocated SrcSpan (HsCmdTop (GhcPass p))
-> SrcSpanLess (GenLocated SrcSpan (HsCmdTop (GhcPass p)))
forall a. HasSrcSpan a => a -> SrcSpanLess a
unLoc GenLocated SrcSpan (HsCmdTop (GhcPass p))
arg1), [SDoc] -> SDoc
hsep [Name -> SDoc
forall a. OutputableBndr a => a -> SDoc
pprInfixOcc (ConLike -> Name
conLikeName ConLike
c), HsCmdTop (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
HsCmdTop (GhcPass p) -> SDoc
pprCmdArg (GenLocated SrcSpan (HsCmdTop (GhcPass p))
-> SrcSpanLess (GenLocated SrcSpan (HsCmdTop (GhcPass p)))
forall a. HasSrcSpan a => a -> SrcSpanLess a
unLoc GenLocated SrcSpan (HsCmdTop (GhcPass p))
arg2)]]
ppr_expr (HsArrForm _ op :: LHsExpr (GhcPass p)
op _ args :: [GenLocated SrcSpan (HsCmdTop (GhcPass p))]
args)
  = SDoc -> Int -> SDoc -> SDoc
hang (String -> SDoc
text "(|" SDoc -> SDoc -> SDoc
<+> LHsExpr (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
LHsExpr (GhcPass p) -> SDoc
ppr_lexpr LHsExpr (GhcPass p)
op)
         4 ([SDoc] -> SDoc
sep ((GenLocated SrcSpan (HsCmdTop (GhcPass p)) -> SDoc)
-> [GenLocated SrcSpan (HsCmdTop (GhcPass p))] -> [SDoc]
forall a b. (a -> b) -> [a] -> [b]
map (HsCmdTop (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
HsCmdTop (GhcPass p) -> SDoc
pprCmdArg(HsCmdTop (GhcPass p) -> SDoc)
-> (GenLocated SrcSpan (HsCmdTop (GhcPass p))
    -> HsCmdTop (GhcPass p))
-> GenLocated SrcSpan (HsCmdTop (GhcPass p))
-> SDoc
forall b c a. (b -> c) -> (a -> b) -> a -> c
.GenLocated SrcSpan (HsCmdTop (GhcPass p)) -> HsCmdTop (GhcPass p)
forall a. HasSrcSpan a => a -> SrcSpanLess a
unLoc) [GenLocated SrcSpan (HsCmdTop (GhcPass p))]
args) SDoc -> SDoc -> SDoc
<+> String -> SDoc
text "|)")
ppr_expr (HsRecFld _ f :: AmbiguousFieldOcc (GhcPass p)
f) = AmbiguousFieldOcc (GhcPass p) -> SDoc
forall a. Outputable a => a -> SDoc
ppr AmbiguousFieldOcc (GhcPass p)
f
ppr_expr (XExpr x :: XXExpr (GhcPass p)
x) = NoExt -> SDoc
forall a. Outputable a => a -> SDoc
ppr XXExpr (GhcPass p)
NoExt
x

ppr_apps :: (OutputableBndrId (GhcPass p))
         => HsExpr (GhcPass p)
         -> [Either (LHsExpr (GhcPass p)) (LHsWcType (NoGhcTc (GhcPass p)))]
         -> SDoc
ppr_apps :: HsExpr (GhcPass p)
-> [Either (LHsExpr (GhcPass p)) (LHsWcType (NoGhcTc (GhcPass p)))]
-> SDoc
ppr_apps (HsApp _ (L _ fun :: HsExpr (GhcPass p)
fun) arg :: LHsExpr (GhcPass p)
arg)        args :: [Either (LHsExpr (GhcPass p)) (LHsWcType (NoGhcTc (GhcPass p)))]
args
  = HsExpr (GhcPass p)
-> [Either (LHsExpr (GhcPass p)) (LHsWcType (NoGhcTc (GhcPass p)))]
-> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
HsExpr (GhcPass p)
-> [Either (LHsExpr (GhcPass p)) (LHsWcType (NoGhcTc (GhcPass p)))]
-> SDoc
ppr_apps HsExpr (GhcPass p)
fun (LHsExpr (GhcPass p)
-> Either
     (LHsExpr (GhcPass p))
     (LHsWcType (GhcPass (NoGhcTcPass (NoGhcTcPass p))))
forall a b. a -> Either a b
Left LHsExpr (GhcPass p)
arg Either
  (LHsExpr (GhcPass p))
  (LHsWcType (GhcPass (NoGhcTcPass (NoGhcTcPass p))))
-> [Either
      (LHsExpr (GhcPass p))
      (LHsWcType (GhcPass (NoGhcTcPass (NoGhcTcPass p))))]
-> [Either
      (LHsExpr (GhcPass p))
      (LHsWcType (GhcPass (NoGhcTcPass (NoGhcTcPass p))))]
forall a. a -> [a] -> [a]
: [Either (LHsExpr (GhcPass p)) (LHsWcType (NoGhcTc (GhcPass p)))]
[Either
   (LHsExpr (GhcPass p))
   (LHsWcType (GhcPass (NoGhcTcPass (NoGhcTcPass p))))]
args)
ppr_apps (HsAppType _ (L _ fun :: HsExpr (GhcPass p)
fun) arg :: LHsWcType (NoGhcTc (GhcPass p))
arg)    args :: [Either (LHsExpr (GhcPass p)) (LHsWcType (NoGhcTc (GhcPass p)))]
args
  = HsExpr (GhcPass p)
-> [Either (LHsExpr (GhcPass p)) (LHsWcType (NoGhcTc (GhcPass p)))]
-> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
HsExpr (GhcPass p)
-> [Either (LHsExpr (GhcPass p)) (LHsWcType (NoGhcTc (GhcPass p)))]
-> SDoc
ppr_apps HsExpr (GhcPass p)
fun (LHsWcType (GhcPass (NoGhcTcPass (NoGhcTcPass p)))
-> Either
     (LHsExpr (GhcPass p))
     (LHsWcType (GhcPass (NoGhcTcPass (NoGhcTcPass p))))
forall a b. b -> Either a b
Right LHsWcType (NoGhcTc (GhcPass p))
LHsWcType (GhcPass (NoGhcTcPass (NoGhcTcPass p)))
arg Either
  (LHsExpr (GhcPass p))
  (LHsWcType (GhcPass (NoGhcTcPass (NoGhcTcPass p))))
-> [Either
      (LHsExpr (GhcPass p))
      (LHsWcType (GhcPass (NoGhcTcPass (NoGhcTcPass p))))]
-> [Either
      (LHsExpr (GhcPass p))
      (LHsWcType (GhcPass (NoGhcTcPass (NoGhcTcPass p))))]
forall a. a -> [a] -> [a]
: [Either (LHsExpr (GhcPass p)) (LHsWcType (NoGhcTc (GhcPass p)))]
[Either
   (LHsExpr (GhcPass p))
   (LHsWcType (GhcPass (NoGhcTcPass (NoGhcTcPass p))))]
args)
ppr_apps fun :: HsExpr (GhcPass p)
fun args :: [Either (LHsExpr (GhcPass p)) (LHsWcType (NoGhcTc (GhcPass p)))]
args = SDoc -> Int -> SDoc -> SDoc
hang (HsExpr (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
HsExpr (GhcPass p) -> SDoc
ppr_expr HsExpr (GhcPass p)
fun) 2 ([SDoc] -> SDoc
sep ((Either
   (LHsExpr (GhcPass p))
   (LHsWcType (GhcPass (NoGhcTcPass (NoGhcTcPass p))))
 -> SDoc)
-> [Either
      (LHsExpr (GhcPass p))
      (LHsWcType (GhcPass (NoGhcTcPass (NoGhcTcPass p))))]
-> [SDoc]
forall a b. (a -> b) -> [a] -> [b]
map Either
  (LHsExpr (GhcPass p))
  (LHsWcType (GhcPass (NoGhcTcPass (NoGhcTcPass p))))
-> SDoc
forall a a. (Outputable a, Outputable a) => Either a a -> SDoc
pp [Either (LHsExpr (GhcPass p)) (LHsWcType (NoGhcTc (GhcPass p)))]
[Either
   (LHsExpr (GhcPass p))
   (LHsWcType (GhcPass (NoGhcTcPass (NoGhcTcPass p))))]
args))
  where
    pp :: Either a a -> SDoc
pp (Left arg :: a
arg)                             = a -> SDoc
forall a. Outputable a => a -> SDoc
ppr a
arg
    -- pp (Right (LHsWcTypeX (HsWC { hswc_body = L _ arg })))
    --   = char '@' <> pprHsType arg
    pp (Right arg :: a
arg)
      = Char -> SDoc
char '@' SDoc -> SDoc -> SDoc
<> a -> SDoc
forall a. Outputable a => a -> SDoc
ppr a
arg

pprExternalSrcLoc :: (StringLiteral,(Int,Int),(Int,Int)) -> SDoc
pprExternalSrcLoc :: (StringLiteral, (Int, Int), (Int, Int)) -> SDoc
pprExternalSrcLoc (StringLiteral _ src :: FastString
src,(n1 :: Int
n1,n2 :: Int
n2),(n3 :: Int
n3,n4 :: Int
n4))
  = (FastString, (Int, Int), (Int, Int)) -> SDoc
forall a. Outputable a => a -> SDoc
ppr (FastString
src,(Int
n1,Int
n2),(Int
n3,Int
n4))

{-
HsSyn records exactly where the user put parens, with HsPar.
So generally speaking we print without adding any parens.
However, some code is internally generated, and in some places
parens are absolutely required; so for these places we use
pprParendLExpr (but don't print double parens of course).

For operator applications we don't add parens, because the operator
fixities should do the job, except in debug mode (-dppr-debug) so we
can see the structure of the parse tree.
-}

pprDebugParendExpr :: (OutputableBndrId (GhcPass p))
                   => PprPrec -> LHsExpr (GhcPass p) -> SDoc
pprDebugParendExpr :: PprPrec -> LHsExpr (GhcPass p) -> SDoc
pprDebugParendExpr p :: PprPrec
p expr :: LHsExpr (GhcPass p)
expr
  = (PprStyle -> SDoc) -> SDoc
getPprStyle (\sty :: PprStyle
sty ->
    if PprStyle -> Bool
debugStyle PprStyle
sty then PprPrec -> LHsExpr (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
PprPrec -> LHsExpr (GhcPass p) -> SDoc
pprParendLExpr PprPrec
p LHsExpr (GhcPass p)
expr
                      else LHsExpr (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
LHsExpr (GhcPass p) -> SDoc
pprLExpr      LHsExpr (GhcPass p)
expr)

pprParendLExpr :: (OutputableBndrId (GhcPass p))
               => PprPrec -> LHsExpr (GhcPass p) -> SDoc
pprParendLExpr :: PprPrec -> LHsExpr (GhcPass p) -> SDoc
pprParendLExpr p :: PprPrec
p (L _ e :: HsExpr (GhcPass p)
e) = PprPrec -> HsExpr (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
PprPrec -> HsExpr (GhcPass p) -> SDoc
pprParendExpr PprPrec
p HsExpr (GhcPass p)
e

pprParendExpr :: (OutputableBndrId (GhcPass p))
              => PprPrec -> HsExpr (GhcPass p) -> SDoc
pprParendExpr :: PprPrec -> HsExpr (GhcPass p) -> SDoc
pprParendExpr p :: PprPrec
p expr :: HsExpr (GhcPass p)
expr
  | PprPrec -> HsExpr (GhcPass p) -> Bool
forall p. PprPrec -> HsExpr p -> Bool
hsExprNeedsParens PprPrec
p HsExpr (GhcPass p)
expr = SDoc -> SDoc
parens (HsExpr (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
HsExpr (GhcPass p) -> SDoc
pprExpr HsExpr (GhcPass p)
expr)
  | Bool
otherwise                = HsExpr (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
HsExpr (GhcPass p) -> SDoc
pprExpr HsExpr (GhcPass p)
expr
        -- Using pprLExpr makes sure that we go 'deeper'
        -- I think that is usually (always?) right

-- | @'hsExprNeedsParens' p e@ returns 'True' if the expression @e@ needs
-- parentheses under precedence @p@.
hsExprNeedsParens :: PprPrec -> HsExpr p -> Bool
hsExprNeedsParens :: PprPrec -> HsExpr p -> Bool
hsExprNeedsParens p :: PprPrec
p = HsExpr p -> Bool
go
  where
    go :: HsExpr p -> Bool
go (HsVar{})                      = Bool
False
    go (HsUnboundVar{})               = Bool
False
    go (HsConLikeOut{})               = Bool
False
    go (HsIPVar{})                    = Bool
False
    go (HsOverLabel{})                = Bool
False
    go (HsLit _ l :: HsLit p
l)                    = PprPrec -> HsLit p -> Bool
forall x. PprPrec -> HsLit x -> Bool
hsLitNeedsParens PprPrec
p HsLit p
l
    go (HsOverLit _ ol :: HsOverLit p
ol)               = PprPrec -> HsOverLit p -> Bool
forall x. PprPrec -> HsOverLit x -> Bool
hsOverLitNeedsParens PprPrec
p HsOverLit p
ol
    go (HsPar{})                      = Bool
False
    go (HsCoreAnn _ _ _ (L _ e :: HsExpr p
e))      = HsExpr p -> Bool
go HsExpr p
e
    go (HsApp{})                      = PprPrec
p PprPrec -> PprPrec -> Bool
forall a. Ord a => a -> a -> Bool
>= PprPrec
appPrec
    go (HsAppType {})                 = PprPrec
p PprPrec -> PprPrec -> Bool
forall a. Ord a => a -> a -> Bool
>= PprPrec
appPrec
    go (OpApp{})                      = PprPrec
p PprPrec -> PprPrec -> Bool
forall a. Ord a => a -> a -> Bool
>= PprPrec
opPrec
    go (NegApp{})                     = PprPrec
p PprPrec -> PprPrec -> Bool
forall a. Ord a => a -> a -> Bool
> PprPrec
topPrec
    go (SectionL{})                   = Bool
True
    go (SectionR{})                   = Bool
True
    go (ExplicitTuple{})              = Bool
False
    go (ExplicitSum{})                = Bool
False
    go (HsLam{})                      = PprPrec
p PprPrec -> PprPrec -> Bool
forall a. Ord a => a -> a -> Bool
> PprPrec
topPrec
    go (HsLamCase{})                  = PprPrec
p PprPrec -> PprPrec -> Bool
forall a. Ord a => a -> a -> Bool
> PprPrec
topPrec
    go (HsCase{})                     = PprPrec
p PprPrec -> PprPrec -> Bool
forall a. Ord a => a -> a -> Bool
> PprPrec
topPrec
    go (HsIf{})                       = PprPrec
p PprPrec -> PprPrec -> Bool
forall a. Ord a => a -> a -> Bool
> PprPrec
topPrec
    go (HsMultiIf{})                  = PprPrec
p PprPrec -> PprPrec -> Bool
forall a. Ord a => a -> a -> Bool
> PprPrec
topPrec
    go (HsLet{})                      = PprPrec
p PprPrec -> PprPrec -> Bool
forall a. Ord a => a -> a -> Bool
> PprPrec
topPrec
    go (HsDo _ sc :: HsStmtContext Name
sc _)
      | HsStmtContext Name -> Bool
forall id. HsStmtContext id -> Bool
isComprehensionContext HsStmtContext Name
sc     = Bool
False
      | Bool
otherwise                     = PprPrec
p PprPrec -> PprPrec -> Bool
forall a. Ord a => a -> a -> Bool
> PprPrec
topPrec
    go (ExplicitList{})               = Bool
False
    go (RecordUpd{})                  = Bool
False
    go (ExprWithTySig{})              = PprPrec
p PprPrec -> PprPrec -> Bool
forall a. Ord a => a -> a -> Bool
>= PprPrec
sigPrec
    go (ArithSeq{})                   = Bool
False
    go (EWildPat{})                   = Bool
False
    go (ELazyPat{})                   = Bool
False
    go (EAsPat{})                     = Bool
False
    go (EViewPat{})                   = Bool
True
    go (HsSCC{})                      = PprPrec
p PprPrec -> PprPrec -> Bool
forall a. Ord a => a -> a -> Bool
>= PprPrec
appPrec
    go (HsWrap _ _ e :: HsExpr p
e)                 = HsExpr p -> Bool
go HsExpr p
e
    go (HsSpliceE{})                  = Bool
False
    go (HsBracket{})                  = Bool
False
    go (HsRnBracketOut{})             = Bool
False
    go (HsTcBracketOut{})             = Bool
False
    go (HsProc{})                     = PprPrec
p PprPrec -> PprPrec -> Bool
forall a. Ord a => a -> a -> Bool
> PprPrec
topPrec
    go (HsStatic{})                   = PprPrec
p PprPrec -> PprPrec -> Bool
forall a. Ord a => a -> a -> Bool
>= PprPrec
appPrec
    go (HsTick _ _ (L _ e :: HsExpr p
e))           = HsExpr p -> Bool
go HsExpr p
e
    go (HsBinTick _ _ _ (L _ e :: HsExpr p
e))      = HsExpr p -> Bool
go HsExpr p
e
    go (HsTickPragma _ _ _ _ (L _ e :: HsExpr p
e)) = HsExpr p -> Bool
go HsExpr p
e
    go (HsArrApp{})                   = Bool
True
    go (HsArrForm{})                  = Bool
True
    go (RecordCon{})                  = Bool
False
    go (HsRecFld{})                   = Bool
False
    go (XExpr{})                      = Bool
True

-- | @'parenthesizeHsExpr' p e@ checks if @'hsExprNeedsParens' p e@ is true,
-- and if so, surrounds @e@ with an 'HsPar'. Otherwise, it simply returns @e@.
parenthesizeHsExpr :: PprPrec -> LHsExpr (GhcPass p) -> LHsExpr (GhcPass p)
parenthesizeHsExpr :: PprPrec -> LHsExpr (GhcPass p) -> LHsExpr (GhcPass p)
parenthesizeHsExpr p :: PprPrec
p le :: LHsExpr (GhcPass p)
le@(L loc :: SrcSpan
loc e :: HsExpr (GhcPass p)
e)
  | PprPrec -> HsExpr (GhcPass p) -> Bool
forall p. PprPrec -> HsExpr p -> Bool
hsExprNeedsParens PprPrec
p HsExpr (GhcPass p)
e = SrcSpan -> HsExpr (GhcPass p) -> LHsExpr (GhcPass p)
forall l e. l -> e -> GenLocated l e
L SrcSpan
loc (XPar (GhcPass p) -> LHsExpr (GhcPass p) -> HsExpr (GhcPass p)
forall p. XPar p -> LHsExpr p -> HsExpr p
HsPar XPar (GhcPass p)
NoExt
NoExt LHsExpr (GhcPass p)
le)
  | Bool
otherwise             = LHsExpr (GhcPass p)
le

isAtomicHsExpr :: HsExpr id -> Bool
-- True of a single token
isAtomicHsExpr :: HsExpr id -> Bool
isAtomicHsExpr (HsVar {})        = Bool
True
isAtomicHsExpr (HsConLikeOut {}) = Bool
True
isAtomicHsExpr (HsLit {})        = Bool
True
isAtomicHsExpr (HsOverLit {})    = Bool
True
isAtomicHsExpr (HsIPVar {})      = Bool
True
isAtomicHsExpr (HsOverLabel {})  = Bool
True
isAtomicHsExpr (HsUnboundVar {}) = Bool
True
isAtomicHsExpr (HsWrap _ _ e :: HsExpr id
e)    = HsExpr id -> Bool
forall id. HsExpr id -> Bool
isAtomicHsExpr HsExpr id
e
isAtomicHsExpr (HsPar _ e :: LHsExpr id
e)       = HsExpr id -> Bool
forall id. HsExpr id -> Bool
isAtomicHsExpr (LHsExpr id -> SrcSpanLess (LHsExpr id)
forall a. HasSrcSpan a => a -> SrcSpanLess a
unLoc LHsExpr id
e)
isAtomicHsExpr (HsRecFld{})      = Bool
True
isAtomicHsExpr _                 = Bool
False

{-
************************************************************************
*                                                                      *
\subsection{Commands (in arrow abstractions)}
*                                                                      *
************************************************************************

We re-use HsExpr to represent these.
-}

-- | Located Haskell Command (for arrow syntax)
type LHsCmd id = Located (HsCmd id)

-- | Haskell Command (e.g. a "statement" in an Arrow proc block)
data HsCmd id
  -- | - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.Annlarrowtail',
  --          'ApiAnnotation.Annrarrowtail','ApiAnnotation.AnnLarrowtail',
  --          'ApiAnnotation.AnnRarrowtail'

  -- For details on above see note [Api annotations] in ApiAnnotation
  = HsCmdArrApp          -- Arrow tail, or arrow application (f -< arg)
        (XCmdArrApp id)  -- type of the arrow expressions f,
                         -- of the form a t t', where arg :: t
        (LHsExpr id)     -- arrow expression, f
        (LHsExpr id)     -- input expression, arg
        HsArrAppType     -- higher-order (-<<) or first-order (-<)
        Bool             -- True => right-to-left (f -< arg)
                         -- False => left-to-right (arg >- f)

  -- | - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpenB' @'(|'@,
  --         'ApiAnnotation.AnnCloseB' @'|)'@

  -- For details on above see note [Api annotations] in ApiAnnotation
  | HsCmdArrForm         -- Command formation,  (| e cmd1 .. cmdn |)
        (XCmdArrForm id)
        (LHsExpr id)     -- The operator.
                         -- After type-checking, a type abstraction to be
                         -- applied to the type of the local environment tuple
        LexicalFixity    -- Whether the operator appeared prefix or infix when
                         -- parsed.
        (Maybe Fixity)   -- fixity (filled in by the renamer), for forms that
                         -- were converted from OpApp's by the renamer
        [LHsCmdTop id]   -- argument commands

  | HsCmdApp    (XCmdApp id)
                (LHsCmd id)
                (LHsExpr id)

  | HsCmdLam    (XCmdLam id)
                (MatchGroup id (LHsCmd id))     -- kappa
       -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnLam',
       --       'ApiAnnotation.AnnRarrow',

       -- For details on above see note [Api annotations] in ApiAnnotation

  | HsCmdPar    (XCmdPar id)
                (LHsCmd id)                     -- parenthesised command
    -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen' @'('@,
    --             'ApiAnnotation.AnnClose' @')'@

    -- For details on above see note [Api annotations] in ApiAnnotation

  | HsCmdCase   (XCmdCase id)
                (LHsExpr id)
                (MatchGroup id (LHsCmd id))     -- bodies are HsCmd's
    -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnCase',
    --       'ApiAnnotation.AnnOf','ApiAnnotation.AnnOpen' @'{'@,
    --       'ApiAnnotation.AnnClose' @'}'@

    -- For details on above see note [Api annotations] in ApiAnnotation

  | HsCmdIf     (XCmdIf id)
                (Maybe (SyntaxExpr id))         -- cond function
                (LHsExpr id)                    -- predicate
                (LHsCmd id)                     -- then part
                (LHsCmd id)                     -- else part
    -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnIf',
    --       'ApiAnnotation.AnnSemi',
    --       'ApiAnnotation.AnnThen','ApiAnnotation.AnnSemi',
    --       'ApiAnnotation.AnnElse',

    -- For details on above see note [Api annotations] in ApiAnnotation

  | HsCmdLet    (XCmdLet id)
                (LHsLocalBinds id)      -- let(rec)
                (LHsCmd  id)
    -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnLet',
    --       'ApiAnnotation.AnnOpen' @'{'@,
    --       'ApiAnnotation.AnnClose' @'}'@,'ApiAnnotation.AnnIn'

    -- For details on above see note [Api annotations] in ApiAnnotation

  | HsCmdDo     (XCmdDo id)                     -- Type of the whole expression
                (Located [CmdLStmt id])
    -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnDo',
    --             'ApiAnnotation.AnnOpen', 'ApiAnnotation.AnnSemi',
    --             'ApiAnnotation.AnnVbar',
    --             'ApiAnnotation.AnnClose'

    -- For details on above see note [Api annotations] in ApiAnnotation

  | HsCmdWrap   (XCmdWrap id)
                HsWrapper
                (HsCmd id)     -- If   cmd :: arg1 --> res
                               --      wrap :: arg1 "->" arg2
                               -- Then (HsCmdWrap wrap cmd) :: arg2 --> res
  | XCmd        (XXCmd id)     -- Note [Trees that Grow] extension point

type instance XCmdArrApp  GhcPs = NoExt
type instance XCmdArrApp  GhcRn = NoExt
type instance XCmdArrApp  GhcTc = Type

type instance XCmdArrForm (GhcPass _) = NoExt
type instance XCmdApp     (GhcPass _) = NoExt
type instance XCmdLam     (GhcPass _) = NoExt
type instance XCmdPar     (GhcPass _) = NoExt
type instance XCmdCase    (GhcPass _) = NoExt
type instance XCmdIf      (GhcPass _) = NoExt
type instance XCmdLet     (GhcPass _) = NoExt

type instance XCmdDo      GhcPs = NoExt
type instance XCmdDo      GhcRn = NoExt
type instance XCmdDo      GhcTc = Type

type instance XCmdWrap    (GhcPass _) = NoExt
type instance XXCmd       (GhcPass _) = NoExt

-- | Haskell Array Application Type
data HsArrAppType = HsHigherOrderApp | HsFirstOrderApp
  deriving Typeable HsArrAppType
DataType
Constr
Typeable HsArrAppType =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> HsArrAppType -> c HsArrAppType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HsArrAppType)
-> (HsArrAppType -> Constr)
-> (HsArrAppType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HsArrAppType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c HsArrAppType))
-> ((forall b. Data b => b -> b) -> HsArrAppType -> HsArrAppType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HsArrAppType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HsArrAppType -> r)
-> (forall u. (forall d. Data d => d -> u) -> HsArrAppType -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> HsArrAppType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HsArrAppType -> m HsArrAppType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsArrAppType -> m HsArrAppType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HsArrAppType -> m HsArrAppType)
-> Data HsArrAppType
HsArrAppType -> DataType
HsArrAppType -> Constr
(forall b. Data b => b -> b) -> HsArrAppType -> HsArrAppType
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsArrAppType -> c HsArrAppType
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsArrAppType
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> HsArrAppType -> u
forall u. (forall d. Data d => d -> u) -> HsArrAppType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HsArrAppType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HsArrAppType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> HsArrAppType -> m HsArrAppType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsArrAppType -> m HsArrAppType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsArrAppType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsArrAppType -> c HsArrAppType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c HsArrAppType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c HsArrAppType)
$cHsFirstOrderApp :: Constr
$cHsHigherOrderApp :: Constr
$tHsArrAppType :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> HsArrAppType -> m HsArrAppType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsArrAppType -> m HsArrAppType
gmapMp :: (forall d. Data d => d -> m d) -> HsArrAppType -> m HsArrAppType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HsArrAppType -> m HsArrAppType
gmapM :: (forall d. Data d => d -> m d) -> HsArrAppType -> m HsArrAppType
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> HsArrAppType -> m HsArrAppType
gmapQi :: Int -> (forall d. Data d => d -> u) -> HsArrAppType -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HsArrAppType -> u
gmapQ :: (forall d. Data d => d -> u) -> HsArrAppType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HsArrAppType -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HsArrAppType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HsArrAppType -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HsArrAppType -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HsArrAppType -> r
gmapT :: (forall b. Data b => b -> b) -> HsArrAppType -> HsArrAppType
$cgmapT :: (forall b. Data b => b -> b) -> HsArrAppType -> HsArrAppType
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c HsArrAppType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c HsArrAppType)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c HsArrAppType)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c HsArrAppType)
dataTypeOf :: HsArrAppType -> DataType
$cdataTypeOf :: HsArrAppType -> DataType
toConstr :: HsArrAppType -> Constr
$ctoConstr :: HsArrAppType -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsArrAppType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HsArrAppType
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsArrAppType -> c HsArrAppType
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HsArrAppType -> c HsArrAppType
$cp1Data :: Typeable HsArrAppType
Data


{- | Top-level command, introducing a new arrow.
This may occur inside a proc (where the stack is empty) or as an
argument of a command-forming operator.
-}

-- | Located Haskell Top-level Command
type LHsCmdTop p = Located (HsCmdTop p)

-- | Haskell Top-level Command
data HsCmdTop p
  = HsCmdTop (XCmdTop p)
             (LHsCmd p)
  | XCmdTop (XXCmdTop p)        -- Note [Trees that Grow] extension point

data CmdTopTc
  = CmdTopTc Type    -- Nested tuple of inputs on the command's stack
             Type    -- return type of the command
             (CmdSyntaxTable GhcTc) -- See Note [CmdSyntaxTable]

type instance XCmdTop  GhcPs = NoExt
type instance XCmdTop  GhcRn = CmdSyntaxTable GhcRn -- See Note [CmdSyntaxTable]
type instance XCmdTop  GhcTc = CmdTopTc

type instance XXCmdTop (GhcPass _) = NoExt

instance (p ~ GhcPass pass, OutputableBndrId p) => Outputable (HsCmd p) where
    ppr :: HsCmd p -> SDoc
ppr cmd :: HsCmd p
cmd = HsCmd (GhcPass pass) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
HsCmd (GhcPass p) -> SDoc
pprCmd HsCmd p
HsCmd (GhcPass pass)
cmd

-----------------------
-- pprCmd and pprLCmd call pprDeeper;
-- the underscore versions do not
pprLCmd :: (OutputableBndrId (GhcPass p)) => LHsCmd (GhcPass p) -> SDoc
pprLCmd :: LHsCmd (GhcPass p) -> SDoc
pprLCmd (L _ c :: HsCmd (GhcPass p)
c) = HsCmd (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
HsCmd (GhcPass p) -> SDoc
pprCmd HsCmd (GhcPass p)
c

pprCmd :: (OutputableBndrId (GhcPass p)) => HsCmd (GhcPass p) -> SDoc
pprCmd :: HsCmd (GhcPass p) -> SDoc
pprCmd c :: HsCmd (GhcPass p)
c | HsCmd (GhcPass p) -> Bool
forall id. HsCmd id -> Bool
isQuietHsCmd HsCmd (GhcPass p)
c =            HsCmd (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
HsCmd (GhcPass p) -> SDoc
ppr_cmd HsCmd (GhcPass p)
c
         | Bool
otherwise      = SDoc -> SDoc
pprDeeper (HsCmd (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
HsCmd (GhcPass p) -> SDoc
ppr_cmd HsCmd (GhcPass p)
c)

isQuietHsCmd :: HsCmd id -> Bool
-- Parentheses do display something, but it gives little info and
-- if we go deeper when we go inside them then we get ugly things
-- like (...)
isQuietHsCmd :: HsCmd id -> Bool
isQuietHsCmd (HsCmdPar {}) = Bool
True
-- applications don't display anything themselves
isQuietHsCmd (HsCmdApp {}) = Bool
True
isQuietHsCmd _ = Bool
False

-----------------------
ppr_lcmd :: (OutputableBndrId (GhcPass p)) => LHsCmd (GhcPass p) -> SDoc
ppr_lcmd :: LHsCmd (GhcPass p) -> SDoc
ppr_lcmd c :: LHsCmd (GhcPass p)
c = HsCmd (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
HsCmd (GhcPass p) -> SDoc
ppr_cmd (LHsCmd (GhcPass p) -> SrcSpanLess (LHsCmd (GhcPass p))
forall a. HasSrcSpan a => a -> SrcSpanLess a
unLoc LHsCmd (GhcPass p)
c)

ppr_cmd :: forall p. (OutputableBndrId (GhcPass p)) => HsCmd (GhcPass p) -> SDoc
ppr_cmd :: HsCmd (GhcPass p) -> SDoc
ppr_cmd (HsCmdPar _ c :: LHsCmd (GhcPass p)
c) = SDoc -> SDoc
parens (LHsCmd (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
LHsCmd (GhcPass p) -> SDoc
ppr_lcmd LHsCmd (GhcPass p)
c)

ppr_cmd (HsCmdApp _ c :: LHsCmd (GhcPass p)
c e :: LHsExpr (GhcPass p)
e)
  = let (fun :: LHsCmd (GhcPass p)
fun, args :: [LHsExpr (GhcPass p)]
args) = LHsCmd (GhcPass p)
-> [LHsExpr (GhcPass p)]
-> (LHsCmd (GhcPass p), [LHsExpr (GhcPass p)])
forall id. LHsCmd id -> [LHsExpr id] -> (LHsCmd id, [LHsExpr id])
collect_args LHsCmd (GhcPass p)
c [LHsExpr (GhcPass p)
e] in
    SDoc -> Int -> SDoc -> SDoc
hang (LHsCmd (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
LHsCmd (GhcPass p) -> SDoc
ppr_lcmd LHsCmd (GhcPass p)
fun) 2 ([SDoc] -> SDoc
sep ((LHsExpr (GhcPass p) -> SDoc) -> [LHsExpr (GhcPass p)] -> [SDoc]
forall a b. (a -> b) -> [a] -> [b]
map LHsExpr (GhcPass p) -> SDoc
forall a. Outputable a => a -> SDoc
ppr [LHsExpr (GhcPass p)]
args))
  where
    collect_args :: LHsCmd id -> [LHsExpr id] -> (LHsCmd id, [LHsExpr id])
collect_args (L _ (HsCmdApp _ fun :: LHsCmd id
fun arg :: LHsExpr id
arg)) args :: [LHsExpr id]
args = LHsCmd id -> [LHsExpr id] -> (LHsCmd id, [LHsExpr id])
collect_args LHsCmd id
fun (LHsExpr id
argLHsExpr id -> [LHsExpr id] -> [LHsExpr id]
forall a. a -> [a] -> [a]
:[LHsExpr id]
args)
    collect_args fun :: LHsCmd id
fun args :: [LHsExpr id]
args = (LHsCmd id
fun, [LHsExpr id]
args)

ppr_cmd (HsCmdLam _ matches :: MatchGroup (GhcPass p) (LHsCmd (GhcPass p))
matches)
  = MatchGroup (GhcPass p) (LHsCmd (GhcPass p)) -> SDoc
forall (idR :: Pass) body.
(OutputableBndrId (GhcPass idR), Outputable body) =>
MatchGroup (GhcPass idR) body -> SDoc
pprMatches MatchGroup (GhcPass p) (LHsCmd (GhcPass p))
matches

ppr_cmd (HsCmdCase _ expr :: LHsExpr (GhcPass p)
expr matches :: MatchGroup (GhcPass p) (LHsCmd (GhcPass p))
matches)
  = [SDoc] -> SDoc
sep [ [SDoc] -> SDoc
sep [String -> SDoc
text "case", Int -> SDoc -> SDoc
nest 4 (LHsExpr (GhcPass p) -> SDoc
forall a. Outputable a => a -> SDoc
ppr LHsExpr (GhcPass p)
expr), PtrString -> SDoc
ptext (String -> PtrString
sLit "of")],
          Int -> SDoc -> SDoc
nest 2 (MatchGroup (GhcPass p) (LHsCmd (GhcPass p)) -> SDoc
forall (idR :: Pass) body.
(OutputableBndrId (GhcPass idR), Outputable body) =>
MatchGroup (GhcPass idR) body -> SDoc
pprMatches MatchGroup (GhcPass p) (LHsCmd (GhcPass p))
matches) ]

ppr_cmd (HsCmdIf _ _ e :: LHsExpr (GhcPass p)
e ct :: LHsCmd (GhcPass p)
ct ce :: LHsCmd (GhcPass p)
ce)
  = [SDoc] -> SDoc
sep [[SDoc] -> SDoc
hsep [String -> SDoc
text "if", Int -> SDoc -> SDoc
nest 2 (LHsExpr (GhcPass p) -> SDoc
forall a. Outputable a => a -> SDoc
ppr LHsExpr (GhcPass p)
e), PtrString -> SDoc
ptext (String -> PtrString
sLit "then")],
         Int -> SDoc -> SDoc
nest 4 (LHsCmd (GhcPass p) -> SDoc
forall a. Outputable a => a -> SDoc
ppr LHsCmd (GhcPass p)
ct),
         String -> SDoc
text "else",
         Int -> SDoc -> SDoc
nest 4 (LHsCmd (GhcPass p) -> SDoc
forall a. Outputable a => a -> SDoc
ppr LHsCmd (GhcPass p)
ce)]

-- special case: let ... in let ...
ppr_cmd (HsCmdLet _ (L _ binds :: HsLocalBinds (GhcPass p)
binds) cmd :: LHsCmd (GhcPass p)
cmd@(L _ (HsCmdLet {})))
  = [SDoc] -> SDoc
sep [SDoc -> Int -> SDoc -> SDoc
hang (String -> SDoc
text "let") 2 ([SDoc] -> SDoc
hsep [HsLocalBinds (GhcPass p) -> SDoc
forall (idL :: Pass) (idR :: Pass).
(OutputableBndrId (GhcPass idL), OutputableBndrId (GhcPass idR)) =>
HsLocalBindsLR (GhcPass idL) (GhcPass idR) -> SDoc
pprBinds HsLocalBinds (GhcPass p)
binds, PtrString -> SDoc
ptext (String -> PtrString
sLit "in")]),
         LHsCmd (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
LHsCmd (GhcPass p) -> SDoc
ppr_lcmd LHsCmd (GhcPass p)
cmd]

ppr_cmd (HsCmdLet _ (L _ binds :: HsLocalBinds (GhcPass p)
binds) cmd :: LHsCmd (GhcPass p)
cmd)
  = [SDoc] -> SDoc
sep [SDoc -> Int -> SDoc -> SDoc
hang (String -> SDoc
text "let") 2 (HsLocalBinds (GhcPass p) -> SDoc
forall (idL :: Pass) (idR :: Pass).
(OutputableBndrId (GhcPass idL), OutputableBndrId (GhcPass idR)) =>
HsLocalBindsLR (GhcPass idL) (GhcPass idR) -> SDoc
pprBinds HsLocalBinds (GhcPass p)
binds),
         SDoc -> Int -> SDoc -> SDoc
hang (String -> SDoc
text "in")  2 (LHsCmd (GhcPass p) -> SDoc
forall a. Outputable a => a -> SDoc
ppr LHsCmd (GhcPass p)
cmd)]

ppr_cmd (HsCmdDo _ (L _ stmts :: [CmdLStmt (GhcPass p)]
stmts))  = HsStmtContext Any -> [CmdLStmt (GhcPass p)] -> SDoc
forall (p :: Pass) body any.
(OutputableBndrId (GhcPass p), Outputable body) =>
HsStmtContext any -> [LStmt (GhcPass p) body] -> SDoc
pprDo HsStmtContext Any
forall id. HsStmtContext id
ArrowExpr [CmdLStmt (GhcPass p)]
stmts

ppr_cmd (HsCmdWrap _ w :: HsWrapper
w cmd :: HsCmd (GhcPass p)
cmd)
  = HsWrapper -> (Bool -> SDoc) -> SDoc
pprHsWrapper HsWrapper
w (\_ -> SDoc -> SDoc
parens (HsCmd (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
HsCmd (GhcPass p) -> SDoc
ppr_cmd HsCmd (GhcPass p)
cmd))
ppr_cmd (HsCmdArrApp _ arrow :: LHsExpr (GhcPass p)
arrow arg :: LHsExpr (GhcPass p)
arg HsFirstOrderApp True)
  = [SDoc] -> SDoc
hsep [LHsExpr (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
LHsExpr (GhcPass p) -> SDoc
ppr_lexpr LHsExpr (GhcPass p)
arrow, SDoc
larrowt, LHsExpr (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
LHsExpr (GhcPass p) -> SDoc
ppr_lexpr LHsExpr (GhcPass p)
arg]
ppr_cmd (HsCmdArrApp _ arrow :: LHsExpr (GhcPass p)
arrow arg :: LHsExpr (GhcPass p)
arg HsFirstOrderApp False)
  = [SDoc] -> SDoc
hsep [LHsExpr (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
LHsExpr (GhcPass p) -> SDoc
ppr_lexpr LHsExpr (GhcPass p)
arg, SDoc
arrowt, LHsExpr (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
LHsExpr (GhcPass p) -> SDoc
ppr_lexpr LHsExpr (GhcPass p)
arrow]
ppr_cmd (HsCmdArrApp _ arrow :: LHsExpr (GhcPass p)
arrow arg :: LHsExpr (GhcPass p)
arg HsHigherOrderApp True)
  = [SDoc] -> SDoc
hsep [LHsExpr (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
LHsExpr (GhcPass p) -> SDoc
ppr_lexpr LHsExpr (GhcPass p)
arrow, SDoc
larrowtt, LHsExpr (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
LHsExpr (GhcPass p) -> SDoc
ppr_lexpr LHsExpr (GhcPass p)
arg]
ppr_cmd (HsCmdArrApp _ arrow :: LHsExpr (GhcPass p)
arrow arg :: LHsExpr (GhcPass p)
arg HsHigherOrderApp False)
  = [SDoc] -> SDoc
hsep [LHsExpr (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
LHsExpr (GhcPass p) -> SDoc
ppr_lexpr LHsExpr (GhcPass p)
arg, SDoc
arrowtt, LHsExpr (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
LHsExpr (GhcPass p) -> SDoc
ppr_lexpr LHsExpr (GhcPass p)
arrow]

ppr_cmd (HsCmdArrForm _ (L _ (HsVar _ (L _ v :: IdP (GhcPass p)
v))) _ (Just _) [arg1 :: LHsCmdTop (GhcPass p)
arg1, arg2 :: LHsCmdTop (GhcPass p)
arg2])
  = SDoc -> Int -> SDoc -> SDoc
hang (HsCmdTop (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
HsCmdTop (GhcPass p) -> SDoc
pprCmdArg (LHsCmdTop (GhcPass p) -> SrcSpanLess (LHsCmdTop (GhcPass p))
forall a. HasSrcSpan a => a -> SrcSpanLess a
unLoc LHsCmdTop (GhcPass p)
arg1)) 4 ([SDoc] -> SDoc
sep [ IdP (GhcPass p) -> SDoc
forall a. OutputableBndr a => a -> SDoc
pprInfixOcc IdP (GhcPass p)
v
                                         , HsCmdTop (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
HsCmdTop (GhcPass p) -> SDoc
pprCmdArg (LHsCmdTop (GhcPass p) -> SrcSpanLess (LHsCmdTop (GhcPass p))
forall a. HasSrcSpan a => a -> SrcSpanLess a
unLoc LHsCmdTop (GhcPass p)
arg2)])
ppr_cmd (HsCmdArrForm _ (L _ (HsVar _ (L _ v :: IdP (GhcPass p)
v))) Infix _    [arg1 :: LHsCmdTop (GhcPass p)
arg1, arg2 :: LHsCmdTop (GhcPass p)
arg2])
  = SDoc -> Int -> SDoc -> SDoc
hang (HsCmdTop (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
HsCmdTop (GhcPass p) -> SDoc
pprCmdArg (LHsCmdTop (GhcPass p) -> SrcSpanLess (LHsCmdTop (GhcPass p))
forall a. HasSrcSpan a => a -> SrcSpanLess a
unLoc LHsCmdTop (GhcPass p)
arg1)) 4 ([SDoc] -> SDoc
sep [ IdP (GhcPass p) -> SDoc
forall a. OutputableBndr a => a -> SDoc
pprInfixOcc IdP (GhcPass p)
v
                                         , HsCmdTop (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
HsCmdTop (GhcPass p) -> SDoc
pprCmdArg (LHsCmdTop (GhcPass p) -> SrcSpanLess (LHsCmdTop (GhcPass p))
forall a. HasSrcSpan a => a -> SrcSpanLess a
unLoc LHsCmdTop (GhcPass p)
arg2)])
ppr_cmd (HsCmdArrForm _ (L _ (HsConLikeOut _ c :: ConLike
c)) _ (Just _) [arg1 :: LHsCmdTop (GhcPass p)
arg1, arg2 :: LHsCmdTop (GhcPass p)
arg2])
  = SDoc -> Int -> SDoc -> SDoc
hang (HsCmdTop (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
HsCmdTop (GhcPass p) -> SDoc
pprCmdArg (LHsCmdTop (GhcPass p) -> SrcSpanLess (LHsCmdTop (GhcPass p))
forall a. HasSrcSpan a => a -> SrcSpanLess a
unLoc LHsCmdTop (GhcPass p)
arg1)) 4 ([SDoc] -> SDoc
sep [ Name -> SDoc
forall a. OutputableBndr a => a -> SDoc
pprInfixOcc (ConLike -> Name
conLikeName ConLike
c)
                                         , HsCmdTop (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
HsCmdTop (GhcPass p) -> SDoc
pprCmdArg (LHsCmdTop (GhcPass p) -> SrcSpanLess (LHsCmdTop (GhcPass p))
forall a. HasSrcSpan a => a -> SrcSpanLess a
unLoc LHsCmdTop (GhcPass p)
arg2)])
ppr_cmd (HsCmdArrForm _ (L _ (HsConLikeOut _ c :: ConLike
c)) Infix _    [arg1 :: LHsCmdTop (GhcPass p)
arg1, arg2 :: LHsCmdTop (GhcPass p)
arg2])
  = SDoc -> Int -> SDoc -> SDoc
hang (HsCmdTop (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
HsCmdTop (GhcPass p) -> SDoc
pprCmdArg (LHsCmdTop (GhcPass p) -> SrcSpanLess (LHsCmdTop (GhcPass p))
forall a. HasSrcSpan a => a -> SrcSpanLess a
unLoc LHsCmdTop (GhcPass p)
arg1)) 4 ([SDoc] -> SDoc
sep [ Name -> SDoc
forall a. OutputableBndr a => a -> SDoc
pprInfixOcc (ConLike -> Name
conLikeName ConLike
c)
                                         , HsCmdTop (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
HsCmdTop (GhcPass p) -> SDoc
pprCmdArg (LHsCmdTop (GhcPass p) -> SrcSpanLess (LHsCmdTop (GhcPass p))
forall a. HasSrcSpan a => a -> SrcSpanLess a
unLoc LHsCmdTop (GhcPass p)
arg2)])
ppr_cmd (HsCmdArrForm _ op :: LHsExpr (GhcPass p)
op _ _ args :: [LHsCmdTop (GhcPass p)]
args)
  = SDoc -> Int -> SDoc -> SDoc
hang (String -> SDoc
text "(|" SDoc -> SDoc -> SDoc
<> LHsExpr (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
LHsExpr (GhcPass p) -> SDoc
ppr_lexpr LHsExpr (GhcPass p)
op)
         4 ([SDoc] -> SDoc
sep ((LHsCmdTop (GhcPass p) -> SDoc)
-> [LHsCmdTop (GhcPass p)] -> [SDoc]
forall a b. (a -> b) -> [a] -> [b]
map (HsCmdTop (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
HsCmdTop (GhcPass p) -> SDoc
pprCmdArg(HsCmdTop (GhcPass p) -> SDoc)
-> (LHsCmdTop (GhcPass p) -> HsCmdTop (GhcPass p))
-> LHsCmdTop (GhcPass p)
-> SDoc
forall b c a. (b -> c) -> (a -> b) -> a -> c
.LHsCmdTop (GhcPass p) -> HsCmdTop (GhcPass p)
forall a. HasSrcSpan a => a -> SrcSpanLess a
unLoc) [LHsCmdTop (GhcPass p)]
args) SDoc -> SDoc -> SDoc
<> String -> SDoc
text "|)")
ppr_cmd (XCmd x :: XXCmd (GhcPass p)
x) = NoExt -> SDoc
forall a. Outputable a => a -> SDoc
ppr XXCmd (GhcPass p)
NoExt
x

pprCmdArg :: (OutputableBndrId (GhcPass p)) => HsCmdTop (GhcPass p) -> SDoc
pprCmdArg :: HsCmdTop (GhcPass p) -> SDoc
pprCmdArg (HsCmdTop _ cmd :: LHsCmd (GhcPass p)
cmd)
  = LHsCmd (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
LHsCmd (GhcPass p) -> SDoc
ppr_lcmd LHsCmd (GhcPass p)
cmd
pprCmdArg (XCmdTop x :: XXCmdTop (GhcPass p)
x) = NoExt -> SDoc
forall a. Outputable a => a -> SDoc
ppr XXCmdTop (GhcPass p)
NoExt
x

instance (p ~ GhcPass pass, OutputableBndrId p) => Outputable (HsCmdTop p) where
    ppr :: HsCmdTop p -> SDoc
ppr = HsCmdTop p -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
HsCmdTop (GhcPass p) -> SDoc
pprCmdArg

{-
************************************************************************
*                                                                      *
\subsection{Record binds}
*                                                                      *
************************************************************************
-}

-- | Haskell Record Bindings
type HsRecordBinds p = HsRecFields p (LHsExpr p)

{-
************************************************************************
*                                                                      *
\subsection{@Match@, @GRHSs@, and @GRHS@ datatypes}
*                                                                      *
************************************************************************

@Match@es are sets of pattern bindings and right hand sides for
functions, patterns or case branches. For example, if a function @g@
is defined as:
\begin{verbatim}
g (x,y) = y
g ((x:ys),y) = y+1,
\end{verbatim}
then \tr{g} has two @Match@es: @(x,y) = y@ and @((x:ys),y) = y+1@.

It is always the case that each element of an @[Match]@ list has the
same number of @pats@s inside it.  This corresponds to saying that
a function defined by pattern matching must have the same number of
patterns in each equation.
-}

data MatchGroup p body
  = MG { MatchGroup p body -> XMG p body
mg_ext     :: XMG p body -- Posr typechecker, types of args and result
       , MatchGroup p body -> Located [LMatch p body]
mg_alts    :: Located [LMatch p body]  -- The alternatives
       , MatchGroup p body -> Origin
mg_origin  :: Origin }
     -- The type is the type of the entire group
     --      t1 -> ... -> tn -> tr
     -- where there are n patterns
  | XMatchGroup (XXMatchGroup p body)

data MatchGroupTc
  = MatchGroupTc
       { MatchGroupTc -> [Type]
mg_arg_tys :: [Type]  -- Types of the arguments, t1..tn
       , MatchGroupTc -> Type
mg_res_ty  :: Type    -- Type of the result, tr
       } deriving Typeable MatchGroupTc
DataType
Constr
Typeable MatchGroupTc =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> MatchGroupTc -> c MatchGroupTc)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c MatchGroupTc)
-> (MatchGroupTc -> Constr)
-> (MatchGroupTc -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c MatchGroupTc))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c MatchGroupTc))
-> ((forall b. Data b => b -> b) -> MatchGroupTc -> MatchGroupTc)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> MatchGroupTc -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> MatchGroupTc -> r)
-> (forall u. (forall d. Data d => d -> u) -> MatchGroupTc -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> MatchGroupTc -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> MatchGroupTc -> m MatchGroupTc)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MatchGroupTc -> m MatchGroupTc)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MatchGroupTc -> m MatchGroupTc)
-> Data MatchGroupTc
MatchGroupTc -> DataType
MatchGroupTc -> Constr
(forall b. Data b => b -> b) -> MatchGroupTc -> MatchGroupTc
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MatchGroupTc -> c MatchGroupTc
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MatchGroupTc
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> MatchGroupTc -> u
forall u. (forall d. Data d => d -> u) -> MatchGroupTc -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MatchGroupTc -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MatchGroupTc -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MatchGroupTc -> m MatchGroupTc
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MatchGroupTc -> m MatchGroupTc
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MatchGroupTc
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MatchGroupTc -> c MatchGroupTc
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MatchGroupTc)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MatchGroupTc)
$cMatchGroupTc :: Constr
$tMatchGroupTc :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> MatchGroupTc -> m MatchGroupTc
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MatchGroupTc -> m MatchGroupTc
gmapMp :: (forall d. Data d => d -> m d) -> MatchGroupTc -> m MatchGroupTc
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MatchGroupTc -> m MatchGroupTc
gmapM :: (forall d. Data d => d -> m d) -> MatchGroupTc -> m MatchGroupTc
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MatchGroupTc -> m MatchGroupTc
gmapQi :: Int -> (forall d. Data d => d -> u) -> MatchGroupTc -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MatchGroupTc -> u
gmapQ :: (forall d. Data d => d -> u) -> MatchGroupTc -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> MatchGroupTc -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MatchGroupTc -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MatchGroupTc -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MatchGroupTc -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MatchGroupTc -> r
gmapT :: (forall b. Data b => b -> b) -> MatchGroupTc -> MatchGroupTc
$cgmapT :: (forall b. Data b => b -> b) -> MatchGroupTc -> MatchGroupTc
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MatchGroupTc)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MatchGroupTc)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c MatchGroupTc)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MatchGroupTc)
dataTypeOf :: MatchGroupTc -> DataType
$cdataTypeOf :: MatchGroupTc -> DataType
toConstr :: MatchGroupTc -> Constr
$ctoConstr :: MatchGroupTc -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MatchGroupTc
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MatchGroupTc
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MatchGroupTc -> c MatchGroupTc
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MatchGroupTc -> c MatchGroupTc
$cp1Data :: Typeable MatchGroupTc
Data

type instance XMG         GhcPs b = NoExt
type instance XMG         GhcRn b = NoExt
type instance XMG         GhcTc b = MatchGroupTc

type instance XXMatchGroup (GhcPass _) b = NoExt

-- | Located Match
type LMatch id body = Located (Match id body)
-- ^ May have 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnSemi' when in a
--   list

-- For details on above see note [Api annotations] in ApiAnnotation
data Match p body
  = Match {
        Match p body -> XCMatch p body
m_ext :: XCMatch p body,
        Match p body -> HsMatchContext (NameOrRdrName (IdP p))
m_ctxt :: HsMatchContext (NameOrRdrName (IdP p)),
          -- See note [m_ctxt in Match]
        Match p body -> [LPat p]
m_pats :: [LPat p], -- The patterns
        Match p body -> GRHSs p body
m_grhss :: (GRHSs p body)
  }
  | XMatch (XXMatch p body)

type instance XCMatch (GhcPass _) b = NoExt
type instance XXMatch (GhcPass _) b = NoExt

instance (idR ~ GhcPass pr, OutputableBndrId idR, Outputable body)
            => Outputable (Match idR body) where
  ppr :: Match idR body -> SDoc
ppr = Match idR body -> SDoc
forall (idR :: Pass) body.
(OutputableBndrId (GhcPass idR), Outputable body) =>
Match (GhcPass idR) body -> SDoc
pprMatch

{-
Note [m_ctxt in Match]
~~~~~~~~~~~~~~~~~~~~~~

A Match can occur in a number of contexts, such as a FunBind, HsCase, HsLam and
so on.

In order to simplify tooling processing and pretty print output, the provenance
is captured in an HsMatchContext.

This is particularly important for the API Annotations for a multi-equation
FunBind.

The parser initially creates a FunBind with a single Match in it for
every function definition it sees.

These are then grouped together by getMonoBind into a single FunBind,
where all the Matches are combined.

In the process, all the original FunBind fun_id's bar one are
discarded, including the locations.

This causes a problem for source to source conversions via API
Annotations, so the original fun_ids and infix flags are preserved in
the Match, when it originates from a FunBind.

Example infix function definition requiring individual API Annotations

    (&&&  ) [] [] =  []
    xs    &&&   [] =  xs
    (  &&&  ) [] ys =  ys



-}


isInfixMatch :: Match id body -> Bool
isInfixMatch :: Match id body -> Bool
isInfixMatch match :: Match id body
match = case Match id body -> HsMatchContext (NameOrRdrName (IdP id))
forall p body.
Match p body -> HsMatchContext (NameOrRdrName (IdP p))
m_ctxt Match id body
match of
  FunRhs {mc_fixity :: forall id. HsMatchContext id -> LexicalFixity
mc_fixity = LexicalFixity
Infix} -> Bool
True
  _                          -> Bool
False

isEmptyMatchGroup :: MatchGroup id body -> Bool
isEmptyMatchGroup :: MatchGroup id body -> Bool
isEmptyMatchGroup (MG { mg_alts :: forall p body. MatchGroup p body -> Located [LMatch p body]
mg_alts = Located [LMatch id body]
ms }) = [LMatch id body] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null ([LMatch id body] -> Bool) -> [LMatch id body] -> Bool
forall a b. (a -> b) -> a -> b
$ Located [LMatch id body] -> SrcSpanLess (Located [LMatch id body])
forall a. HasSrcSpan a => a -> SrcSpanLess a
unLoc Located [LMatch id body]
ms
isEmptyMatchGroup (XMatchGroup{}) = String -> Bool
forall a. String -> a
panic "isEmptyMatchGroup"

-- | Is there only one RHS in this list of matches?
isSingletonMatchGroup :: [LMatch id body] -> Bool
isSingletonMatchGroup :: [LMatch id body] -> Bool
isSingletonMatchGroup matches :: [LMatch id body]
matches
  | [L _ match :: Match id body
match] <- [LMatch id body]
matches
  , Match { m_grhss :: forall p body. Match p body -> GRHSs p body
m_grhss = GRHSs { grhssGRHSs :: forall p body. GRHSs p body -> [LGRHS p body]
grhssGRHSs = [_] } } <- Match id body
match
  = Bool
True
  | Bool
otherwise
  = Bool
False

matchGroupArity :: MatchGroup id body -> Arity
-- Precondition: MatchGroup is non-empty
-- This is called before type checking, when mg_arg_tys is not set
matchGroupArity :: MatchGroup id body -> Int
matchGroupArity (MG { mg_alts :: forall p body. MatchGroup p body -> Located [LMatch p body]
mg_alts = Located [LMatch id body]
alts })
  | L _ (alt1 :: LMatch id body
alt1:_) <- Located [LMatch id body]
alts = [LPat id] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length (LMatch id body -> [LPat id]
forall id body. LMatch id body -> [LPat id]
hsLMatchPats LMatch id body
alt1)
  | Bool
otherwise        = String -> Int
forall a. String -> a
panic "matchGroupArity"
matchGroupArity (XMatchGroup{}) = String -> Int
forall a. String -> a
panic "matchGroupArity"

hsLMatchPats :: LMatch id body -> [LPat id]
hsLMatchPats :: LMatch id body -> [LPat id]
hsLMatchPats (L _ (Match { m_pats :: forall p body. Match p body -> [LPat p]
m_pats = [LPat id]
pats })) = [LPat id]
pats
hsLMatchPats (L _ (XMatch _)) = String -> [LPat id]
forall a. String -> a
panic "hsLMatchPats"

-- | Guarded Right-Hand Sides
--
-- GRHSs are used both for pattern bindings and for Matches
--
--  - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnVbar',
--        'ApiAnnotation.AnnEqual','ApiAnnotation.AnnWhere',
--        'ApiAnnotation.AnnOpen','ApiAnnotation.AnnClose'
--        'ApiAnnotation.AnnRarrow','ApiAnnotation.AnnSemi'

-- For details on above see note [Api annotations] in ApiAnnotation
data GRHSs p body
  = GRHSs {
      GRHSs p body -> XCGRHSs p body
grhssExt :: XCGRHSs p body,
      GRHSs p body -> [LGRHS p body]
grhssGRHSs :: [LGRHS p body],      -- ^ Guarded RHSs
      GRHSs p body -> LHsLocalBinds p
grhssLocalBinds :: LHsLocalBinds p -- ^ The where clause
    }
  | XGRHSs (XXGRHSs p body)

type instance XCGRHSs (GhcPass _) b = NoExt
type instance XXGRHSs (GhcPass _) b = NoExt

-- | Located Guarded Right-Hand Side
type LGRHS id body = Located (GRHS id body)

-- | Guarded Right Hand Side.
data GRHS p body = GRHS (XCGRHS p body)
                        [GuardLStmt p] -- Guards
                        body           -- Right hand side
                  | XGRHS (XXGRHS p body)

type instance XCGRHS (GhcPass _) b = NoExt
type instance XXGRHS (GhcPass _) b = NoExt

-- We know the list must have at least one @Match@ in it.

pprMatches :: (OutputableBndrId (GhcPass idR), Outputable body)
           => MatchGroup (GhcPass idR) body -> SDoc
pprMatches :: MatchGroup (GhcPass idR) body -> SDoc
pprMatches MG { mg_alts :: forall p body. MatchGroup p body -> Located [LMatch p body]
mg_alts = Located [LMatch (GhcPass idR) body]
matches }
    = [SDoc] -> SDoc
vcat ((Match (GhcPass idR) body -> SDoc)
-> [Match (GhcPass idR) body] -> [SDoc]
forall a b. (a -> b) -> [a] -> [b]
map Match (GhcPass idR) body -> SDoc
forall (idR :: Pass) body.
(OutputableBndrId (GhcPass idR), Outputable body) =>
Match (GhcPass idR) body -> SDoc
pprMatch ((LMatch (GhcPass idR) body -> Match (GhcPass idR) body)
-> [LMatch (GhcPass idR) body] -> [Match (GhcPass idR) body]
forall a b. (a -> b) -> [a] -> [b]
map LMatch (GhcPass idR) body -> Match (GhcPass idR) body
forall a. HasSrcSpan a => a -> SrcSpanLess a
unLoc (Located [LMatch (GhcPass idR) body]
-> SrcSpanLess (Located [LMatch (GhcPass idR) body])
forall a. HasSrcSpan a => a -> SrcSpanLess a
unLoc Located [LMatch (GhcPass idR) body]
matches)))
      -- Don't print the type; it's only a place-holder before typechecking
pprMatches (XMatchGroup x :: XXMatchGroup (GhcPass idR) body
x) = NoExt -> SDoc
forall a. Outputable a => a -> SDoc
ppr XXMatchGroup (GhcPass idR) body
NoExt
x

-- Exported to HsBinds, which can't see the defn of HsMatchContext
pprFunBind :: (OutputableBndrId (GhcPass idR), Outputable body)
           => MatchGroup (GhcPass idR) body -> SDoc
pprFunBind :: MatchGroup (GhcPass idR) body -> SDoc
pprFunBind matches :: MatchGroup (GhcPass idR) body
matches = MatchGroup (GhcPass idR) body -> SDoc
forall (idR :: Pass) body.
(OutputableBndrId (GhcPass idR), Outputable body) =>
MatchGroup (GhcPass idR) body -> SDoc
pprMatches MatchGroup (GhcPass idR) body
matches

-- Exported to HsBinds, which can't see the defn of HsMatchContext
pprPatBind :: forall bndr p body. (OutputableBndrId (GhcPass bndr),
                                   OutputableBndrId (GhcPass p),
                                   Outputable body)
           => LPat (GhcPass bndr) -> GRHSs (GhcPass p) body -> SDoc
pprPatBind :: LPat (GhcPass bndr) -> GRHSs (GhcPass p) body -> SDoc
pprPatBind pat :: LPat (GhcPass bndr)
pat (GRHSs (GhcPass p) body
grhss)
 = [SDoc] -> SDoc
sep [LPat (GhcPass bndr) -> SDoc
forall a. Outputable a => a -> SDoc
ppr LPat (GhcPass bndr)
pat,
       Int -> SDoc -> SDoc
nest 2 (HsMatchContext (IdP (GhcPass p)) -> GRHSs (GhcPass p) body -> SDoc
forall (idR :: Pass) body idL.
(OutputableBndrId (GhcPass idR), Outputable body) =>
HsMatchContext idL -> GRHSs (GhcPass idR) body -> SDoc
pprGRHSs (HsMatchContext (IdP (GhcPass p))
forall id. HsMatchContext id
PatBindRhs :: HsMatchContext (IdP (GhcPass p))) GRHSs (GhcPass p) body
grhss)]

pprMatch :: (OutputableBndrId (GhcPass idR), Outputable body)
         => Match (GhcPass idR) body -> SDoc
pprMatch :: Match (GhcPass idR) body -> SDoc
pprMatch match :: Match (GhcPass idR) body
match
  = [SDoc] -> SDoc
sep [ [SDoc] -> SDoc
sep (SDoc
herald SDoc -> [SDoc] -> [SDoc]
forall a. a -> [a] -> [a]
: (LPat (GhcPass idR) -> SDoc) -> [LPat (GhcPass idR)] -> [SDoc]
forall a b. (a -> b) -> [a] -> [b]
map (Int -> SDoc -> SDoc
nest 2 (SDoc -> SDoc)
-> (LPat (GhcPass idR) -> SDoc) -> LPat (GhcPass idR) -> SDoc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PprPrec -> LPat (GhcPass idR) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
PprPrec -> LPat (GhcPass p) -> SDoc
pprParendLPat PprPrec
appPrec) [LPat (GhcPass idR)]
other_pats)
        , Int -> SDoc -> SDoc
nest 2 (HsMatchContext (NameOrRdrName (IdP (GhcPass idR)))
-> GRHSs (GhcPass idR) body -> SDoc
forall (idR :: Pass) body idL.
(OutputableBndrId (GhcPass idR), Outputable body) =>
HsMatchContext idL -> GRHSs (GhcPass idR) body -> SDoc
pprGRHSs HsMatchContext (NameOrRdrName (IdP (GhcPass idR)))
ctxt (Match (GhcPass idR) body -> GRHSs (GhcPass idR) body
forall p body. Match p body -> GRHSs p body
m_grhss Match (GhcPass idR) body
match)) ]
  where
    ctxt :: HsMatchContext (NameOrRdrName (IdP (GhcPass idR)))
ctxt = Match (GhcPass idR) body
-> HsMatchContext (NameOrRdrName (IdP (GhcPass idR)))
forall p body.
Match p body -> HsMatchContext (NameOrRdrName (IdP p))
m_ctxt Match (GhcPass idR) body
match
    (herald :: SDoc
herald, other_pats :: [LPat (GhcPass idR)]
other_pats)
        = case HsMatchContext (NameOrRdrName (IdP (GhcPass idR)))
ctxt of
            FunRhs {mc_fun :: forall id. HsMatchContext id -> Located id
mc_fun=L _ fun :: NameOrRdrName (IdP (GhcPass idR))
fun, mc_fixity :: forall id. HsMatchContext id -> LexicalFixity
mc_fixity=LexicalFixity
fixity, mc_strictness :: forall id. HsMatchContext id -> SrcStrictness
mc_strictness=SrcStrictness
strictness}
                | SrcStrictness
strictness SrcStrictness -> SrcStrictness -> Bool
forall a. Eq a => a -> a -> Bool
== SrcStrictness
SrcStrict -> ASSERT(null $ m_pats match)
                                             (Char -> SDoc
char '!'SDoc -> SDoc -> SDoc
<>NameOrRdrName (IdP (GhcPass idR)) -> SDoc
forall a. OutputableBndr a => a -> SDoc
pprPrefixOcc NameOrRdrName (IdP (GhcPass idR))
fun, Match (GhcPass idR) body -> [LPat (GhcPass idR)]
forall p body. Match p body -> [LPat p]
m_pats Match (GhcPass idR) body
match)
                        -- a strict variable binding
                | LexicalFixity
fixity LexicalFixity -> LexicalFixity -> Bool
forall a. Eq a => a -> a -> Bool
== LexicalFixity
Prefix -> (NameOrRdrName (IdP (GhcPass idR)) -> SDoc
forall a. OutputableBndr a => a -> SDoc
pprPrefixOcc NameOrRdrName (IdP (GhcPass idR))
fun, Match (GhcPass idR) body -> [LPat (GhcPass idR)]
forall p body. Match p body -> [LPat p]
m_pats Match (GhcPass idR) body
match)
                        -- f x y z = e
                        -- Not pprBndr; the AbsBinds will
                        -- have printed the signature

                | [LPat (GhcPass idR)] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [LPat (GhcPass idR)]
pats2 -> (SDoc
pp_infix, [])
                        -- x &&& y = e

                | Bool
otherwise -> (SDoc -> SDoc
parens SDoc
pp_infix, [LPat (GhcPass idR)]
pats2)
                        -- (x &&& y) z = e
                where
                  pp_infix :: SDoc
pp_infix = PprPrec -> LPat (GhcPass idR) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
PprPrec -> LPat (GhcPass p) -> SDoc
pprParendLPat PprPrec
opPrec LPat (GhcPass idR)
pat1
                         SDoc -> SDoc -> SDoc
<+> NameOrRdrName (IdP (GhcPass idR)) -> SDoc
forall a. OutputableBndr a => a -> SDoc
pprInfixOcc NameOrRdrName (IdP (GhcPass idR))
fun
                         SDoc -> SDoc -> SDoc
<+> PprPrec -> LPat (GhcPass idR) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
PprPrec -> LPat (GhcPass p) -> SDoc
pprParendLPat PprPrec
opPrec LPat (GhcPass idR)
pat2

            LambdaExpr -> (Char -> SDoc
char '\\', Match (GhcPass idR) body -> [LPat (GhcPass idR)]
forall p body. Match p body -> [LPat p]
m_pats Match (GhcPass idR) body
match)

            _  -> if [LPat (GhcPass idR)] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null (Match (GhcPass idR) body -> [LPat (GhcPass idR)]
forall p body. Match p body -> [LPat p]
m_pats Match (GhcPass idR) body
match)
                     then (SDoc
empty, [])
                     else ASSERT2( null pats1, ppr ctxt $$ ppr pat1 $$ ppr pats1 )
                          (LPat (GhcPass idR) -> SDoc
forall a. Outputable a => a -> SDoc
ppr LPat (GhcPass idR)
pat1, [])        -- No parens around the single pat

    (pat1 :: LPat (GhcPass idR)
pat1:pats1 :: [LPat (GhcPass idR)]
pats1) = Match (GhcPass idR) body -> [LPat (GhcPass idR)]
forall p body. Match p body -> [LPat p]
m_pats Match (GhcPass idR) body
match
    (pat2 :: LPat (GhcPass idR)
pat2:pats2 :: [LPat (GhcPass idR)]
pats2) = [LPat (GhcPass idR)]
pats1

pprGRHSs :: (OutputableBndrId (GhcPass idR), Outputable body)
         => HsMatchContext idL -> GRHSs (GhcPass idR) body -> SDoc
pprGRHSs :: HsMatchContext idL -> GRHSs (GhcPass idR) body -> SDoc
pprGRHSs ctxt :: HsMatchContext idL
ctxt (GRHSs _ grhss :: [LGRHS (GhcPass idR) body]
grhss (L _ binds :: HsLocalBinds (GhcPass idR)
binds))
  = [SDoc] -> SDoc
vcat ((LGRHS (GhcPass idR) body -> SDoc)
-> [LGRHS (GhcPass idR) body] -> [SDoc]
forall a b. (a -> b) -> [a] -> [b]
map (HsMatchContext idL -> GRHS (GhcPass idR) body -> SDoc
forall (idR :: Pass) body idL.
(OutputableBndrId (GhcPass idR), Outputable body) =>
HsMatchContext idL -> GRHS (GhcPass idR) body -> SDoc
pprGRHS HsMatchContext idL
ctxt (GRHS (GhcPass idR) body -> SDoc)
-> (LGRHS (GhcPass idR) body -> GRHS (GhcPass idR) body)
-> LGRHS (GhcPass idR) body
-> SDoc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LGRHS (GhcPass idR) body -> GRHS (GhcPass idR) body
forall a. HasSrcSpan a => a -> SrcSpanLess a
unLoc) [LGRHS (GhcPass idR) body]
grhss)
  -- Print the "where" even if the contents of the binds is empty. Only
  -- EmptyLocalBinds means no "where" keyword
 SDoc -> SDoc -> SDoc
$$ Bool -> SDoc -> SDoc
ppUnless (HsLocalBinds (GhcPass idR) -> Bool
forall a b. HsLocalBindsLR a b -> Bool
eqEmptyLocalBinds HsLocalBinds (GhcPass idR)
binds)
      (String -> SDoc
text "where" SDoc -> SDoc -> SDoc
$$ Int -> SDoc -> SDoc
nest 4 (HsLocalBinds (GhcPass idR) -> SDoc
forall (idL :: Pass) (idR :: Pass).
(OutputableBndrId (GhcPass idL), OutputableBndrId (GhcPass idR)) =>
HsLocalBindsLR (GhcPass idL) (GhcPass idR) -> SDoc
pprBinds HsLocalBinds (GhcPass idR)
binds))
pprGRHSs _ (XGRHSs x :: XXGRHSs (GhcPass idR) body
x) = NoExt -> SDoc
forall a. Outputable a => a -> SDoc
ppr XXGRHSs (GhcPass idR) body
NoExt
x

pprGRHS :: (OutputableBndrId (GhcPass idR), Outputable body)
        => HsMatchContext idL -> GRHS (GhcPass idR) body -> SDoc
pprGRHS :: HsMatchContext idL -> GRHS (GhcPass idR) body -> SDoc
pprGRHS ctxt :: HsMatchContext idL
ctxt (GRHS _ [] body :: body
body)
 =  HsMatchContext idL -> body -> SDoc
forall body idL.
Outputable body =>
HsMatchContext idL -> body -> SDoc
pp_rhs HsMatchContext idL
ctxt body
body

pprGRHS ctxt :: HsMatchContext idL
ctxt (GRHS _ guards :: [GuardLStmt (GhcPass idR)]
guards body :: body
body)
 = [SDoc] -> SDoc
sep [SDoc
vbar SDoc -> SDoc -> SDoc
<+> [GuardLStmt (GhcPass idR)] -> SDoc
forall a. Outputable a => [a] -> SDoc
interpp'SP [GuardLStmt (GhcPass idR)]
guards, HsMatchContext idL -> body -> SDoc
forall body idL.
Outputable body =>
HsMatchContext idL -> body -> SDoc
pp_rhs HsMatchContext idL
ctxt body
body]

pprGRHS _ (XGRHS x :: XXGRHS (GhcPass idR) body
x) = NoExt -> SDoc
forall a. Outputable a => a -> SDoc
ppr XXGRHS (GhcPass idR) body
NoExt
x

pp_rhs :: Outputable body => HsMatchContext idL -> body -> SDoc
pp_rhs :: HsMatchContext idL -> body -> SDoc
pp_rhs ctxt :: HsMatchContext idL
ctxt rhs :: body
rhs = HsMatchContext idL -> SDoc
forall id. HsMatchContext id -> SDoc
matchSeparator HsMatchContext idL
ctxt SDoc -> SDoc -> SDoc
<+> SDoc -> SDoc
pprDeeper (body -> SDoc
forall a. Outputable a => a -> SDoc
ppr body
rhs)

{-
************************************************************************
*                                                                      *
\subsection{Do stmts and list comprehensions}
*                                                                      *
************************************************************************
-}

-- | Located @do@ block Statement
type LStmt id body = Located (StmtLR id id body)

-- | Located Statement with separate Left and Right id's
type LStmtLR idL idR body = Located (StmtLR idL idR body)

-- | @do@ block Statement
type Stmt id body = StmtLR id id body

-- | Command Located Statement
type CmdLStmt   id = LStmt id (LHsCmd  id)

-- | Command Statement
type CmdStmt    id = Stmt  id (LHsCmd  id)

-- | Expression Located Statement
type ExprLStmt  id = LStmt id (LHsExpr id)

-- | Expression Statement
type ExprStmt   id = Stmt  id (LHsExpr id)

-- | Guard Located Statement
type GuardLStmt id = LStmt id (LHsExpr id)

-- | Guard Statement
type GuardStmt  id = Stmt  id (LHsExpr id)

-- | Ghci Located Statement
type GhciLStmt  id = LStmt id (LHsExpr id)

-- | Ghci Statement
type GhciStmt   id = Stmt  id (LHsExpr id)

-- The SyntaxExprs in here are used *only* for do-notation and monad
-- comprehensions, which have rebindable syntax. Otherwise they are unused.
-- | API Annotations when in qualifier lists or guards
--  - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnVbar',
--         'ApiAnnotation.AnnComma','ApiAnnotation.AnnThen',
--         'ApiAnnotation.AnnBy','ApiAnnotation.AnnBy',
--         'ApiAnnotation.AnnGroup','ApiAnnotation.AnnUsing'

-- For details on above see note [Api annotations] in ApiAnnotation
data StmtLR idL idR body -- body should always be (LHs**** idR)
  = LastStmt  -- Always the last Stmt in ListComp, MonadComp,
              -- and (after the renamer, see RnExpr.checkLastStmt) DoExpr, MDoExpr
              -- Not used for GhciStmtCtxt, PatGuard, which scope over other stuff
          (XLastStmt idL idR body)
          body
          Bool               -- True <=> return was stripped by ApplicativeDo
          (SyntaxExpr idR)   -- The return operator
            -- The return operator is used only for MonadComp
            -- For ListComp we use the baked-in 'return'
            -- For DoExpr, MDoExpr, we don't apply a 'return' at all
            -- See Note [Monad Comprehensions]
            -- - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnLarrow'

  -- For details on above see note [Api annotations] in ApiAnnotation
  | BindStmt (XBindStmt idL idR body) -- Post typechecking,
                                -- result type of the function passed to bind;
                                -- that is, S in (>>=) :: Q -> (R -> S) -> T
             (LPat idL)
             body
             (SyntaxExpr idR) -- The (>>=) operator; see Note [The type of bind in Stmts]
             (SyntaxExpr idR) -- The fail operator
             -- The fail operator is noSyntaxExpr
             -- if the pattern match can't fail

  -- | 'ApplicativeStmt' represents an applicative expression built with
  -- '<$>' and '<*>'.  It is generated by the renamer, and is desugared into the
  -- appropriate applicative expression by the desugarer, but it is intended
  -- to be invisible in error messages.
  --
  -- For full details, see Note [ApplicativeDo] in RnExpr
  --
  | ApplicativeStmt
             (XApplicativeStmt idL idR body) -- Post typecheck, Type of the body
             [ ( SyntaxExpr idR
               , ApplicativeArg idL) ]
                      -- [(<$>, e1), (<*>, e2), ..., (<*>, en)]
             (Maybe (SyntaxExpr idR))  -- 'join', if necessary

  | BodyStmt (XBodyStmt idL idR body) -- Post typecheck, element type
                                      -- of the RHS (used for arrows)
             body              -- See Note [BodyStmt]
             (SyntaxExpr idR)  -- The (>>) operator
             (SyntaxExpr idR)  -- The `guard` operator; used only in MonadComp
                               -- See notes [Monad Comprehensions]

  -- | - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnLet'
  --          'ApiAnnotation.AnnOpen' @'{'@,'ApiAnnotation.AnnClose' @'}'@,

  -- For details on above see note [Api annotations] in ApiAnnotation
  | LetStmt  (XLetStmt idL idR body) (LHsLocalBindsLR idL idR)

  -- ParStmts only occur in a list/monad comprehension
  | ParStmt  (XParStmt idL idR body)    -- Post typecheck,
                                        -- S in (>>=) :: Q -> (R -> S) -> T
             [ParStmtBlock idL idR]
             (HsExpr idR)               -- Polymorphic `mzip` for monad comprehensions
             (SyntaxExpr idR)           -- The `>>=` operator
                                        -- See notes [Monad Comprehensions]
            -- After renaming, the ids are the binders
            -- bound by the stmts and used after themp

  | TransStmt {
      StmtLR idL idR body -> XTransStmt idL idR body
trS_ext   :: XTransStmt idL idR body, -- Post typecheck,
                                            -- R in (>>=) :: Q -> (R -> S) -> T
      StmtLR idL idR body -> TransForm
trS_form  :: TransForm,
      StmtLR idL idR body -> [ExprLStmt idL]
trS_stmts :: [ExprLStmt idL],   -- Stmts to the *left* of the 'group'
                                      -- which generates the tuples to be grouped

      StmtLR idL idR body -> [(IdP idR, IdP idR)]
trS_bndrs :: [(IdP idR, IdP idR)], -- See Note [TransStmt binder map]

      StmtLR idL idR body -> LHsExpr idR
trS_using :: LHsExpr idR,
      StmtLR idL idR body -> Maybe (LHsExpr idR)
trS_by :: Maybe (LHsExpr idR),  -- "by e" (optional)
        -- Invariant: if trS_form = GroupBy, then grp_by = Just e

      StmtLR idL idR body -> SyntaxExpr idR
trS_ret :: SyntaxExpr idR,      -- The monomorphic 'return' function for
                                      -- the inner monad comprehensions
      StmtLR idL idR body -> SyntaxExpr idR
trS_bind :: SyntaxExpr idR,     -- The '(>>=)' operator
      StmtLR idL idR body -> HsExpr idR
trS_fmap :: HsExpr idR          -- The polymorphic 'fmap' function for desugaring
                                      -- Only for 'group' forms
                                      -- Just a simple HsExpr, because it's
                                      -- too polymorphic for tcSyntaxOp
    }                                 -- See Note [Monad Comprehensions]

  -- Recursive statement (see Note [How RecStmt works] below)
  -- | - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnRec'

  -- For details on above see note [Api annotations] in ApiAnnotation
  | RecStmt
     { StmtLR idL idR body -> XRecStmt idL idR body
recS_ext :: XRecStmt idL idR body
     , StmtLR idL idR body -> [LStmtLR idL idR body]
recS_stmts :: [LStmtLR idL idR body]

        -- The next two fields are only valid after renaming
     , StmtLR idL idR body -> [IdP idR]
recS_later_ids :: [IdP idR]
                         -- The ids are a subset of the variables bound by the
                         -- stmts that are used in stmts that follow the RecStmt

     , StmtLR idL idR body -> [IdP idR]
recS_rec_ids :: [IdP idR]
                         -- Ditto, but these variables are the "recursive" ones,
                         -- that are used before they are bound in the stmts of
                         -- the RecStmt.
        -- An Id can be in both groups
        -- Both sets of Ids are (now) treated monomorphically
        -- See Note [How RecStmt works] for why they are separate

        -- Rebindable syntax
     , StmtLR idL idR body -> SyntaxExpr idR
recS_bind_fn :: SyntaxExpr idR -- The bind function
     , StmtLR idL idR body -> SyntaxExpr idR
recS_ret_fn  :: SyntaxExpr idR -- The return function
     , StmtLR idL idR body -> SyntaxExpr idR
recS_mfix_fn :: SyntaxExpr idR -- The mfix function
      }
  | XStmtLR (XXStmtLR idL idR body)

-- Extra fields available post typechecking for RecStmt.
data RecStmtTc =
  RecStmtTc
     { RecStmtTc -> Type
recS_bind_ty :: Type       -- S in (>>=) :: Q -> (R -> S) -> T
     , RecStmtTc -> [PostTcExpr]
recS_later_rets :: [PostTcExpr] -- (only used in the arrow version)
     , RecStmtTc -> [PostTcExpr]
recS_rec_rets :: [PostTcExpr] -- These expressions correspond 1-to-1
                                  -- with recS_later_ids and recS_rec_ids,
                                  -- and are the expressions that should be
                                  -- returned by the recursion.
                                  -- They may not quite be the Ids themselves,
                                  -- because the Id may be *polymorphic*, but
                                  -- the returned thing has to be *monomorphic*,
                                  -- so they may be type applications

      , RecStmtTc -> Type
recS_ret_ty :: Type        -- The type of
                                   -- do { stmts; return (a,b,c) }
                                   -- With rebindable syntax the type might not
                                   -- be quite as simple as (m (tya, tyb, tyc)).
      }


type instance XLastStmt        (GhcPass _) (GhcPass _) b = NoExt

type instance XBindStmt        (GhcPass _) GhcPs b = NoExt
type instance XBindStmt        (GhcPass _) GhcRn b = NoExt
type instance XBindStmt        (GhcPass _) GhcTc b = Type

type instance XApplicativeStmt (GhcPass _) GhcPs b = NoExt
type instance XApplicativeStmt (GhcPass _) GhcRn b = NoExt
type instance XApplicativeStmt (GhcPass _) GhcTc b = Type

type instance XBodyStmt        (GhcPass _) GhcPs b = NoExt
type instance XBodyStmt        (GhcPass _) GhcRn b = NoExt
type instance XBodyStmt        (GhcPass _) GhcTc b = Type

type instance XLetStmt         (GhcPass _) (GhcPass _) b = NoExt

type instance XParStmt         (GhcPass _) GhcPs b = NoExt
type instance XParStmt         (GhcPass _) GhcRn b = NoExt
type instance XParStmt         (GhcPass _) GhcTc b = Type

type instance XTransStmt       (GhcPass _) GhcPs b = NoExt
type instance XTransStmt       (GhcPass _) GhcRn b = NoExt
type instance XTransStmt       (GhcPass _) GhcTc b = Type

type instance XRecStmt         (GhcPass _) GhcPs b = NoExt
type instance XRecStmt         (GhcPass _) GhcRn b = NoExt
type instance XRecStmt         (GhcPass _) GhcTc b = RecStmtTc

type instance XXStmtLR         (GhcPass _) (GhcPass _) b = NoExt

data TransForm   -- The 'f' below is the 'using' function, 'e' is the by function
  = ThenForm     -- then f               or    then f by e             (depending on trS_by)
  | GroupForm    -- then group using f   or    then group by e using f (depending on trS_by)
  deriving Typeable TransForm
DataType
Constr
Typeable TransForm =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> TransForm -> c TransForm)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TransForm)
-> (TransForm -> Constr)
-> (TransForm -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TransForm))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TransForm))
-> ((forall b. Data b => b -> b) -> TransForm -> TransForm)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TransForm -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TransForm -> r)
-> (forall u. (forall d. Data d => d -> u) -> TransForm -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> TransForm -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TransForm -> m TransForm)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TransForm -> m TransForm)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TransForm -> m TransForm)
-> Data TransForm
TransForm -> DataType
TransForm -> Constr
(forall b. Data b => b -> b) -> TransForm -> TransForm
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TransForm -> c TransForm
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TransForm
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> TransForm -> u
forall u. (forall d. Data d => d -> u) -> TransForm -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TransForm -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TransForm -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TransForm -> m TransForm
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TransForm -> m TransForm
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TransForm
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TransForm -> c TransForm
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TransForm)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TransForm)
$cGroupForm :: Constr
$cThenForm :: Constr
$tTransForm :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> TransForm -> m TransForm
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TransForm -> m TransForm
gmapMp :: (forall d. Data d => d -> m d) -> TransForm -> m TransForm
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TransForm -> m TransForm
gmapM :: (forall d. Data d => d -> m d) -> TransForm -> m TransForm
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TransForm -> m TransForm
gmapQi :: Int -> (forall d. Data d => d -> u) -> TransForm -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TransForm -> u
gmapQ :: (forall d. Data d => d -> u) -> TransForm -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TransForm -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TransForm -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TransForm -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TransForm -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TransForm -> r
gmapT :: (forall b. Data b => b -> b) -> TransForm -> TransForm
$cgmapT :: (forall b. Data b => b -> b) -> TransForm -> TransForm
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TransForm)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TransForm)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c TransForm)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TransForm)
dataTypeOf :: TransForm -> DataType
$cdataTypeOf :: TransForm -> DataType
toConstr :: TransForm -> Constr
$ctoConstr :: TransForm -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TransForm
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TransForm
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TransForm -> c TransForm
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TransForm -> c TransForm
$cp1Data :: Typeable TransForm
Data

-- | Parenthesised Statement Block
data ParStmtBlock idL idR
  = ParStmtBlock
        (XParStmtBlock idL idR)
        [ExprLStmt idL]
        [IdP idR]          -- The variables to be returned
        (SyntaxExpr idR)   -- The return operator
  | XParStmtBlock (XXParStmtBlock idL idR)

type instance XParStmtBlock  (GhcPass pL) (GhcPass pR) = NoExt
type instance XXParStmtBlock (GhcPass pL) (GhcPass pR) = NoExt

-- | Applicative Argument
data ApplicativeArg idL
  = ApplicativeArgOne      -- A single statement (BindStmt or BodyStmt)
      (XApplicativeArgOne idL)
      (LPat idL)           -- WildPat if it was a BodyStmt (see below)
      (LHsExpr idL)
      Bool                 -- True <=> was a BodyStmt
                           -- False <=> was a BindStmt
                           -- See Note [Applicative BodyStmt]

  | ApplicativeArgMany     -- do { stmts; return vars }
      (XApplicativeArgMany idL)
      [ExprLStmt idL]      -- stmts
      (HsExpr idL)         -- return (v1,..,vn), or just (v1,..,vn)
      (LPat idL)           -- (v1,...,vn)
  | XApplicativeArg (XXApplicativeArg idL)

type instance XApplicativeArgOne  (GhcPass _) = NoExt
type instance XApplicativeArgMany (GhcPass _) = NoExt
type instance XXApplicativeArg    (GhcPass _) = NoExt

{-
Note [The type of bind in Stmts]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Some Stmts, notably BindStmt, keep the (>>=) bind operator.
We do NOT assume that it has type
    (>>=) :: m a -> (a -> m b) -> m b
In some cases (see Trac #303, #1537) it might have a more
exotic type, such as
    (>>=) :: m i j a -> (a -> m j k b) -> m i k b
So we must be careful not to make assumptions about the type.
In particular, the monad may not be uniform throughout.

Note [TransStmt binder map]
~~~~~~~~~~~~~~~~~~~~~~~~~~~
The [(idR,idR)] in a TransStmt behaves as follows:

  * Before renaming: []

  * After renaming:
          [ (x27,x27), ..., (z35,z35) ]
    These are the variables
       bound by the stmts to the left of the 'group'
       and used either in the 'by' clause,
                or     in the stmts following the 'group'
    Each item is a pair of identical variables.

  * After typechecking:
          [ (x27:Int, x27:[Int]), ..., (z35:Bool, z35:[Bool]) ]
    Each pair has the same unique, but different *types*.

Note [BodyStmt]
~~~~~~~~~~~~~~~
BodyStmts are a bit tricky, because what they mean
depends on the context.  Consider the following contexts:

        A do expression of type (m res_ty)
        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
        * BodyStmt E any_ty:   do { ....; E; ... }
                E :: m any_ty
          Translation: E >> ...

        A list comprehensions of type [elt_ty]
        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
        * BodyStmt E Bool:   [ .. | .... E ]
                        [ .. | ..., E, ... ]
                        [ .. | .... | ..., E | ... ]
                E :: Bool
          Translation: if E then fail else ...

        A guard list, guarding a RHS of type rhs_ty
        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
        * BodyStmt E BooParStmtBlockl:   f x | ..., E, ... = ...rhs...
                E :: Bool
          Translation: if E then fail else ...

        A monad comprehension of type (m res_ty)
        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
        * BodyStmt E Bool:   [ .. | .... E ]
                E :: Bool
          Translation: guard E >> ...

Array comprehensions are handled like list comprehensions.

Note [How RecStmt works]
~~~~~~~~~~~~~~~~~~~~~~~~
Example:
   HsDo [ BindStmt x ex

        , RecStmt { recS_rec_ids   = [a, c]
                  , recS_stmts     = [ BindStmt b (return (a,c))
                                     , LetStmt a = ...b...
                                     , BindStmt c ec ]
                  , recS_later_ids = [a, b]

        , return (a b) ]

Here, the RecStmt binds a,b,c; but
  - Only a,b are used in the stmts *following* the RecStmt,
  - Only a,c are used in the stmts *inside* the RecStmt
        *before* their bindings

Why do we need *both* rec_ids and later_ids?  For monads they could be
combined into a single set of variables, but not for arrows.  That
follows from the types of the respective feedback operators:

        mfix :: MonadFix m => (a -> m a) -> m a
        loop :: ArrowLoop a => a (b,d) (c,d) -> a b c

* For mfix, the 'a' covers the union of the later_ids and the rec_ids
* For 'loop', 'c' is the later_ids and 'd' is the rec_ids

Note [Typing a RecStmt]
~~~~~~~~~~~~~~~~~~~~~~~
A (RecStmt stmts) types as if you had written

  (v1,..,vn, _, ..., _) <- mfix (\~(_, ..., _, r1, ..., rm) ->
                                 do { stmts
                                    ; return (v1,..vn, r1, ..., rm) })

where v1..vn are the later_ids
      r1..rm are the rec_ids

Note [Monad Comprehensions]
~~~~~~~~~~~~~~~~~~~~~~~~~~~
Monad comprehensions require separate functions like 'return' and
'>>=' for desugaring. These functions are stored in the statements
used in monad comprehensions. For example, the 'return' of the 'LastStmt'
expression is used to lift the body of the monad comprehension:

  [ body | stmts ]
   =>
  stmts >>= \bndrs -> return body

In transform and grouping statements ('then ..' and 'then group ..') the
'return' function is required for nested monad comprehensions, for example:

  [ body | stmts, then f, rest ]
   =>
  f [ env | stmts ] >>= \bndrs -> [ body | rest ]

BodyStmts require the 'Control.Monad.guard' function for boolean
expressions:

  [ body | exp, stmts ]
   =>
  guard exp >> [ body | stmts ]

Parallel statements require the 'Control.Monad.Zip.mzip' function:

  [ body | stmts1 | stmts2 | .. ]
   =>
  mzip stmts1 (mzip stmts2 (..)) >>= \(bndrs1, (bndrs2, ..)) -> return body

In any other context than 'MonadComp', the fields for most of these
'SyntaxExpr's stay bottom.


Note [Applicative BodyStmt]

(#12143) For the purposes of ApplicativeDo, we treat any BodyStmt
as if it was a BindStmt with a wildcard pattern.  For example,

  do
    x <- A
    B
    return x

is transformed as if it were

  do
    x <- A
    _ <- B
    return x

so it transforms to

  (\(x,_) -> x) <$> A <*> B

But we have to remember when we treat a BodyStmt like a BindStmt,
because in error messages we want to emit the original syntax the user
wrote, not our internal representation.  So ApplicativeArgOne has a
Bool flag that is True when the original statement was a BodyStmt, so
that we can pretty-print it correctly.
-}

instance (Outputable (StmtLR idL idL (LHsExpr idL)),
          Outputable (XXParStmtBlock idL idR))
        => Outputable (ParStmtBlock idL idR) where
  ppr :: ParStmtBlock idL idR -> SDoc
ppr (ParStmtBlock _ stmts :: [ExprLStmt idL]
stmts _ _) = [ExprLStmt idL] -> SDoc
forall a. Outputable a => [a] -> SDoc
interpp'SP [ExprLStmt idL]
stmts
  ppr (XParStmtBlock x :: XXParStmtBlock idL idR
x)          = XXParStmtBlock idL idR -> SDoc
forall a. Outputable a => a -> SDoc
ppr XXParStmtBlock idL idR
x

instance (idL ~ GhcPass pl,idR ~ GhcPass pr,
          OutputableBndrId idL, OutputableBndrId idR,
          Outputable body)
         => Outputable (StmtLR idL idR body) where
    ppr :: StmtLR idL idR body -> SDoc
ppr stmt :: StmtLR idL idR body
stmt = StmtLR (GhcPass pl) (GhcPass pr) body -> SDoc
forall (idL :: Pass) (idR :: Pass) body.
(OutputableBndrId (GhcPass idL), OutputableBndrId (GhcPass idR),
 Outputable body) =>
StmtLR (GhcPass idL) (GhcPass idR) body -> SDoc
pprStmt StmtLR idL idR body
StmtLR (GhcPass pl) (GhcPass pr) body
stmt

pprStmt :: forall idL idR body . (OutputableBndrId (GhcPass idL),
                                  OutputableBndrId (GhcPass idR),
                                  Outputable body)
        => (StmtLR (GhcPass idL) (GhcPass idR) body) -> SDoc
pprStmt :: StmtLR (GhcPass idL) (GhcPass idR) body -> SDoc
pprStmt (LastStmt _ expr :: body
expr ret_stripped :: Bool
ret_stripped _)
  = SDoc -> SDoc
whenPprDebug (String -> SDoc
text "[last]") SDoc -> SDoc -> SDoc
<+>
       (if Bool
ret_stripped then String -> SDoc
text "return" else SDoc
empty) SDoc -> SDoc -> SDoc
<+>
       body -> SDoc
forall a. Outputable a => a -> SDoc
ppr body
expr
pprStmt (BindStmt _ pat :: LPat (GhcPass idL)
pat expr :: body
expr _ _) = [SDoc] -> SDoc
hsep [LPat (GhcPass idL) -> SDoc
forall a. Outputable a => a -> SDoc
ppr LPat (GhcPass idL)
pat, SDoc
larrow, body -> SDoc
forall a. Outputable a => a -> SDoc
ppr body
expr]
pprStmt (LetStmt _ (L _ binds :: HsLocalBindsLR (GhcPass idL) (GhcPass idR)
binds))   = [SDoc] -> SDoc
hsep [String -> SDoc
text "let", HsLocalBindsLR (GhcPass idL) (GhcPass idR) -> SDoc
forall (idL :: Pass) (idR :: Pass).
(OutputableBndrId (GhcPass idL), OutputableBndrId (GhcPass idR)) =>
HsLocalBindsLR (GhcPass idL) (GhcPass idR) -> SDoc
pprBinds HsLocalBindsLR (GhcPass idL) (GhcPass idR)
binds]
pprStmt (BodyStmt _ expr :: body
expr _ _)     = body -> SDoc
forall a. Outputable a => a -> SDoc
ppr body
expr
pprStmt (ParStmt _ stmtss :: [ParStmtBlock (GhcPass idL) (GhcPass idR)]
stmtss _ _)   = [SDoc] -> SDoc
sep (SDoc -> [SDoc] -> [SDoc]
punctuate (String -> SDoc
text " | ") ((ParStmtBlock (GhcPass idL) (GhcPass idR) -> SDoc)
-> [ParStmtBlock (GhcPass idL) (GhcPass idR)] -> [SDoc]
forall a b. (a -> b) -> [a] -> [b]
map ParStmtBlock (GhcPass idL) (GhcPass idR) -> SDoc
forall a. Outputable a => a -> SDoc
ppr [ParStmtBlock (GhcPass idL) (GhcPass idR)]
stmtss))

pprStmt (TransStmt { trS_stmts :: forall idL idR body. StmtLR idL idR body -> [ExprLStmt idL]
trS_stmts = [ExprLStmt (GhcPass idL)]
stmts, trS_by :: forall idL idR body. StmtLR idL idR body -> Maybe (LHsExpr idR)
trS_by = Maybe (LHsExpr (GhcPass idR))
by
                   , trS_using :: forall idL idR body. StmtLR idL idR body -> LHsExpr idR
trS_using = LHsExpr (GhcPass idR)
using, trS_form :: forall idL idR body. StmtLR idL idR body -> TransForm
trS_form = TransForm
form })
  = [SDoc] -> SDoc
sep ([SDoc] -> SDoc) -> [SDoc] -> SDoc
forall a b. (a -> b) -> a -> b
$ SDoc -> [SDoc] -> [SDoc]
punctuate SDoc
comma ((ExprLStmt (GhcPass idL) -> SDoc)
-> [ExprLStmt (GhcPass idL)] -> [SDoc]
forall a b. (a -> b) -> [a] -> [b]
map ExprLStmt (GhcPass idL) -> SDoc
forall a. Outputable a => a -> SDoc
ppr [ExprLStmt (GhcPass idL)]
stmts [SDoc] -> [SDoc] -> [SDoc]
forall a. [a] -> [a] -> [a]
++ [Maybe (LHsExpr (GhcPass idR))
-> LHsExpr (GhcPass idR) -> TransForm -> SDoc
forall body.
Outputable body =>
Maybe body -> body -> TransForm -> SDoc
pprTransStmt Maybe (LHsExpr (GhcPass idR))
by LHsExpr (GhcPass idR)
using TransForm
form])

pprStmt (RecStmt { recS_stmts :: forall idL idR body. StmtLR idL idR body -> [LStmtLR idL idR body]
recS_stmts = [LStmtLR (GhcPass idL) (GhcPass idR) body]
segment, recS_rec_ids :: forall idL idR body. StmtLR idL idR body -> [IdP idR]
recS_rec_ids = [IdP (GhcPass idR)]
rec_ids
                 , recS_later_ids :: forall idL idR body. StmtLR idL idR body -> [IdP idR]
recS_later_ids = [IdP (GhcPass idR)]
later_ids })
  = String -> SDoc
text "rec" SDoc -> SDoc -> SDoc
<+>
    [SDoc] -> SDoc
vcat [ [LStmtLR (GhcPass idL) (GhcPass idR) body] -> SDoc
forall (idL :: Pass) (idR :: Pass) body.
(OutputableBndrId (GhcPass idL), OutputableBndrId (GhcPass idR),
 Outputable body) =>
[LStmtLR (GhcPass idL) (GhcPass idR) body] -> SDoc
ppr_do_stmts [LStmtLR (GhcPass idL) (GhcPass idR) body]
segment
         , SDoc -> SDoc
whenPprDebug ([SDoc] -> SDoc
vcat [ String -> SDoc
text "rec_ids=" SDoc -> SDoc -> SDoc
<> [IdP (GhcPass idR)] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [IdP (GhcPass idR)]
rec_ids
                            , String -> SDoc
text "later_ids=" SDoc -> SDoc -> SDoc
<> [IdP (GhcPass idR)] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [IdP (GhcPass idR)]
later_ids])]

pprStmt (ApplicativeStmt _ args :: [(SyntaxExpr (GhcPass idR), ApplicativeArg (GhcPass idL))]
args mb_join :: Maybe (SyntaxExpr (GhcPass idR))
mb_join)
  = (PprStyle -> SDoc) -> SDoc
getPprStyle ((PprStyle -> SDoc) -> SDoc) -> (PprStyle -> SDoc) -> SDoc
forall a b. (a -> b) -> a -> b
$ \style :: PprStyle
style ->
      if PprStyle -> Bool
userStyle PprStyle
style
         then SDoc
pp_for_user
         else SDoc
pp_debug
  where
  -- make all the Applicative stuff invisible in error messages by
  -- flattening the whole ApplicativeStmt nest back to a sequence
  -- of statements.
   pp_for_user :: SDoc
pp_for_user = [SDoc] -> SDoc
vcat ([SDoc] -> SDoc) -> [SDoc] -> SDoc
forall a b. (a -> b) -> a -> b
$ ((SyntaxExpr (GhcPass idR), ApplicativeArg (GhcPass idL))
 -> [SDoc])
-> [(SyntaxExpr (GhcPass idR), ApplicativeArg (GhcPass idL))]
-> [SDoc]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (SyntaxExpr (GhcPass idR), ApplicativeArg (GhcPass idL)) -> [SDoc]
forall a. (a, ApplicativeArg (GhcPass idL)) -> [SDoc]
flattenArg [(SyntaxExpr (GhcPass idR), ApplicativeArg (GhcPass idL))]
args

   -- ppr directly rather than transforming here, because we need to
   -- inject a "return" which is hard when we're polymorphic in the id
   -- type.
   flattenStmt :: ExprLStmt (GhcPass idL) -> [SDoc]
   flattenStmt :: ExprLStmt (GhcPass idL) -> [SDoc]
flattenStmt (L _ (ApplicativeStmt _ args :: [(SyntaxExpr (GhcPass idL), ApplicativeArg (GhcPass idL))]
args _)) = ((SyntaxExpr (GhcPass idL), ApplicativeArg (GhcPass idL))
 -> [SDoc])
-> [(SyntaxExpr (GhcPass idL), ApplicativeArg (GhcPass idL))]
-> [SDoc]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (SyntaxExpr (GhcPass idL), ApplicativeArg (GhcPass idL)) -> [SDoc]
forall a. (a, ApplicativeArg (GhcPass idL)) -> [SDoc]
flattenArg [(SyntaxExpr (GhcPass idL), ApplicativeArg (GhcPass idL))]
args
   flattenStmt stmt :: ExprLStmt (GhcPass idL)
stmt = [ExprLStmt (GhcPass idL) -> SDoc
forall a. Outputable a => a -> SDoc
ppr ExprLStmt (GhcPass idL)
stmt]

   flattenArg :: forall a . (a, ApplicativeArg (GhcPass idL)) -> [SDoc]
   flattenArg :: (a, ApplicativeArg (GhcPass idL)) -> [SDoc]
flattenArg (_, ApplicativeArgOne _ pat :: LPat (GhcPass idL)
pat expr :: LHsExpr (GhcPass idL)
expr isBody :: Bool
isBody)
     | Bool
isBody =  -- See Note [Applicative BodyStmt]
     [StmtLR (GhcPass idL) (GhcPass idL) (LHsExpr (GhcPass idL)) -> SDoc
forall a. Outputable a => a -> SDoc
ppr (XBodyStmt (GhcPass idL) (GhcPass idL) (LHsExpr (GhcPass idL))
-> LHsExpr (GhcPass idL)
-> SyntaxExpr (GhcPass idL)
-> SyntaxExpr (GhcPass idL)
-> StmtLR (GhcPass idL) (GhcPass idL) (LHsExpr (GhcPass idL))
forall idL idR body.
XBodyStmt idL idR body
-> body -> SyntaxExpr idR -> SyntaxExpr idR -> StmtLR idL idR body
BodyStmt (String
-> XBodyStmt (GhcPass idL) (GhcPass idL) (LHsExpr (GhcPass idL))
forall a. String -> a
panic "pprStmt") LHsExpr (GhcPass idL)
expr SyntaxExpr (GhcPass idL)
forall (p :: Pass). SyntaxExpr (GhcPass p)
noSyntaxExpr SyntaxExpr (GhcPass idL)
forall (p :: Pass). SyntaxExpr (GhcPass p)
noSyntaxExpr
             :: ExprStmt (GhcPass idL))]
     | Bool
otherwise =
     [StmtLR (GhcPass idL) (GhcPass idL) (LHsExpr (GhcPass idL)) -> SDoc
forall a. Outputable a => a -> SDoc
ppr (XBindStmt (GhcPass idL) (GhcPass idL) (LHsExpr (GhcPass idL))
-> LPat (GhcPass idL)
-> LHsExpr (GhcPass idL)
-> SyntaxExpr (GhcPass idL)
-> SyntaxExpr (GhcPass idL)
-> StmtLR (GhcPass idL) (GhcPass idL) (LHsExpr (GhcPass idL))
forall idL idR body.
XBindStmt idL idR body
-> LPat idL
-> body
-> SyntaxExpr idR
-> SyntaxExpr idR
-> StmtLR idL idR body
BindStmt (String
-> XBindStmt (GhcPass idL) (GhcPass idL) (LHsExpr (GhcPass idL))
forall a. String -> a
panic "pprStmt") LPat (GhcPass idL)
pat LHsExpr (GhcPass idL)
expr SyntaxExpr (GhcPass idL)
forall (p :: Pass). SyntaxExpr (GhcPass p)
noSyntaxExpr SyntaxExpr (GhcPass idL)
forall (p :: Pass). SyntaxExpr (GhcPass p)
noSyntaxExpr
             :: ExprStmt (GhcPass idL))]
   flattenArg (_, ApplicativeArgMany _ stmts :: [ExprLStmt (GhcPass idL)]
stmts _ _) =
     (ExprLStmt (GhcPass idL) -> [SDoc])
-> [ExprLStmt (GhcPass idL)] -> [SDoc]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap ExprLStmt (GhcPass idL) -> [SDoc]
flattenStmt [ExprLStmt (GhcPass idL)]
stmts
   flattenArg (_, XApplicativeArg _) = String -> [SDoc]
forall a. String -> a
panic "flattenArg"

   pp_debug :: SDoc
pp_debug =
     let
         ap_expr :: SDoc
ap_expr = [SDoc] -> SDoc
sep (SDoc -> [SDoc] -> [SDoc]
punctuate (String -> SDoc
text " |") (((SyntaxExpr (GhcPass idR), ApplicativeArg (GhcPass idL)) -> SDoc)
-> [(SyntaxExpr (GhcPass idR), ApplicativeArg (GhcPass idL))]
-> [SDoc]
forall a b. (a -> b) -> [a] -> [b]
map (SyntaxExpr (GhcPass idR), ApplicativeArg (GhcPass idL)) -> SDoc
forall a. (a, ApplicativeArg (GhcPass idL)) -> SDoc
pp_arg [(SyntaxExpr (GhcPass idR), ApplicativeArg (GhcPass idL))]
args))
     in
       if Maybe (SyntaxExpr (GhcPass idR)) -> Bool
forall a. Maybe a -> Bool
isNothing Maybe (SyntaxExpr (GhcPass idR))
mb_join
          then SDoc
ap_expr
          else String -> SDoc
text "join" SDoc -> SDoc -> SDoc
<+> SDoc -> SDoc
parens SDoc
ap_expr

   pp_arg :: (a, ApplicativeArg (GhcPass idL)) -> SDoc
   pp_arg :: (a, ApplicativeArg (GhcPass idL)) -> SDoc
pp_arg (_, ApplicativeArgOne _ pat :: LPat (GhcPass idL)
pat expr :: LHsExpr (GhcPass idL)
expr isBody :: Bool
isBody)
     | Bool
isBody =  -- See Note [Applicative BodyStmt]
     StmtLR (GhcPass idL) (GhcPass idL) (LHsExpr (GhcPass idL)) -> SDoc
forall a. Outputable a => a -> SDoc
ppr (XBodyStmt (GhcPass idL) (GhcPass idL) (LHsExpr (GhcPass idL))
-> LHsExpr (GhcPass idL)
-> SyntaxExpr (GhcPass idL)
-> SyntaxExpr (GhcPass idL)
-> StmtLR (GhcPass idL) (GhcPass idL) (LHsExpr (GhcPass idL))
forall idL idR body.
XBodyStmt idL idR body
-> body -> SyntaxExpr idR -> SyntaxExpr idR -> StmtLR idL idR body
BodyStmt (String
-> XBodyStmt (GhcPass idL) (GhcPass idL) (LHsExpr (GhcPass idL))
forall a. String -> a
panic "pprStmt") LHsExpr (GhcPass idL)
expr SyntaxExpr (GhcPass idL)
forall (p :: Pass). SyntaxExpr (GhcPass p)
noSyntaxExpr SyntaxExpr (GhcPass idL)
forall (p :: Pass). SyntaxExpr (GhcPass p)
noSyntaxExpr
            :: ExprStmt (GhcPass idL))
     | Bool
otherwise =
     StmtLR (GhcPass idL) (GhcPass idL) (LHsExpr (GhcPass idL)) -> SDoc
forall a. Outputable a => a -> SDoc
ppr (XBindStmt (GhcPass idL) (GhcPass idL) (LHsExpr (GhcPass idL))
-> LPat (GhcPass idL)
-> LHsExpr (GhcPass idL)
-> SyntaxExpr (GhcPass idL)
-> SyntaxExpr (GhcPass idL)
-> StmtLR (GhcPass idL) (GhcPass idL) (LHsExpr (GhcPass idL))
forall idL idR body.
XBindStmt idL idR body
-> LPat idL
-> body
-> SyntaxExpr idR
-> SyntaxExpr idR
-> StmtLR idL idR body
BindStmt (String
-> XBindStmt (GhcPass idL) (GhcPass idL) (LHsExpr (GhcPass idL))
forall a. String -> a
panic "pprStmt") LPat (GhcPass idL)
pat LHsExpr (GhcPass idL)
expr SyntaxExpr (GhcPass idL)
forall (p :: Pass). SyntaxExpr (GhcPass p)
noSyntaxExpr SyntaxExpr (GhcPass idL)
forall (p :: Pass). SyntaxExpr (GhcPass p)
noSyntaxExpr
            :: ExprStmt (GhcPass idL))
   pp_arg (_, ApplicativeArgMany _ stmts :: [ExprLStmt (GhcPass idL)]
stmts return :: HsExpr (GhcPass idL)
return pat :: LPat (GhcPass idL)
pat) =
     LPat (GhcPass idL) -> SDoc
forall a. Outputable a => a -> SDoc
ppr LPat (GhcPass idL)
pat SDoc -> SDoc -> SDoc
<+>
     String -> SDoc
text "<-" SDoc -> SDoc -> SDoc
<+>
     HsExpr (GhcPass idL) -> SDoc
forall a. Outputable a => a -> SDoc
ppr (XDo (GhcPass idL)
-> HsStmtContext Name
-> Located [ExprLStmt (GhcPass idL)]
-> HsExpr (GhcPass idL)
forall p.
XDo p -> HsStmtContext Name -> Located [ExprLStmt p] -> HsExpr p
HsDo (String -> XDo (GhcPass idL)
forall a. String -> a
panic "pprStmt") HsStmtContext Name
forall id. HsStmtContext id
DoExpr (SrcSpanLess (Located [ExprLStmt (GhcPass idL)])
-> Located [ExprLStmt (GhcPass idL)]
forall a. HasSrcSpan a => SrcSpanLess a -> a
noLoc
               ([ExprLStmt (GhcPass idL)]
stmts [ExprLStmt (GhcPass idL)]
-> [ExprLStmt (GhcPass idL)] -> [ExprLStmt (GhcPass idL)]
forall a. [a] -> [a] -> [a]
++
                   [SrcSpanLess (ExprLStmt (GhcPass idL)) -> ExprLStmt (GhcPass idL)
forall a. HasSrcSpan a => SrcSpanLess a -> a
noLoc (XLastStmt (GhcPass idL) (GhcPass idL) (LHsExpr (GhcPass idL))
-> LHsExpr (GhcPass idL)
-> Bool
-> SyntaxExpr (GhcPass idL)
-> StmtLR (GhcPass idL) (GhcPass idL) (LHsExpr (GhcPass idL))
forall idL idR body.
XLastStmt idL idR body
-> body -> Bool -> SyntaxExpr idR -> StmtLR idL idR body
LastStmt XLastStmt (GhcPass idL) (GhcPass idL) (LHsExpr (GhcPass idL))
NoExt
noExt (SrcSpanLess (LHsExpr (GhcPass idL)) -> LHsExpr (GhcPass idL)
forall a. HasSrcSpan a => SrcSpanLess a -> a
noLoc SrcSpanLess (LHsExpr (GhcPass idL))
HsExpr (GhcPass idL)
return) Bool
False SyntaxExpr (GhcPass idL)
forall (p :: Pass). SyntaxExpr (GhcPass p)
noSyntaxExpr)])))
   pp_arg (_, XApplicativeArg x :: XXApplicativeArg (GhcPass idL)
x) = NoExt -> SDoc
forall a. Outputable a => a -> SDoc
ppr XXApplicativeArg (GhcPass idL)
NoExt
x

pprStmt (XStmtLR x :: XXStmtLR (GhcPass idL) (GhcPass idR) body
x) = NoExt -> SDoc
forall a. Outputable a => a -> SDoc
ppr XXStmtLR (GhcPass idL) (GhcPass idR) body
NoExt
x

pprTransformStmt :: (OutputableBndrId (GhcPass p))
                 => [IdP (GhcPass p)] -> LHsExpr (GhcPass p)
                 -> Maybe (LHsExpr (GhcPass p)) -> SDoc
pprTransformStmt :: [IdP (GhcPass p)]
-> LHsExpr (GhcPass p) -> Maybe (LHsExpr (GhcPass p)) -> SDoc
pprTransformStmt bndrs :: [IdP (GhcPass p)]
bndrs using :: LHsExpr (GhcPass p)
using by :: Maybe (LHsExpr (GhcPass p))
by
  = [SDoc] -> SDoc
sep [ String -> SDoc
text "then" SDoc -> SDoc -> SDoc
<+> SDoc -> SDoc
whenPprDebug (SDoc -> SDoc
braces ([IdP (GhcPass p)] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [IdP (GhcPass p)]
bndrs))
        , Int -> SDoc -> SDoc
nest 2 (LHsExpr (GhcPass p) -> SDoc
forall a. Outputable a => a -> SDoc
ppr LHsExpr (GhcPass p)
using)
        , Int -> SDoc -> SDoc
nest 2 (Maybe (LHsExpr (GhcPass p)) -> SDoc
forall body. Outputable body => Maybe body -> SDoc
pprBy Maybe (LHsExpr (GhcPass p))
by)]

pprTransStmt :: Outputable body => Maybe body -> body -> TransForm -> SDoc
pprTransStmt :: Maybe body -> body -> TransForm -> SDoc
pprTransStmt by :: Maybe body
by using :: body
using ThenForm
  = [SDoc] -> SDoc
sep [ String -> SDoc
text "then", Int -> SDoc -> SDoc
nest 2 (body -> SDoc
forall a. Outputable a => a -> SDoc
ppr body
using), Int -> SDoc -> SDoc
nest 2 (Maybe body -> SDoc
forall body. Outputable body => Maybe body -> SDoc
pprBy Maybe body
by)]
pprTransStmt by :: Maybe body
by using :: body
using GroupForm
  = [SDoc] -> SDoc
sep [ String -> SDoc
text "then group", Int -> SDoc -> SDoc
nest 2 (Maybe body -> SDoc
forall body. Outputable body => Maybe body -> SDoc
pprBy Maybe body
by), Int -> SDoc -> SDoc
nest 2 (PtrString -> SDoc
ptext (String -> PtrString
sLit "using") SDoc -> SDoc -> SDoc
<+> body -> SDoc
forall a. Outputable a => a -> SDoc
ppr body
using)]

pprBy :: Outputable body => Maybe body -> SDoc
pprBy :: Maybe body -> SDoc
pprBy Nothing  = SDoc
empty
pprBy (Just e :: body
e) = String -> SDoc
text "by" SDoc -> SDoc -> SDoc
<+> body -> SDoc
forall a. Outputable a => a -> SDoc
ppr body
e

pprDo :: (OutputableBndrId (GhcPass p), Outputable body)
      => HsStmtContext any -> [LStmt (GhcPass p) body] -> SDoc
pprDo :: HsStmtContext any -> [LStmt (GhcPass p) body] -> SDoc
pprDo DoExpr        stmts :: [LStmt (GhcPass p) body]
stmts = String -> SDoc
text "do"  SDoc -> SDoc -> SDoc
<+> [LStmt (GhcPass p) body] -> SDoc
forall (idL :: Pass) (idR :: Pass) body.
(OutputableBndrId (GhcPass idL), OutputableBndrId (GhcPass idR),
 Outputable body) =>
[LStmtLR (GhcPass idL) (GhcPass idR) body] -> SDoc
ppr_do_stmts [LStmt (GhcPass p) body]
stmts
pprDo GhciStmtCtxt  stmts :: [LStmt (GhcPass p) body]
stmts = String -> SDoc
text "do"  SDoc -> SDoc -> SDoc
<+> [LStmt (GhcPass p) body] -> SDoc
forall (idL :: Pass) (idR :: Pass) body.
(OutputableBndrId (GhcPass idL), OutputableBndrId (GhcPass idR),
 Outputable body) =>
[LStmtLR (GhcPass idL) (GhcPass idR) body] -> SDoc
ppr_do_stmts [LStmt (GhcPass p) body]
stmts
pprDo ArrowExpr     stmts :: [LStmt (GhcPass p) body]
stmts = String -> SDoc
text "do"  SDoc -> SDoc -> SDoc
<+> [LStmt (GhcPass p) body] -> SDoc
forall (idL :: Pass) (idR :: Pass) body.
(OutputableBndrId (GhcPass idL), OutputableBndrId (GhcPass idR),
 Outputable body) =>
[LStmtLR (GhcPass idL) (GhcPass idR) body] -> SDoc
ppr_do_stmts [LStmt (GhcPass p) body]
stmts
pprDo MDoExpr       stmts :: [LStmt (GhcPass p) body]
stmts = String -> SDoc
text "mdo" SDoc -> SDoc -> SDoc
<+> [LStmt (GhcPass p) body] -> SDoc
forall (idL :: Pass) (idR :: Pass) body.
(OutputableBndrId (GhcPass idL), OutputableBndrId (GhcPass idR),
 Outputable body) =>
[LStmtLR (GhcPass idL) (GhcPass idR) body] -> SDoc
ppr_do_stmts [LStmt (GhcPass p) body]
stmts
pprDo ListComp      stmts :: [LStmt (GhcPass p) body]
stmts = SDoc -> SDoc
brackets    (SDoc -> SDoc) -> SDoc -> SDoc
forall a b. (a -> b) -> a -> b
$ [LStmt (GhcPass p) body] -> SDoc
forall (p :: Pass) body.
(OutputableBndrId (GhcPass p), Outputable body) =>
[LStmt (GhcPass p) body] -> SDoc
pprComp [LStmt (GhcPass p) body]
stmts
pprDo MonadComp     stmts :: [LStmt (GhcPass p) body]
stmts = SDoc -> SDoc
brackets    (SDoc -> SDoc) -> SDoc -> SDoc
forall a b. (a -> b) -> a -> b
$ [LStmt (GhcPass p) body] -> SDoc
forall (p :: Pass) body.
(OutputableBndrId (GhcPass p), Outputable body) =>
[LStmt (GhcPass p) body] -> SDoc
pprComp [LStmt (GhcPass p) body]
stmts
pprDo _             _     = String -> SDoc
forall a. String -> a
panic "pprDo" -- PatGuard, ParStmtCxt

ppr_do_stmts :: (OutputableBndrId (GhcPass idL), OutputableBndrId (GhcPass idR),
                 Outputable body)
             => [LStmtLR (GhcPass idL) (GhcPass idR) body] -> SDoc
-- Print a bunch of do stmts
ppr_do_stmts :: [LStmtLR (GhcPass idL) (GhcPass idR) body] -> SDoc
ppr_do_stmts stmts :: [LStmtLR (GhcPass idL) (GhcPass idR) body]
stmts = ([SDoc] -> SDoc) -> [SDoc] -> SDoc
pprDeeperList [SDoc] -> SDoc
vcat ((LStmtLR (GhcPass idL) (GhcPass idR) body -> SDoc)
-> [LStmtLR (GhcPass idL) (GhcPass idR) body] -> [SDoc]
forall a b. (a -> b) -> [a] -> [b]
map LStmtLR (GhcPass idL) (GhcPass idR) body -> SDoc
forall a. Outputable a => a -> SDoc
ppr [LStmtLR (GhcPass idL) (GhcPass idR) body]
stmts)

pprComp :: (OutputableBndrId (GhcPass p), Outputable body)
        => [LStmt (GhcPass p) body] -> SDoc
pprComp :: [LStmt (GhcPass p) body] -> SDoc
pprComp quals :: [LStmt (GhcPass p) body]
quals     -- Prints:  body | qual1, ..., qualn
  | Just (initStmts :: [LStmt (GhcPass p) body]
initStmts, L _ (LastStmt _ body :: body
body _ _)) <- [LStmt (GhcPass p) body]
-> Maybe ([LStmt (GhcPass p) body], LStmt (GhcPass p) body)
forall a. [a] -> Maybe ([a], a)
snocView [LStmt (GhcPass p) body]
quals
  = if [LStmt (GhcPass p) body] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [LStmt (GhcPass p) body]
initStmts
       -- If there are no statements in a list comprehension besides the last
       -- one, we simply treat it like a normal list. This does arise
       -- occasionally in code that GHC generates, e.g., in implementations of
       -- 'range' for derived 'Ix' instances for product datatypes with exactly
       -- one constructor (e.g., see Trac #12583).
       then body -> SDoc
forall a. Outputable a => a -> SDoc
ppr body
body
       else SDoc -> Int -> SDoc -> SDoc
hang (body -> SDoc
forall a. Outputable a => a -> SDoc
ppr body
body SDoc -> SDoc -> SDoc
<+> SDoc
vbar) 2 ([LStmt (GhcPass p) body] -> SDoc
forall (p :: Pass) body.
(OutputableBndrId (GhcPass p), Outputable body) =>
[LStmt (GhcPass p) body] -> SDoc
pprQuals [LStmt (GhcPass p) body]
initStmts)
  | Bool
otherwise
  = String -> SDoc -> SDoc
forall a. HasCallStack => String -> SDoc -> a
pprPanic "pprComp" ([LStmt (GhcPass p) body] -> SDoc
forall (p :: Pass) body.
(OutputableBndrId (GhcPass p), Outputable body) =>
[LStmt (GhcPass p) body] -> SDoc
pprQuals [LStmt (GhcPass p) body]
quals)

pprQuals :: (OutputableBndrId (GhcPass p), Outputable body)
         => [LStmt (GhcPass p) body] -> SDoc
-- Show list comprehension qualifiers separated by commas
pprQuals :: [LStmt (GhcPass p) body] -> SDoc
pprQuals quals :: [LStmt (GhcPass p) body]
quals = [LStmt (GhcPass p) body] -> SDoc
forall a. Outputable a => [a] -> SDoc
interpp'SP [LStmt (GhcPass p) body]
quals

{-
************************************************************************
*                                                                      *
                Template Haskell quotation brackets
*                                                                      *
************************************************************************
-}

-- | Haskell Splice
data HsSplice id
   = HsTypedSplice       --  $$z  or $$(f 4)
        (XTypedSplice id)
        SpliceDecoration -- Whether $$( ) variant found, for pretty printing
        (IdP id)         -- A unique name to identify this splice point
        (LHsExpr id)     -- See Note [Pending Splices]

   | HsUntypedSplice     --  $z  or $(f 4)
        (XUntypedSplice id)
        SpliceDecoration -- Whether $( ) variant found, for pretty printing
        (IdP id)         -- A unique name to identify this splice point
        (LHsExpr id)     -- See Note [Pending Splices]

   | HsQuasiQuote        -- See Note [Quasi-quote overview] in TcSplice
        (XQuasiQuote id)
        (IdP id)         -- Splice point
        (IdP id)         -- Quoter
        SrcSpan          -- The span of the enclosed string
        FastString       -- The enclosed string

   -- AZ:TODO: use XSplice instead of HsSpliced
   | HsSpliced  -- See Note [Delaying modFinalizers in untyped splices] in
                -- RnSplice.
                -- This is the result of splicing a splice. It is produced by
                -- the renamer and consumed by the typechecker. It lives only
                -- between the two.
        (XSpliced id)
        ThModFinalizers     -- TH finalizers produced by the splice.
        (HsSplicedThing id) -- The result of splicing
   | HsSplicedT
      DelayedSplice
   | XSplice (XXSplice id)  -- Note [Trees that Grow] extension point

type instance XTypedSplice   (GhcPass _) = NoExt
type instance XUntypedSplice (GhcPass _) = NoExt
type instance XQuasiQuote    (GhcPass _) = NoExt
type instance XSpliced       (GhcPass _) = NoExt
type instance XXSplice       (GhcPass _) = NoExt

-- | A splice can appear with various decorations wrapped around it. This data
-- type captures explicitly how it was originally written, for use in the pretty
-- printer.
data SpliceDecoration
  = HasParens -- ^ $( splice ) or $$( splice )
  | HasDollar -- ^ $splice or $$splice
  | NoParens  -- ^ bare splice
  deriving (Typeable SpliceDecoration
DataType
Constr
Typeable SpliceDecoration =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SpliceDecoration -> c SpliceDecoration)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SpliceDecoration)
-> (SpliceDecoration -> Constr)
-> (SpliceDecoration -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SpliceDecoration))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SpliceDecoration))
-> ((forall b. Data b => b -> b)
    -> SpliceDecoration -> SpliceDecoration)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SpliceDecoration -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SpliceDecoration -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> SpliceDecoration -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SpliceDecoration -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> SpliceDecoration -> m SpliceDecoration)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SpliceDecoration -> m SpliceDecoration)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SpliceDecoration -> m SpliceDecoration)
-> Data SpliceDecoration
SpliceDecoration -> DataType
SpliceDecoration -> Constr
(forall b. Data b => b -> b)
-> SpliceDecoration -> SpliceDecoration
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SpliceDecoration -> c SpliceDecoration
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SpliceDecoration
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> SpliceDecoration -> u
forall u. (forall d. Data d => d -> u) -> SpliceDecoration -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SpliceDecoration -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SpliceDecoration -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SpliceDecoration -> m SpliceDecoration
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SpliceDecoration -> m SpliceDecoration
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SpliceDecoration
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SpliceDecoration -> c SpliceDecoration
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SpliceDecoration)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SpliceDecoration)
$cNoParens :: Constr
$cHasDollar :: Constr
$cHasParens :: Constr
$tSpliceDecoration :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> SpliceDecoration -> m SpliceDecoration
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SpliceDecoration -> m SpliceDecoration
gmapMp :: (forall d. Data d => d -> m d)
-> SpliceDecoration -> m SpliceDecoration
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SpliceDecoration -> m SpliceDecoration
gmapM :: (forall d. Data d => d -> m d)
-> SpliceDecoration -> m SpliceDecoration
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SpliceDecoration -> m SpliceDecoration
gmapQi :: Int -> (forall d. Data d => d -> u) -> SpliceDecoration -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> SpliceDecoration -> u
gmapQ :: (forall d. Data d => d -> u) -> SpliceDecoration -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SpliceDecoration -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SpliceDecoration -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SpliceDecoration -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SpliceDecoration -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SpliceDecoration -> r
gmapT :: (forall b. Data b => b -> b)
-> SpliceDecoration -> SpliceDecoration
$cgmapT :: (forall b. Data b => b -> b)
-> SpliceDecoration -> SpliceDecoration
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SpliceDecoration)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SpliceDecoration)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c SpliceDecoration)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SpliceDecoration)
dataTypeOf :: SpliceDecoration -> DataType
$cdataTypeOf :: SpliceDecoration -> DataType
toConstr :: SpliceDecoration -> Constr
$ctoConstr :: SpliceDecoration -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SpliceDecoration
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SpliceDecoration
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SpliceDecoration -> c SpliceDecoration
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SpliceDecoration -> c SpliceDecoration
$cp1Data :: Typeable SpliceDecoration
Data, SpliceDecoration -> SpliceDecoration -> Bool
(SpliceDecoration -> SpliceDecoration -> Bool)
-> (SpliceDecoration -> SpliceDecoration -> Bool)
-> Eq SpliceDecoration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SpliceDecoration -> SpliceDecoration -> Bool
$c/= :: SpliceDecoration -> SpliceDecoration -> Bool
== :: SpliceDecoration -> SpliceDecoration -> Bool
$c== :: SpliceDecoration -> SpliceDecoration -> Bool
Eq, Int -> SpliceDecoration -> ShowS
[SpliceDecoration] -> ShowS
SpliceDecoration -> String
(Int -> SpliceDecoration -> ShowS)
-> (SpliceDecoration -> String)
-> ([SpliceDecoration] -> ShowS)
-> Show SpliceDecoration
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SpliceDecoration] -> ShowS
$cshowList :: [SpliceDecoration] -> ShowS
show :: SpliceDecoration -> String
$cshow :: SpliceDecoration -> String
showsPrec :: Int -> SpliceDecoration -> ShowS
$cshowsPrec :: Int -> SpliceDecoration -> ShowS
Show)

instance Outputable SpliceDecoration where
  ppr :: SpliceDecoration -> SDoc
ppr x :: SpliceDecoration
x = String -> SDoc
text (String -> SDoc) -> String -> SDoc
forall a b. (a -> b) -> a -> b
$ SpliceDecoration -> String
forall a. Show a => a -> String
show SpliceDecoration
x


isTypedSplice :: HsSplice id -> Bool
isTypedSplice :: HsSplice id -> Bool
isTypedSplice (HsTypedSplice {}) = Bool
True
isTypedSplice _                  = Bool
False   -- Quasi-quotes are untyped splices

-- | Finalizers produced by a splice with
-- 'Language.Haskell.TH.Syntax.addModFinalizer'
--
-- See Note [Delaying modFinalizers in untyped splices] in RnSplice. For how
-- this is used.
--
newtype ThModFinalizers = ThModFinalizers [ForeignRef (TH.Q ())]

-- A Data instance which ignores the argument of 'ThModFinalizers'.
instance Data ThModFinalizers where
  gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ThModFinalizers
gunfold _ z :: forall r. r -> c r
z _ = ThModFinalizers -> c ThModFinalizers
forall r. r -> c r
z (ThModFinalizers -> c ThModFinalizers)
-> ThModFinalizers -> c ThModFinalizers
forall a b. (a -> b) -> a -> b
$ [ForeignRef (Q ())] -> ThModFinalizers
ThModFinalizers []
  toConstr :: ThModFinalizers -> Constr
toConstr  a :: ThModFinalizers
a   = DataType -> String -> [String] -> Fixity -> Constr
mkConstr (ThModFinalizers -> DataType
forall a. Data a => a -> DataType
dataTypeOf ThModFinalizers
a) "ThModFinalizers" [] Fixity
Data.Prefix
  dataTypeOf :: ThModFinalizers -> DataType
dataTypeOf a :: ThModFinalizers
a  = String -> [Constr] -> DataType
mkDataType "HsExpr.ThModFinalizers" [ThModFinalizers -> Constr
forall a. Data a => a -> Constr
toConstr ThModFinalizers
a]

-- See Note [Running typed splices in the zonker]
-- These are the arguments that are passed to `TcSplice.runTopSplice`
data DelayedSplice =
  DelayedSplice
    TcLclEnv          -- The local environment to run the splice in
    (LHsExpr GhcRn)   -- The original renamed expression
    TcType            -- The result type of running the splice, unzonked
    (LHsExpr GhcTcId) -- The typechecked expression to run and splice in the result

-- A Data instance which ignores the argument of 'DelayedSplice'.
instance Data DelayedSplice where
  gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DelayedSplice
gunfold _ _ _ = String -> c DelayedSplice
forall a. String -> a
panic "DelayedSplice"
  toConstr :: DelayedSplice -> Constr
toConstr  a :: DelayedSplice
a   = DataType -> String -> [String] -> Fixity -> Constr
mkConstr (DelayedSplice -> DataType
forall a. Data a => a -> DataType
dataTypeOf DelayedSplice
a) "DelayedSplice" [] Fixity
Data.Prefix
  dataTypeOf :: DelayedSplice -> DataType
dataTypeOf a :: DelayedSplice
a  = String -> [Constr] -> DataType
mkDataType "HsExpr.DelayedSplice" [DelayedSplice -> Constr
forall a. Data a => a -> Constr
toConstr DelayedSplice
a]

-- | Haskell Spliced Thing
--
-- Values that can result from running a splice.
data HsSplicedThing id
    = HsSplicedExpr (HsExpr id) -- ^ Haskell Spliced Expression
    | HsSplicedTy   (HsType id) -- ^ Haskell Spliced Type
    | HsSplicedPat  (Pat id)    -- ^ Haskell Spliced Pattern


-- See Note [Pending Splices]
type SplicePointName = Name

-- | Pending Renamer Splice
data PendingRnSplice
  = PendingRnSplice UntypedSpliceFlavour SplicePointName (LHsExpr GhcRn)

data UntypedSpliceFlavour
  = UntypedExpSplice
  | UntypedPatSplice
  | UntypedTypeSplice
  | UntypedDeclSplice
  deriving Typeable UntypedSpliceFlavour
DataType
Constr
Typeable UntypedSpliceFlavour =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> UntypedSpliceFlavour
 -> c UntypedSpliceFlavour)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c UntypedSpliceFlavour)
-> (UntypedSpliceFlavour -> Constr)
-> (UntypedSpliceFlavour -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c UntypedSpliceFlavour))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c UntypedSpliceFlavour))
-> ((forall b. Data b => b -> b)
    -> UntypedSpliceFlavour -> UntypedSpliceFlavour)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> UntypedSpliceFlavour -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> UntypedSpliceFlavour -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> UntypedSpliceFlavour -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> UntypedSpliceFlavour -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> UntypedSpliceFlavour -> m UntypedSpliceFlavour)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> UntypedSpliceFlavour -> m UntypedSpliceFlavour)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> UntypedSpliceFlavour -> m UntypedSpliceFlavour)
-> Data UntypedSpliceFlavour
UntypedSpliceFlavour -> DataType
UntypedSpliceFlavour -> Constr
(forall b. Data b => b -> b)
-> UntypedSpliceFlavour -> UntypedSpliceFlavour
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> UntypedSpliceFlavour
-> c UntypedSpliceFlavour
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UntypedSpliceFlavour
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> UntypedSpliceFlavour -> u
forall u.
(forall d. Data d => d -> u) -> UntypedSpliceFlavour -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UntypedSpliceFlavour -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UntypedSpliceFlavour -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> UntypedSpliceFlavour -> m UntypedSpliceFlavour
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> UntypedSpliceFlavour -> m UntypedSpliceFlavour
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UntypedSpliceFlavour
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> UntypedSpliceFlavour
-> c UntypedSpliceFlavour
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UntypedSpliceFlavour)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c UntypedSpliceFlavour)
$cUntypedDeclSplice :: Constr
$cUntypedTypeSplice :: Constr
$cUntypedPatSplice :: Constr
$cUntypedExpSplice :: Constr
$tUntypedSpliceFlavour :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> UntypedSpliceFlavour -> m UntypedSpliceFlavour
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> UntypedSpliceFlavour -> m UntypedSpliceFlavour
gmapMp :: (forall d. Data d => d -> m d)
-> UntypedSpliceFlavour -> m UntypedSpliceFlavour
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> UntypedSpliceFlavour -> m UntypedSpliceFlavour
gmapM :: (forall d. Data d => d -> m d)
-> UntypedSpliceFlavour -> m UntypedSpliceFlavour
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> UntypedSpliceFlavour -> m UntypedSpliceFlavour
gmapQi :: Int -> (forall d. Data d => d -> u) -> UntypedSpliceFlavour -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> UntypedSpliceFlavour -> u
gmapQ :: (forall d. Data d => d -> u) -> UntypedSpliceFlavour -> [u]
$cgmapQ :: forall u.
(forall d. Data d => d -> u) -> UntypedSpliceFlavour -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UntypedSpliceFlavour -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UntypedSpliceFlavour -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UntypedSpliceFlavour -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UntypedSpliceFlavour -> r
gmapT :: (forall b. Data b => b -> b)
-> UntypedSpliceFlavour -> UntypedSpliceFlavour
$cgmapT :: (forall b. Data b => b -> b)
-> UntypedSpliceFlavour -> UntypedSpliceFlavour
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c UntypedSpliceFlavour)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c UntypedSpliceFlavour)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c UntypedSpliceFlavour)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UntypedSpliceFlavour)
dataTypeOf :: UntypedSpliceFlavour -> DataType
$cdataTypeOf :: UntypedSpliceFlavour -> DataType
toConstr :: UntypedSpliceFlavour -> Constr
$ctoConstr :: UntypedSpliceFlavour -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UntypedSpliceFlavour
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UntypedSpliceFlavour
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> UntypedSpliceFlavour
-> c UntypedSpliceFlavour
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> UntypedSpliceFlavour
-> c UntypedSpliceFlavour
$cp1Data :: Typeable UntypedSpliceFlavour
Data

-- | Pending Type-checker Splice
data PendingTcSplice
  = PendingTcSplice SplicePointName (LHsExpr GhcTc)

{-
Note [Pending Splices]
~~~~~~~~~~~~~~~~~~~~~~
When we rename an untyped bracket, we name and lift out all the nested
splices, so that when the typechecker hits the bracket, it can
typecheck those nested splices without having to walk over the untyped
bracket code.  So for example
    [| f $(g x) |]
looks like

    HsBracket (HsApp (HsVar "f") (HsSpliceE _ (g x)))

which the renamer rewrites to

    HsRnBracketOut (HsApp (HsVar f) (HsSpliceE sn (g x)))
                   [PendingRnSplice UntypedExpSplice sn (g x)]

* The 'sn' is the Name of the splice point, the SplicePointName

* The PendingRnExpSplice gives the splice that splice-point name maps to;
  and the typechecker can now conveniently find these sub-expressions

* The other copy of the splice, in the second argument of HsSpliceE
                                in the renamed first arg of HsRnBracketOut
  is used only for pretty printing

There are four varieties of pending splices generated by the renamer,
distinguished by their UntypedSpliceFlavour

 * Pending expression splices (UntypedExpSplice), e.g.,
       [|$(f x) + 2|]

   UntypedExpSplice is also used for
     * quasi-quotes, where the pending expression expands to
          $(quoter "...blah...")
       (see RnSplice.makePending, HsQuasiQuote case)

     * cross-stage lifting, where the pending expression expands to
          $(lift x)
       (see RnSplice.checkCrossStageLifting)

 * Pending pattern splices (UntypedPatSplice), e.g.,
       [| \$(f x) -> x |]

 * Pending type splices (UntypedTypeSplice), e.g.,
       [| f :: $(g x) |]

 * Pending declaration (UntypedDeclSplice), e.g.,
       [| let $(f x) in ... |]

There is a fifth variety of pending splice, which is generated by the type
checker:

  * Pending *typed* expression splices, (PendingTcSplice), e.g.,
        [||1 + $$(f 2)||]

It would be possible to eliminate HsRnBracketOut and use HsBracketOut for the
output of the renamer. However, when pretty printing the output of the renamer,
e.g., in a type error message, we *do not* want to print out the pending
splices. In contrast, when pretty printing the output of the type checker, we
*do* want to print the pending splices. So splitting them up seems to make
sense, although I hate to add another constructor to HsExpr.
-}

instance (p ~ GhcPass pass, OutputableBndrId p)
       => Outputable (HsSplicedThing p) where
  ppr :: HsSplicedThing p -> SDoc
ppr (HsSplicedExpr e :: HsExpr p
e) = HsExpr (GhcPass pass) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
HsExpr (GhcPass p) -> SDoc
ppr_expr HsExpr p
HsExpr (GhcPass pass)
e
  ppr (HsSplicedTy   t :: HsType p
t) = HsType p -> SDoc
forall a. Outputable a => a -> SDoc
ppr HsType p
t
  ppr (HsSplicedPat  p :: Pat p
p) = Pat p -> SDoc
forall a. Outputable a => a -> SDoc
ppr Pat p
p

instance (p ~ GhcPass pass, OutputableBndrId p) => Outputable (HsSplice p) where
  ppr :: HsSplice p -> SDoc
ppr s :: HsSplice p
s = HsSplice (GhcPass pass) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
HsSplice (GhcPass p) -> SDoc
pprSplice HsSplice p
HsSplice (GhcPass pass)
s

pprPendingSplice :: (OutputableBndrId (GhcPass p))
                 => SplicePointName -> LHsExpr (GhcPass p) -> SDoc
pprPendingSplice :: Name -> LHsExpr (GhcPass p) -> SDoc
pprPendingSplice n :: Name
n e :: LHsExpr (GhcPass p)
e = SDoc -> SDoc
angleBrackets (Name -> SDoc
forall a. Outputable a => a -> SDoc
ppr Name
n SDoc -> SDoc -> SDoc
<> SDoc
comma SDoc -> SDoc -> SDoc
<+> LHsExpr (GhcPass p) -> SDoc
forall a. Outputable a => a -> SDoc
ppr LHsExpr (GhcPass p)
e)

pprSpliceDecl ::  (OutputableBndrId (GhcPass p))
          => HsSplice (GhcPass p) -> SpliceExplicitFlag -> SDoc
pprSpliceDecl :: HsSplice (GhcPass p) -> SpliceExplicitFlag -> SDoc
pprSpliceDecl e :: HsSplice (GhcPass p)
e@HsQuasiQuote{} _ = HsSplice (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
HsSplice (GhcPass p) -> SDoc
pprSplice HsSplice (GhcPass p)
e
pprSpliceDecl e :: HsSplice (GhcPass p)
e ExplicitSplice   = String -> SDoc
text "$(" SDoc -> SDoc -> SDoc
<> HsSplice (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
HsSplice (GhcPass p) -> SDoc
ppr_splice_decl HsSplice (GhcPass p)
e SDoc -> SDoc -> SDoc
<> String -> SDoc
text ")"
pprSpliceDecl e :: HsSplice (GhcPass p)
e ImplicitSplice   = HsSplice (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
HsSplice (GhcPass p) -> SDoc
ppr_splice_decl HsSplice (GhcPass p)
e

ppr_splice_decl :: (OutputableBndrId (GhcPass p))
                => HsSplice (GhcPass p) -> SDoc
ppr_splice_decl :: HsSplice (GhcPass p) -> SDoc
ppr_splice_decl (HsUntypedSplice _ _ n :: IdP (GhcPass p)
n e :: LHsExpr (GhcPass p)
e) = SDoc -> IdP (GhcPass p) -> LHsExpr (GhcPass p) -> SDoc -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
SDoc -> IdP (GhcPass p) -> LHsExpr (GhcPass p) -> SDoc -> SDoc
ppr_splice SDoc
empty IdP (GhcPass p)
n LHsExpr (GhcPass p)
e SDoc
empty
ppr_splice_decl e :: HsSplice (GhcPass p)
e = HsSplice (GhcPass p) -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
HsSplice (GhcPass p) -> SDoc
pprSplice HsSplice (GhcPass p)
e

pprSplice :: (OutputableBndrId (GhcPass p)) => HsSplice (GhcPass p) -> SDoc
pprSplice :: HsSplice (GhcPass p) -> SDoc
pprSplice (HsTypedSplice _ HasParens  n :: IdP (GhcPass p)
n e :: LHsExpr (GhcPass p)
e)
  = SDoc -> IdP (GhcPass p) -> LHsExpr (GhcPass p) -> SDoc -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
SDoc -> IdP (GhcPass p) -> LHsExpr (GhcPass p) -> SDoc -> SDoc
ppr_splice (String -> SDoc
text "$$(") IdP (GhcPass p)
n LHsExpr (GhcPass p)
e (String -> SDoc
text ")")
pprSplice (HsTypedSplice _ HasDollar n :: IdP (GhcPass p)
n e :: LHsExpr (GhcPass p)
e)
  = SDoc -> IdP (GhcPass p) -> LHsExpr (GhcPass p) -> SDoc -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
SDoc -> IdP (GhcPass p) -> LHsExpr (GhcPass p) -> SDoc -> SDoc
ppr_splice (String -> SDoc
text "$$") IdP (GhcPass p)
n LHsExpr (GhcPass p)
e SDoc
empty
pprSplice (HsTypedSplice _ NoParens n :: IdP (GhcPass p)
n e :: LHsExpr (GhcPass p)
e)
  = SDoc -> IdP (GhcPass p) -> LHsExpr (GhcPass p) -> SDoc -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
SDoc -> IdP (GhcPass p) -> LHsExpr (GhcPass p) -> SDoc -> SDoc
ppr_splice SDoc
empty IdP (GhcPass p)
n LHsExpr (GhcPass p)
e SDoc
empty
pprSplice (HsUntypedSplice _ HasParens  n :: IdP (GhcPass p)
n e :: LHsExpr (GhcPass p)
e)
  = SDoc -> IdP (GhcPass p) -> LHsExpr (GhcPass p) -> SDoc -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
SDoc -> IdP (GhcPass p) -> LHsExpr (GhcPass p) -> SDoc -> SDoc
ppr_splice (String -> SDoc
text "$(") IdP (GhcPass p)
n LHsExpr (GhcPass p)
e (String -> SDoc
text ")")
pprSplice (HsUntypedSplice _ HasDollar n :: IdP (GhcPass p)
n e :: LHsExpr (GhcPass p)
e)
  = SDoc -> IdP (GhcPass p) -> LHsExpr (GhcPass p) -> SDoc -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
SDoc -> IdP (GhcPass p) -> LHsExpr (GhcPass p) -> SDoc -> SDoc
ppr_splice (String -> SDoc
text "$")  IdP (GhcPass p)
n LHsExpr (GhcPass p)
e SDoc
empty
pprSplice (HsUntypedSplice _ NoParens n :: IdP (GhcPass p)
n e :: LHsExpr (GhcPass p)
e)
  = SDoc -> IdP (GhcPass p) -> LHsExpr (GhcPass p) -> SDoc -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
SDoc -> IdP (GhcPass p) -> LHsExpr (GhcPass p) -> SDoc -> SDoc
ppr_splice SDoc
empty  IdP (GhcPass p)
n LHsExpr (GhcPass p)
e SDoc
empty
pprSplice (HsQuasiQuote _ n :: IdP (GhcPass p)
n q :: IdP (GhcPass p)
q _ s :: FastString
s)      = IdP (GhcPass p) -> IdP (GhcPass p) -> FastString -> SDoc
forall p. OutputableBndr p => p -> p -> FastString -> SDoc
ppr_quasi IdP (GhcPass p)
n IdP (GhcPass p)
q FastString
s
pprSplice (HsSpliced _ _ thing :: HsSplicedThing (GhcPass p)
thing)         = HsSplicedThing (GhcPass p) -> SDoc
forall a. Outputable a => a -> SDoc
ppr HsSplicedThing (GhcPass p)
thing
pprSplice (HsSplicedT {})               = String -> SDoc
text "Unevaluated typed splice"
pprSplice (XSplice x :: XXSplice (GhcPass p)
x)                   = NoExt -> SDoc
forall a. Outputable a => a -> SDoc
ppr XXSplice (GhcPass p)
NoExt
x

ppr_quasi :: OutputableBndr p => p -> p -> FastString -> SDoc
ppr_quasi :: p -> p -> FastString -> SDoc
ppr_quasi n :: p
n quoter :: p
quoter quote :: FastString
quote = SDoc -> SDoc
whenPprDebug (SDoc -> SDoc
brackets (p -> SDoc
forall a. Outputable a => a -> SDoc
ppr p
n)) SDoc -> SDoc -> SDoc
<>
                           Char -> SDoc
char '[' SDoc -> SDoc -> SDoc
<> p -> SDoc
forall a. Outputable a => a -> SDoc
ppr p
quoter SDoc -> SDoc -> SDoc
<> SDoc
vbar SDoc -> SDoc -> SDoc
<>
                           FastString -> SDoc
forall a. Outputable a => a -> SDoc
ppr FastString
quote SDoc -> SDoc -> SDoc
<> String -> SDoc
text "|]"

ppr_splice :: (OutputableBndrId (GhcPass p))
           => SDoc -> (IdP (GhcPass p)) -> LHsExpr (GhcPass p) -> SDoc -> SDoc
ppr_splice :: SDoc -> IdP (GhcPass p) -> LHsExpr (GhcPass p) -> SDoc -> SDoc
ppr_splice herald :: SDoc
herald n :: IdP (GhcPass p)
n e :: LHsExpr (GhcPass p)
e trail :: SDoc
trail
    = SDoc
herald SDoc -> SDoc -> SDoc
<> SDoc -> SDoc
whenPprDebug (SDoc -> SDoc
brackets (IdP (GhcPass p) -> SDoc
forall a. Outputable a => a -> SDoc
ppr IdP (GhcPass p)
n)) SDoc -> SDoc -> SDoc
<> LHsExpr (GhcPass p) -> SDoc
forall a. Outputable a => a -> SDoc
ppr LHsExpr (GhcPass p)
e SDoc -> SDoc -> SDoc
<> SDoc
trail

-- | Haskell Bracket
data HsBracket p
  = ExpBr  (XExpBr p)   (LHsExpr p)    -- [|  expr  |]
  | PatBr  (XPatBr p)   (LPat p)      -- [p| pat   |]
  | DecBrL (XDecBrL p)  [LHsDecl p]   -- [d| decls |]; result of parser
  | DecBrG (XDecBrG p)  (HsGroup p)   -- [d| decls |]; result of renamer
  | TypBr  (XTypBr p)   (LHsType p)   -- [t| type  |]
  | VarBr  (XVarBr p)   Bool (IdP p)  -- True: 'x, False: ''T
                                -- (The Bool flag is used only in pprHsBracket)
  | TExpBr (XTExpBr p) (LHsExpr p)    -- [||  expr  ||]
  | XBracket (XXBracket p)            -- Note [Trees that Grow] extension point

type instance XExpBr      (GhcPass _) = NoExt
type instance XPatBr      (GhcPass _) = NoExt
type instance XDecBrL     (GhcPass _) = NoExt
type instance XDecBrG     (GhcPass _) = NoExt
type instance XTypBr      (GhcPass _) = NoExt
type instance XVarBr      (GhcPass _) = NoExt
type instance XTExpBr     (GhcPass _) = NoExt
type instance XXBracket   (GhcPass _) = NoExt

isTypedBracket :: HsBracket id -> Bool
isTypedBracket :: HsBracket id -> Bool
isTypedBracket (TExpBr {}) = Bool
True
isTypedBracket _           = Bool
False

instance (p ~ GhcPass pass, OutputableBndrId p)
          => Outputable (HsBracket p) where
  ppr :: HsBracket p -> SDoc
ppr = HsBracket p -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
HsBracket (GhcPass p) -> SDoc
pprHsBracket


pprHsBracket :: (OutputableBndrId (GhcPass p)) => HsBracket (GhcPass p) -> SDoc
pprHsBracket :: HsBracket (GhcPass p) -> SDoc
pprHsBracket (ExpBr _ e :: LHsExpr (GhcPass p)
e)   = SDoc -> SDoc -> SDoc
thBrackets SDoc
empty (LHsExpr (GhcPass p) -> SDoc
forall a. Outputable a => a -> SDoc
ppr LHsExpr (GhcPass p)
e)
pprHsBracket (PatBr _ p :: LPat (GhcPass p)
p)   = SDoc -> SDoc -> SDoc
thBrackets (Char -> SDoc
char 'p') (LPat (GhcPass p) -> SDoc
forall a. Outputable a => a -> SDoc
ppr LPat (GhcPass p)
p)
pprHsBracket (DecBrG _ gp :: HsGroup (GhcPass p)
gp) = SDoc -> SDoc -> SDoc
thBrackets (Char -> SDoc
char 'd') (HsGroup (GhcPass p) -> SDoc
forall a. Outputable a => a -> SDoc
ppr HsGroup (GhcPass p)
gp)
pprHsBracket (DecBrL _ ds :: [LHsDecl (GhcPass p)]
ds) = SDoc -> SDoc -> SDoc
thBrackets (Char -> SDoc
char 'd') ([SDoc] -> SDoc
vcat ((LHsDecl (GhcPass p) -> SDoc) -> [LHsDecl (GhcPass p)] -> [SDoc]
forall a b. (a -> b) -> [a] -> [b]
map LHsDecl (GhcPass p) -> SDoc
forall a. Outputable a => a -> SDoc
ppr [LHsDecl (GhcPass p)]
ds))
pprHsBracket (TypBr _ t :: LHsType (GhcPass p)
t)   = SDoc -> SDoc -> SDoc
thBrackets (Char -> SDoc
char 't') (LHsType (GhcPass p) -> SDoc
forall a. Outputable a => a -> SDoc
ppr LHsType (GhcPass p)
t)
pprHsBracket (VarBr _ True n :: IdP (GhcPass p)
n)
  = Char -> SDoc
char '\'' SDoc -> SDoc -> SDoc
<> IdP (GhcPass p) -> SDoc
forall a. OutputableBndr a => a -> SDoc
pprPrefixOcc IdP (GhcPass p)
n
pprHsBracket (VarBr _ False n :: IdP (GhcPass p)
n)
  = String -> SDoc
text "''" SDoc -> SDoc -> SDoc
<> IdP (GhcPass p) -> SDoc
forall a. OutputableBndr a => a -> SDoc
pprPrefixOcc IdP (GhcPass p)
n
pprHsBracket (TExpBr _ e :: LHsExpr (GhcPass p)
e)  = SDoc -> SDoc
thTyBrackets (LHsExpr (GhcPass p) -> SDoc
forall a. Outputable a => a -> SDoc
ppr LHsExpr (GhcPass p)
e)
pprHsBracket (XBracket e :: XXBracket (GhcPass p)
e)  = NoExt -> SDoc
forall a. Outputable a => a -> SDoc
ppr XXBracket (GhcPass p)
NoExt
e

thBrackets :: SDoc -> SDoc -> SDoc
thBrackets :: SDoc -> SDoc -> SDoc
thBrackets pp_kind :: SDoc
pp_kind pp_body :: SDoc
pp_body = Char -> SDoc
char '[' SDoc -> SDoc -> SDoc
<> SDoc
pp_kind SDoc -> SDoc -> SDoc
<> SDoc
vbar SDoc -> SDoc -> SDoc
<+>
                             SDoc
pp_body SDoc -> SDoc -> SDoc
<+> String -> SDoc
text "|]"

thTyBrackets :: SDoc -> SDoc
thTyBrackets :: SDoc -> SDoc
thTyBrackets pp_body :: SDoc
pp_body = String -> SDoc
text "[||" SDoc -> SDoc -> SDoc
<+> SDoc
pp_body SDoc -> SDoc -> SDoc
<+> PtrString -> SDoc
ptext (String -> PtrString
sLit "||]")

instance Outputable PendingRnSplice where
  ppr :: PendingRnSplice -> SDoc
ppr (PendingRnSplice _ n :: Name
n e :: LHsExpr GhcRn
e) = Name -> LHsExpr GhcRn -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
Name -> LHsExpr (GhcPass p) -> SDoc
pprPendingSplice Name
n LHsExpr GhcRn
e

instance Outputable PendingTcSplice where
  ppr :: PendingTcSplice -> SDoc
ppr (PendingTcSplice n :: Name
n e :: LHsExpr GhcTc
e) = Name -> LHsExpr GhcTc -> SDoc
forall (p :: Pass).
OutputableBndrId (GhcPass p) =>
Name -> LHsExpr (GhcPass p) -> SDoc
pprPendingSplice Name
n LHsExpr GhcTc
e

{-
************************************************************************
*                                                                      *
\subsection{Enumerations and list comprehensions}
*                                                                      *
************************************************************************
-}

-- | Arithmetic Sequence Information
data ArithSeqInfo id
  = From            (LHsExpr id)
  | FromThen        (LHsExpr id)
                    (LHsExpr id)
  | FromTo          (LHsExpr id)
                    (LHsExpr id)
  | FromThenTo      (LHsExpr id)
                    (LHsExpr id)
                    (LHsExpr id)
-- AZ: Sould ArithSeqInfo have a TTG extension?

instance (p ~ GhcPass pass, OutputableBndrId p)
         => Outputable (ArithSeqInfo p) where
    ppr :: ArithSeqInfo p -> SDoc
ppr (From e1 :: LHsExpr p
e1)             = [SDoc] -> SDoc
hcat [LHsExpr p -> SDoc
forall a. Outputable a => a -> SDoc
ppr LHsExpr p
e1, SDoc
pp_dotdot]
    ppr (FromThen e1 :: LHsExpr p
e1 e2 :: LHsExpr p
e2)      = [SDoc] -> SDoc
hcat [LHsExpr p -> SDoc
forall a. Outputable a => a -> SDoc
ppr LHsExpr p
e1, SDoc
comma, SDoc
space, LHsExpr p -> SDoc
forall a. Outputable a => a -> SDoc
ppr LHsExpr p
e2, SDoc
pp_dotdot]
    ppr (FromTo e1 :: LHsExpr p
e1 e3 :: LHsExpr p
e3)        = [SDoc] -> SDoc
hcat [LHsExpr p -> SDoc
forall a. Outputable a => a -> SDoc
ppr LHsExpr p
e1, SDoc
pp_dotdot, LHsExpr p -> SDoc
forall a. Outputable a => a -> SDoc
ppr LHsExpr p
e3]
    ppr (FromThenTo e1 :: LHsExpr p
e1 e2 :: LHsExpr p
e2 e3 :: LHsExpr p
e3)
      = [SDoc] -> SDoc
hcat [LHsExpr p -> SDoc
forall a. Outputable a => a -> SDoc
ppr LHsExpr p
e1, SDoc
comma, SDoc
space, LHsExpr p -> SDoc
forall a. Outputable a => a -> SDoc
ppr LHsExpr p
e2, SDoc
pp_dotdot, LHsExpr p -> SDoc
forall a. Outputable a => a -> SDoc
ppr LHsExpr p
e3]

pp_dotdot :: SDoc
pp_dotdot :: SDoc
pp_dotdot = String -> SDoc
text " .. "

{-
************************************************************************
*                                                                      *
\subsection{HsMatchCtxt}
*                                                                      *
************************************************************************
-}

-- | Haskell Match Context
--
-- Context of a pattern match. This is more subtle than it would seem. See Note
-- [Varieties of pattern matches].
data HsMatchContext id -- Not an extensible tag
  = FunRhs { HsMatchContext id -> Located id
mc_fun        :: Located id    -- ^ function binder of @f@
           , HsMatchContext id -> LexicalFixity
mc_fixity     :: LexicalFixity -- ^ fixing of @f@
           , HsMatchContext id -> SrcStrictness
mc_strictness :: SrcStrictness -- ^ was @f@ banged?
                                            -- See Note [FunBind vs PatBind]
           }
                                -- ^A pattern matching on an argument of a
                                -- function binding
  | LambdaExpr                  -- ^Patterns of a lambda
  | CaseAlt                     -- ^Patterns and guards on a case alternative
  | IfAlt                       -- ^Guards of a multi-way if alternative
  | ProcExpr                    -- ^Patterns of a proc
  | PatBindRhs                  -- ^A pattern binding  eg [y] <- e = e
  | PatBindGuards               -- ^Guards of pattern bindings, e.g.,
                                --    (Just b) | Just _ <- x = e
                                --             | otherwise   = e'

  | RecUpd                      -- ^Record update [used only in DsExpr to
                                --    tell matchWrapper what sort of
                                --    runtime error message to generate]

  | StmtCtxt (HsStmtContext id) -- ^Pattern of a do-stmt, list comprehension,
                                -- pattern guard, etc

  | ThPatSplice            -- ^A Template Haskell pattern splice
  | ThPatQuote             -- ^A Template Haskell pattern quotation [p| (a,b) |]
  | PatSyn                 -- ^A pattern synonym declaration
  deriving a -> HsMatchContext b -> HsMatchContext a
(a -> b) -> HsMatchContext a -> HsMatchContext b
(forall a b. (a -> b) -> HsMatchContext a -> HsMatchContext b)
-> (forall a b. a -> HsMatchContext b -> HsMatchContext a)
-> Functor HsMatchContext
forall a b. a -> HsMatchContext b -> HsMatchContext a
forall a b. (a -> b) -> HsMatchContext a -> HsMatchContext b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> HsMatchContext b -> HsMatchContext a
$c<$ :: forall a b. a -> HsMatchContext b -> HsMatchContext a
fmap :: (a -> b) -> HsMatchContext a -> HsMatchContext b
$cfmap :: forall a b. (a -> b) -> HsMatchContext a -> HsMatchContext b
Functor
deriving instance (Data id) => Data (HsMatchContext id)

instance OutputableBndr id => Outputable (HsMatchContext id) where
  ppr :: HsMatchContext id -> SDoc
ppr m :: HsMatchContext id
m@(FunRhs{})          = String -> SDoc
text "FunRhs" SDoc -> SDoc -> SDoc
<+> Located id -> SDoc
forall a. Outputable a => a -> SDoc
ppr (HsMatchContext id -> Located id
forall id. HsMatchContext id -> Located id
mc_fun HsMatchContext id
m) SDoc -> SDoc -> SDoc
<+> LexicalFixity -> SDoc
forall a. Outputable a => a -> SDoc
ppr (HsMatchContext id -> LexicalFixity
forall id. HsMatchContext id -> LexicalFixity
mc_fixity HsMatchContext id
m)
  ppr LambdaExpr            = String -> SDoc
text "LambdaExpr"
  ppr CaseAlt               = String -> SDoc
text "CaseAlt"
  ppr IfAlt                 = String -> SDoc
text "IfAlt"
  ppr ProcExpr              = String -> SDoc
text "ProcExpr"
  ppr PatBindRhs            = String -> SDoc
text "PatBindRhs"
  ppr PatBindGuards         = String -> SDoc
text "PatBindGuards"
  ppr RecUpd                = String -> SDoc
text "RecUpd"
  ppr (StmtCtxt _)          = String -> SDoc
text "StmtCtxt _"
  ppr ThPatSplice           = String -> SDoc
text "ThPatSplice"
  ppr ThPatQuote            = String -> SDoc
text "ThPatQuote"
  ppr PatSyn                = String -> SDoc
text "PatSyn"

isPatSynCtxt :: HsMatchContext id -> Bool
isPatSynCtxt :: HsMatchContext id -> Bool
isPatSynCtxt ctxt :: HsMatchContext id
ctxt =
  case HsMatchContext id
ctxt of
    PatSyn -> Bool
True
    _      -> Bool
False

-- | Haskell Statement Context. It expects to be parameterised with one of
-- 'RdrName', 'Name' or 'Id'
data HsStmtContext id
  = ListComp
  | MonadComp

  | DoExpr                           -- ^do { ... }
  | MDoExpr                          -- ^mdo { ... }  ie recursive do-expression
  | ArrowExpr                        -- ^do-notation in an arrow-command context

  | GhciStmtCtxt                     -- ^A command-line Stmt in GHCi pat <- rhs
  | PatGuard (HsMatchContext id)     -- ^Pattern guard for specified thing
  | ParStmtCtxt (HsStmtContext id)   -- ^A branch of a parallel stmt
  | TransStmtCtxt (HsStmtContext id) -- ^A branch of a transform stmt
  deriving a -> HsStmtContext b -> HsStmtContext a
(a -> b) -> HsStmtContext a -> HsStmtContext b
(forall a b. (a -> b) -> HsStmtContext a -> HsStmtContext b)
-> (forall a b. a -> HsStmtContext b -> HsStmtContext a)
-> Functor HsStmtContext
forall a b. a -> HsStmtContext b -> HsStmtContext a
forall a b. (a -> b) -> HsStmtContext a -> HsStmtContext b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> HsStmtContext b -> HsStmtContext a
$c<$ :: forall a b. a -> HsStmtContext b -> HsStmtContext a
fmap :: (a -> b) -> HsStmtContext a -> HsStmtContext b
$cfmap :: forall a b. (a -> b) -> HsStmtContext a -> HsStmtContext b
Functor
deriving instance (Data id) => Data (HsStmtContext id)

isComprehensionContext :: HsStmtContext id -> Bool
-- Uses comprehension syntax [ e | quals ]
isComprehensionContext :: HsStmtContext id -> Bool
isComprehensionContext ListComp          = Bool
True
isComprehensionContext MonadComp         = Bool
True
isComprehensionContext (ParStmtCtxt c :: HsStmtContext id
c)   = HsStmtContext id -> Bool
forall id. HsStmtContext id -> Bool
isComprehensionContext HsStmtContext id
c
isComprehensionContext (TransStmtCtxt c :: HsStmtContext id
c) = HsStmtContext id -> Bool
forall id. HsStmtContext id -> Bool
isComprehensionContext HsStmtContext id
c
isComprehensionContext _ = Bool
False

-- | Should pattern match failure in a 'HsStmtContext' be desugared using
-- 'MonadFail'?
isMonadFailStmtContext :: HsStmtContext id -> Bool
isMonadFailStmtContext :: HsStmtContext id -> Bool
isMonadFailStmtContext MonadComp            = Bool
True
isMonadFailStmtContext DoExpr               = Bool
True
isMonadFailStmtContext MDoExpr              = Bool
True
isMonadFailStmtContext GhciStmtCtxt         = Bool
True
isMonadFailStmtContext (ParStmtCtxt ctxt :: HsStmtContext id
ctxt)   = HsStmtContext id -> Bool
forall id. HsStmtContext id -> Bool
isMonadFailStmtContext HsStmtContext id
ctxt
isMonadFailStmtContext (TransStmtCtxt ctxt :: HsStmtContext id
ctxt) = HsStmtContext id -> Bool
forall id. HsStmtContext id -> Bool
isMonadFailStmtContext HsStmtContext id
ctxt
isMonadFailStmtContext _ = Bool
False -- ListComp, PatGuard, ArrowExpr

isMonadCompContext :: HsStmtContext id -> Bool
isMonadCompContext :: HsStmtContext id -> Bool
isMonadCompContext MonadComp = Bool
True
isMonadCompContext _         = Bool
False

matchSeparator :: HsMatchContext id -> SDoc
matchSeparator :: HsMatchContext id -> SDoc
matchSeparator (FunRhs {})   = String -> SDoc
text "="
matchSeparator CaseAlt       = String -> SDoc
text "->"
matchSeparator IfAlt         = String -> SDoc
text "->"
matchSeparator LambdaExpr    = String -> SDoc
text "->"
matchSeparator ProcExpr      = String -> SDoc
text "->"
matchSeparator PatBindRhs    = String -> SDoc
text "="
matchSeparator PatBindGuards = String -> SDoc
text "="
matchSeparator (StmtCtxt _)  = String -> SDoc
text "<-"
matchSeparator RecUpd        = String -> SDoc
text "=" -- This can be printed by the pattern
                                       -- match checker trace
matchSeparator ThPatSplice  = String -> SDoc
forall a. String -> a
panic "unused"
matchSeparator ThPatQuote   = String -> SDoc
forall a. String -> a
panic "unused"
matchSeparator PatSyn       = String -> SDoc
forall a. String -> a
panic "unused"

pprMatchContext :: (Outputable (NameOrRdrName id),Outputable id)
                => HsMatchContext id -> SDoc
pprMatchContext :: HsMatchContext id -> SDoc
pprMatchContext ctxt :: HsMatchContext id
ctxt
  | HsMatchContext id -> Bool
forall id. HsMatchContext id -> Bool
want_an HsMatchContext id
ctxt = String -> SDoc
text "an" SDoc -> SDoc -> SDoc
<+> HsMatchContext id -> SDoc
forall id.
(Outputable (NameOrRdrName id), Outputable id) =>
HsMatchContext id -> SDoc
pprMatchContextNoun HsMatchContext id
ctxt
  | Bool
otherwise    = String -> SDoc
text "a"  SDoc -> SDoc -> SDoc
<+> HsMatchContext id -> SDoc
forall id.
(Outputable (NameOrRdrName id), Outputable id) =>
HsMatchContext id -> SDoc
pprMatchContextNoun HsMatchContext id
ctxt
  where
    want_an :: HsMatchContext id -> Bool
want_an (FunRhs {}) = Bool
True  -- Use "an" in front
    want_an ProcExpr    = Bool
True
    want_an _           = Bool
False

pprMatchContextNoun :: (Outputable (NameOrRdrName id),Outputable id)
                    => HsMatchContext id -> SDoc
pprMatchContextNoun :: HsMatchContext id -> SDoc
pprMatchContextNoun (FunRhs {mc_fun :: forall id. HsMatchContext id -> Located id
mc_fun=L _ fun :: id
fun})
                                    = String -> SDoc
text "equation for"
                                      SDoc -> SDoc -> SDoc
<+> SDoc -> SDoc
quotes (id -> SDoc
forall a. Outputable a => a -> SDoc
ppr id
fun)
pprMatchContextNoun CaseAlt         = String -> SDoc
text "case alternative"
pprMatchContextNoun IfAlt           = String -> SDoc
text "multi-way if alternative"
pprMatchContextNoun RecUpd          = String -> SDoc
text "record-update construct"
pprMatchContextNoun ThPatSplice     = String -> SDoc
text "Template Haskell pattern splice"
pprMatchContextNoun ThPatQuote      = String -> SDoc
text "Template Haskell pattern quotation"
pprMatchContextNoun PatBindRhs      = String -> SDoc
text "pattern binding"
pprMatchContextNoun PatBindGuards   = String -> SDoc
text "pattern binding guards"
pprMatchContextNoun LambdaExpr      = String -> SDoc
text "lambda abstraction"
pprMatchContextNoun ProcExpr        = String -> SDoc
text "arrow abstraction"
pprMatchContextNoun (StmtCtxt ctxt :: HsStmtContext id
ctxt) = String -> SDoc
text "pattern binding in"
                                      SDoc -> SDoc -> SDoc
$$ HsStmtContext id -> SDoc
forall id.
(Outputable id, Outputable (NameOrRdrName id)) =>
HsStmtContext id -> SDoc
pprAStmtContext HsStmtContext id
ctxt
pprMatchContextNoun PatSyn          = String -> SDoc
text "pattern synonym declaration"

-----------------
pprAStmtContext, pprStmtContext :: (Outputable id,
                                    Outputable (NameOrRdrName id))
                                => HsStmtContext id -> SDoc
pprAStmtContext :: HsStmtContext id -> SDoc
pprAStmtContext ctxt :: HsStmtContext id
ctxt = SDoc
article SDoc -> SDoc -> SDoc
<+> HsStmtContext id -> SDoc
forall id.
(Outputable id, Outputable (NameOrRdrName id)) =>
HsStmtContext id -> SDoc
pprStmtContext HsStmtContext id
ctxt
  where
    pp_an :: SDoc
pp_an = String -> SDoc
text "an"
    pp_a :: SDoc
pp_a  = String -> SDoc
text "a"
    article :: SDoc
article = case HsStmtContext id
ctxt of
                  MDoExpr       -> SDoc
pp_an
                  GhciStmtCtxt  -> SDoc
pp_an
                  _             -> SDoc
pp_a


-----------------
pprStmtContext :: HsStmtContext id -> SDoc
pprStmtContext GhciStmtCtxt    = String -> SDoc
text "interactive GHCi command"
pprStmtContext DoExpr          = String -> SDoc
text "'do' block"
pprStmtContext MDoExpr         = String -> SDoc
text "'mdo' block"
pprStmtContext ArrowExpr       = String -> SDoc
text "'do' block in an arrow command"
pprStmtContext ListComp        = String -> SDoc
text "list comprehension"
pprStmtContext MonadComp       = String -> SDoc
text "monad comprehension"
pprStmtContext (PatGuard ctxt :: HsMatchContext id
ctxt) = String -> SDoc
text "pattern guard for" SDoc -> SDoc -> SDoc
$$ HsMatchContext id -> SDoc
forall id.
(Outputable (NameOrRdrName id), Outputable id) =>
HsMatchContext id -> SDoc
pprMatchContext HsMatchContext id
ctxt

-- Drop the inner contexts when reporting errors, else we get
--     Unexpected transform statement
--     in a transformed branch of
--          transformed branch of
--          transformed branch of monad comprehension
pprStmtContext (ParStmtCtxt c :: HsStmtContext id
c) =
  SDoc -> SDoc -> SDoc
ifPprDebug ([SDoc] -> SDoc
sep [String -> SDoc
text "parallel branch of", HsStmtContext id -> SDoc
forall id.
(Outputable id, Outputable (NameOrRdrName id)) =>
HsStmtContext id -> SDoc
pprAStmtContext HsStmtContext id
c])
             (HsStmtContext id -> SDoc
forall id.
(Outputable id, Outputable (NameOrRdrName id)) =>
HsStmtContext id -> SDoc
pprStmtContext HsStmtContext id
c)
pprStmtContext (TransStmtCtxt c :: HsStmtContext id
c) =
  SDoc -> SDoc -> SDoc
ifPprDebug ([SDoc] -> SDoc
sep [String -> SDoc
text "transformed branch of", HsStmtContext id -> SDoc
forall id.
(Outputable id, Outputable (NameOrRdrName id)) =>
HsStmtContext id -> SDoc
pprAStmtContext HsStmtContext id
c])
             (HsStmtContext id -> SDoc
forall id.
(Outputable id, Outputable (NameOrRdrName id)) =>
HsStmtContext id -> SDoc
pprStmtContext HsStmtContext id
c)

instance (Outputable p, Outputable (NameOrRdrName p))
      => Outputable (HsStmtContext p) where
    ppr :: HsStmtContext p -> SDoc
ppr = HsStmtContext p -> SDoc
forall id.
(Outputable id, Outputable (NameOrRdrName id)) =>
HsStmtContext id -> SDoc
pprStmtContext

-- Used to generate the string for a *runtime* error message
matchContextErrString :: Outputable id
                      => HsMatchContext id -> SDoc
matchContextErrString :: HsMatchContext id -> SDoc
matchContextErrString (FunRhs{mc_fun :: forall id. HsMatchContext id -> Located id
mc_fun=L _ fun :: id
fun})   = String -> SDoc
text "function" SDoc -> SDoc -> SDoc
<+> id -> SDoc
forall a. Outputable a => a -> SDoc
ppr id
fun
matchContextErrString CaseAlt                    = String -> SDoc
text "case"
matchContextErrString IfAlt                      = String -> SDoc
text "multi-way if"
matchContextErrString PatBindRhs                 = String -> SDoc
text "pattern binding"
matchContextErrString PatBindGuards              = String -> SDoc
text "pattern binding guards"
matchContextErrString RecUpd                     = String -> SDoc
text "record update"
matchContextErrString LambdaExpr                 = String -> SDoc
text "lambda"
matchContextErrString ProcExpr                   = String -> SDoc
text "proc"
matchContextErrString ThPatSplice                = String -> SDoc
forall a. String -> a
panic "matchContextErrString"  -- Not used at runtime
matchContextErrString ThPatQuote                 = String -> SDoc
forall a. String -> a
panic "matchContextErrString"  -- Not used at runtime
matchContextErrString PatSyn                     = String -> SDoc
forall a. String -> a
panic "matchContextErrString"  -- Not used at runtime
matchContextErrString (StmtCtxt (ParStmtCtxt c :: HsStmtContext id
c))   = HsMatchContext id -> SDoc
forall id. Outputable id => HsMatchContext id -> SDoc
matchContextErrString (HsStmtContext id -> HsMatchContext id
forall id. HsStmtContext id -> HsMatchContext id
StmtCtxt HsStmtContext id
c)
matchContextErrString (StmtCtxt (TransStmtCtxt c :: HsStmtContext id
c)) = HsMatchContext id -> SDoc
forall id. Outputable id => HsMatchContext id -> SDoc
matchContextErrString (HsStmtContext id -> HsMatchContext id
forall id. HsStmtContext id -> HsMatchContext id
StmtCtxt HsStmtContext id
c)
matchContextErrString (StmtCtxt (PatGuard _))      = String -> SDoc
text "pattern guard"
matchContextErrString (StmtCtxt GhciStmtCtxt)      = String -> SDoc
text "interactive GHCi command"
matchContextErrString (StmtCtxt DoExpr)            = String -> SDoc
text "'do' block"
matchContextErrString (StmtCtxt ArrowExpr)         = String -> SDoc
text "'do' block"
matchContextErrString (StmtCtxt MDoExpr)           = String -> SDoc
text "'mdo' block"
matchContextErrString (StmtCtxt ListComp)          = String -> SDoc
text "list comprehension"
matchContextErrString (StmtCtxt MonadComp)         = String -> SDoc
text "monad comprehension"

pprMatchInCtxt :: (OutputableBndrId (GhcPass idR),
                   -- TODO:AZ these constraints do not make sense
                 Outputable (NameOrRdrName (NameOrRdrName (IdP (GhcPass idR)))),
                 Outputable body)
               => Match (GhcPass idR) body -> SDoc
pprMatchInCtxt :: Match (GhcPass idR) body -> SDoc
pprMatchInCtxt match :: Match (GhcPass idR) body
match  = SDoc -> Int -> SDoc -> SDoc
hang (String -> SDoc
text "In" SDoc -> SDoc -> SDoc
<+> HsMatchContext (NameOrRdrName (IdP (GhcPass idR))) -> SDoc
forall id.
(Outputable (NameOrRdrName id), Outputable id) =>
HsMatchContext id -> SDoc
pprMatchContext (Match (GhcPass idR) body
-> HsMatchContext (NameOrRdrName (IdP (GhcPass idR)))
forall p body.
Match p body -> HsMatchContext (NameOrRdrName (IdP p))
m_ctxt Match (GhcPass idR) body
match)
                                        SDoc -> SDoc -> SDoc
<> SDoc
colon)
                             4 (Match (GhcPass idR) body -> SDoc
forall (idR :: Pass) body.
(OutputableBndrId (GhcPass idR), Outputable body) =>
Match (GhcPass idR) body -> SDoc
pprMatch Match (GhcPass idR) body
match)

pprStmtInCtxt :: (OutputableBndrId (GhcPass idL),
                  OutputableBndrId (GhcPass idR),
                  Outputable body)
              => HsStmtContext (IdP (GhcPass idL))
              -> StmtLR (GhcPass idL) (GhcPass idR) body
              -> SDoc
pprStmtInCtxt :: HsStmtContext (IdP (GhcPass idL))
-> StmtLR (GhcPass idL) (GhcPass idR) body -> SDoc
pprStmtInCtxt ctxt :: HsStmtContext (IdP (GhcPass idL))
ctxt (LastStmt _ e :: body
e _ _)
  | HsStmtContext (IdP (GhcPass idL)) -> Bool
forall id. HsStmtContext id -> Bool
isComprehensionContext HsStmtContext (IdP (GhcPass idL))
ctxt      -- For [ e | .. ], do not mutter about "stmts"
  = SDoc -> Int -> SDoc -> SDoc
hang (String -> SDoc
text "In the expression:") 2 (body -> SDoc
forall a. Outputable a => a -> SDoc
ppr body
e)

pprStmtInCtxt ctxt :: HsStmtContext (IdP (GhcPass idL))
ctxt stmt :: StmtLR (GhcPass idL) (GhcPass idR) body
stmt
  = SDoc -> Int -> SDoc -> SDoc
hang (String -> SDoc
text "In a stmt of" SDoc -> SDoc -> SDoc
<+> HsStmtContext (IdP (GhcPass idL)) -> SDoc
forall id.
(Outputable id, Outputable (NameOrRdrName id)) =>
HsStmtContext id -> SDoc
pprAStmtContext HsStmtContext (IdP (GhcPass idL))
ctxt SDoc -> SDoc -> SDoc
<> SDoc
colon)
       2 (StmtLR (GhcPass idL) (GhcPass idR) body -> SDoc
forall (pass :: Pass) (idL :: Pass) body.
(OutputableBndr (IdP (GhcPass (NoGhcTcPass pass))),
 OutputableBndr (NameOrRdrName (IdP (GhcPass (NoGhcTcPass pass)))),
 OutputableBndr (IdP (GhcPass pass)),
 OutputableBndr (NameOrRdrName (IdP (GhcPass pass))),
 OutputableBndr (NameOrRdrName (IdP (GhcPass idL))),
 OutputableBndr (IdP (GhcPass idL)),
 OutputableBndr (IdP (GhcPass (NoGhcTcPass idL))),
 OutputableBndr (NameOrRdrName (IdP (GhcPass (NoGhcTcPass idL)))),
 Outputable (XViaStrategy (GhcPass (NoGhcTcPass idL))),
 Outputable (XIPBinds (GhcPass (NoGhcTcPass idL))),
 Outputable (XViaStrategy (GhcPass idL)),
 Outputable (XIPBinds (GhcPass idL)),
 Outputable (XIPBinds (GhcPass pass)),
 Outputable (XViaStrategy (GhcPass pass)),
 Outputable (XViaStrategy (GhcPass (NoGhcTcPass pass))),
 Outputable (XIPBinds (GhcPass (NoGhcTcPass pass))),
 Outputable body, NoGhcTcPass idL ~ NoGhcTcPass (NoGhcTcPass idL),
 NoGhcTcPass pass ~ NoGhcTcPass (NoGhcTcPass pass)) =>
StmtLR (GhcPass idL) (GhcPass pass) body -> SDoc
ppr_stmt StmtLR (GhcPass idL) (GhcPass idR) body
stmt)
  where
    -- For Group and Transform Stmts, don't print the nested stmts!
    ppr_stmt :: StmtLR (GhcPass idL) (GhcPass pass) body -> SDoc
ppr_stmt (TransStmt { trS_by :: forall idL idR body. StmtLR idL idR body -> Maybe (LHsExpr idR)
trS_by = Maybe (LHsExpr (GhcPass pass))
by, trS_using :: forall idL idR body. StmtLR idL idR body -> LHsExpr idR
trS_using = LHsExpr (GhcPass pass)
using
                        , trS_form :: forall idL idR body. StmtLR idL idR body -> TransForm
trS_form = TransForm
form }) = Maybe (LHsExpr (GhcPass pass))
-> LHsExpr (GhcPass pass) -> TransForm -> SDoc
forall body.
Outputable body =>
Maybe body -> body -> TransForm -> SDoc
pprTransStmt Maybe (LHsExpr (GhcPass pass))
by LHsExpr (GhcPass pass)
using TransForm
form
    ppr_stmt stmt :: StmtLR (GhcPass idL) (GhcPass pass) body
stmt = StmtLR (GhcPass idL) (GhcPass pass) body -> SDoc
forall (idL :: Pass) (idR :: Pass) body.
(OutputableBndrId (GhcPass idL), OutputableBndrId (GhcPass idR),
 Outputable body) =>
StmtLR (GhcPass idL) (GhcPass idR) body -> SDoc
pprStmt StmtLR (GhcPass idL) (GhcPass pass) body
stmt