{-# LANGUAGE CPP                 #-}
{-# LANGUAGE ConstraintKinds     #-}
{-# LANGUAGE FlexibleContexts    #-}
{-# LANGUAGE MultiWayIf          #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeFamilies        #-}

{-# OPTIONS_GHC -Wno-incomplete-record-updates #-}
{-# OPTIONS_GHC -Wno-incomplete-uni-patterns   #-}

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

Renaming of expressions

Basically dependency analysis.

Handles @Match@, @GRHSs@, @HsExpr@, and @Qualifier@ datatypes.  In
general, all of these functions return a renamed thing, and a set of
free variables.
-}

module GHC.Rename.Expr (
        rnLExpr, rnExpr, rnStmts,
        AnnoBody
   ) where

#include "HsVersions.h"

import GHC.Prelude

import GHC.Rename.Bind ( rnLocalBindsAndThen, rnLocalValBindsLHS, rnLocalValBindsRHS
                        , rnMatchGroup, rnGRHS, makeMiniFixityEnv)
import GHC.Hs
import GHC.Tc.Utils.Env ( isBrackStage )
import GHC.Tc.Utils.Monad
import GHC.Unit.Module ( getModule )
import GHC.Rename.Env
import GHC.Rename.Fixity
import GHC.Rename.Utils ( HsDocContext(..), bindLocalNamesFV, checkDupNames
                        , bindLocalNames
                        , mapMaybeFvRn, mapFvRn
                        , warnUnusedLocalBinds, typeAppErr
                        , checkUnusedRecordWildcard )
import GHC.Rename.Unbound ( reportUnboundName )
import GHC.Rename.Splice  ( rnBracket, rnSpliceExpr, checkThLocalName )
import GHC.Rename.HsType
import GHC.Rename.Pat
import GHC.Driver.Session
import GHC.Builtin.Names

import GHC.Types.FieldLabel
import GHC.Types.Fixity
import GHC.Types.Id.Make
import GHC.Types.Name
import GHC.Types.Name.Set
import GHC.Types.Name.Reader
import GHC.Types.Unique.Set
import GHC.Types.SourceText
import GHC.Utils.Misc
import GHC.Data.List.SetOps ( removeDups )
import GHC.Utils.Error
import GHC.Utils.Panic
import GHC.Utils.Outputable as Outputable
import GHC.Types.SrcLoc
import GHC.Data.FastString
import Control.Monad
import GHC.Builtin.Types ( nilDataConName )
import qualified GHC.LanguageExtensions as LangExt

import Data.List (unzip4, minimumBy)
import Data.List.NonEmpty ( NonEmpty(..) )
import Data.Maybe (isJust, isNothing)
import Control.Arrow (first)
import Data.Ord
import Data.Array
import qualified Data.List.NonEmpty as NE

{- Note [Handling overloaded and rebindable constructs]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
For overloaded constructs (overloaded literals, lists, strings), and
rebindable constructs (e.g. if-then-else), our general plan is this,
using overloaded labels #foo as an example:

* In the RENAMER: transform
      HsOverLabel "foo"
      ==> XExpr (HsExpansion (HsOverLabel #foo)
                             (fromLabel `HsAppType` "foo"))
  We write this more compactly in concrete-syntax form like this
      #foo  ==>  fromLabel @"foo"

  Recall that in (HsExpansion orig expanded), 'orig' is the original term
  the user wrote, and 'expanded' is the expanded or desugared version
  to be typechecked.

* In the TYPECHECKER: typecheck the expansion, in this case
      fromLabel @"foo"
  The typechecker (and desugarer) will never see HsOverLabel

In effect, the renamer does a bit of desugaring. Recall GHC.Hs.Expr
Note [Rebindable syntax and HsExpansion], which describes the use of HsExpansion.

RebindableSyntax:
  If RebindableSyntax is off we use the built-in 'fromLabel', defined in
     GHC.Builtin.Names.fromLabelClassOpName
  If RebindableSyntax if ON, we look up "fromLabel" in the environment
     to get whichever one is in scope.
This is accomplished by lookupSyntaxName, and it applies to all the
constructs below.

Here are the constructs that we transform in this way. Some are uniform,
but several have a little bit of special treatment:

* HsIf (if-the-else)
     if b then e1 else e2  ==>  ifThenElse b e1 e2
  We do this /only/ if rebindable syntax is on, because the coverage
  checker looks for HsIf (see GHC.HsToCore.Coverage.addTickHsExpr)
  That means the typechecker and desugarer need to understand HsIf
  for the non-rebindable-syntax case.

* OverLabel (overloaded labels, #lbl)
     #lbl  ==>  fromLabel @"lbl"
  As ever, we use lookupSyntaxName to look up 'fromLabel'
  See Note [Overloaded labels]

* ExplicitList (explicit lists [a,b,c])
  When (and only when) OverloadedLists is on
     [e1,e2]  ==>  fromListN 2 [e1,e2]
  NB: the type checker and desugarer still see ExplicitList,
      but to them it always means the built-in lists.

* SectionL and SectionR (left and right sections)
     (`op` e) ==> rightSection op e
     (e `op`) ==> leftSection  (op e)
  where `leftSection` and `rightSection` are levity-polymorphic
  wired-in Ids. See Note [Left and right sections]

* It's a bit painful to transform `OpApp e1 op e2` to a `HsExpansion`
  form, because the renamer does precedence rearrangement after name
  resolution.  So the renamer leaves an OpApp as an OpApp.

  The typechecker turns `OpApp` into a use of `HsExpansion`
  on the fly, in GHC.Tc.Gen.Head.splitHsApps.  RebindableSyntax
  does not affect this.

Note [Overloaded labels]
~~~~~~~~~~~~~~~~~~~~~~~~
For overloaded labels, note that we /only/ apply `fromLabel` to the
Symbol argument, so the resulting expression has type
    fromLabel @"foo" :: forall a. IsLabel "foo" a => a
Now ordinary Visible Type Application can be used to instantiate the 'a':
the user may have written (#foo @Int).

Notice that this all works fine in a kind-polymorphic setting (#19154).
Suppose we have
    fromLabel :: forall {k1} {k2} (a:k1). blah

Then we want to instantiate those inferred quantifiers k1,k2, before
type-applying to "foo", so we get
    fromLabel @Symbol @blah @"foo" ...

And those inferred kind quantifiers will indeed be instantiated when we
typecheck the renamed-syntax call (fromLabel @"foo").
-}

{-
************************************************************************
*                                                                      *
\subsubsection{Expressions}
*                                                                      *
************************************************************************
-}

rnExprs :: [LHsExpr GhcPs] -> RnM ([LHsExpr GhcRn], FreeVars)
rnExprs :: [LHsExpr GhcPs] -> RnM ([XRec GhcRn (HsExpr GhcRn)], FreeVars)
rnExprs [LHsExpr GhcPs]
ls = [GenLocated SrcSpanAnnA (HsExpr GhcPs)]
-> FreeVars
-> IOEnv
     (Env TcGblEnv TcLclEnv)
     ([GenLocated SrcSpanAnnA (HsExpr GhcRn)], FreeVars)
rnExprs' [LHsExpr GhcPs]
ls forall a. UniqSet a
emptyUniqSet
 where
  rnExprs' :: [GenLocated SrcSpanAnnA (HsExpr GhcPs)]
-> FreeVars
-> IOEnv
     (Env TcGblEnv TcLclEnv)
     ([GenLocated SrcSpanAnnA (HsExpr GhcRn)], FreeVars)
rnExprs' [] FreeVars
acc = forall (m :: * -> *) a. Monad m => a -> m a
return ([], FreeVars
acc)
  rnExprs' (GenLocated SrcSpanAnnA (HsExpr GhcPs)
expr:[GenLocated SrcSpanAnnA (HsExpr GhcPs)]
exprs) FreeVars
acc =
   do { (GenLocated SrcSpanAnnA (HsExpr GhcRn)
expr', FreeVars
fvExpr) <- LHsExpr GhcPs -> RnM (XRec GhcRn (HsExpr GhcRn), FreeVars)
rnLExpr GenLocated SrcSpanAnnA (HsExpr GhcPs)
expr
        -- Now we do a "seq" on the free vars because typically it's small
        -- or empty, especially in very long lists of constants
      ; let  acc' :: FreeVars
acc' = FreeVars
acc FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fvExpr
      ; ([GenLocated SrcSpanAnnA (HsExpr GhcRn)]
exprs', FreeVars
fvExprs) <- FreeVars
acc' seq :: forall a b. a -> b -> b
`seq` [GenLocated SrcSpanAnnA (HsExpr GhcPs)]
-> FreeVars
-> IOEnv
     (Env TcGblEnv TcLclEnv)
     ([GenLocated SrcSpanAnnA (HsExpr GhcRn)], FreeVars)
rnExprs' [GenLocated SrcSpanAnnA (HsExpr GhcPs)]
exprs FreeVars
acc'
      ; forall (m :: * -> *) a. Monad m => a -> m a
return (GenLocated SrcSpanAnnA (HsExpr GhcRn)
expr'forall a. a -> [a] -> [a]
:[GenLocated SrcSpanAnnA (HsExpr GhcRn)]
exprs', FreeVars
fvExprs) }

-- Variables. We look up the variable and return the resulting name.

rnLExpr :: LHsExpr GhcPs -> RnM (LHsExpr GhcRn, FreeVars)
rnLExpr :: LHsExpr GhcPs -> RnM (XRec GhcRn (HsExpr GhcRn), FreeVars)
rnLExpr = forall a b c.
(a -> TcM (b, c)) -> LocatedA a -> TcM (LocatedA b, c)
wrapLocFstMA HsExpr GhcPs -> RnM (HsExpr GhcRn, FreeVars)
rnExpr

rnExpr :: HsExpr GhcPs -> RnM (HsExpr GhcRn, FreeVars)

finishHsVar :: LocatedA Name -> RnM (HsExpr GhcRn, FreeVars)
-- Separated from rnExpr because it's also used
-- when renaming infix expressions
finishHsVar :: LocatedA Name -> RnM (HsExpr GhcRn, FreeVars)
finishHsVar (L SrcSpanAnnA
l Name
name)
 = do { Module
this_mod <- forall (m :: * -> *). HasModule m => m Module
getModule
      ; forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Module -> Name -> Bool
nameIsLocalOrFrom Module
this_mod Name
name) forall a b. (a -> b) -> a -> b
$
        Name -> IOEnv (Env TcGblEnv TcLclEnv) ()
checkThLocalName Name
name
      ; forall (m :: * -> *) a. Monad m => a -> m a
return (forall p. XVar p -> LIdP p -> HsExpr p
HsVar NoExtField
noExtField (forall l e. l -> e -> GenLocated l e
L (forall a. SrcSpanAnn' a -> SrcSpanAnnN
la2na SrcSpanAnnA
l) Name
name), Name -> FreeVars
unitFV Name
name) }

rnUnboundVar :: RdrName -> RnM (HsExpr GhcRn, FreeVars)
rnUnboundVar :: RdrName -> RnM (HsExpr GhcRn, FreeVars)
rnUnboundVar RdrName
v =
  if RdrName -> Bool
isUnqual RdrName
v
  then -- Treat this as a "hole"
       -- Do not fail right now; instead, return HsUnboundVar
       -- and let the type checker report the error
       forall (m :: * -> *) a. Monad m => a -> m a
return (forall p. XUnboundVar p -> OccName -> HsExpr p
HsUnboundVar NoExtField
noExtField (RdrName -> OccName
rdrNameOcc RdrName
v), FreeVars
emptyFVs)

        else -- Fail immediately (qualified name)
             do { Name
n <- RdrName -> RnM Name
reportUnboundName RdrName
v
                ; forall (m :: * -> *) a. Monad m => a -> m a
return (forall p. XVar p -> LIdP p -> HsExpr p
HsVar NoExtField
noExtField (forall a an. a -> LocatedAn an a
noLocA Name
n), FreeVars
emptyFVs) }

rnExpr :: HsExpr GhcPs -> RnM (HsExpr GhcRn, FreeVars)
rnExpr (HsVar XVar GhcPs
_ (L SrcSpanAnnN
l RdrName
v))
  = do { DynFlags
dflags <- forall (m :: * -> *). HasDynFlags m => m DynFlags
getDynFlags
       ; let dup_fields_ok :: DuplicateRecordFields
dup_fields_ok = DynFlags -> DuplicateRecordFields
xopt_DuplicateRecordFields DynFlags
dflags
       ; Maybe AmbiguousResult
mb_name <- DuplicateRecordFields -> RdrName -> RnM (Maybe AmbiguousResult)
lookupExprOccRn DuplicateRecordFields
dup_fields_ok RdrName
v

       ; case Maybe AmbiguousResult
mb_name of {
           Maybe AmbiguousResult
Nothing -> RdrName -> RnM (HsExpr GhcRn, FreeVars)
rnUnboundVar RdrName
v ;
           Just (UnambiguousGre (NormalGreName Name
name))
              | Name
name forall a. Eq a => a -> a -> Bool
== Name
nilDataConName -- Treat [] as an ExplicitList, so that
                                       -- OverloadedLists works correctly
                                       -- Note [Empty lists] in GHC.Hs.Expr
              , Extension -> DynFlags -> Bool
xopt Extension
LangExt.OverloadedLists DynFlags
dflags
              -> HsExpr GhcPs -> RnM (HsExpr GhcRn, FreeVars)
rnExpr (forall p. XExplicitList p -> [LHsExpr p] -> HsExpr p
ExplicitList forall a. EpAnn a
noAnn [])

              | Bool
otherwise
              -> LocatedA Name -> RnM (HsExpr GhcRn, FreeVars)
finishHsVar (forall l e. l -> e -> GenLocated l e
L (forall a ann. SrcSpanAnn' a -> SrcAnn ann
na2la SrcSpanAnnN
l) Name
name) ;
            Just (UnambiguousGre (FieldGreName FieldLabel
fl)) ->
              let sel_name :: Name
sel_name = FieldLabel -> Name
flSelector FieldLabel
fl in
              forall (m :: * -> *) a. Monad m => a -> m a
return ( forall p. XRecFld p -> AmbiguousFieldOcc p -> HsExpr p
HsRecFld NoExtField
noExtField (forall pass.
XUnambiguous pass
-> GenLocated SrcSpanAnnN RdrName -> AmbiguousFieldOcc pass
Unambiguous Name
sel_name (forall l e. l -> e -> GenLocated l e
L SrcSpanAnnN
l RdrName
v) ), Name -> FreeVars
unitFV Name
sel_name) ;
            Just AmbiguousResult
AmbiguousFields ->
              forall (m :: * -> *) a. Monad m => a -> m a
return ( forall p. XRecFld p -> AmbiguousFieldOcc p -> HsExpr p
HsRecFld NoExtField
noExtField (forall pass.
XAmbiguous pass
-> GenLocated SrcSpanAnnN RdrName -> AmbiguousFieldOcc pass
Ambiguous NoExtField
noExtField (forall l e. l -> e -> GenLocated l e
L SrcSpanAnnN
l RdrName
v) ), FreeVars
emptyFVs) } }


rnExpr (HsIPVar XIPVar GhcPs
x HsIPName
v)
  = forall (m :: * -> *) a. Monad m => a -> m a
return (forall p. XIPVar p -> HsIPName -> HsExpr p
HsIPVar XIPVar GhcPs
x HsIPName
v, FreeVars
emptyFVs)

rnExpr (HsUnboundVar XUnboundVar GhcPs
_ OccName
v)
  = forall (m :: * -> *) a. Monad m => a -> m a
return (forall p. XUnboundVar p -> OccName -> HsExpr p
HsUnboundVar NoExtField
noExtField OccName
v, FreeVars
emptyFVs)

-- HsOverLabel: see Note [Handling overloaded and rebindable constructs]
rnExpr (HsOverLabel XOverLabel GhcPs
_ FastString
v)
  = do { (Name
from_label, FreeVars
fvs) <- Name -> RnM (Name, FreeVars)
lookupSyntaxName Name
fromLabelClassOpName
       ; forall (m :: * -> *) a. Monad m => a -> m a
return ( HsExpr GhcRn -> HsExpr GhcRn -> HsExpr GhcRn
mkExpandedExpr (forall p. XOverLabel p -> FastString -> HsExpr p
HsOverLabel forall a. EpAnn a
noAnn FastString
v) forall a b. (a -> b) -> a -> b
$
                  forall p.
XAppTypeE p -> LHsExpr p -> LHsWcType (NoGhcTc p) -> HsExpr p
HsAppType NoExtField
noExtField (Name -> XRec GhcRn (HsExpr GhcRn)
genLHsVar Name
from_label) HsWildCardBndrs GhcRn (LocatedAn AnnListItem (HsType GhcRn))
hs_ty_arg
                , FreeVars
fvs ) }
  where
    hs_ty_arg :: HsWildCardBndrs GhcRn (LocatedAn AnnListItem (HsType GhcRn))
hs_ty_arg = forall thing. thing -> HsWildCardBndrs GhcRn thing
mkEmptyWildCardBndrs forall a b. (a -> b) -> a -> b
$ forall a an. a -> LocatedAn an a
wrapGenSpan forall a b. (a -> b) -> a -> b
$
                forall pass. XTyLit pass -> HsTyLit -> HsType pass
HsTyLit NoExtField
noExtField (SourceText -> FastString -> HsTyLit
HsStrTy SourceText
NoSourceText FastString
v)

rnExpr (HsLit XLitE GhcPs
x lit :: HsLit GhcPs
lit@(HsString XHsString GhcPs
src FastString
s))
  = do { Bool
opt_OverloadedStrings <- forall gbl lcl. Extension -> TcRnIf gbl lcl Bool
xoptM Extension
LangExt.OverloadedStrings
       ; if Bool
opt_OverloadedStrings then
            HsExpr GhcPs -> RnM (HsExpr GhcRn, FreeVars)
rnExpr (forall p. XOverLitE p -> HsOverLit p -> HsExpr p
HsOverLit XLitE GhcPs
x (SourceText -> FastString -> HsOverLit GhcPs
mkHsIsString XHsString GhcPs
src FastString
s))
         else do {
            ; forall p. HsLit p -> IOEnv (Env TcGblEnv TcLclEnv) ()
rnLit HsLit GhcPs
lit
            ; forall (m :: * -> *) a. Monad m => a -> m a
return (forall p. XLitE p -> HsLit p -> HsExpr p
HsLit XLitE GhcPs
x (forall (p1 :: Pass) (p2 :: Pass).
HsLit (GhcPass p1) -> HsLit (GhcPass p2)
convertLit HsLit GhcPs
lit), FreeVars
emptyFVs) } }

rnExpr (HsLit XLitE GhcPs
x HsLit GhcPs
lit)
  = do { forall p. HsLit p -> IOEnv (Env TcGblEnv TcLclEnv) ()
rnLit HsLit GhcPs
lit
       ; forall (m :: * -> *) a. Monad m => a -> m a
return (forall p. XLitE p -> HsLit p -> HsExpr p
HsLit XLitE GhcPs
x(forall (p1 :: Pass) (p2 :: Pass).
HsLit (GhcPass p1) -> HsLit (GhcPass p2)
convertLit HsLit GhcPs
lit), FreeVars
emptyFVs) }

rnExpr (HsOverLit XOverLitE GhcPs
x HsOverLit GhcPs
lit)
  = do { ((HsOverLit GhcRn
lit', Maybe (HsExpr GhcRn)
mb_neg), FreeVars
fvs) <- forall t.
HsOverLit t
-> RnM ((HsOverLit GhcRn, Maybe (HsExpr GhcRn)), FreeVars)
rnOverLit HsOverLit GhcPs
lit -- See Note [Negative zero]
       ; case Maybe (HsExpr GhcRn)
mb_neg of
              Maybe (HsExpr GhcRn)
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall p. XOverLitE p -> HsOverLit p -> HsExpr p
HsOverLit XOverLitE GhcPs
x HsOverLit GhcRn
lit', FreeVars
fvs)
              Just HsExpr GhcRn
neg ->
                 forall (m :: * -> *) a. Monad m => a -> m a
return (forall p. XApp p -> LHsExpr p -> LHsExpr p -> HsExpr p
HsApp EpAnnCO
noComments (forall a an. a -> LocatedAn an a
noLocA HsExpr GhcRn
neg) (forall a an. a -> LocatedAn an a
noLocA (forall p. XOverLitE p -> HsOverLit p -> HsExpr p
HsOverLit XOverLitE GhcPs
x HsOverLit GhcRn
lit'))
                        , FreeVars
fvs ) }

rnExpr (HsApp XApp GhcPs
x LHsExpr GhcPs
fun LHsExpr GhcPs
arg)
  = do { (GenLocated SrcSpanAnnA (HsExpr GhcRn)
fun',FreeVars
fvFun) <- LHsExpr GhcPs -> RnM (XRec GhcRn (HsExpr GhcRn), FreeVars)
rnLExpr LHsExpr GhcPs
fun
       ; (GenLocated SrcSpanAnnA (HsExpr GhcRn)
arg',FreeVars
fvArg) <- LHsExpr GhcPs -> RnM (XRec GhcRn (HsExpr GhcRn), FreeVars)
rnLExpr LHsExpr GhcPs
arg
       ; forall (m :: * -> *) a. Monad m => a -> m a
return (forall p. XApp p -> LHsExpr p -> LHsExpr p -> HsExpr p
HsApp XApp GhcPs
x GenLocated SrcSpanAnnA (HsExpr GhcRn)
fun' GenLocated SrcSpanAnnA (HsExpr GhcRn)
arg', FreeVars
fvFun FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fvArg) }

rnExpr (HsAppType XAppTypeE GhcPs
_ LHsExpr GhcPs
fun LHsWcType (NoGhcTc GhcPs)
arg)
  = do { Bool
type_app <- forall gbl lcl. Extension -> TcRnIf gbl lcl Bool
xoptM Extension
LangExt.TypeApplications
       ; forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless Bool
type_app forall a b. (a -> b) -> a -> b
$ SDoc -> IOEnv (Env TcGblEnv TcLclEnv) ()
addErr forall a b. (a -> b) -> a -> b
$ String -> LHsType GhcPs -> SDoc
typeAppErr String
"type" forall a b. (a -> b) -> a -> b
$ forall pass thing. HsWildCardBndrs pass thing -> thing
hswc_body LHsWcType (NoGhcTc GhcPs)
arg
       ; (GenLocated SrcSpanAnnA (HsExpr GhcRn)
fun',FreeVars
fvFun) <- LHsExpr GhcPs -> RnM (XRec GhcRn (HsExpr GhcRn), FreeVars)
rnLExpr LHsExpr GhcPs
fun
       ; (HsWildCardBndrs GhcRn (LocatedAn AnnListItem (HsType GhcRn))
arg',FreeVars
fvArg) <- HsDocContext -> LHsWcType GhcPs -> RnM (LHsWcType GhcRn, FreeVars)
rnHsWcType HsDocContext
HsTypeCtx LHsWcType (NoGhcTc GhcPs)
arg
       ; forall (m :: * -> *) a. Monad m => a -> m a
return (forall p.
XAppTypeE p -> LHsExpr p -> LHsWcType (NoGhcTc p) -> HsExpr p
HsAppType NoExtField
NoExtField GenLocated SrcSpanAnnA (HsExpr GhcRn)
fun' HsWildCardBndrs GhcRn (LocatedAn AnnListItem (HsType GhcRn))
arg', FreeVars
fvFun FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fvArg) }

rnExpr (OpApp XOpApp GhcPs
_ LHsExpr GhcPs
e1 LHsExpr GhcPs
op LHsExpr GhcPs
e2)
  = do  { (GenLocated SrcSpanAnnA (HsExpr GhcRn)
e1', FreeVars
fv_e1) <- LHsExpr GhcPs -> RnM (XRec GhcRn (HsExpr GhcRn), FreeVars)
rnLExpr LHsExpr GhcPs
e1
        ; (GenLocated SrcSpanAnnA (HsExpr GhcRn)
e2', FreeVars
fv_e2) <- LHsExpr GhcPs -> RnM (XRec GhcRn (HsExpr GhcRn), FreeVars)
rnLExpr LHsExpr GhcPs
e2
        ; (GenLocated SrcSpanAnnA (HsExpr GhcRn)
op', FreeVars
fv_op) <- LHsExpr GhcPs -> RnM (XRec GhcRn (HsExpr GhcRn), FreeVars)
rnLExpr LHsExpr GhcPs
op

        -- Deal with fixity
        -- When renaming code synthesised from "deriving" declarations
        -- we used to avoid fixity stuff, but we can't easily tell any
        -- more, so I've removed the test.  Adding HsPars in GHC.Tc.Deriv.Generate
        -- should prevent bad things happening.
        ; Fixity
fixity <- case GenLocated SrcSpanAnnA (HsExpr GhcRn)
op' of
              L SrcSpanAnnA
_ (HsVar XVar GhcRn
_ (L SrcSpanAnnN
_ Name
n)) -> Name -> IOEnv (Env TcGblEnv TcLclEnv) Fixity
lookupFixityRn Name
n
              L SrcSpanAnnA
_ (HsRecFld XRecFld GhcRn
_ AmbiguousFieldOcc GhcRn
f)    -> AmbiguousFieldOcc GhcRn -> IOEnv (Env TcGblEnv TcLclEnv) Fixity
lookupFieldFixityRn AmbiguousFieldOcc GhcRn
f
              GenLocated SrcSpanAnnA (HsExpr GhcRn)
_ -> forall (m :: * -> *) a. Monad m => a -> m a
return (SourceText -> Int -> FixityDirection -> Fixity
Fixity SourceText
NoSourceText Int
minPrecedence FixityDirection
InfixL)
                   -- c.f. lookupFixity for unbound

        ; Bool
lexical_negation <- forall gbl lcl. Extension -> TcRnIf gbl lcl Bool
xoptM Extension
LangExt.LexicalNegation
        ; let negation_handling :: NegationHandling
negation_handling | Bool
lexical_negation = NegationHandling
KeepNegationIntact
                                | Bool
otherwise = NegationHandling
ReassociateNegation
        ; HsExpr GhcRn
final_e <- NegationHandling
-> XRec GhcRn (HsExpr GhcRn)
-> XRec GhcRn (HsExpr GhcRn)
-> Fixity
-> XRec GhcRn (HsExpr GhcRn)
-> RnM (HsExpr GhcRn)
mkOpAppRn NegationHandling
negation_handling GenLocated SrcSpanAnnA (HsExpr GhcRn)
e1' GenLocated SrcSpanAnnA (HsExpr GhcRn)
op' Fixity
fixity GenLocated SrcSpanAnnA (HsExpr GhcRn)
e2'
        ; forall (m :: * -> *) a. Monad m => a -> m a
return (HsExpr GhcRn
final_e, FreeVars
fv_e1 FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fv_op FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fv_e2) }

rnExpr (NegApp XNegApp GhcPs
_ LHsExpr GhcPs
e SyntaxExpr GhcPs
_)
  = do { (GenLocated SrcSpanAnnA (HsExpr GhcRn)
e', FreeVars
fv_e)         <- LHsExpr GhcPs -> RnM (XRec GhcRn (HsExpr GhcRn), FreeVars)
rnLExpr LHsExpr GhcPs
e
       ; (SyntaxExprRn
neg_name, FreeVars
fv_neg) <- Name -> RnM (SyntaxExpr GhcRn, FreeVars)
lookupSyntax Name
negateName
       ; HsExpr GhcRn
final_e            <- XRec GhcRn (HsExpr GhcRn) -> SyntaxExpr GhcRn -> RnM (HsExpr GhcRn)
mkNegAppRn GenLocated SrcSpanAnnA (HsExpr GhcRn)
e' SyntaxExprRn
neg_name
       ; forall (m :: * -> *) a. Monad m => a -> m a
return (HsExpr GhcRn
final_e, FreeVars
fv_e FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fv_neg) }

------------------------------------------
-- Record dot syntax

rnExpr (HsGetField XGetField GhcPs
_ LHsExpr GhcPs
e Located (HsFieldLabel GhcPs)
f)
 = do { (Name
getField, FreeVars
fv_getField) <- Name -> RnM (Name, FreeVars)
lookupSyntaxName Name
getFieldName
      ; (GenLocated SrcSpanAnnA (HsExpr GhcRn)
e, FreeVars
fv_e) <- LHsExpr GhcPs -> RnM (XRec GhcRn (HsExpr GhcRn), FreeVars)
rnLExpr LHsExpr GhcPs
e
      ; let f' :: Located (HsFieldLabel GhcRn)
f' = Located (HsFieldLabel GhcPs) -> Located (HsFieldLabel GhcRn)
rnHsFieldLabel Located (HsFieldLabel GhcPs)
f
      ; forall (m :: * -> *) a. Monad m => a -> m a
return ( HsExpr GhcRn -> HsExpr GhcRn -> HsExpr GhcRn
mkExpandedExpr
                   (forall p.
XGetField p -> LHsExpr p -> Located (HsFieldLabel p) -> HsExpr p
HsGetField NoExtField
noExtField GenLocated SrcSpanAnnA (HsExpr GhcRn)
e Located (HsFieldLabel GhcRn)
f')
                   (Name
-> XRec GhcRn (HsExpr GhcRn) -> Located FastString -> HsExpr GhcRn
mkGetField Name
getField GenLocated SrcSpanAnnA (HsExpr GhcRn)
e (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall l e. GenLocated l e -> e
unLoc forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall p. HsFieldLabel p -> Located FastString
hflLabel) Located (HsFieldLabel GhcRn)
f'))
               , FreeVars
fv_e FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fv_getField ) }

rnExpr (HsProjection XProjection GhcPs
_ NonEmpty (Located (HsFieldLabel GhcPs))
fs)
  = do { (Name
getField, FreeVars
fv_getField) <- Name -> RnM (Name, FreeVars)
lookupSyntaxName Name
getFieldName
       ; Name
circ <- RdrName -> RnM Name
lookupOccRn RdrName
compose_RDR
       ; let fs' :: NonEmpty (Located (HsFieldLabel GhcRn))
fs' = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Located (HsFieldLabel GhcPs) -> Located (HsFieldLabel GhcRn)
rnHsFieldLabel NonEmpty (Located (HsFieldLabel GhcPs))
fs
       ; forall (m :: * -> *) a. Monad m => a -> m a
return ( HsExpr GhcRn -> HsExpr GhcRn -> HsExpr GhcRn
mkExpandedExpr
                    (forall p.
XProjection p -> NonEmpty (Located (HsFieldLabel p)) -> HsExpr p
HsProjection NoExtField
noExtField NonEmpty (Located (HsFieldLabel GhcRn))
fs')
                    (Name -> Name -> NonEmpty (Located FastString) -> HsExpr GhcRn
mkProjection Name
getField Name
circ (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall l e. GenLocated l e -> e
unLoc forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall p. HsFieldLabel p -> Located FastString
hflLabel)) NonEmpty (Located (HsFieldLabel GhcRn))
fs'))
                , Name -> FreeVars
unitFV Name
circ FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fv_getField) }

------------------------------------------
-- Template Haskell extensions
rnExpr e :: HsExpr GhcPs
e@(HsBracket XBracket GhcPs
_ HsBracket GhcPs
br_body) = HsExpr GhcPs -> HsBracket GhcPs -> RnM (HsExpr GhcRn, FreeVars)
rnBracket HsExpr GhcPs
e HsBracket GhcPs
br_body

rnExpr (HsSpliceE XSpliceE GhcPs
_ HsSplice GhcPs
splice) = HsSplice GhcPs -> RnM (HsExpr GhcRn, FreeVars)
rnSpliceExpr HsSplice GhcPs
splice

---------------------------------------------
--      Sections
-- See Note [Parsing sections] in GHC.Parser
rnExpr (HsPar XPar GhcPs
x (L SrcSpanAnnA
loc (section :: HsExpr GhcPs
section@(SectionL {}))))
  = do  { (HsExpr GhcRn
section', FreeVars
fvs) <- HsExpr GhcPs -> RnM (HsExpr GhcRn, FreeVars)
rnSection HsExpr GhcPs
section
        ; forall (m :: * -> *) a. Monad m => a -> m a
return (forall p. XPar p -> LHsExpr p -> HsExpr p
HsPar XPar GhcPs
x (forall l e. l -> e -> GenLocated l e
L SrcSpanAnnA
loc HsExpr GhcRn
section'), FreeVars
fvs) }

rnExpr (HsPar XPar GhcPs
x (L SrcSpanAnnA
loc (section :: HsExpr GhcPs
section@(SectionR {}))))
  = do  { (HsExpr GhcRn
section', FreeVars
fvs) <- HsExpr GhcPs -> RnM (HsExpr GhcRn, FreeVars)
rnSection HsExpr GhcPs
section
        ; forall (m :: * -> *) a. Monad m => a -> m a
return (forall p. XPar p -> LHsExpr p -> HsExpr p
HsPar XPar GhcPs
x (forall l e. l -> e -> GenLocated l e
L SrcSpanAnnA
loc HsExpr GhcRn
section'), FreeVars
fvs) }

rnExpr (HsPar XPar GhcPs
x LHsExpr GhcPs
e)
  = do  { (GenLocated SrcSpanAnnA (HsExpr GhcRn)
e', FreeVars
fvs_e) <- LHsExpr GhcPs -> RnM (XRec GhcRn (HsExpr GhcRn), FreeVars)
rnLExpr LHsExpr GhcPs
e
        ; forall (m :: * -> *) a. Monad m => a -> m a
return (forall p. XPar p -> LHsExpr p -> HsExpr p
HsPar XPar GhcPs
x GenLocated SrcSpanAnnA (HsExpr GhcRn)
e', FreeVars
fvs_e) }

rnExpr expr :: HsExpr GhcPs
expr@(SectionL {})
  = do  { SDoc -> IOEnv (Env TcGblEnv TcLclEnv) ()
addErr (HsExpr GhcPs -> SDoc
sectionErr HsExpr GhcPs
expr); HsExpr GhcPs -> RnM (HsExpr GhcRn, FreeVars)
rnSection HsExpr GhcPs
expr }
rnExpr expr :: HsExpr GhcPs
expr@(SectionR {})
  = do  { SDoc -> IOEnv (Env TcGblEnv TcLclEnv) ()
addErr (HsExpr GhcPs -> SDoc
sectionErr HsExpr GhcPs
expr); HsExpr GhcPs -> RnM (HsExpr GhcRn, FreeVars)
rnSection HsExpr GhcPs
expr }

---------------------------------------------
rnExpr (HsPragE XPragE GhcPs
x HsPragE GhcPs
prag LHsExpr GhcPs
expr)
  = do { (GenLocated SrcSpanAnnA (HsExpr GhcRn)
expr', FreeVars
fvs_expr) <- LHsExpr GhcPs -> RnM (XRec GhcRn (HsExpr GhcRn), FreeVars)
rnLExpr LHsExpr GhcPs
expr
       ; forall (m :: * -> *) a. Monad m => a -> m a
return (forall p. XPragE p -> HsPragE p -> LHsExpr p -> HsExpr p
HsPragE XPragE GhcPs
x (HsPragE GhcPs -> HsPragE GhcRn
rn_prag HsPragE GhcPs
prag) GenLocated SrcSpanAnnA (HsExpr GhcRn)
expr', FreeVars
fvs_expr) }
  where
    rn_prag :: HsPragE GhcPs -> HsPragE GhcRn
    rn_prag :: HsPragE GhcPs -> HsPragE GhcRn
rn_prag (HsPragSCC XSCC GhcPs
x1 SourceText
src StringLiteral
ann) = forall p. XSCC p -> SourceText -> StringLiteral -> HsPragE p
HsPragSCC XSCC GhcPs
x1 SourceText
src StringLiteral
ann

rnExpr (HsLam XLam GhcPs
x MatchGroup GhcPs (LHsExpr GhcPs)
matches)
  = do { (MatchGroup GhcRn (GenLocated SrcSpanAnnA (HsExpr GhcRn))
matches', FreeVars
fvMatch) <- forall (body :: * -> *).
(Outputable (body GhcPs), AnnoBody body) =>
HsMatchContext GhcRn
-> (LocatedA (body GhcPs) -> RnM (LocatedA (body GhcRn), FreeVars))
-> MatchGroup GhcPs (LocatedA (body GhcPs))
-> RnM (MatchGroup GhcRn (LocatedA (body GhcRn)), FreeVars)
rnMatchGroup forall p. HsMatchContext p
LambdaExpr LHsExpr GhcPs -> RnM (XRec GhcRn (HsExpr GhcRn), FreeVars)
rnLExpr MatchGroup GhcPs (LHsExpr GhcPs)
matches
       ; forall (m :: * -> *) a. Monad m => a -> m a
return (forall p. XLam p -> MatchGroup p (LHsExpr p) -> HsExpr p
HsLam XLam GhcPs
x MatchGroup GhcRn (GenLocated SrcSpanAnnA (HsExpr GhcRn))
matches', FreeVars
fvMatch) }

rnExpr (HsLamCase XLamCase GhcPs
x MatchGroup GhcPs (LHsExpr GhcPs)
matches)
  = do { (MatchGroup GhcRn (GenLocated SrcSpanAnnA (HsExpr GhcRn))
matches', FreeVars
fvs_ms) <- forall (body :: * -> *).
(Outputable (body GhcPs), AnnoBody body) =>
HsMatchContext GhcRn
-> (LocatedA (body GhcPs) -> RnM (LocatedA (body GhcRn), FreeVars))
-> MatchGroup GhcPs (LocatedA (body GhcPs))
-> RnM (MatchGroup GhcRn (LocatedA (body GhcRn)), FreeVars)
rnMatchGroup forall p. HsMatchContext p
CaseAlt LHsExpr GhcPs -> RnM (XRec GhcRn (HsExpr GhcRn), FreeVars)
rnLExpr MatchGroup GhcPs (LHsExpr GhcPs)
matches
       ; forall (m :: * -> *) a. Monad m => a -> m a
return (forall p. XLamCase p -> MatchGroup p (LHsExpr p) -> HsExpr p
HsLamCase XLamCase GhcPs
x MatchGroup GhcRn (GenLocated SrcSpanAnnA (HsExpr GhcRn))
matches', FreeVars
fvs_ms) }

rnExpr (HsCase XCase GhcPs
_ LHsExpr GhcPs
expr MatchGroup GhcPs (LHsExpr GhcPs)
matches)
  = do { (GenLocated SrcSpanAnnA (HsExpr GhcRn)
new_expr, FreeVars
e_fvs) <- LHsExpr GhcPs -> RnM (XRec GhcRn (HsExpr GhcRn), FreeVars)
rnLExpr LHsExpr GhcPs
expr
       ; (MatchGroup GhcRn (GenLocated SrcSpanAnnA (HsExpr GhcRn))
new_matches, FreeVars
ms_fvs) <- forall (body :: * -> *).
(Outputable (body GhcPs), AnnoBody body) =>
HsMatchContext GhcRn
-> (LocatedA (body GhcPs) -> RnM (LocatedA (body GhcRn), FreeVars))
-> MatchGroup GhcPs (LocatedA (body GhcPs))
-> RnM (MatchGroup GhcRn (LocatedA (body GhcRn)), FreeVars)
rnMatchGroup forall p. HsMatchContext p
CaseAlt LHsExpr GhcPs -> RnM (XRec GhcRn (HsExpr GhcRn), FreeVars)
rnLExpr MatchGroup GhcPs (LHsExpr GhcPs)
matches
       ; forall (m :: * -> *) a. Monad m => a -> m a
return (forall p.
XCase p -> LHsExpr p -> MatchGroup p (LHsExpr p) -> HsExpr p
HsCase NoExtField
noExtField GenLocated SrcSpanAnnA (HsExpr GhcRn)
new_expr MatchGroup GhcRn (GenLocated SrcSpanAnnA (HsExpr GhcRn))
new_matches, FreeVars
e_fvs FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
ms_fvs) }

rnExpr (HsLet XLet GhcPs
_ HsLocalBinds GhcPs
binds LHsExpr GhcPs
expr)
  = forall result.
HsLocalBinds GhcPs
-> (HsLocalBinds GhcRn -> FreeVars -> RnM (result, FreeVars))
-> RnM (result, FreeVars)
rnLocalBindsAndThen HsLocalBinds GhcPs
binds forall a b. (a -> b) -> a -> b
$ \HsLocalBinds GhcRn
binds' FreeVars
_ -> do
      { (GenLocated SrcSpanAnnA (HsExpr GhcRn)
expr',FreeVars
fvExpr) <- LHsExpr GhcPs -> RnM (XRec GhcRn (HsExpr GhcRn), FreeVars)
rnLExpr LHsExpr GhcPs
expr
      ; forall (m :: * -> *) a. Monad m => a -> m a
return (forall p. XLet p -> HsLocalBinds p -> LHsExpr p -> HsExpr p
HsLet NoExtField
noExtField HsLocalBinds GhcRn
binds' GenLocated SrcSpanAnnA (HsExpr GhcRn)
expr', FreeVars
fvExpr) }

rnExpr (HsDo XDo GhcPs
_ HsStmtContext (HsDoRn GhcPs)
do_or_lc (L SrcSpanAnnL
l [GenLocated
   SrcSpanAnnA
   (StmtLR GhcPs GhcPs (GenLocated SrcSpanAnnA (HsExpr GhcPs)))]
stmts))
  = do  { (([GenLocated
   SrcSpanAnnA
   (StmtLR GhcRn GhcRn (GenLocated SrcSpanAnnA (HsExpr GhcRn)))]
stmts', ()
_), FreeVars
fvs) <-
           forall (body :: * -> *) thing.
AnnoBody body =>
HsStmtContext GhcRn
-> (body GhcPs -> RnM (body GhcRn, FreeVars))
-> (HsStmtContext GhcRn
    -> [(LStmt GhcRn (LocatedA (body GhcRn)), FreeVars)]
    -> RnM ([LStmt GhcRn (LocatedA (body GhcRn))], FreeVars))
-> [LStmt GhcPs (LocatedA (body GhcPs))]
-> ([Name] -> RnM (thing, FreeVars))
-> RnM (([LStmt GhcRn (LocatedA (body GhcRn))], thing), FreeVars)
rnStmtsWithPostProcessing HsStmtContext (HsDoRn GhcPs)
do_or_lc HsExpr GhcPs -> RnM (HsExpr GhcRn, FreeVars)
rnExpr
             HsStmtContext GhcRn
-> [(ExprLStmt GhcRn, FreeVars)]
-> RnM ([ExprLStmt GhcRn], FreeVars)
postProcessStmtsForApplicativeDo [GenLocated
   SrcSpanAnnA
   (StmtLR GhcPs GhcPs (GenLocated SrcSpanAnnA (HsExpr GhcPs)))]
stmts
             (\ [Name]
_ -> forall (m :: * -> *) a. Monad m => a -> m a
return ((), FreeVars
emptyFVs))
        ; forall (m :: * -> *) a. Monad m => a -> m a
return ( forall p.
XDo p
-> HsStmtContext (HsDoRn p) -> XRec p [ExprLStmt p] -> HsExpr p
HsDo NoExtField
noExtField HsStmtContext (HsDoRn GhcPs)
do_or_lc (forall l e. l -> e -> GenLocated l e
L SrcSpanAnnL
l [GenLocated
   SrcSpanAnnA
   (StmtLR GhcRn GhcRn (GenLocated SrcSpanAnnA (HsExpr GhcRn)))]
stmts'), FreeVars
fvs ) }

-- ExplicitList: see Note [Handling overloaded and rebindable constructs]
rnExpr (ExplicitList XExplicitList GhcPs
_ [LHsExpr GhcPs]
exps)
  = do  { ([GenLocated SrcSpanAnnA (HsExpr GhcRn)]
exps', FreeVars
fvs) <- [LHsExpr GhcPs] -> RnM ([XRec GhcRn (HsExpr GhcRn)], FreeVars)
rnExprs [LHsExpr GhcPs]
exps
        ; Bool
opt_OverloadedLists <- forall gbl lcl. Extension -> TcRnIf gbl lcl Bool
xoptM Extension
LangExt.OverloadedLists
        ; if Bool -> Bool
not Bool
opt_OverloadedLists
          then forall (m :: * -> *) a. Monad m => a -> m a
return  (forall p. XExplicitList p -> [LHsExpr p] -> HsExpr p
ExplicitList NoExtField
noExtField [GenLocated SrcSpanAnnA (HsExpr GhcRn)]
exps', FreeVars
fvs)
          else
    do { (Name
from_list_n_name, FreeVars
fvs') <- Name -> RnM (Name, FreeVars)
lookupSyntaxName Name
fromListNName
       ; let rn_list :: HsExpr GhcRn
rn_list  = forall p. XExplicitList p -> [LHsExpr p] -> HsExpr p
ExplicitList NoExtField
noExtField [GenLocated SrcSpanAnnA (HsExpr GhcRn)]
exps'
             lit_n :: IntegralLit
lit_n    = forall a. Integral a => a -> IntegralLit
mkIntegralLit (forall (t :: * -> *) a. Foldable t => t a -> Int
length [LHsExpr GhcPs]
exps)
             hs_lit :: GenLocated SrcSpanAnnA (HsExpr GhcRn)
hs_lit   = forall a an. a -> LocatedAn an a
wrapGenSpan (forall p. XLitE p -> HsLit p -> HsExpr p
HsLit forall a. EpAnn a
noAnn (forall x. XHsInt x -> IntegralLit -> HsLit x
HsInt NoExtField
noExtField IntegralLit
lit_n))
             exp_list :: HsExpr GhcRn
exp_list = Name -> [XRec GhcRn (HsExpr GhcRn)] -> HsExpr GhcRn
genHsApps Name
from_list_n_name [GenLocated SrcSpanAnnA (HsExpr GhcRn)
hs_lit, forall a an. a -> LocatedAn an a
wrapGenSpan HsExpr GhcRn
rn_list]
       ; forall (m :: * -> *) a. Monad m => a -> m a
return ( HsExpr GhcRn -> HsExpr GhcRn -> HsExpr GhcRn
mkExpandedExpr HsExpr GhcRn
rn_list HsExpr GhcRn
exp_list
                , FreeVars
fvs FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fvs') } }

rnExpr (ExplicitTuple XExplicitTuple GhcPs
_ [HsTupArg GhcPs]
tup_args Boxity
boxity)
  = do { [HsTupArg GhcPs] -> IOEnv (Env TcGblEnv TcLclEnv) ()
checkTupleSection [HsTupArg GhcPs]
tup_args
       ; ([HsTupArg GhcRn]
tup_args', [FreeVars]
fvs) <- forall (m :: * -> *) a b c.
Applicative m =>
(a -> m (b, c)) -> [a] -> m ([b], [c])
mapAndUnzipM HsTupArg GhcPs
-> IOEnv (Env TcGblEnv TcLclEnv) (HsTupArg GhcRn, FreeVars)
rnTupArg [HsTupArg GhcPs]
tup_args
       ; forall (m :: * -> *) a. Monad m => a -> m a
return (forall p. XExplicitTuple p -> [HsTupArg p] -> Boxity -> HsExpr p
ExplicitTuple NoExtField
noExtField [HsTupArg GhcRn]
tup_args' Boxity
boxity, [FreeVars] -> FreeVars
plusFVs [FreeVars]
fvs) }
  where
    rnTupArg :: HsTupArg GhcPs
-> IOEnv (Env TcGblEnv TcLclEnv) (HsTupArg GhcRn, FreeVars)
rnTupArg (Present XPresent GhcPs
x LHsExpr GhcPs
e) = do { (GenLocated SrcSpanAnnA (HsExpr GhcRn)
e',FreeVars
fvs) <- LHsExpr GhcPs -> RnM (XRec GhcRn (HsExpr GhcRn), FreeVars)
rnLExpr LHsExpr GhcPs
e
                                ; forall (m :: * -> *) a. Monad m => a -> m a
return (forall id. XPresent id -> LHsExpr id -> HsTupArg id
Present XPresent GhcPs
x GenLocated SrcSpanAnnA (HsExpr GhcRn)
e', FreeVars
fvs) }
    rnTupArg (Missing XMissing GhcPs
_) = forall (m :: * -> *) a. Monad m => a -> m a
return (forall id. XMissing id -> HsTupArg id
Missing NoExtField
noExtField, FreeVars
emptyFVs)

rnExpr (ExplicitSum XExplicitSum GhcPs
_ Int
alt Int
arity LHsExpr GhcPs
expr)
  = do { (GenLocated SrcSpanAnnA (HsExpr GhcRn)
expr', FreeVars
fvs) <- LHsExpr GhcPs -> RnM (XRec GhcRn (HsExpr GhcRn), FreeVars)
rnLExpr LHsExpr GhcPs
expr
       ; forall (m :: * -> *) a. Monad m => a -> m a
return (forall p. XExplicitSum p -> Int -> Int -> LHsExpr p -> HsExpr p
ExplicitSum NoExtField
noExtField Int
alt Int
arity GenLocated SrcSpanAnnA (HsExpr GhcRn)
expr', FreeVars
fvs) }

rnExpr (RecordCon { rcon_con :: forall p. HsExpr p -> XRec p (ConLikeP p)
rcon_con = XRec GhcPs (ConLikeP GhcPs)
con_id
                  , rcon_flds :: forall p. HsExpr p -> HsRecordBinds p
rcon_flds = rec_binds :: HsRecordBinds GhcPs
rec_binds@(HsRecFields { rec_dotdot :: forall p arg. HsRecFields p arg -> Maybe (Located Int)
rec_dotdot = Maybe (Located Int)
dd }) })
  = do { con_lname :: GenLocated SrcSpanAnnN Name
con_lname@(L SrcSpanAnnN
_ Name
con_name) <- forall ann.
GenLocated (SrcSpanAnn' ann) RdrName
-> TcRn (GenLocated (SrcSpanAnn' ann) Name)
lookupLocatedOccRn XRec GhcPs (ConLikeP GhcPs)
con_id
       ; ([GenLocated
   SrcSpanAnnA
   (HsRecField'
      (FieldOcc GhcRn) (GenLocated SrcSpanAnnA (HsExpr GhcPs)))]
flds, FreeVars
fvs)   <- forall arg.
HsRecFieldContext
-> (SrcSpan -> RdrName -> arg)
-> HsRecFields GhcPs (LocatedA arg)
-> RnM ([LHsRecField GhcRn (LocatedA arg)], FreeVars)
rnHsRecFields (Name -> HsRecFieldContext
HsRecFieldCon Name
con_name) forall {p} {ann}.
(XVar p ~ NoExtField,
 XRec p (IdP p) ~ GenLocated (SrcAnn ann) (IdP p)) =>
SrcSpan -> IdP p -> HsExpr p
mk_hs_var HsRecordBinds GhcPs
rec_binds
       ; ([GenLocated
   SrcSpanAnnA
   (HsRecField'
      (FieldOcc GhcRn) (GenLocated SrcSpanAnnA (HsExpr GhcRn)))]
flds', [FreeVars]
fvss) <- forall (m :: * -> *) a b c.
Applicative m =>
(a -> m (b, c)) -> [a] -> m ([b], [c])
mapAndUnzipM forall {l} {id}.
GenLocated
  l (HsRecField' id (GenLocated SrcSpanAnnA (HsExpr GhcPs)))
-> IOEnv
     (Env TcGblEnv TcLclEnv)
     (GenLocated
        l (HsRecField' id (GenLocated SrcSpanAnnA (HsExpr GhcRn))),
      FreeVars)
rn_field [GenLocated
   SrcSpanAnnA
   (HsRecField'
      (FieldOcc GhcRn) (GenLocated SrcSpanAnnA (HsExpr GhcPs)))]
flds
       ; let rec_binds' :: HsRecFields GhcRn (GenLocated SrcSpanAnnA (HsExpr GhcRn))
rec_binds' = HsRecFields { rec_flds :: [LHsRecField GhcRn (GenLocated SrcSpanAnnA (HsExpr GhcRn))]
rec_flds = [GenLocated
   SrcSpanAnnA
   (HsRecField'
      (FieldOcc GhcRn) (GenLocated SrcSpanAnnA (HsExpr GhcRn)))]
flds', rec_dotdot :: Maybe (Located Int)
rec_dotdot = Maybe (Located Int)
dd }
       ; forall (m :: * -> *) a. Monad m => a -> m a
return (RecordCon { rcon_ext :: XRecordCon GhcRn
rcon_ext = NoExtField
noExtField
                           , rcon_con :: XRec GhcRn (ConLikeP GhcRn)
rcon_con = GenLocated SrcSpanAnnN Name
con_lname, rcon_flds :: HsRecordBinds GhcRn
rcon_flds = HsRecFields GhcRn (GenLocated SrcSpanAnnA (HsExpr GhcRn))
rec_binds' }
                , FreeVars
fvs FreeVars -> FreeVars -> FreeVars
`plusFV` [FreeVars] -> FreeVars
plusFVs [FreeVars]
fvss FreeVars -> Name -> FreeVars
`addOneFV` Name
con_name) }
  where
    mk_hs_var :: SrcSpan -> IdP p -> HsExpr p
mk_hs_var SrcSpan
l IdP p
n = forall p. XVar p -> LIdP p -> HsExpr p
HsVar NoExtField
noExtField (forall l e. l -> e -> GenLocated l e
L (forall ann. SrcSpan -> SrcAnn ann
noAnnSrcSpan SrcSpan
l) IdP p
n)
    rn_field :: GenLocated
  l (HsRecField' id (GenLocated SrcSpanAnnA (HsExpr GhcPs)))
-> IOEnv
     (Env TcGblEnv TcLclEnv)
     (GenLocated
        l (HsRecField' id (GenLocated SrcSpanAnnA (HsExpr GhcRn))),
      FreeVars)
rn_field (L l
l HsRecField' id (GenLocated SrcSpanAnnA (HsExpr GhcPs))
fld) = do { (GenLocated SrcSpanAnnA (HsExpr GhcRn)
arg', FreeVars
fvs) <- LHsExpr GhcPs -> RnM (XRec GhcRn (HsExpr GhcRn), FreeVars)
rnLExpr (forall id arg. HsRecField' id arg -> arg
hsRecFieldArg HsRecField' id (GenLocated SrcSpanAnnA (HsExpr GhcPs))
fld)
                            ; forall (m :: * -> *) a. Monad m => a -> m a
return (forall l e. l -> e -> GenLocated l e
L l
l (HsRecField' id (GenLocated SrcSpanAnnA (HsExpr GhcPs))
fld { hsRecFieldArg :: GenLocated SrcSpanAnnA (HsExpr GhcRn)
hsRecFieldArg = GenLocated SrcSpanAnnA (HsExpr GhcRn)
arg' }), FreeVars
fvs) }

rnExpr (RecordUpd { rupd_expr :: forall p. HsExpr p -> LHsExpr p
rupd_expr = LHsExpr GhcPs
expr, rupd_flds :: forall p. HsExpr p -> Either [LHsRecUpdField p] [LHsRecUpdProj p]
rupd_flds = Either [LHsRecUpdField GhcPs] [LHsRecUpdProj GhcPs]
rbinds })
  = case Either [LHsRecUpdField GhcPs] [LHsRecUpdProj GhcPs]
rbinds of
      Left [LHsRecUpdField GhcPs]
flds -> -- 'OverloadedRecordUpdate' is not in effect. Regular record update.
        do  { ; (GenLocated SrcSpanAnnA (HsExpr GhcRn)
e, FreeVars
fv_e) <- LHsExpr GhcPs -> RnM (XRec GhcRn (HsExpr GhcRn), FreeVars)
rnLExpr LHsExpr GhcPs
expr
              ; ([GenLocated
   SrcSpanAnnA
   (HsRecField'
      (AmbiguousFieldOcc GhcRn) (GenLocated SrcSpanAnnA (HsExpr GhcRn)))]
rs, FreeVars
fv_rs) <- [LHsRecUpdField GhcPs] -> RnM ([LHsRecUpdField GhcRn], FreeVars)
rnHsRecUpdFields [LHsRecUpdField GhcPs]
flds
              ; forall (m :: * -> *) a. Monad m => a -> m a
return ( forall p.
XRecordUpd p
-> LHsExpr p
-> Either [LHsRecUpdField p] [LHsRecUpdProj p]
-> HsExpr p
RecordUpd NoExtField
noExtField GenLocated SrcSpanAnnA (HsExpr GhcRn)
e (forall a b. a -> Either a b
Left [GenLocated
   SrcSpanAnnA
   (HsRecField'
      (AmbiguousFieldOcc GhcRn) (GenLocated SrcSpanAnnA (HsExpr GhcRn)))]
rs), FreeVars
fv_e FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fv_rs )
            }
      Right [LHsRecUpdProj GhcPs]
flds ->  -- 'OverloadedRecordUpdate' is in effect. Record dot update desugaring.
        do { ; forall gbl lcl. Extension -> TcRnIf gbl lcl () -> TcRnIf gbl lcl ()
unlessXOptM Extension
LangExt.RebindableSyntax forall a b. (a -> b) -> a -> b
$
                 SDoc -> IOEnv (Env TcGblEnv TcLclEnv) ()
addErr forall a b. (a -> b) -> a -> b
$ String -> SDoc
text String
"RebindableSyntax is required if OverloadedRecordUpdate is enabled."
             ; let punnedFields :: [HsRecField'
   (FieldLabelStrings GhcPs) (GenLocated SrcSpanAnnA (HsExpr GhcPs))]
punnedFields = [HsRecField'
  (FieldLabelStrings GhcPs) (GenLocated SrcSpanAnnA (HsExpr GhcPs))
fld | (L SrcSpanAnnA
_ HsRecField'
  (FieldLabelStrings GhcPs) (GenLocated SrcSpanAnnA (HsExpr GhcPs))
fld) <- [LHsRecUpdProj GhcPs]
flds, forall id arg. HsRecField' id arg -> Bool
hsRecPun HsRecField'
  (FieldLabelStrings GhcPs) (GenLocated SrcSpanAnnA (HsExpr GhcPs))
fld]
             ; Bool
punsEnabled <-forall gbl lcl. Extension -> TcRnIf gbl lcl Bool
xoptM Extension
LangExt.RecordPuns
             ; forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (forall (t :: * -> *) a. Foldable t => t a -> Bool
null [HsRecField'
   (FieldLabelStrings GhcPs) (GenLocated SrcSpanAnnA (HsExpr GhcPs))]
punnedFields Bool -> Bool -> Bool
|| Bool
punsEnabled) forall a b. (a -> b) -> a -> b
$
                 SDoc -> IOEnv (Env TcGblEnv TcLclEnv) ()
addErr forall a b. (a -> b) -> a -> b
$ String -> SDoc
text String
"For this to work enable NamedFieldPuns."
             ; (Name
getField, FreeVars
fv_getField) <- Name -> RnM (Name, FreeVars)
lookupSyntaxName Name
getFieldName
             ; (Name
setField, FreeVars
fv_setField) <- Name -> RnM (Name, FreeVars)
lookupSyntaxName Name
setFieldName
             ; (GenLocated SrcSpanAnnA (HsExpr GhcRn)
e, FreeVars
fv_e) <- LHsExpr GhcPs -> RnM (XRec GhcRn (HsExpr GhcRn), FreeVars)
rnLExpr LHsExpr GhcPs
expr
             ; ([GenLocated
   SrcSpanAnnA
   (HsRecField'
      (FieldLabelStrings GhcRn) (GenLocated SrcSpanAnnA (HsExpr GhcRn)))]
us, FreeVars
fv_us) <- [LHsRecUpdProj GhcPs] -> RnM ([LHsRecUpdProj GhcRn], FreeVars)
rnHsUpdProjs [LHsRecUpdProj GhcPs]
flds
             ; forall (m :: * -> *) a. Monad m => a -> m a
return ( HsExpr GhcRn -> HsExpr GhcRn -> HsExpr GhcRn
mkExpandedExpr
                          (forall p.
XRecordUpd p
-> LHsExpr p
-> Either [LHsRecUpdField p] [LHsRecUpdProj p]
-> HsExpr p
RecordUpd NoExtField
noExtField GenLocated SrcSpanAnnA (HsExpr GhcRn)
e (forall a b. b -> Either a b
Right [GenLocated
   SrcSpanAnnA
   (HsRecField'
      (FieldLabelStrings GhcRn) (GenLocated SrcSpanAnnA (HsExpr GhcRn)))]
us))
                          (Name
-> Name
-> XRec GhcRn (HsExpr GhcRn)
-> [LHsRecUpdProj GhcRn]
-> HsExpr GhcRn
mkRecordDotUpd Name
getField Name
setField GenLocated SrcSpanAnnA (HsExpr GhcRn)
e [GenLocated
   SrcSpanAnnA
   (HsRecField'
      (FieldLabelStrings GhcRn) (GenLocated SrcSpanAnnA (HsExpr GhcRn)))]
us)
                         , [FreeVars] -> FreeVars
plusFVs [FreeVars
fv_getField, FreeVars
fv_setField, FreeVars
fv_e, FreeVars
fv_us] )
             }

rnExpr (ExprWithTySig XExprWithTySig GhcPs
_ LHsExpr GhcPs
expr LHsSigWcType (NoGhcTc GhcPs)
pty)
  = do  { (HsWildCardBndrs GhcRn (GenLocated SrcSpanAnnA (HsSigType GhcRn))
pty', FreeVars
fvTy)    <- HsDocContext
-> LHsSigWcType GhcPs -> RnM (LHsSigWcType GhcRn, FreeVars)
rnHsSigWcType HsDocContext
ExprWithTySigCtx LHsSigWcType (NoGhcTc GhcPs)
pty
        ; (GenLocated SrcSpanAnnA (HsExpr GhcRn)
expr', FreeVars
fvExpr) <- forall a. [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)
bindSigTyVarsFV (LHsSigWcType GhcRn -> [Name]
hsWcScopedTvs HsWildCardBndrs GhcRn (GenLocated SrcSpanAnnA (HsSigType GhcRn))
pty') forall a b. (a -> b) -> a -> b
$
                             LHsExpr GhcPs -> RnM (XRec GhcRn (HsExpr GhcRn), FreeVars)
rnLExpr LHsExpr GhcPs
expr
        ; forall (m :: * -> *) a. Monad m => a -> m a
return (forall p.
XExprWithTySig p
-> LHsExpr p -> LHsSigWcType (NoGhcTc p) -> HsExpr p
ExprWithTySig NoExtField
noExtField GenLocated SrcSpanAnnA (HsExpr GhcRn)
expr' HsWildCardBndrs GhcRn (GenLocated SrcSpanAnnA (HsSigType GhcRn))
pty', FreeVars
fvExpr FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fvTy) }

-- HsIf: see Note [Handling overloaded and rebindable constructs]
-- Because of the coverage checker it is most convenient /not/ to
-- expand HsIf; unless we are in rebindable syntax.
rnExpr (HsIf XIf GhcPs
_ LHsExpr GhcPs
p LHsExpr GhcPs
b1 LHsExpr GhcPs
b2)
  = do { (GenLocated SrcSpanAnnA (HsExpr GhcRn)
p',  FreeVars
fvP)  <- LHsExpr GhcPs -> RnM (XRec GhcRn (HsExpr GhcRn), FreeVars)
rnLExpr LHsExpr GhcPs
p
       ; (GenLocated SrcSpanAnnA (HsExpr GhcRn)
b1', FreeVars
fvB1) <- LHsExpr GhcPs -> RnM (XRec GhcRn (HsExpr GhcRn), FreeVars)
rnLExpr LHsExpr GhcPs
b1
       ; (GenLocated SrcSpanAnnA (HsExpr GhcRn)
b2', FreeVars
fvB2) <- LHsExpr GhcPs -> RnM (XRec GhcRn (HsExpr GhcRn), FreeVars)
rnLExpr LHsExpr GhcPs
b2
       ; let fvs_if :: FreeVars
fvs_if = [FreeVars] -> FreeVars
plusFVs [FreeVars
fvP, FreeVars
fvB1, FreeVars
fvB2]
             rn_if :: HsExpr GhcRn
rn_if  = forall p. XIf p -> LHsExpr p -> LHsExpr p -> LHsExpr p -> HsExpr p
HsIf NoExtField
noExtField  GenLocated SrcSpanAnnA (HsExpr GhcRn)
p' GenLocated SrcSpanAnnA (HsExpr GhcRn)
b1' GenLocated SrcSpanAnnA (HsExpr GhcRn)
b2'

       -- Deal with rebindable syntax
       -- See Note [Handling overloaded and rebindable constructs]
       ; Maybe Name
mb_ite <- RnM (Maybe Name)
lookupIfThenElse
       ; case Maybe Name
mb_ite of
            Maybe Name
Nothing  -- Non rebindable-syntax case
              -> forall (m :: * -> *) a. Monad m => a -> m a
return (HsExpr GhcRn
rn_if, FreeVars
fvs_if)

            Just Name
ite_name   -- Rebindable-syntax case
              -> do { let ds_if :: HsExpr GhcRn
ds_if = Name -> [XRec GhcRn (HsExpr GhcRn)] -> HsExpr GhcRn
genHsApps Name
ite_name [GenLocated SrcSpanAnnA (HsExpr GhcRn)
p', GenLocated SrcSpanAnnA (HsExpr GhcRn)
b1', GenLocated SrcSpanAnnA (HsExpr GhcRn)
b2']
                          fvs :: FreeVars
fvs   = [FreeVars] -> FreeVars
plusFVs [FreeVars
fvs_if, Name -> FreeVars
unitFV Name
ite_name]
                    ; forall (m :: * -> *) a. Monad m => a -> m a
return (HsExpr GhcRn -> HsExpr GhcRn -> HsExpr GhcRn
mkExpandedExpr HsExpr GhcRn
rn_if HsExpr GhcRn
ds_if, FreeVars
fvs) } }

rnExpr (HsMultiIf XMultiIf GhcPs
_ [LGRHS GhcPs (LHsExpr GhcPs)]
alts)
  = do { ([GenLocated
   (Anno (GRHS GhcRn (GenLocated SrcSpanAnnA (HsExpr GhcRn))))
   (GRHS GhcRn (GenLocated SrcSpanAnnA (HsExpr GhcRn)))]
alts', FreeVars
fvs) <- forall a b. (a -> RnM (b, FreeVars)) -> [a] -> RnM ([b], FreeVars)
mapFvRn (forall (body :: * -> *).
AnnoBody body =>
HsMatchContext GhcRn
-> (LocatedA (body GhcPs) -> RnM (LocatedA (body GhcRn), FreeVars))
-> LGRHS GhcPs (LocatedA (body GhcPs))
-> RnM (LGRHS GhcRn (LocatedA (body GhcRn)), FreeVars)
rnGRHS forall p. HsMatchContext p
IfAlt LHsExpr GhcPs -> RnM (XRec GhcRn (HsExpr GhcRn), FreeVars)
rnLExpr) [LGRHS GhcPs (LHsExpr GhcPs)]
alts
       ; forall (m :: * -> *) a. Monad m => a -> m a
return (forall p. XMultiIf p -> [LGRHS p (LHsExpr p)] -> HsExpr p
HsMultiIf NoExtField
noExtField [GenLocated
   (Anno (GRHS GhcRn (GenLocated SrcSpanAnnA (HsExpr GhcRn))))
   (GRHS GhcRn (GenLocated SrcSpanAnnA (HsExpr GhcRn)))]
alts', FreeVars
fvs) }

rnExpr (ArithSeq XArithSeq GhcPs
_ Maybe (SyntaxExpr GhcPs)
_ ArithSeqInfo GhcPs
seq)
  = do { Bool
opt_OverloadedLists <- forall gbl lcl. Extension -> TcRnIf gbl lcl Bool
xoptM Extension
LangExt.OverloadedLists
       ; (ArithSeqInfo GhcRn
new_seq, FreeVars
fvs) <- ArithSeqInfo GhcPs -> RnM (ArithSeqInfo GhcRn, FreeVars)
rnArithSeq ArithSeqInfo GhcPs
seq
       ; if Bool
opt_OverloadedLists
           then do {
            ; (SyntaxExprRn
from_list_name, FreeVars
fvs') <- Name -> RnM (SyntaxExpr GhcRn, FreeVars)
lookupSyntax Name
fromListName
            ; forall (m :: * -> *) a. Monad m => a -> m a
return (forall p.
XArithSeq p -> Maybe (SyntaxExpr p) -> ArithSeqInfo p -> HsExpr p
ArithSeq NoExtField
noExtField (forall a. a -> Maybe a
Just SyntaxExprRn
from_list_name) ArithSeqInfo GhcRn
new_seq
                     , FreeVars
fvs FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fvs') }
           else
            forall (m :: * -> *) a. Monad m => a -> m a
return (forall p.
XArithSeq p -> Maybe (SyntaxExpr p) -> ArithSeqInfo p -> HsExpr p
ArithSeq NoExtField
noExtField forall a. Maybe a
Nothing ArithSeqInfo GhcRn
new_seq, FreeVars
fvs) }

{-
************************************************************************
*                                                                      *
        Static values
*                                                                      *
************************************************************************

For the static form we check that it is not used in splices.
We also collect the free variables of the term which come from
this module. See Note [Grand plan for static forms] in GHC.Iface.Tidy.StaticPtrTable.
-}

rnExpr e :: HsExpr GhcPs
e@(HsStatic XStatic GhcPs
_ LHsExpr GhcPs
expr) = do
    -- Normally, you wouldn't be able to construct a static expression without
    -- first enabling -XStaticPointers in the first place, since that extension
    -- is what makes the parser treat `static` as a keyword. But this is not a
    -- sufficient safeguard, as one can construct static expressions by another
    -- mechanism: Template Haskell (see #14204). To ensure that GHC is
    -- absolutely prepared to cope with static forms, we check for
    -- -XStaticPointers here as well.
    forall gbl lcl. Extension -> TcRnIf gbl lcl () -> TcRnIf gbl lcl ()
unlessXOptM Extension
LangExt.StaticPointers forall a b. (a -> b) -> a -> b
$
      SDoc -> IOEnv (Env TcGblEnv TcLclEnv) ()
addErr forall a b. (a -> b) -> a -> b
$ SDoc -> Int -> SDoc -> SDoc
hang (String -> SDoc
text String
"Illegal static expression:" SDoc -> SDoc -> SDoc
<+> forall a. Outputable a => a -> SDoc
ppr HsExpr GhcPs
e)
                  Int
2 (String -> SDoc
text String
"Use StaticPointers to enable this extension")
    (GenLocated SrcSpanAnnA (HsExpr GhcRn)
expr',FreeVars
fvExpr) <- LHsExpr GhcPs -> RnM (XRec GhcRn (HsExpr GhcRn), FreeVars)
rnLExpr LHsExpr GhcPs
expr
    ThStage
stage <- TcM ThStage
getStage
    case ThStage
stage of
      Splice SpliceType
_ -> SDoc -> IOEnv (Env TcGblEnv TcLclEnv) ()
addErr forall a b. (a -> b) -> a -> b
$ [SDoc] -> SDoc
sep
             [ String -> SDoc
text String
"static forms cannot be used in splices:"
             , Int -> SDoc -> SDoc
nest Int
2 forall a b. (a -> b) -> a -> b
$ forall a. Outputable a => a -> SDoc
ppr HsExpr GhcPs
e
             ]
      ThStage
_ -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
    Module
mod <- forall (m :: * -> *). HasModule m => m Module
getModule
    let fvExpr' :: FreeVars
fvExpr' = (Name -> Bool) -> FreeVars -> FreeVars
filterNameSet (Module -> Name -> Bool
nameIsLocalOrFrom Module
mod) FreeVars
fvExpr
    forall (m :: * -> *) a. Monad m => a -> m a
return (forall p. XStatic p -> LHsExpr p -> HsExpr p
HsStatic FreeVars
fvExpr' GenLocated SrcSpanAnnA (HsExpr GhcRn)
expr', FreeVars
fvExpr)

{- *********************************************************************
*                                                                      *
        Arrow notation
*                                                                      *
********************************************************************* -}

rnExpr (HsProc XProc GhcPs
x LPat GhcPs
pat LHsCmdTop GhcPs
body)
  = forall a. TcM a -> TcM a
newArrowScope forall a b. (a -> b) -> a -> b
$
    forall a.
HsMatchContext GhcRn
-> LPat GhcPs
-> (LPat GhcRn -> RnM (a, FreeVars))
-> RnM (a, FreeVars)
rnPat (forall p. HsArrowMatchContext -> HsMatchContext p
ArrowMatchCtxt HsArrowMatchContext
ProcExpr) LPat GhcPs
pat forall a b. (a -> b) -> a -> b
$ \ LPat GhcRn
pat' -> do
      { (GenLocated SrcSpan (HsCmdTop GhcRn)
body',FreeVars
fvBody) <- LHsCmdTop GhcPs -> RnM (LHsCmdTop GhcRn, FreeVars)
rnCmdTop LHsCmdTop GhcPs
body
      ; forall (m :: * -> *) a. Monad m => a -> m a
return (forall p. XProc p -> LPat p -> LHsCmdTop p -> HsExpr p
HsProc XProc GhcPs
x LPat GhcRn
pat' GenLocated SrcSpan (HsCmdTop GhcRn)
body', FreeVars
fvBody) }

rnExpr HsExpr GhcPs
other = forall a. HasCallStack => String -> SDoc -> a
pprPanic String
"rnExpr: unexpected expression" (forall a. Outputable a => a -> SDoc
ppr HsExpr GhcPs
other)
        -- HsWrap

{- *********************************************************************
*                                                                      *
        Operator sections
*                                                                      *
********************************************************************* -}


rnSection :: HsExpr GhcPs -> RnM (HsExpr GhcRn, FreeVars)
-- See Note [Parsing sections] in GHC.Parser
-- Also see Note [Handling overloaded and rebindable constructs]

rnSection :: HsExpr GhcPs -> RnM (HsExpr GhcRn, FreeVars)
rnSection section :: HsExpr GhcPs
section@(SectionR XSectionR GhcPs
x LHsExpr GhcPs
op LHsExpr GhcPs
expr)
  -- See Note [Left and right sections]
  = do  { (GenLocated SrcSpanAnnA (HsExpr GhcRn)
op', FreeVars
fvs_op)     <- LHsExpr GhcPs -> RnM (XRec GhcRn (HsExpr GhcRn), FreeVars)
rnLExpr LHsExpr GhcPs
op
        ; (GenLocated SrcSpanAnnA (HsExpr GhcRn)
expr', FreeVars
fvs_expr) <- LHsExpr GhcPs -> RnM (XRec GhcRn (HsExpr GhcRn), FreeVars)
rnLExpr LHsExpr GhcPs
expr
        ; FixityDirection
-> HsExpr GhcPs
-> XRec GhcRn (HsExpr GhcRn)
-> XRec GhcRn (HsExpr GhcRn)
-> IOEnv (Env TcGblEnv TcLclEnv) ()
checkSectionPrec FixityDirection
InfixR HsExpr GhcPs
section GenLocated SrcSpanAnnA (HsExpr GhcRn)
op' GenLocated SrcSpanAnnA (HsExpr GhcRn)
expr'
        ; let rn_section :: HsExpr GhcRn
rn_section = forall p. XSectionR p -> LHsExpr p -> LHsExpr p -> HsExpr p
SectionR XSectionR GhcPs
x GenLocated SrcSpanAnnA (HsExpr GhcRn)
op' GenLocated SrcSpanAnnA (HsExpr GhcRn)
expr'
              ds_section :: HsExpr GhcRn
ds_section = Name -> [XRec GhcRn (HsExpr GhcRn)] -> HsExpr GhcRn
genHsApps Name
rightSectionName [GenLocated SrcSpanAnnA (HsExpr GhcRn)
op',GenLocated SrcSpanAnnA (HsExpr GhcRn)
expr']
        ; forall (m :: * -> *) a. Monad m => a -> m a
return ( HsExpr GhcRn -> HsExpr GhcRn -> HsExpr GhcRn
mkExpandedExpr HsExpr GhcRn
rn_section HsExpr GhcRn
ds_section
                 , FreeVars
fvs_op FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fvs_expr) }

rnSection section :: HsExpr GhcPs
section@(SectionL XSectionL GhcPs
x LHsExpr GhcPs
expr LHsExpr GhcPs
op)
  -- See Note [Left and right sections]
  = do  { (GenLocated SrcSpanAnnA (HsExpr GhcRn)
expr', FreeVars
fvs_expr) <- LHsExpr GhcPs -> RnM (XRec GhcRn (HsExpr GhcRn), FreeVars)
rnLExpr LHsExpr GhcPs
expr
        ; (GenLocated SrcSpanAnnA (HsExpr GhcRn)
op', FreeVars
fvs_op)     <- LHsExpr GhcPs -> RnM (XRec GhcRn (HsExpr GhcRn), FreeVars)
rnLExpr LHsExpr GhcPs
op
        ; FixityDirection
-> HsExpr GhcPs
-> XRec GhcRn (HsExpr GhcRn)
-> XRec GhcRn (HsExpr GhcRn)
-> IOEnv (Env TcGblEnv TcLclEnv) ()
checkSectionPrec FixityDirection
InfixL HsExpr GhcPs
section GenLocated SrcSpanAnnA (HsExpr GhcRn)
op' GenLocated SrcSpanAnnA (HsExpr GhcRn)
expr'
        ; Bool
postfix_ops <- forall gbl lcl. Extension -> TcRnIf gbl lcl Bool
xoptM Extension
LangExt.PostfixOperators
                        -- Note [Left and right sections]
        ; let rn_section :: HsExpr GhcRn
rn_section = forall p. XSectionL p -> LHsExpr p -> LHsExpr p -> HsExpr p
SectionL XSectionL GhcPs
x GenLocated SrcSpanAnnA (HsExpr GhcRn)
expr' GenLocated SrcSpanAnnA (HsExpr GhcRn)
op'
              ds_section :: HsExpr GhcRn
ds_section
                | Bool
postfix_ops = forall p. XApp p -> LHsExpr p -> LHsExpr p -> HsExpr p
HsApp forall a. EpAnn a
noAnn GenLocated SrcSpanAnnA (HsExpr GhcRn)
op' GenLocated SrcSpanAnnA (HsExpr GhcRn)
expr'
                | Bool
otherwise   = Name -> [XRec GhcRn (HsExpr GhcRn)] -> HsExpr GhcRn
genHsApps Name
leftSectionName
                                   [forall a an. a -> LocatedAn an a
wrapGenSpan forall a b. (a -> b) -> a -> b
$ forall p. XApp p -> LHsExpr p -> LHsExpr p -> HsExpr p
HsApp forall a. EpAnn a
noAnn GenLocated SrcSpanAnnA (HsExpr GhcRn)
op' GenLocated SrcSpanAnnA (HsExpr GhcRn)
expr']
        ; forall (m :: * -> *) a. Monad m => a -> m a
return ( HsExpr GhcRn -> HsExpr GhcRn -> HsExpr GhcRn
mkExpandedExpr HsExpr GhcRn
rn_section HsExpr GhcRn
ds_section
                 , FreeVars
fvs_op FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fvs_expr) }

rnSection HsExpr GhcPs
other = forall a. HasCallStack => String -> SDoc -> a
pprPanic String
"rnSection" (forall a. Outputable a => a -> SDoc
ppr HsExpr GhcPs
other)

{- Note [Left and right sections]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Dealing with left sections (x *) and right sections (* x) is
surprisingly fiddly.  We expand like this
     (`op` e) ==> rightSection op e
     (e `op`) ==> leftSection  (op e)

Using an auxiliary function in this way avoids the awkwardness of
generating a lambda, esp if `e` is a redex, so we *don't* want
to generate `(\x -> op x e)`. See Historical
Note [Desugaring operator sections]

Here are their definitions:
   leftSection :: forall r1 r2 n (a:TYPE r1) (b:TYPE r2).
                  (a %n-> b) -> a %n-> b
   leftSection f x = f x

   rightSection :: forall r1 r2 r3 (a:TYPE r1) (b:TYPE r2) (c:TYPE r3).
                   (a %n1 -> b %n2-> c) -> b %n2-> a %n1-> c
   rightSection f y x = f x y

Note the wrinkles:

* We do /not/ use lookupSyntaxName, which would make left and right
  section fall under RebindableSyntax.  Reason: it would be a user-
  facing change, and there are some tricky design choices (#19354).
  Plus, infix operator applications would be trickier to make
  rebindable, so it'd be inconsistent to do so for sections.

  TL;DR: we still us the renamer-expansion mechanism for operator
  sections , but only to eliminate special-purpose code paths in the
  renamer and desugarer.

* leftSection and rightSection must be levity-polymorphic, to allow
  (+# 4#) and (4# +#) to work. See GHC.Types.Id.Make.
  Note [Wired-in Ids for rebindable syntax] in

* leftSection and rightSection must be multiplicity-polymorphic.
  (Test linear/should_compile/OldList showed this up.)

* Because they are levity-polymorphic, we have to define them
  as wired-in Ids, with compulsory inlining.  See
  GHC.Types.Id.Make.leftSectionId, rightSectionId.

* leftSection is just ($) really; but unlike ($) it is
  levity polymorphic in the result type, so we can write
  `(x +#)`, say.

* The type of leftSection must have an arrow in its first argument,
  because (x `ord`) should be rejected, because ord does not take two
  arguments

* It's important that we define leftSection in an eta-expanded way,
  (i.e. not leftSection f = f), so that
      (True `undefined`) `seq` ()
      = (leftSection (undefined True) `seq` ())
  evaluates to () and not undefined

* If PostfixOperators is ON, then we expand a left section like this:
      (e `op`)  ==>   op e
  with no auxiliary function at all.  Simple!

* leftSection and rightSection switch on ImpredicativeTypes locally,
  during Quick Look; see GHC.Tc.Gen.App.wantQuickLook. Consider
  test DeepSubsumption08:
     type Setter st t a b = forall f. Identical f => blah
     (.~) :: Setter s t a b -> b -> s -> t
     clear :: Setter a a' b (Maybe b') -> a -> a'
     clear = (.~ Nothing)
   The expansion look like (rightSection (.~) Nothing).  So we must
   instantiate `rightSection` first type argument to a polytype!
   Hence the special magic in App.wantQuickLook.

Historical Note [Desugaring operator sections]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
This Note explains some historical trickiness in desugaring left and
right sections.  That trickiness has completely disappeared now that
we desugar to calls to 'leftSection` and `rightSection`, but I'm
leaving it here to remind us how nice the new story is.

Desugaring left sections with -XPostfixOperators is straightforward: convert
(expr `op`) to (op expr).

Without -XPostfixOperators it's a bit more tricky. At first it looks as if we
can convert

    (expr `op`)

naively to

    \x -> op expr x

But no!  expr might be a redex, and we can lose laziness badly this
way.  Consider

    map (expr `op`) xs

for example. If expr were a redex then eta-expanding naively would
result in multiple evaluations where the user might only have expected one.

So we convert instead to

    let y = expr in \x -> op y x

Also, note that we must do this for both right and (perhaps surprisingly) left
sections. Why are left sections necessary? Consider the program (found in #18151),

    seq (True `undefined`) ()

according to the Haskell Report this should reduce to () (as it specifies
desugaring via eta expansion). However, if we fail to eta expand we will rather
bottom. Consequently, we must eta expand even in the case of a left section.

If `expr` is actually just a variable, say, then the simplifier
will inline `y`, eliminating the redundant `let`.

Note that this works even in the case that `expr` is unlifted. In this case
bindNonRec will automatically do the right thing, giving us:

    case expr of y -> (\x -> op y x)

See #18151.
-}

{-
************************************************************************
*                                                                      *
        Field Labels
*                                                                      *
************************************************************************
-}

rnHsFieldLabel :: Located (HsFieldLabel GhcPs) -> Located (HsFieldLabel GhcRn)
rnHsFieldLabel :: Located (HsFieldLabel GhcPs) -> Located (HsFieldLabel GhcRn)
rnHsFieldLabel (L SrcSpan
l (HsFieldLabel XCHsFieldLabel GhcPs
x Located FastString
label)) = forall l e. l -> e -> GenLocated l e
L SrcSpan
l (forall p. XCHsFieldLabel p -> Located FastString -> HsFieldLabel p
HsFieldLabel XCHsFieldLabel GhcPs
x Located FastString
label)

rnFieldLabelStrings :: FieldLabelStrings GhcPs -> FieldLabelStrings GhcRn
rnFieldLabelStrings :: FieldLabelStrings GhcPs -> FieldLabelStrings GhcRn
rnFieldLabelStrings (FieldLabelStrings [Located (HsFieldLabel GhcPs)]
fls) = forall p. [Located (HsFieldLabel p)] -> FieldLabelStrings p
FieldLabelStrings (forall a b. (a -> b) -> [a] -> [b]
map Located (HsFieldLabel GhcPs) -> Located (HsFieldLabel GhcRn)
rnHsFieldLabel [Located (HsFieldLabel GhcPs)]
fls)

{-
************************************************************************
*                                                                      *
        Arrow commands
*                                                                      *
************************************************************************
-}

rnCmdArgs :: [LHsCmdTop GhcPs] -> RnM ([LHsCmdTop GhcRn], FreeVars)
rnCmdArgs :: [LHsCmdTop GhcPs] -> RnM ([LHsCmdTop GhcRn], FreeVars)
rnCmdArgs [] = forall (m :: * -> *) a. Monad m => a -> m a
return ([], FreeVars
emptyFVs)
rnCmdArgs (LHsCmdTop GhcPs
arg:[LHsCmdTop GhcPs]
args)
  = do { (GenLocated SrcSpan (HsCmdTop GhcRn)
arg',FreeVars
fvArg) <- LHsCmdTop GhcPs -> RnM (LHsCmdTop GhcRn, FreeVars)
rnCmdTop LHsCmdTop GhcPs
arg
       ; ([GenLocated SrcSpan (HsCmdTop GhcRn)]
args',FreeVars
fvArgs) <- [LHsCmdTop GhcPs] -> RnM ([LHsCmdTop GhcRn], FreeVars)
rnCmdArgs [LHsCmdTop GhcPs]
args
       ; forall (m :: * -> *) a. Monad m => a -> m a
return (GenLocated SrcSpan (HsCmdTop GhcRn)
arg'forall a. a -> [a] -> [a]
:[GenLocated SrcSpan (HsCmdTop GhcRn)]
args', FreeVars
fvArg FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fvArgs) }

rnCmdTop :: LHsCmdTop GhcPs -> RnM (LHsCmdTop GhcRn, FreeVars)
rnCmdTop :: LHsCmdTop GhcPs -> RnM (LHsCmdTop GhcRn, FreeVars)
rnCmdTop = forall a b c. (a -> TcM (b, c)) -> Located a -> TcM (Located b, c)
wrapLocFstM HsCmdTop GhcPs -> RnM (HsCmdTop GhcRn, FreeVars)
rnCmdTop'
 where
  rnCmdTop' :: HsCmdTop GhcPs -> RnM (HsCmdTop GhcRn, FreeVars)
  rnCmdTop' :: HsCmdTop GhcPs -> RnM (HsCmdTop GhcRn, FreeVars)
rnCmdTop' (HsCmdTop XCmdTop GhcPs
_ LHsCmd GhcPs
cmd)
   = do { (GenLocated SrcSpanAnnA (HsCmd GhcRn)
cmd', FreeVars
fvCmd) <- LHsCmd GhcPs -> RnM (LHsCmd GhcRn, FreeVars)
rnLCmd LHsCmd GhcPs
cmd
        ; let cmd_names :: [Name]
cmd_names = [Name
arrAName, Name
composeAName, Name
firstAName] forall a. [a] -> [a] -> [a]
++
                          FreeVars -> [Name]
nameSetElemsStable (HsCmd GhcRn -> FreeVars
methodNamesCmd (forall l e. GenLocated l e -> e
unLoc GenLocated SrcSpanAnnA (HsCmd GhcRn)
cmd'))
        -- Generate the rebindable syntax for the monad
        ; ([HsExpr GhcRn]
cmd_names', FreeVars
cmd_fvs) <- [Name] -> RnM ([HsExpr GhcRn], FreeVars)
lookupSyntaxNames [Name]
cmd_names

        ; forall (m :: * -> *) a. Monad m => a -> m a
return (forall p. XCmdTop p -> LHsCmd p -> HsCmdTop p
HsCmdTop ([Name]
cmd_names forall a b. [a] -> [b] -> [(a, b)]
`zip` [HsExpr GhcRn]
cmd_names') GenLocated SrcSpanAnnA (HsCmd GhcRn)
cmd',
                  FreeVars
fvCmd FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
cmd_fvs) }

rnLCmd :: LHsCmd GhcPs -> RnM (LHsCmd GhcRn, FreeVars)
rnLCmd :: LHsCmd GhcPs -> RnM (LHsCmd GhcRn, FreeVars)
rnLCmd = forall a b c.
(a -> TcM (b, c)) -> LocatedA a -> TcM (LocatedA b, c)
wrapLocFstMA HsCmd GhcPs -> RnM (HsCmd GhcRn, FreeVars)
rnCmd

rnCmd :: HsCmd GhcPs -> RnM (HsCmd GhcRn, FreeVars)

rnCmd :: HsCmd GhcPs -> RnM (HsCmd GhcRn, FreeVars)
rnCmd (HsCmdArrApp XCmdArrApp GhcPs
_ LHsExpr GhcPs
arrow LHsExpr GhcPs
arg HsArrAppType
ho Bool
rtl)
  = do { (GenLocated SrcSpanAnnA (HsExpr GhcRn)
arrow',FreeVars
fvArrow) <- TcM (GenLocated SrcSpanAnnA (HsExpr GhcRn), FreeVars)
-> TcM (GenLocated SrcSpanAnnA (HsExpr GhcRn), FreeVars)
select_arrow_scope (LHsExpr GhcPs -> RnM (XRec GhcRn (HsExpr GhcRn), FreeVars)
rnLExpr LHsExpr GhcPs
arrow)
       ; (GenLocated SrcSpanAnnA (HsExpr GhcRn)
arg',FreeVars
fvArg) <- LHsExpr GhcPs -> RnM (XRec GhcRn (HsExpr GhcRn), FreeVars)
rnLExpr LHsExpr GhcPs
arg
       ; forall (m :: * -> *) a. Monad m => a -> m a
return (forall id.
XCmdArrApp id
-> LHsExpr id -> LHsExpr id -> HsArrAppType -> Bool -> HsCmd id
HsCmdArrApp NoExtField
noExtField GenLocated SrcSpanAnnA (HsExpr GhcRn)
arrow' GenLocated SrcSpanAnnA (HsExpr GhcRn)
arg' HsArrAppType
ho Bool
rtl,
                 FreeVars
fvArrow FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fvArg) }
  where
    select_arrow_scope :: TcM (GenLocated SrcSpanAnnA (HsExpr GhcRn), FreeVars)
-> TcM (GenLocated SrcSpanAnnA (HsExpr GhcRn), FreeVars)
select_arrow_scope TcM (GenLocated SrcSpanAnnA (HsExpr GhcRn), FreeVars)
tc = case HsArrAppType
ho of
        HsArrAppType
HsHigherOrderApp -> TcM (GenLocated SrcSpanAnnA (HsExpr GhcRn), FreeVars)
tc
        HsArrAppType
HsFirstOrderApp  -> forall a. TcM a -> TcM a
escapeArrowScope TcM (GenLocated SrcSpanAnnA (HsExpr GhcRn), FreeVars)
tc
        -- See Note [Escaping the arrow scope] in GHC.Tc.Types
        -- Before renaming 'arrow', use the environment of the enclosing
        -- proc for the (-<) case.
        -- Local bindings, inside the enclosing proc, are not in scope
        -- inside 'arrow'.  In the higher-order case (-<<), they are.

-- infix form
rnCmd (HsCmdArrForm XCmdArrForm GhcPs
_ LHsExpr GhcPs
op LexicalFixity
_ (Just Fixity
_) [LHsCmdTop GhcPs
arg1, LHsCmdTop GhcPs
arg2])
  = do { (GenLocated SrcSpanAnnA (HsExpr GhcRn)
op',FreeVars
fv_op) <- forall a. TcM a -> TcM a
escapeArrowScope (LHsExpr GhcPs -> RnM (XRec GhcRn (HsExpr GhcRn), FreeVars)
rnLExpr LHsExpr GhcPs
op)
       ; let L SrcSpanAnnA
_ (HsVar XVar GhcRn
_ (L SrcSpanAnnN
_ Name
op_name)) = GenLocated SrcSpanAnnA (HsExpr GhcRn)
op'
       ; (GenLocated SrcSpan (HsCmdTop GhcRn)
arg1',FreeVars
fv_arg1) <- LHsCmdTop GhcPs -> RnM (LHsCmdTop GhcRn, FreeVars)
rnCmdTop LHsCmdTop GhcPs
arg1
       ; (GenLocated SrcSpan (HsCmdTop GhcRn)
arg2',FreeVars
fv_arg2) <- LHsCmdTop GhcPs -> RnM (LHsCmdTop GhcRn, FreeVars)
rnCmdTop LHsCmdTop GhcPs
arg2
        -- Deal with fixity
       ; Fixity
fixity <- Name -> IOEnv (Env TcGblEnv TcLclEnv) Fixity
lookupFixityRn Name
op_name
       ; HsCmd GhcRn
final_e <- LHsCmdTop GhcRn
-> XRec GhcRn (HsExpr GhcRn)
-> Fixity
-> LHsCmdTop GhcRn
-> RnM (HsCmd GhcRn)
mkOpFormRn GenLocated SrcSpan (HsCmdTop GhcRn)
arg1' GenLocated SrcSpanAnnA (HsExpr GhcRn)
op' Fixity
fixity GenLocated SrcSpan (HsCmdTop GhcRn)
arg2'
       ; forall (m :: * -> *) a. Monad m => a -> m a
return (HsCmd GhcRn
final_e, FreeVars
fv_arg1 FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fv_op FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fv_arg2) }

rnCmd (HsCmdArrForm XCmdArrForm GhcPs
_ LHsExpr GhcPs
op LexicalFixity
f Maybe Fixity
fixity [LHsCmdTop GhcPs]
cmds)
  = do { (GenLocated SrcSpanAnnA (HsExpr GhcRn)
op',FreeVars
fvOp) <- forall a. TcM a -> TcM a
escapeArrowScope (LHsExpr GhcPs -> RnM (XRec GhcRn (HsExpr GhcRn), FreeVars)
rnLExpr LHsExpr GhcPs
op)
       ; ([GenLocated SrcSpan (HsCmdTop GhcRn)]
cmds',FreeVars
fvCmds) <- [LHsCmdTop GhcPs] -> RnM ([LHsCmdTop GhcRn], FreeVars)
rnCmdArgs [LHsCmdTop GhcPs]
cmds
       ; forall (m :: * -> *) a. Monad m => a -> m a
return ( forall id.
XCmdArrForm id
-> LHsExpr id
-> LexicalFixity
-> Maybe Fixity
-> [LHsCmdTop id]
-> HsCmd id
HsCmdArrForm NoExtField
noExtField GenLocated SrcSpanAnnA (HsExpr GhcRn)
op' LexicalFixity
f Maybe Fixity
fixity [GenLocated SrcSpan (HsCmdTop GhcRn)]
cmds'
                , FreeVars
fvOp FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fvCmds) }

rnCmd (HsCmdApp XCmdApp GhcPs
x LHsCmd GhcPs
fun LHsExpr GhcPs
arg)
  = do { (GenLocated SrcSpanAnnA (HsCmd GhcRn)
fun',FreeVars
fvFun) <- LHsCmd GhcPs -> RnM (LHsCmd GhcRn, FreeVars)
rnLCmd  LHsCmd GhcPs
fun
       ; (GenLocated SrcSpanAnnA (HsExpr GhcRn)
arg',FreeVars
fvArg) <- LHsExpr GhcPs -> RnM (XRec GhcRn (HsExpr GhcRn), FreeVars)
rnLExpr LHsExpr GhcPs
arg
       ; forall (m :: * -> *) a. Monad m => a -> m a
return (forall id. XCmdApp id -> LHsCmd id -> LHsExpr id -> HsCmd id
HsCmdApp XCmdApp GhcPs
x GenLocated SrcSpanAnnA (HsCmd GhcRn)
fun' GenLocated SrcSpanAnnA (HsExpr GhcRn)
arg', FreeVars
fvFun FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fvArg) }

rnCmd (HsCmdLam XCmdLam GhcPs
_ MatchGroup GhcPs (LHsCmd GhcPs)
matches)
  = do { (MatchGroup GhcRn (GenLocated SrcSpanAnnA (HsCmd GhcRn))
matches', FreeVars
fvMatch) <- forall (body :: * -> *).
(Outputable (body GhcPs), AnnoBody body) =>
HsMatchContext GhcRn
-> (LocatedA (body GhcPs) -> RnM (LocatedA (body GhcRn), FreeVars))
-> MatchGroup GhcPs (LocatedA (body GhcPs))
-> RnM (MatchGroup GhcRn (LocatedA (body GhcRn)), FreeVars)
rnMatchGroup (forall p. HsArrowMatchContext -> HsMatchContext p
ArrowMatchCtxt HsArrowMatchContext
KappaExpr) LHsCmd GhcPs -> RnM (LHsCmd GhcRn, FreeVars)
rnLCmd MatchGroup GhcPs (LHsCmd GhcPs)
matches
       ; forall (m :: * -> *) a. Monad m => a -> m a
return (forall id. XCmdLam id -> MatchGroup id (LHsCmd id) -> HsCmd id
HsCmdLam NoExtField
noExtField MatchGroup GhcRn (GenLocated SrcSpanAnnA (HsCmd GhcRn))
matches', FreeVars
fvMatch) }

rnCmd (HsCmdPar XCmdPar GhcPs
x LHsCmd GhcPs
e)
  = do  { (GenLocated SrcSpanAnnA (HsCmd GhcRn)
e', FreeVars
fvs_e) <- LHsCmd GhcPs -> RnM (LHsCmd GhcRn, FreeVars)
rnLCmd LHsCmd GhcPs
e
        ; forall (m :: * -> *) a. Monad m => a -> m a
return (forall id. XCmdPar id -> LHsCmd id -> HsCmd id
HsCmdPar XCmdPar GhcPs
x GenLocated SrcSpanAnnA (HsCmd GhcRn)
e', FreeVars
fvs_e) }

rnCmd (HsCmdCase XCmdCase GhcPs
_ LHsExpr GhcPs
expr MatchGroup GhcPs (LHsCmd GhcPs)
matches)
  = do { (GenLocated SrcSpanAnnA (HsExpr GhcRn)
new_expr, FreeVars
e_fvs) <- LHsExpr GhcPs -> RnM (XRec GhcRn (HsExpr GhcRn), FreeVars)
rnLExpr LHsExpr GhcPs
expr
       ; (MatchGroup GhcRn (GenLocated SrcSpanAnnA (HsCmd GhcRn))
new_matches, FreeVars
ms_fvs) <- forall (body :: * -> *).
(Outputable (body GhcPs), AnnoBody body) =>
HsMatchContext GhcRn
-> (LocatedA (body GhcPs) -> RnM (LocatedA (body GhcRn), FreeVars))
-> MatchGroup GhcPs (LocatedA (body GhcPs))
-> RnM (MatchGroup GhcRn (LocatedA (body GhcRn)), FreeVars)
rnMatchGroup (forall p. HsArrowMatchContext -> HsMatchContext p
ArrowMatchCtxt HsArrowMatchContext
ArrowCaseAlt) LHsCmd GhcPs -> RnM (LHsCmd GhcRn, FreeVars)
rnLCmd MatchGroup GhcPs (LHsCmd GhcPs)
matches
       ; forall (m :: * -> *) a. Monad m => a -> m a
return (forall id.
XCmdCase id -> LHsExpr id -> MatchGroup id (LHsCmd id) -> HsCmd id
HsCmdCase NoExtField
noExtField GenLocated SrcSpanAnnA (HsExpr GhcRn)
new_expr MatchGroup GhcRn (GenLocated SrcSpanAnnA (HsCmd GhcRn))
new_matches
                , FreeVars
e_fvs FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
ms_fvs) }

rnCmd (HsCmdLamCase XCmdLamCase GhcPs
x MatchGroup GhcPs (LHsCmd GhcPs)
matches)
  = do { (MatchGroup GhcRn (GenLocated SrcSpanAnnA (HsCmd GhcRn))
new_matches, FreeVars
ms_fvs) <- forall (body :: * -> *).
(Outputable (body GhcPs), AnnoBody body) =>
HsMatchContext GhcRn
-> (LocatedA (body GhcPs) -> RnM (LocatedA (body GhcRn), FreeVars))
-> MatchGroup GhcPs (LocatedA (body GhcPs))
-> RnM (MatchGroup GhcRn (LocatedA (body GhcRn)), FreeVars)
rnMatchGroup (forall p. HsArrowMatchContext -> HsMatchContext p
ArrowMatchCtxt HsArrowMatchContext
ArrowCaseAlt) LHsCmd GhcPs -> RnM (LHsCmd GhcRn, FreeVars)
rnLCmd MatchGroup GhcPs (LHsCmd GhcPs)
matches
       ; forall (m :: * -> *) a. Monad m => a -> m a
return (forall id. XCmdLamCase id -> MatchGroup id (LHsCmd id) -> HsCmd id
HsCmdLamCase XCmdLamCase GhcPs
x MatchGroup GhcRn (GenLocated SrcSpanAnnA (HsCmd GhcRn))
new_matches, FreeVars
ms_fvs) }

rnCmd (HsCmdIf XCmdIf GhcPs
_ SyntaxExpr GhcPs
_ LHsExpr GhcPs
p LHsCmd GhcPs
b1 LHsCmd GhcPs
b2)
  = do { (GenLocated SrcSpanAnnA (HsExpr GhcRn)
p', FreeVars
fvP) <- LHsExpr GhcPs -> RnM (XRec GhcRn (HsExpr GhcRn), FreeVars)
rnLExpr LHsExpr GhcPs
p
       ; (GenLocated SrcSpanAnnA (HsCmd GhcRn)
b1', FreeVars
fvB1) <- LHsCmd GhcPs -> RnM (LHsCmd GhcRn, FreeVars)
rnLCmd LHsCmd GhcPs
b1
       ; (GenLocated SrcSpanAnnA (HsCmd GhcRn)
b2', FreeVars
fvB2) <- LHsCmd GhcPs -> RnM (LHsCmd GhcRn, FreeVars)
rnLCmd LHsCmd GhcPs
b2

       ; Maybe Name
mb_ite <- RnM (Maybe Name)
lookupIfThenElse
       ; let (SyntaxExprRn
ite, FreeVars
fvITE) = case Maybe Name
mb_ite of
                Just Name
ite_name -> (Name -> SyntaxExprRn
mkRnSyntaxExpr Name
ite_name, Name -> FreeVars
unitFV Name
ite_name)
                Maybe Name
Nothing       -> (SyntaxExprRn
NoSyntaxExprRn,          FreeVars
emptyFVs)

       ; forall (m :: * -> *) a. Monad m => a -> m a
return (forall id.
XCmdIf id
-> SyntaxExpr id
-> LHsExpr id
-> LHsCmd id
-> LHsCmd id
-> HsCmd id
HsCmdIf NoExtField
noExtField SyntaxExprRn
ite GenLocated SrcSpanAnnA (HsExpr GhcRn)
p' GenLocated SrcSpanAnnA (HsCmd GhcRn)
b1' GenLocated SrcSpanAnnA (HsCmd GhcRn)
b2', [FreeVars] -> FreeVars
plusFVs [FreeVars
fvITE, FreeVars
fvP, FreeVars
fvB1, FreeVars
fvB2])}

rnCmd (HsCmdLet XCmdLet GhcPs
_ HsLocalBinds GhcPs
binds LHsCmd GhcPs
cmd)
  = forall result.
HsLocalBinds GhcPs
-> (HsLocalBinds GhcRn -> FreeVars -> RnM (result, FreeVars))
-> RnM (result, FreeVars)
rnLocalBindsAndThen HsLocalBinds GhcPs
binds forall a b. (a -> b) -> a -> b
$ \ HsLocalBinds GhcRn
binds' FreeVars
_ -> do
      { (GenLocated SrcSpanAnnA (HsCmd GhcRn)
cmd',FreeVars
fvExpr) <- LHsCmd GhcPs -> RnM (LHsCmd GhcRn, FreeVars)
rnLCmd LHsCmd GhcPs
cmd
      ; forall (m :: * -> *) a. Monad m => a -> m a
return (forall id. XCmdLet id -> HsLocalBinds id -> LHsCmd id -> HsCmd id
HsCmdLet NoExtField
noExtField HsLocalBinds GhcRn
binds' GenLocated SrcSpanAnnA (HsCmd GhcRn)
cmd', FreeVars
fvExpr) }

rnCmd (HsCmdDo XCmdDo GhcPs
_ (L SrcSpanAnnL
l [GenLocated
   SrcSpanAnnA
   (StmtLR GhcPs GhcPs (GenLocated SrcSpanAnnA (HsCmd GhcPs)))]
stmts))
  = do  { (([GenLocated
   SrcSpanAnnA
   (StmtLR GhcRn GhcRn (GenLocated SrcSpanAnnA (HsCmd GhcRn)))]
stmts', ()
_), FreeVars
fvs) <-
            forall (body :: * -> *) thing.
AnnoBody body =>
HsStmtContext GhcRn
-> (body GhcPs -> RnM (body GhcRn, FreeVars))
-> [LStmt GhcPs (LocatedA (body GhcPs))]
-> ([Name] -> RnM (thing, FreeVars))
-> RnM (([LStmt GhcRn (LocatedA (body GhcRn))], thing), FreeVars)
rnStmts forall p. HsStmtContext p
ArrowExpr HsCmd GhcPs -> RnM (HsCmd GhcRn, FreeVars)
rnCmd [GenLocated
   SrcSpanAnnA
   (StmtLR GhcPs GhcPs (GenLocated SrcSpanAnnA (HsCmd GhcPs)))]
stmts (\ [Name]
_ -> forall (m :: * -> *) a. Monad m => a -> m a
return ((), FreeVars
emptyFVs))
        ; forall (m :: * -> *) a. Monad m => a -> m a
return ( forall id. XCmdDo id -> XRec id [CmdLStmt id] -> HsCmd id
HsCmdDo NoExtField
noExtField (forall l e. l -> e -> GenLocated l e
L SrcSpanAnnL
l [GenLocated
   SrcSpanAnnA
   (StmtLR GhcRn GhcRn (GenLocated SrcSpanAnnA (HsCmd GhcRn)))]
stmts'), FreeVars
fvs ) }

---------------------------------------------------
type CmdNeeds = FreeVars        -- Only inhabitants are
                                --      appAName, choiceAName, loopAName

-- find what methods the Cmd needs (loop, choice, apply)
methodNamesLCmd :: LHsCmd GhcRn -> CmdNeeds
methodNamesLCmd :: LHsCmd GhcRn -> FreeVars
methodNamesLCmd = HsCmd GhcRn -> FreeVars
methodNamesCmd forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall l e. GenLocated l e -> e
unLoc

methodNamesCmd :: HsCmd GhcRn -> CmdNeeds

methodNamesCmd :: HsCmd GhcRn -> FreeVars
methodNamesCmd (HsCmdArrApp XCmdArrApp GhcRn
_ XRec GhcRn (HsExpr GhcRn)
_arrow XRec GhcRn (HsExpr GhcRn)
_arg HsArrAppType
HsFirstOrderApp Bool
_rtl)
  = FreeVars
emptyFVs
methodNamesCmd (HsCmdArrApp XCmdArrApp GhcRn
_ XRec GhcRn (HsExpr GhcRn)
_arrow XRec GhcRn (HsExpr GhcRn)
_arg HsArrAppType
HsHigherOrderApp Bool
_rtl)
  = Name -> FreeVars
unitFV Name
appAName
methodNamesCmd (HsCmdArrForm {}) = FreeVars
emptyFVs

methodNamesCmd (HsCmdPar XCmdPar GhcRn
_ LHsCmd GhcRn
c) = LHsCmd GhcRn -> FreeVars
methodNamesLCmd LHsCmd GhcRn
c

methodNamesCmd (HsCmdIf XCmdIf GhcRn
_ SyntaxExpr GhcRn
_ XRec GhcRn (HsExpr GhcRn)
_ LHsCmd GhcRn
c1 LHsCmd GhcRn
c2)
  = LHsCmd GhcRn -> FreeVars
methodNamesLCmd LHsCmd GhcRn
c1 FreeVars -> FreeVars -> FreeVars
`plusFV` LHsCmd GhcRn -> FreeVars
methodNamesLCmd LHsCmd GhcRn
c2 FreeVars -> Name -> FreeVars
`addOneFV` Name
choiceAName

methodNamesCmd (HsCmdLet XCmdLet GhcRn
_ HsLocalBinds GhcRn
_ LHsCmd GhcRn
c)          = LHsCmd GhcRn -> FreeVars
methodNamesLCmd LHsCmd GhcRn
c
methodNamesCmd (HsCmdDo XCmdDo GhcRn
_ (L SrcSpanAnnL
_ [GenLocated
   SrcSpanAnnA
   (StmtLR GhcRn GhcRn (GenLocated SrcSpanAnnA (HsCmd GhcRn)))]
stmts))   = [CmdLStmt GhcRn] -> FreeVars
methodNamesStmts [GenLocated
   SrcSpanAnnA
   (StmtLR GhcRn GhcRn (GenLocated SrcSpanAnnA (HsCmd GhcRn)))]
stmts
methodNamesCmd (HsCmdApp XCmdApp GhcRn
_ LHsCmd GhcRn
c XRec GhcRn (HsExpr GhcRn)
_)          = LHsCmd GhcRn -> FreeVars
methodNamesLCmd LHsCmd GhcRn
c
methodNamesCmd (HsCmdLam XCmdLam GhcRn
_ MatchGroup GhcRn (LHsCmd GhcRn)
match)        = MatchGroup GhcRn (LHsCmd GhcRn) -> FreeVars
methodNamesMatch MatchGroup GhcRn (LHsCmd GhcRn)
match

methodNamesCmd (HsCmdCase XCmdCase GhcRn
_ XRec GhcRn (HsExpr GhcRn)
_ MatchGroup GhcRn (LHsCmd GhcRn)
matches)
  = MatchGroup GhcRn (LHsCmd GhcRn) -> FreeVars
methodNamesMatch MatchGroup GhcRn (LHsCmd GhcRn)
matches FreeVars -> Name -> FreeVars
`addOneFV` Name
choiceAName
methodNamesCmd (HsCmdLamCase XCmdLamCase GhcRn
_ MatchGroup GhcRn (LHsCmd GhcRn)
matches)
  = MatchGroup GhcRn (LHsCmd GhcRn) -> FreeVars
methodNamesMatch MatchGroup GhcRn (LHsCmd GhcRn)
matches FreeVars -> Name -> FreeVars
`addOneFV` Name
choiceAName

--methodNamesCmd _ = emptyFVs
   -- Other forms can't occur in commands, but it's not convenient
   -- to error here so we just do what's convenient.
   -- The type checker will complain later

---------------------------------------------------
methodNamesMatch :: MatchGroup GhcRn (LHsCmd GhcRn) -> FreeVars
methodNamesMatch :: MatchGroup GhcRn (LHsCmd GhcRn) -> FreeVars
methodNamesMatch (MG { mg_alts :: forall p body. MatchGroup p body -> XRec p [LMatch p body]
mg_alts = L SrcSpanAnnL
_ [GenLocated
   SrcSpanAnnA (Match GhcRn (GenLocated SrcSpanAnnA (HsCmd GhcRn)))]
ms })
  = [FreeVars] -> FreeVars
plusFVs (forall a b. (a -> b) -> [a] -> [b]
map forall {l}.
GenLocated l (Match GhcRn (GenLocated SrcSpanAnnA (HsCmd GhcRn)))
-> FreeVars
do_one [GenLocated
   SrcSpanAnnA (Match GhcRn (GenLocated SrcSpanAnnA (HsCmd GhcRn)))]
ms)
 where
    do_one :: GenLocated l (Match GhcRn (GenLocated SrcSpanAnnA (HsCmd GhcRn)))
-> FreeVars
do_one (L l
_ (Match { m_grhss :: forall p body. Match p body -> GRHSs p body
m_grhss = GRHSs GhcRn (GenLocated SrcSpanAnnA (HsCmd GhcRn))
grhss })) = GRHSs GhcRn (LHsCmd GhcRn) -> FreeVars
methodNamesGRHSs GRHSs GhcRn (GenLocated SrcSpanAnnA (HsCmd GhcRn))
grhss

-------------------------------------------------
-- gaw 2004
methodNamesGRHSs :: GRHSs GhcRn (LHsCmd GhcRn) -> FreeVars
methodNamesGRHSs :: GRHSs GhcRn (LHsCmd GhcRn) -> FreeVars
methodNamesGRHSs (GRHSs XCGRHSs GhcRn (LHsCmd GhcRn)
_ [LGRHS GhcRn (LHsCmd GhcRn)]
grhss HsLocalBinds GhcRn
_) = [FreeVars] -> FreeVars
plusFVs (forall a b. (a -> b) -> [a] -> [b]
map Located (GRHS GhcRn (LHsCmd GhcRn)) -> FreeVars
methodNamesGRHS [LGRHS GhcRn (LHsCmd GhcRn)]
grhss)

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

methodNamesGRHS :: Located (GRHS GhcRn (LHsCmd GhcRn)) -> CmdNeeds
methodNamesGRHS :: Located (GRHS GhcRn (LHsCmd GhcRn)) -> FreeVars
methodNamesGRHS (L SrcSpan
_ (GRHS XCGRHS GhcRn (LHsCmd GhcRn)
_ [ExprLStmt GhcRn]
_ LHsCmd GhcRn
rhs)) = LHsCmd GhcRn -> FreeVars
methodNamesLCmd LHsCmd GhcRn
rhs

---------------------------------------------------
methodNamesStmts :: [LStmtLR GhcRn GhcRn (LHsCmd GhcRn)] -> FreeVars
methodNamesStmts :: [CmdLStmt GhcRn] -> FreeVars
methodNamesStmts [CmdLStmt GhcRn]
stmts = [FreeVars] -> FreeVars
plusFVs (forall a b. (a -> b) -> [a] -> [b]
map CmdLStmt GhcRn -> FreeVars
methodNamesLStmt [CmdLStmt GhcRn]
stmts)

---------------------------------------------------
methodNamesLStmt :: LStmtLR GhcRn GhcRn (LHsCmd GhcRn) -> FreeVars
methodNamesLStmt :: CmdLStmt GhcRn -> FreeVars
methodNamesLStmt = StmtLR GhcRn GhcRn (LHsCmd GhcRn) -> FreeVars
methodNamesStmt forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall l e. GenLocated l e -> e
unLoc

methodNamesStmt :: StmtLR GhcRn GhcRn (LHsCmd GhcRn) -> FreeVars
methodNamesStmt :: StmtLR GhcRn GhcRn (LHsCmd GhcRn) -> FreeVars
methodNamesStmt (LastStmt XLastStmt GhcRn GhcRn (LHsCmd GhcRn)
_ LHsCmd GhcRn
cmd Maybe Bool
_ SyntaxExpr GhcRn
_)           = LHsCmd GhcRn -> FreeVars
methodNamesLCmd LHsCmd GhcRn
cmd
methodNamesStmt (BodyStmt XBodyStmt GhcRn GhcRn (LHsCmd GhcRn)
_ LHsCmd GhcRn
cmd SyntaxExpr GhcRn
_ SyntaxExpr GhcRn
_)           = LHsCmd GhcRn -> FreeVars
methodNamesLCmd LHsCmd GhcRn
cmd
methodNamesStmt (BindStmt XBindStmt GhcRn GhcRn (LHsCmd GhcRn)
_ LPat GhcRn
_ LHsCmd GhcRn
cmd)             = LHsCmd GhcRn -> FreeVars
methodNamesLCmd LHsCmd GhcRn
cmd
methodNamesStmt (RecStmt { recS_stmts :: forall idL idR body.
StmtLR idL idR body -> XRec idR [LStmtLR idL idR body]
recS_stmts = L SrcSpanAnnL
_ [GenLocated
   SrcSpanAnnA
   (StmtLR GhcRn GhcRn (GenLocated SrcSpanAnnA (HsCmd GhcRn)))]
stmts }) =
  [CmdLStmt GhcRn] -> FreeVars
methodNamesStmts [GenLocated
   SrcSpanAnnA
   (StmtLR GhcRn GhcRn (GenLocated SrcSpanAnnA (HsCmd GhcRn)))]
stmts FreeVars -> Name -> FreeVars
`addOneFV` Name
loopAName
methodNamesStmt (LetStmt {})                   = FreeVars
emptyFVs
methodNamesStmt (ParStmt {})                   = FreeVars
emptyFVs
methodNamesStmt (TransStmt {})                 = FreeVars
emptyFVs
methodNamesStmt ApplicativeStmt{}              = FreeVars
emptyFVs
   -- ParStmt and TransStmt can't occur in commands, but it's not
   -- convenient to error here so we just do what's convenient

{-
************************************************************************
*                                                                      *
        Arithmetic sequences
*                                                                      *
************************************************************************
-}

rnArithSeq :: ArithSeqInfo GhcPs -> RnM (ArithSeqInfo GhcRn, FreeVars)
rnArithSeq :: ArithSeqInfo GhcPs -> RnM (ArithSeqInfo GhcRn, FreeVars)
rnArithSeq (From LHsExpr GhcPs
expr)
 = do { (GenLocated SrcSpanAnnA (HsExpr GhcRn)
expr', FreeVars
fvExpr) <- LHsExpr GhcPs -> RnM (XRec GhcRn (HsExpr GhcRn), FreeVars)
rnLExpr LHsExpr GhcPs
expr
      ; forall (m :: * -> *) a. Monad m => a -> m a
return (forall id. LHsExpr id -> ArithSeqInfo id
From GenLocated SrcSpanAnnA (HsExpr GhcRn)
expr', FreeVars
fvExpr) }

rnArithSeq (FromThen LHsExpr GhcPs
expr1 LHsExpr GhcPs
expr2)
 = do { (GenLocated SrcSpanAnnA (HsExpr GhcRn)
expr1', FreeVars
fvExpr1) <- LHsExpr GhcPs -> RnM (XRec GhcRn (HsExpr GhcRn), FreeVars)
rnLExpr LHsExpr GhcPs
expr1
      ; (GenLocated SrcSpanAnnA (HsExpr GhcRn)
expr2', FreeVars
fvExpr2) <- LHsExpr GhcPs -> RnM (XRec GhcRn (HsExpr GhcRn), FreeVars)
rnLExpr LHsExpr GhcPs
expr2
      ; forall (m :: * -> *) a. Monad m => a -> m a
return (forall id. LHsExpr id -> LHsExpr id -> ArithSeqInfo id
FromThen GenLocated SrcSpanAnnA (HsExpr GhcRn)
expr1' GenLocated SrcSpanAnnA (HsExpr GhcRn)
expr2', FreeVars
fvExpr1 FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fvExpr2) }

rnArithSeq (FromTo LHsExpr GhcPs
expr1 LHsExpr GhcPs
expr2)
 = do { (GenLocated SrcSpanAnnA (HsExpr GhcRn)
expr1', FreeVars
fvExpr1) <- LHsExpr GhcPs -> RnM (XRec GhcRn (HsExpr GhcRn), FreeVars)
rnLExpr LHsExpr GhcPs
expr1
      ; (GenLocated SrcSpanAnnA (HsExpr GhcRn)
expr2', FreeVars
fvExpr2) <- LHsExpr GhcPs -> RnM (XRec GhcRn (HsExpr GhcRn), FreeVars)
rnLExpr LHsExpr GhcPs
expr2
      ; forall (m :: * -> *) a. Monad m => a -> m a
return (forall id. LHsExpr id -> LHsExpr id -> ArithSeqInfo id
FromTo GenLocated SrcSpanAnnA (HsExpr GhcRn)
expr1' GenLocated SrcSpanAnnA (HsExpr GhcRn)
expr2', FreeVars
fvExpr1 FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fvExpr2) }

rnArithSeq (FromThenTo LHsExpr GhcPs
expr1 LHsExpr GhcPs
expr2 LHsExpr GhcPs
expr3)
 = do { (GenLocated SrcSpanAnnA (HsExpr GhcRn)
expr1', FreeVars
fvExpr1) <- LHsExpr GhcPs -> RnM (XRec GhcRn (HsExpr GhcRn), FreeVars)
rnLExpr LHsExpr GhcPs
expr1
      ; (GenLocated SrcSpanAnnA (HsExpr GhcRn)
expr2', FreeVars
fvExpr2) <- LHsExpr GhcPs -> RnM (XRec GhcRn (HsExpr GhcRn), FreeVars)
rnLExpr LHsExpr GhcPs
expr2
      ; (GenLocated SrcSpanAnnA (HsExpr GhcRn)
expr3', FreeVars
fvExpr3) <- LHsExpr GhcPs -> RnM (XRec GhcRn (HsExpr GhcRn), FreeVars)
rnLExpr LHsExpr GhcPs
expr3
      ; forall (m :: * -> *) a. Monad m => a -> m a
return (forall id.
LHsExpr id -> LHsExpr id -> LHsExpr id -> ArithSeqInfo id
FromThenTo GenLocated SrcSpanAnnA (HsExpr GhcRn)
expr1' GenLocated SrcSpanAnnA (HsExpr GhcRn)
expr2' GenLocated SrcSpanAnnA (HsExpr GhcRn)
expr3',
                [FreeVars] -> FreeVars
plusFVs [FreeVars
fvExpr1, FreeVars
fvExpr2, FreeVars
fvExpr3]) }

{-
************************************************************************
*                                                                      *
\subsubsection{@Stmt@s: in @do@ expressions}
*                                                                      *
************************************************************************
-}

{-
Note [Deterministic ApplicativeDo and RecursiveDo desugaring]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Both ApplicativeDo and RecursiveDo need to create tuples not
present in the source text.

For ApplicativeDo we create:

  (a,b,c) <- (\c b a -> (a,b,c)) <$>

For RecursiveDo we create:

  mfix (\ ~(a,b,c) -> do ...; return (a',b',c'))

The order of the components in those tuples needs to be stable
across recompilations, otherwise they can get optimized differently
and we end up with incompatible binaries.
To get a stable order we use nameSetElemsStable.
See Note [Deterministic UniqFM] to learn more about nondeterminism.
-}

type AnnoBody body
  = ( Outputable (body GhcPs)
    , Anno (StmtLR GhcPs GhcPs (LocatedA (body GhcPs))) ~ SrcSpanAnnA
    , Anno (StmtLR GhcRn GhcPs (LocatedA (body GhcPs))) ~ SrcSpanAnnA
    , Anno (StmtLR GhcRn GhcRn (LocatedA (body GhcRn))) ~ SrcSpanAnnA
    )

-- | Rename some Stmts
rnStmts :: AnnoBody body
        => HsStmtContext GhcRn
        -> (body GhcPs -> RnM (body GhcRn, FreeVars))
           -- ^ How to rename the body of each statement (e.g. rnLExpr)
        -> [LStmt GhcPs (LocatedA (body GhcPs))]
           -- ^ Statements
        -> ([Name] -> RnM (thing, FreeVars))
           -- ^ if these statements scope over something, this renames it
           -- and returns the result.
        -> RnM (([LStmt GhcRn (LocatedA (body GhcRn))], thing), FreeVars)
rnStmts :: forall (body :: * -> *) thing.
AnnoBody body =>
HsStmtContext GhcRn
-> (body GhcPs -> RnM (body GhcRn, FreeVars))
-> [LStmt GhcPs (LocatedA (body GhcPs))]
-> ([Name] -> RnM (thing, FreeVars))
-> RnM (([LStmt GhcRn (LocatedA (body GhcRn))], thing), FreeVars)
rnStmts HsStmtContext GhcRn
ctxt body GhcPs -> RnM (body GhcRn, FreeVars)
rnBody = forall (body :: * -> *) thing.
AnnoBody body =>
HsStmtContext GhcRn
-> (body GhcPs -> RnM (body GhcRn, FreeVars))
-> (HsStmtContext GhcRn
    -> [(LStmt GhcRn (LocatedA (body GhcRn)), FreeVars)]
    -> RnM ([LStmt GhcRn (LocatedA (body GhcRn))], FreeVars))
-> [LStmt GhcPs (LocatedA (body GhcPs))]
-> ([Name] -> RnM (thing, FreeVars))
-> RnM (([LStmt GhcRn (LocatedA (body GhcRn))], thing), FreeVars)
rnStmtsWithPostProcessing HsStmtContext GhcRn
ctxt body GhcPs -> RnM (body GhcRn, FreeVars)
rnBody forall (body :: * -> *).
HsStmtContext GhcRn
-> [(LStmt GhcRn (LocatedA (body GhcRn)), FreeVars)]
-> RnM ([LStmt GhcRn (LocatedA (body GhcRn))], FreeVars)
noPostProcessStmts

-- | like 'rnStmts' but applies a post-processing step to the renamed Stmts
rnStmtsWithPostProcessing
        :: AnnoBody body
        => HsStmtContext GhcRn
        -> (body GhcPs -> RnM (body GhcRn, FreeVars))
           -- ^ How to rename the body of each statement (e.g. rnLExpr)
        -> (HsStmtContext GhcRn
              -> [(LStmt GhcRn (LocatedA (body GhcRn)), FreeVars)]
              -> RnM ([LStmt GhcRn (LocatedA (body GhcRn))], FreeVars))
           -- ^ postprocess the statements
        -> [LStmt GhcPs (LocatedA (body GhcPs))]
           -- ^ Statements
        -> ([Name] -> RnM (thing, FreeVars))
           -- ^ if these statements scope over something, this renames it
           -- and returns the result.
        -> RnM (([LStmt GhcRn (LocatedA (body GhcRn))], thing), FreeVars)
rnStmtsWithPostProcessing :: forall (body :: * -> *) thing.
AnnoBody body =>
HsStmtContext GhcRn
-> (body GhcPs -> RnM (body GhcRn, FreeVars))
-> (HsStmtContext GhcRn
    -> [(LStmt GhcRn (LocatedA (body GhcRn)), FreeVars)]
    -> RnM ([LStmt GhcRn (LocatedA (body GhcRn))], FreeVars))
-> [LStmt GhcPs (LocatedA (body GhcPs))]
-> ([Name] -> RnM (thing, FreeVars))
-> RnM (([LStmt GhcRn (LocatedA (body GhcRn))], thing), FreeVars)
rnStmtsWithPostProcessing HsStmtContext GhcRn
ctxt body GhcPs -> RnM (body GhcRn, FreeVars)
rnBody HsStmtContext GhcRn
-> [(LStmt GhcRn (LocatedA (body GhcRn)), FreeVars)]
-> RnM ([LStmt GhcRn (LocatedA (body GhcRn))], FreeVars)
ppStmts [LStmt GhcPs (LocatedA (body GhcPs))]
stmts [Name] -> RnM (thing, FreeVars)
thing_inside
 = do { (([(GenLocated
    SrcSpanAnnA (StmtLR GhcRn GhcRn (LocatedA (body GhcRn))),
  FreeVars)]
stmts', thing
thing), FreeVars
fvs) <-
          forall (body :: * -> *) thing.
AnnoBody body =>
HsStmtContext GhcRn
-> (body GhcPs -> RnM (body GhcRn, FreeVars))
-> [LStmt GhcPs (LocatedA (body GhcPs))]
-> ([Name] -> RnM (thing, FreeVars))
-> RnM
     (([(LStmt GhcRn (LocatedA (body GhcRn)), FreeVars)], thing),
      FreeVars)
rnStmtsWithFreeVars HsStmtContext GhcRn
ctxt body GhcPs -> RnM (body GhcRn, FreeVars)
rnBody [LStmt GhcPs (LocatedA (body GhcPs))]
stmts [Name] -> RnM (thing, FreeVars)
thing_inside
      ; ([GenLocated
   SrcSpanAnnA (StmtLR GhcRn GhcRn (LocatedA (body GhcRn)))]
pp_stmts, FreeVars
fvs') <- HsStmtContext GhcRn
-> [(LStmt GhcRn (LocatedA (body GhcRn)), FreeVars)]
-> RnM ([LStmt GhcRn (LocatedA (body GhcRn))], FreeVars)
ppStmts HsStmtContext GhcRn
ctxt [(GenLocated
    SrcSpanAnnA (StmtLR GhcRn GhcRn (LocatedA (body GhcRn))),
  FreeVars)]
stmts'
      ; forall (m :: * -> *) a. Monad m => a -> m a
return (([GenLocated
   SrcSpanAnnA (StmtLR GhcRn GhcRn (LocatedA (body GhcRn)))]
pp_stmts, thing
thing), FreeVars
fvs FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fvs')
      }

-- | maybe rearrange statements according to the ApplicativeDo transformation
postProcessStmtsForApplicativeDo
  :: HsStmtContext GhcRn
  -> [(ExprLStmt GhcRn, FreeVars)]
  -> RnM ([ExprLStmt GhcRn], FreeVars)
postProcessStmtsForApplicativeDo :: HsStmtContext GhcRn
-> [(ExprLStmt GhcRn, FreeVars)]
-> RnM ([ExprLStmt GhcRn], FreeVars)
postProcessStmtsForApplicativeDo HsStmtContext GhcRn
ctxt [(ExprLStmt GhcRn, FreeVars)]
stmts
  = do {
       -- rearrange the statements using ApplicativeStmt if
       -- -XApplicativeDo is on.  Also strip out the FreeVars attached
       -- to each Stmt body.
         Bool
ado_is_on <- forall gbl lcl. Extension -> TcRnIf gbl lcl Bool
xoptM Extension
LangExt.ApplicativeDo
       ; let is_do_expr :: Bool
is_do_expr | DoExpr{} <- HsStmtContext GhcRn
ctxt = Bool
True
                        | Bool
otherwise = Bool
False
       -- don't apply the transformation inside TH brackets, because
       -- GHC.HsToCore.Quote does not handle ApplicativeDo.
       ; Bool
in_th_bracket <- ThStage -> Bool
isBrackStage forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TcM ThStage
getStage
       ; if Bool
ado_is_on Bool -> Bool -> Bool
&& Bool
is_do_expr Bool -> Bool -> Bool
&& Bool -> Bool
not Bool
in_th_bracket
            then do { String -> SDoc -> IOEnv (Env TcGblEnv TcLclEnv) ()
traceRn String
"ppsfa" (forall a. Outputable a => a -> SDoc
ppr [(ExprLStmt GhcRn, FreeVars)]
stmts)
                    ; HsStmtContext GhcRn
-> [(ExprLStmt GhcRn, FreeVars)]
-> RnM ([ExprLStmt GhcRn], FreeVars)
rearrangeForApplicativeDo HsStmtContext GhcRn
ctxt [(ExprLStmt GhcRn, FreeVars)]
stmts }
            else forall (body :: * -> *).
HsStmtContext GhcRn
-> [(LStmt GhcRn (LocatedA (body GhcRn)), FreeVars)]
-> RnM ([LStmt GhcRn (LocatedA (body GhcRn))], FreeVars)
noPostProcessStmts HsStmtContext GhcRn
ctxt [(ExprLStmt GhcRn, FreeVars)]
stmts }

-- | strip the FreeVars annotations from statements
noPostProcessStmts
  :: HsStmtContext GhcRn
  -> [(LStmt GhcRn (LocatedA (body GhcRn)), FreeVars)]
  -> RnM ([LStmt GhcRn (LocatedA (body GhcRn))], FreeVars)
noPostProcessStmts :: forall (body :: * -> *).
HsStmtContext GhcRn
-> [(LStmt GhcRn (LocatedA (body GhcRn)), FreeVars)]
-> RnM ([LStmt GhcRn (LocatedA (body GhcRn))], FreeVars)
noPostProcessStmts HsStmtContext GhcRn
_ [(LStmt GhcRn (LocatedA (body GhcRn)), FreeVars)]
stmts = forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. (a -> b) -> [a] -> [b]
map forall a b. (a, b) -> a
fst [(LStmt GhcRn (LocatedA (body GhcRn)), FreeVars)]
stmts, FreeVars
emptyNameSet)


rnStmtsWithFreeVars :: AnnoBody body
        => HsStmtContext GhcRn
        -> ((body GhcPs) -> RnM ((body GhcRn), FreeVars))
        -> [LStmt GhcPs (LocatedA (body GhcPs))]
        -> ([Name] -> RnM (thing, FreeVars))
        -> RnM ( ([(LStmt GhcRn (LocatedA (body GhcRn)), FreeVars)], thing)
               , FreeVars)
-- Each Stmt body is annotated with its FreeVars, so that
-- we can rearrange statements for ApplicativeDo.
--
-- Variables bound by the Stmts, and mentioned in thing_inside,
-- do not appear in the result FreeVars

rnStmtsWithFreeVars :: forall (body :: * -> *) thing.
AnnoBody body =>
HsStmtContext GhcRn
-> (body GhcPs -> RnM (body GhcRn, FreeVars))
-> [LStmt GhcPs (LocatedA (body GhcPs))]
-> ([Name] -> RnM (thing, FreeVars))
-> RnM
     (([(LStmt GhcRn (LocatedA (body GhcRn)), FreeVars)], thing),
      FreeVars)
rnStmtsWithFreeVars HsStmtContext GhcRn
ctxt body GhcPs -> RnM (body GhcRn, FreeVars)
_ [] [Name] -> RnM (thing, FreeVars)
thing_inside
  = do { HsStmtContext GhcRn -> IOEnv (Env TcGblEnv TcLclEnv) ()
checkEmptyStmts HsStmtContext GhcRn
ctxt
       ; (thing
thing, FreeVars
fvs) <- [Name] -> RnM (thing, FreeVars)
thing_inside []
       ; forall (m :: * -> *) a. Monad m => a -> m a
return (([], thing
thing), FreeVars
fvs) }

rnStmtsWithFreeVars mDoExpr :: HsStmtContext GhcRn
mDoExpr@MDoExpr{} body GhcPs -> RnM (body GhcRn, FreeVars)
rnBody [LStmt GhcPs (LocatedA (body GhcPs))]
stmts [Name] -> RnM (thing, FreeVars)
thing_inside    -- Deal with mdo
  = -- Behave like do { rec { ...all but last... }; last }
    do { (([(GenLocated
    SrcSpanAnnA (StmtLR GhcRn GhcRn (LocatedA (body GhcRn))),
  FreeVars)]
stmts1, ([(GenLocated
    SrcSpanAnnA (StmtLR GhcRn GhcRn (LocatedA (body GhcRn))),
  FreeVars)]
stmts2, thing
thing)), FreeVars
fvs)
           <- forall (body :: * -> *) thing.
AnnoBody body =>
HsStmtContext GhcRn
-> (body GhcPs -> RnM (body GhcRn, FreeVars))
-> LStmt GhcPs (LocatedA (body GhcPs))
-> ([Name] -> RnM (thing, FreeVars))
-> RnM
     (([(LStmt GhcRn (LocatedA (body GhcRn)), FreeVars)], thing),
      FreeVars)
rnStmt HsStmtContext GhcRn
mDoExpr body GhcPs -> RnM (body GhcRn, FreeVars)
rnBody (forall a an. a -> LocatedAn an a
noLocA forall a b. (a -> b) -> a -> b
$ forall (idL :: Pass) bodyR.
(Anno
   [GenLocated
      (Anno (StmtLR (GhcPass idL) GhcPs bodyR))
      (StmtLR (GhcPass idL) GhcPs bodyR)]
 ~ SrcSpanAnnL) =>
EpAnn AnnList
-> LocatedL [LStmtLR (GhcPass idL) GhcPs bodyR]
-> StmtLR (GhcPass idL) GhcPs bodyR
mkRecStmt forall a. EpAnn a
noAnn (forall a an. a -> LocatedAn an a
noLocA [LocatedAn
   AnnListItem (StmtLR GhcPs GhcPs (LocatedA (body GhcPs)))]
all_but_last)) forall a b. (a -> b) -> a -> b
$ \ [Name]
_ ->
              do { GenLocated
  (Anno (StmtLR GhcPs GhcPs (LocatedA (body GhcPs))))
  (StmtLR GhcPs GhcPs (LocatedA (body GhcPs)))
last_stmt' <- forall (body :: * -> *).
AnnoBody body =>
HsStmtContext GhcRn
-> LStmt GhcPs (LocatedA (body GhcPs))
-> RnM (LStmt GhcPs (LocatedA (body GhcPs)))
checkLastStmt HsStmtContext GhcRn
mDoExpr LocatedAn AnnListItem (StmtLR GhcPs GhcPs (LocatedA (body GhcPs)))
last_stmt
                 ; forall (body :: * -> *) thing.
AnnoBody body =>
HsStmtContext GhcRn
-> (body GhcPs -> RnM (body GhcRn, FreeVars))
-> LStmt GhcPs (LocatedA (body GhcPs))
-> ([Name] -> RnM (thing, FreeVars))
-> RnM
     (([(LStmt GhcRn (LocatedA (body GhcRn)), FreeVars)], thing),
      FreeVars)
rnStmt HsStmtContext GhcRn
mDoExpr body GhcPs -> RnM (body GhcRn, FreeVars)
rnBody GenLocated
  (Anno (StmtLR GhcPs GhcPs (LocatedA (body GhcPs))))
  (StmtLR GhcPs GhcPs (LocatedA (body GhcPs)))
last_stmt' [Name] -> RnM (thing, FreeVars)
thing_inside }
        ; forall (m :: * -> *) a. Monad m => a -> m a
return ((([(GenLocated
    SrcSpanAnnA (StmtLR GhcRn GhcRn (LocatedA (body GhcRn))),
  FreeVars)]
stmts1 forall a. [a] -> [a] -> [a]
++ [(GenLocated
    SrcSpanAnnA (StmtLR GhcRn GhcRn (LocatedA (body GhcRn))),
  FreeVars)]
stmts2), thing
thing), FreeVars
fvs) }
  where
    Just ([LocatedAn
   AnnListItem (StmtLR GhcPs GhcPs (LocatedA (body GhcPs)))]
all_but_last, LocatedAn AnnListItem (StmtLR GhcPs GhcPs (LocatedA (body GhcPs)))
last_stmt) = forall a. [a] -> Maybe ([a], a)
snocView [LStmt GhcPs (LocatedA (body GhcPs))]
stmts

rnStmtsWithFreeVars HsStmtContext GhcRn
ctxt body GhcPs -> RnM (body GhcRn, FreeVars)
rnBody (lstmt :: LStmt GhcPs (LocatedA (body GhcPs))
lstmt@(L SrcSpanAnnA
loc StmtLR GhcPs GhcPs (LocatedA (body GhcPs))
_) : [LStmt GhcPs (LocatedA (body GhcPs))]
lstmts) [Name] -> RnM (thing, FreeVars)
thing_inside
  | forall (t :: * -> *) a. Foldable t => t a -> Bool
null [LStmt GhcPs (LocatedA (body GhcPs))]
lstmts
  = forall ann a. SrcSpanAnn' ann -> TcRn a -> TcRn a
setSrcSpanA SrcSpanAnnA
loc forall a b. (a -> b) -> a -> b
$
    do { GenLocated
  (Anno (StmtLR GhcPs GhcPs (LocatedA (body GhcPs))))
  (StmtLR GhcPs GhcPs (LocatedA (body GhcPs)))
lstmt' <- forall (body :: * -> *).
AnnoBody body =>
HsStmtContext GhcRn
-> LStmt GhcPs (LocatedA (body GhcPs))
-> RnM (LStmt GhcPs (LocatedA (body GhcPs)))
checkLastStmt HsStmtContext GhcRn
ctxt LStmt GhcPs (LocatedA (body GhcPs))
lstmt
       ; forall (body :: * -> *) thing.
AnnoBody body =>
HsStmtContext GhcRn
-> (body GhcPs -> RnM (body GhcRn, FreeVars))
-> LStmt GhcPs (LocatedA (body GhcPs))
-> ([Name] -> RnM (thing, FreeVars))
-> RnM
     (([(LStmt GhcRn (LocatedA (body GhcRn)), FreeVars)], thing),
      FreeVars)
rnStmt HsStmtContext GhcRn
ctxt body GhcPs -> RnM (body GhcRn, FreeVars)
rnBody GenLocated
  (Anno (StmtLR GhcPs GhcPs (LocatedA (body GhcPs))))
  (StmtLR GhcPs GhcPs (LocatedA (body GhcPs)))
lstmt' [Name] -> RnM (thing, FreeVars)
thing_inside }

  | Bool
otherwise
  = do { (([(GenLocated
    SrcSpanAnnA (StmtLR GhcRn GhcRn (LocatedA (body GhcRn))),
  FreeVars)]
stmts1, ([(GenLocated
    SrcSpanAnnA (StmtLR GhcRn GhcRn (LocatedA (body GhcRn))),
  FreeVars)]
stmts2, thing
thing)), FreeVars
fvs)
            <- forall ann a. SrcSpanAnn' ann -> TcRn a -> TcRn a
setSrcSpanA SrcSpanAnnA
loc                  forall a b. (a -> b) -> a -> b
$
               do { forall (body :: * -> *).
HsStmtContext GhcRn
-> LStmt GhcPs (LocatedA (body GhcPs))
-> IOEnv (Env TcGblEnv TcLclEnv) ()
checkStmt HsStmtContext GhcRn
ctxt LStmt GhcPs (LocatedA (body GhcPs))
lstmt
                  ; forall (body :: * -> *) thing.
AnnoBody body =>
HsStmtContext GhcRn
-> (body GhcPs -> RnM (body GhcRn, FreeVars))
-> LStmt GhcPs (LocatedA (body GhcPs))
-> ([Name] -> RnM (thing, FreeVars))
-> RnM
     (([(LStmt GhcRn (LocatedA (body GhcRn)), FreeVars)], thing),
      FreeVars)
rnStmt HsStmtContext GhcRn
ctxt body GhcPs -> RnM (body GhcRn, FreeVars)
rnBody LStmt GhcPs (LocatedA (body GhcPs))
lstmt    forall a b. (a -> b) -> a -> b
$ \ [Name]
bndrs1 ->
                    forall (body :: * -> *) thing.
AnnoBody body =>
HsStmtContext GhcRn
-> (body GhcPs -> RnM (body GhcRn, FreeVars))
-> [LStmt GhcPs (LocatedA (body GhcPs))]
-> ([Name] -> RnM (thing, FreeVars))
-> RnM
     (([(LStmt GhcRn (LocatedA (body GhcRn)), FreeVars)], thing),
      FreeVars)
rnStmtsWithFreeVars HsStmtContext GhcRn
ctxt body GhcPs -> RnM (body GhcRn, FreeVars)
rnBody [LStmt GhcPs (LocatedA (body GhcPs))]
lstmts  forall a b. (a -> b) -> a -> b
$ \ [Name]
bndrs2 ->
                    [Name] -> RnM (thing, FreeVars)
thing_inside ([Name]
bndrs1 forall a. [a] -> [a] -> [a]
++ [Name]
bndrs2) }
        ; forall (m :: * -> *) a. Monad m => a -> m a
return ((([(GenLocated
    SrcSpanAnnA (StmtLR GhcRn GhcRn (LocatedA (body GhcRn))),
  FreeVars)]
stmts1 forall a. [a] -> [a] -> [a]
++ [(GenLocated
    SrcSpanAnnA (StmtLR GhcRn GhcRn (LocatedA (body GhcRn))),
  FreeVars)]
stmts2), thing
thing), FreeVars
fvs) }

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

{-
Note [Failing pattern matches in Stmts]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Many things desugar to HsStmts including monadic things like `do` and `mdo`
statements, pattern guards, and list comprehensions (see 'HsStmtContext' for an
exhaustive list). How we deal with pattern match failure is context-dependent.

 * In the case of list comprehensions and pattern guards we don't need any
   'fail' function; the desugarer ignores the fail function of 'BindStmt'
   entirely. So, for list comprehensions, the fail function is set to 'Nothing'
   for clarity.

* In the case of monadic contexts (e.g. monad comprehensions, do, and mdo
   expressions) we want pattern match failure to be desugared to the
   'fail' function (from MonadFail type class).

At one point we failed to make this distinction, leading to #11216.
-}

rnStmt :: AnnoBody body
       => HsStmtContext GhcRn
       -> (body GhcPs -> RnM (body GhcRn, FreeVars))
          -- ^ How to rename the body of the statement
       -> LStmt GhcPs (LocatedA (body GhcPs))
          -- ^ The statement
       -> ([Name] -> RnM (thing, FreeVars))
          -- ^ Rename the stuff that this statement scopes over
       -> RnM ( ([(LStmt GhcRn (LocatedA (body GhcRn)), FreeVars)], thing)
              , FreeVars)
-- Variables bound by the Stmt, and mentioned in thing_inside,
-- do not appear in the result FreeVars

rnStmt :: forall (body :: * -> *) thing.
AnnoBody body =>
HsStmtContext GhcRn
-> (body GhcPs -> RnM (body GhcRn, FreeVars))
-> LStmt GhcPs (LocatedA (body GhcPs))
-> ([Name] -> RnM (thing, FreeVars))
-> RnM
     (([(LStmt GhcRn (LocatedA (body GhcRn)), FreeVars)], thing),
      FreeVars)
rnStmt HsStmtContext GhcRn
ctxt body GhcPs -> RnM (body GhcRn, FreeVars)
rnBody (L SrcSpanAnnA
loc (LastStmt XLastStmt GhcPs GhcPs (LocatedA (body GhcPs))
_ (L SrcSpanAnnA
lb body GhcPs
body) Maybe Bool
noret SyntaxExpr GhcPs
_)) [Name] -> RnM (thing, FreeVars)
thing_inside
  = do  { (body GhcRn
body', FreeVars
fv_expr) <- body GhcPs -> RnM (body GhcRn, FreeVars)
rnBody body GhcPs
body
        ; (SyntaxExprRn
ret_op, FreeVars
fvs1) <- if forall id. HsStmtContext id -> Bool
isMonadCompContext HsStmtContext GhcRn
ctxt
                            then HsStmtContext GhcRn -> Name -> RnM (SyntaxExpr GhcRn, FreeVars)
lookupStmtName HsStmtContext GhcRn
ctxt Name
returnMName
                            else forall (m :: * -> *) a. Monad m => a -> m a
return (forall (p :: Pass). IsPass p => SyntaxExpr (GhcPass p)
noSyntaxExpr, FreeVars
emptyFVs)
                            -- The 'return' in a LastStmt is used only
                            -- for MonadComp; and we don't want to report
                            -- "non in scope: return" in other cases
                            -- #15607

        ; (thing
thing,  FreeVars
fvs3) <- [Name] -> RnM (thing, FreeVars)
thing_inside []
        ; forall (m :: * -> *) a. Monad m => a -> m a
return (([(forall l e. l -> e -> GenLocated l e
L SrcSpanAnnA
loc (forall idL idR body.
XLastStmt idL idR body
-> body -> Maybe Bool -> SyntaxExpr idR -> StmtLR idL idR body
LastStmt NoExtField
noExtField (forall l e. l -> e -> GenLocated l e
L SrcSpanAnnA
lb body GhcRn
body') Maybe Bool
noret SyntaxExprRn
ret_op), FreeVars
fv_expr)]
                  , thing
thing), FreeVars
fv_expr FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fvs1 FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fvs3) }

rnStmt HsStmtContext GhcRn
ctxt body GhcPs -> RnM (body GhcRn, FreeVars)
rnBody (L SrcSpanAnnA
loc (BodyStmt XBodyStmt GhcPs GhcPs (LocatedA (body GhcPs))
_ (L SrcSpanAnnA
lb body GhcPs
body) SyntaxExpr GhcPs
_ SyntaxExpr GhcPs
_)) [Name] -> RnM (thing, FreeVars)
thing_inside
  = do  { (body GhcRn
body', FreeVars
fv_expr) <- body GhcPs -> RnM (body GhcRn, FreeVars)
rnBody body GhcPs
body
        ; (SyntaxExprRn
then_op, FreeVars
fvs1)  <- HsStmtContext GhcRn -> Name -> RnM (SyntaxExpr GhcRn, FreeVars)
lookupQualifiedDoStmtName HsStmtContext GhcRn
ctxt Name
thenMName

        ; (SyntaxExprRn
guard_op, FreeVars
fvs2) <- if forall id. HsStmtContext id -> Bool
isComprehensionContext HsStmtContext GhcRn
ctxt
                              then HsStmtContext GhcRn -> Name -> RnM (SyntaxExpr GhcRn, FreeVars)
lookupStmtName HsStmtContext GhcRn
ctxt Name
guardMName
                              else forall (m :: * -> *) a. Monad m => a -> m a
return (forall (p :: Pass). IsPass p => SyntaxExpr (GhcPass p)
noSyntaxExpr, FreeVars
emptyFVs)
                              -- Only list/monad comprehensions use 'guard'
                              -- Also for sub-stmts of same eg [ e | x<-xs, gd | blah ]
                              -- Here "gd" is a guard

        ; (thing
thing, FreeVars
fvs3)    <- [Name] -> RnM (thing, FreeVars)
thing_inside []
        ; forall (m :: * -> *) a. Monad m => a -> m a
return ( ([(forall l e. l -> e -> GenLocated l e
L SrcSpanAnnA
loc (forall idL idR body.
XBodyStmt idL idR body
-> body -> SyntaxExpr idR -> SyntaxExpr idR -> StmtLR idL idR body
BodyStmt NoExtField
noExtField (forall l e. l -> e -> GenLocated l e
L SrcSpanAnnA
lb body GhcRn
body') SyntaxExprRn
then_op SyntaxExprRn
guard_op), FreeVars
fv_expr)]
                  , thing
thing), FreeVars
fv_expr FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fvs1 FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fvs2 FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fvs3) }

rnStmt HsStmtContext GhcRn
ctxt body GhcPs -> RnM (body GhcRn, FreeVars)
rnBody (L SrcSpanAnnA
loc (BindStmt XBindStmt GhcPs GhcPs (LocatedA (body GhcPs))
_ LPat GhcPs
pat (L SrcSpanAnnA
lb body GhcPs
body))) [Name] -> RnM (thing, FreeVars)
thing_inside
  = do  { (body GhcRn
body', FreeVars
fv_expr) <- body GhcPs -> RnM (body GhcRn, FreeVars)
rnBody body GhcPs
body
                -- The binders do not scope over the expression
        ; (SyntaxExprRn
bind_op, FreeVars
fvs1) <- HsStmtContext GhcRn -> Name -> RnM (SyntaxExpr GhcRn, FreeVars)
lookupQualifiedDoStmtName HsStmtContext GhcRn
ctxt Name
bindMName

        ; (Maybe SyntaxExprRn
fail_op, FreeVars
fvs2) <- LPat GhcPs
-> HsStmtContext GhcRn -> RnM (FailOperator GhcRn, FreeVars)
monadFailOp LPat GhcPs
pat HsStmtContext GhcRn
ctxt

        ; forall a.
HsMatchContext GhcRn
-> LPat GhcPs
-> (LPat GhcRn -> RnM (a, FreeVars))
-> RnM (a, FreeVars)
rnPat (forall p. HsStmtContext p -> HsMatchContext p
StmtCtxt HsStmtContext GhcRn
ctxt) LPat GhcPs
pat forall a b. (a -> b) -> a -> b
$ \ LPat GhcRn
pat' -> do
        { (thing
thing, FreeVars
fvs3) <- [Name] -> RnM (thing, FreeVars)
thing_inside (forall p. CollectPass p => CollectFlag p -> LPat p -> [IdP p]
collectPatBinders forall p. CollectFlag p
CollNoDictBinders LPat GhcRn
pat')
        ; let xbsrn :: XBindStmtRn
xbsrn = XBindStmtRn { xbsrn_bindOp :: SyntaxExpr GhcRn
xbsrn_bindOp = SyntaxExprRn
bind_op, xbsrn_failOp :: FailOperator GhcRn
xbsrn_failOp = Maybe SyntaxExprRn
fail_op }
        ; forall (m :: * -> *) a. Monad m => a -> m a
return (( [( forall l e. l -> e -> GenLocated l e
L SrcSpanAnnA
loc (forall idL idR body.
XBindStmt idL idR body -> LPat idL -> body -> StmtLR idL idR body
BindStmt XBindStmtRn
xbsrn LPat GhcRn
pat' (forall l e. l -> e -> GenLocated l e
L SrcSpanAnnA
lb body GhcRn
body')), FreeVars
fv_expr )]
                  , thing
thing),
                  FreeVars
fv_expr FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fvs1 FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fvs2 FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fvs3) }}
       -- fv_expr shouldn't really be filtered by the rnPatsAndThen
        -- but it does not matter because the names are unique

rnStmt HsStmtContext GhcRn
_ body GhcPs -> RnM (body GhcRn, FreeVars)
_ (L SrcSpanAnnA
loc (LetStmt XLetStmt GhcPs GhcPs (LocatedA (body GhcPs))
_ HsLocalBinds GhcPs
binds)) [Name] -> RnM (thing, FreeVars)
thing_inside
  =     forall result.
HsLocalBinds GhcPs
-> (HsLocalBinds GhcRn -> FreeVars -> RnM (result, FreeVars))
-> RnM (result, FreeVars)
rnLocalBindsAndThen HsLocalBinds GhcPs
binds forall a b. (a -> b) -> a -> b
$ \HsLocalBinds GhcRn
binds' FreeVars
bind_fvs -> do
        { (thing
thing, FreeVars
fvs) <- [Name] -> RnM (thing, FreeVars)
thing_inside (forall (idL :: Pass) (idR :: Pass).
CollectPass (GhcPass idL) =>
CollectFlag (GhcPass idL)
-> HsLocalBindsLR (GhcPass idL) (GhcPass idR)
-> [IdP (GhcPass idL)]
collectLocalBinders forall p. CollectFlag p
CollNoDictBinders HsLocalBinds GhcRn
binds')
        ; forall (m :: * -> *) a. Monad m => a -> m a
return ( ([(forall l e. l -> e -> GenLocated l e
L SrcSpanAnnA
loc (forall idL idR body.
XLetStmt idL idR body
-> HsLocalBindsLR idL idR -> StmtLR idL idR body
LetStmt forall a. EpAnn a
noAnn HsLocalBinds GhcRn
binds'), FreeVars
bind_fvs)], thing
thing)
                 , FreeVars
fvs) }

rnStmt HsStmtContext GhcRn
ctxt body GhcPs -> RnM (body GhcRn, FreeVars)
rnBody (L SrcSpanAnnA
loc (RecStmt { recS_stmts :: forall idL idR body.
StmtLR idL idR body -> XRec idR [LStmtLR idL idR body]
recS_stmts = L SrcSpanAnnL
_ [GenLocated
   SrcSpanAnnA (StmtLR GhcPs GhcPs (LocatedA (body GhcPs)))]
rec_stmts })) [Name] -> RnM (thing, FreeVars)
thing_inside
  = do  { (SyntaxExprRn
return_op, FreeVars
fvs1)  <- HsStmtContext GhcRn -> Name -> RnM (SyntaxExpr GhcRn, FreeVars)
lookupQualifiedDoStmtName HsStmtContext GhcRn
ctxt Name
returnMName
        ; (SyntaxExprRn
mfix_op,   FreeVars
fvs2)  <- HsStmtContext GhcRn -> Name -> RnM (SyntaxExpr GhcRn, FreeVars)
lookupQualifiedDoStmtName HsStmtContext GhcRn
ctxt Name
mfixName
        ; (SyntaxExprRn
bind_op,   FreeVars
fvs3)  <- HsStmtContext GhcRn -> Name -> RnM (SyntaxExpr GhcRn, FreeVars)
lookupQualifiedDoStmtName HsStmtContext GhcRn
ctxt Name
bindMName
        ; let empty_rec_stmt :: StmtLR GhcRn GhcRn (LocatedA (body GhcRn))
empty_rec_stmt = forall bodyR.
(Anno
   [GenLocated
      (Anno (StmtLR GhcRn GhcRn bodyR)) (StmtLR GhcRn GhcRn bodyR)]
 ~ SrcSpanAnnL) =>
StmtLR GhcRn GhcRn bodyR
emptyRecStmtName { recS_ret_fn :: SyntaxExpr GhcRn
recS_ret_fn  = SyntaxExprRn
return_op
                                                , recS_mfix_fn :: SyntaxExpr GhcRn
recS_mfix_fn = SyntaxExprRn
mfix_op
                                                , recS_bind_fn :: SyntaxExpr GhcRn
recS_bind_fn = SyntaxExprRn
bind_op }

        -- Step1: Bring all the binders of the mdo into scope
        -- (Remember that this also removes the binders from the
        -- finally-returned free-vars.)
        -- And rename each individual stmt, making a
        -- singleton segment.  At this stage the FwdRefs field
        -- isn't finished: it's empty for all except a BindStmt
        -- for which it's the fwd refs within the bind itself
        -- (This set may not be empty, because we're in a recursive
        -- context.)
        ; forall (body :: * -> *) a.
AnnoBody body =>
HsStmtContext GhcRn
-> (body GhcPs -> RnM (body GhcRn, FreeVars))
-> [LStmt GhcPs (LocatedA (body GhcPs))]
-> ([Segment (LStmt GhcRn (LocatedA (body GhcRn)))]
    -> RnM (a, FreeVars))
-> RnM (a, FreeVars)
rnRecStmtsAndThen HsStmtContext GhcRn
ctxt body GhcPs -> RnM (body GhcRn, FreeVars)
rnBody [GenLocated
   SrcSpanAnnA (StmtLR GhcPs GhcPs (LocatedA (body GhcPs)))]
rec_stmts   forall a b. (a -> b) -> a -> b
$ \ [Segment (LStmt GhcRn (LocatedA (body GhcRn)))]
segs -> do
        { let bndrs :: [Name]
bndrs = FreeVars -> [Name]
nameSetElemsStable forall a b. (a -> b) -> a -> b
$
                        forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (FreeVars -> FreeVars -> FreeVars
unionNameSet forall b c a. (b -> c) -> (a -> b) -> a -> c
. (\(FreeVars
ds,FreeVars
_,FreeVars
_,GenLocated SrcSpanAnnA (StmtLR GhcRn GhcRn (LocatedA (body GhcRn)))
_) -> FreeVars
ds))
                              FreeVars
emptyNameSet
                              [Segment (LStmt GhcRn (LocatedA (body GhcRn)))]
segs
          -- See Note [Deterministic ApplicativeDo and RecursiveDo desugaring]
        ; (thing
thing, FreeVars
fvs_later) <- [Name] -> RnM (thing, FreeVars)
thing_inside [Name]
bndrs
        ; let ([LStmt GhcRn (LocatedA (body GhcRn))]
rec_stmts', FreeVars
fvs) = forall (body :: * -> *).
AnnoBody body =>
SrcSpan
-> HsStmtContext GhcRn
-> Stmt GhcRn (LocatedA (body GhcRn))
-> [Segment (LStmt GhcRn (LocatedA (body GhcRn)))]
-> FreeVars
-> ([LStmt GhcRn (LocatedA (body GhcRn))], FreeVars)
segmentRecStmts (forall a. SrcSpanAnn' a -> SrcSpan
locA SrcSpanAnnA
loc) HsStmtContext GhcRn
ctxt StmtLR GhcRn GhcRn (LocatedA (body GhcRn))
empty_rec_stmt [Segment (LStmt GhcRn (LocatedA (body GhcRn)))]
segs FreeVars
fvs_later
        -- We aren't going to try to group RecStmts with
        -- ApplicativeDo, so attaching empty FVs is fine.
        ; forall (m :: * -> *) a. Monad m => a -> m a
return ( ((forall a b. [a] -> [b] -> [(a, b)]
zip [LStmt GhcRn (LocatedA (body GhcRn))]
rec_stmts' (forall a. a -> [a]
repeat FreeVars
emptyNameSet)), thing
thing)
                 , FreeVars
fvs FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fvs1 FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fvs2 FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fvs3) } }

rnStmt HsStmtContext GhcRn
ctxt body GhcPs -> RnM (body GhcRn, FreeVars)
_ (L SrcSpanAnnA
loc (ParStmt XParStmt GhcPs GhcPs (LocatedA (body GhcPs))
_ [ParStmtBlock GhcPs GhcPs]
segs HsExpr GhcPs
_ SyntaxExpr GhcPs
_)) [Name] -> RnM (thing, FreeVars)
thing_inside
  = do  { (HsExpr GhcRn
mzip_op, FreeVars
fvs1)   <- HsStmtContext GhcRn -> Name -> RnM (HsExpr GhcRn, FreeVars)
lookupStmtNamePoly HsStmtContext GhcRn
ctxt Name
mzipName
        ; (SyntaxExprRn
bind_op, FreeVars
fvs2)   <- HsStmtContext GhcRn -> Name -> RnM (SyntaxExpr GhcRn, FreeVars)
lookupStmtName HsStmtContext GhcRn
ctxt Name
bindMName
        ; (SyntaxExprRn
return_op, FreeVars
fvs3) <- HsStmtContext GhcRn -> Name -> RnM (SyntaxExpr GhcRn, FreeVars)
lookupStmtName HsStmtContext GhcRn
ctxt Name
returnMName
        ; (([ParStmtBlock GhcRn GhcRn]
segs', thing
thing), FreeVars
fvs4) <- forall thing.
HsStmtContext GhcRn
-> SyntaxExpr GhcRn
-> [ParStmtBlock GhcPs GhcPs]
-> ([Name] -> RnM (thing, FreeVars))
-> RnM (([ParStmtBlock GhcRn GhcRn], thing), FreeVars)
rnParallelStmts (forall p. HsStmtContext p -> HsStmtContext p
ParStmtCtxt HsStmtContext GhcRn
ctxt) SyntaxExprRn
return_op [ParStmtBlock GhcPs GhcPs]
segs [Name] -> RnM (thing, FreeVars)
thing_inside
        ; forall (m :: * -> *) a. Monad m => a -> m a
return (([(forall l e. l -> e -> GenLocated l e
L SrcSpanAnnA
loc (forall idL idR body.
XParStmt idL idR body
-> [ParStmtBlock idL idR]
-> HsExpr idR
-> SyntaxExpr idR
-> StmtLR idL idR body
ParStmt NoExtField
noExtField [ParStmtBlock GhcRn GhcRn]
segs' HsExpr GhcRn
mzip_op SyntaxExprRn
bind_op), FreeVars
fvs4)], thing
thing)
                 , FreeVars
fvs1 FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fvs2 FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fvs3 FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fvs4) }

rnStmt HsStmtContext GhcRn
ctxt body GhcPs -> RnM (body GhcRn, FreeVars)
_ (L SrcSpanAnnA
loc (TransStmt { trS_stmts :: forall idL idR body. StmtLR idL idR body -> [ExprLStmt idL]
trS_stmts = [ExprLStmt GhcPs]
stmts, trS_by :: forall idL idR body. StmtLR idL idR body -> Maybe (LHsExpr idR)
trS_by = Maybe (LHsExpr GhcPs)
by, trS_form :: forall idL idR body. StmtLR idL idR body -> TransForm
trS_form = TransForm
form
                              , trS_using :: forall idL idR body. StmtLR idL idR body -> LHsExpr idR
trS_using = LHsExpr GhcPs
using })) [Name] -> RnM (thing, FreeVars)
thing_inside
  = do { -- Rename the 'using' expression in the context before the transform is begun
         (GenLocated SrcSpanAnnA (HsExpr GhcRn)
using', FreeVars
fvs1) <- LHsExpr GhcPs -> RnM (XRec GhcRn (HsExpr GhcRn), FreeVars)
rnLExpr LHsExpr GhcPs
using

         -- Rename the stmts and the 'by' expression
         -- Keep track of the variables mentioned in the 'by' expression
       ; (([GenLocated
   SrcSpanAnnA
   (StmtLR GhcRn GhcRn (GenLocated SrcSpanAnnA (HsExpr GhcRn)))]
stmts', (Maybe (GenLocated SrcSpanAnnA (HsExpr GhcRn))
by', [Name]
used_bndrs, thing
thing)), FreeVars
fvs2)
             <- forall (body :: * -> *) thing.
AnnoBody body =>
HsStmtContext GhcRn
-> (body GhcPs -> RnM (body GhcRn, FreeVars))
-> [LStmt GhcPs (LocatedA (body GhcPs))]
-> ([Name] -> RnM (thing, FreeVars))
-> RnM (([LStmt GhcRn (LocatedA (body GhcRn))], thing), FreeVars)
rnStmts (forall p. HsStmtContext p -> HsStmtContext p
TransStmtCtxt HsStmtContext GhcRn
ctxt) HsExpr GhcPs -> RnM (HsExpr GhcRn, FreeVars)
rnExpr [ExprLStmt GhcPs]
stmts forall a b. (a -> b) -> a -> b
$ \ [Name]
bndrs ->
                do { (Maybe (GenLocated SrcSpanAnnA (HsExpr GhcRn))
by',   FreeVars
fvs_by) <- forall a b.
(a -> RnM (b, FreeVars)) -> Maybe a -> RnM (Maybe b, FreeVars)
mapMaybeFvRn LHsExpr GhcPs -> RnM (XRec GhcRn (HsExpr GhcRn), FreeVars)
rnLExpr Maybe (LHsExpr GhcPs)
by
                   ; (thing
thing, FreeVars
fvs_thing) <- [Name] -> RnM (thing, FreeVars)
thing_inside [Name]
bndrs
                   ; let fvs :: FreeVars
fvs = FreeVars
fvs_by FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fvs_thing
                         used_bndrs :: [Name]
used_bndrs = forall a. (a -> Bool) -> [a] -> [a]
filter (Name -> FreeVars -> Bool
`elemNameSet` FreeVars
fvs) [Name]
bndrs
                         -- The paper (Fig 5) has a bug here; we must treat any free variable
                         -- of the "thing inside", **or of the by-expression**, as used
                   ; forall (m :: * -> *) a. Monad m => a -> m a
return ((Maybe (GenLocated SrcSpanAnnA (HsExpr GhcRn))
by', [Name]
used_bndrs, thing
thing), FreeVars
fvs) }

       -- Lookup `return`, `(>>=)` and `liftM` for monad comprehensions
       ; (SyntaxExprRn
return_op, FreeVars
fvs3) <- HsStmtContext GhcRn -> Name -> RnM (SyntaxExpr GhcRn, FreeVars)
lookupStmtName HsStmtContext GhcRn
ctxt Name
returnMName
       ; (SyntaxExprRn
bind_op,   FreeVars
fvs4) <- HsStmtContext GhcRn -> Name -> RnM (SyntaxExpr GhcRn, FreeVars)
lookupStmtName HsStmtContext GhcRn
ctxt Name
bindMName
       ; (HsExpr GhcRn
fmap_op,   FreeVars
fvs5) <- case TransForm
form of
                                TransForm
ThenForm -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall (p :: Pass). HsExpr (GhcPass p)
noExpr, FreeVars
emptyFVs)
                                TransForm
_        -> HsStmtContext GhcRn -> Name -> RnM (HsExpr GhcRn, FreeVars)
lookupStmtNamePoly HsStmtContext GhcRn
ctxt Name
fmapName

       ; let all_fvs :: FreeVars
all_fvs  = FreeVars
fvs1 FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fvs2 FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fvs3
                             FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fvs4 FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fvs5
             bndr_map :: [(Name, Name)]
bndr_map = [Name]
used_bndrs forall a b. [a] -> [b] -> [(a, b)]
`zip` [Name]
used_bndrs
             -- See Note [TransStmt binder map] in GHC.Hs.Expr

       ; String -> SDoc -> IOEnv (Env TcGblEnv TcLclEnv) ()
traceRn String
"rnStmt: implicitly rebound these used binders:" (forall a. Outputable a => a -> SDoc
ppr [(Name, Name)]
bndr_map)
       ; forall (m :: * -> *) a. Monad m => a -> m a
return (([(forall l e. l -> e -> GenLocated l e
L SrcSpanAnnA
loc (TransStmt { trS_ext :: XTransStmt GhcRn GhcRn (LocatedA (body GhcRn))
trS_ext = NoExtField
noExtField
                                    , trS_stmts :: [ExprLStmt GhcRn]
trS_stmts = [GenLocated
   SrcSpanAnnA
   (StmtLR GhcRn GhcRn (GenLocated SrcSpanAnnA (HsExpr GhcRn)))]
stmts', trS_bndrs :: [(IdP GhcRn, IdP GhcRn)]
trS_bndrs = [(Name, Name)]
bndr_map
                                    , trS_by :: Maybe (XRec GhcRn (HsExpr GhcRn))
trS_by = Maybe (GenLocated SrcSpanAnnA (HsExpr GhcRn))
by', trS_using :: XRec GhcRn (HsExpr GhcRn)
trS_using = GenLocated SrcSpanAnnA (HsExpr GhcRn)
using', trS_form :: TransForm
trS_form = TransForm
form
                                    , trS_ret :: SyntaxExpr GhcRn
trS_ret = SyntaxExprRn
return_op, trS_bind :: SyntaxExpr GhcRn
trS_bind = SyntaxExprRn
bind_op
                                    , trS_fmap :: HsExpr GhcRn
trS_fmap = HsExpr GhcRn
fmap_op }), FreeVars
fvs2)], thing
thing), FreeVars
all_fvs) }

rnStmt HsStmtContext GhcRn
_ body GhcPs -> RnM (body GhcRn, FreeVars)
_ (L SrcSpanAnnA
_ ApplicativeStmt{}) [Name] -> RnM (thing, FreeVars)
_ =
  forall a. String -> a
panic String
"rnStmt: ApplicativeStmt"

rnParallelStmts :: forall thing. HsStmtContext GhcRn
                -> SyntaxExpr GhcRn
                -> [ParStmtBlock GhcPs GhcPs]
                -> ([Name] -> RnM (thing, FreeVars))
                -> RnM (([ParStmtBlock GhcRn GhcRn], thing), FreeVars)
-- Note [Renaming parallel Stmts]
rnParallelStmts :: forall thing.
HsStmtContext GhcRn
-> SyntaxExpr GhcRn
-> [ParStmtBlock GhcPs GhcPs]
-> ([Name] -> RnM (thing, FreeVars))
-> RnM (([ParStmtBlock GhcRn GhcRn], thing), FreeVars)
rnParallelStmts HsStmtContext GhcRn
ctxt SyntaxExpr GhcRn
return_op [ParStmtBlock GhcPs GhcPs]
segs [Name] -> RnM (thing, FreeVars)
thing_inside
  = do { LocalRdrEnv
orig_lcl_env <- RnM LocalRdrEnv
getLocalRdrEnv
       ; LocalRdrEnv
-> [Name]
-> [ParStmtBlock GhcPs GhcPs]
-> RnM (([ParStmtBlock GhcRn GhcRn], thing), FreeVars)
rn_segs LocalRdrEnv
orig_lcl_env [] [ParStmtBlock GhcPs GhcPs]
segs }
  where
    rn_segs :: LocalRdrEnv
            -> [Name] -> [ParStmtBlock GhcPs GhcPs]
            -> RnM (([ParStmtBlock GhcRn GhcRn], thing), FreeVars)
    rn_segs :: LocalRdrEnv
-> [Name]
-> [ParStmtBlock GhcPs GhcPs]
-> RnM (([ParStmtBlock GhcRn GhcRn], thing), FreeVars)
rn_segs LocalRdrEnv
_ [Name]
bndrs_so_far []
      = do { let ([Name]
bndrs', [NonEmpty Name]
dups) = forall a. (a -> a -> Ordering) -> [a] -> ([a], [NonEmpty a])
removeDups Name -> Name -> Ordering
cmpByOcc [Name]
bndrs_so_far
           ; forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ forall {a}.
Outputable a =>
NonEmpty a -> IOEnv (Env TcGblEnv TcLclEnv) ()
dupErr [NonEmpty Name]
dups
           ; (thing
thing, FreeVars
fvs) <- forall a. [Name] -> RnM a -> RnM a
bindLocalNames [Name]
bndrs' ([Name] -> RnM (thing, FreeVars)
thing_inside [Name]
bndrs')
           ; forall (m :: * -> *) a. Monad m => a -> m a
return (([], thing
thing), FreeVars
fvs) }

    rn_segs LocalRdrEnv
env [Name]
bndrs_so_far (ParStmtBlock XParStmtBlock GhcPs GhcPs
x [ExprLStmt GhcPs]
stmts [IdP GhcPs]
_ SyntaxExpr GhcPs
_ : [ParStmtBlock GhcPs GhcPs]
segs)
      = do { (([GenLocated
   SrcSpanAnnA
   (StmtLR GhcRn GhcRn (GenLocated SrcSpanAnnA (HsExpr GhcRn)))]
stmts', ([Name]
used_bndrs, [ParStmtBlock GhcRn GhcRn]
segs', thing
thing)), FreeVars
fvs)
                    <- forall (body :: * -> *) thing.
AnnoBody body =>
HsStmtContext GhcRn
-> (body GhcPs -> RnM (body GhcRn, FreeVars))
-> [LStmt GhcPs (LocatedA (body GhcPs))]
-> ([Name] -> RnM (thing, FreeVars))
-> RnM (([LStmt GhcRn (LocatedA (body GhcRn))], thing), FreeVars)
rnStmts HsStmtContext GhcRn
ctxt HsExpr GhcPs -> RnM (HsExpr GhcRn, FreeVars)
rnExpr [ExprLStmt GhcPs]
stmts forall a b. (a -> b) -> a -> b
$ \ [Name]
bndrs ->
                       forall a. LocalRdrEnv -> RnM a -> RnM a
setLocalRdrEnv LocalRdrEnv
env       forall a b. (a -> b) -> a -> b
$ do
                       { (([ParStmtBlock GhcRn GhcRn]
segs', thing
thing), FreeVars
fvs) <- LocalRdrEnv
-> [Name]
-> [ParStmtBlock GhcPs GhcPs]
-> RnM (([ParStmtBlock GhcRn GhcRn], thing), FreeVars)
rn_segs LocalRdrEnv
env ([Name]
bndrs forall a. [a] -> [a] -> [a]
++ [Name]
bndrs_so_far) [ParStmtBlock GhcPs GhcPs]
segs
                       ; let used_bndrs :: [Name]
used_bndrs = forall a. (a -> Bool) -> [a] -> [a]
filter (Name -> FreeVars -> Bool
`elemNameSet` FreeVars
fvs) [Name]
bndrs
                       ; forall (m :: * -> *) a. Monad m => a -> m a
return (([Name]
used_bndrs, [ParStmtBlock GhcRn GhcRn]
segs', thing
thing), FreeVars
fvs) }

           ; let seg' :: ParStmtBlock GhcRn GhcRn
seg' = forall idL idR.
XParStmtBlock idL idR
-> [ExprLStmt idL]
-> [IdP idR]
-> SyntaxExpr idR
-> ParStmtBlock idL idR
ParStmtBlock XParStmtBlock GhcPs GhcPs
x [GenLocated
   SrcSpanAnnA
   (StmtLR GhcRn GhcRn (GenLocated SrcSpanAnnA (HsExpr GhcRn)))]
stmts' [Name]
used_bndrs SyntaxExpr GhcRn
return_op
           ; forall (m :: * -> *) a. Monad m => a -> m a
return ((ParStmtBlock GhcRn GhcRn
seg'forall a. a -> [a] -> [a]
:[ParStmtBlock GhcRn GhcRn]
segs', thing
thing), FreeVars
fvs) }

    cmpByOcc :: Name -> Name -> Ordering
cmpByOcc Name
n1 Name
n2 = Name -> OccName
nameOccName Name
n1 forall a. Ord a => a -> a -> Ordering
`compare` Name -> OccName
nameOccName Name
n2
    dupErr :: NonEmpty a -> IOEnv (Env TcGblEnv TcLclEnv) ()
dupErr NonEmpty a
vs = SDoc -> IOEnv (Env TcGblEnv TcLclEnv) ()
addErr (String -> SDoc
text String
"Duplicate binding in parallel list comprehension for:"
                    SDoc -> SDoc -> SDoc
<+> SDoc -> SDoc
quotes (forall a. Outputable a => a -> SDoc
ppr (forall a. NonEmpty a -> a
NE.head NonEmpty a
vs)))

lookupQualifiedDoStmtName :: HsStmtContext GhcRn -> Name -> RnM (SyntaxExpr GhcRn, FreeVars)
-- Like lookupStmtName, but respects QualifiedDo
lookupQualifiedDoStmtName :: HsStmtContext GhcRn -> Name -> RnM (SyntaxExpr GhcRn, FreeVars)
lookupQualifiedDoStmtName HsStmtContext GhcRn
ctxt Name
n
  = case forall p. HsStmtContext p -> Maybe ModuleName
qualifiedDoModuleName_maybe HsStmtContext GhcRn
ctxt of
      Maybe ModuleName
Nothing -> HsStmtContext GhcRn -> Name -> RnM (SyntaxExpr GhcRn, FreeVars)
lookupStmtName HsStmtContext GhcRn
ctxt Name
n
      Just ModuleName
modName ->
        forall (a :: * -> * -> *) b c d.
Arrow a =>
a b c -> a (b, d) (c, d)
first (HsExpr GhcRn -> SyntaxExprRn
mkSyntaxExpr forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (p :: Pass) a.
IsSrcSpanAnn p a =>
IdP (GhcPass p) -> HsExpr (GhcPass p)
nl_HsVar) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Name -> ModuleName -> RnM (Name, FreeVars)
lookupNameWithQualifier Name
n ModuleName
modName

lookupStmtName :: HsStmtContext GhcRn -> Name -> RnM (SyntaxExpr GhcRn, FreeVars)
-- Like lookupSyntax, but respects contexts
lookupStmtName :: HsStmtContext GhcRn -> Name -> RnM (SyntaxExpr GhcRn, FreeVars)
lookupStmtName HsStmtContext GhcRn
ctxt Name
n
  | HsStmtContext GhcRn -> Bool
rebindableContext HsStmtContext GhcRn
ctxt
  = Name -> RnM (SyntaxExpr GhcRn, FreeVars)
lookupSyntax Name
n
  | Bool
otherwise
  = forall (m :: * -> *) a. Monad m => a -> m a
return (Name -> SyntaxExprRn
mkRnSyntaxExpr Name
n, FreeVars
emptyFVs)

lookupStmtNamePoly :: HsStmtContext GhcRn -> Name -> RnM (HsExpr GhcRn, FreeVars)
lookupStmtNamePoly :: HsStmtContext GhcRn -> Name -> RnM (HsExpr GhcRn, FreeVars)
lookupStmtNamePoly HsStmtContext GhcRn
ctxt Name
name
  | HsStmtContext GhcRn -> Bool
rebindableContext HsStmtContext GhcRn
ctxt
  = do { Bool
rebindable_on <- forall gbl lcl. Extension -> TcRnIf gbl lcl Bool
xoptM Extension
LangExt.RebindableSyntax
       ; if Bool
rebindable_on
         then do { Name
fm <- RdrName -> RnM Name
lookupOccRn (Name -> RdrName
nameRdrName Name
name)
                 ; forall (m :: * -> *) a. Monad m => a -> m a
return (forall p. XVar p -> LIdP p -> HsExpr p
HsVar NoExtField
noExtField (forall a an. a -> LocatedAn an a
noLocA Name
fm), Name -> FreeVars
unitFV Name
fm) }
         else RnM (HsExpr GhcRn, FreeVars)
not_rebindable }
  | Bool
otherwise
  = RnM (HsExpr GhcRn, FreeVars)
not_rebindable
  where
    not_rebindable :: RnM (HsExpr GhcRn, FreeVars)
not_rebindable = forall (m :: * -> *) a. Monad m => a -> m a
return (forall p. XVar p -> LIdP p -> HsExpr p
HsVar NoExtField
noExtField (forall a an. a -> LocatedAn an a
noLocA Name
name), FreeVars
emptyFVs)

-- | Is this a context where we respect RebindableSyntax?
-- but ListComp are never rebindable
-- Neither is ArrowExpr, which has its own desugarer in GHC.HsToCore.Arrows
rebindableContext :: HsStmtContext GhcRn -> Bool
rebindableContext :: HsStmtContext GhcRn -> Bool
rebindableContext HsStmtContext GhcRn
ctxt = case HsStmtContext GhcRn
ctxt of
  HsStmtContext GhcRn
ListComp        -> Bool
False
  HsStmtContext GhcRn
ArrowExpr       -> Bool
False
  PatGuard {}     -> Bool
False

  DoExpr Maybe ModuleName
m        -> forall a. Maybe a -> Bool
isNothing Maybe ModuleName
m
  MDoExpr Maybe ModuleName
m       -> forall a. Maybe a -> Bool
isNothing Maybe ModuleName
m
  HsStmtContext GhcRn
MonadComp       -> Bool
True
  HsStmtContext GhcRn
GhciStmtCtxt    -> Bool
True   -- I suppose?

  ParStmtCtxt   HsStmtContext GhcRn
c -> HsStmtContext GhcRn -> Bool
rebindableContext HsStmtContext GhcRn
c     -- Look inside to
  TransStmtCtxt HsStmtContext GhcRn
c -> HsStmtContext GhcRn -> Bool
rebindableContext HsStmtContext GhcRn
c     -- the parent context

{-
Note [Renaming parallel Stmts]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Renaming parallel statements is painful.  Given, say
     [ a+c | a <- as, bs <- bss
           | c <- bs, a <- ds ]
Note that
  (a) In order to report "Defined but not used" about 'bs', we must
      rename each group of Stmts with a thing_inside whose FreeVars
      include at least {a,c}

  (b) We want to report that 'a' is illegally bound in both branches

  (c) The 'bs' in the second group must obviously not be captured by
      the binding in the first group

To satisfy (a) we nest the segements.
To satisfy (b) we check for duplicates just before thing_inside.
To satisfy (c) we reset the LocalRdrEnv each time.

************************************************************************
*                                                                      *
\subsubsection{mdo expressions}
*                                                                      *
************************************************************************
-}

type FwdRefs = NameSet
type Segment stmts = (Defs,
                      Uses,     -- May include defs
                      FwdRefs,  -- A subset of uses that are
                                --   (a) used before they are bound in this segment, or
                                --   (b) used here, and bound in subsequent segments
                      stmts)    -- Either Stmt or [Stmt]


-- wrapper that does both the left- and right-hand sides
rnRecStmtsAndThen :: AnnoBody body =>
                     HsStmtContext GhcRn
                  -> (body GhcPs -> RnM (body GhcRn, FreeVars))
                  -> [LStmt GhcPs (LocatedA (body GhcPs))]
                         -- assumes that the FreeVars returned includes
                         -- the FreeVars of the Segments
                  -> ([Segment (LStmt GhcRn (LocatedA (body GhcRn)))]
                      -> RnM (a, FreeVars))
                  -> RnM (a, FreeVars)
rnRecStmtsAndThen :: forall (body :: * -> *) a.
AnnoBody body =>
HsStmtContext GhcRn
-> (body GhcPs -> RnM (body GhcRn, FreeVars))
-> [LStmt GhcPs (LocatedA (body GhcPs))]
-> ([Segment (LStmt GhcRn (LocatedA (body GhcRn)))]
    -> RnM (a, FreeVars))
-> RnM (a, FreeVars)
rnRecStmtsAndThen HsStmtContext GhcRn
ctxt body GhcPs -> RnM (body GhcRn, FreeVars)
rnBody [LStmt GhcPs (LocatedA (body GhcPs))]
s [Segment (LStmt GhcRn (LocatedA (body GhcRn)))]
-> RnM (a, FreeVars)
cont
  = do  { -- (A) Make the mini fixity env for all of the stmts
          MiniFixityEnv
fix_env <- [LFixitySig GhcPs] -> RnM MiniFixityEnv
makeMiniFixityEnv (forall body. [LStmtLR GhcPs GhcPs body] -> [LFixitySig GhcPs]
collectRecStmtsFixities [LStmt GhcPs (LocatedA (body GhcPs))]
s)

          -- (B) Do the LHSes
        ; [(GenLocated
    (Anno (StmtLR GhcRn GhcPs (LocatedA (body GhcPs))))
    (StmtLR GhcRn GhcPs (LocatedA (body GhcPs))),
  FreeVars)]
new_lhs_and_fv <- forall (body :: * -> *).
AnnoBody body =>
MiniFixityEnv
-> [LStmt GhcPs (LocatedA (body GhcPs))]
-> RnM [(LStmtLR GhcRn GhcPs (LocatedA (body GhcPs)), FreeVars)]
rn_rec_stmts_lhs MiniFixityEnv
fix_env [LStmt GhcPs (LocatedA (body GhcPs))]
s

          --    ...bring them and their fixities into scope
        ; let bound_names :: [IdP GhcRn]
bound_names = forall (idL :: Pass) (idR :: Pass) body.
CollectPass (GhcPass idL) =>
CollectFlag (GhcPass idL)
-> [LStmtLR (GhcPass idL) (GhcPass idR) body]
-> [IdP (GhcPass idL)]
collectLStmtsBinders forall p. CollectFlag p
CollNoDictBinders (forall a b. (a -> b) -> [a] -> [b]
map forall a b. (a, b) -> a
fst [(GenLocated
    (Anno (StmtLR GhcRn GhcPs (LocatedA (body GhcPs))))
    (StmtLR GhcRn GhcPs (LocatedA (body GhcPs))),
  FreeVars)]
new_lhs_and_fv)
              -- Fake uses of variables introduced implicitly (warning suppression, see #4404)
              rec_uses :: [(SrcSpan, [Name])]
rec_uses = forall (idR :: Pass) (body :: * -> *).
[LStmtLR GhcRn (GhcPass idR) (LocatedA (body (GhcPass idR)))]
-> [(SrcSpan, [Name])]
lStmtsImplicits (forall a b. (a -> b) -> [a] -> [b]
map forall a b. (a, b) -> a
fst [(GenLocated
    (Anno (StmtLR GhcRn GhcPs (LocatedA (body GhcPs))))
    (StmtLR GhcRn GhcPs (LocatedA (body GhcPs))),
  FreeVars)]
new_lhs_and_fv)
              implicit_uses :: FreeVars
implicit_uses = [Name] -> FreeVars
mkNameSet forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap forall a b. (a, b) -> b
snd forall a b. (a -> b) -> a -> b
$ [(SrcSpan, [Name])]
rec_uses
        ; forall a. [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)
bindLocalNamesFV [IdP GhcRn]
bound_names forall a b. (a -> b) -> a -> b
$
          forall a. MiniFixityEnv -> [Name] -> RnM a -> RnM a
addLocalFixities MiniFixityEnv
fix_env [IdP GhcRn]
bound_names forall a b. (a -> b) -> a -> b
$ do

          -- (C) do the right-hand-sides and thing-inside
        { [Segment
   (GenLocated
      SrcSpanAnnA (StmtLR GhcRn GhcRn (LocatedA (body GhcRn))))]
segs <- forall (body :: * -> *).
AnnoBody body =>
HsStmtContext GhcRn
-> (body GhcPs -> RnM (body GhcRn, FreeVars))
-> [Name]
-> [(LStmtLR GhcRn GhcPs (LocatedA (body GhcPs)), FreeVars)]
-> RnM [Segment (LStmt GhcRn (LocatedA (body GhcRn)))]
rn_rec_stmts HsStmtContext GhcRn
ctxt body GhcPs -> RnM (body GhcRn, FreeVars)
rnBody [IdP GhcRn]
bound_names [(GenLocated
    (Anno (StmtLR GhcRn GhcPs (LocatedA (body GhcPs))))
    (StmtLR GhcRn GhcPs (LocatedA (body GhcPs))),
  FreeVars)]
new_lhs_and_fv
        ; (a
res, FreeVars
fvs) <- [Segment (LStmt GhcRn (LocatedA (body GhcRn)))]
-> RnM (a, FreeVars)
cont [Segment
   (GenLocated
      SrcSpanAnnA (StmtLR GhcRn GhcRn (LocatedA (body GhcRn))))]
segs
        ; forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ (\(SrcSpan
loc, [Name]
ns) -> SrcSpan
-> FreeVars -> Maybe [Name] -> IOEnv (Env TcGblEnv TcLclEnv) ()
checkUnusedRecordWildcard SrcSpan
loc FreeVars
fvs (forall a. a -> Maybe a
Just [Name]
ns))
                [(SrcSpan, [Name])]
rec_uses
        ; [Name] -> FreeVars -> IOEnv (Env TcGblEnv TcLclEnv) ()
warnUnusedLocalBinds [IdP GhcRn]
bound_names (FreeVars
fvs FreeVars -> FreeVars -> FreeVars
`unionNameSet` FreeVars
implicit_uses)
        ; forall (m :: * -> *) a. Monad m => a -> m a
return (a
res, FreeVars
fvs) }}

-- get all the fixity decls in any Let stmt
collectRecStmtsFixities :: [LStmtLR GhcPs GhcPs body] -> [LFixitySig GhcPs]
collectRecStmtsFixities :: forall body. [LStmtLR GhcPs GhcPs body] -> [LFixitySig GhcPs]
collectRecStmtsFixities [LStmtLR GhcPs GhcPs body]
l =
    forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (\ GenLocated
  (Anno (StmtLR GhcPs GhcPs body)) (StmtLR GhcPs GhcPs body)
s -> \[GenLocated SrcSpanAnnA (FixitySig GhcPs)]
acc -> case GenLocated
  (Anno (StmtLR GhcPs GhcPs body)) (StmtLR GhcPs GhcPs body)
s of
            (L Anno (StmtLR GhcPs GhcPs body)
_ (LetStmt XLetStmt GhcPs GhcPs body
_ (HsValBinds XHsValBinds GhcPs GhcPs
_ (ValBinds XValBinds GhcPs GhcPs
_ LHsBindsLR GhcPs GhcPs
_ [LSig GhcPs]
sigs)))) ->
              forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (\ GenLocated SrcSpanAnnA (Sig GhcPs)
sig -> \ [GenLocated SrcSpanAnnA (FixitySig GhcPs)]
acc -> case GenLocated SrcSpanAnnA (Sig GhcPs)
sig of
                                         (L SrcSpanAnnA
loc (FixSig XFixSig GhcPs
_ FixitySig GhcPs
s)) -> (forall l e. l -> e -> GenLocated l e
L SrcSpanAnnA
loc FixitySig GhcPs
s) forall a. a -> [a] -> [a]
: [GenLocated SrcSpanAnnA (FixitySig GhcPs)]
acc
                                         GenLocated SrcSpanAnnA (Sig GhcPs)
_ -> [GenLocated SrcSpanAnnA (FixitySig GhcPs)]
acc) [GenLocated SrcSpanAnnA (FixitySig GhcPs)]
acc [LSig GhcPs]
sigs
            GenLocated
  (Anno (StmtLR GhcPs GhcPs body)) (StmtLR GhcPs GhcPs body)
_ -> [GenLocated SrcSpanAnnA (FixitySig GhcPs)]
acc) [] [LStmtLR GhcPs GhcPs body]
l

-- left-hand sides

rn_rec_stmt_lhs :: AnnoBody body => MiniFixityEnv
                -> LStmt GhcPs (LocatedA (body GhcPs))
                   -- rename LHS, and return its FVs
                   -- Warning: we will only need the FreeVars below in the case of a BindStmt,
                   -- so we don't bother to compute it accurately in the other cases
                -> RnM [(LStmtLR GhcRn GhcPs (LocatedA (body GhcPs)), FreeVars)]

rn_rec_stmt_lhs :: forall (body :: * -> *).
AnnoBody body =>
MiniFixityEnv
-> LStmt GhcPs (LocatedA (body GhcPs))
-> RnM [(LStmtLR GhcRn GhcPs (LocatedA (body GhcPs)), FreeVars)]
rn_rec_stmt_lhs MiniFixityEnv
_ (L SrcSpanAnnA
loc (BodyStmt XBodyStmt GhcPs GhcPs (LocatedA (body GhcPs))
_ LocatedA (body GhcPs)
body SyntaxExpr GhcPs
a SyntaxExpr GhcPs
b))
  = forall (m :: * -> *) a. Monad m => a -> m a
return [(forall l e. l -> e -> GenLocated l e
L SrcSpanAnnA
loc (forall idL idR body.
XBodyStmt idL idR body
-> body -> SyntaxExpr idR -> SyntaxExpr idR -> StmtLR idL idR body
BodyStmt NoExtField
noExtField LocatedA (body GhcPs)
body SyntaxExpr GhcPs
a SyntaxExpr GhcPs
b), FreeVars
emptyFVs)]

rn_rec_stmt_lhs MiniFixityEnv
_ (L SrcSpanAnnA
loc (LastStmt XLastStmt GhcPs GhcPs (LocatedA (body GhcPs))
_ LocatedA (body GhcPs)
body Maybe Bool
noret SyntaxExpr GhcPs
a))
  = forall (m :: * -> *) a. Monad m => a -> m a
return [(forall l e. l -> e -> GenLocated l e
L SrcSpanAnnA
loc (forall idL idR body.
XLastStmt idL idR body
-> body -> Maybe Bool -> SyntaxExpr idR -> StmtLR idL idR body
LastStmt NoExtField
noExtField LocatedA (body GhcPs)
body Maybe Bool
noret SyntaxExpr GhcPs
a), FreeVars
emptyFVs)]

rn_rec_stmt_lhs MiniFixityEnv
fix_env (L SrcSpanAnnA
loc (BindStmt XBindStmt GhcPs GhcPs (LocatedA (body GhcPs))
_ LPat GhcPs
pat LocatedA (body GhcPs)
body))
  = do
      -- should the ctxt be MDo instead?
      (GenLocated SrcSpanAnnA (Pat GhcRn)
pat', FreeVars
fv_pat) <- NameMaker -> LPat GhcPs -> RnM (LPat GhcRn, FreeVars)
rnBindPat (MiniFixityEnv -> NameMaker
localRecNameMaker MiniFixityEnv
fix_env) LPat GhcPs
pat
      forall (m :: * -> *) a. Monad m => a -> m a
return [(forall l e. l -> e -> GenLocated l e
L SrcSpanAnnA
loc (forall idL idR body.
XBindStmt idL idR body -> LPat idL -> body -> StmtLR idL idR body
BindStmt forall a. EpAnn a
noAnn GenLocated SrcSpanAnnA (Pat GhcRn)
pat' LocatedA (body GhcPs)
body), FreeVars
fv_pat)]

rn_rec_stmt_lhs MiniFixityEnv
_ (L SrcSpanAnnA
_ (LetStmt XLetStmt GhcPs GhcPs (LocatedA (body GhcPs))
_ binds :: HsLocalBinds GhcPs
binds@(HsIPBinds {})))
  = forall a. SDoc -> TcRn a
failWith (forall a. Outputable a => SDoc -> a -> SDoc
badIpBinds (String -> SDoc
text String
"an mdo expression") HsLocalBinds GhcPs
binds)

rn_rec_stmt_lhs MiniFixityEnv
fix_env (L SrcSpanAnnA
loc (LetStmt XLetStmt GhcPs GhcPs (LocatedA (body GhcPs))
_ (HsValBinds XHsValBinds GhcPs GhcPs
x HsValBindsLR GhcPs GhcPs
binds)))
    = do ([Name]
_bound_names, HsValBindsLR GhcRn GhcPs
binds') <- MiniFixityEnv
-> HsValBindsLR GhcPs GhcPs
-> RnM ([Name], HsValBindsLR GhcRn GhcPs)
rnLocalValBindsLHS MiniFixityEnv
fix_env HsValBindsLR GhcPs GhcPs
binds
         forall (m :: * -> *) a. Monad m => a -> m a
return [(forall l e. l -> e -> GenLocated l e
L SrcSpanAnnA
loc (forall idL idR body.
XLetStmt idL idR body
-> HsLocalBindsLR idL idR -> StmtLR idL idR body
LetStmt forall a. EpAnn a
noAnn (forall idL idR.
XHsValBinds idL idR
-> HsValBindsLR idL idR -> HsLocalBindsLR idL idR
HsValBinds XHsValBinds GhcPs GhcPs
x HsValBindsLR GhcRn GhcPs
binds')),
                 -- Warning: this is bogus; see function invariant
                 FreeVars
emptyFVs
                 )]

-- XXX Do we need to do something with the return and mfix names?
rn_rec_stmt_lhs MiniFixityEnv
fix_env (L SrcSpanAnnA
_ (RecStmt { recS_stmts :: forall idL idR body.
StmtLR idL idR body -> XRec idR [LStmtLR idL idR body]
recS_stmts = L SrcSpanAnnL
_ [GenLocated
   SrcSpanAnnA (StmtLR GhcPs GhcPs (LocatedA (body GhcPs)))]
stmts }))  -- Flatten Rec inside Rec
    = forall (body :: * -> *).
AnnoBody body =>
MiniFixityEnv
-> [LStmt GhcPs (LocatedA (body GhcPs))]
-> RnM [(LStmtLR GhcRn GhcPs (LocatedA (body GhcPs)), FreeVars)]
rn_rec_stmts_lhs MiniFixityEnv
fix_env [GenLocated
   SrcSpanAnnA (StmtLR GhcPs GhcPs (LocatedA (body GhcPs)))]
stmts

rn_rec_stmt_lhs MiniFixityEnv
_ stmt :: LStmt GhcPs (LocatedA (body GhcPs))
stmt@(L SrcSpanAnnA
_ (ParStmt {}))       -- Syntactically illegal in mdo
  = forall a. HasCallStack => String -> SDoc -> a
pprPanic String
"rn_rec_stmt" (forall a. Outputable a => a -> SDoc
ppr LStmt GhcPs (LocatedA (body GhcPs))
stmt)

rn_rec_stmt_lhs MiniFixityEnv
_ stmt :: LStmt GhcPs (LocatedA (body GhcPs))
stmt@(L SrcSpanAnnA
_ (TransStmt {}))     -- Syntactically illegal in mdo
  = forall a. HasCallStack => String -> SDoc -> a
pprPanic String
"rn_rec_stmt" (forall a. Outputable a => a -> SDoc
ppr LStmt GhcPs (LocatedA (body GhcPs))
stmt)

rn_rec_stmt_lhs MiniFixityEnv
_ stmt :: LStmt GhcPs (LocatedA (body GhcPs))
stmt@(L SrcSpanAnnA
_ (ApplicativeStmt {})) -- Shouldn't appear yet
  = forall a. HasCallStack => String -> SDoc -> a
pprPanic String
"rn_rec_stmt" (forall a. Outputable a => a -> SDoc
ppr LStmt GhcPs (LocatedA (body GhcPs))
stmt)

rn_rec_stmt_lhs MiniFixityEnv
_ (L SrcSpanAnnA
_ (LetStmt XLetStmt GhcPs GhcPs (LocatedA (body GhcPs))
_ (EmptyLocalBinds XEmptyLocalBinds GhcPs GhcPs
_)))
  = forall a. String -> a
panic String
"rn_rec_stmt LetStmt EmptyLocalBinds"

rn_rec_stmts_lhs :: AnnoBody body => MiniFixityEnv
                 -> [LStmt GhcPs (LocatedA (body GhcPs))]
                 -> RnM [(LStmtLR GhcRn GhcPs (LocatedA (body GhcPs)), FreeVars)]
rn_rec_stmts_lhs :: forall (body :: * -> *).
AnnoBody body =>
MiniFixityEnv
-> [LStmt GhcPs (LocatedA (body GhcPs))]
-> RnM [(LStmtLR GhcRn GhcPs (LocatedA (body GhcPs)), FreeVars)]
rn_rec_stmts_lhs MiniFixityEnv
fix_env [LStmt GhcPs (LocatedA (body GhcPs))]
stmts
  = do { [(GenLocated
    SrcSpanAnnA (StmtLR GhcRn GhcPs (LocatedA (body GhcPs))),
  FreeVars)]
ls <- forall (m :: * -> *) a b. Monad m => (a -> m [b]) -> [a] -> m [b]
concatMapM (forall (body :: * -> *).
AnnoBody body =>
MiniFixityEnv
-> LStmt GhcPs (LocatedA (body GhcPs))
-> RnM [(LStmtLR GhcRn GhcPs (LocatedA (body GhcPs)), FreeVars)]
rn_rec_stmt_lhs MiniFixityEnv
fix_env) [LStmt GhcPs (LocatedA (body GhcPs))]
stmts
       ; let boundNames :: [IdP GhcRn]
boundNames = forall (idL :: Pass) (idR :: Pass) body.
CollectPass (GhcPass idL) =>
CollectFlag (GhcPass idL)
-> [LStmtLR (GhcPass idL) (GhcPass idR) body]
-> [IdP (GhcPass idL)]
collectLStmtsBinders forall p. CollectFlag p
CollNoDictBinders (forall a b. (a -> b) -> [a] -> [b]
map forall a b. (a, b) -> a
fst [(GenLocated
    SrcSpanAnnA (StmtLR GhcRn GhcPs (LocatedA (body GhcPs))),
  FreeVars)]
ls)
            -- First do error checking: we need to check for dups here because we
            -- don't bind all of the variables from the Stmt at once
            -- with bindLocatedLocals.
       ; [Name] -> IOEnv (Env TcGblEnv TcLclEnv) ()
checkDupNames [IdP GhcRn]
boundNames
       ; forall (m :: * -> *) a. Monad m => a -> m a
return [(GenLocated
    SrcSpanAnnA (StmtLR GhcRn GhcPs (LocatedA (body GhcPs))),
  FreeVars)]
ls }


-- right-hand-sides

rn_rec_stmt :: AnnoBody body =>
               HsStmtContext GhcRn
            -> (body GhcPs -> RnM (body GhcRn, FreeVars))
            -> [Name]
            -> (LStmtLR GhcRn GhcPs (LocatedA (body GhcPs)), FreeVars)
            -> RnM [Segment (LStmt GhcRn (LocatedA (body GhcRn)))]
        -- Rename a Stmt that is inside a RecStmt (or mdo)
        -- Assumes all binders are already in scope
        -- Turns each stmt into a singleton Stmt
rn_rec_stmt :: forall (body :: * -> *).
AnnoBody body =>
HsStmtContext GhcRn
-> (body GhcPs -> RnM (body GhcRn, FreeVars))
-> [Name]
-> (LStmtLR GhcRn GhcPs (LocatedA (body GhcPs)), FreeVars)
-> RnM [Segment (LStmt GhcRn (LocatedA (body GhcRn)))]
rn_rec_stmt HsStmtContext GhcRn
ctxt body GhcPs -> RnM (body GhcRn, FreeVars)
rnBody [Name]
_ (L SrcSpanAnnA
loc (LastStmt XLastStmt GhcRn GhcPs (LocatedA (body GhcPs))
_ (L SrcSpanAnnA
lb body GhcPs
body) Maybe Bool
noret SyntaxExpr GhcPs
_), FreeVars
_)
  = do  { (body GhcRn
body', FreeVars
fv_expr) <- body GhcPs -> RnM (body GhcRn, FreeVars)
rnBody body GhcPs
body
        ; (SyntaxExprRn
ret_op, FreeVars
fvs1)   <- forall p.
HsStmtContext p -> Name -> RnM (SyntaxExpr GhcRn, FreeVars)
lookupQualifiedDo HsStmtContext GhcRn
ctxt Name
returnMName
        ; forall (m :: * -> *) a. Monad m => a -> m a
return [(FreeVars
emptyNameSet, FreeVars
fv_expr FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fvs1, FreeVars
emptyNameSet,
                   forall l e. l -> e -> GenLocated l e
L SrcSpanAnnA
loc (forall idL idR body.
XLastStmt idL idR body
-> body -> Maybe Bool -> SyntaxExpr idR -> StmtLR idL idR body
LastStmt NoExtField
noExtField (forall l e. l -> e -> GenLocated l e
L SrcSpanAnnA
lb body GhcRn
body') Maybe Bool
noret SyntaxExprRn
ret_op))] }

rn_rec_stmt HsStmtContext GhcRn
ctxt body GhcPs -> RnM (body GhcRn, FreeVars)
rnBody [Name]
_ (L SrcSpanAnnA
loc (BodyStmt XBodyStmt GhcRn GhcPs (LocatedA (body GhcPs))
_ (L SrcSpanAnnA
lb body GhcPs
body) SyntaxExpr GhcPs
_ SyntaxExpr GhcPs
_), FreeVars
_)
  = do { (body GhcRn
body', FreeVars
fvs) <- body GhcPs -> RnM (body GhcRn, FreeVars)
rnBody body GhcPs
body
       ; (SyntaxExprRn
then_op, FreeVars
fvs1) <- forall p.
HsStmtContext p -> Name -> RnM (SyntaxExpr GhcRn, FreeVars)
lookupQualifiedDo HsStmtContext GhcRn
ctxt Name
thenMName
       ; forall (m :: * -> *) a. Monad m => a -> m a
return [(FreeVars
emptyNameSet, FreeVars
fvs FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fvs1, FreeVars
emptyNameSet,
                 forall l e. l -> e -> GenLocated l e
L SrcSpanAnnA
loc (forall idL idR body.
XBodyStmt idL idR body
-> body -> SyntaxExpr idR -> SyntaxExpr idR -> StmtLR idL idR body
BodyStmt NoExtField
noExtField (forall l e. l -> e -> GenLocated l e
L SrcSpanAnnA
lb body GhcRn
body') SyntaxExprRn
then_op forall (p :: Pass). IsPass p => SyntaxExpr (GhcPass p)
noSyntaxExpr))] }

rn_rec_stmt HsStmtContext GhcRn
ctxt body GhcPs -> RnM (body GhcRn, FreeVars)
rnBody [Name]
_ (L SrcSpanAnnA
loc (BindStmt XBindStmt GhcRn GhcPs (LocatedA (body GhcPs))
_ LPat GhcRn
pat' (L SrcSpanAnnA
lb body GhcPs
body)), FreeVars
fv_pat)
  = do { (body GhcRn
body', FreeVars
fv_expr) <- body GhcPs -> RnM (body GhcRn, FreeVars)
rnBody body GhcPs
body
       ; (SyntaxExprRn
bind_op, FreeVars
fvs1) <- forall p.
HsStmtContext p -> Name -> RnM (SyntaxExpr GhcRn, FreeVars)
lookupQualifiedDo HsStmtContext GhcRn
ctxt Name
bindMName

       ; (Maybe SyntaxExprRn
fail_op, FreeVars
fvs2) <- forall p. HsStmtContext p -> RnM (FailOperator GhcRn, FreeVars)
getMonadFailOp HsStmtContext GhcRn
ctxt

       ; let bndrs :: FreeVars
bndrs = [Name] -> FreeVars
mkNameSet (forall p. CollectPass p => CollectFlag p -> LPat p -> [IdP p]
collectPatBinders forall p. CollectFlag p
CollNoDictBinders LPat GhcRn
pat')
             fvs :: FreeVars
fvs   = FreeVars
fv_expr FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fv_pat FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fvs1 FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fvs2
       ; let xbsrn :: XBindStmtRn
xbsrn = XBindStmtRn { xbsrn_bindOp :: SyntaxExpr GhcRn
xbsrn_bindOp = SyntaxExprRn
bind_op, xbsrn_failOp :: FailOperator GhcRn
xbsrn_failOp = Maybe SyntaxExprRn
fail_op }
       ; forall (m :: * -> *) a. Monad m => a -> m a
return [(FreeVars
bndrs, FreeVars
fvs, FreeVars
bndrs FreeVars -> FreeVars -> FreeVars
`intersectNameSet` FreeVars
fvs,
                  forall l e. l -> e -> GenLocated l e
L SrcSpanAnnA
loc (forall idL idR body.
XBindStmt idL idR body -> LPat idL -> body -> StmtLR idL idR body
BindStmt XBindStmtRn
xbsrn LPat GhcRn
pat' (forall l e. l -> e -> GenLocated l e
L SrcSpanAnnA
lb body GhcRn
body')))] }

rn_rec_stmt HsStmtContext GhcRn
_ body GhcPs -> RnM (body GhcRn, FreeVars)
_ [Name]
_ (L SrcSpanAnnA
_ (LetStmt XLetStmt GhcRn GhcPs (LocatedA (body GhcPs))
_ binds :: HsLocalBindsLR GhcRn GhcPs
binds@(HsIPBinds {})), FreeVars
_)
  = forall a. SDoc -> TcRn a
failWith (forall a. Outputable a => SDoc -> a -> SDoc
badIpBinds (String -> SDoc
text String
"an mdo expression") HsLocalBindsLR GhcRn GhcPs
binds)

rn_rec_stmt HsStmtContext GhcRn
_ body GhcPs -> RnM (body GhcRn, FreeVars)
_ [Name]
all_bndrs (L SrcSpanAnnA
loc (LetStmt XLetStmt GhcRn GhcPs (LocatedA (body GhcPs))
_ (HsValBinds XHsValBinds GhcRn GhcPs
x HsValBindsLR GhcRn GhcPs
binds')), FreeVars
_)
  = do { (HsValBinds GhcRn
binds', DefUses
du_binds) <- FreeVars
-> HsValBindsLR GhcRn GhcPs -> RnM (HsValBinds GhcRn, DefUses)
rnLocalValBindsRHS ([Name] -> FreeVars
mkNameSet [Name]
all_bndrs) HsValBindsLR GhcRn GhcPs
binds'
           -- fixities and unused are handled above in rnRecStmtsAndThen
       ; let fvs :: FreeVars
fvs = DefUses -> FreeVars
allUses DefUses
du_binds
       ; forall (m :: * -> *) a. Monad m => a -> m a
return [(DefUses -> FreeVars
duDefs DefUses
du_binds, FreeVars
fvs, FreeVars
emptyNameSet,
                 forall l e. l -> e -> GenLocated l e
L SrcSpanAnnA
loc (forall idL idR body.
XLetStmt idL idR body
-> HsLocalBindsLR idL idR -> StmtLR idL idR body
LetStmt forall a. EpAnn a
noAnn (forall idL idR.
XHsValBinds idL idR
-> HsValBindsLR idL idR -> HsLocalBindsLR idL idR
HsValBinds XHsValBinds GhcRn GhcPs
x HsValBinds GhcRn
binds')))] }

-- no RecStmt case because they get flattened above when doing the LHSes
rn_rec_stmt HsStmtContext GhcRn
_ body GhcPs -> RnM (body GhcRn, FreeVars)
_ [Name]
_ stmt :: (LStmtLR GhcRn GhcPs (LocatedA (body GhcPs)), FreeVars)
stmt@(L SrcSpanAnnA
_ (RecStmt {}), FreeVars
_)
  = forall a. HasCallStack => String -> SDoc -> a
pprPanic String
"rn_rec_stmt: RecStmt" (forall a. Outputable a => a -> SDoc
ppr (LStmtLR GhcRn GhcPs (LocatedA (body GhcPs)), FreeVars)
stmt)

rn_rec_stmt HsStmtContext GhcRn
_ body GhcPs -> RnM (body GhcRn, FreeVars)
_ [Name]
_ stmt :: (LStmtLR GhcRn GhcPs (LocatedA (body GhcPs)), FreeVars)
stmt@(L SrcSpanAnnA
_ (ParStmt {}), FreeVars
_)       -- Syntactically illegal in mdo
  = forall a. HasCallStack => String -> SDoc -> a
pprPanic String
"rn_rec_stmt: ParStmt" (forall a. Outputable a => a -> SDoc
ppr (LStmtLR GhcRn GhcPs (LocatedA (body GhcPs)), FreeVars)
stmt)

rn_rec_stmt HsStmtContext GhcRn
_ body GhcPs -> RnM (body GhcRn, FreeVars)
_ [Name]
_ stmt :: (LStmtLR GhcRn GhcPs (LocatedA (body GhcPs)), FreeVars)
stmt@(L SrcSpanAnnA
_ (TransStmt {}), FreeVars
_)     -- Syntactically illegal in mdo
  = forall a. HasCallStack => String -> SDoc -> a
pprPanic String
"rn_rec_stmt: TransStmt" (forall a. Outputable a => a -> SDoc
ppr (LStmtLR GhcRn GhcPs (LocatedA (body GhcPs)), FreeVars)
stmt)

rn_rec_stmt HsStmtContext GhcRn
_ body GhcPs -> RnM (body GhcRn, FreeVars)
_ [Name]
_ (L SrcSpanAnnA
_ (LetStmt XLetStmt GhcRn GhcPs (LocatedA (body GhcPs))
_ (EmptyLocalBinds XEmptyLocalBinds GhcRn GhcPs
_)), FreeVars
_)
  = forall a. String -> a
panic String
"rn_rec_stmt: LetStmt EmptyLocalBinds"

rn_rec_stmt HsStmtContext GhcRn
_ body GhcPs -> RnM (body GhcRn, FreeVars)
_ [Name]
_ stmt :: (LStmtLR GhcRn GhcPs (LocatedA (body GhcPs)), FreeVars)
stmt@(L SrcSpanAnnA
_ (ApplicativeStmt {}), FreeVars
_)
  = forall a. HasCallStack => String -> SDoc -> a
pprPanic String
"rn_rec_stmt: ApplicativeStmt" (forall a. Outputable a => a -> SDoc
ppr (LStmtLR GhcRn GhcPs (LocatedA (body GhcPs)), FreeVars)
stmt)

rn_rec_stmts :: AnnoBody body =>
                HsStmtContext GhcRn
             -> (body GhcPs -> RnM (body GhcRn, FreeVars))
             -> [Name]
             -> [(LStmtLR GhcRn GhcPs (LocatedA (body GhcPs)), FreeVars)]
             -> RnM [Segment (LStmt GhcRn (LocatedA (body GhcRn)))]
rn_rec_stmts :: forall (body :: * -> *).
AnnoBody body =>
HsStmtContext GhcRn
-> (body GhcPs -> RnM (body GhcRn, FreeVars))
-> [Name]
-> [(LStmtLR GhcRn GhcPs (LocatedA (body GhcPs)), FreeVars)]
-> RnM [Segment (LStmt GhcRn (LocatedA (body GhcRn)))]
rn_rec_stmts HsStmtContext GhcRn
ctxt body GhcPs -> RnM (body GhcRn, FreeVars)
rnBody [Name]
bndrs [(LStmtLR GhcRn GhcPs (LocatedA (body GhcPs)), FreeVars)]
stmts
  = do { [[Segment
    (GenLocated
       SrcSpanAnnA (StmtLR GhcRn GhcRn (LocatedA (body GhcRn))))]]
segs_s <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (forall (body :: * -> *).
AnnoBody body =>
HsStmtContext GhcRn
-> (body GhcPs -> RnM (body GhcRn, FreeVars))
-> [Name]
-> (LStmtLR GhcRn GhcPs (LocatedA (body GhcPs)), FreeVars)
-> RnM [Segment (LStmt GhcRn (LocatedA (body GhcRn)))]
rn_rec_stmt HsStmtContext GhcRn
ctxt body GhcPs -> RnM (body GhcRn, FreeVars)
rnBody [Name]
bndrs) [(LStmtLR GhcRn GhcPs (LocatedA (body GhcPs)), FreeVars)]
stmts
       ; forall (m :: * -> *) a. Monad m => a -> m a
return (forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [[Segment
    (GenLocated
       SrcSpanAnnA (StmtLR GhcRn GhcRn (LocatedA (body GhcRn))))]]
segs_s) }

---------------------------------------------
segmentRecStmts :: AnnoBody body
                => SrcSpan -> HsStmtContext GhcRn
                -> Stmt GhcRn (LocatedA (body GhcRn))
                -> [Segment (LStmt GhcRn (LocatedA (body GhcRn)))] -> FreeVars
                -> ([LStmt GhcRn (LocatedA (body GhcRn))], FreeVars)

segmentRecStmts :: forall (body :: * -> *).
AnnoBody body =>
SrcSpan
-> HsStmtContext GhcRn
-> Stmt GhcRn (LocatedA (body GhcRn))
-> [Segment (LStmt GhcRn (LocatedA (body GhcRn)))]
-> FreeVars
-> ([LStmt GhcRn (LocatedA (body GhcRn))], FreeVars)
segmentRecStmts SrcSpan
loc HsStmtContext GhcRn
ctxt Stmt GhcRn (LocatedA (body GhcRn))
empty_rec_stmt [Segment (LStmt GhcRn (LocatedA (body GhcRn)))]
segs FreeVars
fvs_later
  | forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Segment (LStmt GhcRn (LocatedA (body GhcRn)))]
segs
  = ([], FreeVars
fvs_later)

  | MDoExpr Maybe ModuleName
_ <- HsStmtContext GhcRn
ctxt
  = forall (body :: * -> *).
Stmt GhcRn (LocatedA (body GhcRn))
-> [Segment [LStmt GhcRn (LocatedA (body GhcRn))]]
-> FreeVars
-> ([LStmt GhcRn (LocatedA (body GhcRn))], FreeVars)
segsToStmts Stmt GhcRn (LocatedA (body GhcRn))
empty_rec_stmt [Segment [LStmt GhcRn (LocatedA (body GhcRn))]]
grouped_segs FreeVars
fvs_later
               -- Step 4: Turn the segments into Stmts
                --         Use RecStmt when and only when there are fwd refs
                --         Also gather up the uses from the end towards the
                --         start, so we can tell the RecStmt which things are
                --         used 'after' the RecStmt

  | Bool
otherwise
  = ([ forall l e. l -> e -> GenLocated l e
L (forall ann. SrcSpan -> SrcAnn ann
noAnnSrcSpan SrcSpan
loc) forall a b. (a -> b) -> a -> b
$
       Stmt GhcRn (LocatedA (body GhcRn))
empty_rec_stmt { recS_stmts :: XRec GhcRn [LStmt GhcRn (LocatedA (body GhcRn))]
recS_stmts = forall a an. a -> LocatedAn an a
noLocA [GenLocated SrcSpanAnnA (Stmt GhcRn (LocatedA (body GhcRn)))]
ss
                      , recS_later_ids :: [IdP GhcRn]
recS_later_ids = FreeVars -> [Name]
nameSetElemsStable
                                           (FreeVars
defs FreeVars -> FreeVars -> FreeVars
`intersectNameSet` FreeVars
fvs_later)
                      , recS_rec_ids :: [IdP GhcRn]
recS_rec_ids   = FreeVars -> [Name]
nameSetElemsStable
                                           (FreeVars
defs FreeVars -> FreeVars -> FreeVars
`intersectNameSet` FreeVars
uses) }]
          -- See Note [Deterministic ApplicativeDo and RecursiveDo desugaring]
    , FreeVars
uses FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fvs_later)

  where
    ([FreeVars]
defs_s, [FreeVars]
uses_s, [FreeVars]
_, [GenLocated SrcSpanAnnA (Stmt GhcRn (LocatedA (body GhcRn)))]
ss) = forall a b c d. [(a, b, c, d)] -> ([a], [b], [c], [d])
unzip4 [Segment (LStmt GhcRn (LocatedA (body GhcRn)))]
segs
    defs :: FreeVars
defs = [FreeVars] -> FreeVars
plusFVs [FreeVars]
defs_s
    uses :: FreeVars
uses = [FreeVars] -> FreeVars
plusFVs [FreeVars]
uses_s

                -- Step 2: Fill in the fwd refs.
                --         The segments are all singletons, but their fwd-ref
                --         field mentions all the things used by the segment
                --         that are bound after their use
    segs_w_fwd_refs :: [Segment
   (GenLocated SrcSpanAnnA (Stmt GhcRn (LocatedA (body GhcRn))))]
segs_w_fwd_refs = forall a. [Segment a] -> [Segment a]
addFwdRefs [Segment (LStmt GhcRn (LocatedA (body GhcRn)))]
segs

                -- Step 3: Group together the segments to make bigger segments
                --         Invariant: in the result, no segment uses a variable
                --                    bound in a later segment
    grouped_segs :: [Segment [LStmt GhcRn (LocatedA (body GhcRn))]]
grouped_segs = forall body.
HsStmtContext GhcRn
-> [Segment (LStmt GhcRn body)] -> [Segment [LStmt GhcRn body]]
glomSegments HsStmtContext GhcRn
ctxt [Segment
   (GenLocated SrcSpanAnnA (Stmt GhcRn (LocatedA (body GhcRn))))]
segs_w_fwd_refs

----------------------------
addFwdRefs :: [Segment a] -> [Segment a]
-- So far the segments only have forward refs *within* the Stmt
--      (which happens for bind:  x <- ...x...)
-- This function adds the cross-seg fwd ref info

addFwdRefs :: forall a. [Segment a] -> [Segment a]
addFwdRefs [Segment a]
segs
  = forall a b. (a, b) -> a
fst (forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr forall {d}.
(FreeVars, FreeVars, FreeVars, d)
-> ([(FreeVars, FreeVars, FreeVars, d)], FreeVars)
-> ([(FreeVars, FreeVars, FreeVars, d)], FreeVars)
mk_seg ([], FreeVars
emptyNameSet) [Segment a]
segs)
  where
    mk_seg :: (FreeVars, FreeVars, FreeVars, d)
-> ([(FreeVars, FreeVars, FreeVars, d)], FreeVars)
-> ([(FreeVars, FreeVars, FreeVars, d)], FreeVars)
mk_seg (FreeVars
defs, FreeVars
uses, FreeVars
fwds, d
stmts) ([(FreeVars, FreeVars, FreeVars, d)]
segs, FreeVars
later_defs)
        = ((FreeVars, FreeVars, FreeVars, d)
new_seg forall a. a -> [a] -> [a]
: [(FreeVars, FreeVars, FreeVars, d)]
segs, FreeVars
all_defs)
        where
          new_seg :: (FreeVars, FreeVars, FreeVars, d)
new_seg = (FreeVars
defs, FreeVars
uses, FreeVars
new_fwds, d
stmts)
          all_defs :: FreeVars
all_defs = FreeVars
later_defs FreeVars -> FreeVars -> FreeVars
`unionNameSet` FreeVars
defs
          new_fwds :: FreeVars
new_fwds = FreeVars
fwds FreeVars -> FreeVars -> FreeVars
`unionNameSet` (FreeVars
uses FreeVars -> FreeVars -> FreeVars
`intersectNameSet` FreeVars
later_defs)
                -- Add the downstream fwd refs here

{-
Note [Segmenting mdo]
~~~~~~~~~~~~~~~~~~~~~
NB. June 7 2012: We only glom segments that appear in an explicit mdo;
and leave those found in "do rec"'s intact.  See
https://gitlab.haskell.org/ghc/ghc/issues/4148 for the discussion
leading to this design choice.  Hence the test in segmentRecStmts.

Note [Glomming segments]
~~~~~~~~~~~~~~~~~~~~~~~~
Glomming the singleton segments of an mdo into minimal recursive groups.

At first I thought this was just strongly connected components, but
there's an important constraint: the order of the stmts must not change.

Consider
     mdo { x <- ...y...
           p <- z
           y <- ...x...
           q <- x
           z <- y
           r <- x }

Here, the first stmt mention 'y', which is bound in the third.
But that means that the innocent second stmt (p <- z) gets caught
up in the recursion.  And that in turn means that the binding for
'z' has to be included... and so on.

Start at the tail { r <- x }
Now add the next one { z <- y ; r <- x }
Now add one more     { q <- x ; z <- y ; r <- x }
Now one more... but this time we have to group a bunch into rec
     { rec { y <- ...x... ; q <- x ; z <- y } ; r <- x }
Now one more, which we can add on without a rec
     { p <- z ;
       rec { y <- ...x... ; q <- x ; z <- y } ;
       r <- x }
Finally we add the last one; since it mentions y we have to
glom it together with the first two groups
     { rec { x <- ...y...; p <- z ; y <- ...x... ;
             q <- x ; z <- y } ;
       r <- x }
-}

glomSegments :: HsStmtContext GhcRn
             -> [Segment (LStmt GhcRn body)]
             -> [Segment [LStmt GhcRn body]]
                                  -- Each segment has a non-empty list of Stmts
-- See Note [Glomming segments]

glomSegments :: forall body.
HsStmtContext GhcRn
-> [Segment (LStmt GhcRn body)] -> [Segment [LStmt GhcRn body]]
glomSegments HsStmtContext GhcRn
_ [] = []
glomSegments HsStmtContext GhcRn
ctxt ((FreeVars
defs,FreeVars
uses,FreeVars
fwds,LStmt GhcRn body
stmt) : [Segment (LStmt GhcRn body)]
segs)
        -- Actually stmts will always be a singleton
  = (FreeVars
seg_defs, FreeVars
seg_uses, FreeVars
seg_fwds, [GenLocated
   (Anno (StmtLR GhcRn GhcRn body)) (StmtLR GhcRn GhcRn body)]
seg_stmts)  forall a. a -> [a] -> [a]
: [(FreeVars, FreeVars, FreeVars,
  [GenLocated
     (Anno (StmtLR GhcRn GhcRn body)) (StmtLR GhcRn GhcRn body)])]
others
  where
    segs' :: [Segment [LStmt GhcRn body]]
segs'            = forall body.
HsStmtContext GhcRn
-> [Segment (LStmt GhcRn body)] -> [Segment [LStmt GhcRn body]]
glomSegments HsStmtContext GhcRn
ctxt [Segment (LStmt GhcRn body)]
segs
    ([(FreeVars, FreeVars, FreeVars,
  [GenLocated
     (Anno (StmtLR GhcRn GhcRn body)) (StmtLR GhcRn GhcRn body)])]
extras, [(FreeVars, FreeVars, FreeVars,
  [GenLocated
     (Anno (StmtLR GhcRn GhcRn body)) (StmtLR GhcRn GhcRn body)])]
others) = forall a. FreeVars -> [Segment a] -> ([Segment a], [Segment a])
grab FreeVars
uses [Segment [LStmt GhcRn body]]
segs'
    ([FreeVars]
ds, [FreeVars]
us, [FreeVars]
fs, [[GenLocated
    (Anno (StmtLR GhcRn GhcRn body)) (StmtLR GhcRn GhcRn body)]]
ss) = forall a b c d. [(a, b, c, d)] -> ([a], [b], [c], [d])
unzip4 [(FreeVars, FreeVars, FreeVars,
  [GenLocated
     (Anno (StmtLR GhcRn GhcRn body)) (StmtLR GhcRn GhcRn body)])]
extras

    seg_defs :: FreeVars
seg_defs  = [FreeVars] -> FreeVars
plusFVs [FreeVars]
ds FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
defs
    seg_uses :: FreeVars
seg_uses  = [FreeVars] -> FreeVars
plusFVs [FreeVars]
us FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
uses
    seg_fwds :: FreeVars
seg_fwds  = [FreeVars] -> FreeVars
plusFVs [FreeVars]
fs FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fwds
    seg_stmts :: [GenLocated
   (Anno (StmtLR GhcRn GhcRn body)) (StmtLR GhcRn GhcRn body)]
seg_stmts = LStmt GhcRn body
stmt forall a. a -> [a] -> [a]
: forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [[GenLocated
    (Anno (StmtLR GhcRn GhcRn body)) (StmtLR GhcRn GhcRn body)]]
ss

    grab :: NameSet             -- The client
         -> [Segment a]
         -> ([Segment a],       -- Needed by the 'client'
             [Segment a])       -- Not needed by the client
        -- The result is simply a split of the input
    grab :: forall a. FreeVars -> [Segment a] -> ([Segment a], [Segment a])
grab FreeVars
uses [Segment a]
dus
        = (forall a. [a] -> [a]
reverse [Segment a]
yeses, forall a. [a] -> [a]
reverse [Segment a]
noes)
        where
          ([Segment a]
noes, [Segment a]
yeses)           = forall a. (a -> Bool) -> [a] -> ([a], [a])
span Segment a -> Bool
not_needed (forall a. [a] -> [a]
reverse [Segment a]
dus)
          not_needed :: Segment a -> Bool
not_needed (FreeVars
defs,FreeVars
_,FreeVars
_,a
_) = FreeVars -> FreeVars -> Bool
disjointNameSet FreeVars
defs FreeVars
uses

----------------------------------------------------
segsToStmts :: Stmt GhcRn (LocatedA (body GhcRn))
                                  -- A RecStmt with the SyntaxOps filled in
            -> [Segment [LStmt GhcRn (LocatedA (body GhcRn))]]
                                  -- Each Segment has a non-empty list of Stmts
            -> FreeVars           -- Free vars used 'later'
            -> ([LStmt GhcRn (LocatedA (body GhcRn))], FreeVars)

segsToStmts :: forall (body :: * -> *).
Stmt GhcRn (LocatedA (body GhcRn))
-> [Segment [LStmt GhcRn (LocatedA (body GhcRn))]]
-> FreeVars
-> ([LStmt GhcRn (LocatedA (body GhcRn))], FreeVars)
segsToStmts Stmt GhcRn (LocatedA (body GhcRn))
_ [] FreeVars
fvs_later = ([], FreeVars
fvs_later)
segsToStmts Stmt GhcRn (LocatedA (body GhcRn))
empty_rec_stmt ((FreeVars
defs, FreeVars
uses, FreeVars
fwds, [LStmt GhcRn (LocatedA (body GhcRn))]
ss) : [Segment [LStmt GhcRn (LocatedA (body GhcRn))]]
segs) FreeVars
fvs_later
  = ASSERT( not (null ss) )
    (GenLocated SrcSpanAnnA (Stmt GhcRn (LocatedA (body GhcRn)))
new_stmt forall a. a -> [a] -> [a]
: [LStmt GhcRn (LocatedA (body GhcRn))]
later_stmts, FreeVars
later_uses FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
uses)
  where
    ([LStmt GhcRn (LocatedA (body GhcRn))]
later_stmts, FreeVars
later_uses) = forall (body :: * -> *).
Stmt GhcRn (LocatedA (body GhcRn))
-> [Segment [LStmt GhcRn (LocatedA (body GhcRn))]]
-> FreeVars
-> ([LStmt GhcRn (LocatedA (body GhcRn))], FreeVars)
segsToStmts Stmt GhcRn (LocatedA (body GhcRn))
empty_rec_stmt [Segment [LStmt GhcRn (LocatedA (body GhcRn))]]
segs FreeVars
fvs_later
    new_stmt :: GenLocated SrcSpanAnnA (Stmt GhcRn (LocatedA (body GhcRn)))
new_stmt | Bool
non_rec   = forall a. [a] -> a
head [LStmt GhcRn (LocatedA (body GhcRn))]
ss
             | Bool
otherwise = forall l e. l -> e -> GenLocated l e
L (forall l e. GenLocated l e -> l
getLoc (forall a. [a] -> a
head [LStmt GhcRn (LocatedA (body GhcRn))]
ss)) Stmt GhcRn (LocatedA (body GhcRn))
rec_stmt
    rec_stmt :: Stmt GhcRn (LocatedA (body GhcRn))
rec_stmt = Stmt GhcRn (LocatedA (body GhcRn))
empty_rec_stmt { recS_stmts :: XRec GhcRn [LStmt GhcRn (LocatedA (body GhcRn))]
recS_stmts     = forall a an. a -> LocatedAn an a
noLocA [LStmt GhcRn (LocatedA (body GhcRn))]
ss
                              , recS_later_ids :: [IdP GhcRn]
recS_later_ids = FreeVars -> [Name]
nameSetElemsStable FreeVars
used_later
                              , recS_rec_ids :: [IdP GhcRn]
recS_rec_ids   = FreeVars -> [Name]
nameSetElemsStable FreeVars
fwds }
          -- See Note [Deterministic ApplicativeDo and RecursiveDo desugaring]
    non_rec :: Bool
non_rec    = forall a. [a] -> Bool
isSingleton [LStmt GhcRn (LocatedA (body GhcRn))]
ss Bool -> Bool -> Bool
&& FreeVars -> Bool
isEmptyNameSet FreeVars
fwds
    used_later :: FreeVars
used_later = FreeVars
defs FreeVars -> FreeVars -> FreeVars
`intersectNameSet` FreeVars
later_uses
                                -- The ones needed after the RecStmt

{-
************************************************************************
*                                                                      *
ApplicativeDo
*                                                                      *
************************************************************************

Note [ApplicativeDo]

= Example =

For a sequence of statements

 do
     x <- A
     y <- B x
     z <- C
     return (f x y z)

We want to transform this to

  (\(x,y) z -> f x y z) <$> (do x <- A; y <- B x; return (x,y)) <*> C

It would be easy to notice that "y <- B x" and "z <- C" are
independent and do something like this:

 do
     x <- A
     (y,z) <- (,) <$> B x <*> C
     return (f x y z)

But this isn't enough! A and C were also independent, and this
transformation loses the ability to do A and C in parallel.

The algorithm works by first splitting the sequence of statements into
independent "segments", and a separate "tail" (the final statement). In
our example above, the segements would be

     [ x <- A
     , y <- B x ]

     [ z <- C ]

and the tail is:

     return (f x y z)

Then we take these segments and make an Applicative expression from them:

     (\(x,y) z -> return (f x y z))
       <$> do { x <- A; y <- B x; return (x,y) }
       <*> C

Finally, we recursively apply the transformation to each segment, to
discover any nested parallelism.

= Syntax & spec =

  expr ::= ... | do {stmt_1; ..; stmt_n} expr | ...

  stmt ::= pat <- expr
         | (arg_1 | ... | arg_n)  -- applicative composition, n>=1
         | ...                    -- other kinds of statement (e.g. let)

  arg ::= pat <- expr
        | {stmt_1; ..; stmt_n} {var_1..var_n}

(note that in the actual implementation,the expr in a do statement is
represented by a LastStmt as the final stmt, this is just a
representational issue and may change later.)

== Transformation to introduce applicative stmts ==

ado {} tail = tail
ado {pat <- expr} {return expr'} = (mkArg(pat <- expr)); return expr'
ado {one} tail = one : tail
ado stmts tail
  | n == 1 = ado before (ado after tail)
    where (before,after) = split(stmts_1)
  | n > 1  = (mkArg(stmts_1) | ... | mkArg(stmts_n)); tail
  where
    {stmts_1 .. stmts_n} = segments(stmts)

segments(stmts) =
  -- divide stmts into segments with no interdependencies

mkArg({pat <- expr}) = (pat <- expr)
mkArg({stmt_1; ...; stmt_n}) =
  {stmt_1; ...; stmt_n} {vars(stmt_1) u .. u vars(stmt_n)}

split({stmt_1; ..; stmt_n) =
  ({stmt_1; ..; stmt_i}, {stmt_i+1; ..; stmt_n})
  -- 1 <= i <= n
  -- i is a good place to insert a bind

== Desugaring for do ==

dsDo {} expr = expr

dsDo {pat <- rhs; stmts} expr =
   rhs >>= \pat -> dsDo stmts expr

dsDo {(arg_1 | ... | arg_n)} (return expr) =
  (\argpat (arg_1) .. argpat(arg_n) -> expr)
     <$> argexpr(arg_1)
     <*> ...
     <*> argexpr(arg_n)

dsDo {(arg_1 | ... | arg_n); stmts} expr =
  join (\argpat (arg_1) .. argpat(arg_n) -> dsDo stmts expr)
     <$> argexpr(arg_1)
     <*> ...
     <*> argexpr(arg_n)

= Relevant modules in the rest of the compiler =

ApplicativeDo touches a few phases in the compiler:

* Renamer: The journey begins here in the renamer, where do-blocks are
  scheduled as outlined above and transformed into applicative
  combinators.  However, the code is still represented as a do-block
  with special forms of applicative statements. This allows us to
  recover the original do-block when e.g. printing type errors, where
  we don't want to show any of the applicative combinators since they
  don't exist in the source code.
  See ApplicativeStmt and ApplicativeArg in HsExpr.

* Typechecker: ApplicativeDo passes through the typechecker much like any
  other form of expression. The only crux is that the typechecker has to
  be aware of the special ApplicativeDo statements in the do-notation, and
  typecheck them appropriately.
  Relevant module: GHC.Tc.Gen.Match

* Desugarer: Any do-block which contains applicative statements is desugared
  as outlined above, to use the Applicative combinators.
  Relevant module: GHC.HsToCore.Expr

-}

-- | The 'Name's of @return@ and @pure@. These may not be 'returnName' and
-- 'pureName' due to @QualifiedDo@ or @RebindableSyntax@.
data MonadNames = MonadNames { MonadNames -> Name
return_name, MonadNames -> Name
pure_name :: Name }

instance Outputable MonadNames where
  ppr :: MonadNames -> SDoc
ppr (MonadNames {return_name :: MonadNames -> Name
return_name=Name
return_name,pure_name :: MonadNames -> Name
pure_name=Name
pure_name}) =
    [SDoc] -> SDoc
hcat
    [String -> SDoc
text String
"MonadNames { return_name = "
    ,forall a. Outputable a => a -> SDoc
ppr Name
return_name
    ,String -> SDoc
text String
", pure_name = "
    ,forall a. Outputable a => a -> SDoc
ppr Name
pure_name
    ,String -> SDoc
text String
"}"
    ]

-- | rearrange a list of statements using ApplicativeDoStmt.  See
-- Note [ApplicativeDo].
rearrangeForApplicativeDo
  :: HsStmtContext GhcRn
  -> [(ExprLStmt GhcRn, FreeVars)]
  -> RnM ([ExprLStmt GhcRn], FreeVars)

rearrangeForApplicativeDo :: HsStmtContext GhcRn
-> [(ExprLStmt GhcRn, FreeVars)]
-> RnM ([ExprLStmt GhcRn], FreeVars)
rearrangeForApplicativeDo HsStmtContext GhcRn
_ [] = forall (m :: * -> *) a. Monad m => a -> m a
return ([], FreeVars
emptyNameSet)
rearrangeForApplicativeDo HsStmtContext GhcRn
_ [(ExprLStmt GhcRn
one,FreeVars
_)] = forall (m :: * -> *) a. Monad m => a -> m a
return ([ExprLStmt GhcRn
one], FreeVars
emptyNameSet)
rearrangeForApplicativeDo HsStmtContext GhcRn
ctxt [(ExprLStmt GhcRn, FreeVars)]
stmts0 = do
  Bool
optimal_ado <- forall gbl lcl. GeneralFlag -> TcRnIf gbl lcl Bool
goptM GeneralFlag
Opt_OptimalApplicativeDo
  let stmt_tree :: ExprStmtTree
stmt_tree | Bool
optimal_ado = [(ExprLStmt GhcRn, FreeVars)] -> ExprStmtTree
mkStmtTreeOptimal [(GenLocated
    SrcSpanAnnA
    (StmtLR GhcRn GhcRn (GenLocated SrcSpanAnnA (HsExpr GhcRn))),
  FreeVars)]
stmts
                | Bool
otherwise = [(ExprLStmt GhcRn, FreeVars)] -> ExprStmtTree
mkStmtTreeHeuristic [(GenLocated
    SrcSpanAnnA
    (StmtLR GhcRn GhcRn (GenLocated SrcSpanAnnA (HsExpr GhcRn))),
  FreeVars)]
stmts
  String -> SDoc -> IOEnv (Env TcGblEnv TcLclEnv) ()
traceRn String
"rearrangeForADo" (forall a. Outputable a => a -> SDoc
ppr ExprStmtTree
stmt_tree)
  (Name
return_name, FreeVars
_) <- forall p. HsStmtContext p -> Name -> RnM (Name, FreeVars)
lookupQualifiedDoName HsStmtContext GhcRn
ctxt Name
returnMName
  (Name
pure_name, FreeVars
_)   <- forall p. HsStmtContext p -> Name -> RnM (Name, FreeVars)
lookupQualifiedDoName HsStmtContext GhcRn
ctxt Name
pureAName
  let monad_names :: MonadNames
monad_names = MonadNames { return_name :: Name
return_name = Name
return_name
                               , pure_name :: Name
pure_name   = Name
pure_name }
  MonadNames
-> HsStmtContext GhcRn
-> ExprStmtTree
-> [ExprLStmt GhcRn]
-> FreeVars
-> RnM ([ExprLStmt GhcRn], FreeVars)
stmtTreeToStmts MonadNames
monad_names HsStmtContext GhcRn
ctxt ExprStmtTree
stmt_tree [GenLocated
  SrcSpanAnnA
  (StmtLR GhcRn GhcRn (GenLocated SrcSpanAnnA (HsExpr GhcRn)))
last] FreeVars
last_fvs
  where
    ([(GenLocated
    SrcSpanAnnA
    (StmtLR GhcRn GhcRn (GenLocated SrcSpanAnnA (HsExpr GhcRn))),
  FreeVars)]
stmts,(GenLocated
  SrcSpanAnnA
  (StmtLR GhcRn GhcRn (GenLocated SrcSpanAnnA (HsExpr GhcRn)))
last,FreeVars
last_fvs)) = forall {a}. [a] -> ([a], a)
findLast [(ExprLStmt GhcRn, FreeVars)]
stmts0
    findLast :: [a] -> ([a], a)
findLast [] = forall a. HasCallStack => String -> a
error String
"findLast"
    findLast [a
last] = (